103 files changed, 4577 insertions, 3607 deletions

diff --git a/drivers/gpu/drm/drm_buffer.c b/drivers/gpu/drm/drm_buffer.c
index 55d03ed05000..529a0dbe9fc6 100644
--- a/drivers/gpu/drm/drm_buffer.c
+++ b/drivers/gpu/drm/drm_buffer.c
@@ -98,8 +98,8 @@ EXPORT_SYMBOL(drm_buffer_alloc);
  *   user_data: A pointer the data that is copied to the buffer.
  *   size: The Number of bytes to copy.
  */
-extern int drm_buffer_copy_from_user(struct drm_buffer *buf,
-                void __user *user_data, int size)
+int drm_buffer_copy_from_user(struct drm_buffer *buf,
+                              void __user *user_data, int size)
 {
         int nr_pages = size / PAGE_SIZE + 1;
         int idx;
@@ -163,7 +163,7 @@ void *drm_buffer_read_object(struct drm_buffer *buf,
 {
         int idx = drm_buffer_index(buf);
         int page = drm_buffer_page(buf);
-        void *obj = 0;
+        void *obj = NULL;
 
         if (idx + objsize <= PAGE_SIZE) {
                 obj = &buf->data[page][idx];
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index 7e31d4348340..dcbeb98f195a 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -34,6 +34,9 @@
 #include "drm_crtc_helper.h"
 #include "drm_fb_helper.h"
 
+static bool drm_kms_helper_poll = true;
+module_param_named(poll, drm_kms_helper_poll, bool, 0600);
+
 static void drm_mode_validate_flag(struct drm_connector *connector,
                                    int flags)
 {
@@ -99,8 +102,10 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
                         connector->status = connector_status_disconnected;
                 if (connector->funcs->force)
                         connector->funcs->force(connector);
-        } else
-                connector->status = connector->funcs->detect(connector);
+        } else {
+                connector->status = connector->funcs->detect(connector, true);
+                drm_kms_helper_poll_enable(dev);
+        }
 
         if (connector->status == connector_status_disconnected) {
                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
@@ -110,11 +115,10 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
         }
 
         count = (*connector_funcs->get_modes)(connector);
-        if (!count) {
+        if (count == 0 && connector->status == connector_status_connected)
                 count = drm_add_modes_noedid(connector, 1024, 768);
-                if (!count)
-                        return 0;
-        }
+        if (count == 0)
+                goto prune;
 
         drm_mode_connector_list_update(connector);
 
@@ -633,13 +637,13 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
                 mode_changed = true;
 
         if (mode_changed) {
-                old_fb = set->crtc->fb;
-                set->crtc->fb = set->fb;
                 set->crtc->enabled = (set->mode != NULL);
                 if (set->mode != NULL) {
                         DRM_DEBUG_KMS("attempting to set mode from"
                                         " userspace\n");
                         drm_mode_debug_printmodeline(set->mode);
+                        old_fb = set->crtc->fb;
+                        set->crtc->fb = set->fb;
                         if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
                                                       set->x, set->y,
                                                       old_fb)) {
@@ -840,6 +844,9 @@ static void output_poll_execute(struct work_struct *work)
         enum drm_connector_status old_status, status;
         bool repoll = false, changed = false;
 
+        if (!drm_kms_helper_poll)
+                return;
+
         mutex_lock(&dev->mode_config.mutex);
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 
@@ -859,7 +866,7 @@ static void output_poll_execute(struct work_struct *work)
                     !(connector->polled & DRM_CONNECTOR_POLL_HPD))
                         continue;
 
-                status = connector->funcs->detect(connector);
+                status = connector->funcs->detect(connector, false);
                 if (old_status != status)
                         changed = true;
         }
@@ -890,6 +897,9 @@ void drm_kms_helper_poll_enable(struct drm_device *dev)
         bool poll = false;
         struct drm_connector *connector;
 
+        if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
+                return;
+
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 if (connector->polled)
                         poll = true;
@@ -919,8 +929,10 @@ void drm_helper_hpd_irq_event(struct drm_device *dev)
 {
         if (!dev->mode_config.poll_enabled)
                 return;
+
         /* kill timer and schedule immediate execution, this doesn't block */
         cancel_delayed_work(&dev->mode_config.output_poll_work);
-        queue_delayed_work(system_nrt_wq, &dev->mode_config.output_poll_work, 0);
+        if (drm_kms_helper_poll)
+                queue_delayed_work(system_nrt_wq, &dev->mode_config.output_poll_work, 0);
 }
 EXPORT_SYMBOL(drm_helper_hpd_irq_event);
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 90288ec7c284..84da748555bc 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -55,6 +55,9 @@
 static int drm_version(struct drm_device *dev, void *data,
                        struct drm_file *file_priv);
 
+#define DRM_IOCTL_DEF(ioctl, _func, _flags) \
+        [DRM_IOCTL_NR(ioctl)] = {.cmd = ioctl, .func = _func, .flags = _flags, .cmd_drv = 0}
+
 /** Ioctl table */
 static struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version, 0),
@@ -421,6 +424,7 @@ long drm_ioctl(struct file *filp,
         int retcode = -EINVAL;
         char stack_kdata[128];
         char *kdata = NULL;
+        unsigned int usize, asize;
 
         dev = file_priv->minor->dev;
         atomic_inc(&dev->ioctl_count);
@@ -436,11 +440,18 @@ long drm_ioctl(struct file *filp,
             ((nr < DRM_COMMAND_BASE) || (nr >= DRM_COMMAND_END)))
                 goto err_i1;
         if ((nr >= DRM_COMMAND_BASE) && (nr < DRM_COMMAND_END) &&
-            (nr < DRM_COMMAND_BASE + dev->driver->num_ioctls))
+            (nr < DRM_COMMAND_BASE + dev->driver->num_ioctls)) {
+                u32 drv_size;
                 ioctl = &dev->driver->ioctls[nr - DRM_COMMAND_BASE];
+                drv_size = _IOC_SIZE(ioctl->cmd_drv);
+                usize = asize = _IOC_SIZE(cmd);
+                if (drv_size > asize)
+                        asize = drv_size;
+        }
         else if ((nr >= DRM_COMMAND_END) || (nr < DRM_COMMAND_BASE)) {
                 ioctl = &drm_ioctls[nr];
                 cmd = ioctl->cmd;
+                usize = asize = _IOC_SIZE(cmd);
         } else
                 goto err_i1;
 
@@ -460,10 +471,10 @@ long drm_ioctl(struct file *filp,
                 retcode = -EACCES;
         } else {
                 if (cmd & (IOC_IN | IOC_OUT)) {
-                        if (_IOC_SIZE(cmd) <= sizeof(stack_kdata)) {
+                        if (asize <= sizeof(stack_kdata)) {
                                 kdata = stack_kdata;
                         } else {
-                                kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
+                                kdata = kmalloc(asize, GFP_KERNEL);
                                 if (!kdata) {
                                         retcode = -ENOMEM;
                                         goto err_i1;
@@ -473,11 +484,13 @@ long drm_ioctl(struct file *filp,
 
                 if (cmd & IOC_IN) {
                         if (copy_from_user(kdata, (void __user *)arg,
-                                           _IOC_SIZE(cmd)) != 0) {
+                                           usize) != 0) {
                                 retcode = -EFAULT;
                                 goto err_i1;
                         }
-                }
+                } else
+                        memset(kdata, 0, usize);
+
                 if (ioctl->flags & DRM_UNLOCKED)
                         retcode = func(dev, kdata, file_priv);
                 else {
@@ -488,7 +501,7 @@ long drm_ioctl(struct file *filp,
 
                 if (cmd & IOC_OUT) {
                         if (copy_to_user((void __user *)arg, kdata,
-                                         _IOC_SIZE(cmd)) != 0)
+                                         usize) != 0)
                                 retcode = -EFAULT;
                 }
         }
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index de82e201d682..6a5e403f9aa1 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -94,10 +94,11 @@ static bool drm_fb_helper_connector_parse_command_line(struct drm_fb_helper_conn
         int i;
         enum drm_connector_force force = DRM_FORCE_UNSPECIFIED;
         struct drm_fb_helper_cmdline_mode *cmdline_mode;
-        struct drm_connector *connector = fb_helper_conn->connector;
+        struct drm_connector *connector;
 
         if (!fb_helper_conn)
                 return false;
+        connector = fb_helper_conn->connector;
 
         cmdline_mode = &fb_helper_conn->cmdline_mode;
         if (!mode_option)
@@ -369,7 +370,7 @@ static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
 }
 static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
 
-static void drm_fb_helper_sysrq(int dummy1, struct tty_struct *dummy3)
+static void drm_fb_helper_sysrq(int dummy1)
 {
         schedule_work(&drm_fb_helper_restore_work);
 }
diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c
index 3a652a65546f..b744dad5c237 100644
--- a/drivers/gpu/drm/drm_fops.c
+++ b/drivers/gpu/drm/drm_fops.c
@@ -41,6 +41,7 @@
 
 /* from BKL pushdown: note that nothing else serializes idr_find() */
 DEFINE_MUTEX(drm_global_mutex);
+EXPORT_SYMBOL(drm_global_mutex);
 
 static int drm_open_helper(struct inode *inode, struct file *filp,
                            struct drm_device * dev);
diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
index bf92d07510df..5663d2719063 100644
--- a/drivers/gpu/drm/drm_gem.c
+++ b/drivers/gpu/drm/drm_gem.c
@@ -148,7 +148,7 @@ int drm_gem_object_init(struct drm_device *dev,
                 return -ENOMEM;
 
         kref_init(&obj->refcount);
-        kref_init(&obj->handlecount);
+        atomic_set(&obj->handle_count, 0);
         obj->size = size;
 
         atomic_inc(&dev->object_count);
@@ -462,28 +462,6 @@ drm_gem_object_free(struct kref *kref)
 }
 EXPORT_SYMBOL(drm_gem_object_free);
 
-/**
- * Called after the last reference to the object has been lost.
- * Must be called without holding struct_mutex
- *
- * Frees the object
- */
-void
-drm_gem_object_free_unlocked(struct kref *kref)
-{
-        struct drm_gem_object *obj = (struct drm_gem_object *) kref;
-        struct drm_device *dev = obj->dev;
-
-        if (dev->driver->gem_free_object_unlocked != NULL)
-                dev->driver->gem_free_object_unlocked(obj);
-        else if (dev->driver->gem_free_object != NULL) {
-                mutex_lock(&dev->struct_mutex);
-                dev->driver->gem_free_object(obj);
-                mutex_unlock(&dev->struct_mutex);
-        }
-}
-EXPORT_SYMBOL(drm_gem_object_free_unlocked);
-
 static void drm_gem_object_ref_bug(struct kref *list_kref)
 {
         BUG();
@@ -496,12 +474,8 @@ static void drm_gem_object_ref_bug(struct kref *list_kref)
  * called before drm_gem_object_free or we'll be touching
  * freed memory
  */
-void
-drm_gem_object_handle_free(struct kref *kref)
+void drm_gem_object_handle_free(struct drm_gem_object *obj)
 {
-        struct drm_gem_object *obj = container_of(kref,
-                                                  struct drm_gem_object,
-                                                  handlecount);
         struct drm_device *dev = obj->dev;
 
         /* Remove any name for this object */
@@ -528,6 +502,10 @@ void drm_gem_vm_open(struct vm_area_struct *vma)
         struct drm_gem_object *obj = vma->vm_private_data;
 
         drm_gem_object_reference(obj);
+
+        mutex_lock(&obj->dev->struct_mutex);
+        drm_vm_open_locked(vma);
+        mutex_unlock(&obj->dev->struct_mutex);
 }
 EXPORT_SYMBOL(drm_gem_vm_open);
 
@@ -535,7 +513,10 @@ void drm_gem_vm_close(struct vm_area_struct *vma)
 {
         struct drm_gem_object *obj = vma->vm_private_data;
 
-        drm_gem_object_unreference_unlocked(obj);
+        mutex_lock(&obj->dev->struct_mutex);
+        drm_vm_close_locked(vma);
+        drm_gem_object_unreference(obj);
+        mutex_unlock(&obj->dev->struct_mutex);
 }
 EXPORT_SYMBOL(drm_gem_vm_close);
 
diff --git a/drivers/gpu/drm/drm_info.c b/drivers/gpu/drm/drm_info.c
index 2ef2c7827243..974e970ce3f8 100644
--- a/drivers/gpu/drm/drm_info.c
+++ b/drivers/gpu/drm/drm_info.c
@@ -255,7 +255,7 @@ int drm_gem_one_name_info(int id, void *ptr, void *data)
 
         seq_printf(m, "%6d %8zd %7d %8d\n",
                    obj->name, obj->size,
-                   atomic_read(&obj->handlecount.refcount),
+                   atomic_read(&obj->handle_count),
                    atomic_read(&obj->refcount.refcount));
         return 0;
 }
diff --git a/drivers/gpu/drm/drm_lock.c b/drivers/gpu/drm/drm_lock.c
index e2f70a516c34..9bf93bc9a32c 100644
--- a/drivers/gpu/drm/drm_lock.c
+++ b/drivers/gpu/drm/drm_lock.c
@@ -92,7 +92,9 @@ int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
                 }
 
                 /* Contention */
+                mutex_unlock(&drm_global_mutex);
                 schedule();
+                mutex_lock(&drm_global_mutex);
                 if (signal_pending(current)) {
                         ret = -EINTR;
                         break;
diff --git a/drivers/gpu/drm/drm_mm.c b/drivers/gpu/drm/drm_mm.c
index da99edc50888..a6bfc302ed90 100644
--- a/drivers/gpu/drm/drm_mm.c
+++ b/drivers/gpu/drm/drm_mm.c
@@ -285,21 +285,21 @@ void drm_mm_put_block(struct drm_mm_node *cur)
 
 EXPORT_SYMBOL(drm_mm_put_block);
 
-static int check_free_mm_node(struct drm_mm_node *entry, unsigned long size,
-                              unsigned alignment)
+static int check_free_hole(unsigned long start, unsigned long end,
+                           unsigned long size, unsigned alignment)
 {
         unsigned wasted = 0;
 
-        if (entry->size < size)
+        if (end - start < size)
                 return 0;
 
         if (alignment) {
-                register unsigned tmp = entry->start % alignment;
+                unsigned tmp = start % alignment;
                 if (tmp)
                         wasted = alignment - tmp;
         }
 
-        if (entry->size >= size + wasted) {
+        if (end >= start + size + wasted) {
                 return 1;
         }
 
@@ -320,7 +320,8 @@ struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
         best_size = ~0UL;
 
         list_for_each_entry(entry, &mm->free_stack, free_stack) {
-                if (!check_free_mm_node(entry, size, alignment))
+                if (!check_free_hole(entry->start, entry->start + entry->size,
+                                     size, alignment))
                         continue;
 
                 if (!best_match)
@@ -353,10 +354,12 @@ struct drm_mm_node *drm_mm_search_free_in_range(const struct drm_mm *mm,
         best_size = ~0UL;
 
         list_for_each_entry(entry, &mm->free_stack, free_stack) {
-                if (entry->start > end || (entry->start+entry->size) < start)
-                        continue;
+                unsigned long adj_start = entry->start < start ?
+                        start : entry->start;
+                unsigned long adj_end = entry->start + entry->size > end ?
+                        end : entry->start + entry->size;
 
-                if (!check_free_mm_node(entry, size, alignment))
+                if (!check_free_hole(adj_start, adj_end, size, alignment))
                         continue;
 
                 if (!best_match)
@@ -449,7 +452,8 @@ int drm_mm_scan_add_block(struct drm_mm_node *node)
         node->free_stack.prev = prev_free;
         node->free_stack.next = next_free;
 
-        if (check_free_mm_node(node, mm->scan_size, mm->scan_alignment)) {
+        if (check_free_hole(node->start, node->start + node->size,
+                            mm->scan_size, mm->scan_alignment)) {
                 mm->scan_hit_start = node->start;
                 mm->scan_hit_size = node->size;
 
diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
index f1f473ea97d3..949326d2a8e5 100644
--- a/drivers/gpu/drm/drm_modes.c
+++ b/drivers/gpu/drm/drm_modes.c
@@ -251,7 +251,10 @@ struct drm_display_mode *drm_cvt_mode(struct drm_device *dev, int hdisplay,
                 drm_mode->htotal = drm_mode->hdisplay + CVT_RB_H_BLANK;
                 /* Fill in HSync values */
                 drm_mode->hsync_end = drm_mode->hdisplay + CVT_RB_H_BLANK / 2;
-                drm_mode->hsync_start = drm_mode->hsync_end = CVT_RB_H_SYNC;
+                drm_mode->hsync_start = drm_mode->hsync_end - CVT_RB_H_SYNC;
+                /* Fill in VSync values */
+                drm_mode->vsync_start = drm_mode->vdisplay + CVT_RB_VFPORCH;
+                drm_mode->vsync_end = drm_mode->vsync_start + vsync;
         }
         /* 15/13. Find pixel clock frequency (kHz for xf86) */
         drm_mode->clock = drm_mode->htotal * HV_FACTOR * 1000 / hperiod;
diff --git a/drivers/gpu/drm/drm_pci.c b/drivers/gpu/drm/drm_pci.c
index e20f78b542a7..f5bd9e590c80 100644
--- a/drivers/gpu/drm/drm_pci.c
+++ b/drivers/gpu/drm/drm_pci.c
@@ -164,6 +164,8 @@ int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
         dev->hose = pdev->sysdata;
 #endif
 
+        mutex_lock(&drm_global_mutex);
+
         if ((ret = drm_fill_in_dev(dev, ent, driver))) {
                 printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
                 goto err_g2;
@@ -199,6 +201,7 @@ int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
                  driver->name, driver->major, driver->minor, driver->patchlevel,
                  driver->date, pci_name(pdev), dev->primary->index);
 
+        mutex_unlock(&drm_global_mutex);
         return 0;
 
 err_g4:
@@ -210,6 +213,7 @@ err_g2:
         pci_disable_device(pdev);
 err_g1:
         kfree(dev);
+        mutex_unlock(&drm_global_mutex);
         return ret;
 }
 EXPORT_SYMBOL(drm_get_pci_dev);
diff --git a/drivers/gpu/drm/drm_platform.c b/drivers/gpu/drm/drm_platform.c
index 460e9a3afa8d..92d1d0fb7b75 100644
--- a/drivers/gpu/drm/drm_platform.c
+++ b/drivers/gpu/drm/drm_platform.c
@@ -53,6 +53,8 @@ int drm_get_platform_dev(struct platform_device *platdev,
         dev->platformdev = platdev;
         dev->dev = &platdev->dev;
 
+        mutex_lock(&drm_global_mutex);
+
         ret = drm_fill_in_dev(dev, NULL, driver);
 
         if (ret) {
@@ -87,6 +89,8 @@ int drm_get_platform_dev(struct platform_device *platdev,
 
         list_add_tail(&dev->driver_item, &driver->device_list);
 
+        mutex_unlock(&drm_global_mutex);
+
         DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
                  driver->name, driver->major, driver->minor, driver->patchlevel,
                  driver->date, dev->primary->index);
@@ -100,6 +104,7 @@ err_g2:
                 drm_put_minor(&dev->control);
 err_g1:
         kfree(dev);
+        mutex_unlock(&drm_global_mutex);
         return ret;
 }
 EXPORT_SYMBOL(drm_get_platform_dev);
diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index 86118a742231..85da4c40694c 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -159,7 +159,7 @@ static ssize_t status_show(struct device *device,
         struct drm_connector *connector = to_drm_connector(device);
         enum drm_connector_status status;
 
-        status = connector->funcs->detect(connector);
+        status = connector->funcs->detect(connector, true);
         return snprintf(buf, PAGE_SIZE, "%s\n",
                         drm_get_connector_status_name(status));
 }
diff --git a/drivers/gpu/drm/drm_vm.c b/drivers/gpu/drm/drm_vm.c
index 3778360eceea..5df450683aab 100644
--- a/drivers/gpu/drm/drm_vm.c
+++ b/drivers/gpu/drm/drm_vm.c
@@ -138,7 +138,7 @@ static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
                                 break;
                 }
 
-                if (!agpmem)
+                if (&agpmem->head == &dev->agp->memory)
                         goto vm_fault_error;
 
                 /*
@@ -433,15 +433,7 @@ static void drm_vm_open(struct vm_area_struct *vma)
         mutex_unlock(&dev->struct_mutex);
 }
 
-/**
- * \c close method for all virtual memory types.
- *
- * \param vma virtual memory area.
- *
- * Search the \p vma private data entry in drm_device::vmalist, unlink it, and
- * free it.
- */
-static void drm_vm_close(struct vm_area_struct *vma)
+void drm_vm_close_locked(struct vm_area_struct *vma)
 {
         struct drm_file *priv = vma->vm_file->private_data;
         struct drm_device *dev = priv->minor->dev;
@@ -451,7 +443,6 @@ static void drm_vm_close(struct vm_area_struct *vma)
                   vma->vm_start, vma->vm_end - vma->vm_start);
         atomic_dec(&dev->vma_count);
 
-        mutex_lock(&dev->struct_mutex);
         list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                 if (pt->vma == vma) {
                         list_del(&pt->head);
@@ -459,6 +450,23 @@ static void drm_vm_close(struct vm_area_struct *vma)
                         break;
                 }
         }
+}
+
+/**
+ * \c close method for all virtual memory types.
+ *
+ * \param vma virtual memory area.
+ *
+ * Search the \p vma private data entry in drm_device::vmalist, unlink it, and
+ * free it.
+ */
+static void drm_vm_close(struct vm_area_struct *vma)
+{
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->minor->dev;
+
+        mutex_lock(&dev->struct_mutex);
+        drm_vm_close_locked(vma);
         mutex_unlock(&dev->struct_mutex);
 }
 
diff --git a/drivers/gpu/drm/i810/i810_dma.c b/drivers/gpu/drm/i810/i810_dma.c
index 0e6c131313d9..fb07e73581e8 100644
--- a/drivers/gpu/drm/i810/i810_dma.c
+++ b/drivers/gpu/drm/i810/i810_dma.c
@@ -116,7 +116,7 @@ static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
 static const struct file_operations i810_buffer_fops = {
         .open = drm_open,
         .release = drm_release,
-        .unlocked_ioctl = drm_ioctl,
+        .unlocked_ioctl = i810_ioctl,
         .mmap = i810_mmap_buffers,
         .fasync = drm_fasync,
 };
@@ -1255,21 +1255,21 @@ long i810_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 }
 
 struct drm_ioctl_desc i810_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_I810_INIT, i810_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_VERTEX, i810_dma_vertex, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_CLEAR, i810_clear_bufs, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_FLUSH, i810_flush_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_GETAGE, i810_getage, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_GETBUF, i810_getbuf, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_SWAP, i810_swap_bufs, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_COPY, i810_copybuf, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_DOCOPY, i810_docopy, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_OV0INFO, i810_ov0_info, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_FSTATUS, i810_fstatus, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_OV0FLIP, i810_ov0_flip, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_MC, i810_dma_mc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_RSTATUS, i810_rstatus, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I810_FLIP, i810_flip_bufs, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_INIT, i810_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_VERTEX, i810_dma_vertex, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_CLEAR, i810_clear_bufs, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_FLUSH, i810_flush_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_GETAGE, i810_getage, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_GETBUF, i810_getbuf, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_SWAP, i810_swap_bufs, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_COPY, i810_copybuf, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_DOCOPY, i810_docopy, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_OV0INFO, i810_ov0_info, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_FSTATUS, i810_fstatus, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_OV0FLIP, i810_ov0_flip, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_MC, i810_dma_mc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_RSTATUS, i810_rstatus, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I810_FLIP, i810_flip_bufs, DRM_AUTH|DRM_UNLOCKED),
 };
 
 int i810_max_ioctl = DRM_ARRAY_SIZE(i810_ioctls);
diff --git a/drivers/gpu/drm/i830/i830_dma.c b/drivers/gpu/drm/i830/i830_dma.c
index 5168862c9227..cc92c7e6236f 100644
--- a/drivers/gpu/drm/i830/i830_dma.c
+++ b/drivers/gpu/drm/i830/i830_dma.c
@@ -118,7 +118,7 @@ static int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
 static const struct file_operations i830_buffer_fops = {
         .open = drm_open,
         .release = drm_release,
-        .unlocked_ioctl = drm_ioctl,
+        .unlocked_ioctl = i830_ioctl,
         .mmap = i830_mmap_buffers,
         .fasync = drm_fasync,
 };
@@ -1524,20 +1524,20 @@ long i830_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 }
 
 struct drm_ioctl_desc i830_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_I830_INIT, i830_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_VERTEX, i830_dma_vertex, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_CLEAR, i830_clear_bufs, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_FLUSH, i830_flush_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_GETAGE, i830_getage, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_GETBUF, i830_getbuf, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_SWAP, i830_swap_bufs, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_COPY, i830_copybuf, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_DOCOPY, i830_docopy, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_FLIP, i830_flip_bufs, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_IRQ_EMIT, i830_irq_emit, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_IRQ_WAIT, i830_irq_wait, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_GETPARAM, i830_getparam, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I830_SETPARAM, i830_setparam, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_INIT, i830_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_VERTEX, i830_dma_vertex, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_CLEAR, i830_clear_bufs, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_FLUSH, i830_flush_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_GETAGE, i830_getage, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_GETBUF, i830_getbuf, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_SWAP, i830_swap_bufs, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_COPY, i830_copybuf, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_DOCOPY, i830_docopy, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_FLIP, i830_flip_bufs, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_IRQ_EMIT, i830_irq_emit, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_IRQ_WAIT, i830_irq_wait, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_GETPARAM, i830_getparam, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I830_SETPARAM, i830_setparam, DRM_AUTH|DRM_UNLOCKED),
 };
 
 int i830_max_ioctl = DRM_ARRAY_SIZE(i830_ioctls);
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index da78f2c0d909..5c8e53458edb 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -8,6 +8,7 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \
           i915_suspend.o \
           i915_gem.o \
           i915_gem_debug.o \
+          i915_gem_evict.o \
           i915_gem_tiling.o \
           i915_trace_points.o \
           intel_display.o \
@@ -18,6 +19,7 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \
           intel_hdmi.o \
           intel_sdvo.o \
           intel_modes.o \
+          intel_panel.o \
           intel_i2c.o \
           intel_fb.o \
           intel_tv.o \
diff --git a/drivers/gpu/drm/i915/dvo.h b/drivers/gpu/drm/i915/dvo.h
index 0d6ff640e1c6..8c2ad014c47f 100644
--- a/drivers/gpu/drm/i915/dvo.h
+++ b/drivers/gpu/drm/i915/dvo.h
@@ -30,20 +30,17 @@
 #include "intel_drv.h"
 
 struct intel_dvo_device {
-        char *name;
+        const char *name;
         int type;
         /* DVOA/B/C output register */
         u32 dvo_reg;
         /* GPIO register used for i2c bus to control this device */
         u32 gpio;
         int slave_addr;
-        struct i2c_adapter *i2c_bus;
 
         const struct intel_dvo_dev_ops *dev_ops;
         void *dev_priv;
-
-        struct drm_display_mode *panel_fixed_mode;
-        bool panel_wants_dither;
+        struct i2c_adapter *i2c_bus;
 };
 
 struct intel_dvo_dev_ops {
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 9214119c0154..5e43d7076789 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -31,6 +31,7 @@
 #include <linux/slab.h>
 #include "drmP.h"
 #include "drm.h"
+#include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
 
@@ -121,6 +122,54 @@ static int i915_gem_object_list_info(struct seq_file *m, void *data)
         return 0;
 }
 
+static int i915_gem_pageflip_info(struct seq_file *m, void *data)
+{
+        struct drm_info_node *node = (struct drm_info_node *) m->private;
+        struct drm_device *dev = node->minor->dev;
+        unsigned long flags;
+        struct intel_crtc *crtc;
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, base.head) {
+                const char *pipe = crtc->pipe ? "B" : "A";
+                const char *plane = crtc->plane ? "B" : "A";
+                struct intel_unpin_work *work;
+
+                spin_lock_irqsave(&dev->event_lock, flags);
+                work = crtc->unpin_work;
+                if (work == NULL) {
+                        seq_printf(m, "No flip due on pipe %s (plane %s)\n",
+                                   pipe, plane);
+                } else {
+                        if (!work->pending) {
+                                seq_printf(m, "Flip queued on pipe %s (plane %s)\n",
+                                           pipe, plane);
+                        } else {
+                                seq_printf(m, "Flip pending (waiting for vsync) on pipe %s (plane %s)\n",
+                                           pipe, plane);
+                        }
+                        if (work->enable_stall_check)
+                                seq_printf(m, "Stall check enabled, ");
+                        else
+                                seq_printf(m, "Stall check waiting for page flip ioctl, ");
+                        seq_printf(m, "%d prepares\n", work->pending);
+
+                        if (work->old_fb_obj) {
+                                struct drm_i915_gem_object *obj_priv = to_intel_bo(work->old_fb_obj);
+                                if(obj_priv)
+                                        seq_printf(m, "Old framebuffer gtt_offset 0x%08x\n", obj_priv->gtt_offset );
+                        }
+                        if (work->pending_flip_obj) {
+                                struct drm_i915_gem_object *obj_priv = to_intel_bo(work->pending_flip_obj);
+                                if(obj_priv)
+                                        seq_printf(m, "New framebuffer gtt_offset 0x%08x\n", obj_priv->gtt_offset );
+                        }
+                }
+                spin_unlock_irqrestore(&dev->event_lock, flags);
+        }
+
+        return 0;
+}
+
 static int i915_gem_request_info(struct seq_file *m, void *data)
 {
         struct drm_info_node *node = (struct drm_info_node *) m->private;
@@ -467,6 +516,9 @@ static int i915_error_state(struct seq_file *m, void *unused)
                 }
         }
 
+        if (error->overlay)
+                intel_overlay_print_error_state(m, error->overlay);
+
 out:
         spin_unlock_irqrestore(&dev_priv->error_lock, flags);
 
@@ -774,6 +826,7 @@ static struct drm_info_list i915_debugfs_list[] = {
         {"i915_gem_active", i915_gem_object_list_info, 0, (void *) ACTIVE_LIST},
         {"i915_gem_flushing", i915_gem_object_list_info, 0, (void *) FLUSHING_LIST},
         {"i915_gem_inactive", i915_gem_object_list_info, 0, (void *) INACTIVE_LIST},
+        {"i915_gem_pageflip", i915_gem_pageflip_info, 0},
         {"i915_gem_request", i915_gem_request_info, 0},
         {"i915_gem_seqno", i915_gem_seqno_info, 0},
         {"i915_gem_fence_regs", i915_gem_fence_regs_info, 0},
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index f19ffe87af3c..2dd2c93ebfa3 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -499,6 +499,13 @@ static int i915_dispatch_batchbuffer(struct drm_device * dev,
                 }
         }
 
+
+        if (IS_G4X(dev) || IS_IRONLAKE(dev)) {
+                BEGIN_LP_RING(2);
+                OUT_RING(MI_FLUSH | MI_NO_WRITE_FLUSH | MI_INVALIDATE_ISP);
+                OUT_RING(MI_NOOP);
+                ADVANCE_LP_RING();
+        }
         i915_emit_breadcrumb(dev);
 
         return 0;
@@ -613,8 +620,10 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
                 ret = copy_from_user(cliprects, batch->cliprects,
                                      batch->num_cliprects *
                                      sizeof(struct drm_clip_rect));
-                if (ret != 0)
+                if (ret != 0) {
+                        ret = -EFAULT;
                         goto fail_free;
+                }
         }
 
         mutex_lock(&dev->struct_mutex);
@@ -655,8 +664,10 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                 return -ENOMEM;
 
         ret = copy_from_user(batch_data, cmdbuf->buf, cmdbuf->sz);
-        if (ret != 0)
+        if (ret != 0) {
+                ret = -EFAULT;
                 goto fail_batch_free;
+        }
 
         if (cmdbuf->num_cliprects) {
                 cliprects = kcalloc(cmdbuf->num_cliprects,
@@ -669,8 +680,10 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                 ret = copy_from_user(cliprects, cmdbuf->cliprects,
                                      cmdbuf->num_cliprects *
                                      sizeof(struct drm_clip_rect));
-                if (ret != 0)
+                if (ret != 0) {
+                        ret = -EFAULT;
                         goto fail_clip_free;
+                }
         }
 
         mutex_lock(&dev->struct_mutex);
@@ -878,7 +891,7 @@ intel_alloc_mchbar_resource(struct drm_device *dev)
         int reg = IS_I965G(dev) ? MCHBAR_I965 : MCHBAR_I915;
         u32 temp_lo, temp_hi = 0;
         u64 mchbar_addr;
-        int ret = 0;
+        int ret;
 
         if (IS_I965G(dev))
                 pci_read_config_dword(dev_priv->bridge_dev, reg + 4, &temp_hi);
@@ -888,22 +901,23 @@ intel_alloc_mchbar_resource(struct drm_device *dev)
         /* If ACPI doesn't have it, assume we need to allocate it ourselves */
 #ifdef CONFIG_PNP
         if (mchbar_addr &&
-            pnp_range_reserved(mchbar_addr, mchbar_addr + MCHBAR_SIZE)) {
-                ret = 0;
-                goto out;
-        }
+            pnp_range_reserved(mchbar_addr, mchbar_addr + MCHBAR_SIZE))
+                return 0;
 #endif
 
         /* Get some space for it */
-        ret = pci_bus_alloc_resource(dev_priv->bridge_dev->bus, &dev_priv->mch_res,
+        dev_priv->mch_res.name = "i915 MCHBAR";
+        dev_priv->mch_res.flags = IORESOURCE_MEM;
+        ret = pci_bus_alloc_resource(dev_priv->bridge_dev->bus,
+                                     &dev_priv->mch_res,
                                      MCHBAR_SIZE, MCHBAR_SIZE,
                                      PCIBIOS_MIN_MEM,
-                                     0,   pcibios_align_resource,
+                                     0, pcibios_align_resource,
                                      dev_priv->bridge_dev);
         if (ret) {
                 DRM_DEBUG_DRIVER("failed bus alloc: %d\n", ret);
                 dev_priv->mch_res.start = 0;
-                goto out;
+                return ret;
         }
 
         if (IS_I965G(dev))
@@ -912,8 +926,7 @@ intel_alloc_mchbar_resource(struct drm_device *dev)
 
         pci_write_config_dword(dev_priv->bridge_dev, reg,
                                lower_32_bits(dev_priv->mch_res.start));
-out:
-        return ret;
+        return 0;
 }
 
 /* Setup MCHBAR if possible, return true if we should disable it again */
@@ -1774,9 +1787,9 @@ unsigned long i915_chipset_val(struct drm_i915_private *dev_priv)
                 }
         }
 
-        div_u64(diff, diff1);
+        diff = div_u64(diff, diff1);
         ret = ((m * diff) + c);
-        div_u64(ret, 10);
+        ret = div_u64(ret, 10);
 
         dev_priv->last_count1 = total_count;
         dev_priv->last_time1 = now;
@@ -1845,7 +1858,7 @@ void i915_update_gfx_val(struct drm_i915_private *dev_priv)
 
         /* More magic constants... */
         diff = diff * 1181;
-        div_u64(diff, diffms * 10);
+        diff = div_u64(diff, diffms * 10);
         dev_priv->gfx_power = diff;
 }
 
@@ -2075,6 +2088,10 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 goto free_priv;
         }
 
+        /* overlay on gen2 is broken and can't address above 1G */
+        if (IS_GEN2(dev))
+                dma_set_coherent_mask(&dev->pdev->dev, DMA_BIT_MASK(30));
+
         dev_priv->regs = ioremap(base, size);
         if (!dev_priv->regs) {
                 DRM_ERROR("failed to map registers\n");
@@ -2214,6 +2231,9 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         dev_priv->mchdev_lock = &mchdev_lock;
         spin_unlock(&mchdev_lock);
 
+        /* XXX Prevent module unload due to memory corruption bugs. */
+        __module_get(THIS_MODULE);
+
         return 0;
 
 out_workqueue_free:
@@ -2360,46 +2380,46 @@ void i915_driver_postclose(struct drm_device *dev, struct drm_file *file_priv)
 }
 
 struct drm_ioctl_desc i915_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_I915_INIT, i915_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_I915_FLUSH, i915_flush_ioctl, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_FLIP, i915_flip_bufs, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_BATCHBUFFER, i915_batchbuffer, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_IRQ_EMIT, i915_irq_emit, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_IRQ_WAIT, i915_irq_wait, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_GETPARAM, i915_getparam, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_SETPARAM, i915_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_I915_ALLOC, i915_mem_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_FREE, i915_mem_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_INIT_HEAP, i915_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_I915_CMDBUFFER, i915_cmdbuffer, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_DESTROY_HEAP,  i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY ),
-        DRM_IOCTL_DEF(DRM_I915_SET_VBLANK_PIPE,  i915_vblank_pipe_set, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY ),
-        DRM_IOCTL_DEF(DRM_I915_GET_VBLANK_PIPE,  i915_vblank_pipe_get, DRM_AUTH ),
-        DRM_IOCTL_DEF(DRM_I915_VBLANK_SWAP, i915_vblank_swap, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_I915_HWS_ADDR, i915_set_status_page, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_I915_GEM_INIT, i915_gem_init_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_EXECBUFFER, i915_gem_execbuffer, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_EXECBUFFER2, i915_gem_execbuffer2, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_PIN, i915_gem_pin_ioctl, DRM_AUTH|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_UNPIN, i915_gem_unpin_ioctl, DRM_AUTH|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_BUSY, i915_gem_busy_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_THROTTLE, i915_gem_throttle_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_ENTERVT, i915_gem_entervt_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_LEAVEVT, i915_gem_leavevt_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_CREATE, i915_gem_create_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_PREAD, i915_gem_pread_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_PWRITE, i915_gem_pwrite_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_MMAP, i915_gem_mmap_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_MMAP_GTT, i915_gem_mmap_gtt_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_SET_DOMAIN, i915_gem_set_domain_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_SW_FINISH, i915_gem_sw_finish_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_SET_TILING, i915_gem_set_tiling, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_GET_TILING, i915_gem_get_tiling, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_GET_APERTURE, i915_gem_get_aperture_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GET_PIPE_FROM_CRTC_ID, intel_get_pipe_from_crtc_id, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_GEM_MADVISE, i915_gem_madvise_ioctl, DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_OVERLAY_PUT_IMAGE, intel_overlay_put_image, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_I915_OVERLAY_ATTRS, intel_overlay_attrs, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_INIT, i915_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(I915_FLUSH, i915_flush_ioctl, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_FLIP, i915_flip_bufs, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_BATCHBUFFER, i915_batchbuffer, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_IRQ_EMIT, i915_irq_emit, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_IRQ_WAIT, i915_irq_wait, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_GETPARAM, i915_getparam, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_SETPARAM, i915_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(I915_ALLOC, i915_mem_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_FREE, i915_mem_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_INIT_HEAP, i915_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(I915_CMDBUFFER, i915_cmdbuffer, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_DESTROY_HEAP,  i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(I915_SET_VBLANK_PIPE,  i915_vblank_pipe_set, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(I915_GET_VBLANK_PIPE,  i915_vblank_pipe_get, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_VBLANK_SWAP, i915_vblank_swap, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(I915_HWS_ADDR, i915_set_status_page, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(I915_GEM_INIT, i915_gem_init_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_EXECBUFFER, i915_gem_execbuffer, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_EXECBUFFER2, i915_gem_execbuffer2, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_PIN, i915_gem_pin_ioctl, DRM_AUTH|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_UNPIN, i915_gem_unpin_ioctl, DRM_AUTH|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_BUSY, i915_gem_busy_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_THROTTLE, i915_gem_throttle_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_ENTERVT, i915_gem_entervt_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_LEAVEVT, i915_gem_leavevt_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_CREATE, i915_gem_create_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_PREAD, i915_gem_pread_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_PWRITE, i915_gem_pwrite_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_MMAP, i915_gem_mmap_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_MMAP_GTT, i915_gem_mmap_gtt_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_SET_DOMAIN, i915_gem_set_domain_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_SW_FINISH, i915_gem_sw_finish_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_SET_TILING, i915_gem_set_tiling, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_GET_TILING, i915_gem_get_tiling, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_GET_APERTURE, i915_gem_get_aperture_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GET_PIPE_FROM_CRTC_ID, intel_get_pipe_from_crtc_id, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_GEM_MADVISE, i915_gem_madvise_ioctl, DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_OVERLAY_PUT_IMAGE, intel_overlay_put_image, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(I915_OVERLAY_ATTRS, intel_overlay_attrs, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
 };
 
 int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 5044f653e8ea..6dbe14cc4f74 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -61,91 +61,86 @@ extern int intel_agp_enabled;
         .driver_data = (unsigned long) info }
 
 static const struct intel_device_info intel_i830_info = {
-        .is_i8xx = 1, .is_mobile = 1, .cursor_needs_physical = 1,
+        .gen = 2, .is_i8xx = 1, .is_mobile = 1, .cursor_needs_physical = 1,
 };
 
 static const struct intel_device_info intel_845g_info = {
-        .is_i8xx = 1,
+        .gen = 2, .is_i8xx = 1,
 };
 
 static const struct intel_device_info intel_i85x_info = {
-        .is_i8xx = 1, .is_i85x = 1, .is_mobile = 1,
+        .gen = 2, .is_i8xx = 1, .is_i85x = 1, .is_mobile = 1,
         .cursor_needs_physical = 1,
 };
 
 static const struct intel_device_info intel_i865g_info = {
-        .is_i8xx = 1,
+        .gen = 2, .is_i8xx = 1,
 };
 
 static const struct intel_device_info intel_i915g_info = {
-        .is_i915g = 1, .is_i9xx = 1, .cursor_needs_physical = 1,
+        .gen = 3, .is_i915g = 1, .is_i9xx = 1, .cursor_needs_physical = 1,
 };
 static const struct intel_device_info intel_i915gm_info = {
-        .is_i9xx = 1,  .is_mobile = 1,
+        .gen = 3, .is_i9xx = 1,  .is_mobile = 1,
         .cursor_needs_physical = 1,
 };
 static const struct intel_device_info intel_i945g_info = {
-        .is_i9xx = 1, .has_hotplug = 1, .cursor_needs_physical = 1,
+        .gen = 3, .is_i9xx = 1, .has_hotplug = 1, .cursor_needs_physical = 1,
 };
 static const struct intel_device_info intel_i945gm_info = {
-        .is_i945gm = 1, .is_i9xx = 1, .is_mobile = 1,
+        .gen = 3, .is_i945gm = 1, .is_i9xx = 1, .is_mobile = 1,
         .has_hotplug = 1, .cursor_needs_physical = 1,
 };
 
 static const struct intel_device_info intel_i965g_info = {
-        .is_broadwater = 1, .is_i965g = 1, .is_i9xx = 1, .has_hotplug = 1,
+        .gen = 4, .is_broadwater = 1, .is_i965g = 1, .is_i9xx = 1,
+        .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_i965gm_info = {
-        .is_crestline = 1, .is_i965g = 1, .is_i965gm = 1, .is_i9xx = 1,
-        .is_mobile = 1, .has_fbc = 1, .has_rc6 = 1,
-        .has_hotplug = 1,
+        .gen = 4, .is_crestline = 1, .is_i965g = 1, .is_i965gm = 1, .is_i9xx = 1,
+        .is_mobile = 1, .has_fbc = 1, .has_rc6 = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_g33_info = {
-        .is_g33 = 1, .is_i9xx = 1, .need_gfx_hws = 1,
-        .has_hotplug = 1,
+        .gen = 3, .is_g33 = 1, .is_i9xx = 1,
+        .need_gfx_hws = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_g45_info = {
-        .is_i965g = 1, .is_g4x = 1, .is_i9xx = 1, .need_gfx_hws = 1,
-        .has_pipe_cxsr = 1,
-        .has_hotplug = 1,
+        .gen = 4, .is_i965g = 1, .is_g4x = 1, .is_i9xx = 1, .need_gfx_hws = 1,
+        .has_pipe_cxsr = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_gm45_info = {
-        .is_i965g = 1, .is_g4x = 1, .is_i9xx = 1,
+        .gen = 4, .is_i965g = 1, .is_g4x = 1, .is_i9xx = 1,
         .is_mobile = 1, .need_gfx_hws = 1, .has_fbc = 1, .has_rc6 = 1,
-        .has_pipe_cxsr = 1,
-        .has_hotplug = 1,
+        .has_pipe_cxsr = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_pineview_info = {
-        .is_g33 = 1, .is_pineview = 1, .is_mobile = 1, .is_i9xx = 1,
-        .need_gfx_hws = 1,
-        .has_hotplug = 1,
+        .gen = 3, .is_g33 = 1, .is_pineview = 1, .is_mobile = 1, .is_i9xx = 1,
+        .need_gfx_hws = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_ironlake_d_info = {
-        .is_ironlake = 1, .is_i965g = 1, .is_i9xx = 1, .need_gfx_hws = 1,
-        .has_pipe_cxsr = 1,
-        .has_hotplug = 1,
+        .gen = 5, .is_ironlake = 1, .is_i965g = 1, .is_i9xx = 1,
+        .need_gfx_hws = 1, .has_pipe_cxsr = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_ironlake_m_info = {
-        .is_ironlake = 1, .is_mobile = 1, .is_i965g = 1, .is_i9xx = 1,
-        .need_gfx_hws = 1, .has_fbc = 1, .has_rc6 = 1,
-        .has_hotplug = 1,
+        .gen = 5, .is_ironlake = 1, .is_mobile = 1, .is_i965g = 1, .is_i9xx = 1,
+        .need_gfx_hws = 1, .has_fbc = 1, .has_rc6 = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_sandybridge_d_info = {
-        .is_i965g = 1, .is_i9xx = 1, .need_gfx_hws = 1,
-        .has_hotplug = 1, .is_gen6 = 1,
+        .gen = 6, .is_i965g = 1, .is_i9xx = 1,
+        .need_gfx_hws = 1, .has_hotplug = 1,
 };
 
 static const struct intel_device_info intel_sandybridge_m_info = {
-        .is_i965g = 1, .is_mobile = 1, .is_i9xx = 1, .need_gfx_hws = 1,
-        .has_hotplug = 1, .is_gen6 = 1,
+        .gen = 6, .is_i965g = 1, .is_mobile = 1, .is_i9xx = 1,
+        .need_gfx_hws = 1, .has_hotplug = 1,
 };
 
 static const struct pci_device_id pciidlist[] = {               /* aka */
@@ -175,12 +170,18 @@ static const struct pci_device_id pciidlist[] = {		/* aka */
         INTEL_VGA_DEVICE(0x2e22, &intel_g45_info),              /* G45_G */
         INTEL_VGA_DEVICE(0x2e32, &intel_g45_info),              /* G41_G */
         INTEL_VGA_DEVICE(0x2e42, &intel_g45_info),              /* B43_G */
+        INTEL_VGA_DEVICE(0x2e92, &intel_g45_info),              /* B43_G.1 */
         INTEL_VGA_DEVICE(0xa001, &intel_pineview_info),
         INTEL_VGA_DEVICE(0xa011, &intel_pineview_info),
         INTEL_VGA_DEVICE(0x0042, &intel_ironlake_d_info),
         INTEL_VGA_DEVICE(0x0046, &intel_ironlake_m_info),
         INTEL_VGA_DEVICE(0x0102, &intel_sandybridge_d_info),
+        INTEL_VGA_DEVICE(0x0112, &intel_sandybridge_d_info),
+        INTEL_VGA_DEVICE(0x0122, &intel_sandybridge_d_info),
         INTEL_VGA_DEVICE(0x0106, &intel_sandybridge_m_info),
+        INTEL_VGA_DEVICE(0x0116, &intel_sandybridge_m_info),
+        INTEL_VGA_DEVICE(0x0126, &intel_sandybridge_m_info),
+        INTEL_VGA_DEVICE(0x010A, &intel_sandybridge_d_info),
         {0, 0, 0}
 };
 
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 906663b9929e..af4a263cf257 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -113,6 +113,9 @@ struct intel_opregion {
         int enabled;
 };
 
+struct intel_overlay;
+struct intel_overlay_error_state;
+
 struct drm_i915_master_private {
         drm_local_map_t *sarea;
         struct _drm_i915_sarea *sarea_priv;
@@ -166,6 +169,7 @@ struct drm_i915_error_state {
                 u32 purgeable:1;
         } *active_bo;
         u32 active_bo_count;
+        struct intel_overlay_error_state *overlay;
 };
 
 struct drm_i915_display_funcs {
@@ -186,9 +190,8 @@ struct drm_i915_display_funcs {
         /* clock gating init */
 };
 
-struct intel_overlay;
-
 struct intel_device_info {
+        u8 gen;
         u8 is_mobile : 1;
         u8 is_i8xx : 1;
         u8 is_i85x : 1;
@@ -204,7 +207,6 @@ struct intel_device_info {
         u8 is_broadwater : 1;
         u8 is_crestline : 1;
         u8 is_ironlake : 1;
-        u8 is_gen6 : 1;
         u8 has_fbc : 1;
         u8 has_rc6 : 1;
         u8 has_pipe_cxsr : 1;
@@ -242,6 +244,7 @@ typedef struct drm_i915_private {
         struct pci_dev *bridge_dev;
         struct intel_ring_buffer render_ring;
         struct intel_ring_buffer bsd_ring;
+        uint32_t next_seqno;
 
         drm_dma_handle_t *status_page_dmah;
         void *seqno_page;
@@ -251,6 +254,7 @@ typedef struct drm_i915_private {
         drm_local_map_t hws_map;
         struct drm_gem_object *seqno_obj;
         struct drm_gem_object *pwrctx;
+        struct drm_gem_object *renderctx;
 
         struct resource mch_res;
 
@@ -285,6 +289,9 @@ typedef struct drm_i915_private {
         unsigned int sr01, adpa, ppcr, dvob, dvoc, lvds;
         int vblank_pipe;
         int num_pipe;
+        u32 flush_rings;
+#define FLUSH_RENDER_RING       0x1
+#define FLUSH_BSD_RING          0x2
 
         /* For hangcheck timer */
 #define DRM_I915_HANGCHECK_PERIOD 75 /* in jiffies */
@@ -568,8 +575,6 @@ typedef struct drm_i915_private {
                  */
                 struct delayed_work retire_work;
 
-                uint32_t next_gem_seqno;
-
                 /**
                  * Waiting sequence number, if any
                  */
@@ -610,6 +615,8 @@ typedef struct drm_i915_private {
         struct sdvo_device_mapping sdvo_mappings[2];
         /* indicate whether the LVDS_BORDER should be enabled or not */
         unsigned int lvds_border_bits;
+        /* Panel fitter placement and size for Ironlake+ */
+        u32 pch_pf_pos, pch_pf_size;
 
         struct drm_crtc *plane_to_crtc_mapping[2];
         struct drm_crtc *pipe_to_crtc_mapping[2];
@@ -669,6 +676,8 @@ struct drm_i915_gem_object {
         struct list_head list;
         /** This object's place on GPU write list */
         struct list_head gpu_write_list;
+        /** This object's place on eviction list */
+        struct list_head evict_list;
 
         /**
          * This is set if the object is on the active or flushing lists
@@ -978,6 +987,7 @@ int i915_gem_init_ringbuffer(struct drm_device *dev);
 void i915_gem_cleanup_ringbuffer(struct drm_device *dev);
 int i915_gem_do_init(struct drm_device *dev, unsigned long start,
                      unsigned long end);
+int i915_gpu_idle(struct drm_device *dev);
 int i915_gem_idle(struct drm_device *dev);
 uint32_t i915_add_request(struct drm_device *dev,
                 struct drm_file *file_priv,
@@ -991,7 +1001,9 @@ int i915_gem_object_set_to_gtt_domain(struct drm_gem_object *obj,
                                       int write);
 int i915_gem_object_set_to_display_plane(struct drm_gem_object *obj);
 int i915_gem_attach_phys_object(struct drm_device *dev,
-                                struct drm_gem_object *obj, int id);
+                                struct drm_gem_object *obj,
+                                int id,
+                                int align);
 void i915_gem_detach_phys_object(struct drm_device *dev,
                                  struct drm_gem_object *obj);
 void i915_gem_free_all_phys_object(struct drm_device *dev);
@@ -1003,6 +1015,11 @@ int i915_gem_object_flush_write_domain(struct drm_gem_object *obj);
 void i915_gem_shrinker_init(void);
 void i915_gem_shrinker_exit(void);
 
+/* i915_gem_evict.c */
+int i915_gem_evict_something(struct drm_device *dev, int min_size, unsigned alignment);
+int i915_gem_evict_everything(struct drm_device *dev);
+int i915_gem_evict_inactive(struct drm_device *dev);
+
 /* i915_gem_tiling.c */
 void i915_gem_detect_bit_6_swizzle(struct drm_device *dev);
 void i915_gem_object_do_bit_17_swizzle(struct drm_gem_object *obj);
@@ -1066,6 +1083,10 @@ extern bool ironlake_set_drps(struct drm_device *dev, u8 val);
 extern void intel_detect_pch (struct drm_device *dev);
 extern int intel_trans_dp_port_sel (struct drm_crtc *crtc);
 
+/* overlay */
+extern struct intel_overlay_error_state *intel_overlay_capture_error_state(struct drm_device *dev);
+extern void intel_overlay_print_error_state(struct seq_file *m, struct intel_overlay_error_state *error);
+
 /**
  * Lock test for when it's just for synchronization of ring access.
  *
@@ -1092,26 +1113,26 @@ extern int intel_trans_dp_port_sel (struct drm_crtc *crtc);
 #define I915_VERBOSE 0
 
 #define BEGIN_LP_RING(n)  do { \
-        drm_i915_private_t *dev_priv = dev->dev_private;                \
+        drm_i915_private_t *dev_priv__ = dev->dev_private;                \
         if (I915_VERBOSE)                                               \
                 DRM_DEBUG("   BEGIN_LP_RING %x\n", (int)(n));           \
-        intel_ring_begin(dev, &dev_priv->render_ring, (n));             \
+        intel_ring_begin(dev, &dev_priv__->render_ring, (n));           \
 } while (0)
 
 
 #define OUT_RING(x) do {                                                \
-        drm_i915_private_t *dev_priv = dev->dev_private;                \
+        drm_i915_private_t *dev_priv__ = dev->dev_private;              \
         if (I915_VERBOSE)                                               \
                 DRM_DEBUG("   OUT_RING %x\n", (int)(x));                \
-        intel_ring_emit(dev, &dev_priv->render_ring, x);                \
+        intel_ring_emit(dev, &dev_priv__->render_ring, x);              \
 } while (0)
 
 #define ADVANCE_LP_RING() do {                                          \
-        drm_i915_private_t *dev_priv = dev->dev_private;                \
+        drm_i915_private_t *dev_priv__ = dev->dev_private;                \
         if (I915_VERBOSE)                                               \
                 DRM_DEBUG("ADVANCE_LP_RING %x\n",                       \
-                                dev_priv->render_ring.tail);            \
-        intel_ring_advance(dev, &dev_priv->render_ring);                \
+                                dev_priv__->render_ring.tail);          \
+        intel_ring_advance(dev, &dev_priv__->render_ring);              \
 } while(0)
 
 /**
@@ -1141,7 +1162,6 @@ extern int intel_trans_dp_port_sel (struct drm_crtc *crtc);
 #define IS_845G(dev)            ((dev)->pci_device == 0x2562)
 #define IS_I85X(dev)            (INTEL_INFO(dev)->is_i85x)
 #define IS_I865G(dev)           ((dev)->pci_device == 0x2572)
-#define IS_GEN2(dev)            (INTEL_INFO(dev)->is_i8xx)
 #define IS_I915G(dev)           (INTEL_INFO(dev)->is_i915g)
 #define IS_I915GM(dev)          ((dev)->pci_device == 0x2592)
 #define IS_I945G(dev)           ((dev)->pci_device == 0x2772)
@@ -1160,27 +1180,13 @@ extern int intel_trans_dp_port_sel (struct drm_crtc *crtc);
 #define IS_IRONLAKE_M(dev)      ((dev)->pci_device == 0x0046)
 #define IS_IRONLAKE(dev)        (INTEL_INFO(dev)->is_ironlake)
 #define IS_I9XX(dev)            (INTEL_INFO(dev)->is_i9xx)
-#define IS_GEN6(dev)            (INTEL_INFO(dev)->is_gen6)
 #define IS_MOBILE(dev)          (INTEL_INFO(dev)->is_mobile)
 
-#define IS_GEN3(dev)    (IS_I915G(dev) ||                       \
-                         IS_I915GM(dev) ||                      \
-                         IS_I945G(dev) ||                       \
-                         IS_I945GM(dev) ||                      \
-                         IS_G33(dev) || \
-                         IS_PINEVIEW(dev))
-#define IS_GEN4(dev)    ((dev)->pci_device == 0x2972 ||         \
-                         (dev)->pci_device == 0x2982 ||         \
-                         (dev)->pci_device == 0x2992 ||         \
-                         (dev)->pci_device == 0x29A2 ||         \
-                         (dev)->pci_device == 0x2A02 ||         \
-                         (dev)->pci_device == 0x2A12 ||         \
-                         (dev)->pci_device == 0x2E02 ||         \
-                         (dev)->pci_device == 0x2E12 ||         \
-                         (dev)->pci_device == 0x2E22 ||         \
-                         (dev)->pci_device == 0x2E32 ||         \
-                         (dev)->pci_device == 0x2A42 ||         \
-                         (dev)->pci_device == 0x2E42)
+#define IS_GEN2(dev)    (INTEL_INFO(dev)->gen == 2)
+#define IS_GEN3(dev)    (INTEL_INFO(dev)->gen == 3)
+#define IS_GEN4(dev)    (INTEL_INFO(dev)->gen == 4)
+#define IS_GEN5(dev)    (INTEL_INFO(dev)->gen == 5)
+#define IS_GEN6(dev)    (INTEL_INFO(dev)->gen == 6)
 
 #define HAS_BSD(dev)            (IS_IRONLAKE(dev) || IS_G4X(dev))
 #define I915_NEED_GFX_HWS(dev)  (INTEL_INFO(dev)->need_gfx_hws)
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 0758c7802e6b..90b1d6753b9d 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -34,7 +34,9 @@
 #include <linux/slab.h>
 #include <linux/swap.h>
 #include <linux/pci.h>
+#include <linux/intel-gtt.h>
 
+static uint32_t i915_gem_get_gtt_alignment(struct drm_gem_object *obj);
 static int i915_gem_object_flush_gpu_write_domain(struct drm_gem_object *obj);
 static void i915_gem_object_flush_gtt_write_domain(struct drm_gem_object *obj);
 static void i915_gem_object_flush_cpu_write_domain(struct drm_gem_object *obj);
@@ -48,8 +50,6 @@ static int i915_gem_object_wait_rendering(struct drm_gem_object *obj);
 static int i915_gem_object_bind_to_gtt(struct drm_gem_object *obj,
                                            unsigned alignment);
 static void i915_gem_clear_fence_reg(struct drm_gem_object *obj);
-static int i915_gem_evict_something(struct drm_device *dev, int min_size);
-static int i915_gem_evict_from_inactive_list(struct drm_device *dev);
 static int i915_gem_phys_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
                                 struct drm_i915_gem_pwrite *args,
                                 struct drm_file *file_priv);
@@ -58,6 +58,14 @@ static void i915_gem_free_object_tail(struct drm_gem_object *obj);
 static LIST_HEAD(shrink_list);
 static DEFINE_SPINLOCK(shrink_list_lock);
 
+static inline bool
+i915_gem_object_is_inactive(struct drm_i915_gem_object *obj_priv)
+{
+        return obj_priv->gtt_space &&
+                !obj_priv->active &&
+                obj_priv->pin_count == 0;
+}
+
 int i915_gem_do_init(struct drm_device *dev, unsigned long start,
                      unsigned long end)
 {
@@ -128,12 +136,13 @@ i915_gem_create_ioctl(struct drm_device *dev, void *data,
                 return -ENOMEM;
 
         ret = drm_gem_handle_create(file_priv, obj, &handle);
+        /* drop reference from allocate - handle holds it now */
         drm_gem_object_unreference_unlocked(obj);
-        if (ret)
+        if (ret) {
                 return ret;
+        }
 
         args->handle = handle;
-
         return 0;
 }
 
@@ -313,7 +322,8 @@ i915_gem_object_get_pages_or_evict(struct drm_gem_object *obj)
         if (ret == -ENOMEM) {
                 struct drm_device *dev = obj->dev;
 
-                ret = i915_gem_evict_something(dev, obj->size);
+                ret = i915_gem_evict_something(dev, obj->size,
+                                               i915_gem_get_gtt_alignment(obj));
                 if (ret)
                         return ret;
 
@@ -459,14 +469,17 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data,
                 return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
-        /* Bounds check source.
-         *
-         * XXX: This could use review for overflow issues...
-         */
-        if (args->offset > obj->size || args->size > obj->size ||
-            args->offset + args->size > obj->size) {
-                drm_gem_object_unreference_unlocked(obj);
-                return -EINVAL;
+        /* Bounds check source.  */
+        if (args->offset > obj->size || args->size > obj->size - args->offset) {
+                ret = -EINVAL;
+                goto err;
+        }
+
+        if (!access_ok(VERIFY_WRITE,
+                       (char __user *)(uintptr_t)args->data_ptr,
+                       args->size)) {
+                ret = -EFAULT;
+                goto err;
         }
 
         if (i915_gem_object_needs_bit17_swizzle(obj)) {
@@ -478,8 +491,8 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data,
                                                         file_priv);
         }
 
+err:
         drm_gem_object_unreference_unlocked(obj);
-
         return ret;
 }
 
@@ -568,8 +581,6 @@ i915_gem_gtt_pwrite_fast(struct drm_device *dev, struct drm_gem_object *obj,
 
         user_data = (char __user *) (uintptr_t) args->data_ptr;
         remain = args->size;
-        if (!access_ok(VERIFY_READ, user_data, remain))
-                return -EFAULT;
 
 
         mutex_lock(&dev->struct_mutex);
@@ -922,14 +933,17 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
                 return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
-        /* Bounds check destination.
-         *
-         * XXX: This could use review for overflow issues...
-         */
-        if (args->offset > obj->size || args->size > obj->size ||
-            args->offset + args->size > obj->size) {
-                drm_gem_object_unreference_unlocked(obj);
-                return -EINVAL;
+        /* Bounds check destination. */
+        if (args->offset > obj->size || args->size > obj->size - args->offset) {
+                ret = -EINVAL;
+                goto err;
+        }
+
+        if (!access_ok(VERIFY_READ,
+                       (char __user *)(uintptr_t)args->data_ptr,
+                       args->size)) {
+                ret = -EFAULT;
+                goto err;
         }
 
         /* We can only do the GTT pwrite on untiled buffers, as otherwise
@@ -963,8 +977,8 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
                 DRM_INFO("pwrite failed %d\n", ret);
 #endif
 
+err:
         drm_gem_object_unreference_unlocked(obj);
-
         return ret;
 }
 
@@ -1036,6 +1050,11 @@ i915_gem_set_domain_ioctl(struct drm_device *dev, void *data,
                 ret = i915_gem_object_set_to_cpu_domain(obj, write_domain != 0);
         }
 
+        
+        /* Maintain LRU order of "inactive" objects */
+        if (ret == 0 && i915_gem_object_is_inactive(obj_priv))
+                list_move_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
+
         drm_gem_object_unreference(obj);
         mutex_unlock(&dev->struct_mutex);
         return ret;
@@ -1137,7 +1156,7 @@ int i915_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
         struct drm_gem_object *obj = vma->vm_private_data;
         struct drm_device *dev = obj->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
+        drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_gem_object *obj_priv = to_intel_bo(obj);
         pgoff_t page_offset;
         unsigned long pfn;
@@ -1155,8 +1174,6 @@ int i915_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
                 if (ret)
                         goto unlock;
 
-                list_add_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
-
                 ret = i915_gem_object_set_to_gtt_domain(obj, write);
                 if (ret)
                         goto unlock;
@@ -1169,6 +1186,9 @@ int i915_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
                         goto unlock;
         }
 
+        if (i915_gem_object_is_inactive(obj_priv))
+                list_move_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
+
         pfn = ((dev->agp->base + obj_priv->gtt_offset) >> PAGE_SHIFT) +
                 page_offset;
 
@@ -1363,7 +1383,6 @@ i915_gem_mmap_gtt_ioctl(struct drm_device *dev, void *data,
                         struct drm_file *file_priv)
 {
         struct drm_i915_gem_mmap_gtt *args = data;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_gem_object *obj;
         struct drm_i915_gem_object *obj_priv;
         int ret;
@@ -1409,7 +1428,6 @@ i915_gem_mmap_gtt_ioctl(struct drm_device *dev, void *data,
                         mutex_unlock(&dev->struct_mutex);
                         return ret;
                 }
-                list_add_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
         }
 
         drm_gem_object_unreference(obj);
@@ -1493,9 +1511,16 @@ i915_gem_object_truncate(struct drm_gem_object *obj)
         struct drm_i915_gem_object *obj_priv = to_intel_bo(obj);
         struct inode *inode;
 
+        /* Our goal here is to return as much of the memory as
+         * is possible back to the system as we are called from OOM.
+         * To do this we must instruct the shmfs to drop all of its
+         * backing pages, *now*. Here we mirror the actions taken
+         * when by shmem_delete_inode() to release the backing store.
+         */
         inode = obj->filp->f_path.dentry->d_inode;
-        if (inode->i_op->truncate)
-                inode->i_op->truncate (inode);
+        truncate_inode_pages(inode->i_mapping, 0);
+        if (inode->i_op->truncate_range)
+                inode->i_op->truncate_range(inode, 0, (loff_t)-1);
 
         obj_priv->madv = __I915_MADV_PURGED;
 }
@@ -1887,19 +1912,6 @@ i915_gem_flush(struct drm_device *dev,
                                 flush_domains);
 }
 
-static void
-i915_gem_flush_ring(struct drm_device *dev,
-               uint32_t invalidate_domains,
-               uint32_t flush_domains,
-               struct intel_ring_buffer *ring)
-{
-        if (flush_domains & I915_GEM_DOMAIN_CPU)
-                drm_agp_chipset_flush(dev);
-        ring->flush(dev, ring,
-                        invalidate_domains,
-                        flush_domains);
-}
-
 /**
  * Ensures that all rendering to the object has completed and the object is
  * safe to unbind from the GTT or access from the CPU.
@@ -1973,8 +1985,6 @@ i915_gem_object_unbind(struct drm_gem_object *obj)
          * cause memory corruption through use-after-free.
          */
 
-        BUG_ON(obj_priv->active);
-
         /* release the fence reg _after_ flushing */
         if (obj_priv->fence_reg != I915_FENCE_REG_NONE)
                 i915_gem_clear_fence_reg(obj);
@@ -2010,34 +2020,7 @@ i915_gem_object_unbind(struct drm_gem_object *obj)
         return ret;
 }
 
-static struct drm_gem_object *
-i915_gem_find_inactive_object(struct drm_device *dev, int min_size)
-{
-        drm_i915_private_t *dev_priv = dev->dev_private;
-        struct drm_i915_gem_object *obj_priv;
-        struct drm_gem_object *best = NULL;
-        struct drm_gem_object *first = NULL;
-
-        /* Try to find the smallest clean object */
-        list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list, list) {
-                struct drm_gem_object *obj = &obj_priv->base;
-                if (obj->size >= min_size) {
-                        if ((!obj_priv->dirty ||
-                             i915_gem_object_is_purgeable(obj_priv)) &&
-                            (!best || obj->size < best->size)) {
-                                best = obj;
-                                if (best->size == min_size)
-                                        return best;
-                        }
-                        if (!first)
-                            first = obj;
-                }
-        }
-
-        return best ? best : first;
-}
-
-static int
+int
 i915_gpu_idle(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
@@ -2078,155 +2061,6 @@ i915_gpu_idle(struct drm_device *dev)
         return ret;
 }
 
-static int
-i915_gem_evict_everything(struct drm_device *dev)
-{
-        drm_i915_private_t *dev_priv = dev->dev_private;
-        int ret;
-        bool lists_empty;
-
-        spin_lock(&dev_priv->mm.active_list_lock);
-        lists_empty = (list_empty(&dev_priv->mm.inactive_list) &&
-                       list_empty(&dev_priv->mm.flushing_list) &&
-                       list_empty(&dev_priv->render_ring.active_list) &&
-                       (!HAS_BSD(dev)
-                        || list_empty(&dev_priv->bsd_ring.active_list)));
-        spin_unlock(&dev_priv->mm.active_list_lock);
-
-        if (lists_empty)
-                return -ENOSPC;
-
-        /* Flush everything (on to the inactive lists) and evict */
-        ret = i915_gpu_idle(dev);
-        if (ret)
-                return ret;
-
-        BUG_ON(!list_empty(&dev_priv->mm.flushing_list));
-
-        ret = i915_gem_evict_from_inactive_list(dev);
-        if (ret)
-                return ret;
-
-        spin_lock(&dev_priv->mm.active_list_lock);
-        lists_empty = (list_empty(&dev_priv->mm.inactive_list) &&
-                       list_empty(&dev_priv->mm.flushing_list) &&
-                       list_empty(&dev_priv->render_ring.active_list) &&
-                       (!HAS_BSD(dev)
-                        || list_empty(&dev_priv->bsd_ring.active_list)));
-        spin_unlock(&dev_priv->mm.active_list_lock);
-        BUG_ON(!lists_empty);
-
-        return 0;
-}
-
-static int
-i915_gem_evict_something(struct drm_device *dev, int min_size)
-{
-        drm_i915_private_t *dev_priv = dev->dev_private;
-        struct drm_gem_object *obj;
-        int ret;
-
-        struct intel_ring_buffer *render_ring = &dev_priv->render_ring;
-        struct intel_ring_buffer *bsd_ring = &dev_priv->bsd_ring;
-        for (;;) {
-                i915_gem_retire_requests(dev);
-
-                /* If there's an inactive buffer available now, grab it
-                 * and be done.
-                 */
-                obj = i915_gem_find_inactive_object(dev, min_size);
-                if (obj) {
-                        struct drm_i915_gem_object *obj_priv;
-
-#if WATCH_LRU
-                        DRM_INFO("%s: evicting %p\n", __func__, obj);
-#endif
-                        obj_priv = to_intel_bo(obj);
-                        BUG_ON(obj_priv->pin_count != 0);
-                        BUG_ON(obj_priv->active);
-
-                        /* Wait on the rendering and unbind the buffer. */
-                        return i915_gem_object_unbind(obj);
-                }
-
-                /* If we didn't get anything, but the ring is still processing
-                 * things, wait for the next to finish and hopefully leave us
-                 * a buffer to evict.
-                 */
-                if (!list_empty(&render_ring->request_list)) {
-                        struct drm_i915_gem_request *request;
-
-                        request = list_first_entry(&render_ring->request_list,
-                                                   struct drm_i915_gem_request,
-                                                   list);
-
-                        ret = i915_wait_request(dev,
-                                        request->seqno, request->ring);
-                        if (ret)
-                                return ret;
-
-                        continue;
-                }
-
-                if (HAS_BSD(dev) && !list_empty(&bsd_ring->request_list)) {
-                        struct drm_i915_gem_request *request;
-
-                        request = list_first_entry(&bsd_ring->request_list,
-                                                   struct drm_i915_gem_request,
-                                                   list);
-
-                        ret = i915_wait_request(dev,
-                                        request->seqno, request->ring);
-                        if (ret)
-                                return ret;
-
-                        continue;
-                }
-
-                /* If we didn't have anything on the request list but there
-                 * are buffers awaiting a flush, emit one and try again.
-                 * When we wait on it, those buffers waiting for that flush
-                 * will get moved to inactive.
-                 */
-                if (!list_empty(&dev_priv->mm.flushing_list)) {
-                        struct drm_i915_gem_object *obj_priv;
-
-                        /* Find an object that we can immediately reuse */
-                        list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list, list) {
-                                obj = &obj_priv->base;
-                                if (obj->size >= min_size)
-                                        break;
-
-                                obj = NULL;
-                        }
-
-                        if (obj != NULL) {
-                                uint32_t seqno;
-
-                                i915_gem_flush_ring(dev,
-                                               obj->write_domain,
-                                               obj->write_domain,
-                                               obj_priv->ring);
-                                seqno = i915_add_request(dev, NULL,
-                                                obj->write_domain,
-                                                obj_priv->ring);
-                                if (seqno == 0)
-                                        return -ENOMEM;
-                                continue;
-                        }
-                }
-
-                /* If we didn't do any of the above, there's no single buffer
-                 * large enough to swap out for the new one, so just evict
-                 * everything and start again. (This should be rare.)
-                 */
-                if (!list_empty (&dev_priv->mm.inactive_list))
-                        return i915_gem_evict_from_inactive_list(dev);
-                else
-                        return i915_gem_evict_everything(dev);
-        }
-}
-
 int
 i915_gem_object_get_pages(struct drm_gem_object *obj,
                           gfp_t gfpmask)
@@ -2519,14 +2353,21 @@ i915_gem_object_get_fence_reg(struct drm_gem_object *obj)
 
         reg->obj = obj;
 
-        if (IS_GEN6(dev))
+        switch (INTEL_INFO(dev)->gen) {
+        case 6:
                 sandybridge_write_fence_reg(reg);
-        else if (IS_I965G(dev))
+                break;
+        case 5:
+        case 4:
                 i965_write_fence_reg(reg);
-        else if (IS_I9XX(dev))
+                break;
+        case 3:
                 i915_write_fence_reg(reg);
-        else
+                break;
+        case 2:
                 i830_write_fence_reg(reg);
+                break;
+        }
 
         trace_i915_gem_object_get_fence(obj, obj_priv->fence_reg,
                         obj_priv->tiling_mode);
@@ -2549,22 +2390,26 @@ i915_gem_clear_fence_reg(struct drm_gem_object *obj)
         struct drm_i915_gem_object *obj_priv = to_intel_bo(obj);
         struct drm_i915_fence_reg *reg =
                 &dev_priv->fence_regs[obj_priv->fence_reg];
+        uint32_t fence_reg;
 
-        if (IS_GEN6(dev)) {
+        switch (INTEL_INFO(dev)->gen) {
+        case 6:
                 I915_WRITE64(FENCE_REG_SANDYBRIDGE_0 +
                              (obj_priv->fence_reg * 8), 0);
-        } else if (IS_I965G(dev)) {
+                break;
+        case 5:
+        case 4:
                 I915_WRITE64(FENCE_REG_965_0 + (obj_priv->fence_reg * 8), 0);
-        } else {
-                uint32_t fence_reg;
-
-                if (obj_priv->fence_reg < 8)
-                        fence_reg = FENCE_REG_830_0 + obj_priv->fence_reg * 4;
+                break;
+        case 3:
+                if (obj_priv->fence_reg >= 8)
+                        fence_reg = FENCE_REG_945_8 + (obj_priv->fence_reg - 8) * 4;
                 else
-                        fence_reg = FENCE_REG_945_8 + (obj_priv->fence_reg -
-                                                       8) * 4;
+        case 2:
+                        fence_reg = FENCE_REG_830_0 + obj_priv->fence_reg * 4;
 
                 I915_WRITE(fence_reg, 0);
+                break;
         }
 
         reg->obj = NULL;
@@ -2666,7 +2511,7 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
 #if WATCH_LRU
                 DRM_INFO("%s: GTT full, evicting something\n", __func__);
 #endif
-                ret = i915_gem_evict_something(dev, obj->size);
+                ret = i915_gem_evict_something(dev, obj->size, alignment);
                 if (ret)
                         return ret;
 
@@ -2684,7 +2529,8 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
 
                 if (ret == -ENOMEM) {
                         /* first try to clear up some space from the GTT */
-                        ret = i915_gem_evict_something(dev, obj->size);
+                        ret = i915_gem_evict_something(dev, obj->size,
+                                                       alignment);
                         if (ret) {
                                 /* now try to shrink everyone else */
                                 if (gfpmask) {
@@ -2714,7 +2560,7 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
                 drm_mm_put_block(obj_priv->gtt_space);
                 obj_priv->gtt_space = NULL;
 
-                ret = i915_gem_evict_something(dev, obj->size);
+                ret = i915_gem_evict_something(dev, obj->size, alignment);
                 if (ret)
                         return ret;
 
@@ -2723,6 +2569,9 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
         atomic_inc(&dev->gtt_count);
         atomic_add(obj->size, &dev->gtt_memory);
 
+        /* keep track of bounds object by adding it to the inactive list */
+        list_add_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
+
         /* Assert that the object is not currently in any GPU domain. As it
          * wasn't in the GTT, there shouldn't be any way it could have been in
          * a GPU cache
@@ -3117,6 +2966,7 @@ static void
 i915_gem_object_set_to_gpu_domain(struct drm_gem_object *obj)
 {
         struct drm_device               *dev = obj->dev;
+        drm_i915_private_t              *dev_priv = dev->dev_private;
         struct drm_i915_gem_object      *obj_priv = to_intel_bo(obj);
         uint32_t                        invalidate_domains = 0;
         uint32_t                        flush_domains = 0;
@@ -3179,6 +3029,13 @@ i915_gem_object_set_to_gpu_domain(struct drm_gem_object *obj)
                 obj->pending_write_domain = obj->write_domain;
         obj->read_domains = obj->pending_read_domains;
 
+        if (flush_domains & I915_GEM_GPU_DOMAINS) {
+                if (obj_priv->ring == &dev_priv->render_ring)
+                        dev_priv->flush_rings |= FLUSH_RENDER_RING;
+                else if (obj_priv->ring == &dev_priv->bsd_ring)
+                        dev_priv->flush_rings |= FLUSH_BSD_RING;
+        }
+
         dev->invalidate_domains |= invalidate_domains;
         dev->flush_domains |= flush_domains;
 #if WATCH_BUF
@@ -3403,6 +3260,8 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
                                   (int) reloc->offset,
                                   reloc->read_domains,
                                   reloc->write_domain);
+                        drm_gem_object_unreference(target_obj);
+                        i915_gem_object_unpin(obj);
                         return -EINVAL;
                 }
                 if (reloc->write_domain & I915_GEM_DOMAIN_CPU ||
@@ -3718,7 +3577,6 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
                 ring = &dev_priv->render_ring;
         }
 
-
         if (args->buffer_count < 1) {
                 DRM_ERROR("execbuf with %d buffers\n", args->buffer_count);
                 return -EINVAL;
@@ -3746,6 +3604,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
                 if (ret != 0) {
                         DRM_ERROR("copy %d cliprects failed: %d\n",
                                   args->num_cliprects, ret);
+                        ret = -EFAULT;
                         goto pre_mutex_err;
                 }
         }
@@ -3892,6 +3751,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
          */
         dev->invalidate_domains = 0;
         dev->flush_domains = 0;
+        dev_priv->flush_rings = 0;
 
         for (i = 0; i < args->buffer_count; i++) {
                 struct drm_gem_object *obj = object_list[i];
@@ -3912,16 +3772,14 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
                 i915_gem_flush(dev,
                                dev->invalidate_domains,
                                dev->flush_domains);
-                if (dev->flush_domains & I915_GEM_GPU_DOMAINS) {
+                if (dev_priv->flush_rings & FLUSH_RENDER_RING)
                         (void)i915_add_request(dev, file_priv,
-                                        dev->flush_domains,
-                                        &dev_priv->render_ring);
-
-                        if (HAS_BSD(dev))
-                                (void)i915_add_request(dev, file_priv,
-                                                dev->flush_domains,
-                                                &dev_priv->bsd_ring);
-                }
+                                               dev->flush_domains,
+                                               &dev_priv->render_ring);
+                if (dev_priv->flush_rings & FLUSH_BSD_RING)
+                        (void)i915_add_request(dev, file_priv,
+                                               dev->flush_domains,
+                                               &dev_priv->bsd_ring);
         }
 
         for (i = 0; i < args->buffer_count; i++) {
@@ -4192,6 +4050,10 @@ i915_gem_object_pin(struct drm_gem_object *obj, uint32_t alignment)
                 if (alignment == 0)
                         alignment = i915_gem_get_gtt_alignment(obj);
                 if (obj_priv->gtt_offset & (alignment - 1)) {
+                        WARN(obj_priv->pin_count,
+                             "bo is already pinned with incorrect alignment:"
+                             " offset=%x, req.alignment=%x\n",
+                             obj_priv->gtt_offset, alignment);
                         ret = i915_gem_object_unbind(obj);
                         if (ret)
                                 return ret;
@@ -4213,8 +4075,7 @@ i915_gem_object_pin(struct drm_gem_object *obj, uint32_t alignment)
                 atomic_inc(&dev->pin_count);
                 atomic_add(obj->size, &dev->pin_memory);
                 if (!obj_priv->active &&
-                    (obj->write_domain & I915_GEM_GPU_DOMAINS) == 0 &&
-                    !list_empty(&obj_priv->list))
+                    (obj->write_domain & I915_GEM_GPU_DOMAINS) == 0)
                         list_del_init(&obj_priv->list);
         }
         i915_verify_inactive(dev, __FILE__, __LINE__);
@@ -4359,22 +4220,34 @@ i915_gem_busy_ioctl(struct drm_device *dev, void *data,
         }
 
         mutex_lock(&dev->struct_mutex);
-        /* Update the active list for the hardware's current position.
-         * Otherwise this only updates on a delayed timer or when irqs are
-         * actually unmasked, and our working set ends up being larger than
-         * required.
-         */
-        i915_gem_retire_requests(dev);
 
-        obj_priv = to_intel_bo(obj);
-        /* Don't count being on the flushing list against the object being
-         * done.  Otherwise, a buffer left on the flushing list but not getting
-         * flushed (because nobody's flushing that domain) won't ever return
-         * unbusy and get reused by libdrm's bo cache.  The other expected
-         * consumer of this interface, OpenGL's occlusion queries, also specs
-         * that the objects get unbusy "eventually" without any interference.
+        /* Count all active objects as busy, even if they are currently not used
+         * by the gpu. Users of this interface expect objects to eventually
+         * become non-busy without any further actions, therefore emit any
+         * necessary flushes here.
          */
-        args->busy = obj_priv->active && obj_priv->last_rendering_seqno != 0;
+        obj_priv = to_intel_bo(obj);
+        args->busy = obj_priv->active;
+        if (args->busy) {
+                /* Unconditionally flush objects, even when the gpu still uses this
+                 * object. Userspace calling this function indicates that it wants to
+                 * use this buffer rather sooner than later, so issuing the required
+                 * flush earlier is beneficial.
+                 */
+                if (obj->write_domain) {
+                        i915_gem_flush(dev, 0, obj->write_domain);
+                        (void)i915_add_request(dev, file_priv, obj->write_domain, obj_priv->ring);
+                }
+
+                /* Update the active list for the hardware's current position.
+                 * Otherwise this only updates on a delayed timer or when irqs
+                 * are actually unmasked, and our working set ends up being
+                 * larger than required.
+                 */
+                i915_gem_retire_requests_ring(dev, obj_priv->ring);
+
+                args->busy = obj_priv->active;
+        }
 
         drm_gem_object_unreference(obj);
         mutex_unlock(&dev->struct_mutex);
@@ -4514,30 +4387,6 @@ void i915_gem_free_object(struct drm_gem_object *obj)
         i915_gem_free_object_tail(obj);
 }
 
-/** Unbinds all inactive objects. */
-static int
-i915_gem_evict_from_inactive_list(struct drm_device *dev)
-{
-        drm_i915_private_t *dev_priv = dev->dev_private;
-
-        while (!list_empty(&dev_priv->mm.inactive_list)) {
-                struct drm_gem_object *obj;
-                int ret;
-
-                obj = &list_first_entry(&dev_priv->mm.inactive_list,
-                                        struct drm_i915_gem_object,
-                                        list)->base;
-
-                ret = i915_gem_object_unbind(obj);
-                if (ret != 0) {
-                        DRM_ERROR("Error unbinding object: %d\n", ret);
-                        return ret;
-                }
-        }
-
-        return 0;
-}
-
 int
 i915_gem_idle(struct drm_device *dev)
 {
@@ -4562,7 +4411,7 @@ i915_gem_idle(struct drm_device *dev)
 
         /* Under UMS, be paranoid and evict. */
         if (!drm_core_check_feature(dev, DRIVER_MODESET)) {
-                ret = i915_gem_evict_from_inactive_list(dev);
+                ret = i915_gem_evict_inactive(dev);
                 if (ret) {
                         mutex_unlock(&dev->struct_mutex);
                         return ret;
@@ -4680,6 +4529,8 @@ i915_gem_init_ringbuffer(struct drm_device *dev)
                         goto cleanup_render_ring;
         }
 
+        dev_priv->next_seqno = 1;
+
         return 0;
 
 cleanup_render_ring:
@@ -4841,7 +4692,7 @@ i915_gem_load(struct drm_device *dev)
  * e.g. for cursor + overlay regs
  */
 int i915_gem_init_phys_object(struct drm_device *dev,
-                              int id, int size)
+                              int id, int size, int align)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_gem_phys_object *phys_obj;
@@ -4856,7 +4707,7 @@ int i915_gem_init_phys_object(struct drm_device *dev,
 
         phys_obj->id = id;
 
-        phys_obj->handle = drm_pci_alloc(dev, size, 0);
+        phys_obj->handle = drm_pci_alloc(dev, size, align);
         if (!phys_obj->handle) {
                 ret = -ENOMEM;
                 goto kfree_obj;
@@ -4938,7 +4789,9 @@ out:
 
 int
 i915_gem_attach_phys_object(struct drm_device *dev,
-                            struct drm_gem_object *obj, int id)
+                            struct drm_gem_object *obj,
+                            int id,
+                            int align)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_gem_object *obj_priv;
@@ -4957,11 +4810,10 @@ i915_gem_attach_phys_object(struct drm_device *dev,
                 i915_gem_detach_phys_object(dev, obj);
         }
 
-
         /* create a new object */
         if (!dev_priv->mm.phys_objs[id - 1]) {
                 ret = i915_gem_init_phys_object(dev, id,
-                                                obj->size);
+                                                obj->size, align);
                 if (ret) {
                         DRM_ERROR("failed to init phys object %d size: %zu\n", id, obj->size);
                         goto out;
diff --git a/drivers/gpu/drm/i915/i915_gem_evict.c b/drivers/gpu/drm/i915/i915_gem_evict.c
new file mode 100644
index 000000000000..5c428fa3e0b3
--- /dev/null
+++ b/drivers/gpu/drm/i915/i915_gem_evict.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright © 2008-2010 Intel Corporation
+ *
+ * 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 (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 NONINFRINGEMENT.  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.
+ *
+ * Authors:
+ *    Eric Anholt <eric@anholt.net>
+ *    Chris Wilson <chris@chris-wilson.co.uuk>
+ *
+ */
+
+#include "drmP.h"
+#include "drm.h"
+#include "i915_drv.h"
+#include "i915_drm.h"
+
+static struct drm_i915_gem_object *
+i915_gem_next_active_object(struct drm_device *dev,
+                            struct list_head **render_iter,
+                            struct list_head **bsd_iter)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_i915_gem_object *render_obj = NULL, *bsd_obj = NULL;
+
+        if (*render_iter != &dev_priv->render_ring.active_list)
+                render_obj = list_entry(*render_iter,
+                                        struct drm_i915_gem_object,
+                                        list);
+
+        if (HAS_BSD(dev)) {
+                if (*bsd_iter != &dev_priv->bsd_ring.active_list)
+                        bsd_obj = list_entry(*bsd_iter,
+                                             struct drm_i915_gem_object,
+                                             list);
+
+                if (render_obj == NULL) {
+                        *bsd_iter = (*bsd_iter)->next;
+                        return bsd_obj;
+                }
+
+                if (bsd_obj == NULL) {
+                        *render_iter = (*render_iter)->next;
+                        return render_obj;
+                }
+
+                /* XXX can we handle seqno wrapping? */
+                if (render_obj->last_rendering_seqno < bsd_obj->last_rendering_seqno) {
+                        *render_iter = (*render_iter)->next;
+                        return render_obj;
+                } else {
+                        *bsd_iter = (*bsd_iter)->next;
+                        return bsd_obj;
+                }
+        } else {
+                *render_iter = (*render_iter)->next;
+                return render_obj;
+        }
+}
+
+static bool
+mark_free(struct drm_i915_gem_object *obj_priv,
+           struct list_head *unwind)
+{
+        list_add(&obj_priv->evict_list, unwind);
+        drm_gem_object_reference(&obj_priv->base);
+        return drm_mm_scan_add_block(obj_priv->gtt_space);
+}
+
+#define i915_for_each_active_object(OBJ, R, B) \
+        *(R) = dev_priv->render_ring.active_list.next; \
+        *(B) = dev_priv->bsd_ring.active_list.next; \
+        while (((OBJ) = i915_gem_next_active_object(dev, (R), (B))) != NULL)
+
+int
+i915_gem_evict_something(struct drm_device *dev, int min_size, unsigned alignment)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct list_head eviction_list, unwind_list;
+        struct drm_i915_gem_object *obj_priv;
+        struct list_head *render_iter, *bsd_iter;
+        int ret = 0;
+
+        i915_gem_retire_requests(dev);
+
+        /* Re-check for free space after retiring requests */
+        if (drm_mm_search_free(&dev_priv->mm.gtt_space,
+                               min_size, alignment, 0))
+                return 0;
+
+        /*
+         * The goal is to evict objects and amalgamate space in LRU order.
+         * The oldest idle objects reside on the inactive list, which is in
+         * retirement order. The next objects to retire are those on the (per
+         * ring) active list that do not have an outstanding flush. Once the
+         * hardware reports completion (the seqno is updated after the
+         * batchbuffer has been finished) the clean buffer objects would
+         * be retired to the inactive list. Any dirty objects would be added
+         * to the tail of the flushing list. So after processing the clean
+         * active objects we need to emit a MI_FLUSH to retire the flushing
+         * list, hence the retirement order of the flushing list is in
+         * advance of the dirty objects on the active lists.
+         *
+         * The retirement sequence is thus:
+         *   1. Inactive objects (already retired)
+         *   2. Clean active objects
+         *   3. Flushing list
+         *   4. Dirty active objects.
+         *
+         * On each list, the oldest objects lie at the HEAD with the freshest
+         * object on the TAIL.
+         */
+
+        INIT_LIST_HEAD(&unwind_list);
+        drm_mm_init_scan(&dev_priv->mm.gtt_space, min_size, alignment);
+
+        /* First see if there is a large enough contiguous idle region... */
+        list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list, list) {
+                if (mark_free(obj_priv, &unwind_list))
+                        goto found;
+        }
+
+        /* Now merge in the soon-to-be-expired objects... */
+        i915_for_each_active_object(obj_priv, &render_iter, &bsd_iter) {
+                /* Does the object require an outstanding flush? */
+                if (obj_priv->base.write_domain || obj_priv->pin_count)
+                        continue;
+
+                if (mark_free(obj_priv, &unwind_list))
+                        goto found;
+        }
+
+        /* Finally add anything with a pending flush (in order of retirement) */
+        list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list, list) {
+                if (obj_priv->pin_count)
+                        continue;
+
+                if (mark_free(obj_priv, &unwind_list))
+                        goto found;
+        }
+        i915_for_each_active_object(obj_priv, &render_iter, &bsd_iter) {
+                if (! obj_priv->base.write_domain || obj_priv->pin_count)
+                        continue;
+
+                if (mark_free(obj_priv, &unwind_list))
+                        goto found;
+        }
+
+        /* Nothing found, clean up and bail out! */
+        list_for_each_entry(obj_priv, &unwind_list, evict_list) {
+                ret = drm_mm_scan_remove_block(obj_priv->gtt_space);
+                BUG_ON(ret);
+                drm_gem_object_unreference(&obj_priv->base);
+        }
+
+        /* We expect the caller to unpin, evict all and try again, or give up.
+         * So calling i915_gem_evict_everything() is unnecessary.
+         */
+        return -ENOSPC;
+
+found:
+        /* drm_mm doesn't allow any other other operations while
+         * scanning, therefore store to be evicted objects on a
+         * temporary list. */
+        INIT_LIST_HEAD(&eviction_list);
+        while (!list_empty(&unwind_list)) {
+                obj_priv = list_first_entry(&unwind_list,
+                                            struct drm_i915_gem_object,
+                                            evict_list);
+                if (drm_mm_scan_remove_block(obj_priv->gtt_space)) {
+                        list_move(&obj_priv->evict_list, &eviction_list);
+                        continue;
+                }
+                list_del(&obj_priv->evict_list);
+                drm_gem_object_unreference(&obj_priv->base);
+        }
+
+        /* Unbinding will emit any required flushes */
+        while (!list_empty(&eviction_list)) {
+                obj_priv = list_first_entry(&eviction_list,
+                                            struct drm_i915_gem_object,
+                                            evict_list);
+                if (ret == 0)
+                        ret = i915_gem_object_unbind(&obj_priv->base);
+                list_del(&obj_priv->evict_list);
+                drm_gem_object_unreference(&obj_priv->base);
+        }
+
+        return ret;
+}
+
+int
+i915_gem_evict_everything(struct drm_device *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        int ret;
+        bool lists_empty;
+
+        spin_lock(&dev_priv->mm.active_list_lock);
+        lists_empty = (list_empty(&dev_priv->mm.inactive_list) &&
+                       list_empty(&dev_priv->mm.flushing_list) &&
+                       list_empty(&dev_priv->render_ring.active_list) &&
+                       (!HAS_BSD(dev)
+                        || list_empty(&dev_priv->bsd_ring.active_list)));
+        spin_unlock(&dev_priv->mm.active_list_lock);
+
+        if (lists_empty)
+                return -ENOSPC;
+
+        /* Flush everything (on to the inactive lists) and evict */
+        ret = i915_gpu_idle(dev);
+        if (ret)
+                return ret;
+
+        BUG_ON(!list_empty(&dev_priv->mm.flushing_list));
+
+        ret = i915_gem_evict_inactive(dev);
+        if (ret)
+                return ret;
+
+        spin_lock(&dev_priv->mm.active_list_lock);
+        lists_empty = (list_empty(&dev_priv->mm.inactive_list) &&
+                       list_empty(&dev_priv->mm.flushing_list) &&
+                       list_empty(&dev_priv->render_ring.active_list) &&
+                       (!HAS_BSD(dev)
+                        || list_empty(&dev_priv->bsd_ring.active_list)));
+        spin_unlock(&dev_priv->mm.active_list_lock);
+        BUG_ON(!lists_empty);
+
+        return 0;
+}
+
+/** Unbinds all inactive objects. */
+int
+i915_gem_evict_inactive(struct drm_device *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+
+        while (!list_empty(&dev_priv->mm.inactive_list)) {
+                struct drm_gem_object *obj;
+                int ret;
+
+                obj = &list_first_entry(&dev_priv->mm.inactive_list,
+                                        struct drm_i915_gem_object,
+                                        list)->base;
+
+                ret = i915_gem_object_unbind(obj);
+                if (ret != 0) {
+                        DRM_ERROR("Error unbinding object: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 85785a8844ed..744225ebb4b2 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -425,9 +425,11 @@ static struct drm_i915_error_object *
 i915_error_object_create(struct drm_device *dev,
                          struct drm_gem_object *src)
 {
+        drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_error_object *dst;
         struct drm_i915_gem_object *src_priv;
         int page, page_count;
+        u32 reloc_offset;
 
         if (src == NULL)
                 return NULL;
@@ -442,18 +444,27 @@ i915_error_object_create(struct drm_device *dev,
         if (dst == NULL)
                 return NULL;
 
+        reloc_offset = src_priv->gtt_offset;
         for (page = 0; page < page_count; page++) {
-                void *s, *d = kmalloc(PAGE_SIZE, GFP_ATOMIC);
                 unsigned long flags;
+                void __iomem *s;
+                void *d;
 
+                d = kmalloc(PAGE_SIZE, GFP_ATOMIC);
                 if (d == NULL)
                         goto unwind;
+
                 local_irq_save(flags);
-                s = kmap_atomic(src_priv->pages[page], KM_IRQ0);
-                memcpy(d, s, PAGE_SIZE);
-                kunmap_atomic(s, KM_IRQ0);
+                s = io_mapping_map_atomic_wc(dev_priv->mm.gtt_mapping,
+                                             reloc_offset,
+                                             KM_IRQ0);
+                memcpy_fromio(d, s, PAGE_SIZE);
+                io_mapping_unmap_atomic(s, KM_IRQ0);
                 local_irq_restore(flags);
+
                 dst->pages[page] = d;
+
+                reloc_offset += PAGE_SIZE;
         }
         dst->page_count = page_count;
         dst->gtt_offset = src_priv->gtt_offset;
@@ -489,6 +500,7 @@ i915_error_state_free(struct drm_device *dev,
         i915_error_object_free(error->batchbuffer[1]);
         i915_error_object_free(error->ringbuffer);
         kfree(error->active_bo);
+        kfree(error->overlay);
         kfree(error);
 }
 
@@ -612,18 +624,57 @@ static void i915_capture_error_state(struct drm_device *dev)
 
                 if (batchbuffer[1] == NULL &&
                     error->acthd >= obj_priv->gtt_offset &&
-                    error->acthd < obj_priv->gtt_offset + obj->size &&
-                    batchbuffer[0] != obj)
+                    error->acthd < obj_priv->gtt_offset + obj->size)
                         batchbuffer[1] = obj;
 
                 count++;
         }
+        /* Scan the other lists for completeness for those bizarre errors. */
+        if (batchbuffer[0] == NULL || batchbuffer[1] == NULL) {
+                list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list, list) {
+                        struct drm_gem_object *obj = &obj_priv->base;
+
+                        if (batchbuffer[0] == NULL &&
+                            bbaddr >= obj_priv->gtt_offset &&
+                            bbaddr < obj_priv->gtt_offset + obj->size)
+                                batchbuffer[0] = obj;
+
+                        if (batchbuffer[1] == NULL &&
+                            error->acthd >= obj_priv->gtt_offset &&
+                            error->acthd < obj_priv->gtt_offset + obj->size)
+                                batchbuffer[1] = obj;
+
+                        if (batchbuffer[0] && batchbuffer[1])
+                                break;
+                }
+        }
+        if (batchbuffer[0] == NULL || batchbuffer[1] == NULL) {
+                list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list, list) {
+                        struct drm_gem_object *obj = &obj_priv->base;
+
+                        if (batchbuffer[0] == NULL &&
+                            bbaddr >= obj_priv->gtt_offset &&
+                            bbaddr < obj_priv->gtt_offset + obj->size)
+                                batchbuffer[0] = obj;
+
+                        if (batchbuffer[1] == NULL &&
+                            error->acthd >= obj_priv->gtt_offset &&
+                            error->acthd < obj_priv->gtt_offset + obj->size)
+                                batchbuffer[1] = obj;
+
+                        if (batchbuffer[0] && batchbuffer[1])
+                                break;
+                }
+        }
 
         /* We need to copy these to an anonymous buffer as the simplest
          * method to avoid being overwritten by userpace.
          */
         error->batchbuffer[0] = i915_error_object_create(dev, batchbuffer[0]);
-        error->batchbuffer[1] = i915_error_object_create(dev, batchbuffer[1]);
+        if (batchbuffer[1] != batchbuffer[0])
+                error->batchbuffer[1] = i915_error_object_create(dev, batchbuffer[1]);
+        else
+                error->batchbuffer[1] = NULL;
 
         /* Record the ringbuffer */
         error->ringbuffer = i915_error_object_create(dev,
@@ -667,6 +718,8 @@ static void i915_capture_error_state(struct drm_device *dev)
 
         do_gettimeofday(&error->time);
 
+        error->overlay = intel_overlay_capture_error_state(dev);
+
         spin_lock_irqsave(&dev_priv->error_lock, flags);
         if (dev_priv->first_error == NULL) {
                 dev_priv->first_error = error;
@@ -834,6 +887,49 @@ static void i915_handle_error(struct drm_device *dev, bool wedged)
         queue_work(dev_priv->wq, &dev_priv->error_work);
 }
 
+static void i915_pageflip_stall_check(struct drm_device *dev, int pipe)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_crtc *crtc = dev_priv->pipe_to_crtc_mapping[pipe];
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct drm_i915_gem_object *obj_priv;
+        struct intel_unpin_work *work;
+        unsigned long flags;
+        bool stall_detected;
+
+        /* Ignore early vblank irqs */
+        if (intel_crtc == NULL)
+                return;
+
+        spin_lock_irqsave(&dev->event_lock, flags);
+        work = intel_crtc->unpin_work;
+
+        if (work == NULL || work->pending || !work->enable_stall_check) {
+                /* Either the pending flip IRQ arrived, or we're too early. Don't check */
+                spin_unlock_irqrestore(&dev->event_lock, flags);
+                return;
+        }
+
+        /* Potential stall - if we see that the flip has happened, assume a missed interrupt */
+        obj_priv = to_intel_bo(work->pending_flip_obj);
+        if(IS_I965G(dev)) {
+                int dspsurf = intel_crtc->plane == 0 ? DSPASURF : DSPBSURF;
+                stall_detected = I915_READ(dspsurf) == obj_priv->gtt_offset;
+        } else {
+                int dspaddr = intel_crtc->plane == 0 ? DSPAADDR : DSPBADDR;
+                stall_detected = I915_READ(dspaddr) == (obj_priv->gtt_offset +
+                                                        crtc->y * crtc->fb->pitch +
+                                                        crtc->x * crtc->fb->bits_per_pixel/8);
+        }
+
+        spin_unlock_irqrestore(&dev->event_lock, flags);
+
+        if (stall_detected) {
+                DRM_DEBUG_DRIVER("Pageflip stall detected\n");
+                intel_prepare_page_flip(dev, intel_crtc->plane);
+        }
+}
+
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
         struct drm_device *dev = (struct drm_device *) arg;
@@ -951,15 +1047,19 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
                 if (pipea_stats & vblank_status) {
                         vblank++;
                         drm_handle_vblank(dev, 0);
-                        if (!dev_priv->flip_pending_is_done)
+                        if (!dev_priv->flip_pending_is_done) {
+                                i915_pageflip_stall_check(dev, 0);
                                 intel_finish_page_flip(dev, 0);
+                        }
                 }
 
                 if (pipeb_stats & vblank_status) {
                         vblank++;
                         drm_handle_vblank(dev, 1);
-                        if (!dev_priv->flip_pending_is_done)
+                        if (!dev_priv->flip_pending_is_done) {
+                                i915_pageflip_stall_check(dev, 1);
                                 intel_finish_page_flip(dev, 1);
+                        }
                 }
 
                 if ((pipea_stats & PIPE_LEGACY_BLC_EVENT_STATUS) ||
@@ -1250,7 +1350,25 @@ void i915_hangcheck_elapsed(unsigned long data)
                 i915_seqno_passed(i915_get_gem_seqno(dev,
                                 &dev_priv->render_ring),
                         i915_get_tail_request(dev)->seqno)) {
+                bool missed_wakeup = false;
+
                 dev_priv->hangcheck_count = 0;
+
+                /* Issue a wake-up to catch stuck h/w. */
+                if (dev_priv->render_ring.waiting_gem_seqno &&
+                    waitqueue_active(&dev_priv->render_ring.irq_queue)) {
+                        DRM_WAKEUP(&dev_priv->render_ring.irq_queue);
+                        missed_wakeup = true;
+                }
+
+                if (dev_priv->bsd_ring.waiting_gem_seqno &&
+                    waitqueue_active(&dev_priv->bsd_ring.irq_queue)) {
+                        DRM_WAKEUP(&dev_priv->bsd_ring.irq_queue);
+                        missed_wakeup = true;
+                }
+
+                if (missed_wakeup)
+                        DRM_ERROR("Hangcheck timer elapsed... GPU idle, missed IRQ.\n");
                 return;
         }
 
@@ -1318,12 +1436,17 @@ static int ironlake_irq_postinstall(struct drm_device *dev)
         I915_WRITE(DEIER, dev_priv->de_irq_enable_reg);
         (void) I915_READ(DEIER);
 
-        /* user interrupt should be enabled, but masked initial */
+        /* Gen6 only needs render pipe_control now */
+        if (IS_GEN6(dev))
+                render_mask = GT_PIPE_NOTIFY;
+
         dev_priv->gt_irq_mask_reg = ~render_mask;
         dev_priv->gt_irq_enable_reg = render_mask;
 
         I915_WRITE(GTIIR, I915_READ(GTIIR));
         I915_WRITE(GTIMR, dev_priv->gt_irq_mask_reg);
+        if (IS_GEN6(dev))
+                I915_WRITE(GEN6_RENDER_IMR, ~GEN6_RENDER_PIPE_CONTROL_NOTIFY_INTERRUPT);
         I915_WRITE(GTIER, dev_priv->gt_irq_enable_reg);
         (void) I915_READ(GTIER);
 
diff --git a/drivers/gpu/drm/i915/i915_opregion.c b/drivers/gpu/drm/i915/i915_opregion.c
index d1bf92b99788..ea5d3fea4b61 100644
--- a/drivers/gpu/drm/i915/i915_opregion.c
+++ b/drivers/gpu/drm/i915/i915_opregion.c
@@ -114,10 +114,6 @@ struct opregion_asle {
 #define ASLE_REQ_MSK           0xf
 
 /* response bits of ASLE irq request */
-#define ASLE_ALS_ILLUM_FAIL    (2<<10)
-#define ASLE_BACKLIGHT_FAIL    (2<<12)
-#define ASLE_PFIT_FAIL         (2<<14)
-#define ASLE_PWM_FREQ_FAIL     (2<<16)
 #define ASLE_ALS_ILLUM_FAILED   (1<<10)
 #define ASLE_BACKLIGHT_FAILED   (1<<12)
 #define ASLE_PFIT_FAILED        (1<<14)
@@ -155,11 +151,11 @@ static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
         u32 max_backlight, level, shift;
 
         if (!(bclp & ASLE_BCLP_VALID))
-                return ASLE_BACKLIGHT_FAIL;
+                return ASLE_BACKLIGHT_FAILED;
 
         bclp &= ASLE_BCLP_MSK;
         if (bclp < 0 || bclp > 255)
-                return ASLE_BACKLIGHT_FAIL;
+                return ASLE_BACKLIGHT_FAILED;
 
         blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
         blc_pwm_ctl2 = I915_READ(BLC_PWM_CTL2);
@@ -211,7 +207,7 @@ static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
         /* Panel fitting is currently controlled by the X code, so this is a
            noop until modesetting support works fully */
         if (!(pfit & ASLE_PFIT_VALID))
-                return ASLE_PFIT_FAIL;
+                return ASLE_PFIT_FAILED;
         return 0;
 }
 
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index 281db6e5403a..4f5e15577e89 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -170,6 +170,7 @@
 #define   MI_NO_WRITE_FLUSH     (1 << 2)
 #define   MI_SCENE_COUNT        (1 << 3) /* just increment scene count */
 #define   MI_END_SCENE          (1 << 4) /* flush binner and incr scene count */
+#define   MI_INVALIDATE_ISP     (1 << 5) /* invalidate indirect state pointers */
 #define MI_BATCH_BUFFER_END     MI_INSTR(0x0a, 0)
 #define MI_REPORT_HEAD          MI_INSTR(0x07, 0)
 #define MI_OVERLAY_FLIP         MI_INSTR(0x11,0)
@@ -180,6 +181,12 @@
 #define MI_DISPLAY_FLIP         MI_INSTR(0x14, 2)
 #define MI_DISPLAY_FLIP_I915    MI_INSTR(0x14, 1)
 #define   MI_DISPLAY_FLIP_PLANE(n) ((n) << 20)
+#define MI_SET_CONTEXT          MI_INSTR(0x18, 0)
+#define   MI_MM_SPACE_GTT               (1<<8)
+#define   MI_MM_SPACE_PHYSICAL          (0<<8)
+#define   MI_SAVE_EXT_STATE_EN          (1<<3)
+#define   MI_RESTORE_EXT_STATE_EN       (1<<2)
+#define   MI_RESTORE_INHIBIT            (1<<0)
 #define MI_STORE_DWORD_IMM      MI_INSTR(0x20, 1)
 #define   MI_MEM_VIRTUAL        (1 << 22) /* 965+ only */
 #define MI_STORE_DWORD_INDEX    MI_INSTR(0x21, 1)
@@ -312,6 +319,7 @@
 
 #define MI_MODE         0x0209c
 # define VS_TIMER_DISPATCH                              (1 << 6)
+# define MI_FLUSH_ENABLE                                (1 << 11)
 
 #define SCPD0           0x0209c /* 915+ only */
 #define IER             0x020a0
@@ -1100,6 +1108,11 @@
 #define PEG_BAND_GAP_DATA       0x14d68
 
 /*
+ * Logical Context regs
+ */
+#define CCID                    0x2180
+#define   CCID_EN               (1<<0)
+/*
  * Overlay regs
  */
 
@@ -2069,6 +2082,7 @@
 #define PIPE_DITHER_TYPE_ST01           (1 << 2)
 /* Pipe A */
 #define PIPEADSL                0x70000
+#define   DSL_LINEMASK          0x00000fff
 #define PIPEACONF               0x70008
 #define   PIPEACONF_ENABLE      (1<<31)
 #define   PIPEACONF_DISABLE     0
@@ -2192,9 +2206,17 @@
 #define  WM1_LP_SR_EN           (1<<31)
 #define  WM1_LP_LATENCY_SHIFT   24
 #define  WM1_LP_LATENCY_MASK    (0x7f<<24)
+#define  WM1_LP_FBC_LP1_MASK    (0xf<<20)
+#define  WM1_LP_FBC_LP1_SHIFT   20
 #define  WM1_LP_SR_MASK         (0x1ff<<8)
 #define  WM1_LP_SR_SHIFT        8
 #define  WM1_LP_CURSOR_MASK     (0x3f)
+#define WM2_LP_ILK              0x4510c
+#define  WM2_LP_EN              (1<<31)
+#define WM3_LP_ILK              0x45110
+#define  WM3_LP_EN              (1<<31)
+#define WM1S_LP_ILK             0x45120
+#define  WM1S_LP_EN             (1<<31)
 
 /* Memory latency timer register */
 #define MLTR_ILK                0x11222
@@ -2928,6 +2950,7 @@
 #define  TRANS_DP_VSYNC_ACTIVE_LOW      0
 #define  TRANS_DP_HSYNC_ACTIVE_HIGH     (1<<3)
 #define  TRANS_DP_HSYNC_ACTIVE_LOW      0
+#define  TRANS_DP_SYNC_MASK     (3<<3)
 
 /* SNB eDP training params */
 /* SNB A-stepping */
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index 6e2025274db5..31f08581e93a 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -34,7 +34,7 @@ static bool i915_pipe_enabled(struct drm_device *dev, enum pipe pipe)
         struct drm_i915_private *dev_priv = dev->dev_private;
         u32     dpll_reg;
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dpll_reg = (pipe == PIPE_A) ? PCH_DPLL_A: PCH_DPLL_B;
         } else {
                 dpll_reg = (pipe == PIPE_A) ? DPLL_A: DPLL_B;
@@ -53,7 +53,7 @@ static void i915_save_palette(struct drm_device *dev, enum pipe pipe)
         if (!i915_pipe_enabled(dev, pipe))
                 return;
 
-        if (IS_IRONLAKE(dev))
+        if (HAS_PCH_SPLIT(dev))
                 reg = (pipe == PIPE_A) ? LGC_PALETTE_A : LGC_PALETTE_B;
 
         if (pipe == PIPE_A)
@@ -75,7 +75,7 @@ static void i915_restore_palette(struct drm_device *dev, enum pipe pipe)
         if (!i915_pipe_enabled(dev, pipe))
                 return;
 
-        if (IS_IRONLAKE(dev))
+        if (HAS_PCH_SPLIT(dev))
                 reg = (pipe == PIPE_A) ? LGC_PALETTE_A : LGC_PALETTE_B;
 
         if (pipe == PIPE_A)
@@ -239,7 +239,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
         if (drm_core_check_feature(dev, DRIVER_MODESET))
                 return;
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->savePCH_DREF_CONTROL = I915_READ(PCH_DREF_CONTROL);
                 dev_priv->saveDISP_ARB_CTL = I915_READ(DISP_ARB_CTL);
         }
@@ -247,7 +247,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
         /* Pipe & plane A info */
         dev_priv->savePIPEACONF = I915_READ(PIPEACONF);
         dev_priv->savePIPEASRC = I915_READ(PIPEASRC);
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->saveFPA0 = I915_READ(PCH_FPA0);
                 dev_priv->saveFPA1 = I915_READ(PCH_FPA1);
                 dev_priv->saveDPLL_A = I915_READ(PCH_DPLL_A);
@@ -256,7 +256,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
                 dev_priv->saveFPA1 = I915_READ(FPA1);
                 dev_priv->saveDPLL_A = I915_READ(DPLL_A);
         }
-        if (IS_I965G(dev) && !IS_IRONLAKE(dev))
+        if (IS_I965G(dev) && !HAS_PCH_SPLIT(dev))
                 dev_priv->saveDPLL_A_MD = I915_READ(DPLL_A_MD);
         dev_priv->saveHTOTAL_A = I915_READ(HTOTAL_A);
         dev_priv->saveHBLANK_A = I915_READ(HBLANK_A);
@@ -264,10 +264,10 @@ static void i915_save_modeset_reg(struct drm_device *dev)
         dev_priv->saveVTOTAL_A = I915_READ(VTOTAL_A);
         dev_priv->saveVBLANK_A = I915_READ(VBLANK_A);
         dev_priv->saveVSYNC_A = I915_READ(VSYNC_A);
-        if (!IS_IRONLAKE(dev))
+        if (!HAS_PCH_SPLIT(dev))
                 dev_priv->saveBCLRPAT_A = I915_READ(BCLRPAT_A);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->savePIPEA_DATA_M1 = I915_READ(PIPEA_DATA_M1);
                 dev_priv->savePIPEA_DATA_N1 = I915_READ(PIPEA_DATA_N1);
                 dev_priv->savePIPEA_LINK_M1 = I915_READ(PIPEA_LINK_M1);
@@ -304,7 +304,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
         /* Pipe & plane B info */
         dev_priv->savePIPEBCONF = I915_READ(PIPEBCONF);
         dev_priv->savePIPEBSRC = I915_READ(PIPEBSRC);
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->saveFPB0 = I915_READ(PCH_FPB0);
                 dev_priv->saveFPB1 = I915_READ(PCH_FPB1);
                 dev_priv->saveDPLL_B = I915_READ(PCH_DPLL_B);
@@ -313,7 +313,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
                 dev_priv->saveFPB1 = I915_READ(FPB1);
                 dev_priv->saveDPLL_B = I915_READ(DPLL_B);
         }
-        if (IS_I965G(dev) && !IS_IRONLAKE(dev))
+        if (IS_I965G(dev) && !HAS_PCH_SPLIT(dev))
                 dev_priv->saveDPLL_B_MD = I915_READ(DPLL_B_MD);
         dev_priv->saveHTOTAL_B = I915_READ(HTOTAL_B);
         dev_priv->saveHBLANK_B = I915_READ(HBLANK_B);
@@ -321,10 +321,10 @@ static void i915_save_modeset_reg(struct drm_device *dev)
         dev_priv->saveVTOTAL_B = I915_READ(VTOTAL_B);
         dev_priv->saveVBLANK_B = I915_READ(VBLANK_B);
         dev_priv->saveVSYNC_B = I915_READ(VSYNC_B);
-        if (!IS_IRONLAKE(dev))
+        if (!HAS_PCH_SPLIT(dev))
                 dev_priv->saveBCLRPAT_B = I915_READ(BCLRPAT_B);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->savePIPEB_DATA_M1 = I915_READ(PIPEB_DATA_M1);
                 dev_priv->savePIPEB_DATA_N1 = I915_READ(PIPEB_DATA_N1);
                 dev_priv->savePIPEB_LINK_M1 = I915_READ(PIPEB_LINK_M1);
@@ -369,7 +369,7 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
         if (drm_core_check_feature(dev, DRIVER_MODESET))
                 return;
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dpll_a_reg = PCH_DPLL_A;
                 dpll_b_reg = PCH_DPLL_B;
                 fpa0_reg = PCH_FPA0;
@@ -385,7 +385,7 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
                 fpb1_reg = FPB1;
         }
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(PCH_DREF_CONTROL, dev_priv->savePCH_DREF_CONTROL);
                 I915_WRITE(DISP_ARB_CTL, dev_priv->saveDISP_ARB_CTL);
         }
@@ -395,16 +395,20 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
         if (dev_priv->saveDPLL_A & DPLL_VCO_ENABLE) {
                 I915_WRITE(dpll_a_reg, dev_priv->saveDPLL_A &
                            ~DPLL_VCO_ENABLE);
-                DRM_UDELAY(150);
+                POSTING_READ(dpll_a_reg);
+                udelay(150);
         }
         I915_WRITE(fpa0_reg, dev_priv->saveFPA0);
         I915_WRITE(fpa1_reg, dev_priv->saveFPA1);
         /* Actually enable it */
         I915_WRITE(dpll_a_reg, dev_priv->saveDPLL_A);
-        DRM_UDELAY(150);
-        if (IS_I965G(dev) && !IS_IRONLAKE(dev))
+        POSTING_READ(dpll_a_reg);
+        udelay(150);
+        if (IS_I965G(dev) && !HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(DPLL_A_MD, dev_priv->saveDPLL_A_MD);
-        DRM_UDELAY(150);
+                POSTING_READ(DPLL_A_MD);
+        }
+        udelay(150);
 
         /* Restore mode */
         I915_WRITE(HTOTAL_A, dev_priv->saveHTOTAL_A);
@@ -413,10 +417,10 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
         I915_WRITE(VTOTAL_A, dev_priv->saveVTOTAL_A);
         I915_WRITE(VBLANK_A, dev_priv->saveVBLANK_A);
         I915_WRITE(VSYNC_A, dev_priv->saveVSYNC_A);
-        if (!IS_IRONLAKE(dev))
+        if (!HAS_PCH_SPLIT(dev))
                 I915_WRITE(BCLRPAT_A, dev_priv->saveBCLRPAT_A);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(PIPEA_DATA_M1, dev_priv->savePIPEA_DATA_M1);
                 I915_WRITE(PIPEA_DATA_N1, dev_priv->savePIPEA_DATA_N1);
                 I915_WRITE(PIPEA_LINK_M1, dev_priv->savePIPEA_LINK_M1);
@@ -460,16 +464,20 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
         if (dev_priv->saveDPLL_B & DPLL_VCO_ENABLE) {
                 I915_WRITE(dpll_b_reg, dev_priv->saveDPLL_B &
                            ~DPLL_VCO_ENABLE);
-                DRM_UDELAY(150);
+                POSTING_READ(dpll_b_reg);
+                udelay(150);
         }
         I915_WRITE(fpb0_reg, dev_priv->saveFPB0);
         I915_WRITE(fpb1_reg, dev_priv->saveFPB1);
         /* Actually enable it */
         I915_WRITE(dpll_b_reg, dev_priv->saveDPLL_B);
-        DRM_UDELAY(150);
-        if (IS_I965G(dev) && !IS_IRONLAKE(dev))
+        POSTING_READ(dpll_b_reg);
+        udelay(150);
+        if (IS_I965G(dev) && !HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(DPLL_B_MD, dev_priv->saveDPLL_B_MD);
-        DRM_UDELAY(150);
+                POSTING_READ(DPLL_B_MD);
+        }
+        udelay(150);
 
         /* Restore mode */
         I915_WRITE(HTOTAL_B, dev_priv->saveHTOTAL_B);
@@ -478,10 +486,10 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
         I915_WRITE(VTOTAL_B, dev_priv->saveVTOTAL_B);
         I915_WRITE(VBLANK_B, dev_priv->saveVBLANK_B);
         I915_WRITE(VSYNC_B, dev_priv->saveVSYNC_B);
-        if (!IS_IRONLAKE(dev))
+        if (!HAS_PCH_SPLIT(dev))
                 I915_WRITE(BCLRPAT_B, dev_priv->saveBCLRPAT_B);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(PIPEB_DATA_M1, dev_priv->savePIPEB_DATA_M1);
                 I915_WRITE(PIPEB_DATA_N1, dev_priv->savePIPEB_DATA_N1);
                 I915_WRITE(PIPEB_LINK_M1, dev_priv->savePIPEB_LINK_M1);
@@ -546,14 +554,14 @@ void i915_save_display(struct drm_device *dev)
                 dev_priv->saveCURSIZE = I915_READ(CURSIZE);
 
         /* CRT state */
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->saveADPA = I915_READ(PCH_ADPA);
         } else {
                 dev_priv->saveADPA = I915_READ(ADPA);
         }
 
         /* LVDS state */
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->savePP_CONTROL = I915_READ(PCH_PP_CONTROL);
                 dev_priv->saveBLC_PWM_CTL = I915_READ(BLC_PWM_PCH_CTL1);
                 dev_priv->saveBLC_PWM_CTL2 = I915_READ(BLC_PWM_PCH_CTL2);
@@ -571,10 +579,10 @@ void i915_save_display(struct drm_device *dev)
                         dev_priv->saveLVDS = I915_READ(LVDS);
         }
 
-        if (!IS_I830(dev) && !IS_845G(dev) && !IS_IRONLAKE(dev))
+        if (!IS_I830(dev) && !IS_845G(dev) && !HAS_PCH_SPLIT(dev))
                 dev_priv->savePFIT_CONTROL = I915_READ(PFIT_CONTROL);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->savePP_ON_DELAYS = I915_READ(PCH_PP_ON_DELAYS);
                 dev_priv->savePP_OFF_DELAYS = I915_READ(PCH_PP_OFF_DELAYS);
                 dev_priv->savePP_DIVISOR = I915_READ(PCH_PP_DIVISOR);
@@ -602,7 +610,7 @@ void i915_save_display(struct drm_device *dev)
 
         /* Only save FBC state on the platform that supports FBC */
         if (I915_HAS_FBC(dev)) {
-                if (IS_IRONLAKE_M(dev)) {
+                if (HAS_PCH_SPLIT(dev)) {
                         dev_priv->saveDPFC_CB_BASE = I915_READ(ILK_DPFC_CB_BASE);
                 } else if (IS_GM45(dev)) {
                         dev_priv->saveDPFC_CB_BASE = I915_READ(DPFC_CB_BASE);
@@ -618,7 +626,7 @@ void i915_save_display(struct drm_device *dev)
         dev_priv->saveVGA0 = I915_READ(VGA0);
         dev_priv->saveVGA1 = I915_READ(VGA1);
         dev_priv->saveVGA_PD = I915_READ(VGA_PD);
-        if (IS_IRONLAKE(dev))
+        if (HAS_PCH_SPLIT(dev))
                 dev_priv->saveVGACNTRL = I915_READ(CPU_VGACNTRL);
         else
                 dev_priv->saveVGACNTRL = I915_READ(VGACNTRL);
@@ -660,24 +668,24 @@ void i915_restore_display(struct drm_device *dev)
                 I915_WRITE(CURSIZE, dev_priv->saveCURSIZE);
 
         /* CRT state */
-        if (IS_IRONLAKE(dev))
+        if (HAS_PCH_SPLIT(dev))
                 I915_WRITE(PCH_ADPA, dev_priv->saveADPA);
         else
                 I915_WRITE(ADPA, dev_priv->saveADPA);
 
         /* LVDS state */
-        if (IS_I965G(dev) && !IS_IRONLAKE(dev))
+        if (IS_I965G(dev) && !HAS_PCH_SPLIT(dev))
                 I915_WRITE(BLC_PWM_CTL2, dev_priv->saveBLC_PWM_CTL2);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(PCH_LVDS, dev_priv->saveLVDS);
         } else if (IS_MOBILE(dev) && !IS_I830(dev))
                 I915_WRITE(LVDS, dev_priv->saveLVDS);
 
-        if (!IS_I830(dev) && !IS_845G(dev) && !IS_IRONLAKE(dev))
+        if (!IS_I830(dev) && !IS_845G(dev) && !HAS_PCH_SPLIT(dev))
                 I915_WRITE(PFIT_CONTROL, dev_priv->savePFIT_CONTROL);
 
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(BLC_PWM_PCH_CTL1, dev_priv->saveBLC_PWM_CTL);
                 I915_WRITE(BLC_PWM_PCH_CTL2, dev_priv->saveBLC_PWM_CTL2);
                 I915_WRITE(BLC_PWM_CPU_CTL, dev_priv->saveBLC_CPU_PWM_CTL);
@@ -708,7 +716,7 @@ void i915_restore_display(struct drm_device *dev)
 
         /* only restore FBC info on the platform that supports FBC*/
         if (I915_HAS_FBC(dev)) {
-                if (IS_IRONLAKE_M(dev)) {
+                if (HAS_PCH_SPLIT(dev)) {
                         ironlake_disable_fbc(dev);
                         I915_WRITE(ILK_DPFC_CB_BASE, dev_priv->saveDPFC_CB_BASE);
                 } else if (IS_GM45(dev)) {
@@ -723,14 +731,15 @@ void i915_restore_display(struct drm_device *dev)
                 }
         }
         /* VGA state */
-        if (IS_IRONLAKE(dev))
+        if (HAS_PCH_SPLIT(dev))
                 I915_WRITE(CPU_VGACNTRL, dev_priv->saveVGACNTRL);
         else
                 I915_WRITE(VGACNTRL, dev_priv->saveVGACNTRL);
         I915_WRITE(VGA0, dev_priv->saveVGA0);
         I915_WRITE(VGA1, dev_priv->saveVGA1);
         I915_WRITE(VGA_PD, dev_priv->saveVGA_PD);
-        DRM_UDELAY(150);
+        POSTING_READ(VGA_PD);
+        udelay(150);
 
         i915_restore_vga(dev);
 }
@@ -748,7 +757,7 @@ int i915_save_state(struct drm_device *dev)
         i915_save_display(dev);
 
         /* Interrupt state */
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 dev_priv->saveDEIER = I915_READ(DEIER);
                 dev_priv->saveDEIMR = I915_READ(DEIMR);
                 dev_priv->saveGTIER = I915_READ(GTIER);
@@ -762,7 +771,7 @@ int i915_save_state(struct drm_device *dev)
                 dev_priv->saveIMR = I915_READ(IMR);
         }
 
-        if (IS_IRONLAKE_M(dev))
+        if (HAS_PCH_SPLIT(dev))
                 ironlake_disable_drps(dev);
 
         /* Cache mode state */
@@ -780,16 +789,25 @@ int i915_save_state(struct drm_device *dev)
                 dev_priv->saveSWF2[i] = I915_READ(SWF30 + (i << 2));
 
         /* Fences */
-        if (IS_I965G(dev)) {
+        switch (INTEL_INFO(dev)->gen) {
+        case 6:
+                for (i = 0; i < 16; i++)
+                        dev_priv->saveFENCE[i] = I915_READ64(FENCE_REG_SANDYBRIDGE_0 + (i * 8));
+                break;
+        case 5:
+        case 4:
                 for (i = 0; i < 16; i++)
                         dev_priv->saveFENCE[i] = I915_READ64(FENCE_REG_965_0 + (i * 8));
-        } else {
-                for (i = 0; i < 8; i++)
-                        dev_priv->saveFENCE[i] = I915_READ(FENCE_REG_830_0 + (i * 4));
-
+                break;
+        case 3:
                 if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev))
                         for (i = 0; i < 8; i++)
                                 dev_priv->saveFENCE[i+8] = I915_READ(FENCE_REG_945_8 + (i * 4));
+        case 2:
+                for (i = 0; i < 8; i++)
+                        dev_priv->saveFENCE[i] = I915_READ(FENCE_REG_830_0 + (i * 4));
+                break;
+
         }
 
         return 0;
@@ -806,21 +824,30 @@ int i915_restore_state(struct drm_device *dev)
         I915_WRITE(HWS_PGA, dev_priv->saveHWS);
 
         /* Fences */
-        if (IS_I965G(dev)) {
+        switch (INTEL_INFO(dev)->gen) {
+        case 6:
+                for (i = 0; i < 16; i++)
+                        I915_WRITE64(FENCE_REG_SANDYBRIDGE_0 + (i * 8), dev_priv->saveFENCE[i]);
+                break;
+        case 5:
+        case 4:
                 for (i = 0; i < 16; i++)
                         I915_WRITE64(FENCE_REG_965_0 + (i * 8), dev_priv->saveFENCE[i]);
-        } else {
-                for (i = 0; i < 8; i++)
-                        I915_WRITE(FENCE_REG_830_0 + (i * 4), dev_priv->saveFENCE[i]);
+                break;
+        case 3:
+        case 2:
                 if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev))
                         for (i = 0; i < 8; i++)
                                 I915_WRITE(FENCE_REG_945_8 + (i * 4), dev_priv->saveFENCE[i+8]);
+                for (i = 0; i < 8; i++)
+                        I915_WRITE(FENCE_REG_830_0 + (i * 4), dev_priv->saveFENCE[i]);
+                break;
         }
 
         i915_restore_display(dev);
 
         /* Interrupt state */
-        if (IS_IRONLAKE(dev)) {
+        if (HAS_PCH_SPLIT(dev)) {
                 I915_WRITE(DEIER, dev_priv->saveDEIER);
                 I915_WRITE(DEIMR, dev_priv->saveDEIMR);
                 I915_WRITE(GTIER, dev_priv->saveGTIER);
@@ -835,7 +862,7 @@ int i915_restore_state(struct drm_device *dev)
         /* Clock gating state */
         intel_init_clock_gating(dev);
 
-        if (IS_IRONLAKE_M(dev))
+        if (HAS_PCH_SPLIT(dev))
                 ironlake_enable_drps(dev);
 
         /* Cache mode state */
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index ee0732b222a1..197d4f32585a 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -160,19 +160,20 @@ static bool intel_ironlake_crt_detect_hotplug(struct drm_connector *connector)
         struct drm_i915_private *dev_priv = dev->dev_private;
         u32 adpa, temp;
         bool ret;
+        bool turn_off_dac = false;
 
         temp = adpa = I915_READ(PCH_ADPA);
 
-        if (HAS_PCH_CPT(dev)) {
-                /* Disable DAC before force detect */
-                I915_WRITE(PCH_ADPA, adpa & ~ADPA_DAC_ENABLE);
-                (void)I915_READ(PCH_ADPA);
-        } else {
-                adpa &= ~ADPA_CRT_HOTPLUG_MASK;
-                /* disable HPD first */
-                I915_WRITE(PCH_ADPA, adpa);
-                (void)I915_READ(PCH_ADPA);
-        }
+        if (HAS_PCH_SPLIT(dev))
+                turn_off_dac = true;
+
+        adpa &= ~ADPA_CRT_HOTPLUG_MASK;
+        if (turn_off_dac)
+                adpa &= ~ADPA_DAC_ENABLE;
+
+        /* disable HPD first */
+        I915_WRITE(PCH_ADPA, adpa);
+        (void)I915_READ(PCH_ADPA);
 
         adpa |= (ADPA_CRT_HOTPLUG_PERIOD_128 |
                         ADPA_CRT_HOTPLUG_WARMUP_10MS |
@@ -185,10 +186,11 @@ static bool intel_ironlake_crt_detect_hotplug(struct drm_connector *connector)
         DRM_DEBUG_KMS("pch crt adpa 0x%x", adpa);
         I915_WRITE(PCH_ADPA, adpa);
 
-        while ((I915_READ(PCH_ADPA) & ADPA_CRT_HOTPLUG_FORCE_TRIGGER) != 0)
-                ;
+        if (wait_for((I915_READ(PCH_ADPA) & ADPA_CRT_HOTPLUG_FORCE_TRIGGER) == 0,
+                     1000, 1))
+                DRM_DEBUG_KMS("timed out waiting for FORCE_TRIGGER");
 
-        if (HAS_PCH_CPT(dev)) {
+        if (turn_off_dac) {
                 I915_WRITE(PCH_ADPA, temp);
                 (void)I915_READ(PCH_ADPA);
         }
@@ -237,17 +239,13 @@ static bool intel_crt_detect_hotplug(struct drm_connector *connector)
         hotplug_en |= CRT_HOTPLUG_FORCE_DETECT;
 
         for (i = 0; i < tries ; i++) {
-                unsigned long timeout;
                 /* turn on the FORCE_DETECT */
                 I915_WRITE(PORT_HOTPLUG_EN, hotplug_en);
-                timeout = jiffies + msecs_to_jiffies(1000);
                 /* wait for FORCE_DETECT to go off */
-                do {
-                        if (!(I915_READ(PORT_HOTPLUG_EN) &
-                                        CRT_HOTPLUG_FORCE_DETECT))
-                                break;
-                        msleep(1);
-                } while (time_after(timeout, jiffies));
+                if (wait_for((I915_READ(PORT_HOTPLUG_EN) &
+                              CRT_HOTPLUG_FORCE_DETECT) == 0,
+                             1000, 1))
+                        DRM_DEBUG_KMS("timed out waiting for FORCE_DETECT to go off");
         }
 
         stat = I915_READ(PORT_HOTPLUG_STAT);
@@ -331,7 +329,7 @@ intel_crt_load_detect(struct drm_crtc *crtc, struct intel_encoder *intel_encoder
                 I915_WRITE(pipeconf_reg, pipeconf | PIPECONF_FORCE_BORDER);
                 /* Wait for next Vblank to substitue
                  * border color for Color info */
-                intel_wait_for_vblank(dev);
+                intel_wait_for_vblank(dev, pipe);
                 st00 = I915_READ8(VGA_MSR_WRITE);
                 status = ((st00 & (1 << 4)) != 0) ?
                         connector_status_connected :
@@ -402,7 +400,8 @@ intel_crt_load_detect(struct drm_crtc *crtc, struct intel_encoder *intel_encoder
         return status;
 }
 
-static enum drm_connector_status intel_crt_detect(struct drm_connector *connector)
+static enum drm_connector_status
+intel_crt_detect(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
         struct drm_encoder *encoder = intel_attached_encoder(connector);
@@ -421,6 +420,9 @@ static enum drm_connector_status intel_crt_detect(struct drm_connector *connecto
         if (intel_crt_detect_ddc(encoder))
                 return connector_status_connected;
 
+        if (!force)
+                return connector->status;
+
         /* for pre-945g platforms use load detect */
         if (encoder->crtc && encoder->crtc->enabled) {
                 status = intel_crt_load_detect(encoder->crtc, intel_encoder);
@@ -508,17 +510,8 @@ static const struct drm_connector_helper_funcs intel_crt_connector_helper_funcs
         .best_encoder = intel_attached_encoder,
 };
 
-static void intel_crt_enc_destroy(struct drm_encoder *encoder)
-{
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-
-        intel_i2c_destroy(intel_encoder->ddc_bus);
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
-}
-
 static const struct drm_encoder_funcs intel_crt_enc_funcs = {
-        .destroy = intel_crt_enc_destroy,
+        .destroy = intel_encoder_destroy,
 };
 
 void intel_crt_init(struct drm_device *dev)
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 5ec10e02341b..979228594599 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -29,6 +29,7 @@
 #include <linux/i2c.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
+#include <linux/vgaarb.h>
 #include "drmP.h"
 #include "intel_drv.h"
 #include "i915_drm.h"
@@ -976,14 +977,84 @@ intel_find_pll_g4x_dp(const intel_limit_t *limit, struct drm_crtc *crtc,
     return true;
 }
 
-void
-intel_wait_for_vblank(struct drm_device *dev)
+/**
+ * intel_wait_for_vblank - wait for vblank on a given pipe
+ * @dev: drm device
+ * @pipe: pipe to wait for
+ *
+ * Wait for vblank to occur on a given pipe.  Needed for various bits of
+ * mode setting code.
+ */
+void intel_wait_for_vblank(struct drm_device *dev, int pipe)
 {
-        /* Wait for 20ms, i.e. one cycle at 50hz. */
-        if (in_dbg_master())
-                mdelay(20); /* The kernel debugger cannot call msleep() */
-        else
-                msleep(20);
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        int pipestat_reg = (pipe == 0 ? PIPEASTAT : PIPEBSTAT);
+
+        /* Clear existing vblank status. Note this will clear any other
+         * sticky status fields as well.
+         *
+         * This races with i915_driver_irq_handler() with the result
+         * that either function could miss a vblank event.  Here it is not
+         * fatal, as we will either wait upon the next vblank interrupt or
+         * timeout.  Generally speaking intel_wait_for_vblank() is only
+         * called during modeset at which time the GPU should be idle and
+         * should *not* be performing page flips and thus not waiting on
+         * vblanks...
+         * Currently, the result of us stealing a vblank from the irq
+         * handler is that a single frame will be skipped during swapbuffers.
+         */
+        I915_WRITE(pipestat_reg,
+                   I915_READ(pipestat_reg) | PIPE_VBLANK_INTERRUPT_STATUS);
+
+        /* Wait for vblank interrupt bit to set */
+        if (wait_for((I915_READ(pipestat_reg) &
+                      PIPE_VBLANK_INTERRUPT_STATUS),
+                     50, 0))
+                DRM_DEBUG_KMS("vblank wait timed out\n");
+}
+
+/*
+ * intel_wait_for_pipe_off - wait for pipe to turn off
+ * @dev: drm device
+ * @pipe: pipe to wait for
+ *
+ * After disabling a pipe, we can't wait for vblank in the usual way,
+ * spinning on the vblank interrupt status bit, since we won't actually
+ * see an interrupt when the pipe is disabled.
+ *
+ * On Gen4 and above:
+ *   wait for the pipe register state bit to turn off
+ *
+ * Otherwise:
+ *   wait for the display line value to settle (it usually
+ *   ends up stopping at the start of the next frame).
+ *  
+ */
+static void intel_wait_for_pipe_off(struct drm_device *dev, int pipe)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        if (INTEL_INFO(dev)->gen >= 4) {
+                int pipeconf_reg = (pipe == 0 ? PIPEACONF : PIPEBCONF);
+
+                /* Wait for the Pipe State to go off */
+                if (wait_for((I915_READ(pipeconf_reg) & I965_PIPECONF_ACTIVE) == 0,
+                             100, 0))
+                        DRM_DEBUG_KMS("pipe_off wait timed out\n");
+        } else {
+                u32 last_line;
+                int pipedsl_reg = (pipe == 0 ? PIPEADSL : PIPEBDSL);
+                unsigned long timeout = jiffies + msecs_to_jiffies(100);
+
+                /* Wait for the display line to settle */
+                do {
+                        last_line = I915_READ(pipedsl_reg) & DSL_LINEMASK;
+                        mdelay(5);
+                } while (((I915_READ(pipedsl_reg) & DSL_LINEMASK) != last_line) &&
+                         time_after(timeout, jiffies));
+                if (time_after(jiffies, timeout))
+                        DRM_DEBUG_KMS("pipe_off wait timed out\n");
+        }
 }
 
 /* Parameters have changed, update FBC info */
@@ -1037,7 +1108,6 @@ static void i8xx_enable_fbc(struct drm_crtc *crtc, unsigned long interval)
 void i8xx_disable_fbc(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        unsigned long timeout = jiffies + msecs_to_jiffies(1);
         u32 fbc_ctl;
 
         if (!I915_HAS_FBC(dev))
@@ -1052,16 +1122,11 @@ void i8xx_disable_fbc(struct drm_device *dev)
         I915_WRITE(FBC_CONTROL, fbc_ctl);
 
         /* Wait for compressing bit to clear */
-        while (I915_READ(FBC_STATUS) & FBC_STAT_COMPRESSING) {
-                if (time_after(jiffies, timeout)) {
-                        DRM_DEBUG_DRIVER("FBC idle timed out\n");
-                        break;
-                }
-                ; /* do nothing */
+        if (wait_for((I915_READ(FBC_STATUS) & FBC_STAT_COMPRESSING) == 0, 10, 0)) {
+                DRM_DEBUG_KMS("FBC idle timed out\n");
+                return;
         }
 
-        intel_wait_for_vblank(dev);
-
         DRM_DEBUG_KMS("disabled FBC\n");
 }
 
@@ -1118,7 +1183,6 @@ void g4x_disable_fbc(struct drm_device *dev)
         dpfc_ctl = I915_READ(DPFC_CONTROL);
         dpfc_ctl &= ~DPFC_CTL_EN;
         I915_WRITE(DPFC_CONTROL, dpfc_ctl);
-        intel_wait_for_vblank(dev);
 
         DRM_DEBUG_KMS("disabled FBC\n");
 }
@@ -1179,7 +1243,6 @@ void ironlake_disable_fbc(struct drm_device *dev)
         dpfc_ctl = I915_READ(ILK_DPFC_CONTROL);
         dpfc_ctl &= ~DPFC_CTL_EN;
         I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl);
-        intel_wait_for_vblank(dev);
 
         DRM_DEBUG_KMS("disabled FBC\n");
 }
@@ -1453,7 +1516,7 @@ intel_pipe_set_base_atomic(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                         dspcntr &= ~DISPPLANE_TILED;
         }
 
-        if (IS_IRONLAKE(dev))
+        if (HAS_PCH_SPLIT(dev))
                 /* must disable */
                 dspcntr |= DISPPLANE_TRICKLE_FEED_DISABLE;
 
@@ -1462,23 +1525,22 @@ intel_pipe_set_base_atomic(struct drm_crtc *crtc, struct drm_framebuffer *fb,
         Start = obj_priv->gtt_offset;
         Offset = y * fb->pitch + x * (fb->bits_per_pixel / 8);
 
-        DRM_DEBUG("Writing base %08lX %08lX %d %d\n", Start, Offset, x, y);
+        DRM_DEBUG_KMS("Writing base %08lX %08lX %d %d %d\n",
+                      Start, Offset, x, y, fb->pitch);
         I915_WRITE(dspstride, fb->pitch);
         if (IS_I965G(dev)) {
-                I915_WRITE(dspbase, Offset);
-                I915_READ(dspbase);
                 I915_WRITE(dspsurf, Start);
-                I915_READ(dspsurf);
                 I915_WRITE(dsptileoff, (y << 16) | x);
+                I915_WRITE(dspbase, Offset);
         } else {
                 I915_WRITE(dspbase, Start + Offset);
-                I915_READ(dspbase);
         }
+        POSTING_READ(dspbase);
 
-        if ((IS_I965G(dev) || plane == 0))
+        if (IS_I965G(dev) || plane == 0)
                 intel_update_fbc(crtc, &crtc->mode);
 
-        intel_wait_for_vblank(dev);
+        intel_wait_for_vblank(dev, intel_crtc->pipe);
         intel_increase_pllclock(crtc, true);
 
         return 0;
@@ -1489,7 +1551,6 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
                     struct drm_framebuffer *old_fb)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_i915_master_private *master_priv;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
         struct intel_framebuffer *intel_fb;
@@ -1497,13 +1558,6 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
         struct drm_gem_object *obj;
         int pipe = intel_crtc->pipe;
         int plane = intel_crtc->plane;
-        unsigned long Start, Offset;
-        int dspbase = (plane == 0 ? DSPAADDR : DSPBADDR);
-        int dspsurf = (plane == 0 ? DSPASURF : DSPBSURF);
-        int dspstride = (plane == 0) ? DSPASTRIDE : DSPBSTRIDE;
-        int dsptileoff = (plane == 0 ? DSPATILEOFF : DSPBTILEOFF);
-        int dspcntr_reg = (plane == 0) ? DSPACNTR : DSPBCNTR;
-        u32 dspcntr;
         int ret;
 
         /* no fb bound */
@@ -1539,73 +1593,18 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
                 return ret;
         }
 
-        dspcntr = I915_READ(dspcntr_reg);
-        /* Mask out pixel format bits in case we change it */
-        dspcntr &= ~DISPPLANE_PIXFORMAT_MASK;
-        switch (crtc->fb->bits_per_pixel) {
-        case 8:
-                dspcntr |= DISPPLANE_8BPP;
-                break;
-        case 16:
-                if (crtc->fb->depth == 15)
-                        dspcntr |= DISPPLANE_15_16BPP;
-                else
-                        dspcntr |= DISPPLANE_16BPP;
-                break;
-        case 24:
-        case 32:
-                if (crtc->fb->depth == 30)
-                        dspcntr |= DISPPLANE_32BPP_30BIT_NO_ALPHA;
-                else
-                        dspcntr |= DISPPLANE_32BPP_NO_ALPHA;
-                break;
-        default:
-                DRM_ERROR("Unknown color depth\n");
+        ret = intel_pipe_set_base_atomic(crtc, crtc->fb, x, y);
+        if (ret) {
                 i915_gem_object_unpin(obj);
                 mutex_unlock(&dev->struct_mutex);
-                return -EINVAL;
-        }
-        if (IS_I965G(dev)) {
-                if (obj_priv->tiling_mode != I915_TILING_NONE)
-                        dspcntr |= DISPPLANE_TILED;
-                else
-                        dspcntr &= ~DISPPLANE_TILED;
-        }
-
-        if (HAS_PCH_SPLIT(dev))
-                /* must disable */
-                dspcntr |= DISPPLANE_TRICKLE_FEED_DISABLE;
-
-        I915_WRITE(dspcntr_reg, dspcntr);
-
-        Start = obj_priv->gtt_offset;
-        Offset = y * crtc->fb->pitch + x * (crtc->fb->bits_per_pixel / 8);
-
-        DRM_DEBUG_KMS("Writing base %08lX %08lX %d %d %d\n",
-                      Start, Offset, x, y, crtc->fb->pitch);
-        I915_WRITE(dspstride, crtc->fb->pitch);
-        if (IS_I965G(dev)) {
-                I915_WRITE(dspbase, Offset);
-                I915_READ(dspbase);
-                I915_WRITE(dspsurf, Start);
-                I915_READ(dspsurf);
-                I915_WRITE(dsptileoff, (y << 16) | x);
-        } else {
-                I915_WRITE(dspbase, Start + Offset);
-                I915_READ(dspbase);
+                return ret;
         }
 
-        if ((IS_I965G(dev) || plane == 0))
-                intel_update_fbc(crtc, &crtc->mode);
-
-        intel_wait_for_vblank(dev);
-
         if (old_fb) {
                 intel_fb = to_intel_framebuffer(old_fb);
                 obj_priv = to_intel_bo(intel_fb->obj);
                 i915_gem_object_unpin(intel_fb->obj);
         }
-        intel_increase_pllclock(crtc, true);
 
         mutex_unlock(&dev->struct_mutex);
 
@@ -1627,54 +1626,6 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
         return 0;
 }
 
-/* Disable the VGA plane that we never use */
-static void i915_disable_vga (struct drm_device *dev)
-{
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        u8 sr1;
-        u32 vga_reg;
-
-        if (HAS_PCH_SPLIT(dev))
-                vga_reg = CPU_VGACNTRL;
-        else
-                vga_reg = VGACNTRL;
-
-        if (I915_READ(vga_reg) & VGA_DISP_DISABLE)
-                return;
-
-        I915_WRITE8(VGA_SR_INDEX, 1);
-        sr1 = I915_READ8(VGA_SR_DATA);
-        I915_WRITE8(VGA_SR_DATA, sr1 | (1 << 5));
-        udelay(100);
-
-        I915_WRITE(vga_reg, VGA_DISP_DISABLE);
-}
-
-static void ironlake_disable_pll_edp (struct drm_crtc *crtc)
-{
-        struct drm_device *dev = crtc->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 dpa_ctl;
-
-        DRM_DEBUG_KMS("\n");
-        dpa_ctl = I915_READ(DP_A);
-        dpa_ctl &= ~DP_PLL_ENABLE;
-        I915_WRITE(DP_A, dpa_ctl);
-}
-
-static void ironlake_enable_pll_edp (struct drm_crtc *crtc)
-{
-        struct drm_device *dev = crtc->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 dpa_ctl;
-
-        dpa_ctl = I915_READ(DP_A);
-        dpa_ctl |= DP_PLL_ENABLE;
-        I915_WRITE(DP_A, dpa_ctl);
-        udelay(200);
-}
-
-
 static void ironlake_set_pll_edp (struct drm_crtc *crtc, int clock)
 {
         struct drm_device *dev = crtc->dev;
@@ -1928,9 +1879,6 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
         int fdi_tx_reg = (pipe == 0) ? FDI_TXA_CTL : FDI_TXB_CTL;
         int fdi_rx_reg = (pipe == 0) ? FDI_RXA_CTL : FDI_RXB_CTL;
         int transconf_reg = (pipe == 0) ? TRANSACONF : TRANSBCONF;
-        int pf_ctl_reg = (pipe == 0) ? PFA_CTL_1 : PFB_CTL_1;
-        int pf_win_size = (pipe == 0) ? PFA_WIN_SZ : PFB_WIN_SZ;
-        int pf_win_pos = (pipe == 0) ? PFA_WIN_POS : PFB_WIN_POS;
         int cpu_htot_reg = (pipe == 0) ? HTOTAL_A : HTOTAL_B;
         int cpu_hblank_reg = (pipe == 0) ? HBLANK_A : HBLANK_B;
         int cpu_hsync_reg = (pipe == 0) ? HSYNC_A : HSYNC_B;
@@ -1945,7 +1893,6 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
         int trans_vsync_reg = (pipe == 0) ? TRANS_VSYNC_A : TRANS_VSYNC_B;
         int trans_dpll_sel = (pipe == 0) ? 0 : 1;
         u32 temp;
-        int n;
         u32 pipe_bpc;
 
         temp = I915_READ(pipeconf_reg);
@@ -1958,7 +1905,7 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
         case DRM_MODE_DPMS_ON:
         case DRM_MODE_DPMS_STANDBY:
         case DRM_MODE_DPMS_SUSPEND:
-                DRM_DEBUG_KMS("crtc %d dpms on\n", pipe);
+                DRM_DEBUG_KMS("crtc %d/%d dpms on\n", pipe, plane);
 
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS)) {
                         temp = I915_READ(PCH_LVDS);
@@ -1968,10 +1915,7 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                         }
                 }
 
-                if (HAS_eDP) {
-                        /* enable eDP PLL */
-                        ironlake_enable_pll_edp(crtc);
-                } else {
+                if (!HAS_eDP) {
 
                         /* enable PCH FDI RX PLL, wait warmup plus DMI latency */
                         temp = I915_READ(fdi_rx_reg);
@@ -2003,17 +1947,19 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                 }
 
                 /* Enable panel fitting for LVDS */
-                if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS)
-                    || HAS_eDP || intel_pch_has_edp(crtc)) {
-                        temp = I915_READ(pf_ctl_reg);
-                        I915_WRITE(pf_ctl_reg, temp | PF_ENABLE | PF_FILTER_MED_3x3);
-
-                        /* currently full aspect */
-                        I915_WRITE(pf_win_pos, 0);
-
-                        I915_WRITE(pf_win_size,
-                                   (dev_priv->panel_fixed_mode->hdisplay << 16) |
-                                   (dev_priv->panel_fixed_mode->vdisplay));
+                if (dev_priv->pch_pf_size &&
+                    (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS)
+                    || HAS_eDP || intel_pch_has_edp(crtc))) {
+                        /* Force use of hard-coded filter coefficients
+                         * as some pre-programmed values are broken,
+                         * e.g. x201.
+                         */
+                        I915_WRITE(pipe ? PFB_CTL_1 : PFA_CTL_1,
+                                   PF_ENABLE | PF_FILTER_MED_3x3);
+                        I915_WRITE(pipe ? PFB_WIN_POS : PFA_WIN_POS,
+                                   dev_priv->pch_pf_pos);
+                        I915_WRITE(pipe ? PFB_WIN_SZ : PFA_WIN_SZ,
+                                   dev_priv->pch_pf_size);
                 }
 
                 /* Enable CPU pipe */
@@ -2097,9 +2043,10 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                                 int reg;
 
                                 reg = I915_READ(trans_dp_ctl);
-                                reg &= ~TRANS_DP_PORT_SEL_MASK;
-                                reg = TRANS_DP_OUTPUT_ENABLE |
-                                      TRANS_DP_ENH_FRAMING;
+                                reg &= ~(TRANS_DP_PORT_SEL_MASK |
+                                         TRANS_DP_SYNC_MASK);
+                                reg |= (TRANS_DP_OUTPUT_ENABLE |
+                                        TRANS_DP_ENH_FRAMING);
 
                                 if (crtc->mode.flags & DRM_MODE_FLAG_PHSYNC)
                                       reg |= TRANS_DP_HSYNC_ACTIVE_HIGH;
@@ -2137,18 +2084,17 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                         I915_WRITE(transconf_reg, temp | TRANS_ENABLE);
                         I915_READ(transconf_reg);
 
-                        while ((I915_READ(transconf_reg) & TRANS_STATE_ENABLE) == 0)
-                                ;
-
+                        if (wait_for(I915_READ(transconf_reg) & TRANS_STATE_ENABLE, 100, 1))
+                                DRM_ERROR("failed to enable transcoder\n");
                 }
 
                 intel_crtc_load_lut(crtc);
 
                 intel_update_fbc(crtc, &crtc->mode);
+                break;
 
-        break;
         case DRM_MODE_DPMS_OFF:
-                DRM_DEBUG_KMS("crtc %d dpms off\n", pipe);
+                DRM_DEBUG_KMS("crtc %d/%d dpms off\n", pipe, plane);
 
                 drm_vblank_off(dev, pipe);
                 /* Disable display plane */
@@ -2164,40 +2110,22 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                     dev_priv->display.disable_fbc)
                         dev_priv->display.disable_fbc(dev);
 
-                i915_disable_vga(dev);
-
                 /* disable cpu pipe, disable after all planes disabled */
                 temp = I915_READ(pipeconf_reg);
                 if ((temp & PIPEACONF_ENABLE) != 0) {
                         I915_WRITE(pipeconf_reg, temp & ~PIPEACONF_ENABLE);
-                        I915_READ(pipeconf_reg);
-                        n = 0;
+
                         /* wait for cpu pipe off, pipe state */
-                        while ((I915_READ(pipeconf_reg) & I965_PIPECONF_ACTIVE) != 0) {
-                                n++;
-                                if (n < 60) {
-                                        udelay(500);
-                                        continue;
-                                } else {
-                                        DRM_DEBUG_KMS("pipe %d off delay\n",
-                                                                pipe);
-                                        break;
-                                }
-                        }
+                        if (wait_for((I915_READ(pipeconf_reg) & I965_PIPECONF_ACTIVE) == 0, 50, 1))
+                                DRM_ERROR("failed to turn off cpu pipe\n");
                 } else
                         DRM_DEBUG_KMS("crtc %d is disabled\n", pipe);
 
                 udelay(100);
 
                 /* Disable PF */
-                temp = I915_READ(pf_ctl_reg);
-                if ((temp & PF_ENABLE) != 0) {
-                        I915_WRITE(pf_ctl_reg, temp & ~PF_ENABLE);
-                        I915_READ(pf_ctl_reg);
-                }
-                I915_WRITE(pf_win_size, 0);
-                POSTING_READ(pf_win_size);
-
+                I915_WRITE(pipe ? PFB_CTL_1 : PFA_CTL_1, 0);
+                I915_WRITE(pipe ? PFB_WIN_SZ : PFA_WIN_SZ, 0);
 
                 /* disable CPU FDI tx and PCH FDI rx */
                 temp = I915_READ(fdi_tx_reg);
@@ -2244,20 +2172,10 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                 temp = I915_READ(transconf_reg);
                 if ((temp & TRANS_ENABLE) != 0) {
                         I915_WRITE(transconf_reg, temp & ~TRANS_ENABLE);
-                        I915_READ(transconf_reg);
-                        n = 0;
+
                         /* wait for PCH transcoder off, transcoder state */
-                        while ((I915_READ(transconf_reg) & TRANS_STATE_ENABLE) != 0) {
-                                n++;
-                                if (n < 60) {
-                                        udelay(500);
-                                        continue;
-                                } else {
-                                        DRM_DEBUG_KMS("transcoder %d off "
-                                                        "delay\n", pipe);
-                                        break;
-                                }
-                        }
+                        if (wait_for((I915_READ(transconf_reg) & TRANS_STATE_ENABLE) == 0, 50, 1))
+                                DRM_ERROR("failed to disable transcoder\n");
                 }
 
                 temp = I915_READ(transconf_reg);
@@ -2294,10 +2212,6 @@ static void ironlake_crtc_dpms(struct drm_crtc *crtc, int mode)
                 I915_WRITE(pch_dpll_reg, temp & ~DPLL_VCO_ENABLE);
                 I915_READ(pch_dpll_reg);
 
-                if (HAS_eDP) {
-                        ironlake_disable_pll_edp(crtc);
-                }
-
                 /* Switch from PCDclk to Rawclk */
                 temp = I915_READ(fdi_rx_reg);
                 temp &= ~FDI_SEL_PCDCLK;
@@ -2372,8 +2286,6 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
         case DRM_MODE_DPMS_ON:
         case DRM_MODE_DPMS_STANDBY:
         case DRM_MODE_DPMS_SUSPEND:
-                intel_update_watermarks(dev);
-
                 /* Enable the DPLL */
                 temp = I915_READ(dpll_reg);
                 if ((temp & DPLL_VCO_ENABLE) == 0) {
@@ -2413,8 +2325,6 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
                 intel_crtc_dpms_overlay(intel_crtc, true);
         break;
         case DRM_MODE_DPMS_OFF:
-                intel_update_watermarks(dev);
-
                 /* Give the overlay scaler a chance to disable if it's on this pipe */
                 intel_crtc_dpms_overlay(intel_crtc, false);
                 drm_vblank_off(dev, pipe);
@@ -2423,9 +2333,6 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
                     dev_priv->display.disable_fbc)
                         dev_priv->display.disable_fbc(dev);
 
-                /* Disable the VGA plane that we never use */
-                i915_disable_vga(dev);
-
                 /* Disable display plane */
                 temp = I915_READ(dspcntr_reg);
                 if ((temp & DISPLAY_PLANE_ENABLE) != 0) {
@@ -2435,15 +2342,13 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
                         I915_READ(dspbase_reg);
                 }
 
-                if (!IS_I9XX(dev)) {
-                        /* Wait for vblank for the disable to take effect */
-                        intel_wait_for_vblank(dev);
-                }
-
                 /* Don't disable pipe A or pipe A PLLs if needed */
                 if (pipeconf_reg == PIPEACONF &&
-                    (dev_priv->quirks & QUIRK_PIPEA_FORCE))
+                    (dev_priv->quirks & QUIRK_PIPEA_FORCE)) {
+                        /* Wait for vblank for the disable to take effect */
+                        intel_wait_for_vblank(dev, pipe);
                         goto skip_pipe_off;
+                }
 
                 /* Next, disable display pipes */
                 temp = I915_READ(pipeconf_reg);
@@ -2452,8 +2357,8 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
                         I915_READ(pipeconf_reg);
                 }
 
-                /* Wait for vblank for the disable to take effect. */
-                intel_wait_for_vblank(dev);
+                /* Wait for the pipe to turn off */
+                intel_wait_for_pipe_off(dev, pipe);
 
                 temp = I915_READ(dpll_reg);
                 if ((temp & DPLL_VCO_ENABLE) != 0) {
@@ -2469,9 +2374,6 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
 
 /**
  * Sets the power management mode of the pipe and plane.
- *
- * This code should probably grow support for turning the cursor off and back
- * on appropriately at the same time as we're turning the pipe off/on.
  */
 static void intel_crtc_dpms(struct drm_crtc *crtc, int mode)
 {
@@ -2482,9 +2384,29 @@ static void intel_crtc_dpms(struct drm_crtc *crtc, int mode)
         int pipe = intel_crtc->pipe;
         bool enabled;
 
-        dev_priv->display.dpms(crtc, mode);
+        if (intel_crtc->dpms_mode == mode)
+                return;
 
         intel_crtc->dpms_mode = mode;
+        intel_crtc->cursor_on = mode == DRM_MODE_DPMS_ON;
+
+        /* When switching on the display, ensure that SR is disabled
+         * with multiple pipes prior to enabling to new pipe.
+         *
+         * When switching off the display, make sure the cursor is
+         * properly hidden prior to disabling the pipe.
+         */
+        if (mode == DRM_MODE_DPMS_ON)
+                intel_update_watermarks(dev);
+        else
+                intel_crtc_update_cursor(crtc);
+
+        dev_priv->display.dpms(crtc, mode);
+
+        if (mode == DRM_MODE_DPMS_ON)
+                intel_crtc_update_cursor(crtc);
+        else
+                intel_update_watermarks(dev);
 
         if (!dev->primary->master)
                 return;
@@ -2536,16 +2458,38 @@ void intel_encoder_commit (struct drm_encoder *encoder)
         encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
 }
 
+void intel_encoder_destroy(struct drm_encoder *encoder)
+{
+        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
+
+        if (intel_encoder->ddc_bus)
+                intel_i2c_destroy(intel_encoder->ddc_bus);
+
+        if (intel_encoder->i2c_bus)
+                intel_i2c_destroy(intel_encoder->i2c_bus);
+
+        drm_encoder_cleanup(encoder);
+        kfree(intel_encoder);
+}
+
 static bool intel_crtc_mode_fixup(struct drm_crtc *crtc,
                                   struct drm_display_mode *mode,
                                   struct drm_display_mode *adjusted_mode)
 {
         struct drm_device *dev = crtc->dev;
+
         if (HAS_PCH_SPLIT(dev)) {
                 /* FDI link clock is fixed at 2.7G */
                 if (mode->clock * 3 > IRONLAKE_FDI_FREQ * 4)
                         return false;
         }
+
+        /* XXX some encoders set the crtcinfo, others don't.
+         * Obviously we need some form of conflict resolution here...
+         */
+        if (adjusted_mode->crtc_htotal == 0)
+                drm_mode_set_crtcinfo(adjusted_mode, 0);
+
         return true;
 }
 
@@ -2845,14 +2789,8 @@ static unsigned long intel_calculate_wm(unsigned long clock_in_khz,
         /* Don't promote wm_size to unsigned... */
         if (wm_size > (long)wm->max_wm)
                 wm_size = wm->max_wm;
-        if (wm_size <= 0) {
+        if (wm_size <= 0)
                 wm_size = wm->default_wm;
-                DRM_ERROR("Insufficient FIFO for plane, expect flickering:"
-                          " entries required = %ld, available = %lu.\n",
-                          entries_required + wm->guard_size,
-                          wm->fifo_size);
-        }
-
         return wm_size;
 }
 
@@ -2867,7 +2805,7 @@ struct cxsr_latency {
         unsigned long cursor_hpll_disable;
 };
 
-static struct cxsr_latency cxsr_latency_table[] = {
+static const struct cxsr_latency cxsr_latency_table[] = {
         {1, 0, 800, 400, 3382, 33382, 3983, 33983},    /* DDR2-400 SC */
         {1, 0, 800, 667, 3354, 33354, 3807, 33807},    /* DDR2-667 SC */
         {1, 0, 800, 800, 3347, 33347, 3763, 33763},    /* DDR2-800 SC */
@@ -2905,11 +2843,13 @@ static struct cxsr_latency cxsr_latency_table[] = {
         {0, 1, 400, 800, 6042, 36042, 6584, 36584},    /* DDR3-800 SC */
 };
 
-static struct cxsr_latency *intel_get_cxsr_latency(int is_desktop, int is_ddr3, 
-                                                   int fsb, int mem)
+static const struct cxsr_latency *intel_get_cxsr_latency(int is_desktop,
+                                                         int is_ddr3,
+                                                         int fsb,
+                                                         int mem)
 {
+        const struct cxsr_latency *latency;
         int i;
-        struct cxsr_latency *latency;
 
         if (fsb == 0 || mem == 0)
                 return NULL;
@@ -2930,13 +2870,9 @@ static struct cxsr_latency *intel_get_cxsr_latency(int is_desktop, int is_ddr3,
 static void pineview_disable_cxsr(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 reg;
 
         /* deactivate cxsr */
-        reg = I915_READ(DSPFW3);
-        reg &= ~(PINEVIEW_SELF_REFRESH_EN);
-        I915_WRITE(DSPFW3, reg);
-        DRM_INFO("Big FIFO is disabled\n");
+        I915_WRITE(DSPFW3, I915_READ(DSPFW3) & ~PINEVIEW_SELF_REFRESH_EN);
 }
 
 /*
@@ -3024,12 +2960,12 @@ static void pineview_update_wm(struct drm_device *dev,  int planea_clock,
                           int pixel_size)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
+        const struct cxsr_latency *latency;
         u32 reg;
         unsigned long wm;
-        struct cxsr_latency *latency;
         int sr_clock;
 
-        latency = intel_get_cxsr_latency(IS_PINEVIEW_G(dev), dev_priv->is_ddr3, 
+        latency = intel_get_cxsr_latency(IS_PINEVIEW_G(dev), dev_priv->is_ddr3,
                                          dev_priv->fsb_freq, dev_priv->mem_freq);
         if (!latency) {
                 DRM_DEBUG_KMS("Unknown FSB/MEM found, disable CxSR\n");
@@ -3075,9 +3011,8 @@ static void pineview_update_wm(struct drm_device *dev,  int planea_clock,
                 DRM_DEBUG_KMS("DSPFW3 register is %x\n", reg);
 
                 /* activate cxsr */
-                reg = I915_READ(DSPFW3);
-                reg |= PINEVIEW_SELF_REFRESH_EN;
-                I915_WRITE(DSPFW3, reg);
+                I915_WRITE(DSPFW3,
+                           I915_READ(DSPFW3) | PINEVIEW_SELF_REFRESH_EN);
                 DRM_DEBUG_KMS("Self-refresh is enabled\n");
         } else {
                 pineview_disable_cxsr(dev);
@@ -3354,12 +3289,11 @@ static void ironlake_update_wm(struct drm_device *dev,  int planea_clock,
         int line_count;
         int planea_htotal = 0, planeb_htotal = 0;
         struct drm_crtc *crtc;
-        struct intel_crtc *intel_crtc;
 
         /* Need htotal for all active display plane */
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                intel_crtc = to_intel_crtc(crtc);
-                if (crtc->enabled) {
+                struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+                if (intel_crtc->dpms_mode == DRM_MODE_DPMS_ON) {
                         if (intel_crtc->plane == 0)
                                 planea_htotal = crtc->mode.htotal;
                         else
@@ -3470,8 +3404,7 @@ static void ironlake_update_wm(struct drm_device *dev,  int planea_clock,
                 reg_value = I915_READ(WM1_LP_ILK);
                 reg_value &= ~(WM1_LP_LATENCY_MASK | WM1_LP_SR_MASK |
                                WM1_LP_CURSOR_MASK);
-                reg_value |= WM1_LP_SR_EN |
-                             (ilk_sr_latency << WM1_LP_LATENCY_SHIFT) |
+                reg_value |= (ilk_sr_latency << WM1_LP_LATENCY_SHIFT) |
                              (sr_wm << WM1_LP_SR_SHIFT) | cursor_wm;
 
                 I915_WRITE(WM1_LP_ILK, reg_value);
@@ -3519,7 +3452,6 @@ static void intel_update_watermarks(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_crtc *crtc;
-        struct intel_crtc *intel_crtc;
         int sr_hdisplay = 0;
         unsigned long planea_clock = 0, planeb_clock = 0, sr_clock = 0;
         int enabled = 0, pixel_size = 0;
@@ -3530,8 +3462,8 @@ static void intel_update_watermarks(struct drm_device *dev)
 
         /* Get the clock config from both planes */
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                intel_crtc = to_intel_crtc(crtc);
-                if (crtc->enabled) {
+                struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+                if (intel_crtc->dpms_mode == DRM_MODE_DPMS_ON) {
                         enabled++;
                         if (intel_crtc->plane == 0) {
                                 DRM_DEBUG_KMS("plane A (pipe %d) clock: %d\n",
@@ -3589,10 +3521,9 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         u32 dpll = 0, fp = 0, fp2 = 0, dspcntr, pipeconf;
         bool ok, has_reduced_clock = false, is_sdvo = false, is_dvo = false;
         bool is_crt = false, is_lvds = false, is_tv = false, is_dp = false;
-        bool is_edp = false;
+        struct intel_encoder *has_edp_encoder = NULL;
         struct drm_mode_config *mode_config = &dev->mode_config;
         struct drm_encoder *encoder;
-        struct intel_encoder *intel_encoder = NULL;
         const intel_limit_t *limit;
         int ret;
         struct fdi_m_n m_n = {0};
@@ -3613,12 +3544,12 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         drm_vblank_pre_modeset(dev, pipe);
 
         list_for_each_entry(encoder, &mode_config->encoder_list, head) {
+                struct intel_encoder *intel_encoder;
 
-                if (!encoder || encoder->crtc != crtc)
+                if (encoder->crtc != crtc)
                         continue;
 
                 intel_encoder = enc_to_intel_encoder(encoder);
-
                 switch (intel_encoder->type) {
                 case INTEL_OUTPUT_LVDS:
                         is_lvds = true;
@@ -3642,7 +3573,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                         is_dp = true;
                         break;
                 case INTEL_OUTPUT_EDP:
-                        is_edp = true;
+                        has_edp_encoder = intel_encoder;
                         break;
                 }
 
@@ -3720,10 +3651,10 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 int lane = 0, link_bw, bpp;
                 /* eDP doesn't require FDI link, so just set DP M/N
                    according to current link config */
-                if (is_edp) {
+                if (has_edp_encoder) {
                         target_clock = mode->clock;
-                        intel_edp_link_config(intel_encoder,
-                                        &lane, &link_bw);
+                        intel_edp_link_config(has_edp_encoder,
+                                              &lane, &link_bw);
                 } else {
                         /* DP over FDI requires target mode clock
                            instead of link clock */
@@ -3744,7 +3675,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                                 temp |= PIPE_8BPC;
                         else
                                 temp |= PIPE_6BPC;
-                } else if (is_edp || (is_dp && intel_pch_has_edp(crtc))) {
+                } else if (has_edp_encoder || (is_dp && intel_pch_has_edp(crtc))) {
                         switch (dev_priv->edp_bpp/3) {
                         case 8:
                                 temp |= PIPE_8BPC;
@@ -3817,7 +3748,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
 
                 udelay(200);
 
-                if (is_edp) {
+                if (has_edp_encoder) {
                         if (dev_priv->lvds_use_ssc) {
                                 temp |= DREF_SSC1_ENABLE;
                                 I915_WRITE(PCH_DREF_CONTROL, temp);
@@ -3966,9 +3897,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 dpll_reg = pch_dpll_reg;
         }
 
-        if (is_edp) {
-                ironlake_disable_pll_edp(crtc);
-        } else if ((dpll & DPLL_VCO_ENABLE)) {
+        if (!has_edp_encoder) {
                 I915_WRITE(fp_reg, fp);
                 I915_WRITE(dpll_reg, dpll & ~DPLL_VCO_ENABLE);
                 I915_READ(dpll_reg);
@@ -4063,7 +3992,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 }
         }
 
-        if (!is_edp) {
+        if (!has_edp_encoder) {
                 I915_WRITE(fp_reg, fp);
                 I915_WRITE(dpll_reg, dpll);
                 I915_READ(dpll_reg);
@@ -4142,7 +4071,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 I915_WRITE(link_m1_reg, m_n.link_m);
                 I915_WRITE(link_n1_reg, m_n.link_n);
 
-                if (is_edp) {
+                if (has_edp_encoder) {
                         ironlake_set_pll_edp(crtc, adjusted_mode->clock);
                 } else {
                         /* enable FDI RX PLL too */
@@ -4167,7 +4096,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         I915_WRITE(pipeconf_reg, pipeconf);
         I915_READ(pipeconf_reg);
 
-        intel_wait_for_vblank(dev);
+        intel_wait_for_vblank(dev, pipe);
 
         if (IS_IRONLAKE(dev)) {
                 /* enable address swizzle for tiling buffer */
@@ -4180,9 +4109,6 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         /* Flush the plane changes */
         ret = intel_pipe_set_base(crtc, x, y, old_fb);
 
-        if ((IS_I965G(dev) || plane == 0))
-                intel_update_fbc(crtc, &crtc->mode);
-
         intel_update_watermarks(dev);
 
         drm_vblank_post_modeset(dev, pipe);
@@ -4216,6 +4142,62 @@ void intel_crtc_load_lut(struct drm_crtc *crtc)
         }
 }
 
+static void i845_update_cursor(struct drm_crtc *crtc, u32 base)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        bool visible = base != 0;
+        u32 cntl;
+
+        if (intel_crtc->cursor_visible == visible)
+                return;
+
+        cntl = I915_READ(CURACNTR);
+        if (visible) {
+                /* On these chipsets we can only modify the base whilst
+                 * the cursor is disabled.
+                 */
+                I915_WRITE(CURABASE, base);
+
+                cntl &= ~(CURSOR_FORMAT_MASK);
+                /* XXX width must be 64, stride 256 => 0x00 << 28 */
+                cntl |= CURSOR_ENABLE |
+                        CURSOR_GAMMA_ENABLE |
+                        CURSOR_FORMAT_ARGB;
+        } else
+                cntl &= ~(CURSOR_ENABLE | CURSOR_GAMMA_ENABLE);
+        I915_WRITE(CURACNTR, cntl);
+
+        intel_crtc->cursor_visible = visible;
+}
+
+static void i9xx_update_cursor(struct drm_crtc *crtc, u32 base)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        int pipe = intel_crtc->pipe;
+        bool visible = base != 0;
+
+        if (intel_crtc->cursor_visible != visible) {
+                uint32_t cntl = I915_READ(pipe == 0 ? CURACNTR : CURBCNTR);
+                if (base) {
+                        cntl &= ~(CURSOR_MODE | MCURSOR_PIPE_SELECT);
+                        cntl |= CURSOR_MODE_64_ARGB_AX | MCURSOR_GAMMA_ENABLE;
+                        cntl |= pipe << 28; /* Connect to correct pipe */
+                } else {
+                        cntl &= ~(CURSOR_MODE | MCURSOR_GAMMA_ENABLE);
+                        cntl |= CURSOR_MODE_DISABLE;
+                }
+                I915_WRITE(pipe == 0 ? CURACNTR : CURBCNTR, cntl);
+
+                intel_crtc->cursor_visible = visible;
+        }
+        /* and commit changes on next vblank */
+        I915_WRITE(pipe == 0 ? CURABASE : CURBBASE, base);
+}
+
 /* If no-part of the cursor is visible on the framebuffer, then the GPU may hang... */
 static void intel_crtc_update_cursor(struct drm_crtc *crtc)
 {
@@ -4225,12 +4207,12 @@ static void intel_crtc_update_cursor(struct drm_crtc *crtc)
         int pipe = intel_crtc->pipe;
         int x = intel_crtc->cursor_x;
         int y = intel_crtc->cursor_y;
-        uint32_t base, pos;
+        u32 base, pos;
         bool visible;
 
         pos = 0;
 
-        if (crtc->fb) {
+        if (intel_crtc->cursor_on && crtc->fb) {
                 base = intel_crtc->cursor_addr;
                 if (x > (int) crtc->fb->width)
                         base = 0;
@@ -4259,37 +4241,14 @@ static void intel_crtc_update_cursor(struct drm_crtc *crtc)
         pos |= y << CURSOR_Y_SHIFT;
 
         visible = base != 0;
-        if (!visible && !intel_crtc->cursor_visble)
+        if (!visible && !intel_crtc->cursor_visible)
                 return;
 
         I915_WRITE(pipe == 0 ? CURAPOS : CURBPOS, pos);
-        if (intel_crtc->cursor_visble != visible) {
-                uint32_t cntl = I915_READ(pipe == 0 ? CURACNTR : CURBCNTR);
-                if (base) {
-                        /* Hooray for CUR*CNTR differences */
-                        if (IS_MOBILE(dev) || IS_I9XX(dev)) {
-                                cntl &= ~(CURSOR_MODE | MCURSOR_PIPE_SELECT);
-                                cntl |= CURSOR_MODE_64_ARGB_AX | MCURSOR_GAMMA_ENABLE;
-                                cntl |= pipe << 28; /* Connect to correct pipe */
-                        } else {
-                                cntl &= ~(CURSOR_FORMAT_MASK);
-                                cntl |= CURSOR_ENABLE;
-                                cntl |= CURSOR_FORMAT_ARGB | CURSOR_GAMMA_ENABLE;
-                        }
-                } else {
-                        if (IS_MOBILE(dev) || IS_I9XX(dev)) {
-                                cntl &= ~(CURSOR_MODE | MCURSOR_GAMMA_ENABLE);
-                                cntl |= CURSOR_MODE_DISABLE;
-                        } else {
-                                cntl &= ~(CURSOR_ENABLE | CURSOR_GAMMA_ENABLE);
-                        }
-                }
-                I915_WRITE(pipe == 0 ? CURACNTR : CURBCNTR, cntl);
-
-                intel_crtc->cursor_visble = visible;
-        }
-        /* and commit changes on next vblank */
-        I915_WRITE(pipe == 0 ? CURABASE : CURBBASE, base);
+        if (IS_845G(dev) || IS_I865G(dev))
+                i845_update_cursor(crtc, base);
+        else
+                i9xx_update_cursor(crtc, base);
 
         if (visible)
                 intel_mark_busy(dev, to_intel_framebuffer(crtc->fb)->obj);
@@ -4354,8 +4313,10 @@ static int intel_crtc_cursor_set(struct drm_crtc *crtc,
 
                 addr = obj_priv->gtt_offset;
         } else {
+                int align = IS_I830(dev) ? 16 * 1024 : 256;
                 ret = i915_gem_attach_phys_object(dev, bo,
-                                                  (intel_crtc->pipe == 0) ? I915_GEM_PHYS_CURSOR_0 : I915_GEM_PHYS_CURSOR_1);
+                                                  (intel_crtc->pipe == 0) ? I915_GEM_PHYS_CURSOR_0 : I915_GEM_PHYS_CURSOR_1,
+                                                  align);
                 if (ret) {
                         DRM_ERROR("failed to attach phys object\n");
                         goto fail_locked;
@@ -4544,7 +4505,7 @@ struct drm_crtc *intel_get_load_detect_pipe(struct intel_encoder *intel_encoder,
                 encoder_funcs->commit(encoder);
         }
         /* let the connector get through one full cycle before testing */
-        intel_wait_for_vblank(dev);
+        intel_wait_for_vblank(dev, intel_crtc->pipe);
 
         return crtc;
 }
@@ -4749,7 +4710,7 @@ static void intel_increase_pllclock(struct drm_crtc *crtc, bool schedule)
                 dpll &= ~DISPLAY_RATE_SELECT_FPA1;
                 I915_WRITE(dpll_reg, dpll);
                 dpll = I915_READ(dpll_reg);
-                intel_wait_for_vblank(dev);
+                intel_wait_for_vblank(dev, pipe);
                 dpll = I915_READ(dpll_reg);
                 if (dpll & DISPLAY_RATE_SELECT_FPA1)
                         DRM_DEBUG_DRIVER("failed to upclock LVDS!\n");
@@ -4793,7 +4754,7 @@ static void intel_decrease_pllclock(struct drm_crtc *crtc)
                 dpll |= DISPLAY_RATE_SELECT_FPA1;
                 I915_WRITE(dpll_reg, dpll);
                 dpll = I915_READ(dpll_reg);
-                intel_wait_for_vblank(dev);
+                intel_wait_for_vblank(dev, pipe);
                 dpll = I915_READ(dpll_reg);
                 if (!(dpll & DISPLAY_RATE_SELECT_FPA1))
                         DRM_DEBUG_DRIVER("failed to downclock LVDS!\n");
@@ -4916,15 +4877,6 @@ static void intel_crtc_destroy(struct drm_crtc *crtc)
         kfree(intel_crtc);
 }
 
-struct intel_unpin_work {
-        struct work_struct work;
-        struct drm_device *dev;
-        struct drm_gem_object *old_fb_obj;
-        struct drm_gem_object *pending_flip_obj;
-        struct drm_pending_vblank_event *event;
-        int pending;
-};
-
 static void intel_unpin_work_fn(struct work_struct *__work)
 {
         struct intel_unpin_work *work =
@@ -5012,7 +4964,8 @@ void intel_prepare_page_flip(struct drm_device *dev, int plane)
 
         spin_lock_irqsave(&dev->event_lock, flags);
         if (intel_crtc->unpin_work) {
-                intel_crtc->unpin_work->pending = 1;
+                if ((++intel_crtc->unpin_work->pending) > 1)
+                        DRM_ERROR("Prepared flip multiple times\n");
         } else {
                 DRM_DEBUG_DRIVER("preparing flip with no unpin work?\n");
         }
@@ -5031,9 +4984,9 @@ static int intel_crtc_page_flip(struct drm_crtc *crtc,
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
         struct intel_unpin_work *work;
         unsigned long flags, offset;
-        int pipesrc_reg = (intel_crtc->pipe == 0) ? PIPEASRC : PIPEBSRC;
-        int ret, pipesrc;
-        u32 flip_mask;
+        int pipe = intel_crtc->pipe;
+        u32 pf, pipesrc;
+        int ret;
 
         work = kzalloc(sizeof *work, GFP_KERNEL);
         if (work == NULL)
@@ -5082,34 +5035,73 @@ static int intel_crtc_page_flip(struct drm_crtc *crtc,
         atomic_inc(&obj_priv->pending_flip);
         work->pending_flip_obj = obj;
 
-        if (intel_crtc->plane)
-                flip_mask = I915_DISPLAY_PLANE_B_FLIP_PENDING_INTERRUPT;
-        else
-                flip_mask = I915_DISPLAY_PLANE_A_FLIP_PENDING_INTERRUPT;
+        if (IS_GEN3(dev) || IS_GEN2(dev)) {
+                u32 flip_mask;
 
-        /* Wait for any previous flip to finish */
-        if (IS_GEN3(dev))
-                while (I915_READ(ISR) & flip_mask)
-                        ;
+                if (intel_crtc->plane)
+                        flip_mask = MI_WAIT_FOR_PLANE_B_FLIP;
+                else
+                        flip_mask = MI_WAIT_FOR_PLANE_A_FLIP;
+
+                BEGIN_LP_RING(2);
+                OUT_RING(MI_WAIT_FOR_EVENT | flip_mask);
+                OUT_RING(0);
+                ADVANCE_LP_RING();
+        }
+
+        work->enable_stall_check = true;
 
         /* Offset into the new buffer for cases of shared fbs between CRTCs */
-        offset = obj_priv->gtt_offset;
-        offset += (crtc->y * fb->pitch) + (crtc->x * (fb->bits_per_pixel) / 8);
+        offset = crtc->y * fb->pitch + crtc->x * fb->bits_per_pixel/8;
 
         BEGIN_LP_RING(4);
-        if (IS_I965G(dev)) {
+        switch(INTEL_INFO(dev)->gen) {
+        case 2:
                 OUT_RING(MI_DISPLAY_FLIP |
                          MI_DISPLAY_FLIP_PLANE(intel_crtc->plane));
                 OUT_RING(fb->pitch);
-                OUT_RING(offset | obj_priv->tiling_mode);
-                pipesrc = I915_READ(pipesrc_reg); 
-                OUT_RING(pipesrc & 0x0fff0fff);
-        } else {
+                OUT_RING(obj_priv->gtt_offset + offset);
+                OUT_RING(MI_NOOP);
+                break;
+
+        case 3:
                 OUT_RING(MI_DISPLAY_FLIP_I915 |
                          MI_DISPLAY_FLIP_PLANE(intel_crtc->plane));
                 OUT_RING(fb->pitch);
-                OUT_RING(offset);
+                OUT_RING(obj_priv->gtt_offset + offset);
                 OUT_RING(MI_NOOP);
+                break;
+
+        case 4:
+        case 5:
+                /* i965+ uses the linear or tiled offsets from the
+                 * Display Registers (which do not change across a page-flip)
+                 * so we need only reprogram the base address.
+                 */
+                OUT_RING(MI_DISPLAY_FLIP |
+                         MI_DISPLAY_FLIP_PLANE(intel_crtc->plane));
+                OUT_RING(fb->pitch);
+                OUT_RING(obj_priv->gtt_offset | obj_priv->tiling_mode);
+
+                /* XXX Enabling the panel-fitter across page-flip is so far
+                 * untested on non-native modes, so ignore it for now.
+                 * pf = I915_READ(pipe == 0 ? PFA_CTL_1 : PFB_CTL_1) & PF_ENABLE;
+                 */
+                pf = 0;
+                pipesrc = I915_READ(pipe == 0 ? PIPEASRC : PIPEBSRC) & 0x0fff0fff;
+                OUT_RING(pf | pipesrc);
+                break;
+
+        case 6:
+                OUT_RING(MI_DISPLAY_FLIP |
+                         MI_DISPLAY_FLIP_PLANE(intel_crtc->plane));
+                OUT_RING(fb->pitch | obj_priv->tiling_mode);
+                OUT_RING(obj_priv->gtt_offset);
+
+                pf = I915_READ(pipe == 0 ? PFA_CTL_1 : PFB_CTL_1) & PF_ENABLE;
+                pipesrc = I915_READ(pipe == 0 ? PIPEASRC : PIPEBSRC) & 0x0fff0fff;
+                OUT_RING(pf | pipesrc);
+                break;
         }
         ADVANCE_LP_RING();
 
@@ -5190,7 +5182,7 @@ static void intel_crtc_init(struct drm_device *dev, int pipe)
         dev_priv->pipe_to_crtc_mapping[intel_crtc->pipe] = &intel_crtc->base;
 
         intel_crtc->cursor_addr = 0;
-        intel_crtc->dpms_mode = DRM_MODE_DPMS_OFF;
+        intel_crtc->dpms_mode = -1;
         drm_crtc_helper_add(&intel_crtc->base, &intel_helper_funcs);
 
         intel_crtc->busy = false;
@@ -5432,37 +5424,37 @@ static const struct drm_mode_config_funcs intel_mode_funcs = {
 };
 
 static struct drm_gem_object *
-intel_alloc_power_context(struct drm_device *dev)
+intel_alloc_context_page(struct drm_device *dev)
 {
-        struct drm_gem_object *pwrctx;
+        struct drm_gem_object *ctx;
         int ret;
 
-        pwrctx = i915_gem_alloc_object(dev, 4096);
-        if (!pwrctx) {
+        ctx = i915_gem_alloc_object(dev, 4096);
+        if (!ctx) {
                 DRM_DEBUG("failed to alloc power context, RC6 disabled\n");
                 return NULL;
         }
 
         mutex_lock(&dev->struct_mutex);
-        ret = i915_gem_object_pin(pwrctx, 4096);
+        ret = i915_gem_object_pin(ctx, 4096);
         if (ret) {
                 DRM_ERROR("failed to pin power context: %d\n", ret);
                 goto err_unref;
         }
 
-        ret = i915_gem_object_set_to_gtt_domain(pwrctx, 1);
+        ret = i915_gem_object_set_to_gtt_domain(ctx, 1);
         if (ret) {
                 DRM_ERROR("failed to set-domain on power context: %d\n", ret);
                 goto err_unpin;
         }
         mutex_unlock(&dev->struct_mutex);
 
-        return pwrctx;
+        return ctx;
 
 err_unpin:
-        i915_gem_object_unpin(pwrctx);
+        i915_gem_object_unpin(ctx);
 err_unref:
-        drm_gem_object_unreference(pwrctx);
+        drm_gem_object_unreference(ctx);
         mutex_unlock(&dev->struct_mutex);
         return NULL;
 }
@@ -5494,7 +5486,6 @@ void ironlake_enable_drps(struct drm_device *dev)
         struct drm_i915_private *dev_priv = dev->dev_private;
         u32 rgvmodectl = I915_READ(MEMMODECTL);
         u8 fmax, fmin, fstart, vstart;
-        int i = 0;
 
         /* 100ms RC evaluation intervals */
         I915_WRITE(RCUPEI, 100000);
@@ -5538,13 +5529,8 @@ void ironlake_enable_drps(struct drm_device *dev)
         rgvmodectl |= MEMMODE_SWMODE_EN;
         I915_WRITE(MEMMODECTL, rgvmodectl);
 
-        while (I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) {
-                if (i++ > 100) {
-                        DRM_ERROR("stuck trying to change perf mode\n");
-                        break;
-                }
-                msleep(1);
-        }
+        if (wait_for((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 1, 0))
+                DRM_ERROR("stuck trying to change perf mode\n");
         msleep(1);
 
         ironlake_set_drps(dev, fstart);
@@ -5704,6 +5690,9 @@ void intel_init_clock_gating(struct drm_device *dev)
                         I915_WRITE(DISP_ARB_CTL,
                                         (I915_READ(DISP_ARB_CTL) |
                                                 DISP_FBC_WM_DIS));
+                I915_WRITE(WM3_LP_ILK, 0);
+                I915_WRITE(WM2_LP_ILK, 0);
+                I915_WRITE(WM1_LP_ILK, 0);
                 }
                 /*
                  * Based on the document from hardware guys the following bits
@@ -5768,6 +5757,29 @@ void intel_init_clock_gating(struct drm_device *dev)
          * GPU can automatically power down the render unit if given a page
          * to save state.
          */
+        if (IS_IRONLAKE_M(dev)) {
+                if (dev_priv->renderctx == NULL)
+                        dev_priv->renderctx = intel_alloc_context_page(dev);
+                if (dev_priv->renderctx) {
+                        struct drm_i915_gem_object *obj_priv;
+                        obj_priv = to_intel_bo(dev_priv->renderctx);
+                        if (obj_priv) {
+                                BEGIN_LP_RING(4);
+                                OUT_RING(MI_SET_CONTEXT);
+                                OUT_RING(obj_priv->gtt_offset |
+                                                MI_MM_SPACE_GTT |
+                                                MI_SAVE_EXT_STATE_EN |
+                                                MI_RESTORE_EXT_STATE_EN |
+                                                MI_RESTORE_INHIBIT);
+                                OUT_RING(MI_NOOP);
+                                OUT_RING(MI_FLUSH);
+                                ADVANCE_LP_RING();
+                        }
+                } else
+                        DRM_DEBUG_KMS("Failed to allocate render context."
+                                       "Disable RC6\n");
+        }
+
         if (I915_HAS_RC6(dev) && drm_core_check_feature(dev, DRIVER_MODESET)) {
                 struct drm_i915_gem_object *obj_priv = NULL;
 
@@ -5776,7 +5788,7 @@ void intel_init_clock_gating(struct drm_device *dev)
                 } else {
                         struct drm_gem_object *pwrctx;
 
-                        pwrctx = intel_alloc_power_context(dev);
+                        pwrctx = intel_alloc_context_page(dev);
                         if (pwrctx) {
                                 dev_priv->pwrctx = pwrctx;
                                 obj_priv = to_intel_bo(pwrctx);
@@ -5948,6 +5960,29 @@ static void intel_init_quirks(struct drm_device *dev)
         }
 }
 
+/* Disable the VGA plane that we never use */
+static void i915_disable_vga(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u8 sr1;
+        u32 vga_reg;
+
+        if (HAS_PCH_SPLIT(dev))
+                vga_reg = CPU_VGACNTRL;
+        else
+                vga_reg = VGACNTRL;
+
+        vga_get_uninterruptible(dev->pdev, VGA_RSRC_LEGACY_IO);
+        outb(1, VGA_SR_INDEX);
+        sr1 = inb(VGA_SR_DATA);
+        outb(sr1 | 1<<5, VGA_SR_DATA);
+        vga_put(dev->pdev, VGA_RSRC_LEGACY_IO);
+        udelay(300);
+
+        I915_WRITE(vga_reg, VGA_DISP_DISABLE);
+        POSTING_READ(vga_reg);
+}
+
 void intel_modeset_init(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
@@ -5996,6 +6031,9 @@ void intel_modeset_init(struct drm_device *dev)
 
         intel_init_clock_gating(dev);
 
+        /* Just disable it once at startup */
+        i915_disable_vga(dev);
+
         if (IS_IRONLAKE_M(dev)) {
                 ironlake_enable_drps(dev);
                 intel_init_emon(dev);
@@ -6034,6 +6072,16 @@ void intel_modeset_cleanup(struct drm_device *dev)
         if (dev_priv->display.disable_fbc)
                 dev_priv->display.disable_fbc(dev);
 
+        if (dev_priv->renderctx) {
+                struct drm_i915_gem_object *obj_priv;
+
+                obj_priv = to_intel_bo(dev_priv->renderctx);
+                I915_WRITE(CCID, obj_priv->gtt_offset &~ CCID_EN);
+                I915_READ(CCID);
+                i915_gem_object_unpin(dev_priv->renderctx);
+                drm_gem_object_unreference(dev_priv->renderctx);
+        }
+
         if (dev_priv->pwrctx) {
                 struct drm_i915_gem_object *obj_priv;
 
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 40be1fa65be1..9ab8708ac6ba 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -42,10 +42,11 @@
 
 #define DP_LINK_CONFIGURATION_SIZE      9
 
-#define IS_eDP(i) ((i)->type == INTEL_OUTPUT_EDP)
-#define IS_PCH_eDP(dp_priv) ((dp_priv)->is_pch_edp)
+#define IS_eDP(i) ((i)->base.type == INTEL_OUTPUT_EDP)
+#define IS_PCH_eDP(i) ((i)->is_pch_edp)
 
-struct intel_dp_priv {
+struct intel_dp {
+        struct intel_encoder base;
         uint32_t output_reg;
         uint32_t DP;
         uint8_t  link_configuration[DP_LINK_CONFIGURATION_SIZE];
@@ -54,40 +55,39 @@ struct intel_dp_priv {
         uint8_t link_bw;
         uint8_t lane_count;
         uint8_t dpcd[4];
-        struct intel_encoder *intel_encoder;
         struct i2c_adapter adapter;
         struct i2c_algo_dp_aux_data algo;
         bool is_pch_edp;
 };
 
-static void
-intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP,
-                    uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE]);
+static struct intel_dp *enc_to_intel_dp(struct drm_encoder *encoder)
+{
+        return container_of(enc_to_intel_encoder(encoder), struct intel_dp, base);
+}
 
-static void
-intel_dp_link_down(struct intel_encoder *intel_encoder, uint32_t DP);
+static void intel_dp_link_train(struct intel_dp *intel_dp);
+static void intel_dp_link_down(struct intel_dp *intel_dp);
 
 void
 intel_edp_link_config (struct intel_encoder *intel_encoder,
-                int *lane_num, int *link_bw)
+                       int *lane_num, int *link_bw)
 {
-        struct intel_dp_priv   *dp_priv = intel_encoder->dev_priv;
+        struct intel_dp *intel_dp = container_of(intel_encoder, struct intel_dp, base);
 
-        *lane_num = dp_priv->lane_count;
-        if (dp_priv->link_bw == DP_LINK_BW_1_62)
+        *lane_num = intel_dp->lane_count;
+        if (intel_dp->link_bw == DP_LINK_BW_1_62)
                 *link_bw = 162000;
-        else if (dp_priv->link_bw == DP_LINK_BW_2_7)
+        else if (intel_dp->link_bw == DP_LINK_BW_2_7)
                 *link_bw = 270000;
 }
 
 static int
-intel_dp_max_lane_count(struct intel_encoder *intel_encoder)
+intel_dp_max_lane_count(struct intel_dp *intel_dp)
 {
-        struct intel_dp_priv   *dp_priv = intel_encoder->dev_priv;
         int max_lane_count = 4;
 
-        if (dp_priv->dpcd[0] >= 0x11) {
-                max_lane_count = dp_priv->dpcd[2] & 0x1f;
+        if (intel_dp->dpcd[0] >= 0x11) {
+                max_lane_count = intel_dp->dpcd[2] & 0x1f;
                 switch (max_lane_count) {
                 case 1: case 2: case 4:
                         break;
@@ -99,10 +99,9 @@ intel_dp_max_lane_count(struct intel_encoder *intel_encoder)
 }
 
 static int
-intel_dp_max_link_bw(struct intel_encoder *intel_encoder)
+intel_dp_max_link_bw(struct intel_dp *intel_dp)
 {
-        struct intel_dp_priv   *dp_priv = intel_encoder->dev_priv;
-        int max_link_bw = dp_priv->dpcd[1];
+        int max_link_bw = intel_dp->dpcd[1];
 
         switch (max_link_bw) {
         case DP_LINK_BW_1_62:
@@ -126,13 +125,11 @@ intel_dp_link_clock(uint8_t link_bw)
 
 /* I think this is a fiction */
 static int
-intel_dp_link_required(struct drm_device *dev,
-                       struct intel_encoder *intel_encoder, int pixel_clock)
+intel_dp_link_required(struct drm_device *dev, struct intel_dp *intel_dp, int pixel_clock)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
 
-        if (IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv))
+        if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp))
                 return (pixel_clock * dev_priv->edp_bpp) / 8;
         else
                 return pixel_clock * 3;
@@ -149,14 +146,13 @@ intel_dp_mode_valid(struct drm_connector *connector,
                     struct drm_display_mode *mode)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
         struct drm_device *dev = connector->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_encoder));
-        int max_lanes = intel_dp_max_lane_count(intel_encoder);
+        int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_dp));
+        int max_lanes = intel_dp_max_lane_count(intel_dp);
 
-        if ((IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) &&
+        if ((IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp)) &&
             dev_priv->panel_fixed_mode) {
                 if (mode->hdisplay > dev_priv->panel_fixed_mode->hdisplay)
                         return MODE_PANEL;
@@ -167,8 +163,8 @@ intel_dp_mode_valid(struct drm_connector *connector,
 
         /* only refuse the mode on non eDP since we have seen some wierd eDP panels
            which are outside spec tolerances but somehow work by magic */
-        if (!IS_eDP(intel_encoder) &&
-            (intel_dp_link_required(connector->dev, intel_encoder, mode->clock)
+        if (!IS_eDP(intel_dp) &&
+            (intel_dp_link_required(connector->dev, intel_dp, mode->clock)
              > intel_dp_max_data_rate(max_link_clock, max_lanes)))
                 return MODE_CLOCK_HIGH;
 
@@ -232,19 +228,17 @@ intel_hrawclk(struct drm_device *dev)
 }
 
 static int
-intel_dp_aux_ch(struct intel_encoder *intel_encoder,
+intel_dp_aux_ch(struct intel_dp *intel_dp,
                 uint8_t *send, int send_bytes,
                 uint8_t *recv, int recv_size)
 {
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
-        uint32_t output_reg = dp_priv->output_reg;
-        struct drm_device *dev = intel_encoder->enc.dev;
+        uint32_t output_reg = intel_dp->output_reg;
+        struct drm_device *dev = intel_dp->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         uint32_t ch_ctl = output_reg + 0x10;
         uint32_t ch_data = ch_ctl + 4;
         int i;
         int recv_bytes;
-        uint32_t ctl;
         uint32_t status;
         uint32_t aux_clock_divider;
         int try, precharge;
@@ -253,7 +247,7 @@ intel_dp_aux_ch(struct intel_encoder *intel_encoder,
          * and would like to run at 2MHz. So, take the
          * hrawclk value and divide by 2 and use that
          */
-        if (IS_eDP(intel_encoder)) {
+        if (IS_eDP(intel_dp)) {
                 if (IS_GEN6(dev))
                         aux_clock_divider = 200; /* SNB eDP input clock at 400Mhz */
                 else
@@ -268,41 +262,43 @@ intel_dp_aux_ch(struct intel_encoder *intel_encoder,
         else
                 precharge = 5;
 
+        if (I915_READ(ch_ctl) & DP_AUX_CH_CTL_SEND_BUSY) {
+                DRM_ERROR("dp_aux_ch not started status 0x%08x\n",
+                          I915_READ(ch_ctl));
+                return -EBUSY;
+        }
+
         /* Must try at least 3 times according to DP spec */
         for (try = 0; try < 5; try++) {
                 /* Load the send data into the aux channel data registers */
-                for (i = 0; i < send_bytes; i += 4) {
-                        uint32_t    d = pack_aux(send + i, send_bytes - i);
-        
-                        I915_WRITE(ch_data + i, d);
-                }
-        
-                ctl = (DP_AUX_CH_CTL_SEND_BUSY |
-                       DP_AUX_CH_CTL_TIME_OUT_400us |
-                       (send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
-                       (precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
-                       (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT) |
-                       DP_AUX_CH_CTL_DONE |
-                       DP_AUX_CH_CTL_TIME_OUT_ERROR |
-                       DP_AUX_CH_CTL_RECEIVE_ERROR);
+                for (i = 0; i < send_bytes; i += 4)
+                        I915_WRITE(ch_data + i,
+                                   pack_aux(send + i, send_bytes - i));
         
                 /* Send the command and wait for it to complete */
-                I915_WRITE(ch_ctl, ctl);
-                (void) I915_READ(ch_ctl);
+                I915_WRITE(ch_ctl,
+                           DP_AUX_CH_CTL_SEND_BUSY |
+                           DP_AUX_CH_CTL_TIME_OUT_400us |
+                           (send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
+                           (precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
+                           (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT) |
+                           DP_AUX_CH_CTL_DONE |
+                           DP_AUX_CH_CTL_TIME_OUT_ERROR |
+                           DP_AUX_CH_CTL_RECEIVE_ERROR);
                 for (;;) {
-                        udelay(100);
                         status = I915_READ(ch_ctl);
                         if ((status & DP_AUX_CH_CTL_SEND_BUSY) == 0)
                                 break;
+                        udelay(100);
                 }
         
                 /* Clear done status and any errors */
-                I915_WRITE(ch_ctl, (status |
-                                DP_AUX_CH_CTL_DONE |
-                                DP_AUX_CH_CTL_TIME_OUT_ERROR |
-                                DP_AUX_CH_CTL_RECEIVE_ERROR));
-                (void) I915_READ(ch_ctl);
-                if ((status & DP_AUX_CH_CTL_TIME_OUT_ERROR) == 0)
+                I915_WRITE(ch_ctl,
+                           status |
+                           DP_AUX_CH_CTL_DONE |
+                           DP_AUX_CH_CTL_TIME_OUT_ERROR |
+                           DP_AUX_CH_CTL_RECEIVE_ERROR);
+                if (status & DP_AUX_CH_CTL_DONE)
                         break;
         }
 
@@ -329,22 +325,19 @@ intel_dp_aux_ch(struct intel_encoder *intel_encoder,
         /* Unload any bytes sent back from the other side */
         recv_bytes = ((status & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >>
                       DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT);
-
         if (recv_bytes > recv_size)
                 recv_bytes = recv_size;
         
-        for (i = 0; i < recv_bytes; i += 4) {
-                uint32_t    d = I915_READ(ch_data + i);
-
-                unpack_aux(d, recv + i, recv_bytes - i);
-        }
+        for (i = 0; i < recv_bytes; i += 4)
+                unpack_aux(I915_READ(ch_data + i),
+                           recv + i, recv_bytes - i);
 
         return recv_bytes;
 }
 
 /* Write data to the aux channel in native mode */
 static int
-intel_dp_aux_native_write(struct intel_encoder *intel_encoder,
+intel_dp_aux_native_write(struct intel_dp *intel_dp,
                           uint16_t address, uint8_t *send, int send_bytes)
 {
         int ret;
@@ -361,7 +354,7 @@ intel_dp_aux_native_write(struct intel_encoder *intel_encoder,
         memcpy(&msg[4], send, send_bytes);
         msg_bytes = send_bytes + 4;
         for (;;) {
-                ret = intel_dp_aux_ch(intel_encoder, msg, msg_bytes, &ack, 1);
+                ret = intel_dp_aux_ch(intel_dp, msg, msg_bytes, &ack, 1);
                 if (ret < 0)
                         return ret;
                 if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK)
@@ -376,15 +369,15 @@ intel_dp_aux_native_write(struct intel_encoder *intel_encoder,
 
 /* Write a single byte to the aux channel in native mode */
 static int
-intel_dp_aux_native_write_1(struct intel_encoder *intel_encoder,
+intel_dp_aux_native_write_1(struct intel_dp *intel_dp,
                             uint16_t address, uint8_t byte)
 {
-        return intel_dp_aux_native_write(intel_encoder, address, &byte, 1);
+        return intel_dp_aux_native_write(intel_dp, address, &byte, 1);
 }
 
 /* read bytes from a native aux channel */
 static int
-intel_dp_aux_native_read(struct intel_encoder *intel_encoder,
+intel_dp_aux_native_read(struct intel_dp *intel_dp,
                          uint16_t address, uint8_t *recv, int recv_bytes)
 {
         uint8_t msg[4];
@@ -403,7 +396,7 @@ intel_dp_aux_native_read(struct intel_encoder *intel_encoder,
         reply_bytes = recv_bytes + 1;
 
         for (;;) {
-                ret = intel_dp_aux_ch(intel_encoder, msg, msg_bytes,
+                ret = intel_dp_aux_ch(intel_dp, msg, msg_bytes,
                                       reply, reply_bytes);
                 if (ret == 0)
                         return -EPROTO;
@@ -426,10 +419,9 @@ intel_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
                     uint8_t write_byte, uint8_t *read_byte)
 {
         struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
-        struct intel_dp_priv *dp_priv = container_of(adapter,
-                                                     struct intel_dp_priv,
-                                                     adapter);
-        struct intel_encoder *intel_encoder = dp_priv->intel_encoder;
+        struct intel_dp *intel_dp = container_of(adapter,
+                                                struct intel_dp,
+                                                adapter);
         uint16_t address = algo_data->address;
         uint8_t msg[5];
         uint8_t reply[2];
@@ -468,7 +460,7 @@ intel_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
         }
 
         for (;;) {
-          ret = intel_dp_aux_ch(intel_encoder,
+          ret = intel_dp_aux_ch(intel_dp,
                                 msg, msg_bytes,
                                 reply, reply_bytes);
                 if (ret < 0) {
@@ -496,57 +488,42 @@ intel_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
 }
 
 static int
-intel_dp_i2c_init(struct intel_encoder *intel_encoder,
+intel_dp_i2c_init(struct intel_dp *intel_dp,
                   struct intel_connector *intel_connector, const char *name)
 {
-        struct intel_dp_priv   *dp_priv = intel_encoder->dev_priv;
-
         DRM_DEBUG_KMS("i2c_init %s\n", name);
-        dp_priv->algo.running = false;
-        dp_priv->algo.address = 0;
-        dp_priv->algo.aux_ch = intel_dp_i2c_aux_ch;
-
-        memset(&dp_priv->adapter, '\0', sizeof (dp_priv->adapter));
-        dp_priv->adapter.owner = THIS_MODULE;
-        dp_priv->adapter.class = I2C_CLASS_DDC;
-        strncpy (dp_priv->adapter.name, name, sizeof(dp_priv->adapter.name) - 1);
-        dp_priv->adapter.name[sizeof(dp_priv->adapter.name) - 1] = '\0';
-        dp_priv->adapter.algo_data = &dp_priv->algo;
-        dp_priv->adapter.dev.parent = &intel_connector->base.kdev;
-        
-        return i2c_dp_aux_add_bus(&dp_priv->adapter);
+        intel_dp->algo.running = false;
+        intel_dp->algo.address = 0;
+        intel_dp->algo.aux_ch = intel_dp_i2c_aux_ch;
+
+        memset(&intel_dp->adapter, '\0', sizeof (intel_dp->adapter));
+        intel_dp->adapter.owner = THIS_MODULE;
+        intel_dp->adapter.class = I2C_CLASS_DDC;
+        strncpy (intel_dp->adapter.name, name, sizeof(intel_dp->adapter.name) - 1);
+        intel_dp->adapter.name[sizeof(intel_dp->adapter.name) - 1] = '\0';
+        intel_dp->adapter.algo_data = &intel_dp->algo;
+        intel_dp->adapter.dev.parent = &intel_connector->base.kdev;
+
+        return i2c_dp_aux_add_bus(&intel_dp->adapter);
 }
 
 static bool
 intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode,
                     struct drm_display_mode *adjusted_mode)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dp_priv   *dp_priv = intel_encoder->dev_priv;
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
         int lane_count, clock;
-        int max_lane_count = intel_dp_max_lane_count(intel_encoder);
-        int max_clock = intel_dp_max_link_bw(intel_encoder) == DP_LINK_BW_2_7 ? 1 : 0;
+        int max_lane_count = intel_dp_max_lane_count(intel_dp);
+        int max_clock = intel_dp_max_link_bw(intel_dp) == DP_LINK_BW_2_7 ? 1 : 0;
         static int bws[2] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7 };
 
-        if ((IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) &&
+        if ((IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp)) &&
             dev_priv->panel_fixed_mode) {
-                struct drm_display_mode *fixed_mode = dev_priv->panel_fixed_mode;
-
-                adjusted_mode->hdisplay = fixed_mode->hdisplay;
-                adjusted_mode->hsync_start = fixed_mode->hsync_start;
-                adjusted_mode->hsync_end = fixed_mode->hsync_end;
-                adjusted_mode->htotal = fixed_mode->htotal;
-
-                adjusted_mode->vdisplay = fixed_mode->vdisplay;
-                adjusted_mode->vsync_start = fixed_mode->vsync_start;
-                adjusted_mode->vsync_end = fixed_mode->vsync_end;
-                adjusted_mode->vtotal = fixed_mode->vtotal;
-
-                adjusted_mode->clock = fixed_mode->clock;
-                drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
-
+                intel_fixed_panel_mode(dev_priv->panel_fixed_mode, adjusted_mode);
+                intel_pch_panel_fitting(dev, DRM_MODE_SCALE_FULLSCREEN,
+                                        mode, adjusted_mode);
                 /*
                  * the mode->clock is used to calculate the Data&Link M/N
                  * of the pipe. For the eDP the fixed clock should be used.
@@ -558,31 +535,33 @@ intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode,
                 for (clock = 0; clock <= max_clock; clock++) {
                         int link_avail = intel_dp_max_data_rate(intel_dp_link_clock(bws[clock]), lane_count);
 
-                        if (intel_dp_link_required(encoder->dev, intel_encoder, mode->clock)
+                        if (intel_dp_link_required(encoder->dev, intel_dp, mode->clock)
                                         <= link_avail) {
-                                dp_priv->link_bw = bws[clock];
-                                dp_priv->lane_count = lane_count;
-                                adjusted_mode->clock = intel_dp_link_clock(dp_priv->link_bw);
+                                intel_dp->link_bw = bws[clock];
+                                intel_dp->lane_count = lane_count;
+                                adjusted_mode->clock = intel_dp_link_clock(intel_dp->link_bw);
                                 DRM_DEBUG_KMS("Display port link bw %02x lane "
                                                 "count %d clock %d\n",
-                                       dp_priv->link_bw, dp_priv->lane_count,
+                                       intel_dp->link_bw, intel_dp->lane_count,
                                        adjusted_mode->clock);
                                 return true;
                         }
                 }
         }
 
-        if (IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) {
+        if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp)) {
                 /* okay we failed just pick the highest */
-                dp_priv->lane_count = max_lane_count;
-                dp_priv->link_bw = bws[max_clock];
-                adjusted_mode->clock = intel_dp_link_clock(dp_priv->link_bw);
+                intel_dp->lane_count = max_lane_count;
+                intel_dp->link_bw = bws[max_clock];
+                adjusted_mode->clock = intel_dp_link_clock(intel_dp->link_bw);
                 DRM_DEBUG_KMS("Force picking display port link bw %02x lane "
                               "count %d clock %d\n",
-                              dp_priv->link_bw, dp_priv->lane_count,
+                              intel_dp->link_bw, intel_dp->lane_count,
                               adjusted_mode->clock);
+
                 return true;
         }
+
         return false;
 }
 
@@ -626,17 +605,14 @@ bool intel_pch_has_edp(struct drm_crtc *crtc)
         struct drm_encoder *encoder;
 
         list_for_each_entry(encoder, &mode_config->encoder_list, head) {
-                struct intel_encoder *intel_encoder;
-                struct intel_dp_priv *dp_priv;
+                struct intel_dp *intel_dp;
 
-                if (!encoder || encoder->crtc != crtc)
+                if (encoder->crtc != crtc)
                         continue;
 
-                intel_encoder = enc_to_intel_encoder(encoder);
-                dp_priv = intel_encoder->dev_priv;
-
-                if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT)
-                        return dp_priv->is_pch_edp;
+                intel_dp = enc_to_intel_dp(encoder);
+                if (intel_dp->base.type == INTEL_OUTPUT_DISPLAYPORT)
+                        return intel_dp->is_pch_edp;
         }
         return false;
 }
@@ -657,18 +633,15 @@ intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode,
          * Find the lane count in the intel_encoder private
          */
         list_for_each_entry(encoder, &mode_config->encoder_list, head) {
-                struct intel_encoder *intel_encoder;
-                struct intel_dp_priv *dp_priv;
+                struct intel_dp *intel_dp;
 
                 if (encoder->crtc != crtc)
                         continue;
 
-                intel_encoder = enc_to_intel_encoder(encoder);
-                dp_priv = intel_encoder->dev_priv;
-
-                if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT) {
-                        lane_count = dp_priv->lane_count;
-                        if (IS_PCH_eDP(dp_priv))
+                intel_dp = enc_to_intel_dp(encoder);
+                if (intel_dp->base.type == INTEL_OUTPUT_DISPLAYPORT) {
+                        lane_count = intel_dp->lane_count;
+                        if (IS_PCH_eDP(intel_dp))
                                 bpp = dev_priv->edp_bpp;
                         break;
                 }
@@ -724,107 +697,114 @@ intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                   struct drm_display_mode *adjusted_mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
-        struct drm_crtc *crtc = intel_encoder->enc.crtc;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+        struct drm_crtc *crtc = intel_dp->base.enc.crtc;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 
-        dp_priv->DP = (DP_VOLTAGE_0_4 |
+        intel_dp->DP = (DP_VOLTAGE_0_4 |
                        DP_PRE_EMPHASIS_0);
 
         if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
-                dp_priv->DP |= DP_SYNC_HS_HIGH;
+                intel_dp->DP |= DP_SYNC_HS_HIGH;
         if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
-                dp_priv->DP |= DP_SYNC_VS_HIGH;
+                intel_dp->DP |= DP_SYNC_VS_HIGH;
 
-        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_encoder))
-                dp_priv->DP |= DP_LINK_TRAIN_OFF_CPT;
+        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_dp))
+                intel_dp->DP |= DP_LINK_TRAIN_OFF_CPT;
         else
-                dp_priv->DP |= DP_LINK_TRAIN_OFF;
+                intel_dp->DP |= DP_LINK_TRAIN_OFF;
 
-        switch (dp_priv->lane_count) {
+        switch (intel_dp->lane_count) {
         case 1:
-                dp_priv->DP |= DP_PORT_WIDTH_1;
+                intel_dp->DP |= DP_PORT_WIDTH_1;
                 break;
         case 2:
-                dp_priv->DP |= DP_PORT_WIDTH_2;
+                intel_dp->DP |= DP_PORT_WIDTH_2;
                 break;
         case 4:
-                dp_priv->DP |= DP_PORT_WIDTH_4;
+                intel_dp->DP |= DP_PORT_WIDTH_4;
                 break;
         }
-        if (dp_priv->has_audio)
-                dp_priv->DP |= DP_AUDIO_OUTPUT_ENABLE;
+        if (intel_dp->has_audio)
+                intel_dp->DP |= DP_AUDIO_OUTPUT_ENABLE;
 
-        memset(dp_priv->link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
-        dp_priv->link_configuration[0] = dp_priv->link_bw;
-        dp_priv->link_configuration[1] = dp_priv->lane_count;
+        memset(intel_dp->link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
+        intel_dp->link_configuration[0] = intel_dp->link_bw;
+        intel_dp->link_configuration[1] = intel_dp->lane_count;
 
         /*
          * Check for DPCD version > 1.1 and enhanced framing support
          */
-        if (dp_priv->dpcd[0] >= 0x11 && (dp_priv->dpcd[2] & DP_ENHANCED_FRAME_CAP)) {
-                dp_priv->link_configuration[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
-                dp_priv->DP |= DP_ENHANCED_FRAMING;
+        if (intel_dp->dpcd[0] >= 0x11 && (intel_dp->dpcd[2] & DP_ENHANCED_FRAME_CAP)) {
+                intel_dp->link_configuration[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
+                intel_dp->DP |= DP_ENHANCED_FRAMING;
         }
 
         /* CPT DP's pipe select is decided in TRANS_DP_CTL */
         if (intel_crtc->pipe == 1 && !HAS_PCH_CPT(dev))
-                dp_priv->DP |= DP_PIPEB_SELECT;
+                intel_dp->DP |= DP_PIPEB_SELECT;
 
-        if (IS_eDP(intel_encoder)) {
+        if (IS_eDP(intel_dp)) {
                 /* don't miss out required setting for eDP */
-                dp_priv->DP |= DP_PLL_ENABLE;
+                intel_dp->DP |= DP_PLL_ENABLE;
                 if (adjusted_mode->clock < 200000)
-                        dp_priv->DP |= DP_PLL_FREQ_160MHZ;
+                        intel_dp->DP |= DP_PLL_FREQ_160MHZ;
                 else
-                        dp_priv->DP |= DP_PLL_FREQ_270MHZ;
+                        intel_dp->DP |= DP_PLL_FREQ_270MHZ;
         }
 }
 
 static void ironlake_edp_panel_on (struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        unsigned long timeout = jiffies + msecs_to_jiffies(5000);
-        u32 pp, pp_status;
+        u32 pp;
 
-        pp_status = I915_READ(PCH_PP_STATUS);
-        if (pp_status & PP_ON)
+        if (I915_READ(PCH_PP_STATUS) & PP_ON)
                 return;
 
         pp = I915_READ(PCH_PP_CONTROL);
+
+        /* ILK workaround: disable reset around power sequence */
+        pp &= ~PANEL_POWER_RESET;
+        I915_WRITE(PCH_PP_CONTROL, pp);
+        POSTING_READ(PCH_PP_CONTROL);
+
         pp |= PANEL_UNLOCK_REGS | POWER_TARGET_ON;
         I915_WRITE(PCH_PP_CONTROL, pp);
-        do {
-                pp_status = I915_READ(PCH_PP_STATUS);
-        } while (((pp_status & PP_ON) == 0) && !time_after(jiffies, timeout));
 
-        if (time_after(jiffies, timeout))
-                DRM_DEBUG_KMS("panel on wait timed out: 0x%08x\n", pp_status);
+        if (wait_for(I915_READ(PCH_PP_STATUS) & PP_ON, 5000, 10))
+                DRM_ERROR("panel on wait timed out: 0x%08x\n",
+                          I915_READ(PCH_PP_STATUS));
 
         pp &= ~(PANEL_UNLOCK_REGS | EDP_FORCE_VDD);
+        pp |= PANEL_POWER_RESET; /* restore panel reset bit */
         I915_WRITE(PCH_PP_CONTROL, pp);
+        POSTING_READ(PCH_PP_CONTROL);
 }
 
 static void ironlake_edp_panel_off (struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        unsigned long timeout = jiffies + msecs_to_jiffies(5000);
-        u32 pp, pp_status;
+        u32 pp;
 
         pp = I915_READ(PCH_PP_CONTROL);
+
+        /* ILK workaround: disable reset around power sequence */
+        pp &= ~PANEL_POWER_RESET;
+        I915_WRITE(PCH_PP_CONTROL, pp);
+        POSTING_READ(PCH_PP_CONTROL);
+
         pp &= ~POWER_TARGET_ON;
         I915_WRITE(PCH_PP_CONTROL, pp);
-        do {
-                pp_status = I915_READ(PCH_PP_STATUS);
-        } while ((pp_status & PP_ON) && !time_after(jiffies, timeout));
 
-        if (time_after(jiffies, timeout))
-                DRM_DEBUG_KMS("panel off wait timed out\n");
+        if (wait_for((I915_READ(PCH_PP_STATUS) & PP_ON) == 0, 5000, 10))
+                DRM_ERROR("panel off wait timed out: 0x%08x\n",
+                          I915_READ(PCH_PP_STATUS));
 
         /* Make sure VDD is enabled so DP AUX will work */
-        pp |= EDP_FORCE_VDD;
+        pp |= EDP_FORCE_VDD | PANEL_POWER_RESET; /* restore panel reset bit */
         I915_WRITE(PCH_PP_CONTROL, pp);
+        POSTING_READ(PCH_PP_CONTROL);
 }
 
 static void ironlake_edp_backlight_on (struct drm_device *dev)
@@ -849,33 +829,87 @@ static void ironlake_edp_backlight_off (struct drm_device *dev)
         I915_WRITE(PCH_PP_CONTROL, pp);
 }
 
+static void ironlake_edp_pll_on(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 dpa_ctl;
+
+        DRM_DEBUG_KMS("\n");
+        dpa_ctl = I915_READ(DP_A);
+        dpa_ctl &= ~DP_PLL_ENABLE;
+        I915_WRITE(DP_A, dpa_ctl);
+}
+
+static void ironlake_edp_pll_off(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 dpa_ctl;
+
+        dpa_ctl = I915_READ(DP_A);
+        dpa_ctl |= DP_PLL_ENABLE;
+        I915_WRITE(DP_A, dpa_ctl);
+        udelay(200);
+}
+
+static void intel_dp_prepare(struct drm_encoder *encoder)
+{
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+        struct drm_device *dev = encoder->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t dp_reg = I915_READ(intel_dp->output_reg);
+
+        if (IS_eDP(intel_dp)) {
+                ironlake_edp_backlight_off(dev);
+                ironlake_edp_panel_on(dev);
+                ironlake_edp_pll_on(encoder);
+        }
+        if (dp_reg & DP_PORT_EN)
+                intel_dp_link_down(intel_dp);
+}
+
+static void intel_dp_commit(struct drm_encoder *encoder)
+{
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+        struct drm_device *dev = encoder->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t dp_reg = I915_READ(intel_dp->output_reg);
+
+        if (!(dp_reg & DP_PORT_EN)) {
+                intel_dp_link_train(intel_dp);
+        }
+        if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp))
+                ironlake_edp_backlight_on(dev);
+}
+
 static void
 intel_dp_dpms(struct drm_encoder *encoder, int mode)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        uint32_t dp_reg = I915_READ(dp_priv->output_reg);
+        uint32_t dp_reg = I915_READ(intel_dp->output_reg);
 
         if (mode != DRM_MODE_DPMS_ON) {
-                if (dp_reg & DP_PORT_EN) {
-                        intel_dp_link_down(intel_encoder, dp_priv->DP);
-                        if (IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) {
-                                ironlake_edp_backlight_off(dev);
-                                ironlake_edp_panel_off(dev);
-                        }
+                if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp)) {
+                        ironlake_edp_backlight_off(dev);
+                        ironlake_edp_panel_off(dev);
                 }
+                if (dp_reg & DP_PORT_EN)
+                        intel_dp_link_down(intel_dp);
+                if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp))
+                        ironlake_edp_pll_off(encoder);
         } else {
                 if (!(dp_reg & DP_PORT_EN)) {
-                        intel_dp_link_train(intel_encoder, dp_priv->DP, dp_priv->link_configuration);
-                        if (IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) {
+                        if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp))
                                 ironlake_edp_panel_on(dev);
+                        intel_dp_link_train(intel_dp);
+                        if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp))
                                 ironlake_edp_backlight_on(dev);
-                        }
                 }
         }
-        dp_priv->dpms_mode = mode;
+        intel_dp->dpms_mode = mode;
 }
 
 /*
@@ -883,12 +917,12 @@ intel_dp_dpms(struct drm_encoder *encoder, int mode)
  * link status information
  */
 static bool
-intel_dp_get_link_status(struct intel_encoder *intel_encoder,
+intel_dp_get_link_status(struct intel_dp *intel_dp,
                          uint8_t link_status[DP_LINK_STATUS_SIZE])
 {
         int ret;
 
-        ret = intel_dp_aux_native_read(intel_encoder,
+        ret = intel_dp_aux_native_read(intel_dp,
                                        DP_LANE0_1_STATUS,
                                        link_status, DP_LINK_STATUS_SIZE);
         if (ret != DP_LINK_STATUS_SIZE)
@@ -965,7 +999,7 @@ intel_dp_pre_emphasis_max(uint8_t voltage_swing)
 }
 
 static void
-intel_get_adjust_train(struct intel_encoder *intel_encoder,
+intel_get_adjust_train(struct intel_dp *intel_dp,
                        uint8_t link_status[DP_LINK_STATUS_SIZE],
                        int lane_count,
                        uint8_t train_set[4])
@@ -1101,27 +1135,23 @@ intel_channel_eq_ok(uint8_t link_status[DP_LINK_STATUS_SIZE], int lane_count)
 }
 
 static bool
-intel_dp_set_link_train(struct intel_encoder *intel_encoder,
+intel_dp_set_link_train(struct intel_dp *intel_dp,
                         uint32_t dp_reg_value,
                         uint8_t dp_train_pat,
-                        uint8_t train_set[4],
-                        bool first)
+                        uint8_t train_set[4])
 {
-        struct drm_device *dev = intel_encoder->enc.dev;
+        struct drm_device *dev = intel_dp->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
         int ret;
 
-        I915_WRITE(dp_priv->output_reg, dp_reg_value);
-        POSTING_READ(dp_priv->output_reg);
-        if (first)
-                intel_wait_for_vblank(dev);
+        I915_WRITE(intel_dp->output_reg, dp_reg_value);
+        POSTING_READ(intel_dp->output_reg);
 
-        intel_dp_aux_native_write_1(intel_encoder,
+        intel_dp_aux_native_write_1(intel_dp,
                                     DP_TRAINING_PATTERN_SET,
                                     dp_train_pat);
 
-        ret = intel_dp_aux_native_write(intel_encoder,
+        ret = intel_dp_aux_native_write(intel_dp,
                                         DP_TRAINING_LANE0_SET, train_set, 4);
         if (ret != 4)
                 return false;
@@ -1130,28 +1160,33 @@ intel_dp_set_link_train(struct intel_encoder *intel_encoder,
 }
 
 static void
-intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP,
-                    uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE])
+intel_dp_link_train(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_encoder->enc.dev;
+        struct drm_device *dev = intel_dp->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
         uint8_t train_set[4];
         uint8_t link_status[DP_LINK_STATUS_SIZE];
         int i;
         uint8_t voltage;
         bool clock_recovery = false;
         bool channel_eq = false;
-        bool first = true;
         int tries;
         u32 reg;
+        uint32_t DP = intel_dp->DP;
+        struct intel_crtc *intel_crtc = to_intel_crtc(intel_dp->base.enc.crtc);
+
+        /* Enable output, wait for it to become active */
+        I915_WRITE(intel_dp->output_reg, intel_dp->DP);
+        POSTING_READ(intel_dp->output_reg);
+        intel_wait_for_vblank(dev, intel_crtc->pipe);
 
         /* Write the link configuration data */
-        intel_dp_aux_native_write(intel_encoder, DP_LINK_BW_SET,
-                                  link_configuration, DP_LINK_CONFIGURATION_SIZE);
+        intel_dp_aux_native_write(intel_dp, DP_LINK_BW_SET,
+                                  intel_dp->link_configuration,
+                                  DP_LINK_CONFIGURATION_SIZE);
 
         DP |= DP_PORT_EN;
-        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_encoder))
+        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_dp))
                 DP &= ~DP_LINK_TRAIN_MASK_CPT;
         else
                 DP &= ~DP_LINK_TRAIN_MASK;
@@ -1162,39 +1197,38 @@ intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP,
         for (;;) {
                 /* Use train_set[0] to set the voltage and pre emphasis values */
                 uint32_t    signal_levels;
-                if (IS_GEN6(dev) && IS_eDP(intel_encoder)) {
+                if (IS_GEN6(dev) && IS_eDP(intel_dp)) {
                         signal_levels = intel_gen6_edp_signal_levels(train_set[0]);
                         DP = (DP & ~EDP_LINK_TRAIN_VOL_EMP_MASK_SNB) | signal_levels;
                 } else {
-                        signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count);
+                        signal_levels = intel_dp_signal_levels(train_set[0], intel_dp->lane_count);
                         DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels;
                 }
 
-                if (HAS_PCH_CPT(dev) && !IS_eDP(intel_encoder))
+                if (HAS_PCH_CPT(dev) && !IS_eDP(intel_dp))
                         reg = DP | DP_LINK_TRAIN_PAT_1_CPT;
                 else
                         reg = DP | DP_LINK_TRAIN_PAT_1;
 
-                if (!intel_dp_set_link_train(intel_encoder, reg,
-                                             DP_TRAINING_PATTERN_1, train_set, first))
+                if (!intel_dp_set_link_train(intel_dp, reg,
+                                             DP_TRAINING_PATTERN_1, train_set))
                         break;
-                first = false;
                 /* Set training pattern 1 */
 
                 udelay(100);
-                if (!intel_dp_get_link_status(intel_encoder, link_status))
+                if (!intel_dp_get_link_status(intel_dp, link_status))
                         break;
 
-                if (intel_clock_recovery_ok(link_status, dp_priv->lane_count)) {
+                if (intel_clock_recovery_ok(link_status, intel_dp->lane_count)) {
                         clock_recovery = true;
                         break;
                 }
 
                 /* Check to see if we've tried the max voltage */
-                for (i = 0; i < dp_priv->lane_count; i++)
+                for (i = 0; i < intel_dp->lane_count; i++)
                         if ((train_set[i] & DP_TRAIN_MAX_SWING_REACHED) == 0)
                                 break;
-                if (i == dp_priv->lane_count)
+                if (i == intel_dp->lane_count)
                         break;
 
                 /* Check to see if we've tried the same voltage 5 times */
@@ -1207,7 +1241,7 @@ intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP,
                 voltage = train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
 
                 /* Compute new train_set as requested by target */
-                intel_get_adjust_train(intel_encoder, link_status, dp_priv->lane_count, train_set);
+                intel_get_adjust_train(intel_dp, link_status, intel_dp->lane_count, train_set);
         }
 
         /* channel equalization */
@@ -1217,30 +1251,29 @@ intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP,
                 /* Use train_set[0] to set the voltage and pre emphasis values */
                 uint32_t    signal_levels;
 
-                if (IS_GEN6(dev) && IS_eDP(intel_encoder)) {
+                if (IS_GEN6(dev) && IS_eDP(intel_dp)) {
                         signal_levels = intel_gen6_edp_signal_levels(train_set[0]);
                         DP = (DP & ~EDP_LINK_TRAIN_VOL_EMP_MASK_SNB) | signal_levels;
                 } else {
-                        signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count);
+                        signal_levels = intel_dp_signal_levels(train_set[0], intel_dp->lane_count);
                         DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels;
                 }
 
-                if (HAS_PCH_CPT(dev) && !IS_eDP(intel_encoder))
+                if (HAS_PCH_CPT(dev) && !IS_eDP(intel_dp))
                         reg = DP | DP_LINK_TRAIN_PAT_2_CPT;
                 else
                         reg = DP | DP_LINK_TRAIN_PAT_2;
 
                 /* channel eq pattern */
-                if (!intel_dp_set_link_train(intel_encoder, reg,
-                                             DP_TRAINING_PATTERN_2, train_set,
-                                             false))
+                if (!intel_dp_set_link_train(intel_dp, reg,
+                                             DP_TRAINING_PATTERN_2, train_set))
                         break;
 
                 udelay(400);
-                if (!intel_dp_get_link_status(intel_encoder, link_status))
+                if (!intel_dp_get_link_status(intel_dp, link_status))
                         break;
 
-                if (intel_channel_eq_ok(link_status, dp_priv->lane_count)) {
+                if (intel_channel_eq_ok(link_status, intel_dp->lane_count)) {
                         channel_eq = true;
                         break;
                 }
@@ -1250,53 +1283,53 @@ intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP,
                         break;
 
                 /* Compute new train_set as requested by target */
-                intel_get_adjust_train(intel_encoder, link_status, dp_priv->lane_count, train_set);
+                intel_get_adjust_train(intel_dp, link_status, intel_dp->lane_count, train_set);
                 ++tries;
         }
 
-        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_encoder))
+        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_dp))
                 reg = DP | DP_LINK_TRAIN_OFF_CPT;
         else
                 reg = DP | DP_LINK_TRAIN_OFF;
 
-        I915_WRITE(dp_priv->output_reg, reg);
-        POSTING_READ(dp_priv->output_reg);
-        intel_dp_aux_native_write_1(intel_encoder,
+        I915_WRITE(intel_dp->output_reg, reg);
+        POSTING_READ(intel_dp->output_reg);
+        intel_dp_aux_native_write_1(intel_dp,
                                     DP_TRAINING_PATTERN_SET, DP_TRAINING_PATTERN_DISABLE);
 }
 
 static void
-intel_dp_link_down(struct intel_encoder *intel_encoder, uint32_t DP)
+intel_dp_link_down(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_encoder->enc.dev;
+        struct drm_device *dev = intel_dp->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
+        uint32_t DP = intel_dp->DP;
 
         DRM_DEBUG_KMS("\n");
 
-        if (IS_eDP(intel_encoder)) {
+        if (IS_eDP(intel_dp)) {
                 DP &= ~DP_PLL_ENABLE;
-                I915_WRITE(dp_priv->output_reg, DP);
-                POSTING_READ(dp_priv->output_reg);
+                I915_WRITE(intel_dp->output_reg, DP);
+                POSTING_READ(intel_dp->output_reg);
                 udelay(100);
         }
 
-        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_encoder)) {
+        if (HAS_PCH_CPT(dev) && !IS_eDP(intel_dp)) {
                 DP &= ~DP_LINK_TRAIN_MASK_CPT;
-                I915_WRITE(dp_priv->output_reg, DP | DP_LINK_TRAIN_PAT_IDLE_CPT);
-                POSTING_READ(dp_priv->output_reg);
+                I915_WRITE(intel_dp->output_reg, DP | DP_LINK_TRAIN_PAT_IDLE_CPT);
+                POSTING_READ(intel_dp->output_reg);
         } else {
                 DP &= ~DP_LINK_TRAIN_MASK;
-                I915_WRITE(dp_priv->output_reg, DP | DP_LINK_TRAIN_PAT_IDLE);
-                POSTING_READ(dp_priv->output_reg);
+                I915_WRITE(intel_dp->output_reg, DP | DP_LINK_TRAIN_PAT_IDLE);
+                POSTING_READ(intel_dp->output_reg);
         }
 
         udelay(17000);
 
-        if (IS_eDP(intel_encoder))
+        if (IS_eDP(intel_dp))
                 DP |= DP_LINK_TRAIN_OFF;
-        I915_WRITE(dp_priv->output_reg, DP & ~DP_PORT_EN);
-        POSTING_READ(dp_priv->output_reg);
+        I915_WRITE(intel_dp->output_reg, DP & ~DP_PORT_EN);
+        POSTING_READ(intel_dp->output_reg);
 }
 
 /*
@@ -1309,41 +1342,39 @@ intel_dp_link_down(struct intel_encoder *intel_encoder, uint32_t DP)
  */
 
 static void
-intel_dp_check_link_status(struct intel_encoder *intel_encoder)
+intel_dp_check_link_status(struct intel_dp *intel_dp)
 {
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
         uint8_t link_status[DP_LINK_STATUS_SIZE];
 
-        if (!intel_encoder->enc.crtc)
+        if (!intel_dp->base.enc.crtc)
                 return;
 
-        if (!intel_dp_get_link_status(intel_encoder, link_status)) {
-                intel_dp_link_down(intel_encoder, dp_priv->DP);
+        if (!intel_dp_get_link_status(intel_dp, link_status)) {
+                intel_dp_link_down(intel_dp);
                 return;
         }
 
-        if (!intel_channel_eq_ok(link_status, dp_priv->lane_count))
-                intel_dp_link_train(intel_encoder, dp_priv->DP, dp_priv->link_configuration);
+        if (!intel_channel_eq_ok(link_status, intel_dp->lane_count))
+                intel_dp_link_train(intel_dp);
 }
 
 static enum drm_connector_status
 ironlake_dp_detect(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
         enum drm_connector_status status;
 
         status = connector_status_disconnected;
-        if (intel_dp_aux_native_read(intel_encoder,
-                                     0x000, dp_priv->dpcd,
-                                     sizeof (dp_priv->dpcd)) == sizeof (dp_priv->dpcd))
+        if (intel_dp_aux_native_read(intel_dp,
+                                     0x000, intel_dp->dpcd,
+                                     sizeof (intel_dp->dpcd)) == sizeof (intel_dp->dpcd))
         {
-                if (dp_priv->dpcd[0] != 0)
+                if (intel_dp->dpcd[0] != 0)
                         status = connector_status_connected;
         }
-        DRM_DEBUG_KMS("DPCD: %hx%hx%hx%hx\n", dp_priv->dpcd[0],
-                      dp_priv->dpcd[1], dp_priv->dpcd[2], dp_priv->dpcd[3]);
+        DRM_DEBUG_KMS("DPCD: %hx%hx%hx%hx\n", intel_dp->dpcd[0],
+                      intel_dp->dpcd[1], intel_dp->dpcd[2], intel_dp->dpcd[3]);
         return status;
 }
 
@@ -1354,22 +1385,21 @@ ironlake_dp_detect(struct drm_connector *connector)
  * \return false if DP port is disconnected.
  */
 static enum drm_connector_status
-intel_dp_detect(struct drm_connector *connector)
+intel_dp_detect(struct drm_connector *connector, bool force)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct drm_device *dev = intel_encoder->enc.dev;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+        struct drm_device *dev = intel_dp->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
         uint32_t temp, bit;
         enum drm_connector_status status;
 
-        dp_priv->has_audio = false;
+        intel_dp->has_audio = false;
 
         if (HAS_PCH_SPLIT(dev))
                 return ironlake_dp_detect(connector);
 
-        switch (dp_priv->output_reg) {
+        switch (intel_dp->output_reg) {
         case DP_B:
                 bit = DPB_HOTPLUG_INT_STATUS;
                 break;
@@ -1389,11 +1419,11 @@ intel_dp_detect(struct drm_connector *connector)
                 return connector_status_disconnected;
 
         status = connector_status_disconnected;
-        if (intel_dp_aux_native_read(intel_encoder,
-                                     0x000, dp_priv->dpcd,
-                                     sizeof (dp_priv->dpcd)) == sizeof (dp_priv->dpcd))
+        if (intel_dp_aux_native_read(intel_dp,
+                                     0x000, intel_dp->dpcd,
+                                     sizeof (intel_dp->dpcd)) == sizeof (intel_dp->dpcd))
         {
-                if (dp_priv->dpcd[0] != 0)
+                if (intel_dp->dpcd[0] != 0)
                         status = connector_status_connected;
         }
         return status;
@@ -1402,18 +1432,17 @@ intel_dp_detect(struct drm_connector *connector)
 static int intel_dp_get_modes(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct drm_device *dev = intel_encoder->enc.dev;
+        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+        struct drm_device *dev = intel_dp->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
         int ret;
 
         /* We should parse the EDID data and find out if it has an audio sink
          */
 
-        ret = intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
+        ret = intel_ddc_get_modes(connector, intel_dp->base.ddc_bus);
         if (ret) {
-                if ((IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) &&
+                if ((IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp)) &&
                     !dev_priv->panel_fixed_mode) {
                         struct drm_display_mode *newmode;
                         list_for_each_entry(newmode, &connector->probed_modes,
@@ -1430,7 +1459,7 @@ static int intel_dp_get_modes(struct drm_connector *connector)
         }
 
         /* if eDP has no EDID, try to use fixed panel mode from VBT */
-        if (IS_eDP(intel_encoder) || IS_PCH_eDP(dp_priv)) {
+        if (IS_eDP(intel_dp) || IS_PCH_eDP(intel_dp)) {
                 if (dev_priv->panel_fixed_mode != NULL) {
                         struct drm_display_mode *mode;
                         mode = drm_mode_duplicate(dev, dev_priv->panel_fixed_mode);
@@ -1452,9 +1481,9 @@ intel_dp_destroy (struct drm_connector *connector)
 static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = {
         .dpms = intel_dp_dpms,
         .mode_fixup = intel_dp_mode_fixup,
-        .prepare = intel_encoder_prepare,
+        .prepare = intel_dp_prepare,
         .mode_set = intel_dp_mode_set,
-        .commit = intel_encoder_commit,
+        .commit = intel_dp_commit,
 };
 
 static const struct drm_connector_funcs intel_dp_connector_funcs = {
@@ -1470,27 +1499,17 @@ static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs =
         .best_encoder = intel_attached_encoder,
 };
 
-static void intel_dp_enc_destroy(struct drm_encoder *encoder)
-{
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-
-        if (intel_encoder->i2c_bus)
-                intel_i2c_destroy(intel_encoder->i2c_bus);
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
-}
-
 static const struct drm_encoder_funcs intel_dp_enc_funcs = {
-        .destroy = intel_dp_enc_destroy,
+        .destroy = intel_encoder_destroy,
 };
 
 void
 intel_dp_hot_plug(struct intel_encoder *intel_encoder)
 {
-        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
+        struct intel_dp *intel_dp = container_of(intel_encoder, struct intel_dp, base);
 
-        if (dp_priv->dpms_mode == DRM_MODE_DPMS_ON)
-                intel_dp_check_link_status(intel_encoder);
+        if (intel_dp->dpms_mode == DRM_MODE_DPMS_ON)
+                intel_dp_check_link_status(intel_dp);
 }
 
 /* Return which DP Port should be selected for Transcoder DP control */
@@ -1500,18 +1519,18 @@ intel_trans_dp_port_sel (struct drm_crtc *crtc)
         struct drm_device *dev = crtc->dev;
         struct drm_mode_config *mode_config = &dev->mode_config;
         struct drm_encoder *encoder;
-        struct intel_encoder *intel_encoder = NULL;
 
         list_for_each_entry(encoder, &mode_config->encoder_list, head) {
+                struct intel_dp *intel_dp;
+
                 if (encoder->crtc != crtc)
                         continue;
 
-                intel_encoder = enc_to_intel_encoder(encoder);
-                if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT) {
-                        struct intel_dp_priv *dp_priv = intel_encoder->dev_priv;
-                        return dp_priv->output_reg;
-                }
+                intel_dp = enc_to_intel_dp(encoder);
+                if (intel_dp->base.type == INTEL_OUTPUT_DISPLAYPORT)
+                        return intel_dp->output_reg;
         }
+
         return -1;
 }
 
@@ -1540,30 +1559,28 @@ intel_dp_init(struct drm_device *dev, int output_reg)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_connector *connector;
+        struct intel_dp *intel_dp;
         struct intel_encoder *intel_encoder;
         struct intel_connector *intel_connector;
-        struct intel_dp_priv *dp_priv;
         const char *name = NULL;
         int type;
 
-        intel_encoder = kcalloc(sizeof(struct intel_encoder) +
-                               sizeof(struct intel_dp_priv), 1, GFP_KERNEL);
-        if (!intel_encoder)
+        intel_dp = kzalloc(sizeof(struct intel_dp), GFP_KERNEL);
+        if (!intel_dp)
                 return;
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
-                kfree(intel_encoder);
+                kfree(intel_dp);
                 return;
         }
+        intel_encoder = &intel_dp->base;
 
-        dp_priv = (struct intel_dp_priv *)(intel_encoder + 1);
-
-        if (HAS_PCH_SPLIT(dev) && (output_reg == PCH_DP_D))
+        if (HAS_PCH_SPLIT(dev) && output_reg == PCH_DP_D)
                 if (intel_dpd_is_edp(dev))
-                        dp_priv->is_pch_edp = true;
+                        intel_dp->is_pch_edp = true;
 
-        if (output_reg == DP_A || IS_PCH_eDP(dp_priv)) {
+        if (output_reg == DP_A || IS_PCH_eDP(intel_dp)) {
                 type = DRM_MODE_CONNECTOR_eDP;
                 intel_encoder->type = INTEL_OUTPUT_EDP;
         } else {
@@ -1584,18 +1601,16 @@ intel_dp_init(struct drm_device *dev, int output_reg)
         else if (output_reg == DP_D || output_reg == PCH_DP_D)
                 intel_encoder->clone_mask = (1 << INTEL_DP_D_CLONE_BIT);
 
-        if (IS_eDP(intel_encoder))
+        if (IS_eDP(intel_dp))
                 intel_encoder->clone_mask = (1 << INTEL_EDP_CLONE_BIT);
 
         intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
         connector->interlace_allowed = true;
         connector->doublescan_allowed = 0;
 
-        dp_priv->intel_encoder = intel_encoder;
-        dp_priv->output_reg = output_reg;
-        dp_priv->has_audio = false;
-        dp_priv->dpms_mode = DRM_MODE_DPMS_ON;
-        intel_encoder->dev_priv = dp_priv;
+        intel_dp->output_reg = output_reg;
+        intel_dp->has_audio = false;
+        intel_dp->dpms_mode = DRM_MODE_DPMS_ON;
 
         drm_encoder_init(dev, &intel_encoder->enc, &intel_dp_enc_funcs,
                          DRM_MODE_ENCODER_TMDS);
@@ -1630,12 +1645,12 @@ intel_dp_init(struct drm_device *dev, int output_reg)
                         break;
         }
 
-        intel_dp_i2c_init(intel_encoder, intel_connector, name);
+        intel_dp_i2c_init(intel_dp, intel_connector, name);
 
-        intel_encoder->ddc_bus = &dp_priv->adapter;
+        intel_encoder->ddc_bus = &intel_dp->adapter;
         intel_encoder->hot_plug = intel_dp_hot_plug;
 
-        if (output_reg == DP_A || IS_PCH_eDP(dp_priv)) {
+        if (output_reg == DP_A || IS_PCH_eDP(intel_dp)) {
                 /* initialize panel mode from VBT if available for eDP */
                 if (dev_priv->lfp_lvds_vbt_mode) {
                         dev_priv->panel_fixed_mode =
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index b2190148703a..8828b3ac6414 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -32,6 +32,20 @@
 #include "drm_crtc.h"
 
 #include "drm_crtc_helper.h"
+
+#define wait_for(COND, MS, W) ({ \
+        unsigned long timeout__ = jiffies + msecs_to_jiffies(MS);       \
+        int ret__ = 0;                                                  \
+        while (! (COND)) {                                              \
+                if (time_after(jiffies, timeout__)) {                   \
+                        ret__ = -ETIMEDOUT;                             \
+                        break;                                          \
+                }                                                       \
+                if (W) msleep(W);                                       \
+        }                                                               \
+        ret__;                                                          \
+})
+
 /*
  * Display related stuff
  */
@@ -102,7 +116,6 @@ struct intel_encoder {
         struct i2c_adapter *ddc_bus;
         bool load_detect_temp;
         bool needs_tv_clock;
-        void *dev_priv;
         void (*hot_plug)(struct intel_encoder *);
         int crtc_mask;
         int clone_mask;
@@ -110,7 +123,6 @@ struct intel_encoder {
 
 struct intel_connector {
         struct drm_connector base;
-        void *dev_priv;
 };
 
 struct intel_crtc;
@@ -156,7 +168,7 @@ struct intel_crtc {
         uint32_t cursor_addr;
         int16_t cursor_x, cursor_y;
         int16_t cursor_width, cursor_height;
-        bool cursor_visble;
+        bool cursor_visible, cursor_on;
 };
 
 #define to_intel_crtc(x) container_of(x, struct intel_crtc, base)
@@ -164,6 +176,16 @@ struct intel_crtc {
 #define enc_to_intel_encoder(x) container_of(x, struct intel_encoder, enc)
 #define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base)
 
+struct intel_unpin_work {
+        struct work_struct work;
+        struct drm_device *dev;
+        struct drm_gem_object *old_fb_obj;
+        struct drm_gem_object *pending_flip_obj;
+        struct drm_pending_vblank_event *event;
+        int pending;
+        bool enable_stall_check;
+};
+
 struct i2c_adapter *intel_i2c_create(struct drm_device *dev, const u32 reg,
                                      const char *name);
 void intel_i2c_destroy(struct i2c_adapter *adapter);
@@ -188,10 +210,18 @@ extern bool intel_dpd_is_edp(struct drm_device *dev);
 extern void intel_edp_link_config (struct intel_encoder *, int *, int *);
 
 
+extern void intel_fixed_panel_mode(struct drm_display_mode *fixed_mode,
+                                   struct drm_display_mode *adjusted_mode);
+extern void intel_pch_panel_fitting(struct drm_device *dev,
+                                    int fitting_mode,
+                                    struct drm_display_mode *mode,
+                                    struct drm_display_mode *adjusted_mode);
+
 extern int intel_panel_fitter_pipe (struct drm_device *dev);
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
 extern void intel_encoder_prepare (struct drm_encoder *encoder);
 extern void intel_encoder_commit (struct drm_encoder *encoder);
+extern void intel_encoder_destroy(struct drm_encoder *encoder);
 
 extern struct drm_encoder *intel_attached_encoder(struct drm_connector *connector);
 
@@ -199,7 +229,7 @@ extern struct drm_display_mode *intel_crtc_mode_get(struct drm_device *dev,
                                                     struct drm_crtc *crtc);
 int intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data,
                                 struct drm_file *file_priv);
-extern void intel_wait_for_vblank(struct drm_device *dev);
+extern void intel_wait_for_vblank(struct drm_device *dev, int pipe);
 extern struct drm_crtc *intel_get_crtc_from_pipe(struct drm_device *dev, int pipe);
 extern struct drm_crtc *intel_get_load_detect_pipe(struct intel_encoder *intel_encoder,
                                                    struct drm_connector *connector,
diff --git a/drivers/gpu/drm/i915/intel_dvo.c b/drivers/gpu/drm/i915/intel_dvo.c
index 227feca7cf8d..7c9ec1472d46 100644
--- a/drivers/gpu/drm/i915/intel_dvo.c
+++ b/drivers/gpu/drm/i915/intel_dvo.c
@@ -38,7 +38,7 @@
 #define CH7xxx_ADDR     0x76
 #define TFP410_ADDR     0x38
 
-static struct intel_dvo_device intel_dvo_devices[] = {
+static const struct intel_dvo_device intel_dvo_devices[] = {
         {
                 .type = INTEL_DVO_CHIP_TMDS,
                 .name = "sil164",
@@ -77,20 +77,33 @@ static struct intel_dvo_device intel_dvo_devices[] = {
         }
 };
 
+struct intel_dvo {
+        struct intel_encoder base;
+
+        struct intel_dvo_device dev;
+
+        struct drm_display_mode *panel_fixed_mode;
+        bool panel_wants_dither;
+};
+
+static struct intel_dvo *enc_to_intel_dvo(struct drm_encoder *encoder)
+{
+        return container_of(enc_to_intel_encoder(encoder), struct intel_dvo, base);
+}
+
 static void intel_dvo_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_i915_private *dev_priv = encoder->dev->dev_private;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
-        u32 dvo_reg = dvo->dvo_reg;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
+        u32 dvo_reg = intel_dvo->dev.dvo_reg;
         u32 temp = I915_READ(dvo_reg);
 
         if (mode == DRM_MODE_DPMS_ON) {
                 I915_WRITE(dvo_reg, temp | DVO_ENABLE);
                 I915_READ(dvo_reg);
-                dvo->dev_ops->dpms(dvo, mode);
+                intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, mode);
         } else {
-                dvo->dev_ops->dpms(dvo, mode);
+                intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, mode);
                 I915_WRITE(dvo_reg, temp & ~DVO_ENABLE);
                 I915_READ(dvo_reg);
         }
@@ -100,38 +113,36 @@ static int intel_dvo_mode_valid(struct drm_connector *connector,
                                 struct drm_display_mode *mode)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
 
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                 return MODE_NO_DBLESCAN;
 
         /* XXX: Validate clock range */
 
-        if (dvo->panel_fixed_mode) {
-                if (mode->hdisplay > dvo->panel_fixed_mode->hdisplay)
+        if (intel_dvo->panel_fixed_mode) {
+                if (mode->hdisplay > intel_dvo->panel_fixed_mode->hdisplay)
                         return MODE_PANEL;
-                if (mode->vdisplay > dvo->panel_fixed_mode->vdisplay)
+                if (mode->vdisplay > intel_dvo->panel_fixed_mode->vdisplay)
                         return MODE_PANEL;
         }
 
-        return dvo->dev_ops->mode_valid(dvo, mode);
+        return intel_dvo->dev.dev_ops->mode_valid(&intel_dvo->dev, mode);
 }
 
 static bool intel_dvo_mode_fixup(struct drm_encoder *encoder,
                                  struct drm_display_mode *mode,
                                  struct drm_display_mode *adjusted_mode)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
 
         /* If we have timings from the BIOS for the panel, put them in
          * to the adjusted mode.  The CRTC will be set up for this mode,
          * with the panel scaling set up to source from the H/VDisplay
          * of the original mode.
          */
-        if (dvo->panel_fixed_mode != NULL) {
-#define C(x) adjusted_mode->x = dvo->panel_fixed_mode->x
+        if (intel_dvo->panel_fixed_mode != NULL) {
+#define C(x) adjusted_mode->x = intel_dvo->panel_fixed_mode->x
                 C(hdisplay);
                 C(hsync_start);
                 C(hsync_end);
@@ -145,8 +156,8 @@ static bool intel_dvo_mode_fixup(struct drm_encoder *encoder,
 #undef C
         }
 
-        if (dvo->dev_ops->mode_fixup)
-                return dvo->dev_ops->mode_fixup(dvo, mode, adjusted_mode);
+        if (intel_dvo->dev.dev_ops->mode_fixup)
+                return intel_dvo->dev.dev_ops->mode_fixup(&intel_dvo->dev, mode, adjusted_mode);
 
         return true;
 }
@@ -158,11 +169,10 @@ static void intel_dvo_mode_set(struct drm_encoder *encoder,
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
         int pipe = intel_crtc->pipe;
         u32 dvo_val;
-        u32 dvo_reg = dvo->dvo_reg, dvo_srcdim_reg;
+        u32 dvo_reg = intel_dvo->dev.dvo_reg, dvo_srcdim_reg;
         int dpll_reg = (pipe == 0) ? DPLL_A : DPLL_B;
 
         switch (dvo_reg) {
@@ -178,7 +188,7 @@ static void intel_dvo_mode_set(struct drm_encoder *encoder,
                 break;
         }
 
-        dvo->dev_ops->mode_set(dvo, mode, adjusted_mode);
+        intel_dvo->dev.dev_ops->mode_set(&intel_dvo->dev, mode, adjusted_mode);
 
         /* Save the data order, since I don't know what it should be set to. */
         dvo_val = I915_READ(dvo_reg) &
@@ -211,43 +221,42 @@ static void intel_dvo_mode_set(struct drm_encoder *encoder,
  *
  * Unimplemented.
  */
-static enum drm_connector_status intel_dvo_detect(struct drm_connector *connector)
+static enum drm_connector_status
+intel_dvo_detect(struct drm_connector *connector, bool force)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
 
-        return dvo->dev_ops->detect(dvo);
+        return intel_dvo->dev.dev_ops->detect(&intel_dvo->dev);
 }
 
 static int intel_dvo_get_modes(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
 
         /* We should probably have an i2c driver get_modes function for those
          * devices which will have a fixed set of modes determined by the chip
          * (TV-out, for example), but for now with just TMDS and LVDS,
          * that's not the case.
          */
-        intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
+        intel_ddc_get_modes(connector, intel_dvo->base.ddc_bus);
         if (!list_empty(&connector->probed_modes))
                 return 1;
 
-
-        if (dvo->panel_fixed_mode != NULL) {
+        if (intel_dvo->panel_fixed_mode != NULL) {
                 struct drm_display_mode *mode;
-                mode = drm_mode_duplicate(connector->dev, dvo->panel_fixed_mode);
+                mode = drm_mode_duplicate(connector->dev, intel_dvo->panel_fixed_mode);
                 if (mode) {
                         drm_mode_probed_add(connector, mode);
                         return 1;
                 }
         }
+
         return 0;
 }
 
-static void intel_dvo_destroy (struct drm_connector *connector)
+static void intel_dvo_destroy(struct drm_connector *connector)
 {
         drm_sysfs_connector_remove(connector);
         drm_connector_cleanup(connector);
@@ -277,28 +286,20 @@ static const struct drm_connector_helper_funcs intel_dvo_connector_helper_funcs
 
 static void intel_dvo_enc_destroy(struct drm_encoder *encoder)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
-
-        if (dvo) {
-                if (dvo->dev_ops->destroy)
-                        dvo->dev_ops->destroy(dvo);
-                if (dvo->panel_fixed_mode)
-                        kfree(dvo->panel_fixed_mode);
-        }
-        if (intel_encoder->i2c_bus)
-                intel_i2c_destroy(intel_encoder->i2c_bus);
-        if (intel_encoder->ddc_bus)
-                intel_i2c_destroy(intel_encoder->ddc_bus);
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
+
+        if (intel_dvo->dev.dev_ops->destroy)
+                intel_dvo->dev.dev_ops->destroy(&intel_dvo->dev);
+
+        kfree(intel_dvo->panel_fixed_mode);
+
+        intel_encoder_destroy(encoder);
 }
 
 static const struct drm_encoder_funcs intel_dvo_enc_funcs = {
         .destroy = intel_dvo_enc_destroy,
 };
 
-
 /**
  * Attempts to get a fixed panel timing for LVDS (currently only the i830).
  *
@@ -306,15 +307,13 @@ static const struct drm_encoder_funcs intel_dvo_enc_funcs = {
  * chip being on DVOB/C and having multiple pipes.
  */
 static struct drm_display_mode *
-intel_dvo_get_current_mode (struct drm_connector *connector)
+intel_dvo_get_current_mode(struct drm_connector *connector)
 {
         struct drm_device *dev = connector->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_dvo_device *dvo = intel_encoder->dev_priv;
-        uint32_t dvo_reg = dvo->dvo_reg;
-        uint32_t dvo_val = I915_READ(dvo_reg);
+        struct intel_dvo *intel_dvo = enc_to_intel_dvo(encoder);
+        uint32_t dvo_val = I915_READ(intel_dvo->dev.dvo_reg);
         struct drm_display_mode *mode = NULL;
 
         /* If the DVO port is active, that'll be the LVDS, so we can pull out
@@ -327,7 +326,6 @@ intel_dvo_get_current_mode (struct drm_connector *connector)
                 crtc = intel_get_crtc_from_pipe(dev, pipe);
                 if (crtc) {
                         mode = intel_crtc_mode_get(dev, crtc);
-
                         if (mode) {
                                 mode->type |= DRM_MODE_TYPE_PREFERRED;
                                 if (dvo_val & DVO_HSYNC_ACTIVE_HIGH)
@@ -337,28 +335,32 @@ intel_dvo_get_current_mode (struct drm_connector *connector)
                         }
                 }
         }
+
         return mode;
 }
 
 void intel_dvo_init(struct drm_device *dev)
 {
         struct intel_encoder *intel_encoder;
+        struct intel_dvo *intel_dvo;
         struct intel_connector *intel_connector;
-        struct intel_dvo_device *dvo;
         struct i2c_adapter *i2cbus = NULL;
         int ret = 0;
         int i;
         int encoder_type = DRM_MODE_ENCODER_NONE;
-        intel_encoder = kzalloc (sizeof(struct intel_encoder), GFP_KERNEL);
-        if (!intel_encoder)
+
+        intel_dvo = kzalloc(sizeof(struct intel_dvo), GFP_KERNEL);
+        if (!intel_dvo)
                 return;
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
-                kfree(intel_encoder);
+                kfree(intel_dvo);
                 return;
         }
 
+        intel_encoder = &intel_dvo->base;
+
         /* Set up the DDC bus */
         intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOD, "DVODDC_D");
         if (!intel_encoder->ddc_bus)
@@ -367,10 +369,9 @@ void intel_dvo_init(struct drm_device *dev)
         /* Now, try to find a controller */
         for (i = 0; i < ARRAY_SIZE(intel_dvo_devices); i++) {
                 struct drm_connector *connector = &intel_connector->base;
+                const struct intel_dvo_device *dvo = &intel_dvo_devices[i];
                 int gpio;
 
-                dvo = &intel_dvo_devices[i];
-
                 /* Allow the I2C driver info to specify the GPIO to be used in
                  * special cases, but otherwise default to what's defined
                  * in the spec.
@@ -393,11 +394,8 @@ void intel_dvo_init(struct drm_device *dev)
                         continue;
                 }
 
-                if (dvo->dev_ops!= NULL)
-                        ret = dvo->dev_ops->init(dvo, i2cbus);
-                else
-                        ret = false;
-
+                intel_dvo->dev = *dvo;
+                ret = dvo->dev_ops->init(&intel_dvo->dev, i2cbus);
                 if (!ret)
                         continue;
 
@@ -429,9 +427,6 @@ void intel_dvo_init(struct drm_device *dev)
                 connector->interlace_allowed = false;
                 connector->doublescan_allowed = false;
 
-                intel_encoder->dev_priv = dvo;
-                intel_encoder->i2c_bus = i2cbus;
-
                 drm_encoder_init(dev, &intel_encoder->enc,
                                  &intel_dvo_enc_funcs, encoder_type);
                 drm_encoder_helper_add(&intel_encoder->enc,
@@ -447,9 +442,9 @@ void intel_dvo_init(struct drm_device *dev)
                          * headers, likely), so for now, just get the current
                          * mode being output through DVO.
                          */
-                        dvo->panel_fixed_mode =
+                        intel_dvo->panel_fixed_mode =
                                 intel_dvo_get_current_mode(connector);
-                        dvo->panel_wants_dither = true;
+                        intel_dvo->panel_wants_dither = true;
                 }
 
                 drm_sysfs_connector_add(connector);
@@ -461,6 +456,6 @@ void intel_dvo_init(struct drm_device *dev)
         if (i2cbus != NULL)
                 intel_i2c_destroy(i2cbus);
 free_intel:
-        kfree(intel_encoder);
+        kfree(intel_dvo);
         kfree(intel_connector);
 }
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c
index 7bdc96256bf5..b61966c126d3 100644
--- a/drivers/gpu/drm/i915/intel_fb.c
+++ b/drivers/gpu/drm/i915/intel_fb.c
@@ -237,8 +237,10 @@ int intel_fbdev_destroy(struct drm_device *dev,
         drm_fb_helper_fini(&ifbdev->helper);
 
         drm_framebuffer_cleanup(&ifb->base);
-        if (ifb->obj)
+        if (ifb->obj) {
                 drm_gem_object_unreference(ifb->obj);
+                ifb->obj = NULL;
+        }
 
         return 0;
 }
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 197887ed1823..926934a482ec 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -37,11 +37,17 @@
 #include "i915_drm.h"
 #include "i915_drv.h"
 
-struct intel_hdmi_priv {
+struct intel_hdmi {
+        struct intel_encoder base;
         u32 sdvox_reg;
         bool has_hdmi_sink;
 };
 
+static struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder)
+{
+        return container_of(enc_to_intel_encoder(encoder), struct intel_hdmi, base);
+}
+
 static void intel_hdmi_mode_set(struct drm_encoder *encoder,
                                 struct drm_display_mode *mode,
                                 struct drm_display_mode *adjusted_mode)
@@ -50,8 +56,7 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_crtc *crtc = encoder->crtc;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
         u32 sdvox;
 
         sdvox = SDVO_ENCODING_HDMI | SDVO_BORDER_ENABLE;
@@ -60,7 +65,7 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
                 sdvox |= SDVO_HSYNC_ACTIVE_HIGH;
 
-        if (hdmi_priv->has_hdmi_sink) {
+        if (intel_hdmi->has_hdmi_sink) {
                 sdvox |= SDVO_AUDIO_ENABLE;
                 if (HAS_PCH_CPT(dev))
                         sdvox |= HDMI_MODE_SELECT;
@@ -73,26 +78,25 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
                         sdvox |= SDVO_PIPE_B_SELECT;
         }
 
-        I915_WRITE(hdmi_priv->sdvox_reg, sdvox);
-        POSTING_READ(hdmi_priv->sdvox_reg);
+        I915_WRITE(intel_hdmi->sdvox_reg, sdvox);
+        POSTING_READ(intel_hdmi->sdvox_reg);
 }
 
 static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
         u32 temp;
 
-        temp = I915_READ(hdmi_priv->sdvox_reg);
+        temp = I915_READ(intel_hdmi->sdvox_reg);
 
         /* HW workaround, need to toggle enable bit off and on for 12bpc, but
          * we do this anyway which shows more stable in testing.
          */
         if (HAS_PCH_SPLIT(dev)) {
-                I915_WRITE(hdmi_priv->sdvox_reg, temp & ~SDVO_ENABLE);
-                POSTING_READ(hdmi_priv->sdvox_reg);
+                I915_WRITE(intel_hdmi->sdvox_reg, temp & ~SDVO_ENABLE);
+                POSTING_READ(intel_hdmi->sdvox_reg);
         }
 
         if (mode != DRM_MODE_DPMS_ON) {
@@ -101,15 +105,15 @@ static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
                 temp |= SDVO_ENABLE;
         }
 
-        I915_WRITE(hdmi_priv->sdvox_reg, temp);
-        POSTING_READ(hdmi_priv->sdvox_reg);
+        I915_WRITE(intel_hdmi->sdvox_reg, temp);
+        POSTING_READ(intel_hdmi->sdvox_reg);
 
         /* HW workaround, need to write this twice for issue that may result
          * in first write getting masked.
          */
         if (HAS_PCH_SPLIT(dev)) {
-                I915_WRITE(hdmi_priv->sdvox_reg, temp);
-                POSTING_READ(hdmi_priv->sdvox_reg);
+                I915_WRITE(intel_hdmi->sdvox_reg, temp);
+                POSTING_READ(intel_hdmi->sdvox_reg);
         }
 }
 
@@ -135,22 +139,20 @@ static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,
 }
 
 static enum drm_connector_status
-intel_hdmi_detect(struct drm_connector *connector)
+intel_hdmi_detect(struct drm_connector *connector, bool force)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
         struct edid *edid = NULL;
         enum drm_connector_status status = connector_status_disconnected;
 
-        hdmi_priv->has_hdmi_sink = false;
-        edid = drm_get_edid(connector,
-                            intel_encoder->ddc_bus);
+        intel_hdmi->has_hdmi_sink = false;
+        edid = drm_get_edid(connector, intel_hdmi->base.ddc_bus);
 
         if (edid) {
                 if (edid->input & DRM_EDID_INPUT_DIGITAL) {
                         status = connector_status_connected;
-                        hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
+                        intel_hdmi->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
                 }
                 connector->display_info.raw_edid = NULL;
                 kfree(edid);
@@ -162,13 +164,13 @@ intel_hdmi_detect(struct drm_connector *connector)
 static int intel_hdmi_get_modes(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
 
         /* We should parse the EDID data and find out if it's an HDMI sink so
          * we can send audio to it.
          */
 
-        return intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
+        return intel_ddc_get_modes(connector, intel_hdmi->base.ddc_bus);
 }
 
 static void intel_hdmi_destroy(struct drm_connector *connector)
@@ -199,18 +201,8 @@ static const struct drm_connector_helper_funcs intel_hdmi_connector_helper_funcs
         .best_encoder = intel_attached_encoder,
 };
 
-static void intel_hdmi_enc_destroy(struct drm_encoder *encoder)
-{
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-
-        if (intel_encoder->i2c_bus)
-                intel_i2c_destroy(intel_encoder->i2c_bus);
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
-}
-
 static const struct drm_encoder_funcs intel_hdmi_enc_funcs = {
-        .destroy = intel_hdmi_enc_destroy,
+        .destroy = intel_encoder_destroy,
 };
 
 void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
@@ -219,21 +211,19 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
         struct drm_connector *connector;
         struct intel_encoder *intel_encoder;
         struct intel_connector *intel_connector;
-        struct intel_hdmi_priv *hdmi_priv;
+        struct intel_hdmi *intel_hdmi;
 
-        intel_encoder = kcalloc(sizeof(struct intel_encoder) +
-                               sizeof(struct intel_hdmi_priv), 1, GFP_KERNEL);
-        if (!intel_encoder)
+        intel_hdmi = kzalloc(sizeof(struct intel_hdmi), GFP_KERNEL);
+        if (!intel_hdmi)
                 return;
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
-                kfree(intel_encoder);
+                kfree(intel_hdmi);
                 return;
         }
 
-        hdmi_priv = (struct intel_hdmi_priv *)(intel_encoder + 1);
-
+        intel_encoder = &intel_hdmi->base;
         connector = &intel_connector->base;
         drm_connector_init(dev, connector, &intel_hdmi_connector_funcs,
                            DRM_MODE_CONNECTOR_HDMIA);
@@ -274,8 +264,7 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
         if (!intel_encoder->ddc_bus)
                 goto err_connector;
 
-        hdmi_priv->sdvox_reg = sdvox_reg;
-        intel_encoder->dev_priv = hdmi_priv;
+        intel_hdmi->sdvox_reg = sdvox_reg;
 
         drm_encoder_init(dev, &intel_encoder->enc, &intel_hdmi_enc_funcs,
                          DRM_MODE_ENCODER_TMDS);
@@ -298,7 +287,7 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
 
 err_connector:
         drm_connector_cleanup(connector);
-        kfree(intel_encoder);
+        kfree(intel_hdmi);
         kfree(intel_connector);
 
         return;
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index 0a2e60059fb3..6ec39a86ed06 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -41,12 +41,18 @@
 #include <linux/acpi.h>
 
 /* Private structure for the integrated LVDS support */
-struct intel_lvds_priv {
+struct intel_lvds {
+        struct intel_encoder base;
         int fitting_mode;
         u32 pfit_control;
         u32 pfit_pgm_ratios;
 };
 
+static struct intel_lvds *enc_to_intel_lvds(struct drm_encoder *encoder)
+{
+        return container_of(enc_to_intel_encoder(encoder), struct intel_lvds, base);
+}
+
 /**
  * Sets the backlight level.
  *
@@ -90,7 +96,7 @@ static u32 intel_lvds_get_max_backlight(struct drm_device *dev)
 static void intel_lvds_set_power(struct drm_device *dev, bool on)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 pp_status, ctl_reg, status_reg, lvds_reg;
+        u32 ctl_reg, status_reg, lvds_reg;
 
         if (HAS_PCH_SPLIT(dev)) {
                 ctl_reg = PCH_PP_CONTROL;
@@ -108,9 +114,8 @@ static void intel_lvds_set_power(struct drm_device *dev, bool on)
 
                 I915_WRITE(ctl_reg, I915_READ(ctl_reg) |
                            POWER_TARGET_ON);
-                do {
-                        pp_status = I915_READ(status_reg);
-                } while ((pp_status & PP_ON) == 0);
+                if (wait_for(I915_READ(status_reg) & PP_ON, 1000, 0))
+                        DRM_ERROR("timed out waiting to enable LVDS pipe");
 
                 intel_lvds_set_backlight(dev, dev_priv->backlight_duty_cycle);
         } else {
@@ -118,9 +123,8 @@ static void intel_lvds_set_power(struct drm_device *dev, bool on)
 
                 I915_WRITE(ctl_reg, I915_READ(ctl_reg) &
                            ~POWER_TARGET_ON);
-                do {
-                        pp_status = I915_READ(status_reg);
-                } while (pp_status & PP_ON);
+                if (wait_for((I915_READ(status_reg) & PP_ON) == 0, 1000, 0))
+                        DRM_ERROR("timed out waiting for LVDS pipe to turn off");
 
                 I915_WRITE(lvds_reg, I915_READ(lvds_reg) & ~LVDS_PORT_EN);
                 POSTING_READ(lvds_reg);
@@ -219,9 +223,8 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
+        struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
         struct drm_encoder *tmp_encoder;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_lvds_priv *lvds_priv = intel_encoder->dev_priv;
         u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
 
         /* Should never happen!! */
@@ -241,26 +244,20 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
         /* If we don't have a panel mode, there is nothing we can do */
         if (dev_priv->panel_fixed_mode == NULL)
                 return true;
+
         /*
          * We have timings from the BIOS for the panel, put them in
          * to the adjusted mode.  The CRTC will be set up for this mode,
          * with the panel scaling set up to source from the H/VDisplay
          * of the original mode.
          */
-        adjusted_mode->hdisplay = dev_priv->panel_fixed_mode->hdisplay;
-        adjusted_mode->hsync_start =
-                dev_priv->panel_fixed_mode->hsync_start;
-        adjusted_mode->hsync_end =
-                dev_priv->panel_fixed_mode->hsync_end;
-        adjusted_mode->htotal = dev_priv->panel_fixed_mode->htotal;
-        adjusted_mode->vdisplay = dev_priv->panel_fixed_mode->vdisplay;
-        adjusted_mode->vsync_start =
-                dev_priv->panel_fixed_mode->vsync_start;
-        adjusted_mode->vsync_end =
-                dev_priv->panel_fixed_mode->vsync_end;
-        adjusted_mode->vtotal = dev_priv->panel_fixed_mode->vtotal;
-        adjusted_mode->clock = dev_priv->panel_fixed_mode->clock;
-        drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
+        intel_fixed_panel_mode(dev_priv->panel_fixed_mode, adjusted_mode);
+
+        if (HAS_PCH_SPLIT(dev)) {
+                intel_pch_panel_fitting(dev, intel_lvds->fitting_mode,
+                                        mode, adjusted_mode);
+                return true;
+        }
 
         /* Make sure pre-965s set dither correctly */
         if (!IS_I965G(dev)) {
@@ -273,10 +270,6 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
             adjusted_mode->vdisplay == mode->vdisplay)
                 goto out;
 
-        /* full screen scale for now */
-        if (HAS_PCH_SPLIT(dev))
-                goto out;
-
         /* 965+ wants fuzzy fitting */
         if (IS_I965G(dev))
                 pfit_control |= ((intel_crtc->pipe << PFIT_PIPE_SHIFT) |
@@ -288,12 +281,10 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
          * to register description and PRM.
          * Change the value here to see the borders for debugging
          */
-        if (!HAS_PCH_SPLIT(dev)) {
-                I915_WRITE(BCLRPAT_A, 0);
-                I915_WRITE(BCLRPAT_B, 0);
-        }
+        I915_WRITE(BCLRPAT_A, 0);
+        I915_WRITE(BCLRPAT_B, 0);
 
-        switch (lvds_priv->fitting_mode) {
+        switch (intel_lvds->fitting_mode) {
         case DRM_MODE_SCALE_CENTER:
                 /*
                  * For centered modes, we have to calculate border widths &
@@ -378,8 +369,8 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
         }
 
 out:
-        lvds_priv->pfit_control = pfit_control;
-        lvds_priv->pfit_pgm_ratios = pfit_pgm_ratios;
+        intel_lvds->pfit_control = pfit_control;
+        intel_lvds->pfit_pgm_ratios = pfit_pgm_ratios;
         dev_priv->lvds_border_bits = border;
 
         /*
@@ -427,8 +418,7 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
 {
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_lvds_priv *lvds_priv = intel_encoder->dev_priv;
+        struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
 
         /*
          * The LVDS pin pair will already have been turned on in the
@@ -444,8 +434,8 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
          * screen.  Should be enabled before the pipe is enabled, according to
          * register description and PRM.
          */
-        I915_WRITE(PFIT_PGM_RATIOS, lvds_priv->pfit_pgm_ratios);
-        I915_WRITE(PFIT_CONTROL, lvds_priv->pfit_control);
+        I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
+        I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
 }
 
 /**
@@ -455,7 +445,8 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
  * connected and closed means disconnected.  We also send hotplug events as
  * needed, using lid status notification from the input layer.
  */
-static enum drm_connector_status intel_lvds_detect(struct drm_connector *connector)
+static enum drm_connector_status
+intel_lvds_detect(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
         enum drm_connector_status status = connector_status_connected;
@@ -550,7 +541,9 @@ static int intel_lid_notify(struct notifier_block *nb, unsigned long val,
          * the LID nofication event.
          */
         if (connector)
-                connector->status = connector->funcs->detect(connector);
+                connector->status = connector->funcs->detect(connector,
+                                                             false);
+
         /* Don't force modeset on machines where it causes a GPU lockup */
         if (dmi_check_system(intel_no_modeset_on_lid))
                 return NOTIFY_OK;
@@ -600,18 +593,17 @@ static int intel_lvds_set_property(struct drm_connector *connector,
                                 connector->encoder) {
                 struct drm_crtc *crtc = connector->encoder->crtc;
                 struct drm_encoder *encoder = connector->encoder;
-                struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-                struct intel_lvds_priv *lvds_priv = intel_encoder->dev_priv;
+                struct intel_lvds *intel_lvds = enc_to_intel_lvds(encoder);
 
                 if (value == DRM_MODE_SCALE_NONE) {
                         DRM_DEBUG_KMS("no scaling not supported\n");
                         return 0;
                 }
-                if (lvds_priv->fitting_mode == value) {
+                if (intel_lvds->fitting_mode == value) {
                         /* the LVDS scaling property is not changed */
                         return 0;
                 }
-                lvds_priv->fitting_mode = value;
+                intel_lvds->fitting_mode = value;
                 if (crtc && crtc->enabled) {
                         /*
                          * If the CRTC is enabled, the display will be changed
@@ -647,19 +639,8 @@ static const struct drm_connector_funcs intel_lvds_connector_funcs = {
         .destroy = intel_lvds_destroy,
 };
 
-
-static void intel_lvds_enc_destroy(struct drm_encoder *encoder)
-{
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-
-        if (intel_encoder->ddc_bus)
-                intel_i2c_destroy(intel_encoder->ddc_bus);
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
-}
-
 static const struct drm_encoder_funcs intel_lvds_enc_funcs = {
-        .destroy = intel_lvds_enc_destroy,
+        .destroy = intel_encoder_destroy,
 };
 
 static int __init intel_no_lvds_dmi_callback(const struct dmi_system_id *id)
@@ -843,13 +824,13 @@ static int lvds_is_present_in_vbt(struct drm_device *dev)
 void intel_lvds_init(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_lvds *intel_lvds;
         struct intel_encoder *intel_encoder;
         struct intel_connector *intel_connector;
         struct drm_connector *connector;
         struct drm_encoder *encoder;
         struct drm_display_mode *scan; /* *modes, *bios_mode; */
         struct drm_crtc *crtc;
-        struct intel_lvds_priv *lvds_priv;
         u32 lvds;
         int pipe, gpio = GPIOC;
 
@@ -872,20 +853,20 @@ void intel_lvds_init(struct drm_device *dev)
                 gpio = PCH_GPIOC;
         }
 
-        intel_encoder = kzalloc(sizeof(struct intel_encoder) +
-                                sizeof(struct intel_lvds_priv), GFP_KERNEL);
-        if (!intel_encoder) {
+        intel_lvds = kzalloc(sizeof(struct intel_lvds), GFP_KERNEL);
+        if (!intel_lvds) {
                 return;
         }
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
-                kfree(intel_encoder);
+                kfree(intel_lvds);
                 return;
         }
 
-        connector = &intel_connector->base;
+        intel_encoder = &intel_lvds->base;
         encoder = &intel_encoder->enc;
+        connector = &intel_connector->base;
         drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs,
                            DRM_MODE_CONNECTOR_LVDS);
 
@@ -897,16 +878,12 @@ void intel_lvds_init(struct drm_device *dev)
 
         intel_encoder->clone_mask = (1 << INTEL_LVDS_CLONE_BIT);
         intel_encoder->crtc_mask = (1 << 1);
-        if (IS_I965G(dev))
-                intel_encoder->crtc_mask |= (1 << 0);
         drm_encoder_helper_add(encoder, &intel_lvds_helper_funcs);
         drm_connector_helper_add(connector, &intel_lvds_connector_helper_funcs);
         connector->display_info.subpixel_order = SubPixelHorizontalRGB;
         connector->interlace_allowed = false;
         connector->doublescan_allowed = false;
 
-        lvds_priv = (struct intel_lvds_priv *)(intel_encoder + 1);
-        intel_encoder->dev_priv = lvds_priv;
         /* create the scaling mode property */
         drm_mode_create_scaling_mode_property(dev);
         /*
@@ -916,7 +893,7 @@ void intel_lvds_init(struct drm_device *dev)
         drm_connector_attach_property(&intel_connector->base,
                                       dev->mode_config.scaling_mode_property,
                                       DRM_MODE_SCALE_ASPECT);
-        lvds_priv->fitting_mode = DRM_MODE_SCALE_ASPECT;
+        intel_lvds->fitting_mode = DRM_MODE_SCALE_ASPECT;
         /*
          * LVDS discovery:
          * 1) check for EDID on DDC
@@ -1024,6 +1001,6 @@ failed:
                 intel_i2c_destroy(intel_encoder->ddc_bus);
         drm_connector_cleanup(connector);
         drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
+        kfree(intel_lvds);
         kfree(intel_connector);
 }
diff --git a/drivers/gpu/drm/i915/intel_overlay.c b/drivers/gpu/drm/i915/intel_overlay.c
index d39aea24eabe..1d306a458be6 100644
--- a/drivers/gpu/drm/i915/intel_overlay.c
+++ b/drivers/gpu/drm/i915/intel_overlay.c
@@ -25,6 +25,8 @@
  *
  * Derived from Xorg ddx, xf86-video-intel, src/i830_video.c
  */
+
+#include <linux/seq_file.h>
 #include "drmP.h"
 #include "drm.h"
 #include "i915_drm.h"
@@ -1367,7 +1369,8 @@ void intel_setup_overlay(struct drm_device *dev)
                 overlay->flip_addr = overlay->reg_bo->gtt_offset;
         } else {
                 ret = i915_gem_attach_phys_object(dev, reg_bo,
-                                I915_GEM_PHYS_OVERLAY_REGS);
+                                                  I915_GEM_PHYS_OVERLAY_REGS,
+                                                  0);
                 if (ret) {
                         DRM_ERROR("failed to attach phys overlay regs\n");
                         goto out_free_bo;
@@ -1416,3 +1419,99 @@ void intel_cleanup_overlay(struct drm_device *dev)
                 kfree(dev_priv->overlay);
         }
 }
+
+struct intel_overlay_error_state {
+        struct overlay_registers regs;
+        unsigned long base;
+        u32 dovsta;
+        u32 isr;
+};
+
+struct intel_overlay_error_state *
+intel_overlay_capture_error_state(struct drm_device *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct intel_overlay *overlay = dev_priv->overlay;
+        struct intel_overlay_error_state *error;
+        struct overlay_registers __iomem *regs;
+
+        if (!overlay || !overlay->active)
+                return NULL;
+
+        error = kmalloc(sizeof(*error), GFP_ATOMIC);
+        if (error == NULL)
+                return NULL;
+
+        error->dovsta = I915_READ(DOVSTA);
+        error->isr = I915_READ(ISR);
+        if (OVERLAY_NONPHYSICAL(overlay->dev))
+                error->base = (long) overlay->reg_bo->gtt_offset;
+        else
+                error->base = (long) overlay->reg_bo->phys_obj->handle->vaddr;
+
+        regs = intel_overlay_map_regs_atomic(overlay);
+        if (!regs)
+                goto err;
+
+        memcpy_fromio(&error->regs, regs, sizeof(struct overlay_registers));
+        intel_overlay_unmap_regs_atomic(overlay);
+
+        return error;
+
+err:
+        kfree(error);
+        return NULL;
+}
+
+void
+intel_overlay_print_error_state(struct seq_file *m, struct intel_overlay_error_state *error)
+{
+        seq_printf(m, "Overlay, status: 0x%08x, interrupt: 0x%08x\n",
+                   error->dovsta, error->isr);
+        seq_printf(m, "  Register file at 0x%08lx:\n",
+                   error->base);
+
+#define P(x) seq_printf(m, "    " #x ": 0x%08x\n", error->regs.x)
+        P(OBUF_0Y);
+        P(OBUF_1Y);
+        P(OBUF_0U);
+        P(OBUF_0V);
+        P(OBUF_1U);
+        P(OBUF_1V);
+        P(OSTRIDE);
+        P(YRGB_VPH);
+        P(UV_VPH);
+        P(HORZ_PH);
+        P(INIT_PHS);
+        P(DWINPOS);
+        P(DWINSZ);
+        P(SWIDTH);
+        P(SWIDTHSW);
+        P(SHEIGHT);
+        P(YRGBSCALE);
+        P(UVSCALE);
+        P(OCLRC0);
+        P(OCLRC1);
+        P(DCLRKV);
+        P(DCLRKM);
+        P(SCLRKVH);
+        P(SCLRKVL);
+        P(SCLRKEN);
+        P(OCONFIG);
+        P(OCMD);
+        P(OSTART_0Y);
+        P(OSTART_1Y);
+        P(OSTART_0U);
+        P(OSTART_0V);
+        P(OSTART_1U);
+        P(OSTART_1V);
+        P(OTILEOFF_0Y);
+        P(OTILEOFF_1Y);
+        P(OTILEOFF_0U);
+        P(OTILEOFF_0V);
+        P(OTILEOFF_1U);
+        P(OTILEOFF_1V);
+        P(FASTHSCALE);
+        P(UVSCALEV);
+#undef P
+}
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
new file mode 100644
index 000000000000..e7f5299d9d57
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2006-2010 Intel Corporation
+ * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
+ *
+ * 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 (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 NONINFRINGEMENT.  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.
+ *
+ * Authors:
+ *      Eric Anholt <eric@anholt.net>
+ *      Dave Airlie <airlied@linux.ie>
+ *      Jesse Barnes <jesse.barnes@intel.com>
+ *      Chris Wilson <chris@chris-wilson.co.uk>
+ */
+
+#include "intel_drv.h"
+
+void
+intel_fixed_panel_mode(struct drm_display_mode *fixed_mode,
+                       struct drm_display_mode *adjusted_mode)
+{
+        adjusted_mode->hdisplay = fixed_mode->hdisplay;
+        adjusted_mode->hsync_start = fixed_mode->hsync_start;
+        adjusted_mode->hsync_end = fixed_mode->hsync_end;
+        adjusted_mode->htotal = fixed_mode->htotal;
+
+        adjusted_mode->vdisplay = fixed_mode->vdisplay;
+        adjusted_mode->vsync_start = fixed_mode->vsync_start;
+        adjusted_mode->vsync_end = fixed_mode->vsync_end;
+        adjusted_mode->vtotal = fixed_mode->vtotal;
+
+        adjusted_mode->clock = fixed_mode->clock;
+
+        drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
+}
+
+/* adjusted_mode has been preset to be the panel's fixed mode */
+void
+intel_pch_panel_fitting(struct drm_device *dev,
+                        int fitting_mode,
+                        struct drm_display_mode *mode,
+                        struct drm_display_mode *adjusted_mode)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        int x, y, width, height;
+
+        x = y = width = height = 0;
+
+        /* Native modes don't need fitting */
+        if (adjusted_mode->hdisplay == mode->hdisplay &&
+            adjusted_mode->vdisplay == mode->vdisplay)
+                goto done;
+
+        switch (fitting_mode) {
+        case DRM_MODE_SCALE_CENTER:
+                width = mode->hdisplay;
+                height = mode->vdisplay;
+                x = (adjusted_mode->hdisplay - width + 1)/2;
+                y = (adjusted_mode->vdisplay - height + 1)/2;
+                break;
+
+        case DRM_MODE_SCALE_ASPECT:
+                /* Scale but preserve the aspect ratio */
+                {
+                        u32 scaled_width = adjusted_mode->hdisplay * mode->vdisplay;
+                        u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
+                        if (scaled_width > scaled_height) { /* pillar */
+                                width = scaled_height / mode->vdisplay;
+                                x = (adjusted_mode->hdisplay - width + 1) / 2;
+                                y = 0;
+                                height = adjusted_mode->vdisplay;
+                        } else if (scaled_width < scaled_height) { /* letter */
+                                height = scaled_width / mode->hdisplay;
+                                y = (adjusted_mode->vdisplay - height + 1) / 2;
+                                x = 0;
+                                width = adjusted_mode->hdisplay;
+                        } else {
+                                x = y = 0;
+                                width = adjusted_mode->hdisplay;
+                                height = adjusted_mode->vdisplay;
+                        }
+                }
+                break;
+
+        default:
+        case DRM_MODE_SCALE_FULLSCREEN:
+                x = y = 0;
+                width = adjusted_mode->hdisplay;
+                height = adjusted_mode->vdisplay;
+                break;
+        }
+
+done:
+        dev_priv->pch_pf_pos = (x << 16) | y;
+        dev_priv->pch_pf_size = (width << 16) | height;
+}
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index 26362f8495a8..cb3508f78bc3 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -33,18 +33,35 @@
 #include "i915_drm.h"
 #include "i915_trace.h"
 
+static u32 i915_gem_get_seqno(struct drm_device *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        u32 seqno;
+
+        seqno = dev_priv->next_seqno;
+
+        /* reserve 0 for non-seqno */
+        if (++dev_priv->next_seqno == 0)
+                dev_priv->next_seqno = 1;
+
+        return seqno;
+}
+
 static void
 render_ring_flush(struct drm_device *dev,
                 struct intel_ring_buffer *ring,
                 u32     invalidate_domains,
                 u32     flush_domains)
 {
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        u32 cmd;
+
 #if WATCH_EXEC
         DRM_INFO("%s: invalidate %08x flush %08x\n", __func__,
                   invalidate_domains, flush_domains);
 #endif
-        u32 cmd;
-        trace_i915_gem_request_flush(dev, ring->next_seqno,
+
+        trace_i915_gem_request_flush(dev, dev_priv->next_seqno,
                                      invalidate_domains, flush_domains);
 
         if ((invalidate_domains | flush_domains) & I915_GEM_GPU_DOMAINS) {
@@ -203,9 +220,13 @@ static int init_render_ring(struct drm_device *dev,
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         int ret = init_ring_common(dev, ring);
+        int mode;
+
         if (IS_I9XX(dev) && !IS_GEN3(dev)) {
-                I915_WRITE(MI_MODE,
-                                (VS_TIMER_DISPATCH) << 16 | VS_TIMER_DISPATCH);
+                mode = VS_TIMER_DISPATCH << 16 | VS_TIMER_DISPATCH;
+                if (IS_GEN6(dev))
+                        mode |= MI_FLUSH_ENABLE << 16 | MI_FLUSH_ENABLE;
+                I915_WRITE(MI_MODE, mode);
         }
         return ret;
 }
@@ -233,9 +254,10 @@ render_ring_add_request(struct drm_device *dev,
                 struct drm_file *file_priv,
                 u32 flush_domains)
 {
-        u32 seqno;
         drm_i915_private_t *dev_priv = dev->dev_private;
-        seqno = intel_ring_get_seqno(dev, ring);
+        u32 seqno;
+
+        seqno = i915_gem_get_seqno(dev);
 
         if (IS_GEN6(dev)) {
                 BEGIN_LP_RING(6);
@@ -405,7 +427,9 @@ bsd_ring_add_request(struct drm_device *dev,
                 u32 flush_domains)
 {
         u32 seqno;
-        seqno = intel_ring_get_seqno(dev, ring);
+
+        seqno = i915_gem_get_seqno(dev);
+
         intel_ring_begin(dev, ring, 4);
         intel_ring_emit(dev, ring, MI_STORE_DWORD_INDEX);
         intel_ring_emit(dev, ring,
@@ -479,7 +503,7 @@ render_ring_dispatch_gem_execbuffer(struct drm_device *dev,
         exec_start = (uint32_t) exec_offset + exec->batch_start_offset;
         exec_len = (uint32_t) exec->batch_len;
 
-        trace_i915_gem_request_submit(dev, dev_priv->mm.next_gem_seqno + 1);
+        trace_i915_gem_request_submit(dev, dev_priv->next_seqno + 1);
 
         count = nbox ? nbox : 1;
 
@@ -515,7 +539,16 @@ render_ring_dispatch_gem_execbuffer(struct drm_device *dev,
                 intel_ring_advance(dev, ring);
         }
 
+        if (IS_G4X(dev) || IS_IRONLAKE(dev)) {
+                intel_ring_begin(dev, ring, 2);
+                intel_ring_emit(dev, ring, MI_FLUSH |
+                                MI_NO_WRITE_FLUSH |
+                                MI_INVALIDATE_ISP );
+                intel_ring_emit(dev, ring, MI_NOOP);
+                intel_ring_advance(dev, ring);
+        }
         /* XXX breadcrumb */
+
         return 0;
 }
 
@@ -588,9 +621,10 @@ err:
 int intel_init_ring_buffer(struct drm_device *dev,
                 struct intel_ring_buffer *ring)
 {
-        int ret;
         struct drm_i915_gem_object *obj_priv;
         struct drm_gem_object *obj;
+        int ret;
+
         ring->dev = dev;
 
         if (I915_NEED_GFX_HWS(dev)) {
@@ -603,16 +637,14 @@ int intel_init_ring_buffer(struct drm_device *dev,
         if (obj == NULL) {
                 DRM_ERROR("Failed to allocate ringbuffer\n");
                 ret = -ENOMEM;
-                goto cleanup;
+                goto err_hws;
         }
 
         ring->gem_object = obj;
 
         ret = i915_gem_object_pin(obj, ring->alignment);
-        if (ret != 0) {
-                drm_gem_object_unreference(obj);
-                goto cleanup;
-        }
+        if (ret)
+                goto err_unref;
 
         obj_priv = to_intel_bo(obj);
         ring->map.size = ring->size;
@@ -624,18 +656,14 @@ int intel_init_ring_buffer(struct drm_device *dev,
         drm_core_ioremap_wc(&ring->map, dev);
         if (ring->map.handle == NULL) {
                 DRM_ERROR("Failed to map ringbuffer.\n");
-                i915_gem_object_unpin(obj);
-                drm_gem_object_unreference(obj);
                 ret = -EINVAL;
-                goto cleanup;
+                goto err_unpin;
         }
 
         ring->virtual_start = ring->map.handle;
         ret = ring->init(dev, ring);
-        if (ret != 0) {
-                intel_cleanup_ring_buffer(dev, ring);
-                return ret;
-        }
+        if (ret)
+                goto err_unmap;
 
         if (!drm_core_check_feature(dev, DRIVER_MODESET))
                 i915_kernel_lost_context(dev);
@@ -649,7 +677,15 @@ int intel_init_ring_buffer(struct drm_device *dev,
         INIT_LIST_HEAD(&ring->active_list);
         INIT_LIST_HEAD(&ring->request_list);
         return ret;
-cleanup:
+
+err_unmap:
+        drm_core_ioremapfree(&ring->map, dev);
+err_unpin:
+        i915_gem_object_unpin(obj);
+err_unref:
+        drm_gem_object_unreference(obj);
+        ring->gem_object = NULL;
+err_hws:
         cleanup_status_page(dev, ring);
         return ret;
 }
@@ -682,9 +718,11 @@ int intel_wrap_ring_buffer(struct drm_device *dev,
         }
 
         virt = (unsigned int *)(ring->virtual_start + ring->tail);
-        rem /= 4;
-        while (rem--)
+        rem /= 8;
+        while (rem--) {
+                *virt++ = MI_NOOP;
                 *virt++ = MI_NOOP;
+        }
 
         ring->tail = 0;
         ring->space = ring->head - 8;
@@ -729,21 +767,14 @@ void intel_ring_begin(struct drm_device *dev,
                 intel_wrap_ring_buffer(dev, ring);
         if (unlikely(ring->space < n))
                 intel_wait_ring_buffer(dev, ring, n);
-}
 
-void intel_ring_emit(struct drm_device *dev,
-                struct intel_ring_buffer *ring, unsigned int data)
-{
-        unsigned int *virt = ring->virtual_start + ring->tail;
-        *virt = data;
-        ring->tail += 4;
-        ring->tail &= ring->size - 1;
-        ring->space -= 4;
+        ring->space -= n;
 }
 
 void intel_ring_advance(struct drm_device *dev,
                 struct intel_ring_buffer *ring)
 {
+        ring->tail &= ring->size - 1;
         ring->advance_ring(dev, ring);
 }
 
@@ -762,18 +793,6 @@ void intel_fill_struct(struct drm_device *dev,
         intel_ring_advance(dev, ring);
 }
 
-u32 intel_ring_get_seqno(struct drm_device *dev,
-                struct intel_ring_buffer *ring)
-{
-        u32 seqno;
-        seqno = ring->next_seqno;
-
-        /* reserve 0 for non-seqno */
-        if (++ring->next_seqno == 0)
-                ring->next_seqno = 1;
-        return seqno;
-}
-
 struct intel_ring_buffer render_ring = {
         .name                   = "render ring",
         .regs                   = {
@@ -791,7 +810,6 @@ struct intel_ring_buffer render_ring = {
         .head                   = 0,
         .tail                   = 0,
         .space                  = 0,
-        .next_seqno             = 1,
         .user_irq_refcount      = 0,
         .irq_gem_seqno          = 0,
         .waiting_gem_seqno      = 0,
@@ -830,7 +848,6 @@ struct intel_ring_buffer bsd_ring = {
         .head                   = 0,
         .tail                   = 0,
         .space                  = 0,
-        .next_seqno             = 1,
         .user_irq_refcount      = 0,
         .irq_gem_seqno          = 0,
         .waiting_gem_seqno      = 0,
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.h b/drivers/gpu/drm/i915/intel_ringbuffer.h
index d5568d3766de..525e7d3edda8 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.h
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.h
@@ -26,7 +26,6 @@ struct  intel_ring_buffer {
         unsigned int    head;
         unsigned int    tail;
         unsigned int    space;
-        u32             next_seqno;
         struct intel_hw_status_page status_page;
 
         u32             irq_gem_seqno;          /* last seq seem at irq time */
@@ -106,8 +105,16 @@ int intel_wrap_ring_buffer(struct drm_device *dev,
                 struct intel_ring_buffer *ring);
 void intel_ring_begin(struct drm_device *dev,
                 struct intel_ring_buffer *ring, int n);
-void intel_ring_emit(struct drm_device *dev,
-                struct intel_ring_buffer *ring, u32 data);
+
+static inline void intel_ring_emit(struct drm_device *dev,
+                                   struct intel_ring_buffer *ring,
+                                   unsigned int data)
+{
+        unsigned int *virt = ring->virtual_start + ring->tail;
+        *virt = data;
+        ring->tail += 4;
+}
+
 void intel_fill_struct(struct drm_device *dev,
                 struct intel_ring_buffer *ring,
                 void *data,
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index d9d4d51aa89e..ee73e428a84a 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -31,8 +31,8 @@
 #include "drmP.h"
 #include "drm.h"
 #include "drm_crtc.h"
-#include "intel_drv.h"
 #include "drm_edid.h"
+#include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
 #include "intel_sdvo_regs.h"
@@ -47,9 +47,10 @@
 
 #define IS_TV(c)        (c->output_flag & SDVO_TV_MASK)
 #define IS_LVDS(c)      (c->output_flag & SDVO_LVDS_MASK)
+#define IS_TV_OR_LVDS(c) (c->output_flag & (SDVO_TV_MASK | SDVO_LVDS_MASK))
 
 
-static char *tv_format_names[] = {
+static const char *tv_format_names[] = {
         "NTSC_M"   , "NTSC_J"  , "NTSC_443",
         "PAL_B"    , "PAL_D"   , "PAL_G"   ,
         "PAL_H"    , "PAL_I"   , "PAL_M"   ,
@@ -61,7 +62,9 @@ static char *tv_format_names[] = {
 
 #define TV_FORMAT_NUM  (sizeof(tv_format_names) / sizeof(*tv_format_names))
 
-struct intel_sdvo_priv {
+struct intel_sdvo {
+        struct intel_encoder base;
+
         u8 slave_addr;
 
         /* Register for the SDVO device: SDVOB or SDVOC */
@@ -95,7 +98,7 @@ struct intel_sdvo_priv {
         bool is_tv;
 
         /* This is for current tv format name */
-        char *tv_format_name;
+        int tv_format_index;
 
         /**
          * This is set if we treat the device as HDMI, instead of DVI.
@@ -132,37 +135,40 @@ struct intel_sdvo_priv {
 };
 
 struct intel_sdvo_connector {
+        struct intel_connector base;
+
         /* Mark the type of connector */
         uint16_t output_flag;
 
         /* This contains all current supported TV format */
-        char *tv_format_supported[TV_FORMAT_NUM];
+        u8 tv_format_supported[TV_FORMAT_NUM];
         int   format_supported_num;
-        struct drm_property *tv_format_property;
-        struct drm_property *tv_format_name_property[TV_FORMAT_NUM];
-
-        /**
-         * Returned SDTV resolutions allowed for the current format, if the
-         * device reported it.
-         */
-        struct intel_sdvo_sdtv_resolution_reply sdtv_resolutions;
+        struct drm_property *tv_format;
 
         /* add the property for the SDVO-TV */
-        struct drm_property *left_property;
-        struct drm_property *right_property;
-        struct drm_property *top_property;
-        struct drm_property *bottom_property;
-        struct drm_property *hpos_property;
-        struct drm_property *vpos_property;
+        struct drm_property *left;
+        struct drm_property *right;
+        struct drm_property *top;
+        struct drm_property *bottom;
+        struct drm_property *hpos;
+        struct drm_property *vpos;
+        struct drm_property *contrast;
+        struct drm_property *saturation;
+        struct drm_property *hue;
+        struct drm_property *sharpness;
+        struct drm_property *flicker_filter;
+        struct drm_property *flicker_filter_adaptive;
+        struct drm_property *flicker_filter_2d;
+        struct drm_property *tv_chroma_filter;
+        struct drm_property *tv_luma_filter;
+        struct drm_property *dot_crawl;
 
         /* add the property for the SDVO-TV/LVDS */
-        struct drm_property *brightness_property;
-        struct drm_property *contrast_property;
-        struct drm_property *saturation_property;
-        struct drm_property *hue_property;
+        struct drm_property *brightness;
 
         /* Add variable to record current setting for the above property */
         u32     left_margin, right_margin, top_margin, bottom_margin;
+
         /* this is to get the range of margin.*/
         u32     max_hscan,  max_vscan;
         u32     max_hpos, cur_hpos;
@@ -171,36 +177,54 @@ struct intel_sdvo_connector {
         u32     cur_contrast,   max_contrast;
         u32     cur_saturation, max_saturation;
         u32     cur_hue,        max_hue;
+        u32     cur_sharpness,  max_sharpness;
+        u32     cur_flicker_filter,             max_flicker_filter;
+        u32     cur_flicker_filter_adaptive,    max_flicker_filter_adaptive;
+        u32     cur_flicker_filter_2d,          max_flicker_filter_2d;
+        u32     cur_tv_chroma_filter,   max_tv_chroma_filter;
+        u32     cur_tv_luma_filter,     max_tv_luma_filter;
+        u32     cur_dot_crawl,  max_dot_crawl;
 };
 
+static struct intel_sdvo *enc_to_intel_sdvo(struct drm_encoder *encoder)
+{
+        return container_of(enc_to_intel_encoder(encoder), struct intel_sdvo, base);
+}
+
+static struct intel_sdvo_connector *to_intel_sdvo_connector(struct drm_connector *connector)
+{
+        return container_of(to_intel_connector(connector), struct intel_sdvo_connector, base);
+}
+
 static bool
-intel_sdvo_output_setup(struct intel_encoder *intel_encoder,
-                        uint16_t flags);
-static void
-intel_sdvo_tv_create_property(struct drm_connector *connector, int type);
-static void
-intel_sdvo_create_enhance_property(struct drm_connector *connector);
+intel_sdvo_output_setup(struct intel_sdvo *intel_sdvo, uint16_t flags);
+static bool
+intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
+                              struct intel_sdvo_connector *intel_sdvo_connector,
+                              int type);
+static bool
+intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo,
+                                   struct intel_sdvo_connector *intel_sdvo_connector);
 
 /**
  * Writes the SDVOB or SDVOC with the given value, but always writes both
  * SDVOB and SDVOC to work around apparent hardware issues (according to
  * comments in the BIOS).
  */
-static void intel_sdvo_write_sdvox(struct intel_encoder *intel_encoder, u32 val)
+static void intel_sdvo_write_sdvox(struct intel_sdvo *intel_sdvo, u32 val)
 {
-        struct drm_device *dev = intel_encoder->enc.dev;
+        struct drm_device *dev = intel_sdvo->base.enc.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_sdvo_priv   *sdvo_priv = intel_encoder->dev_priv;
         u32 bval = val, cval = val;
         int i;
 
-        if (sdvo_priv->sdvo_reg == PCH_SDVOB) {
-                I915_WRITE(sdvo_priv->sdvo_reg, val);
-                I915_READ(sdvo_priv->sdvo_reg);
+        if (intel_sdvo->sdvo_reg == PCH_SDVOB) {
+                I915_WRITE(intel_sdvo->sdvo_reg, val);
+                I915_READ(intel_sdvo->sdvo_reg);
                 return;
         }
 
-        if (sdvo_priv->sdvo_reg == SDVOB) {
+        if (intel_sdvo->sdvo_reg == SDVOB) {
                 cval = I915_READ(SDVOC);
         } else {
                 bval = I915_READ(SDVOB);
@@ -219,33 +243,27 @@ static void intel_sdvo_write_sdvox(struct intel_encoder *intel_encoder, u32 val)
         }
 }
 
-static bool intel_sdvo_read_byte(struct intel_encoder *intel_encoder, u8 addr,
-                                 u8 *ch)
+static bool intel_sdvo_read_byte(struct intel_sdvo *intel_sdvo, u8 addr, u8 *ch)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        u8 out_buf[2];
+        u8 out_buf[2] = { addr, 0 };
         u8 buf[2];
-        int ret;
-
         struct i2c_msg msgs[] = {
                 {
-                        .addr = sdvo_priv->slave_addr >> 1,
+                        .addr = intel_sdvo->slave_addr >> 1,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = sdvo_priv->slave_addr >> 1,
+                        .addr = intel_sdvo->slave_addr >> 1,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = buf,
                 }
         };
+        int ret;
 
-        out_buf[0] = addr;
-        out_buf[1] = 0;
-
-        if ((ret = i2c_transfer(intel_encoder->i2c_bus, msgs, 2)) == 2)
+        if ((ret = i2c_transfer(intel_sdvo->base.i2c_bus, msgs, 2)) == 2)
         {
                 *ch = buf[0];
                 return true;
@@ -255,35 +273,26 @@ static bool intel_sdvo_read_byte(struct intel_encoder *intel_encoder, u8 addr,
         return false;
 }
 
-static bool intel_sdvo_write_byte(struct intel_encoder *intel_encoder, int addr,
-                                  u8 ch)
+static bool intel_sdvo_write_byte(struct intel_sdvo *intel_sdvo, int addr, u8 ch)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        u8 out_buf[2];
+        u8 out_buf[2] = { addr, ch };
         struct i2c_msg msgs[] = {
                 {
-                        .addr = sdvo_priv->slave_addr >> 1,
+                        .addr = intel_sdvo->slave_addr >> 1,
                         .flags = 0,
                         .len = 2,
                         .buf = out_buf,
                 }
         };
 
-        out_buf[0] = addr;
-        out_buf[1] = ch;
-
-        if (i2c_transfer(intel_encoder->i2c_bus, msgs, 1) == 1)
-        {
-                return true;
-        }
-        return false;
+        return i2c_transfer(intel_sdvo->base.i2c_bus, msgs, 1) == 1;
 }
 
 #define SDVO_CMD_NAME_ENTRY(cmd) {cmd, #cmd}
 /** Mapping of command numbers to names, for debug output */
 static const struct _sdvo_cmd_name {
         u8 cmd;
-        char *name;
+        const char *name;
 } sdvo_cmd_names[] = {
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_RESET),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_DEVICE_CAPS),
@@ -328,13 +337,14 @@ static const struct _sdvo_cmd_name {
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SDTV_RESOLUTION_SUPPORT),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SCALED_HDTV_RESOLUTION_SUPPORT),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS),
+
     /* Add the op code for SDVO enhancements */
-    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_POSITION_H),
-    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_POSITION_H),
-    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_POSITION_H),
-    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_POSITION_V),
-    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_POSITION_V),
-    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_POSITION_V),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_HPOS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HPOS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HPOS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_VPOS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_VPOS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_VPOS),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_SATURATION),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SATURATION),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_SATURATION),
@@ -353,6 +363,27 @@ static const struct _sdvo_cmd_name {
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_OVERSCAN_V),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_OVERSCAN_V),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_OVERSCAN_V),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_FLICKER_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FLICKER_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_FLICKER_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_FLICKER_FILTER_ADAPTIVE),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FLICKER_FILTER_ADAPTIVE),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_FLICKER_FILTER_ADAPTIVE),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_FLICKER_FILTER_2D),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FLICKER_FILTER_2D),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_FLICKER_FILTER_2D),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_SHARPNESS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SHARPNESS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_SHARPNESS),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_DOT_CRAWL),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_DOT_CRAWL),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_TV_CHROMA_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_TV_CHROMA_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TV_CHROMA_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_TV_LUMA_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_TV_LUMA_FILTER),
+    SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TV_LUMA_FILTER),
+
     /* HDMI op code */
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPP_ENCODE),
     SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_ENCODE),
@@ -377,17 +408,15 @@ static const struct _sdvo_cmd_name {
 };
 
 #define IS_SDVOB(reg)   (reg == SDVOB || reg == PCH_SDVOB)
-#define SDVO_NAME(dev_priv) (IS_SDVOB((dev_priv)->sdvo_reg) ? "SDVOB" : "SDVOC")
-#define SDVO_PRIV(encoder)   ((struct intel_sdvo_priv *) (encoder)->dev_priv)
+#define SDVO_NAME(svdo) (IS_SDVOB((svdo)->sdvo_reg) ? "SDVOB" : "SDVOC")
 
-static void intel_sdvo_debug_write(struct intel_encoder *intel_encoder, u8 cmd,
-                                   void *args, int args_len)
+static void intel_sdvo_debug_write(struct intel_sdvo *intel_sdvo, u8 cmd,
+                                   const void *args, int args_len)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
         int i;
 
         DRM_DEBUG_KMS("%s: W: %02X ",
-                                SDVO_NAME(sdvo_priv), cmd);
+                                SDVO_NAME(intel_sdvo), cmd);
         for (i = 0; i < args_len; i++)
                 DRM_LOG_KMS("%02X ", ((u8 *)args)[i]);
         for (; i < 8; i++)
@@ -403,19 +432,20 @@ static void intel_sdvo_debug_write(struct intel_encoder *intel_encoder, u8 cmd,
         DRM_LOG_KMS("\n");
 }
 
-static void intel_sdvo_write_cmd(struct intel_encoder *intel_encoder, u8 cmd,
-                                 void *args, int args_len)
+static bool intel_sdvo_write_cmd(struct intel_sdvo *intel_sdvo, u8 cmd,
+                                 const void *args, int args_len)
 {
         int i;
 
-        intel_sdvo_debug_write(intel_encoder, cmd, args, args_len);
+        intel_sdvo_debug_write(intel_sdvo, cmd, args, args_len);
 
         for (i = 0; i < args_len; i++) {
-                intel_sdvo_write_byte(intel_encoder, SDVO_I2C_ARG_0 - i,
-                                      ((u8*)args)[i]);
+                if (!intel_sdvo_write_byte(intel_sdvo, SDVO_I2C_ARG_0 - i,
+                                           ((u8*)args)[i]))
+                        return false;
         }
 
-        intel_sdvo_write_byte(intel_encoder, SDVO_I2C_OPCODE, cmd);
+        return intel_sdvo_write_byte(intel_sdvo, SDVO_I2C_OPCODE, cmd);
 }
 
 static const char *cmd_status_names[] = {
@@ -428,14 +458,13 @@ static const char *cmd_status_names[] = {
         "Scaling not supported"
 };
 
-static void intel_sdvo_debug_response(struct intel_encoder *intel_encoder,
+static void intel_sdvo_debug_response(struct intel_sdvo *intel_sdvo,
                                       void *response, int response_len,
                                       u8 status)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
         int i;
 
-        DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(sdvo_priv));
+        DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(intel_sdvo));
         for (i = 0; i < response_len; i++)
                 DRM_LOG_KMS("%02X ", ((u8 *)response)[i]);
         for (; i < 8; i++)
@@ -447,8 +476,8 @@ static void intel_sdvo_debug_response(struct intel_encoder *intel_encoder,
         DRM_LOG_KMS("\n");
 }
 
-static u8 intel_sdvo_read_response(struct intel_encoder *intel_encoder,
-                                   void *response, int response_len)
+static bool intel_sdvo_read_response(struct intel_sdvo *intel_sdvo,
+                                     void *response, int response_len)
 {
         int i;
         u8 status;
@@ -457,24 +486,26 @@ static u8 intel_sdvo_read_response(struct intel_encoder *intel_encoder,
         while (retry--) {
                 /* Read the command response */
                 for (i = 0; i < response_len; i++) {
-                        intel_sdvo_read_byte(intel_encoder,
-                                             SDVO_I2C_RETURN_0 + i,
-                                             &((u8 *)response)[i]);
+                        if (!intel_sdvo_read_byte(intel_sdvo,
+                                                  SDVO_I2C_RETURN_0 + i,
+                                                  &((u8 *)response)[i]))
+                                return false;
                 }
 
                 /* read the return status */
-                intel_sdvo_read_byte(intel_encoder, SDVO_I2C_CMD_STATUS,
-                                     &status);
+                if (!intel_sdvo_read_byte(intel_sdvo, SDVO_I2C_CMD_STATUS,
+                                          &status))
+                        return false;
 
-                intel_sdvo_debug_response(intel_encoder, response, response_len,
+                intel_sdvo_debug_response(intel_sdvo, response, response_len,
                                           status);
                 if (status != SDVO_CMD_STATUS_PENDING)
-                        return status;
+                        break;
 
                 mdelay(50);
         }
 
-        return status;
+        return status == SDVO_CMD_STATUS_SUCCESS;
 }
 
 static int intel_sdvo_get_pixel_multiplier(struct drm_display_mode *mode)
@@ -494,37 +525,36 @@ static int intel_sdvo_get_pixel_multiplier(struct drm_display_mode *mode)
  * another I2C transaction after issuing the DDC bus switch, it will be
  * switched to the internal SDVO register.
  */
-static void intel_sdvo_set_control_bus_switch(struct intel_encoder *intel_encoder,
+static void intel_sdvo_set_control_bus_switch(struct intel_sdvo *intel_sdvo,
                                               u8 target)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
         u8 out_buf[2], cmd_buf[2], ret_value[2], ret;
         struct i2c_msg msgs[] = {
                 {
-                        .addr = sdvo_priv->slave_addr >> 1,
+                        .addr = intel_sdvo->slave_addr >> 1,
                         .flags = 0,
                         .len = 2,
                         .buf = out_buf,
                 },
                 /* the following two are to read the response */
                 {
-                        .addr = sdvo_priv->slave_addr >> 1,
+                        .addr = intel_sdvo->slave_addr >> 1,
                         .flags = 0,
                         .len = 1,
                         .buf = cmd_buf,
                 },
                 {
-                        .addr = sdvo_priv->slave_addr >> 1,
+                        .addr = intel_sdvo->slave_addr >> 1,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = ret_value,
                 },
         };
 
-        intel_sdvo_debug_write(intel_encoder, SDVO_CMD_SET_CONTROL_BUS_SWITCH,
+        intel_sdvo_debug_write(intel_sdvo, SDVO_CMD_SET_CONTROL_BUS_SWITCH,
                                         &target, 1);
         /* write the DDC switch command argument */
-        intel_sdvo_write_byte(intel_encoder, SDVO_I2C_ARG_0, target);
+        intel_sdvo_write_byte(intel_sdvo, SDVO_I2C_ARG_0, target);
 
         out_buf[0] = SDVO_I2C_OPCODE;
         out_buf[1] = SDVO_CMD_SET_CONTROL_BUS_SWITCH;
@@ -533,7 +563,7 @@ static void intel_sdvo_set_control_bus_switch(struct intel_encoder *intel_encode
         ret_value[0] = 0;
         ret_value[1] = 0;
 
-        ret = i2c_transfer(intel_encoder->i2c_bus, msgs, 3);
+        ret = i2c_transfer(intel_sdvo->base.i2c_bus, msgs, 3);
         if (ret != 3) {
                 /* failure in I2C transfer */
                 DRM_DEBUG_KMS("I2c transfer returned %d\n", ret);
@@ -547,23 +577,29 @@ static void intel_sdvo_set_control_bus_switch(struct intel_encoder *intel_encode
         return;
 }
 
-static bool intel_sdvo_set_target_input(struct intel_encoder *intel_encoder, bool target_0, bool target_1)
+static bool intel_sdvo_set_value(struct intel_sdvo *intel_sdvo, u8 cmd, const void *data, int len)
 {
-        struct intel_sdvo_set_target_input_args targets = {0};
-        u8 status;
-
-        if (target_0 && target_1)
-                return SDVO_CMD_STATUS_NOTSUPP;
+        if (!intel_sdvo_write_cmd(intel_sdvo, cmd, data, len))
+                return false;
 
-        if (target_1)
-                targets.target_1 = 1;
+        return intel_sdvo_read_response(intel_sdvo, NULL, 0);
+}
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TARGET_INPUT, &targets,
-                             sizeof(targets));
+static bool
+intel_sdvo_get_value(struct intel_sdvo *intel_sdvo, u8 cmd, void *value, int len)
+{
+        if (!intel_sdvo_write_cmd(intel_sdvo, cmd, NULL, 0))
+                return false;
 
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
+        return intel_sdvo_read_response(intel_sdvo, value, len);
+}
 
-        return (status == SDVO_CMD_STATUS_SUCCESS);
+static bool intel_sdvo_set_target_input(struct intel_sdvo *intel_sdvo)
+{
+        struct intel_sdvo_set_target_input_args targets = {0};
+        return intel_sdvo_set_value(intel_sdvo,
+                                    SDVO_CMD_SET_TARGET_INPUT,
+                                    &targets, sizeof(targets));
 }
 
 /**
@@ -572,14 +608,12 @@ static bool intel_sdvo_set_target_input(struct intel_encoder *intel_encoder, boo
  * This function is making an assumption about the layout of the response,
  * which should be checked against the docs.
  */
-static bool intel_sdvo_get_trained_inputs(struct intel_encoder *intel_encoder, bool *input_1, bool *input_2)
+static bool intel_sdvo_get_trained_inputs(struct intel_sdvo *intel_sdvo, bool *input_1, bool *input_2)
 {
         struct intel_sdvo_get_trained_inputs_response response;
-        u8 status;
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0);
-        status = intel_sdvo_read_response(intel_encoder, &response, sizeof(response));
-        if (status != SDVO_CMD_STATUS_SUCCESS)
+        if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_TRAINED_INPUTS,
+                                  &response, sizeof(response)))
                 return false;
 
         *input_1 = response.input0_trained;
@@ -587,21 +621,18 @@ static bool intel_sdvo_get_trained_inputs(struct intel_encoder *intel_encoder, b
         return true;
 }
 
-static bool intel_sdvo_set_active_outputs(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_active_outputs(struct intel_sdvo *intel_sdvo,
                                           u16 outputs)
 {
-        u8 status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs,
-                             sizeof(outputs));
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        return (status == SDVO_CMD_STATUS_SUCCESS);
+        return intel_sdvo_set_value(intel_sdvo,
+                                    SDVO_CMD_SET_ACTIVE_OUTPUTS,
+                                    &outputs, sizeof(outputs));
 }
 
-static bool intel_sdvo_set_encoder_power_state(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_encoder_power_state(struct intel_sdvo *intel_sdvo,
                                                int mode)
 {
-        u8 status, state = SDVO_ENCODER_STATE_ON;
+        u8 state = SDVO_ENCODER_STATE_ON;
 
         switch (mode) {
         case DRM_MODE_DPMS_ON:
@@ -618,88 +649,63 @@ static bool intel_sdvo_set_encoder_power_state(struct intel_encoder *intel_encod
                 break;
         }
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ENCODER_POWER_STATE, &state,
-                             sizeof(state));
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-
-        return (status == SDVO_CMD_STATUS_SUCCESS);
+        return intel_sdvo_set_value(intel_sdvo,
+                                    SDVO_CMD_SET_ENCODER_POWER_STATE, &state, sizeof(state));
 }
 
-static bool intel_sdvo_get_input_pixel_clock_range(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_get_input_pixel_clock_range(struct intel_sdvo *intel_sdvo,
                                                    int *clock_min,
                                                    int *clock_max)
 {
         struct intel_sdvo_pixel_clock_range clocks;
-        u8 status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE,
-                             NULL, 0);
-
-        status = intel_sdvo_read_response(intel_encoder, &clocks, sizeof(clocks));
 
-        if (status != SDVO_CMD_STATUS_SUCCESS)
+        if (!intel_sdvo_get_value(intel_sdvo,
+                                  SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE,
+                                  &clocks, sizeof(clocks)))
                 return false;
 
         /* Convert the values from units of 10 kHz to kHz. */
         *clock_min = clocks.min * 10;
         *clock_max = clocks.max * 10;
-
         return true;
 }
 
-static bool intel_sdvo_set_target_output(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_target_output(struct intel_sdvo *intel_sdvo,
                                          u16 outputs)
 {
-        u8 status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TARGET_OUTPUT, &outputs,
-                             sizeof(outputs));
-
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        return (status == SDVO_CMD_STATUS_SUCCESS);
+        return intel_sdvo_set_value(intel_sdvo,
+                                    SDVO_CMD_SET_TARGET_OUTPUT,
+                                    &outputs, sizeof(outputs));
 }
 
-static bool intel_sdvo_set_timing(struct intel_encoder *intel_encoder, u8 cmd,
+static bool intel_sdvo_set_timing(struct intel_sdvo *intel_sdvo, u8 cmd,
                                   struct intel_sdvo_dtd *dtd)
 {
-        u8 status;
-
-        intel_sdvo_write_cmd(intel_encoder, cmd, &dtd->part1, sizeof(dtd->part1));
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        intel_sdvo_write_cmd(intel_encoder, cmd + 1, &dtd->part2, sizeof(dtd->part2));
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        return true;
+        return intel_sdvo_set_value(intel_sdvo, cmd, &dtd->part1, sizeof(dtd->part1)) &&
+                intel_sdvo_set_value(intel_sdvo, cmd + 1, &dtd->part2, sizeof(dtd->part2));
 }
 
-static bool intel_sdvo_set_input_timing(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_input_timing(struct intel_sdvo *intel_sdvo,
                                          struct intel_sdvo_dtd *dtd)
 {
-        return intel_sdvo_set_timing(intel_encoder,
+        return intel_sdvo_set_timing(intel_sdvo,
                                      SDVO_CMD_SET_INPUT_TIMINGS_PART1, dtd);
 }
 
-static bool intel_sdvo_set_output_timing(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_output_timing(struct intel_sdvo *intel_sdvo,
                                          struct intel_sdvo_dtd *dtd)
 {
-        return intel_sdvo_set_timing(intel_encoder,
+        return intel_sdvo_set_timing(intel_sdvo,
                                      SDVO_CMD_SET_OUTPUT_TIMINGS_PART1, dtd);
 }
 
 static bool
-intel_sdvo_create_preferred_input_timing(struct intel_encoder *intel_encoder,
+intel_sdvo_create_preferred_input_timing(struct intel_sdvo *intel_sdvo,
                                          uint16_t clock,
                                          uint16_t width,
                                          uint16_t height)
 {
         struct intel_sdvo_preferred_input_timing_args args;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        uint8_t status;
 
         memset(&args, 0, sizeof(args));
         args.clock = clock;
@@ -707,59 +713,32 @@ intel_sdvo_create_preferred_input_timing(struct intel_encoder *intel_encoder,
         args.height = height;
         args.interlace = 0;
 
-        if (sdvo_priv->is_lvds &&
-           (sdvo_priv->sdvo_lvds_fixed_mode->hdisplay != width ||
-            sdvo_priv->sdvo_lvds_fixed_mode->vdisplay != height))
+        if (intel_sdvo->is_lvds &&
+           (intel_sdvo->sdvo_lvds_fixed_mode->hdisplay != width ||
+            intel_sdvo->sdvo_lvds_fixed_mode->vdisplay != height))
                 args.scaled = 1;
 
-        intel_sdvo_write_cmd(intel_encoder,
-                             SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING,
-                             &args, sizeof(args));
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        return true;
+        return intel_sdvo_set_value(intel_sdvo,
+                                    SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING,
+                                    &args, sizeof(args));
 }
 
-static bool intel_sdvo_get_preferred_input_timing(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_get_preferred_input_timing(struct intel_sdvo *intel_sdvo,
                                                   struct intel_sdvo_dtd *dtd)
 {
-        bool status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1,
-                             NULL, 0);
-
-        status = intel_sdvo_read_response(intel_encoder, &dtd->part1,
-                                          sizeof(dtd->part1));
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2,
-                             NULL, 0);
-
-        status = intel_sdvo_read_response(intel_encoder, &dtd->part2,
-                                          sizeof(dtd->part2));
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        return false;
+        return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1,
+                                    &dtd->part1, sizeof(dtd->part1)) &&
+                intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2,
+                                     &dtd->part2, sizeof(dtd->part2));
 }
 
-static bool intel_sdvo_set_clock_rate_mult(struct intel_encoder *intel_encoder, u8 val)
+static bool intel_sdvo_set_clock_rate_mult(struct intel_sdvo *intel_sdvo, u8 val)
 {
-        u8 status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1);
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        return true;
+        return intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1);
 }
 
 static void intel_sdvo_get_dtd_from_mode(struct intel_sdvo_dtd *dtd,
-                                         struct drm_display_mode *mode)
+                                         const struct drm_display_mode *mode)
 {
         uint16_t width, height;
         uint16_t h_blank_len, h_sync_len, v_blank_len, v_sync_len;
@@ -808,7 +787,7 @@ static void intel_sdvo_get_dtd_from_mode(struct intel_sdvo_dtd *dtd,
 }
 
 static void intel_sdvo_get_mode_from_dtd(struct drm_display_mode * mode,
-                                         struct intel_sdvo_dtd *dtd)
+                                         const struct intel_sdvo_dtd *dtd)
 {
         mode->hdisplay = dtd->part1.h_active;
         mode->hdisplay += ((dtd->part1.h_high >> 4) & 0x0f) << 8;
@@ -840,45 +819,33 @@ static void intel_sdvo_get_mode_from_dtd(struct drm_display_mode * mode,
                 mode->flags |= DRM_MODE_FLAG_PVSYNC;
 }
 
-static bool intel_sdvo_get_supp_encode(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_get_supp_encode(struct intel_sdvo *intel_sdvo,
                                        struct intel_sdvo_encode *encode)
 {
-        uint8_t status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SUPP_ENCODE, NULL, 0);
-        status = intel_sdvo_read_response(intel_encoder, encode, sizeof(*encode));
-        if (status != SDVO_CMD_STATUS_SUCCESS) { /* non-support means DVI */
-                memset(encode, 0, sizeof(*encode));
-                return false;
-        }
+        if (intel_sdvo_get_value(intel_sdvo,
+                                  SDVO_CMD_GET_SUPP_ENCODE,
+                                  encode, sizeof(*encode)))
+                return true;
 
-        return true;
+        /* non-support means DVI */
+        memset(encode, 0, sizeof(*encode));
+        return false;
 }
 
-static bool intel_sdvo_set_encode(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_encode(struct intel_sdvo *intel_sdvo,
                                   uint8_t mode)
 {
-        uint8_t status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ENCODE, &mode, 1);
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-
-        return (status == SDVO_CMD_STATUS_SUCCESS);
+        return intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_ENCODE, &mode, 1);
 }
 
-static bool intel_sdvo_set_colorimetry(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_colorimetry(struct intel_sdvo *intel_sdvo,
                                        uint8_t mode)
 {
-        uint8_t status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_COLORIMETRY, &mode, 1);
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-
-        return (status == SDVO_CMD_STATUS_SUCCESS);
+        return intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_COLORIMETRY, &mode, 1);
 }
 
 #if 0
-static void intel_sdvo_dump_hdmi_buf(struct intel_encoder *intel_encoder)
+static void intel_sdvo_dump_hdmi_buf(struct intel_sdvo *intel_sdvo)
 {
         int i, j;
         uint8_t set_buf_index[2];
@@ -887,8 +854,7 @@ static void intel_sdvo_dump_hdmi_buf(struct intel_encoder *intel_encoder)
         uint8_t buf[48];
         uint8_t *pos;
 
-        intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_AV_SPLIT, NULL, 0);
-        intel_sdvo_read_response(encoder, &av_split, 1);
+        intel_sdvo_get_value(encoder, SDVO_CMD_GET_HBUF_AV_SPLIT, &av_split, 1);
 
         for (i = 0; i <= av_split; i++) {
                 set_buf_index[0] = i; set_buf_index[1] = 0;
@@ -908,7 +874,7 @@ static void intel_sdvo_dump_hdmi_buf(struct intel_encoder *intel_encoder)
 }
 #endif
 
-static void intel_sdvo_set_hdmi_buf(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_hdmi_buf(struct intel_sdvo *intel_sdvo,
                                     int index,
                                     uint8_t *data, int8_t size, uint8_t tx_rate)
 {
@@ -917,15 +883,18 @@ static void intel_sdvo_set_hdmi_buf(struct intel_encoder *intel_encoder,
     set_buf_index[0] = index;
     set_buf_index[1] = 0;
 
-    intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_INDEX,
-                         set_buf_index, 2);
+    if (!intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_HBUF_INDEX,
+                              set_buf_index, 2))
+            return false;
 
     for (; size > 0; size -= 8) {
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_DATA, data, 8);
+        if (!intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_HBUF_DATA, data, 8))
+                return false;
+
         data += 8;
     }
 
-    intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_TXRATE, &tx_rate, 1);
+    return intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_HBUF_TXRATE, &tx_rate, 1);
 }
 
 static uint8_t intel_sdvo_calc_hbuf_csum(uint8_t *data, uint8_t size)
@@ -1000,7 +969,7 @@ struct dip_infoframe {
         } __attribute__ ((packed)) u;
 } __attribute__((packed));
 
-static void intel_sdvo_set_avi_infoframe(struct intel_encoder *intel_encoder,
+static bool intel_sdvo_set_avi_infoframe(struct intel_sdvo *intel_sdvo,
                                          struct drm_display_mode * mode)
 {
         struct dip_infoframe avi_if = {
@@ -1011,133 +980,107 @@ static void intel_sdvo_set_avi_infoframe(struct intel_encoder *intel_encoder,
 
         avi_if.checksum = intel_sdvo_calc_hbuf_csum((uint8_t *)&avi_if,
                                                     4 + avi_if.len);
-        intel_sdvo_set_hdmi_buf(intel_encoder, 1, (uint8_t *)&avi_if,
-                                4 + avi_if.len,
-                                SDVO_HBUF_TX_VSYNC);
+        return intel_sdvo_set_hdmi_buf(intel_sdvo, 1, (uint8_t *)&avi_if,
+                                       4 + avi_if.len,
+                                       SDVO_HBUF_TX_VSYNC);
 }
 
-static void intel_sdvo_set_tv_format(struct intel_encoder *intel_encoder)
+static bool intel_sdvo_set_tv_format(struct intel_sdvo *intel_sdvo)
 {
-
         struct intel_sdvo_tv_format format;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        uint32_t format_map, i;
-        uint8_t status;
+        uint32_t format_map;
 
-        for (i = 0; i < TV_FORMAT_NUM; i++)
-                if (tv_format_names[i] == sdvo_priv->tv_format_name)
-                        break;
-
-        format_map = 1 << i;
+        format_map = 1 << intel_sdvo->tv_format_index;
         memset(&format, 0, sizeof(format));
-        memcpy(&format, &format_map, sizeof(format_map) > sizeof(format) ?
-                        sizeof(format) : sizeof(format_map));
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TV_FORMAT, &format,
-                             sizeof(format));
+        memcpy(&format, &format_map, min(sizeof(format), sizeof(format_map)));
 
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                DRM_DEBUG_KMS("%s: Failed to set TV format\n",
-                          SDVO_NAME(sdvo_priv));
+        BUILD_BUG_ON(sizeof(format) != 6);
+        return intel_sdvo_set_value(intel_sdvo,
+                                    SDVO_CMD_SET_TV_FORMAT,
+                                    &format, sizeof(format));
 }
 
-static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
-                                  struct drm_display_mode *mode,
-                                  struct drm_display_mode *adjusted_mode)
+static bool
+intel_sdvo_set_output_timings_from_mode(struct intel_sdvo *intel_sdvo,
+                                        struct drm_display_mode *mode)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *dev_priv = intel_encoder->dev_priv;
+        struct intel_sdvo_dtd output_dtd;
 
-        if (dev_priv->is_tv) {
-                struct intel_sdvo_dtd output_dtd;
-                bool success;
+        if (!intel_sdvo_set_target_output(intel_sdvo,
+                                          intel_sdvo->attached_output))
+                return false;
 
-                /* We need to construct preferred input timings based on our
-                 * output timings.  To do that, we have to set the output
-                 * timings, even though this isn't really the right place in
-                 * the sequence to do it. Oh well.
-                 */
+        intel_sdvo_get_dtd_from_mode(&output_dtd, mode);
+        if (!intel_sdvo_set_output_timing(intel_sdvo, &output_dtd))
+                return false;
 
+        return true;
+}
 
-                /* Set output timings */
-                intel_sdvo_get_dtd_from_mode(&output_dtd, mode);
-                intel_sdvo_set_target_output(intel_encoder,
-                                             dev_priv->attached_output);
-                intel_sdvo_set_output_timing(intel_encoder, &output_dtd);
+static bool
+intel_sdvo_set_input_timings_for_mode(struct intel_sdvo *intel_sdvo,
+                                        struct drm_display_mode *mode,
+                                        struct drm_display_mode *adjusted_mode)
+{
+        struct intel_sdvo_dtd input_dtd;
 
-                /* Set the input timing to the screen. Assume always input 0. */
-                intel_sdvo_set_target_input(intel_encoder, true, false);
+        /* Reset the input timing to the screen. Assume always input 0. */
+        if (!intel_sdvo_set_target_input(intel_sdvo))
+                return false;
 
+        if (!intel_sdvo_create_preferred_input_timing(intel_sdvo,
+                                                      mode->clock / 10,
+                                                      mode->hdisplay,
+                                                      mode->vdisplay))
+                return false;
 
-                success = intel_sdvo_create_preferred_input_timing(intel_encoder,
-                                                                   mode->clock / 10,
-                                                                   mode->hdisplay,
-                                                                   mode->vdisplay);
-                if (success) {
-                        struct intel_sdvo_dtd input_dtd;
+        if (!intel_sdvo_get_preferred_input_timing(intel_sdvo,
+                                                   &input_dtd))
+                return false;
 
-                        intel_sdvo_get_preferred_input_timing(intel_encoder,
-                                                             &input_dtd);
-                        intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
-                        dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags;
+        intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
+        intel_sdvo->sdvo_flags = input_dtd.part2.sdvo_flags;
 
-                        drm_mode_set_crtcinfo(adjusted_mode, 0);
+        drm_mode_set_crtcinfo(adjusted_mode, 0);
+        mode->clock = adjusted_mode->clock;
+        return true;
+}
 
-                        mode->clock = adjusted_mode->clock;
+static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
+                                  struct drm_display_mode *mode,
+                                  struct drm_display_mode *adjusted_mode)
+{
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
 
-                        adjusted_mode->clock *=
-                                intel_sdvo_get_pixel_multiplier(mode);
-                } else {
+        /* We need to construct preferred input timings based on our
+         * output timings.  To do that, we have to set the output
+         * timings, even though this isn't really the right place in
+         * the sequence to do it. Oh well.
+         */
+        if (intel_sdvo->is_tv) {
+                if (!intel_sdvo_set_output_timings_from_mode(intel_sdvo, mode))
                         return false;
-                }
-        } else if (dev_priv->is_lvds) {
-                struct intel_sdvo_dtd output_dtd;
-                bool success;
-
-                drm_mode_set_crtcinfo(dev_priv->sdvo_lvds_fixed_mode, 0);
-                /* Set output timings */
-                intel_sdvo_get_dtd_from_mode(&output_dtd,
-                                dev_priv->sdvo_lvds_fixed_mode);
-
-                intel_sdvo_set_target_output(intel_encoder,
-                                             dev_priv->attached_output);
-                intel_sdvo_set_output_timing(intel_encoder, &output_dtd);
-
-                /* Set the input timing to the screen. Assume always input 0. */
-                intel_sdvo_set_target_input(intel_encoder, true, false);
-
-
-                success = intel_sdvo_create_preferred_input_timing(
-                                intel_encoder,
-                                mode->clock / 10,
-                                mode->hdisplay,
-                                mode->vdisplay);
-
-                if (success) {
-                        struct intel_sdvo_dtd input_dtd;
 
-                        intel_sdvo_get_preferred_input_timing(intel_encoder,
-                                                             &input_dtd);
-                        intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
-                        dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags;
+                (void) intel_sdvo_set_input_timings_for_mode(intel_sdvo,
+                                                             mode,
+                                                             adjusted_mode);
+        } else if (intel_sdvo->is_lvds) {
+                drm_mode_set_crtcinfo(intel_sdvo->sdvo_lvds_fixed_mode, 0);
 
-                        drm_mode_set_crtcinfo(adjusted_mode, 0);
-
-                        mode->clock = adjusted_mode->clock;
-
-                        adjusted_mode->clock *=
-                                intel_sdvo_get_pixel_multiplier(mode);
-                } else {
+                if (!intel_sdvo_set_output_timings_from_mode(intel_sdvo,
+                                                            intel_sdvo->sdvo_lvds_fixed_mode))
                         return false;
-                }
 
-        } else {
-                /* Make the CRTC code factor in the SDVO pixel multiplier.  The
-                 * SDVO device will be told of the multiplier during mode_set.
-                 */
-                adjusted_mode->clock *= intel_sdvo_get_pixel_multiplier(mode);
+                (void) intel_sdvo_set_input_timings_for_mode(intel_sdvo,
+                                                             mode,
+                                                             adjusted_mode);
         }
+
+        /* Make the CRTC code factor in the SDVO pixel multiplier.  The
+         * SDVO device will be told of the multiplier during mode_set.
+         */
+        adjusted_mode->clock *= intel_sdvo_get_pixel_multiplier(mode);
+
         return true;
 }
 
@@ -1149,13 +1092,11 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_crtc *crtc = encoder->crtc;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
         u32 sdvox = 0;
-        int sdvo_pixel_multiply;
+        int sdvo_pixel_multiply, rate;
         struct intel_sdvo_in_out_map in_out;
         struct intel_sdvo_dtd input_dtd;
-        u8 status;
 
         if (!mode)
                 return;
@@ -1166,41 +1107,46 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
          * channel on the motherboard.  In a two-input device, the first input
          * will be SDVOB and the second SDVOC.
          */
-        in_out.in0 = sdvo_priv->attached_output;
+        in_out.in0 = intel_sdvo->attached_output;
         in_out.in1 = 0;
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_IN_OUT_MAP,
+        intel_sdvo_set_value(intel_sdvo,
+                             SDVO_CMD_SET_IN_OUT_MAP,
                              &in_out, sizeof(in_out));
-        status = intel_sdvo_read_response(intel_encoder, NULL, 0);
 
-        if (sdvo_priv->is_hdmi) {
-                intel_sdvo_set_avi_infoframe(intel_encoder, mode);
+        if (intel_sdvo->is_hdmi) {
+                if (!intel_sdvo_set_avi_infoframe(intel_sdvo, mode))
+                        return;
+
                 sdvox |= SDVO_AUDIO_ENABLE;
         }
 
         /* We have tried to get input timing in mode_fixup, and filled into
            adjusted_mode */
-        if (sdvo_priv->is_tv || sdvo_priv->is_lvds) {
-                intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
-                input_dtd.part2.sdvo_flags = sdvo_priv->sdvo_flags;
-        } else
-                intel_sdvo_get_dtd_from_mode(&input_dtd, mode);
+        intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
+        if (intel_sdvo->is_tv || intel_sdvo->is_lvds)
+                input_dtd.part2.sdvo_flags = intel_sdvo->sdvo_flags;
 
         /* If it's a TV, we already set the output timing in mode_fixup.
          * Otherwise, the output timing is equal to the input timing.
          */
-        if (!sdvo_priv->is_tv && !sdvo_priv->is_lvds) {
+        if (!intel_sdvo->is_tv && !intel_sdvo->is_lvds) {
                 /* Set the output timing to the screen */
-                intel_sdvo_set_target_output(intel_encoder,
-                                             sdvo_priv->attached_output);
-                intel_sdvo_set_output_timing(intel_encoder, &input_dtd);
+                if (!intel_sdvo_set_target_output(intel_sdvo,
+                                                  intel_sdvo->attached_output))
+                        return;
+
+                (void) intel_sdvo_set_output_timing(intel_sdvo, &input_dtd);
         }
 
         /* Set the input timing to the screen. Assume always input 0. */
-        intel_sdvo_set_target_input(intel_encoder, true, false);
+        if (!intel_sdvo_set_target_input(intel_sdvo))
+                return;
 
-        if (sdvo_priv->is_tv)
-                intel_sdvo_set_tv_format(intel_encoder);
+        if (intel_sdvo->is_tv) {
+                if (!intel_sdvo_set_tv_format(intel_sdvo))
+                        return;
+        }
 
         /* We would like to use intel_sdvo_create_preferred_input_timing() to
          * provide the device with a timing it can support, if it supports that
@@ -1217,23 +1163,17 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
                 intel_sdvo_set_input_timing(encoder, &input_dtd);
         }
 #else
-        intel_sdvo_set_input_timing(intel_encoder, &input_dtd);
+        (void) intel_sdvo_set_input_timing(intel_sdvo, &input_dtd);
 #endif
 
-        switch (intel_sdvo_get_pixel_multiplier(mode)) {
-        case 1:
-                intel_sdvo_set_clock_rate_mult(intel_encoder,
-                                               SDVO_CLOCK_RATE_MULT_1X);
-                break;
-        case 2:
-                intel_sdvo_set_clock_rate_mult(intel_encoder,
-                                               SDVO_CLOCK_RATE_MULT_2X);
-                break;
-        case 4:
-                intel_sdvo_set_clock_rate_mult(intel_encoder,
-                                               SDVO_CLOCK_RATE_MULT_4X);
-                break;
+        sdvo_pixel_multiply = intel_sdvo_get_pixel_multiplier(mode);
+        switch (sdvo_pixel_multiply) {
+        case 1: rate = SDVO_CLOCK_RATE_MULT_1X; break;
+        case 2: rate = SDVO_CLOCK_RATE_MULT_2X; break;
+        case 4: rate = SDVO_CLOCK_RATE_MULT_4X; break;
         }
+        if (!intel_sdvo_set_clock_rate_mult(intel_sdvo, rate))
+                return;
 
         /* Set the SDVO control regs. */
         if (IS_I965G(dev)) {
@@ -1243,8 +1183,8 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
                 if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
                         sdvox |= SDVO_HSYNC_ACTIVE_HIGH;
         } else {
-                sdvox |= I915_READ(sdvo_priv->sdvo_reg);
-                switch (sdvo_priv->sdvo_reg) {
+                sdvox |= I915_READ(intel_sdvo->sdvo_reg);
+                switch (intel_sdvo->sdvo_reg) {
                 case SDVOB:
                         sdvox &= SDVOB_PRESERVE_MASK;
                         break;
@@ -1257,7 +1197,6 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
         if (intel_crtc->pipe == 1)
                 sdvox |= SDVO_PIPE_B_SELECT;
 
-        sdvo_pixel_multiply = intel_sdvo_get_pixel_multiplier(mode);
         if (IS_I965G(dev)) {
                 /* done in crtc_mode_set as the dpll_md reg must be written early */
         } else if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev)) {
@@ -1266,28 +1205,28 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
                 sdvox |= (sdvo_pixel_multiply - 1) << SDVO_PORT_MULTIPLY_SHIFT;
         }
 
-        if (sdvo_priv->sdvo_flags & SDVO_NEED_TO_STALL)
+        if (intel_sdvo->sdvo_flags & SDVO_NEED_TO_STALL)
                 sdvox |= SDVO_STALL_SELECT;
-        intel_sdvo_write_sdvox(intel_encoder, sdvox);
+        intel_sdvo_write_sdvox(intel_sdvo, sdvox);
 }
 
 static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
+        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
         u32 temp;
 
         if (mode != DRM_MODE_DPMS_ON) {
-                intel_sdvo_set_active_outputs(intel_encoder, 0);
+                intel_sdvo_set_active_outputs(intel_sdvo, 0);
                 if (0)
-                        intel_sdvo_set_encoder_power_state(intel_encoder, mode);
+                        intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
 
                 if (mode == DRM_MODE_DPMS_OFF) {
-                        temp = I915_READ(sdvo_priv->sdvo_reg);
+                        temp = I915_READ(intel_sdvo->sdvo_reg);
                         if ((temp & SDVO_ENABLE) != 0) {
-                                intel_sdvo_write_sdvox(intel_encoder, temp & ~SDVO_ENABLE);
+                                intel_sdvo_write_sdvox(intel_sdvo, temp & ~SDVO_ENABLE);
                         }
                 }
         } else {
@@ -1295,28 +1234,25 @@ static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
                 int i;
                 u8 status;
 
-                temp = I915_READ(sdvo_priv->sdvo_reg);
+                temp = I915_READ(intel_sdvo->sdvo_reg);
                 if ((temp & SDVO_ENABLE) == 0)
-                        intel_sdvo_write_sdvox(intel_encoder, temp | SDVO_ENABLE);
+                        intel_sdvo_write_sdvox(intel_sdvo, temp | SDVO_ENABLE);
                 for (i = 0; i < 2; i++)
-                  intel_wait_for_vblank(dev);
-
-                status = intel_sdvo_get_trained_inputs(intel_encoder, &input1,
-                                                       &input2);
-
+                        intel_wait_for_vblank(dev, intel_crtc->pipe);
 
+                status = intel_sdvo_get_trained_inputs(intel_sdvo, &input1, &input2);
                 /* Warn if the device reported failure to sync.
                  * A lot of SDVO devices fail to notify of sync, but it's
                  * a given it the status is a success, we succeeded.
                  */
                 if (status == SDVO_CMD_STATUS_SUCCESS && !input1) {
                         DRM_DEBUG_KMS("First %s output reported failure to "
-                                        "sync\n", SDVO_NAME(sdvo_priv));
+                                        "sync\n", SDVO_NAME(intel_sdvo));
                 }
 
                 if (0)
-                        intel_sdvo_set_encoder_power_state(intel_encoder, mode);
-                intel_sdvo_set_active_outputs(intel_encoder, sdvo_priv->attached_output);
+                        intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
+                intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
         }
         return;
 }
@@ -1325,42 +1261,31 @@ static int intel_sdvo_mode_valid(struct drm_connector *connector,
                                  struct drm_display_mode *mode)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
 
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                 return MODE_NO_DBLESCAN;
 
-        if (sdvo_priv->pixel_clock_min > mode->clock)
+        if (intel_sdvo->pixel_clock_min > mode->clock)
                 return MODE_CLOCK_LOW;
 
-        if (sdvo_priv->pixel_clock_max < mode->clock)
+        if (intel_sdvo->pixel_clock_max < mode->clock)
                 return MODE_CLOCK_HIGH;
 
-        if (sdvo_priv->is_lvds == true) {
-                if (sdvo_priv->sdvo_lvds_fixed_mode == NULL)
-                        return MODE_PANEL;
-
-                if (mode->hdisplay > sdvo_priv->sdvo_lvds_fixed_mode->hdisplay)
+        if (intel_sdvo->is_lvds) {
+                if (mode->hdisplay > intel_sdvo->sdvo_lvds_fixed_mode->hdisplay)
                         return MODE_PANEL;
 
-                if (mode->vdisplay > sdvo_priv->sdvo_lvds_fixed_mode->vdisplay)
+                if (mode->vdisplay > intel_sdvo->sdvo_lvds_fixed_mode->vdisplay)
                         return MODE_PANEL;
         }
 
         return MODE_OK;
 }
 
-static bool intel_sdvo_get_capabilities(struct intel_encoder *intel_encoder, struct intel_sdvo_caps *caps)
+static bool intel_sdvo_get_capabilities(struct intel_sdvo *intel_sdvo, struct intel_sdvo_caps *caps)
 {
-        u8 status;
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0);
-        status = intel_sdvo_read_response(intel_encoder, caps, sizeof(*caps));
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-
-        return true;
+        return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_DEVICE_CAPS, caps, sizeof(*caps));
 }
 
 /* No use! */
@@ -1368,12 +1293,12 @@ static bool intel_sdvo_get_capabilities(struct intel_encoder *intel_encoder, str
 struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB)
 {
         struct drm_connector *connector = NULL;
-        struct intel_encoder *iout = NULL;
-        struct intel_sdvo_priv *sdvo;
+        struct intel_sdvo *iout = NULL;
+        struct intel_sdvo *sdvo;
 
         /* find the sdvo connector */
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
-                iout = to_intel_encoder(connector);
+                iout = to_intel_sdvo(connector);
 
                 if (iout->type != INTEL_OUTPUT_SDVO)
                         continue;
@@ -1395,75 +1320,69 @@ int intel_sdvo_supports_hotplug(struct drm_connector *connector)
 {
         u8 response[2];
         u8 status;
-        struct intel_encoder *intel_encoder;
+        struct intel_sdvo *intel_sdvo;
         DRM_DEBUG_KMS("\n");
 
         if (!connector)
                 return 0;
 
-        intel_encoder = to_intel_encoder(connector);
-
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
-        status = intel_sdvo_read_response(intel_encoder, &response, 2);
+        intel_sdvo = to_intel_sdvo(connector);
 
-        if (response[0] !=0)
-                return 1;
-
-        return 0;
+        return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
+                                    &response, 2) && response[0];
 }
 
 void intel_sdvo_set_hotplug(struct drm_connector *connector, int on)
 {
         u8 response[2];
         u8 status;
-        struct intel_encoder *intel_encoder = to_intel_encoder(connector);
+        struct intel_sdvo *intel_sdvo = to_intel_sdvo(connector);
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
-        intel_sdvo_read_response(intel_encoder, &response, 2);
+        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
+        intel_sdvo_read_response(intel_sdvo, &response, 2);
 
         if (on) {
-                intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
-                status = intel_sdvo_read_response(intel_encoder, &response, 2);
+                intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
+                status = intel_sdvo_read_response(intel_sdvo, &response, 2);
 
-                intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
+                intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
         } else {
                 response[0] = 0;
                 response[1] = 0;
-                intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
+                intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
         }
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
-        intel_sdvo_read_response(intel_encoder, &response, 2);
+        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
+        intel_sdvo_read_response(intel_sdvo, &response, 2);
 }
 #endif
 
 static bool
-intel_sdvo_multifunc_encoder(struct intel_encoder *intel_encoder)
+intel_sdvo_multifunc_encoder(struct intel_sdvo *intel_sdvo)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
         int caps = 0;
 
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_TMDS1))
                 caps++;
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_RGB0 | SDVO_OUTPUT_RGB1))
                 caps++;
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_SVID0 | SDVO_OUTPUT_SVID1))
                 caps++;
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_CVBS0 | SDVO_OUTPUT_CVBS1))
                 caps++;
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_YPRPB0 | SDVO_OUTPUT_YPRPB1))
                 caps++;
 
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_SCART0 | SDVO_OUTPUT_SCART1))
                 caps++;
 
-        if (sdvo_priv->caps.output_flags &
+        if (intel_sdvo->caps.output_flags &
                 (SDVO_OUTPUT_LVDS0 | SDVO_OUTPUT_LVDS1))
                 caps++;
 
@@ -1475,11 +1394,11 @@ intel_find_analog_connector(struct drm_device *dev)
 {
         struct drm_connector *connector;
         struct drm_encoder *encoder;
-        struct intel_encoder *intel_encoder;
+        struct intel_sdvo *intel_sdvo;
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-                intel_encoder = enc_to_intel_encoder(encoder);
-                if (intel_encoder->type == INTEL_OUTPUT_ANALOG) {
+                intel_sdvo = enc_to_intel_sdvo(encoder);
+                if (intel_sdvo->base.type == INTEL_OUTPUT_ANALOG) {
                         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                                 if (encoder == intel_attached_encoder(connector))
                                         return connector;
@@ -1493,12 +1412,12 @@ static int
 intel_analog_is_connected(struct drm_device *dev)
 {
         struct drm_connector *analog_connector;
-        analog_connector = intel_find_analog_connector(dev);
 
+        analog_connector = intel_find_analog_connector(dev);
         if (!analog_connector)
                 return false;
 
-        if (analog_connector->funcs->detect(analog_connector) ==
+        if (analog_connector->funcs->detect(analog_connector, false) ==
                         connector_status_disconnected)
                 return false;
 
@@ -1509,54 +1428,52 @@ enum drm_connector_status
 intel_sdvo_hdmi_sink_detect(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_connector = intel_connector->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
+        struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
         enum drm_connector_status status = connector_status_connected;
         struct edid *edid = NULL;
 
-        edid = drm_get_edid(connector, intel_encoder->ddc_bus);
+        edid = drm_get_edid(connector, intel_sdvo->base.ddc_bus);
 
         /* This is only applied to SDVO cards with multiple outputs */
-        if (edid == NULL && intel_sdvo_multifunc_encoder(intel_encoder)) {
+        if (edid == NULL && intel_sdvo_multifunc_encoder(intel_sdvo)) {
                 uint8_t saved_ddc, temp_ddc;
-                saved_ddc = sdvo_priv->ddc_bus;
-                temp_ddc = sdvo_priv->ddc_bus >> 1;
+                saved_ddc = intel_sdvo->ddc_bus;
+                temp_ddc = intel_sdvo->ddc_bus >> 1;
                 /*
                  * Don't use the 1 as the argument of DDC bus switch to get
                  * the EDID. It is used for SDVO SPD ROM.
                  */
                 while(temp_ddc > 1) {
-                        sdvo_priv->ddc_bus = temp_ddc;
-                        edid = drm_get_edid(connector, intel_encoder->ddc_bus);
+                        intel_sdvo->ddc_bus = temp_ddc;
+                        edid = drm_get_edid(connector, intel_sdvo->base.ddc_bus);
                         if (edid) {
                                 /*
                                  * When we can get the EDID, maybe it is the
                                  * correct DDC bus. Update it.
                                  */
-                                sdvo_priv->ddc_bus = temp_ddc;
+                                intel_sdvo->ddc_bus = temp_ddc;
                                 break;
                         }
                         temp_ddc >>= 1;
                 }
                 if (edid == NULL)
-                        sdvo_priv->ddc_bus = saved_ddc;
+                        intel_sdvo->ddc_bus = saved_ddc;
         }
         /* when there is no edid and no monitor is connected with VGA
          * port, try to use the CRT ddc to read the EDID for DVI-connector
          */
-        if (edid == NULL && sdvo_priv->analog_ddc_bus &&
+        if (edid == NULL && intel_sdvo->analog_ddc_bus &&
             !intel_analog_is_connected(connector->dev))
-                edid = drm_get_edid(connector, sdvo_priv->analog_ddc_bus);
+                edid = drm_get_edid(connector, intel_sdvo->analog_ddc_bus);
 
         if (edid != NULL) {
                 bool is_digital = !!(edid->input & DRM_EDID_INPUT_DIGITAL);
-                bool need_digital = !!(sdvo_connector->output_flag & SDVO_TMDS_MASK);
+                bool need_digital = !!(intel_sdvo_connector->output_flag & SDVO_TMDS_MASK);
 
                 /* DDC bus is shared, match EDID to connector type */
                 if (is_digital && need_digital)
-                        sdvo_priv->is_hdmi = drm_detect_hdmi_monitor(edid);
+                        intel_sdvo->is_hdmi = drm_detect_hdmi_monitor(edid);
                 else if (is_digital != need_digital)
                         status = connector_status_disconnected;
 
@@ -1569,36 +1486,33 @@ intel_sdvo_hdmi_sink_detect(struct drm_connector *connector)
         return status;
 }
 
-static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connector)
+static enum drm_connector_status
+intel_sdvo_detect(struct drm_connector *connector, bool force)
 {
         uint16_t response;
-        u8 status;
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        struct intel_sdvo_connector *sdvo_connector = intel_connector->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
+        struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
         enum drm_connector_status ret;
 
-        intel_sdvo_write_cmd(intel_encoder,
-                             SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0);
-        if (sdvo_priv->is_tv) {
+        if (!intel_sdvo_write_cmd(intel_sdvo,
+                             SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0))
+                return connector_status_unknown;
+        if (intel_sdvo->is_tv) {
                 /* add 30ms delay when the output type is SDVO-TV */
                 mdelay(30);
         }
-        status = intel_sdvo_read_response(intel_encoder, &response, 2);
+        if (!intel_sdvo_read_response(intel_sdvo, &response, 2))
+                return connector_status_unknown;
 
         DRM_DEBUG_KMS("SDVO response %d %d\n", response & 0xff, response >> 8);
 
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return connector_status_unknown;
-
         if (response == 0)
                 return connector_status_disconnected;
 
-        sdvo_priv->attached_output = response;
+        intel_sdvo->attached_output = response;
 
-        if ((sdvo_connector->output_flag & response) == 0)
+        if ((intel_sdvo_connector->output_flag & response) == 0)
                 ret = connector_status_disconnected;
         else if (response & SDVO_TMDS_MASK)
                 ret = intel_sdvo_hdmi_sink_detect(connector);
@@ -1607,16 +1521,16 @@ static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connect
 
         /* May update encoder flag for like clock for SDVO TV, etc.*/
         if (ret == connector_status_connected) {
-                sdvo_priv->is_tv = false;
-                sdvo_priv->is_lvds = false;
-                intel_encoder->needs_tv_clock = false;
+                intel_sdvo->is_tv = false;
+                intel_sdvo->is_lvds = false;
+                intel_sdvo->base.needs_tv_clock = false;
 
                 if (response & SDVO_TV_MASK) {
-                        sdvo_priv->is_tv = true;
-                        intel_encoder->needs_tv_clock = true;
+                        intel_sdvo->is_tv = true;
+                        intel_sdvo->base.needs_tv_clock = true;
                 }
                 if (response & SDVO_LVDS_MASK)
-                        sdvo_priv->is_lvds = true;
+                        intel_sdvo->is_lvds = intel_sdvo->sdvo_lvds_fixed_mode != NULL;
         }
 
         return ret;
@@ -1625,12 +1539,11 @@ static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connect
 static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
         int num_modes;
 
         /* set the bus switch and get the modes */
-        num_modes = intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
+        num_modes = intel_ddc_get_modes(connector, intel_sdvo->base.ddc_bus);
 
         /*
          * Mac mini hack.  On this device, the DVI-I connector shares one DDC
@@ -1639,11 +1552,11 @@ static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
          * which case we'll look there for the digital DDC data.
          */
         if (num_modes == 0 &&
-            sdvo_priv->analog_ddc_bus &&
+            intel_sdvo->analog_ddc_bus &&
             !intel_analog_is_connected(connector->dev)) {
                 /* Switch to the analog ddc bus and try that
                  */
-                (void) intel_ddc_get_modes(connector, sdvo_priv->analog_ddc_bus);
+                (void) intel_ddc_get_modes(connector, intel_sdvo->analog_ddc_bus);
         }
 }
 
@@ -1715,52 +1628,43 @@ struct drm_display_mode sdvo_tv_modes[] = {
 static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
         struct intel_sdvo_sdtv_resolution_request tv_res;
         uint32_t reply = 0, format_map = 0;
         int i;
-        uint8_t status;
-
 
         /* Read the list of supported input resolutions for the selected TV
          * format.
          */
-        for (i = 0; i < TV_FORMAT_NUM; i++)
-                if (tv_format_names[i] ==  sdvo_priv->tv_format_name)
-                        break;
-
-        format_map = (1 << i);
+        format_map = 1 << intel_sdvo->tv_format_index;
         memcpy(&tv_res, &format_map,
-               sizeof(struct intel_sdvo_sdtv_resolution_request) >
-               sizeof(format_map) ? sizeof(format_map) :
-               sizeof(struct intel_sdvo_sdtv_resolution_request));
+               min(sizeof(format_map), sizeof(struct intel_sdvo_sdtv_resolution_request)));
 
-        intel_sdvo_set_target_output(intel_encoder, sdvo_priv->attached_output);
+        if (!intel_sdvo_set_target_output(intel_sdvo, intel_sdvo->attached_output))
+                return;
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SDTV_RESOLUTION_SUPPORT,
-                             &tv_res, sizeof(tv_res));
-        status = intel_sdvo_read_response(intel_encoder, &reply, 3);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
+        BUILD_BUG_ON(sizeof(tv_res) != 3);
+        if (!intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_SDTV_RESOLUTION_SUPPORT,
+                                  &tv_res, sizeof(tv_res)))
+                return;
+        if (!intel_sdvo_read_response(intel_sdvo, &reply, 3))
                 return;
 
         for (i = 0; i < ARRAY_SIZE(sdvo_tv_modes); i++)
                 if (reply & (1 << i)) {
                         struct drm_display_mode *nmode;
                         nmode = drm_mode_duplicate(connector->dev,
-                                        &sdvo_tv_modes[i]);
+                                                   &sdvo_tv_modes[i]);
                         if (nmode)
                                 drm_mode_probed_add(connector, nmode);
                 }
-
 }
 
 static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
         struct drm_i915_private *dev_priv = connector->dev->dev_private;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
         struct drm_display_mode *newmode;
 
         /*
@@ -1768,7 +1672,7 @@ static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
          * Assume that the preferred modes are
          * arranged in priority order.
          */
-        intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
+        intel_ddc_get_modes(connector, intel_sdvo->base.ddc_bus);
         if (list_empty(&connector->probed_modes) == false)
                 goto end;
 
@@ -1787,8 +1691,9 @@ static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
 end:
         list_for_each_entry(newmode, &connector->probed_modes, head) {
                 if (newmode->type & DRM_MODE_TYPE_PREFERRED) {
-                        sdvo_priv->sdvo_lvds_fixed_mode =
+                        intel_sdvo->sdvo_lvds_fixed_mode =
                                 drm_mode_duplicate(connector->dev, newmode);
+                        intel_sdvo->is_lvds = true;
                         break;
                 }
         }
@@ -1797,66 +1702,67 @@ end:
 
 static int intel_sdvo_get_modes(struct drm_connector *connector)
 {
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_connector = intel_connector->dev_priv;
+        struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
 
-        if (IS_TV(sdvo_connector))
+        if (IS_TV(intel_sdvo_connector))
                 intel_sdvo_get_tv_modes(connector);
-        else if (IS_LVDS(sdvo_connector))
+        else if (IS_LVDS(intel_sdvo_connector))
                 intel_sdvo_get_lvds_modes(connector);
         else
                 intel_sdvo_get_ddc_modes(connector);
 
-        if (list_empty(&connector->probed_modes))
-                return 0;
-        return 1;
+        return !list_empty(&connector->probed_modes);
 }
 
-static
-void intel_sdvo_destroy_enhance_property(struct drm_connector *connector)
+static void
+intel_sdvo_destroy_enhance_property(struct drm_connector *connector)
 {
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_priv = intel_connector->dev_priv;
+        struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
         struct drm_device *dev = connector->dev;
 
-        if (IS_TV(sdvo_priv)) {
-                if (sdvo_priv->left_property)
-                        drm_property_destroy(dev, sdvo_priv->left_property);
-                if (sdvo_priv->right_property)
-                        drm_property_destroy(dev, sdvo_priv->right_property);
-                if (sdvo_priv->top_property)
-                        drm_property_destroy(dev, sdvo_priv->top_property);
-                if (sdvo_priv->bottom_property)
-                        drm_property_destroy(dev, sdvo_priv->bottom_property);
-                if (sdvo_priv->hpos_property)
-                        drm_property_destroy(dev, sdvo_priv->hpos_property);
-                if (sdvo_priv->vpos_property)
-                        drm_property_destroy(dev, sdvo_priv->vpos_property);
-                if (sdvo_priv->saturation_property)
-                        drm_property_destroy(dev,
-                                        sdvo_priv->saturation_property);
-                if (sdvo_priv->contrast_property)
-                        drm_property_destroy(dev,
-                                        sdvo_priv->contrast_property);
-                if (sdvo_priv->hue_property)
-                        drm_property_destroy(dev, sdvo_priv->hue_property);
-        }
-        if (IS_TV(sdvo_priv) || IS_LVDS(sdvo_priv)) {
-                if (sdvo_priv->brightness_property)
-                        drm_property_destroy(dev,
-                                        sdvo_priv->brightness_property);
-        }
-        return;
+        if (intel_sdvo_connector->left)
+                drm_property_destroy(dev, intel_sdvo_connector->left);
+        if (intel_sdvo_connector->right)
+                drm_property_destroy(dev, intel_sdvo_connector->right);
+        if (intel_sdvo_connector->top)
+                drm_property_destroy(dev, intel_sdvo_connector->top);
+        if (intel_sdvo_connector->bottom)
+                drm_property_destroy(dev, intel_sdvo_connector->bottom);
+        if (intel_sdvo_connector->hpos)
+                drm_property_destroy(dev, intel_sdvo_connector->hpos);
+        if (intel_sdvo_connector->vpos)
+                drm_property_destroy(dev, intel_sdvo_connector->vpos);
+        if (intel_sdvo_connector->saturation)
+                drm_property_destroy(dev, intel_sdvo_connector->saturation);
+        if (intel_sdvo_connector->contrast)
+                drm_property_destroy(dev, intel_sdvo_connector->contrast);
+        if (intel_sdvo_connector->hue)
+                drm_property_destroy(dev, intel_sdvo_connector->hue);
+        if (intel_sdvo_connector->sharpness)
+                drm_property_destroy(dev, intel_sdvo_connector->sharpness);
+        if (intel_sdvo_connector->flicker_filter)
+                drm_property_destroy(dev, intel_sdvo_connector->flicker_filter);
+        if (intel_sdvo_connector->flicker_filter_2d)
+                drm_property_destroy(dev, intel_sdvo_connector->flicker_filter_2d);
+        if (intel_sdvo_connector->flicker_filter_adaptive)
+                drm_property_destroy(dev, intel_sdvo_connector->flicker_filter_adaptive);
+        if (intel_sdvo_connector->tv_luma_filter)
+                drm_property_destroy(dev, intel_sdvo_connector->tv_luma_filter);
+        if (intel_sdvo_connector->tv_chroma_filter)
+                drm_property_destroy(dev, intel_sdvo_connector->tv_chroma_filter);
+        if (intel_sdvo_connector->dot_crawl)
+                drm_property_destroy(dev, intel_sdvo_connector->dot_crawl);
+        if (intel_sdvo_connector->brightness)
+                drm_property_destroy(dev, intel_sdvo_connector->brightness);
 }
 
 static void intel_sdvo_destroy(struct drm_connector *connector)
 {
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_connector = intel_connector->dev_priv;
+        struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
 
-        if (sdvo_connector->tv_format_property)
+        if (intel_sdvo_connector->tv_format)
                 drm_property_destroy(connector->dev,
-                                     sdvo_connector->tv_format_property);
+                                     intel_sdvo_connector->tv_format);
 
         intel_sdvo_destroy_enhance_property(connector);
         drm_sysfs_connector_remove(connector);
@@ -1870,132 +1776,118 @@ intel_sdvo_set_property(struct drm_connector *connector,
                         uint64_t val)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_connector = intel_connector->dev_priv;
-        struct drm_crtc *crtc = encoder->crtc;
-        int ret = 0;
-        bool changed = false;
-        uint8_t cmd, status;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
+        struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
         uint16_t temp_value;
+        uint8_t cmd;
+        int ret;
 
         ret = drm_connector_property_set_value(connector, property, val);
-        if (ret < 0)
-                goto out;
+        if (ret)
+                return ret;
+
+#define CHECK_PROPERTY(name, NAME) \
+        if (intel_sdvo_connector->name == property) { \
+                if (intel_sdvo_connector->cur_##name == temp_value) return 0; \
+                if (intel_sdvo_connector->max_##name < temp_value) return -EINVAL; \
+                cmd = SDVO_CMD_SET_##NAME; \
+                intel_sdvo_connector->cur_##name = temp_value; \
+                goto set_value; \
+        }
 
-        if (property == sdvo_connector->tv_format_property) {
-                if (val >= TV_FORMAT_NUM) {
-                        ret = -EINVAL;
-                        goto out;
-                }
-                if (sdvo_priv->tv_format_name ==
-                    sdvo_connector->tv_format_supported[val])
-                        goto out;
+        if (property == intel_sdvo_connector->tv_format) {
+                if (val >= TV_FORMAT_NUM)
+                        return -EINVAL;
 
-                sdvo_priv->tv_format_name = sdvo_connector->tv_format_supported[val];
-                changed = true;
-        }
+                if (intel_sdvo->tv_format_index ==
+                    intel_sdvo_connector->tv_format_supported[val])
+                        return 0;
 
-        if (IS_TV(sdvo_connector) || IS_LVDS(sdvo_connector)) {
-                cmd = 0;
+                intel_sdvo->tv_format_index = intel_sdvo_connector->tv_format_supported[val];
+                goto done;
+        } else if (IS_TV_OR_LVDS(intel_sdvo_connector)) {
                 temp_value = val;
-                if (sdvo_connector->left_property == property) {
+                if (intel_sdvo_connector->left == property) {
                         drm_connector_property_set_value(connector,
-                                sdvo_connector->right_property, val);
-                        if (sdvo_connector->left_margin == temp_value)
-                                goto out;
-
-                        sdvo_connector->left_margin = temp_value;
-                        sdvo_connector->right_margin = temp_value;
-                        temp_value = sdvo_connector->max_hscan -
-                                        sdvo_connector->left_margin;
+                                                         intel_sdvo_connector->right, val);
+                        if (intel_sdvo_connector->left_margin == temp_value)
+                                return 0;
+
+                        intel_sdvo_connector->left_margin = temp_value;
+                        intel_sdvo_connector->right_margin = temp_value;
+                        temp_value = intel_sdvo_connector->max_hscan -
+                                intel_sdvo_connector->left_margin;
                         cmd = SDVO_CMD_SET_OVERSCAN_H;
-                } else if (sdvo_connector->right_property == property) {
+                        goto set_value;
+                } else if (intel_sdvo_connector->right == property) {
                         drm_connector_property_set_value(connector,
-                                sdvo_connector->left_property, val);
-                        if (sdvo_connector->right_margin == temp_value)
-                                goto out;
-
-                        sdvo_connector->left_margin = temp_value;
-                        sdvo_connector->right_margin = temp_value;
-                        temp_value = sdvo_connector->max_hscan -
-                                sdvo_connector->left_margin;
+                                                         intel_sdvo_connector->left, val);
+                        if (intel_sdvo_connector->right_margin == temp_value)
+                                return 0;
+
+                        intel_sdvo_connector->left_margin = temp_value;
+                        intel_sdvo_connector->right_margin = temp_value;
+                        temp_value = intel_sdvo_connector->max_hscan -
+                                intel_sdvo_connector->left_margin;
                         cmd = SDVO_CMD_SET_OVERSCAN_H;
-                } else if (sdvo_connector->top_property == property) {
+                        goto set_value;
+                } else if (intel_sdvo_connector->top == property) {
                         drm_connector_property_set_value(connector,
-                                sdvo_connector->bottom_property, val);
-                        if (sdvo_connector->top_margin == temp_value)
-                                goto out;
-
-                        sdvo_connector->top_margin = temp_value;
-                        sdvo_connector->bottom_margin = temp_value;
-                        temp_value = sdvo_connector->max_vscan -
-                                        sdvo_connector->top_margin;
+                                                         intel_sdvo_connector->bottom, val);
+                        if (intel_sdvo_connector->top_margin == temp_value)
+                                return 0;
+
+                        intel_sdvo_connector->top_margin = temp_value;
+                        intel_sdvo_connector->bottom_margin = temp_value;
+                        temp_value = intel_sdvo_connector->max_vscan -
+                                intel_sdvo_connector->top_margin;
                         cmd = SDVO_CMD_SET_OVERSCAN_V;
-                } else if (sdvo_connector->bottom_property == property) {
+                        goto set_value;
+                } else if (intel_sdvo_connector->bottom == property) {
                         drm_connector_property_set_value(connector,
-                                sdvo_connector->top_property, val);
-                        if (sdvo_connector->bottom_margin == temp_value)
-                                goto out;
-                        sdvo_connector->top_margin = temp_value;
-                        sdvo_connector->bottom_margin = temp_value;
-                        temp_value = sdvo_connector->max_vscan -
-                                        sdvo_connector->top_margin;
+                                                         intel_sdvo_connector->top, val);
+                        if (intel_sdvo_connector->bottom_margin == temp_value)
+                                return 0;
+
+                        intel_sdvo_connector->top_margin = temp_value;
+                        intel_sdvo_connector->bottom_margin = temp_value;
+                        temp_value = intel_sdvo_connector->max_vscan -
+                                intel_sdvo_connector->top_margin;
                         cmd = SDVO_CMD_SET_OVERSCAN_V;
-                } else if (sdvo_connector->hpos_property == property) {
-                        if (sdvo_connector->cur_hpos == temp_value)
-                                goto out;
-
-                        cmd = SDVO_CMD_SET_POSITION_H;
-                        sdvo_connector->cur_hpos = temp_value;
-                } else if (sdvo_connector->vpos_property == property) {
-                        if (sdvo_connector->cur_vpos == temp_value)
-                                goto out;
-
-                        cmd = SDVO_CMD_SET_POSITION_V;
-                        sdvo_connector->cur_vpos = temp_value;
-                } else if (sdvo_connector->saturation_property == property) {
-                        if (sdvo_connector->cur_saturation == temp_value)
-                                goto out;
-
-                        cmd = SDVO_CMD_SET_SATURATION;
-                        sdvo_connector->cur_saturation = temp_value;
-                } else if (sdvo_connector->contrast_property == property) {
-                        if (sdvo_connector->cur_contrast == temp_value)
-                                goto out;
-
-                        cmd = SDVO_CMD_SET_CONTRAST;
-                        sdvo_connector->cur_contrast = temp_value;
-                } else if (sdvo_connector->hue_property == property) {
-                        if (sdvo_connector->cur_hue == temp_value)
-                                goto out;
-
-                        cmd = SDVO_CMD_SET_HUE;
-                        sdvo_connector->cur_hue = temp_value;
-                } else if (sdvo_connector->brightness_property == property) {
-                        if (sdvo_connector->cur_brightness == temp_value)
-                                goto out;
-
-                        cmd = SDVO_CMD_SET_BRIGHTNESS;
-                        sdvo_connector->cur_brightness = temp_value;
-                }
-                if (cmd) {
-                        intel_sdvo_write_cmd(intel_encoder, cmd, &temp_value, 2);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                                                NULL, 0);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO command \n");
-                                return -EINVAL;
-                        }
-                        changed = true;
+                        goto set_value;
                 }
+                CHECK_PROPERTY(hpos, HPOS)
+                CHECK_PROPERTY(vpos, VPOS)
+                CHECK_PROPERTY(saturation, SATURATION)
+                CHECK_PROPERTY(contrast, CONTRAST)
+                CHECK_PROPERTY(hue, HUE)
+                CHECK_PROPERTY(brightness, BRIGHTNESS)
+                CHECK_PROPERTY(sharpness, SHARPNESS)
+                CHECK_PROPERTY(flicker_filter, FLICKER_FILTER)
+                CHECK_PROPERTY(flicker_filter_2d, FLICKER_FILTER_2D)
+                CHECK_PROPERTY(flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE)
+                CHECK_PROPERTY(tv_chroma_filter, TV_CHROMA_FILTER)
+                CHECK_PROPERTY(tv_luma_filter, TV_LUMA_FILTER)
+                CHECK_PROPERTY(dot_crawl, DOT_CRAWL)
         }
-        if (changed && crtc)
+
+        return -EINVAL; /* unknown property */
+
+set_value:
+        if (!intel_sdvo_set_value(intel_sdvo, cmd, &temp_value, 2))
+                return -EIO;
+
+
+done:
+        if (encoder->crtc) {
+                struct drm_crtc *crtc = encoder->crtc;
+
                 drm_crtc_helper_set_mode(crtc, &crtc->mode, crtc->x,
-                                crtc->y, crtc->fb);
-out:
-        return ret;
+                                         crtc->y, crtc->fb);
+        }
+
+        return 0;
+#undef CHECK_PROPERTY
 }
 
 static const struct drm_encoder_helper_funcs intel_sdvo_helper_funcs = {
@@ -2022,28 +1914,57 @@ static const struct drm_connector_helper_funcs intel_sdvo_connector_helper_funcs
 
 static void intel_sdvo_enc_destroy(struct drm_encoder *encoder)
 {
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
 
-        if (intel_encoder->i2c_bus)
-                intel_i2c_destroy(intel_encoder->i2c_bus);
-        if (intel_encoder->ddc_bus)
-                intel_i2c_destroy(intel_encoder->ddc_bus);
-        if (sdvo_priv->analog_ddc_bus)
-                intel_i2c_destroy(sdvo_priv->analog_ddc_bus);
+        if (intel_sdvo->analog_ddc_bus)
+                intel_i2c_destroy(intel_sdvo->analog_ddc_bus);
 
-        if (sdvo_priv->sdvo_lvds_fixed_mode != NULL)
+        if (intel_sdvo->sdvo_lvds_fixed_mode != NULL)
                 drm_mode_destroy(encoder->dev,
-                                 sdvo_priv->sdvo_lvds_fixed_mode);
+                                 intel_sdvo->sdvo_lvds_fixed_mode);
 
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
+        intel_encoder_destroy(encoder);
 }
 
 static const struct drm_encoder_funcs intel_sdvo_enc_funcs = {
         .destroy = intel_sdvo_enc_destroy,
 };
 
+static void
+intel_sdvo_guess_ddc_bus(struct intel_sdvo *sdvo)
+{
+        uint16_t mask = 0;
+        unsigned int num_bits;
+
+        /* Make a mask of outputs less than or equal to our own priority in the
+         * list.
+         */
+        switch (sdvo->controlled_output) {
+        case SDVO_OUTPUT_LVDS1:
+                mask |= SDVO_OUTPUT_LVDS1;
+        case SDVO_OUTPUT_LVDS0:
+                mask |= SDVO_OUTPUT_LVDS0;
+        case SDVO_OUTPUT_TMDS1:
+                mask |= SDVO_OUTPUT_TMDS1;
+        case SDVO_OUTPUT_TMDS0:
+                mask |= SDVO_OUTPUT_TMDS0;
+        case SDVO_OUTPUT_RGB1:
+                mask |= SDVO_OUTPUT_RGB1;
+        case SDVO_OUTPUT_RGB0:
+                mask |= SDVO_OUTPUT_RGB0;
+                break;
+        }
+
+        /* Count bits to find what number we are in the priority list. */
+        mask &= sdvo->caps.output_flags;
+        num_bits = hweight16(mask);
+        /* If more than 3 outputs, default to DDC bus 3 for now. */
+        if (num_bits > 3)
+                num_bits = 3;
+
+        /* Corresponds to SDVO_CONTROL_BUS_DDCx */
+        sdvo->ddc_bus = 1 << num_bits;
+}
 
 /**
  * Choose the appropriate DDC bus for control bus switch command for this
@@ -2054,7 +1975,7 @@ static const struct drm_encoder_funcs intel_sdvo_enc_funcs = {
  */
 static void
 intel_sdvo_select_ddc_bus(struct drm_i915_private *dev_priv,
-                          struct intel_sdvo_priv *sdvo, u32 reg)
+                          struct intel_sdvo *sdvo, u32 reg)
 {
         struct sdvo_device_mapping *mapping;
 
@@ -2063,61 +1984,53 @@ intel_sdvo_select_ddc_bus(struct drm_i915_private *dev_priv,
         else
                 mapping = &(dev_priv->sdvo_mappings[1]);
 
-        sdvo->ddc_bus = 1 << ((mapping->ddc_pin & 0xf0) >> 4);
+        if (mapping->initialized)
+                sdvo->ddc_bus = 1 << ((mapping->ddc_pin & 0xf0) >> 4);
+        else
+                intel_sdvo_guess_ddc_bus(sdvo);
 }
 
 static bool
-intel_sdvo_get_digital_encoding_mode(struct intel_encoder *output, int device)
+intel_sdvo_get_digital_encoding_mode(struct intel_sdvo *intel_sdvo, int device)
 {
-        struct intel_sdvo_priv *sdvo_priv = output->dev_priv;
-        uint8_t status;
-
-        if (device == 0)
-                intel_sdvo_set_target_output(output, SDVO_OUTPUT_TMDS0);
-        else
-                intel_sdvo_set_target_output(output, SDVO_OUTPUT_TMDS1);
-
-        intel_sdvo_write_cmd(output, SDVO_CMD_GET_ENCODE, NULL, 0);
-        status = intel_sdvo_read_response(output, &sdvo_priv->is_hdmi, 1);
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return false;
-        return true;
+        return intel_sdvo_set_target_output(intel_sdvo,
+                                            device == 0 ? SDVO_OUTPUT_TMDS0 : SDVO_OUTPUT_TMDS1) &&
+                intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_ENCODE,
+                                     &intel_sdvo->is_hdmi, 1);
 }
 
-static struct intel_encoder *
-intel_sdvo_chan_to_intel_encoder(struct intel_i2c_chan *chan)
+static struct intel_sdvo *
+intel_sdvo_chan_to_intel_sdvo(struct intel_i2c_chan *chan)
 {
         struct drm_device *dev = chan->drm_dev;
         struct drm_encoder *encoder;
-        struct intel_encoder *intel_encoder = NULL;
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-                intel_encoder = enc_to_intel_encoder(encoder);
-                if (intel_encoder->ddc_bus == &chan->adapter)
-                        break;
+                struct intel_sdvo *intel_sdvo = enc_to_intel_sdvo(encoder);
+                if (intel_sdvo->base.ddc_bus == &chan->adapter)
+                        return intel_sdvo;
         }
-        return intel_encoder;
+
+        return NULL;
 }
 
 static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap,
                                   struct i2c_msg msgs[], int num)
 {
-        struct intel_encoder *intel_encoder;
-        struct intel_sdvo_priv *sdvo_priv;
+        struct intel_sdvo *intel_sdvo;
         struct i2c_algo_bit_data *algo_data;
         const struct i2c_algorithm *algo;
 
         algo_data = (struct i2c_algo_bit_data *)i2c_adap->algo_data;
-        intel_encoder =
-                intel_sdvo_chan_to_intel_encoder(
-                                (struct intel_i2c_chan *)(algo_data->data));
-        if (intel_encoder == NULL)
+        intel_sdvo =
+                intel_sdvo_chan_to_intel_sdvo((struct intel_i2c_chan *)
+                                              (algo_data->data));
+        if (intel_sdvo == NULL)
                 return -EINVAL;
 
-        sdvo_priv = intel_encoder->dev_priv;
-        algo = intel_encoder->i2c_bus->algo;
+        algo = intel_sdvo->base.i2c_bus->algo;
 
-        intel_sdvo_set_control_bus_switch(intel_encoder, sdvo_priv->ddc_bus);
+        intel_sdvo_set_control_bus_switch(intel_sdvo, intel_sdvo->ddc_bus);
         return algo->master_xfer(i2c_adap, msgs, num);
 }
 
@@ -2162,27 +2075,9 @@ intel_sdvo_get_slave_addr(struct drm_device *dev, int sdvo_reg)
                 return 0x72;
 }
 
-static bool
-intel_sdvo_connector_alloc (struct intel_connector **ret)
-{
-        struct intel_connector *intel_connector;
-        struct intel_sdvo_connector *sdvo_connector;
-
-        *ret = kzalloc(sizeof(*intel_connector) +
-                        sizeof(*sdvo_connector), GFP_KERNEL);
-        if (!*ret)
-                return false;
-
-        intel_connector = *ret;
-        sdvo_connector = (struct intel_sdvo_connector *)(intel_connector + 1);
-        intel_connector->dev_priv = sdvo_connector;
-
-        return true;
-}
-
 static void
-intel_sdvo_connector_create (struct drm_encoder *encoder,
-                             struct drm_connector *connector)
+intel_sdvo_connector_init(struct drm_encoder *encoder,
+                          struct drm_connector *connector)
 {
         drm_connector_init(encoder->dev, connector, &intel_sdvo_connector_funcs,
                            connector->connector_type);
@@ -2198,582 +2093,467 @@ intel_sdvo_connector_create (struct drm_encoder *encoder,
 }
 
 static bool
-intel_sdvo_dvi_init(struct intel_encoder *intel_encoder, int device)
+intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
 {
-        struct drm_encoder *encoder = &intel_encoder->enc;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct drm_encoder *encoder = &intel_sdvo->base.enc;
         struct drm_connector *connector;
         struct intel_connector *intel_connector;
-        struct intel_sdvo_connector *sdvo_connector;
+        struct intel_sdvo_connector *intel_sdvo_connector;
 
-        if (!intel_sdvo_connector_alloc(&intel_connector))
+        intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
+        if (!intel_sdvo_connector)
                 return false;
 
-        sdvo_connector = intel_connector->dev_priv;
-
         if (device == 0) {
-                sdvo_priv->controlled_output |= SDVO_OUTPUT_TMDS0;
-                sdvo_connector->output_flag = SDVO_OUTPUT_TMDS0;
+                intel_sdvo->controlled_output |= SDVO_OUTPUT_TMDS0;
+                intel_sdvo_connector->output_flag = SDVO_OUTPUT_TMDS0;
         } else if (device == 1) {
-                sdvo_priv->controlled_output |= SDVO_OUTPUT_TMDS1;
-                sdvo_connector->output_flag = SDVO_OUTPUT_TMDS1;
+                intel_sdvo->controlled_output |= SDVO_OUTPUT_TMDS1;
+                intel_sdvo_connector->output_flag = SDVO_OUTPUT_TMDS1;
         }
 
+        intel_connector = &intel_sdvo_connector->base;
         connector = &intel_connector->base;
         connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
         encoder->encoder_type = DRM_MODE_ENCODER_TMDS;
         connector->connector_type = DRM_MODE_CONNECTOR_DVID;
 
-        if (intel_sdvo_get_supp_encode(intel_encoder, &sdvo_priv->encode)
-                && intel_sdvo_get_digital_encoding_mode(intel_encoder, device)
-                && sdvo_priv->is_hdmi) {
+        if (intel_sdvo_get_supp_encode(intel_sdvo, &intel_sdvo->encode)
+                && intel_sdvo_get_digital_encoding_mode(intel_sdvo, device)
+                && intel_sdvo->is_hdmi) {
                 /* enable hdmi encoding mode if supported */
-                intel_sdvo_set_encode(intel_encoder, SDVO_ENCODE_HDMI);
-                intel_sdvo_set_colorimetry(intel_encoder,
+                intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_HDMI);
+                intel_sdvo_set_colorimetry(intel_sdvo,
                                            SDVO_COLORIMETRY_RGB256);
                 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA;
         }
-        intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
-                                    (1 << INTEL_ANALOG_CLONE_BIT);
+        intel_sdvo->base.clone_mask = ((1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
+                                       (1 << INTEL_ANALOG_CLONE_BIT));
 
-        intel_sdvo_connector_create(encoder, connector);
+        intel_sdvo_connector_init(encoder, connector);
 
         return true;
 }
 
 static bool
-intel_sdvo_tv_init(struct intel_encoder *intel_encoder, int type)
+intel_sdvo_tv_init(struct intel_sdvo *intel_sdvo, int type)
 {
-        struct drm_encoder *encoder = &intel_encoder->enc;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct drm_encoder *encoder = &intel_sdvo->base.enc;
         struct drm_connector *connector;
         struct intel_connector *intel_connector;
-        struct intel_sdvo_connector *sdvo_connector;
+        struct intel_sdvo_connector *intel_sdvo_connector;
 
-        if (!intel_sdvo_connector_alloc(&intel_connector))
-                return false;
+        intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
+        if (!intel_sdvo_connector)
+                return false;
 
+        intel_connector = &intel_sdvo_connector->base;
         connector = &intel_connector->base;
         encoder->encoder_type = DRM_MODE_ENCODER_TVDAC;
         connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO;
-        sdvo_connector = intel_connector->dev_priv;
 
-        sdvo_priv->controlled_output |= type;
-        sdvo_connector->output_flag = type;
+        intel_sdvo->controlled_output |= type;
+        intel_sdvo_connector->output_flag = type;
 
-        sdvo_priv->is_tv = true;
-        intel_encoder->needs_tv_clock = true;
-        intel_encoder->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT;
+        intel_sdvo->is_tv = true;
+        intel_sdvo->base.needs_tv_clock = true;
+        intel_sdvo->base.clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT;
 
-        intel_sdvo_connector_create(encoder, connector);
+        intel_sdvo_connector_init(encoder, connector);
 
-        intel_sdvo_tv_create_property(connector, type);
+        if (!intel_sdvo_tv_create_property(intel_sdvo, intel_sdvo_connector, type))
+                goto err;
 
-        intel_sdvo_create_enhance_property(connector);
+        if (!intel_sdvo_create_enhance_property(intel_sdvo, intel_sdvo_connector))
+                goto err;
 
         return true;
+
+err:
+        intel_sdvo_destroy(connector);
+        return false;
 }
 
 static bool
-intel_sdvo_analog_init(struct intel_encoder *intel_encoder, int device)
+intel_sdvo_analog_init(struct intel_sdvo *intel_sdvo, int device)
 {
-        struct drm_encoder *encoder = &intel_encoder->enc;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct drm_encoder *encoder = &intel_sdvo->base.enc;
         struct drm_connector *connector;
         struct intel_connector *intel_connector;
-        struct intel_sdvo_connector *sdvo_connector;
+        struct intel_sdvo_connector *intel_sdvo_connector;
 
-        if (!intel_sdvo_connector_alloc(&intel_connector))
-                return false;
+        intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
+        if (!intel_sdvo_connector)
+                return false;
 
+        intel_connector = &intel_sdvo_connector->base;
         connector = &intel_connector->base;
         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
         encoder->encoder_type = DRM_MODE_ENCODER_DAC;
         connector->connector_type = DRM_MODE_CONNECTOR_VGA;
-        sdvo_connector = intel_connector->dev_priv;
 
         if (device == 0) {
-                sdvo_priv->controlled_output |= SDVO_OUTPUT_RGB0;
-                sdvo_connector->output_flag = SDVO_OUTPUT_RGB0;
+                intel_sdvo->controlled_output |= SDVO_OUTPUT_RGB0;
+                intel_sdvo_connector->output_flag = SDVO_OUTPUT_RGB0;
         } else if (device == 1) {
-                sdvo_priv->controlled_output |= SDVO_OUTPUT_RGB1;
-                sdvo_connector->output_flag = SDVO_OUTPUT_RGB1;
+                intel_sdvo->controlled_output |= SDVO_OUTPUT_RGB1;
+                intel_sdvo_connector->output_flag = SDVO_OUTPUT_RGB1;
         }
 
-        intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
-                                    (1 << INTEL_ANALOG_CLONE_BIT);
+        intel_sdvo->base.clone_mask = ((1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
+                                       (1 << INTEL_ANALOG_CLONE_BIT));
 
-        intel_sdvo_connector_create(encoder, connector);
+        intel_sdvo_connector_init(encoder, connector);
         return true;
 }
 
 static bool
-intel_sdvo_lvds_init(struct intel_encoder *intel_encoder, int device)
+intel_sdvo_lvds_init(struct intel_sdvo *intel_sdvo, int device)
 {
-        struct drm_encoder *encoder = &intel_encoder->enc;
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
+        struct drm_encoder *encoder = &intel_sdvo->base.enc;
         struct drm_connector *connector;
         struct intel_connector *intel_connector;
-        struct intel_sdvo_connector *sdvo_connector;
+        struct intel_sdvo_connector *intel_sdvo_connector;
 
-        if (!intel_sdvo_connector_alloc(&intel_connector))
-                return false;
+        intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
+        if (!intel_sdvo_connector)
+                return false;
 
-        connector = &intel_connector->base;
+        intel_connector = &intel_sdvo_connector->base;
+        connector = &intel_connector->base;
         encoder->encoder_type = DRM_MODE_ENCODER_LVDS;
         connector->connector_type = DRM_MODE_CONNECTOR_LVDS;
-        sdvo_connector = intel_connector->dev_priv;
-
-        sdvo_priv->is_lvds = true;
 
         if (device == 0) {
-                sdvo_priv->controlled_output |= SDVO_OUTPUT_LVDS0;
-                sdvo_connector->output_flag = SDVO_OUTPUT_LVDS0;
+                intel_sdvo->controlled_output |= SDVO_OUTPUT_LVDS0;
+                intel_sdvo_connector->output_flag = SDVO_OUTPUT_LVDS0;
         } else if (device == 1) {
-                sdvo_priv->controlled_output |= SDVO_OUTPUT_LVDS1;
-                sdvo_connector->output_flag = SDVO_OUTPUT_LVDS1;
+                intel_sdvo->controlled_output |= SDVO_OUTPUT_LVDS1;
+                intel_sdvo_connector->output_flag = SDVO_OUTPUT_LVDS1;
         }
 
-        intel_encoder->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) |
-                                    (1 << INTEL_SDVO_LVDS_CLONE_BIT);
+        intel_sdvo->base.clone_mask = ((1 << INTEL_ANALOG_CLONE_BIT) |
+                                       (1 << INTEL_SDVO_LVDS_CLONE_BIT));
 
-        intel_sdvo_connector_create(encoder, connector);
-        intel_sdvo_create_enhance_property(connector);
-        return true;
+        intel_sdvo_connector_init(encoder, connector);
+        if (!intel_sdvo_create_enhance_property(intel_sdvo, intel_sdvo_connector))
+                goto err;
+
+        return true;
+
+err:
+        intel_sdvo_destroy(connector);
+        return false;
 }
 
 static bool
-intel_sdvo_output_setup(struct intel_encoder *intel_encoder, uint16_t flags)
+intel_sdvo_output_setup(struct intel_sdvo *intel_sdvo, uint16_t flags)
 {
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-
-        sdvo_priv->is_tv = false;
-        intel_encoder->needs_tv_clock = false;
-        sdvo_priv->is_lvds = false;
+        intel_sdvo->is_tv = false;
+        intel_sdvo->base.needs_tv_clock = false;
+        intel_sdvo->is_lvds = false;
 
         /* SDVO requires XXX1 function may not exist unless it has XXX0 function.*/
 
         if (flags & SDVO_OUTPUT_TMDS0)
-                if (!intel_sdvo_dvi_init(intel_encoder, 0))
+                if (!intel_sdvo_dvi_init(intel_sdvo, 0))
                         return false;
 
         if ((flags & SDVO_TMDS_MASK) == SDVO_TMDS_MASK)
-                if (!intel_sdvo_dvi_init(intel_encoder, 1))
+                if (!intel_sdvo_dvi_init(intel_sdvo, 1))
                         return false;
 
         /* TV has no XXX1 function block */
         if (flags & SDVO_OUTPUT_SVID0)
-                if (!intel_sdvo_tv_init(intel_encoder, SDVO_OUTPUT_SVID0))
+                if (!intel_sdvo_tv_init(intel_sdvo, SDVO_OUTPUT_SVID0))
                         return false;
 
         if (flags & SDVO_OUTPUT_CVBS0)
-                if (!intel_sdvo_tv_init(intel_encoder, SDVO_OUTPUT_CVBS0))
+                if (!intel_sdvo_tv_init(intel_sdvo, SDVO_OUTPUT_CVBS0))
                         return false;
 
         if (flags & SDVO_OUTPUT_RGB0)
-                if (!intel_sdvo_analog_init(intel_encoder, 0))
+                if (!intel_sdvo_analog_init(intel_sdvo, 0))
                         return false;
 
         if ((flags & SDVO_RGB_MASK) == SDVO_RGB_MASK)
-                if (!intel_sdvo_analog_init(intel_encoder, 1))
+                if (!intel_sdvo_analog_init(intel_sdvo, 1))
                         return false;
 
         if (flags & SDVO_OUTPUT_LVDS0)
-                if (!intel_sdvo_lvds_init(intel_encoder, 0))
+                if (!intel_sdvo_lvds_init(intel_sdvo, 0))
                         return false;
 
         if ((flags & SDVO_LVDS_MASK) == SDVO_LVDS_MASK)
-                if (!intel_sdvo_lvds_init(intel_encoder, 1))
+                if (!intel_sdvo_lvds_init(intel_sdvo, 1))
                         return false;
 
         if ((flags & SDVO_OUTPUT_MASK) == 0) {
                 unsigned char bytes[2];
 
-                sdvo_priv->controlled_output = 0;
-                memcpy(bytes, &sdvo_priv->caps.output_flags, 2);
+                intel_sdvo->controlled_output = 0;
+                memcpy(bytes, &intel_sdvo->caps.output_flags, 2);
                 DRM_DEBUG_KMS("%s: Unknown SDVO output type (0x%02x%02x)\n",
-                              SDVO_NAME(sdvo_priv),
+                              SDVO_NAME(intel_sdvo),
                               bytes[0], bytes[1]);
                 return false;
         }
-        intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
+        intel_sdvo->base.crtc_mask = (1 << 0) | (1 << 1);
 
         return true;
 }
 
-static void intel_sdvo_tv_create_property(struct drm_connector *connector, int type)
+static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
+                                          struct intel_sdvo_connector *intel_sdvo_connector,
+                                          int type)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_connector = intel_connector->dev_priv;
+        struct drm_device *dev = intel_sdvo->base.enc.dev;
         struct intel_sdvo_tv_format format;
         uint32_t format_map, i;
-        uint8_t status;
 
-        intel_sdvo_set_target_output(intel_encoder, type);
+        if (!intel_sdvo_set_target_output(intel_sdvo, type))
+                return false;
 
-        intel_sdvo_write_cmd(intel_encoder,
-                             SDVO_CMD_GET_SUPPORTED_TV_FORMATS, NULL, 0);
-        status = intel_sdvo_read_response(intel_encoder,
-                                          &format, sizeof(format));
-        if (status != SDVO_CMD_STATUS_SUCCESS)
-                return;
+        if (!intel_sdvo_get_value(intel_sdvo,
+                                  SDVO_CMD_GET_SUPPORTED_TV_FORMATS,
+                                  &format, sizeof(format)))
+                return false;
 
-        memcpy(&format_map, &format, sizeof(format) > sizeof(format_map) ?
-               sizeof(format_map) : sizeof(format));
+        memcpy(&format_map, &format, min(sizeof(format_map), sizeof(format)));
 
         if (format_map == 0)
-                return;
+                return false;
 
-        sdvo_connector->format_supported_num = 0;
+        intel_sdvo_connector->format_supported_num = 0;
         for (i = 0 ; i < TV_FORMAT_NUM; i++)
-                if (format_map & (1 << i)) {
-                        sdvo_connector->tv_format_supported
-                        [sdvo_connector->format_supported_num++] =
-                        tv_format_names[i];
-                }
+                if (format_map & (1 << i))
+                        intel_sdvo_connector->tv_format_supported[intel_sdvo_connector->format_supported_num++] = i;
 
 
-        sdvo_connector->tv_format_property =
-                        drm_property_create(
-                                connector->dev, DRM_MODE_PROP_ENUM,
-                                "mode", sdvo_connector->format_supported_num);
+        intel_sdvo_connector->tv_format =
+                        drm_property_create(dev, DRM_MODE_PROP_ENUM,
+                                            "mode", intel_sdvo_connector->format_supported_num);
+        if (!intel_sdvo_connector->tv_format)
+                return false;
 
-        for (i = 0; i < sdvo_connector->format_supported_num; i++)
+        for (i = 0; i < intel_sdvo_connector->format_supported_num; i++)
                 drm_property_add_enum(
-                                sdvo_connector->tv_format_property, i,
-                                i, sdvo_connector->tv_format_supported[i]);
+                                intel_sdvo_connector->tv_format, i,
+                                i, tv_format_names[intel_sdvo_connector->tv_format_supported[i]]);
 
-        sdvo_priv->tv_format_name = sdvo_connector->tv_format_supported[0];
-        drm_connector_attach_property(
-                        connector, sdvo_connector->tv_format_property, 0);
+        intel_sdvo->tv_format_index = intel_sdvo_connector->tv_format_supported[0];
+        drm_connector_attach_property(&intel_sdvo_connector->base.base,
+                                      intel_sdvo_connector->tv_format, 0);
+        return true;
 
 }
 
-static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
+#define ENHANCEMENT(name, NAME) do { \
+        if (enhancements.name) { \
+                if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_MAX_##NAME, &data_value, 4) || \
+                    !intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_##NAME, &response, 2)) \
+                        return false; \
+                intel_sdvo_connector->max_##name = data_value[0]; \
+                intel_sdvo_connector->cur_##name = response; \
+                intel_sdvo_connector->name = \
+                        drm_property_create(dev, DRM_MODE_PROP_RANGE, #name, 2); \
+                if (!intel_sdvo_connector->name) return false; \
+                intel_sdvo_connector->name->values[0] = 0; \
+                intel_sdvo_connector->name->values[1] = data_value[0]; \
+                drm_connector_attach_property(connector, \
+                                              intel_sdvo_connector->name, \
+                                              intel_sdvo_connector->cur_##name); \
+                DRM_DEBUG_KMS(#name ": max %d, default %d, current %d\n", \
+                              data_value[0], data_value[1], response); \
+        } \
+} while(0)
+
+static bool
+intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
+                                      struct intel_sdvo_connector *intel_sdvo_connector,
+                                      struct intel_sdvo_enhancements_reply enhancements)
 {
-        struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_connector *intel_connector = to_intel_connector(connector);
-        struct intel_sdvo_connector *sdvo_priv = intel_connector->dev_priv;
-        struct intel_sdvo_enhancements_reply sdvo_data;
-        struct drm_device *dev = connector->dev;
-        uint8_t status;
+        struct drm_device *dev = intel_sdvo->base.enc.dev;
+        struct drm_connector *connector = &intel_sdvo_connector->base.base;
         uint16_t response, data_value[2];
 
-        intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS,
-                                                NULL, 0);
-        status = intel_sdvo_read_response(intel_encoder, &sdvo_data,
-                                        sizeof(sdvo_data));
-        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                DRM_DEBUG_KMS(" incorrect response is returned\n");
-                return;
+        /* when horizontal overscan is supported, Add the left/right  property */
+        if (enhancements.overscan_h) {
+                if (!intel_sdvo_get_value(intel_sdvo,
+                                          SDVO_CMD_GET_MAX_OVERSCAN_H,
+                                          &data_value, 4))
+                        return false;
+
+                if (!intel_sdvo_get_value(intel_sdvo,
+                                          SDVO_CMD_GET_OVERSCAN_H,
+                                          &response, 2))
+                        return false;
+
+                intel_sdvo_connector->max_hscan = data_value[0];
+                intel_sdvo_connector->left_margin = data_value[0] - response;
+                intel_sdvo_connector->right_margin = intel_sdvo_connector->left_margin;
+                intel_sdvo_connector->left =
+                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
+                                            "left_margin", 2);
+                if (!intel_sdvo_connector->left)
+                        return false;
+
+                intel_sdvo_connector->left->values[0] = 0;
+                intel_sdvo_connector->left->values[1] = data_value[0];
+                drm_connector_attach_property(connector,
+                                              intel_sdvo_connector->left,
+                                              intel_sdvo_connector->left_margin);
+
+                intel_sdvo_connector->right =
+                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
+                                            "right_margin", 2);
+                if (!intel_sdvo_connector->right)
+                        return false;
+
+                intel_sdvo_connector->right->values[0] = 0;
+                intel_sdvo_connector->right->values[1] = data_value[0];
+                drm_connector_attach_property(connector,
+                                              intel_sdvo_connector->right,
+                                              intel_sdvo_connector->right_margin);
+                DRM_DEBUG_KMS("h_overscan: max %d, "
+                              "default %d, current %d\n",
+                              data_value[0], data_value[1], response);
         }
-        response = *((uint16_t *)&sdvo_data);
-        if (!response) {
-                DRM_DEBUG_KMS("No enhancement is supported\n");
-                return;
+
+        if (enhancements.overscan_v) {
+                if (!intel_sdvo_get_value(intel_sdvo,
+                                          SDVO_CMD_GET_MAX_OVERSCAN_V,
+                                          &data_value, 4))
+                        return false;
+
+                if (!intel_sdvo_get_value(intel_sdvo,
+                                          SDVO_CMD_GET_OVERSCAN_V,
+                                          &response, 2))
+                        return false;
+
+                intel_sdvo_connector->max_vscan = data_value[0];
+                intel_sdvo_connector->top_margin = data_value[0] - response;
+                intel_sdvo_connector->bottom_margin = intel_sdvo_connector->top_margin;
+                intel_sdvo_connector->top =
+                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
+                                            "top_margin", 2);
+                if (!intel_sdvo_connector->top)
+                        return false;
+
+                intel_sdvo_connector->top->values[0] = 0;
+                intel_sdvo_connector->top->values[1] = data_value[0];
+                drm_connector_attach_property(connector,
+                                              intel_sdvo_connector->top,
+                                              intel_sdvo_connector->top_margin);
+
+                intel_sdvo_connector->bottom =
+                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
+                                            "bottom_margin", 2);
+                if (!intel_sdvo_connector->bottom)
+                        return false;
+
+                intel_sdvo_connector->bottom->values[0] = 0;
+                intel_sdvo_connector->bottom->values[1] = data_value[0];
+                drm_connector_attach_property(connector,
+                                              intel_sdvo_connector->bottom,
+                                              intel_sdvo_connector->bottom_margin);
+                DRM_DEBUG_KMS("v_overscan: max %d, "
+                              "default %d, current %d\n",
+                              data_value[0], data_value[1], response);
         }
-        if (IS_TV(sdvo_priv)) {
-                /* when horizontal overscan is supported, Add the left/right
-                 * property
-                 */
-                if (sdvo_data.overscan_h) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_OVERSCAN_H, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO max "
-                                                "h_overscan\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_OVERSCAN_H, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO h_overscan\n");
-                                return;
-                        }
-                        sdvo_priv->max_hscan = data_value[0];
-                        sdvo_priv->left_margin = data_value[0] - response;
-                        sdvo_priv->right_margin = sdvo_priv->left_margin;
-                        sdvo_priv->left_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "left_margin", 2);
-                        sdvo_priv->left_property->values[0] = 0;
-                        sdvo_priv->left_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->left_property,
-                                                sdvo_priv->left_margin);
-                        sdvo_priv->right_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "right_margin", 2);
-                        sdvo_priv->right_property->values[0] = 0;
-                        sdvo_priv->right_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->right_property,
-                                                sdvo_priv->right_margin);
-                        DRM_DEBUG_KMS("h_overscan: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
-                if (sdvo_data.overscan_v) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_OVERSCAN_V, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO max "
-                                                "v_overscan\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_OVERSCAN_V, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO v_overscan\n");
-                                return;
-                        }
-                        sdvo_priv->max_vscan = data_value[0];
-                        sdvo_priv->top_margin = data_value[0] - response;
-                        sdvo_priv->bottom_margin = sdvo_priv->top_margin;
-                        sdvo_priv->top_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "top_margin", 2);
-                        sdvo_priv->top_property->values[0] = 0;
-                        sdvo_priv->top_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->top_property,
-                                                sdvo_priv->top_margin);
-                        sdvo_priv->bottom_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "bottom_margin", 2);
-                        sdvo_priv->bottom_property->values[0] = 0;
-                        sdvo_priv->bottom_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->bottom_property,
-                                                sdvo_priv->bottom_margin);
-                        DRM_DEBUG_KMS("v_overscan: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
-                if (sdvo_data.position_h) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_POSITION_H, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO Max h_pos\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_POSITION_H, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO get h_postion\n");
-                                return;
-                        }
-                        sdvo_priv->max_hpos = data_value[0];
-                        sdvo_priv->cur_hpos = response;
-                        sdvo_priv->hpos_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "hpos", 2);
-                        sdvo_priv->hpos_property->values[0] = 0;
-                        sdvo_priv->hpos_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->hpos_property,
-                                                sdvo_priv->cur_hpos);
-                        DRM_DEBUG_KMS("h_position: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
-                if (sdvo_data.position_v) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_POSITION_V, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO Max v_pos\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_POSITION_V, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO get v_postion\n");
-                                return;
-                        }
-                        sdvo_priv->max_vpos = data_value[0];
-                        sdvo_priv->cur_vpos = response;
-                        sdvo_priv->vpos_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "vpos", 2);
-                        sdvo_priv->vpos_property->values[0] = 0;
-                        sdvo_priv->vpos_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->vpos_property,
-                                                sdvo_priv->cur_vpos);
-                        DRM_DEBUG_KMS("v_position: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
-                if (sdvo_data.saturation) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_SATURATION, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO Max sat\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_SATURATION, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO get sat\n");
-                                return;
-                        }
-                        sdvo_priv->max_saturation = data_value[0];
-                        sdvo_priv->cur_saturation = response;
-                        sdvo_priv->saturation_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "saturation", 2);
-                        sdvo_priv->saturation_property->values[0] = 0;
-                        sdvo_priv->saturation_property->values[1] =
-                                                        data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->saturation_property,
-                                                sdvo_priv->cur_saturation);
-                        DRM_DEBUG_KMS("saturation: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
-                if (sdvo_data.contrast) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_CONTRAST, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO Max contrast\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_CONTRAST, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO get contrast\n");
-                                return;
-                        }
-                        sdvo_priv->max_contrast = data_value[0];
-                        sdvo_priv->cur_contrast = response;
-                        sdvo_priv->contrast_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "contrast", 2);
-                        sdvo_priv->contrast_property->values[0] = 0;
-                        sdvo_priv->contrast_property->values[1] = data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->contrast_property,
-                                                sdvo_priv->cur_contrast);
-                        DRM_DEBUG_KMS("contrast: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
-                if (sdvo_data.hue) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_HUE, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO Max hue\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_HUE, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO get hue\n");
-                                return;
-                        }
-                        sdvo_priv->max_hue = data_value[0];
-                        sdvo_priv->cur_hue = response;
-                        sdvo_priv->hue_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "hue", 2);
-                        sdvo_priv->hue_property->values[0] = 0;
-                        sdvo_priv->hue_property->values[1] =
-                                                        data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->hue_property,
-                                                sdvo_priv->cur_hue);
-                        DRM_DEBUG_KMS("hue: max %d, default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
+
+        ENHANCEMENT(hpos, HPOS);
+        ENHANCEMENT(vpos, VPOS);
+        ENHANCEMENT(saturation, SATURATION);
+        ENHANCEMENT(contrast, CONTRAST);
+        ENHANCEMENT(hue, HUE);
+        ENHANCEMENT(sharpness, SHARPNESS);
+        ENHANCEMENT(brightness, BRIGHTNESS);
+        ENHANCEMENT(flicker_filter, FLICKER_FILTER);
+        ENHANCEMENT(flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE);
+        ENHANCEMENT(flicker_filter_2d, FLICKER_FILTER_2D);
+        ENHANCEMENT(tv_chroma_filter, TV_CHROMA_FILTER);
+        ENHANCEMENT(tv_luma_filter, TV_LUMA_FILTER);
+
+        if (enhancements.dot_crawl) {
+                if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_DOT_CRAWL, &response, 2))
+                        return false;
+
+                intel_sdvo_connector->max_dot_crawl = 1;
+                intel_sdvo_connector->cur_dot_crawl = response & 0x1;
+                intel_sdvo_connector->dot_crawl =
+                        drm_property_create(dev, DRM_MODE_PROP_RANGE, "dot_crawl", 2);
+                if (!intel_sdvo_connector->dot_crawl)
+                        return false;
+
+                intel_sdvo_connector->dot_crawl->values[0] = 0;
+                intel_sdvo_connector->dot_crawl->values[1] = 1;
+                drm_connector_attach_property(connector,
+                                              intel_sdvo_connector->dot_crawl,
+                                              intel_sdvo_connector->cur_dot_crawl);
+                DRM_DEBUG_KMS("dot crawl: current %d\n", response);
         }
-        if (IS_TV(sdvo_priv) || IS_LVDS(sdvo_priv)) {
-                if (sdvo_data.brightness) {
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_MAX_BRIGHTNESS, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &data_value, 4);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO Max bright\n");
-                                return;
-                        }
-                        intel_sdvo_write_cmd(intel_encoder,
-                                SDVO_CMD_GET_BRIGHTNESS, NULL, 0);
-                        status = intel_sdvo_read_response(intel_encoder,
-                                &response, 2);
-                        if (status != SDVO_CMD_STATUS_SUCCESS) {
-                                DRM_DEBUG_KMS("Incorrect SDVO get brigh\n");
-                                return;
-                        }
-                        sdvo_priv->max_brightness = data_value[0];
-                        sdvo_priv->cur_brightness = response;
-                        sdvo_priv->brightness_property =
-                                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                "brightness", 2);
-                        sdvo_priv->brightness_property->values[0] = 0;
-                        sdvo_priv->brightness_property->values[1] =
-                                                        data_value[0];
-                        drm_connector_attach_property(connector,
-                                                sdvo_priv->brightness_property,
-                                                sdvo_priv->cur_brightness);
-                        DRM_DEBUG_KMS("brightness: max %d, "
-                                        "default %d, current %d\n",
-                                        data_value[0], data_value[1], response);
-                }
+
+        return true;
+}
+
+static bool
+intel_sdvo_create_enhance_property_lvds(struct intel_sdvo *intel_sdvo,
+                                        struct intel_sdvo_connector *intel_sdvo_connector,
+                                        struct intel_sdvo_enhancements_reply enhancements)
+{
+        struct drm_device *dev = intel_sdvo->base.enc.dev;
+        struct drm_connector *connector = &intel_sdvo_connector->base.base;
+        uint16_t response, data_value[2];
+
+        ENHANCEMENT(brightness, BRIGHTNESS);
+
+        return true;
+}
+#undef ENHANCEMENT
+
+static bool intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo,
+                                               struct intel_sdvo_connector *intel_sdvo_connector)
+{
+        union {
+                struct intel_sdvo_enhancements_reply reply;
+                uint16_t response;
+        } enhancements;
+
+        enhancements.response = 0;
+        intel_sdvo_get_value(intel_sdvo,
+                             SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS,
+                             &enhancements, sizeof(enhancements));
+        if (enhancements.response == 0) {
+                DRM_DEBUG_KMS("No enhancement is supported\n");
+                return true;
         }
-        return;
+
+        if (IS_TV(intel_sdvo_connector))
+                return intel_sdvo_create_enhance_property_tv(intel_sdvo, intel_sdvo_connector, enhancements.reply);
+        else if(IS_LVDS(intel_sdvo_connector))
+                return intel_sdvo_create_enhance_property_lvds(intel_sdvo, intel_sdvo_connector, enhancements.reply);
+        else
+                return true;
+
 }
 
 bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_encoder *intel_encoder;
-        struct intel_sdvo_priv *sdvo_priv;
+        struct intel_sdvo *intel_sdvo;
         u8 ch[0x40];
         int i;
         u32 i2c_reg, ddc_reg, analog_ddc_reg;
 
-        intel_encoder = kcalloc(sizeof(struct intel_encoder)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL);
-        if (!intel_encoder) {
+        intel_sdvo = kzalloc(sizeof(struct intel_sdvo), GFP_KERNEL);
+        if (!intel_sdvo)
                 return false;
-        }
 
-        sdvo_priv = (struct intel_sdvo_priv *)(intel_encoder + 1);
-        sdvo_priv->sdvo_reg = sdvo_reg;
+        intel_sdvo->sdvo_reg = sdvo_reg;
 
-        intel_encoder->dev_priv = sdvo_priv;
+        intel_encoder = &intel_sdvo->base;
         intel_encoder->type = INTEL_OUTPUT_SDVO;
 
         if (HAS_PCH_SPLIT(dev)) {
@@ -2795,14 +2575,14 @@ bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
         if (!intel_encoder->i2c_bus)
                 goto err_inteloutput;
 
-        sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, sdvo_reg);
+        intel_sdvo->slave_addr = intel_sdvo_get_slave_addr(dev, sdvo_reg);
 
         /* Save the bit-banging i2c functionality for use by the DDC wrapper */
         intel_sdvo_i2c_bit_algo.functionality = intel_encoder->i2c_bus->algo->functionality;
 
         /* Read the regs to test if we can talk to the device */
         for (i = 0; i < 0x40; i++) {
-                if (!intel_sdvo_read_byte(intel_encoder, i, &ch[i])) {
+                if (!intel_sdvo_read_byte(intel_sdvo, i, &ch[i])) {
                         DRM_DEBUG_KMS("No SDVO device found on SDVO%c\n",
                                       IS_SDVOB(sdvo_reg) ? 'B' : 'C');
                         goto err_i2c;
@@ -2812,17 +2592,16 @@ bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
         /* setup the DDC bus. */
         if (IS_SDVOB(sdvo_reg)) {
                 intel_encoder->ddc_bus = intel_i2c_create(dev, ddc_reg, "SDVOB DDC BUS");
-                sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, analog_ddc_reg,
+                intel_sdvo->analog_ddc_bus = intel_i2c_create(dev, analog_ddc_reg,
                                                 "SDVOB/VGA DDC BUS");
                 dev_priv->hotplug_supported_mask |= SDVOB_HOTPLUG_INT_STATUS;
         } else {
                 intel_encoder->ddc_bus = intel_i2c_create(dev, ddc_reg, "SDVOC DDC BUS");
-                sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, analog_ddc_reg,
+                intel_sdvo->analog_ddc_bus = intel_i2c_create(dev, analog_ddc_reg,
                                                 "SDVOC/VGA DDC BUS");
                 dev_priv->hotplug_supported_mask |= SDVOC_HOTPLUG_INT_STATUS;
         }
-
-        if (intel_encoder->ddc_bus == NULL)
+        if (intel_encoder->ddc_bus == NULL || intel_sdvo->analog_ddc_bus == NULL)
                 goto err_i2c;
 
         /* Wrap with our custom algo which switches to DDC mode */
@@ -2833,53 +2612,56 @@ bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
         drm_encoder_helper_add(&intel_encoder->enc, &intel_sdvo_helper_funcs);
 
         /* In default case sdvo lvds is false */
-        intel_sdvo_get_capabilities(intel_encoder, &sdvo_priv->caps);
+        if (!intel_sdvo_get_capabilities(intel_sdvo, &intel_sdvo->caps))
+                goto err_enc;
 
-        if (intel_sdvo_output_setup(intel_encoder,
-                                    sdvo_priv->caps.output_flags) != true) {
+        if (intel_sdvo_output_setup(intel_sdvo,
+                                    intel_sdvo->caps.output_flags) != true) {
                 DRM_DEBUG_KMS("SDVO output failed to setup on SDVO%c\n",
                               IS_SDVOB(sdvo_reg) ? 'B' : 'C');
-                goto err_i2c;
+                goto err_enc;
         }
 
-        intel_sdvo_select_ddc_bus(dev_priv, sdvo_priv, sdvo_reg);
+        intel_sdvo_select_ddc_bus(dev_priv, intel_sdvo, sdvo_reg);
 
         /* Set the input timing to the screen. Assume always input 0. */
-        intel_sdvo_set_target_input(intel_encoder, true, false);
-
-        intel_sdvo_get_input_pixel_clock_range(intel_encoder,
-                                               &sdvo_priv->pixel_clock_min,
-                                               &sdvo_priv->pixel_clock_max);
+        if (!intel_sdvo_set_target_input(intel_sdvo))
+                goto err_enc;
 
+        if (!intel_sdvo_get_input_pixel_clock_range(intel_sdvo,
+                                                    &intel_sdvo->pixel_clock_min,
+                                                    &intel_sdvo->pixel_clock_max))
+                goto err_enc;
 
         DRM_DEBUG_KMS("%s device VID/DID: %02X:%02X.%02X, "
                         "clock range %dMHz - %dMHz, "
                         "input 1: %c, input 2: %c, "
                         "output 1: %c, output 2: %c\n",
-                        SDVO_NAME(sdvo_priv),
-                        sdvo_priv->caps.vendor_id, sdvo_priv->caps.device_id,
-                        sdvo_priv->caps.device_rev_id,
-                        sdvo_priv->pixel_clock_min / 1000,
-                        sdvo_priv->pixel_clock_max / 1000,
-                        (sdvo_priv->caps.sdvo_inputs_mask & 0x1) ? 'Y' : 'N',
-                        (sdvo_priv->caps.sdvo_inputs_mask & 0x2) ? 'Y' : 'N',
+                        SDVO_NAME(intel_sdvo),
+                        intel_sdvo->caps.vendor_id, intel_sdvo->caps.device_id,
+                        intel_sdvo->caps.device_rev_id,
+                        intel_sdvo->pixel_clock_min / 1000,
+                        intel_sdvo->pixel_clock_max / 1000,
+                        (intel_sdvo->caps.sdvo_inputs_mask & 0x1) ? 'Y' : 'N',
+                        (intel_sdvo->caps.sdvo_inputs_mask & 0x2) ? 'Y' : 'N',
                         /* check currently supported outputs */
-                        sdvo_priv->caps.output_flags &
+                        intel_sdvo->caps.output_flags &
                         (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_RGB0) ? 'Y' : 'N',
-                        sdvo_priv->caps.output_flags &
+                        intel_sdvo->caps.output_flags &
                         (SDVO_OUTPUT_TMDS1 | SDVO_OUTPUT_RGB1) ? 'Y' : 'N');
-
         return true;
 
+err_enc:
+        drm_encoder_cleanup(&intel_encoder->enc);
 err_i2c:
-        if (sdvo_priv->analog_ddc_bus != NULL)
-                intel_i2c_destroy(sdvo_priv->analog_ddc_bus);
+        if (intel_sdvo->analog_ddc_bus != NULL)
+                intel_i2c_destroy(intel_sdvo->analog_ddc_bus);
         if (intel_encoder->ddc_bus != NULL)
                 intel_i2c_destroy(intel_encoder->ddc_bus);
         if (intel_encoder->i2c_bus != NULL)
                 intel_i2c_destroy(intel_encoder->i2c_bus);
 err_inteloutput:
-        kfree(intel_encoder);
+        kfree(intel_sdvo);
 
         return false;
 }
diff --git a/drivers/gpu/drm/i915/intel_sdvo_regs.h b/drivers/gpu/drm/i915/intel_sdvo_regs.h
index ba5cdf8ae40b..a386b022e538 100644
--- a/drivers/gpu/drm/i915/intel_sdvo_regs.h
+++ b/drivers/gpu/drm/i915/intel_sdvo_regs.h
@@ -312,7 +312,7 @@ struct intel_sdvo_set_target_input_args {
 # define SDVO_CLOCK_RATE_MULT_4X                                (1 << 3)
 
 #define SDVO_CMD_GET_SUPPORTED_TV_FORMATS               0x27
-/** 5 bytes of bit flags for TV formats shared by all TV format functions */
+/** 6 bytes of bit flags for TV formats shared by all TV format functions */
 struct intel_sdvo_tv_format {
     unsigned int ntsc_m:1;
     unsigned int ntsc_j:1;
@@ -596,32 +596,32 @@ struct intel_sdvo_enhancements_reply {
     unsigned int overscan_h:1;
 
     unsigned int overscan_v:1;
-    unsigned int position_h:1;
-    unsigned int position_v:1;
+    unsigned int hpos:1;
+    unsigned int vpos:1;
     unsigned int sharpness:1;
     unsigned int dot_crawl:1;
     unsigned int dither:1;
-    unsigned int max_tv_chroma_filter:1;
-    unsigned int max_tv_luma_filter:1;
+    unsigned int tv_chroma_filter:1;
+    unsigned int tv_luma_filter:1;
 } __attribute__((packed));
 
 /* Picture enhancement limits below are dependent on the current TV format,
  * and thus need to be queried and set after it.
  */
-#define SDVO_CMD_GET_MAX_FLICKER_FITER                  0x4d
-#define SDVO_CMD_GET_MAX_ADAPTIVE_FLICKER_FITER         0x7b
-#define SDVO_CMD_GET_MAX_2D_FLICKER_FITER               0x52
+#define SDVO_CMD_GET_MAX_FLICKER_FILTER                 0x4d
+#define SDVO_CMD_GET_MAX_FLICKER_FILTER_ADAPTIVE        0x7b
+#define SDVO_CMD_GET_MAX_FLICKER_FILTER_2D              0x52
 #define SDVO_CMD_GET_MAX_SATURATION                     0x55
 #define SDVO_CMD_GET_MAX_HUE                            0x58
 #define SDVO_CMD_GET_MAX_BRIGHTNESS                     0x5b
 #define SDVO_CMD_GET_MAX_CONTRAST                       0x5e
 #define SDVO_CMD_GET_MAX_OVERSCAN_H                     0x61
 #define SDVO_CMD_GET_MAX_OVERSCAN_V                     0x64
-#define SDVO_CMD_GET_MAX_POSITION_H                     0x67
-#define SDVO_CMD_GET_MAX_POSITION_V                     0x6a
-#define SDVO_CMD_GET_MAX_SHARPNESS_V                    0x6d
-#define SDVO_CMD_GET_MAX_TV_CHROMA                      0x74
-#define SDVO_CMD_GET_MAX_TV_LUMA                        0x77
+#define SDVO_CMD_GET_MAX_HPOS                           0x67
+#define SDVO_CMD_GET_MAX_VPOS                           0x6a
+#define SDVO_CMD_GET_MAX_SHARPNESS                      0x6d
+#define SDVO_CMD_GET_MAX_TV_CHROMA_FILTER               0x74
+#define SDVO_CMD_GET_MAX_TV_LUMA_FILTER                 0x77
 struct intel_sdvo_enhancement_limits_reply {
     u16 max_value;
     u16 default_value;
@@ -638,10 +638,10 @@ struct intel_sdvo_enhancement_limits_reply {
 
 #define SDVO_CMD_GET_FLICKER_FILTER                     0x4e
 #define SDVO_CMD_SET_FLICKER_FILTER                     0x4f
-#define SDVO_CMD_GET_ADAPTIVE_FLICKER_FITER             0x50
-#define SDVO_CMD_SET_ADAPTIVE_FLICKER_FITER             0x51
-#define SDVO_CMD_GET_2D_FLICKER_FITER                   0x53
-#define SDVO_CMD_SET_2D_FLICKER_FITER                   0x54
+#define SDVO_CMD_GET_FLICKER_FILTER_ADAPTIVE            0x50
+#define SDVO_CMD_SET_FLICKER_FILTER_ADAPTIVE            0x51
+#define SDVO_CMD_GET_FLICKER_FILTER_2D                  0x53
+#define SDVO_CMD_SET_FLICKER_FILTER_2D                  0x54
 #define SDVO_CMD_GET_SATURATION                         0x56
 #define SDVO_CMD_SET_SATURATION                         0x57
 #define SDVO_CMD_GET_HUE                                0x59
@@ -654,16 +654,16 @@ struct intel_sdvo_enhancement_limits_reply {
 #define SDVO_CMD_SET_OVERSCAN_H                         0x63
 #define SDVO_CMD_GET_OVERSCAN_V                         0x65
 #define SDVO_CMD_SET_OVERSCAN_V                         0x66
-#define SDVO_CMD_GET_POSITION_H                         0x68
-#define SDVO_CMD_SET_POSITION_H                         0x69
-#define SDVO_CMD_GET_POSITION_V                         0x6b
-#define SDVO_CMD_SET_POSITION_V                         0x6c
+#define SDVO_CMD_GET_HPOS                               0x68
+#define SDVO_CMD_SET_HPOS                               0x69
+#define SDVO_CMD_GET_VPOS                               0x6b
+#define SDVO_CMD_SET_VPOS                               0x6c
 #define SDVO_CMD_GET_SHARPNESS                          0x6e
 #define SDVO_CMD_SET_SHARPNESS                          0x6f
-#define SDVO_CMD_GET_TV_CHROMA                          0x75
-#define SDVO_CMD_SET_TV_CHROMA                          0x76
-#define SDVO_CMD_GET_TV_LUMA                            0x78
-#define SDVO_CMD_SET_TV_LUMA                            0x79
+#define SDVO_CMD_GET_TV_CHROMA_FILTER                   0x75
+#define SDVO_CMD_SET_TV_CHROMA_FILTER                   0x76
+#define SDVO_CMD_GET_TV_LUMA_FILTER                     0x78
+#define SDVO_CMD_SET_TV_LUMA_FILTER                     0x79
 struct intel_sdvo_enhancements_arg {
     u16 value;
 }__attribute__((packed));
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index cc3726a4a1cb..4a117e318a73 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -44,7 +44,9 @@ enum tv_margin {
 };
 
 /** Private structure for the integrated TV support */
-struct intel_tv_priv {
+struct intel_tv {
+        struct intel_encoder base;
+
         int type;
         char *tv_format;
         int margin[4];
@@ -896,6 +898,11 @@ static const struct tv_mode tv_modes[] = {
         },
 };
 
+static struct intel_tv *enc_to_intel_tv(struct drm_encoder *encoder)
+{
+        return container_of(enc_to_intel_encoder(encoder), struct intel_tv, base);
+}
+
 static void
 intel_tv_dpms(struct drm_encoder *encoder, int mode)
 {
@@ -929,19 +936,17 @@ intel_tv_mode_lookup (char *tv_format)
 }
 
 static const struct tv_mode *
-intel_tv_mode_find (struct intel_encoder *intel_encoder)
+intel_tv_mode_find (struct intel_tv *intel_tv)
 {
-        struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
-
-        return intel_tv_mode_lookup(tv_priv->tv_format);
+        return intel_tv_mode_lookup(intel_tv->tv_format);
 }
 
 static enum drm_mode_status
 intel_tv_mode_valid(struct drm_connector *connector, struct drm_display_mode *mode)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
 
         /* Ensure TV refresh is close to desired refresh */
         if (tv_mode && abs(tv_mode->refresh - drm_mode_vrefresh(mode) * 1000)
@@ -957,8 +962,8 @@ intel_tv_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode,
 {
         struct drm_device *dev = encoder->dev;
         struct drm_mode_config *drm_config = &dev->mode_config;
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        const struct tv_mode *tv_mode = intel_tv_mode_find (intel_encoder);
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
         struct drm_encoder *other_encoder;
 
         if (!tv_mode)
@@ -983,9 +988,8 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_crtc *crtc = encoder->crtc;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
-        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
         u32 tv_ctl;
         u32 hctl1, hctl2, hctl3;
         u32 vctl1, vctl2, vctl3, vctl4, vctl5, vctl6, vctl7;
@@ -1001,7 +1005,7 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
         tv_ctl = I915_READ(TV_CTL);
         tv_ctl &= TV_CTL_SAVE;
 
-        switch (tv_priv->type) {
+        switch (intel_tv->type) {
         default:
         case DRM_MODE_CONNECTOR_Unknown:
         case DRM_MODE_CONNECTOR_Composite:
@@ -1154,11 +1158,11 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
 
                 /* Wait for vblank for the disable to take effect */
                 if (!IS_I9XX(dev))
-                        intel_wait_for_vblank(dev);
+                        intel_wait_for_vblank(dev, intel_crtc->pipe);
 
                 I915_WRITE(pipeconf_reg, pipeconf & ~PIPEACONF_ENABLE);
                 /* Wait for vblank for the disable to take effect. */
-                intel_wait_for_vblank(dev);
+                intel_wait_for_vblank(dev, intel_crtc->pipe);
 
                 /* Filter ctl must be set before TV_WIN_SIZE */
                 I915_WRITE(TV_FILTER_CTL_1, TV_AUTO_SCALE);
@@ -1168,12 +1172,12 @@ intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                 else
                         ysize = 2*tv_mode->nbr_end + 1;
 
-                xpos += tv_priv->margin[TV_MARGIN_LEFT];
-                ypos += tv_priv->margin[TV_MARGIN_TOP];
-                xsize -= (tv_priv->margin[TV_MARGIN_LEFT] +
-                          tv_priv->margin[TV_MARGIN_RIGHT]);
-                ysize -= (tv_priv->margin[TV_MARGIN_TOP] +
-                          tv_priv->margin[TV_MARGIN_BOTTOM]);
+                xpos += intel_tv->margin[TV_MARGIN_LEFT];
+                ypos += intel_tv->margin[TV_MARGIN_TOP];
+                xsize -= (intel_tv->margin[TV_MARGIN_LEFT] +
+                          intel_tv->margin[TV_MARGIN_RIGHT]);
+                ysize -= (intel_tv->margin[TV_MARGIN_TOP] +
+                          intel_tv->margin[TV_MARGIN_BOTTOM]);
                 I915_WRITE(TV_WIN_POS, (xpos<<16)|ypos);
                 I915_WRITE(TV_WIN_SIZE, (xsize<<16)|ysize);
 
@@ -1222,9 +1226,9 @@ static const struct drm_display_mode reported_modes[] = {
  * \return false if TV is disconnected.
  */
 static int
-intel_tv_detect_type (struct drm_crtc *crtc, struct intel_encoder *intel_encoder)
+intel_tv_detect_type (struct intel_tv *intel_tv)
 {
-        struct drm_encoder *encoder = &intel_encoder->enc;
+        struct drm_encoder *encoder = &intel_tv->base.enc;
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         unsigned long irqflags;
@@ -1263,11 +1267,15 @@ intel_tv_detect_type (struct drm_crtc *crtc, struct intel_encoder *intel_encoder
                    DAC_C_0_7_V);
         I915_WRITE(TV_CTL, tv_ctl);
         I915_WRITE(TV_DAC, tv_dac);
-        intel_wait_for_vblank(dev);
+        POSTING_READ(TV_DAC);
+        msleep(20);
+
         tv_dac = I915_READ(TV_DAC);
         I915_WRITE(TV_DAC, save_tv_dac);
         I915_WRITE(TV_CTL, save_tv_ctl);
-        intel_wait_for_vblank(dev);
+        POSTING_READ(TV_CTL);
+        msleep(20);
+
         /*
          *  A B C
          *  0 1 1 Composite
@@ -1304,12 +1312,11 @@ intel_tv_detect_type (struct drm_crtc *crtc, struct intel_encoder *intel_encoder
 static void intel_tv_find_better_format(struct drm_connector *connector)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
-        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
         int i;
 
-        if ((tv_priv->type == DRM_MODE_CONNECTOR_Component) ==
+        if ((intel_tv->type == DRM_MODE_CONNECTOR_Component) ==
                 tv_mode->component_only)
                 return;
 
@@ -1317,12 +1324,12 @@ static void intel_tv_find_better_format(struct drm_connector *connector)
         for (i = 0; i < sizeof(tv_modes) / sizeof(*tv_modes); i++) {
                 tv_mode = tv_modes + i;
 
-                if ((tv_priv->type == DRM_MODE_CONNECTOR_Component) ==
+                if ((intel_tv->type == DRM_MODE_CONNECTOR_Component) ==
                         tv_mode->component_only)
                         break;
         }
 
-        tv_priv->tv_format = tv_mode->name;
+        intel_tv->tv_format = tv_mode->name;
         drm_connector_property_set_value(connector,
                 connector->dev->mode_config.tv_mode_property, i);
 }
@@ -1334,33 +1341,32 @@ static void intel_tv_find_better_format(struct drm_connector *connector)
  * we have a pipe programmed in order to probe the TV.
  */
 static enum drm_connector_status
-intel_tv_detect(struct drm_connector *connector)
+intel_tv_detect(struct drm_connector *connector, bool force)
 {
-        struct drm_crtc *crtc;
         struct drm_display_mode mode;
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
-        int dpms_mode;
-        int type = tv_priv->type;
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        int type;
 
         mode = reported_modes[0];
         drm_mode_set_crtcinfo(&mode, CRTC_INTERLACE_HALVE_V);
 
         if (encoder->crtc && encoder->crtc->enabled) {
-                type = intel_tv_detect_type(encoder->crtc, intel_encoder);
-        } else {
-                crtc = intel_get_load_detect_pipe(intel_encoder, connector,
+                type = intel_tv_detect_type(intel_tv);
+        } else if (force) {
+                struct drm_crtc *crtc;
+                int dpms_mode;
+
+                crtc = intel_get_load_detect_pipe(&intel_tv->base, connector,
                                                   &mode, &dpms_mode);
                 if (crtc) {
-                        type = intel_tv_detect_type(crtc, intel_encoder);
-                        intel_release_load_detect_pipe(intel_encoder, connector,
+                        type = intel_tv_detect_type(intel_tv);
+                        intel_release_load_detect_pipe(&intel_tv->base, connector,
                                                        dpms_mode);
                 } else
-                        type = -1;
-        }
-
-        tv_priv->type = type;
+                        return connector_status_unknown;
+        } else
+                return connector->status;
 
         if (type < 0)
                 return connector_status_disconnected;
@@ -1391,8 +1397,8 @@ intel_tv_chose_preferred_modes(struct drm_connector *connector,
                                struct drm_display_mode *mode_ptr)
 {
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
 
         if (tv_mode->nbr_end < 480 && mode_ptr->vdisplay == 480)
                 mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
@@ -1417,8 +1423,8 @@ intel_tv_get_modes(struct drm_connector *connector)
 {
         struct drm_display_mode *mode_ptr;
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
+        const struct tv_mode *tv_mode = intel_tv_mode_find(intel_tv);
         int j, count = 0;
         u64 tmp;
 
@@ -1483,8 +1489,7 @@ intel_tv_set_property(struct drm_connector *connector, struct drm_property *prop
 {
         struct drm_device *dev = connector->dev;
         struct drm_encoder *encoder = intel_attached_encoder(connector);
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-        struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
+        struct intel_tv *intel_tv = enc_to_intel_tv(encoder);
         struct drm_crtc *crtc = encoder->crtc;
         int ret = 0;
         bool changed = false;
@@ -1494,30 +1499,30 @@ intel_tv_set_property(struct drm_connector *connector, struct drm_property *prop
                 goto out;
 
         if (property == dev->mode_config.tv_left_margin_property &&
-                tv_priv->margin[TV_MARGIN_LEFT] != val) {
-                tv_priv->margin[TV_MARGIN_LEFT] = val;
+                intel_tv->margin[TV_MARGIN_LEFT] != val) {
+                intel_tv->margin[TV_MARGIN_LEFT] = val;
                 changed = true;
         } else if (property == dev->mode_config.tv_right_margin_property &&
-                tv_priv->margin[TV_MARGIN_RIGHT] != val) {
-                tv_priv->margin[TV_MARGIN_RIGHT] = val;
+                intel_tv->margin[TV_MARGIN_RIGHT] != val) {
+                intel_tv->margin[TV_MARGIN_RIGHT] = val;
                 changed = true;
         } else if (property == dev->mode_config.tv_top_margin_property &&
-                tv_priv->margin[TV_MARGIN_TOP] != val) {
-                tv_priv->margin[TV_MARGIN_TOP] = val;
+                intel_tv->margin[TV_MARGIN_TOP] != val) {
+                intel_tv->margin[TV_MARGIN_TOP] = val;
                 changed = true;
         } else if (property == dev->mode_config.tv_bottom_margin_property &&
-                tv_priv->margin[TV_MARGIN_BOTTOM] != val) {
-                tv_priv->margin[TV_MARGIN_BOTTOM] = val;
+                intel_tv->margin[TV_MARGIN_BOTTOM] != val) {
+                intel_tv->margin[TV_MARGIN_BOTTOM] = val;
                 changed = true;
         } else if (property == dev->mode_config.tv_mode_property) {
                 if (val >= ARRAY_SIZE(tv_modes)) {
                         ret = -EINVAL;
                         goto out;
                 }
-                if (!strcmp(tv_priv->tv_format, tv_modes[val].name))
+                if (!strcmp(intel_tv->tv_format, tv_modes[val].name))
                         goto out;
 
-                tv_priv->tv_format = tv_modes[val].name;
+                intel_tv->tv_format = tv_modes[val].name;
                 changed = true;
         } else {
                 ret = -EINVAL;
@@ -1553,16 +1558,8 @@ static const struct drm_connector_helper_funcs intel_tv_connector_helper_funcs =
         .best_encoder = intel_attached_encoder,
 };
 
-static void intel_tv_enc_destroy(struct drm_encoder *encoder)
-{
-        struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
-
-        drm_encoder_cleanup(encoder);
-        kfree(intel_encoder);
-}
-
 static const struct drm_encoder_funcs intel_tv_enc_funcs = {
-        .destroy = intel_tv_enc_destroy,
+        .destroy = intel_encoder_destroy,
 };
 
 /*
@@ -1606,9 +1603,9 @@ intel_tv_init(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_connector *connector;
+        struct intel_tv *intel_tv;
         struct intel_encoder *intel_encoder;
         struct intel_connector *intel_connector;
-        struct intel_tv_priv *tv_priv;
         u32 tv_dac_on, tv_dac_off, save_tv_dac;
         char **tv_format_names;
         int i, initial_mode = 0;
@@ -1647,18 +1644,18 @@ intel_tv_init(struct drm_device *dev)
             (tv_dac_off & TVDAC_STATE_CHG_EN) != 0)
                 return;
 
-        intel_encoder = kzalloc(sizeof(struct intel_encoder) +
-                               sizeof(struct intel_tv_priv), GFP_KERNEL);
-        if (!intel_encoder) {
+        intel_tv = kzalloc(sizeof(struct intel_tv), GFP_KERNEL);
+        if (!intel_tv) {
                 return;
         }
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
-                kfree(intel_encoder);
+                kfree(intel_tv);
                 return;
         }
 
+        intel_encoder = &intel_tv->base;
         connector = &intel_connector->base;
 
         drm_connector_init(dev, connector, &intel_tv_connector_funcs,
@@ -1668,22 +1665,20 @@ intel_tv_init(struct drm_device *dev)
                          DRM_MODE_ENCODER_TVDAC);
 
         drm_mode_connector_attach_encoder(&intel_connector->base, &intel_encoder->enc);
-        tv_priv = (struct intel_tv_priv *)(intel_encoder + 1);
         intel_encoder->type = INTEL_OUTPUT_TVOUT;
         intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
         intel_encoder->clone_mask = (1 << INTEL_TV_CLONE_BIT);
         intel_encoder->enc.possible_crtcs = ((1 << 0) | (1 << 1));
         intel_encoder->enc.possible_clones = (1 << INTEL_OUTPUT_TVOUT);
-        intel_encoder->dev_priv = tv_priv;
-        tv_priv->type = DRM_MODE_CONNECTOR_Unknown;
+        intel_tv->type = DRM_MODE_CONNECTOR_Unknown;
 
         /* BIOS margin values */
-        tv_priv->margin[TV_MARGIN_LEFT] = 54;
-        tv_priv->margin[TV_MARGIN_TOP] = 36;
-        tv_priv->margin[TV_MARGIN_RIGHT] = 46;
-        tv_priv->margin[TV_MARGIN_BOTTOM] = 37;
+        intel_tv->margin[TV_MARGIN_LEFT] = 54;
+        intel_tv->margin[TV_MARGIN_TOP] = 36;
+        intel_tv->margin[TV_MARGIN_RIGHT] = 46;
+        intel_tv->margin[TV_MARGIN_BOTTOM] = 37;
 
-        tv_priv->tv_format = kstrdup(tv_modes[initial_mode].name, GFP_KERNEL);
+        intel_tv->tv_format = kstrdup(tv_modes[initial_mode].name, GFP_KERNEL);
 
         drm_encoder_helper_add(&intel_encoder->enc, &intel_tv_helper_funcs);
         drm_connector_helper_add(connector, &intel_tv_connector_helper_funcs);
@@ -1703,16 +1698,16 @@ intel_tv_init(struct drm_device *dev)
                                    initial_mode);
         drm_connector_attach_property(connector,
                                    dev->mode_config.tv_left_margin_property,
-                                   tv_priv->margin[TV_MARGIN_LEFT]);
+                                   intel_tv->margin[TV_MARGIN_LEFT]);
         drm_connector_attach_property(connector,
                                    dev->mode_config.tv_top_margin_property,
-                                   tv_priv->margin[TV_MARGIN_TOP]);
+                                   intel_tv->margin[TV_MARGIN_TOP]);
         drm_connector_attach_property(connector,
                                    dev->mode_config.tv_right_margin_property,
-                                   tv_priv->margin[TV_MARGIN_RIGHT]);
+                                   intel_tv->margin[TV_MARGIN_RIGHT]);
         drm_connector_attach_property(connector,
                                    dev->mode_config.tv_bottom_margin_property,
-                                   tv_priv->margin[TV_MARGIN_BOTTOM]);
+                                   intel_tv->margin[TV_MARGIN_BOTTOM]);
 out:
         drm_sysfs_connector_add(connector);
 }
diff --git a/drivers/gpu/drm/mga/mga_state.c b/drivers/gpu/drm/mga/mga_state.c
index fff82045c427..9ce2827f8c00 100644
--- a/drivers/gpu/drm/mga/mga_state.c
+++ b/drivers/gpu/drm/mga/mga_state.c
@@ -1085,19 +1085,19 @@ file_priv)
 }
 
 struct drm_ioctl_desc mga_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_MGA_INIT, mga_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_MGA_FLUSH, mga_dma_flush, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_RESET, mga_dma_reset, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_SWAP, mga_dma_swap, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_CLEAR, mga_dma_clear, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_VERTEX, mga_dma_vertex, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_INDICES, mga_dma_indices, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_ILOAD, mga_dma_iload, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_BLIT, mga_dma_blit, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_GETPARAM, mga_getparam, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_SET_FENCE, mga_set_fence, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_WAIT_FENCE, mga_wait_fence, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_MGA_DMA_BOOTSTRAP, mga_dma_bootstrap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(MGA_INIT, mga_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(MGA_FLUSH, mga_dma_flush, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_RESET, mga_dma_reset, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_SWAP, mga_dma_swap, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_CLEAR, mga_dma_clear, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_VERTEX, mga_dma_vertex, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_INDICES, mga_dma_indices, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_ILOAD, mga_dma_iload, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_BLIT, mga_dma_blit, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_GETPARAM, mga_getparam, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_SET_FENCE, mga_set_fence, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_WAIT_FENCE, mga_wait_fence, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(MGA_DMA_BOOTSTRAP, mga_dma_bootstrap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 };
 
 int mga_max_ioctl = DRM_ARRAY_SIZE(mga_ioctls);
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.c b/drivers/gpu/drm/nouveau/nouveau_bios.c
index 0b69a9628c95..974b0f8ae048 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.c
@@ -2166,7 +2166,7 @@ peek_fb(struct drm_device *dev, struct io_mapping *fb,
         uint32_t val = 0;
 
         if (off < pci_resource_len(dev->pdev, 1)) {
-                uint32_t __iomem *p =
+                uint8_t __iomem *p =
                         io_mapping_map_atomic_wc(fb, off & PAGE_MASK, KM_USER0);
 
                 val = ioread32(p + (off & ~PAGE_MASK));
@@ -2182,7 +2182,7 @@ poke_fb(struct drm_device *dev, struct io_mapping *fb,
         uint32_t off, uint32_t val)
 {
         if (off < pci_resource_len(dev->pdev, 1)) {
-                uint32_t __iomem *p =
+                uint8_t __iomem *p =
                         io_mapping_map_atomic_wc(fb, off & PAGE_MASK, KM_USER0);
 
                 iowrite32(val, p + (off & ~PAGE_MASK));
@@ -3869,27 +3869,10 @@ static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_entr
         }
 #ifdef __powerpc__
         /* Powerbook specific quirks */
-        if ((dev->pci_device & 0xffff) == 0x0179 ||
-            (dev->pci_device & 0xffff) == 0x0189 ||
-            (dev->pci_device & 0xffff) == 0x0329) {
-                if (script == LVDS_RESET) {
-                        nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
-
-                } else if (script == LVDS_PANEL_ON) {
-                        bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
-                                  bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
-                                  | (1 << 31));
-                        bios_wr32(bios, NV_PCRTC_GPIO_EXT,
-                                  bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1);
-
-                } else if (script == LVDS_PANEL_OFF) {
-                        bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
-                                  bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
-                                  & ~(1 << 31));
-                        bios_wr32(bios, NV_PCRTC_GPIO_EXT,
-                                  bios_rd32(bios, NV_PCRTC_GPIO_EXT) & ~3);
-                }
-        }
+        if (script == LVDS_RESET &&
+            (dev->pci_device == 0x0179 || dev->pci_device == 0x0189 ||
+             dev->pci_device == 0x0329))
+                nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
 #endif
 
         return 0;
@@ -4381,11 +4364,8 @@ int nouveau_bios_parse_lvds_table(struct drm_device *dev, int pxclk, bool *dl, b
          *
          * For the moment, a quirk will do :)
          */
-        if ((dev->pdev->device == 0x01d7) &&
-            (dev->pdev->subsystem_vendor == 0x1028) &&
-            (dev->pdev->subsystem_device == 0x01c2)) {
+        if (nv_match_device(dev, 0x01d7, 0x1028, 0x01c2))
                 bios->fp.duallink_transition_clk = 80000;
-        }
 
         /* set dual_link flag for EDID case */
         if (pxclk && (chip_version < 0x25 || chip_version > 0x28))
@@ -4587,7 +4567,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                         return 1;
                 }
 
-                NV_TRACE(dev, "0x%04X: parsing output script 0\n", script);
+                NV_DEBUG_KMS(dev, "0x%04X: parsing output script 0\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent);
         } else
         if (pxclk == -1) {
@@ -4597,7 +4577,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                         return 1;
                 }
 
-                NV_TRACE(dev, "0x%04X: parsing output script 1\n", script);
+                NV_DEBUG_KMS(dev, "0x%04X: parsing output script 1\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent);
         } else
         if (pxclk == -2) {
@@ -4610,7 +4590,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                         return 1;
                 }
 
-                NV_TRACE(dev, "0x%04X: parsing output script 2\n", script);
+                NV_DEBUG_KMS(dev, "0x%04X: parsing output script 2\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent);
         } else
         if (pxclk > 0) {
@@ -4622,7 +4602,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                         return 1;
                 }
 
-                NV_TRACE(dev, "0x%04X: parsing clock script 0\n", script);
+                NV_DEBUG_KMS(dev, "0x%04X: parsing clock script 0\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent);
         } else
         if (pxclk < 0) {
@@ -4634,7 +4614,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                         return 1;
                 }
 
-                NV_TRACE(dev, "0x%04X: parsing clock script 1\n", script);
+                NV_DEBUG_KMS(dev, "0x%04X: parsing clock script 1\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent);
         }
 
@@ -5357,19 +5337,17 @@ static int parse_bit_tmds_tbl_entry(struct drm_device *dev, struct nvbios *bios,
         }
 
         tmdstableptr = ROM16(bios->data[bitentry->offset]);
-
-        if (tmdstableptr == 0x0) {
+        if (!tmdstableptr) {
                 NV_ERROR(dev, "Pointer to TMDS table invalid\n");
                 return -EINVAL;
         }
 
+        NV_INFO(dev, "TMDS table version %d.%d\n",
+                bios->data[tmdstableptr] >> 4, bios->data[tmdstableptr] & 0xf);
+
         /* nv50+ has v2.0, but we don't parse it atm */
-        if (bios->data[tmdstableptr] != 0x11) {
-                NV_WARN(dev,
-                        "TMDS table revision %d.%d not currently supported\n",
-                        bios->data[tmdstableptr] >> 4, bios->data[tmdstableptr] & 0xf);
+        if (bios->data[tmdstableptr] != 0x11)
                 return -ENOSYS;
-        }
 
         /*
          * These two scripts are odd: they don't seem to get run even when
@@ -5809,6 +5787,20 @@ parse_dcb_gpio_table(struct nvbios *bios)
                         gpio->line = tvdac_gpio[1] >> 4;
                         gpio->invert = tvdac_gpio[0] & 2;
                 }
+        } else {
+                /*
+                 * No systematic way to store GPIO info on pre-v2.2
+                 * DCBs, try to match the PCI device IDs.
+                 */
+
+                /* Apple iMac G4 NV18 */
+                if (nv_match_device(dev, 0x0189, 0x10de, 0x0010)) {
+                        struct dcb_gpio_entry *gpio = new_gpio_entry(bios);
+
+                        gpio->tag = DCB_GPIO_TVDAC0;
+                        gpio->line = 4;
+                }
+
         }
 
         if (!gpio_table_ptr)
@@ -5884,9 +5876,7 @@ apply_dcb_connector_quirks(struct nvbios *bios, int idx)
         struct drm_device *dev = bios->dev;
 
         /* Gigabyte NX85T */
-        if ((dev->pdev->device == 0x0421) &&
-            (dev->pdev->subsystem_vendor == 0x1458) &&
-            (dev->pdev->subsystem_device == 0x344c)) {
+        if (nv_match_device(dev, 0x0421, 0x1458, 0x344c)) {
                 if (cte->type == DCB_CONNECTOR_HDMI_1)
                         cte->type = DCB_CONNECTOR_DVI_I;
         }
@@ -6139,7 +6129,7 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
                         entry->tmdsconf.slave_addr = (conf & 0x00000070) >> 4;
 
                 break;
-        case 0xe:
+        case OUTPUT_EOL:
                 /* weird g80 mobile type that "nv" treats as a terminator */
                 dcb->entries--;
                 return false;
@@ -6176,22 +6166,14 @@ parse_dcb15_entry(struct drm_device *dev, struct dcb_table *dcb,
                 entry->type = OUTPUT_TV;
                 break;
         case 2:
-        case 3:
-                entry->type = OUTPUT_LVDS;
-                break;
         case 4:
-                switch ((conn & 0x000000f0) >> 4) {
-                case 0:
-                        entry->type = OUTPUT_TMDS;
-                        break;
-                case 1:
+                if (conn & 0x10)
                         entry->type = OUTPUT_LVDS;
-                        break;
-                default:
-                        NV_ERROR(dev, "Unknown DCB subtype 4/%d\n",
-                                 (conn & 0x000000f0) >> 4);
-                        return false;
-                }
+                else
+                        entry->type = OUTPUT_TMDS;
+                break;
+        case 3:
+                entry->type = OUTPUT_LVDS;
                 break;
         default:
                 NV_ERROR(dev, "Unknown DCB type %d\n", conn & 0x0000000f);
@@ -6307,9 +6289,7 @@ apply_dcb_encoder_quirks(struct drm_device *dev, int idx, u32 *conn, u32 *conf)
          * nasty problems until this is sorted (assuming it's not a
          * VBIOS bug).
          */
-        if ((dev->pdev->device == 0x040d) &&
-            (dev->pdev->subsystem_vendor == 0x1028) &&
-            (dev->pdev->subsystem_device == 0x019b)) {
+        if (nv_match_device(dev, 0x040d, 0x1028, 0x019b)) {
                 if (*conn == 0x02026312 && *conf == 0x00000020)
                         return false;
         }
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.h b/drivers/gpu/drm/nouveau/nouveau_bios.h
index fd14dfd3d780..c1de2f3fcb0e 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.h
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.h
@@ -95,6 +95,7 @@ enum dcb_type {
         OUTPUT_TMDS = 2,
         OUTPUT_LVDS = 3,
         OUTPUT_DP = 6,
+        OUTPUT_EOL = 14, /* DCB 4.0+, appears to be end-of-list */
         OUTPUT_ANY = -1
 };
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.c b/drivers/gpu/drm/nouveau/nouveau_bo.c
index 84f85183d041..f6f44779d82f 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bo.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bo.c
@@ -36,6 +36,21 @@
 #include <linux/log2.h>
 #include <linux/slab.h>
 
+int
+nouveau_bo_sync_gpu(struct nouveau_bo *nvbo, struct nouveau_channel *chan)
+{
+        struct nouveau_fence *prev_fence = nvbo->bo.sync_obj;
+        int ret;
+
+        if (!prev_fence || nouveau_fence_channel(prev_fence) == chan)
+                return 0;
+
+        spin_lock(&nvbo->bo.lock);
+        ret = ttm_bo_wait(&nvbo->bo, false, false, false);
+        spin_unlock(&nvbo->bo.lock);
+        return ret;
+}
+
 static void
 nouveau_bo_del_ttm(struct ttm_buffer_object *bo)
 {
diff --git a/drivers/gpu/drm/nouveau/nouveau_channel.c b/drivers/gpu/drm/nouveau/nouveau_channel.c
index 90fdcda332be..0480f064f2c1 100644
--- a/drivers/gpu/drm/nouveau/nouveau_channel.c
+++ b/drivers/gpu/drm/nouveau/nouveau_channel.c
@@ -426,18 +426,18 @@ nouveau_ioctl_fifo_free(struct drm_device *dev, void *data,
  ***********************************/
 
 struct drm_ioctl_desc nouveau_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GETPARAM, nouveau_ioctl_getparam, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_SETPARAM, nouveau_ioctl_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_CHANNEL_ALLOC, nouveau_ioctl_fifo_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_CHANNEL_FREE, nouveau_ioctl_fifo_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GROBJ_ALLOC, nouveau_ioctl_grobj_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_NOTIFIEROBJ_ALLOC, nouveau_ioctl_notifier_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GPUOBJ_FREE, nouveau_ioctl_gpuobj_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GEM_NEW, nouveau_gem_ioctl_new, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GEM_PUSHBUF, nouveau_gem_ioctl_pushbuf, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GEM_CPU_PREP, nouveau_gem_ioctl_cpu_prep, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GEM_CPU_FINI, nouveau_gem_ioctl_cpu_fini, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_NOUVEAU_GEM_INFO, nouveau_gem_ioctl_info, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GETPARAM, nouveau_ioctl_getparam, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_SETPARAM, nouveau_ioctl_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_ALLOC, nouveau_ioctl_fifo_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_FREE, nouveau_ioctl_fifo_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GROBJ_ALLOC, nouveau_ioctl_grobj_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_NOTIFIEROBJ_ALLOC, nouveau_ioctl_notifier_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GPUOBJ_FREE, nouveau_ioctl_gpuobj_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_NEW, nouveau_gem_ioctl_new, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_PUSHBUF, nouveau_gem_ioctl_pushbuf, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_PREP, nouveau_gem_ioctl_cpu_prep, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_FINI, nouveau_gem_ioctl_cpu_fini, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_INFO, nouveau_gem_ioctl_info, DRM_AUTH),
 };
 
 int nouveau_max_ioctl = DRM_ARRAY_SIZE(nouveau_ioctls);
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index b1b22baf1428..fc737037f751 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
@@ -104,7 +104,7 @@ nouveau_connector_ddc_detect(struct drm_connector *connector,
         int i;
 
         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
-                struct nouveau_i2c_chan *i2c;
+                struct nouveau_i2c_chan *i2c = NULL;
                 struct nouveau_encoder *nv_encoder;
                 struct drm_mode_object *obj;
                 int id;
@@ -117,7 +117,9 @@ nouveau_connector_ddc_detect(struct drm_connector *connector,
                 if (!obj)
                         continue;
                 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
-                i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
+
+                if (nv_encoder->dcb->i2c_index < 0xf)
+                        i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
 
                 if (i2c && nouveau_probe_i2c_addr(i2c, 0x50)) {
                         *pnv_encoder = nv_encoder;
@@ -166,7 +168,7 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
 }
 
 static enum drm_connector_status
-nouveau_connector_detect(struct drm_connector *connector)
+nouveau_connector_detect(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
@@ -244,7 +246,7 @@ detect_analog:
 }
 
 static enum drm_connector_status
-nouveau_connector_detect_lvds(struct drm_connector *connector)
+nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
         struct drm_nouveau_private *dev_priv = dev->dev_private;
@@ -265,7 +267,7 @@ nouveau_connector_detect_lvds(struct drm_connector *connector)
 
         /* Try retrieving EDID via DDC */
         if (!dev_priv->vbios.fp_no_ddc) {
-                status = nouveau_connector_detect(connector);
+                status = nouveau_connector_detect(connector, force);
                 if (status == connector_status_connected)
                         goto out;
         }
@@ -556,8 +558,10 @@ nouveau_connector_get_modes(struct drm_connector *connector)
         if (nv_encoder->dcb->type == OUTPUT_LVDS &&
             (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
              dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
-                nv_connector->native_mode = drm_mode_create(dev);
-                nouveau_bios_fp_mode(dev, nv_connector->native_mode);
+                struct drm_display_mode mode;
+
+                nouveau_bios_fp_mode(dev, &mode);
+                nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
         }
 
         /* Find the native mode if this is a digital panel, if we didn't
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h
index e424bf74d706..b1be617373b6 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drv.h
+++ b/drivers/gpu/drm/nouveau/nouveau_drv.h
@@ -1165,6 +1165,7 @@ extern u16 nouveau_bo_rd16(struct nouveau_bo *nvbo, unsigned index);
 extern void nouveau_bo_wr16(struct nouveau_bo *nvbo, unsigned index, u16 val);
 extern u32 nouveau_bo_rd32(struct nouveau_bo *nvbo, unsigned index);
 extern void nouveau_bo_wr32(struct nouveau_bo *nvbo, unsigned index, u32 val);
+extern int nouveau_bo_sync_gpu(struct nouveau_bo *, struct nouveau_channel *);
 
 /* nouveau_fence.c */
 struct nouveau_fence;
@@ -1388,6 +1389,15 @@ nv_two_reg_pll(struct drm_device *dev)
         return false;
 }
 
+static inline bool
+nv_match_device(struct drm_device *dev, unsigned device,
+                unsigned sub_vendor, unsigned sub_device)
+{
+        return dev->pdev->device == device &&
+                dev->pdev->subsystem_vendor == sub_vendor &&
+                dev->pdev->subsystem_device == sub_device;
+}
+
 #define NV_SW                                                        0x0000506e
 #define NV_SW_DMA_SEMAPHORE                                          0x00000060
 #define NV_SW_SEMAPHORE_OFFSET                                       0x00000064
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c
index 6b208ffafa8d..87ac21ec23d2 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.c
@@ -64,16 +64,17 @@ nouveau_fence_update(struct nouveau_channel *chan)
         struct nouveau_fence *fence;
         uint32_t sequence;
 
+        spin_lock(&chan->fence.lock);
+
         if (USE_REFCNT)
                 sequence = nvchan_rd32(chan, 0x48);
         else
                 sequence = atomic_read(&chan->fence.last_sequence_irq);
 
         if (chan->fence.sequence_ack == sequence)
-                return;
+                goto out;
         chan->fence.sequence_ack = sequence;
 
-        spin_lock(&chan->fence.lock);
         list_for_each_safe(entry, tmp, &chan->fence.pending) {
                 fence = list_entry(entry, struct nouveau_fence, entry);
 
@@ -85,6 +86,7 @@ nouveau_fence_update(struct nouveau_channel *chan)
                 if (sequence == chan->fence.sequence_ack)
                         break;
         }
+out:
         spin_unlock(&chan->fence.lock);
 }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c
index 0f417ac1b696..19620a6709f5 100644
--- a/drivers/gpu/drm/nouveau/nouveau_gem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_gem.c
@@ -167,11 +167,9 @@ nouveau_gem_ioctl_new(struct drm_device *dev, void *data,
                 goto out;
 
         ret = drm_gem_handle_create(file_priv, nvbo->gem, &req->info.handle);
+        /* drop reference from allocate - handle holds it now */
+        drm_gem_object_unreference_unlocked(nvbo->gem);
 out:
-        drm_gem_object_handle_unreference_unlocked(nvbo->gem);
-
-        if (ret)
-                drm_gem_object_unreference_unlocked(nvbo->gem);
         return ret;
 }
 
@@ -245,7 +243,7 @@ validate_fini_list(struct list_head *list, struct nouveau_fence *fence)
                 list_del(&nvbo->entry);
                 nvbo->reserved_by = NULL;
                 ttm_bo_unreserve(&nvbo->bo);
-                drm_gem_object_unreference(nvbo->gem);
+                drm_gem_object_unreference_unlocked(nvbo->gem);
         }
 }
 
@@ -300,7 +298,7 @@ retry:
                         validate_fini(op, NULL);
                         if (ret == -EAGAIN)
                                 ret = ttm_bo_wait_unreserved(&nvbo->bo, false);
-                        drm_gem_object_unreference(gem);
+                        drm_gem_object_unreference_unlocked(gem);
                         if (ret) {
                                 NV_ERROR(dev, "fail reserve\n");
                                 return ret;
@@ -337,7 +335,9 @@ retry:
                                 return -EINVAL;
                         }
 
+                        mutex_unlock(&drm_global_mutex);
                         ret = ttm_bo_wait_cpu(&nvbo->bo, false);
+                        mutex_lock(&drm_global_mutex);
                         if (ret) {
                                 NV_ERROR(dev, "fail wait_cpu\n");
                                 return ret;
@@ -361,16 +361,11 @@ validate_list(struct nouveau_channel *chan, struct list_head *list,
 
         list_for_each_entry(nvbo, list, entry) {
                 struct drm_nouveau_gem_pushbuf_bo *b = &pbbo[nvbo->pbbo_index];
-                struct nouveau_fence *prev_fence = nvbo->bo.sync_obj;
 
-                if (prev_fence && nouveau_fence_channel(prev_fence) != chan) {
-                        spin_lock(&nvbo->bo.lock);
-                        ret = ttm_bo_wait(&nvbo->bo, false, false, false);
-                        spin_unlock(&nvbo->bo.lock);
-                        if (unlikely(ret)) {
-                                NV_ERROR(dev, "fail wait other chan\n");
-                                return ret;
-                        }
+                ret = nouveau_bo_sync_gpu(nvbo, chan);
+                if (unlikely(ret)) {
+                        NV_ERROR(dev, "fail pre-validate sync\n");
+                        return ret;
                 }
 
                 ret = nouveau_gem_set_domain(nvbo->gem, b->read_domains,
@@ -381,7 +376,7 @@ validate_list(struct nouveau_channel *chan, struct list_head *list,
                         return ret;
                 }
 
-                nvbo->channel = chan;
+                nvbo->channel = (b->read_domains & (1 << 31)) ? NULL : chan;
                 ret = ttm_bo_validate(&nvbo->bo, &nvbo->placement,
                                       false, false, false);
                 nvbo->channel = NULL;
@@ -390,6 +385,12 @@ validate_list(struct nouveau_channel *chan, struct list_head *list,
                         return ret;
                 }
 
+                ret = nouveau_bo_sync_gpu(nvbo, chan);
+                if (unlikely(ret)) {
+                        NV_ERROR(dev, "fail post-validate sync\n");
+                        return ret;
+                }
+
                 if (nvbo->bo.offset == b->presumed.offset &&
                     ((nvbo->bo.mem.mem_type == TTM_PL_VRAM &&
                       b->presumed.domain & NOUVEAU_GEM_DOMAIN_VRAM) ||
@@ -613,7 +614,20 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
                 return PTR_ERR(bo);
         }
 
-        mutex_lock(&dev->struct_mutex);
+        /* Mark push buffers as being used on PFIFO, the validation code
+         * will then make sure that if the pushbuf bo moves, that they
+         * happen on the kernel channel, which will in turn cause a sync
+         * to happen before we try and submit the push buffer.
+         */
+        for (i = 0; i < req->nr_push; i++) {
+                if (push[i].bo_index >= req->nr_buffers) {
+                        NV_ERROR(dev, "push %d buffer not in list\n", i);
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                bo[push[i].bo_index].read_domains |= (1 << 31);
+        }
 
         /* Validate buffer list */
         ret = nouveau_gem_pushbuf_validate(chan, file_priv, bo, req->buffers,
@@ -647,7 +661,7 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
                                       push[i].length);
                 }
         } else
-        if (dev_priv->card_type >= NV_20) {
+        if (dev_priv->chipset >= 0x25) {
                 ret = RING_SPACE(chan, req->nr_push * 2);
                 if (ret) {
                         NV_ERROR(dev, "cal_space: %d\n", ret);
@@ -713,7 +727,6 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
 out:
         validate_fini(&op, fence);
         nouveau_fence_unref((void**)&fence);
-        mutex_unlock(&dev->struct_mutex);
         kfree(bo);
         kfree(push);
 
@@ -722,7 +735,7 @@ out_next:
                 req->suffix0 = 0x00000000;
                 req->suffix1 = 0x00000000;
         } else
-        if (dev_priv->card_type >= NV_20) {
+        if (dev_priv->chipset >= 0x25) {
                 req->suffix0 = 0x00020000;
                 req->suffix1 = 0x00000000;
         } else {
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.c b/drivers/gpu/drm/nouveau/nouveau_i2c.c
index 0bd407ca3d42..84614858728b 100644
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.c
+++ b/drivers/gpu/drm/nouveau/nouveau_i2c.c
@@ -163,7 +163,7 @@ nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index)
         if (entry->chan)
                 return -EEXIST;
 
-        if (dev_priv->card_type == NV_C0 && entry->read >= NV50_I2C_PORTS) {
+        if (dev_priv->card_type >= NV_50 && entry->read >= NV50_I2C_PORTS) {
                 NV_ERROR(dev, "unknown i2c port %d\n", entry->read);
                 return -EINVAL;
         }
diff --git a/drivers/gpu/drm/nouveau/nouveau_sgdma.c b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
index 491767fe4fcf..6b9187d7f67d 100644
--- a/drivers/gpu/drm/nouveau/nouveau_sgdma.c
+++ b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
@@ -214,6 +214,7 @@ int
 nouveau_sgdma_init(struct drm_device *dev)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct pci_dev *pdev = dev->pdev;
         struct nouveau_gpuobj *gpuobj = NULL;
         uint32_t aper_size, obj_size;
         int i, ret;
@@ -239,10 +240,19 @@ nouveau_sgdma_init(struct drm_device *dev)
 
         dev_priv->gart_info.sg_dummy_page =
                 alloc_page(GFP_KERNEL|__GFP_DMA32);
+        if (!dev_priv->gart_info.sg_dummy_page) {
+                nouveau_gpuobj_del(dev, &gpuobj);
+                return -ENOMEM;
+        }
+
         set_bit(PG_locked, &dev_priv->gart_info.sg_dummy_page->flags);
         dev_priv->gart_info.sg_dummy_bus =
-                pci_map_page(dev->pdev, dev_priv->gart_info.sg_dummy_page, 0,
+                pci_map_page(pdev, dev_priv->gart_info.sg_dummy_page, 0,
                              PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
+        if (pci_dma_mapping_error(pdev, dev_priv->gart_info.sg_dummy_bus)) {
+                nouveau_gpuobj_del(dev, &gpuobj);
+                return -EFAULT;
+        }
 
         if (dev_priv->card_type < NV_50) {
                 /* Maybe use NV_DMA_TARGET_AGP for PCIE? NVIDIA do this, and
diff --git a/drivers/gpu/drm/nouveau/nv04_dfp.c b/drivers/gpu/drm/nouveau/nv04_dfp.c
index a5dcf7685800..0d3206a7046c 100644
--- a/drivers/gpu/drm/nouveau/nv04_dfp.c
+++ b/drivers/gpu/drm/nouveau/nv04_dfp.c
@@ -444,6 +444,7 @@ static void nv04_dfp_commit(struct drm_encoder *encoder)
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct dcb_entry *dcbe = nv_encoder->dcb;
         int head = nouveau_crtc(encoder->crtc)->index;
+        struct drm_encoder *slave_encoder;
 
         if (dcbe->type == OUTPUT_TMDS)
                 run_tmds_table(dev, dcbe, head, nv_encoder->mode.clock);
@@ -462,9 +463,10 @@ static void nv04_dfp_commit(struct drm_encoder *encoder)
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);
 
         /* Init external transmitters */
-        if (get_tmds_slave(encoder))
-                get_slave_funcs(get_tmds_slave(encoder))->mode_set(
-                        encoder, &nv_encoder->mode, &nv_encoder->mode);
+        slave_encoder = get_tmds_slave(encoder);
+        if (slave_encoder)
+                get_slave_funcs(slave_encoder)->mode_set(
+                        slave_encoder, &nv_encoder->mode, &nv_encoder->mode);
 
         helper->dpms(encoder, DRM_MODE_DPMS_ON);
 
@@ -473,6 +475,27 @@ static void nv04_dfp_commit(struct drm_encoder *encoder)
                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
 }
 
+static void nv04_dfp_update_backlight(struct drm_encoder *encoder, int mode)
+{
+#ifdef __powerpc__
+        struct drm_device *dev = encoder->dev;
+
+        /* BIOS scripts usually take care of the backlight, thanks
+         * Apple for your consistency.
+         */
+        if (dev->pci_device == 0x0179 || dev->pci_device == 0x0189 ||
+            dev->pci_device == 0x0329) {
+                if (mode == DRM_MODE_DPMS_ON) {
+                        nv_mask(dev, NV_PBUS_DEBUG_DUALHEAD_CTL, 0, 1 << 31);
+                        nv_mask(dev, NV_PCRTC_GPIO_EXT, 3, 1);
+                } else {
+                        nv_mask(dev, NV_PBUS_DEBUG_DUALHEAD_CTL, 1 << 31, 0);
+                        nv_mask(dev, NV_PCRTC_GPIO_EXT, 3, 0);
+                }
+        }
+#endif
+}
+
 static inline bool is_powersaving_dpms(int mode)
 {
         return (mode != DRM_MODE_DPMS_ON);
@@ -520,6 +543,7 @@ static void nv04_lvds_dpms(struct drm_encoder *encoder, int mode)
                                          LVDS_PANEL_OFF, 0);
         }
 
+        nv04_dfp_update_backlight(encoder, mode);
         nv04_dfp_update_fp_control(encoder, mode);
 
         if (mode == DRM_MODE_DPMS_ON)
@@ -543,6 +567,7 @@ static void nv04_tmds_dpms(struct drm_encoder *encoder, int mode)
         NV_INFO(dev, "Setting dpms mode %d on tmds encoder (output %d)\n",
                      mode, nv_encoder->dcb->index);
 
+        nv04_dfp_update_backlight(encoder, mode);
         nv04_dfp_update_fp_control(encoder, mode);
 }
 
diff --git a/drivers/gpu/drm/nouveau/nv17_tv.c b/drivers/gpu/drm/nouveau/nv17_tv.c
index 44fefb0c7083..13cdc05b7c2d 100644
--- a/drivers/gpu/drm/nouveau/nv17_tv.c
+++ b/drivers/gpu/drm/nouveau/nv17_tv.c
@@ -121,10 +121,14 @@ static bool
 get_tv_detect_quirks(struct drm_device *dev, uint32_t *pin_mask)
 {
         /* Zotac FX5200 */
-        if (dev->pdev->device == 0x0322 &&
-            dev->pdev->subsystem_vendor == 0x19da &&
-            (dev->pdev->subsystem_device == 0x1035 ||
-             dev->pdev->subsystem_device == 0x2035)) {
+        if (nv_match_device(dev, 0x0322, 0x19da, 0x1035) ||
+            nv_match_device(dev, 0x0322, 0x19da, 0x2035)) {
+                *pin_mask = 0xc;
+                return false;
+        }
+
+        /* MSI nForce2 IGP */
+        if (nv_match_device(dev, 0x01f0, 0x1462, 0x5710)) {
                 *pin_mask = 0xc;
                 return false;
         }
diff --git a/drivers/gpu/drm/nouveau/nv50_instmem.c b/drivers/gpu/drm/nouveau/nv50_instmem.c
index 37c7b48ab24a..91ef93cf1f35 100644
--- a/drivers/gpu/drm/nouveau/nv50_instmem.c
+++ b/drivers/gpu/drm/nouveau/nv50_instmem.c
@@ -139,6 +139,8 @@ nv50_instmem_init(struct drm_device *dev)
         chan->file_priv = (struct drm_file *)-2;
         dev_priv->fifos[0] = dev_priv->fifos[127] = chan;
 
+        INIT_LIST_HEAD(&chan->ramht_refs);
+
         /* Channel's PRAMIN object + heap */
         ret = nouveau_gpuobj_new_fake(dev, 0, c_offset, c_size, 0,
                                                         NULL, &chan->ramin);
@@ -278,7 +280,7 @@ nv50_instmem_init(struct drm_device *dev)
         /*XXX: incorrect, but needed to make hash func "work" */
         dev_priv->ramht_offset = 0x10000;
         dev_priv->ramht_bits   = 9;
-        dev_priv->ramht_size   = (1 << dev_priv->ramht_bits);
+        dev_priv->ramht_size   = (1 << dev_priv->ramht_bits) * 8;
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/nvc0_instmem.c b/drivers/gpu/drm/nouveau/nvc0_instmem.c
index 3ab3cdc42173..6b451f864783 100644
--- a/drivers/gpu/drm/nouveau/nvc0_instmem.c
+++ b/drivers/gpu/drm/nouveau/nvc0_instmem.c
@@ -142,14 +142,16 @@ int
 nvc0_instmem_suspend(struct drm_device *dev)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
+        u32 *buf;
         int i;
 
         dev_priv->susres.ramin_copy = vmalloc(65536);
         if (!dev_priv->susres.ramin_copy)
                 return -ENOMEM;
+        buf = dev_priv->susres.ramin_copy;
 
-        for (i = 0x700000; i < 0x710000; i += 4)
-                dev_priv->susres.ramin_copy[i/4] = nv_rd32(dev, i);
+        for (i = 0; i < 65536; i += 4)
+                buf[i/4] = nv_rd32(dev, NV04_PRAMIN + i);
         return 0;
 }
 
@@ -157,14 +159,15 @@ void
 nvc0_instmem_resume(struct drm_device *dev)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
+        u32 *buf = dev_priv->susres.ramin_copy;
         u64 chan;
         int i;
 
         chan = dev_priv->vram_size - dev_priv->ramin_rsvd_vram;
         nv_wr32(dev, 0x001700, chan >> 16);
 
-        for (i = 0x700000; i < 0x710000; i += 4)
-                nv_wr32(dev, i, dev_priv->susres.ramin_copy[i/4]);
+        for (i = 0; i < 65536; i += 4)
+                nv_wr32(dev, NV04_PRAMIN + i, buf[i/4]);
         vfree(dev_priv->susres.ramin_copy);
         dev_priv->susres.ramin_copy = NULL;
 
@@ -221,7 +224,7 @@ nvc0_instmem_init(struct drm_device *dev)
         /*XXX: incorrect, but needed to make hash func "work" */
         dev_priv->ramht_offset = 0x10000;
         dev_priv->ramht_bits   = 9;
-        dev_priv->ramht_size   = (1 << dev_priv->ramht_bits);
+        dev_priv->ramht_size   = (1 << dev_priv->ramht_bits) * 8;
         return 0;
 }
 
diff --git a/drivers/gpu/drm/r128/r128_state.c b/drivers/gpu/drm/r128/r128_state.c
index 077af1f2f9b4..a9e33ce65918 100644
--- a/drivers/gpu/drm/r128/r128_state.c
+++ b/drivers/gpu/drm/r128/r128_state.c
@@ -1639,30 +1639,29 @@ void r128_driver_preclose(struct drm_device *dev, struct drm_file *file_priv)
                         r128_do_cleanup_pageflip(dev);
         }
 }
-
 void r128_driver_lastclose(struct drm_device *dev)
 {
         r128_do_cleanup_cce(dev);
 }
 
 struct drm_ioctl_desc r128_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_R128_INIT, r128_cce_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_R128_CCE_START, r128_cce_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_R128_CCE_STOP, r128_cce_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_R128_CCE_RESET, r128_cce_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_R128_CCE_IDLE, r128_cce_idle, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_RESET, r128_engine_reset, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_FULLSCREEN, r128_fullscreen, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_SWAP, r128_cce_swap, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_FLIP, r128_cce_flip, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_CLEAR, r128_cce_clear, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_VERTEX, r128_cce_vertex, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_INDICES, r128_cce_indices, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_BLIT, r128_cce_blit, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_DEPTH, r128_cce_depth, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_STIPPLE, r128_cce_stipple, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_R128_INDIRECT, r128_cce_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_R128_GETPARAM, r128_getparam, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_INIT, r128_cce_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(R128_CCE_START, r128_cce_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(R128_CCE_STOP, r128_cce_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(R128_CCE_RESET, r128_cce_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(R128_CCE_IDLE, r128_cce_idle, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_RESET, r128_engine_reset, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_FULLSCREEN, r128_fullscreen, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_SWAP, r128_cce_swap, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_FLIP, r128_cce_flip, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_CLEAR, r128_cce_clear, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_VERTEX, r128_cce_vertex, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_INDICES, r128_cce_indices, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_BLIT, r128_cce_blit, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_DEPTH, r128_cce_depth, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_STIPPLE, r128_cce_stipple, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(R128_INDIRECT, r128_cce_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(R128_GETPARAM, r128_getparam, DRM_AUTH),
 };
 
 int r128_max_ioctl = DRM_ARRAY_SIZE(r128_ioctls);
diff --git a/drivers/gpu/drm/radeon/atombios.h b/drivers/gpu/drm/radeon/atombios.h
index 1bc72c3190a9..fe359a239df3 100644
--- a/drivers/gpu/drm/radeon/atombios.h
+++ b/drivers/gpu/drm/radeon/atombios.h
@@ -4999,7 +4999,7 @@ typedef struct _SW_I2C_IO_DATA_PARAMETERS
 #define SW_I2C_CNTL_WRITE1BIT 6
 
 //==============================VESA definition Portion===============================
-#define VESA_OEM_PRODUCT_REV                                '01.00'
+#define VESA_OEM_PRODUCT_REV                                "01.00"
 #define VESA_MODE_ATTRIBUTE_MODE_SUPPORT             0xBB       //refer to VBE spec p.32, no TTY support
 #define VESA_MODE_WIN_ATTRIBUTE                                              7
 #define VESA_WIN_SIZE                                                                                        64
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 12ad512bd3d3..cd0290f946cf 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -332,6 +332,11 @@ static void atombios_crtc_set_timing(struct drm_crtc *crtc,
         args.usV_SyncWidth =
                 cpu_to_le16(mode->crtc_vsync_end - mode->crtc_vsync_start);
 
+        args.ucOverscanRight = radeon_crtc->h_border;
+        args.ucOverscanLeft = radeon_crtc->h_border;
+        args.ucOverscanBottom = radeon_crtc->v_border;
+        args.ucOverscanTop = radeon_crtc->v_border;
+
         if (mode->flags & DRM_MODE_FLAG_NVSYNC)
                 misc |= ATOM_VSYNC_POLARITY;
         if (mode->flags & DRM_MODE_FLAG_NHSYNC)
@@ -471,6 +476,8 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
         struct radeon_encoder *radeon_encoder = NULL;
         u32 adjusted_clock = mode->clock;
         int encoder_mode = 0;
+        u32 dp_clock = mode->clock;
+        int bpc = 8;
 
         /* reset the pll flags */
         pll->flags = 0;
@@ -513,6 +520,17 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
                 if (encoder->crtc == crtc) {
                         radeon_encoder = to_radeon_encoder(encoder);
                         encoder_mode = atombios_get_encoder_mode(encoder);
+                        if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT | ATOM_DEVICE_DFP_SUPPORT)) {
+                                struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
+                                if (connector) {
+                                        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                                        struct radeon_connector_atom_dig *dig_connector =
+                                                radeon_connector->con_priv;
+
+                                        dp_clock = dig_connector->dp_clock;
+                                }
+                        }
+
                         if (ASIC_IS_AVIVO(rdev)) {
                                 /* DVO wants 2x pixel clock if the DVO chip is in 12 bit mode */
                                 if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1)
@@ -521,6 +539,21 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
                                         pll->algo = PLL_ALGO_LEGACY;
                                         pll->flags |= RADEON_PLL_PREFER_CLOSEST_LOWER;
                                 }
+                                /* There is some evidence (often anecdotal) that RV515/RV620 LVDS
+                                 * (on some boards at least) prefers the legacy algo.  I'm not
+                                 * sure whether this should handled generically or on a
+                                 * case-by-case quirk basis.  Both algos should work fine in the
+                                 * majority of cases.
+                                 */
+                                if ((radeon_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT)) &&
+                                    ((rdev->family == CHIP_RV515) ||
+                                     (rdev->family == CHIP_RV620))) {
+                                        /* allow the user to overrride just in case */
+                                        if (radeon_new_pll == 1)
+                                                pll->algo = PLL_ALGO_NEW;
+                                        else
+                                                pll->algo = PLL_ALGO_LEGACY;
+                                }
                         } else {
                                 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC)
                                         pll->flags |= RADEON_PLL_NO_ODD_POST_DIV;
@@ -555,6 +588,14 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
                                 args.v1.usPixelClock = cpu_to_le16(mode->clock / 10);
                                 args.v1.ucTransmitterID = radeon_encoder->encoder_id;
                                 args.v1.ucEncodeMode = encoder_mode;
+                                if (encoder_mode == ATOM_ENCODER_MODE_DP) {
+                                        /* may want to enable SS on DP eventually */
+                                        /* args.v1.ucConfig |=
+                                           ADJUST_DISPLAY_CONFIG_SS_ENABLE;*/
+                                } else if (encoder_mode == ATOM_ENCODER_MODE_LVDS) {
+                                        args.v1.ucConfig |=
+                                                ADJUST_DISPLAY_CONFIG_SS_ENABLE;
+                                }
 
                                 atom_execute_table(rdev->mode_info.atom_context,
                                                    index, (uint32_t *)&args);
@@ -568,10 +609,20 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
                                 if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) {
                                         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
 
-                                        if (encoder_mode == ATOM_ENCODER_MODE_DP)
+                                        if (encoder_mode == ATOM_ENCODER_MODE_DP) {
+                                                /* may want to enable SS on DP/eDP eventually */
+                                                /*args.v3.sInput.ucDispPllConfig |=
+                                                  DISPPLL_CONFIG_SS_ENABLE;*/
                                                 args.v3.sInput.ucDispPllConfig |=
                                                         DISPPLL_CONFIG_COHERENT_MODE;
-                                        else {
+                                                /* 16200 or 27000 */
+                                                args.v3.sInput.usPixelClock = cpu_to_le16(dp_clock / 10);
+                                        } else {
+                                                if (encoder_mode == ATOM_ENCODER_MODE_HDMI) {
+                                                        /* deep color support */
+                                                        args.v3.sInput.usPixelClock =
+                                                                cpu_to_le16((mode->clock * bpc / 8) / 10);
+                                                }
                                                 if (dig->coherent_mode)
                                                         args.v3.sInput.ucDispPllConfig |=
                                                                 DISPPLL_CONFIG_COHERENT_MODE;
@@ -580,13 +631,19 @@ static u32 atombios_adjust_pll(struct drm_crtc *crtc,
                                                                 DISPPLL_CONFIG_DUAL_LINK;
                                         }
                                 } else if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
-                                        /* may want to enable SS on DP/eDP eventually */
-                                        /*args.v3.sInput.ucDispPllConfig |=
-                                                DISPPLL_CONFIG_SS_ENABLE;*/
-                                        if (encoder_mode == ATOM_ENCODER_MODE_DP)
+                                        if (encoder_mode == ATOM_ENCODER_MODE_DP) {
+                                                /* may want to enable SS on DP/eDP eventually */
+                                                /*args.v3.sInput.ucDispPllConfig |=
+                                                  DISPPLL_CONFIG_SS_ENABLE;*/
                                                 args.v3.sInput.ucDispPllConfig |=
                                                         DISPPLL_CONFIG_COHERENT_MODE;
-                                        else {
+                                                /* 16200 or 27000 */
+                                                args.v3.sInput.usPixelClock = cpu_to_le16(dp_clock / 10);
+                                        } else if (encoder_mode == ATOM_ENCODER_MODE_LVDS) {
+                                                /* want to enable SS on LVDS eventually */
+                                                /*args.v3.sInput.ucDispPllConfig |=
+                                                  DISPPLL_CONFIG_SS_ENABLE;*/
+                                        } else {
                                                 if (mode->clock > 165000)
                                                         args.v3.sInput.ucDispPllConfig |=
                                                                 DISPPLL_CONFIG_DUAL_LINK;
@@ -1019,11 +1076,11 @@ static int avivo_crtc_set_base(struct drm_crtc *crtc, int x, int y,
 
         if (rdev->family >= CHIP_RV770) {
                 if (radeon_crtc->crtc_id) {
-                        WREG32(R700_D2GRPH_PRIMARY_SURFACE_ADDRESS_HIGH, 0);
-                        WREG32(R700_D2GRPH_SECONDARY_SURFACE_ADDRESS_HIGH, 0);
+                        WREG32(R700_D2GRPH_PRIMARY_SURFACE_ADDRESS_HIGH, upper_32_bits(fb_location));
+                        WREG32(R700_D2GRPH_SECONDARY_SURFACE_ADDRESS_HIGH, upper_32_bits(fb_location));
                 } else {
-                        WREG32(R700_D1GRPH_PRIMARY_SURFACE_ADDRESS_HIGH, 0);
-                        WREG32(R700_D1GRPH_SECONDARY_SURFACE_ADDRESS_HIGH, 0);
+                        WREG32(R700_D1GRPH_PRIMARY_SURFACE_ADDRESS_HIGH, upper_32_bits(fb_location));
+                        WREG32(R700_D1GRPH_SECONDARY_SURFACE_ADDRESS_HIGH, upper_32_bits(fb_location));
                 }
         }
         WREG32(AVIVO_D1GRPH_PRIMARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset,
@@ -1160,8 +1217,18 @@ int atombios_crtc_mode_set(struct drm_crtc *crtc,
         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
         struct drm_device *dev = crtc->dev;
         struct radeon_device *rdev = dev->dev_private;
+        struct drm_encoder *encoder;
+        bool is_tvcv = false;
 
-        /* TODO color tiling */
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+                /* find tv std */
+                if (encoder->crtc == crtc) {
+                        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+                        if (radeon_encoder->active_device &
+                            (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT))
+                                is_tvcv = true;
+                }
+        }
 
         atombios_disable_ss(crtc);
         /* always set DCPLL */
@@ -1170,9 +1237,14 @@ int atombios_crtc_mode_set(struct drm_crtc *crtc,
         atombios_crtc_set_pll(crtc, adjusted_mode);
         atombios_enable_ss(crtc);
 
-        if (ASIC_IS_AVIVO(rdev))
+        if (ASIC_IS_DCE4(rdev))
                 atombios_set_crtc_dtd_timing(crtc, adjusted_mode);
-        else {
+        else if (ASIC_IS_AVIVO(rdev)) {
+                if (is_tvcv)
+                        atombios_crtc_set_timing(crtc, adjusted_mode);
+                else
+                        atombios_set_crtc_dtd_timing(crtc, adjusted_mode);
+        } else {
                 atombios_crtc_set_timing(crtc, adjusted_mode);
                 if (radeon_crtc->crtc_id == 0)
                         atombios_set_crtc_dtd_timing(crtc, adjusted_mode);
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
index 36e0d4b545e6..4e7778d44b8d 100644
--- a/drivers/gpu/drm/radeon/atombios_dp.c
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -610,7 +610,7 @@ void dp_link_train(struct drm_encoder *encoder,
                 enc_id |= ATOM_DP_CONFIG_DIG2_ENCODER;
         else
                 enc_id |= ATOM_DP_CONFIG_DIG1_ENCODER;
-        if (dig_connector->linkb)
+        if (dig->linkb)
                 enc_id |= ATOM_DP_CONFIG_LINK_B;
         else
                 enc_id |= ATOM_DP_CONFIG_LINK_A;
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 957d5067ad9c..79082d4398ae 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -675,6 +675,43 @@ static int evergreen_cp_load_microcode(struct radeon_device *rdev)
         return 0;
 }
 
+static int evergreen_cp_start(struct radeon_device *rdev)
+{
+        int r;
+        uint32_t cp_me;
+
+        r = radeon_ring_lock(rdev, 7);
+        if (r) {
+                DRM_ERROR("radeon: cp failed to lock ring (%d).\n", r);
+                return r;
+        }
+        radeon_ring_write(rdev, PACKET3(PACKET3_ME_INITIALIZE, 5));
+        radeon_ring_write(rdev, 0x1);
+        radeon_ring_write(rdev, 0x0);
+        radeon_ring_write(rdev, rdev->config.evergreen.max_hw_contexts - 1);
+        radeon_ring_write(rdev, PACKET3_ME_INITIALIZE_DEVICE_ID(1));
+        radeon_ring_write(rdev, 0);
+        radeon_ring_write(rdev, 0);
+        radeon_ring_unlock_commit(rdev);
+
+        cp_me = 0xff;
+        WREG32(CP_ME_CNTL, cp_me);
+
+        r = radeon_ring_lock(rdev, 4);
+        if (r) {
+                DRM_ERROR("radeon: cp failed to lock ring (%d).\n", r);
+                return r;
+        }
+        /* init some VGT regs */
+        radeon_ring_write(rdev, PACKET3(PACKET3_SET_CONTEXT_REG, 2));
+        radeon_ring_write(rdev, (VGT_VERTEX_REUSE_BLOCK_CNTL - PACKET3_SET_CONTEXT_REG_START) >> 2);
+        radeon_ring_write(rdev, 0xe);
+        radeon_ring_write(rdev, 0x10);
+        radeon_ring_unlock_commit(rdev);
+
+        return 0;
+}
+
 int evergreen_cp_resume(struct radeon_device *rdev)
 {
         u32 tmp;
@@ -719,7 +756,7 @@ int evergreen_cp_resume(struct radeon_device *rdev)
         rdev->cp.rptr = RREG32(CP_RB_RPTR);
         rdev->cp.wptr = RREG32(CP_RB_WPTR);
 
-        r600_cp_start(rdev);
+        evergreen_cp_start(rdev);
         rdev->cp.ready = true;
         r = radeon_ring_test(rdev);
         if (r) {
@@ -1123,14 +1160,25 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
                                                                         EVERGREEN_MAX_BACKENDS_MASK));
                         break;
                 }
-        } else
-                gb_backend_map =
-                        evergreen_get_tile_pipe_to_backend_map(rdev,
-                                                               rdev->config.evergreen.max_tile_pipes,
-                                                               rdev->config.evergreen.max_backends,
-                                                               ((EVERGREEN_MAX_BACKENDS_MASK <<
-                                                                 rdev->config.evergreen.max_backends) &
-                                                                EVERGREEN_MAX_BACKENDS_MASK));
+        } else {
+                switch (rdev->family) {
+                case CHIP_CYPRESS:
+                case CHIP_HEMLOCK:
+                        gb_backend_map = 0x66442200;
+                        break;
+                case CHIP_JUNIPER:
+                        gb_backend_map = 0x00006420;
+                        break;
+                default:
+                        gb_backend_map =
+                                evergreen_get_tile_pipe_to_backend_map(rdev,
+                                                                       rdev->config.evergreen.max_tile_pipes,
+                                                                       rdev->config.evergreen.max_backends,
+                                                                       ((EVERGREEN_MAX_BACKENDS_MASK <<
+                                                                         rdev->config.evergreen.max_backends) &
+                                                                        EVERGREEN_MAX_BACKENDS_MASK));
+                }
+        }
 
         rdev->config.evergreen.tile_config = gb_addr_config;
         WREG32(GB_BACKEND_MAP, gb_backend_map);
@@ -2054,11 +2102,6 @@ int evergreen_resume(struct radeon_device *rdev)
          */
         /* post card */
         atom_asic_init(rdev->mode_info.atom_context);
-        /* Initialize clocks */
-        r = radeon_clocks_init(rdev);
-        if (r) {
-                return r;
-        }
 
         r = evergreen_startup(rdev);
         if (r) {
@@ -2164,9 +2207,6 @@ int evergreen_init(struct radeon_device *rdev)
         radeon_surface_init(rdev);
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
-        r = radeon_clocks_init(rdev);
-        if (r)
-                return r;
         /* Fence driver */
         r = radeon_fence_driver_init(rdev);
         if (r)
@@ -2236,7 +2276,6 @@ void evergreen_fini(struct radeon_device *rdev)
         evergreen_pcie_gart_fini(rdev);
         radeon_gem_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_clocks_fini(rdev);
         radeon_agp_fini(rdev);
         radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index e817a0bb5eb4..e151f16a8f86 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -2020,18 +2020,7 @@ bool r100_gpu_cp_is_lockup(struct radeon_device *rdev, struct r100_gpu_lockup *l
                 return false;
         }
         elapsed = jiffies_to_msecs(cjiffies - lockup->last_jiffies);
-        if (elapsed >= 3000) {
-                /* very likely the improbable case where current
-                 * rptr is equal to last recorded, a while ago, rptr
-                 * this is more likely a false positive update tracking
-                 * information which should force us to be recall at
-                 * latter point
-                 */
-                lockup->last_cp_rptr = cp->rptr;
-                lockup->last_jiffies = jiffies;
-                return false;
-        }
-        if (elapsed >= 1000) {
+        if (elapsed >= 10000) {
                 dev_err(rdev->dev, "GPU lockup CP stall for more than %lumsec\n", elapsed);
                 return true;
         }
@@ -3308,13 +3297,14 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
         unsigned long size;
         unsigned prim_walk;
         unsigned nverts;
+        unsigned num_cb = track->num_cb;
 
-        for (i = 0; i < track->num_cb; i++) {
+        if (!track->zb_cb_clear && !track->color_channel_mask &&
+            !track->blend_read_enable)
+                num_cb = 0;
+
+        for (i = 0; i < num_cb; i++) {
                 if (track->cb[i].robj == NULL) {
-                        if (!(track->zb_cb_clear || track->color_channel_mask ||
-                              track->blend_read_enable)) {
-                                continue;
-                        }
                         DRM_ERROR("[drm] No buffer for color buffer %d !\n", i);
                         return -EINVAL;
                 }
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c
index d0ebae9dde25..7a04959ba0ee 100644
--- a/drivers/gpu/drm/radeon/r600.c
+++ b/drivers/gpu/drm/radeon/r600.c
@@ -2119,10 +2119,7 @@ int r600_cp_start(struct radeon_device *rdev)
         }
         radeon_ring_write(rdev, PACKET3(PACKET3_ME_INITIALIZE, 5));
         radeon_ring_write(rdev, 0x1);
-        if (rdev->family >= CHIP_CEDAR) {
-                radeon_ring_write(rdev, 0x0);
-                radeon_ring_write(rdev, rdev->config.evergreen.max_hw_contexts - 1);
-        } else if (rdev->family >= CHIP_RV770) {
+        if (rdev->family >= CHIP_RV770) {
                 radeon_ring_write(rdev, 0x0);
                 radeon_ring_write(rdev, rdev->config.rv770.max_hw_contexts - 1);
         } else {
@@ -2489,11 +2486,6 @@ int r600_resume(struct radeon_device *rdev)
          */
         /* post card */
         atom_asic_init(rdev->mode_info.atom_context);
-        /* Initialize clocks */
-        r = radeon_clocks_init(rdev);
-        if (r) {
-                return r;
-        }
 
         r = r600_startup(rdev);
         if (r) {
@@ -2586,9 +2578,6 @@ int r600_init(struct radeon_device *rdev)
         radeon_surface_init(rdev);
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
-        r = radeon_clocks_init(rdev);
-        if (r)
-                return r;
         /* Fence driver */
         r = radeon_fence_driver_init(rdev);
         if (r)
@@ -2663,7 +2652,6 @@ void r600_fini(struct radeon_device *rdev)
         radeon_agp_fini(rdev);
         radeon_gem_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_clocks_fini(rdev);
         radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
@@ -2741,7 +2729,7 @@ int r600_ib_test(struct radeon_device *rdev)
         if (i < rdev->usec_timeout) {
                 DRM_INFO("ib test succeeded in %u usecs\n", i);
         } else {
-                DRM_ERROR("radeon: ib test failed (sracth(0x%04X)=0x%08X)\n",
+                DRM_ERROR("radeon: ib test failed (scratch(0x%04X)=0x%08X)\n",
                           scratch, tmp);
                 r = -EINVAL;
         }
@@ -3540,8 +3528,9 @@ void r600_ioctl_wait_idle(struct radeon_device *rdev, struct radeon_bo *bo)
         /* r7xx hw bug.  write to HDP_DEBUG1 followed by fb read
          * rather than write to HDP_REG_COHERENCY_FLUSH_CNTL
          */
-        if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740)) {
-                void __iomem *ptr = (void *)rdev->gart.table.vram.ptr;
+        if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740) &&
+            rdev->vram_scratch.ptr) {
+                void __iomem *ptr = (void *)rdev->vram_scratch.ptr;
                 u32 tmp;
 
                 WREG32(HDP_DEBUG1, 0);
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c
index d13622ae74e9..9ceb2a1ce799 100644
--- a/drivers/gpu/drm/radeon/r600_blit_kms.c
+++ b/drivers/gpu/drm/radeon/r600_blit_kms.c
@@ -1,3 +1,28 @@
+/*
+ * Copyright 2009 Advanced Micro Devices, Inc.
+ * Copyright 2009 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, 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) AND/OR ITS SUPPLIERS 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.
+ *
+ */
+
 #include "drmP.h"
 #include "drm.h"
 #include "radeon_drm.h"
diff --git a/drivers/gpu/drm/radeon/r600_blit_shaders.h b/drivers/gpu/drm/radeon/r600_blit_shaders.h
index fdc3b378cbb0..f437d36dd98c 100644
--- a/drivers/gpu/drm/radeon/r600_blit_shaders.h
+++ b/drivers/gpu/drm/radeon/r600_blit_shaders.h
@@ -1,3 +1,27 @@
+/*
+ * Copyright 2009 Advanced Micro Devices, Inc.
+ * Copyright 2009 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, 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) AND/OR ITS SUPPLIERS 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.
+ *
+ */
 
 #ifndef R600_BLIT_SHADERS_H
 #define R600_BLIT_SHADERS_H
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index d8864949e387..250a3a918193 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -1170,9 +1170,8 @@ static inline int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 i
         /* using get ib will give us the offset into the mipmap bo */
         word0 = radeon_get_ib_value(p, idx + 3) << 8;
         if ((mipmap_size + word0) > radeon_bo_size(mipmap)) {
-                dev_warn(p->dev, "mipmap bo too small (%d %d %d %d %d %d -> %d have %ld)\n",
-                        w0, h0, bpe, blevel, nlevels, word0, mipmap_size, radeon_bo_size(texture));
-                return -EINVAL;
+                /*dev_warn(p->dev, "mipmap bo too small (%d %d %d %d %d %d -> %d have %ld)\n",
+                  w0, h0, bpe, blevel, nlevels, word0, mipmap_size, radeon_bo_size(texture));*/
         }
         return 0;
 }
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 3dfcfa3ca425..a168d644bf9e 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -1013,6 +1013,11 @@ int radeon_gem_set_tiling_ioctl(struct drm_device *dev, void *data,
 int radeon_gem_get_tiling_ioctl(struct drm_device *dev, void *data,
                                 struct drm_file *filp);
 
+/* VRAM scratch page for HDP bug */
+struct r700_vram_scratch {
+        struct radeon_bo                *robj;
+        volatile uint32_t               *ptr;
+};
 
 /*
  * Core structure, functions and helpers.
@@ -1079,6 +1084,7 @@ struct radeon_device {
         const struct firmware *pfp_fw;  /* r6/700 PFP firmware */
         const struct firmware *rlc_fw;  /* r6/700 RLC firmware */
         struct r600_blit r600_blit;
+        struct r700_vram_scratch vram_scratch;
         int msi_enabled; /* msi enabled */
         struct r600_ih ih; /* r6/700 interrupt ring */
         struct workqueue_struct *wq;
@@ -1333,8 +1339,6 @@ extern bool radeon_card_posted(struct radeon_device *rdev);
 extern void radeon_update_bandwidth_info(struct radeon_device *rdev);
 extern void radeon_update_display_priority(struct radeon_device *rdev);
 extern bool radeon_boot_test_post_card(struct radeon_device *rdev);
-extern int radeon_clocks_init(struct radeon_device *rdev);
-extern void radeon_clocks_fini(struct radeon_device *rdev);
 extern void radeon_scratch_init(struct radeon_device *rdev);
 extern void radeon_surface_init(struct radeon_device *rdev);
 extern int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data);
diff --git a/drivers/gpu/drm/radeon/radeon_agp.c b/drivers/gpu/drm/radeon/radeon_agp.c
index f40dfb77f9b1..bd2f33e5c91a 100644
--- a/drivers/gpu/drm/radeon/radeon_agp.c
+++ b/drivers/gpu/drm/radeon/radeon_agp.c
@@ -156,7 +156,13 @@ int radeon_agp_init(struct radeon_device *rdev)
         }
 
         mode.mode = info.mode;
-        agp_status = (RREG32(RADEON_AGP_STATUS) | RADEON_AGPv3_MODE) & mode.mode;
+        /* chips with the agp to pcie bridge don't have the AGP_STATUS register
+         * Just use the whatever mode the host sets up.
+         */
+        if (rdev->family <= CHIP_RV350)
+                agp_status = (RREG32(RADEON_AGP_STATUS) | RADEON_AGPv3_MODE) & mode.mode;
+        else
+                agp_status = mode.mode;
         is_v3 = !!(agp_status & RADEON_AGPv3_MODE);
 
         if (is_v3) {
diff --git a/drivers/gpu/drm/radeon/radeon_asic.c b/drivers/gpu/drm/radeon/radeon_asic.c
index 646f96f97c77..25e1dd197791 100644
--- a/drivers/gpu/drm/radeon/radeon_asic.c
+++ b/drivers/gpu/drm/radeon/radeon_asic.c
@@ -733,6 +733,7 @@ static struct radeon_asic evergreen_asic = {
         .set_engine_clock = &radeon_atom_set_engine_clock,
         .get_memory_clock = &radeon_atom_get_memory_clock,
         .set_memory_clock = &radeon_atom_set_memory_clock,
+        .get_pcie_lanes = NULL,
         .set_pcie_lanes = NULL,
         .set_clock_gating = NULL,
         .set_surface_reg = r600_set_surface_reg,
@@ -857,21 +858,3 @@ int radeon_asic_init(struct radeon_device *rdev)
         return 0;
 }
 
-/*
- * Wrapper around modesetting bits. Move to radeon_clocks.c?
- */
-int radeon_clocks_init(struct radeon_device *rdev)
-{
-        int r;
-
-        r = radeon_static_clocks_init(rdev->ddev);
-        if (r) {
-                return r;
-        }
-        DRM_INFO("Clocks initialized !\n");
-        return 0;
-}
-
-void radeon_clocks_fini(struct radeon_device *rdev)
-{
-}
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 6d30868744ee..68932ba7b8a4 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -32,11 +32,11 @@
 
 /* from radeon_encoder.c */
 extern uint32_t
-radeon_get_encoder_id(struct drm_device *dev, uint32_t supported_device,
-                      uint8_t dac);
+radeon_get_encoder_enum(struct drm_device *dev, uint32_t supported_device,
+                        uint8_t dac);
 extern void radeon_link_encoder_connector(struct drm_device *dev);
 extern void
-radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id,
+radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_enum,
                         uint32_t supported_device);
 
 /* from radeon_connector.c */
@@ -46,14 +46,14 @@ radeon_add_atom_connector(struct drm_device *dev,
                           uint32_t supported_device,
                           int connector_type,
                           struct radeon_i2c_bus_rec *i2c_bus,
-                          bool linkb, uint32_t igp_lane_info,
+                          uint32_t igp_lane_info,
                           uint16_t connector_object_id,
                           struct radeon_hpd *hpd,
                           struct radeon_router *router);
 
 /* from radeon_legacy_encoder.c */
 extern void
-radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id,
+radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum,
                           uint32_t supported_device);
 
 union atom_supported_devices {
@@ -85,6 +85,19 @@ static inline struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_dev
                 for (i = 0; i < num_indices; i++) {
                         gpio = &i2c_info->asGPIO_Info[i];
 
+                        /* some evergreen boards have bad data for this entry */
+                        if (ASIC_IS_DCE4(rdev)) {
+                                if ((i == 7) &&
+                                    (gpio->usClkMaskRegisterIndex == 0x1936) &&
+                                    (gpio->sucI2cId.ucAccess == 0)) {
+                                        gpio->sucI2cId.ucAccess = 0x97;
+                                        gpio->ucDataMaskShift = 8;
+                                        gpio->ucDataEnShift = 8;
+                                        gpio->ucDataY_Shift = 8;
+                                        gpio->ucDataA_Shift = 8;
+                                }
+                        }
+
                         if (gpio->sucI2cId.ucAccess == id) {
                                 i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
                                 i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
@@ -147,6 +160,20 @@ void radeon_atombios_i2c_init(struct radeon_device *rdev)
                 for (i = 0; i < num_indices; i++) {
                         gpio = &i2c_info->asGPIO_Info[i];
                         i2c.valid = false;
+
+                        /* some evergreen boards have bad data for this entry */
+                        if (ASIC_IS_DCE4(rdev)) {
+                                if ((i == 7) &&
+                                    (gpio->usClkMaskRegisterIndex == 0x1936) &&
+                                    (gpio->sucI2cId.ucAccess == 0)) {
+                                        gpio->sucI2cId.ucAccess = 0x97;
+                                        gpio->ucDataMaskShift = 8;
+                                        gpio->ucDataEnShift = 8;
+                                        gpio->ucDataY_Shift = 8;
+                                        gpio->ucDataA_Shift = 8;
+                                }
+                        }
+
                         i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
                         i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
                         i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
@@ -226,6 +253,8 @@ static struct radeon_hpd radeon_atom_get_hpd_info_from_gpio(struct radeon_device
         struct radeon_hpd hpd;
         u32 reg;
 
+        memset(&hpd, 0, sizeof(struct radeon_hpd));
+
         if (ASIC_IS_DCE4(rdev))
                 reg = EVERGREEN_DC_GPIO_HPD_A;
         else
@@ -288,6 +317,15 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                         *connector_type = DRM_MODE_CONNECTOR_DVID;
         }
 
+        /* MSI K9A2GM V2/V3 board has no HDMI or DVI */
+        if ((dev->pdev->device == 0x796e) &&
+            (dev->pdev->subsystem_vendor == 0x1462) &&
+            (dev->pdev->subsystem_device == 0x7302)) {
+                if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) ||
+                    (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
+                        return false;
+        }
+
         /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
         if ((dev->pdev->device == 0x7941) &&
             (dev->pdev->subsystem_vendor == 0x147b) &&
@@ -477,7 +515,6 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
         int i, j, k, path_size, device_support;
         int connector_type;
         u16 igp_lane_info, conn_id, connector_object_id;
-        bool linkb;
         struct radeon_i2c_bus_rec ddc_bus;
         struct radeon_router router;
         struct radeon_gpio_rec gpio;
@@ -510,7 +547,7 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                 addr += path_size;
                 path = (ATOM_DISPLAY_OBJECT_PATH *) addr;
                 path_size += le16_to_cpu(path->usSize);
-                linkb = false;
+
                 if (device_support & le16_to_cpu(path->usDeviceTag)) {
                         uint8_t con_obj_id, con_obj_num, con_obj_type;
 
@@ -601,13 +638,10 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                      OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
 
                                 if (grph_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
-                                        if (grph_obj_num == 2)
-                                                linkb = true;
-                                        else
-                                                linkb = false;
+                                        u16 encoder_obj = le16_to_cpu(path->usGraphicObjIds[j]);
 
                                         radeon_add_atom_encoder(dev,
-                                                                grph_obj_id,
+                                                                encoder_obj,
                                                                 le16_to_cpu
                                                                 (path->
                                                                  usDeviceTag));
@@ -744,7 +778,7 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                                   le16_to_cpu(path->
                                                               usDeviceTag),
                                                   connector_type, &ddc_bus,
-                                                  linkb, igp_lane_info,
+                                                  igp_lane_info,
                                                   connector_object_id,
                                                   &hpd,
                                                   &router);
@@ -933,13 +967,13 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
 
                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom)
                         radeon_add_atom_encoder(dev,
-                                                radeon_get_encoder_id(dev,
+                                                radeon_get_encoder_enum(dev,
                                                                       (1 << i),
                                                                       dac),
                                                 (1 << i));
                 else
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         (1 << i),
                                                                         dac),
                                                   (1 << i));
@@ -996,7 +1030,7 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
                                                   bios_connectors[i].
                                                   connector_type,
                                                   &bios_connectors[i].ddc_bus,
-                                                  false, 0,
+                                                  0,
                                                   connector_object_id,
                                                   &bios_connectors[i].hpd,
                                                   &router);
@@ -1183,7 +1217,7 @@ bool radeon_atombios_sideport_present(struct radeon_device *rdev)
                                 return true;
                         break;
                 case 2:
-                        if (igp_info->info_2.ucMemoryType & 0x0f)
+                        if (igp_info->info_2.ulBootUpSidePortClock)
                                 return true;
                         break;
                 default:
@@ -1305,6 +1339,7 @@ struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
         union lvds_info *lvds_info;
         uint8_t frev, crev;
         struct radeon_encoder_atom_dig *lvds = NULL;
+        int encoder_enum = (encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
 
         if (atom_parse_data_header(mode_info->atom_context, index, NULL,
                                    &frev, &crev, &data_offset)) {
@@ -1368,6 +1403,12 @@ struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
                 }
 
                 encoder->native_mode = lvds->native_mode;
+
+                if (encoder_enum == 2)
+                        lvds->linkb = true;
+                else
+                        lvds->linkb = false;
+
         }
         return lvds;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c
index 14448a740ba6..5249af8931e6 100644
--- a/drivers/gpu/drm/radeon/radeon_clocks.c
+++ b/drivers/gpu/drm/radeon/radeon_clocks.c
@@ -327,6 +327,14 @@ void radeon_get_clock_info(struct drm_device *dev)
         mpll->max_feedback_div = 0xff;
         mpll->best_vco = 0;
 
+        if (!rdev->clock.default_sclk)
+                rdev->clock.default_sclk = radeon_get_engine_clock(rdev);
+        if ((!rdev->clock.default_mclk) && rdev->asic->get_memory_clock)
+                rdev->clock.default_mclk = radeon_get_memory_clock(rdev);
+
+        rdev->pm.current_sclk = rdev->clock.default_sclk;
+        rdev->pm.current_mclk = rdev->clock.default_mclk;
+
 }
 
 /* 10 khz */
@@ -897,53 +905,3 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable)
         }
 }
 
-static void radeon_apply_clock_quirks(struct radeon_device *rdev)
-{
-        uint32_t tmp;
-
-        /* XXX make sure engine is idle */
-
-        if (rdev->family < CHIP_RS600) {
-                tmp = RREG32_PLL(RADEON_SCLK_CNTL);
-                if (ASIC_IS_R300(rdev) || ASIC_IS_RV100(rdev))
-                        tmp |= RADEON_SCLK_FORCE_CP | RADEON_SCLK_FORCE_VIP;
-                if ((rdev->family == CHIP_RV250)
-                    || (rdev->family == CHIP_RV280))
-                        tmp |=
-                            RADEON_SCLK_FORCE_DISP1 | RADEON_SCLK_FORCE_DISP2;
-                if ((rdev->family == CHIP_RV350)
-                    || (rdev->family == CHIP_RV380))
-                        tmp |= R300_SCLK_FORCE_VAP;
-                if (rdev->family == CHIP_R420)
-                        tmp |= R300_SCLK_FORCE_PX | R300_SCLK_FORCE_TX;
-                WREG32_PLL(RADEON_SCLK_CNTL, tmp);
-        } else if (rdev->family < CHIP_R600) {
-                tmp = RREG32_PLL(AVIVO_CP_DYN_CNTL);
-                tmp |= AVIVO_CP_FORCEON;
-                WREG32_PLL(AVIVO_CP_DYN_CNTL, tmp);
-
-                tmp = RREG32_PLL(AVIVO_E2_DYN_CNTL);
-                tmp |= AVIVO_E2_FORCEON;
-                WREG32_PLL(AVIVO_E2_DYN_CNTL, tmp);
-
-                tmp = RREG32_PLL(AVIVO_IDCT_DYN_CNTL);
-                tmp |= AVIVO_IDCT_FORCEON;
-                WREG32_PLL(AVIVO_IDCT_DYN_CNTL, tmp);
-        }
-}
-
-int radeon_static_clocks_init(struct drm_device *dev)
-{
-        struct radeon_device *rdev = dev->dev_private;
-
-        /* XXX make sure engine is idle */
-
-        if (radeon_dynclks != -1) {
-                if (radeon_dynclks) {
-                        if (rdev->asic->set_clock_gating)
-                                radeon_set_clock_gating(rdev, 1);
-                }
-        }
-        radeon_apply_clock_quirks(rdev);
-        return 0;
-}
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index 885dcfac1838..a04b7a6ad95f 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -39,8 +39,8 @@
 
 /* from radeon_encoder.c */
 extern uint32_t
-radeon_get_encoder_id(struct drm_device *dev, uint32_t supported_device,
-                      uint8_t dac);
+radeon_get_encoder_enum(struct drm_device *dev, uint32_t supported_device,
+                        uint8_t dac);
 extern void radeon_link_encoder_connector(struct drm_device *dev);
 
 /* from radeon_connector.c */
@@ -55,7 +55,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
 
 /* from radeon_legacy_encoder.c */
 extern void
-radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id,
+radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum,
                           uint32_t supported_device);
 
 /* old legacy ATI BIOS routines */
@@ -1485,6 +1485,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         /* PowerMac8,1 ? */
                         /* imac g5 isight */
                         rdev->mode_info.connector_table = CT_IMAC_G5_ISIGHT;
+                } else if ((rdev->pdev->device == 0x4a48) &&
+                           (rdev->pdev->subsystem_vendor == 0x1002) &&
+                           (rdev->pdev->subsystem_device == 0x4a48)) {
+                        /* Mac X800 */
+                        rdev->mode_info.connector_table = CT_MAC_X800;
                 } else
 #endif /* CONFIG_PPC_PMAC */
 #ifdef CONFIG_PPC64
@@ -1505,7 +1510,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
                                                                         1),
                                                   ATOM_DEVICE_CRT1_SUPPORT);
@@ -1520,7 +1525,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         ddc_i2c = combios_setup_i2c_bus(rdev, DDC_NONE_DETECTED, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_LCD1_SUPPORT,
                                                                         0),
                                                   ATOM_DEVICE_LCD1_SUPPORT);
@@ -1535,7 +1540,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
                                                                         1),
                                                   ATOM_DEVICE_CRT1_SUPPORT);
@@ -1550,12 +1555,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                         hpd.hpd = RADEON_HPD_1;
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_DFP1_SUPPORT,
                                                                         0),
                                                   ATOM_DEVICE_DFP1_SUPPORT);
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_CRT2_SUPPORT,
                                                                         2),
                                                   ATOM_DEVICE_CRT2_SUPPORT);
@@ -1571,7 +1576,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
                                                                         1),
                                                   ATOM_DEVICE_CRT1_SUPPORT);
@@ -1588,7 +1593,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                         ddc_i2c.valid = false;
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_TV1_SUPPORT,
                                                                         2),
                                                   ATOM_DEVICE_TV1_SUPPORT);
@@ -1607,7 +1612,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_LCD1_SUPPORT);
@@ -1619,7 +1624,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_CRT2_SUPPORT);
@@ -1631,7 +1636,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1648,7 +1653,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_LCD1_SUPPORT);
@@ -1660,12 +1665,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_2; /* ??? */
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_DFP2_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_DFP2_SUPPORT);
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                 1),
                                           ATOM_DEVICE_CRT1_SUPPORT);
@@ -1680,7 +1685,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1697,7 +1702,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_LCD1_SUPPORT);
@@ -1709,12 +1714,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_DFP1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_DFP1_SUPPORT);
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                 1),
                                           ATOM_DEVICE_CRT1_SUPPORT);
@@ -1728,7 +1733,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1745,7 +1750,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_LCD1_SUPPORT);
@@ -1757,7 +1762,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                 1),
                                           ATOM_DEVICE_CRT1_SUPPORT);
@@ -1769,7 +1774,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1786,12 +1791,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_2; /* ??? */
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_DFP2_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_DFP2_SUPPORT);
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_CRT2_SUPPORT);
@@ -1806,7 +1811,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1823,12 +1828,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_DFP1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_DFP1_SUPPORT);
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_CRT2_SUPPORT);
@@ -1842,7 +1847,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1859,7 +1864,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
                 hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_DFP1_SUPPORT,
                                                                 0),
                                           ATOM_DEVICE_DFP1_SUPPORT);
@@ -1871,7 +1876,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_CRT2_SUPPORT);
@@ -1883,7 +1888,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1900,7 +1905,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                 1),
                                           ATOM_DEVICE_CRT1_SUPPORT);
@@ -1912,7 +1917,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_CRT2_SUPPORT);
@@ -1924,7 +1929,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c.valid = false;
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_TV1_SUPPORT);
@@ -1941,7 +1946,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                 1),
                                           ATOM_DEVICE_CRT1_SUPPORT);
@@ -1952,7 +1957,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
-                                          radeon_get_encoder_id(dev,
+                                          radeon_get_encoder_enum(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
                                                                 2),
                                           ATOM_DEVICE_CRT2_SUPPORT);
@@ -1961,6 +1966,48 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_VGA,
                                             &hpd);
                 break;
+        case CT_MAC_X800:
+                DRM_INFO("Connector Table: %d (mac x800)\n",
+                         rdev->mode_info.connector_table);
+                /* DVI - primary dac, internal tmds */
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
+                hpd.hpd = RADEON_HPD_1; /* ??? */
+                radeon_add_legacy_encoder(dev,
+                                          radeon_get_encoder_enum(dev,
+                                                                  ATOM_DEVICE_DFP1_SUPPORT,
+                                                                  0),
+                                          ATOM_DEVICE_DFP1_SUPPORT);
+                radeon_add_legacy_encoder(dev,
+                                          radeon_get_encoder_enum(dev,
+                                                                  ATOM_DEVICE_CRT1_SUPPORT,
+                                                                  1),
+                                          ATOM_DEVICE_CRT1_SUPPORT);
+                radeon_add_legacy_connector(dev, 0,
+                                            ATOM_DEVICE_DFP1_SUPPORT |
+                                            ATOM_DEVICE_CRT1_SUPPORT,
+                                            DRM_MODE_CONNECTOR_DVII, &ddc_i2c,
+                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I,
+                                            &hpd);
+                /* DVI - tv dac, dvo */
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
+                hpd.hpd = RADEON_HPD_2; /* ??? */
+                radeon_add_legacy_encoder(dev,
+                                          radeon_get_encoder_enum(dev,
+                                                                  ATOM_DEVICE_DFP2_SUPPORT,
+                                                                  0),
+                                          ATOM_DEVICE_DFP2_SUPPORT);
+                radeon_add_legacy_encoder(dev,
+                                          radeon_get_encoder_enum(dev,
+                                                                  ATOM_DEVICE_CRT2_SUPPORT,
+                                                                  2),
+                                          ATOM_DEVICE_CRT2_SUPPORT);
+                radeon_add_legacy_connector(dev, 1,
+                                            ATOM_DEVICE_DFP2_SUPPORT |
+                                            ATOM_DEVICE_CRT2_SUPPORT,
+                                            DRM_MODE_CONNECTOR_DVII, &ddc_i2c,
+                                            CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I,
+                                            &hpd);
+                break;
         default:
                 DRM_INFO("Connector table: %d (invalid)\n",
                          rdev->mode_info.connector_table);
@@ -2109,7 +2156,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 else
                                         devices = ATOM_DEVICE_DFP1_SUPPORT;
                                 radeon_add_legacy_encoder(dev,
-                                                          radeon_get_encoder_id
+                                                          radeon_get_encoder_enum
                                                           (dev, devices, 0),
                                                           devices);
                                 radeon_add_legacy_connector(dev, i, devices,
@@ -2123,7 +2170,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 if (tmp & 0x1) {
                                         devices = ATOM_DEVICE_CRT2_SUPPORT;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_CRT2_SUPPORT,
                                                                    2),
@@ -2131,7 +2178,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 } else {
                                         devices = ATOM_DEVICE_CRT1_SUPPORT;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_CRT1_SUPPORT,
                                                                    1),
@@ -2151,7 +2198,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 if (tmp & 0x1) {
                                         devices |= ATOM_DEVICE_CRT2_SUPPORT;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_CRT2_SUPPORT,
                                                                    2),
@@ -2159,7 +2206,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 } else {
                                         devices |= ATOM_DEVICE_CRT1_SUPPORT;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_CRT1_SUPPORT,
                                                                    1),
@@ -2168,7 +2215,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 if ((tmp >> 4) & 0x1) {
                                         devices |= ATOM_DEVICE_DFP2_SUPPORT;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_DFP2_SUPPORT,
                                                                    0),
@@ -2177,7 +2224,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 } else {
                                         devices |= ATOM_DEVICE_DFP1_SUPPORT;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_DFP1_SUPPORT,
                                                                    0),
@@ -2202,7 +2249,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                         connector_object_id = CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I;
                                 }
                                 radeon_add_legacy_encoder(dev,
-                                                          radeon_get_encoder_id
+                                                          radeon_get_encoder_enum
                                                           (dev, devices, 0),
                                                           devices);
                                 radeon_add_legacy_connector(dev, i, devices,
@@ -2215,7 +2262,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         case CONNECTOR_CTV_LEGACY:
                         case CONNECTOR_STV_LEGACY:
                                 radeon_add_legacy_encoder(dev,
-                                                          radeon_get_encoder_id
+                                                          radeon_get_encoder_enum
                                                           (dev,
                                                            ATOM_DEVICE_TV1_SUPPORT,
                                                            2),
@@ -2242,12 +2289,12 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         DRM_DEBUG_KMS("Found DFP table, assuming DVI connector\n");
 
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
                                                                         1),
                                                   ATOM_DEVICE_CRT1_SUPPORT);
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_DFP1_SUPPORT,
                                                                         0),
                                                   ATOM_DEVICE_DFP1_SUPPORT);
@@ -2268,7 +2315,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         DRM_DEBUG_KMS("Found CRT table, assuming VGA connector\n");
                         if (crt_info) {
                                 radeon_add_legacy_encoder(dev,
-                                                          radeon_get_encoder_id(dev,
+                                                          radeon_get_encoder_enum(dev,
                                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                                 1),
                                                           ATOM_DEVICE_CRT1_SUPPORT);
@@ -2297,7 +2344,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                      COMBIOS_LCD_DDC_INFO_TABLE);
 
                         radeon_add_legacy_encoder(dev,
-                                                  radeon_get_encoder_id(dev,
+                                                  radeon_get_encoder_enum(dev,
                                                                         ATOM_DEVICE_LCD1_SUPPORT,
                                                                         0),
                                                   ATOM_DEVICE_LCD1_SUPPORT);
@@ -2351,7 +2398,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                         hpd.hpd = RADEON_HPD_NONE;
                                         ddc_i2c.valid = false;
                                         radeon_add_legacy_encoder(dev,
-                                                                  radeon_get_encoder_id
+                                                                  radeon_get_encoder_enum
                                                                   (dev,
                                                                    ATOM_DEVICE_TV1_SUPPORT,
                                                                    2),
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 47c4b276d30c..ecc1a8fafbfd 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -481,7 +481,8 @@ static int radeon_lvds_mode_valid(struct drm_connector *connector,
         return MODE_OK;
 }
 
-static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
+static enum drm_connector_status
+radeon_lvds_detect(struct drm_connector *connector, bool force)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
@@ -594,7 +595,8 @@ static int radeon_vga_mode_valid(struct drm_connector *connector,
         return MODE_OK;
 }
 
-static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
+static enum drm_connector_status
+radeon_vga_detect(struct drm_connector *connector, bool force)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         struct drm_encoder *encoder;
@@ -691,7 +693,8 @@ static int radeon_tv_mode_valid(struct drm_connector *connector,
         return MODE_OK;
 }
 
-static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
+static enum drm_connector_status
+radeon_tv_detect(struct drm_connector *connector, bool force)
 {
         struct drm_encoder *encoder;
         struct drm_encoder_helper_funcs *encoder_funcs;
@@ -748,7 +751,8 @@ static int radeon_dvi_get_modes(struct drm_connector *connector)
  * we have to check if this analog encoder is shared with anyone else (TV)
  * if its shared we have to set the other connector to disconnected.
  */
-static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
+static enum drm_connector_status
+radeon_dvi_detect(struct drm_connector *connector, bool force)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         struct drm_encoder *encoder = NULL;
@@ -972,32 +976,35 @@ static int radeon_dp_get_modes(struct drm_connector *connector)
         return ret;
 }
 
-static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
+static enum drm_connector_status
+radeon_dp_detect(struct drm_connector *connector, bool force)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         enum drm_connector_status ret = connector_status_disconnected;
         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
-        u8 sink_type;
 
         if (radeon_connector->edid) {
                 kfree(radeon_connector->edid);
                 radeon_connector->edid = NULL;
         }
 
-        sink_type = radeon_dp_getsinktype(radeon_connector);
-        if ((sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
-            (sink_type == CONNECTOR_OBJECT_ID_eDP)) {
-                if (radeon_dp_getdpcd(radeon_connector)) {
-                        radeon_dig_connector->dp_sink_type = sink_type;
+        if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
+                /* eDP is always DP */
+                radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
+                if (radeon_dp_getdpcd(radeon_connector))
                         ret = connector_status_connected;
-                }
         } else {
-                if (radeon_ddc_probe(radeon_connector)) {
-                        radeon_dig_connector->dp_sink_type = sink_type;
-                        ret = connector_status_connected;
+                radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
+                if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
+                        if (radeon_dp_getdpcd(radeon_connector))
+                                ret = connector_status_connected;
+                } else {
+                        if (radeon_ddc_probe(radeon_connector))
+                                ret = connector_status_connected;
                 }
         }
 
+        radeon_connector_update_scratch_regs(connector, ret);
         return ret;
 }
 
@@ -1037,7 +1044,6 @@ radeon_add_atom_connector(struct drm_device *dev,
                           uint32_t supported_device,
                           int connector_type,
                           struct radeon_i2c_bus_rec *i2c_bus,
-                          bool linkb,
                           uint32_t igp_lane_info,
                           uint16_t connector_object_id,
                           struct radeon_hpd *hpd,
@@ -1050,10 +1056,16 @@ radeon_add_atom_connector(struct drm_device *dev,
         uint32_t subpixel_order = SubPixelNone;
         bool shared_ddc = false;
 
-        /* fixme - tv/cv/din */
         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
                 return;
 
+        /* if the user selected tv=0 don't try and add the connector */
+        if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
+             (connector_type == DRM_MODE_CONNECTOR_Composite) ||
+             (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
+            (radeon_tv == 0))
+                return;
+
         /* see if we already added it */
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 radeon_connector = to_radeon_connector(connector);
@@ -1128,7 +1140,6 @@ radeon_add_atom_connector(struct drm_device *dev,
                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
                 if (!radeon_dig_connector)
                         goto failed;
-                radeon_dig_connector->linkb = linkb;
                 radeon_dig_connector->igp_lane_info = igp_lane_info;
                 radeon_connector->con_priv = radeon_dig_connector;
                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
@@ -1158,7 +1169,6 @@ radeon_add_atom_connector(struct drm_device *dev,
                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
                 if (!radeon_dig_connector)
                         goto failed;
-                radeon_dig_connector->linkb = linkb;
                 radeon_dig_connector->igp_lane_info = igp_lane_info;
                 radeon_connector->con_priv = radeon_dig_connector;
                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
@@ -1182,7 +1192,6 @@ radeon_add_atom_connector(struct drm_device *dev,
                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
                 if (!radeon_dig_connector)
                         goto failed;
-                radeon_dig_connector->linkb = linkb;
                 radeon_dig_connector->igp_lane_info = igp_lane_info;
                 radeon_connector->con_priv = radeon_dig_connector;
                 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
@@ -1211,25 +1220,22 @@ radeon_add_atom_connector(struct drm_device *dev,
         case DRM_MODE_CONNECTOR_SVIDEO:
         case DRM_MODE_CONNECTOR_Composite:
         case DRM_MODE_CONNECTOR_9PinDIN:
-                if (radeon_tv == 1) {
-                        drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
-                        drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
-                        radeon_connector->dac_load_detect = true;
-                        drm_connector_attach_property(&radeon_connector->base,
-                                                      rdev->mode_info.load_detect_property,
-                                                      1);
-                        drm_connector_attach_property(&radeon_connector->base,
-                                                      rdev->mode_info.tv_std_property,
-                                                      radeon_atombios_get_tv_info(rdev));
-                        /* no HPD on analog connectors */
-                        radeon_connector->hpd.hpd = RADEON_HPD_NONE;
-                }
+                drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
+                drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
+                radeon_connector->dac_load_detect = true;
+                drm_connector_attach_property(&radeon_connector->base,
+                                              rdev->mode_info.load_detect_property,
+                                              1);
+                drm_connector_attach_property(&radeon_connector->base,
+                                              rdev->mode_info.tv_std_property,
+                                              radeon_atombios_get_tv_info(rdev));
+                /* no HPD on analog connectors */
+                radeon_connector->hpd.hpd = RADEON_HPD_NONE;
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
                 if (!radeon_dig_connector)
                         goto failed;
-                radeon_dig_connector->linkb = linkb;
                 radeon_dig_connector->igp_lane_info = igp_lane_info;
                 radeon_connector->con_priv = radeon_dig_connector;
                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
@@ -1275,10 +1281,16 @@ radeon_add_legacy_connector(struct drm_device *dev,
         struct radeon_connector *radeon_connector;
         uint32_t subpixel_order = SubPixelNone;
 
-        /* fixme - tv/cv/din */
         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
                 return;
 
+        /* if the user selected tv=0 don't try and add the connector */
+        if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
+             (connector_type == DRM_MODE_CONNECTOR_Composite) ||
+             (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
+            (radeon_tv == 0))
+                return;
+
         /* see if we already added it */
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 radeon_connector = to_radeon_connector(connector);
@@ -1350,26 +1362,24 @@ radeon_add_legacy_connector(struct drm_device *dev,
         case DRM_MODE_CONNECTOR_SVIDEO:
         case DRM_MODE_CONNECTOR_Composite:
         case DRM_MODE_CONNECTOR_9PinDIN:
-                if (radeon_tv == 1) {
-                        drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
-                        drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
-                        radeon_connector->dac_load_detect = true;
-                        /* RS400,RC410,RS480 chipset seems to report a lot
-                         * of false positive on load detect, we haven't yet
-                         * found a way to make load detect reliable on those
-                         * chipset, thus just disable it for TV.
-                         */
-                        if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
-                                radeon_connector->dac_load_detect = false;
-                        drm_connector_attach_property(&radeon_connector->base,
-                                                      rdev->mode_info.load_detect_property,
-                                                      radeon_connector->dac_load_detect);
-                        drm_connector_attach_property(&radeon_connector->base,
-                                                      rdev->mode_info.tv_std_property,
-                                                      radeon_combios_get_tv_info(rdev));
-                        /* no HPD on analog connectors */
-                        radeon_connector->hpd.hpd = RADEON_HPD_NONE;
-                }
+                drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
+                drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
+                radeon_connector->dac_load_detect = true;
+                /* RS400,RC410,RS480 chipset seems to report a lot
+                 * of false positive on load detect, we haven't yet
+                 * found a way to make load detect reliable on those
+                 * chipset, thus just disable it for TV.
+                 */
+                if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
+                        radeon_connector->dac_load_detect = false;
+                drm_connector_attach_property(&radeon_connector->base,
+                                              rdev->mode_info.load_detect_property,
+                                              radeon_connector->dac_load_detect);
+                drm_connector_attach_property(&radeon_connector->base,
+                                              rdev->mode_info.tv_std_property,
+                                              radeon_combios_get_tv_info(rdev));
+                /* no HPD on analog connectors */
+                radeon_connector->hpd.hpd = RADEON_HPD_NONE;
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 4f7a170d1566..256d204a6d24 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -199,7 +199,7 @@ void radeon_vram_location(struct radeon_device *rdev, struct radeon_mc *mc, u64
                 mc->mc_vram_size = mc->aper_size;
         }
         mc->vram_end = mc->vram_start + mc->mc_vram_size - 1;
-        if (rdev->flags & RADEON_IS_AGP && mc->vram_end > mc->gtt_start && mc->vram_end <= mc->gtt_end) {
+        if (rdev->flags & RADEON_IS_AGP && mc->vram_end > mc->gtt_start && mc->vram_start <= mc->gtt_end) {
                 dev_warn(rdev->dev, "limiting VRAM to PCI aperture size\n");
                 mc->real_vram_size = mc->aper_size;
                 mc->mc_vram_size = mc->aper_size;
@@ -293,30 +293,20 @@ bool radeon_card_posted(struct radeon_device *rdev)
 void radeon_update_bandwidth_info(struct radeon_device *rdev)
 {
         fixed20_12 a;
-        u32 sclk, mclk;
+        u32 sclk = rdev->pm.current_sclk;
+        u32 mclk = rdev->pm.current_mclk;
 
-        if (rdev->flags & RADEON_IS_IGP) {
-                sclk = radeon_get_engine_clock(rdev);
-                mclk = rdev->clock.default_mclk;
-
-                a.full = dfixed_const(100);
-                rdev->pm.sclk.full = dfixed_const(sclk);
-                rdev->pm.sclk.full = dfixed_div(rdev->pm.sclk, a);
-                rdev->pm.mclk.full = dfixed_const(mclk);
-                rdev->pm.mclk.full = dfixed_div(rdev->pm.mclk, a);
+        /* sclk/mclk in Mhz */
+        a.full = dfixed_const(100);
+        rdev->pm.sclk.full = dfixed_const(sclk);
+        rdev->pm.sclk.full = dfixed_div(rdev->pm.sclk, a);
+        rdev->pm.mclk.full = dfixed_const(mclk);
+        rdev->pm.mclk.full = dfixed_div(rdev->pm.mclk, a);
 
+        if (rdev->flags & RADEON_IS_IGP) {
                 a.full = dfixed_const(16);
                 /* core_bandwidth = sclk(Mhz) * 16 */
                 rdev->pm.core_bandwidth.full = dfixed_div(rdev->pm.sclk, a);
-        } else {
-                sclk = radeon_get_engine_clock(rdev);
-                mclk = radeon_get_memory_clock(rdev);
-
-                a.full = dfixed_const(100);
-                rdev->pm.sclk.full = dfixed_const(sclk);
-                rdev->pm.sclk.full = dfixed_div(rdev->pm.sclk, a);
-                rdev->pm.mclk.full = dfixed_const(mclk);
-                rdev->pm.mclk.full = dfixed_div(rdev->pm.mclk, a);
         }
 }
 
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 5764f4d3b4f1..b92d2f2fcbed 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -349,6 +349,8 @@ static void radeon_print_display_setup(struct drm_device *dev)
                                         DRM_INFO("    DFP4: %s\n", encoder_names[radeon_encoder->encoder_id]);
                                 if (devices & ATOM_DEVICE_DFP5_SUPPORT)
                                         DRM_INFO("    DFP5: %s\n", encoder_names[radeon_encoder->encoder_id]);
+                                if (devices & ATOM_DEVICE_DFP6_SUPPORT)
+                                        DRM_INFO("    DFP6: %s\n", encoder_names[radeon_encoder->encoder_id]);
                                 if (devices & ATOM_DEVICE_TV1_SUPPORT)
                                         DRM_INFO("    TV1: %s\n", encoder_names[radeon_encoder->encoder_id]);
                                 if (devices & ATOM_DEVICE_CV_SUPPORT)
@@ -841,8 +843,9 @@ static void radeon_user_framebuffer_destroy(struct drm_framebuffer *fb)
 {
         struct radeon_framebuffer *radeon_fb = to_radeon_framebuffer(fb);
 
-        if (radeon_fb->obj)
+        if (radeon_fb->obj) {
                 drm_gem_object_unreference_unlocked(radeon_fb->obj);
+        }
         drm_framebuffer_cleanup(fb);
         kfree(radeon_fb);
 }
@@ -1094,6 +1097,18 @@ void radeon_modeset_fini(struct radeon_device *rdev)
         radeon_i2c_fini(rdev);
 }
 
+static bool is_hdtv_mode(struct drm_display_mode *mode)
+{
+        /* try and guess if this is a tv or a monitor */
+        if ((mode->vdisplay == 480 && mode->hdisplay == 720) || /* 480p */
+            (mode->vdisplay == 576) || /* 576p */
+            (mode->vdisplay == 720) || /* 720p */
+            (mode->vdisplay == 1080)) /* 1080p */
+                return true;
+        else
+                return false;
+}
+
 bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
                                 struct drm_display_mode *mode,
                                 struct drm_display_mode *adjusted_mode)
@@ -1128,20 +1143,22 @@ bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
                                 radeon_crtc->rmx_type = radeon_encoder->rmx_type;
                         else
                                 radeon_crtc->rmx_type = RMX_OFF;
-                        src_v = crtc->mode.vdisplay;
-                        dst_v = radeon_crtc->native_mode.vdisplay;
-                        src_h = crtc->mode.hdisplay;
-                        dst_h = radeon_crtc->native_mode.vdisplay;
                         /* copy native mode */
                         memcpy(&radeon_crtc->native_mode,
                                &radeon_encoder->native_mode,
                                 sizeof(struct drm_display_mode));
+                        src_v = crtc->mode.vdisplay;
+                        dst_v = radeon_crtc->native_mode.vdisplay;
+                        src_h = crtc->mode.hdisplay;
+                        dst_h = radeon_crtc->native_mode.hdisplay;
 
                         /* fix up for overscan on hdmi */
                         if (ASIC_IS_AVIVO(rdev) &&
+                            (!(mode->flags & DRM_MODE_FLAG_INTERLACE)) &&
                             ((radeon_encoder->underscan_type == UNDERSCAN_ON) ||
                              ((radeon_encoder->underscan_type == UNDERSCAN_AUTO) &&
-                              drm_detect_hdmi_monitor(radeon_connector->edid)))) {
+                              drm_detect_hdmi_monitor(radeon_connector->edid) &&
+                              is_hdtv_mode(mode)))) {
                                 radeon_crtc->h_border = (mode->hdisplay >> 5) + 16;
                                 radeon_crtc->v_border = (mode->vdisplay >> 5) + 16;
                                 radeon_crtc->rmx_type = RMX_FULL;
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c
index 263c8098d7dd..2c293e8304d6 100644
--- a/drivers/gpu/drm/radeon/radeon_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_encoders.c
@@ -81,7 +81,7 @@ void radeon_setup_encoder_clones(struct drm_device *dev)
 }
 
 uint32_t
-radeon_get_encoder_id(struct drm_device *dev, uint32_t supported_device, uint8_t dac)
+radeon_get_encoder_enum(struct drm_device *dev, uint32_t supported_device, uint8_t dac)
 {
         struct radeon_device *rdev = dev->dev_private;
         uint32_t ret = 0;
@@ -97,59 +97,59 @@ radeon_get_encoder_id(struct drm_device *dev, uint32_t supported_device, uint8_t
                         if ((rdev->family == CHIP_RS300) ||
                             (rdev->family == CHIP_RS400) ||
                             (rdev->family == CHIP_RS480))
-                                ret = ENCODER_OBJECT_ID_INTERNAL_DAC2;
+                                ret = ENCODER_INTERNAL_DAC2_ENUM_ID1;
                         else if (ASIC_IS_AVIVO(rdev))
-                                ret = ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1;
+                                ret = ENCODER_INTERNAL_KLDSCP_DAC1_ENUM_ID1;
                         else
-                                ret = ENCODER_OBJECT_ID_INTERNAL_DAC1;
+                                ret = ENCODER_INTERNAL_DAC1_ENUM_ID1;
                         break;
                 case 2: /* dac b */
                         if (ASIC_IS_AVIVO(rdev))
-                                ret = ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2;
+                                ret = ENCODER_INTERNAL_KLDSCP_DAC2_ENUM_ID1;
                         else {
                                 /*if (rdev->family == CHIP_R200)
-                                  ret = ENCODER_OBJECT_ID_INTERNAL_DVO1;
+                                  ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
                                   else*/
-                                ret = ENCODER_OBJECT_ID_INTERNAL_DAC2;
+                                ret = ENCODER_INTERNAL_DAC2_ENUM_ID1;
                         }
                         break;
                 case 3: /* external dac */
                         if (ASIC_IS_AVIVO(rdev))
-                                ret = ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1;
+                                ret = ENCODER_INTERNAL_KLDSCP_DVO1_ENUM_ID1;
                         else
-                                ret = ENCODER_OBJECT_ID_INTERNAL_DVO1;
+                                ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
                         break;
                 }
                 break;
         case ATOM_DEVICE_LCD1_SUPPORT:
                 if (ASIC_IS_AVIVO(rdev))
-                        ret = ENCODER_OBJECT_ID_INTERNAL_LVTM1;
+                        ret = ENCODER_INTERNAL_LVTM1_ENUM_ID1;
                 else
-                        ret = ENCODER_OBJECT_ID_INTERNAL_LVDS;
+                        ret = ENCODER_INTERNAL_LVDS_ENUM_ID1;
                 break;
         case ATOM_DEVICE_DFP1_SUPPORT:
                 if ((rdev->family == CHIP_RS300) ||
                     (rdev->family == CHIP_RS400) ||
                     (rdev->family == CHIP_RS480))
-                        ret = ENCODER_OBJECT_ID_INTERNAL_DVO1;
+                        ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
                 else if (ASIC_IS_AVIVO(rdev))
-                        ret = ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1;
+                        ret = ENCODER_INTERNAL_KLDSCP_TMDS1_ENUM_ID1;
                 else
-                        ret = ENCODER_OBJECT_ID_INTERNAL_TMDS1;
+                        ret = ENCODER_INTERNAL_TMDS1_ENUM_ID1;
                 break;
         case ATOM_DEVICE_LCD2_SUPPORT:
         case ATOM_DEVICE_DFP2_SUPPORT:
                 if ((rdev->family == CHIP_RS600) ||
                     (rdev->family == CHIP_RS690) ||
                     (rdev->family == CHIP_RS740))
-                        ret = ENCODER_OBJECT_ID_INTERNAL_DDI;
+                        ret = ENCODER_INTERNAL_DDI_ENUM_ID1;
                 else if (ASIC_IS_AVIVO(rdev))
-                        ret = ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1;
+                        ret = ENCODER_INTERNAL_KLDSCP_DVO1_ENUM_ID1;
                 else
-                        ret = ENCODER_OBJECT_ID_INTERNAL_DVO1;
+                        ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
                 break;
         case ATOM_DEVICE_DFP3_SUPPORT:
-                ret = ENCODER_OBJECT_ID_INTERNAL_LVTM1;
+                ret = ENCODER_INTERNAL_LVTM1_ENUM_ID1;
                 break;
         }
 
@@ -228,32 +228,6 @@ radeon_get_connector_for_encoder(struct drm_encoder *encoder)
         return NULL;
 }
 
-static struct radeon_connector_atom_dig *
-radeon_get_atom_connector_priv_from_encoder(struct drm_encoder *encoder)
-{
-        struct drm_device *dev = encoder->dev;
-        struct radeon_device *rdev = dev->dev_private;
-        struct drm_connector *connector;
-        struct radeon_connector *radeon_connector;
-        struct radeon_connector_atom_dig *dig_connector;
-
-        if (!rdev->is_atom_bios)
-                return NULL;
-
-        connector = radeon_get_connector_for_encoder(encoder);
-        if (!connector)
-                return NULL;
-
-        radeon_connector = to_radeon_connector(connector);
-
-        if (!radeon_connector->con_priv)
-                return NULL;
-
-        dig_connector = radeon_connector->con_priv;
-
-        return dig_connector;
-}
-
 void radeon_panel_mode_fixup(struct drm_encoder *encoder,
                              struct drm_display_mode *adjusted_mode)
 {
@@ -512,14 +486,12 @@ atombios_digital_setup(struct drm_encoder *encoder, int action)
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
-        struct radeon_connector_atom_dig *dig_connector =
-                radeon_get_atom_connector_priv_from_encoder(encoder);
         union lvds_encoder_control args;
         int index = 0;
         int hdmi_detected = 0;
         uint8_t frev, crev;
 
-        if (!dig || !dig_connector)
+        if (!dig)
                 return;
 
         if (atombios_get_encoder_mode(encoder) == ATOM_ENCODER_MODE_HDMI)
@@ -562,7 +534,7 @@ atombios_digital_setup(struct drm_encoder *encoder, int action)
                                 if (dig->lvds_misc & ATOM_PANEL_MISC_888RGB)
                                         args.v1.ucMisc |= (1 << 1);
                         } else {
-                                if (dig_connector->linkb)
+                                if (dig->linkb)
                                         args.v1.ucMisc |= PANEL_ENCODER_MISC_TMDS_LINKB;
                                 if (radeon_encoder->pixel_clock > 165000)
                                         args.v1.ucMisc |= PANEL_ENCODER_MISC_DUAL;
@@ -601,7 +573,7 @@ atombios_digital_setup(struct drm_encoder *encoder, int action)
                                                 args.v2.ucTemporal |= PANEL_ENCODER_TEMPORAL_LEVEL_4;
                                 }
                         } else {
-                                if (dig_connector->linkb)
+                                if (dig->linkb)
                                         args.v2.ucMisc |= PANEL_ENCODER_MISC_TMDS_LINKB;
                                 if (radeon_encoder->pixel_clock > 165000)
                                         args.v2.ucMisc |= PANEL_ENCODER_MISC_DUAL;
@@ -623,6 +595,8 @@ atombios_digital_setup(struct drm_encoder *encoder, int action)
 int
 atombios_get_encoder_mode(struct drm_encoder *encoder)
 {
+        struct drm_device *dev = encoder->dev;
+        struct radeon_device *rdev = dev->dev_private;
         struct drm_connector *connector;
         struct radeon_connector *radeon_connector;
         struct radeon_connector_atom_dig *dig_connector;
@@ -636,9 +610,13 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
         switch (connector->connector_type) {
         case DRM_MODE_CONNECTOR_DVII:
         case DRM_MODE_CONNECTOR_HDMIB: /* HDMI-B is basically DL-DVI; analog works fine */
-                if (drm_detect_hdmi_monitor(radeon_connector->edid))
-                        return ATOM_ENCODER_MODE_HDMI;
-                else if (radeon_connector->use_digital)
+                if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
+                        /* fix me */
+                        if (ASIC_IS_DCE4(rdev))
+                                return ATOM_ENCODER_MODE_DVI;
+                        else
+                                return ATOM_ENCODER_MODE_HDMI;
+                } else if (radeon_connector->use_digital)
                         return ATOM_ENCODER_MODE_DVI;
                 else
                         return ATOM_ENCODER_MODE_CRT;
@@ -646,9 +624,13 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
         case DRM_MODE_CONNECTOR_DVID:
         case DRM_MODE_CONNECTOR_HDMIA:
         default:
-                if (drm_detect_hdmi_monitor(radeon_connector->edid))
-                        return ATOM_ENCODER_MODE_HDMI;
-                else
+                if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
+                        /* fix me */
+                        if (ASIC_IS_DCE4(rdev))
+                                return ATOM_ENCODER_MODE_DVI;
+                        else
+                                return ATOM_ENCODER_MODE_HDMI;
+                } else
                         return ATOM_ENCODER_MODE_DVI;
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
@@ -660,9 +642,13 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
                         return ATOM_ENCODER_MODE_DP;
-                else if (drm_detect_hdmi_monitor(radeon_connector->edid))
-                        return ATOM_ENCODER_MODE_HDMI;
-                else
+                else if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
+                        /* fix me */
+                        if (ASIC_IS_DCE4(rdev))
+                                return ATOM_ENCODER_MODE_DVI;
+                        else
+                                return ATOM_ENCODER_MODE_HDMI;
+                } else
                         return ATOM_ENCODER_MODE_DVI;
                 break;
         case DRM_MODE_CONNECTOR_DVIA:
@@ -729,13 +715,24 @@ atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
-        struct radeon_connector_atom_dig *dig_connector =
-                radeon_get_atom_connector_priv_from_encoder(encoder);
+        struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
         union dig_encoder_control args;
         int index = 0;
         uint8_t frev, crev;
+        int dp_clock = 0;
+        int dp_lane_count = 0;
+
+        if (connector) {
+                struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                struct radeon_connector_atom_dig *dig_connector =
+                        radeon_connector->con_priv;
 
-        if (!dig || !dig_connector)
+                dp_clock = dig_connector->dp_clock;
+                dp_lane_count = dig_connector->dp_lane_count;
+        }
+
+        /* no dig encoder assigned */
+        if (dig->dig_encoder == -1)
                 return;
 
         memset(&args, 0, sizeof(args));
@@ -757,9 +754,9 @@ atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
         args.v1.ucEncoderMode = atombios_get_encoder_mode(encoder);
 
         if (args.v1.ucEncoderMode == ATOM_ENCODER_MODE_DP) {
-                if (dig_connector->dp_clock == 270000)
+                if (dp_clock == 270000)
                         args.v1.ucConfig |= ATOM_ENCODER_CONFIG_DPLINKRATE_2_70GHZ;
-                args.v1.ucLaneNum = dig_connector->dp_lane_count;
+                args.v1.ucLaneNum = dp_lane_count;
         } else if (radeon_encoder->pixel_clock > 165000)
                 args.v1.ucLaneNum = 8;
         else
@@ -781,7 +778,7 @@ atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
                         args.v1.ucConfig = ATOM_ENCODER_CONFIG_V2_TRANSMITTER3;
                         break;
                 }
-                if (dig_connector->linkb)
+                if (dig->linkb)
                         args.v1.ucConfig |= ATOM_ENCODER_CONFIG_LINKB;
                 else
                         args.v1.ucConfig |= ATOM_ENCODER_CONFIG_LINKA;
@@ -804,38 +801,47 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
-        struct radeon_connector_atom_dig *dig_connector =
-                radeon_get_atom_connector_priv_from_encoder(encoder);
-        struct drm_connector *connector;
-        struct radeon_connector *radeon_connector;
+        struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
         union dig_transmitter_control args;
         int index = 0;
         uint8_t frev, crev;
         bool is_dp = false;
         int pll_id = 0;
+        int dp_clock = 0;
+        int dp_lane_count = 0;
+        int connector_object_id = 0;
+        int igp_lane_info = 0;
 
-        if (!dig || !dig_connector)
-                return;
+        if (connector) {
+                struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                struct radeon_connector_atom_dig *dig_connector =
+                        radeon_connector->con_priv;
 
-        connector = radeon_get_connector_for_encoder(encoder);
-        radeon_connector = to_radeon_connector(connector);
+                dp_clock = dig_connector->dp_clock;
+                dp_lane_count = dig_connector->dp_lane_count;
+                connector_object_id =
+                        (radeon_connector->connector_object_id & OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
+                igp_lane_info = dig_connector->igp_lane_info;
+        }
+
+        /* no dig encoder assigned */
+        if (dig->dig_encoder == -1)
+                return;
 
         if (atombios_get_encoder_mode(encoder) == ATOM_ENCODER_MODE_DP)
                 is_dp = true;
 
         memset(&args, 0, sizeof(args));
 
-        if (ASIC_IS_DCE32(rdev) || ASIC_IS_DCE4(rdev))
+        switch (radeon_encoder->encoder_id) {
+        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
+        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1:
+        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2:
                 index = GetIndexIntoMasterTable(COMMAND, UNIPHYTransmitterControl);
-        else {
-                switch (radeon_encoder->encoder_id) {
-                case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
-                        index = GetIndexIntoMasterTable(COMMAND, DIG1TransmitterControl);
-                        break;
-                case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
-                        index = GetIndexIntoMasterTable(COMMAND, DIG2TransmitterControl);
-                        break;
-                }
+                break;
+        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
+                index = GetIndexIntoMasterTable(COMMAND, LVTMATransmitterControl);
+                break;
         }
 
         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
@@ -843,14 +849,14 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
 
         args.v1.ucAction = action;
         if (action == ATOM_TRANSMITTER_ACTION_INIT) {
-                args.v1.usInitInfo = radeon_connector->connector_object_id;
+                args.v1.usInitInfo = connector_object_id;
         } else if (action == ATOM_TRANSMITTER_ACTION_SETUP_VSEMPH) {
                 args.v1.asMode.ucLaneSel = lane_num;
                 args.v1.asMode.ucLaneSet = lane_set;
         } else {
                 if (is_dp)
                         args.v1.usPixelClock =
-                                cpu_to_le16(dig_connector->dp_clock / 10);
+                                cpu_to_le16(dp_clock / 10);
                 else if (radeon_encoder->pixel_clock > 165000)
                         args.v1.usPixelClock = cpu_to_le16((radeon_encoder->pixel_clock / 2) / 10);
                 else
@@ -858,13 +864,13 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
         }
         if (ASIC_IS_DCE4(rdev)) {
                 if (is_dp)
-                        args.v3.ucLaneNum = dig_connector->dp_lane_count;
+                        args.v3.ucLaneNum = dp_lane_count;
                 else if (radeon_encoder->pixel_clock > 165000)
                         args.v3.ucLaneNum = 8;
                 else
                         args.v3.ucLaneNum = 4;
 
-                if (dig_connector->linkb) {
+                if (dig->linkb) {
                         args.v3.acConfig.ucLinkSel = 1;
                         args.v3.acConfig.ucEncoderSel = 1;
                 }
@@ -904,7 +910,7 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
                 }
         } else if (ASIC_IS_DCE32(rdev)) {
                 args.v2.acConfig.ucEncoderSel = dig->dig_encoder;
-                if (dig_connector->linkb)
+                if (dig->linkb)
                         args.v2.acConfig.ucLinkSel = 1;
 
                 switch (radeon_encoder->encoder_id) {
@@ -938,23 +944,23 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
                 if ((rdev->flags & RADEON_IS_IGP) &&
                     (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_UNIPHY)) {
                         if (is_dp || (radeon_encoder->pixel_clock <= 165000)) {
-                                if (dig_connector->igp_lane_info & 0x1)
+                                if (igp_lane_info & 0x1)
                                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_0_3;
-                                else if (dig_connector->igp_lane_info & 0x2)
+                                else if (igp_lane_info & 0x2)
                                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_4_7;
-                                else if (dig_connector->igp_lane_info & 0x4)
+                                else if (igp_lane_info & 0x4)
                                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_8_11;
-                                else if (dig_connector->igp_lane_info & 0x8)
+                                else if (igp_lane_info & 0x8)
                                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_12_15;
                         } else {
-                                if (dig_connector->igp_lane_info & 0x3)
+                                if (igp_lane_info & 0x3)
                                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_0_7;
-                                else if (dig_connector->igp_lane_info & 0xc)
+                                else if (igp_lane_info & 0xc)
                                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_8_15;
                         }
                 }
 
-                if (dig_connector->linkb)
+                if (dig->linkb)
                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKB;
                 else
                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKA;
@@ -1072,8 +1078,7 @@ radeon_atom_encoder_dpms(struct drm_encoder *encoder, int mode)
         if (is_dig) {
                 switch (mode) {
                 case DRM_MODE_DPMS_ON:
-                        if (!ASIC_IS_DCE4(rdev))
-                                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE_OUTPUT, 0, 0);
+                        atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE_OUTPUT, 0, 0);
                         if (atombios_get_encoder_mode(encoder) == ATOM_ENCODER_MODE_DP) {
                                 struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
 
@@ -1085,8 +1090,7 @@ radeon_atom_encoder_dpms(struct drm_encoder *encoder, int mode)
                 case DRM_MODE_DPMS_STANDBY:
                 case DRM_MODE_DPMS_SUSPEND:
                 case DRM_MODE_DPMS_OFF:
-                        if (!ASIC_IS_DCE4(rdev))
-                                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_DISABLE_OUTPUT, 0, 0);
+                        atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_DISABLE_OUTPUT, 0, 0);
                         if (atombios_get_encoder_mode(encoder) == ATOM_ENCODER_MODE_DP) {
                                 if (ASIC_IS_DCE4(rdev))
                                         atombios_dig_encoder_setup(encoder, ATOM_ENCODER_CMD_DP_VIDEO_OFF);
@@ -1290,24 +1294,22 @@ static int radeon_atom_pick_dig_encoder(struct drm_encoder *encoder)
         uint32_t dig_enc_in_use = 0;
 
         if (ASIC_IS_DCE4(rdev)) {
-                struct radeon_connector_atom_dig *dig_connector =
-                        radeon_get_atom_connector_priv_from_encoder(encoder);
-
+                dig = radeon_encoder->enc_priv;
                 switch (radeon_encoder->encoder_id) {
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
-                        if (dig_connector->linkb)
+                        if (dig->linkb)
                                 return 1;
                         else
                                 return 0;
                         break;
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1:
-                        if (dig_connector->linkb)
+                        if (dig->linkb)
                                 return 3;
                         else
                                 return 2;
                         break;
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2:
-                        if (dig_connector->linkb)
+                        if (dig->linkb)
                                 return 5;
                         else
                                 return 4;
@@ -1641,6 +1643,7 @@ radeon_atombios_set_dac_info(struct radeon_encoder *radeon_encoder)
 struct radeon_encoder_atom_dig *
 radeon_atombios_set_dig_info(struct radeon_encoder *radeon_encoder)
 {
+        int encoder_enum = (radeon_encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
         struct radeon_encoder_atom_dig *dig = kzalloc(sizeof(struct radeon_encoder_atom_dig), GFP_KERNEL);
 
         if (!dig)
@@ -1650,11 +1653,16 @@ radeon_atombios_set_dig_info(struct radeon_encoder *radeon_encoder)
         dig->coherent_mode = true;
         dig->dig_encoder = -1;
 
+        if (encoder_enum == 2)
+                dig->linkb = true;
+        else
+                dig->linkb = false;
+
         return dig;
 }
 
 void
-radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device)
+radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_enum, uint32_t supported_device)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct drm_encoder *encoder;
@@ -1663,7 +1671,7 @@ radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t su
         /* see if we already added it */
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                 radeon_encoder = to_radeon_encoder(encoder);
-                if (radeon_encoder->encoder_id == encoder_id) {
+                if (radeon_encoder->encoder_enum == encoder_enum) {
                         radeon_encoder->devices |= supported_device;
                         return;
                 }
@@ -1691,7 +1699,8 @@ radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t su
 
         radeon_encoder->enc_priv = NULL;
 
-        radeon_encoder->encoder_id = encoder_id;
+        radeon_encoder->encoder_enum = encoder_enum;
+        radeon_encoder->encoder_id = (encoder_enum & OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
         radeon_encoder->devices = supported_device;
         radeon_encoder->rmx_type = RMX_OFF;
         radeon_encoder->underscan_type = UNDERSCAN_OFF;
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c
index dbf86962bdd1..40b0c087b592 100644
--- a/drivers/gpu/drm/radeon/radeon_fb.c
+++ b/drivers/gpu/drm/radeon/radeon_fb.c
@@ -94,6 +94,7 @@ static void radeonfb_destroy_pinned_object(struct drm_gem_object *gobj)
         ret = radeon_bo_reserve(rbo, false);
         if (likely(ret == 0)) {
                 radeon_bo_kunmap(rbo);
+                radeon_bo_unpin(rbo);
                 radeon_bo_unreserve(rbo);
         }
         drm_gem_object_unreference_unlocked(gobj);
@@ -118,7 +119,7 @@ static int radeonfb_create_pinned_object(struct radeon_fbdev *rfbdev,
         aligned_size = ALIGN(size, PAGE_SIZE);
         ret = radeon_gem_object_create(rdev, aligned_size, 0,
                                        RADEON_GEM_DOMAIN_VRAM,
-                                       false, ttm_bo_type_kernel,
+                                       false, true,
                                        &gobj);
         if (ret) {
                 printk(KERN_ERR "failed to allocate framebuffer (%d)\n",
@@ -325,8 +326,6 @@ static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfb
 {
         struct fb_info *info;
         struct radeon_framebuffer *rfb = &rfbdev->rfb;
-        struct radeon_bo *rbo;
-        int r;
 
         if (rfbdev->helper.fbdev) {
                 info = rfbdev->helper.fbdev;
@@ -338,14 +337,8 @@ static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfb
         }
 
         if (rfb->obj) {
-                rbo = rfb->obj->driver_private;
-                r = radeon_bo_reserve(rbo, false);
-                if (likely(r == 0)) {
-                        radeon_bo_kunmap(rbo);
-                        radeon_bo_unpin(rbo);
-                        radeon_bo_unreserve(rbo);
-                }
-                drm_gem_object_unreference_unlocked(rfb->obj);
+                radeonfb_destroy_pinned_object(rfb->obj);
+                rfb->obj = NULL;
         }
         drm_fb_helper_fini(&rfbdev->helper);
         drm_framebuffer_cleanup(&rfb->base);
diff --git a/drivers/gpu/drm/radeon/radeon_gem.c b/drivers/gpu/drm/radeon/radeon_gem.c
index c578f265b24c..d1e595d91723 100644
--- a/drivers/gpu/drm/radeon/radeon_gem.c
+++ b/drivers/gpu/drm/radeon/radeon_gem.c
@@ -201,11 +201,11 @@ int radeon_gem_create_ioctl(struct drm_device *dev, void *data,
                 return r;
         }
         r = drm_gem_handle_create(filp, gobj, &handle);
+        /* drop reference from allocate - handle holds it now */
+        drm_gem_object_unreference_unlocked(gobj);
         if (r) {
-                drm_gem_object_unreference_unlocked(gobj);
                 return r;
         }
-        drm_gem_object_handle_unreference_unlocked(gobj);
         args->handle = handle;
         return 0;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_i2c.c b/drivers/gpu/drm/radeon/radeon_i2c.c
index bfd2ce5f5372..6a13ee38a5b9 100644
--- a/drivers/gpu/drm/radeon/radeon_i2c.c
+++ b/drivers/gpu/drm/radeon/radeon_i2c.c
@@ -99,6 +99,13 @@ static void radeon_i2c_do_lock(struct radeon_i2c_chan *i2c, int lock_state)
                 }
         }
 
+        /* switch the pads to ddc mode */
+        if (ASIC_IS_DCE3(rdev) && rec->hw_capable) {
+                temp = RREG32(rec->mask_clk_reg);
+                temp &= ~(1 << 16);
+                WREG32(rec->mask_clk_reg, temp);
+        }
+
         /* clear the output pin values */
         temp = RREG32(rec->a_clk_reg) & ~rec->a_clk_mask;
         WREG32(rec->a_clk_reg, temp);
@@ -206,7 +213,7 @@ static void post_xfer(struct i2c_adapter *i2c_adap)
 
 static u32 radeon_get_i2c_prescale(struct radeon_device *rdev)
 {
-        u32 sclk = radeon_get_engine_clock(rdev);
+        u32 sclk = rdev->pm.current_sclk;
         u32 prescale = 0;
         u32 nm;
         u8 n, m, loop;
diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c
index 059bfa4098d7..a108c7ed14f5 100644
--- a/drivers/gpu/drm/radeon/radeon_irq_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c
@@ -121,11 +121,12 @@ int radeon_irq_kms_init(struct radeon_device *rdev)
          * chips.  Disable MSI on them for now.
          */
         if ((rdev->family >= CHIP_RV380) &&
-            (!(rdev->flags & RADEON_IS_IGP))) {
+            (!(rdev->flags & RADEON_IS_IGP)) &&
+            (!(rdev->flags & RADEON_IS_AGP))) {
                 int ret = pci_enable_msi(rdev->pdev);
                 if (!ret) {
                         rdev->msi_enabled = 1;
-                        DRM_INFO("radeon: using MSI.\n");
+                        dev_info(rdev->dev, "radeon: using MSI.\n");
                 }
         }
         rdev->irq.installed = true;
diff --git a/drivers/gpu/drm/radeon/radeon_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c
index b1c8ace5f080..8fbbe1c6ebbd 100644
--- a/drivers/gpu/drm/radeon/radeon_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_kms.c
@@ -161,6 +161,7 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
                         DRM_DEBUG_KMS("tiling config is r6xx+ only!\n");
                         return -EINVAL;
                 }
+                break;
         case RADEON_INFO_WANT_HYPERZ:
                 /* The "value" here is both an input and output parameter.
                  * If the input value is 1, filp requests hyper-z access.
@@ -202,6 +203,10 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
  */
 int radeon_driver_firstopen_kms(struct drm_device *dev)
 {
+        struct radeon_device *rdev = dev->dev_private;
+
+        if (rdev->powered_down)
+                return -EINVAL;
         return 0;
 }
 
@@ -323,45 +328,45 @@ KMS_INVALID_IOCTL(radeon_surface_free_kms)
 
 
 struct drm_ioctl_desc radeon_ioctls_kms[] = {
-        DRM_IOCTL_DEF(DRM_RADEON_CP_INIT, radeon_cp_init_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_START, radeon_cp_start_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_STOP, radeon_cp_stop_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_RESET, radeon_cp_reset_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_IDLE, radeon_cp_idle_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_RESUME, radeon_cp_resume_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_RESET, radeon_engine_reset_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_FULLSCREEN, radeon_fullscreen_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SWAP, radeon_cp_swap_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CLEAR, radeon_cp_clear_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_VERTEX, radeon_cp_vertex_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_INDICES, radeon_cp_indices_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_TEXTURE, radeon_cp_texture_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_STIPPLE, radeon_cp_stipple_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_INDIRECT, radeon_cp_indirect_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_VERTEX2, radeon_cp_vertex2_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CMDBUF, radeon_cp_cmdbuf_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_GETPARAM, radeon_cp_getparam_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_FLIP, radeon_cp_flip_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_ALLOC, radeon_mem_alloc_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_FREE, radeon_mem_free_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_INIT_HEAP, radeon_mem_init_heap_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_IRQ_EMIT, radeon_irq_emit_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_IRQ_WAIT, radeon_irq_wait_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SETPARAM, radeon_cp_setparam_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SURF_ALLOC, radeon_surface_alloc_kms, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SURF_FREE, radeon_surface_free_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_INIT, radeon_cp_init_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_START, radeon_cp_start_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_STOP, radeon_cp_stop_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_RESET, radeon_cp_reset_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_IDLE, radeon_cp_idle_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_RESUME, radeon_cp_resume_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_RESET, radeon_engine_reset_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_FULLSCREEN, radeon_fullscreen_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SWAP, radeon_cp_swap_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CLEAR, radeon_cp_clear_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_VERTEX, radeon_cp_vertex_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_INDICES, radeon_cp_indices_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_TEXTURE, radeon_cp_texture_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_STIPPLE, radeon_cp_stipple_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_INDIRECT, radeon_cp_indirect_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_VERTEX2, radeon_cp_vertex2_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CMDBUF, radeon_cp_cmdbuf_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_GETPARAM, radeon_cp_getparam_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_FLIP, radeon_cp_flip_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_ALLOC, radeon_mem_alloc_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_FREE, radeon_mem_free_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_INIT_HEAP, radeon_mem_init_heap_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_IRQ_EMIT, radeon_irq_emit_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_IRQ_WAIT, radeon_irq_wait_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SETPARAM, radeon_cp_setparam_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SURF_ALLOC, radeon_surface_alloc_kms, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SURF_FREE, radeon_surface_free_kms, DRM_AUTH),
         /* KMS */
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_INFO, radeon_gem_info_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_CREATE, radeon_gem_create_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_MMAP, radeon_gem_mmap_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_SET_DOMAIN, radeon_gem_set_domain_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_PREAD, radeon_gem_pread_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_PWRITE, radeon_gem_pwrite_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_WAIT_IDLE, radeon_gem_wait_idle_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_CS, radeon_cs_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_INFO, radeon_info_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_SET_TILING, radeon_gem_set_tiling_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_GET_TILING, radeon_gem_get_tiling_ioctl, DRM_AUTH|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_RADEON_GEM_BUSY, radeon_gem_busy_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_INFO, radeon_gem_info_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_CREATE, radeon_gem_create_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_MMAP, radeon_gem_mmap_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_SET_DOMAIN, radeon_gem_set_domain_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_PREAD, radeon_gem_pread_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_PWRITE, radeon_gem_pwrite_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_WAIT_IDLE, radeon_gem_wait_idle_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_CS, radeon_cs_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_INFO, radeon_info_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_SET_TILING, radeon_gem_set_tiling_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_GET_TILING, radeon_gem_get_tiling_ioctl, DRM_AUTH|DRM_UNLOCKED),
+        DRM_IOCTL_DEF_DRV(RADEON_GEM_BUSY, radeon_gem_busy_ioctl, DRM_AUTH|DRM_UNLOCKED),
 };
 int radeon_max_kms_ioctl = DRM_ARRAY_SIZE(radeon_ioctls_kms);
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
index 989df519a1e4..305049afde15 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
@@ -272,7 +272,7 @@ static uint8_t radeon_compute_pll_gain(uint16_t ref_freq, uint16_t ref_div,
         if (!ref_div)
                 return 1;
 
-        vcoFreq = ((unsigned)ref_freq & fb_div) / ref_div;
+        vcoFreq = ((unsigned)ref_freq * fb_div) / ref_div;
 
         /*
          * This is horribly crude: the VCO frequency range is divided into
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
index b8149cbc0c70..0b8397000f4c 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
@@ -1345,7 +1345,7 @@ static struct radeon_encoder_ext_tmds *radeon_legacy_get_ext_tmds_info(struct ra
 }
 
 void
-radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device)
+radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum, uint32_t supported_device)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct drm_encoder *encoder;
@@ -1354,7 +1354,7 @@ radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t
         /* see if we already added it */
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                 radeon_encoder = to_radeon_encoder(encoder);
-                if (radeon_encoder->encoder_id == encoder_id) {
+                if (radeon_encoder->encoder_enum == encoder_enum) {
                         radeon_encoder->devices |= supported_device;
                         return;
                 }
@@ -1374,7 +1374,8 @@ radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t
 
         radeon_encoder->enc_priv = NULL;
 
-        radeon_encoder->encoder_id = encoder_id;
+        radeon_encoder->encoder_enum = encoder_enum;
+        radeon_encoder->encoder_id = (encoder_enum & OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
         radeon_encoder->devices = supported_device;
         radeon_encoder->rmx_type = RMX_OFF;
 
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h
index 5bbc086b9267..17a6602b5885 100644
--- a/drivers/gpu/drm/radeon/radeon_mode.h
+++ b/drivers/gpu/drm/radeon/radeon_mode.h
@@ -204,7 +204,7 @@ struct radeon_i2c_chan {
 
 /* mostly for macs, but really any system without connector tables */
 enum radeon_connector_table {
-        CT_NONE,
+        CT_NONE = 0,
         CT_GENERIC,
         CT_IBOOK,
         CT_POWERBOOK_EXTERNAL,
@@ -215,6 +215,7 @@ enum radeon_connector_table {
         CT_IMAC_G5_ISIGHT,
         CT_EMAC,
         CT_RN50_POWER,
+        CT_MAC_X800,
 };
 
 enum radeon_dvo_chip {
@@ -342,6 +343,7 @@ struct radeon_atom_ss {
 };
 
 struct radeon_encoder_atom_dig {
+        bool linkb;
         /* atom dig */
         bool coherent_mode;
         int dig_encoder; /* -1 disabled, 0 DIGA, 1 DIGB */
@@ -360,6 +362,7 @@ struct radeon_encoder_atom_dac {
 
 struct radeon_encoder {
         struct drm_encoder base;
+        uint32_t encoder_enum;
         uint32_t encoder_id;
         uint32_t devices;
         uint32_t active_device;
@@ -378,7 +381,6 @@ struct radeon_encoder {
 
 struct radeon_connector_atom_dig {
         uint32_t igp_lane_info;
-        bool linkb;
         /* displayport */
         struct radeon_i2c_chan *dp_i2c_bus;
         u8 dpcd[8];
@@ -599,7 +601,6 @@ extern bool radeon_get_atom_connector_info_from_supported_devices_table(struct d
 void radeon_enc_destroy(struct drm_encoder *encoder);
 void radeon_copy_fb(struct drm_device *dev, struct drm_gem_object *dst_obj);
 void radeon_combios_asic_init(struct drm_device *dev);
-extern int radeon_static_clocks_init(struct drm_device *dev);
 bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
                                         struct drm_display_mode *mode,
                                         struct drm_display_mode *adjusted_mode);
diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c
index 58038f5cab38..f87efec76236 100644
--- a/drivers/gpu/drm/radeon/radeon_pm.c
+++ b/drivers/gpu/drm/radeon/radeon_pm.c
@@ -226,6 +226,11 @@ static void radeon_pm_set_clocks(struct radeon_device *rdev)
 {
         int i;
 
+        /* no need to take locks, etc. if nothing's going to change */
+        if ((rdev->pm.requested_clock_mode_index == rdev->pm.current_clock_mode_index) &&
+            (rdev->pm.requested_power_state_index == rdev->pm.current_power_state_index))
+                return;
+
         mutex_lock(&rdev->ddev->struct_mutex);
         mutex_lock(&rdev->vram_mutex);
         mutex_lock(&rdev->cp.mutex);
@@ -632,8 +637,6 @@ void radeon_pm_fini(struct radeon_device *rdev)
         }
 
         radeon_hwmon_fini(rdev);
-        if (rdev->pm.i2c_bus)
-                radeon_i2c_destroy(rdev->pm.i2c_bus);
 }
 
 void radeon_pm_compute_clocks(struct radeon_device *rdev)
diff --git a/drivers/gpu/drm/radeon/radeon_state.c b/drivers/gpu/drm/radeon/radeon_state.c
index b3ba44c0a818..4ae5a3d1074e 100644
--- a/drivers/gpu/drm/radeon/radeon_state.c
+++ b/drivers/gpu/drm/radeon/radeon_state.c
@@ -3228,34 +3228,34 @@ void radeon_driver_postclose(struct drm_device *dev, struct drm_file *file_priv)
 }
 
 struct drm_ioctl_desc radeon_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_RADEON_CP_INIT, radeon_cp_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_START, radeon_cp_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_STOP, radeon_cp_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_RESET, radeon_cp_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_IDLE, radeon_cp_idle, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CP_RESUME, radeon_cp_resume, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_RESET, radeon_engine_reset, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_FULLSCREEN, radeon_fullscreen, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SWAP, radeon_cp_swap, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CLEAR, radeon_cp_clear, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_VERTEX, radeon_cp_vertex, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_INDICES, radeon_cp_indices, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_TEXTURE, radeon_cp_texture, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_STIPPLE, radeon_cp_stipple, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_INDIRECT, radeon_cp_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_VERTEX2, radeon_cp_vertex2, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CMDBUF, radeon_cp_cmdbuf, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_GETPARAM, radeon_cp_getparam, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_FLIP, radeon_cp_flip, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_ALLOC, radeon_mem_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_FREE, radeon_mem_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_INIT_HEAP, radeon_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_RADEON_IRQ_EMIT, radeon_irq_emit, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_IRQ_WAIT, radeon_irq_wait, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SETPARAM, radeon_cp_setparam, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SURF_ALLOC, radeon_surface_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_SURF_FREE, radeon_surface_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_RADEON_CS, r600_cs_legacy_ioctl, DRM_AUTH)
+        DRM_IOCTL_DEF_DRV(RADEON_CP_INIT, radeon_cp_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_START, radeon_cp_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_STOP, radeon_cp_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_RESET, radeon_cp_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_IDLE, radeon_cp_idle, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CP_RESUME, radeon_cp_resume, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_RESET, radeon_engine_reset, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_FULLSCREEN, radeon_fullscreen, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SWAP, radeon_cp_swap, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CLEAR, radeon_cp_clear, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_VERTEX, radeon_cp_vertex, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_INDICES, radeon_cp_indices, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_TEXTURE, radeon_cp_texture, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_STIPPLE, radeon_cp_stipple, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_INDIRECT, radeon_cp_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_VERTEX2, radeon_cp_vertex2, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CMDBUF, radeon_cp_cmdbuf, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_GETPARAM, radeon_cp_getparam, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_FLIP, radeon_cp_flip, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_ALLOC, radeon_mem_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_FREE, radeon_mem_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_INIT_HEAP, radeon_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(RADEON_IRQ_EMIT, radeon_irq_emit, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_IRQ_WAIT, radeon_irq_wait, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SETPARAM, radeon_cp_setparam, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SURF_ALLOC, radeon_surface_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_SURF_FREE, radeon_surface_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(RADEON_CS, r600_cs_legacy_ioctl, DRM_AUTH)
 };
 
 int radeon_max_ioctl = DRM_ARRAY_SIZE(radeon_ioctls);
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index f1c796810117..bfa59db374d2 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -905,6 +905,54 @@ static void rv770_gpu_init(struct radeon_device *rdev)
 
 }
 
+static int rv770_vram_scratch_init(struct radeon_device *rdev)
+{
+        int r;
+        u64 gpu_addr;
+
+        if (rdev->vram_scratch.robj == NULL) {
+                r = radeon_bo_create(rdev, NULL, RADEON_GPU_PAGE_SIZE,
+                                        true, RADEON_GEM_DOMAIN_VRAM,
+                                        &rdev->vram_scratch.robj);
+                if (r) {
+                        return r;
+                }
+        }
+
+        r = radeon_bo_reserve(rdev->vram_scratch.robj, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(rdev->vram_scratch.robj,
+                          RADEON_GEM_DOMAIN_VRAM, &gpu_addr);
+        if (r) {
+                radeon_bo_unreserve(rdev->vram_scratch.robj);
+                return r;
+        }
+        r = radeon_bo_kmap(rdev->vram_scratch.robj,
+                                (void **)&rdev->vram_scratch.ptr);
+        if (r)
+                radeon_bo_unpin(rdev->vram_scratch.robj);
+        radeon_bo_unreserve(rdev->vram_scratch.robj);
+
+        return r;
+}
+
+static void rv770_vram_scratch_fini(struct radeon_device *rdev)
+{
+        int r;
+
+        if (rdev->vram_scratch.robj == NULL) {
+                return;
+        }
+        r = radeon_bo_reserve(rdev->vram_scratch.robj, false);
+        if (likely(r == 0)) {
+                radeon_bo_kunmap(rdev->vram_scratch.robj);
+                radeon_bo_unpin(rdev->vram_scratch.robj);
+                radeon_bo_unreserve(rdev->vram_scratch.robj);
+        }
+        radeon_bo_unref(&rdev->vram_scratch.robj);
+}
+
 int rv770_mc_init(struct radeon_device *rdev)
 {
         u32 tmp;
@@ -970,6 +1018,9 @@ static int rv770_startup(struct radeon_device *rdev)
                 if (r)
                         return r;
         }
+        r = rv770_vram_scratch_init(rdev);
+        if (r)
+                return r;
         rv770_gpu_init(rdev);
         r = r600_blit_init(rdev);
         if (r) {
@@ -1023,11 +1074,6 @@ int rv770_resume(struct radeon_device *rdev)
          */
         /* post card */
         atom_asic_init(rdev->mode_info.atom_context);
-        /* Initialize clocks */
-        r = radeon_clocks_init(rdev);
-        if (r) {
-                return r;
-        }
 
         r = rv770_startup(rdev);
         if (r) {
@@ -1118,9 +1164,6 @@ int rv770_init(struct radeon_device *rdev)
         radeon_surface_init(rdev);
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
-        r = radeon_clocks_init(rdev);
-        if (r)
-                return r;
         /* Fence driver */
         r = radeon_fence_driver_init(rdev);
         if (r)
@@ -1195,9 +1238,9 @@ void rv770_fini(struct radeon_device *rdev)
         r600_irq_fini(rdev);
         radeon_irq_kms_fini(rdev);
         rv770_pcie_gart_fini(rdev);
+        rv770_vram_scratch_fini(rdev);
         radeon_gem_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_clocks_fini(rdev);
         radeon_agp_fini(rdev);
         radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
diff --git a/drivers/gpu/drm/savage/savage_bci.c b/drivers/gpu/drm/savage/savage_bci.c
index 976dc8d25280..bf5f83ea14fe 100644
--- a/drivers/gpu/drm/savage/savage_bci.c
+++ b/drivers/gpu/drm/savage/savage_bci.c
@@ -1082,10 +1082,10 @@ void savage_reclaim_buffers(struct drm_device *dev, struct drm_file *file_priv)
 }
 
 struct drm_ioctl_desc savage_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_SAVAGE_BCI_INIT, savage_bci_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_SAVAGE_BCI_CMDBUF, savage_bci_cmdbuf, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_SAVAGE_BCI_EVENT_EMIT, savage_bci_event_emit, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_SAVAGE_BCI_EVENT_WAIT, savage_bci_event_wait, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SAVAGE_BCI_INIT, savage_bci_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(SAVAGE_BCI_CMDBUF, savage_bci_cmdbuf, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SAVAGE_BCI_EVENT_EMIT, savage_bci_event_emit, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SAVAGE_BCI_EVENT_WAIT, savage_bci_event_wait, DRM_AUTH),
 };
 
 int savage_max_ioctl = DRM_ARRAY_SIZE(savage_ioctls);
diff --git a/drivers/gpu/drm/sis/sis_mm.c b/drivers/gpu/drm/sis/sis_mm.c
index 07d0f2979cac..7fe2b63412ce 100644
--- a/drivers/gpu/drm/sis/sis_mm.c
+++ b/drivers/gpu/drm/sis/sis_mm.c
@@ -320,12 +320,12 @@ void sis_reclaim_buffers_locked(struct drm_device *dev,
 }
 
 struct drm_ioctl_desc sis_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_SIS_FB_ALLOC, sis_fb_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_SIS_FB_FREE, sis_drm_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_SIS_AGP_INIT, sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF(DRM_SIS_AGP_ALLOC, sis_ioctl_agp_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_SIS_AGP_FREE, sis_drm_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_SIS_FB_INIT, sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(SIS_FB_ALLOC, sis_fb_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SIS_FB_FREE, sis_drm_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SIS_AGP_INIT, sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(SIS_AGP_ALLOC, sis_ioctl_agp_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SIS_AGP_FREE, sis_drm_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(SIS_FB_INIT, sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY),
 };
 
 int sis_max_ioctl = DRM_ARRAY_SIZE(sis_ioctls);
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index cb4cf7ef4d1e..db809e034cc4 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -442,6 +442,43 @@ out_err:
 }
 
 /**
+ * Call bo::reserved and with the lru lock held.
+ * Will release GPU memory type usage on destruction.
+ * This is the place to put in driver specific hooks.
+ * Will release the bo::reserved lock and the
+ * lru lock on exit.
+ */
+
+static void ttm_bo_cleanup_memtype_use(struct ttm_buffer_object *bo)
+{
+        struct ttm_bo_global *glob = bo->glob;
+
+        if (bo->ttm) {
+
+                /**
+                 * Release the lru_lock, since we don't want to have
+                 * an atomic requirement on ttm_tt[unbind|destroy].
+                 */
+
+                spin_unlock(&glob->lru_lock);
+                ttm_tt_unbind(bo->ttm);
+                ttm_tt_destroy(bo->ttm);
+                bo->ttm = NULL;
+                spin_lock(&glob->lru_lock);
+        }
+
+        if (bo->mem.mm_node) {
+                drm_mm_put_block(bo->mem.mm_node);
+                bo->mem.mm_node = NULL;
+        }
+
+        atomic_set(&bo->reserved, 0);
+        wake_up_all(&bo->event_queue);
+        spin_unlock(&glob->lru_lock);
+}
+
+
+/**
  * If bo idle, remove from delayed- and lru lists, and unref.
  * If not idle, and already on delayed list, do nothing.
  * If not idle, and not on delayed list, put on delayed list,
@@ -456,6 +493,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, bool remove_all)
         int ret;
 
         spin_lock(&bo->lock);
+retry:
         (void) ttm_bo_wait(bo, false, false, !remove_all);
 
         if (!bo->sync_obj) {
@@ -464,31 +502,52 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, bool remove_all)
                 spin_unlock(&bo->lock);
 
                 spin_lock(&glob->lru_lock);
-                put_count = ttm_bo_del_from_lru(bo);
+                ret = ttm_bo_reserve_locked(bo, false, !remove_all, false, 0);
+
+                /**
+                 * Someone else has the object reserved. Bail and retry.
+                 */
 
-                ret = ttm_bo_reserve_locked(bo, false, false, false, 0);
-                BUG_ON(ret);
-                if (bo->ttm)
-                        ttm_tt_unbind(bo->ttm);
+                if (unlikely(ret == -EBUSY)) {
+                        spin_unlock(&glob->lru_lock);
+                        spin_lock(&bo->lock);
+                        goto requeue;
+                }
+
+                /**
+                 * We can re-check for sync object without taking
+                 * the bo::lock since setting the sync object requires
+                 * also bo::reserved. A busy object at this point may
+                 * be caused by another thread starting an accelerated
+                 * eviction.
+                 */
+
+                if (unlikely(bo->sync_obj)) {
+                        atomic_set(&bo->reserved, 0);
+                        wake_up_all(&bo->event_queue);
+                        spin_unlock(&glob->lru_lock);
+                        spin_lock(&bo->lock);
+                        if (remove_all)
+                                goto retry;
+                        else
+                                goto requeue;
+                }
+
+                put_count = ttm_bo_del_from_lru(bo);
 
                 if (!list_empty(&bo->ddestroy)) {
                         list_del_init(&bo->ddestroy);
                         ++put_count;
                 }
-                if (bo->mem.mm_node) {
-                        drm_mm_put_block(bo->mem.mm_node);
-                        bo->mem.mm_node = NULL;
-                }
-                spin_unlock(&glob->lru_lock);
 
-                atomic_set(&bo->reserved, 0);
+                ttm_bo_cleanup_memtype_use(bo);
 
                 while (put_count--)
                         kref_put(&bo->list_kref, ttm_bo_ref_bug);
 
                 return 0;
         }
-
+requeue:
         spin_lock(&glob->lru_lock);
         if (list_empty(&bo->ddestroy)) {
                 void *sync_obj = bo->sync_obj;
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 7cffb3e04232..3451a82adba7 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -351,6 +351,7 @@ static int ttm_buffer_object_transfer(struct ttm_buffer_object *bo,
         INIT_LIST_HEAD(&fbo->lru);
         INIT_LIST_HEAD(&fbo->swap);
         fbo->vm_node = NULL;
+        atomic_set(&fbo->cpu_writers, 0);
 
         fbo->sync_obj = driver->sync_obj_ref(bo->sync_obj);
         kref_init(&fbo->list_kref);
diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc.c b/drivers/gpu/drm/ttm/ttm_page_alloc.c
index ca904799f018..b1e02fffd3cc 100644
--- a/drivers/gpu/drm/ttm/ttm_page_alloc.c
+++ b/drivers/gpu/drm/ttm/ttm_page_alloc.c
@@ -69,7 +69,7 @@ struct ttm_page_pool {
         spinlock_t              lock;
         bool                    fill_lock;
         struct list_head        list;
-        int                     gfp_flags;
+        gfp_t                   gfp_flags;
         unsigned                npages;
         char                    *name;
         unsigned long           nfrees;
@@ -475,7 +475,7 @@ static void ttm_handle_caching_state_failure(struct list_head *pages,
  * This function is reentrant if caller updates count depending on number of
  * pages returned in pages array.
  */
-static int ttm_alloc_new_pages(struct list_head *pages, int gfp_flags,
+static int ttm_alloc_new_pages(struct list_head *pages, gfp_t gfp_flags,
                 int ttm_flags, enum ttm_caching_state cstate, unsigned count)
 {
         struct page **caching_array;
@@ -666,7 +666,7 @@ int ttm_get_pages(struct list_head *pages, int flags,
 {
         struct ttm_page_pool *pool = ttm_get_pool(flags, cstate);
         struct page *p = NULL;
-        int gfp_flags = GFP_USER;
+        gfp_t gfp_flags = GFP_USER;
         int r;
 
         /* set zero flag for page allocation if required */
@@ -818,7 +818,7 @@ int ttm_page_alloc_init(struct ttm_mem_global *glob, unsigned max_pages)
         return 0;
 }
 
-void ttm_page_alloc_fini()
+void ttm_page_alloc_fini(void)
 {
         int i;
 
diff --git a/drivers/gpu/drm/via/via_dma.c b/drivers/gpu/drm/via/via_dma.c
index 68dda74a50ae..cc0ffa9abd00 100644
--- a/drivers/gpu/drm/via/via_dma.c
+++ b/drivers/gpu/drm/via/via_dma.c
@@ -722,20 +722,20 @@ static int via_cmdbuf_size(struct drm_device *dev, void *data, struct drm_file *
 }
 
 struct drm_ioctl_desc via_ioctls[] = {
-        DRM_IOCTL_DEF(DRM_VIA_ALLOCMEM, via_mem_alloc, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_FREEMEM, via_mem_free, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_AGP_INIT, via_agp_init, DRM_AUTH|DRM_MASTER),
-        DRM_IOCTL_DEF(DRM_VIA_FB_INIT, via_fb_init, DRM_AUTH|DRM_MASTER),
-        DRM_IOCTL_DEF(DRM_VIA_MAP_INIT, via_map_init, DRM_AUTH|DRM_MASTER),
-        DRM_IOCTL_DEF(DRM_VIA_DEC_FUTEX, via_decoder_futex, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_DMA_INIT, via_dma_init, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_CMDBUFFER, via_cmdbuffer, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_FLUSH, via_flush_ioctl, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_PCICMD, via_pci_cmdbuffer, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_CMDBUF_SIZE, via_cmdbuf_size, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_WAIT_IRQ, via_wait_irq, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_DMA_BLIT, via_dma_blit, DRM_AUTH),
-        DRM_IOCTL_DEF(DRM_VIA_BLIT_SYNC, via_dma_blit_sync, DRM_AUTH)
+        DRM_IOCTL_DEF_DRV(VIA_ALLOCMEM, via_mem_alloc, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_FREEMEM, via_mem_free, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_AGP_INIT, via_agp_init, DRM_AUTH|DRM_MASTER),
+        DRM_IOCTL_DEF_DRV(VIA_FB_INIT, via_fb_init, DRM_AUTH|DRM_MASTER),
+        DRM_IOCTL_DEF_DRV(VIA_MAP_INIT, via_map_init, DRM_AUTH|DRM_MASTER),
+        DRM_IOCTL_DEF_DRV(VIA_DEC_FUTEX, via_decoder_futex, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_DMA_INIT, via_dma_init, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_CMDBUFFER, via_cmdbuffer, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_FLUSH, via_flush_ioctl, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_PCICMD, via_pci_cmdbuffer, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_CMDBUF_SIZE, via_cmdbuf_size, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_WAIT_IRQ, via_wait_irq, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_DMA_BLIT, via_dma_blit, DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(VIA_BLIT_SYNC, via_dma_blit_sync, DRM_AUTH)
 };
 
 int via_max_ioctl = DRM_ARRAY_SIZE(via_ioctls);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index 9dd395b90216..a96ed6d9d010 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -99,47 +99,47 @@
  */
 
 #define VMW_IOCTL_DEF(ioctl, func, flags) \
-        [DRM_IOCTL_NR(ioctl) - DRM_COMMAND_BASE] = {ioctl, flags, func}
+  [DRM_IOCTL_NR(DRM_IOCTL_##ioctl) - DRM_COMMAND_BASE] = {DRM_##ioctl, flags, func, DRM_IOCTL_##ioctl}
 
 /**
  * Ioctl definitions.
  */
 
 static struct drm_ioctl_desc vmw_ioctls[] = {
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_GET_PARAM, vmw_getparam_ioctl,
+        VMW_IOCTL_DEF(VMW_GET_PARAM, vmw_getparam_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_ALLOC_DMABUF, vmw_dmabuf_alloc_ioctl,
+        VMW_IOCTL_DEF(VMW_ALLOC_DMABUF, vmw_dmabuf_alloc_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_UNREF_DMABUF, vmw_dmabuf_unref_ioctl,
+        VMW_IOCTL_DEF(VMW_UNREF_DMABUF, vmw_dmabuf_unref_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_CURSOR_BYPASS,
+        VMW_IOCTL_DEF(VMW_CURSOR_BYPASS,
                       vmw_kms_cursor_bypass_ioctl,
                       DRM_MASTER | DRM_CONTROL_ALLOW | DRM_UNLOCKED),
 
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_CONTROL_STREAM, vmw_overlay_ioctl,
+        VMW_IOCTL_DEF(VMW_CONTROL_STREAM, vmw_overlay_ioctl,
                       DRM_MASTER | DRM_CONTROL_ALLOW | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_CLAIM_STREAM, vmw_stream_claim_ioctl,
+        VMW_IOCTL_DEF(VMW_CLAIM_STREAM, vmw_stream_claim_ioctl,
                       DRM_MASTER | DRM_CONTROL_ALLOW | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_UNREF_STREAM, vmw_stream_unref_ioctl,
+        VMW_IOCTL_DEF(VMW_UNREF_STREAM, vmw_stream_unref_ioctl,
                       DRM_MASTER | DRM_CONTROL_ALLOW | DRM_UNLOCKED),
 
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_CREATE_CONTEXT, vmw_context_define_ioctl,
+        VMW_IOCTL_DEF(VMW_CREATE_CONTEXT, vmw_context_define_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_UNREF_CONTEXT, vmw_context_destroy_ioctl,
+        VMW_IOCTL_DEF(VMW_UNREF_CONTEXT, vmw_context_destroy_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_CREATE_SURFACE, vmw_surface_define_ioctl,
+        VMW_IOCTL_DEF(VMW_CREATE_SURFACE, vmw_surface_define_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_UNREF_SURFACE, vmw_surface_destroy_ioctl,
+        VMW_IOCTL_DEF(VMW_UNREF_SURFACE, vmw_surface_destroy_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_REF_SURFACE, vmw_surface_reference_ioctl,
+        VMW_IOCTL_DEF(VMW_REF_SURFACE, vmw_surface_reference_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_EXECBUF, vmw_execbuf_ioctl,
+        VMW_IOCTL_DEF(VMW_EXECBUF, vmw_execbuf_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_FIFO_DEBUG, vmw_fifo_debug_ioctl,
+        VMW_IOCTL_DEF(VMW_FIFO_DEBUG, vmw_fifo_debug_ioctl,
                       DRM_AUTH | DRM_ROOT_ONLY | DRM_MASTER | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_FENCE_WAIT, vmw_fence_wait_ioctl,
+        VMW_IOCTL_DEF(VMW_FENCE_WAIT, vmw_fence_wait_ioctl,
                       DRM_AUTH | DRM_UNLOCKED),
-        VMW_IOCTL_DEF(DRM_IOCTL_VMW_UPDATE_LAYOUT, vmw_kms_update_layout_ioctl,
+        VMW_IOCTL_DEF(VMW_UPDATE_LAYOUT, vmw_kms_update_layout_ioctl,
                       DRM_MASTER | DRM_CONTROL_ALLOW | DRM_UNLOCKED)
 };
 
@@ -148,13 +148,16 @@ static struct pci_device_id vmw_pci_id_list[] = {
         {0, 0, 0}
 };
 
-static char *vmw_devname = "vmwgfx";
+static int enable_fbdev;
 
 static int vmw_probe(struct pci_dev *, const struct pci_device_id *);
 static void vmw_master_init(struct vmw_master *);
 static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
                               void *ptr);
 
+MODULE_PARM_DESC(enable_fbdev, "Enable vmwgfx fbdev");
+module_param_named(enable_fbdev, enable_fbdev, int, 0600);
+
 static void vmw_print_capabilities(uint32_t capabilities)
 {
         DRM_INFO("Capabilities:\n");
@@ -192,8 +195,6 @@ static int vmw_request_device(struct vmw_private *dev_priv)
 {
         int ret;
 
-        vmw_kms_save_vga(dev_priv);
-
         ret = vmw_fifo_init(dev_priv, &dev_priv->fifo);
         if (unlikely(ret != 0)) {
                 DRM_ERROR("Unable to initialize FIFO.\n");
@@ -206,9 +207,35 @@ static int vmw_request_device(struct vmw_private *dev_priv)
 static void vmw_release_device(struct vmw_private *dev_priv)
 {
         vmw_fifo_release(dev_priv, &dev_priv->fifo);
-        vmw_kms_restore_vga(dev_priv);
 }
 
+int vmw_3d_resource_inc(struct vmw_private *dev_priv)
+{
+        int ret = 0;
+
+        mutex_lock(&dev_priv->release_mutex);
+        if (unlikely(dev_priv->num_3d_resources++ == 0)) {
+                ret = vmw_request_device(dev_priv);
+                if (unlikely(ret != 0))
+                        --dev_priv->num_3d_resources;
+        }
+        mutex_unlock(&dev_priv->release_mutex);
+        return ret;
+}
+
+
+void vmw_3d_resource_dec(struct vmw_private *dev_priv)
+{
+        int32_t n3d;
+
+        mutex_lock(&dev_priv->release_mutex);
+        if (unlikely(--dev_priv->num_3d_resources == 0))
+                vmw_release_device(dev_priv);
+        n3d = (int32_t) dev_priv->num_3d_resources;
+        mutex_unlock(&dev_priv->release_mutex);
+
+        BUG_ON(n3d < 0);
+}
 
 static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
 {
@@ -228,6 +255,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         dev_priv->last_read_sequence = (uint32_t) -100;
         mutex_init(&dev_priv->hw_mutex);
         mutex_init(&dev_priv->cmdbuf_mutex);
+        mutex_init(&dev_priv->release_mutex);
         rwlock_init(&dev_priv->resource_lock);
         idr_init(&dev_priv->context_idr);
         idr_init(&dev_priv->surface_idr);
@@ -244,6 +272,8 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         dev_priv->vram_start = pci_resource_start(dev->pdev, 1);
         dev_priv->mmio_start = pci_resource_start(dev->pdev, 2);
 
+        dev_priv->enable_fb = enable_fbdev;
+
         mutex_lock(&dev_priv->hw_mutex);
 
         vmw_write(dev_priv, SVGA_REG_ID, SVGA_ID_2);
@@ -343,17 +373,6 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
 
         dev->dev_private = dev_priv;
 
-        if (!dev->devname)
-                dev->devname = vmw_devname;
-
-        if (dev_priv->capabilities & SVGA_CAP_IRQMASK) {
-                ret = drm_irq_install(dev);
-                if (unlikely(ret != 0)) {
-                        DRM_ERROR("Failed installing irq: %d\n", ret);
-                        goto out_no_irq;
-                }
-        }
-
         ret = pci_request_regions(dev->pdev, "vmwgfx probe");
         dev_priv->stealth = (ret != 0);
         if (dev_priv->stealth) {
@@ -369,26 +388,52 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
                         goto out_no_device;
                 }
         }
-        ret = vmw_request_device(dev_priv);
+        ret = vmw_kms_init(dev_priv);
         if (unlikely(ret != 0))
-                goto out_no_device;
-        vmw_kms_init(dev_priv);
+                goto out_no_kms;
         vmw_overlay_init(dev_priv);
-        vmw_fb_init(dev_priv);
+        if (dev_priv->enable_fb) {
+                ret = vmw_3d_resource_inc(dev_priv);
+                if (unlikely(ret != 0))
+                        goto out_no_fifo;
+                vmw_kms_save_vga(dev_priv);
+                vmw_fb_init(dev_priv);
+                DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ?
+                         "Detected device 3D availability.\n" :
+                         "Detected no device 3D availability.\n");
+        } else {
+                DRM_INFO("Delayed 3D detection since we're not "
+                         "running the device in SVGA mode yet.\n");
+        }
+
+        if (dev_priv->capabilities & SVGA_CAP_IRQMASK) {
+                ret = drm_irq_install(dev);
+                if (unlikely(ret != 0)) {
+                        DRM_ERROR("Failed installing irq: %d\n", ret);
+                        goto out_no_irq;
+                }
+        }
 
         dev_priv->pm_nb.notifier_call = vmwgfx_pm_notifier;
         register_pm_notifier(&dev_priv->pm_nb);
 
-        DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ? "Have 3D\n" : "No 3D\n");
-
         return 0;
 
-out_no_device:
-        if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
-                drm_irq_uninstall(dev_priv->dev);
-        if (dev->devname == vmw_devname)
-                dev->devname = NULL;
 out_no_irq:
+        if (dev_priv->enable_fb) {
+                vmw_fb_close(dev_priv);
+                vmw_kms_restore_vga(dev_priv);
+                vmw_3d_resource_dec(dev_priv);
+        }
+out_no_fifo:
+        vmw_overlay_close(dev_priv);
+        vmw_kms_close(dev_priv);
+out_no_kms:
+        if (dev_priv->stealth)
+                pci_release_region(dev->pdev, 2);
+        else
+                pci_release_regions(dev->pdev);
+out_no_device:
         ttm_object_device_release(&dev_priv->tdev);
 out_err4:
         iounmap(dev_priv->mmio_virt);
@@ -415,19 +460,20 @@ static int vmw_driver_unload(struct drm_device *dev)
 
         unregister_pm_notifier(&dev_priv->pm_nb);
 
-        vmw_fb_close(dev_priv);
+        if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
+                drm_irq_uninstall(dev_priv->dev);
+        if (dev_priv->enable_fb) {
+                vmw_fb_close(dev_priv);
+                vmw_kms_restore_vga(dev_priv);
+                vmw_3d_resource_dec(dev_priv);
+        }
         vmw_kms_close(dev_priv);
         vmw_overlay_close(dev_priv);
-        vmw_release_device(dev_priv);
         if (dev_priv->stealth)
                 pci_release_region(dev->pdev, 2);
         else
                 pci_release_regions(dev->pdev);
 
-        if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
-                drm_irq_uninstall(dev_priv->dev);
-        if (dev->devname == vmw_devname)
-                dev->devname = NULL;
         ttm_object_device_release(&dev_priv->tdev);
         iounmap(dev_priv->mmio_virt);
         drm_mtrr_del(dev_priv->mmio_mtrr, dev_priv->mmio_start,
@@ -500,7 +546,7 @@ static long vmw_unlocked_ioctl(struct file *filp, unsigned int cmd,
                 struct drm_ioctl_desc *ioctl =
                     &vmw_ioctls[nr - DRM_COMMAND_BASE];
 
-                if (unlikely(ioctl->cmd != cmd)) {
+                if (unlikely(ioctl->cmd_drv != cmd)) {
                         DRM_ERROR("Invalid command format, ioctl %d\n",
                                   nr - DRM_COMMAND_BASE);
                         return -EINVAL;
@@ -589,6 +635,16 @@ static int vmw_master_set(struct drm_device *dev,
         struct vmw_master *vmaster = vmw_master(file_priv->master);
         int ret = 0;
 
+        if (!dev_priv->enable_fb) {
+                ret = vmw_3d_resource_inc(dev_priv);
+                if (unlikely(ret != 0))
+                        return ret;
+                vmw_kms_save_vga(dev_priv);
+                mutex_lock(&dev_priv->hw_mutex);
+                vmw_write(dev_priv, SVGA_REG_TRACES, 0);
+                mutex_unlock(&dev_priv->hw_mutex);
+        }
+
         if (active) {
                 BUG_ON(active != &dev_priv->fbdev_master);
                 ret = ttm_vt_lock(&active->lock, false, vmw_fp->tfile);
@@ -617,7 +673,13 @@ static int vmw_master_set(struct drm_device *dev,
         return 0;
 
 out_no_active_lock:
-        vmw_release_device(dev_priv);
+        if (!dev_priv->enable_fb) {
+                mutex_lock(&dev_priv->hw_mutex);
+                vmw_write(dev_priv, SVGA_REG_TRACES, 1);
+                mutex_unlock(&dev_priv->hw_mutex);
+                vmw_kms_restore_vga(dev_priv);
+                vmw_3d_resource_dec(dev_priv);
+        }
         return ret;
 }
 
@@ -645,11 +707,23 @@ static void vmw_master_drop(struct drm_device *dev,
 
         ttm_lock_set_kill(&vmaster->lock, true, SIGTERM);
 
+        if (!dev_priv->enable_fb) {
+                ret = ttm_bo_evict_mm(&dev_priv->bdev, TTM_PL_VRAM);
+                if (unlikely(ret != 0))
+                        DRM_ERROR("Unable to clean VRAM on master drop.\n");
+                mutex_lock(&dev_priv->hw_mutex);
+                vmw_write(dev_priv, SVGA_REG_TRACES, 1);
+                mutex_unlock(&dev_priv->hw_mutex);
+                vmw_kms_restore_vga(dev_priv);
+                vmw_3d_resource_dec(dev_priv);
+        }
+
         dev_priv->active_master = &dev_priv->fbdev_master;
         ttm_lock_set_kill(&dev_priv->fbdev_master.lock, false, SIGTERM);
         ttm_vt_unlock(&dev_priv->fbdev_master.lock);
 
-        vmw_fb_on(dev_priv);
+        if (dev_priv->enable_fb)
+                vmw_fb_on(dev_priv);
 }
 
 
@@ -722,6 +796,7 @@ static struct drm_driver driver = {
         .irq_postinstall = vmw_irq_postinstall,
         .irq_uninstall = vmw_irq_uninstall,
         .irq_handler = vmw_irq_handler,
+        .get_vblank_counter = vmw_get_vblank_counter,
         .reclaim_buffers_locked = NULL,
         .get_map_ofs = drm_core_get_map_ofs,
         .get_reg_ofs = drm_core_get_reg_ofs,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index 429f917b60bf..58de6393f611 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -277,6 +277,7 @@ struct vmw_private {
 
         bool stealth;
         bool is_opened;
+        bool enable_fb;
 
         /**
          * Master management.
@@ -285,6 +286,9 @@ struct vmw_private {
         struct vmw_master *active_master;
         struct vmw_master fbdev_master;
         struct notifier_block pm_nb;
+
+        struct mutex release_mutex;
+        uint32_t num_3d_resources;
 };
 
 static inline struct vmw_private *vmw_priv(struct drm_device *dev)
@@ -319,6 +323,9 @@ static inline uint32_t vmw_read(struct vmw_private *dev_priv,
         return val;
 }
 
+int vmw_3d_resource_inc(struct vmw_private *dev_priv);
+void vmw_3d_resource_dec(struct vmw_private *dev_priv);
+
 /**
  * GMR utilities - vmwgfx_gmr.c
  */
@@ -511,6 +518,7 @@ void vmw_kms_write_svga(struct vmw_private *vmw_priv,
                         unsigned bbp, unsigned depth);
 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
                                 struct drm_file *file_priv);
+u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc);
 
 /**
  * Overlay control - vmwgfx_overlay.c
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
index 870967a97c15..409e172f4abf 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
@@ -615,6 +615,11 @@ int vmw_dmabuf_to_start_of_vram(struct vmw_private *vmw_priv,
         if (unlikely(ret != 0))
                 goto err_unlock;
 
+        if (bo->mem.mem_type == TTM_PL_VRAM &&
+            bo->mem.mm_node->start < bo->num_pages)
+                (void) ttm_bo_validate(bo, &vmw_sys_placement, false,
+                                       false, false);
+
         ret = ttm_bo_validate(bo, &ne_placement, false, false, false);
 
         /* Could probably bug on */
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
index e6a1eb7ea954..0fe31766e4cf 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
@@ -106,6 +106,7 @@ int vmw_fifo_init(struct vmw_private *dev_priv, struct vmw_fifo_state *fifo)
         mutex_lock(&dev_priv->hw_mutex);
         dev_priv->enable_state = vmw_read(dev_priv, SVGA_REG_ENABLE);
         dev_priv->config_done_state = vmw_read(dev_priv, SVGA_REG_CONFIG_DONE);
+        dev_priv->traces_state = vmw_read(dev_priv, SVGA_REG_TRACES);
         vmw_write(dev_priv, SVGA_REG_ENABLE, 1);
 
         min = 4;
@@ -175,6 +176,8 @@ void vmw_fifo_release(struct vmw_private *dev_priv, struct vmw_fifo_state *fifo)
                   dev_priv->config_done_state);
         vmw_write(dev_priv, SVGA_REG_ENABLE,
                   dev_priv->enable_state);
+        vmw_write(dev_priv, SVGA_REG_TRACES,
+                  dev_priv->traces_state);
 
         mutex_unlock(&dev_priv->hw_mutex);
         vmw_fence_queue_takedown(&fifo->fence_queue);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index 64d7f47df868..e882ba099f0c 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -898,7 +898,19 @@ int vmw_kms_save_vga(struct vmw_private *vmw_priv)
                 save->width = vmw_read(vmw_priv, SVGA_REG_DISPLAY_WIDTH);
                 save->height = vmw_read(vmw_priv, SVGA_REG_DISPLAY_HEIGHT);
                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, SVGA_ID_INVALID);
+                if (i == 0 && vmw_priv->num_displays == 1 &&
+                    save->width == 0 && save->height == 0) {
+
+                        /*
+                         * It should be fairly safe to assume that these
+                         * values are uninitialized.
+                         */
+
+                        save->width = vmw_priv->vga_width - save->pos_x;
+                        save->height = vmw_priv->vga_height - save->pos_y;
+                }
         }
+
         return 0;
 }
 
@@ -984,3 +996,8 @@ out_unlock:
         ttm_read_unlock(&vmaster->lock);
         return ret;
 }
+
+u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc)
+{
+        return 0;
+}
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
index 2ff5cf78235f..11cb39e3accb 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
@@ -27,6 +27,8 @@
 
 #include "vmwgfx_kms.h"
 
+#define VMWGFX_LDU_NUM_DU 8
+
 #define vmw_crtc_to_ldu(x) \
         container_of(x, struct vmw_legacy_display_unit, base.crtc)
 #define vmw_encoder_to_ldu(x) \
@@ -335,7 +337,8 @@ static void vmw_ldu_connector_restore(struct drm_connector *connector)
 }
 
 static enum drm_connector_status
-        vmw_ldu_connector_detect(struct drm_connector *connector)
+        vmw_ldu_connector_detect(struct drm_connector *connector,
+                                 bool force)
 {
         if (vmw_connector_to_ldu(connector)->pref_active)
                 return connector_status_connected;
@@ -516,7 +519,7 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
 
         drm_connector_init(dev, connector, &vmw_legacy_connector_funcs,
                            DRM_MODE_CONNECTOR_LVDS);
-        connector->status = vmw_ldu_connector_detect(connector);
+        connector->status = vmw_ldu_connector_detect(connector, true);
 
         drm_encoder_init(dev, encoder, &vmw_legacy_encoder_funcs,
                          DRM_MODE_ENCODER_LVDS);
@@ -535,6 +538,10 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
 
 int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
 {
+        struct drm_device *dev = dev_priv->dev;
+        int i;
+        int ret;
+
         if (dev_priv->ldu_priv) {
                 DRM_INFO("ldu system already on\n");
                 return -EINVAL;
@@ -552,23 +559,24 @@ int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
 
         drm_mode_create_dirty_info_property(dev_priv->dev);
 
-        vmw_ldu_init(dev_priv, 0);
-        /* for old hardware without multimon only enable one display */
         if (dev_priv->capabilities & SVGA_CAP_MULTIMON) {
-                vmw_ldu_init(dev_priv, 1);
-                vmw_ldu_init(dev_priv, 2);
-                vmw_ldu_init(dev_priv, 3);
-                vmw_ldu_init(dev_priv, 4);
-                vmw_ldu_init(dev_priv, 5);
-                vmw_ldu_init(dev_priv, 6);
-                vmw_ldu_init(dev_priv, 7);
+                for (i = 0; i < VMWGFX_LDU_NUM_DU; ++i)
+                        vmw_ldu_init(dev_priv, i);
+                ret = drm_vblank_init(dev, VMWGFX_LDU_NUM_DU);
+        } else {
+                /* for old hardware without multimon only enable one display */
+                vmw_ldu_init(dev_priv, 0);
+                ret = drm_vblank_init(dev, 1);
         }
 
-        return 0;
+        return ret;
 }
 
 int vmw_kms_close_legacy_display_system(struct vmw_private *dev_priv)
 {
+        struct drm_device *dev = dev_priv->dev;
+
+        drm_vblank_cleanup(dev);
         if (!dev_priv->ldu_priv)
                 return -ENOSYS;
 
@@ -610,7 +618,7 @@ int vmw_kms_ldu_update_layout(struct vmw_private *dev_priv, unsigned num,
                         ldu->pref_height = 600;
                         ldu->pref_active = false;
                 }
-                con->status = vmw_ldu_connector_detect(con);
+                con->status = vmw_ldu_connector_detect(con, true);
         }
 
         mutex_unlock(&dev->mode_config.mutex);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
index 5f2d5df01e5c..c8c40e9979db 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
@@ -211,6 +211,7 @@ static void vmw_hw_context_destroy(struct vmw_resource *res)
         cmd->body.cid = cpu_to_le32(res->id);
 
         vmw_fifo_commit(dev_priv, sizeof(*cmd));
+        vmw_3d_resource_dec(dev_priv);
 }
 
 static int vmw_context_init(struct vmw_private *dev_priv,
@@ -247,6 +248,7 @@ static int vmw_context_init(struct vmw_private *dev_priv,
         cmd->body.cid = cpu_to_le32(res->id);
 
         vmw_fifo_commit(dev_priv, sizeof(*cmd));
+        (void) vmw_3d_resource_inc(dev_priv);
         vmw_resource_activate(res, vmw_hw_context_destroy);
         return 0;
 }
@@ -406,6 +408,7 @@ static void vmw_hw_surface_destroy(struct vmw_resource *res)
         cmd->body.sid = cpu_to_le32(res->id);
 
         vmw_fifo_commit(dev_priv, sizeof(*cmd));
+        vmw_3d_resource_dec(dev_priv);
 }
 
 void vmw_surface_res_free(struct vmw_resource *res)
@@ -473,6 +476,7 @@ int vmw_surface_init(struct vmw_private *dev_priv,
         }
 
         vmw_fifo_commit(dev_priv, submit_size);
+        (void) vmw_3d_resource_inc(dev_priv);
         vmw_resource_activate(res, vmw_hw_surface_destroy);
         return 0;
 }
diff --git a/drivers/gpu/vga/vgaarb.c b/drivers/gpu/vga/vgaarb.c
index b87569e96b16..f366f968155a 100644
--- a/drivers/gpu/vga/vgaarb.c
+++ b/drivers/gpu/vga/vgaarb.c
@@ -598,7 +598,7 @@ static inline void vga_update_device_decodes(struct vga_device *vgadev,
         pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
 }
 
-void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
+static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
 {
         struct vga_device *vgadev;
         unsigned long flags;