32 files changed, 2472 insertions, 2157 deletions

diff --git a/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.c b/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.c
index ca4f795f0..7e36018a0 100644
--- a/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.c
+++ b/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.c
@@ -50,21 +50,39 @@ struct u_vbuf_elements {
     * - src_format != native_format, as discussed above.
     * - src_offset % 4 != 0 (if the caps don't allow such an offset). */
    boolean incompatible_layout;
+   /* Per-element flags. */
+   boolean incompatible_layout_elem[PIPE_MAX_ATTRIBS];
 };
 
 struct u_vbuf_priv {
    struct u_vbuf_mgr b;
    struct pipe_context *pipe;
-
    struct translate_cache *translate_cache;
-   unsigned translate_vb_slot;
 
+   /* Whether there is any user buffer. */
+   boolean any_user_vbs;
+
+   /* Vertex element state bound by the state tracker. */
+   void *saved_ve;
+   /* and its associated helper structure for this module. */
    struct u_vbuf_elements *ve;
-   void *saved_ve, *fallback_ve;
+
+   /* Vertex elements used for the translate fallback. */
+   struct pipe_vertex_element fallback_velems[PIPE_MAX_ATTRIBS];
+   /* If non-NULL, this is a vertex element state used for the translate
+    * fallback and therefore used for rendering too. */
+   void *fallback_ve;
+   /* The vertex buffer slot index where translated vertices have been
+    * stored in. */
+   unsigned translate_vb_slot;
+   /* When binding the fallback vertex element state, we don't want to
+    * change saved_ve and ve. This is set to TRUE in such cases. */
    boolean ve_binding_lock;
 
-   boolean any_user_vbs;
+   /* Whether there is a buffer with a non-native layout. */
    boolean incompatible_vb_layout;
+   /* Per-buffer flags. */
+   boolean incompatible_vb[PIPE_MAX_ATTRIBS];
 };
 
 static void u_vbuf_init_format_caps(struct u_vbuf_priv *mgr)
@@ -107,6 +125,7 @@ u_vbuf_create(struct pipe_context *pipe,
 
    mgr->pipe = pipe;
    mgr->translate_cache = translate_cache_create();
+   mgr->translate_vb_slot = ~0;
 
    mgr->b.uploader = u_upload_create(pipe, upload_buffer_size,
                                      upload_buffer_alignment,
@@ -151,27 +170,21 @@ u_vbuf_translate_begin(struct u_vbuf_priv *mgr,
    struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0};
    struct pipe_resource *out_buffer = NULL;
    unsigned i, num_verts, out_offset;
-   struct pipe_vertex_element new_velems[PIPE_MAX_ATTRIBS];
    boolean upload_flushed = FALSE;
 
    memset(&key, 0, sizeof(key));
    memset(tr_elem_index, 0xff, sizeof(tr_elem_index));
 
    /* Initialize the translate key, i.e. the recipe how vertices should be
-     * translated. */
+    * translated. */
    memset(&key, 0, sizeof key);
    for (i = 0; i < mgr->ve->count; i++) {
-      struct pipe_vertex_buffer *vb =
-            &mgr->b.vertex_buffer[mgr->ve->ve[i].vertex_buffer_index];
       enum pipe_format output_format = mgr->ve->native_format[i];
       unsigned output_format_size = mgr->ve->native_format_size[i];
 
       /* Check for support. */
-      if (mgr->ve->ve[i].src_format == mgr->ve->native_format[i] &&
-          (mgr->b.caps.fetch_dword_unaligned ||
-           (vb->buffer_offset % 4 == 0 &&
-            vb->stride % 4 == 0 &&
-            mgr->ve->ve[i].src_offset % 4 == 0))) {
+      if (!mgr->ve->incompatible_layout_elem[i] &&
+          !mgr->incompatible_vb[mgr->ve->ve[i].vertex_buffer_index]) {
          continue;
       }
 
@@ -274,19 +287,19 @@ u_vbuf_translate_begin(struct u_vbuf_priv *mgr,
       for (i = 0; i < mgr->ve->count; i++) {
          if (tr_elem_index[i] < key.nr_elements) {
             te = &key.element[tr_elem_index[i]];
-            new_velems[i].instance_divisor = mgr->ve->ve[i].instance_divisor;
-            new_velems[i].src_format = te->output_format;
-            new_velems[i].src_offset = te->output_offset;
-            new_velems[i].vertex_buffer_index = mgr->translate_vb_slot;
+            mgr->fallback_velems[i].instance_divisor = mgr->ve->ve[i].instance_divisor;
+            mgr->fallback_velems[i].src_format = te->output_format;
+            mgr->fallback_velems[i].src_offset = te->output_offset;
+            mgr->fallback_velems[i].vertex_buffer_index = mgr->translate_vb_slot;
          } else {
-            memcpy(&new_velems[i], &mgr->ve->ve[i],
+            memcpy(&mgr->fallback_velems[i], &mgr->ve->ve[i],
                    sizeof(struct pipe_vertex_element));
          }
       }
 
       mgr->fallback_ve =
             mgr->pipe->create_vertex_elements_state(mgr->pipe, mgr->ve->count,
-                                                    new_velems);
+                                                    mgr->fallback_velems);
 
       /* Preserve saved_ve. */
       mgr->ve_binding_lock = TRUE;
@@ -312,6 +325,7 @@ static void u_vbuf_translate_end(struct u_vbuf_priv *mgr)
    /* Delete the now-unused VBO. */
    pipe_resource_reference(&mgr->b.real_vertex_buffer[mgr->translate_vb_slot].buffer,
                            NULL);
+   mgr->translate_vb_slot = ~0;
    mgr->b.nr_real_vertex_buffers = mgr->b.nr_vertex_buffers;
 }
 
@@ -406,10 +420,12 @@ u_vbuf_create_vertex_elements(struct u_vbuf_mgr *mgrb,
       ve->native_format_size[i] =
             util_format_get_blocksize(ve->native_format[i]);
 
-      ve->incompatible_layout =
-            ve->incompatible_layout ||
+      ve->incompatible_layout_elem[i] =
             ve->ve[i].src_format != ve->native_format[i] ||
             (!mgr->b.caps.fetch_dword_unaligned && ve->ve[i].src_offset % 4 != 0);
+      ve->incompatible_layout =
+            ve->incompatible_layout ||
+            ve->incompatible_layout_elem[i];
    }
 
    /* Align the formats to the size of DWORD if needed. */
@@ -453,6 +469,7 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf_mgr *mgrb,
 
    mgr->any_user_vbs = FALSE;
    mgr->incompatible_vb_layout = FALSE;
+   memset(mgr->incompatible_vb, 0, sizeof(mgr->incompatible_vb));
 
    if (!mgr->b.caps.fetch_dword_unaligned) {
       /* Check if the strides and offsets are aligned to the size of DWORD. */
@@ -461,7 +478,7 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf_mgr *mgrb,
             if (bufs[i].stride % 4 != 0 ||
                 bufs[i].buffer_offset % 4 != 0) {
                mgr->incompatible_vb_layout = TRUE;
-               break;
+               mgr->incompatible_vb[i] = TRUE;
             }
          }
       }
@@ -503,6 +520,19 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf_mgr *mgrb,
    mgr->b.nr_real_vertex_buffers = count;
 }
 
+void u_vbuf_set_index_buffer(struct u_vbuf_mgr *mgr,
+                             const struct pipe_index_buffer *ib)
+{
+   if (ib && ib->buffer) {
+      assert(ib->offset % ib->index_size == 0);
+      pipe_resource_reference(&mgr->index_buffer.buffer, ib->buffer);
+      mgr->index_buffer.offset = ib->offset;
+      mgr->index_buffer.index_size = ib->index_size;
+   } else {
+      pipe_resource_reference(&mgr->index_buffer.buffer, NULL);
+   }
+}
+
 static void
 u_vbuf_upload_buffers(struct u_vbuf_priv *mgr,
                       int min_index, int max_index,
@@ -512,16 +542,23 @@ u_vbuf_upload_buffers(struct u_vbuf_priv *mgr,
    unsigned count = max_index + 1 - min_index;
    unsigned nr_velems = mgr->ve->count;
    unsigned nr_vbufs = mgr->b.nr_vertex_buffers;
+   struct pipe_vertex_element *velems =
+         mgr->fallback_ve ? mgr->fallback_velems : mgr->ve->ve;
    unsigned start_offset[PIPE_MAX_ATTRIBS];
    unsigned end_offset[PIPE_MAX_ATTRIBS] = {0};
 
    /* Determine how much data needs to be uploaded. */
    for (i = 0; i < nr_velems; i++) {
-      struct pipe_vertex_element *velem = &mgr->ve->ve[i];
+      struct pipe_vertex_element *velem = &velems[i];
       unsigned index = velem->vertex_buffer_index;
       struct pipe_vertex_buffer *vb = &mgr->b.vertex_buffer[index];
       unsigned instance_div, first, size;
 
+      /* Skip the buffer generated by translate. */
+      if (index == mgr->translate_vb_slot) {
+         continue;
+      }
+
       assert(vb->buffer);
 
       if (!u_vbuf_resource(vb->buffer)->user_ptr) {
@@ -580,43 +617,182 @@ u_vbuf_upload_buffers(struct u_vbuf_priv *mgr,
    }
 }
 
-static void u_vbuf_compute_max_index(struct u_vbuf_priv *mgr)
+unsigned u_vbuf_draw_max_vertex_count(struct u_vbuf_mgr *mgrb)
 {
+   struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
    unsigned i, nr = mgr->ve->count;
-
-   mgr->b.max_index = ~0;
+   struct pipe_vertex_element *velems =
+         mgr->fallback_ve ? mgr->fallback_velems : mgr->ve->ve;
+   unsigned result = ~0;
 
    for (i = 0; i < nr; i++) {
       struct pipe_vertex_buffer *vb =
-            &mgr->b.vertex_buffer[mgr->ve->ve[i].vertex_buffer_index];
-      unsigned max_index, src_size, unused;
+            &mgr->b.real_vertex_buffer[velems[i].vertex_buffer_index];
+      unsigned size, max_count, value;
 
+      /* We're not interested in constant and per-instance attribs. */
       if (!vb->buffer ||
           !vb->stride ||
-          u_vbuf_resource(vb->buffer)->user_ptr ||
-          mgr->ve->ve[i].instance_divisor) {
+          velems[i].instance_divisor) {
          continue;
       }
 
-      src_size = mgr->ve->ve[i].src_offset + mgr->ve->src_format_size[i];
+      size = vb->buffer->width0;
 
-      /* If src_offset is greater than stride (which means it's a buffer
-       * offset rather than a vertex offset)... */
-      if (src_size >= vb->stride) {
-         unused = 0;
-      } else {
-         /* How many bytes is unused after the last vertex.
-          * width0 may be "count*stride - unused" and we have to compensate
-          * for that when dividing by stride. */
-         unused = vb->stride - src_size;
+      /* Subtract buffer_offset. */
+      value = vb->buffer_offset;
+      if (value >= size) {
+         return 0;
+      }
+      size -= value;
+
+      /* Subtract src_offset. */
+      value = velems[i].src_offset;
+      if (value >= size) {
+         return 0;
+      }
+      size -= value;
+
+      /* Subtract format_size. */
+      value = mgr->ve->native_format_size[i];
+      if (value >= size) {
+         return 0;
+      }
+      size -= value;
+
+      /* Compute the max count. */
+      max_count = 1 + size / vb->stride;
+      result = MIN2(result, max_count);
+   }
+   return result;
+}
+
+static boolean u_vbuf_need_minmax_index(struct u_vbuf_priv *mgr)
+{
+   unsigned i, nr = mgr->ve->count;
+
+   for (i = 0; i < nr; i++) {
+      struct pipe_vertex_buffer *vb;
+      unsigned index;
+
+      /* Per-instance attribs don't need min/max_index. */
+      if (mgr->ve->ve[i].instance_divisor) {
+         continue;
+      }
+
+      index = mgr->ve->ve[i].vertex_buffer_index;
+      vb = &mgr->b.vertex_buffer[index];
+
+      /* Constant attribs don't need min/max_index. */
+      if (!vb->stride) {
+         continue;
       }
 
-      /* Compute the maximum index for this vertex element. */
-      max_index =
-         (vb->buffer->width0 - vb->buffer_offset + (unsigned)unused) /
-         vb->stride - 1;
+      /* Per-vertex attribs need min/max_index. */
+      if (u_vbuf_resource(vb->buffer)->user_ptr ||
+          mgr->ve->incompatible_layout_elem[i] ||
+          mgr->incompatible_vb[index]) {
+         return TRUE;
+      }
+   }
+
+   return FALSE;
+}
+
+static void u_vbuf_get_minmax_index(struct pipe_context *pipe,
+                                    struct pipe_index_buffer *ib,
+                                    const struct pipe_draw_info *info,
+                                    int *out_min_index,
+                                    int *out_max_index)
+{
+   struct pipe_transfer *transfer = NULL;
+   const void *indices;
+   unsigned i;
+   unsigned restart_index = info->restart_index;
+
+   if (u_vbuf_resource(ib->buffer)->user_ptr) {
+      indices = u_vbuf_resource(ib->buffer)->user_ptr +
+                ib->offset + info->start * ib->index_size;
+   } else {
+      indices = pipe_buffer_map_range(pipe, ib->buffer,
+                                      ib->offset + info->start * ib->index_size,
+                                      info->count * ib->index_size,
+                                      PIPE_TRANSFER_READ, &transfer);
+   }
+
+   switch (ib->index_size) {
+   case 4: {
+      const unsigned *ui_indices = (const unsigned*)indices;
+      unsigned max_ui = 0;
+      unsigned min_ui = ~0U;
+      if (info->primitive_restart) {
+         for (i = 0; i < info->count; i++) {
+            if (ui_indices[i] != restart_index) {
+               if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
+               if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
+            }
+         }
+      }
+      else {
+         for (i = 0; i < info->count; i++) {
+            if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
+            if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
+         }
+      }
+      *out_min_index = min_ui;
+      *out_max_index = max_ui;
+      break;
+   }
+   case 2: {
+      const unsigned short *us_indices = (const unsigned short*)indices;
+      unsigned max_us = 0;
+      unsigned min_us = ~0U;
+      if (info->primitive_restart) {
+         for (i = 0; i < info->count; i++) {
+            if (us_indices[i] != restart_index) {
+               if (us_indices[i] > max_us) max_us = us_indices[i];
+               if (us_indices[i] < min_us) min_us = us_indices[i];
+            }
+         }
+      }
+      else {
+         for (i = 0; i < info->count; i++) {
+            if (us_indices[i] > max_us) max_us = us_indices[i];
+            if (us_indices[i] < min_us) min_us = us_indices[i];
+         }
+      }
+      *out_min_index = min_us;
+      *out_max_index = max_us;
+      break;
+   }
+   case 1: {
+      const unsigned char *ub_indices = (const unsigned char*)indices;
+      unsigned max_ub = 0;
+      unsigned min_ub = ~0U;
+      if (info->primitive_restart) {
+         for (i = 0; i < info->count; i++) {
+            if (ub_indices[i] != restart_index) {
+               if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
+               if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
+            }
+         }
+      }
+      else {
+         for (i = 0; i < info->count; i++) {
+            if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
+            if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
+         }
+      }
+      *out_min_index = min_ub;
+      *out_max_index = max_ub;
+      break;
+   }
+   default:
+      assert(0);
+   }
 
-      mgr->b.max_index = MIN2(mgr->b.max_index, max_index);
+   if (transfer) {
+      pipe_buffer_unmap(pipe, transfer);
    }
 }
 
@@ -627,17 +803,25 @@ u_vbuf_draw_begin(struct u_vbuf_mgr *mgrb,
    struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
    int min_index, max_index;
 
-   u_vbuf_compute_max_index(mgr);
+   if (!mgr->incompatible_vb_layout &&
+       !mgr->ve->incompatible_layout &&
+       !mgr->any_user_vbs) {
+      return 0;
+   }
 
    if (info->indexed) {
-      min_index = info->min_index;
-      if (info->max_index == ~0) {
-         max_index = mgr->b.max_index;
+      if (info->max_index != ~0) {
+         min_index = info->min_index + info->index_bias;
+         max_index = info->max_index + info->index_bias;
+      } else if (u_vbuf_need_minmax_index(mgr)) {
+         u_vbuf_get_minmax_index(mgr->pipe, &mgr->b.index_buffer, info,
+                                 &min_index, &max_index);
+         min_index += info->index_bias;
+         max_index += info->index_bias;
       } else {
-         max_index = MIN2(info->max_index, mgr->b.max_index);
+         min_index = 0;
+         max_index = 0;
       }
-      min_index += info->index_bias;
-      max_index += info->index_bias;
    } else {
       min_index = info->start;
       max_index = info->start + info->count - 1;
@@ -652,7 +836,7 @@ u_vbuf_draw_begin(struct u_vbuf_mgr *mgrb,
    if (mgr->any_user_vbs) {
       u_vbuf_upload_buffers(mgr, min_index, max_index, info->instance_count);
    }
-   return mgr->any_user_vbs || mgr->fallback_ve ? U_VBUF_BUFFERS_UPDATED : 0;
+   return U_VBUF_BUFFERS_UPDATED;
 }
 
 void u_vbuf_draw_end(struct u_vbuf_mgr *mgrb)
diff --git a/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.h b/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.h
index d854e4449..42ca0ac35 100644
--- a/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.h
+++ b/mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.h
@@ -67,8 +67,8 @@ struct u_vbuf_mgr {
    struct pipe_vertex_buffer real_vertex_buffer[PIPE_MAX_ATTRIBS];
    int nr_real_vertex_buffers;
 
-   /* Precomputed max_index for hardware vertex buffers. */
-   unsigned max_index;
+   /* The index buffer. */
+   struct pipe_index_buffer index_buffer;
 
    /* This uploader can optionally be used by the driver.
     *
@@ -126,9 +126,14 @@ void u_vbuf_set_vertex_buffers(struct u_vbuf_mgr *mgr,
                                unsigned count,
                                const struct pipe_vertex_buffer *bufs);
 
+void u_vbuf_set_index_buffer(struct u_vbuf_mgr *mgr,
+                             const struct pipe_index_buffer *ib);
+
 enum u_vbuf_return_flags u_vbuf_draw_begin(struct u_vbuf_mgr *mgr,
                                            const struct pipe_draw_info *info);
 
+unsigned u_vbuf_draw_max_vertex_count(struct u_vbuf_mgr *mgr);
+
 void u_vbuf_draw_end(struct u_vbuf_mgr *mgr);
 
 
diff --git a/mesalib/src/glsl/ir_clone.cpp b/mesalib/src/glsl/ir_clone.cpp
index e8ac9fbe4..c63615c7e 100644
--- a/mesalib/src/glsl/ir_clone.cpp
+++ b/mesalib/src/glsl/ir_clone.cpp
@@ -51,6 +51,7 @@ ir_variable::clone(void *mem_ctx, struct hash_table *ht) const
    var->pixel_center_integer = this->pixel_center_integer;
    var->explicit_location = this->explicit_location;
    var->has_initializer = this->has_initializer;
+   var->depth_layout = this->depth_layout;
 
    var->num_state_slots = this->num_state_slots;
    if (this->state_slots) {
diff --git a/mesalib/src/glsl/linker.cpp b/mesalib/src/glsl/linker.cpp
index 0ec773d6c..35270881a 100644
--- a/mesalib/src/glsl/linker.cpp
+++ b/mesalib/src/glsl/linker.cpp
@@ -1876,6 +1876,57 @@ store_tfeedback_info(struct gl_context *ctx, struct gl_shader_program *prog,
 }
 
 /**
+ * Store the gl_FragDepth layout in the gl_shader_program struct.
+ */
+static void
+store_fragdepth_layout(struct gl_shader_program *prog)
+{
+   if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL) {
+      return;
+   }
+
+   struct exec_list *ir = prog->_LinkedShaders[MESA_SHADER_FRAGMENT]->ir;
+
+   /* We don't look up the gl_FragDepth symbol directly because if
+    * gl_FragDepth is not used in the shader, it's removed from the IR.
+    * However, the symbol won't be removed from the symbol table.
+    *
+    * We're only interested in the cases where the variable is NOT removed
+    * from the IR.
+    */
+   foreach_list(node, ir) {
+      ir_variable *const var = ((ir_instruction *) node)->as_variable();
+
+      if (var == NULL || var->mode != ir_var_out) {
+         continue;
+      }
+
+      if (strcmp(var->name, "gl_FragDepth") == 0) {
+         switch (var->depth_layout) {
+         case ir_depth_layout_none:
+            prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_NONE;
+            return;
+         case ir_depth_layout_any:
+            prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_ANY;
+            return;
+         case ir_depth_layout_greater:
+            prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_GREATER;
+            return;
+         case ir_depth_layout_less:
+            prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_LESS;
+            return;
+         case ir_depth_layout_unchanged:
+            prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_UNCHANGED;
+            return;
+         default:
+            assert(0);
+            return;
+         }
+      }
+   }
+}
+
+/**
  * Validate the resources used by a program versus the implementation limits
  */
 static bool
@@ -2177,6 +2228,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
 
    update_array_sizes(prog);
    link_assign_uniform_locations(prog);
+   store_fragdepth_layout(prog);
 
    if (!check_resources(ctx, prog))
       goto done;
diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c
index f8b148cee..5b329f5c3 100644
--- a/mesalib/src/mesa/main/fbobject.c
+++ b/mesalib/src/mesa/main/fbobject.c
@@ -78,14 +78,6 @@ static struct gl_renderbuffer DummyRenderbuffer;
 static struct gl_framebuffer IncompleteFramebuffer;
 
 
-static inline GLboolean
-is_cube_face(GLenum target)
-{
-   return (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
-           target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
-}
-
-
 /**
  * Is the given FBO a user-created FBO?
  */
@@ -2008,7 +2000,7 @@ framebuffer_texture(struct gl_context *ctx, const char *caller, GLenum target,
          }
          else {
             err = (texObj->Target == GL_TEXTURE_CUBE_MAP)
-                ? !is_cube_face(textarget)
+                ? !_mesa_is_cube_face(textarget)
                 : (texObj->Target != textarget);
          }
       }
diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 285ec0783..b3427dac1 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -2218,6 +2218,9 @@ struct gl_shader_program
    /** Post-link transform feedback info. */
    struct gl_transform_feedback_info LinkedTransformFeedback;
 
+   /** Post-link gl_FragDepth layout for ARB_conservative_depth. */
+   enum gl_frag_depth_layout FragDepthLayout;
+
    /** Geometry shader state - copied into gl_geometry_program at link time */
    struct {
       GLint VerticesOut;
diff --git a/mesalib/src/mesa/main/readpix.c b/mesalib/src/mesa/main/readpix.c
index 86b87534d..8048a7286 100644
--- a/mesalib/src/mesa/main/readpix.c
+++ b/mesalib/src/mesa/main/readpix.c
@@ -70,6 +70,11 @@ fast_read_depth_pixels( struct gl_context *ctx,
    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
 			       &map, &stride);
 
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return GL_TRUE;  /* don't bother trying the slow path */
+   }
+
    dstStride = _mesa_image_row_stride(packing, width, GL_DEPTH_COMPONENT, type);
    dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
 					   GL_DEPTH_COMPONENT, type, 0, 0);
@@ -126,6 +131,10 @@ read_depth_pixels( struct gl_context *ctx,
 
    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
 			       &map, &stride);
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return;
+   }
 
    /* General case (slower) */
    for (j = 0; j < height; j++, y++) {
@@ -165,6 +174,10 @@ read_stencil_pixels( struct gl_context *ctx,
 
    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
 			       &map, &stride);
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return;
+   }
 
    /* process image row by row */
    for (j = 0; j < height; j++) {
@@ -211,6 +224,10 @@ fast_read_rgba_pixels_memcpy( struct gl_context *ctx,
 
    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
 			       &map, &stride);
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return GL_TRUE;  /* don't bother trying the slow path */
+   }
 
    texelBytes = _mesa_get_format_bytes(rb->Format);
    for (j = 0; j < height; j++) {
@@ -224,7 +241,7 @@ fast_read_rgba_pixels_memcpy( struct gl_context *ctx,
    return GL_TRUE;
 }
 
-static GLboolean
+static void
 slow_read_rgba_pixels( struct gl_context *ctx,
 		       GLint x, GLint y,
 		       GLsizei width, GLsizei height,
@@ -248,6 +265,10 @@ slow_read_rgba_pixels( struct gl_context *ctx,
 
    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
 			       &map, &stride);
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return;
+   }
 
    for (j = 0; j < height; j++) {
       if (_mesa_is_integer_format(format)) {
@@ -263,8 +284,6 @@ slow_read_rgba_pixels( struct gl_context *ctx,
    }
 
    ctx->Driver.UnmapRenderbuffer(ctx, rb);
-
-   return GL_TRUE;
 }
 
 /*
@@ -327,6 +346,10 @@ fast_read_depth_stencil_pixels(struct gl_context *ctx,
 
    ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
 			       &map, &stride);
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return GL_TRUE;  /* don't bother trying the slow path */
+   }
 
    for (i = 0; i < height; i++) {
       _mesa_unpack_uint_24_8_depth_stencil_row(rb->Format, width,
@@ -363,8 +386,18 @@ fast_read_depth_stencil_pixels_separate(struct gl_context *ctx,
 
    ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height,
 			       GL_MAP_READ_BIT, &depthMap, &depthStride);
+   if (!depthMap) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return GL_TRUE;  /* don't bother trying the slow path */
+   }
+
    ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height,
 			       GL_MAP_READ_BIT, &stencilMap, &stencilStride);
+   if (!stencilMap) {
+      ctx->Driver.UnmapRenderbuffer(ctx, depthRb);
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return GL_TRUE;  /* don't bother trying the slow path */
+   }
 
    for (j = 0; j < height; j++) {
       GLubyte stencilVals[MAX_WIDTH];
@@ -407,10 +440,20 @@ slow_read_depth_stencil_pixels_separate(struct gl_context *ctx,
     */
    ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height,
 			       GL_MAP_READ_BIT, &depthMap, &depthStride);
+   if (!depthMap) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+      return;
+   }
+
    if (stencilRb != depthRb) {
       ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height,
                                   GL_MAP_READ_BIT, &stencilMap,
                                   &stencilStride);
+      if (!stencilMap) {
+         ctx->Driver.UnmapRenderbuffer(ctx, depthRb);
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+         return;
+      }
    }
    else {
       stencilMap = depthMap;
diff --git a/mesalib/src/mesa/main/texgetimage.c b/mesalib/src/mesa/main/texgetimage.c
index 31d49f2d8..06506594d 100644
--- a/mesalib/src/mesa/main/texgetimage.c
+++ b/mesalib/src/mesa/main/texgetimage.c
@@ -386,11 +386,10 @@ get_tex_memcpy(struct gl_context *ctx, GLenum format, GLenum type,
     * so we don't have to worry about those.
     * XXX more format combinations could be supported here.
     */
-   if ((target == GL_TEXTURE_1D ||
-        target == GL_TEXTURE_2D ||
-        target == GL_TEXTURE_RECTANGLE ||
-        (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
-         target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))) {
+   if (target == GL_TEXTURE_1D ||
+       target == GL_TEXTURE_2D ||
+       target == GL_TEXTURE_RECTANGLE ||
+       _mesa_is_cube_face(target)) {
       if ((texImage->TexFormat == MESA_FORMAT_ARGB8888 ||
              texImage->TexFormat == MESA_FORMAT_SARGB8) &&
           format == GL_BGRA &&
diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index a84d6873d..c8ea4329f 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -522,8 +522,7 @@ _mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat )
 GLuint
 _mesa_tex_target_to_face(GLenum target)
 {
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)
+   if (_mesa_is_cube_face(target))
       return (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
    else
       return 0;
@@ -3094,8 +3093,7 @@ compressed_texture_error_check(struct gl_context *ctx, GLint dimensions,
    }
 
    /* For cube map, width must equal height */
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB && width != height) {
+   if (_mesa_is_cube_face(target) && width != height) {
       *reason = "width != height";
       return GL_INVALID_VALUE;
    }
@@ -3183,8 +3181,7 @@ compressed_subtexture_error_check(struct gl_context *ctx, GLint dimensions,
             return GL_INVALID_ENUM; /*target*/
          maxLevels = ctx->Const.MaxCubeTextureLevels;
       }
-      else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-               target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
+      else if (_mesa_is_cube_face(target)) {
          if (!ctx->Extensions.ARB_texture_cube_map)
             return GL_INVALID_ENUM; /*target*/
          maxLevels = ctx->Const.MaxCubeTextureLevels;
diff --git a/mesalib/src/mesa/main/teximage.h b/mesalib/src/mesa/main/teximage.h
index fd315bea3..9cc7d5a54 100644
--- a/mesalib/src/mesa/main/teximage.h
+++ b/mesalib/src/mesa/main/teximage.h
@@ -36,6 +36,16 @@
 #include "formats.h"
 
 
+/** Is the given value one of the 6 cube faces? */
+static inline GLboolean
+_mesa_is_cube_face(GLenum target)
+{
+   return (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
+           target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB);
+}
+
+
+
 /** \name Internal functions */
 /*@{*/
 
diff --git a/mesalib/src/mesa/program/ir_to_mesa.cpp b/mesalib/src/mesa/program/ir_to_mesa.cpp
index 5cee83778..5a68fc51d 100644
--- a/mesalib/src/mesa/program/ir_to_mesa.cpp
+++ b/mesalib/src/mesa/program/ir_to_mesa.cpp
@@ -685,29 +685,6 @@ ir_to_mesa_visitor::visit(ir_variable *ir)
 
       fp->OriginUpperLeft = ir->origin_upper_left;
       fp->PixelCenterInteger = ir->pixel_center_integer;
-
-   } else if (strcmp(ir->name, "gl_FragDepth") == 0) {
-      struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog;
-      switch (ir->depth_layout) {
-      case ir_depth_layout_none:
-	 fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_NONE;
-	 break;
-      case ir_depth_layout_any:
-	 fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_ANY;
-	 break;
-      case ir_depth_layout_greater:
-	 fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_GREATER;
-	 break;
-      case ir_depth_layout_less:
-	 fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_LESS;
-	 break;
-      case ir_depth_layout_unchanged:
-	 fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_UNCHANGED;
-	 break;
-      default:
-	 assert(0);
-	 break;
-      }
    }
 
    if (ir->mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) {
@@ -3222,6 +3199,12 @@ get_mesa_program(struct gl_context *ctx,
    do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER);
    count_resources(prog);
 
+   /* Set the gl_FragDepth layout. */
+   if (target == GL_FRAGMENT_PROGRAM_ARB) {
+      struct gl_fragment_program *fp = (struct gl_fragment_program *)prog;
+      fp->FragDepthLayout = shader_program->FragDepthLayout;
+   }
+
    _mesa_reference_program(ctx, &shader->Program, prog);
 
    if ((ctx->Shader.Flags & GLSL_NO_OPT) == 0) {
diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c
index cb518e1af..05a71d35c 100644
--- a/mesalib/src/mesa/state_tracker/st_draw.c
+++ b/mesalib/src/mesa/state_tracker/st_draw.c
@@ -648,45 +648,108 @@ check_uniforms(struct gl_context *ctx)
    }
 }
 
-/** Helper code for primitive restart fallback */
-#define DO_DRAW(pipe, cur_start, cur_count) \
-   do { \
-      info.start = cur_start; \
-      info.count = cur_count; \
-      if (u_trim_pipe_prim(info.mode, &info.count)) { \
-         if (transfer) \
-            pipe_buffer_unmap(pipe, transfer); \
-         pipe->draw_vbo(pipe, &info); \
-         if (transfer) { \
-            ptr = pipe_buffer_map(pipe, ibuffer->buffer, PIPE_TRANSFER_READ, &transfer); \
-            assert(ptr != NULL); \
-            ptr = ADD_POINTERS(ptr, ibuffer->offset); \
-         } \
-      } \
-   } while(0)
-      
-/** More helper code for primitive restart fallback */
-#define PRIM_RESTART_LOOP(elements) \
-   do { \
-      for (i = start; i < end; i++) { \
-         if (elements[i] == info.restart_index) { \
-            if (cur_count > 0) { \
-               /* draw elts up to prev pos */ \
-               DO_DRAW(pipe, cur_start, cur_count); \
-            } \
-            /* begin new prim at next elt */ \
-            cur_start = i + 1; \
-            cur_count = 0; \
-         } \
-         else { \
-            cur_count++; \
+
+/*
+ * Notes on primitive restart:
+ * The code below is used when the gallium driver does not support primitive
+ * restart itself.  We map the index buffer, find the restart indexes, unmap
+ * the index buffer then draw the sub-primitives delineated by the restarts.
+ * A couple possible optimizations:
+ * 1. Save the list of sub-primitive (start, count) values in a list attached
+ *    to the index buffer for re-use in subsequent draws.  The list would be
+ *    invalidated when the contents of the buffer changed.
+ * 2. If drawing triangle strips or quad strips, create a new index buffer
+ *    that uses duplicated vertices to render the disjoint strips as one
+ *    long strip.  We'd have to be careful to avoid using too much memory
+ *    for this.
+ * Finally, some apps might perform better if they don't use primitive restart
+ * at all rather than this fallback path.  Set MESA_EXTENSION_OVERRIDE to
+ * "-GL_NV_primitive_restart" to test that.
+ */
+
+
+struct sub_primitive
+{
+   unsigned start, count;
+};
+
+
+/**
+ * Scan the elements array to find restart indexes.  Return a list
+ * of primitive (start,count) pairs to indicate how to draw the sub-
+ * primitives delineated by the restart index.
+ */
+static struct sub_primitive *
+find_sub_primitives(const void *elements, unsigned element_size,
+                    unsigned start, unsigned end, unsigned restart_index,
+                    unsigned *num_sub_prims)
+{
+   const unsigned max_prims = end - start;
+   struct sub_primitive *sub_prims;
+   unsigned i, cur_start, cur_count, num;
+
+   sub_prims = (struct sub_primitive *)
+      malloc(max_prims * sizeof(struct sub_primitive));
+
+   if (!sub_prims) {
+      *num_sub_prims = 0;
+      return NULL;
+   }
+
+   cur_start = start;
+   cur_count = 0;
+   num = 0;
+
+#define SCAN_ELEMENTS(TYPE) \
+   for (i = start; i < end; i++) { \
+      if (((const TYPE *) elements)[i] == restart_index) { \
+         if (cur_count > 0) { \
+            assert(num < max_prims); \
+            sub_prims[num].start = cur_start; \
+            sub_prims[num].count = cur_count; \
+            num++; \
          } \
+         cur_start = i + 1; \
+         cur_count = 0; \
       } \
-      if (cur_count > 0) { \
-         DO_DRAW(pipe, cur_start, cur_count); \
+      else { \
+         cur_count++; \
       } \
-   } while (0)
+   } \
+   if (cur_count > 0) { \
+      assert(num < max_prims); \
+      sub_prims[num].start = cur_start; \
+      sub_prims[num].count = cur_count; \
+      num++; \
+   }
+
+   switch (element_size) {
+   case 1:
+      SCAN_ELEMENTS(ubyte);
+      break;
+   case 2:
+      SCAN_ELEMENTS(ushort);
+      break;
+   case 4:
+      SCAN_ELEMENTS(uint);
+      break;
+   default:
+      assert(0 && "bad index_size in find_sub_primitives()");
+   }
+
+#undef SCAN_ELEMENTS
+
+   *num_sub_prims = num;
+
+   return sub_prims;
+}
+
 
+/**
+ * For gallium drivers that don't support the primitive restart
+ * feature, handle it here by breaking up the indexed primitive into
+ * sub-primitives.
+ */
 static void
 handle_fallback_primitive_restart(struct pipe_context *pipe,
                                   const struct _mesa_index_buffer *ib,
@@ -695,78 +758,61 @@ handle_fallback_primitive_restart(struct pipe_context *pipe,
 {
    const unsigned start = orig_info->start;
    const unsigned count = orig_info->count;
-   const unsigned end = start + count;
    struct pipe_draw_info info = *orig_info;
    struct pipe_transfer *transfer = NULL;
-   unsigned instance, i, cur_start, cur_count;
-   const void *ptr;
+   unsigned instance, i;
+   const void *ptr = NULL;
+   struct sub_primitive *sub_prims;
+   unsigned num_sub_prims;
 
-   info.primitive_restart = FALSE;
-
-   if (!info.indexed) {
-      /* Splitting the draw arrays call is handled by the VBO module */
-      if (u_trim_pipe_prim(info.mode, &info.count))
-         pipe->draw_vbo(pipe, &info);
+   assert(info.indexed);
+   assert(ibuffer->buffer);
+   assert(ib);
 
+   if (!ibuffer->buffer || !ib)
       return;
-   }
 
-   /* info.indexed == TRUE */
-   assert(ibuffer);
-   assert(ibuffer->buffer);
+   info.primitive_restart = FALSE;
+   info.instance_count = 1;
 
-   if (ib) {
-      struct gl_buffer_object *bufobj = ib->obj;
-      if (bufobj && bufobj->Name) {
-         ptr = NULL;
-      }
-      else {
-         ptr = ib->ptr;
-      }
-   } else {
-      ptr = NULL;
+   if (ib->obj && _mesa_is_bufferobj(ib->obj)) {
+      ptr = pipe_buffer_map_range(pipe, ibuffer->buffer,
+                                  start * ibuffer->index_size, /* start */
+                                  count * ibuffer->index_size, /* length */
+                                  PIPE_TRANSFER_READ, &transfer);
+   }
+   else {
+      ptr = ib->ptr;
    }
 
    if (!ptr)
-      ptr = pipe_buffer_map(pipe, ibuffer->buffer, PIPE_TRANSFER_READ, &transfer);
+      return;
 
-   if (!ptr)
-     return;
    ptr = ADD_POINTERS(ptr, ibuffer->offset);
 
-   /* Need to loop over instances as well to preserve draw order */
+   sub_prims = find_sub_primitives(ptr, ibuffer->index_size,
+                                   0, count, orig_info->restart_index,
+                                   &num_sub_prims);
+
+   if (transfer)
+      pipe_buffer_unmap(pipe, transfer);
+
+   /* Now draw the sub primitives.
+    * Need to loop over instances as well to preserve draw order.
+    */
    for (instance = 0; instance < orig_info->instance_count; instance++) {
       info.start_instance = instance + orig_info->start_instance;
-      info.instance_count = 1;
-      cur_start = start;
-      cur_count = 0;
-
-      switch (ibuffer->index_size) {
-      case 1:
-         {
-            const ubyte *elt_ub = (const ubyte *)ptr; 
-            PRIM_RESTART_LOOP(elt_ub);
-         }
-         break;
-      case 2:
-         {
-            const ushort *elt_us = (const ushort *)ptr;
-            PRIM_RESTART_LOOP(elt_us);
-         }
-         break;
-      case 4:
-         {
-            const uint *elt_ui = (const uint *)ptr;
-            PRIM_RESTART_LOOP(elt_ui);
+      for (i = 0; i < num_sub_prims; i++) {
+         info.start = sub_prims[i].start;
+         info.count = sub_prims[i].count;
+         if (u_trim_pipe_prim(info.mode, &info.count)) {
+            pipe->draw_vbo(pipe, &info);
          }
-         break;
-      default:
-         assert(0 && "bad index_size in handle_fallback_primitive_restart()");
       }
    }
 
-   if (transfer)
-      pipe_buffer_unmap(pipe, transfer);
+   if (sub_prims)
+      free(sub_prims);
 }
 
 
@@ -978,10 +1024,13 @@ st_draw_vbo(struct gl_context *ctx,
          info.min_index = min_index;
          info.max_index = max_index;
       }
-   }
 
-   info.primitive_restart = ctx->Array.PrimitiveRestart;
-   info.restart_index = ctx->Array.RestartIndex;
+      /* The VBO module handles restart for the non-indexed GLDrawArrays
+       * so we only set these fields for indexed drawing:
+       */
+      info.primitive_restart = ctx->Array.PrimitiveRestart;
+      info.restart_index = ctx->Array.RestartIndex;
+   }
 
    /* do actual drawing */
    for (i = 0; i < nr_prims; i++) {
@@ -996,19 +1045,14 @@ st_draw_vbo(struct gl_context *ctx,
       }
 
       if (info.primitive_restart) {
-         /*
-          * Handle primitive restart for drivers that doesn't support it.
-          *
-          * The VBO module handles restart inside of draw_arrays for us,
-          * but we should still remove the primitive_restart flag on the
-          * info struct, the fallback function does this for us. Just
-          * remove the flag for all drivers in this case as well.
-          */
-         if (st->sw_primitive_restart || !info.indexed)
+         if (st->sw_primitive_restart) {
+            /* Handle primitive restart for drivers that doesn't support it */
             handle_fallback_primitive_restart(pipe, ib, &ibuffer, &info);
-         else
+         }
+         else {
             /* don't trim, restarts might be inside index list */
             pipe->draw_vbo(pipe, &info);
+         }
       }
       else if (u_trim_pipe_prim(info.mode, &info.count))
          pipe->draw_vbo(pipe, &info);
diff --git a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
index 0bf6766f7..929c7af01 100644
--- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
+++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
@@ -1017,29 +1017,6 @@ glsl_to_tgsi_visitor::visit(ir_variable *ir)
 
       fp->OriginUpperLeft = ir->origin_upper_left;
       fp->PixelCenterInteger = ir->pixel_center_integer;
-
-   } else if (strcmp(ir->name, "gl_FragDepth") == 0) {
-      struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog;
-      switch (ir->depth_layout) {
-      case ir_depth_layout_none:
-         fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_NONE;
-         break;
-      case ir_depth_layout_any:
-         fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_ANY;
-         break;
-      case ir_depth_layout_greater:
-         fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_GREATER;
-         break;
-      case ir_depth_layout_less:
-         fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_LESS;
-         break;
-      case ir_depth_layout_unchanged:
-         fp->FragDepthLayout = FRAG_DEPTH_LAYOUT_UNCHANGED;
-         break;
-      default:
-         assert(0);
-         break;
-      }
    }
 
    if (ir->mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) {
diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac
index 63d59f92d..e80403075 100644
--- a/xorg-server/configure.ac
+++ b/xorg-server/configure.ac
@@ -26,8 +26,8 @@ dnl
 dnl Process this file with autoconf to create configure.
 
 AC_PREREQ(2.57)
-AC_INIT([xorg-server], 1.11.0, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
-RELEASE_DATE="2011-08-26"
+AC_INIT([xorg-server], 1.11.99.1, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
+RELEASE_DATE="2011-11-20"
 AC_CONFIG_SRCDIR([Makefile.am])
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
 AM_MAINTAINER_MODE
diff --git a/xorg-server/hw/xfree86/common/xf86PciInfo.h b/xorg-server/hw/xfree86/common/xf86PciInfo.h
index 356c7db4d..e2d78627b 100644
--- a/xorg-server/hw/xfree86/common/xf86PciInfo.h
+++ b/xorg-server/hw/xfree86/common/xf86PciInfo.h
@@ -47,6 +47,8 @@
 #ifndef _XF86_PCIINFO_H
 #define _XF86_PCIINFO_H
 
+#warning "xf86PciInfo.h is deprecated.  For greater compatibility, drivers should include necessary PCI IDs locally rather than relying on this file from xorg-server."
+
 /* PCI Pseudo Vendor */
 #define PCI_VENDOR_GENERIC		0x00FF
 
diff --git a/xorg-server/hw/xfree86/common/xf86VidMode.c b/xorg-server/hw/xfree86/common/xf86VidMode.c
index eb29fd09e..2ae5484e3 100644
--- a/xorg-server/hw/xfree86/common/xf86VidMode.c
+++ b/xorg-server/hw/xfree86/common/xf86VidMode.c
@@ -1,669 +1,672 @@
-/*

- * Copyright (c) 1999-2003 by The XFree86 Project, Inc.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sublicense,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice shall be included in

- * all copies or substantial portions of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR

- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

- * OTHER DEALINGS IN THE SOFTWARE.

- *

- * Except as contained in this notice, the name of the copyright holder(s)

- * and author(s) shall not be used in advertising or otherwise to promote

- * the sale, use or other dealings in this Software without prior written

- * authorization from the copyright holder(s) and author(s).

- */

-

-/*

- * This file contains the VidMode functions required by the extension.

- * These have been added to avoid the need for the higher level extension

- * code to access the private XFree86 data structures directly. Wherever

- * possible this code uses the functions in xf86Mode.c to do the work,

- * so that two version of code that do similar things don't have to be

- * maintained.

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <X11/X.h>

-#include "os.h"

-#include "xf86.h"

-#include "xf86Priv.h"

-

-#ifdef XF86VIDMODE

-#include "vidmodeproc.h"

-#include "xf86cmap.h"

-

-static DevPrivateKeyRec VidModeKeyRec;

-static DevPrivateKey VidModeKey;

-static int VidModeCount = 0;

-static Bool VidModeClose(int i, ScreenPtr pScreen);

-

-#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))

-

-#endif

-

-Bool

-VidModeExtensionInit(ScreenPtr pScreen)

-{

-#ifdef XF86VIDMODE

-    VidModePtr pVidMode;

-    

-    if (!xf86GetVidModeEnabled()) {

-	DebugF("!xf86GetVidModeEnabled()\n");

-	return FALSE;

-    }

-

-    VidModeKey = &VidModeKeyRec;

-

-    if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, 0))

-	return FALSE;

-

-    pVidMode = calloc(sizeof(VidModeRec), 1);

-    if (!pVidMode)

-	return FALSE;

-

-    dixSetPrivate(&pScreen->devPrivates, VidModeKey, pVidMode);

-

-    pVidMode->Flags = 0;

-    pVidMode->Next = NULL;

-    pVidMode->CloseScreen = pScreen->CloseScreen;

-    pScreen->CloseScreen = VidModeClose;

-    VidModeCount++;

-    return TRUE;

-#else

-    DebugF("no vidmode extension\n");

-    return FALSE;

-#endif

-}

-

-

-#ifdef XF86VIDMODE

-

-static Bool

-VidModeClose(int i, ScreenPtr pScreen)

-{

-    VidModePtr pVidMode = VMPTR(pScreen);

-

-    /* This shouldn't happen */

-    if (!pVidMode)

-	return FALSE;

-

-    pScreen->CloseScreen = pVidMode->CloseScreen;

-

-    if (--VidModeCount == 0) {

-	free(dixLookupPrivate(&pScreen->devPrivates, VidModeKey));

-	dixSetPrivate(&pScreen->devPrivates, VidModeKey, NULL);

-	VidModeKey = NULL;

-    }

-    return pScreen->CloseScreen(i, pScreen);

-}

-

-Bool

-VidModeAvailable(int scrnIndex)

-{

-    ScrnInfoPtr pScrn;

-    VidModePtr pVidMode;

-

-    if (VidModeKey == NULL) {

-	DebugF("VidModeKey == NULL\n");

-	return FALSE;

-    }

- 

-    pScrn = xf86Screens[scrnIndex];

-    if (pScrn == NULL) {

-	DebugF("pScrn == NULL\n");

-	return FALSE;

-    }

-    

-    pVidMode = VMPTR(pScrn->pScreen);

-    if (pVidMode)

-	return TRUE;

-    else {

-	DebugF("pVidMode == NULL\n");

-	return FALSE;

-    }

-}

-

-Bool

-VidModeGetCurrentModeline(int scrnIndex, pointer *mode, int *dotClock)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-

-    if (pScrn->currentMode) {

-	*mode = (pointer)(pScrn->currentMode);

-	*dotClock = pScrn->currentMode->Clock;

-

-	return TRUE;

-    }

-    return FALSE;

-}

-

-int

-VidModeGetDotClock(int scrnIndex, int Clock)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return 0;

-

-    pScrn = xf86Screens[scrnIndex];

-    if ((pScrn->progClock) || (Clock >= MAXCLOCKS))

-	return Clock;

-    else  

-	return pScrn->clock[Clock];

-}

-

-int

-VidModeGetNumOfClocks(int scrnIndex, Bool *progClock)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return 0;

-

-    pScrn = xf86Screens[scrnIndex];

-    if (pScrn->progClock){

-	*progClock = TRUE;

-	return 0;

-    } else {

-	*progClock = FALSE;

-	return pScrn->numClocks;

-    }

-}

-

-Bool

-VidModeGetClocks(int scrnIndex, int *Clocks)

-{

-    ScrnInfoPtr pScrn;

-    int i;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-

-    if (pScrn->progClock)

-	return FALSE;

-

-    for (i = 0;  i < pScrn->numClocks;  i++)

-	*Clocks++ = pScrn->clock[i];

-

-    return TRUE;

-}

-

-

-Bool

-VidModeGetFirstModeline(int scrnIndex, pointer *mode, int *dotClock)

-{

-    ScrnInfoPtr pScrn;

-    VidModePtr pVidMode;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    pVidMode = VMPTR(pScrn->pScreen);

-    pVidMode->First = pScrn->modes;

-    pVidMode->Next =  pVidMode->First->next;

-

-    if (pVidMode->First->status == MODE_OK) {

-      *mode = (pointer)(pVidMode->First);

-      *dotClock = VidModeGetDotClock(scrnIndex, pVidMode->First->Clock);

-      return TRUE;

-    }

-

-    return VidModeGetNextModeline(scrnIndex, mode, dotClock);

-}

-

-Bool

-VidModeGetNextModeline(int scrnIndex, pointer *mode, int *dotClock)

-{

-    ScrnInfoPtr pScrn;

-    VidModePtr pVidMode;

-    DisplayModePtr p;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    pVidMode = VMPTR(pScrn->pScreen);

-

-    for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {

-	if (p->status == MODE_OK) {

-	    pVidMode->Next = p->next;

-	    *mode = (pointer)p;

-	    *dotClock = VidModeGetDotClock(scrnIndex, p->Clock);

-	    return TRUE;

-	}

-    }

-    

-    return FALSE;

-}

-

-Bool

-VidModeDeleteModeline(int scrnIndex, pointer mode)

-{

-    ScrnInfoPtr pScrn;

-

-    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    xf86DeleteMode(&(pScrn->modes), (DisplayModePtr)mode);

-    return TRUE;

-}

-

-Bool

-VidModeZoomViewport(int scrnIndex, int zoom)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    xf86ZoomViewport(pScrn->pScreen, zoom);

-    return TRUE;

-}

-

-Bool

-VidModeSetViewPort(int scrnIndex, int x, int y)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    pScrn->frameX0 = min( max(x, 0),

-	                 pScrn->virtualX - pScrn->currentMode->HDisplay );

-    pScrn->frameX1 = pScrn->frameX0 + pScrn->currentMode->HDisplay - 1;

-    pScrn->frameY0 = min( max(y, 0),

-	                 pScrn->virtualY - pScrn->currentMode->VDisplay );

-    pScrn->frameY1 = pScrn->frameY0 + pScrn->currentMode->VDisplay - 1;

-    if (pScrn->AdjustFrame != NULL)

-	(pScrn->AdjustFrame)(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);

-

-    return TRUE;

-}

-

-Bool

-VidModeGetViewPort(int scrnIndex, int *x, int *y)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    *x = pScrn->frameX0;

-    *y = pScrn->frameY0;

-    return TRUE;

-}

-

-Bool

-VidModeSwitchMode(int scrnIndex, pointer mode)

-{

-    ScrnInfoPtr pScrn;

-    DisplayModePtr pTmpMode;

-    Bool retval;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    /* save in case we fail */

-    pTmpMode = pScrn->currentMode;

-    /* Force a mode switch */

-    pScrn->currentMode = NULL;

-    retval = xf86SwitchMode(pScrn->pScreen, mode);

-    /* we failed: restore it */

-    if (retval == FALSE)

-	pScrn->currentMode = pTmpMode;

-    return retval;

-}

-

-Bool

-VidModeLockZoom(int scrnIndex, Bool lock)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-

-    if (xf86Info.dontZoom)

-	return FALSE;

-

-    xf86LockZoom(pScrn->pScreen, lock);

-    return TRUE;

-}

-

-Bool

-VidModeGetMonitor(int scrnIndex, pointer *monitor)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    *monitor = (pointer)(pScrn->monitor);

-

-    return TRUE;

-}

-

-ModeStatus

-VidModeCheckModeForMonitor(int scrnIndex, pointer mode)

-{

-    ScrnInfoPtr pScrn;

-

-    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))

-	return MODE_ERROR;

-

-    pScrn = xf86Screens[scrnIndex];

-

-    return xf86CheckModeForMonitor((DisplayModePtr)mode, pScrn->monitor);

-}

-

-ModeStatus

-VidModeCheckModeForDriver(int scrnIndex, pointer mode)

-{

-    ScrnInfoPtr pScrn;

-

-    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))

-	return MODE_ERROR;

-

-    pScrn = xf86Screens[scrnIndex];

-

-    return xf86CheckModeForDriver(pScrn, (DisplayModePtr)mode, 0);

-}

-

-void

-VidModeSetCrtcForMode(int scrnIndex, pointer mode)

-{

-    ScrnInfoPtr pScrn;

-    DisplayModePtr ScreenModes;

-    

-    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))

-	return;

-

-    /* Ugly hack so that the xf86Mode.c function can be used without change */

-    pScrn = xf86Screens[scrnIndex];

-    ScreenModes = pScrn->modes;

-    pScrn->modes = (DisplayModePtr)mode;

-    

-    xf86SetCrtcForModes(pScrn, pScrn->adjustFlags);

-    pScrn->modes = ScreenModes;

-    return;

-}

-

-Bool

-VidModeAddModeline(int scrnIndex, pointer mode)

-{

-    ScrnInfoPtr pScrn;

-    

-    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-

-    ((DisplayModePtr)mode)->name         = strdup(""); /* freed by deletemode */

-    ((DisplayModePtr)mode)->status       = MODE_OK;

-    ((DisplayModePtr)mode)->next         = pScrn->modes->next;

-    ((DisplayModePtr)mode)->prev         = pScrn->modes;

-    pScrn->modes->next                   = (DisplayModePtr)mode;

-    if( ((DisplayModePtr)mode)->next != NULL )

-      ((DisplayModePtr)mode)->next->prev   = (DisplayModePtr)mode;

-

-    return TRUE;

-}

-

-int

-VidModeGetNumOfModes(int scrnIndex)

-{

-    pointer mode = NULL;

-    int dotClock= 0, nummodes = 0;

-  

-    if (!VidModeGetFirstModeline(scrnIndex, &mode, &dotClock))

-	return nummodes;

-

-    do {

-	nummodes++;

-	if (!VidModeGetNextModeline(scrnIndex, &mode, &dotClock))

-	    return nummodes;

-    } while (TRUE);

-}

-

-Bool

-VidModeSetGamma(int scrnIndex, float red, float green, float blue)

-{

-    ScrnInfoPtr pScrn;

-    Gamma gamma;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    gamma.red = red;

-    gamma.green = green;

-    gamma.blue = blue;

-    if (xf86ChangeGamma(pScrn->pScreen, gamma) != Success)

-	return FALSE;

-    else

-	return TRUE;

-}

-

-Bool

-VidModeGetGamma(int scrnIndex, float *red, float *green, float *blue)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-	return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    *red = pScrn->gamma.red;

-    *green = pScrn->gamma.green;

-    *blue = pScrn->gamma.blue;

-    return TRUE;

-}

-

-Bool

-VidModeSetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-        return FALSE;

- 

-    pScrn = xf86Screens[scrnIndex];

-    xf86ChangeGammaRamp(pScrn->pScreen, size, r, g, b);

-    return TRUE;

-}

-

-Bool

-VidModeGetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)

-{

-    ScrnInfoPtr pScrn;

-

-    if (!VidModeAvailable(scrnIndex))

-        return FALSE;

-

-    pScrn = xf86Screens[scrnIndex];

-    xf86GetGammaRamp(pScrn->pScreen, size, r, g, b);

-    return TRUE;

-}

-

-int

-VidModeGetGammaRampSize(int scrnIndex)

-{

-    if (!VidModeAvailable(scrnIndex))

-        return 0;

-

-    return xf86GetGammaRampSize(xf86Screens[scrnIndex]->pScreen);

-}

-

-pointer

-VidModeCreateMode(void)

-{

-    DisplayModePtr mode;

-  

-    mode = malloc(sizeof(DisplayModeRec));

-    if (mode != NULL) {

-	mode->name          = "";

-	mode->VScan         = 1;    /* divides refresh rate. default = 1 */

-	mode->Private       = NULL;

-	mode->next          = mode;

-	mode->prev          = mode;

-    }

-    return mode;

-}

-

-void

-VidModeCopyMode(pointer modefrom, pointer modeto)

-{

-  memcpy(modeto, modefrom, sizeof(DisplayModeRec));

-}

-

-

-int

-VidModeGetModeValue(pointer mode, int valtyp)

-{

-  int ret = 0;

-  

-  switch (valtyp) {

-    case VIDMODE_H_DISPLAY:

-	ret = ((DisplayModePtr) mode)->HDisplay;

-	break;

-    case VIDMODE_H_SYNCSTART:

-	ret = ((DisplayModePtr)mode)->HSyncStart;

-	break;

-    case VIDMODE_H_SYNCEND:

-	ret = ((DisplayModePtr)mode)->HSyncEnd;

-	break;

-    case VIDMODE_H_TOTAL:

-	ret = ((DisplayModePtr)mode)->HTotal;

-	break;

-    case VIDMODE_H_SKEW:

-	ret = ((DisplayModePtr)mode)->HSkew;

-	break;

-    case VIDMODE_V_DISPLAY:

-	ret = ((DisplayModePtr)mode)->VDisplay;

-	break;

-    case VIDMODE_V_SYNCSTART:

-	ret = ((DisplayModePtr)mode)->VSyncStart;

-	break;

-    case VIDMODE_V_SYNCEND:

-	ret = ((DisplayModePtr)mode)->VSyncEnd;

-	break;

-    case VIDMODE_V_TOTAL:

-	ret = ((DisplayModePtr)mode)->VTotal;

-	break;

-    case VIDMODE_FLAGS:

-	ret = ((DisplayModePtr)mode)->Flags;

-	break;

-    case VIDMODE_CLOCK:

-	ret = ((DisplayModePtr)mode)->Clock;

-	break;

-  }

-  return ret;

-}

-

-void

-VidModeSetModeValue(pointer mode, int valtyp, int val)

-{

-  switch (valtyp) {

-    case VIDMODE_H_DISPLAY:

-	((DisplayModePtr)mode)->HDisplay = val;

-	break;

-    case VIDMODE_H_SYNCSTART:

-	((DisplayModePtr)mode)->HSyncStart = val;

-	break;

-    case VIDMODE_H_SYNCEND:

-	((DisplayModePtr)mode)->HSyncEnd = val;

-	break;

-    case VIDMODE_H_TOTAL:

-	((DisplayModePtr)mode)->HTotal = val;

-	break;

-    case VIDMODE_H_SKEW:

-	((DisplayModePtr)mode)->HSkew = val;

-	break;

-    case VIDMODE_V_DISPLAY:

-	((DisplayModePtr)mode)->VDisplay = val;

-	break;

-    case VIDMODE_V_SYNCSTART:

-	((DisplayModePtr)mode)->VSyncStart = val;

-	break;

-    case VIDMODE_V_SYNCEND:

-	((DisplayModePtr)mode)->VSyncEnd = val;

-	break;

-    case VIDMODE_V_TOTAL:

-	((DisplayModePtr)mode)->VTotal = val;

-	break;

-    case VIDMODE_FLAGS:

-	((DisplayModePtr)mode)->Flags = val;

-	break;

-    case VIDMODE_CLOCK:

-	((DisplayModePtr)mode)->Clock = val;

-	break;

-  }

-  return;

-}

-

-vidMonitorValue

-VidModeGetMonitorValue(pointer monitor, int valtyp, int indx)

-{

-  vidMonitorValue ret = { NULL, };

-  

-  switch (valtyp) {

-    case VIDMODE_MON_VENDOR:

-	ret.ptr = (((MonPtr)monitor)->vendor);

-	break;

-    case VIDMODE_MON_MODEL:

-	ret.ptr = (((MonPtr)monitor)->model);

-	break;

-    case VIDMODE_MON_NHSYNC:

-	ret.i = ((MonPtr)monitor)->nHsync;

-	break;

-    case VIDMODE_MON_NVREFRESH:

-	ret.i = ((MonPtr)monitor)->nVrefresh;

-	break;

-    case VIDMODE_MON_HSYNC_LO:

-	ret.f = (100.0 * ((MonPtr)monitor)->hsync[indx].lo);

-	break;

-    case VIDMODE_MON_HSYNC_HI:

-	ret.f = (100.0 * ((MonPtr)monitor)->hsync[indx].hi);

-	break;

-    case VIDMODE_MON_VREFRESH_LO:

-	ret.f = (100.0 * ((MonPtr)monitor)->vrefresh[indx].lo);

-	break;

-    case VIDMODE_MON_VREFRESH_HI:

-	ret.f = (100.0 * ((MonPtr)monitor)->vrefresh[indx].hi);

-	break;

-  }

-  return ret;

-}

-

-

-#endif /* XF86VIDMODE */

+/*
+ * Copyright (c) 1999-2003 by The XFree86 Project, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the copyright holder(s)
+ * and author(s) shall not be used in advertising or otherwise to promote
+ * the sale, use or other dealings in this Software without prior written
+ * authorization from the copyright holder(s) and author(s).
+ */
+
+/*
+ * This file contains the VidMode functions required by the extension.
+ * These have been added to avoid the need for the higher level extension
+ * code to access the private XFree86 data structures directly. Wherever
+ * possible this code uses the functions in xf86Mode.c to do the work,
+ * so that two version of code that do similar things don't have to be
+ * maintained.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "os.h"
+#include "xf86.h"
+#include "xf86Priv.h"
+
+#ifdef XF86VIDMODE
+#include "vidmodeproc.h"
+#include "xf86cmap.h"
+
+static DevPrivateKeyRec VidModeKeyRec;
+static DevPrivateKey VidModeKey;
+static int VidModeCount = 0;
+static Bool VidModeClose(int i, ScreenPtr pScreen);
+
+#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))
+
+#endif
+
+Bool
+VidModeExtensionInit(ScreenPtr pScreen)
+{
+#ifdef XF86VIDMODE
+    VidModePtr pVidMode;
+    
+    if (!xf86GetVidModeEnabled()) {
+	DebugF("!xf86GetVidModeEnabled()\n");
+	return FALSE;
+    }
+
+    VidModeKey = &VidModeKeyRec;
+
+    if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, 0))
+	return FALSE;
+
+    pVidMode = calloc(sizeof(VidModeRec), 1);
+    if (!pVidMode)
+	return FALSE;
+
+    dixSetPrivate(&pScreen->devPrivates, VidModeKey, pVidMode);
+
+    pVidMode->Flags = 0;
+    pVidMode->Next = NULL;
+    pVidMode->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = VidModeClose;
+    VidModeCount++;
+    return TRUE;
+#else
+    DebugF("no vidmode extension\n");
+    return FALSE;
+#endif
+}
+
+
+#ifdef XF86VIDMODE
+
+static Bool
+VidModeClose(int i, ScreenPtr pScreen)
+{
+    VidModePtr pVidMode = VMPTR(pScreen);
+
+    /* This shouldn't happen */
+    if (!pVidMode)
+	return FALSE;
+
+    pScreen->CloseScreen = pVidMode->CloseScreen;
+
+    if (--VidModeCount == 0) {
+	free(dixLookupPrivate(&pScreen->devPrivates, VidModeKey));
+	dixSetPrivate(&pScreen->devPrivates, VidModeKey, NULL);
+	VidModeKey = NULL;
+    }
+    return pScreen->CloseScreen(i, pScreen);
+}
+
+Bool
+VidModeAvailable(int scrnIndex)
+{
+    ScrnInfoPtr pScrn;
+    VidModePtr pVidMode;
+
+    if (VidModeKey == NULL) {
+	DebugF("VidModeKey == NULL\n");
+	return FALSE;
+    }
+ 
+    pScrn = xf86Screens[scrnIndex];
+    if (pScrn == NULL) {
+	DebugF("pScrn == NULL\n");
+	return FALSE;
+    }
+    
+    pVidMode = VMPTR(pScrn->pScreen);
+    if (pVidMode)
+	return TRUE;
+    else {
+	DebugF("pVidMode == NULL\n");
+	return FALSE;
+    }
+}
+
+Bool
+VidModeGetCurrentModeline(int scrnIndex, pointer *mode, int *dotClock)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+
+    if (pScrn->currentMode) {
+	*mode = (pointer)(pScrn->currentMode);
+	*dotClock = pScrn->currentMode->Clock;
+
+	return TRUE;
+    }
+    return FALSE;
+}
+
+int
+VidModeGetDotClock(int scrnIndex, int Clock)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return 0;
+
+    pScrn = xf86Screens[scrnIndex];
+    if ((pScrn->progClock) || (Clock >= MAXCLOCKS))
+	return Clock;
+    else  
+	return pScrn->clock[Clock];
+}
+
+int
+VidModeGetNumOfClocks(int scrnIndex, Bool *progClock)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return 0;
+
+    pScrn = xf86Screens[scrnIndex];
+    if (pScrn->progClock){
+	*progClock = TRUE;
+	return 0;
+    } else {
+	*progClock = FALSE;
+	return pScrn->numClocks;
+    }
+}
+
+Bool
+VidModeGetClocks(int scrnIndex, int *Clocks)
+{
+    ScrnInfoPtr pScrn;
+    int i;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+
+    if (pScrn->progClock)
+	return FALSE;
+
+    for (i = 0;  i < pScrn->numClocks;  i++)
+	*Clocks++ = pScrn->clock[i];
+
+    return TRUE;
+}
+
+
+Bool
+VidModeGetFirstModeline(int scrnIndex, pointer *mode, int *dotClock)
+{
+    ScrnInfoPtr pScrn;
+    VidModePtr pVidMode;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    if (pScrn->modes == NULL)
+	    return FALSE;
+
+    pVidMode = VMPTR(pScrn->pScreen);
+    pVidMode->First = pScrn->modes;
+    pVidMode->Next =  pVidMode->First->next;
+
+    if (pVidMode->First->status == MODE_OK) {
+      *mode = (pointer)(pVidMode->First);
+      *dotClock = VidModeGetDotClock(scrnIndex, pVidMode->First->Clock);
+      return TRUE;
+    }
+
+    return VidModeGetNextModeline(scrnIndex, mode, dotClock);
+}
+
+Bool
+VidModeGetNextModeline(int scrnIndex, pointer *mode, int *dotClock)
+{
+    ScrnInfoPtr pScrn;
+    VidModePtr pVidMode;
+    DisplayModePtr p;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    pVidMode = VMPTR(pScrn->pScreen);
+
+    for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
+	if (p->status == MODE_OK) {
+	    pVidMode->Next = p->next;
+	    *mode = (pointer)p;
+	    *dotClock = VidModeGetDotClock(scrnIndex, p->Clock);
+	    return TRUE;
+	}
+    }
+    
+    return FALSE;
+}
+
+Bool
+VidModeDeleteModeline(int scrnIndex, pointer mode)
+{
+    ScrnInfoPtr pScrn;
+
+    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    xf86DeleteMode(&(pScrn->modes), (DisplayModePtr)mode);
+    return TRUE;
+}
+
+Bool
+VidModeZoomViewport(int scrnIndex, int zoom)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    xf86ZoomViewport(pScrn->pScreen, zoom);
+    return TRUE;
+}
+
+Bool
+VidModeSetViewPort(int scrnIndex, int x, int y)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    pScrn->frameX0 = min( max(x, 0),
+	                 pScrn->virtualX - pScrn->currentMode->HDisplay );
+    pScrn->frameX1 = pScrn->frameX0 + pScrn->currentMode->HDisplay - 1;
+    pScrn->frameY0 = min( max(y, 0),
+	                 pScrn->virtualY - pScrn->currentMode->VDisplay );
+    pScrn->frameY1 = pScrn->frameY0 + pScrn->currentMode->VDisplay - 1;
+    if (pScrn->AdjustFrame != NULL)
+	(pScrn->AdjustFrame)(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+
+    return TRUE;
+}
+
+Bool
+VidModeGetViewPort(int scrnIndex, int *x, int *y)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    *x = pScrn->frameX0;
+    *y = pScrn->frameY0;
+    return TRUE;
+}
+
+Bool
+VidModeSwitchMode(int scrnIndex, pointer mode)
+{
+    ScrnInfoPtr pScrn;
+    DisplayModePtr pTmpMode;
+    Bool retval;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    /* save in case we fail */
+    pTmpMode = pScrn->currentMode;
+    /* Force a mode switch */
+    pScrn->currentMode = NULL;
+    retval = xf86SwitchMode(pScrn->pScreen, mode);
+    /* we failed: restore it */
+    if (retval == FALSE)
+	pScrn->currentMode = pTmpMode;
+    return retval;
+}
+
+Bool
+VidModeLockZoom(int scrnIndex, Bool lock)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+
+    if (xf86Info.dontZoom)
+	return FALSE;
+
+    xf86LockZoom(pScrn->pScreen, lock);
+    return TRUE;
+}
+
+Bool
+VidModeGetMonitor(int scrnIndex, pointer *monitor)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    *monitor = (pointer)(pScrn->monitor);
+
+    return TRUE;
+}
+
+ModeStatus
+VidModeCheckModeForMonitor(int scrnIndex, pointer mode)
+{
+    ScrnInfoPtr pScrn;
+
+    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+	return MODE_ERROR;
+
+    pScrn = xf86Screens[scrnIndex];
+
+    return xf86CheckModeForMonitor((DisplayModePtr)mode, pScrn->monitor);
+}
+
+ModeStatus
+VidModeCheckModeForDriver(int scrnIndex, pointer mode)
+{
+    ScrnInfoPtr pScrn;
+
+    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+	return MODE_ERROR;
+
+    pScrn = xf86Screens[scrnIndex];
+
+    return xf86CheckModeForDriver(pScrn, (DisplayModePtr)mode, 0);
+}
+
+void
+VidModeSetCrtcForMode(int scrnIndex, pointer mode)
+{
+    ScrnInfoPtr pScrn;
+    DisplayModePtr ScreenModes;
+    
+    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+	return;
+
+    /* Ugly hack so that the xf86Mode.c function can be used without change */
+    pScrn = xf86Screens[scrnIndex];
+    ScreenModes = pScrn->modes;
+    pScrn->modes = (DisplayModePtr)mode;
+    
+    xf86SetCrtcForModes(pScrn, pScrn->adjustFlags);
+    pScrn->modes = ScreenModes;
+    return;
+}
+
+Bool
+VidModeAddModeline(int scrnIndex, pointer mode)
+{
+    ScrnInfoPtr pScrn;
+    
+    if ((mode == NULL) || (!VidModeAvailable(scrnIndex)))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+
+    ((DisplayModePtr)mode)->name         = strdup(""); /* freed by deletemode */
+    ((DisplayModePtr)mode)->status       = MODE_OK;
+    ((DisplayModePtr)mode)->next         = pScrn->modes->next;
+    ((DisplayModePtr)mode)->prev         = pScrn->modes;
+    pScrn->modes->next                   = (DisplayModePtr)mode;
+    if( ((DisplayModePtr)mode)->next != NULL )
+      ((DisplayModePtr)mode)->next->prev   = (DisplayModePtr)mode;
+
+    return TRUE;
+}
+
+int
+VidModeGetNumOfModes(int scrnIndex)
+{
+    pointer mode = NULL;
+    int dotClock= 0, nummodes = 0;
+  
+    if (!VidModeGetFirstModeline(scrnIndex, &mode, &dotClock))
+	return nummodes;
+
+    do {
+	nummodes++;
+	if (!VidModeGetNextModeline(scrnIndex, &mode, &dotClock))
+	    return nummodes;
+    } while (TRUE);
+}
+
+Bool
+VidModeSetGamma(int scrnIndex, float red, float green, float blue)
+{
+    ScrnInfoPtr pScrn;
+    Gamma gamma;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    gamma.red = red;
+    gamma.green = green;
+    gamma.blue = blue;
+    if (xf86ChangeGamma(pScrn->pScreen, gamma) != Success)
+	return FALSE;
+    else
+	return TRUE;
+}
+
+Bool
+VidModeGetGamma(int scrnIndex, float *red, float *green, float *blue)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+	return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    *red = pScrn->gamma.red;
+    *green = pScrn->gamma.green;
+    *blue = pScrn->gamma.blue;
+    return TRUE;
+}
+
+Bool
+VidModeSetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+        return FALSE;
+ 
+    pScrn = xf86Screens[scrnIndex];
+    xf86ChangeGammaRamp(pScrn->pScreen, size, r, g, b);
+    return TRUE;
+}
+
+Bool
+VidModeGetGammaRamp(int scrnIndex, int size, CARD16 *r, CARD16 *g, CARD16 *b)
+{
+    ScrnInfoPtr pScrn;
+
+    if (!VidModeAvailable(scrnIndex))
+        return FALSE;
+
+    pScrn = xf86Screens[scrnIndex];
+    xf86GetGammaRamp(pScrn->pScreen, size, r, g, b);
+    return TRUE;
+}
+
+int
+VidModeGetGammaRampSize(int scrnIndex)
+{
+    if (!VidModeAvailable(scrnIndex))
+        return 0;
+
+    return xf86GetGammaRampSize(xf86Screens[scrnIndex]->pScreen);
+}
+
+pointer
+VidModeCreateMode(void)
+{
+    DisplayModePtr mode;
+  
+    mode = malloc(sizeof(DisplayModeRec));
+    if (mode != NULL) {
+	mode->name          = "";
+	mode->VScan         = 1;    /* divides refresh rate. default = 1 */
+	mode->Private       = NULL;
+	mode->next          = mode;
+	mode->prev          = mode;
+    }
+    return mode;
+}
+
+void
+VidModeCopyMode(pointer modefrom, pointer modeto)
+{
+  memcpy(modeto, modefrom, sizeof(DisplayModeRec));
+}
+
+
+int
+VidModeGetModeValue(pointer mode, int valtyp)
+{
+  int ret = 0;
+  
+  switch (valtyp) {
+    case VIDMODE_H_DISPLAY:
+	ret = ((DisplayModePtr) mode)->HDisplay;
+	break;
+    case VIDMODE_H_SYNCSTART:
+	ret = ((DisplayModePtr)mode)->HSyncStart;
+	break;
+    case VIDMODE_H_SYNCEND:
+	ret = ((DisplayModePtr)mode)->HSyncEnd;
+	break;
+    case VIDMODE_H_TOTAL:
+	ret = ((DisplayModePtr)mode)->HTotal;
+	break;
+    case VIDMODE_H_SKEW:
+	ret = ((DisplayModePtr)mode)->HSkew;
+	break;
+    case VIDMODE_V_DISPLAY:
+	ret = ((DisplayModePtr)mode)->VDisplay;
+	break;
+    case VIDMODE_V_SYNCSTART:
+	ret = ((DisplayModePtr)mode)->VSyncStart;
+	break;
+    case VIDMODE_V_SYNCEND:
+	ret = ((DisplayModePtr)mode)->VSyncEnd;
+	break;
+    case VIDMODE_V_TOTAL:
+	ret = ((DisplayModePtr)mode)->VTotal;
+	break;
+    case VIDMODE_FLAGS:
+	ret = ((DisplayModePtr)mode)->Flags;
+	break;
+    case VIDMODE_CLOCK:
+	ret = ((DisplayModePtr)mode)->Clock;
+	break;
+  }
+  return ret;
+}
+
+void
+VidModeSetModeValue(pointer mode, int valtyp, int val)
+{
+  switch (valtyp) {
+    case VIDMODE_H_DISPLAY:
+	((DisplayModePtr)mode)->HDisplay = val;
+	break;
+    case VIDMODE_H_SYNCSTART:
+	((DisplayModePtr)mode)->HSyncStart = val;
+	break;
+    case VIDMODE_H_SYNCEND:
+	((DisplayModePtr)mode)->HSyncEnd = val;
+	break;
+    case VIDMODE_H_TOTAL:
+	((DisplayModePtr)mode)->HTotal = val;
+	break;
+    case VIDMODE_H_SKEW:
+	((DisplayModePtr)mode)->HSkew = val;
+	break;
+    case VIDMODE_V_DISPLAY:
+	((DisplayModePtr)mode)->VDisplay = val;
+	break;
+    case VIDMODE_V_SYNCSTART:
+	((DisplayModePtr)mode)->VSyncStart = val;
+	break;
+    case VIDMODE_V_SYNCEND:
+	((DisplayModePtr)mode)->VSyncEnd = val;
+	break;
+    case VIDMODE_V_TOTAL:
+	((DisplayModePtr)mode)->VTotal = val;
+	break;
+    case VIDMODE_FLAGS:
+	((DisplayModePtr)mode)->Flags = val;
+	break;
+    case VIDMODE_CLOCK:
+	((DisplayModePtr)mode)->Clock = val;
+	break;
+  }
+  return;
+}
+
+vidMonitorValue
+VidModeGetMonitorValue(pointer monitor, int valtyp, int indx)
+{
+  vidMonitorValue ret = { NULL, };
+  
+  switch (valtyp) {
+    case VIDMODE_MON_VENDOR:
+	ret.ptr = (((MonPtr)monitor)->vendor);
+	break;
+    case VIDMODE_MON_MODEL:
+	ret.ptr = (((MonPtr)monitor)->model);
+	break;
+    case VIDMODE_MON_NHSYNC:
+	ret.i = ((MonPtr)monitor)->nHsync;
+	break;
+    case VIDMODE_MON_NVREFRESH:
+	ret.i = ((MonPtr)monitor)->nVrefresh;
+	break;
+    case VIDMODE_MON_HSYNC_LO:
+	ret.f = (100.0 * ((MonPtr)monitor)->hsync[indx].lo);
+	break;
+    case VIDMODE_MON_HSYNC_HI:
+	ret.f = (100.0 * ((MonPtr)monitor)->hsync[indx].hi);
+	break;
+    case VIDMODE_MON_VREFRESH_LO:
+	ret.f = (100.0 * ((MonPtr)monitor)->vrefresh[indx].lo);
+	break;
+    case VIDMODE_MON_VREFRESH_HI:
+	ret.f = (100.0 * ((MonPtr)monitor)->vrefresh[indx].hi);
+	break;
+  }
+  return ret;
+}
+
+
+#endif /* XF86VIDMODE */
diff --git a/xorg-server/hw/xfree86/common/xf86pciBus.c b/xorg-server/hw/xfree86/common/xf86pciBus.c
index bc09bd20c..87dc02512 100644
--- a/xorg-server/hw/xfree86/common/xf86pciBus.c
+++ b/xorg-server/hw/xfree86/common/xf86pciBus.c
@@ -49,6 +49,7 @@
 #define XF86_OS_PRIVS
 #include "xf86_OSproc.h"
 
