Merge remote branch 'upstream/gallium-0.1' into nouveau-gallium-0.1

115 files changed, 972 insertions, 642 deletions

diff --git a/src/Makefile b/src/Makefile
index f93987e6880..fab0069a716 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -21,7 +21,7 @@ subdirs:
 		fi \
 	done
 
-install:
+install: $(TOP)/$(LIB_DIR)
 	@for dir in $(SUBDIRS) ; do \
 		if [ -d $$dir ] ; then \
 			(cd $$dir && $(MAKE) install) || exit 1 ; \
@@ -29,7 +29,7 @@ install:
 	done
 
 $(TOP)/$(LIB_DIR):
-	-mkdir $(TOP)/$(LIB_DIR)
+	-@test -d $(TOP)/$(LIB_DIR) || mkdir -p $(TOP)/$(LIB_DIR)
 
 
 clean:
diff --git a/src/egl/main/eglconfigutil.c b/src/egl/main/eglconfigutil.c
index b6585619a53..db2ff1bfe8a 100644
--- a/src/egl/main/eglconfigutil.c
+++ b/src/egl/main/eglconfigutil.c
@@ -118,13 +118,13 @@ _eglConfigToContextModesRec(const _EGLConfig *config, __GLcontextModes *mode)
 EGLBoolean
 _eglFillInConfigs(_EGLConfig * configs,
                   GLenum fb_format, GLenum fb_type,
-                  const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
+                  const uint8_t * depth_bits, const uint8_t * stencil_bits,
                   unsigned num_depth_stencil_bits,
                   const GLenum * db_modes, unsigned num_db_modes,
                   int visType)
 {
 #if 0
-   static const u_int8_t bits_table[3][4] = {
+   static const uint8_t bits_table[3][4] = {
             /* R  G  B  A */
             { 5, 6, 5, 0 },  /* Any GL_UNSIGNED_SHORT_5_6_5 */
             { 8, 8, 8, 0 },  /* Any RGB with any GL_UNSIGNED_INT_8_8_8_8 */
@@ -135,7 +135,7 @@ _eglFillInConfigs(_EGLConfig * configs,
     * Given the four supported fb_type values, this results in valid array
     * indices of 3, 4, 5, and 7.
     */
-   static const u_int32_t masks_table_rgb[8][4] = {
+   static const uint32_t masks_table_rgb[8][4] = {
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
@@ -146,7 +146,7 @@ _eglFillInConfigs(_EGLConfig * configs,
             {0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000}  /* 8_8_8_8_REV */
          };
 
-   static const u_int32_t masks_table_rgba[8][4] = {
+   static const uint32_t masks_table_rgba[8][4] = {
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
@@ -157,7 +157,7 @@ _eglFillInConfigs(_EGLConfig * configs,
             {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000},  /* 8_8_8_8_REV */
          };
 
-   static const u_int32_t masks_table_bgr[8][4] = {
+   static const uint32_t masks_table_bgr[8][4] = {
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
@@ -168,7 +168,7 @@ _eglFillInConfigs(_EGLConfig * configs,
             {0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000},  /* 8_8_8_8_REV */
          };
 
-   static const u_int32_t masks_table_bgra[8][4] = {
+   static const uint32_t masks_table_bgra[8][4] = {
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
             {0x00000000, 0x00000000, 0x00000000, 0x00000000},
@@ -179,12 +179,12 @@ _eglFillInConfigs(_EGLConfig * configs,
             {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000},  /* 8_8_8_8_REV */
          };
 
-   static const u_int8_t bytes_per_pixel[8] = {
+   static const uint8_t bytes_per_pixel[8] = {
             0, 0, 0, 2, 2, 4, 0, 4
          };
 
-   const u_int8_t * bits;
-   const u_int32_t * masks;
+   const uint8_t * bits;
+   const uint32_t * masks;
    const int index = fb_type & 0x07;
    _EGLConfig *config;
    unsigned i;
diff --git a/src/egl/main/eglconfigutil.h b/src/egl/main/eglconfigutil.h
index 5db906db651..7fe875a7d01 100644
--- a/src/egl/main/eglconfigutil.h
+++ b/src/egl/main/eglconfigutil.h
@@ -4,6 +4,7 @@
 
 #include "eglconfig.h"
 #include "GL/internal/glcore.h"
+#include "stdint.h"
 
 
 extern void
@@ -13,7 +14,7 @@ _eglConfigToContextModesRec(const _EGLConfig *config, __GLcontextModes *mode);
 extern EGLBoolean
 _eglFillInConfigs( _EGLConfig *configs,
                    EGLenum fb_format, EGLenum fb_type,
-                   const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
+                   const uint8_t * depth_bits, const uint8_t * stencil_bits,
                    unsigned num_depth_stencil_bits,
                    const EGLenum * db_modes, unsigned num_db_modes,
                    int visType );
diff --git a/src/gallium/auxiliary/translate/translate_generic.c b/src/gallium/auxiliary/translate/translate_generic.c
index 3fec89b36e9..4c8179ffa87 100644
--- a/src/gallium/auxiliary/translate/translate_generic.c
+++ b/src/gallium/auxiliary/translate/translate_generic.c
@@ -121,6 +121,8 @@ emit_##NAME(const float *attrib, void *ptr)		\
 #define FROM_16_SNORM(i)   ((float) ((short *) ptr)[i] / 32767.0f)
 #define FROM_32_SNORM(i)   ((float) ((int *) ptr)[i] / 2147483647.0f)
 
+#define FROM_32_FIXED(i)   (((int *) ptr)[i] / 65536.0f)
+
 #define TO_64_FLOAT(x)   ((double) x)
 #define TO_32_FLOAT(x)   (x)
 
@@ -140,6 +142,8 @@ emit_##NAME(const float *attrib, void *ptr)		\
 #define TO_16_SNORM(x)   ((short) (x * 32767.0f))
 #define TO_32_SNORM(x)   ((int) (x * 2147483647.0f))
 
+#define TO_32_FIXED(x)   ((int) (x * 65536.0f))
+
 
 
 ATTRIB( R64G64B64A64_FLOAT,   4, double, FROM_64_FLOAT, TO_64_FLOAT )
@@ -215,6 +219,11 @@ ATTRIB( R8_SNORM,        1, char, FROM_8_SNORM, TO_8_SNORM )
 ATTRIB( A8R8G8B8_UNORM,       4, ubyte, FROM_8_UNORM, TO_8_UNORM )
 //ATTRIB( R8G8B8A8_UNORM,       4, ubyte, FROM_8_UNORM, TO_8_UNORM )
 
+ATTRIB( R32G32B32A32_FIXED,   4, int, FROM_32_FIXED, TO_32_FIXED )
+ATTRIB( R32G32B32_FIXED,      3, int, FROM_32_FIXED, TO_32_FIXED )
+ATTRIB( R32G32_FIXED,         2, int, FROM_32_FIXED, TO_32_FIXED )
+ATTRIB( R32_FIXED,            1, int, FROM_32_FIXED, TO_32_FIXED )
+
 
 
 static void
@@ -386,6 +395,15 @@ static fetch_func get_fetch_func( enum pipe_format format )
    case PIPE_FORMAT_B8G8R8A8_UNORM:
       return &fetch_B8G8R8A8_UNORM;
 
+   case PIPE_FORMAT_R32_FIXED:
+      return &fetch_R32_FIXED;
+   case PIPE_FORMAT_R32G32_FIXED:
+      return &fetch_R32G32_FIXED;
+   case PIPE_FORMAT_R32G32B32_FIXED:
+      return &fetch_R32G32B32_FIXED;
+   case PIPE_FORMAT_R32G32B32A32_FIXED:
+      return &fetch_R32G32B32A32_FIXED;
+
    default:
       assert(0); 
       return &fetch_NULL;
diff --git a/src/gallium/auxiliary/util/p_debug.c b/src/gallium/auxiliary/util/p_debug.c
index 9d56f8bfabf..7b28900a25d 100644
--- a/src/gallium/auxiliary/util/p_debug.c
+++ b/src/gallium/auxiliary/util/p_debug.c
@@ -30,14 +30,28 @@
 
 #include <stdarg.h>
 
+
 #ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
+
 #include <windows.h>
 #include <winddi.h>
+
+#elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN      // Exclude rarely-used stuff from Windows headers
+#endif
+#include <windows.h>
+
 #else
+
 #include <stdio.h>
 #include <stdlib.h>
+
 #endif
 
+
+
 #include "pipe/p_compiler.h" 
 #include "pipe/p_util.h" 
 #include "pipe/p_debug.h" 
@@ -74,6 +88,17 @@ void _debug_vprintf(const char *format, va_list ap)
 #else
    /* TODO: Implement debug print for WINCE */
 #endif
+#elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
+   /* EngDebugPrint does not handle float point arguments, so we need to use
+    * our own vsnprintf implementation. It is also very slow, so buffer until
+    * we find a newline. */
+   static char buf[512 + 1] = {'\0'};
+   size_t len = strlen(buf);
+   int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap);
+   if(ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) {
+      OutputDebugStringA(buf);
+      buf[0] = '\0';
+   }
 #else
    vfprintf(stderr, format, ap);
 #endif
@@ -100,9 +125,9 @@ void debug_print_blob( const char *name,
 
 void _debug_break(void) 
 {
-#if (defined(__i386__) || defined(__386__)) && defined(__GNUC__)
+#if defined(PIPE_ARCH_X86) && defined(PIPE_CC_GCC)
    __asm("int3");
-#elif (defined(__i386__) || defined(__386__)) && defined(__MSC__)
+#elif defined(PIPE_ARCH_X86) && defined(PIPE_CC_MSVC)
    _asm {int 3};
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
    EngDebugBreak();
diff --git a/src/gallium/auxiliary/util/p_util.c b/src/gallium/auxiliary/util/p_util.c
index 2a92f8e408b..4e60b1b8418 100644
--- a/src/gallium/auxiliary/util/p_util.c
+++ b/src/gallium/auxiliary/util/p_util.c
@@ -37,6 +37,7 @@
 /**
  * Copy 2D rect from one place to another.
  * Position and sizes are in pixels.
+ * src_pitch may be negative to do vertical flip of pixels from source.
  */
 void
 pipe_copy_rect(ubyte * dst,
@@ -52,13 +53,21 @@ pipe_copy_rect(ubyte * dst,
                int src_y)
 {
    unsigned i;
+   int src_pitch_pos = src_pitch < 0 ? -src_pitch : src_pitch;
+
+   assert(cpp > 0);
+   assert(src_x >= 0);
+   assert(src_y >= 0);
+   assert(dst_x >= 0);
+   assert(dst_y >= 0);
 
    dst_pitch *= cpp;
    src_pitch *= cpp;
+   src_pitch_pos *= cpp;
    dst += dst_x * cpp;
    src += src_x * cpp;
    dst += dst_y * dst_pitch;
-   src += src_y * src_pitch;
+   src += src_y * src_pitch_pos;
    width *= cpp;
 
    if (width == dst_pitch && width == src_pitch)
diff --git a/src/gallium/auxiliary/util/u_blit.c b/src/gallium/auxiliary/util/u_blit.c
index 7b9415d49ae..6555dcd5882 100644
--- a/src/gallium/auxiliary/util/u_blit.c
+++ b/src/gallium/auxiliary/util/u_blit.c
@@ -223,6 +223,49 @@ setup_vertex_data(struct blit_state *ctx,
 
 
 /**
+ * Setup vertex data for the textured quad we'll draw.
+ * Note: y=0=top
+ */
+static void
+setup_vertex_data_tex(struct blit_state *ctx,
+                      float x0, float y0, float x1, float y1,
+                      float s0, float t0, float s1, float t1,
+                      float z)
+{
+   void *buf;
+
+   ctx->vertices[0][0][0] = x0;
+   ctx->vertices[0][0][1] = y0;
+   ctx->vertices[0][0][2] = z;
+   ctx->vertices[0][1][0] = s0; /*s*/
+   ctx->vertices[0][1][1] = t0; /*t*/
+
+   ctx->vertices[1][0][0] = x1;
+   ctx->vertices[1][0][1] = y0;
+   ctx->vertices[1][0][2] = z;
+   ctx->vertices[1][1][0] = s1; /*s*/
+   ctx->vertices[1][1][1] = t0; /*t*/
+
+   ctx->vertices[2][0][0] = x1;
+   ctx->vertices[2][0][1] = y1;
+   ctx->vertices[2][0][2] = z;
+   ctx->vertices[2][1][0] = s1;
+   ctx->vertices[2][1][1] = t1;
+
+   ctx->vertices[3][0][0] = x0;
+   ctx->vertices[3][0][1] = y1;
+   ctx->vertices[3][0][2] = z;
+   ctx->vertices[3][1][0] = s0;
+   ctx->vertices[3][1][1] = t1;
+
+   buf = ctx->pipe->winsys->buffer_map(ctx->pipe->winsys, ctx->vbuf,
+                                       PIPE_BUFFER_USAGE_CPU_WRITE);
+
+   memcpy(buf, ctx->vertices, sizeof(ctx->vertices));
+
+   ctx->pipe->winsys->buffer_unmap(ctx->pipe->winsys, ctx->vbuf);
+}
+/**
  * Copy pixel block from src surface to dst surface.
  * Overlapping regions are acceptable.
  * XXX need some control over blitting Z and/or stencil.
@@ -362,3 +405,99 @@ util_blit_pixels(struct blit_state *ctx,
    screen->texture_release(screen, &tex);
 }
 
+/**
+ * Copy pixel block from src texture to dst surface.
+ * Overlapping regions are acceptable.
+ *
+ * XXX Should support selection of level.
+ * XXX need some control over blitting Z and/or stencil.
+ */
+void
+util_blit_pixels_tex(struct blit_state *ctx,
+                 struct pipe_texture *tex,
+                 int srcX0, int srcY0,
+                 int srcX1, int srcY1,
+                 struct pipe_surface *dst,
+                 int dstX0, int dstY0,
+                 int dstX1, int dstY1,
+                 float z, uint filter)
+{
+   struct pipe_context *pipe = ctx->pipe;
+   struct pipe_screen *screen = pipe->screen;
+   struct pipe_framebuffer_state fb;
+   float s0, t0, s1, t1;
+
+   assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
+          filter == PIPE_TEX_MIPFILTER_LINEAR);
+
+   assert(tex->width[0] != 0);
+   assert(tex->height[0] != 0);
+
+   s0 = srcX0 / (float)tex->width[0];
+   s1 = srcX1 / (float)tex->width[0];
+   t0 = srcY0 / (float)tex->height[0];
+   t1 = srcY1 / (float)tex->height[0];
+
+   assert(screen->is_format_supported(screen, dst->format, PIPE_SURFACE));
+
+   /* save state (restored below) */
+   cso_save_blend(ctx->cso);
+   cso_save_depth_stencil_alpha(ctx->cso);
+   cso_save_rasterizer(ctx->cso);
+   cso_save_samplers(ctx->cso);
+   cso_save_sampler_textures(ctx->cso);
+   cso_save_framebuffer(ctx->cso);
+   cso_save_fragment_shader(ctx->cso);
+   cso_save_vertex_shader(ctx->cso);
+   cso_save_viewport(ctx->cso);
+
+   /* set misc state we care about */
+   cso_set_blend(ctx->cso, &ctx->blend);
+   cso_set_depth_stencil_alpha(ctx->cso, &ctx->depthstencil);
+   cso_set_rasterizer(ctx->cso, &ctx->rasterizer);
+   cso_set_viewport(ctx->cso, &ctx->viewport);
+
+   /* sampler */
+   ctx->sampler.min_img_filter = filter;
+   ctx->sampler.mag_img_filter = filter;
+   cso_single_sampler(ctx->cso, 0, &ctx->sampler);
+   cso_single_sampler_done(ctx->cso);
+
+   /* texture */
+   cso_set_sampler_textures(ctx->cso, 1, &tex);
+
+   /* shaders */
+   cso_set_fragment_shader_handle(ctx->cso, ctx->fs);
+   cso_set_vertex_shader_handle(ctx->cso, ctx->vs);
+
+   /* drawing dest */
+   memset(&fb, 0, sizeof(fb));
+   fb.width = dst->width;
+   fb.height = dst->height;
+   fb.num_cbufs = 1;
+   fb.cbufs[0] = dst;
+   cso_set_framebuffer(ctx->cso, &fb);
+
+   /* draw quad */
+   setup_vertex_data_tex(ctx,
+                     (float) dstX0, (float) dstY0,
+                     (float) dstX1, (float) dstY1,
+                     s0, t0, s1, t1,
+                     z);
+
+   util_draw_vertex_buffer(ctx->pipe, ctx->vbuf,
+                           PIPE_PRIM_TRIANGLE_FAN,
+                           4,  /* verts */
+                           2); /* attribs/vert */
+
+   /* restore state we changed */
+   cso_restore_blend(ctx->cso);
+   cso_restore_depth_stencil_alpha(ctx->cso);
+   cso_restore_rasterizer(ctx->cso);
+   cso_restore_samplers(ctx->cso);
+   cso_restore_sampler_textures(ctx->cso);
+   cso_restore_framebuffer(ctx->cso);
+   cso_restore_fragment_shader(ctx->cso);
+   cso_restore_vertex_shader(ctx->cso);
+   cso_restore_viewport(ctx->cso);
+}
diff --git a/src/gallium/auxiliary/util/u_blit.h b/src/gallium/auxiliary/util/u_blit.h
index 0ce9732e620..308075698fb 100644
--- a/src/gallium/auxiliary/util/u_blit.h
+++ b/src/gallium/auxiliary/util/u_blit.h
@@ -37,20 +37,19 @@ extern "C" {
    
 struct pipe_context;
 struct pipe_surface;
+struct pipe_texture;
 struct cso_context;
 
 
 struct blit_state;
 
+
 extern struct blit_state *
 util_create_blit(struct pipe_context *pipe, struct cso_context *cso);
 
-
 extern void
 util_destroy_blit(struct blit_state *ctx);
 
-
-
 extern void
 util_blit_pixels(struct blit_state *ctx,
                  struct pipe_surface *src,
@@ -61,6 +60,16 @@ util_blit_pixels(struct blit_state *ctx,
                  int dstX1, int dstY1,
                  float z, uint filter);
 
+extern void
+util_blit_pixels_tex(struct blit_state *ctx,
+                     struct pipe_texture *tex,
+                     int srcX0, int srcY0,
+                     int srcX1, int srcY1,
+                     struct pipe_surface *dst,
+                     int dstX0, int dstY0,
+                     int dstX1, int dstY1,
+                     float z, uint filter);
+
 
 #ifdef __cplusplus
 }
diff --git a/src/gallium/auxiliary/util/u_draw_quad.h b/src/gallium/auxiliary/util/u_draw_quad.h
index 5b6539a99ca..ec4862ead39 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.h
+++ b/src/gallium/auxiliary/util/u_draw_quad.h
@@ -33,6 +33,7 @@
 extern "C" {
 #endif
 
+struct pipe_buffer;
 
 extern void 
 util_draw_vertex_buffer(struct pipe_context *pipe,
diff --git a/src/gallium/drivers/cell/ppu/cell_surface.c b/src/gallium/drivers/cell/ppu/cell_surface.c
index a35db0ef991..18f37919241 100644
--- a/src/gallium/drivers/cell/ppu/cell_surface.c
+++ b/src/gallium/drivers/cell/ppu/cell_surface.c
@@ -60,7 +60,7 @@ cell_surface_data(struct pipe_context *pipe,
 
 static void
 cell_surface_copy(struct pipe_context *pipe,
-                  unsigned do_flip,
+                  boolean do_flip,
                   struct pipe_surface *dst,
                   unsigned dstx, unsigned dsty,
                   struct pipe_surface *src,
@@ -76,7 +76,7 @@ cell_surface_copy(struct pipe_context *pipe,
                   width, height,
                   pipe_surface_map(src),
                   do_flip ? -src->pitch : src->pitch,
-                  srcx, do_flip ? 1 - srcy - height : srcy);
+                  srcx, do_flip ? height - 1 - srcy : srcy);
 
    pipe_surface_unmap(src);
    pipe_surface_unmap(dst);
diff --git a/src/gallium/drivers/i915simple/i915_context.h b/src/gallium/drivers/i915simple/i915_context.h
index 892a88fd2cc..5d411a66486 100644
--- a/src/gallium/drivers/i915simple/i915_context.h
+++ b/src/gallium/drivers/i915simple/i915_context.h
@@ -192,6 +192,8 @@ struct i915_texture {
    unsigned depth_pitch;          /* per-image on i945? */
    unsigned total_height;
 
+   unsigned tiled;
+
    unsigned nr_images[PIPE_MAX_TEXTURE_LEVELS];
 
    /* Explicitly store the offset of each image for each cube face or
@@ -202,10 +204,6 @@ struct i915_texture {
     */
    unsigned *image_offset[PIPE_MAX_TEXTURE_LEVELS];   /**< array [depth] of offsets */
 
-   /* Includes image offset tables:
-    */
-   unsigned level_offset[PIPE_MAX_TEXTURE_LEVELS];
-
    /* The data is held here:
     */
    struct pipe_buffer *buffer;
diff --git a/src/gallium/drivers/i915simple/i915_state_emit.c b/src/gallium/drivers/i915simple/i915_state_emit.c
index bc801a82f03..19d968fd8b6 100644
--- a/src/gallium/drivers/i915simple/i915_state_emit.c
+++ b/src/gallium/drivers/i915simple/i915_state_emit.c
@@ -213,10 +213,10 @@ i915_emit_hardware_state(struct i915_context *i915 )
       if (cbuf_surface) {
 	 unsigned cpitch = (cbuf_surface->pitch * cbuf_surface->cpp);
 	 unsigned ctile = BUF_3D_USE_FENCE;
-#if 0
-	 if (!((cpitch - 1) & cpitch) && cpitch >= 512)
+	 if (cbuf_surface->texture &&
+	       ((struct i915_texture*)(cbuf_surface->texture))->tiled) {
 	    ctile = BUF_3D_TILED_SURFACE;
-#endif
+	 }
 
 	 OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
 
@@ -234,10 +234,10 @@ i915_emit_hardware_state(struct i915_context *i915 )
       if (depth_surface) {
 	 unsigned zpitch = (depth_surface->pitch * depth_surface->cpp);
 	 unsigned ztile = BUF_3D_USE_FENCE;
-#if 0
-	 if (!((zpitch - 1) & zpitch) && zpitch >= 512)
+	 if (depth_surface->texture &&
+	       ((struct i915_texture*)(depth_surface->texture))->tiled) {
 	    ztile = BUF_3D_TILED_SURFACE;
-#endif
+	 }
 
 	 OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
 
diff --git a/src/gallium/drivers/i915simple/i915_state_sampler.c b/src/gallium/drivers/i915simple/i915_state_sampler.c
index 24440843f33..379aff38460 100644
--- a/src/gallium/drivers/i915simple/i915_state_sampler.c
+++ b/src/gallium/drivers/i915simple/i915_state_sampler.c
@@ -234,6 +234,7 @@ i915_update_texture(struct i915_context *i915,
    const uint width = pt->width[0], height = pt->height[0], depth = pt->depth[0];
    const uint num_levels = pt->last_level;
    unsigned max_lod = num_levels * 4;
+   unsigned tiled = MS3_USE_FENCE_REGS;
 
    assert(tex);
    assert(width);
@@ -246,12 +247,17 @@ i915_update_texture(struct i915_context *i915,
    assert(format);
    assert(pitch);
 
+   if (tex->tiled) {
+      assert(!((pitch - 1) & pitch));
+      tiled = MS3_TILED_SURFACE;
+   }
+
    /* MS3 state */
    state[0] =
       (((height - 1) << MS3_HEIGHT_SHIFT)
        | ((width - 1) << MS3_WIDTH_SHIFT)
        | format
-       | MS3_USE_FENCE_REGS);
+       | tiled);
 
    /*
     * XXX When min_filter != mag_filter and there's just one mipmap level,
diff --git a/src/gallium/drivers/i915simple/i915_surface.c b/src/gallium/drivers/i915simple/i915_surface.c
index 98367ac0739..cc55a0910ed 100644
--- a/src/gallium/drivers/i915simple/i915_surface.c
+++ b/src/gallium/drivers/i915simple/i915_surface.c
@@ -41,7 +41,7 @@
  */
 static void
 i915_surface_copy(struct pipe_context *pipe,
-                  unsigned do_flip,
+                  boolean do_flip,
 		  struct pipe_surface *dst,
 		  unsigned dstx, unsigned dsty,
 		  struct pipe_surface *src,
@@ -66,7 +66,7 @@ i915_surface_copy(struct pipe_context *pipe,
                      width, height, 
                      src_map, 
                      do_flip ? -(int) src->pitch : src->pitch, 
-                     srcx, do_flip ? 1 - srcy - height : srcy);
+                     srcx, do_flip ? height - 1 - srcy : srcy);
 
       pipe->screen->surface_unmap(pipe->screen, src);
       pipe->screen->surface_unmap(pipe->screen, dst);
diff --git a/src/gallium/drivers/i915simple/i915_texture.c b/src/gallium/drivers/i915simple/i915_texture.c
index 9cd32e39191..b2e490c7db1 100644
--- a/src/gallium/drivers/i915simple/i915_texture.c
+++ b/src/gallium/drivers/i915simple/i915_texture.c
@@ -100,7 +100,7 @@ static void
 i915_miptree_set_level_info(struct i915_texture *tex,
                              unsigned level,
                              unsigned nr_images,
-                             unsigned x, unsigned y, unsigned w, unsigned h, unsigned d)
+                             unsigned w, unsigned h, unsigned d)
 {
    struct pipe_texture *pt = &tex->base;
 
@@ -110,7 +110,6 @@ i915_miptree_set_level_info(struct i915_texture *tex,
    pt->height[level] = h;
    pt->depth[level] = d;
 
-   tex->level_offset[level] = (x + y * tex->pitch) * pt->cpp;
    tex->nr_images[level] = nr_images;
 
    /*
@@ -166,7 +165,7 @@ i915_displaytarget_layout(struct i915_texture *tex)
    if (pt->last_level > 0 || pt->cpp != 4)
       return 0;
 
-   i915_miptree_set_level_info( tex, 0, 1, 0, 0,
+   i915_miptree_set_level_info( tex, 0, 1,
                                 tex->base.width[0],
                                 tex->base.height[0],
                                 1 );
@@ -175,6 +174,7 @@ i915_displaytarget_layout(struct i915_texture *tex)
    if (tex->base.width[0] >= 128) {
       tex->pitch = power_of_two(tex->base.width[0] * pt->cpp) / pt->cpp;
       tex->total_height = round_up(tex->base.height[0], 8);
+      tex->tiled = 1;
    } else {
       tex->pitch = round_up(tex->base.width[0], 64 / pt->cpp);
       tex->total_height = tex->base.height[0];
@@ -230,7 +230,8 @@ i945_miptree_layout_2d( struct i915_texture *tex )
    for (level = 0; level <= pt->last_level; level++) {
       unsigned img_height;
 
-      i915_miptree_set_level_info(tex, level, 1, x, y, width, height, 1);
+      i915_miptree_set_level_info(tex, level, 1, width, height, 1);
+      i915_miptree_set_image_offset(tex, level, 0, x, y);
 
       if (pt->compressed)
 	 img_height = MAX2(1, height/4);
@@ -294,7 +295,7 @@ i945_miptree_layout_cube(struct i915_texture *tex)
    /* Set all the levels to effectively occupy the whole rectangular region.
    */
    for (level = 0; level <= pt->last_level; level++) {
-      i915_miptree_set_level_info(tex, level, 6, 0, 0, lvlWidth, lvlHeight, 1);
+      i915_miptree_set_level_info(tex, level, 6, lvlWidth, lvlHeight, 1);
       lvlWidth /= 2;
       lvlHeight /= 2;
    }
@@ -380,8 +381,6 @@ i915_miptree_layout(struct i915_texture * tex)
 
          for (level = 0; level <= pt->last_level; level++) {
             i915_miptree_set_level_info(tex, level, 6,
-                                         0, 0,
-                                         /*OLD: tex->pitch, tex->total_height,*/
                                          lvlWidth, lvlHeight,
                                          1);
             lvlWidth /= 2;
@@ -416,7 +415,7 @@ i915_miptree_layout(struct i915_texture * tex)
           */
          for (level = 0; level <= MAX2(8, pt->last_level);
               level++) {
-            i915_miptree_set_level_info(tex, level, depth, 0, tex->total_height,
+            i915_miptree_set_level_info(tex, level, depth,
                                          width, height, depth);
 
 
@@ -458,8 +457,9 @@ i915_miptree_layout(struct i915_texture * tex)
 
          for (level = 0; level <= pt->last_level; level++) {
             i915_miptree_set_level_info(tex, level, 1,
-                                         0, tex->total_height,
                                          width, height, 1);
+            i915_miptree_set_image_offset(tex, level, 0,
+                                           0, tex->total_height);
 
             if (pt->compressed)
                img_height = MAX2(1, height / 4);
@@ -515,12 +515,11 @@ i945_miptree_layout(struct i915_texture * tex)
             unsigned q, j;
 
             i915_miptree_set_level_info(tex, level, nr_images,
-                                         0, tex->total_height,
                                          width, height, depth);
 
             for (q = 0; q < nr_images;) {
                for (j = 0; j < pack_x_nr && q < nr_images; j++, q++) {
-                  i915_miptree_set_image_offset(tex, level, q, x, y);
+                  i915_miptree_set_image_offset(tex, level, q, x, y + tex->total_height);
                   x += pack_x_pitch;
                }
 
@@ -648,15 +647,14 @@ i915_get_tex_surface(struct pipe_screen *screen,
    struct pipe_surface *ps;
    unsigned offset;  /* in bytes */
 
-   offset = tex->level_offset[level];
-
    if (pt->target == PIPE_TEXTURE_CUBE) {
-      offset += tex->image_offset[level][face] * pt->cpp;
+      offset = tex->image_offset[level][face] * pt->cpp;
    }
    else if (pt->target == PIPE_TEXTURE_3D) {
-      offset += tex->image_offset[level][zslice] * pt->cpp;
+      offset = tex->image_offset[level][zslice] * pt->cpp;
    }
    else {
+      offset = tex->image_offset[level][0] * pt->cpp;
       assert(face == 0);
       assert(zslice == 0);
    }
@@ -679,6 +677,38 @@ i915_get_tex_surface(struct pipe_screen *screen,
    return ps;
 }
 
+static struct pipe_texture *
+i915_texture_blanket(struct pipe_screen * screen,
+                     const struct pipe_texture *base,
+                     const unsigned *pitch,
+                     struct pipe_buffer *buffer)
+{
+   struct i915_texture *tex;
+   assert(screen);
+
+   /* Only supports one type */
+   if (base->target != PIPE_TEXTURE_2D ||
+       base->last_level != 0 ||
+       base->depth[0] != 1) {
+      return NULL;
+   }
+
+   tex = CALLOC_STRUCT(i915_texture);
+   if (!tex)
+      return NULL;
+
+   tex->base = *base;
+
+   tex->pitch = pitch[0];
+
+   i915_miptree_set_level_info(tex, 0, 1, base->width[0], base->height[0], 1);
+   i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
+
+   pipe_buffer_reference(screen->winsys, &tex->buffer, buffer);
+
+   return &tex->base;
+}
+
 void
 i915_init_texture_functions(struct i915_context *i915)
 {
@@ -715,5 +745,6 @@ i915_init_screen_texture_functions(struct pipe_screen *screen)
    screen->texture_create = i915_texture_create;
    screen->texture_release = i915_texture_release;
    screen->get_tex_surface = i915_get_tex_surface;
+   screen->texture_blanket = i915_texture_blanket;
    screen->tex_surface_release = i915_tex_surface_release;
 }
diff --git a/src/gallium/drivers/i965simple/brw_surface.c b/src/gallium/drivers/i965simple/brw_surface.c
index 3e3736b2806..3d98a2bf199 100644
--- a/src/gallium/drivers/i965simple/brw_surface.c
+++ b/src/gallium/drivers/i965simple/brw_surface.c
@@ -41,7 +41,7 @@
  */
 static void
 brw_surface_copy(struct pipe_context *pipe,
-                 unsigned do_flip,
+                 boolean do_flip,
                  struct pipe_surface *dst,
                  unsigned dstx, unsigned dsty,
                  struct pipe_surface *src,
@@ -66,7 +66,7 @@ brw_surface_copy(struct pipe_context *pipe,
                      width, height, 
                      src_map, 
                      do_flip ? -(int) src->pitch : src->pitch, 
-                     srcx, do_flip ? 1 - srcy - height : srcy);
+                     srcx, do_flip ? height - 1 - srcy : srcy);
 
       pipe->screen->surface_unmap(pipe->screen, src);
       pipe->screen->surface_unmap(pipe->screen, dst);
diff --git a/src/gallium/drivers/softpipe/sp_surface.c b/src/gallium/drivers/softpipe/sp_surface.c
index 29a1e92416e..9fd48aeccc5 100644
--- a/src/gallium/drivers/softpipe/sp_surface.c
+++ b/src/gallium/drivers/softpipe/sp_surface.c
@@ -35,12 +35,16 @@
 
 
 
-/* Assumes all values are within bounds -- no checking at this level -
+/**
+ * Copy a rectangular region from one surface to another.
+ * Surfaces must have same bpp.
+ *
+ * Assumes all values are within bounds -- no checking at this level -
  * do it higher up if required.
  */
 static void
 sp_surface_copy(struct pipe_context *pipe,
-                unsigned do_flip,
+                boolean do_flip,
 		struct pipe_surface *dst,
 		unsigned dstx, unsigned dsty,
 		struct pipe_surface *src,
@@ -54,9 +58,11 @@ sp_surface_copy(struct pipe_context *pipe,
                                                     src,
                                                     PIPE_BUFFER_USAGE_CPU_READ );
 
-   assert( dst->cpp == src->cpp );
-   assert(src_map && dst_map);
+   assert(dst->cpp == src->cpp);
+   assert(src_map);
+   assert(dst_map);
 
+   /* If do_flip, invert src_y position and pass negative src stride */
    pipe_copy_rect(dst_map,
                   dst->cpp,
                   dst->pitch,
@@ -64,7 +70,7 @@ sp_surface_copy(struct pipe_context *pipe,
                   width, height,
                   src_map,
                   do_flip ? -(int) src->pitch : src->pitch,
-                  srcx, do_flip ? 1 - srcy - height : srcy);
+                  srcx, do_flip ? src->height - 1 - srcy : srcy);
 
    pipe->screen->surface_unmap(pipe->screen, src);
    pipe->screen->surface_unmap(pipe->screen, dst);
diff --git a/src/gallium/drivers/softpipe/sp_texture.c b/src/gallium/drivers/softpipe/sp_texture.c
index ef8c5bd6b0c..2ef17a220b4 100644
--- a/src/gallium/drivers/softpipe/sp_texture.c
+++ b/src/gallium/drivers/softpipe/sp_texture.c
@@ -198,7 +198,7 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
       ps->cpp = pt->cpp;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->pitch = ps->width;
+      ps->pitch = spt->pitch[level];
       ps->offset = spt->level_offset[level];
       ps->usage = usage;
       
diff --git a/src/gallium/include/pipe/p_compiler.h b/src/gallium/include/pipe/p_compiler.h
index 521ef2d189b..d2b8c41be3d 100644
--- a/src/gallium/include/pipe/p_compiler.h
+++ b/src/gallium/include/pipe/p_compiler.h
@@ -39,20 +39,15 @@
 #define __WIN32__
 #endif
 
-#if defined(_MSC_VER) && !defined(__MSC__)
-#define __MSC__
-#endif
-
-
-#if defined(__MSC__)
+#if defined(_MSC_VER)
 
 /* Avoid 'expression is always true' warning */
 #pragma warning(disable: 4296)
 
-#endif /* __MSC__ */
+#endif /* _MSC_VER */
 
 
-#if defined(__MSC__)
+#if defined(_MSC_VER)
 
 typedef __int8             int8_t;
 typedef unsigned __int8    uint8_t;
@@ -114,7 +109,7 @@ typedef unsigned char boolean;
 /* Function inlining */
 #if defined(__GNUC__)
 #  define INLINE __inline__
-#elif defined(__MSC__)
+#elif defined(_MSC_VER)
 #  define INLINE __inline
 #elif defined(__ICL)
 #  define INLINE __inline
@@ -138,7 +133,7 @@ typedef unsigned char boolean;
 
 
 
-#if defined __GNUC__
+#if defined(__GNUC__)
 #define ALIGN16_DECL(TYPE, NAME, SIZE)  TYPE NAME##___aligned[SIZE] __attribute__(( aligned( 16 ) ))
 #define ALIGN16_ASSIGN(NAME) NAME##___aligned
 #define ALIGN16_ATTRIB  __attribute__(( aligned( 16 ) ))
diff --git a/src/gallium/include/pipe/p_context.h b/src/gallium/include/pipe/p_context.h
index faf112c6d61..2646706ff23 100644
--- a/src/gallium/include/pipe/p_context.h
+++ b/src/gallium/include/pipe/p_context.h
@@ -192,7 +192,7 @@ struct pipe_context {
     */
    /*@{*/
    void (*surface_copy)(struct pipe_context *pipe,
-                        unsigned do_flip,	/*<< flip surface contents vertically */
+                        boolean do_flip,/**< flip surface contents vertically */
 			struct pipe_surface *dest,
 			unsigned destx, unsigned desty,
 			struct pipe_surface *src, /* don't make this const - 
diff --git a/src/gallium/include/pipe/p_debug.h b/src/gallium/include/pipe/p_debug.h
index 9011557006d..a5816c3cbb7 100644
--- a/src/gallium/include/pipe/p_debug.h
+++ b/src/gallium/include/pipe/p_debug.h
@@ -132,9 +132,9 @@ void _debug_break(void);
  * Hard-coded breakpoint.
  */
 #ifdef DEBUG
-#if (defined(__i386__) || defined(__386__)) && defined(__GNUC__)
+#if defined(PIPE_ARCH_X86) && defined(PIPE_CC_GCC)
 #define debug_break() __asm("int3")
-#elif defined(_M_IX86) && defined(_MSC_VER)
+#elif defined(PIPE_ARCH_X86) && defined(PIPE_CC_MSVC)
 #define debug_break()  do { _asm {int 3} } while(0)
 #else
 #define debug_break() _debug_break()
diff --git a/src/gallium/include/pipe/p_format.h b/src/gallium/include/pipe/p_format.h
index 579fdb2957f..00aa02311c4 100644
--- a/src/gallium/include/pipe/p_format.h
+++ b/src/gallium/include/pipe/p_format.h
@@ -83,6 +83,7 @@ static INLINE uint pf_layout(uint f)  /**< PIPE_FORMAT_LAYOUT_ */
 #define PIPE_FORMAT_TYPE_USCALED 4  /**< uints, not normalized */
 #define PIPE_FORMAT_TYPE_SSCALED 5  /**< ints, not normalized */
 #define PIPE_FORMAT_TYPE_SRGB    6  /**< sRGB colorspace */
+#define PIPE_FORMAT_TYPE_FIXED   7  /**< 16.16 fixed point */
 
 
 /**
@@ -353,6 +354,10 @@ enum pipe_format {
    PIPE_FORMAT_R8G8B8_SSCALED        = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RGB1, 1, 1, 1, 0, PIPE_FORMAT_TYPE_SSCALED ),
    PIPE_FORMAT_R8G8B8A8_SSCALED      = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RGBA, 1, 1, 1, 1, PIPE_FORMAT_TYPE_SSCALED ),
    PIPE_FORMAT_R8G8B8X8_SSCALED      = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RGB1, 1, 1, 1, 1, PIPE_FORMAT_TYPE_SSCALED ),
+   PIPE_FORMAT_R32_FIXED             = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_R001, 4, 0, 0, 0, PIPE_FORMAT_TYPE_FIXED ),
+   PIPE_FORMAT_R32G32_FIXED          = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RG01, 4, 4, 0, 0, PIPE_FORMAT_TYPE_FIXED ),
+   PIPE_FORMAT_R32G32B32_FIXED       = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RGB1, 4, 4, 4, 0, PIPE_FORMAT_TYPE_FIXED ),
+   PIPE_FORMAT_R32G32B32A32_FIXED    = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RGBA, 4, 4, 4, 4, PIPE_FORMAT_TYPE_FIXED ),
    /* sRGB formats */
    PIPE_FORMAT_L8_SRGB               = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRR1, 1, 1, 1, 0, PIPE_FORMAT_TYPE_SRGB ),
    PIPE_FORMAT_A8_L8_SRGB            = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRRG, 1, 1, 1, 1, PIPE_FORMAT_TYPE_SRGB ),
diff --git a/src/gallium/include/pipe/p_thread.h b/src/gallium/include/pipe/p_thread.h
index af9150aafbd..6e526b7aa8b 100644
--- a/src/gallium/include/pipe/p_thread.h
+++ b/src/gallium/include/pipe/p_thread.h
@@ -62,12 +62,6 @@
 #define _P_THREAD_H_
 
 
-#if defined(USE_MGL_NAMESPACE)
-#define _glapi_Dispatch _mglapi_Dispatch
-#endif
-
-
-
 #if (defined(PTHREADS) || defined(SOLARIS_THREADS) ||\
      defined(WIN32_THREADS) || defined(USE_XTHREADS) || defined(BEOS_THREADS)) \
     && !defined(THREADS)
@@ -330,22 +324,6 @@ _glthread_GetTSD(_glthread_TSD *);
 extern void
 _glthread_SetTSD(_glthread_TSD *, void *);
 
-#if defined(GLX_USE_TLS)
-
-extern __thread struct _glapi_table * _glapi_tls_Dispatch
-    __attribute__((tls_model("initial-exec")));
-
-#define GET_DISPATCH() _glapi_tls_Dispatch
-
-#elif !defined(GL_CALL)
-# if defined(THREADS)
-#  define GET_DISPATCH() \
-   ((__builtin_expect( _glapi_Dispatch != NULL, 1 )) \
-       ? _glapi_Dispatch : _glapi_get_dispatch())
-# else
-#  define GET_DISPATCH() _glapi_Dispatch
-# endif /* defined(THREADS) */
-#endif  /* ndef GL_CALL */
 
 
 #endif /* _P_THREAD_H_ */
diff --git a/src/gallium/include/pipe/p_util.h b/src/gallium/include/pipe/p_util.h
index 8b3003bcefb..cf2447822ab 100644
--- a/src/gallium/include/pipe/p_util.h
+++ b/src/gallium/include/pipe/p_util.h
@@ -224,7 +224,7 @@ static INLINE int align_int(int x, int align)
 
 
 
-#if defined(__MSC__) && defined(__WIN32__)
+#if defined(PIPE_CC_MSVC) && defined(PIPE_ARCH_X86)
 static INLINE unsigned ffs( unsigned u )
 {
    unsigned i;
@@ -341,14 +341,14 @@ static INLINE int ifloor(float f)
 }
 
 
-#if defined(__GNUC__) && defined(__i386__) 
+#if defined(PIPE_CC_GCC) && defined(PIPE_ARCH_X86) 
 static INLINE int iround(float f)
 {
    int r;
    __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st");
    return r;
 }
-#elif defined(__MSC__) && defined(__WIN32__)
+#elif defined(PIPE_CC_MSVC) && defined(PIPE_ARCH_X86)
 static INLINE int iround(float f)
 {
    int r;
@@ -409,7 +409,7 @@ extern void pipe_copy_rect(ubyte * dst, unsigned cpp, unsigned dst_pitch,
 
 
 #if defined(_MSC_VER) 
-#if _MSC_VER < 1400 && !defined(__cplusplus)
+#if _MSC_VER < 1400 && !defined(__cplusplus) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
  
 static INLINE float cosf( float f ) 
 {
diff --git a/src/gallium/winsys/common/intel_drm/intel_be_device.c b/src/gallium/winsys/common/intel_drm/intel_be_device.c
index 3eed0fe4107..efb57a394e4 100644
--- a/src/gallium/winsys/common/intel_drm/intel_be_device.c
+++ b/src/gallium/winsys/common/intel_drm/intel_be_device.c
@@ -16,6 +16,8 @@
 #include "pipe/p_util.h"
 #include "pipe/p_inlines.h"
 
+#include "i915simple/i915_screen.h"
+
 /* Turn a pipe winsys into an intel/pipe winsys:
  */
 static INLINE struct intel_be_device *
@@ -192,7 +194,7 @@ intel_be_fence_finish( struct pipe_winsys *sws,
  */
 
 boolean
-intel_be_init_device(struct intel_be_device *dev, int fd)
+intel_be_init_device(struct intel_be_device *dev, int fd, unsigned id)
 {
 	dev->fd = fd;
 	dev->max_batch_size = 16 * 4096;
@@ -252,6 +254,11 @@ intel_be_init_device(struct intel_be_device *dev, int fd)
 					 1, 40, dev->max_batch_size * 16, 0,
 					 dev->fMan);
 
+	/* Fill in this struct with callbacks that i915simple will need to
+	 * communicate with the window system, buffer manager, etc.
+	 */
+	dev->screen = i915_create_screen(&dev->base, id);
+
 	return true;
 }
 
diff --git a/src/gallium/winsys/common/intel_drm/intel_be_device.h b/src/gallium/winsys/common/intel_drm/intel_be_device.h
index ec5cace71c8..abf02539171 100644
--- a/src/gallium/winsys/common/intel_drm/intel_be_device.h
+++ b/src/gallium/winsys/common/intel_drm/intel_be_device.h
@@ -12,6 +12,11 @@ struct intel_be_device
 {
 	struct pipe_winsys base;
 
+	/**
+	 * Hw level screen
+	 */
+	struct pipe_screen *screen;
+
 	int fd; /**< Drm file discriptor */
 
 	size_t max_batch_size;
@@ -28,7 +33,7 @@ struct intel_be_device
 };
 
 boolean
-intel_be_init_device(struct intel_be_device *device, int fd);
+intel_be_init_device(struct intel_be_device *device, int fd, unsigned id);
 
 void
 intel_be_destroy_device(struct intel_be_device *dev);
diff --git a/src/gallium/winsys/dri/intel/Makefile b/src/gallium/winsys/dri/intel/Makefile
index 00ce21f6903..5b51f0815d5 100644
--- a/src/gallium/winsys/dri/intel/Makefile
+++ b/src/gallium/winsys/dri/intel/Makefile
@@ -6,8 +6,9 @@ LIBNAME = i915_dri.so
 
 PIPE_DRIVERS = \
 	$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
-	$(TOP)/src/gallium/drivers/i915simple/libi915simple.a \
-	$(TOP)/src/gallium/winsys/common/intel_drm/libinteldrm.a
+	$(TOP)/src/gallium/winsys/common/intel_drm/libinteldrm.a \
+	$(TOP)/src/gallium/drivers/i915simple/libi915simple.a
+
 
 DRIVER_SOURCES = \
 	intel_winsys_softpipe.c \
diff --git a/src/gallium/winsys/dri/intel/intel_context.c b/src/gallium/winsys/dri/intel/intel_context.c
index 8284e0edbb9..97ef731aaad 100644
--- a/src/gallium/winsys/dri/intel/intel_context.c
+++ b/src/gallium/winsys/dri/intel/intel_context.c
@@ -134,25 +134,6 @@ static const struct dri_debug_control debug_control[] = {
 
 
 
-/**
- * Create i915 hardware rendering context.
- */
-static struct pipe_context *
-intel_create_i915simple(struct intel_context *intel,
-			struct pipe_winsys *winsys)
-{
-   struct pipe_screen *screen;
-	
-   /* Fill in this struct with callbacks that i915simple will need to
-    * communicate with the window system, buffer manager, etc.
-    */
-   screen = i915_create_screen(winsys, intel->intelScreen->deviceID);
-
-   /* Create the i915simple context:
-    */
-   return i915_create_context(screen, winsys, &intel->base.base );
-}
-
 static void
 intel_lock_hardware(struct intel_be_context *context)
 {
@@ -250,7 +231,9 @@ intelCreateContext(const __GLcontextModes * visual,
       case PCI_CHIP_Q35_G:
       case PCI_CHIP_I915_G:
       case PCI_CHIP_I915_GM:
-	 pipe = intel_create_i915simple( intel, &intelScreen->base.base );
+	 pipe = i915_create_context(intelScreen->base.screen,
+				    &intelScreen->base.base,
+				    &intel->base.base);
 	 break;
       default:
 	 fprintf(stderr, "Unknown PCIID %x in %s, using software driver\n",
diff --git a/src/gallium/winsys/dri/intel/intel_screen.c b/src/gallium/winsys/dri/intel/intel_screen.c
index 8817a80a5a5..18427a4586f 100644
--- a/src/gallium/winsys/dri/intel/intel_screen.c
+++ b/src/gallium/winsys/dri/intel/intel_screen.c
@@ -38,10 +38,69 @@
 #include "intel_drm/ws_dri_bufpool.h"
 
 #include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "pipe/p_inlines.h"
 #include "state_tracker/st_public.h"
 #include "state_tracker/st_cb_fbo.h"
 
+static void
+intelCreateSurface(struct intel_screen *intelScreen, struct pipe_winsys *winsys, unsigned handle);
+
+static void
+intelCreateSurface(struct intel_screen *intelScreen, struct pipe_winsys *winsys, unsigned handle)
+{
+   struct intel_be_buffer *be_buf = malloc(sizeof(*be_buf));
+   struct pipe_screen *screen = intelScreen->base.screen;
+   struct pipe_texture *texture;
+   struct pipe_texture templat;
+   struct pipe_surface *surface;
+   struct pipe_buffer *buffer = &be_buf->base;
+   unsigned pitch;
+
+   assert(intelScreen->front.cpp == 4);
+
+   /* XXX create a intel_be function for this */
+   {
+      driGenBuffers(intelScreen->base.staticPool, "front", 1, &intelScreen->front.buffer, 0, 0, 0);
+      driBOSetReferenced(intelScreen->front.buffer, handle);
+
+      memset(be_buf, 0, sizeof(*be_buf));
+      buffer->refcount = 1;
+      buffer->alignment = 0;
+      buffer->usage = 0;
+      buffer->size = driBOSize(intelScreen->front.buffer);
+      be_buf->driBO = intelScreen->front.buffer;
+   }
 
+   memset(&templat, 0, sizeof(templat));
+   templat.tex_usage |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
+   templat.target = PIPE_TEXTURE_2D;
+   templat.last_level = 0;
+   templat.depth[0] = 1;
+   templat.format = PIPE_FORMAT_A8R8G8B8_UNORM;
+   templat.cpp = intelScreen->front.cpp;
+   templat.width[0] = intelScreen->front.width;
+   templat.height[0] = intelScreen->front.height;
+   pitch = intelScreen->front.pitch / intelScreen->front.cpp;
+
+   texture = screen->texture_blanket(screen,
+                                     &templat,
+                                     &pitch,
+                                     buffer);
+
+   /* Unref the buffer we don't need it anyways */
+   pipe_buffer_reference(screen->winsys, &buffer, NULL);
+
+   surface = screen->get_tex_surface(screen,
+                                     texture,
+                                     0,
+                                     0,
+                                     0,
+                                     PIPE_BUFFER_USAGE_GPU_WRITE);
+
+   intelScreen->front.texture = texture;
+   intelScreen->front.surface = surface;
+}
 
 PUBLIC const char __driConfigOptions[] =
    DRI_CONF_BEGIN DRI_CONF_SECTION_PERFORMANCE
@@ -157,10 +216,12 @@ intelUpdateScreenRotation(__DRIscreenPrivate * sPriv, drmI830Sarea * sarea)
    }
 #else
    if (intelScreen->base.staticPool) {
-      if (intelScreen->front.buffer)
+      if (intelScreen->front.buffer) {
 	 driBOUnReference(intelScreen->front.buffer);
-      driGenBuffers(intelScreen->base.staticPool, "front", 1, &intelScreen->front.buffer, 0, 0, 0);
-      driBOSetReferenced(intelScreen->front.buffer, sarea->front_bo_handle);
+	 pipe_surface_reference(&intelScreen->front.surface, NULL);
+	 pipe_texture_reference(&intelScreen->front.texture, NULL);
+      }
+      intelCreateSurface(intelScreen, &intelScreen->base.base, sarea->front_bo_handle);
    }
 #endif
 }
@@ -198,10 +259,12 @@ intel_flush_frontbuffer( struct pipe_winsys *winsys,
                          struct pipe_surface *surf,
                          void *context_private)
 {
-   struct intel_context *intel = (struct intel_context *) context_private;
-   __DRIdrawablePrivate *dPriv = intel->driDrawable;
+   //struct intel_context *intel = (struct intel_context *) context_private;
+   //__DRIdrawablePrivate *dPriv = intel->driDrawable;
+
+   assert((int)"Doesn't work currently" & 0);
 
-   intelDisplaySurface(dPriv, surf, NULL);
+   //intelDisplaySurface(dPriv, surf, NULL);
 }
 
 static boolean
@@ -254,9 +317,9 @@ intelInitDriver(__DRIscreenPrivate * sPriv)
       (*glx_enable_extension) (psc, "GLX_SGI_make_current_read");
    }
 
-   intel_be_init_device(&intelScreen->base, sPriv->fd);
    intelScreen->base.base.flush_frontbuffer = intel_flush_frontbuffer;
    intelScreen->base.base.get_name = intel_get_name;
+   intel_be_init_device(&intelScreen->base, sPriv->fd, intelScreen->deviceID);
 
    return GL_TRUE;
 }
@@ -418,8 +481,8 @@ intelFillInModes(unsigned pixel_bits, unsigned depth_bits,
       GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
    };
 
-   u_int8_t depth_bits_array[3];
-   u_int8_t stencil_bits_array[3];
+   uint8_t depth_bits_array[3];
+   uint8_t stencil_bits_array[3];
 
 
    depth_bits_array[0] = 0;
diff --git a/src/gallium/winsys/dri/intel/intel_screen.h b/src/gallium/winsys/dri/intel/intel_screen.h
index 80369179031..e62f9e71eca 100644
--- a/src/gallium/winsys/dri/intel/intel_screen.h
+++ b/src/gallium/winsys/dri/intel/intel_screen.h
@@ -47,6 +47,8 @@ struct intel_screen
       /* We create a static dri buffer for the frontbuffer.
        */
       struct _DriBufferObject *buffer;
+      struct pipe_surface *surface;
+      struct pipe_texture *texture;
 
       char *map;                   /* memory map */
       int offset;                  /* from start of video mem, in bytes */
diff --git a/src/gallium/winsys/gdi/wmesa.c b/src/gallium/winsys/gdi/wmesa.c
index 74a82923524..0b93f8c4c32 100644
--- a/src/gallium/winsys/gdi/wmesa.c
+++ b/src/gallium/winsys/gdi/wmesa.c
@@ -469,7 +469,8 @@ wm_surface_alloc_storage(struct pipe_winsys *winsys,
                          struct pipe_surface *surf,
                          unsigned width, unsigned height,
                          enum pipe_format format, 
-                         unsigned flags)
+                         unsigned flags,
+                         unsigned tex_usage)
 {
    const unsigned alignment = 64;
 
diff --git a/src/mesa/Makefile b/src/mesa/Makefile
index 2d0a6e01678..cf75baa706d 100644
--- a/src/mesa/Makefile
+++ b/src/mesa/Makefile
@@ -32,11 +32,11 @@ default: depend asm_subdirs libmesa.a $(GLAPI_LIB) driver_subdirs
 # Helper libraries used by many drivers:
 
 # Make archive of core mesa object files
-libmesa.a: $(MESA_OBJECTS) asm_subdirs
+libmesa.a: $(MESA_OBJECTS)
 	@ $(TOP)/bin/mklib -o mesa -static $(MESA_OBJECTS)
 
 # Make archive of gl* API dispatcher functions only
-$(GLAPI_LIB): $(GLAPI_OBJECTS) asm_subdirs
+$(GLAPI_LIB): $(GLAPI_OBJECTS)
 	@if [ "${WINDOW_SYSTEM}" = "dri" ] ; then \
 		touch libglapi.a ; \
 	else \
@@ -120,7 +120,7 @@ install-osmesa: default
 	$(INSTALL) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_NAME)* \
 		$(DESTDIR)$(INSTALL_DIR)/$(LIB_DIR)
 
-install-dri:
+install-dri: default
 	cd drivers/dri && $(MAKE) install
 
 
diff --git a/src/mesa/SConscript b/src/mesa/SConscript
index af83db0b5f5..d2de189f690 100644
--- a/src/mesa/SConscript
+++ b/src/mesa/SConscript
@@ -231,6 +231,7 @@ if env['platform'] != 'winddk':
 	glapi_sources = [
 		'main/dispatch.c',
 		'glapi/glapi.c',
+		'glapi/glapi_getproc.c',
 		'glapi/glthread.c',
 	]
 	
diff --git a/src/mesa/drivers/dri/common/dri_util.h b/src/mesa/drivers/dri/common/dri_util.h
index 027cb7f461e..c0cda5d25fc 100644
--- a/src/mesa/drivers/dri/common/dri_util.h
+++ b/src/mesa/drivers/dri/common/dri_util.h
@@ -200,7 +200,7 @@ struct __DRIswapInfoRec {
     /** 
      * Number of swapBuffers operations that have been *completed*. 
      */
-    u_int64_t swap_count;
+    uint64_t swap_count;
 
     /**
      * Unadjusted system time of the last buffer swap.  This is the time
@@ -214,7 +214,7 @@ struct __DRIswapInfoRec {
      * swap, it has missed its deadline.  If swap_interval is 0, then the
      * swap deadline is 1 frame after the previous swap.
      */
-    u_int64_t swap_missed_count;
+    uint64_t swap_missed_count;
 
     /**
      * Amount of time used by the last swap that missed its deadline.  This
diff --git a/src/mesa/drivers/dri/common/mmio.h b/src/mesa/drivers/dri/common/mmio.h
index 2b7b4123e5a..891056e1705 100644
--- a/src/mesa/drivers/dri/common/mmio.h
+++ b/src/mesa/drivers/dri/common/mmio.h
@@ -37,10 +37,10 @@
 
 #if defined( __powerpc__ )
 
-static __inline__ u_int32_t
+static __inline__ uint32_t
 read_MMIO_LE32( volatile void * base, unsigned long offset )
 {
-   u_int32_t val;
+   uint32_t val;
 
    __asm__ __volatile__( "lwbrx	%0, %1, %2 ; eieio"
 			 : "=r" (val)
@@ -50,10 +50,10 @@ read_MMIO_LE32( volatile void * base, unsigned long offset )
 
 #else
 
-static __inline__ u_int32_t
+static __inline__ uint32_t
 read_MMIO_LE32( volatile void * base, unsigned long offset )
 {
-   volatile u_int32_t * p = (volatile u_int32_t *) (((volatile char *) base) + offset);
+   volatile uint32_t * p = (volatile uint32_t *) (((volatile char *) base) + offset);
    return LE32_TO_CPU( p[0] );
 }
 
diff --git a/src/mesa/drivers/dri/common/utils.c b/src/mesa/drivers/dri/common/utils.c
index 6a189e72858..94db3199287 100644
--- a/src/mesa/drivers/dri/common/utils.c
+++ b/src/mesa/drivers/dri/common/utils.c
@@ -539,12 +539,12 @@ GLboolean driClipRectToFramebuffer( const GLframebuffer *buffer,
 GLboolean
 driFillInModes( __GLcontextModes ** ptr_to_modes,
 		GLenum fb_format, GLenum fb_type,
-		const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
+		const uint8_t * depth_bits, const uint8_t * stencil_bits,
 		unsigned num_depth_stencil_bits,
 		const GLenum * db_modes, unsigned num_db_modes,
 		int visType )
 {
-   static const u_int8_t bits_table[3][4] = {
+   static const uint8_t bits_table[3][4] = {
      /* R  G  B  A */
       { 5, 6, 5, 0 }, /* Any GL_UNSIGNED_SHORT_5_6_5 */
       { 8, 8, 8, 0 }, /* Any RGB with any GL_UNSIGNED_INT_8_8_8_8 */
@@ -555,7 +555,7 @@ driFillInModes( __GLcontextModes ** ptr_to_modes,
     * Given the four supported fb_type values, this results in valid array
     * indices of 3, 4, 5, and 7.
     */
-   static const u_int32_t masks_table_rgb[8][4] = {
+   static const uint32_t masks_table_rgb[8][4] = {
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
@@ -566,7 +566,7 @@ driFillInModes( __GLcontextModes ** ptr_to_modes,
       { 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 }  /* 8_8_8_8_REV */
    };
 
-   static const u_int32_t masks_table_rgba[8][4] = {
+   static const uint32_t masks_table_rgba[8][4] = {
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
@@ -577,7 +577,7 @@ driFillInModes( __GLcontextModes ** ptr_to_modes,
       { 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }, /* 8_8_8_8_REV */
    };
 
-   static const u_int32_t masks_table_bgr[8][4] = {
+   static const uint32_t masks_table_bgr[8][4] = {
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
@@ -588,7 +588,7 @@ driFillInModes( __GLcontextModes ** ptr_to_modes,
       { 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }, /* 8_8_8_8_REV */
    };
 
-   static const u_int32_t masks_table_bgra[8][4] = {
+   static const uint32_t masks_table_bgra[8][4] = {
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
       { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
@@ -599,12 +599,12 @@ driFillInModes( __GLcontextModes ** ptr_to_modes,
       { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 }, /* 8_8_8_8_REV */
    };
 
-   static const u_int8_t bytes_per_pixel[8] = {
+   static const uint8_t bytes_per_pixel[8] = {
       0, 0, 0, 2, 2, 4, 0, 4
    };
 
-   const u_int8_t  * bits;
-   const u_int32_t * masks;
+   const uint8_t  * bits;
+   const uint32_t * masks;
    const int index = fb_type & 0x07;
    __GLcontextModes * modes = *ptr_to_modes;
    unsigned i;
diff --git a/src/mesa/drivers/dri/common/utils.h b/src/mesa/drivers/dri/common/utils.h
index b28b895627d..1067d0a8bfd 100644
--- a/src/mesa/drivers/dri/common/utils.h
+++ b/src/mesa/drivers/dri/common/utils.h
@@ -113,7 +113,7 @@ extern GLboolean driClipRectToFramebuffer( const GLframebuffer *buffer,
 
 extern GLboolean driFillInModes( __GLcontextModes ** modes,
     GLenum fb_format, GLenum fb_type,
-    const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
+    const uint8_t * depth_bits, const uint8_t * stencil_bits,
     unsigned num_depth_stencil_bits,
     const GLenum * db_modes, unsigned num_db_modes, int visType );
 
diff --git a/src/mesa/drivers/dri/fb/fb_dri.c b/src/mesa/drivers/dri/fb/fb_dri.c
index a6d7590eff7..523a0c0380f 100644
--- a/src/mesa/drivers/dri/fb/fb_dri.c
+++ b/src/mesa/drivers/dri/fb/fb_dri.c
@@ -677,8 +677,8 @@ fbFillInModes( unsigned pixel_bits, unsigned depth_bits,
       GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
    };
 
-   u_int8_t depth_bits_array[2];
-   u_int8_t stencil_bits_array[2];
+   uint8_t depth_bits_array[2];
+   uint8_t stencil_bits_array[2];
 
 
    depth_bits_array[0] = depth_bits;
diff --git a/src/mesa/drivers/dri/fb/fb_egl.c b/src/mesa/drivers/dri/fb/fb_egl.c
index 517e71f8880..cc6a266df30 100644
--- a/src/mesa/drivers/dri/fb/fb_egl.c
+++ b/src/mesa/drivers/dri/fb/fb_egl.c
@@ -113,8 +113,8 @@ fbFillInConfigs(_EGLDisplay *disp, unsigned pixel_bits, unsigned depth_bits,
             GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
          };
 
-   u_int8_t depth_bits_array[2];
-   u_int8_t stencil_bits_array[2];
+   uint8_t depth_bits_array[2];
+   uint8_t stencil_bits_array[2];
 
    depth_bits_array[0] = 0;
    depth_bits_array[1] = depth_bits;
diff --git a/src/mesa/drivers/dri/ffb/ffb_xmesa.c b/src/mesa/drivers/dri/ffb/ffb_xmesa.c
index f521de63c02..a31cd57e882 100644
--- a/src/mesa/drivers/dri/ffb/ffb_xmesa.c
+++ b/src/mesa/drivers/dri/ffb/ffb_xmesa.c
@@ -641,8 +641,8 @@ ffbFillInModes( unsigned pixel_bits, unsigned depth_bits,
       GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
    };
 
-   u_int8_t depth_bits_array[3];
-   u_int8_t stencil_bits_array[3];
+   uint8_t depth_bits_array[3];
+   uint8_t stencil_bits_array[3];
 
 
    depth_bits_array[0] = 0;
diff --git a/src/mesa/drivers/dri/gamma/gamma_context.h b/src/mesa/drivers/dri/gamma/gamma_context.h
index fb70df6c37c..86af674ae75 100644
--- a/src/mesa/drivers/dri/gamma/gamma_context.h
+++ b/src/mesa/drivers/dri/gamma/gamma_context.h
@@ -159,13 +159,13 @@ struct gamma_texture_object_t {
       int internalFormat;
    } image[GAMMA_TEX_MAXLEVELS];
 
-   u_int32_t TextureBaseAddr[GAMMA_TEX_MAXLEVELS];
-   u_int32_t TextureAddressMode;
-   u_int32_t TextureColorMode;
-   u_int32_t TextureFilterMode;
-   u_int32_t TextureFormat;
-   u_int32_t TextureReadMode;
-   u_int32_t TextureBorderColor;
+   uint32_t TextureBaseAddr[GAMMA_TEX_MAXLEVELS];
+   uint32_t TextureAddressMode;
+   uint32_t TextureColorMode;
+   uint32_t TextureFilterMode;
+   uint32_t TextureFormat;
+   uint32_t TextureReadMode;
+   uint32_t TextureBorderColor;
 };		
 
 #define GAMMA_NO_PALETTE        0x0
@@ -299,18 +299,18 @@ struct gamma_context {
    	unsigned int lastStamp;
    
 
-    	u_int32_t 		ClearColor;
-	u_int32_t		Color;
-	u_int32_t		DitherMode;
-    	u_int32_t		ClearDepth;
-	u_int32_t		FogMode;
-	u_int32_t		AreaStippleMode;
-	u_int32_t		LBReadFormat;
-	u_int32_t		LBWriteFormat;
-	u_int32_t		LineMode;
-	u_int32_t		PointMode;
-	u_int32_t		TriangleMode;
-	u_int32_t		AntialiasMode;
+    	uint32_t 		ClearColor;
+	uint32_t		Color;
+	uint32_t		DitherMode;
+    	uint32_t		ClearDepth;
+	uint32_t		FogMode;
+	uint32_t		AreaStippleMode;
+	uint32_t		LBReadFormat;
+	uint32_t		LBWriteFormat;
+	uint32_t		LineMode;
+	uint32_t		PointMode;
+	uint32_t		TriangleMode;
+	uint32_t		AntialiasMode;
 	GLfloat			ViewportScaleX;
 	GLfloat			ViewportScaleY;
 	GLfloat			ViewportScaleZ;
diff --git a/src/mesa/drivers/dri/gamma/gamma_render.c b/src/mesa/drivers/dri/gamma/gamma_render.c
index 4b462f22525..9180ef925d0 100644
--- a/src/mesa/drivers/dri/gamma/gamma_render.c
+++ b/src/mesa/drivers/dri/gamma/gamma_render.c
@@ -74,7 +74,7 @@ static void gamma_emit( GLcontext *ctx, GLuint start, GLuint end)
 	    WRITEF(gmesa->buf, Tr4, tc0[i][2]);
 	    WRITEF(gmesa->buf, Tt4, tc0[i][0]);
 	    WRITEF(gmesa->buf, Ts4, tc0[i][1]);
-	    WRITE(gmesa->buf, PackedColor4, *(u_int32_t*)col[i]);
+	    WRITE(gmesa->buf, PackedColor4, *(uint32_t*)col[i]);
 	    WRITEF(gmesa->buf, Vw, coord[i][3]);
 	    WRITEF(gmesa->buf, Vz, coord[i][2]);
 	    WRITEF(gmesa->buf, Vy, coord[i][1]);
@@ -85,7 +85,7 @@ static void gamma_emit( GLcontext *ctx, GLuint start, GLuint end)
 	    CHECK_DMA_BUFFER(gmesa, 7);
 	    WRITEF(gmesa->buf, Tt2, tc0[i][0]);
 	    WRITEF(gmesa->buf, Ts2, tc0[i][1]);
-	    WRITE(gmesa->buf, PackedColor4, *(u_int32_t*)col[i]);
+	    WRITE(gmesa->buf, PackedColor4, *(uint32_t*)col[i]);
 	    WRITEF(gmesa->buf, Vw, coord[i][3]);
 	    WRITEF(gmesa->buf, Vz, coord[i][2]);
 	    WRITEF(gmesa->buf, Vy, coord[i][1]);
@@ -94,7 +94,7 @@ static void gamma_emit( GLcontext *ctx, GLuint start, GLuint end)
    } else {
       for (i=start; i < end; i++) {
 	    CHECK_DMA_BUFFER(gmesa, 4);
-	    WRITE(gmesa->buf, PackedColor4, *(u_int32_t*)col[i]);
+	    WRITE(gmesa->buf, PackedColor4, *(uint32_t*)col[i]);
 	    WRITEF(gmesa->buf, Vz, coord[i][2]);
 	    WRITEF(gmesa->buf, Vy, coord[i][1]);
 	    WRITEF(gmesa->buf, Vx3, coord[i][0]);
diff --git a/src/mesa/drivers/dri/gamma/gamma_span.c b/src/mesa/drivers/dri/gamma/gamma_span.c
index 012d77782b1..ea9a20595c9 100644
--- a/src/mesa/drivers/dri/gamma/gamma_span.c
+++ b/src/mesa/drivers/dri/gamma/gamma_span.c
@@ -171,10 +171,10 @@ static void gammaReadRGBASpan8888( const GLcontext *ctx,
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
    gammaScreenPtr gammascrn = gmesa->gammaScreen;
-   u_int32_t dwords1, dwords2, i = 0;
+   uint32_t dwords1, dwords2, i = 0;
    char *src = (char *)rgba[0];
    GLuint read = n * gammascrn->cpp; /* Number of bytes we are expecting */
-   u_int32_t data;
+   uint32_t data;
 
    FLUSH_DMA_BUFFER(gmesa);
    CHECK_DMA_BUFFER(gmesa, 16);
@@ -196,8 +196,8 @@ static void gammaReadRGBASpan8888( const GLcontext *ctx,
 
 moredata:
 
-   dwords1 = *(volatile u_int32_t*)(void *)(((u_int8_t*)gammascrn->regions[0].map) + (GlintOutFIFOWords));
-   dwords2 = *(volatile u_int32_t*)(void *)(((u_int8_t*)gammascrn->regions[2].map) + (GlintOutFIFOWords));
+   dwords1 = *(volatile uint32_t*)(void *)(((uint8_t*)gammascrn->regions[0].map) + (GlintOutFIFOWords));
+   dwords2 = *(volatile uint32_t*)(void *)(((uint8_t*)gammascrn->regions[2].map) + (GlintOutFIFOWords));
 
    if (dwords1) {
 	memcpy(src, (char*)gammascrn->regions[1].map + 0x1000, dwords1 << 2);
diff --git a/src/mesa/drivers/dri/gamma/gamma_state.c b/src/mesa/drivers/dri/gamma/gamma_state.c
index a0690f64d0e..9e7626a6fd3 100644
--- a/src/mesa/drivers/dri/gamma/gamma_state.c
+++ b/src/mesa/drivers/dri/gamma/gamma_state.c
@@ -44,9 +44,9 @@
 static void gammaUpdateAlphaMode( GLcontext *ctx )
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
-   u_int32_t a = gmesa->AlphaTestMode;
-   u_int32_t b = gmesa->AlphaBlendMode;
-   u_int32_t f = gmesa->AB_FBReadMode_Save = 0;
+   uint32_t a = gmesa->AlphaTestMode;
+   uint32_t b = gmesa->AlphaBlendMode;
+   uint32_t f = gmesa->AB_FBReadMode_Save = 0;
    GLubyte refByte = (GLint) (ctx->Color.AlphaRef * 255.0);
 
    a &= ~(AT_CompareMask | AT_RefValueMask);
@@ -418,10 +418,10 @@ static void gammaDDClear( GLcontext *ctx, GLbitfield mask )
 static void gammaUpdateZMode( GLcontext *ctx )
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
-   u_int32_t z = gmesa->DepthMode;
-   u_int32_t delta = gmesa->DeltaMode;
-   u_int32_t window = gmesa->Window;
-   u_int32_t lbread = gmesa->LBReadMode;
+   uint32_t z = gmesa->DepthMode;
+   uint32_t delta = gmesa->DeltaMode;
+   uint32_t window = gmesa->Window;
+   uint32_t lbread = gmesa->LBReadMode;
 
    z &= ~DM_CompareMask;
 
@@ -537,9 +537,9 @@ static void gammaDDFlush( GLcontext *ctx )
 static void gammaUpdateFogAttrib( GLcontext *ctx )
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
-   u_int32_t f = gmesa->FogMode;
-   u_int32_t g = gmesa->GeometryMode;
-   u_int32_t d = gmesa->DeltaMode;
+   uint32_t f = gmesa->FogMode;
+   uint32_t g = gmesa->GeometryMode;
+   uint32_t d = gmesa->DeltaMode;
 
    if (ctx->Fog.Enabled) {
       f |= FogModeEnable;
@@ -635,7 +635,7 @@ static void gammaDDPointSize( GLcontext *ctx, GLfloat size )
 static void gammaUpdatePolygon( GLcontext *ctx )
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
-   u_int32_t g = gmesa->GeometryMode;
+   uint32_t g = gmesa->GeometryMode;
 
    g &= ~(GM_PolyOffsetFillEnable | GM_PolyOffsetPointEnable |
           GM_PolyOffsetLineEnable);
@@ -753,7 +753,7 @@ static void gammaDDScissor( GLcontext *ctx,
 static void gammaUpdateCull( GLcontext *ctx )
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
-   u_int32_t g = gmesa->GeometryMode;
+   uint32_t g = gmesa->GeometryMode;
 
    g &= ~(GM_PolyCullMask | GM_FFMask);
 
@@ -973,8 +973,8 @@ static void gammaDDLightModelfv( GLcontext *ctx, GLenum pname,
 static void gammaDDShadeModel( GLcontext *ctx, GLenum mode )
 {
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
-   u_int32_t g = gmesa->GeometryMode;
-   u_int32_t c = gmesa->ColorDDAMode;
+   uint32_t g = gmesa->GeometryMode;
+   uint32_t c = gmesa->ColorDDAMode;
 
    g &= ~GM_ShadingMask;
    c &= ~ColorDDAShadingMask;
@@ -1241,7 +1241,7 @@ static void gammaDDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
 
    case GL_DITHER:
       do {
-	 u_int32_t d = gmesa->DitherMode;
+	 uint32_t d = gmesa->DitherMode;
 	 FLUSH_BATCH( gmesa );
 
 	 if ( state ) {
@@ -1273,7 +1273,7 @@ static void gammaDDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
 #if ENABLELIGHTING
    case GL_LIGHTING:
       do {
-	 u_int32_t l = gmesa->LightingMode;
+	 uint32_t l = gmesa->LightingMode;
 	 FLUSH_BATCH( gmesa );
 
 	 if ( state ) {
@@ -1291,7 +1291,7 @@ static void gammaDDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
 
    case GL_COLOR_MATERIAL:
       do {
-	 u_int32_t m = gmesa->MaterialMode;
+	 uint32_t m = gmesa->MaterialMode;
 	 FLUSH_BATCH( gmesa );
 
 	 if ( state ) {
diff --git a/src/mesa/drivers/dri/gamma/gamma_tex.c b/src/mesa/drivers/dri/gamma/gamma_tex.c
index 0770cbf694b..3b4ee4e581c 100644
--- a/src/mesa/drivers/dri/gamma/gamma_tex.c
+++ b/src/mesa/drivers/dri/gamma/gamma_tex.c
@@ -31,8 +31,8 @@ static GLuint gammaComputeLodBias(GLfloat bias)
 static void gammaSetTexWrapping(gammaTextureObjectPtr t, 
 			       GLenum wraps, GLenum wrapt)
 {
-   u_int32_t t1 = t->TextureAddressMode;
-   u_int32_t t2 = t->TextureReadMode;
+   uint32_t t1 = t->TextureAddressMode;
+   uint32_t t2 = t->TextureReadMode;
 
    t1 &= ~(TAM_SWrap_Mask | TAM_TWrap_Mask);
    t2 &= ~(TRM_UWrap_Mask | TRM_VWrap_Mask);
@@ -57,8 +57,8 @@ static void gammaSetTexFilter(gammaContextPtr gmesa,
 			     GLenum minf, GLenum magf,
                              GLfloat bias)
 {
-   u_int32_t t1 = t->TextureAddressMode;
-   u_int32_t t2 = t->TextureReadMode;
+   uint32_t t1 = t->TextureAddressMode;
+   uint32_t t2 = t->TextureReadMode;
 
    t2 &= ~(TRM_Mag_Mask | TRM_Min_Mask);
 
diff --git a/src/mesa/drivers/dri/gamma/gamma_tritmp.h b/src/mesa/drivers/dri/gamma/gamma_tritmp.h
index 56e0a850c8b..bea2508d4a2 100644
--- a/src/mesa/drivers/dri/gamma/gamma_tritmp.h
+++ b/src/mesa/drivers/dri/gamma/gamma_tritmp.h
@@ -2,8 +2,8 @@
 static void TAG(gamma_point)( gammaContextPtr gmesa, 
 			     const gammaVertex *v0 )
 {
-    u_int32_t vColor;
-    u_int32_t vBegin;
+    uint32_t vColor;
+    uint32_t vBegin;
 
     vBegin = gmesa->Begin | B_PrimType_Points;
 
@@ -56,8 +56,8 @@ static void TAG(gamma_line)( gammaContextPtr gmesa,
 			     const gammaVertex *v0,
 			     const gammaVertex *v1 )
 {
-    u_int32_t vColor;
-    u_int32_t vBegin;
+    uint32_t vColor;
+    uint32_t vBegin;
 
     vBegin = gmesa->Begin | B_PrimType_Lines;
 
@@ -165,8 +165,8 @@ static void TAG(gamma_triangle)( gammaContextPtr gmesa,
 				 const gammaVertex *v1, 
 				 const gammaVertex *v2 )
 {
-    u_int32_t vColor;
-    u_int32_t vBegin;
+    uint32_t vColor;
+    uint32_t vBegin;
 
     vBegin = gmesa->Begin | B_PrimType_Triangles;
 
@@ -310,8 +310,8 @@ static void TAG(gamma_quad)( gammaContextPtr gmesa,
 			    const gammaVertex *v2,
 			    const gammaVertex *v3 )
 {
-    u_int32_t vColor;
-    u_int32_t vBegin;
+    uint32_t vColor;
+    uint32_t vBegin;
 
     vBegin = gmesa->Begin | B_PrimType_Quads;
 
diff --git a/src/mesa/drivers/dri/i810/i810screen.c b/src/mesa/drivers/dri/i810/i810screen.c
index 695b996319a..733c97b2ad4 100644
--- a/src/mesa/drivers/dri/i810/i810screen.c
+++ b/src/mesa/drivers/dri/i810/i810screen.c
@@ -63,11 +63,11 @@ static __GLcontextModes *fill_in_modes( __GLcontextModes *modes,
 				       unsigned num_db_modes,
 				       int visType )
 {
-    static const u_int8_t bits[1][4] = {
+    static const uint8_t bits[1][4] = {
 	{          5,          6,          5,          0 }
     };
 
-    static const u_int32_t masks[1][4] = {
+    static const uint32_t masks[1][4] = {
 	{ 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }
     };
 
diff --git a/src/mesa/drivers/dri/i915/intel_ioctl.c b/src/mesa/drivers/dri/i915/intel_ioctl.c
index ede3b6378fe..aa7c6d106ce 100644
--- a/src/mesa/drivers/dri/i915/intel_ioctl.c
+++ b/src/mesa/drivers/dri/i915/intel_ioctl.c
@@ -40,10 +40,10 @@
 #include "intel_batchbuffer.h"
 #include "drm.h"
 
-u_int32_t intelGetLastFrame (intelContextPtr intel) 
+uint32_t intelGetLastFrame (intelContextPtr intel) 
 {
    int ret;
-   u_int32_t frame;
+   uint32_t frame;
    drm_i915_getparam_t gp;
    
    gp.param = I915_PARAM_LAST_DISPATCH;
diff --git a/src/mesa/drivers/dri/i915/intel_ioctl.h b/src/mesa/drivers/dri/i915/intel_ioctl.h
index 6ea47e462e1..8d79e9d73b4 100644
--- a/src/mesa/drivers/dri/i915/intel_ioctl.h
+++ b/src/mesa/drivers/dri/i915/intel_ioctl.h
@@ -67,6 +67,6 @@ extern GLboolean intelIsAgpMemory( intelContextPtr intel, const GLvoid *pointer,
 extern GLuint intelAgpOffsetFromVirtual( intelContextPtr intel, const GLvoid *p );
 
 extern void intelWaitIrq( intelContextPtr intel, int seq );
-extern u_int32_t intelGetLastFrame (intelContextPtr intel);
+extern uint32_t intelGetLastFrame (intelContextPtr intel);
 extern int intelEmitIrqLocked( intelContextPtr intel );
 #endif
diff --git a/src/mesa/drivers/dri/i915/intel_screen.c b/src/mesa/drivers/dri/i915/intel_screen.c
index ca8610b4965..7e7935510a0 100644
--- a/src/mesa/drivers/dri/i915/intel_screen.c
+++ b/src/mesa/drivers/dri/i915/intel_screen.c
@@ -566,8 +566,8 @@ intelFillInModes( unsigned pixel_bits, unsigned depth_bits,
       GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
    };
 
-   u_int8_t depth_bits_array[3];
-   u_int8_t stencil_bits_array[3];
+   uint8_t depth_bits_array[3];
+   uint8_t stencil_bits_array[3];
 
 
    depth_bits_array[0] = 0;
diff --git a/src/mesa/drivers/dri/i965/intel_screen.c b/src/mesa/drivers/dri/i965/intel_screen.c
index 5dac50df32c..bc3dd30b7ed 100644
--- a/src/mesa/drivers/dri/i965/intel_screen.c
+++ b/src/mesa/drivers/dri/i965/intel_screen.c
@@ -578,8 +578,8 @@ intelFillInModes( unsigned pixel_bits, unsigned depth_bits,
       GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
    };
 
-   u_int8_t depth_bits_array[3];
-   u_int8_t stencil_bits_array[3];
+   uint8_t depth_bits_array[3];
+   uint8_t stencil_bits_array[3];
 
 
    depth_bits_array[0] = 0;
diff --git a/src/mesa/drivers/dri/mach64/mach64_screen.c b/src/mesa/drivers/dri/mach64/mach64_screen.c
index b780ba65eab..300a3deaaf9 100644
--- a/src/mesa/drivers/dri/mach64/mach64_screen.c
+++ b/src/mesa/drivers/dri/mach64/mach64_screen.c
@@ -77,12 +77,12 @@ static __GLcontextModes * fill_in_modes( __GLcontextModes * modes,
 					 unsigned num_db_modes,
 					 int visType )
 {
-       static const u_int8_t bits[2][4] = {
+       static const uint8_t bits[2][4] = {
 	{          5,          6,          5,          0 },
 	{          8,          8,          8,          0 }
     };
 
-    static const u_int32_t masks[2][4] = {
+    static const uint32_t masks[2][4] = {
 	{ 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 },
 	{ 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }
     };
diff --git a/src/mesa/drivers/dri/mga/mga_xmesa.c b/src/mesa/drivers/dri/mga/mga_xmesa.c
index 6148f6b4880..d0cf06fea5a 100644
--- a/src/mesa/drivers/dri/mga/mga_xmesa.c
+++ b/src/mesa/drivers/dri/mga/mga_xmesa.c
@@ -130,8 +130,8 @@ mgaFillInModes( unsigned pixel_bits, unsigned depth_bits,
 	GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
     };
 
-    u_int8_t depth_bits_array[3];
-    u_int8_t stencil_bits_array[3];
+    uint8_t depth_bits_array[3];
+    uint8_t stencil_bits_array[3];
 
 
     depth_bits_array[0] = 0;
diff --git a/src/mesa/drivers/dri/mga/mga_xmesa.h b/src/mesa/drivers/dri/mga/mga_xmesa.h
index 0f81c9cbecc..7de7bb06e87 100644
--- a/src/mesa/drivers/dri/mga/mga_xmesa.h
+++ b/src/mesa/drivers/dri/mga/mga_xmesa.h
@@ -148,7 +148,7 @@ do {						\
 #define MGA_BASE( reg )		((unsigned long)(mmesa->mgaScreen->mmio.map))
 #define MGA_ADDR( reg )		(MGA_BASE(reg) + reg)
 
-#define MGA_DEREF( reg )	*(volatile u_int32_t *)MGA_ADDR( reg )
+#define MGA_DEREF( reg )	*(volatile uint32_t *)MGA_ADDR( reg )
 #define MGA_READ( reg )		MGA_DEREF( reg )
 
 #endif
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_context.h b/src/mesa/drivers/dri/nouveau/nouveau_context.h
index 9a0be2cb2a5..db4d4cb6b71 100644
--- a/src/mesa/drivers/dri/nouveau/nouveau_context.h
+++ b/src/mesa/drivers/dri/nouveau/nouveau_context.h
@@ -46,13 +46,13 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 typedef struct nouveau_fifo_t{
 	int channel;
-	u_int32_t* buffer;
-	u_int32_t* mmio;
-	u_int32_t put_base;
-	u_int32_t current;
-	u_int32_t put;
-	u_int32_t free;
-	u_int32_t max;
+	uint32_t* buffer;
+	uint32_t* mmio;
+	uint32_t put_base;
+	uint32_t current;
+	uint32_t put;
+	uint32_t free;
+	uint32_t max;
 }
 nouveau_fifo;
 
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_fifo.c b/src/mesa/drivers/dri/nouveau/nouveau_fifo.c
index 7b5e96b4c26..5eb53aa46cb 100644
--- a/src/mesa/drivers/dri/nouveau/nouveau_fifo.c
+++ b/src/mesa/drivers/dri/nouveau/nouveau_fifo.c
@@ -45,12 +45,12 @@ int nouveau_fifo_remaining=0;
 
 #define RING_SKIPS 8
 
-void WAIT_RING(nouveauContextPtr nmesa,u_int32_t size)
+void WAIT_RING(nouveauContextPtr nmesa,uint32_t size)
 {
 #ifdef NOUVEAU_RING_DEBUG
 	return;
 #endif
-	u_int32_t fifo_get;
+	uint32_t fifo_get;
 	while(nmesa->fifo.free < size+1) {
 		fifo_get = NV_FIFO_READ_GET();
 
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_fifo.h b/src/mesa/drivers/dri/nouveau/nouveau_fifo.h
index 23325dcea53..67f9cd4fc89 100644
--- a/src/mesa/drivers/dri/nouveau/nouveau_fifo.h
+++ b/src/mesa/drivers/dri/nouveau/nouveau_fifo.h
@@ -44,10 +44,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define NOUVEAU_RING_TRACE 1
 #endif
 
-#define NV_READ(reg) *(volatile u_int32_t *)(nmesa->mmio + (reg))
+#define NV_READ(reg) *(volatile uint32_t *)(nmesa->mmio + (reg))
 
-#define NV_FIFO_READ(reg) *(volatile u_int32_t *)(nmesa->fifo.mmio + (reg/4))
-#define NV_FIFO_WRITE(reg,value) *(volatile u_int32_t *)(nmesa->fifo.mmio + (reg/4)) = value;
+#define NV_FIFO_READ(reg) *(volatile uint32_t *)(nmesa->fifo.mmio + (reg/4))
+#define NV_FIFO_WRITE(reg,value) *(volatile uint32_t *)(nmesa->fifo.mmio + (reg/4)) = value;
 #define NV_FIFO_READ_GET() ((NV_FIFO_READ(NV03_FIFO_REGS_DMAGET) - nmesa->fifo.put_base) >> 2)
 #define NV_FIFO_WRITE_PUT(val) do { \
 	if (NOUVEAU_RING_TRACE) {\
@@ -136,7 +136,7 @@ if (NOUVEAU_RING_TRACE) \
 
 #endif
 
-extern void WAIT_RING(nouveauContextPtr nmesa,u_int32_t size);
+extern void WAIT_RING(nouveauContextPtr nmesa,uint32_t size);
 extern void nouveau_state_cache_flush(nouveauContextPtr nmesa);
 extern void nouveau_state_cache_init(nouveauContextPtr nmesa);
 
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_screen.c b/src/mesa/drivers/dri/nouveau/nouveau_screen.c
index 69b0691bb7b..2cf6f979e40 100644
--- a/src/mesa/drivers/dri/nouveau/nouveau_screen.c
+++ b/src/mesa/drivers/dri/nouveau/nouveau_screen.c
@@ -257,8 +257,8 @@ nouveauFillInModes( unsigned pixel_bits, unsigned depth_bits,
 		GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
 	};
 
-	u_int8_t depth_bits_array[4]   = { 0, 16, 24, 24 };
-	u_int8_t stencil_bits_array[4] = { 0,  0,  0,  8 };
+	uint8_t depth_bits_array[4]   = { 0, 16, 24, 24 };
+	uint8_t stencil_bits_array[4] = { 0,  0,  0,  8 };
 
 	depth_buffer_factor = 4;
 	back_buffer_factor  = (have_back_buffer) ? 3 : 1;
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_screen.h b/src/mesa/drivers/dri/nouveau/nouveau_screen.h
index decdafa86d5..bbe5810128f 100644
--- a/src/mesa/drivers/dri/nouveau/nouveau_screen.h
+++ b/src/mesa/drivers/dri/nouveau/nouveau_screen.h
@@ -35,8 +35,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 typedef struct {
 	nouveau_card* card;
-	u_int32_t bus_type;
-	u_int32_t agp_mode;
+	uint32_t bus_type;
+	uint32_t agp_mode;
 
         GLint fbFormat;
 
diff --git a/src/mesa/drivers/dri/r128/r128_context.h b/src/mesa/drivers/dri/r128/r128_context.h
index 3f96836df11..1d10cb0b4fe 100644
--- a/src/mesa/drivers/dri/r128/r128_context.h
+++ b/src/mesa/drivers/dri/r128/r128_context.h
@@ -137,9 +137,9 @@ struct r128_context {
    GLfloat hw_viewport[16];
    GLfloat depth_scale;
 
-   u_int32_t ClearColor;			/* Color used to clear color buffer */
-   u_int32_t ClearDepth;			/* Value used to clear depth buffer */
-   u_int32_t ClearStencil;		/* Value used to clear stencil */
+   uint32_t ClearColor;			/* Color used to clear color buffer */
+   uint32_t ClearDepth;			/* Value used to clear depth buffer */
+   uint32_t ClearStencil;		/* Value used to clear stencil */
 
    /* Map GL texture units onto hardware
     */
diff --git a/src/mesa/drivers/dri/r128/r128_ioctl.c b/src/mesa/drivers/dri/r128/r128_ioctl.c
index 25188061a07..dcb5d10459e 100644
--- a/src/mesa/drivers/dri/r128/r128_ioctl.c
+++ b/src/mesa/drivers/dri/r128/r128_ioctl.c
@@ -230,7 +230,7 @@ static int r128WaitForFrameCompletion( r128ContextPtr rmesa )
    int wait = 0;
 
    while ( 1 ) {
-      u_int32_t frame = read_MMIO_LE32( R128MMIO, R128_LAST_FRAME_REG );
+      uint32_t frame = read_MMIO_LE32( R128MMIO, R128_LAST_FRAME_REG );
 
       if ( rmesa->sarea->last_frame - frame <= R128_MAX_OUTSTANDING ) {
 	 break;
diff --git a/src/mesa/drivers/dri/r128/r128_ioctl.h b/src/mesa/drivers/dri/r128/r128_ioctl.h
index 57063c41f5e..52ae3a293f8 100644
--- a/src/mesa/drivers/dri/r128/r128_ioctl.h
+++ b/src/mesa/drivers/dri/r128/r128_ioctl.h
@@ -38,7 +38,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r128_reg.h"
 #include "r128_lock.h"
 
-#define R128_BUFFER_MAX_DWORDS	(R128_BUFFER_SIZE / sizeof(u_int32_t))
+#define R128_BUFFER_MAX_DWORDS	(R128_BUFFER_SIZE / sizeof(uint32_t))
 
 
 extern drmBufPtr r128GetBufferLocked( r128ContextPtr rmesa );
@@ -47,7 +47,7 @@ extern void r128FlushVerticesLocked( r128ContextPtr rmesa );
 static __inline void *r128AllocDmaLow( r128ContextPtr rmesa, int count,
 				       int vert_size )
 {
-   u_int32_t *head;
+   uint32_t *head;
    int bytes = count * vert_size;
 
    if ( !rmesa->vert_buf ) {
@@ -61,7 +61,7 @@ static __inline void *r128AllocDmaLow( r128ContextPtr rmesa, int count,
       UNLOCK_HARDWARE( rmesa );
    }
 
-   head = (u_int32_t *)((char *)rmesa->vert_buf->address + rmesa->vert_buf->used);
+   head = (uint32_t *)((char *)rmesa->vert_buf->address + rmesa->vert_buf->used);
    rmesa->vert_buf->used += bytes;
    rmesa->num_verts += count;
    
diff --git a/src/mesa/drivers/dri/r128/r128_screen.c b/src/mesa/drivers/dri/r128/r128_screen.c
index 0722b80ee51..1e9616272f0 100644
--- a/src/mesa/drivers/dri/r128/r128_screen.c
+++ b/src/mesa/drivers/dri/r128/r128_screen.c
@@ -442,8 +442,8 @@ r128FillInModes( unsigned pixel_bits, unsigned depth_bits,
 	GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
     };
 
-    u_int8_t depth_bits_array[2];
-    u_int8_t stencil_bits_array[2];
+    uint8_t depth_bits_array[2];
+    uint8_t stencil_bits_array[2];
 
 
     depth_bits_array[0] = depth_bits;
diff --git a/src/mesa/drivers/dri/r128/r128_tex.c b/src/mesa/drivers/dri/r128/r128_tex.c
index 554a92287f7..5712351b037 100644
--- a/src/mesa/drivers/dri/r128/r128_tex.c
+++ b/src/mesa/drivers/dri/r128/r128_tex.c
@@ -461,9 +461,9 @@ static void r128TexEnv( GLcontext *ctx, GLenum target,
 
    case GL_TEXTURE_LOD_BIAS:
       {
-	 u_int32_t t = rmesa->setup.tex_cntl_c;
+	 uint32_t t = rmesa->setup.tex_cntl_c;
 	 GLint bias;
-	 u_int32_t b;
+	 uint32_t b;
 
 	 /* GTH: This isn't exactly correct, but gives good results up to a
 	  * certain point.  It is better than completely ignoring the LOD
@@ -483,7 +483,7 @@ static void r128TexEnv( GLcontext *ctx, GLenum target,
 	    bias = 127;
 	 }
 
-	 b = (u_int32_t)bias & 0xff;
+	 b = (uint32_t)bias & 0xff;
 	 t &= ~R128_LOD_BIAS_MASK;
 	 t |= (b << R128_LOD_BIAS_SHIFT);
 
diff --git a/src/mesa/drivers/dri/r128/r128_tex.h b/src/mesa/drivers/dri/r128/r128_tex.h
index 994dffb5a9a..e863436f4b2 100644
--- a/src/mesa/drivers/dri/r128/r128_tex.h
+++ b/src/mesa/drivers/dri/r128/r128_tex.h
@@ -67,7 +67,7 @@ extern void r128InitTextureFuncs( struct dd_function_table *functions );
 #define R128PACKCOLOR4444( r, g, b, a )					\
    ((((a) & 0xf0) << 8) | (((r) & 0xf0) << 4) | ((g) & 0xf0) | ((b) >> 4))
 
-static __inline__ u_int32_t r128PackColor( GLuint cpp,
+static __inline__ uint32_t r128PackColor( GLuint cpp,
 					GLubyte r, GLubyte g,
 					GLubyte b, GLubyte a )
 {
diff --git a/src/mesa/drivers/dri/r128/r128_texmem.c b/src/mesa/drivers/dri/r128/r128_texmem.c
index a7d02806369..af510a38c95 100644
--- a/src/mesa/drivers/dri/r128/r128_texmem.c
+++ b/src/mesa/drivers/dri/r128/r128_texmem.c
@@ -84,7 +84,7 @@ static void uploadSubImage( r128ContextPtr rmesa, r128TexObjPtr t,
    int imageWidth, imageHeight;
    int remaining, rows;
    int format, dwords;
-   u_int32_t pitch, offset;
+   uint32_t pitch, offset;
    int i;
 
    /* Ensure we have a valid texture to upload */
@@ -200,7 +200,7 @@ static void uploadSubImage( r128ContextPtr rmesa, r128TexObjPtr t,
 	 remaining > 0 ;
 	 remaining -= rows, y += rows, i++ )
    {
-      u_int32_t *dst;
+      uint32_t *dst;
       drmBufPtr buffer;
 
       assert(image->Data);
@@ -211,7 +211,7 @@ static void uploadSubImage( r128ContextPtr rmesa, r128TexObjPtr t,
       LOCK_HARDWARE( rmesa );
       buffer = r128GetBufferLocked( rmesa );
 
-      dst = (u_int32_t *)((char *)buffer->address + R128_HOSTDATA_BLIT_OFFSET);
+      dst = (uint32_t *)((char *)buffer->address + R128_HOSTDATA_BLIT_OFFSET);
 
       /* Copy the next chunck of the texture image into the blit buffer */
       {
diff --git a/src/mesa/drivers/dri/r128/r128_texobj.h b/src/mesa/drivers/dri/r128/r128_texobj.h
index 08eac87758b..8a0596eea8e 100644
--- a/src/mesa/drivers/dri/r128/r128_texobj.h
+++ b/src/mesa/drivers/dri/r128/r128_texobj.h
@@ -52,14 +52,14 @@ typedef struct r128_tex_obj r128TexObj, *r128TexObjPtr;
 struct r128_tex_obj {
    driTextureObject   base;
 
-   u_int32_t bufAddr;			/* Offset to start of locally
+   uint32_t bufAddr;			/* Offset to start of locally
 					   shared texture block */
 
    GLuint age;
    r128TexImage image[R128_MAX_TEXTURE_LEVELS]; /* Image data for all
 						   mipmap levels */
 
-   u_int32_t textureFormat;		/* Actual hardware format */
+   uint32_t textureFormat;		/* Actual hardware format */
 
    drm_r128_texture_regs_t setup;		/* Setup regs for texture */
 };
diff --git a/src/mesa/drivers/dri/r128/server/r128.h b/src/mesa/drivers/dri/r128/server/r128.h
index ca08d7c86a8..413c7c66908 100644
--- a/src/mesa/drivers/dri/r128/server/r128.h
+++ b/src/mesa/drivers/dri/r128/server/r128.h
@@ -86,74 +86,74 @@ typedef struct {        /* All values in XCLKS    */
 
 typedef struct {
 				/* Common registers */
-    u_int32_t     ovr_clr;
-    u_int32_t     ovr_wid_left_right;
-    u_int32_t     ovr_wid_top_bottom;
-    u_int32_t     ov0_scale_cntl;
-    u_int32_t     mpp_tb_config;
-    u_int32_t     mpp_gp_config;
-    u_int32_t     subpic_cntl;
-    u_int32_t     viph_control;
-    u_int32_t     i2c_cntl_1;
-    u_int32_t     gen_int_cntl;
-    u_int32_t     cap0_trig_cntl;
-    u_int32_t     cap1_trig_cntl;
-    u_int32_t     bus_cntl;
-    u_int32_t     config_cntl;
+    uint32_t     ovr_clr;
+    uint32_t     ovr_wid_left_right;
+    uint32_t     ovr_wid_top_bottom;
+    uint32_t     ov0_scale_cntl;
+    uint32_t     mpp_tb_config;
+    uint32_t     mpp_gp_config;
+    uint32_t     subpic_cntl;
+    uint32_t     viph_control;
+    uint32_t     i2c_cntl_1;
+    uint32_t     gen_int_cntl;
+    uint32_t     cap0_trig_cntl;
+    uint32_t     cap1_trig_cntl;
+    uint32_t     bus_cntl;
+    uint32_t     config_cntl;
 
 				/* Other registers to save for VT switches */
-    u_int32_t     dp_datatype;
-    u_int32_t     gen_reset_cntl;
-    u_int32_t     clock_cntl_index;
-    u_int32_t     amcgpio_en_reg;
-    u_int32_t     amcgpio_mask;
+    uint32_t     dp_datatype;
+    uint32_t     gen_reset_cntl;
+    uint32_t     clock_cntl_index;
+    uint32_t     amcgpio_en_reg;
+    uint32_t     amcgpio_mask;
 
 				/* CRTC registers */
-    u_int32_t     crtc_gen_cntl;
-    u_int32_t     crtc_ext_cntl;
-    u_int32_t     dac_cntl;
-    u_int32_t     crtc_h_total_disp;
-    u_int32_t     crtc_h_sync_strt_wid;
-    u_int32_t     crtc_v_total_disp;
-    u_int32_t     crtc_v_sync_strt_wid;
-    u_int32_t     crtc_offset;
-    u_int32_t     crtc_offset_cntl;
-    u_int32_t     crtc_pitch;
+    uint32_t     crtc_gen_cntl;
+    uint32_t     crtc_ext_cntl;
+    uint32_t     dac_cntl;
+    uint32_t     crtc_h_total_disp;
+    uint32_t     crtc_h_sync_strt_wid;
+    uint32_t     crtc_v_total_disp;
+    uint32_t     crtc_v_sync_strt_wid;
+    uint32_t     crtc_offset;
+    uint32_t     crtc_offset_cntl;
+    uint32_t     crtc_pitch;
 
 				/* CRTC2 registers */
-    u_int32_t     crtc2_gen_cntl;
+    uint32_t     crtc2_gen_cntl;
 
 				/* Flat panel registers */
-    u_int32_t     fp_crtc_h_total_disp;
-    u_int32_t     fp_crtc_v_total_disp;
-    u_int32_t     fp_gen_cntl;
-    u_int32_t     fp_h_sync_strt_wid;
-    u_int32_t     fp_horz_stretch;
-    u_int32_t     fp_panel_cntl;
-    u_int32_t     fp_v_sync_strt_wid;
-    u_int32_t     fp_vert_stretch;
-    u_int32_t     lvds_gen_cntl;
-    u_int32_t     tmds_crc;
-    u_int32_t     tmds_transmitter_cntl;
+    uint32_t     fp_crtc_h_total_disp;
+    uint32_t     fp_crtc_v_total_disp;
+    uint32_t     fp_gen_cntl;
+    uint32_t     fp_h_sync_strt_wid;
+    uint32_t     fp_horz_stretch;
+    uint32_t     fp_panel_cntl;
+    uint32_t     fp_v_sync_strt_wid;
+    uint32_t     fp_vert_stretch;
+    uint32_t     lvds_gen_cntl;
+    uint32_t     tmds_crc;
+    uint32_t     tmds_transmitter_cntl;
 
 				/* Computed values for PLL */
-    u_int32_t     dot_clock_freq;
-    u_int32_t     pll_output_freq;
+    uint32_t     dot_clock_freq;
+    uint32_t     pll_output_freq;
     int        feedback_div;
     int        post_div;
 
 				/* PLL registers */
-    u_int32_t     ppll_ref_div;
-    u_int32_t     ppll_div_3;
-    u_int32_t     htotal_cntl;
+    uint32_t     ppll_ref_div;
+    uint32_t     ppll_div_3;
+    uint32_t     htotal_cntl;
 
 				/* DDA register */
-    u_int32_t     dda_config;
-    u_int32_t     dda_on_off;
+    uint32_t     dda_config;
+    uint32_t     dda_on_off;
 
 				/* Pallet */
     GLboolean  palette_valid;
-    u_int32_t     palette[256];
+    uint32_t     palette[256];
 } R128SaveRec, *R128SavePtr;
 
 typedef struct {
@@ -168,8 +168,8 @@ typedef struct {
     unsigned char     *MMIO;        /* Map of MMIO region                    */
     unsigned char     *FB;          /* Map of frame buffer                   */
 
-    u_int32_t            MemCntl;
-    u_int32_t            BusCntl;
+    uint32_t            MemCntl;
+    uint32_t            BusCntl;
     unsigned long     FbMapSize;    /* Size of frame buffer, in bytes        */
     int               Flags;        /* Saved copy of mode flags              */
 
@@ -200,7 +200,7 @@ typedef struct {
 				/* Computed values for Rage 128 */
     int               pitch;
     int               datatype;
-    u_int32_t            dp_gui_master_cntl;
+    uint32_t            dp_gui_master_cntl;
 
 				/* Saved values for ScreenToScreenCopy */
     int               xdir;
@@ -305,18 +305,18 @@ typedef struct {
     int               log2TexGran;
 
 				/* Saved scissor values */
-    u_int32_t            sc_left;
-    u_int32_t            sc_right;
-    u_int32_t            sc_top;
-    u_int32_t            sc_bottom;
+    uint32_t            sc_left;
+    uint32_t            sc_right;
+    uint32_t            sc_top;
+    uint32_t            sc_bottom;
 
-    u_int32_t            re_top_left;
-    u_int32_t            re_width_height;
+    uint32_t            re_top_left;
+    uint32_t            re_width_height;
 
-    u_int32_t            aux_sc_cntl;
+    uint32_t            aux_sc_cntl;
 
     int               irq;
-    u_int32_t            gen_int_cntl;
+    uint32_t            gen_int_cntl;
 
     GLboolean              DMAForXv;
 
@@ -387,7 +387,7 @@ do {									\
 
 #define R128_VERBOSE	0
 
-#define RING_LOCALS	u_int32_t *__head; int __count;
+#define RING_LOCALS	uint32_t *__head; int __count;
 
 #define R128CCE_REFRESH(pScrn, info)					\
 do {									\
@@ -428,12 +428,12 @@ do {									\
          fprintf(stderr,				\
 		  "ADVANCE_RING() used: %d+%d=%d/%d\n",			\
 		  info->indirectBuffer->used - info->indirectStart,	\
-		  __count * sizeof(u_int32_t),				\
+		  __count * sizeof(uint32_t),				\
 		  info->indirectBuffer->used - info->indirectStart +	\
-		  __count * sizeof(u_int32_t),				\
+		  __count * sizeof(uint32_t),				\
 		  info->indirectBuffer->total - info->indirectStart );	\
    }									\
-   info->indirectBuffer->used += __count * (int)sizeof(u_int32_t);		\
+   info->indirectBuffer->used += __count * (int)sizeof(uint32_t);		\
 } while (0)
 
 #define OUT_RING( x ) do {						\
diff --git a/src/mesa/drivers/dri/r128/server/r128_dri.c b/src/mesa/drivers/dri/r128/server/r128_dri.c
index efe9232dc25..6e3db948af7 100644
--- a/src/mesa/drivers/dri/r128/server/r128_dri.c
+++ b/src/mesa/drivers/dri/r128/server/r128_dri.c
@@ -271,7 +271,7 @@ static GLboolean R128DRIPciInit(const DRIDriverContext *ctx)
 {
     R128InfoPtr info = ctx->driverPrivate;
     unsigned char *R128MMIO = ctx->MMIOAddress;
-    u_int32_t chunk;
+    uint32_t chunk;
     int ret;
     int flags;
 
diff --git a/src/mesa/drivers/dri/r200/r200_ioctl.c b/src/mesa/drivers/dri/r200/r200_ioctl.c
index 2366bde5250..ed57defb498 100644
--- a/src/mesa/drivers/dri/r200/r200_ioctl.c
+++ b/src/mesa/drivers/dri/r200/r200_ioctl.c
@@ -333,11 +333,11 @@ void r200AllocDmaRegion( r200ContextPtr rmesa,
  * SwapBuffers with client-side throttling
  */
 
-static u_int32_t r200GetLastFrame(r200ContextPtr rmesa)
+static uint32_t r200GetLastFrame(r200ContextPtr rmesa)
 {
    drm_radeon_getparam_t gp;
    int ret;
-   u_int32_t frame;
+   uint32_t frame;
 
    gp.param = RADEON_PARAM_LAST_FRAME;
    gp.value = (int *)&frame;
diff --git a/src/mesa/drivers/dri/r200/r200_state.c b/src/mesa/drivers/dri/r200/r200_state.c
index 1d975ecd57d..e9d2d9a3cd1 100644
--- a/src/mesa/drivers/dri/r200/r200_state.c
+++ b/src/mesa/drivers/dri/r200/r200_state.c
@@ -902,7 +902,7 @@ static void r200PolygonMode( GLcontext *ctx, GLenum face, GLenum mode )
 static void r200UpdateSpecular( GLcontext *ctx )
 {
    r200ContextPtr rmesa = R200_CONTEXT(ctx);
-   u_int32_t p = rmesa->hw.ctx.cmd[CTX_PP_CNTL];
+   uint32_t p = rmesa->hw.ctx.cmd[CTX_PP_CNTL];
 
    R200_STATECHANGE( rmesa, tcl );
    R200_STATECHANGE( rmesa, vtx );
diff --git a/src/mesa/drivers/dri/radeon/radeon_ioctl.c b/src/mesa/drivers/dri/radeon/radeon_ioctl.c
index f7e461239e7..a0c563c7cba 100644
--- a/src/mesa/drivers/dri/radeon/radeon_ioctl.c
+++ b/src/mesa/drivers/dri/radeon/radeon_ioctl.c
@@ -777,11 +777,11 @@ void radeonAllocDmaRegion( radeonContextPtr rmesa,
  * SwapBuffers with client-side throttling
  */
 
-static u_int32_t radeonGetLastFrame (radeonContextPtr rmesa) 
+static uint32_t radeonGetLastFrame (radeonContextPtr rmesa) 
 {
    drm_radeon_getparam_t gp;
    int ret;
-   u_int32_t frame;
+   uint32_t frame;
 
    gp.param = RADEON_PARAM_LAST_FRAME;
    gp.value = (int *)&frame;
@@ -1025,7 +1025,7 @@ static void radeonClear( GLcontext *ctx, GLbitfield mask )
    radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
    __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
    drm_radeon_sarea_t *sarea = rmesa->sarea;
-   u_int32_t clear;
+   uint32_t clear;
    GLuint flags = 0;
    GLuint color_mask = 0;
    GLint ret, i;
diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.c b/src/mesa/drivers/dri/radeon/radeon_screen.c
index 4a459486088..762848fc260 100644
--- a/src/mesa/drivers/dri/radeon/radeon_screen.c
+++ b/src/mesa/drivers/dri/radeon/radeon_screen.c
@@ -271,8 +271,8 @@ radeonFillInModes( unsigned pixel_bits, unsigned depth_bits,
 	GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
     };
 
-    u_int8_t depth_bits_array[2];
-    u_int8_t stencil_bits_array[2];
+    uint8_t depth_bits_array[2];
+    uint8_t stencil_bits_array[2];
 
 
     depth_bits_array[0] = depth_bits;
@@ -427,7 +427,7 @@ radeonCreateScreen( __DRIscreenPrivate *sPriv )
       __driUtilMessage("%s: drmMap (2) failed\n", __FUNCTION__ );
       return NULL;
    }
-   screen->scratch = (__volatile__ u_int32_t *)
+   screen->scratch = (__volatile__ uint32_t *)
       ((GLubyte *)screen->status.map + RADEON_SCRATCH_REG_OFFSET);
 
    screen->buffers = drmMapBufs( sPriv->fd );
diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.h b/src/mesa/drivers/dri/radeon/radeon_screen.h
index f8c0cc96dfd..c9b0c3af125 100644
--- a/src/mesa/drivers/dri/radeon/radeon_screen.h
+++ b/src/mesa/drivers/dri/radeon/radeon_screen.h
@@ -83,7 +83,7 @@ typedef struct {
 
    drmBufMapPtr buffers;
 
-   __volatile__ u_int32_t *scratch;
+   __volatile__ uint32_t *scratch;
 
    __DRIscreenPrivate *driScreen;
    unsigned int sarea_priv_offset;
diff --git a/src/mesa/drivers/dri/radeon/radeon_state.c b/src/mesa/drivers/dri/radeon/radeon_state.c
index 856d27df75c..1fe5c244cdb 100644
--- a/src/mesa/drivers/dri/radeon/radeon_state.c
+++ b/src/mesa/drivers/dri/radeon/radeon_state.c
@@ -687,7 +687,7 @@ static void radeonPolygonMode( GLcontext *ctx, GLenum face, GLenum mode )
 static void radeonUpdateSpecular( GLcontext *ctx )
 {
    radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
-   u_int32_t p = rmesa->hw.ctx.cmd[CTX_PP_CNTL];
+   uint32_t p = rmesa->hw.ctx.cmd[CTX_PP_CNTL];
    GLuint flag = 0;
 
    RADEON_STATECHANGE( rmesa, tcl );
diff --git a/src/mesa/drivers/dri/radeon/server/radeon_egl.c b/src/mesa/drivers/dri/radeon/server/radeon_egl.c
index 2f6ea559032..c16d66e4ece 100644
--- a/src/mesa/drivers/dri/radeon/server/radeon_egl.c
+++ b/src/mesa/drivers/dri/radeon/server/radeon_egl.c
@@ -935,8 +935,8 @@ radeonFillInConfigs(_EGLDisplay *disp, unsigned pixel_bits,
             GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
          };
 
-   u_int8_t depth_bits_array[2];
-   u_int8_t stencil_bits_array[2];
+   uint8_t depth_bits_array[2];
+   uint8_t stencil_bits_array[2];
 
    depth_bits_array[0] = depth_bits;
    depth_bits_array[1] = depth_bits;
diff --git a/src/mesa/drivers/dri/savage/savage_3d_reg.h b/src/mesa/drivers/dri/savage/savage_3d_reg.h
index bc81d732967..45733cdf929 100644
--- a/src/mesa/drivers/dri/savage/savage_3d_reg.h
+++ b/src/mesa/drivers/dri/savage/savage_3d_reg.h
@@ -43,7 +43,7 @@ typedef union
         unsigned reserved : 4;
         unsigned ofs      : 28;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegZPixelOffset;
 
 /* This reg exists only on Savage4. */
@@ -60,7 +60,7 @@ typedef union
         unsigned passZpassOp :  3;
         unsigned reserved    :  3;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegStencilCtrl;
 
 /**************************
@@ -85,7 +85,7 @@ typedef union
         unsigned palSize    : 2;
         unsigned newPal     : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexDescr_s4;
 typedef union
 {
@@ -102,7 +102,7 @@ typedef union
         unsigned reserved3 : 10;
         unsigned newPal    : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexDescr_s3d;
 
 /* The layout of this reg is the same on Savage4 and Savage3D,
@@ -116,7 +116,7 @@ typedef union
         unsigned reserved : 1;
         unsigned addr     : 29;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexAddr;
 
 /* The layout of this reg is the same on Savage4 and Savage3D. */
@@ -127,7 +127,7 @@ typedef union
         unsigned reserved : 3;
         unsigned addr     : 29;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexPalAddr;
 
 /* The layout of this reg on Savage4 and Savage3D are very similar. */
@@ -138,7 +138,7 @@ typedef union
         unsigned xprClr0 : 16;
         unsigned xprClr1 : 16; /* this is reserved on Savage3D */
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexXprClr;   /* transparency color in RGB565 format*/
 
 /* The layout of this reg differs between Savage4 and Savage3D.
@@ -164,7 +164,7 @@ typedef union
         unsigned alphaArg1Invert    : 1;
         unsigned alphaArg2Invert    : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexCtrl_s4;
 typedef union
 {
@@ -187,7 +187,7 @@ typedef union
         unsigned texXprEn      : 1;
         unsigned reserved2     : 11;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexCtrl_s3d;
 
 /* This reg exists only on Savage4. */
@@ -218,7 +218,7 @@ typedef union
         unsigned colorDoDiffMul  : 1;
         unsigned LeftShiftVal    : 2;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexBlendCtrl;
 
 /* This reg exists only on Savage4. */
@@ -231,7 +231,7 @@ typedef union
         unsigned red   : 8;
         unsigned alpha : 8;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTexBlendColor;
 
 /********************************
@@ -247,7 +247,7 @@ typedef union
         unsigned widthInTile  : 6;
         unsigned bitPerPixel  : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegTiledSurface;
 
 /********************************
@@ -264,7 +264,7 @@ typedef union
         unsigned scissorYStart : 12;
         unsigned alphaRefVal   : 8;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDrawCtrl0;
 
 /* This reg exists only on Savage4. */
@@ -281,7 +281,7 @@ typedef union
         unsigned alphaTestCmpFunc :  3;
         unsigned alphaTestEn      :  1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDrawCtrl1;
 
 /* This reg exists only on Savage4. */
@@ -312,7 +312,7 @@ typedef union
         unsigned flushPdDestWrites   :  1;
         unsigned flushPdZbufWrites   :  1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDrawLocalCtrl;
 
 /* This reg exists only on Savage3D. */
@@ -342,7 +342,7 @@ typedef union
 	 */
         unsigned interpMode        : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDrawCtrl;
 
 #define SAVAGETBC_DECAL_S3D                     0
@@ -364,7 +364,7 @@ typedef union
         unsigned scissorYStart : 11;
 	unsigned reserved2     : 5;
     } ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegScissorsStart;
 
 /* This reg exists only on Savage3D. */
@@ -377,7 +377,7 @@ typedef union
         unsigned scissorYEnd : 11;
 	unsigned reserved2   : 5;
     } ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegScissorsEnd;
 
 /********************************
@@ -396,7 +396,7 @@ typedef union
         unsigned reserved : 1;
         unsigned addr     : 29; /*quad word aligned*/
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegVertBufAddr;
 
 /* I havn't found a Savage3D equivalent of this reg in the Utah-driver. 
@@ -411,7 +411,7 @@ typedef union
         unsigned reserved : 1;
         unsigned addr     : 29; /*4-quad word aligned*/
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDMABufAddr;
 
 /********************************
@@ -439,7 +439,7 @@ typedef union
         unsigned reserved   : 17;
         unsigned kickOff    : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegFlag;
 
 /********************************
@@ -464,7 +464,7 @@ typedef union
         unsigned floatZEn      : 1;
         unsigned wToZEn        : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegZBufCtrl_s4;
 typedef union
 {
@@ -486,7 +486,7 @@ typedef union
         unsigned wrZafterAlphaTst : 1;
         unsigned reserved2        : 15;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegZBufCtrl_s3d;
 
 /* The layout of this reg on Savage4 and Savage3D is very similar. */
@@ -507,7 +507,7 @@ typedef union
 	 */
         unsigned zDepthSelect     : 1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegZBufOffset;
 
 /* The layout of this reg is the same on Savage4 and Savage3D. */
@@ -524,7 +524,7 @@ typedef union
         unsigned wHigh     : 6;
         unsigned reserved4 : 2;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegZWatermarks;
 
 /********************************
@@ -542,7 +542,7 @@ typedef union
         unsigned fogMode     : 1;
         unsigned fogEndShift : 2;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegFogCtrl;
 
 /*not in spec, but tempo for pp and driver*/
@@ -553,7 +553,7 @@ typedef union
         unsigned fogDensity : 16;
         unsigned fogStart   : 16;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegFogParam;
 
 /**************************************
@@ -577,7 +577,7 @@ typedef union
         unsigned antiAliasMode  :  2;
         unsigned dstPixFmt      :  1;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDestCtrl;
 
 /* The layout of this reg on Savage4 and Savage3D are very similar. */
@@ -596,7 +596,7 @@ typedef union
 	 * However, it is not used in either driver. */
         unsigned destFlush     : 2;
     }ni;
-    u_int32_t ui;
+    uint32_t ui;
 } savageRegDestTexWatermarks;
 
 /* Savage4/Twister/ProSavage register BCI addresses */
@@ -641,7 +641,7 @@ typedef union
 #define SAVAGE_FIRST_REG 0x18
 #define SAVAGE_NR_REGS   34
 typedef struct savage_registers_s4_t {
-    u_int32_t                   unused1[6];        /* 0x18-0x1d */
+    uint32_t                   unused1[6];        /* 0x18-0x1d */
     savageRegDrawLocalCtrl     drawLocalCtrl;     /* 0x1e */
     savageRegTexPalAddr        texPalAddr;        /* 0x1f */
     savageRegTexCtrl_s4        texCtrl[2];        /* 0x20, 0x21 */
@@ -649,7 +649,7 @@ typedef struct savage_registers_s4_t {
     savageRegTexBlendCtrl      texBlendCtrl[2];   /* 0x24, 0x25 */
     savageRegTexXprClr         texXprClr;         /* 0x26 */
     savageRegTexDescr_s4       texDescr;          /* 0x27 */
-    u_int8_t                   fogTable[32];      /* 0x28-0x2f (8dwords) */
+    uint8_t                   fogTable[32];      /* 0x28-0x2f (8dwords) */
     savageRegFogCtrl           fogCtrl;           /* 0x30 */
     savageRegStencilCtrl       stencilCtrl;       /* 0x31 */
     savageRegZBufCtrl_s4       zBufCtrl;          /* 0x32 */
@@ -667,8 +667,8 @@ typedef struct savage_registers_s3d_t {
     savageRegTexAddr           texAddr;           /* 0x1a */
     savageRegTexDescr_s3d      texDescr;          /* 0x1b */
     savageRegTexCtrl_s3d       texCtrl;           /* 0x1c */
-    u_int32_t                  unused1[3];        /* 0x1d-0x1f */
-    u_int8_t                   fogTable[64];      /* 0x20-0x2f (16dwords) */
+    uint32_t                  unused1[3];        /* 0x1d-0x1f */
+    uint8_t                   fogTable[64];      /* 0x20-0x2f (16dwords) */
     savageRegFogCtrl           fogCtrl;           /* 0x30 */
     savageRegDrawCtrl          drawCtrl;          /* 0x31 */
     savageRegZBufCtrl_s3d      zBufCtrl;          /* 0x32 */
@@ -678,12 +678,12 @@ typedef struct savage_registers_s3d_t {
     savageRegScissorsEnd       scissorsEnd;       /* 0x36 */
     savageRegZWatermarks       zWatermarks;       /* 0x37 */
     savageRegDestTexWatermarks destTexWatermarks; /* 0x38 */
-    u_int32_t                   unused2;           /* 0x39 */
+    uint32_t                   unused2;           /* 0x39 */
 } savageRegistersS3D;
 typedef union savage_registers_t {
     savageRegistersS4  s4;
     savageRegistersS3D s3d;
-    u_int32_t           ui[SAVAGE_NR_REGS];
+    uint32_t           ui[SAVAGE_NR_REGS];
 } savageRegisters;
 
 
diff --git a/src/mesa/drivers/dri/savage/savage_xmesa.c b/src/mesa/drivers/dri/savage/savage_xmesa.c
index 43422db9a82..00171253290 100644
--- a/src/mesa/drivers/dri/savage/savage_xmesa.c
+++ b/src/mesa/drivers/dri/savage/savage_xmesa.c
@@ -487,7 +487,7 @@ savageCreateContext( const __GLcontextModes *mesaVis,
    imesa->clientVtxBuf.total = imesa->bufferSize / 4;
    imesa->clientVtxBuf.used = 0;
    imesa->clientVtxBuf.flushed = 0;
-   imesa->clientVtxBuf.buf = (u_int32_t *)malloc(imesa->bufferSize);
+   imesa->clientVtxBuf.buf = (uint32_t *)malloc(imesa->bufferSize);
 
    imesa->vtxBuf = &imesa->clientVtxBuf;
 
@@ -956,8 +956,8 @@ savageFillInModes( unsigned pixel_bits, unsigned depth_bits,
 	GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
     };
 
-    u_int8_t depth_bits_array[2];
-    u_int8_t stencil_bits_array[2];
+    uint8_t depth_bits_array[2];
+    uint8_t stencil_bits_array[2];
 
 
     depth_bits_array[0] = depth_bits;
diff --git a/src/mesa/drivers/dri/savage/savagecontext.h b/src/mesa/drivers/dri/savage/savagecontext.h
index c4573b0da41..3fe3d71d4ec 100644
--- a/src/mesa/drivers/dri/savage/savagecontext.h
+++ b/src/mesa/drivers/dri/savage/savagecontext.h
@@ -130,7 +130,7 @@ typedef void (*savage_point_func)( savageContextPtr, savageVertex * );
 struct savage_vtxbuf_t {
     GLuint total, used, flushed; /* in 32 bit units */
     GLuint idx;		/* for DMA buffers */
-    u_int32_t *buf;
+    uint32_t *buf;
 };
 
 struct savage_cmdbuf_t {
diff --git a/src/mesa/drivers/dri/savage/savageioctl.c b/src/mesa/drivers/dri/savage/savageioctl.c
index 4eac1fb3498..bea9a3ea535 100644
--- a/src/mesa/drivers/dri/savage/savageioctl.c
+++ b/src/mesa/drivers/dri/savage/savageioctl.c
@@ -112,7 +112,7 @@ void savageGetDMABuffer( savageContextPtr imesa )
    imesa->dmaVtxBuf.used = 0;
    imesa->dmaVtxBuf.flushed = 0;
    imesa->dmaVtxBuf.idx = buf->idx;
-   imesa->dmaVtxBuf.buf = (u_int32_t *)buf->address;
+   imesa->dmaVtxBuf.buf = (uint32_t *)buf->address;
 
    if (SAVAGE_DEBUG & DEBUG_DMA)
       fprintf(stderr, "finished getbuffer\n");
@@ -137,7 +137,7 @@ static void savage_BCI_clear(GLcontext *ctx, drm_savage_clear_t *pclear)
 		unsigned int y = pbox->y1;
 		unsigned int width = pbox->x2 - x;
 		unsigned int height = pbox->y2 - y;
- 		u_int32_t *bciptr;
+ 		uint32_t *bciptr;
 
 		if (pbox->x1 > pbox->x2 ||
 		    pbox->y1 > pbox->y2 ||
@@ -147,27 +147,27 @@ static void savage_BCI_clear(GLcontext *ctx, drm_savage_clear_t *pclear)
 
 	   	if ( pclear->flags & SAVAGE_FRONT ) {
 		        bciptr = savageDMAAlloc (imesa, 8);
-			WRITE_CMD((bciptr) , 0x4BCC8C00,u_int32_t);
-			WRITE_CMD((bciptr) , imesa->savageScreen->frontOffset,u_int32_t);
-			WRITE_CMD((bciptr) , imesa->savageScreen->frontBitmapDesc,u_int32_t);
-			WRITE_CMD((bciptr) , pclear->clear_color,u_int32_t);
-			WRITE_CMD((bciptr) , (y <<16) | x,u_int32_t);
-			WRITE_CMD((bciptr) , (height << 16) | width,u_int32_t);
+			WRITE_CMD((bciptr) , 0x4BCC8C00,uint32_t);
+			WRITE_CMD((bciptr) , imesa->savageScreen->frontOffset,uint32_t);
+			WRITE_CMD((bciptr) , imesa->savageScreen->frontBitmapDesc,uint32_t);
+			WRITE_CMD((bciptr) , pclear->clear_color,uint32_t);
+			WRITE_CMD((bciptr) , (y <<16) | x,uint32_t);
+			WRITE_CMD((bciptr) , (height << 16) | width,uint32_t);
 			savageDMACommit (imesa, bciptr);
 		}
 		if ( pclear->flags & SAVAGE_BACK ) {
 		        bciptr = savageDMAAlloc (imesa, 8);
-			WRITE_CMD((bciptr) , 0x4BCC8C00,u_int32_t);
-			WRITE_CMD((bciptr) , imesa->savageScreen->backOffset,u_int32_t);
-			WRITE_CMD((bciptr) , imesa->savageScreen->backBitmapDesc,u_int32_t);
-			WRITE_CMD((bciptr) , pclear->clear_color,u_int32_t);
-			WRITE_CMD((bciptr) , (y <<16) | x,u_int32_t);
-			WRITE_CMD((bciptr) , (height << 16) | width,u_int32_t);
+			WRITE_CMD((bciptr) , 0x4BCC8C00,uint32_t);
+			WRITE_CMD((bciptr) , imesa->savageScreen->backOffset,uint32_t);
+			WRITE_CMD((bciptr) , imesa->savageScreen->backBitmapDesc,uint32_t);
+			WRITE_CMD((bciptr) , pclear->clear_color,uint32_t);
+			WRITE_CMD((bciptr) , (y <<16) | x,uint32_t);
+			WRITE_CMD((bciptr) , (height << 16) | width,uint32_t);
 			savageDMACommit (imesa, bciptr);
 		}
 		
 		if ( pclear->flags & (SAVAGE_DEPTH |SAVAGE_STENCIL) ) {
-		        u_int32_t writeMask = 0x0;
+		        uint32_t writeMask = 0x0;
 		        if(imesa->hw_stencil)
 		        {        
 		            if(pclear->flags & SAVAGE_STENCIL)
@@ -199,8 +199,8 @@ static void savage_BCI_clear(GLcontext *ctx, drm_savage_clear_t *pclear)
 				bciptr = savageDMAAlloc (imesa, 10);
 			        if(writeMask != 0xFFFFFFFF)
 			        {
-                                    WRITE_CMD((bciptr) , 0x960100D7,u_int32_t);
-                                    WRITE_CMD((bciptr) , writeMask,u_int32_t);
+                                    WRITE_CMD((bciptr) , 0x960100D7,uint32_t);
+                                    WRITE_CMD((bciptr) , writeMask,uint32_t);
                                 }
                             }
 			    else
@@ -208,18 +208,18 @@ static void savage_BCI_clear(GLcontext *ctx, drm_savage_clear_t *pclear)
 				bciptr = savageDMAAlloc (imesa, 6);
 			    }
 
-			    WRITE_CMD((bciptr) , 0x4BCC8C00,u_int32_t);
-			    WRITE_CMD((bciptr) , imesa->savageScreen->depthOffset,u_int32_t);
-			    WRITE_CMD((bciptr) , imesa->savageScreen->depthBitmapDesc,u_int32_t);
-			    WRITE_CMD((bciptr) , pclear->clear_depth,u_int32_t);
-			    WRITE_CMD((bciptr) , (y <<16) | x,u_int32_t);
-			    WRITE_CMD((bciptr) , (height << 16) | width,u_int32_t);
+			    WRITE_CMD((bciptr) , 0x4BCC8C00,uint32_t);
+			    WRITE_CMD((bciptr) , imesa->savageScreen->depthOffset,uint32_t);
+			    WRITE_CMD((bciptr) , imesa->savageScreen->depthBitmapDesc,uint32_t);
+			    WRITE_CMD((bciptr) , pclear->clear_depth,uint32_t);
+			    WRITE_CMD((bciptr) , (y <<16) | x,uint32_t);
+			    WRITE_CMD((bciptr) , (height << 16) | width,uint32_t);
 			    if(imesa->hw_stencil)
 			    {
 			        if(writeMask != 0xFFFFFFFF)
 			        {
-			           WRITE_CMD((bciptr) , 0x960100D7,u_int32_t);
-                                   WRITE_CMD((bciptr) , 0xFFFFFFFF,u_int32_t);  
+			           WRITE_CMD((bciptr) , 0x960100D7,uint32_t);
+                                   WRITE_CMD((bciptr) , 0xFFFFFFFF,uint32_t);  
 			        }
 			    }
 			    savageDMACommit (imesa, bciptr);
@@ -236,7 +236,7 @@ static void savage_BCI_swap(savageContextPtr imesa)
     int nbox = imesa->sarea->nbox;
     drm_clip_rect_t *pbox = imesa->sarea->boxes;
     int i;
-    volatile u_int32_t *bciptr;
+    volatile uint32_t *bciptr;
     
     if (nbox > SAVAGE_NR_SAREA_CLIPRECTS)
         nbox = SAVAGE_NR_SAREA_CLIPRECTS;
diff --git a/src/mesa/drivers/dri/savage/savageioctl.h b/src/mesa/drivers/dri/savage/savageioctl.h
index c7ff0017fde..98629048aef 100644
--- a/src/mesa/drivers/dri/savage/savageioctl.h
+++ b/src/mesa/drivers/dri/savage/savageioctl.h
@@ -77,10 +77,10 @@ GLboolean savageHaveIndexedVerts( savageContextPtr imesa )
 }
 
 static __inline
-u_int32_t *savageAllocVtxBuf( savageContextPtr imesa, GLuint words )
+uint32_t *savageAllocVtxBuf( savageContextPtr imesa, GLuint words )
 {
    struct savage_vtxbuf_t *buffer = imesa->vtxBuf;
-   u_int32_t *head;
+   uint32_t *head;
 
    if (buffer == &imesa->dmaVtxBuf) {
        if (!buffer->total) {
@@ -116,9 +116,9 @@ u_int32_t *savageAllocVtxBuf( savageContextPtr imesa, GLuint words )
 }
 
 static __inline
-u_int32_t *savageAllocIndexedVerts( savageContextPtr imesa, GLuint n )
+uint32_t *savageAllocIndexedVerts( savageContextPtr imesa, GLuint n )
 {
-    u_int32_t *ret;
+    uint32_t *ret;
     savageFlushVertices(imesa);
     ret = savageAllocVtxBuf(imesa, n*imesa->HwVertexSize);
     imesa->firstElt = imesa->vtxBuf->flushed / imesa->HwVertexSize;
@@ -172,9 +172,9 @@ drm_savage_cmd_header_t *savageAllocCmdBuf( savageContextPtr imesa, GLuint bytes
  * - increments the number of elts. Final allocation is done in savageFlushElts
  */
 static __inline
-u_int16_t *savageAllocElts( savageContextPtr imesa, GLuint n )
+uint16_t *savageAllocElts( savageContextPtr imesa, GLuint n )
 {
-    u_int16_t *ret;
+    uint16_t *ret;
     GLuint qwords;
     assert (savageHaveIndexedVerts(imesa));
 
@@ -195,7 +195,7 @@ u_int16_t *savageAllocElts( savageContextPtr imesa, GLuint n )
 	imesa->elts.n = 0;
     }
 
-    ret = (u_int16_t *)(imesa->elts.cmd+1) + imesa->elts.n;
+    ret = (uint16_t *)(imesa->elts.cmd+1) + imesa->elts.n;
     imesa->elts.n += n;
     return ret;
 }
diff --git a/src/mesa/drivers/dri/savage/savagestate.c b/src/mesa/drivers/dri/savage/savagestate.c
index 741a9dda4f7..84fd3157edf 100644
--- a/src/mesa/drivers/dri/savage/savagestate.c
+++ b/src/mesa/drivers/dri/savage/savagestate.c
@@ -122,9 +122,9 @@ static void savageDDBlendEquationSeparate(GLcontext *ctx,
 static void savageBlendFunc_s4(GLcontext *ctx)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
-    u_int32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
-    u_int32_t drawCtrl0 = imesa->regs.s4.drawCtrl0.ui;
-    u_int32_t drawCtrl1 = imesa->regs.s4.drawCtrl1.ui;
+    uint32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
+    uint32_t drawCtrl0 = imesa->regs.s4.drawCtrl0.ui;
+    uint32_t drawCtrl1 = imesa->regs.s4.drawCtrl1.ui;
 
     /* set up draw control register (including blending, alpha
      * test, and shading model)
@@ -297,8 +297,8 @@ static void savageBlendFunc_s4(GLcontext *ctx)
 static void savageBlendFunc_s3d(GLcontext *ctx)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
-    u_int32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
-    u_int32_t zBufCtrl = imesa->regs.s3d.zBufCtrl.ui;
+    uint32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
+    uint32_t zBufCtrl = imesa->regs.s3d.zBufCtrl.ui;
 
     /* set up draw control register (including blending, alpha
      * test, dithering, and shading model)
@@ -486,9 +486,9 @@ static void savageDDDepthFunc_s4(GLcontext *ctx, GLenum func)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
     ZCmpFunc zmode;
-    u_int32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
-    u_int32_t zBufCtrl = imesa->regs.s4.zBufCtrl.ui;
-    u_int32_t zWatermarks = imesa->regs.s4.zWatermarks.ui; /* FIXME: in DRM */
+    uint32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
+    uint32_t zBufCtrl = imesa->regs.s4.zBufCtrl.ui;
+    uint32_t zWatermarks = imesa->regs.s4.zWatermarks.ui; /* FIXME: in DRM */
 
     /* set up z-buffer control register (global)
      * set up z-buffer offset register (global)
@@ -550,9 +550,9 @@ static void savageDDDepthFunc_s3d(GLcontext *ctx, GLenum func)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
     ZCmpFunc zmode;
-    u_int32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
-    u_int32_t zBufCtrl = imesa->regs.s3d.zBufCtrl.ui;
-    u_int32_t zWatermarks = imesa->regs.s3d.zWatermarks.ui; /* FIXME: in DRM */
+    uint32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
+    uint32_t zBufCtrl = imesa->regs.s3d.zBufCtrl.ui;
+    uint32_t zWatermarks = imesa->regs.s3d.zWatermarks.ui; /* FIXME: in DRM */
 
     /* set up z-buffer control register (global)
      * set up z-buffer offset register (global)
@@ -638,7 +638,7 @@ static void savageDDScissor( GLcontext *ctx, GLint x, GLint y,
 static void savageDDDrawBuffer(GLcontext *ctx, GLenum mode )
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
-    u_int32_t destCtrl = imesa->regs.s4.destCtrl.ui;
+    uint32_t destCtrl = imesa->regs.s4.destCtrl.ui;
 
     /*
      * _DrawDestMask is easier to cope with than <mode>.
@@ -865,7 +865,7 @@ static void savageDDColorMask_s3d(GLcontext *ctx,
 
 static void savageUpdateSpecular_s4(GLcontext *ctx) {
     savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
-    u_int32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
+    uint32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
 
     if (NEED_SECONDARY_COLOR(ctx)) {
 	imesa->regs.s4.drawLocalCtrl.ni.specShadeEn = GL_TRUE;
@@ -879,7 +879,7 @@ static void savageUpdateSpecular_s4(GLcontext *ctx) {
 
 static void savageUpdateSpecular_s3d(GLcontext *ctx) {
     savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
-    u_int32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
+    uint32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
 
     if (NEED_SECONDARY_COLOR(ctx)) {
 	imesa->regs.s3d.drawCtrl.ni.specShadeEn = GL_TRUE;
@@ -905,7 +905,7 @@ static void savageDDLightModelfv_s3d(GLcontext *ctx, GLenum pname,
 static void savageDDShadeModel_s4(GLcontext *ctx, GLuint mod)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
-    u_int32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
+    uint32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;
 
     if (mod == GL_SMOOTH)  
     {    
@@ -922,7 +922,7 @@ static void savageDDShadeModel_s4(GLcontext *ctx, GLuint mod)
 static void savageDDShadeModel_s3d(GLcontext *ctx, GLuint mod)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
-    u_int32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
+    uint32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;
 
     if (mod == GL_SMOOTH)  
     {    
@@ -948,7 +948,7 @@ static void savageDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
     GLuint  fogClr;
-    u_int32_t fogCtrl = imesa->regs.s4.fogCtrl.ui;
+    uint32_t fogCtrl = imesa->regs.s4.fogCtrl.ui;
 
     /*if ((ctx->Fog.Enabled) &&(pname == GL_FOG_COLOR))*/
     if (ctx->Fog.Enabled)
@@ -980,8 +980,8 @@ savageDDStencilFuncSeparate(GLcontext *ctx, GLenum face, GLenum func,
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
     unsigned a=0;
-    const u_int32_t zBufCtrl = imesa->regs.s4.zBufCtrl.ui;
-    const u_int32_t stencilCtrl = imesa->regs.s4.stencilCtrl.ui;
+    const uint32_t zBufCtrl = imesa->regs.s4.zBufCtrl.ui;
+    const uint32_t stencilCtrl = imesa->regs.s4.stencilCtrl.ui;
 
     imesa->regs.s4.zBufCtrl.ni.stencilRefVal = ctx->Stencil.Ref[0] & 0xff;
     imesa->regs.s4.stencilCtrl.ni.readMask  = ctx->Stencil.ValueMask[0] & 0xff;
@@ -1041,7 +1041,7 @@ savageDDStencilOpSeparate(GLcontext *ctx, GLenum face, GLenum fail,
                           GLenum zfail, GLenum zpass)
 {
     savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
-    const u_int32_t stencilCtrl = imesa->regs.s4.stencilCtrl.ui;
+    const uint32_t stencilCtrl = imesa->regs.s4.stencilCtrl.ui;
 
     imesa->regs.s4.stencilCtrl.ni.failOp = get_stencil_op_value( ctx->Stencil.FailFunc[0] );
     imesa->regs.s4.stencilCtrl.ni.passZfailOp = get_stencil_op_value( ctx->Stencil.ZFailFunc[0] );
@@ -1613,8 +1613,8 @@ static void savageDDInitState_s3d( savageContextPtr imesa )
     imesa->globalRegMask.s3d.zBufCtrl.ni.zBufEn = 0x1;
 }
 void savageDDInitState( savageContextPtr imesa ) {
-    memset (imesa->regs.ui, 0, SAVAGE_NR_REGS*sizeof(u_int32_t));
-    memset (imesa->globalRegMask.ui, 0xff, SAVAGE_NR_REGS*sizeof(u_int32_t));
+    memset (imesa->regs.ui, 0, SAVAGE_NR_REGS*sizeof(uint32_t));
+    memset (imesa->globalRegMask.ui, 0xff, SAVAGE_NR_REGS*sizeof(uint32_t));
     if (imesa->savageScreen->chipset >= S3_SAVAGE4)
 	savageDDInitState_s4 (imesa);
     else
@@ -1656,7 +1656,7 @@ void savageDDInitState( savageContextPtr imesa ) {
         imesa->regs.s4.zBufOffset.ni.zDepthSelect = 1;      
     }
 
-    memcpy (imesa->oldRegs.ui, imesa->regs.ui, SAVAGE_NR_REGS*sizeof(u_int32_t));
+    memcpy (imesa->oldRegs.ui, imesa->regs.ui, SAVAGE_NR_REGS*sizeof(uint32_t));
 
     /* Emit the initial state to the (empty) command buffer. */
     assert (imesa->cmdBuf.write == imesa->cmdBuf.base);
diff --git a/src/mesa/drivers/dri/savage/savagetex.c b/src/mesa/drivers/dri/savage/savagetex.c
index 719e50f964c..dbe30d4c947 100644
--- a/src/mesa/drivers/dri/savage/savagetex.c
+++ b/src/mesa/drivers/dri/savage/savagetex.c
@@ -1365,7 +1365,7 @@ static void savageUpdateTex0State_s4( GLcontext *ctx )
     if (imesa->regs.s4.texDescr.ni.tex1En)
         imesa->regs.s4.texDescr.ni.texBLoopEn = GL_TRUE;
 
-    imesa->regs.s4.texAddr[0].ui = (u_int32_t) t->setup.physAddr | 0x2;
+    imesa->regs.s4.texAddr[0].ui = (uint32_t) t->setup.physAddr | 0x2;
     if(t->base.heap->heapId == SAVAGE_AGP_HEAP)
 	imesa->regs.s4.texAddr[0].ui |= 0x1;
     
@@ -1550,7 +1550,7 @@ static void savageUpdateTex1State_s4( GLcontext *ctx )
     imesa->regs.s4.texCtrl[1].ni.dMax = t->base.lastLevel - t->base.firstLevel;
     imesa->regs.s4.texDescr.ni.texBLoopEn = GL_TRUE;
 
-    imesa->regs.s4.texAddr[1].ui = (u_int32_t) t->setup.physAddr | 2;
+    imesa->regs.s4.texAddr[1].ui = (uint32_t) t->setup.physAddr | 2;
     if(t->base.heap->heapId == SAVAGE_AGP_HEAP)
 	imesa->regs.s4.texAddr[1].ui |= 0x1;
 }
@@ -1701,7 +1701,7 @@ static void savageUpdateTexState_s3d( GLcontext *ctx )
     assert (t->hwFormat <= 7);
     imesa->regs.s3d.texDescr.ni.texFmt = t->hwFormat;
 
-    imesa->regs.s3d.texAddr.ui = (u_int32_t) t->setup.physAddr | 2;
+    imesa->regs.s3d.texAddr.ui = (uint32_t) t->setup.physAddr | 2;
     if(t->base.heap->heapId == SAVAGE_AGP_HEAP)
 	imesa->regs.s3d.texAddr.ui |= 0x1;
 }
diff --git a/src/mesa/drivers/dri/savage/savagetris.c b/src/mesa/drivers/dri/savage/savagetris.c
index 52c7f5fa765..a1c7bb167e7 100644
--- a/src/mesa/drivers/dri/savage/savagetris.c
+++ b/src/mesa/drivers/dri/savage/savagetris.c
@@ -100,7 +100,7 @@ static void __inline__ savage_draw_triangle (savageContextPtr imesa,
 					     savageVertexPtr v1,
 					     savageVertexPtr v2) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 3*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 3*vertsize);
    GLuint j;
 
    EMIT_VERT (j, vb, vertsize, 0, v0);
@@ -114,7 +114,7 @@ static void __inline__ savage_draw_quad (savageContextPtr imesa,
 					 savageVertexPtr v2,
 					 savageVertexPtr v3) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
    GLuint j;
 
    EMIT_VERT (j, vb, vertsize, 0, v0);
@@ -128,7 +128,7 @@ static void __inline__ savage_draw_quad (savageContextPtr imesa,
 static __inline__ void savage_draw_point (savageContextPtr imesa,
 					  savageVertexPtr tmp) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
    const GLfloat x = tmp->v.x;
    const GLfloat y = tmp->v.y;
    const GLfloat sz = 0.5 * CLAMP(imesa->glCtx->Point.Size,
@@ -165,7 +165,7 @@ static __inline__ void savage_draw_line (savageContextPtr imesa,
 					 savageVertexPtr v0,
 					 savageVertexPtr v1 ) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
    const GLfloat width = CLAMP(imesa->glCtx->Line.Width,
                                imesa->glCtx->Const.MinLineWidth,
                                imesa->glCtx->Const.MaxLineWidth);
@@ -224,7 +224,7 @@ static void __inline__ savage_ptex_tri (savageContextPtr imesa,
 					savageVertexPtr v1,
 					savageVertexPtr v2) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 3*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 3*vertsize);
    savageVertex tmp;
    GLuint j;
 
@@ -237,7 +237,7 @@ static __inline__ void savage_ptex_line (savageContextPtr imesa,
 					 savageVertexPtr v0,
 					 savageVertexPtr v1 ) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
    const GLfloat width = CLAMP(imesa->glCtx->Line.Width,
                                imesa->glCtx->Const.MinLineWidth,
                                imesa->glCtx->Const.MaxLineWidth);
@@ -284,7 +284,7 @@ static __inline__ void savage_ptex_line (savageContextPtr imesa,
 static __inline__ void savage_ptex_point (savageContextPtr imesa,
 					  savageVertexPtr v0) {
    GLuint vertsize = imesa->HwVertexSize;
-   u_int32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
+   uint32_t *vb = savageAllocVtxBuf (imesa, 6*vertsize);
    const GLfloat x = v0->v.x;
    const GLfloat y = v0->v.y;
    const GLfloat sz = 0.5 * CLAMP(imesa->glCtx->Point.Size,
diff --git a/src/mesa/drivers/dri/sis/sis_screen.c b/src/mesa/drivers/dri/sis/sis_screen.c
index d90482f3d71..f55027e0945 100644
--- a/src/mesa/drivers/dri/sis/sis_screen.c
+++ b/src/mesa/drivers/dri/sis/sis_screen.c
@@ -77,8 +77,8 @@ sisFillInModes(int bpp)
    static const GLenum back_buffer_modes[] = {
       GLX_NONE, GLX_SWAP_UNDEFINED_OML
    };
-   u_int8_t depth_bits_array[4];
-   u_int8_t stencil_bits_array[4];
+   uint8_t depth_bits_array[4];
+   uint8_t stencil_bits_array[4];
 
    depth_bits_array[0] = 0;
    stencil_bits_array[0] = 0;
diff --git a/src/mesa/drivers/dri/unichrome/server/via_dri.c b/src/mesa/drivers/dri/unichrome/server/via_dri.c
index 98331459403..74034485e28 100644
--- a/src/mesa/drivers/dri/unichrome/server/via_dri.c
+++ b/src/mesa/drivers/dri/unichrome/server/via_dri.c
@@ -52,9 +52,9 @@ static int VIADRIFinishScreenInit(DRIDriverContext * ctx);
 
 /* _SOLO : missing macros normally defined by X code */
 #define xf86DrvMsg(a, b, ...) fprintf(stderr, __VA_ARGS__)
-#define MMIO_IN8(base, addr) ((*(((volatile u_int8_t*)base)+(addr)))+0)
-#define MMIO_OUT8(base, addr, val) ((*(((volatile u_int8_t*)base)+(addr)))=((u_int8_t)val))
-#define MMIO_OUT16(base, addr, val) ((*(volatile u_int16_t*)(((u_int8_t*)base)+(addr)))=((u_int16_t)val))
+#define MMIO_IN8(base, addr) ((*(((volatile uint8_t*)base)+(addr)))+0)
+#define MMIO_OUT8(base, addr, val) ((*(((volatile uint8_t*)base)+(addr)))=((uint8_t)val))
+#define MMIO_OUT16(base, addr, val) ((*(volatile uint16_t*)(((uint8_t*)base)+(addr)))=((uint16_t)val))
 
 #define VIDEO	0 
 #define AGP		1
@@ -523,9 +523,9 @@ static int VIADRIKernelInit(DRIDriverContext * ctx, VIAPtr pVia)
     drmInfo.fb_offset           = pVia->FrameBufferBase;
     drmInfo.mmio_offset         = pVia->registerHandle;
     if (pVia->IsPCI)
-	drmInfo.agpAddr = (u_int32_t)NULL;
+	drmInfo.agpAddr = (uint32_t)NULL;
     else
-	drmInfo.agpAddr = (u_int32_t)pVia->agpAddr;
+	drmInfo.agpAddr = (uint32_t)pVia->agpAddr;
 
     if ((drmCommandWrite(pVia->drmFD, DRM_VIA_MAP_INIT,&drmInfo,
 			     sizeof(drm_via_init_t))) < 0)
@@ -631,7 +631,7 @@ static void VIADisableMMIO(DRIDriverContext * ctx)
 static void VIADisableExtendedFIFO(DRIDriverContext *ctx)
 {
     VIAPtr  pVia = VIAPTR(ctx);
-    u_int32_t  dwGE230, dwGE298;
+    uint32_t  dwGE230, dwGE298;
 
     /* Cause of exit XWindow will dump back register value, others chipset no
      * need to set extended fifo value */
@@ -653,8 +653,8 @@ static void VIADisableExtendedFIFO(DRIDriverContext *ctx)
 static void VIAEnableExtendedFIFO(DRIDriverContext *ctx)
 {
     VIAPtr  pVia = VIAPTR(ctx);
-    u_int8_t   bRegTemp;
-    u_int32_t  dwGE230, dwGE298;
+    uint8_t   bRegTemp;
+    uint32_t  dwGE230, dwGE298;
 
     switch (pVia->Chipset) {
     case VIA_CLE266:
@@ -849,7 +849,7 @@ static void VIAEnableExtendedFIFO(DRIDriverContext *ctx)
              SR1C[7:0], SR1D[1:0] (10bits) *=*/
         wRegTemp = (pBIOSInfo->offsetWidthByQWord >> 1) + 4;
         VGAOUT8(0x3c4, 0x1c);
-        VGAOUT8(0x3c5, (u_int8_t)(wRegTemp & 0xFF));
+        VGAOUT8(0x3c5, (uint8_t)(wRegTemp & 0xFF));
         VGAOUT8(0x3c4, 0x1d);
         bRegTemp = VGAIN8(0x3c5) & ~0x03;
         VGAOUT8(0x3c5, bRegTemp | ((wRegTemp & 0x300) >> 8));
@@ -895,7 +895,7 @@ static void VIAEnableExtendedFIFO(DRIDriverContext *ctx)
              SR1C[7:0], SR1D[1:0] (10bits) *=*/
         wRegTemp = (pBIOSInfo->offsetWidthByQWord >> 1) + 4;
         VGAOUT8(0x3c4, 0x1c);
-        VGAOUT8(0x3c5, (u_int8_t)(wRegTemp & 0xFF));
+        VGAOUT8(0x3c5, (uint8_t)(wRegTemp & 0xFF));
         VGAOUT8(0x3c4, 0x1d);
         bRegTemp = VGAIN8(0x3c5) & ~0x03;
         VGAOUT8(0x3c5, bRegTemp | ((wRegTemp & 0x300) >> 8));
@@ -923,9 +923,9 @@ static void VIAEnableExtendedFIFO(DRIDriverContext *ctx)
 static void VIAInitialize2DEngine(DRIDriverContext *ctx)
 {
     VIAPtr  pVia = VIAPTR(ctx);
-    u_int32_t  dwVQStartAddr, dwVQEndAddr;
-    u_int32_t  dwVQLen, dwVQStartL, dwVQEndL, dwVQStartEndH;
-    u_int32_t  dwGEMode;
+    uint32_t  dwVQStartAddr, dwVQEndAddr;
+    uint32_t  dwVQLen, dwVQStartL, dwVQEndL, dwVQStartEndH;
+    uint32_t  dwGEMode;
 
     /* init 2D engine regs to reset 2D engine */
     VIASETREG(0x04, 0x0);
@@ -1068,14 +1068,14 @@ static void VIAInitialize3DEngine(DRIDriverContext *ctx)
 
         for (i = 0; i <= 0x7D; i++)
         {
-            VIASETREG(0x440, (u_int32_t) i << 24);
+            VIASETREG(0x440, (uint32_t) i << 24);
         }
 
         VIASETREG(0x43C, 0x00020000);
 
         for (i = 0; i <= 0x94; i++)
         {
-            VIASETREG(0x440, (u_int32_t) i << 24);
+            VIASETREG(0x440, (uint32_t) i << 24);
         }
 
         VIASETREG(0x440, 0x82400000);
@@ -1085,7 +1085,7 @@ static void VIAInitialize3DEngine(DRIDriverContext *ctx)
 
         for (i = 0; i <= 0x94; i++)
         {
-            VIASETREG(0x440, (u_int32_t) i << 24);
+            VIASETREG(0x440, (uint32_t) i << 24);
         }
 
         VIASETREG(0x440, 0x82400000);
@@ -1093,7 +1093,7 @@ static void VIAInitialize3DEngine(DRIDriverContext *ctx)
 
         for (i = 0; i <= 0x03; i++)
         {
-            VIASETREG(0x440, (u_int32_t) i << 24);
+            VIASETREG(0x440, (uint32_t) i << 24);
         }
 
         VIASETREG(0x43C, 0x00030000);
diff --git a/src/mesa/drivers/dri/unichrome/server/via_driver.h b/src/mesa/drivers/dri/unichrome/server/via_driver.h
index a643fd9fbb0..cd3b038bfd9 100644
--- a/src/mesa/drivers/dri/unichrome/server/via_driver.h
+++ b/src/mesa/drivers/dri/unichrome/server/via_driver.h
@@ -211,12 +211,12 @@ typedef struct _VIA {
     XAAInfoRecPtr       AccelInfoRec;
     xRectangle          Rect;
 #endif
-    u_int32_t            SavedCmd;
-    u_int32_t            SavedFgColor;
-    u_int32_t            SavedBgColor;
-    u_int32_t            SavedPattern0;
-    u_int32_t            SavedPattern1;
-    u_int32_t            SavedPatternAddr;
+    uint32_t            SavedCmd;
+    uint32_t            SavedFgColor;
+    uint32_t            SavedBgColor;
+    uint32_t            SavedPattern0;
+    uint32_t            SavedPattern1;
+    uint32_t            SavedPatternAddr;
 
 #if 0
     /* Support for Int10 processing */
@@ -254,8 +254,8 @@ typedef struct _VIA {
 #endif
 
 /*
-    u_int32_t            Cap0_Deinterlace;
-    u_int32_t            Cap1_Deinterlace;
+    uint32_t            Cap0_Deinterlace;
+    uint32_t            Cap1_Deinterlace;
 
     int                 Cap0_FieldSwap;
     int                 NoCap0_HFilter;
@@ -271,7 +271,7 @@ typedef struct _VIA {
     VIAConfigPrivPtr 	pVisualConfigsPriv;
     unsigned long 	agpHandle;
     unsigned long 	registerHandle;
-    u_int32_t            agpAddr;
+    uint32_t            agpAddr;
     unsigned char 	*agpBase;
     unsigned int 	agpSize;
     int  		IsPCI;
@@ -287,11 +287,11 @@ typedef struct _VIA {
 #endif
 
     int     V4LEnabled;
-    u_int16_t    ActiveDevice;	/* if SAMM, non-equal pBIOSInfo->ActiveDevice */
+    uint16_t    ActiveDevice;	/* if SAMM, non-equal pBIOSInfo->ActiveDevice */
     unsigned char       *CursorImage;
-    u_int32_t    CursorFG;
-    u_int32_t    CursorBG;
-    u_int32_t    CursorMC;
+    uint32_t    CursorFG;
+    uint32_t    CursorBG;
+    uint32_t    CursorMC;
 
     unsigned char	MemClk;
     int 		EnableExtendedFIFO;
diff --git a/src/mesa/drivers/dri/unichrome/via_screen.c b/src/mesa/drivers/dri/unichrome/via_screen.c
index 90f76be44d4..b81549df0e9 100644
--- a/src/mesa/drivers/dri/unichrome/via_screen.c
+++ b/src/mesa/drivers/dri/unichrome/via_screen.c
@@ -365,8 +365,8 @@ viaFillInModes( unsigned pixel_bits, GLboolean have_back_buffer )
     /* The 32-bit depth-buffer mode isn't supported yet, so don't actually
      * enable it.
      */
-    static const u_int8_t depth_bits_array[4]   = { 0, 16, 24, 32 };
-    static const u_int8_t stencil_bits_array[4] = { 0,  0,  8,  0 };
+    static const uint8_t depth_bits_array[4]   = { 0, 16, 24, 32 };
+    static const uint8_t stencil_bits_array[4] = { 0,  0,  8,  0 };
     const unsigned depth_buffer_factor = 3;
 
 
diff --git a/src/mesa/drivers/dri/unichrome/via_state.c b/src/mesa/drivers/dri/unichrome/via_state.c
index bccdbe93264..5b0453423ef 100644
--- a/src/mesa/drivers/dri/unichrome/via_state.c
+++ b/src/mesa/drivers/dri/unichrome/via_state.c
@@ -773,10 +773,10 @@ void viaInitState(GLcontext *ctx)
 /**
  * Convert S and T texture coordinate wrap modes to hardware bits.
  */
-static u_int32_t
+static uint32_t
 get_wrap_mode( GLenum sWrap, GLenum tWrap )
 {
-    u_int32_t v = 0;
+    uint32_t v = 0;
 
 
     switch( sWrap ) {
@@ -808,10 +808,10 @@ get_wrap_mode( GLenum sWrap, GLenum tWrap )
     return v;
 }
 
-static u_int32_t
+static uint32_t
 get_minmag_filter( GLenum min, GLenum mag )
 {
-    u_int32_t v = 0;
+    uint32_t v = 0;
 
     switch (min) {
     case GL_NEAREST:
diff --git a/src/mesa/glapi/glapi.c b/src/mesa/glapi/glapi.c
index ed59ddb0b73..c236656d9a6 100644
--- a/src/mesa/glapi/glapi.c
+++ b/src/mesa/glapi/glapi.c
@@ -82,6 +82,7 @@ _glapi_set_warning_func( _glapi_warning_func func )
 static GLboolean
 warn(void)
 {
+#if !defined(_WIN32_WCE)
    if ((WarnFlag || getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG"))
        && warning_func) {
       return GL_TRUE;
@@ -89,6 +90,9 @@ warn(void)
    else {
       return GL_FALSE;
    }
+#else
+   return GL_FALSE;
+#endif
 }
 
 
diff --git a/src/mesa/glapi/glthread.h b/src/mesa/glapi/glthread.h
index b8e9d5f59b8..ad2a63584b7 100644
--- a/src/mesa/glapi/glthread.h
+++ b/src/mesa/glapi/glthread.h
@@ -144,19 +144,19 @@ typedef unsigned int _glthread_Cond;
 //  #warning Condition variables not implemented.
 
 #define _glthread_INIT_COND(cond)	    \
-  abort();
+  ASSERT(0);
 
 #define _glthread_DESTROY_COND(name) \
-  abort();
+  ASSERT(0);
 
 #define _glthread_COND_WAIT(cond, mutex) \
-  abort();
+  ASSERT(0);
 
 #define _glthread_COND_SIGNAL(cond) \
-  abort();
+  ASSERT(0);
 
 #define _glthread_COND_BROADCAST(cond) \
-  abort();
+  ASSERT(0);
 
 #endif
 
diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c
index 6aeb18fa272..8ce6b51d17c 100644
--- a/src/mesa/main/enums.c
+++ b/src/mesa/main/enums.c
@@ -4870,8 +4870,8 @@ const char *_mesa_lookup_enum_by_nr( int nr )
 {
    unsigned * i;
 
-   i = (unsigned *)bsearch( & nr, reduced_enums, Elements(reduced_enums),
-                            sizeof(reduced_enums[0]), (cfunc) compar_nr );
+   i = (unsigned *)_mesa_bsearch( & nr, reduced_enums, Elements(reduced_enums),
+                                  sizeof(reduced_enums[0]), (cfunc) compar_nr );
 
    if ( i != NULL ) {
       return & enum_string_table[ all_enums[ *i ].offset ];
@@ -4888,8 +4888,8 @@ int _mesa_lookup_enum_by_name( const char *symbol )
    enum_elt * f = NULL;
 
    if ( symbol != NULL ) {
-      f = (enum_elt *)bsearch( symbol, all_enums, Elements(all_enums),
-			       sizeof( enum_elt ), (cfunc) compar_name );
+      f = (enum_elt *)_mesa_bsearch( symbol, all_enums, Elements(all_enums),
+                                     sizeof( enum_elt ), (cfunc) compar_name );
    }
 
    return (f != NULL) ? f->n : -1;
diff --git a/src/mesa/main/glheader.h b/src/mesa/main/glheader.h
index 0f74bc83ccc..57d7e60ad3d 100644
--- a/src/mesa/main/glheader.h
+++ b/src/mesa/main/glheader.h
@@ -69,16 +69,33 @@
 #include <stdarg.h>
 
 
-/* Get typedefs for uintptr_t and friends */
-#if defined(__MINGW32__) || defined(__NetBSD__)
-#  include <stdint.h>
-#elif defined(_WIN32)
-#  include <BaseTsd.h>
-#  if _MSC_VER == 1200
-     typedef UINT_PTR uintptr_t;
-#  endif 
+/* Get standard integer types */
+#if defined(_MSC_VER)
+
+   typedef __int8             int8_t;
+   typedef unsigned __int8    uint8_t;
+   typedef __int16            int16_t;
+   typedef unsigned __int16   uint16_t;
+#  ifndef __eglplatform_h_
+     typedef __int32            int32_t;
+#  endif
+   typedef unsigned __int32   uint32_t;
+   typedef __int64            int64_t;
+   typedef unsigned __int64   uint64_t;
+
+#  if defined(_WIN64)
+     typedef __int64            intptr_t;
+     typedef unsigned __int64   uintptr_t;
+#  else
+     typedef __int32            intptr_t;
+     typedef unsigned __int32   uintptr_t;
+#  endif
+
+#  define INT64_C(__val) __val##i64
+#  define UINT64_C(__val) __val##ui64
+
 #else
-#  include <inttypes.h>
+#  include <stdint.h>
 #endif
 
 #if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__) && !defined(BUILD_FOR_SNAP)
@@ -233,6 +250,7 @@
 #endif
 
 
+#if !defined(_WIN32_WCE)
 #if defined(BUILD_FOR_SNAP) && defined(CHECKED)
 #  define ASSERT(X)   _CHECK(X) 
 #elif defined(DEBUG)
@@ -240,6 +258,7 @@
 #else
 #  define ASSERT(X)
 #endif
+#endif
 
 
 #if !defined __GNUC__ || __GNUC__ < 3
diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c
index d798f80e253..7231fa699cb 100644
--- a/src/mesa/main/imports.c
+++ b/src/mesa/main/imports.c
@@ -539,10 +539,10 @@ _mesa_pow(double x, double y)
  * Find the first bit set in a word.
  */
 int
-_mesa_ffs(int i)
+_mesa_ffs(int32_t i)
 {
 #if (defined(_WIN32) && !defined(__MINGW32__) ) || defined(__IBMC__) || defined(__IBMCPP__)
-   register int bit = 1;
+   register int32_t bit = 1;
    if ((i & 0xffff) == 0) {
       bit += 16;
       i >>= 16;
@@ -573,11 +573,7 @@ _mesa_ffs(int i)
  *          if no bits set.
  */
 int
-#ifdef __MINGW32__
-_mesa_ffsll(long val)
-#else
-_mesa_ffsll(long long val)
-#endif
+_mesa_ffsll(int64_t val)
 {
 #ifdef ffsll
    return ffsll(val);
@@ -586,11 +582,11 @@ _mesa_ffsll(long long val)
 
    assert(sizeof(val) == 8);
 
-   bit = _mesa_ffs(val);
+   bit = _mesa_ffs((int32_t)val);
    if (bit != 0)
       return bit;
 
-   bit = _mesa_ffs(val >> 32);
+   bit = _mesa_ffs((int32_t)(val >> 32));
    if (bit != 0)
       return 32 + bit;
 
@@ -765,7 +761,24 @@ void *
 _mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 
                int (*compar)(const void *, const void *) )
 {
+#if defined(_WIN32_WCE)
+   void *mid;
+   int cmp;
+   while (nmemb) {
+      nmemb >>= 1;
+      mid = (char *)base + nmemb * size;
+      cmp = (*compar)(key, mid);
+      if (cmp == 0)
+	 return mid;
+      if (cmp > 0) {
+	 base = (char *)mid + size;
+	 --nmemb;
+      }
+   }
+   return NULL;
+#else
    return bsearch(key, base, nmemb, size, compar);
+#endif
 }
 
 /*@}*/
@@ -781,7 +794,7 @@ _mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size,
 char *
 _mesa_getenv( const char *var )
 {
-#if defined(_XBOX)
+#if defined(_XBOX) || defined(_WIN32_WCE)
    return NULL;
 #else
    return getenv(var);
diff --git a/src/mesa/main/imports.h b/src/mesa/main/imports.h
index ebdfc452a7a..d91a1366b07 100644
--- a/src/mesa/main/imports.h
+++ b/src/mesa/main/imports.h
@@ -332,7 +332,7 @@ static INLINE int iround(float f)
    return r;
 }
 #define IROUND(x)  iround(x)
-#elif defined(USE_X86_ASM) && defined(__MSC__) && defined(__WIN32__)
+#elif defined(USE_X86_ASM) && defined(_MSC_VER)
 static INLINE int iround(float f)
 {
    int r;
@@ -697,14 +697,10 @@ extern double
 _mesa_pow(double x, double y);
 
 extern int
-_mesa_ffs(int i);
+_mesa_ffs(int32_t i);
 
 extern int
-#ifdef __MINGW32__
-_mesa_ffsll(long i);
-#else
-_mesa_ffsll(long long i);
-#endif
+_mesa_ffsll(int64_t i);
 
 extern unsigned int
 _mesa_bitcount(unsigned int n);
diff --git a/src/mesa/main/mm.c b/src/mesa/main/mm.c
index fb7809ed221..6f381b02a7f 100644
--- a/src/mesa/main/mm.c
+++ b/src/mesa/main/mm.c
@@ -53,11 +53,11 @@ mmDumpMemInfo(const struct mem_block *heap)
 }
 
 struct mem_block *
-mmInit(unsigned int ofs, int size)
+mmInit(unsigned ofs, unsigned size)
 {
    struct mem_block *heap, *block;
   
-   if (size <= 0) 
+   if (!size) 
       return NULL;
 
    heap = (struct mem_block *) _mesa_calloc(sizeof(struct mem_block));
@@ -91,8 +91,8 @@ mmInit(unsigned int ofs, int size)
 
 static struct mem_block *
 SliceBlock(struct mem_block *p, 
-           unsigned int startofs, int size, 
-           int reserved, int alignment)
+           unsigned startofs, unsigned size, 
+           unsigned reserved, unsigned alignment)
 {
    struct mem_block *newblock;
 
@@ -160,14 +160,14 @@ SliceBlock(struct mem_block *p,
 
 
 struct mem_block *
-mmAllocMem(struct mem_block *heap, int size, int align2, int startSearch)
+mmAllocMem(struct mem_block *heap, unsigned size, unsigned align2, unsigned startSearch)
 {
    struct mem_block *p;
-   const int mask = (1 << align2)-1;
-   unsigned int startofs = 0;
-   unsigned int endofs;
+   const unsigned mask = (1 << align2)-1;
+   unsigned startofs = 0;
+   unsigned endofs;
 
-   if (!heap || align2 < 0 || size <= 0)
+   if (!heap || !align2 || !size)
       return NULL;
 
    for (p = heap->next_free; p != heap; p = p->next_free) {
@@ -193,7 +193,7 @@ mmAllocMem(struct mem_block *heap, int size, int align2, int startSearch)
 
 
 struct mem_block *
-mmFindBlock(struct mem_block *heap, int start)
+mmFindBlock(struct mem_block *heap, unsigned start)
 {
    struct mem_block *p;
 
diff --git a/src/mesa/main/mm.h b/src/mesa/main/mm.h
index 5ad3ffd6d15..df340808ac9 100644
--- a/src/mesa/main/mm.h
+++ b/src/mesa/main/mm.h
@@ -39,10 +39,10 @@ struct mem_block {
    struct mem_block *next, *prev;
    struct mem_block *next_free, *prev_free;
    struct mem_block *heap;
-   unsigned int ofs;
-   int size;
-   unsigned int free:1;
-   unsigned int reserved:1;
+   unsigned ofs;
+   unsigned size;
+   unsigned free:1;
+   unsigned reserved:1;
 };
 
 
@@ -51,7 +51,7 @@ struct mem_block {
  * input: total size in bytes
  * return: a heap pointer if OK, NULL if error
  */
-extern struct mem_block *mmInit(unsigned int ofs, int size);
+extern struct mem_block *mmInit(unsigned ofs, unsigned size);
 
 /**
  * Allocate 'size' bytes with 2^align2 bytes alignment,
@@ -63,8 +63,8 @@ extern struct mem_block *mmInit(unsigned int ofs, int size);
  *		startSearch = linear offset from start of heap to begin search
  * return: pointer to the allocated block, 0 if error
  */
-extern struct mem_block *mmAllocMem(struct mem_block *heap, int size, int align2, 
-                            int startSearch);
+extern struct mem_block *mmAllocMem(struct mem_block *heap, unsigned size, 
+                                    unsigned align2, unsigned startSearch);
 
 /**
  * Free block starts at offset
@@ -78,7 +78,7 @@ extern int mmFreeMem(struct mem_block *b);
  * input: pointer to a heap, start offset
  * return: pointer to a block
  */
-extern struct mem_block *mmFindBlock(struct mem_block *heap, int start);
+extern struct mem_block *mmFindBlock(struct mem_block *heap, unsigned start);
 
 /**
  * destroy MM
diff --git a/src/mesa/main/texcompress_fxt1.c b/src/mesa/main/texcompress_fxt1.c
index b6991f45ed8..16a3ba076fd 100644
--- a/src/mesa/main/texcompress_fxt1.c
+++ b/src/mesa/main/texcompress_fxt1.c
@@ -298,22 +298,17 @@ const struct gl_texture_format _mesa_texformat_rgba_fxt1 = {
 /*
  * Define a 64-bit unsigned integer type and macros
  */
-#if defined(__GNUC__) && !defined(__cplusplus)
+#if 1
 
 #define FX64_NATIVE 1
 
-#ifdef __MINGW32__
-typedef unsigned long Fx64;
-#else
-typedef unsigned long long Fx64;
-#endif
-
+typedef uint64_t Fx64;
 
 #define FX64_MOV32(a, b) a = b
 #define FX64_OR32(a, b)  a |= b
 #define FX64_SHL(a, c)   a <<= c
 
-#else  /* !__GNUC__ */
+#else
 
 #define FX64_NATIVE 0
 
@@ -335,7 +330,7 @@ typedef struct {
        }                                               \
    } while (0)
 
-#endif /* !__GNUC__ */
+#endif
 
 
 #define F(i) (GLfloat)1 /* can be used to obtain an oblong metric: 0.30 / 0.59 / 0.11 */
diff --git a/src/mesa/main/texstore.c b/src/mesa/main/texstore.c
index 519a73b9604..113eef69f4c 100644
--- a/src/mesa/main/texstore.c
+++ b/src/mesa/main/texstore.c
@@ -2405,16 +2405,15 @@ GLboolean
 _mesa_texstore_s8_z24(TEXSTORE_PARAMS)
 {
    const GLuint depthScale = 0xffffff;
-
-   ASSERT(dstFormat == &_mesa_texformat_s8_z24);
-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);
-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
-
    const GLint srcRowStride
       = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
       / sizeof(GLuint);
    GLint img, row;
 
+   ASSERT(dstFormat == &_mesa_texformat_s8_z24);
+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);
+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
+
    /* Incase we only upload depth we need to preserve the stencil */
    if (srcFormat == GL_DEPTH_COMPONENT) {
       for (img = 0; img < srcDepth; img++) {
diff --git a/src/mesa/math/m_debug_util.h b/src/mesa/math/m_debug_util.h
index f7ce4679b6d..776c26475e7 100644
--- a/src/mesa/math/m_debug_util.h
+++ b/src/mesa/math/m_debug_util.h
@@ -303,7 +303,7 @@ enum { NIL = 0, ONE = 1, NEG = -1, VAR = 2 };
  */
 #if defined(__GNUC__)
 #  define ALIGN16(type, array)	type array __attribute__ ((aligned (16)))
-#elif defined(__MSC__)
+#elif defined(_MSC_VER)
 #  define ALIGN16(type, array)	type array __declspec(align(16)) /* GH: Does this work? */
 #elif defined(__WATCOMC__)
 #  define ALIGN16(type, array)	                    /* Watcom does not support this */ 
diff --git a/src/mesa/math/m_debug_xform.c b/src/mesa/math/m_debug_xform.c
index 2af837cf64b..0b07b4fd68d 100644
--- a/src/mesa/math/m_debug_xform.c
+++ b/src/mesa/math/m_debug_xform.c
@@ -206,7 +206,8 @@ static int test_transform_function( transform_func func, int psize,
          case VAR:
             break;
          default:
-            abort();
+            ASSERT(0);
+            return 0;
          }
       }
    }
diff --git a/src/mesa/shader/program.c b/src/mesa/shader/program.c
index a0817a91ec0..b27ed6b7d37 100644
--- a/src/mesa/shader/program.c
+++ b/src/mesa/shader/program.c
@@ -467,7 +467,7 @@ _mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
    for (i = 0; i < prog->NumInstructions; i++) {
       struct prog_instruction *inst = prog->Instructions + i;
       if (inst->BranchTarget > 0) {
-         if (inst->BranchTarget >= start) {
+         if ((GLuint)inst->BranchTarget >= start) {
             inst->BranchTarget += count;
          }
       }
diff --git a/src/mesa/shader/shader_api.c b/src/mesa/shader/shader_api.c
index 856179e1d5b..97edb254003 100644
--- a/src/mesa/shader/shader_api.c
+++ b/src/mesa/shader/shader_api.c
@@ -1079,7 +1079,7 @@ update_textures_used(struct gl_program *prog)
  */
 static void
 set_program_uniform(GLcontext *ctx, struct gl_program *program, GLint location,
-                    GLenum type, GLint count, GLint elems, const void *values)
+                    GLenum type, GLsizei count, GLint elems, const void *values)
 {
    if (program->Parameters->Parameters[location].Type == PROGRAM_SAMPLER) {
       /* This controls which texture unit which is used by a sampler */
@@ -1111,7 +1111,7 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program, GLint location,
    }
    else {
       /* ordinary uniform variable */
-      GLuint k, i;
+      GLsizei k, i;
 
       if (count * elems > program->Parameters->Parameters[location].Size) {
          _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(count too large)");
diff --git a/src/mesa/shader/slang/slang_compile.c b/src/mesa/shader/slang/slang_compile.c
index cdea1c51287..8485103129b 100644
--- a/src/mesa/shader/slang/slang_compile.c
+++ b/src/mesa/shader/slang/slang_compile.c
@@ -1934,7 +1934,7 @@ compile_with_grammar(grammar id, const char *source, slang_code_unit * unit,
    byte *prod;
    GLuint size, start, version;
    slang_string preprocessed;
-   int maxVersion;
+   GLuint maxVersion;
 
 #if FEATURE_ARB_shading_language_120
    maxVersion = 120;
diff --git a/src/mesa/shader/slang/slang_print.c b/src/mesa/shader/slang/slang_print.c
index f3e127cb13f..4a7d4bbbc74 100644
--- a/src/mesa/shader/slang/slang_print.c
+++ b/src/mesa/shader/slang/slang_print.c
@@ -182,14 +182,14 @@ static void
 print_generic2(const slang_operation *op, const char *oper,
                const char *s, int indent)
 {
-   int i;
+   GLuint i;
    if (oper) {
       spaces(indent);
       printf("[%p locals %p] %s %s\n", (void*) op, (void*) op->locals, oper, s);
    }
    for (i = 0; i < op->num_children; i++) {
       spaces(indent);
-      printf("//child %d:\n", i);
+      printf("//child %u:\n", i);
       slang_print_tree(&op->children[i], indent);
    }
 }
@@ -804,7 +804,7 @@ int
 slang_checksum_tree(const slang_operation *op)
 {
    int s = op->num_children;
-   int i;
+   GLuint i;
 
    for (i = 0; i < op->num_children; i++) {
       s += slang_checksum_tree(&op->children[i]);
diff --git a/src/mesa/state_tracker/st_atom_sampler.c b/src/mesa/state_tracker/st_atom_sampler.c
index 9abd0b3531d..1e182eef1c5 100644
--- a/src/mesa/state_tracker/st_atom_sampler.c
+++ b/src/mesa/state_tracker/st_atom_sampler.c
@@ -67,7 +67,7 @@ gl_wrap_to_sp(GLenum wrap)
    case GL_MIRROR_CLAMP_TO_BORDER_EXT:
       return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
    default:
-      abort();
+      assert(0);
       return 0;
    }
 }
diff --git a/src/mesa/state_tracker/st_cb_bitmap.c b/src/mesa/state_tracker/st_cb_bitmap.c
index 9e32ee2eb40..6fa3cbd533c 100644
--- a/src/mesa/state_tracker/st_cb_bitmap.c
+++ b/src/mesa/state_tracker/st_cb_bitmap.c
@@ -494,14 +494,14 @@ draw_bitmap_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
       const GLfloat width = (GLfloat)fb->Width;
       const GLfloat height = (GLfloat)fb->Height;
       struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5 * width;
-      vp.scale[1] = (GLfloat)(height * (invert ? -0.5 : 0.5));
-      vp.scale[2] = 1.0;
-      vp.scale[3] = 1.0;
-      vp.translate[0] = (GLfloat)(0.5 * width);
-      vp.translate[1] = (GLfloat)(0.5 * height);
-      vp.translate[2] = 0.0;
-      vp.translate[3] = 0.0;
+      vp.scale[0] =  0.5f * width;
+      vp.scale[1] = height * (invert ? -0.5f : 0.5f);
+      vp.scale[2] = 1.0f;
+      vp.scale[3] = 1.0f;
+      vp.translate[0] = 0.5f * width;
+      vp.translate[1] = 0.5f * height;
+      vp.translate[2] = 0.0f;
+      vp.translate[3] = 0.0f;
       cso_set_viewport(cso, &vp);
    }
 
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index a486581989c..d8f1d2367c1 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -425,12 +425,12 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
       const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
       const GLfloat fb_width = fb->Width;
       const GLfloat fb_height = fb->Height;
-      const GLfloat clip_x0 = x0 / fb_width * 2.0 - 1.0;
-      const GLfloat clip_y0 = y0 / fb_height * 2.0 - 1.0;
-      const GLfloat clip_x1 = x1 / fb_width * 2.0 - 1.0;
-      const GLfloat clip_y1 = y1 / fb_height * 2.0 - 1.0;
-      const GLfloat sLeft = 0.0F, sRight = 1.0F;
-      const GLfloat tTop = invertTex, tBot = 1.0 - tTop;
+      const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;
+      const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;
+      const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;
+      const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;
+      const GLfloat sLeft = 0.0f, sRight = 1.0f;
+      const GLfloat tTop = invertTex, tBot = 1.0f - tTop;
       GLuint tex, i;
 
       /* upper-left */
@@ -463,21 +463,21 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
       if (color) {
          for (i = 0; i < 4; i++) {
             verts[i][0][2] = z;   /*Z*/
-            verts[i][0][3] = 1.0; /*W*/
+            verts[i][0][3] = 1.0f; /*W*/
             verts[i][1][0] = color[0];
             verts[i][1][1] = color[1];
             verts[i][1][2] = color[2];
             verts[i][1][3] = color[3];
-            verts[i][2][2] = 0.0; /*R*/
-            verts[i][2][3] = 1.0; /*Q*/
+            verts[i][2][2] = 0.0f; /*R*/
+            verts[i][2][3] = 1.0f; /*Q*/
          }
       }
       else {
          for (i = 0; i < 4; i++) {
             verts[i][0][2] = z;   /*Z*/
-            verts[i][0][3] = 1.0; /*W*/
-            verts[i][1][2] = 0.0; /*R*/
-            verts[i][1][3] = 1.0; /*Q*/
+            verts[i][0][3] = 1.0f; /*W*/
+            verts[i][1][2] = 0.0f; /*R*/
+            verts[i][1][3] = 1.0f; /*Q*/
          }
       }
    }
@@ -517,7 +517,7 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
    struct pipe_context *pipe = ctx->st->pipe;
    struct cso_context *cso = ctx->st->cso_context;
    GLfloat x0, y0, x1, y1;
-   GLuint maxSize;
+   GLsizei maxSize;
 
    /* limit checks */
    /* XXX if DrawPixels image is larger than max texture size, break
@@ -574,14 +574,14 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
       const float width = ctx->DrawBuffer->Width;
       const float height = ctx->DrawBuffer->Height;
       struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5 * width;
-      vp.scale[1] = -0.5 * height;
-      vp.scale[2] = 1.0;
-      vp.scale[3] = 1.0;
-      vp.translate[0] = 0.5 * width;
-      vp.translate[1] = 0.5 * height;
-      vp.translate[2] = 0.0;
-      vp.translate[3] = 0.0;
+      vp.scale[0] =  0.5f * width;
+      vp.scale[1] = -0.5f * height;
+      vp.scale[2] = 1.0f;
+      vp.scale[3] = 1.0f;
+      vp.translate[0] = 0.5f * width;
+      vp.translate[1] = 0.5f * height;
+      vp.translate[2] = 0.0f;
+      vp.translate[3] = 0.0f;
       cso_set_viewport(cso, &vp);
    }
 
diff --git a/src/mesa/state_tracker/st_cb_readpixels.c b/src/mesa/state_tracker/st_cb_readpixels.c
index 08934af3195..c5193631a75 100644
--- a/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/src/mesa/state_tracker/st_cb_readpixels.c
@@ -177,7 +177,8 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
    struct pipe_screen *screen = pipe->screen;
    GLfloat temp[MAX_WIDTH][4];
    const GLbitfield transferOps = ctx->_ImageTransferState;
-   GLint i, yStep, dfStride;
+   GLsizei i, j;
+   GLint yStep, dfStride;
    GLfloat *df;
    struct st_renderbuffer *strb;
    struct gl_pixelstore_attrib clippedPacking = *pack;
@@ -258,7 +259,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
           surf->format == PIPE_FORMAT_X8Z24_UNORM) {
          if (format == GL_DEPTH_COMPONENT) {
             for (i = 0; i < height; i++) {
-               GLuint ztemp[MAX_WIDTH], j;
+               GLuint ztemp[MAX_WIDTH];
                GLfloat zfloat[MAX_WIDTH];
                const double scale = 1.0 / ((1 << 24) - 1);
                pipe_get_tile_raw(pipe, surf, x, y, width, 1, ztemp, 0);
@@ -283,7 +284,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
       }
       else if (surf->format == PIPE_FORMAT_Z16_UNORM) {
          for (i = 0; i < height; i++) {
-            GLushort ztemp[MAX_WIDTH], j;
+            GLushort ztemp[MAX_WIDTH];
             GLfloat zfloat[MAX_WIDTH];
             const double scale = 1.0 / 0xffff;
             pipe_get_tile_raw(pipe, surf, x, y, width, 1, ztemp, 0);
@@ -298,7 +299,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
       }
       else if (surf->format == PIPE_FORMAT_Z32_UNORM) {
          for (i = 0; i < height; i++) {
-            GLuint ztemp[MAX_WIDTH], j;
+            GLuint ztemp[MAX_WIDTH];
             GLfloat zfloat[MAX_WIDTH];
             const double scale = 1.0 / 0xffffffff;
             pipe_get_tile_raw(pipe, surf, x, y, width, 1, ztemp, 0);
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index ed65f3b0aad..7d52d1da1b6 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -1157,11 +1157,13 @@ do_copy_texsubimage(GLcontext *ctx,
    struct pipe_context *pipe = ctx->st->pipe;
    struct pipe_screen *screen = pipe->screen;
    uint dest_format, src_format;
-   uint do_flip = FALSE;
    GLboolean use_fallback = GL_TRUE;
 
    (void) texImage;
 
+   /* XX need this?*/
+   st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
+
    /* determine if copying depth or color data */
    if (baseFormat == GL_DEPTH_COMPONENT) {
       strb = st_renderbuffer(fb->_DepthBuffer);
@@ -1178,40 +1180,15 @@ do_copy_texsubimage(GLcontext *ctx,
    assert(strb->surface);
    assert(stImage->pt);
 
-   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-      srcY = strb->Base.Height - srcY - height;
-      do_flip = TRUE;
-   }
-
    src_format = strb->surface->format;
    dest_format = stImage->pt->format;
 
    if (ctx->_ImageTransferState == 0x0) {
       /* do blit-style copy */
-
-      /* XXX may need to invert image depending on window
-       * vs. user-created FBO
-       */
-
-#if 0
-      /* A bit of fiddling to get the blitter to work with -ve
-       * pitches.  But we get a nice inverted blit this way, so it's
-       * worth it:
-       */
-      intelEmitCopyBlit(intel,
-                        stImage->pt->cpp,
-                        -src->pitch,
-                        src->buffer,
-                        src->height * src->pitch * src->cpp,
-                        stImage->pt->pitch,
-                        stImage->pt->region->buffer,
-                        dest_offset,
-                        x, y + height, dstx, dsty, width, height,
-                        GL_COPY); /* ? */
-#else
       struct pipe_surface *dest_surface;
 
-      dest_surface = screen->get_tex_surface(screen, stImage->pt, stImage->face,
+      dest_surface = screen->get_tex_surface(screen, stImage->pt,
+                                             stImage->face,
                                              stImage->level, destZ,
                                              PIPE_BUFFER_USAGE_GPU_WRITE);
 
@@ -1219,34 +1196,45 @@ do_copy_texsubimage(GLcontext *ctx,
       assert(dest_surface->buffer);
 
       if (src_format == dest_format) {
-          pipe->surface_copy(pipe,
-			     do_flip,
-			     /* dest */
-			     dest_surface,
-			     destX, destY,
-			     /* src */
-			     strb->surface,
-			     srcX, srcY,
-			     /* size */
-			     width, height);
-          use_fallback = GL_FALSE;
+         boolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
+         pipe->surface_copy(pipe,
+                            do_flip,
+                            /* dest */
+                            dest_surface,
+                            destX, destY,
+                            /* src */
+                            strb->surface,
+                            srcX, srcY,
+                            /* size */
+                            width, height);
+         use_fallback = GL_FALSE;
       }
       else if (screen->is_format_supported(screen, strb->surface->format,
                                            PIPE_TEXTURE) &&
                screen->is_format_supported(screen, dest_surface->format,
                                            PIPE_SURFACE)) {
+         boolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
+         int srcY0, srcY1;
+         if (do_flip) {
+            srcY1 = strb->Base.Height - srcY - height;
+            srcY0 = srcY1 + height;
+         }
+         else {
+            srcY0 = srcY;
+            srcY1 = srcY0 + height;
+         }
          util_blit_pixels(ctx->st->blit,
                           strb->surface,
-                          srcX, do_flip ? srcY + height : srcY,
-                          srcX + width, do_flip ? srcY : srcY + height,
+                          srcX, srcY0,
+                          srcX + width, srcY1,
                           dest_surface,
-                          destX, destY, destX + width, destY + height,
+                          destX, destY,
+                          destX + width, destY + height,
                           0.0, PIPE_TEX_MIPFILTER_NEAREST);
          use_fallback = GL_FALSE;
       }
 
       pipe_surface_reference(&dest_surface, NULL);
-#endif
    }
 
    if (use_fallback) {
diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c
index 5300848ef6a..21911774d79 100644
--- a/src/mesa/state_tracker/st_draw.c
+++ b/src/mesa/state_tracker/st_draw.c
@@ -147,6 +147,14 @@ static GLuint byte_types_scale[4] = {
    PIPE_FORMAT_R8G8B8A8_SSCALED
 };
 
+static GLuint fixed_types[4] = {
+   PIPE_FORMAT_R32_FIXED,
+   PIPE_FORMAT_R32G32_FIXED,
+   PIPE_FORMAT_R32G32B32_FIXED,
+   PIPE_FORMAT_R32G32B32A32_FIXED
+};
+
+
 
 /**
  * Return a PIPE_FORMAT_x for the given GL datatype and size.
@@ -154,8 +162,8 @@ static GLuint byte_types_scale[4] = {
 static GLuint
 pipe_vertex_format(GLenum type, GLuint size, GLboolean normalized)
 {
-   assert(type >= GL_BYTE);
-   assert(type <= GL_DOUBLE);
+   assert((type >= GL_BYTE && type <= GL_DOUBLE) ||
+          type == GL_FIXED);
    assert(size >= 1);
    assert(size <= 4);
 
@@ -169,6 +177,7 @@ pipe_vertex_format(GLenum type, GLuint size, GLboolean normalized)
       case GL_UNSIGNED_INT: return uint_types_norm[size-1];
       case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1];
       case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1];
+      case GL_FIXED: return fixed_types[size-1];
       default: assert(0); return 0;
       }      
    }
@@ -182,6 +191,7 @@ pipe_vertex_format(GLenum type, GLuint size, GLboolean normalized)
       case GL_UNSIGNED_INT: return uint_types_scale[size-1];
       case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1];
       case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1];
+      case GL_FIXED: return fixed_types[size-1];
       default: assert(0); return 0;
       }      
    }
@@ -206,7 +216,7 @@ setup_edgeflags(GLcontext *ctx, GLenum primMode, GLint start, GLint count,
        (ctx->Polygon.FrontMode != GL_FILL ||
         ctx->Polygon.BackMode != GL_FILL)) {
       /* need edge flags */
-      GLuint i;
+      GLint i;
       unsigned *vec;
       struct st_buffer_object *stobj = st_buffer_object(array->BufferObj);
       ubyte *map;
diff --git a/src/mesa/state_tracker/st_extensions.c b/src/mesa/state_tracker/st_extensions.c
index 6f94ba39aeb..d804d2b453d 100644
--- a/src/mesa/state_tracker/st_extensions.c
+++ b/src/mesa/state_tracker/st_extensions.c
@@ -43,7 +43,7 @@ static int _min(int a, int b)
    return (a < b) ? a : b;
 }
 
-static int _max(int a, int b)
+static float _maxf(float a, float b)
 {
    return (a > b) ? a : b;
 }
@@ -94,17 +94,17 @@ void st_init_limits(struct st_context *st)
               1, MAX_DRAW_BUFFERS);
 
    c->MaxLineWidth
-      = _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));
+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));
    c->MaxLineWidthAA
-      = _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));
+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));
 
    c->MaxPointSize
-      = _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));
+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));
    c->MaxPointSizeAA
-      = _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));
+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));
 
    c->MaxTextureMaxAnisotropy
-      = _max(2.0, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));
+      = _maxf(2.0f, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));
 
    c->MaxTextureLodBias
       = screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_LOD_BIAS);
diff --git a/src/mesa/state_tracker/st_framebuffer.c b/src/mesa/state_tracker/st_framebuffer.c
index 7e6db467576..1b6e68c2a11 100644
--- a/src/mesa/state_tracker/st_framebuffer.c
+++ b/src/mesa/state_tracker/st_framebuffer.c
@@ -230,6 +230,22 @@ st_get_framebuffer_surface(struct st_framebuffer *stfb, uint surfIndex)
    return NULL;
 }
 
+struct pipe_texture *
+st_get_framebuffer_texture(struct st_framebuffer *stfb, uint surfIndex)
+{
+   struct st_renderbuffer *strb;
+
+   assert(surfIndex <= ST_SURFACE_DEPTH);
+
+   /* sanity checks, ST tokens should match Mesa tokens */
+   assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
+   assert(ST_SURFACE_BACK_RIGHT == BUFFER_BACK_RIGHT);
+
+   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
+   if (strb)
+      return strb->texture;
+   return NULL;
+}
 
 /**
  * This function is to be called prior to SwapBuffers on the given
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index a8b6faad1c2..150545dfadc 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -772,7 +772,8 @@ tgsi_translate_mesa_program(
                                         TGSI_WRITEMASK_XYZW );
             break;
          default:
-            abort();
+            assert(0);
+            return 0;
          }
          ti += tgsi_build_full_declaration(&fulldecl,
                                            &tokens[ti],
diff --git a/src/mesa/state_tracker/st_public.h b/src/mesa/state_tracker/st_public.h
index b99984215f7..ca4e9577b1b 100644
--- a/src/mesa/state_tracker/st_public.h
+++ b/src/mesa/state_tracker/st_public.h
@@ -74,6 +74,9 @@ void st_set_framebuffer_surface(struct st_framebuffer *stfb,
 struct pipe_surface *st_get_framebuffer_surface(struct st_framebuffer *stfb,
                                                 uint surfIndex);
 
+struct pipe_texture *st_get_framebuffer_texture(struct st_framebuffer *stfb,
+                                                uint surfIndex);
+
 void *st_framebuffer_private( struct st_framebuffer *stfb );
 
 void st_unreference_framebuffer( struct st_framebuffer **stfb );