+#define PCI_VENDOR_GENERIC		0x00FF
 
 /* Bus-specific globals */
 Bool pciSlotClaimed = FALSE;
diff --git a/xorg-server/hw/xfree86/doc/ddxDesign.xml b/xorg-server/hw/xfree86/doc/ddxDesign.xml
index 0d5e952a2..c406cd744 100644
--- a/xorg-server/hw/xfree86/doc/ddxDesign.xml
+++ b/xorg-server/hw/xfree86/doc/ddxDesign.xml
@@ -3553,13 +3553,6 @@ The following include files are typically required by video drivers:
 	  </para>
 
 	  <para>
-  Drivers that need to access PCI vendor/device definitions need this:
-	    <literallayout><filename>
-    "xf86PciInfo.h"
-	      </filename></literallayout>
-	  </para>
-
-	  <para>
   Drivers that need to access the PCI config space need this:
 	    <literallayout><filename>
     "xf86Pci.h"
diff --git a/xorg-server/hw/xfree86/dri2/dri2.c b/xorg-server/hw/xfree86/dri2/dri2.c
index a97508d21..0d613be8e 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.c
+++ b/xorg-server/hw/xfree86/dri2/dri2.c
@@ -816,7 +816,8 @@ DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable)
     /* If we're currently waiting for a swap on this drawable, reset
      * the request and suspend the client.  We only support one
      * blocked client per drawable. */
-    if ((pPriv->swapsPending) &&
+    if (pPriv &&
+	pPriv->swapsPending &&
 	pPriv->blockedClient == NULL) {
 	ResetCurrentRequest(client);
 	client->sequence--;
@@ -1234,14 +1235,24 @@ DRI2CloseScreen(ScreenPtr pScreen)
 }
 
 extern ExtensionModule dri2ExtensionModule;
+extern Bool DRI2ModuleSetup(void);
+
+/* Called by InitExtensions() */
+Bool
+DRI2ModuleSetup(void)
+{
+    dri2DrawableRes = CreateNewResourceType(DRI2DrawableGone, "DRI2Drawable");
+    if (!dri2DrawableRes)
+	return FALSE;
+
+    return TRUE;
+}
 
 static pointer
 DRI2Setup(pointer module, pointer opts, int *errmaj, int *errmin)
 {
     static Bool setupDone = FALSE;
 
-    dri2DrawableRes = CreateNewResourceType(DRI2DrawableGone, "DRI2Drawable");
-
     if (!setupDone)
     {
 	setupDone = TRUE;
diff --git a/xorg-server/hw/xfree86/dri2/dri2ext.c b/xorg-server/hw/xfree86/dri2/dri2ext.c
index 934abf6de..e612cf051 100644
--- a/xorg-server/hw/xfree86/dri2/dri2ext.c
+++ b/xorg-server/hw/xfree86/dri2/dri2ext.c
@@ -50,6 +50,7 @@
 #include "xf86Module.h"
 
 static ExtensionEntry	*dri2Extension;
+extern Bool DRI2ModuleSetup(void);
 
 static Bool
 validDrawable(ClientPtr client, XID drawable, Mask access_mode,
@@ -634,6 +635,8 @@ DRI2ExtensionInit(void)
 				 StandardMinorOpcode);
 
     DRI2EventBase = dri2Extension->eventBase;
+
+    DRI2ModuleSetup();
 }
 
 extern Bool noDRI2Extension;
diff --git a/xorg-server/hw/xfree86/fbdevhw/fbdevhw.c b/xorg-server/hw/xfree86/fbdevhw/fbdevhw.c
index dee731be4..30a2a9133 100644
--- a/xorg-server/hw/xfree86/fbdevhw/fbdevhw.c
+++ b/xorg-server/hw/xfree86/fbdevhw/fbdevhw.c
@@ -9,7 +9,6 @@
 #include "xf86_OSproc.h"
 
 /* pci stuff */
-#include "xf86PciInfo.h"
 #include "xf86Pci.h"
 
 #include "xf86cmap.h"
diff --git a/xorg-server/hw/xfree86/modes/xf86EdidModes.c b/xorg-server/hw/xfree86/modes/xf86EdidModes.c
index 9e0dc9d32..86065f869 100644
--- a/xorg-server/hw/xfree86/modes/xf86EdidModes.c
+++ b/xorg-server/hw/xfree86/modes/xf86EdidModes.c
@@ -1,1216 +1,1221 @@
-/*

- * Copyright 2006 Luc Verhaegen.

- * Copyright 2008 Red Hat, Inc.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sub license,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice (including the

- * next paragraph) shall be included in all copies or substantial portions

- * of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL

- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

- * DEALINGS IN THE SOFTWARE.

- */

-

-/**

- * @file This file covers code to convert a xf86MonPtr containing EDID-probed

- * information into a list of modes, including applying monitor-specific

- * quirks to fix broken EDID data.

- */

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#else

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#endif

-

-#define _PARSE_EDID_

-#include "xf86.h"

-#include "xf86DDC.h"

-#include <X11/Xatom.h>

-#include "property.h"

-#include "propertyst.h"

-#include "xf86Crtc.h"

-#include <string.h>

-#include <math.h>

-

-static void handle_detailed_rblank(struct detailed_monitor_section *det_mon,

-                                   void *data)

-{

-    if (det_mon->type == DS_RANGES)

-        if (det_mon->section.ranges.supported_blanking & CVT_REDUCED)

-            *(Bool*)data = TRUE;

-}

-

-static Bool

-xf86MonitorSupportsReducedBlanking(xf86MonPtr DDC)

-{

-    /* EDID 1.4 explicitly defines RB support */

-    if (DDC->ver.revision >= 4) {

-        Bool ret = FALSE;

-

-        xf86ForEachDetailedBlock(DDC, handle_detailed_rblank, &ret);

-        return ret;

-    }

-

-    /* For anything older, assume digital means RB support. Boo. */

-    if (DDC->features.input_type)

-        return TRUE;

-

-    return FALSE;

-}

-

-static Bool quirk_prefer_large_60 (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Belinea 10 15 55 */

-    if (memcmp (DDC->vendor.name, "MAX", 4) == 0 &&

-	((DDC->vendor.prod_id == 1516) ||

-	(DDC->vendor.prod_id == 0x77e)))

-	return TRUE;

-    

-    /* Acer AL1706 */

-    if (memcmp (DDC->vendor.name, "ACR", 4) == 0 &&

-	DDC->vendor.prod_id == 44358)

-	return TRUE;

-

-    /* Bug #10814: Samsung SyncMaster 225BW */

-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&

-	DDC->vendor.prod_id == 596)

-	return TRUE;

-

-    /* Bug #10545: Samsung SyncMaster 226BW */

-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&

-	DDC->vendor.prod_id == 638)

-	return TRUE;

-

-    /* Acer F51 */

-    if (memcmp (DDC->vendor.name, "API", 4) == 0 &&

-	DDC->vendor.prod_id == 0x7602)

-	return TRUE;

-

-

-    return FALSE;

-}

-

-static Bool quirk_prefer_large_75 (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Bug #11603: Funai Electronics PM36B */

-    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&

-	DDC->vendor.prod_id == 13600)

-	return TRUE;

-

-    return FALSE;

-}

-

-static Bool quirk_detailed_h_in_cm (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Bug #11603: Funai Electronics PM36B */

-    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&

-	DDC->vendor.prod_id == 13600)

-	return TRUE;

-

-    return FALSE;

-}

-

-static Bool quirk_detailed_v_in_cm (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Bug #11603: Funai Electronics PM36B */

-    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&

-	DDC->vendor.prod_id == 13600)

-	return TRUE;

-

-    /* Bug #21000: LGPhilipsLCD LP154W01-TLAJ */

-    if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&

-	DDC->vendor.prod_id == 47360)

-	return TRUE;

-

-    /* Bug #10304: LGPhilipsLCD LP154W01-A5 */

-    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 &&

-	DDC->vendor.prod_id == 0)

-	return TRUE;

-

-    /* Bug #24482: LGPhilipsLCD LP154W01-TLA1 */

-    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 &&

-	DDC->vendor.prod_id == 0x2a00)

-	return TRUE;

-

-    /* Bug #28414: HP Compaq NC8430 LP154W01-TLA8 */

-    if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&

-	DDC->vendor.prod_id == 5750)

-	return TRUE;

-

-    /* Bug #21750: Samsung Syncmaster 2333HD */

-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&

-	DDC->vendor.prod_id == 1157)

-	return TRUE;

-

-    return FALSE;

-}

-

-static Bool quirk_detailed_use_maximum_size (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Bug #21324: Iiyama Vision Master 450 */

-    if (memcmp (DDC->vendor.name, "IVM", 4) == 0 &&

-	DDC->vendor.prod_id == 6400)

-	return TRUE;

-

-    return FALSE;

-}

-

-static Bool quirk_135_clock_too_high (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Envision Peripherals, Inc. EN-7100e.  See bug #9550. */

-    if (memcmp (DDC->vendor.name, "EPI", 4) == 0 &&

-	DDC->vendor.prod_id == 59264)

-	return TRUE;

-    

-    return FALSE;

-}

-

-static Bool quirk_first_detailed_preferred (int scrnIndex, xf86MonPtr DDC)

-{

-    /* Philips 107p5 CRT. Reported on xorg@ with pastebin. */

-    if (memcmp (DDC->vendor.name, "PHL", 4) == 0 &&

-	DDC->vendor.prod_id == 57364)

-	return TRUE;

-

-    /* Proview AY765C 17" LCD. See bug #15160*/

-    if (memcmp (DDC->vendor.name, "PTS", 4) == 0 &&

-	DDC->vendor.prod_id == 765)

-	return TRUE;

-

-    /* ACR of some sort RH #284231 */

-    if (memcmp (DDC->vendor.name, "ACR", 4) == 0 &&

-	DDC->vendor.prod_id == 2423)

-	return TRUE;

-

-    /* Peacock Ergovision 19.  See rh#492359 */

-    if (memcmp (DDC->vendor.name, "PEA", 4) == 0 &&

-	DDC->vendor.prod_id == 9003)

-	return TRUE;

-

-    return FALSE;

-}

-

-static Bool quirk_detailed_sync_pp(int scrnIndex, xf86MonPtr DDC)

-{

-    /* Bug #12439: Samsung SyncMaster 205BW */

-    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&

-	DDC->vendor.prod_id == 541)

-	return TRUE;

-    return FALSE;

-}

-

-/* This should probably be made more generic */

-static Bool quirk_dvi_single_link(int scrnIndex, xf86MonPtr DDC)

-{

-    /* Red Hat bug #453106: Apple 23" Cinema Display */

-    if (memcmp (DDC->vendor.name, "APL", 4) == 0 &&

-	DDC->vendor.prod_id == 0x921c)

-	return TRUE;

-    return FALSE;

-}

-

-typedef struct {

-    Bool	(*detect) (int scrnIndex, xf86MonPtr DDC);

-    ddc_quirk_t	quirk;

-    char	*description;

-} ddc_quirk_map_t;

-

-static const ddc_quirk_map_t ddc_quirks[] = {

-    {

-	quirk_prefer_large_60,   DDC_QUIRK_PREFER_LARGE_60,

-	"Detailed timing is not preferred, use largest mode at 60Hz"

-    },

-    {

-	quirk_135_clock_too_high,   DDC_QUIRK_135_CLOCK_TOO_HIGH,

-	"Recommended 135MHz pixel clock is too high"

-    },

-    {

-	quirk_prefer_large_75,   DDC_QUIRK_PREFER_LARGE_75,

-	"Detailed timing is not preferred, use largest mode at 75Hz"

-    },

-    {

-	quirk_detailed_h_in_cm,   DDC_QUIRK_DETAILED_H_IN_CM,

-	"Detailed timings give horizontal size in cm."

-    },

-    {

-	quirk_detailed_v_in_cm,   DDC_QUIRK_DETAILED_V_IN_CM,

-	"Detailed timings give vertical size in cm."

-    },

-    {

-	quirk_detailed_use_maximum_size,   DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE,

-	"Use maximum size instead of detailed timing sizes."

-    },

-    {

-	quirk_first_detailed_preferred, DDC_QUIRK_FIRST_DETAILED_PREFERRED,

-	"First detailed timing was not marked as preferred."

-    },

-    {

-	quirk_detailed_sync_pp, DDC_QUIRK_DETAILED_SYNC_PP,

-	"Use +hsync +vsync for detailed timing."

-    },

-    {

-	quirk_dvi_single_link, DDC_QUIRK_DVI_SINGLE_LINK,

-	"Forcing maximum pixel clock to single DVI link."

-    },

-    { 

-	NULL,		DDC_QUIRK_NONE,

-	"No known quirks"

-    },

-};

-

-/*

- * These more or less come from the DMT spec.  The 720x400 modes are

- * inferred from historical 80x25 practice.  The 640x480@67 and 832x624@75

- * modes are old-school Mac modes.  The EDID spec says the 1152x864@75 mode

- * should be 1152x870, again for the Mac, but instead we use the x864 DMT

- * mode.

- *

- * The DMT modes have been fact-checked; the rest are mild guesses.

- */

-#define MODEPREFIX NULL, NULL, NULL, 0, M_T_DRIVER

-#define MODESUFFIX 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,FALSE,FALSE,0,NULL,0,0.0,0.0

-

-static const DisplayModeRec DDCEstablishedModes[17] = {

-    { MODEPREFIX,    40000,  800,  840,  968, 1056, 0,  600,  601,  605,  628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@60Hz */

-    { MODEPREFIX,    36000,  800,  824,  896, 1024, 0,  600,  601,  603,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@56Hz */

-    { MODEPREFIX,    31500,  640,  656,  720,  840, 0,  480,  481,  484,  500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@75Hz */

-    { MODEPREFIX,    31500,  640,  664,  704,  832, 0,  480,  489,  492,  520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@72Hz */

-    { MODEPREFIX,    30240,  640,  704,  768,  864, 0,  480,  483,  486,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@67Hz */

-    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@60Hz */

-    { MODEPREFIX,    35500,  720,  738,  846,  900, 0,  400,  421,  423,  449, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 720x400@88Hz */

-    { MODEPREFIX,    28320,  720,  738,  846,  900, 0,  400,  412,  414,  449, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@70Hz */

-    { MODEPREFIX,   135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@75Hz */

-    { MODEPREFIX,    78750, 1024, 1040, 1136, 1312, 0,  768,  769,  772,  800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@75Hz */

-    { MODEPREFIX,    75000, 1024, 1048, 1184, 1328, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@70Hz */

-    { MODEPREFIX,    65000, 1024, 1048, 1184, 1344, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@60Hz */

-    { MODEPREFIX,    44900, 1024, 1032, 1208, 1264, 0,  768,  768,  772,  817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* 1024x768@43Hz */

-    { MODEPREFIX,    57284,  832,  864,  928, 1152, 0,  624,  625,  628,  667, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 832x624@75Hz */

-    { MODEPREFIX,    49500,  800,  816,  896, 1056, 0,  600,  601,  604,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@75Hz */

-    { MODEPREFIX,    50000,  800,  856,  976, 1040, 0,  600,  637,  643,  666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@72Hz */

-    { MODEPREFIX,   108000, 1152, 1216, 1344, 1600, 0,  864,  865,  868,  900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1152x864@75Hz */

-};

-

-static DisplayModePtr

-DDCModesFromEstablished(int scrnIndex, struct established_timings *timing,

-			ddc_quirk_t quirks)

-{

-    DisplayModePtr Modes = NULL, Mode = NULL;

-    CARD32 bits = (timing->t1) | (timing->t2 << 8) |

-        ((timing->t_manu & 0x80) << 9);

-    int i;

-

-    for (i = 0; i < 17; i++) {

-        if (bits & (0x01 << i)) {

-            Mode = xf86DuplicateMode(&DDCEstablishedModes[i]);

-            Modes = xf86ModesAdd(Modes, Mode);

-        }

-    }

-

-    return Modes;

-}

-

-/* Autogenerated from the DMT spec */

-const DisplayModeRec DMTModes[] = {

-    { MODEPREFIX,    31500,  640,  672,  736,  832, 0,  350,  382,  385,  445, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x350@85Hz */

-    { MODEPREFIX,    31500,  640,  672,  736,  832, 0,  400,  401,  404,  445, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 640x400@85Hz */

-    { MODEPREFIX,    35500,  720,  756,  828,  936, 0,  400,  401,  404,  446, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@85Hz */

-    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@60Hz */

-    { MODEPREFIX,    31500,  640,  664,  704,  832, 0,  480,  489,  492,  520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@72Hz */

-    { MODEPREFIX,    31500,  640,  656,  720,  840, 0,  480,  481,  484,  500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@75Hz */

-    { MODEPREFIX,    36000,  640,  696,  752,  832, 0,  480,  481,  484,  509, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@85Hz */

-    { MODEPREFIX,    36000,  800,  824,  896, 1024, 0,  600,  601,  603,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@56Hz */

-    { MODEPREFIX,    40000,  800,  840,  968, 1056, 0,  600,  601,  605,  628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@60Hz */

-    { MODEPREFIX,    50000,  800,  856,  976, 1040, 0,  600,  637,  643,  666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@72Hz */

-    { MODEPREFIX,    49500,  800,  816,  896, 1056, 0,  600,  601,  604,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@75Hz */

-    { MODEPREFIX,    56250,  800,  832,  896, 1048, 0,  600,  601,  604,  631, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@85Hz */

-    { MODEPREFIX,    73250,  800,  848,  880,  960, 0,  600,  603,  607,  636, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 800x600@120Hz RB */

-    { MODEPREFIX,    33750,  848,  864,  976, 1088, 0,  480,  486,  494,  517, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 848x480@60Hz */

-    { MODEPREFIX,    44900, 1024, 1032, 1208, 1264, 0,  768,  768,  772,  817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* 1024x768@43Hz (interlaced) */

-    { MODEPREFIX,    65000, 1024, 1048, 1184, 1344, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@60Hz */

-    { MODEPREFIX,    75000, 1024, 1048, 1184, 1328, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@70Hz */

-    { MODEPREFIX,    78750, 1024, 1040, 1136, 1312, 0,  768,  769,  772,  800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@75Hz */

-    { MODEPREFIX,    94500, 1024, 1072, 1168, 1376, 0,  768,  769,  772,  808, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@85Hz */

-    { MODEPREFIX,   115500, 1024, 1072, 1104, 1184, 0,  768,  771,  775,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@120Hz RB */

-    { MODEPREFIX,   108000, 1152, 1216, 1344, 1600, 0,  864,  865,  868,  900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1152x864@75Hz */

-    { MODEPREFIX,    68250, 1280, 1328, 1360, 1440, 0,  768,  771,  778,  790, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x768@60Hz RB */

-    { MODEPREFIX,    79500, 1280, 1344, 1472, 1664, 0,  768,  771,  778,  798, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@60Hz */

-    { MODEPREFIX,   102250, 1280, 1360, 1488, 1696, 0,  768,  771,  778,  805, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@75Hz */

-    { MODEPREFIX,   117500, 1280, 1360, 1496, 1712, 0,  768,  771,  778,  809, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@85Hz */

-    { MODEPREFIX,   140250, 1280, 1328, 1360, 1440, 0,  768,  771,  778,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x768@120Hz RB */

-    { MODEPREFIX,    71000, 1280, 1328, 1360, 1440, 0,  800,  803,  809,  823, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x800@60Hz RB */

-    { MODEPREFIX,    83500, 1280, 1352, 1480, 1680, 0,  800,  803,  809,  831, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@60Hz */

-    { MODEPREFIX,   106500, 1280, 1360, 1488, 1696, 0,  800,  803,  809,  838, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@75Hz */

-    { MODEPREFIX,   122500, 1280, 1360, 1496, 1712, 0,  800,  803,  809,  843, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@85Hz */

-    { MODEPREFIX,   146250, 1280, 1328, 1360, 1440, 0,  800,  803,  809,  847, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x800@120Hz RB */

-    { MODEPREFIX,   108000, 1280, 1376, 1488, 1800, 0,  960,  961,  964, 1000, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x960@60Hz */

-    { MODEPREFIX,   148500, 1280, 1344, 1504, 1728, 0,  960,  961,  964, 1011, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x960@85Hz */

-    { MODEPREFIX,   175500, 1280, 1328, 1360, 1440, 0,  960,  963,  967, 1017, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x960@120Hz RB */

-    { MODEPREFIX,   108000, 1280, 1328, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@60Hz */

-    { MODEPREFIX,   135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@75Hz */

-    { MODEPREFIX,   157500, 1280, 1344, 1504, 1728, 0, 1024, 1025, 1028, 1072, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@85Hz */

-    { MODEPREFIX,   187250, 1280, 1328, 1360, 1440, 0, 1024, 1027, 1034, 1084, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x1024@120Hz RB */

-    { MODEPREFIX,    85500, 1360, 1424, 1536, 1792, 0,  768,  771,  777,  795, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1360x768@60Hz */

-    { MODEPREFIX,   148250, 1360, 1408, 1440, 1520, 0,  768,  771,  776,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1360x768@120Hz RB */

-    { MODEPREFIX,   101000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1400x1050@60Hz RB */

-    { MODEPREFIX,   121750, 1400, 1488, 1632, 1864, 0, 1050, 1053, 1057, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@60Hz */

-    { MODEPREFIX,   156000, 1400, 1504, 1648, 1896, 0, 1050, 1053, 1057, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@75Hz */

-    { MODEPREFIX,   179500, 1400, 1504, 1656, 1912, 0, 1050, 1053, 1057, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@85Hz */

-    { MODEPREFIX,   208000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1400x1050@120Hz RB */

-    { MODEPREFIX,    88750, 1440, 1488, 1520, 1600, 0,  900,  903,  909,  926, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1440x900@60Hz RB */

-    { MODEPREFIX,   106500, 1440, 1520, 1672, 1904, 0,  900,  903,  909,  934, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@60Hz */

-    { MODEPREFIX,   136750, 1440, 1536, 1688, 1936, 0,  900,  903,  909,  942, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@75Hz */

-    { MODEPREFIX,   157000, 1440, 1544, 1696, 1952, 0,  900,  903,  909,  948, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@85Hz */

-    { MODEPREFIX,   182750, 1440, 1488, 1520, 1600, 0,  900,  903,  909,  953, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1440x900@120Hz RB */

-    { MODEPREFIX,   162000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@60Hz */

-    { MODEPREFIX,   175500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@65Hz */

-    { MODEPREFIX,   189000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@70Hz */

-    { MODEPREFIX,   202500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@75Hz */

-    { MODEPREFIX,   229500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@85Hz */

-    { MODEPREFIX,   268250, 1600, 1648, 1680, 1760, 0, 1200, 1203, 1207, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1600x1200@120Hz RB */

-    { MODEPREFIX,   119000, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1680x1050@60Hz RB */

-    { MODEPREFIX,   146250, 1680, 1784, 1960, 2240, 0, 1050, 1053, 1059, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@60Hz */

-    { MODEPREFIX,   187000, 1680, 1800, 1976, 2272, 0, 1050, 1053, 1059, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@75Hz */

-    { MODEPREFIX,   214750, 1680, 1808, 1984, 2288, 0, 1050, 1053, 1059, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@85Hz */

-    { MODEPREFIX,   245500, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1680x1050@120Hz RB */

-    { MODEPREFIX,   204750, 1792, 1920, 2120, 2448, 0, 1344, 1345, 1348, 1394, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1792x1344@60Hz */

-    { MODEPREFIX,   261000, 1792, 1888, 2104, 2456, 0, 1344, 1345, 1348, 1417, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1792x1344@75Hz */

-    { MODEPREFIX,   333250, 1792, 1840, 1872, 1952, 0, 1344, 1347, 1351, 1423, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1792x1344@120Hz RB */

-    { MODEPREFIX,   218250, 1856, 1952, 2176, 2528, 0, 1392, 1393, 1396, 1439, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1856x1392@60Hz */

-    { MODEPREFIX,   288000, 1856, 1984, 2208, 2560, 0, 1392, 1393, 1396, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1856x1392@75Hz */

-    { MODEPREFIX,   356500, 1856, 1904, 1936, 2016, 0, 1392, 1395, 1399, 1474, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1856x1392@120Hz RB */

-    { MODEPREFIX,   154000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1235, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1200@60Hz RB */

-    { MODEPREFIX,   193250, 1920, 2056, 2256, 2592, 0, 1200, 1203, 1209, 1245, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@60Hz */

-    { MODEPREFIX,   245250, 1920, 2056, 2264, 2608, 0, 1200, 1203, 1209, 1255, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@75Hz */

-    { MODEPREFIX,   281250, 1920, 2064, 2272, 2624, 0, 1200, 1203, 1209, 1262, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@85Hz */

-    { MODEPREFIX,   317000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1200@120Hz RB */

-    { MODEPREFIX,   234000, 1920, 2048, 2256, 2600, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1440@60Hz */

-    { MODEPREFIX,   297000, 1920, 2064, 2288, 2640, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1440@75Hz */

-    { MODEPREFIX,   380500, 1920, 1968, 2000, 2080, 0, 1440, 1443, 1447, 1525, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1440@120Hz RB */

-    { MODEPREFIX,   268500, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1646, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 2560x1600@60Hz RB */

-    { MODEPREFIX,   348500, 2560, 2752, 3032, 3504, 0, 1600, 1603, 1609, 1658, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@60Hz */

-    { MODEPREFIX,   443250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1672, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@75Hz */

-    { MODEPREFIX,   505250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1682, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@85Hz */

-    { MODEPREFIX,   552750, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1694, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 2560x1600@120Hz RB */

-};

-

-#define LEVEL_DMT 0

-#define LEVEL_GTF 1

-#define LEVEL_CVT 2

-

-static int

-MonitorStandardTimingLevel(xf86MonPtr DDC)

-{

-    if (DDC->ver.revision >= 2) {

-	if (DDC->ver.revision >= 4 && CVT_SUPPORTED(DDC->features.msc)) {

-	    return LEVEL_CVT;

-	}

-	return LEVEL_GTF;

-    }

-    return LEVEL_DMT;

-}

-

-static int

-ModeRefresh(const DisplayModeRec *mode)

-{

-    return (int)(xf86ModeVRefresh(mode) + 0.5);

-}

-

-/*

- * If rb is not set, then we'll not consider reduced-blanking modes as

- * part of the DMT pool.  For the 'standard' EDID mode descriptor there's

- * no way to specify whether the mode should be RB or not.

- */

-DisplayModePtr

-FindDMTMode(int hsize, int vsize, int refresh, Bool rb)

-{

-    int i;

-    const DisplayModeRec *ret;

-

-    for (i = 0; i < sizeof(DMTModes) / sizeof(DisplayModeRec); i++) {

-	ret = &DMTModes[i];

-

-	if (!rb && xf86ModeIsReduced(ret))

-	    continue;

-

-	if (ret->HDisplay == hsize &&

-	    ret->VDisplay == vsize &&

-	    refresh == ModeRefresh(ret))

-	    return xf86DuplicateMode(ret);

-    }

-

-    return NULL;

-}

-

-/*

- * Appendix B of the EDID 1.4 spec defines the right thing to do here.

- * If the timing given here matches a mode defined in the VESA DMT standard,

- * we _must_ use that.  If the device supports CVT modes, then we should

- * generate a CVT timing.  If both of the above fail, use GTF.

- *

- * There are some wrinkles here.  EDID 1.1 and 1.0 sinks can't really

- * "support" GTF, since it wasn't a standard yet; so if they ask for a

- * timing in this section that isn't defined in DMT, returning a GTF mode

- * may not actually be valid.  EDID 1.3 sinks often report support for

- * some CVT modes, but they are not required to support CVT timings for

- * modes in the standard timing descriptor, so we should _not_ treat them

- * as CVT-compliant (unless specified in an extension block I suppose).

- *

- * EDID 1.4 requires that all sink devices support both GTF and CVT timings

- * for modes in this section, but does say that CVT is preferred.

- */

-static DisplayModePtr

-DDCModesFromStandardTiming(struct std_timings *timing, ddc_quirk_t quirks,

-			   int timing_level, Bool rb)

-{

-    DisplayModePtr Modes = NULL, Mode = NULL;

-    int i, hsize, vsize, refresh;

-

-    for (i = 0; i < STD_TIMINGS; i++) {

-	hsize = timing[i].hsize;

-	vsize = timing[i].vsize;

-	refresh = timing[i].refresh;

-

-	/* HDTV hack, because you can't say 1366 */

-	if (refresh == 60 &&

-	    ((hsize == 1360 && vsize == 765) ||

-	     (hsize == 1368 && vsize == 769))) {

-	    Mode = xf86CVTMode(1366, 768, 60, FALSE, FALSE);

-	    Mode->HDisplay = 1366;

-	    Mode->HSyncStart--;

-	    Mode->HSyncEnd--;

-	} else if (hsize && vsize && refresh) {

-	    Mode = FindDMTMode(hsize, vsize, refresh, rb);

-

-	    if (!Mode) {

-		if (timing_level == LEVEL_CVT)

-		    /* pass rb here too? */

-		    Mode = xf86CVTMode(hsize, vsize, refresh, FALSE, FALSE);

-		else if (timing_level == LEVEL_GTF)

-		    Mode = xf86GTFMode(hsize, vsize, refresh, FALSE, FALSE);

-	    }

-

-	}

-

-	if (Mode) {

-	    Mode->type = M_T_DRIVER;

-	    Modes = xf86ModesAdd(Modes, Mode);

-	}

-	Mode = NULL;

-    }

-

-    return Modes;

-}

-

-static void

-DDCModeDoInterlaceQuirks(DisplayModePtr mode)

-{

-    /*

-     * EDID is delightfully ambiguous about how interlaced modes are to be

-     * encoded.  X's internal representation is of frame height, but some

-     * HDTV detailed timings are encoded as field height.

-     *

-     * The format list here is from CEA, in frame size.  Technically we

-     * should be checking refresh rate too.  Whatever.

-     */

-    static const struct {

-	int w, h;

-    } cea_interlaced[] = {

-	{ 1920, 1080 },

-	{  720,  480 },

-	{ 1440,  480 },

-	{ 2880,  480 },

-	{  720,  576 },

-	{ 1440,  576 },

-	{ 2880,  576 },

-    };

-    static const int n_modes = sizeof(cea_interlaced)/sizeof(cea_interlaced[0]);

-    int i;

-

-    for (i = 0; i < n_modes; i++) {

-	if ((mode->HDisplay == cea_interlaced[i].w) &&

-	    (mode->VDisplay == cea_interlaced[i].h / 2)) {

-	    mode->VDisplay *= 2;

-	    mode->VSyncStart *= 2;

-	    mode->VSyncEnd *= 2;

-	    mode->VTotal *= 2;

-	    mode->VTotal |= 1;

-	}

-    }

-

-    mode->Flags |= V_INTERLACE;

-}

-

-/*

- *

- */

-static DisplayModePtr

-DDCModeFromDetailedTiming(int scrnIndex, struct detailed_timings *timing,

-			  Bool preferred, ddc_quirk_t quirks)

-{

-    DisplayModePtr Mode;

-

-    /*

-     * Refuse to create modes that are insufficiently large.  64 is a random

-     * number, maybe the spec says something about what the minimum is.  In

-     * particular I see this frequently with _old_ EDID, 1.0 or so, so maybe

-     * our parser is just being too aggresive there.

-     */

-    if (timing->h_active < 64 || timing->v_active < 64) {

-	xf86DrvMsg(scrnIndex, X_INFO,

-		   "%s: Ignoring tiny %dx%d mode\n", __func__,

-		   timing->h_active, timing->v_active);

-	return NULL;

-    }

-

-    /* We don't do stereo */

-    if (timing->stereo) {

-        xf86DrvMsg(scrnIndex, X_INFO,

-		   "%s: Ignoring: We don't handle stereo.\n", __func__);

-        return NULL;

-    }

-

-    /* We only do seperate sync currently */

-    if (timing->sync != 0x03) {

-         xf86DrvMsg(scrnIndex, X_INFO,

-		    "%s: %dx%d Warning: We only handle separate"

-                    " sync.\n", __func__, timing->h_active, timing->v_active);

-    }

-

-    Mode = xnfcalloc(1, sizeof(DisplayModeRec));

-

-    Mode->type = M_T_DRIVER;

-    if (preferred)

-	Mode->type |= M_T_PREFERRED;

-

-    if( ( quirks & DDC_QUIRK_135_CLOCK_TOO_HIGH ) &&

-	timing->clock == 135000000 )

-        Mode->Clock = 108880;

-    else

-        Mode->Clock = timing->clock / 1000.0;

-

-    Mode->HDisplay = timing->h_active;

-    Mode->HSyncStart = timing->h_active + timing->h_sync_off;

-    Mode->HSyncEnd = Mode->HSyncStart + timing->h_sync_width;

-    Mode->HTotal = timing->h_active + timing->h_blanking;

-

-    Mode->VDisplay = timing->v_active;

-    Mode->VSyncStart = timing->v_active + timing->v_sync_off;

-    Mode->VSyncEnd = Mode->VSyncStart + timing->v_sync_width;

-    Mode->VTotal = timing->v_active + timing->v_blanking;

-

-    /* perform basic check on the detail timing */

-    if (Mode->HSyncEnd > Mode->HTotal || Mode->VSyncEnd > Mode->VTotal) {

-	free(Mode);

-	return NULL;

-    }

-

-    /* We ignore h/v_size and h/v_border for now. */

-

-    if (timing->interlaced)

-	DDCModeDoInterlaceQuirks(Mode);

-

-    if (quirks & DDC_QUIRK_DETAILED_SYNC_PP)

-	Mode->Flags |= V_PVSYNC | V_PHSYNC;

-    else {

-	if (timing->misc & 0x02)

-	    Mode->Flags |= V_PVSYNC;

-	else

-	    Mode->Flags |= V_NVSYNC;

-

-	if (timing->misc & 0x01)

-	    Mode->Flags |= V_PHSYNC;

-	else

-	    Mode->Flags |= V_NHSYNC;

-    }

-

-    xf86SetModeDefaultName(Mode);

-

-    return Mode;

-}

-

-static DisplayModePtr

-DDCModesFromCVT(int scrnIndex, struct cvt_timings *t)

-{

-    DisplayModePtr modes = NULL;

-    int i;

-

-    for (i = 0; i < 4; i++) {

-	if (t[i].height) {

-	    if (t[i].rates & 0x10)

-		modes = xf86ModesAdd(modes,

-			xf86CVTMode(t[i].width, t[i].height, 50, 0, 0));

-	    if (t[i].rates & 0x08)

-		modes = xf86ModesAdd(modes,

-			xf86CVTMode(t[i].width, t[i].height, 60, 0, 0));

-	    if (t[i].rates & 0x04)

-		modes = xf86ModesAdd(modes,

-			xf86CVTMode(t[i].width, t[i].height, 75, 0, 0));

-	    if (t[i].rates & 0x02)

-		modes = xf86ModesAdd(modes,

-			xf86CVTMode(t[i].width, t[i].height, 85, 0, 0));

-	    if (t[i].rates & 0x01)

-		modes = xf86ModesAdd(modes,

-			xf86CVTMode(t[i].width, t[i].height, 60, 1, 0));

-	} else break;

-    }

-

-    return modes;

-}

-

-static const struct {

-    short w;

-    short h;

-    short r;

-    short rb;

-} EstIIIModes[] = {

-    /* byte 6 */

-    { 640, 350, 85, 0 },

-    { 640, 400, 85, 0 },

-    { 720, 400, 85, 0 },

-    { 640, 480, 85, 0 },

-    { 848, 480, 60, 0 },

-    { 800, 600, 85, 0 },

-    { 1024, 768, 85, 0 },

-    { 1152, 864, 75, 0 },

-    /* byte 7 */

-    { 1280, 768, 60, 1 },

-    { 1280, 768, 60, 0 },

-    { 1280, 768, 75, 0 },

-    { 1280, 768, 85, 0 },

-    { 1280, 960, 60, 0 },

-    { 1280, 960, 85, 0 },

-    { 1280, 1024, 60, 0 },

-    { 1280, 1024, 85, 0 },

-    /* byte 8 */

-    { 1360, 768, 60, 0 },

-    { 1440, 900, 60, 1 },

-    { 1440, 900, 60, 0 },

-    { 1440, 900, 75, 0 },

-    { 1440, 900, 85, 0 },

-    { 1400, 1050, 60, 1 },

-    { 1400, 1050, 60, 0 },

-    { 1400, 1050, 75, 0 },

-    /* byte 9 */

-    { 1400, 1050, 85, 0 },

-    { 1680, 1050, 60, 1 },

-    { 1680, 1050, 60, 0 },

-    { 1680, 1050, 75, 0 },

-    { 1680, 1050, 85, 0 },

-    { 1600, 1200, 60, 0 },

-    { 1600, 1200, 65, 0 },

-    { 1600, 1200, 70, 0 },

-    /* byte 10 */

-    { 1600, 1200, 75, 0 },

-    { 1600, 1200, 85, 0 },

-    { 1792, 1344, 60, 0 },

-    { 1792, 1344, 85, 0 },

-    { 1856, 1392, 60, 0 },

-    { 1856, 1392, 75, 0 },

-    { 1920, 1200, 60, 1 },

-    { 1920, 1200, 60, 0 },

-    /* byte 11 */

-    { 1920, 1200, 75, 0 },

-    { 1920, 1200, 85, 0 },

-    { 1920, 1440, 60, 0 },

-    { 1920, 1440, 75, 0 },

-};

-

-static DisplayModePtr

-DDCModesFromEstIII(unsigned char *est)

-{

-    DisplayModePtr modes = NULL;

-    int i, j, m;

-

-    for (i = 0; i < 6; i++) {

-	for (j = 7; j > 0; j--) {

-	    if (est[i] & (1 << j)) {

-		m = (i * 8) + (7 - j);

-		modes = xf86ModesAdd(modes,

-				     FindDMTMode(EstIIIModes[m].w,

-						 EstIIIModes[m].h,

-						 EstIIIModes[m].r,

-						 EstIIIModes[m].rb));

-	    }

-	}

-    }

-

-    return modes;

-}

-

-/*

- * This is only valid when the sink claims to be continuous-frequency

- * but does not supply a detailed range descriptor.  Such sinks are

- * arguably broken.  Currently the mode validation code isn't aware of

- * this; the non-RANDR code even punts the decision of optional sync

- * range checking to the driver.  Loss.

- */

-static void

-DDCGuessRangesFromModes(int scrnIndex, MonPtr Monitor, DisplayModePtr Modes)

-{

-    DisplayModePtr Mode = Modes;

-

-    if (!Monitor || !Modes)

-        return;

-

-    /* set up the ranges for scanning through the modes */

-    Monitor->nHsync = 1;

-    Monitor->hsync[0].lo = 1024.0;

-    Monitor->hsync[0].hi = 0.0;

-

-    Monitor->nVrefresh = 1;

-    Monitor->vrefresh[0].lo = 1024.0;

-    Monitor->vrefresh[0].hi = 0.0;

-

-    while (Mode) {

-        if (!Mode->HSync)

-            Mode->HSync = ((float) Mode->Clock ) / ((float) Mode->HTotal);

-

-        if (!Mode->VRefresh)

-            Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) / 

-                ((float) (Mode->HTotal * Mode->VTotal));

-

-        if (Mode->HSync < Monitor->hsync[0].lo)

-            Monitor->hsync[0].lo = Mode->HSync;

-

-        if (Mode->HSync > Monitor->hsync[0].hi)

-            Monitor->hsync[0].hi = Mode->HSync;

-

-        if (Mode->VRefresh < Monitor->vrefresh[0].lo)

-            Monitor->vrefresh[0].lo = Mode->VRefresh;

-

-        if (Mode->VRefresh > Monitor->vrefresh[0].hi)

-            Monitor->vrefresh[0].hi = Mode->VRefresh;

-

-        Mode = Mode->next;

-    }

-}

-

-ddc_quirk_t

-xf86DDCDetectQuirks(int scrnIndex, xf86MonPtr DDC, Bool verbose)

-{

-    ddc_quirk_t	quirks;

-    int i;

-

-    quirks = DDC_QUIRK_NONE;

-    for (i = 0; ddc_quirks[i].detect; i++) {

-	if (ddc_quirks[i].detect (scrnIndex, DDC)) {

-	    if (verbose) {

-		xf86DrvMsg (scrnIndex, X_INFO, "    EDID quirk: %s\n",

-			    ddc_quirks[i].description);

-	    }

-	    quirks |= ddc_quirks[i].quirk;

-	}

-    }

-

-    return quirks;

-}

-

-void xf86DetTimingApplyQuirks(struct detailed_monitor_section *det_mon,

-                              ddc_quirk_t quirks,

-                              int hsize, int vsize)

-{

-    if (det_mon->type != DT)

-        return;

-

-    if (quirks & DDC_QUIRK_DETAILED_H_IN_CM)

-        det_mon->section.d_timings.h_size *= 10;

-

-    if (quirks & DDC_QUIRK_DETAILED_V_IN_CM)

-        det_mon->section.d_timings.v_size *= 10;

-

-    if (quirks & DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {

-        det_mon->section.d_timings.h_size = 10 * hsize;

-        det_mon->section.d_timings.v_size = 10 * vsize;

-    }

-}

-

-/**

- * Applies monitor-specific quirks to the decoded EDID information.

- *

- * Note that some quirks applying to the mode list are still implemented in

- * xf86DDCGetModes.

- */

-void

-xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC)

-{

-    ddc_quirk_t quirks = xf86DDCDetectQuirks (scrnIndex, DDC, FALSE);

-    int i;

-

-    for (i = 0; i < DET_TIMINGS; i++) {

-        xf86DetTimingApplyQuirks(DDC->det_mon + i, quirks,

-                                 DDC->features.hsize,

-                                 DDC->features.vsize);

-    }

-}

-

-/**

- * Walks the modes list, finding the mode with the largest area which is

- * closest to the target refresh rate, and marks it as the only preferred mode.

-*/

-static void

-xf86DDCSetPreferredRefresh(int scrnIndex, DisplayModePtr modes,

-			   float target_refresh)

-{

-	DisplayModePtr	mode, best = modes;

-

-	for (mode = modes; mode; mode = mode->next)

-	{

-	    mode->type &= ~M_T_PREFERRED;

-

-	    if (mode == best) continue;

-

-	    if (mode->HDisplay * mode->VDisplay >

-		best->HDisplay * best->VDisplay)

-	    {

-		best = mode;

-		continue;

-	    }

-	    if (mode->HDisplay * mode->VDisplay ==

-		best->HDisplay * best->VDisplay)

-	    {

-		double	mode_refresh = xf86ModeVRefresh (mode);

-		double	best_refresh = xf86ModeVRefresh (best);

-		double	mode_dist = fabs(mode_refresh - target_refresh);

-		double	best_dist = fabs(best_refresh - target_refresh);

-

-		if (mode_dist < best_dist)

-		{

-		    best = mode;

-		    continue;

-		}

-	    }

-	}

-	if (best)

-	    best->type |= M_T_PREFERRED;

-}

-

-#define CEA_VIDEO_MODES_NUM  64

-static const DisplayModeRec CEAVideoModes[CEA_VIDEO_MODES_NUM] = {

-    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 1:640x480@60Hz */

-    { MODEPREFIX,    27000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 2:720x480@60Hz */

-    { MODEPREFIX,    27000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 3:720x480@60Hz */

-    { MODEPREFIX,    74250, 1280, 1390, 1430, 1650, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 4: 1280x720@60Hz */

-    { MODEPREFIX,    74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 5:1920x1080i@60Hz */

-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 6:1440x480i@60Hz */

-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 7:1440x480i@60Hz */

-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 8:1440x240@60Hz */

-    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 9:1440x240@60Hz */

-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 10:2880x480i@60Hz */

-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 11:2880x480i@60Hz */

-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 12:2880x240@60Hz */

-    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 13:2880x240@60Hz */

-    { MODEPREFIX,    54000, 1440, 1472, 1596, 1716, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 14:1440x480@60Hz */

-    { MODEPREFIX,    54000, 1440, 1472, 1596, 1716, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 15:1440x480@60Hz */

-    { MODEPREFIX,   148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 16:1920x1080@60Hz */

-    { MODEPREFIX,    27000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 17:720x576@50Hz */

-    { MODEPREFIX,    27000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 18:720x576@50Hz */

-    { MODEPREFIX,    74250, 1280, 1720, 1760, 1980, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 19: 1280x720@50Hz */

-    { MODEPREFIX,    74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 20:1920x1080i@50Hz */

-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 21:1440x576i@50Hz */

-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 22:1440x576i@50Hz */

-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 23:1440x288@50Hz */

-    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 24:1440x288@50Hz */

-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 25:2880x576i@50Hz */

-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 26:2880x576i@50Hz */

-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 27:2880x288@50Hz */

-    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 28:2880x288@50Hz */

-    { MODEPREFIX,    54000, 1440, 1464, 1592, 1728, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 29:1440x576@50Hz */

-    { MODEPREFIX,    54000, 1440, 1464, 1592, 1728, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 30:1440x576@50Hz */

-    { MODEPREFIX,   148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 31:1920x1080@50Hz */

-    { MODEPREFIX,    74250, 1920, 2558, 2602, 2750, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 32:1920x1080@24Hz */

-    { MODEPREFIX,    74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 33:1920x1080@25Hz */

-    { MODEPREFIX,    74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 34:1920x1080@30Hz */

-    { MODEPREFIX,   108000, 2880, 2944, 3192, 3432, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 35:2880x480@60Hz */

-    { MODEPREFIX,   108000, 2880, 2944, 3192, 3432, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 36:2880x480@60Hz */

-    { MODEPREFIX,   108000, 2880, 2928, 3184, 3456, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 37:2880x576@50Hz */

-    { MODEPREFIX,   108000, 2880, 2928, 3184, 3456, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 38:2880x576@50Hz */

-    { MODEPREFIX,    72000, 1920, 1952, 2120, 2304, 0, 1080, 1126, 1136, 1250, 0, V_PHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 39:1920x1080i@50Hz */

-    { MODEPREFIX,   148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 40:1920x1080i@100Hz */

-    { MODEPREFIX,   148500, 1280, 1720, 1760, 1980, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 41:1280x720@100Hz */

-    { MODEPREFIX,    54000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 42:720x576@100Hz */

-    { MODEPREFIX,    54000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 43:720x576@100Hz */

-    { MODEPREFIX,    54000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 44:1440x576i@100Hz */

-    { MODEPREFIX,    54000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 45:1440x576i@100Hz */

-    { MODEPREFIX,   148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 46:1920x1080i@120Hz */

-    { MODEPREFIX,   148500, 1280, 1390, 1430, 1650, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 47:1280x720@120Hz */

-    { MODEPREFIX,    54000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 48:720x480@120Hz */

-    { MODEPREFIX,    54000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 49:720x480@120Hz */

-    { MODEPREFIX,    54000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 50:1440x480i@120Hz */

-    { MODEPREFIX,    54000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 51:1440x480i@120Hz */

-    { MODEPREFIX,   108000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 52:720x576@200Hz */

-    { MODEPREFIX,   108000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 53:720x576@200Hz */

-    { MODEPREFIX,   108000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 54:1440x576i@200Hz */

-    { MODEPREFIX,   108000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 55:1440x576i@200Hz */

-    { MODEPREFIX,   108000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 56:720x480@240Hz */

-    { MODEPREFIX,   108000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 57:720x480@240Hz */

-    { MODEPREFIX,   108000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 58:1440x480i@240 */

-    { MODEPREFIX,   108000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 59:1440x480i@240 */

-    { MODEPREFIX,    59400, 1280, 3040, 3080, 3300, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 60: 1280x720@24Hz */

-    { MODEPREFIX,    74250, 1280, 3700, 3740, 3960, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 61: 1280x720@25Hz */

-    { MODEPREFIX,    74250, 1280, 3040, 3080, 3300, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 62: 1280x720@30Hz */

-    { MODEPREFIX,   297000, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 63: 1920x1080@120Hz */

-    { MODEPREFIX,   297000, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 64:1920x1080@100Hz */

-};

-

-/* chose mode line by cea short video descriptor*/

-static void handle_cea_svd(struct cea_video_block *video, void *data)

-{

-    DisplayModePtr Mode;

-    DisplayModePtr *Modes = (DisplayModePtr *) data;

-    int vid;

-

-    vid = video ->video_code & 0x7f;

-    if (vid < CEA_VIDEO_MODES_NUM) {

-	Mode = xf86DuplicateMode(CEAVideoModes + vid);

-	*Modes = xf86ModesAdd(*Modes, Mode);

-    }

-}

-

-static DisplayModePtr

-DDCModesFromCEAExtension(int scrnIndex, xf86MonPtr MonPtr)

-{

-    DisplayModePtr Modes = NULL;

-

-    xf86ForEachVideoBlock(MonPtr,

-                          handle_cea_svd,

-                          &Modes);

-

-    return Modes;

-}

-

-struct det_modes_parameter {

-    xf86MonPtr DDC;

-    ddc_quirk_t quirks;

-    DisplayModePtr  Modes;

-    Bool rb;

-    Bool preferred;

-    int timing_level;

-};

-

-static void handle_detailed_modes(struct detailed_monitor_section *det_mon,

-	                          void *data)

-{

-    DisplayModePtr  Mode;

-    struct det_modes_parameter *p = (struct det_modes_parameter *)data;

-

-    xf86DetTimingApplyQuirks(det_mon,p->quirks,

-                             p->DDC->features.hsize,

-                             p->DDC->features.vsize);

-

-    switch (det_mon->type) {

-    case DT:

-        Mode = DDCModeFromDetailedTiming(p->DDC->scrnIndex,

-                                         &det_mon->section.d_timings,

-                                         p->preferred,

-                                         p->quirks);

-        p->preferred = FALSE;

-        p->Modes = xf86ModesAdd(p->Modes, Mode);

-        break;

-    case DS_STD_TIMINGS:

-        Mode = DDCModesFromStandardTiming(det_mon->section.std_t,

-                                          p->quirks, p->timing_level,p->rb);

-        p->Modes = xf86ModesAdd(p->Modes, Mode);

-        break;

-    case DS_CVT:

-        Mode = DDCModesFromCVT(p->DDC->scrnIndex, det_mon->section.cvt);

-        p->Modes = xf86ModesAdd(p->Modes, Mode);

-        break;

-    case DS_EST_III:

-	Mode = DDCModesFromEstIII(det_mon->section.est_iii);

-	p->Modes = xf86ModesAdd(p->Modes, Mode);

-	break;

-    default:

-        break;

-    }

-}

-

-DisplayModePtr

-xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)

-{

-    DisplayModePtr  Modes = NULL, Mode;

-    ddc_quirk_t	    quirks;

-    Bool	    preferred, rb;

-    int		    timing_level;

-    struct det_modes_parameter p;

-

-    xf86DrvMsg (scrnIndex, X_INFO, "EDID vendor \"%s\", prod id %d\n",

-		DDC->vendor.name, DDC->vendor.prod_id);

-

-    quirks = xf86DDCDetectQuirks(scrnIndex, DDC, TRUE);

-

-    preferred = PREFERRED_TIMING_MODE(DDC->features.msc);

-    if (DDC->ver.revision >= 4)

-	preferred = TRUE;

-    if (quirks & DDC_QUIRK_FIRST_DETAILED_PREFERRED)

-	preferred = TRUE;

-    if (quirks & (DDC_QUIRK_PREFER_LARGE_60 | DDC_QUIRK_PREFER_LARGE_75))

-	preferred = FALSE;

-

-    rb = xf86MonitorSupportsReducedBlanking(DDC);

-

-    timing_level = MonitorStandardTimingLevel(DDC);

-

-    p.quirks = quirks;

-    p.DDC = DDC;

-    p.Modes = Modes;

-    p.rb = rb;

-    p.preferred = preferred;

-    p.timing_level = timing_level;

-    xf86ForEachDetailedBlock(DDC, handle_detailed_modes, &p);

-    Modes = p.Modes;

-

-    /* Add established timings */

-    Mode = DDCModesFromEstablished(scrnIndex, &DDC->timings1, quirks);

-    Modes = xf86ModesAdd(Modes, Mode);

-

-    /* Add standard timings */

-    Mode = DDCModesFromStandardTiming(DDC->timings2, quirks, timing_level, rb);

-    Modes = xf86ModesAdd(Modes, Mode);

-

-    /* Add cea-extension mode timings */

-    Mode = DDCModesFromCEAExtension(scrnIndex,DDC);

-    Modes = xf86ModesAdd(Modes, Mode);

-

-    if (quirks & DDC_QUIRK_PREFER_LARGE_60)

-	xf86DDCSetPreferredRefresh(scrnIndex, Modes, 60);

-

-    if (quirks & DDC_QUIRK_PREFER_LARGE_75)

-	xf86DDCSetPreferredRefresh(scrnIndex, Modes, 75);

-

-    Modes = xf86PruneDuplicateModes(Modes);

-

-    return Modes;

-}

-

-struct det_mon_parameter {

-    MonPtr Monitor;

-    ddc_quirk_t quirks;

-    Bool have_hsync;

-    Bool have_vrefresh;

-    Bool have_maxpixclock;

-};

-

-static void handle_detailed_monset(struct detailed_monitor_section *det_mon,

-                                   void *data)

-{

-    int clock;

-    struct det_mon_parameter *p = (struct det_mon_parameter *)data;

-    int scrnIndex = ((xf86MonPtr)(p->Monitor->DDC))->scrnIndex;

-

-    switch (det_mon->type) {

-    case DS_RANGES:

-        if (!p->have_hsync) {

-            if (!p->Monitor->nHsync)

-                xf86DrvMsg(scrnIndex, X_INFO,

-                    "Using EDID range info for horizontal sync\n");

-                p->Monitor->hsync[p->Monitor->nHsync].lo =

-                    det_mon->section.ranges.min_h;

-                p->Monitor->hsync[p->Monitor->nHsync].hi =

-                    det_mon->section.ranges.max_h;

-                p->Monitor->nHsync++;

-        } else {

-            xf86DrvMsg(scrnIndex, X_INFO,

-                "Using hsync ranges from config file\n");

-        }

-

-        if (!p->have_vrefresh) {

-            if (!p->Monitor->nVrefresh)

-                xf86DrvMsg(scrnIndex, X_INFO,

-                    "Using EDID range info for vertical refresh\n");

-            p->Monitor->vrefresh[p->Monitor->nVrefresh].lo =

-                det_mon->section.ranges.min_v;

-            p->Monitor->vrefresh[p->Monitor->nVrefresh].hi =

-                det_mon->section.ranges.max_v;

-            p->Monitor->nVrefresh++;

-        } else {

-            xf86DrvMsg(scrnIndex, X_INFO,

-                "Using vrefresh ranges from config file\n");

-        }

-

-        clock = det_mon->section.ranges.max_clock * 1000;

-        if (p->quirks & DDC_QUIRK_DVI_SINGLE_LINK)

-            clock = min(clock, 165000);

-        if (!p->have_maxpixclock && clock > p->Monitor->maxPixClock)

-            p->Monitor->maxPixClock = clock;

-

-        break;

-    default:

-        break;

-    }

-}

-

-/*

- * Fill out MonPtr with xf86MonPtr information.

- */

-void

-xf86EdidMonitorSet(int scrnIndex, MonPtr Monitor, xf86MonPtr DDC)

-{

-    DisplayModePtr Modes = NULL, Mode;

-    struct det_mon_parameter p;

-

-    if (!Monitor || !DDC)

-        return;

-

-    Monitor->DDC = DDC;

-

-    if (Monitor->widthmm <= 0 || Monitor->heightmm <= 0) {

-	Monitor->widthmm = 10 * DDC->features.hsize;

-	Monitor->heightmm = 10 * DDC->features.vsize;

-    }

-

-    Monitor->reducedblanking = xf86MonitorSupportsReducedBlanking(DDC);

-

-    Modes = xf86DDCGetModes(scrnIndex, DDC);

-

-    /* Go through the detailed monitor sections */

-    p.Monitor = Monitor;

-    p.quirks = xf86DDCDetectQuirks(scrnIndex, Monitor->DDC, FALSE);

-    p.have_hsync = (Monitor->nHsync != 0);

-    p.have_vrefresh = (Monitor->nVrefresh != 0);

-    p.have_maxpixclock = (Monitor->maxPixClock != 0);

-    xf86ForEachDetailedBlock(DDC, handle_detailed_monset, &p);

-

-    if (Modes) {

-        /* Print Modes */

-        xf86DrvMsg(scrnIndex, X_INFO, "Printing DDC gathered Modelines:\n");

-

-        Mode = Modes;

-        while (Mode) {

-            xf86PrintModeline(scrnIndex, Mode);

-            Mode = Mode->next;

-        }

-

-        /* Do we still need ranges to be filled in? */

-        if (!Monitor->nHsync || !Monitor->nVrefresh)

-            DDCGuessRangesFromModes(scrnIndex, Monitor, Modes);

-

-        /* look for last Mode */

-        Mode = Modes;

-

-        while (Mode->next)

-            Mode = Mode->next;

-

-        /* add to MonPtr */

-        if (Monitor->Modes) {

-            Monitor->Last->next = Modes;

-            Modes->prev = Monitor->Last;

-            Monitor->Last = Mode;

-        } else {

-            Monitor->Modes = Modes;

-            Monitor->Last = Mode;

-        }

-    }

-}

+/*
+ * Copyright 2006 Luc Verhaegen.
+ * Copyright 2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * @file This file covers code to convert a xf86MonPtr containing EDID-probed
+ * information into a list of modes, including applying monitor-specific
+ * quirks to fix broken EDID data.
+ */
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#else
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#endif
+
+#define _PARSE_EDID_
+#include "xf86.h"
+#include "xf86DDC.h"
+#include <X11/Xatom.h>
+#include "property.h"
+#include "propertyst.h"
+#include "xf86Crtc.h"
+#include <string.h>
+#include <math.h>
+
+static void handle_detailed_rblank(struct detailed_monitor_section *det_mon,
+                                   void *data)
+{
+    if (det_mon->type == DS_RANGES)
+        if (det_mon->section.ranges.supported_blanking & CVT_REDUCED)
+            *(Bool*)data = TRUE;
+}
+
+static Bool
+xf86MonitorSupportsReducedBlanking(xf86MonPtr DDC)
+{
+    /* EDID 1.4 explicitly defines RB support */
+    if (DDC->ver.revision >= 4) {
+        Bool ret = FALSE;
+
+        xf86ForEachDetailedBlock(DDC, handle_detailed_rblank, &ret);
+        return ret;
+    }
+
+    /* For anything older, assume digital means RB support. Boo. */
+    if (DDC->features.input_type)
+        return TRUE;
+
+    return FALSE;
+}
+
+static Bool quirk_prefer_large_60 (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Belinea 10 15 55 */
+    if (memcmp (DDC->vendor.name, "MAX", 4) == 0 &&
+	((DDC->vendor.prod_id == 1516) ||
+	(DDC->vendor.prod_id == 0x77e)))
+	return TRUE;
+    
+    /* Acer AL1706 */
+    if (memcmp (DDC->vendor.name, "ACR", 4) == 0 &&
+	DDC->vendor.prod_id == 44358)
+	return TRUE;
+
+    /* Bug #10814: Samsung SyncMaster 225BW */
+    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
+	DDC->vendor.prod_id == 596)
+	return TRUE;
+
+    /* Bug #10545: Samsung SyncMaster 226BW */
+    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
+	DDC->vendor.prod_id == 638)
+	return TRUE;
+
+    /* Acer F51 */
+    if (memcmp (DDC->vendor.name, "API", 4) == 0 &&
+	DDC->vendor.prod_id == 0x7602)
+	return TRUE;
+
+
+    return FALSE;
+}
+
+static Bool quirk_prefer_large_75 (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Bug #11603: Funai Electronics PM36B */
+    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
+	DDC->vendor.prod_id == 13600)
+	return TRUE;
+
+    return FALSE;
+}
+
+static Bool quirk_detailed_h_in_cm (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Bug #11603: Funai Electronics PM36B */
+    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
+	DDC->vendor.prod_id == 13600)
+	return TRUE;
+
+    return FALSE;
+}
+
+static Bool quirk_detailed_v_in_cm (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Bug #11603: Funai Electronics PM36B */
+    if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
+	DDC->vendor.prod_id == 13600)
+	return TRUE;
+
+    /* Bug #21000: LGPhilipsLCD LP154W01-TLAJ */
+    if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&
+	DDC->vendor.prod_id == 47360)
+	return TRUE;
+
+    /* Bug #10304: LGPhilipsLCD LP154W01-A5 */
+    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 &&
+	DDC->vendor.prod_id == 0)
+	return TRUE;
+
+    /* Bug #24482: LGPhilipsLCD LP154W01-TLA1 */
+    if (memcmp(DDC->vendor.name, "LPL", 4) == 0 &&
+	DDC->vendor.prod_id == 0x2a00)
+	return TRUE;
+
+    /* Bug #28414: HP Compaq NC8430 LP154W01-TLA8 */
+    if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&
+	DDC->vendor.prod_id == 5750)
+	return TRUE;
+
+    /* Bug #21750: Samsung Syncmaster 2333HD */
+    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
+	DDC->vendor.prod_id == 1157)
+	return TRUE;
+
+    return FALSE;
+}
+
+static Bool quirk_detailed_use_maximum_size (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Bug #21324: Iiyama Vision Master 450 */
+    if (memcmp (DDC->vendor.name, "IVM", 4) == 0 &&
+	DDC->vendor.prod_id == 6400)
+	return TRUE;
+
+    /* Bug #41141: Acer Aspire One */
+    if (memcmp (DDC->vendor.name, "LGD", 4) == 0 &&
+	DDC->vendor.prod_id == 0x7f01)
+	return TRUE;
+
+    return FALSE;
+}
+
+static Bool quirk_135_clock_too_high (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Envision Peripherals, Inc. EN-7100e.  See bug #9550. */
+    if (memcmp (DDC->vendor.name, "EPI", 4) == 0 &&
+	DDC->vendor.prod_id == 59264)
+	return TRUE;
+    
+    return FALSE;
+}
+
+static Bool quirk_first_detailed_preferred (int scrnIndex, xf86MonPtr DDC)
+{
+    /* Philips 107p5 CRT. Reported on xorg@ with pastebin. */
+    if (memcmp (DDC->vendor.name, "PHL", 4) == 0 &&
+	DDC->vendor.prod_id == 57364)
+	return TRUE;
+
+    /* Proview AY765C 17" LCD. See bug #15160*/
+    if (memcmp (DDC->vendor.name, "PTS", 4) == 0 &&
+	DDC->vendor.prod_id == 765)
+	return TRUE;
+
+    /* ACR of some sort RH #284231 */
+    if (memcmp (DDC->vendor.name, "ACR", 4) == 0 &&
+	DDC->vendor.prod_id == 2423)
+	return TRUE;
+
+    /* Peacock Ergovision 19.  See rh#492359 */
+    if (memcmp (DDC->vendor.name, "PEA", 4) == 0 &&
+	DDC->vendor.prod_id == 9003)
+	return TRUE;
+
+    return FALSE;
+}
+
+static Bool quirk_detailed_sync_pp(int scrnIndex, xf86MonPtr DDC)
+{
+    /* Bug #12439: Samsung SyncMaster 205BW */
+    if (memcmp (DDC->vendor.name, "SAM", 4) == 0 &&
+	DDC->vendor.prod_id == 541)
+	return TRUE;
+    return FALSE;
+}
+
+/* This should probably be made more generic */
+static Bool quirk_dvi_single_link(int scrnIndex, xf86MonPtr DDC)
+{
+    /* Red Hat bug #453106: Apple 23" Cinema Display */
+    if (memcmp (DDC->vendor.name, "APL", 4) == 0 &&
+	DDC->vendor.prod_id == 0x921c)
+	return TRUE;
+    return FALSE;
+}
+
+typedef struct {
+    Bool	(*detect) (int scrnIndex, xf86MonPtr DDC);
+    ddc_quirk_t	quirk;
+    char	*description;
+} ddc_quirk_map_t;
+
+static const ddc_quirk_map_t ddc_quirks[] = {
+    {
+	quirk_prefer_large_60,   DDC_QUIRK_PREFER_LARGE_60,
+	"Detailed timing is not preferred, use largest mode at 60Hz"
+    },
+    {
+	quirk_135_clock_too_high,   DDC_QUIRK_135_CLOCK_TOO_HIGH,
+	"Recommended 135MHz pixel clock is too high"
+    },
+    {
+	quirk_prefer_large_75,   DDC_QUIRK_PREFER_LARGE_75,
+	"Detailed timing is not preferred, use largest mode at 75Hz"
+    },
+    {
+	quirk_detailed_h_in_cm,   DDC_QUIRK_DETAILED_H_IN_CM,
+	"Detailed timings give horizontal size in cm."
+    },
+    {
+	quirk_detailed_v_in_cm,   DDC_QUIRK_DETAILED_V_IN_CM,
+	"Detailed timings give vertical size in cm."
+    },
+    {
+	quirk_detailed_use_maximum_size,   DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE,
+	"Use maximum size instead of detailed timing sizes."
+    },
+    {
+	quirk_first_detailed_preferred, DDC_QUIRK_FIRST_DETAILED_PREFERRED,
+	"First detailed timing was not marked as preferred."
+    },
+    {
+	quirk_detailed_sync_pp, DDC_QUIRK_DETAILED_SYNC_PP,
+	"Use +hsync +vsync for detailed timing."
+    },
+    {
+	quirk_dvi_single_link, DDC_QUIRK_DVI_SINGLE_LINK,
+	"Forcing maximum pixel clock to single DVI link."
+    },
+    { 
+	NULL,		DDC_QUIRK_NONE,
+	"No known quirks"
+    },
+};
+
+/*
+ * These more or less come from the DMT spec.  The 720x400 modes are
+ * inferred from historical 80x25 practice.  The 640x480@67 and 832x624@75
+ * modes are old-school Mac modes.  The EDID spec says the 1152x864@75 mode
+ * should be 1152x870, again for the Mac, but instead we use the x864 DMT
+ * mode.
+ *
+ * The DMT modes have been fact-checked; the rest are mild guesses.
+ */
+#define MODEPREFIX NULL, NULL, NULL, 0, M_T_DRIVER
+#define MODESUFFIX 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,FALSE,FALSE,0,NULL,0,0.0,0.0
+
+static const DisplayModeRec DDCEstablishedModes[17] = {
+    { MODEPREFIX,    40000,  800,  840,  968, 1056, 0,  600,  601,  605,  628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@60Hz */
+    { MODEPREFIX,    36000,  800,  824,  896, 1024, 0,  600,  601,  603,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@56Hz */
+    { MODEPREFIX,    31500,  640,  656,  720,  840, 0,  480,  481,  484,  500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@75Hz */
+    { MODEPREFIX,    31500,  640,  664,  704,  832, 0,  480,  489,  492,  520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@72Hz */
+    { MODEPREFIX,    30240,  640,  704,  768,  864, 0,  480,  483,  486,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@67Hz */
+    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@60Hz */
+    { MODEPREFIX,    35500,  720,  738,  846,  900, 0,  400,  421,  423,  449, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 720x400@88Hz */
+    { MODEPREFIX,    28320,  720,  738,  846,  900, 0,  400,  412,  414,  449, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@70Hz */
+    { MODEPREFIX,   135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@75Hz */
+    { MODEPREFIX,    78750, 1024, 1040, 1136, 1312, 0,  768,  769,  772,  800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@75Hz */
+    { MODEPREFIX,    75000, 1024, 1048, 1184, 1328, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@70Hz */
+    { MODEPREFIX,    65000, 1024, 1048, 1184, 1344, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@60Hz */
+    { MODEPREFIX,    44900, 1024, 1032, 1208, 1264, 0,  768,  768,  772,  817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* 1024x768@43Hz */
+    { MODEPREFIX,    57284,  832,  864,  928, 1152, 0,  624,  625,  628,  667, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 832x624@75Hz */
+    { MODEPREFIX,    49500,  800,  816,  896, 1056, 0,  600,  601,  604,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@75Hz */
+    { MODEPREFIX,    50000,  800,  856,  976, 1040, 0,  600,  637,  643,  666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@72Hz */
+    { MODEPREFIX,   108000, 1152, 1216, 1344, 1600, 0,  864,  865,  868,  900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1152x864@75Hz */
+};
+
+static DisplayModePtr
+DDCModesFromEstablished(int scrnIndex, struct established_timings *timing,
+			ddc_quirk_t quirks)
+{
+    DisplayModePtr Modes = NULL, Mode = NULL;
+    CARD32 bits = (timing->t1) | (timing->t2 << 8) |
+        ((timing->t_manu & 0x80) << 9);
+    int i;
+
+    for (i = 0; i < 17; i++) {
+        if (bits & (0x01 << i)) {
+            Mode = xf86DuplicateMode(&DDCEstablishedModes[i]);
+            Modes = xf86ModesAdd(Modes, Mode);
+        }
+    }
+
+    return Modes;
+}
+
+/* Autogenerated from the DMT spec */
+const DisplayModeRec DMTModes[] = {
+    { MODEPREFIX,    31500,  640,  672,  736,  832, 0,  350,  382,  385,  445, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x350@85Hz */
+    { MODEPREFIX,    31500,  640,  672,  736,  832, 0,  400,  401,  404,  445, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 640x400@85Hz */
+    { MODEPREFIX,    35500,  720,  756,  828,  936, 0,  400,  401,  404,  446, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 720x400@85Hz */
+    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@60Hz */
+    { MODEPREFIX,    31500,  640,  664,  704,  832, 0,  480,  489,  492,  520, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@72Hz */
+    { MODEPREFIX,    31500,  640,  656,  720,  840, 0,  480,  481,  484,  500, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@75Hz */
+    { MODEPREFIX,    36000,  640,  696,  752,  832, 0,  480,  481,  484,  509, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 640x480@85Hz */
+    { MODEPREFIX,    36000,  800,  824,  896, 1024, 0,  600,  601,  603,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@56Hz */
+    { MODEPREFIX,    40000,  800,  840,  968, 1056, 0,  600,  601,  605,  628, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@60Hz */
+    { MODEPREFIX,    50000,  800,  856,  976, 1040, 0,  600,  637,  643,  666, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@72Hz */
+    { MODEPREFIX,    49500,  800,  816,  896, 1056, 0,  600,  601,  604,  625, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@75Hz */
+    { MODEPREFIX,    56250,  800,  832,  896, 1048, 0,  600,  601,  604,  631, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 800x600@85Hz */
+    { MODEPREFIX,    73250,  800,  848,  880,  960, 0,  600,  603,  607,  636, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 800x600@120Hz RB */
+    { MODEPREFIX,    33750,  848,  864,  976, 1088, 0,  480,  486,  494,  517, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 848x480@60Hz */
+    { MODEPREFIX,    44900, 1024, 1032, 1208, 1264, 0,  768,  768,  772,  817, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* 1024x768@43Hz (interlaced) */
+    { MODEPREFIX,    65000, 1024, 1048, 1184, 1344, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@60Hz */
+    { MODEPREFIX,    75000, 1024, 1048, 1184, 1328, 0,  768,  771,  777,  806, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@70Hz */
+    { MODEPREFIX,    78750, 1024, 1040, 1136, 1312, 0,  768,  769,  772,  800, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@75Hz */
+    { MODEPREFIX,    94500, 1024, 1072, 1168, 1376, 0,  768,  769,  772,  808, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1024x768@85Hz */
+    { MODEPREFIX,   115500, 1024, 1072, 1104, 1184, 0,  768,  771,  775,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1024x768@120Hz RB */
+    { MODEPREFIX,   108000, 1152, 1216, 1344, 1600, 0,  864,  865,  868,  900, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1152x864@75Hz */
+    { MODEPREFIX,    68250, 1280, 1328, 1360, 1440, 0,  768,  771,  778,  790, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x768@60Hz RB */
+    { MODEPREFIX,    79500, 1280, 1344, 1472, 1664, 0,  768,  771,  778,  798, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@60Hz */
+    { MODEPREFIX,   102250, 1280, 1360, 1488, 1696, 0,  768,  771,  778,  805, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@75Hz */
+    { MODEPREFIX,   117500, 1280, 1360, 1496, 1712, 0,  768,  771,  778,  809, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x768@85Hz */
+    { MODEPREFIX,   140250, 1280, 1328, 1360, 1440, 0,  768,  771,  778,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x768@120Hz RB */
+    { MODEPREFIX,    71000, 1280, 1328, 1360, 1440, 0,  800,  803,  809,  823, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x800@60Hz RB */
+    { MODEPREFIX,    83500, 1280, 1352, 1480, 1680, 0,  800,  803,  809,  831, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@60Hz */
+    { MODEPREFIX,   106500, 1280, 1360, 1488, 1696, 0,  800,  803,  809,  838, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@75Hz */
+    { MODEPREFIX,   122500, 1280, 1360, 1496, 1712, 0,  800,  803,  809,  843, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x800@85Hz */
+    { MODEPREFIX,   146250, 1280, 1328, 1360, 1440, 0,  800,  803,  809,  847, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x800@120Hz RB */
+    { MODEPREFIX,   108000, 1280, 1376, 1488, 1800, 0,  960,  961,  964, 1000, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x960@60Hz */
+    { MODEPREFIX,   148500, 1280, 1344, 1504, 1728, 0,  960,  961,  964, 1011, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x960@85Hz */
+    { MODEPREFIX,   175500, 1280, 1328, 1360, 1440, 0,  960,  963,  967, 1017, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x960@120Hz RB */
+    { MODEPREFIX,   108000, 1280, 1328, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@60Hz */
+    { MODEPREFIX,   135000, 1280, 1296, 1440, 1688, 0, 1024, 1025, 1028, 1066, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@75Hz */
+    { MODEPREFIX,   157500, 1280, 1344, 1504, 1728, 0, 1024, 1025, 1028, 1072, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1280x1024@85Hz */
+    { MODEPREFIX,   187250, 1280, 1328, 1360, 1440, 0, 1024, 1027, 1034, 1084, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1280x1024@120Hz RB */
+    { MODEPREFIX,    85500, 1360, 1424, 1536, 1792, 0,  768,  771,  777,  795, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1360x768@60Hz */
+    { MODEPREFIX,   148250, 1360, 1408, 1440, 1520, 0,  768,  771,  776,  813, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1360x768@120Hz RB */
+    { MODEPREFIX,   101000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1400x1050@60Hz RB */
+    { MODEPREFIX,   121750, 1400, 1488, 1632, 1864, 0, 1050, 1053, 1057, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@60Hz */
+    { MODEPREFIX,   156000, 1400, 1504, 1648, 1896, 0, 1050, 1053, 1057, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@75Hz */
+    { MODEPREFIX,   179500, 1400, 1504, 1656, 1912, 0, 1050, 1053, 1057, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1400x1050@85Hz */
+    { MODEPREFIX,   208000, 1400, 1448, 1480, 1560, 0, 1050, 1053, 1057, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1400x1050@120Hz RB */
+    { MODEPREFIX,    88750, 1440, 1488, 1520, 1600, 0,  900,  903,  909,  926, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1440x900@60Hz RB */
+    { MODEPREFIX,   106500, 1440, 1520, 1672, 1904, 0,  900,  903,  909,  934, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@60Hz */
+    { MODEPREFIX,   136750, 1440, 1536, 1688, 1936, 0,  900,  903,  909,  942, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@75Hz */
+    { MODEPREFIX,   157000, 1440, 1544, 1696, 1952, 0,  900,  903,  909,  948, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1440x900@85Hz */
+    { MODEPREFIX,   182750, 1440, 1488, 1520, 1600, 0,  900,  903,  909,  953, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1440x900@120Hz RB */
+    { MODEPREFIX,   162000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@60Hz */
+    { MODEPREFIX,   175500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@65Hz */
+    { MODEPREFIX,   189000, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@70Hz */
+    { MODEPREFIX,   202500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@75Hz */
+    { MODEPREFIX,   229500, 1600, 1664, 1856, 2160, 0, 1200, 1201, 1204, 1250, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* 1600x1200@85Hz */
+    { MODEPREFIX,   268250, 1600, 1648, 1680, 1760, 0, 1200, 1203, 1207, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1600x1200@120Hz RB */
+    { MODEPREFIX,   119000, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1080, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1680x1050@60Hz RB */
+    { MODEPREFIX,   146250, 1680, 1784, 1960, 2240, 0, 1050, 1053, 1059, 1089, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@60Hz */
+    { MODEPREFIX,   187000, 1680, 1800, 1976, 2272, 0, 1050, 1053, 1059, 1099, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@75Hz */
+    { MODEPREFIX,   214750, 1680, 1808, 1984, 2288, 0, 1050, 1053, 1059, 1105, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1680x1050@85Hz */
+    { MODEPREFIX,   245500, 1680, 1728, 1760, 1840, 0, 1050, 1053, 1059, 1112, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1680x1050@120Hz RB */
+    { MODEPREFIX,   204750, 1792, 1920, 2120, 2448, 0, 1344, 1345, 1348, 1394, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1792x1344@60Hz */
+    { MODEPREFIX,   261000, 1792, 1888, 2104, 2456, 0, 1344, 1345, 1348, 1417, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1792x1344@75Hz */
+    { MODEPREFIX,   333250, 1792, 1840, 1872, 1952, 0, 1344, 1347, 1351, 1423, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1792x1344@120Hz RB */
+    { MODEPREFIX,   218250, 1856, 1952, 2176, 2528, 0, 1392, 1393, 1396, 1439, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1856x1392@60Hz */
+    { MODEPREFIX,   288000, 1856, 1984, 2208, 2560, 0, 1392, 1393, 1396, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1856x1392@75Hz */
+    { MODEPREFIX,   356500, 1856, 1904, 1936, 2016, 0, 1392, 1395, 1399, 1474, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1856x1392@120Hz RB */
+    { MODEPREFIX,   154000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1235, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1200@60Hz RB */
+    { MODEPREFIX,   193250, 1920, 2056, 2256, 2592, 0, 1200, 1203, 1209, 1245, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@60Hz */
+    { MODEPREFIX,   245250, 1920, 2056, 2264, 2608, 0, 1200, 1203, 1209, 1255, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@75Hz */
+    { MODEPREFIX,   281250, 1920, 2064, 2272, 2624, 0, 1200, 1203, 1209, 1262, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1200@85Hz */
+    { MODEPREFIX,   317000, 1920, 1968, 2000, 2080, 0, 1200, 1203, 1209, 1271, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1200@120Hz RB */
+    { MODEPREFIX,   234000, 1920, 2048, 2256, 2600, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1440@60Hz */
+    { MODEPREFIX,   297000, 1920, 2064, 2288, 2640, 0, 1440, 1441, 1444, 1500, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 1920x1440@75Hz */
+    { MODEPREFIX,   380500, 1920, 1968, 2000, 2080, 0, 1440, 1443, 1447, 1525, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 1920x1440@120Hz RB */
+    { MODEPREFIX,   268500, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1646, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 2560x1600@60Hz RB */
+    { MODEPREFIX,   348500, 2560, 2752, 3032, 3504, 0, 1600, 1603, 1609, 1658, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@60Hz */
+    { MODEPREFIX,   443250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1672, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@75Hz */
+    { MODEPREFIX,   505250, 2560, 2768, 3048, 3536, 0, 1600, 1603, 1609, 1682, 0, V_NHSYNC | V_PVSYNC, MODESUFFIX }, /* 2560x1600@85Hz */
+    { MODEPREFIX,   552750, 2560, 2608, 2640, 2720, 0, 1600, 1603, 1609, 1694, 0, V_PHSYNC | V_NVSYNC, MODESUFFIX }, /* 2560x1600@120Hz RB */
+};
+
+#define LEVEL_DMT 0
+#define LEVEL_GTF 1
+#define LEVEL_CVT 2
+
+static int
+MonitorStandardTimingLevel(xf86MonPtr DDC)
+{
+    if (DDC->ver.revision >= 2) {
+	if (DDC->ver.revision >= 4 && CVT_SUPPORTED(DDC->features.msc)) {
+	    return LEVEL_CVT;
+	}
+	return LEVEL_GTF;
+    }
+    return LEVEL_DMT;
+}
+
+static int
+ModeRefresh(const DisplayModeRec *mode)
+{
+    return (int)(xf86ModeVRefresh(mode) + 0.5);
+}
+
+/*
+ * If rb is not set, then we'll not consider reduced-blanking modes as
+ * part of the DMT pool.  For the 'standard' EDID mode descriptor there's
+ * no way to specify whether the mode should be RB or not.
+ */
+DisplayModePtr
+FindDMTMode(int hsize, int vsize, int refresh, Bool rb)
+{
+    int i;
+    const DisplayModeRec *ret;
+
+    for (i = 0; i < sizeof(DMTModes) / sizeof(DisplayModeRec); i++) {
+	ret = &DMTModes[i];
+
+	if (!rb && xf86ModeIsReduced(ret))
+	    continue;
+
+	if (ret->HDisplay == hsize &&
+	    ret->VDisplay == vsize &&
+	    refresh == ModeRefresh(ret))
+	    return xf86DuplicateMode(ret);
+    }
+
+    return NULL;
+}
+
+/*
+ * Appendix B of the EDID 1.4 spec defines the right thing to do here.
+ * If the timing given here matches a mode defined in the VESA DMT standard,
+ * we _must_ use that.  If the device supports CVT modes, then we should
+ * generate a CVT timing.  If both of the above fail, use GTF.
+ *
+ * There are some wrinkles here.  EDID 1.1 and 1.0 sinks can't really
+ * "support" GTF, since it wasn't a standard yet; so if they ask for a
+ * timing in this section that isn't defined in DMT, returning a GTF mode
+ * may not actually be valid.  EDID 1.3 sinks often report support for
+ * some CVT modes, but they are not required to support CVT timings for
+ * modes in the standard timing descriptor, so we should _not_ treat them
+ * as CVT-compliant (unless specified in an extension block I suppose).
+ *
+ * EDID 1.4 requires that all sink devices support both GTF and CVT timings
+ * for modes in this section, but does say that CVT is preferred.
+ */
+static DisplayModePtr
+DDCModesFromStandardTiming(struct std_timings *timing, ddc_quirk_t quirks,
+			   int timing_level, Bool rb)
+{
+    DisplayModePtr Modes = NULL, Mode = NULL;
+    int i, hsize, vsize, refresh;
+
+    for (i = 0; i < STD_TIMINGS; i++) {
+	hsize = timing[i].hsize;
+	vsize = timing[i].vsize;
+	refresh = timing[i].refresh;
+
+	/* HDTV hack, because you can't say 1366 */
+	if (refresh == 60 &&
+	    ((hsize == 1360 && vsize == 765) ||
+	     (hsize == 1368 && vsize == 769))) {
+	    Mode = xf86CVTMode(1366, 768, 60, FALSE, FALSE);
+	    Mode->HDisplay = 1366;
+	    Mode->HSyncStart--;
+	    Mode->HSyncEnd--;
+	} else if (hsize && vsize && refresh) {
+	    Mode = FindDMTMode(hsize, vsize, refresh, rb);
+
+	    if (!Mode) {
+		if (timing_level == LEVEL_CVT)
+		    /* pass rb here too? */
+		    Mode = xf86CVTMode(hsize, vsize, refresh, FALSE, FALSE);
+		else if (timing_level == LEVEL_GTF)
+		    Mode = xf86GTFMode(hsize, vsize, refresh, FALSE, FALSE);
+	    }
+
+	}
+
+	if (Mode) {
+	    Mode->type = M_T_DRIVER;
+	    Modes = xf86ModesAdd(Modes, Mode);
+	}
+	Mode = NULL;
+    }
+
+    return Modes;
+}
+
+static void
+DDCModeDoInterlaceQuirks(DisplayModePtr mode)
+{
+    /*
+     * EDID is delightfully ambiguous about how interlaced modes are to be
+     * encoded.  X's internal representation is of frame height, but some
+     * HDTV detailed timings are encoded as field height.
+     *
+     * The format list here is from CEA, in frame size.  Technically we
+     * should be checking refresh rate too.  Whatever.
+     */
+    static const struct {
+	int w, h;
+    } cea_interlaced[] = {
+	{ 1920, 1080 },
+	{  720,  480 },
+	{ 1440,  480 },
+	{ 2880,  480 },
+	{  720,  576 },
+	{ 1440,  576 },
+	{ 2880,  576 },
+    };
+    static const int n_modes = sizeof(cea_interlaced)/sizeof(cea_interlaced[0]);
+    int i;
+
+    for (i = 0; i < n_modes; i++) {
+	if ((mode->HDisplay == cea_interlaced[i].w) &&
+	    (mode->VDisplay == cea_interlaced[i].h / 2)) {
+	    mode->VDisplay *= 2;
+	    mode->VSyncStart *= 2;
+	    mode->VSyncEnd *= 2;
+	    mode->VTotal *= 2;
+	    mode->VTotal |= 1;
+	}
+    }
+
+    mode->Flags |= V_INTERLACE;
+}
+
+/*
+ *
+ */
+static DisplayModePtr
+DDCModeFromDetailedTiming(int scrnIndex, struct detailed_timings *timing,
+			  Bool preferred, ddc_quirk_t quirks)
+{
+    DisplayModePtr Mode;
+
+    /*
+     * Refuse to create modes that are insufficiently large.  64 is a random
+     * number, maybe the spec says something about what the minimum is.  In
+     * particular I see this frequently with _old_ EDID, 1.0 or so, so maybe
+     * our parser is just being too aggresive there.
+     */
+    if (timing->h_active < 64 || timing->v_active < 64) {
+	xf86DrvMsg(scrnIndex, X_INFO,
+		   "%s: Ignoring tiny %dx%d mode\n", __func__,
+		   timing->h_active, timing->v_active);
+	return NULL;
+    }
+
+    /* We don't do stereo */
+    if (timing->stereo) {
+        xf86DrvMsg(scrnIndex, X_INFO,
+		   "%s: Ignoring: We don't handle stereo.\n", __func__);
+        return NULL;
+    }
+
+    /* We only do seperate sync currently */
+    if (timing->sync != 0x03) {
+         xf86DrvMsg(scrnIndex, X_INFO,
+		    "%s: %dx%d Warning: We only handle separate"
+                    " sync.\n", __func__, timing->h_active, timing->v_active);
+    }
+
+    Mode = xnfcalloc(1, sizeof(DisplayModeRec));
+
+    Mode->type = M_T_DRIVER;
+    if (preferred)
+	Mode->type |= M_T_PREFERRED;
+
+    if( ( quirks & DDC_QUIRK_135_CLOCK_TOO_HIGH ) &&
+	timing->clock == 135000000 )
+        Mode->Clock = 108880;
+    else
+        Mode->Clock = timing->clock / 1000.0;
+
+    Mode->HDisplay = timing->h_active;
+    Mode->HSyncStart = timing->h_active + timing->h_sync_off;
+    Mode->HSyncEnd = Mode->HSyncStart + timing->h_sync_width;
+    Mode->HTotal = timing->h_active + timing->h_blanking;
+
+    Mode->VDisplay = timing->v_active;
+    Mode->VSyncStart = timing->v_active + timing->v_sync_off;
+    Mode->VSyncEnd = Mode->VSyncStart + timing->v_sync_width;
+    Mode->VTotal = timing->v_active + timing->v_blanking;
+
+    /* perform basic check on the detail timing */
+    if (Mode->HSyncEnd > Mode->HTotal || Mode->VSyncEnd > Mode->VTotal) {
+	free(Mode);
+	return NULL;
+    }
+
+    /* We ignore h/v_size and h/v_border for now. */
+
+    if (timing->interlaced)
+	DDCModeDoInterlaceQuirks(Mode);
+
+    if (quirks & DDC_QUIRK_DETAILED_SYNC_PP)
+	Mode->Flags |= V_PVSYNC | V_PHSYNC;
+    else {
+	if (timing->misc & 0x02)
+	    Mode->Flags |= V_PVSYNC;
+	else
+	    Mode->Flags |= V_NVSYNC;
+
+	if (timing->misc & 0x01)
+	    Mode->Flags |= V_PHSYNC;
+	else
+	    Mode->Flags |= V_NHSYNC;
+    }
+
+    xf86SetModeDefaultName(Mode);
+
+    return Mode;
+}
+
+static DisplayModePtr
+DDCModesFromCVT(int scrnIndex, struct cvt_timings *t)
+{
+    DisplayModePtr modes = NULL;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+	if (t[i].height) {
+	    if (t[i].rates & 0x10)
+		modes = xf86ModesAdd(modes,
+			xf86CVTMode(t[i].width, t[i].height, 50, 0, 0));
+	    if (t[i].rates & 0x08)
+		modes = xf86ModesAdd(modes,
+			xf86CVTMode(t[i].width, t[i].height, 60, 0, 0));
+	    if (t[i].rates & 0x04)
+		modes = xf86ModesAdd(modes,
+			xf86CVTMode(t[i].width, t[i].height, 75, 0, 0));
+	    if (t[i].rates & 0x02)
+		modes = xf86ModesAdd(modes,
+			xf86CVTMode(t[i].width, t[i].height, 85, 0, 0));
+	    if (t[i].rates & 0x01)
+		modes = xf86ModesAdd(modes,
+			xf86CVTMode(t[i].width, t[i].height, 60, 1, 0));
+	} else break;
+    }
+
+    return modes;
+}
+
+static const struct {
+    short w;
+    short h;
+    short r;
+    short rb;
+} EstIIIModes[] = {
+    /* byte 6 */
+    { 640, 350, 85, 0 },
+    { 640, 400, 85, 0 },
+    { 720, 400, 85, 0 },
+    { 640, 480, 85, 0 },
+    { 848, 480, 60, 0 },
+    { 800, 600, 85, 0 },
+    { 1024, 768, 85, 0 },
+    { 1152, 864, 75, 0 },
+    /* byte 7 */
+    { 1280, 768, 60, 1 },
+    { 1280, 768, 60, 0 },
+    { 1280, 768, 75, 0 },
+    { 1280, 768, 85, 0 },
+    { 1280, 960, 60, 0 },
+    { 1280, 960, 85, 0 },
+    { 1280, 1024, 60, 0 },
+    { 1280, 1024, 85, 0 },
+    /* byte 8 */
+    { 1360, 768, 60, 0 },
+    { 1440, 900, 60, 1 },
+    { 1440, 900, 60, 0 },
+    { 1440, 900, 75, 0 },
+    { 1440, 900, 85, 0 },
+    { 1400, 1050, 60, 1 },
+    { 1400, 1050, 60, 0 },
+    { 1400, 1050, 75, 0 },
+    /* byte 9 */
+    { 1400, 1050, 85, 0 },
+    { 1680, 1050, 60, 1 },
+    { 1680, 1050, 60, 0 },
+    { 1680, 1050, 75, 0 },
+    { 1680, 1050, 85, 0 },
+    { 1600, 1200, 60, 0 },
+    { 1600, 1200, 65, 0 },
+    { 1600, 1200, 70, 0 },
+    /* byte 10 */
+    { 1600, 1200, 75, 0 },
+    { 1600, 1200, 85, 0 },
+    { 1792, 1344, 60, 0 },
+    { 1792, 1344, 85, 0 },
+    { 1856, 1392, 60, 0 },
+    { 1856, 1392, 75, 0 },
+    { 1920, 1200, 60, 1 },
+    { 1920, 1200, 60, 0 },
+    /* byte 11 */
+    { 1920, 1200, 75, 0 },
+    { 1920, 1200, 85, 0 },
+    { 1920, 1440, 60, 0 },
+    { 1920, 1440, 75, 0 },
+};
+
+static DisplayModePtr
+DDCModesFromEstIII(unsigned char *est)
+{
+    DisplayModePtr modes = NULL;
+    int i, j, m;
+
+    for (i = 0; i < 6; i++) {
+	for (j = 7; j > 0; j--) {
+	    if (est[i] & (1 << j)) {
+		m = (i * 8) + (7 - j);
+		modes = xf86ModesAdd(modes,
+				     FindDMTMode(EstIIIModes[m].w,
+						 EstIIIModes[m].h,
+						 EstIIIModes[m].r,
+						 EstIIIModes[m].rb));
+	    }
+	}
+    }
+
+    return modes;
+}
+
+/*
+ * This is only valid when the sink claims to be continuous-frequency
+ * but does not supply a detailed range descriptor.  Such sinks are
+ * arguably broken.  Currently the mode validation code isn't aware of
+ * this; the non-RANDR code even punts the decision of optional sync
+ * range checking to the driver.  Loss.
+ */
+static void
+DDCGuessRangesFromModes(int scrnIndex, MonPtr Monitor, DisplayModePtr Modes)
+{
+    DisplayModePtr Mode = Modes;
+
+    if (!Monitor || !Modes)
+        return;
+
+    /* set up the ranges for scanning through the modes */
+    Monitor->nHsync = 1;
+    Monitor->hsync[0].lo = 1024.0;
+    Monitor->hsync[0].hi = 0.0;
+
+    Monitor->nVrefresh = 1;
+    Monitor->vrefresh[0].lo = 1024.0;
+    Monitor->vrefresh[0].hi = 0.0;
+
+    while (Mode) {
+        if (!Mode->HSync)
+            Mode->HSync = ((float) Mode->Clock ) / ((float) Mode->HTotal);
+
+        if (!Mode->VRefresh)
+            Mode->VRefresh = (1000.0 * ((float) Mode->Clock)) / 
+                ((float) (Mode->HTotal * Mode->VTotal));
+
+        if (Mode->HSync < Monitor->hsync[0].lo)
+            Monitor->hsync[0].lo = Mode->HSync;
+
+        if (Mode->HSync > Monitor->hsync[0].hi)
+            Monitor->hsync[0].hi = Mode->HSync;
+
+        if (Mode->VRefresh < Monitor->vrefresh[0].lo)
+            Monitor->vrefresh[0].lo = Mode->VRefresh;
+
+        if (Mode->VRefresh > Monitor->vrefresh[0].hi)
+            Monitor->vrefresh[0].hi = Mode->VRefresh;
+
+        Mode = Mode->next;
+    }
+}
+
+ddc_quirk_t
+xf86DDCDetectQuirks(int scrnIndex, xf86MonPtr DDC, Bool verbose)
+{
+    ddc_quirk_t	quirks;
+    int i;
+
+    quirks = DDC_QUIRK_NONE;
+    for (i = 0; ddc_quirks[i].detect; i++) {
+	if (ddc_quirks[i].detect (scrnIndex, DDC)) {
+	    if (verbose) {
+		xf86DrvMsg (scrnIndex, X_INFO, "    EDID quirk: %s\n",
+			    ddc_quirks[i].description);
+	    }
+	    quirks |= ddc_quirks[i].quirk;
+	}
+    }
+
+    return quirks;
+}
+
+void xf86DetTimingApplyQuirks(struct detailed_monitor_section *det_mon,
+                              ddc_quirk_t quirks,
+                              int hsize, int vsize)
+{
+    if (det_mon->type != DT)
+        return;
+
+    if (quirks & DDC_QUIRK_DETAILED_H_IN_CM)
+        det_mon->section.d_timings.h_size *= 10;
+
+    if (quirks & DDC_QUIRK_DETAILED_V_IN_CM)
+        det_mon->section.d_timings.v_size *= 10;
+
+    if (quirks & DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {
+        det_mon->section.d_timings.h_size = 10 * hsize;
+        det_mon->section.d_timings.v_size = 10 * vsize;
+    }
+}
+
+/**
+ * Applies monitor-specific quirks to the decoded EDID information.
+ *
+ * Note that some quirks applying to the mode list are still implemented in
+ * xf86DDCGetModes.
+ */
+void
+xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC)
+{
+    ddc_quirk_t quirks = xf86DDCDetectQuirks (scrnIndex, DDC, FALSE);
+    int i;
+
+    for (i = 0; i < DET_TIMINGS; i++) {
+        xf86DetTimingApplyQuirks(DDC->det_mon + i, quirks,
+                                 DDC->features.hsize,
+                                 DDC->features.vsize);
+    }
+}
+
+/**
+ * Walks the modes list, finding the mode with the largest area which is
+ * closest to the target refresh rate, and marks it as the only preferred mode.
+*/
+static void
+xf86DDCSetPreferredRefresh(int scrnIndex, DisplayModePtr modes,
+			   float target_refresh)
+{
+	DisplayModePtr	mode, best = modes;
+
+	for (mode = modes; mode; mode = mode->next)
+	{
+	    mode->type &= ~M_T_PREFERRED;
+
+	    if (mode == best) continue;
+
+	    if (mode->HDisplay * mode->VDisplay >
+		best->HDisplay * best->VDisplay)
+	    {
+		best = mode;
+		continue;
+	    }
+	    if (mode->HDisplay * mode->VDisplay ==
+		best->HDisplay * best->VDisplay)
+	    {
+		double	mode_refresh = xf86ModeVRefresh (mode);
+		double	best_refresh = xf86ModeVRefresh (best);
+		double	mode_dist = fabs(mode_refresh - target_refresh);
+		double	best_dist = fabs(best_refresh - target_refresh);
+
+		if (mode_dist < best_dist)
+		{
+		    best = mode;
+		    continue;
+		}
+	    }
+	}
+	if (best)
+	    best->type |= M_T_PREFERRED;
+}
+
+#define CEA_VIDEO_MODES_NUM  64
+static const DisplayModeRec CEAVideoModes[CEA_VIDEO_MODES_NUM] = {
+    { MODEPREFIX,    25175,  640,  656,  752,  800, 0,  480,  490,  492,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 1:640x480@60Hz */
+    { MODEPREFIX,    27000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 2:720x480@60Hz */
+    { MODEPREFIX,    27000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 3:720x480@60Hz */
+    { MODEPREFIX,    74250, 1280, 1390, 1430, 1650, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 4: 1280x720@60Hz */
+    { MODEPREFIX,    74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 5:1920x1080i@60Hz */
+    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 6:1440x480i@60Hz */
+    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 7:1440x480i@60Hz */
+    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 8:1440x240@60Hz */
+    { MODEPREFIX,    27000, 1440, 1478, 1602, 1716, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 9:1440x240@60Hz */
+    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 10:2880x480i@60Hz */
+    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 11:2880x480i@60Hz */
+    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 12:2880x240@60Hz */
+    { MODEPREFIX,    54000, 2880, 2956, 3204, 3432, 0,  240,  244,  247,  262, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 13:2880x240@60Hz */
+    { MODEPREFIX,    54000, 1440, 1472, 1596, 1716, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 14:1440x480@60Hz */
+    { MODEPREFIX,    54000, 1440, 1472, 1596, 1716, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 15:1440x480@60Hz */
+    { MODEPREFIX,   148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 16:1920x1080@60Hz */
+    { MODEPREFIX,    27000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 17:720x576@50Hz */
+    { MODEPREFIX,    27000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 18:720x576@50Hz */
+    { MODEPREFIX,    74250, 1280, 1720, 1760, 1980, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 19: 1280x720@50Hz */
+    { MODEPREFIX,    74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 20:1920x1080i@50Hz */
+    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 21:1440x576i@50Hz */
+    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 22:1440x576i@50Hz */
+    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 23:1440x288@50Hz */
+    { MODEPREFIX,    27000, 1440, 1464, 1590, 1728, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 24:1440x288@50Hz */
+    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 25:2880x576i@50Hz */
+    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 26:2880x576i@50Hz */
+    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 27:2880x288@50Hz */
+    { MODEPREFIX,    54000, 2880, 2928, 3180, 3456, 0,  288,  290,  293,  312, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 28:2880x288@50Hz */
+    { MODEPREFIX,    54000, 1440, 1464, 1592, 1728, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 29:1440x576@50Hz */
+    { MODEPREFIX,    54000, 1440, 1464, 1592, 1728, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 30:1440x576@50Hz */
+    { MODEPREFIX,   148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 31:1920x1080@50Hz */
+    { MODEPREFIX,    74250, 1920, 2558, 2602, 2750, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 32:1920x1080@24Hz */
+    { MODEPREFIX,    74250, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 33:1920x1080@25Hz */
+    { MODEPREFIX,    74250, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 34:1920x1080@30Hz */
+    { MODEPREFIX,   108000, 2880, 2944, 3192, 3432, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 35:2880x480@60Hz */
+    { MODEPREFIX,   108000, 2880, 2944, 3192, 3432, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 36:2880x480@60Hz */
+    { MODEPREFIX,   108000, 2880, 2928, 3184, 3456, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 37:2880x576@50Hz */
+    { MODEPREFIX,   108000, 2880, 2928, 3184, 3456, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 38:2880x576@50Hz */
+    { MODEPREFIX,    72000, 1920, 1952, 2120, 2304, 0, 1080, 1126, 1136, 1250, 0, V_PHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 39:1920x1080i@50Hz */
+    { MODEPREFIX,   148500, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 40:1920x1080i@100Hz */
+    { MODEPREFIX,   148500, 1280, 1720, 1760, 1980, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 41:1280x720@100Hz */
+    { MODEPREFIX,    54000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 42:720x576@100Hz */
+    { MODEPREFIX,    54000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 43:720x576@100Hz */
+    { MODEPREFIX,    54000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 44:1440x576i@100Hz */
+    { MODEPREFIX,    54000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 45:1440x576i@100Hz */
+    { MODEPREFIX,   148500, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC | V_INTERLACE, MODESUFFIX }, /* VIC 46:1920x1080i@120Hz */
+    { MODEPREFIX,   148500, 1280, 1390, 1430, 1650, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 47:1280x720@120Hz */
+    { MODEPREFIX,    54000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 48:720x480@120Hz */
+    { MODEPREFIX,    54000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 49:720x480@120Hz */
+    { MODEPREFIX,    54000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 50:1440x480i@120Hz */
+    { MODEPREFIX,    54000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 51:1440x480i@120Hz */
+    { MODEPREFIX,   108000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 52:720x576@200Hz */
+    { MODEPREFIX,   108000,  720,  732,  796,  864, 0,  576,  581,  586,  625, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 53:720x576@200Hz */
+    { MODEPREFIX,   108000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 54:1440x576i@200Hz */
+    { MODEPREFIX,   108000, 1440, 1464, 1590, 1728, 0,  576,  580,  586,  625, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 55:1440x576i@200Hz */
+    { MODEPREFIX,   108000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 56:720x480@240Hz */
+    { MODEPREFIX,   108000,  720,  736,  798,  858, 0,  480,  489,  495,  525, 0, V_NHSYNC | V_NVSYNC, MODESUFFIX }, /* VIC 57:720x480@240Hz */
+    { MODEPREFIX,   108000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 58:1440x480i@240 */
+    { MODEPREFIX,   108000, 1440, 1478, 1602, 1716, 0,  480,  488,  494,  525, 0, V_NHSYNC | V_NVSYNC | V_INTERLACE, MODESUFFIX },/* VIC 59:1440x480i@240 */
+    { MODEPREFIX,    59400, 1280, 3040, 3080, 3300, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 60: 1280x720@24Hz */
+    { MODEPREFIX,    74250, 1280, 3700, 3740, 3960, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 61: 1280x720@25Hz */
+    { MODEPREFIX,    74250, 1280, 3040, 3080, 3300, 0,  720,  725,  730,  750, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 62: 1280x720@30Hz */
+    { MODEPREFIX,   297000, 1920, 2008, 2052, 2200, 0, 1080, 1084, 1089, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 63: 1920x1080@120Hz */
+    { MODEPREFIX,   297000, 1920, 2448, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0, V_PHSYNC | V_PVSYNC, MODESUFFIX }, /* VIC 64:1920x1080@100Hz */
+};
+
+/* chose mode line by cea short video descriptor*/
+static void handle_cea_svd(struct cea_video_block *video, void *data)
+{
+    DisplayModePtr Mode;
+    DisplayModePtr *Modes = (DisplayModePtr *) data;
+    int vid;
+
+    vid = video ->video_code & 0x7f;
+    if (vid < CEA_VIDEO_MODES_NUM) {
+	Mode = xf86DuplicateMode(CEAVideoModes + vid);
+	*Modes = xf86ModesAdd(*Modes, Mode);
+    }
+}
+
+static DisplayModePtr
+DDCModesFromCEAExtension(int scrnIndex, xf86MonPtr MonPtr)
+{
+    DisplayModePtr Modes = NULL;
+
+    xf86ForEachVideoBlock(MonPtr,
+                          handle_cea_svd,
+                          &Modes);
+
+    return Modes;
+}
+
+struct det_modes_parameter {
+    xf86MonPtr DDC;
+    ddc_quirk_t quirks;
+    DisplayModePtr  Modes;
+    Bool rb;
+    Bool preferred;
+    int timing_level;
+};
+
+static void handle_detailed_modes(struct detailed_monitor_section *det_mon,
+	                          void *data)
+{
+    DisplayModePtr  Mode;
+    struct det_modes_parameter *p = (struct det_modes_parameter *)data;
+
+    xf86DetTimingApplyQuirks(det_mon,p->quirks,
+                             p->DDC->features.hsize,
+                             p->DDC->features.vsize);
+
+    switch (det_mon->type) {
+    case DT:
+        Mode = DDCModeFromDetailedTiming(p->DDC->scrnIndex,
+                                         &det_mon->section.d_timings,
+                                         p->preferred,
+                                         p->quirks);
+        p->preferred = FALSE;
+        p->Modes = xf86ModesAdd(p->Modes, Mode);
+        break;
+    case DS_STD_TIMINGS:
+        Mode = DDCModesFromStandardTiming(det_mon->section.std_t,
+                                          p->quirks, p->timing_level,p->rb);
+        p->Modes = xf86ModesAdd(p->Modes, Mode);
+        break;
+    case DS_CVT:
+        Mode = DDCModesFromCVT(p->DDC->scrnIndex, det_mon->section.cvt);
+        p->Modes = xf86ModesAdd(p->Modes, Mode);
+        break;
+    case DS_EST_III:
+	Mode = DDCModesFromEstIII(det_mon->section.est_iii);
+	p->Modes = xf86ModesAdd(p->Modes, Mode);
+	break;
+    default:
+        break;
+    }
+}
+
+DisplayModePtr
+xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)
+{
+    DisplayModePtr  Modes = NULL, Mode;
+    ddc_quirk_t	    quirks;
+    Bool	    preferred, rb;
+    int		    timing_level;
+    struct det_modes_parameter p;
+
+    xf86DrvMsg (scrnIndex, X_INFO, "EDID vendor \"%s\", prod id %d\n",
+		DDC->vendor.name, DDC->vendor.prod_id);
+
+    quirks = xf86DDCDetectQuirks(scrnIndex, DDC, TRUE);
+
+    preferred = PREFERRED_TIMING_MODE(DDC->features.msc);
+    if (DDC->ver.revision >= 4)
+	preferred = TRUE;
+    if (quirks & DDC_QUIRK_FIRST_DETAILED_PREFERRED)
+	preferred = TRUE;
+    if (quirks & (DDC_QUIRK_PREFER_LARGE_60 | DDC_QUIRK_PREFER_LARGE_75))
+	preferred = FALSE;
+
+    rb = xf86MonitorSupportsReducedBlanking(DDC);
+
+    timing_level = MonitorStandardTimingLevel(DDC);
+
+    p.quirks = quirks;
+    p.DDC = DDC;
+    p.Modes = Modes;
+    p.rb = rb;
+    p.preferred = preferred;
+    p.timing_level = timing_level;
+    xf86ForEachDetailedBlock(DDC, handle_detailed_modes, &p);
+    Modes = p.Modes;
+
+    /* Add established timings */
+    Mode = DDCModesFromEstablished(scrnIndex, &DDC->timings1, quirks);
+    Modes = xf86ModesAdd(Modes, Mode);
+
+    /* Add standard timings */
+    Mode = DDCModesFromStandardTiming(DDC->timings2, quirks, timing_level, rb);
+    Modes = xf86ModesAdd(Modes, Mode);
+
+    /* Add cea-extension mode timings */
+    Mode = DDCModesFromCEAExtension(scrnIndex,DDC);
+    Modes = xf86ModesAdd(Modes, Mode);
+
+    if (quirks & DDC_QUIRK_PREFER_LARGE_60)
+	xf86DDCSetPreferredRefresh(scrnIndex, Modes, 60);
+
+    if (quirks & DDC_QUIRK_PREFER_LARGE_75)
+	xf86DDCSetPreferredRefresh(scrnIndex, Modes, 75);
+
+    Modes = xf86PruneDuplicateModes(Modes);
+
+    return Modes;
+}
+
+struct det_mon_parameter {
+    MonPtr Monitor;
+    ddc_quirk_t quirks;
+    Bool have_hsync;
+    Bool have_vrefresh;
+    Bool have_maxpixclock;
+};
+
+static void handle_detailed_monset(struct detailed_monitor_section *det_mon,
+                                   void *data)
+{
+    int clock;
+    struct det_mon_parameter *p = (struct det_mon_parameter *)data;
+    int scrnIndex = ((xf86MonPtr)(p->Monitor->DDC))->scrnIndex;
+
+    switch (det_mon->type) {
+    case DS_RANGES:
+        if (!p->have_hsync) {
+            if (!p->Monitor->nHsync)
+                xf86DrvMsg(scrnIndex, X_INFO,
+                    "Using EDID range info for horizontal sync\n");
+                p->Monitor->hsync[p->Monitor->nHsync].lo =
+                    det_mon->section.ranges.min_h;
+                p->Monitor->hsync[p->Monitor->nHsync].hi =
+                    det_mon->section.ranges.max_h;
+                p->Monitor->nHsync++;
+        } else {
+            xf86DrvMsg(scrnIndex, X_INFO,
+                "Using hsync ranges from config file\n");
+        }
+
+        if (!p->have_vrefresh) {
+            if (!p->Monitor->nVrefresh)
+                xf86DrvMsg(scrnIndex, X_INFO,
+                    "Using EDID range info for vertical refresh\n");
+            p->Monitor->vrefresh[p->Monitor->nVrefresh].lo =
+                det_mon->section.ranges.min_v;
+            p->Monitor->vrefresh[p->Monitor->nVrefresh].hi =
+                det_mon->section.ranges.max_v;
+            p->Monitor->nVrefresh++;
+        } else {
+            xf86DrvMsg(scrnIndex, X_INFO,
+                "Using vrefresh ranges from config file\n");
+        }
+
+        clock = det_mon->section.ranges.max_clock * 1000;
+        if (p->quirks & DDC_QUIRK_DVI_SINGLE_LINK)
+            clock = min(clock, 165000);
+        if (!p->have_maxpixclock && clock > p->Monitor->maxPixClock)
+            p->Monitor->maxPixClock = clock;
+
+        break;
+    default:
+        break;
+    }
+}
+
+/*
+ * Fill out MonPtr with xf86MonPtr information.
+ */
+void
+xf86EdidMonitorSet(int scrnIndex, MonPtr Monitor, xf86MonPtr DDC)
+{
+    DisplayModePtr Modes = NULL, Mode;
+    struct det_mon_parameter p;
+
+    if (!Monitor || !DDC)
+        return;
+
+    Monitor->DDC = DDC;
+
+    if (Monitor->widthmm <= 0 || Monitor->heightmm <= 0) {
+	Monitor->widthmm = 10 * DDC->features.hsize;
+	Monitor->heightmm = 10 * DDC->features.vsize;
+    }
+
+    Monitor->reducedblanking = xf86MonitorSupportsReducedBlanking(DDC);
+
+    Modes = xf86DDCGetModes(scrnIndex, DDC);
+
+    /* Go through the detailed monitor sections */
+    p.Monitor = Monitor;
+    p.quirks = xf86DDCDetectQuirks(scrnIndex, Monitor->DDC, FALSE);
+    p.have_hsync = (Monitor->nHsync != 0);
+    p.have_vrefresh = (Monitor->nVrefresh != 0);
+    p.have_maxpixclock = (Monitor->maxPixClock != 0);
+    xf86ForEachDetailedBlock(DDC, handle_detailed_monset, &p);
+
+    if (Modes) {
+        /* Print Modes */
+        xf86DrvMsg(scrnIndex, X_INFO, "Printing DDC gathered Modelines:\n");
+
+        Mode = Modes;
+        while (Mode) {
+            xf86PrintModeline(scrnIndex, Mode);
+            Mode = Mode->next;
+        }
+
+        /* Do we still need ranges to be filled in? */
+        if (!Monitor->nHsync || !Monitor->nVrefresh)
+            DDCGuessRangesFromModes(scrnIndex, Monitor, Modes);
+
+        /* look for last Mode */
+        Mode = Modes;
+
+        while (Mode->next)
+            Mode = Mode->next;
+
+        /* add to MonPtr */
+        if (Monitor->Modes) {
+            Monitor->Last->next = Modes;
+            Modes->prev = Monitor->Last;
+            Monitor->Last = Mode;
+        } else {
+            Monitor->Modes = Modes;
+            Monitor->Last = Mode;
+        }
+    }
+}
diff --git a/xorg-server/hw/xfree86/os-support/bus/Pci.h b/xorg-server/hw/xfree86/os-support/bus/Pci.h
index 88560ecdc..5709bd841 100644
--- a/xorg-server/hw/xfree86/os-support/bus/Pci.h
+++ b/xorg-server/hw/xfree86/os-support/bus/Pci.h
@@ -108,7 +108,6 @@
 #define _PCI_H 1
 
 #include "xf86Pci.h"
-#include "xf86PciInfo.h"
 
 /*
  * Global Definitions
diff --git a/xorg-server/hw/xfree86/os-support/linux/lnx_video.c b/xorg-server/hw/xfree86/os-support/linux/lnx_video.c
index e711784e7..0d91f7a52 100644
--- a/xorg-server/hw/xfree86/os-support/linux/lnx_video.c
+++ b/xorg-server/hw/xfree86/os-support/linux/lnx_video.c
@@ -465,11 +465,11 @@ mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
 static void
 unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
 {
-    memType alignOff = (memType)Base 
-	- ((memType)Base & ~(getpagesize() - 1));
+    uintptr_t alignOff = (uintptr_t)Base
+	- ((uintptr_t)Base & ~(getpagesize() - 1));
 
-    DebugF("alignment offset: %lx\n",alignOff);
-    munmap((caddr_t)((memType)Base - alignOff), (Size + alignOff));
+    DebugF("alignment offset: %lx\n", (unsigned long)alignOff);
+    munmap((void *)((uintptr_t)Base - alignOff), (Size + alignOff));
 }
 
 
diff --git a/xorg-server/hw/xfree86/sdksyms.sh b/xorg-server/hw/xfree86/sdksyms.sh
index b8e7023f3..4a4e1f64d 100644
--- a/xorg-server/hw/xfree86/sdksyms.sh
+++ b/xorg-server/hw/xfree86/sdksyms.sh
@@ -121,7 +121,6 @@ cat > sdksyms.c << EOF
 #include "xf86Module.h"
 #include "xf86Opt.h"
 #ifdef XSERVER_LIBPCIACCESS
- #include "xf86PciInfo.h"
  #include "xf86VGAarbiter.h"
 #endif
 #include "xf86Priv.h"
diff --git a/xorg-server/include/Makefile.am b/xorg-server/include/Makefile.am
index 6f63c764f..972f403ce 100644
--- a/xorg-server/include/Makefile.am
+++ b/xorg-server/include/Makefile.am
@@ -32,6 +32,7 @@ sdk_HEADERS =		\
 	misc.h		\
 	miscstruct.h	\
 	opaque.h	\
+	optionstr.h	\
 	os.h		\
 	pixmap.h	\
 	pixmapstr.h	\
diff --git a/xorg-server/include/os.h b/xorg-server/include/os.h
index 642caeb99..cddf30ca8 100644
--- a/xorg-server/include/os.h
+++ b/xorg-server/include/os.h
@@ -453,9 +453,10 @@ extern _X_EXPORT CallbackListPtr ReplyCallback;
 typedef struct {
     ClientPtr client;
     const void *replyData;
-    unsigned long dataLenBytes;
+    unsigned long dataLenBytes; /* actual bytes from replyData + pad bytes */
     unsigned long bytesRemaining;
     Bool startOfReply;
+    unsigned long padBytes;     /* pad bytes from zeroed array */
 } ReplyInfoRec;
 
 /* stuff for FlushCallback */
diff --git a/xorg-server/miext/rootless/rootlessScreen.c b/xorg-server/miext/rootless/rootlessScreen.c
index 0801e7206..c8557066e 100644
--- a/xorg-server/miext/rootless/rootlessScreen.c
+++ b/xorg-server/miext/rootless/rootlessScreen.c
@@ -247,8 +247,8 @@ RootlessComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
     WindowPtr srcWin, dstWin, maskWin = NULL;
 
     if (pMask) {                        // pMask can be NULL
-        maskWin = (pMask->pDrawable->type == DRAWABLE_WINDOW) ?
-                  (WindowPtr)pMask->pDrawable :  NULL;
+        maskWin = (pMask->pDrawable && pMask->pDrawable->type == DRAWABLE_WINDOW) ?
+                  (WindowPtr)pMask->pDrawable : NULL;
     }
     srcWin  = (pSrc->pDrawable && pSrc->pDrawable->type  == DRAWABLE_WINDOW) ?
               (WindowPtr)pSrc->pDrawable  :  NULL;
diff --git a/xorg-server/os/io.c b/xorg-server/os/io.c
index b30f20767..f8354a6af 100644
--- a/xorg-server/os/io.c
+++ b/xorg-server/os/io.c
@@ -809,6 +809,7 @@ WriteToClient (ClientPtr who, int count, const void *__buf)
 	replyinfo.client = who;
 	replyinfo.replyData = buf;
 	replyinfo.dataLenBytes = count + padBytes;
+	replyinfo.padBytes = padBytes;
 	if (who->replyBytesRemaining)
 	{ /* still sending data of an earlier reply */
 	    who->replyBytesRemaining -= count + padBytes;
diff --git a/xorg-server/record/record.c b/xorg-server/record/record.c
index 68311ac8f..db77b64f5 100644
--- a/xorg-server/record/record.c
+++ b/xorg-server/record/record.c
@@ -269,8 +269,9 @@ RecordFlushReplyBuffer(
  *	  device events and EndOfData, pClient is NULL.
  *	category is the category of the protocol element, as defined
  *	  by the RECORD spec.
- *	data is a pointer to the protocol data, and datalen is its length
- *	  in bytes.
+ *	data is a pointer to the protocol data, and datalen - padlen
+ *	  is its length in bytes.
+ *	padlen is the number of pad bytes from a zeroed array.
  *	futurelen is the number of bytes that will be sent in subsequent
  *	  calls to this function to complete this protocol element.  
  *	  In those subsequent calls, futurelen will be -1 to indicate
@@ -290,7 +291,7 @@ RecordFlushReplyBuffer(
  */
 static void
 RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
-		       int category, pointer data, int datalen, int futurelen)
+		       int category, pointer data, int datalen, int padlen, int futurelen)
 {
     CARD32 elemHeaderData[2];
     int numElemHeaders = 0;
@@ -398,15 +399,20 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
 	}
 	if (datalen)
 	{
+	    static char padBuffer[3]; /* as in FlushClient */
 	    memcpy(pContext->replyBuffer + pContext->numBufBytes,
-		   data, datalen);
-	    pContext->numBufBytes += datalen;
+		   data, datalen - padlen);
+	    pContext->numBufBytes += datalen - padlen;
+	    memcpy(pContext->replyBuffer + pContext->numBufBytes,
+		   padBuffer, padlen);
+	    pContext->numBufBytes += padlen;
 	}
     }
     else
+    {
 	RecordFlushReplyBuffer(pContext, (pointer)elemHeaderData,
-			       numElemHeaders, (pointer)data, datalen);
-
+			       numElemHeaders, (pointer)data, datalen - padlen);
+    }
 } /* RecordAProtocolElement */
 
 
@@ -483,19 +489,19 @@ RecordABigRequest(RecordContextPtr pContext, ClientPtr client, xReq *stuff)
     /* record the request header */
     bytesLeft = client->req_len << 2;
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-			   (pointer)stuff, SIZEOF(xReq), bytesLeft);
+			   (pointer)stuff, SIZEOF(xReq), 0, bytesLeft);
 
     /* reinsert the extended length field that was squished out */
     bigLength = client->req_len + bytes_to_int32(sizeof(bigLength));
     if (client->swapped)
 	swapl(&bigLength);
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-		(pointer)&bigLength, sizeof(bigLength), /* continuation */ -1);
+               (pointer)&bigLength, sizeof(bigLength), 0, /* continuation */ -1);
     bytesLeft -= sizeof(bigLength);
 
     /* record the rest of the request after the length */
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-		(pointer)(stuff + 1), bytesLeft, /* continuation */ -1);
+               (pointer)(stuff + 1), bytesLeft, 0, /* continuation */ -1);
 } /* RecordABigRequest */
 
 
@@ -542,7 +548,7 @@ RecordARequest(ClientPtr client)
 		    RecordABigRequest(pContext, client, stuff);
 		else
 		    RecordAProtocolElement(pContext, client, XRecordFromClient,
-				(pointer)stuff, client->req_len << 2, 0);
+				(pointer)stuff, client->req_len << 2, 0, 0);
 	    }
 	    else /* extension, check minor opcode */
 	    {
@@ -566,7 +572,7 @@ RecordARequest(ClientPtr client)
 			else
 			    RecordAProtocolElement(pContext, client, 
 					XRecordFromClient, (pointer)stuff,
-					client->req_len << 2, 0);
+					client->req_len << 2, 0, 0);
 			break;
 		    }			    
 		} /* end for each minor op info */
@@ -619,7 +625,8 @@ RecordAReply(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
 	    if (pContext->continuedReply)
 	    {
 		RecordAProtocolElement(pContext, client, XRecordFromServer,
-		   (pointer)pri->replyData, pri->dataLenBytes, /* continuation */ -1);
+		   (pointer)pri->replyData, pri->dataLenBytes,
+			    pri->padBytes, /* continuation */ -1);
 		if (!pri->bytesRemaining)
 		    pContext->continuedReply = 0;
 	    }
@@ -629,7 +636,7 @@ RecordAReply(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
 		if (majorop <= 127)
 		{ /* core reply */
 		    RecordAProtocolElement(pContext, client, XRecordFromServer,
-		       (pointer)pri->replyData, pri->dataLenBytes, pri->bytesRemaining);
+		       (pointer)pri->replyData, pri->dataLenBytes, 0, pri->bytesRemaining);
 		    if (pri->bytesRemaining)
 			pContext->continuedReply = 1;
 		}
@@ -651,7 +658,7 @@ RecordAReply(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
 			{
 			    RecordAProtocolElement(pContext, client, 
 				XRecordFromServer, (pointer)pri->replyData,
-				pri->dataLenBytes, pri->bytesRemaining);
+				pri->dataLenBytes, 0, pri->bytesRemaining);
 			    if (pri->bytesRemaining)
 				pContext->continuedReply = 1;
 			    break;
@@ -723,7 +730,7 @@ RecordADeliveredEventOrError(CallbackListPtr *pcbl, pointer nulldata, pointer ca
 			
 		    }
 		    RecordAProtocolElement(pContext, pClient,
-			XRecordFromServer, pEvToRecord, SIZEOF(xEvent), 0);
+			XRecordFromServer, pEvToRecord, SIZEOF(xEvent), 0, 0);
 		}
 	    } /* end for each event */
 	} /* end this client is on this context */
@@ -774,7 +781,7 @@ RecordSendProtocolEvents(RecordClientsAndProtocolPtr pRCAP,
 	    }
 
 	    RecordAProtocolElement(pContext, NULL,
-		    XRecordFromServer,  pEvToRecord, SIZEOF(xEvent), 0);
+		    XRecordFromServer,  pEvToRecord, SIZEOF(xEvent), 0, 0);
 	    /* make sure device events get flushed in the absence
 	     * of other client activity
 	     */
@@ -2415,7 +2422,7 @@ ProcRecordEnableContext(ClientPtr client)
     assert(numEnabledContexts > 0);
 
     /* send StartOfData */
-    RecordAProtocolElement(pContext, NULL, XRecordStartOfData, NULL, 0, 0);
+    RecordAProtocolElement(pContext, NULL, XRecordStartOfData, NULL, 0, 0, 0);
     RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
     return Success;
 } /* ProcRecordEnableContext */
@@ -2446,7 +2453,7 @@ RecordDisableContext(RecordContextPtr pContext)
     if (!pContext->pRecordingClient) return;
     if (!pContext->pRecordingClient->clientGone)
     {
-	RecordAProtocolElement(pContext, NULL, XRecordEndOfData, NULL, 0, 0);
+	RecordAProtocolElement(pContext, NULL, XRecordEndOfData, NULL, 0, 0, 0);
 	RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
 	/* Re-enable request processing on this connection. */
 	AttendClient(pContext->pRecordingClient);
@@ -2761,7 +2768,7 @@ RecordConnectionSetupInfo(RecordContextPtr pContext, NewClientInfoRec *pci)
 	SwapConnSetupPrefix(pci->prefix, (xConnSetupPrefix*)pConnSetup);
 	SwapConnSetupInfo((char*)pci->setup, (char*)(pConnSetup + prefixsize));
 	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			       (pointer)pConnSetup, prefixsize + restsize, 0);
+			       (pointer)pConnSetup, prefixsize + restsize, 0, 0);
 	free(pConnSetup);
     }
     else
@@ -2770,9 +2777,9 @@ RecordConnectionSetupInfo(RecordContextPtr pContext, NewClientInfoRec *pci)
 	 * data in two pieces
 	 */
 	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			(pointer)pci->prefix, prefixsize, restsize);
+			(pointer)pci->prefix, prefixsize, 0, restsize);
 	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			(pointer)pci->setup, restsize, /* continuation */ -1);
+			(pointer)pci->setup, restsize, 0, /* continuation */ -1);
     }
 } /* RecordConnectionSetupInfo */
 
@@ -2849,7 +2856,7 @@ RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer callda
 	    {
 		if (pContext->pRecordingClient && pRCAP->clientDied)
 		    RecordAProtocolElement(pContext, pClient,
-					   XRecordClientDied, NULL, 0, 0);
+					   XRecordClientDied, NULL, 0, 0, 0);
 		RecordDeleteClientFromRCAP(pRCAP, pos);
 	    }
 	}
diff --git a/xorg-server/xkeyboard-config/symbols/pc b/xorg-server/xkeyboard-config/symbols/pc
index e1965ce63..7e13ecb25 100644
--- a/xorg-server/xkeyboard-config/symbols/pc
+++ b/xorg-server/xkeyboard-config/symbols/pc
@@ -14,7 +14,7 @@ xkb_symbols "pc105" {
     include "pc(editing)"
     include "keypad(x11)"
 
-    key <BKSP> {	[ BackSpace	]	};
+    key <BKSP> {	[ BackSpace, BackSpace	]	};
 
     key  <TAB> {	[ Tab,	ISO_Left_Tab	]	};
     key <RTRN> {	[ Return	]	};
diff --git a/xorg-server/xkeyboard-config/symbols/us b/xorg-server/xkeyboard-config/symbols/us
index 1d8bdd0dd..7c3ee2499 100644
--- a/xorg-server/xkeyboard-config/symbols/us
+++ b/xorg-server/xkeyboard-config/symbols/us
@@ -573,7 +573,7 @@ xkb_symbols "dvp" {
     key <AE10> { [ bracketright,    6                                           ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" };
     key <AE11> { [ exclam,          8,              exclamdown                  ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" };
     key <AE12> { [ numbersign,      grave,          dead_grave                  ] };
-    key <BKSP> { [ BackSpace                                                    ] };
+    key <BKSP> { [ BackSpace,       BackSpace                                   ] };
 
     // upper row, left side
     key <AD01> { [ semicolon,       colon,          dead_diaeresis              ] };