81 files changed, 6782 insertions, 1762 deletions

diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index f831ea159291..96eddd17e050 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -92,6 +92,7 @@ config DRM_I830
 config DRM_I915
         tristate "i915 driver"
         depends on AGP_INTEL
+        select SHMEM
         select DRM_KMS_HELPER
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 3c8827a7aabd..91567ac806f1 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -15,7 +15,7 @@ drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
 
 drm-$(CONFIG_COMPAT) += drm_ioc32.o
 
-drm_kms_helper-y := drm_fb_helper.o drm_crtc_helper.o
+drm_kms_helper-y := drm_fb_helper.o drm_crtc_helper.o drm_dp_i2c_helper.o
 
 obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o
 
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 3bc870d38a97..4a7bbdbedfc2 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -125,6 +125,15 @@ static struct drm_prop_enum_list drm_tv_subconnector_enum_list[] =
 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
                  drm_tv_subconnector_enum_list)
 
+static struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
+        { DRM_MODE_DIRTY_OFF,      "Off"      },
+        { DRM_MODE_DIRTY_ON,       "On"       },
+        { DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
+};
+
+DRM_ENUM_NAME_FN(drm_get_dirty_info_name,
+                 drm_dirty_info_enum_list)
+
 struct drm_conn_prop_enum_list {
         int type;
         char *name;
@@ -803,6 +812,36 @@ int drm_mode_create_dithering_property(struct drm_device *dev)
 EXPORT_SYMBOL(drm_mode_create_dithering_property);
 
 /**
+ * drm_mode_create_dirty_property - create dirty property
+ * @dev: DRM device
+ *
+ * Called by a driver the first time it's needed, must be attached to desired
+ * connectors.
+ */
+int drm_mode_create_dirty_info_property(struct drm_device *dev)
+{
+        struct drm_property *dirty_info;
+        int i;
+
+        if (dev->mode_config.dirty_info_property)
+                return 0;
+
+        dirty_info =
+                drm_property_create(dev, DRM_MODE_PROP_ENUM |
+                                    DRM_MODE_PROP_IMMUTABLE,
+                                    "dirty",
+                                    ARRAY_SIZE(drm_dirty_info_enum_list));
+        for (i = 0; i < ARRAY_SIZE(drm_dirty_info_enum_list); i++)
+                drm_property_add_enum(dirty_info, i,
+                                      drm_dirty_info_enum_list[i].type,
+                                      drm_dirty_info_enum_list[i].name);
+        dev->mode_config.dirty_info_property = dirty_info;
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
+
+/**
  * drm_mode_config_init - initialize DRM mode_configuration structure
  * @dev: DRM device
  *
@@ -1754,6 +1793,71 @@ out:
         return ret;
 }
 
+int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
+                           void *data, struct drm_file *file_priv)
+{
+        struct drm_clip_rect __user *clips_ptr;
+        struct drm_clip_rect *clips = NULL;
+        struct drm_mode_fb_dirty_cmd *r = data;
+        struct drm_mode_object *obj;
+        struct drm_framebuffer *fb;
+        unsigned flags;
+        int num_clips;
+        int ret = 0;
+
+        mutex_lock(&dev->mode_config.mutex);
+        obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
+        if (!obj) {
+                DRM_ERROR("invalid framebuffer id\n");
+                ret = -EINVAL;
+                goto out_err1;
+        }
+        fb = obj_to_fb(obj);
+
+        num_clips = r->num_clips;
+        clips_ptr = (struct drm_clip_rect *)(unsigned long)r->clips_ptr;
+
+        if (!num_clips != !clips_ptr) {
+                ret = -EINVAL;
+                goto out_err1;
+        }
+
+        flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags;
+
+        /* If userspace annotates copy, clips must come in pairs */
+        if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) {
+                ret = -EINVAL;
+                goto out_err1;
+        }
+
+        if (num_clips && clips_ptr) {
+                clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL);
+                if (!clips) {
+                        ret = -ENOMEM;
+                        goto out_err1;
+                }
+
+                ret = copy_from_user(clips, clips_ptr,
+                                     num_clips * sizeof(*clips));
+                if (ret)
+                        goto out_err2;
+        }
+
+        if (fb->funcs->dirty) {
+                ret = fb->funcs->dirty(fb, flags, r->color, clips, num_clips);
+        } else {
+                ret = -ENOSYS;
+                goto out_err2;
+        }
+
+out_err2:
+        kfree(clips);
+out_err1:
+        mutex_unlock(&dev->mode_config.mutex);
+        return ret;
+}
+
+
 /**
  * drm_fb_release - remove and free the FBs on this file
  * @filp: file * from the ioctl
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index 1fe4e1d344fd..3963b3c1081a 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -109,7 +109,7 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
 
         count = (*connector_funcs->get_modes)(connector);
         if (!count) {
-                count = drm_add_modes_noedid(connector, 800, 600);
+                count = drm_add_modes_noedid(connector, 1024, 768);
                 if (!count)
                         return 0;
         }
@@ -331,6 +331,7 @@ create_mode:
                             cmdline_mode->refresh_specified ? cmdline_mode->refresh : 60,
                             cmdline_mode->rb, cmdline_mode->interlace,
                             cmdline_mode->margins);
+        drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
         list_add(&mode->head, &connector->modes);
         return mode;
 }
diff --git a/drivers/gpu/drm/i915/intel_dp_i2c.c b/drivers/gpu/drm/drm_dp_i2c_helper.c
index a57273ade677..548887c8506f 100644
--- a/drivers/gpu/drm/i915/intel_dp_i2c.c
+++ b/drivers/gpu/drm/drm_dp_i2c_helper.c
@@ -28,84 +28,20 @@
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/i2c.h>
-#include "intel_dp.h"
+#include "drm_dp_helper.h"
 #include "drmP.h"
 
 /* Run a single AUX_CH I2C transaction, writing/reading data as necessary */
-
-#define MODE_I2C_START  1
-#define MODE_I2C_WRITE  2
-#define MODE_I2C_READ   4
-#define MODE_I2C_STOP   8
-
 static int
 i2c_algo_dp_aux_transaction(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;
-        uint16_t address = algo_data->address;
-        uint8_t msg[5];
-        uint8_t reply[2];
-        int msg_bytes;
-        int reply_bytes;
         int ret;
-
-        /* Set up the command byte */
-        if (mode & MODE_I2C_READ)
-                msg[0] = AUX_I2C_READ << 4;
-        else
-                msg[0] = AUX_I2C_WRITE << 4;
-
-        if (!(mode & MODE_I2C_STOP))
-                msg[0] |= AUX_I2C_MOT << 4;
-
-        msg[1] = address >> 8;
-        msg[2] = address;
-
-        switch (mode) {
-        case MODE_I2C_WRITE:
-                msg[3] = 0;
-                msg[4] = write_byte;
-                msg_bytes = 5;
-                reply_bytes = 1;
-                break;
-        case MODE_I2C_READ:
-                msg[3] = 0;
-                msg_bytes = 4;
-                reply_bytes = 2;
-                break;
-        default:
-                msg_bytes = 3;
-                reply_bytes = 1;
-                break;
-        }
-
-        for (;;) {
-                ret = (*algo_data->aux_ch)(adapter,
-                                           msg, msg_bytes,
-                                           reply, reply_bytes);
-                if (ret < 0) {
-                        DRM_DEBUG_KMS("aux_ch failed %d\n", ret);
-                        return ret;
-                }
-                switch (reply[0] & AUX_I2C_REPLY_MASK) {
-                case AUX_I2C_REPLY_ACK:
-                        if (mode == MODE_I2C_READ) {
-                                *read_byte = reply[1];
-                        }
-                        return reply_bytes - 1;
-                case AUX_I2C_REPLY_NACK:
-                        DRM_DEBUG_KMS("aux_ch nack\n");
-                        return -EREMOTEIO;
-                case AUX_I2C_REPLY_DEFER:
-                        DRM_DEBUG_KMS("aux_ch defer\n");
-                        udelay(100);
-                        break;
-                default:
-                        DRM_ERROR("aux_ch invalid reply 0x%02x\n", reply[0]);
-                        return -EREMOTEIO;
-                }
-        }
+        
+        ret = (*algo_data->aux_ch)(adapter, mode,
+                                   write_byte, read_byte);
+        return ret;
 }
 
 /*
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index bfaf59b02bda..ff2f1042cb44 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -146,6 +146,7 @@ static struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_MASTER|DRM_CONTROL_ALLOW),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb, DRM_MASTER|DRM_CONTROL_ALLOW),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_PAGE_FLIP, drm_mode_page_flip_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_DIRTYFB, drm_mode_dirtyfb_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW)
 };
 
 #define DRM_CORE_IOCTL_COUNT    ARRAY_SIZE( drm_ioctls )
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index cea665d86dd3..c39b26f1abed 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -123,18 +123,20 @@ static const u8 edid_header[] = {
  */
 static bool edid_is_valid(struct edid *edid)
 {
-        int i;
+        int i, score = 0;
         u8 csum = 0;
         u8 *raw_edid = (u8 *)edid;
 
-        if (memcmp(edid->header, edid_header, sizeof(edid_header)))
-                goto bad;
-        if (edid->version != 1) {
-                DRM_ERROR("EDID has major version %d, instead of 1\n", edid->version);
+        for (i = 0; i < sizeof(edid_header); i++)
+                if (raw_edid[i] == edid_header[i])
+                        score++;
+
+        if (score == 8) ;
+        else if (score >= 6) {
+                DRM_DEBUG("Fixing EDID header, your hardware may be failing\n");
+                memcpy(raw_edid, edid_header, sizeof(edid_header));
+        } else
                 goto bad;
-        }
-        if (edid->revision > 4)
-                DRM_DEBUG("EDID minor > 4, assuming backward compatibility\n");
 
         for (i = 0; i < EDID_LENGTH; i++)
                 csum += raw_edid[i];
@@ -143,6 +145,14 @@ static bool edid_is_valid(struct edid *edid)
                 goto bad;
         }
 
+        if (edid->version != 1) {
+                DRM_ERROR("EDID has major version %d, instead of 1\n", edid->version);
+                goto bad;
+        }
+
+        if (edid->revision > 4)
+                DRM_DEBUG("EDID minor > 4, assuming backward compatibility\n");
+
         return 1;
 
 bad:
@@ -481,16 +491,17 @@ static struct drm_display_mode drm_dmt_modes[] = {
                    3048, 3536, 0, 1600, 1603, 1609, 1682, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
 };
+static const int drm_num_dmt_modes =
+        sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
 
 static struct drm_display_mode *drm_find_dmt(struct drm_device *dev,
                         int hsize, int vsize, int fresh)
 {
-        int i, count;
+        int i;
         struct drm_display_mode *ptr, *mode;
 
-        count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
         mode = NULL;
-        for (i = 0; i < count; i++) {
+        for (i = 0; i < drm_num_dmt_modes; i++) {
                 ptr = &drm_dmt_modes[i];
                 if (hsize == ptr->hdisplay &&
                         vsize == ptr->vdisplay &&
@@ -662,6 +673,12 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
                 return NULL;
         }
 
+        /* Some EDIDs have bogus h/vtotal values */
+        if (mode->hsync_end > mode->htotal)
+                mode->htotal = mode->hsync_end + 1;
+        if (mode->vsync_end > mode->vtotal)
+                mode->vtotal = mode->vsync_end + 1;
+
         drm_mode_set_name(mode);
 
         if (pt->misc & DRM_EDID_PT_INTERLACED)
@@ -828,8 +845,165 @@ static int add_standard_modes(struct drm_connector *connector, struct edid *edid
         return modes;
 }
 
+/*
+ * XXX fix this for:
+ * - GTF secondary curve formula
+ * - EDID 1.4 range offsets
+ * - CVT extended bits
+ */
+static bool
+mode_in_range(struct drm_display_mode *mode, struct detailed_timing *timing)
+{
+        struct detailed_data_monitor_range *range;
+        int hsync, vrefresh;
+
+        range = &timing->data.other_data.data.range;
+
+        hsync = drm_mode_hsync(mode);
+        vrefresh = drm_mode_vrefresh(mode);
+
+        if (hsync < range->min_hfreq_khz || hsync > range->max_hfreq_khz)
+                return false;
+
+        if (vrefresh < range->min_vfreq || vrefresh > range->max_vfreq)
+                return false;
+
+        if (range->pixel_clock_mhz && range->pixel_clock_mhz != 0xff) {
+                /* be forgiving since it's in units of 10MHz */
+                int max_clock = range->pixel_clock_mhz * 10 + 9;
+                max_clock *= 1000;
+                if (mode->clock > max_clock)
+                        return false;
+        }
+
+        return true;
+}
+
+/*
+ * XXX If drm_dmt_modes ever regrows the CVT-R modes (and it will) this will
+ * need to account for them.
+ */
+static int drm_gtf_modes_for_range(struct drm_connector *connector,
+                                   struct detailed_timing *timing)
+{
+        int i, modes = 0;
+        struct drm_display_mode *newmode;
+        struct drm_device *dev = connector->dev;
+
+        for (i = 0; i < drm_num_dmt_modes; i++) {
+                if (mode_in_range(drm_dmt_modes + i, timing)) {
+                        newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
+                        if (newmode) {
+                                drm_mode_probed_add(connector, newmode);
+                                modes++;
+                        }
+                }
+        }
+
+        return modes;
+}
+
+static int drm_cvt_modes(struct drm_connector *connector,
+                         struct detailed_timing *timing)
+{
+        int i, j, modes = 0;
+        struct drm_display_mode *newmode;
+        struct drm_device *dev = connector->dev;
+        struct cvt_timing *cvt;
+        const int rates[] = { 60, 85, 75, 60, 50 };
+
+        for (i = 0; i < 4; i++) {
+                int width, height;
+                cvt = &(timing->data.other_data.data.cvt[i]);
+
+                height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 8) + 1) * 2;
+                switch (cvt->code[1] & 0xc0) {
+                case 0x00:
+                        width = height * 4 / 3;
+                        break;
+                case 0x40:
+                        width = height * 16 / 9;
+                        break;
+                case 0x80:
+                        width = height * 16 / 10;
+                        break;
+                case 0xc0:
+                        width = height * 15 / 9;
+                        break;
+                }
+
+                for (j = 1; j < 5; j++) {
+                        if (cvt->code[2] & (1 << j)) {
+                                newmode = drm_cvt_mode(dev, width, height,
+                                                       rates[j], j == 0,
+                                                       false, false);
+                                if (newmode) {
+                                        drm_mode_probed_add(connector, newmode);
+                                        modes++;
+                                }
+                        }
+                }
+        }
+
+        return modes;
+}
+
+static int add_detailed_modes(struct drm_connector *connector,
+                              struct detailed_timing *timing,
+                              struct edid *edid, u32 quirks, int preferred)
+{
+        int i, modes = 0;
+        struct detailed_non_pixel *data = &timing->data.other_data;
+        int timing_level = standard_timing_level(edid);
+        int gtf = (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF);
+        struct drm_display_mode *newmode;
+        struct drm_device *dev = connector->dev;
+
+        if (timing->pixel_clock) {
+                newmode = drm_mode_detailed(dev, edid, timing, quirks);
+                if (!newmode)
+                        return 0;
+
+                if (preferred)
+                        newmode->type |= DRM_MODE_TYPE_PREFERRED;
+
+                drm_mode_probed_add(connector, newmode);
+                return 1;
+        }
+
+        /* other timing types */
+        switch (data->type) {
+        case EDID_DETAIL_MONITOR_RANGE:
+                if (gtf)
+                        modes += drm_gtf_modes_for_range(connector, timing);
+                break;
+        case EDID_DETAIL_STD_MODES:
+                /* Six modes per detailed section */
+                for (i = 0; i < 6; i++) {
+                        struct std_timing *std;
+                        struct drm_display_mode *newmode;
+
+                        std = &data->data.timings[i];
+                        newmode = drm_mode_std(dev, std, edid->revision,
+                                               timing_level);
+                        if (newmode) {
+                                drm_mode_probed_add(connector, newmode);
+                                modes++;
+                        }
+                }
+                break;
+        case EDID_DETAIL_CVT_3BYTE:
+                modes += drm_cvt_modes(connector, timing);
+                break;
+        default:
+                break;
+        }
+
+        return modes;
+}
+
 /**
- * add_detailed_modes - get detailed mode info from EDID data
+ * add_detailed_info - get detailed mode info from EDID data
  * @connector: attached connector
  * @edid: EDID block to scan
  * @quirks: quirks to apply
@@ -840,67 +1014,24 @@ static int add_standard_modes(struct drm_connector *connector, struct edid *edid
 static int add_detailed_info(struct drm_connector *connector,
                              struct edid *edid, u32 quirks)
 {
-        struct drm_device *dev = connector->dev;
-        int i, j, modes = 0;
-        int timing_level;
-
-        timing_level = standard_timing_level(edid);
+        int i, modes = 0;
 
         for (i = 0; i < EDID_DETAILED_TIMINGS; i++) {
                 struct detailed_timing *timing = &edid->detailed_timings[i];
-                struct detailed_non_pixel *data = &timing->data.other_data;
-                struct drm_display_mode *newmode;
+                int preferred = (i == 0) && (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING);
 
-                /* X server check is version 1.1 or higher */
-                if (edid->version == 1 && edid->revision >= 1 &&
-                    !timing->pixel_clock) {
-                        /* Other timing or info */
-                        switch (data->type) {
-                        case EDID_DETAIL_MONITOR_SERIAL:
-                                break;
-                        case EDID_DETAIL_MONITOR_STRING:
-                                break;
-                        case EDID_DETAIL_MONITOR_RANGE:
-                                /* Get monitor range data */
-                                break;
-                        case EDID_DETAIL_MONITOR_NAME:
-                                break;
-                        case EDID_DETAIL_MONITOR_CPDATA:
-                                break;
-                        case EDID_DETAIL_STD_MODES:
-                                for (j = 0; j < 6; i++) {
-                                        struct std_timing *std;
-                                        struct drm_display_mode *newmode;
-
-                                        std = &data->data.timings[j];
-                                        newmode = drm_mode_std(dev, std,
-                                                               edid->revision,
-                                                               timing_level);
-                                        if (newmode) {
-                                                drm_mode_probed_add(connector, newmode);
-                                                modes++;
-                                        }
-                                }
-                                break;
-                        default:
-                                break;
-                        }
-                } else {
-                        newmode = drm_mode_detailed(dev, edid, timing, quirks);
-                        if (!newmode)
-                                continue;
-
-                        /* First detailed mode is preferred */
-                        if (i == 0 && (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING))
-                                newmode->type |= DRM_MODE_TYPE_PREFERRED;
-                        drm_mode_probed_add(connector, newmode);
+                /* In 1.0, only timings are allowed */
+                if (!timing->pixel_clock && edid->version == 1 &&
+                        edid->revision == 0)
+                        continue;
 
-                        modes++;
-                }
+                modes += add_detailed_modes(connector, timing, edid, quirks,
+                                            preferred);
         }
 
         return modes;
 }
+
 /**
  * add_detailed_mode_eedid - get detailed mode info from addtional timing
  *                      EDID block
@@ -914,12 +1045,9 @@ static int add_detailed_info(struct drm_connector *connector,
 static int add_detailed_info_eedid(struct drm_connector *connector,
                              struct edid *edid, u32 quirks)
 {
-        struct drm_device *dev = connector->dev;
-        int i, j, modes = 0;
+        int i, modes = 0;
         char *edid_ext = NULL;
         struct detailed_timing *timing;
-        struct detailed_non_pixel *data;
-        struct drm_display_mode *newmode;
         int edid_ext_num;
         int start_offset, end_offset;
         int timing_level;
@@ -970,51 +1098,7 @@ static int add_detailed_info_eedid(struct drm_connector *connector,
         for (i = start_offset; i < end_offset;
                         i += sizeof(struct detailed_timing)) {
                 timing = (struct detailed_timing *)(edid_ext + i);
-                data = &timing->data.other_data;
-                /* Detailed mode timing */
-                if (timing->pixel_clock) {
-                        newmode = drm_mode_detailed(dev, edid, timing, quirks);
-                        if (!newmode)
-                                continue;
-
-                        drm_mode_probed_add(connector, newmode);
-
-                        modes++;
-                        continue;
-                }
-
-                /* Other timing or info */
-                switch (data->type) {
-                case EDID_DETAIL_MONITOR_SERIAL:
-                        break;
-                case EDID_DETAIL_MONITOR_STRING:
-                        break;
-                case EDID_DETAIL_MONITOR_RANGE:
-                        /* Get monitor range data */
-                        break;
-                case EDID_DETAIL_MONITOR_NAME:
-                        break;
-                case EDID_DETAIL_MONITOR_CPDATA:
-                        break;
-                case EDID_DETAIL_STD_MODES:
-                        /* Five modes per detailed section */
-                        for (j = 0; j < 5; i++) {
-                                struct std_timing *std;
-                                struct drm_display_mode *newmode;
-
-                                std = &data->data.timings[j];
-                                newmode = drm_mode_std(dev, std,
-                                                       edid->revision,
-                                                       timing_level);
-                                if (newmode) {
-                                        drm_mode_probed_add(connector, newmode);
-                                        modes++;
-                                }
-                        }
-                        break;
-                default:
-                        break;
-                }
+                modes += add_detailed_modes(connector, timing, edid, quirks, 0);
         }
 
         return modes;
@@ -1060,19 +1144,19 @@ static int drm_ddc_read_edid(struct drm_connector *connector,
                              struct i2c_adapter *adapter,
                              char *buf, int len)
 {
-        int ret;
+        int i;
 
-        ret = drm_do_probe_ddc_edid(adapter, buf, len);
-        if (ret != 0) {
-                goto end;
-        }
-        if (!edid_is_valid((struct edid *)buf)) {
-                dev_warn(&connector->dev->pdev->dev, "%s: EDID invalid.\n",
-                         drm_get_connector_name(connector));
-                ret = -1;
+        for (i = 0; i < 4; i++) {
+                if (drm_do_probe_ddc_edid(adapter, buf, len))
+                        return -1;
+                if (edid_is_valid((struct edid *)buf))
+                        return 0;
         }
-end:
-        return ret;
+
+        /* repeated checksum failures; warn, but carry on */
+        dev_warn(&connector->dev->pdev->dev, "%s: EDID invalid.\n",
+                 drm_get_connector_name(connector));
+        return -1;
 }
 
 /**
@@ -1290,6 +1374,8 @@ int drm_add_modes_noedid(struct drm_connector *connector,
                                         ptr->vdisplay > vdisplay)
                                 continue;
                 }
+                if (drm_mode_vrefresh(ptr) > 61)
+                        continue;
                 mode = drm_mode_duplicate(dev, ptr);
                 if (mode) {
                         drm_mode_probed_add(connector, mode);
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index dc8e374a0b55..1b49fa055f4f 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -373,11 +373,9 @@ static void drm_fb_helper_off(struct fb_info *info, int dpms_mode)
                                         mutex_unlock(&dev->mode_config.mutex);
                                 }
                         }
-                        if (dpms_mode == DRM_MODE_DPMS_OFF) {
-                                mutex_lock(&dev->mode_config.mutex);
-                                crtc_funcs->dpms(crtc, dpms_mode);
-                                mutex_unlock(&dev->mode_config.mutex);
-                        }
+                        mutex_lock(&dev->mode_config.mutex);
+                        crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
+                        mutex_unlock(&dev->mode_config.mutex);
                 }
         }
 }
@@ -385,18 +383,23 @@ static void drm_fb_helper_off(struct fb_info *info, int dpms_mode)
 int drm_fb_helper_blank(int blank, struct fb_info *info)
 {
         switch (blank) {
+        /* Display: On; HSync: On, VSync: On */
         case FB_BLANK_UNBLANK:
                 drm_fb_helper_on(info);
                 break;
+        /* Display: Off; HSync: On, VSync: On */
         case FB_BLANK_NORMAL:
-                drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
+                drm_fb_helper_off(info, DRM_MODE_DPMS_ON);
                 break;
+        /* Display: Off; HSync: Off, VSync: On */
         case FB_BLANK_HSYNC_SUSPEND:
                 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
                 break;
+        /* Display: Off; HSync: On, VSync: Off */
         case FB_BLANK_VSYNC_SUSPEND:
                 drm_fb_helper_off(info, DRM_MODE_DPMS_SUSPEND);
                 break;
+        /* Display: Off; HSync: Off, VSync: Off */
         case FB_BLANK_POWERDOWN:
                 drm_fb_helper_off(info, DRM_MODE_DPMS_OFF);
                 break;
@@ -599,7 +602,7 @@ int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
         struct drm_framebuffer *fb = fb_helper->fb;
         int depth;
 
-        if (var->pixclock == -1 || !var->pixclock)
+        if (var->pixclock != 0)
                 return -EINVAL;
 
         /* Need to resize the fb object !!! */
@@ -691,7 +694,7 @@ int drm_fb_helper_set_par(struct fb_info *info)
         int ret;
         int i;
 
-        if (var->pixclock != -1) {
+        if (var->pixclock != 0) {
                 DRM_ERROR("PIXEL CLCOK SET\n");
                 return -EINVAL;
         }
@@ -904,9 +907,14 @@ int drm_fb_helper_single_fb_probe(struct drm_device *dev,
         fb_helper->fb = fb;
 
         if (new_fb) {
-                info->var.pixclock = -1;
-                if (register_framebuffer(info) < 0)
+                info->var.pixclock = 0;
+                ret = fb_alloc_cmap(&info->cmap, modeset->crtc->gamma_size, 0);
+                if (ret)
+                        return ret;
+                if (register_framebuffer(info) < 0) {
+                        fb_dealloc_cmap(&info->cmap);
                         return -EINVAL;
+                }
         } else {
                 drm_fb_helper_set_par(info);
         }
@@ -936,6 +944,7 @@ void drm_fb_helper_free(struct drm_fb_helper *helper)
                 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
         }
         drm_fb_helper_crtc_free(helper);
+        fb_dealloc_cmap(&helper->fb->fbdev->cmap);
 }
 EXPORT_SYMBOL(drm_fb_helper_free);
 
diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c
index 8ac7fbf6b2b7..08d14df3bb42 100644
--- a/drivers/gpu/drm/drm_fops.c
+++ b/drivers/gpu/drm/drm_fops.c
@@ -300,6 +300,18 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
                                 goto out_free;
                         }
                 }
+                mutex_lock(&dev->struct_mutex);
+                if (dev->driver->master_set) {
+                        ret = dev->driver->master_set(dev, priv, true);
+                        if (ret) {
+                                /* drop both references if this fails */
+                                drm_master_put(&priv->minor->master);
+                                drm_master_put(&priv->master);
+                                mutex_unlock(&dev->struct_mutex);
+                                goto out_free;
+                        }
+                }
+                mutex_unlock(&dev->struct_mutex);
         } else {
                 /* get a reference to the master */
                 priv->master = drm_master_get(priv->minor->master);
@@ -533,6 +545,8 @@ int drm_release(struct inode *inode, struct file *filp)
 
                 if (file_priv->minor->master == file_priv->master) {
                         /* drop the reference held my the minor */
+                        if (dev->driver->master_drop)
+                                dev->driver->master_drop(dev, file_priv, true);
                         drm_master_put(&file_priv->minor->master);
                 }
         }
diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
index 80391995bdec..e9dbb481c469 100644
--- a/drivers/gpu/drm/drm_gem.c
+++ b/drivers/gpu/drm/drm_gem.c
@@ -552,7 +552,7 @@ int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
         vma->vm_flags |= VM_RESERVED | VM_IO | VM_PFNMAP | VM_DONTEXPAND;
         vma->vm_ops = obj->dev->driver->gem_vm_ops;
         vma->vm_private_data = map->handle;
-        vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
+        vma->vm_page_prot =  pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
 
         /* Take a ref for this mapping of the object, so that the fault
          * handler can dereference the mmap offset's pointer to the object.
diff --git a/drivers/gpu/drm/drm_mm.c b/drivers/gpu/drm/drm_mm.c
index c861d80fd779..1f0d717dbad6 100644
--- a/drivers/gpu/drm/drm_mm.c
+++ b/drivers/gpu/drm/drm_mm.c
@@ -103,6 +103,11 @@ static struct drm_mm_node *drm_mm_kmalloc(struct drm_mm *mm, int atomic)
         return child;
 }
 
+/* drm_mm_pre_get() - pre allocate drm_mm_node structure
+ * drm_mm:      memory manager struct we are pre-allocating for
+ *
+ * Returns 0 on success or -ENOMEM if allocation fails.
+ */
 int drm_mm_pre_get(struct drm_mm *mm)
 {
         struct drm_mm_node *node;
@@ -253,12 +258,14 @@ void drm_mm_put_block(struct drm_mm_node *cur)
                                 prev_node->size += next_node->size;
                                 list_del(&next_node->ml_entry);
                                 list_del(&next_node->fl_entry);
+                                spin_lock(&mm->unused_lock);
                                 if (mm->num_unused < MM_UNUSED_TARGET) {
                                         list_add(&next_node->fl_entry,
                                                  &mm->unused_nodes);
                                         ++mm->num_unused;
                                 } else
                                         kfree(next_node);
+                                spin_unlock(&mm->unused_lock);
                         } else {
                                 next_node->size += cur->size;
                                 next_node->start = cur->start;
@@ -271,11 +278,13 @@ void drm_mm_put_block(struct drm_mm_node *cur)
                 list_add(&cur->fl_entry, &mm->fl_entry);
         } else {
                 list_del(&cur->ml_entry);
+                spin_lock(&mm->unused_lock);
                 if (mm->num_unused < MM_UNUSED_TARGET) {
                         list_add(&cur->fl_entry, &mm->unused_nodes);
                         ++mm->num_unused;
                 } else
                         kfree(cur);
+                spin_unlock(&mm->unused_lock);
         }
 }
 
@@ -386,7 +395,7 @@ int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm)
                 else
                         total_used += entry->size;
         }
-        seq_printf(m, "total: %d, used %d free %d\n", total, total_free, total_used);
+        seq_printf(m, "total: %d, used %d free %d\n", total, total_used, total_free);
         return 0;
 }
 EXPORT_SYMBOL(drm_mm_dump_table);
diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
index 51f677215f1d..6d81a02463a3 100644
--- a/drivers/gpu/drm/drm_modes.c
+++ b/drivers/gpu/drm/drm_modes.c
@@ -553,6 +553,32 @@ int drm_mode_height(struct drm_display_mode *mode)
 }
 EXPORT_SYMBOL(drm_mode_height);
 
+/** drm_mode_hsync - get the hsync of a mode
+ * @mode: mode
+ *
+ * LOCKING:
+ * None.
+ *
+ * Return @modes's hsync rate in kHz, rounded to the nearest int.
+ */
+int drm_mode_hsync(struct drm_display_mode *mode)
+{
+        unsigned int calc_val;
+
+        if (mode->hsync)
+                return mode->hsync;
+
+        if (mode->htotal < 0)
+                return 0;
+
+        calc_val = (mode->clock * 1000) / mode->htotal; /* hsync in Hz */
+        calc_val += 500;                                /* round to 1000Hz */
+        calc_val /= 1000;                               /* truncate to kHz */
+
+        return calc_val;
+}
+EXPORT_SYMBOL(drm_mode_hsync);
+
 /**
  * drm_mode_vrefresh - get the vrefresh of a mode
  * @mode: mode
@@ -560,7 +586,7 @@ EXPORT_SYMBOL(drm_mode_height);
  * LOCKING:
  * None.
  *
- * Return @mode's vrefresh rate or calculate it if necessary.
+ * Return @mode's vrefresh rate in Hz or calculate it if necessary.
  *
  * FIXME: why is this needed?  shouldn't vrefresh be set already?
  *
diff --git a/drivers/gpu/drm/drm_stub.c b/drivers/gpu/drm/drm_stub.c
index adb864dfef3e..ad73e141afdb 100644
--- a/drivers/gpu/drm/drm_stub.c
+++ b/drivers/gpu/drm/drm_stub.c
@@ -128,6 +128,7 @@ struct drm_master *drm_master_get(struct drm_master *master)
         kref_get(&master->refcount);
         return master;
 }
+EXPORT_SYMBOL(drm_master_get);
 
 static void drm_master_destroy(struct kref *kref)
 {
@@ -170,10 +171,13 @@ void drm_master_put(struct drm_master **master)
         kref_put(&(*master)->refcount, drm_master_destroy);
         *master = NULL;
 }
+EXPORT_SYMBOL(drm_master_put);
 
 int drm_setmaster_ioctl(struct drm_device *dev, void *data,
                         struct drm_file *file_priv)
 {
+        int ret = 0;
+
         if (file_priv->is_master)
                 return 0;
 
@@ -188,6 +192,13 @@ int drm_setmaster_ioctl(struct drm_device *dev, void *data,
                 mutex_lock(&dev->struct_mutex);
                 file_priv->minor->master = drm_master_get(file_priv->master);
                 file_priv->is_master = 1;
+                if (dev->driver->master_set) {
+                        ret = dev->driver->master_set(dev, file_priv, false);
+                        if (unlikely(ret != 0)) {
+                                file_priv->is_master = 0;
+                                drm_master_put(&file_priv->minor->master);
+                        }
+                }
                 mutex_unlock(&dev->struct_mutex);
         }
 
@@ -204,6 +215,8 @@ int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
                 return -EINVAL;
 
         mutex_lock(&dev->struct_mutex);
+        if (dev->driver->master_drop)
+                dev->driver->master_drop(dev, file_priv, false);
         drm_master_put(&file_priv->minor->master);
         file_priv->is_master = 0;
         mutex_unlock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 87b21996cd6a..9929f84ec3e1 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -15,7 +15,6 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \
           intel_lvds.o \
           intel_bios.o \
           intel_dp.o \
-          intel_dp_i2c.o \
           intel_hdmi.o \
           intel_sdvo.o \
           intel_modes.o \
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 1d6171087298..fbecac72f5bb 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -305,6 +305,7 @@ typedef struct drm_i915_private {
         u32 saveVBLANK_A;
         u32 saveVSYNC_A;
         u32 saveBCLRPAT_A;
+        u32 saveTRANSACONF;
         u32 saveTRANS_HTOTAL_A;
         u32 saveTRANS_HBLANK_A;
         u32 saveTRANS_HSYNC_A;
@@ -335,6 +336,7 @@ typedef struct drm_i915_private {
         u32 saveVBLANK_B;
         u32 saveVSYNC_B;
         u32 saveBCLRPAT_B;
+        u32 saveTRANSBCONF;
         u32 saveTRANS_HTOTAL_B;
         u32 saveTRANS_HBLANK_B;
         u32 saveTRANS_HSYNC_B;
@@ -421,6 +423,16 @@ typedef struct drm_i915_private {
         u32 savePFB_WIN_SZ;
         u32 savePFA_WIN_POS;
         u32 savePFB_WIN_POS;
+        u32 savePCH_DREF_CONTROL;
+        u32 saveDISP_ARB_CTL;
+        u32 savePIPEA_DATA_M1;
+        u32 savePIPEA_DATA_N1;
+        u32 savePIPEA_LINK_M1;
+        u32 savePIPEA_LINK_N1;
+        u32 savePIPEB_DATA_M1;
+        u32 savePIPEB_DATA_N1;
+        u32 savePIPEB_LINK_M1;
+        u32 savePIPEB_LINK_N1;
 
         struct {
                 struct drm_mm gtt_space;
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index a1345d78e138..85f4c5de97e2 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -273,10 +273,15 @@ irqreturn_t ironlake_irq_handler(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         int ret = IRQ_NONE;
-        u32 de_iir, gt_iir, pch_iir;
+        u32 de_iir, gt_iir, de_ier, pch_iir;
         u32 new_de_iir, new_gt_iir, new_pch_iir;
         struct drm_i915_master_private *master_priv;
 
+        /* disable master interrupt before clearing iir  */
+        de_ier = I915_READ(DEIER);
+        I915_WRITE(DEIER, de_ier & ~DE_MASTER_IRQ_CONTROL);
+        (void)I915_READ(DEIER);
+
         de_iir = I915_READ(DEIIR);
         gt_iir = I915_READ(GTIIR);
         pch_iir = I915_READ(SDEIIR);
@@ -324,6 +329,9 @@ irqreturn_t ironlake_irq_handler(struct drm_device *dev)
                 pch_iir = new_pch_iir;
         }
 
+        I915_WRITE(DEIER, de_ier);
+        (void)I915_READ(DEIER);
+
         return ret;
 }
 
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index 00f6d97c7cc5..d5ebb00a9d49 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -239,6 +239,11 @@ static void i915_save_modeset_reg(struct drm_device *dev)
         if (drm_core_check_feature(dev, DRIVER_MODESET))
                 return;
 
+        if (IS_IRONLAKE(dev)) {
+                dev_priv->savePCH_DREF_CONTROL = I915_READ(PCH_DREF_CONTROL);
+                dev_priv->saveDISP_ARB_CTL = I915_READ(DISP_ARB_CTL);
+        }
+
         /* Pipe & plane A info */
         dev_priv->savePIPEACONF = I915_READ(PIPEACONF);
         dev_priv->savePIPEASRC = I915_READ(PIPEASRC);
@@ -263,6 +268,11 @@ static void i915_save_modeset_reg(struct drm_device *dev)
                 dev_priv->saveBCLRPAT_A = I915_READ(BCLRPAT_A);
 
         if (IS_IRONLAKE(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);
+                dev_priv->savePIPEA_LINK_N1 = I915_READ(PIPEA_LINK_N1);
+
                 dev_priv->saveFDI_TXA_CTL = I915_READ(FDI_TXA_CTL);
                 dev_priv->saveFDI_RXA_CTL = I915_READ(FDI_RXA_CTL);
 
@@ -270,6 +280,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
                 dev_priv->savePFA_WIN_SZ = I915_READ(PFA_WIN_SZ);
                 dev_priv->savePFA_WIN_POS = I915_READ(PFA_WIN_POS);
 
+                dev_priv->saveTRANSACONF = I915_READ(TRANSACONF);
                 dev_priv->saveTRANS_HTOTAL_A = I915_READ(TRANS_HTOTAL_A);
                 dev_priv->saveTRANS_HBLANK_A = I915_READ(TRANS_HBLANK_A);
                 dev_priv->saveTRANS_HSYNC_A = I915_READ(TRANS_HSYNC_A);
@@ -314,6 +325,11 @@ static void i915_save_modeset_reg(struct drm_device *dev)
                 dev_priv->saveBCLRPAT_B = I915_READ(BCLRPAT_B);
 
         if (IS_IRONLAKE(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);
+                dev_priv->savePIPEB_LINK_N1 = I915_READ(PIPEB_LINK_N1);
+
                 dev_priv->saveFDI_TXB_CTL = I915_READ(FDI_TXB_CTL);
                 dev_priv->saveFDI_RXB_CTL = I915_READ(FDI_RXB_CTL);
 
@@ -321,6 +337,7 @@ static void i915_save_modeset_reg(struct drm_device *dev)
                 dev_priv->savePFB_WIN_SZ = I915_READ(PFB_WIN_SZ);
                 dev_priv->savePFB_WIN_POS = I915_READ(PFB_WIN_POS);
 
+                dev_priv->saveTRANSBCONF = I915_READ(TRANSBCONF);
                 dev_priv->saveTRANS_HTOTAL_B = I915_READ(TRANS_HTOTAL_B);
                 dev_priv->saveTRANS_HBLANK_B = I915_READ(TRANS_HBLANK_B);
                 dev_priv->saveTRANS_HSYNC_B = I915_READ(TRANS_HSYNC_B);
@@ -368,6 +385,11 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
                 fpb1_reg = FPB1;
         }
 
+        if (IS_IRONLAKE(dev)) {
+                I915_WRITE(PCH_DREF_CONTROL, dev_priv->savePCH_DREF_CONTROL);
+                I915_WRITE(DISP_ARB_CTL, dev_priv->saveDISP_ARB_CTL);
+        }
+
         /* Pipe & plane A info */
         /* Prime the clock */
         if (dev_priv->saveDPLL_A & DPLL_VCO_ENABLE) {
@@ -395,6 +417,11 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
                 I915_WRITE(BCLRPAT_A, dev_priv->saveBCLRPAT_A);
 
         if (IS_IRONLAKE(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);
+                I915_WRITE(PIPEA_LINK_N1, dev_priv->savePIPEA_LINK_N1);
+
                 I915_WRITE(FDI_RXA_CTL, dev_priv->saveFDI_RXA_CTL);
                 I915_WRITE(FDI_TXA_CTL, dev_priv->saveFDI_TXA_CTL);
 
@@ -402,6 +429,7 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
                 I915_WRITE(PFA_WIN_SZ, dev_priv->savePFA_WIN_SZ);
                 I915_WRITE(PFA_WIN_POS, dev_priv->savePFA_WIN_POS);
 
+                I915_WRITE(TRANSACONF, dev_priv->saveTRANSACONF);
                 I915_WRITE(TRANS_HTOTAL_A, dev_priv->saveTRANS_HTOTAL_A);
                 I915_WRITE(TRANS_HBLANK_A, dev_priv->saveTRANS_HBLANK_A);
                 I915_WRITE(TRANS_HSYNC_A, dev_priv->saveTRANS_HSYNC_A);
@@ -439,7 +467,7 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
         /* Actually enable it */
         I915_WRITE(dpll_b_reg, dev_priv->saveDPLL_B);
         DRM_UDELAY(150);
-        if (IS_I965G(dev))
+        if (IS_I965G(dev) && !IS_IRONLAKE(dev))
                 I915_WRITE(DPLL_B_MD, dev_priv->saveDPLL_B_MD);
         DRM_UDELAY(150);
 
@@ -454,6 +482,11 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
                 I915_WRITE(BCLRPAT_B, dev_priv->saveBCLRPAT_B);
 
         if (IS_IRONLAKE(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);
+                I915_WRITE(PIPEB_LINK_N1, dev_priv->savePIPEB_LINK_N1);
+
                 I915_WRITE(FDI_RXB_CTL, dev_priv->saveFDI_RXB_CTL);
                 I915_WRITE(FDI_TXB_CTL, dev_priv->saveFDI_TXB_CTL);
 
@@ -461,6 +494,7 @@ static void i915_restore_modeset_reg(struct drm_device *dev)
                 I915_WRITE(PFB_WIN_SZ, dev_priv->savePFB_WIN_SZ);
                 I915_WRITE(PFB_WIN_POS, dev_priv->savePFB_WIN_POS);
 
+                I915_WRITE(TRANSBCONF, dev_priv->saveTRANSBCONF);
                 I915_WRITE(TRANS_HTOTAL_B, dev_priv->saveTRANS_HTOTAL_B);
                 I915_WRITE(TRANS_HBLANK_B, dev_priv->saveTRANS_HBLANK_B);
                 I915_WRITE(TRANS_HSYNC_B, dev_priv->saveTRANS_HSYNC_B);
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index ec5df0f88417..9f3d3e563414 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -234,8 +234,8 @@ static bool intel_crt_detect_hotplug(struct drm_connector *connector)
                 } while (time_after(timeout, jiffies));
         }
 
-        if ((I915_READ(PORT_HOTPLUG_STAT) & CRT_HOTPLUG_MONITOR_MASK) ==
-            CRT_HOTPLUG_MONITOR_COLOR)
+        if ((I915_READ(PORT_HOTPLUG_STAT) & CRT_HOTPLUG_MONITOR_MASK) !=
+            CRT_HOTPLUG_MONITOR_NONE)
                 return true;
 
         return false;
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 279dc96e3eb2..52cd9b006da2 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -32,7 +32,7 @@
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
-#include "intel_dp.h"
+#include "drm_dp_helper.h"
 
 #include "drm_crtc_helper.h"
 
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 632f1b44c28a..4e7aa8b7b938 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -33,7 +33,7 @@
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
-#include "intel_dp.h"
+#include "drm_dp_helper.h"
 
 
 #define DP_LINK_STATUS_SIZE     6
@@ -383,17 +383,77 @@ intel_dp_aux_native_read(struct intel_output *intel_output,
 }
 
 static int
-intel_dp_i2c_aux_ch(struct i2c_adapter *adapter,
-                    uint8_t *send, int send_bytes,
-                    uint8_t *recv, int recv_bytes)
+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_output *intel_output = dp_priv->intel_output;
+        uint16_t address = algo_data->address;
+        uint8_t msg[5];
+        uint8_t reply[2];
+        int msg_bytes;
+        int reply_bytes;
+        int ret;
+
+        /* Set up the command byte */
+        if (mode & MODE_I2C_READ)
+                msg[0] = AUX_I2C_READ << 4;
+        else
+                msg[0] = AUX_I2C_WRITE << 4;
+
+        if (!(mode & MODE_I2C_STOP))
+                msg[0] |= AUX_I2C_MOT << 4;
+
+        msg[1] = address >> 8;
+        msg[2] = address;
+
+        switch (mode) {
+        case MODE_I2C_WRITE:
+                msg[3] = 0;
+                msg[4] = write_byte;
+                msg_bytes = 5;
+                reply_bytes = 1;
+                break;
+        case MODE_I2C_READ:
+                msg[3] = 0;
+                msg_bytes = 4;
+                reply_bytes = 2;
+                break;
+        default:
+                msg_bytes = 3;
+                reply_bytes = 1;
+                break;
+        }
 
-        return intel_dp_aux_ch(intel_output,
-                               send, send_bytes, recv, recv_bytes);
+        for (;;) {
+          ret = intel_dp_aux_ch(intel_output,
+                                msg, msg_bytes,
+                                reply, reply_bytes);
+                if (ret < 0) {
+                        DRM_DEBUG_KMS("aux_ch failed %d\n", ret);
+                        return ret;
+                }
+                switch (reply[0] & AUX_I2C_REPLY_MASK) {
+                case AUX_I2C_REPLY_ACK:
+                        if (mode == MODE_I2C_READ) {
+                                *read_byte = reply[1];
+                        }
+                        return reply_bytes - 1;
+                case AUX_I2C_REPLY_NACK:
+                        DRM_DEBUG_KMS("aux_ch nack\n");
+                        return -EREMOTEIO;
+                case AUX_I2C_REPLY_DEFER:
+                        DRM_DEBUG_KMS("aux_ch defer\n");
+                        udelay(100);
+                        break;
+                default:
+                        DRM_ERROR("aux_ch invalid reply 0x%02x\n", reply[0]);
+                        return -EREMOTEIO;
+                }
+        }
 }
 
 static int
diff --git a/drivers/gpu/drm/i915/intel_dp.h b/drivers/gpu/drm/i915/intel_dp.h
deleted file mode 100644
index 2b38054d3b6d..000000000000
--- a/drivers/gpu/drm/i915/intel_dp.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright © 2008 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting documentation, and
- * that the name of the copyright holders not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make no representations
- * about the suitability of this software for any purpose.  It is provided "as
- * is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
- * OF THIS SOFTWARE.
- */
-
-#ifndef _INTEL_DP_H_
-#define _INTEL_DP_H_
-
-/* From the VESA DisplayPort spec */
-
-#define AUX_NATIVE_WRITE        0x8
-#define AUX_NATIVE_READ         0x9
-#define AUX_I2C_WRITE           0x0
-#define AUX_I2C_READ            0x1
-#define AUX_I2C_STATUS          0x2
-#define AUX_I2C_MOT             0x4
-
-#define AUX_NATIVE_REPLY_ACK    (0x0 << 4)
-#define AUX_NATIVE_REPLY_NACK   (0x1 << 4)
-#define AUX_NATIVE_REPLY_DEFER  (0x2 << 4)
-#define AUX_NATIVE_REPLY_MASK   (0x3 << 4)
-
-#define AUX_I2C_REPLY_ACK       (0x0 << 6)
-#define AUX_I2C_REPLY_NACK      (0x1 << 6)
-#define AUX_I2C_REPLY_DEFER     (0x2 << 6)
-#define AUX_I2C_REPLY_MASK      (0x3 << 6)
-
-/* AUX CH addresses */
-#define DP_LINK_BW_SET          0x100
-# define DP_LINK_BW_1_62                    0x06
-# define DP_LINK_BW_2_7                     0x0a
-
-#define DP_LANE_COUNT_SET       0x101
-# define DP_LANE_COUNT_MASK                 0x0f
-# define DP_LANE_COUNT_ENHANCED_FRAME_EN    (1 << 7)
-
-#define DP_TRAINING_PATTERN_SET 0x102
-
-# define DP_TRAINING_PATTERN_DISABLE        0
-# define DP_TRAINING_PATTERN_1              1
-# define DP_TRAINING_PATTERN_2              2
-# define DP_TRAINING_PATTERN_MASK           0x3
-
-# define DP_LINK_QUAL_PATTERN_DISABLE       (0 << 2)
-# define DP_LINK_QUAL_PATTERN_D10_2         (1 << 2)
-# define DP_LINK_QUAL_PATTERN_ERROR_RATE    (2 << 2)
-# define DP_LINK_QUAL_PATTERN_PRBS7         (3 << 2)
-# define DP_LINK_QUAL_PATTERN_MASK          (3 << 2)
-
-# define DP_RECOVERED_CLOCK_OUT_EN          (1 << 4)
-# define DP_LINK_SCRAMBLING_DISABLE         (1 << 5)
-
-# define DP_SYMBOL_ERROR_COUNT_BOTH         (0 << 6)
-# define DP_SYMBOL_ERROR_COUNT_DISPARITY    (1 << 6)
-# define DP_SYMBOL_ERROR_COUNT_SYMBOL       (2 << 6)
-# define DP_SYMBOL_ERROR_COUNT_MASK         (3 << 6)
-
-#define DP_TRAINING_LANE0_SET               0x103
-#define DP_TRAINING_LANE1_SET               0x104
-#define DP_TRAINING_LANE2_SET               0x105
-#define DP_TRAINING_LANE3_SET               0x106
-
-# define DP_TRAIN_VOLTAGE_SWING_MASK        0x3
-# define DP_TRAIN_VOLTAGE_SWING_SHIFT       0
-# define DP_TRAIN_MAX_SWING_REACHED         (1 << 2)
-# define DP_TRAIN_VOLTAGE_SWING_400         (0 << 0)
-# define DP_TRAIN_VOLTAGE_SWING_600         (1 << 0)
-# define DP_TRAIN_VOLTAGE_SWING_800         (2 << 0)
-# define DP_TRAIN_VOLTAGE_SWING_1200        (3 << 0)
-
-# define DP_TRAIN_PRE_EMPHASIS_MASK         (3 << 3)
-# define DP_TRAIN_PRE_EMPHASIS_0            (0 << 3)
-# define DP_TRAIN_PRE_EMPHASIS_3_5          (1 << 3)
-# define DP_TRAIN_PRE_EMPHASIS_6            (2 << 3)
-# define DP_TRAIN_PRE_EMPHASIS_9_5          (3 << 3)
-
-# define DP_TRAIN_PRE_EMPHASIS_SHIFT        3
-# define DP_TRAIN_MAX_PRE_EMPHASIS_REACHED  (1 << 5)
-
-#define DP_DOWNSPREAD_CTRL                  0x107
-# define DP_SPREAD_AMP_0_5                  (1 << 4)
-
-#define DP_MAIN_LINK_CHANNEL_CODING_SET     0x108
-# define DP_SET_ANSI_8B10B                  (1 << 0)
-
-#define DP_LANE0_1_STATUS                   0x202
-#define DP_LANE2_3_STATUS                   0x203
-
-# define DP_LANE_CR_DONE                    (1 << 0)
-# define DP_LANE_CHANNEL_EQ_DONE            (1 << 1)
-# define DP_LANE_SYMBOL_LOCKED              (1 << 2)
-
-#define DP_LANE_ALIGN_STATUS_UPDATED        0x204
-
-#define DP_INTERLANE_ALIGN_DONE             (1 << 0)
-#define DP_DOWNSTREAM_PORT_STATUS_CHANGED   (1 << 6)
-#define DP_LINK_STATUS_UPDATED              (1 << 7)
-
-#define DP_SINK_STATUS                      0x205
-
-#define DP_RECEIVE_PORT_0_STATUS            (1 << 0)
-#define DP_RECEIVE_PORT_1_STATUS            (1 << 1)
-
-#define DP_ADJUST_REQUEST_LANE0_1           0x206
-#define DP_ADJUST_REQUEST_LANE2_3           0x207
-
-#define DP_ADJUST_VOLTAGE_SWING_LANE0_MASK  0x03
-#define DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT 0
-#define DP_ADJUST_PRE_EMPHASIS_LANE0_MASK   0x0c
-#define DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT  2
-#define DP_ADJUST_VOLTAGE_SWING_LANE1_MASK  0x30
-#define DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT 4
-#define DP_ADJUST_PRE_EMPHASIS_LANE1_MASK   0xc0
-#define DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT  6
-
-struct i2c_algo_dp_aux_data {
-        bool running;
-        u16 address;
-        int (*aux_ch) (struct i2c_adapter *adapter,
-                       uint8_t *send, int send_bytes,
-                       uint8_t *recv, int recv_bytes);
-};
-
-int
-i2c_dp_aux_add_bus(struct i2c_adapter *adapter);
-
-#endif /* _INTEL_DP_H_ */
diff --git a/drivers/gpu/drm/radeon/Makefile b/drivers/gpu/drm/radeon/Makefile
index b5713eedd6e1..feb52eee4314 100644
--- a/drivers/gpu/drm/radeon/Makefile
+++ b/drivers/gpu/drm/radeon/Makefile
@@ -49,7 +49,7 @@ radeon-y += radeon_device.o radeon_kms.o \
         radeon_cs.o radeon_bios.o radeon_benchmark.o r100.o r300.o r420.o \
         rs400.o rs600.o rs690.o rv515.o r520.o r600.o rv770.o radeon_test.o \
         r200.o radeon_legacy_tv.o r600_cs.o r600_blit.o r600_blit_shaders.o \
-        r600_blit_kms.o radeon_pm.o
+        r600_blit_kms.o radeon_pm.o atombios_dp.o
 
 radeon-$(CONFIG_COMPAT) += radeon_ioc32.o
 
diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
index 901befe03da2..6578d19dff93 100644
--- a/drivers/gpu/drm/radeon/atom.c
+++ b/drivers/gpu/drm/radeon/atom.c
@@ -107,6 +107,7 @@ static uint32_t atom_iio_execute(struct atom_context *ctx, int base,
                         base += 3;
                         break;
                 case ATOM_IIO_WRITE:
+                        (void)ctx->card->reg_read(ctx->card, CU16(base + 1));
                         ctx->card->reg_write(ctx->card, CU16(base + 1), temp);
                         base += 3;
                         break;
@@ -262,10 +263,10 @@ static uint32_t atom_get_src_int(atom_exec_context *ctx, uint8_t attr,
         case ATOM_ARG_FB:
                 idx = U8(*ptr);
                 (*ptr)++;
+                val = gctx->scratch[((gctx->fb_base + idx) / 4)];
                 if (print)
                         DEBUG("FB[0x%02X]", idx);
-                printk(KERN_INFO "FB access is not implemented.\n");
-                return 0;
+                break;
         case ATOM_ARG_IMM:
                 switch (align) {
                 case ATOM_SRC_DWORD:
@@ -487,9 +488,9 @@ static void atom_put_dst(atom_exec_context *ctx, int arg, uint8_t attr,
         case ATOM_ARG_FB:
                 idx = U8(*ptr);
                 (*ptr)++;
+                gctx->scratch[((gctx->fb_base + idx) / 4)] = val;
                 DEBUG("FB[0x%02X]", idx);
-                printk(KERN_INFO "FB access is not implemented.\n");
-                return;
+                break;
         case ATOM_ARG_PLL:
                 idx = U8(*ptr);
                 (*ptr)++;
@@ -1213,3 +1214,28 @@ void atom_parse_cmd_header(struct atom_context *ctx, int index, uint8_t * frev,
                 *crev = CU8(idx + 3);
         return;
 }
+
+int atom_allocate_fb_scratch(struct atom_context *ctx)
+{
+        int index = GetIndexIntoMasterTable(DATA, VRAM_UsageByFirmware);
+        uint16_t data_offset;
+        int usage_bytes;
+        struct _ATOM_VRAM_USAGE_BY_FIRMWARE *firmware_usage;
+
+        atom_parse_data_header(ctx, index, NULL, NULL, NULL, &data_offset);
+
+        firmware_usage = (struct _ATOM_VRAM_USAGE_BY_FIRMWARE *)(ctx->bios + data_offset);
+
+        DRM_DEBUG("atom firmware requested %08x %dkb\n",
+                  firmware_usage->asFirmwareVramReserveInfo[0].ulStartAddrUsedByFirmware,
+                  firmware_usage->asFirmwareVramReserveInfo[0].usFirmwareUseInKb);
+
+        usage_bytes = firmware_usage->asFirmwareVramReserveInfo[0].usFirmwareUseInKb * 1024;
+        if (usage_bytes == 0)
+                usage_bytes = 20 * 1024;
+        /* allocate some scratch memory */
+        ctx->scratch = kzalloc(usage_bytes, GFP_KERNEL);
+        if (!ctx->scratch)
+                return -ENOMEM;
+        return 0;
+}
diff --git a/drivers/gpu/drm/radeon/atom.h b/drivers/gpu/drm/radeon/atom.h
index e6eb38f2bcae..6671848e5ea1 100644
--- a/drivers/gpu/drm/radeon/atom.h
+++ b/drivers/gpu/drm/radeon/atom.h
@@ -132,6 +132,7 @@ struct atom_context {
         uint8_t shift;
         int cs_equal, cs_above;
         int io_mode;
+        uint32_t *scratch;
 };
 
 extern int atom_debug;
@@ -142,6 +143,7 @@ int atom_asic_init(struct atom_context *);
 void atom_destroy(struct atom_context *);
 void atom_parse_data_header(struct atom_context *ctx, int index, uint16_t *size, uint8_t *frev, uint8_t *crev, uint16_t *data_start);
 void atom_parse_cmd_header(struct atom_context *ctx, int index, uint8_t *frev, uint8_t *crev);
+int atom_allocate_fb_scratch(struct atom_context *ctx);
 #include "atom-types.h"
 #include "atombios.h"
 #include "ObjectID.h"
diff --git a/drivers/gpu/drm/radeon/atombios.h b/drivers/gpu/drm/radeon/atombios.h
index c11ddddfb3b6..e83927644de4 100644
--- a/drivers/gpu/drm/radeon/atombios.h
+++ b/drivers/gpu/drm/radeon/atombios.h
@@ -2680,7 +2680,7 @@ typedef struct _ATOM_I2C_RECORD {
 typedef struct _ATOM_HPD_INT_RECORD {
         ATOM_COMMON_RECORD_HEADER sheader;
         UCHAR ucHPDIntGPIOID;   /* Corresponding block in GPIO_PIN_INFO table gives the pin info */
-        UCHAR ucPluggged_PinState;
+        UCHAR ucPlugged_PinState;
 } ATOM_HPD_INT_RECORD;
 
 typedef struct _ATOM_OUTPUT_PROTECTION_RECORD {
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index c15287a590ff..fba3c96b915b 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -241,6 +241,7 @@ void atombios_crtc_dpms(struct drm_crtc *crtc, int mode)
 {
         struct drm_device *dev = crtc->dev;
         struct radeon_device *rdev = dev->dev_private;
+        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
 
         switch (mode) {
         case DRM_MODE_DPMS_ON:
@@ -248,20 +249,19 @@ void atombios_crtc_dpms(struct drm_crtc *crtc, int mode)
                 if (ASIC_IS_DCE3(rdev))
                         atombios_enable_crtc_memreq(crtc, 1);
                 atombios_blank_crtc(crtc, 0);
+                drm_vblank_post_modeset(dev, radeon_crtc->crtc_id);
+                radeon_crtc_load_lut(crtc);
                 break;
         case DRM_MODE_DPMS_STANDBY:
         case DRM_MODE_DPMS_SUSPEND:
         case DRM_MODE_DPMS_OFF:
+                drm_vblank_pre_modeset(dev, radeon_crtc->crtc_id);
                 atombios_blank_crtc(crtc, 1);
                 if (ASIC_IS_DCE3(rdev))
                         atombios_enable_crtc_memreq(crtc, 0);
                 atombios_enable_crtc(crtc, 0);
                 break;
         }
-
-        if (mode != DRM_MODE_DPMS_OFF) {
-                radeon_crtc_load_lut(crtc);
-        }
 }
 
 static void
@@ -457,9 +457,8 @@ void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
                                 if (encoder->encoder_type !=
                                     DRM_MODE_ENCODER_DAC)
                                         pll_flags |= RADEON_PLL_NO_ODD_POST_DIV;
-                                if (!ASIC_IS_AVIVO(rdev)
-                                    && (encoder->encoder_type ==
-                                        DRM_MODE_ENCODER_LVDS))
+                                if (encoder->encoder_type ==
+                                        DRM_MODE_ENCODER_LVDS)
                                         pll_flags |= RADEON_PLL_USE_REF_DIV;
                         }
                         radeon_encoder = to_radeon_encoder(encoder);
@@ -574,21 +573,34 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_framebuffer *radeon_fb;
         struct drm_gem_object *obj;
-        struct drm_radeon_gem_object *obj_priv;
+        struct radeon_bo *rbo;
         uint64_t fb_location;
         uint32_t fb_format, fb_pitch_pixels, tiling_flags;
+        int r;
 
-        if (!crtc->fb)
-                return -EINVAL;
+        /* no fb bound */
+        if (!crtc->fb) {
+                DRM_DEBUG("No FB bound\n");
+                return 0;
+        }
 
         radeon_fb = to_radeon_framebuffer(crtc->fb);
 
+        /* Pin framebuffer & get tilling informations */
         obj = radeon_fb->obj;
-        obj_priv = obj->driver_private;
-
-        if (radeon_gem_object_pin(obj, RADEON_GEM_DOMAIN_VRAM, &fb_location)) {
+        rbo = obj->driver_private;
+        r = radeon_bo_reserve(rbo, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(rbo, RADEON_GEM_DOMAIN_VRAM, &fb_location);
+        if (unlikely(r != 0)) {
+                radeon_bo_unreserve(rbo);
                 return -EINVAL;
         }
+        radeon_bo_get_tiling_flags(rbo, &tiling_flags, NULL);
+        radeon_bo_unreserve(rbo);
+        if (tiling_flags & RADEON_TILING_MACRO)
+                fb_format |= AVIVO_D1GRPH_MACRO_ADDRESS_MODE;
 
         switch (crtc->fb->bits_per_pixel) {
         case 8:
@@ -618,11 +630,6 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                 return -EINVAL;
         }
 
-        radeon_object_get_tiling_flags(obj->driver_private,
-                                       &tiling_flags, NULL);
-        if (tiling_flags & RADEON_TILING_MACRO)
-                fb_format |= AVIVO_D1GRPH_MACRO_ADDRESS_MODE;
-
         if (tiling_flags & RADEON_TILING_MICRO)
                 fb_format |= AVIVO_D1GRPH_TILED;
 
@@ -674,7 +681,12 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
 
         if (old_fb && old_fb != crtc->fb) {
                 radeon_fb = to_radeon_framebuffer(old_fb);
-                radeon_gem_object_unpin(radeon_fb->obj);
+                rbo = radeon_fb->obj->driver_private;
+                r = radeon_bo_reserve(rbo, false);
+                if (unlikely(r != 0))
+                        return r;
+                radeon_bo_unpin(rbo);
+                radeon_bo_unreserve(rbo);
         }
 
         /* Bytes per pixel may have changed */
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
new file mode 100644
index 000000000000..0d63c4436e7c
--- /dev/null
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -0,0 +1,790 @@
+/*
+ * Copyright 2007-8 Advanced Micro Devices, Inc.
+ * Copyright 2008 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Dave Airlie
+ *          Alex Deucher
+ */
+#include "drmP.h"
+#include "radeon_drm.h"
+#include "radeon.h"
+
+#include "atom.h"
+#include "atom-bits.h"
+#include "drm_dp_helper.h"
+
+/* move these to drm_dp_helper.c/h */
+#define DP_LINK_CONFIGURATION_SIZE 9
+#define DP_LINK_STATUS_SIZE        6
+#define DP_DPCD_SIZE               8
+
+static char *voltage_names[] = {
+        "0.4V", "0.6V", "0.8V", "1.2V"
+};
+static char *pre_emph_names[] = {
+        "0dB", "3.5dB", "6dB", "9.5dB"
+};
+
+static const int dp_clocks[] = {
+        54000,  /* 1 lane, 1.62 Ghz */
+        90000,  /* 1 lane, 2.70 Ghz */
+        108000, /* 2 lane, 1.62 Ghz */
+        180000, /* 2 lane, 2.70 Ghz */
+        216000, /* 4 lane, 1.62 Ghz */
+        360000, /* 4 lane, 2.70 Ghz */
+};
+
+static const int num_dp_clocks = sizeof(dp_clocks) / sizeof(int);
+
+/* common helper functions */
+static int dp_lanes_for_mode_clock(u8 dpcd[DP_DPCD_SIZE], int mode_clock)
+{
+        int i;
+        u8 max_link_bw;
+        u8 max_lane_count;
+
+        if (!dpcd)
+                return 0;
+
+        max_link_bw = dpcd[DP_MAX_LINK_RATE];
+        max_lane_count = dpcd[DP_MAX_LANE_COUNT] & DP_MAX_LANE_COUNT_MASK;
+
+        switch (max_link_bw) {
+        case DP_LINK_BW_1_62:
+        default:
+                for (i = 0; i < num_dp_clocks; i++) {
+                        if (i % 2)
+                                continue;
+                        switch (max_lane_count) {
+                        case 1:
+                                if (i > 1)
+                                        return 0;
+                                break;
+                        case 2:
+                                if (i > 3)
+                                        return 0;
+                                break;
+                        case 4:
+                        default:
+                                break;
+                        }
+                        if (dp_clocks[i] > mode_clock) {
+                                if (i < 2)
+                                        return 1;
+                                else if (i < 4)
+                                        return 2;
+                                else
+                                        return 4;
+                        }
+                }
+                break;
+        case DP_LINK_BW_2_7:
+                for (i = 0; i < num_dp_clocks; i++) {
+                        switch (max_lane_count) {
+                        case 1:
+                                if (i > 1)
+                                        return 0;
+                                break;
+                        case 2:
+                                if (i > 3)
+                                        return 0;
+                                break;
+                        case 4:
+                        default:
+                                break;
+                        }
+                        if (dp_clocks[i] > mode_clock) {
+                                if (i < 2)
+                                        return 1;
+                                else if (i < 4)
+                                        return 2;
+                                else
+                                        return 4;
+                        }
+                }
+                break;
+        }
+
+        return 0;
+}
+
+static int dp_link_clock_for_mode_clock(u8 dpcd[DP_DPCD_SIZE], int mode_clock)
+{
+        int i;
+        u8 max_link_bw;
+        u8 max_lane_count;
+
+        if (!dpcd)
+                return 0;
+
+        max_link_bw = dpcd[DP_MAX_LINK_RATE];
+        max_lane_count = dpcd[DP_MAX_LANE_COUNT] & DP_MAX_LANE_COUNT_MASK;
+
+        switch (max_link_bw) {
+        case DP_LINK_BW_1_62:
+        default:
+                for (i = 0; i < num_dp_clocks; i++) {
+                        if (i % 2)
+                                continue;
+                        switch (max_lane_count) {
+                        case 1:
+                                if (i > 1)
+                                        return 0;
+                                break;
+                        case 2:
+                                if (i > 3)
+                                        return 0;
+                                break;
+                        case 4:
+                        default:
+                                break;
+                        }
+                        if (dp_clocks[i] > mode_clock)
+                                return 162000;
+                }
+                break;
+        case DP_LINK_BW_2_7:
+                for (i = 0; i < num_dp_clocks; i++) {
+                        switch (max_lane_count) {
+                        case 1:
+                                if (i > 1)
+                                        return 0;
+                                break;
+                        case 2:
+                                if (i > 3)
+                                        return 0;
+                                break;
+                        case 4:
+                        default:
+                                break;
+                        }
+                        if (dp_clocks[i] > mode_clock)
+                                return (i % 2) ? 270000 : 162000;
+                }
+        }
+
+        return 0;
+}
+
+int dp_mode_valid(u8 dpcd[DP_DPCD_SIZE], int mode_clock)
+{
+        int lanes = dp_lanes_for_mode_clock(dpcd, mode_clock);
+        int bw = dp_lanes_for_mode_clock(dpcd, mode_clock);
+
+        if ((lanes == 0) || (bw == 0))
+                return MODE_CLOCK_HIGH;
+
+        return MODE_OK;
+}
+
+static u8 dp_link_status(u8 link_status[DP_LINK_STATUS_SIZE], int r)
+{
+        return link_status[r - DP_LANE0_1_STATUS];
+}
+
+static u8 dp_get_lane_status(u8 link_status[DP_LINK_STATUS_SIZE],
+                             int lane)
+{
+        int i = DP_LANE0_1_STATUS + (lane >> 1);
+        int s = (lane & 1) * 4;
+        u8 l = dp_link_status(link_status, i);
+        return (l >> s) & 0xf;
+}
+
+static bool dp_clock_recovery_ok(u8 link_status[DP_LINK_STATUS_SIZE],
+                                 int lane_count)
+{
+        int lane;
+        u8 lane_status;
+
+        for (lane = 0; lane < lane_count; lane++) {
+                lane_status = dp_get_lane_status(link_status, lane);
+                if ((lane_status & DP_LANE_CR_DONE) == 0)
+                        return false;
+        }
+        return true;
+}
+
+static bool dp_channel_eq_ok(u8 link_status[DP_LINK_STATUS_SIZE],
+                             int lane_count)
+{
+        u8 lane_align;
+        u8 lane_status;
+        int lane;
+
+        lane_align = dp_link_status(link_status,
+                                    DP_LANE_ALIGN_STATUS_UPDATED);
+        if ((lane_align & DP_INTERLANE_ALIGN_DONE) == 0)
+                return false;
+        for (lane = 0; lane < lane_count; lane++) {
+                lane_status = dp_get_lane_status(link_status, lane);
+                if ((lane_status & DP_CHANNEL_EQ_BITS) != DP_CHANNEL_EQ_BITS)
+                        return false;
+        }
+        return true;
+}
+
+static u8 dp_get_adjust_request_voltage(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                                        int lane)
+
+{
+        int i = DP_ADJUST_REQUEST_LANE0_1 + (lane >> 1);
+        int s = ((lane & 1) ?
+                 DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT :
+                 DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT);
+        u8 l = dp_link_status(link_status, i);
+
+        return ((l >> s) & 0x3) << DP_TRAIN_VOLTAGE_SWING_SHIFT;
+}
+
+static u8 dp_get_adjust_request_pre_emphasis(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                                             int lane)
+{
+        int i = DP_ADJUST_REQUEST_LANE0_1 + (lane >> 1);
+        int s = ((lane & 1) ?
+                 DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT :
+                 DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT);
+        u8 l = dp_link_status(link_status, i);
+
+        return ((l >> s) & 0x3) << DP_TRAIN_PRE_EMPHASIS_SHIFT;
+}
+
+/* XXX fix me -- chip specific */
+#define DP_VOLTAGE_MAX         DP_TRAIN_VOLTAGE_SWING_1200
+static u8 dp_pre_emphasis_max(u8 voltage_swing)
+{
+        switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
+        case DP_TRAIN_VOLTAGE_SWING_400:
+                return DP_TRAIN_PRE_EMPHASIS_6;
+        case DP_TRAIN_VOLTAGE_SWING_600:
+                return DP_TRAIN_PRE_EMPHASIS_6;
+        case DP_TRAIN_VOLTAGE_SWING_800:
+                return DP_TRAIN_PRE_EMPHASIS_3_5;
+        case DP_TRAIN_VOLTAGE_SWING_1200:
+        default:
+                return DP_TRAIN_PRE_EMPHASIS_0;
+        }
+}
+
+static void dp_get_adjust_train(u8 link_status[DP_LINK_STATUS_SIZE],
+                                int lane_count,
+                                u8 train_set[4])
+{
+        u8 v = 0;
+        u8 p = 0;
+        int lane;
+
+        for (lane = 0; lane < lane_count; lane++) {
+                u8 this_v = dp_get_adjust_request_voltage(link_status, lane);
+                u8 this_p = dp_get_adjust_request_pre_emphasis(link_status, lane);
+
+                DRM_DEBUG("requested signal parameters: lane %d voltage %s pre_emph %s\n",
+                          lane,
+                          voltage_names[this_v >> DP_TRAIN_VOLTAGE_SWING_SHIFT],
+                          pre_emph_names[this_p >> DP_TRAIN_PRE_EMPHASIS_SHIFT]);
+
+                if (this_v > v)
+                        v = this_v;
+                if (this_p > p)
+                        p = this_p;
+        }
+
+        if (v >= DP_VOLTAGE_MAX)
+                v = DP_VOLTAGE_MAX | DP_TRAIN_MAX_SWING_REACHED;
+
+        if (p >= dp_pre_emphasis_max(v))
+                p = dp_pre_emphasis_max(v) | DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
+
+        DRM_DEBUG("using signal parameters: voltage %s pre_emph %s\n",
+                  voltage_names[(v & DP_TRAIN_VOLTAGE_SWING_MASK) >> DP_TRAIN_VOLTAGE_SWING_SHIFT],
+                  pre_emph_names[(p & DP_TRAIN_PRE_EMPHASIS_MASK) >> DP_TRAIN_PRE_EMPHASIS_SHIFT]);
+
+        for (lane = 0; lane < 4; lane++)
+                train_set[lane] = v | p;
+}
+
+
+/* radeon aux chan functions */
+bool radeon_process_aux_ch(struct radeon_i2c_chan *chan, u8 *req_bytes,
+                           int num_bytes, u8 *read_byte,
+                           u8 read_buf_len, u8 delay)
+{
+        struct drm_device *dev = chan->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        PROCESS_AUX_CHANNEL_TRANSACTION_PS_ALLOCATION args;
+        int index = GetIndexIntoMasterTable(COMMAND, ProcessAuxChannelTransaction);
+        unsigned char *base;
+
+        memset(&args, 0, sizeof(args));
+
+        base = (unsigned char *)rdev->mode_info.atom_context->scratch;
+
+        memcpy(base, req_bytes, num_bytes);
+
+        args.lpAuxRequest = 0;
+        args.lpDataOut = 16;
+        args.ucDataOutLen = 0;
+        args.ucChannelID = chan->rec.i2c_id;
+        args.ucDelay = delay / 10;
+
+        atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
+
+        if (args.ucReplyStatus) {
+                DRM_DEBUG("failed to get auxch %02x%02x %02x %02x 0x%02x %02x\n",
+                          req_bytes[1], req_bytes[0], req_bytes[2], req_bytes[3],
+                          chan->rec.i2c_id, args.ucReplyStatus);
+                return false;
+        }
+
+        if (args.ucDataOutLen && read_byte && read_buf_len) {
+                if (read_buf_len < args.ucDataOutLen) {
+                        DRM_ERROR("Buffer to small for return answer %d %d\n",
+                                  read_buf_len, args.ucDataOutLen);
+                        return false;
+                }
+                {
+                        int len = min(read_buf_len, args.ucDataOutLen);
+                        memcpy(read_byte, base + 16, len);
+                }
+        }
+        return true;
+}
+
+bool radeon_dp_aux_native_write(struct radeon_connector *radeon_connector, uint16_t address,
+                                uint8_t send_bytes, uint8_t *send)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+        u8 msg[20];
+        u8 msg_len, dp_msg_len;
+        bool ret;
+
+        dp_msg_len = 4;
+        msg[0] = address;
+        msg[1] = address >> 8;
+        msg[2] = AUX_NATIVE_WRITE << 4;
+        dp_msg_len += send_bytes;
+        msg[3] = (dp_msg_len << 4) | (send_bytes - 1);
+
+        if (send_bytes > 16)
+                return false;
+
+        memcpy(&msg[4], send, send_bytes);
+        msg_len = 4 + send_bytes;
+        ret = radeon_process_aux_ch(dig_connector->dp_i2c_bus, msg, msg_len, NULL, 0, 0);
+        return ret;
+}
+
+bool radeon_dp_aux_native_read(struct radeon_connector *radeon_connector, uint16_t address,
+                               uint8_t delay, uint8_t expected_bytes,
+                               uint8_t *read_p)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+        u8 msg[20];
+        u8 msg_len, dp_msg_len;
+        bool ret = false;
+        msg_len = 4;
+        dp_msg_len = 4;
+        msg[0] = address;
+        msg[1] = address >> 8;
+        msg[2] = AUX_NATIVE_READ << 4;
+        msg[3] = (dp_msg_len) << 4;
+        msg[3] |= expected_bytes - 1;
+
+        ret = radeon_process_aux_ch(dig_connector->dp_i2c_bus, msg, msg_len, read_p, expected_bytes, delay);
+        return ret;
+}
+
+/* radeon dp functions */
+static u8 radeon_dp_encoder_service(struct radeon_device *rdev, int action, int dp_clock,
+                                    uint8_t ucconfig, uint8_t lane_num)
+{
+        DP_ENCODER_SERVICE_PARAMETERS args;
+        int index = GetIndexIntoMasterTable(COMMAND, DPEncoderService);
+
+        memset(&args, 0, sizeof(args));
+        args.ucLinkClock = dp_clock / 10;
+        args.ucConfig = ucconfig;
+        args.ucAction = action;
+        args.ucLaneNum = lane_num;
+        args.ucStatus = 0;
+
+        atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
+        return args.ucStatus;
+}
+
+u8 radeon_dp_getsinktype(struct radeon_connector *radeon_connector)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+        struct drm_device *dev = radeon_connector->base.dev;
+        struct radeon_device *rdev = dev->dev_private;
+
+        return radeon_dp_encoder_service(rdev, ATOM_DP_ACTION_GET_SINK_TYPE, 0,
+                                         dig_connector->dp_i2c_bus->rec.i2c_id, 0);
+}
+
+bool radeon_dp_getdpcd(struct radeon_connector *radeon_connector)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+        u8 msg[25];
+        int ret;
+
+        ret = radeon_dp_aux_native_read(radeon_connector, DP_DPCD_REV, 0, 8, msg);
+        if (ret) {
+                memcpy(dig_connector->dpcd, msg, 8);
+                {
+                        int i;
+                        DRM_DEBUG("DPCD: ");
+                        for (i = 0; i < 8; i++)
+                                DRM_DEBUG("%02x ", msg[i]);
+                        DRM_DEBUG("\n");
+                }
+                return true;
+        }
+        dig_connector->dpcd[0] = 0;
+        return false;
+}
+
+void radeon_dp_set_link_config(struct drm_connector *connector,
+                               struct drm_display_mode *mode)
+{
+        struct radeon_connector *radeon_connector;
+        struct radeon_connector_atom_dig *dig_connector;
+
+        if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
+                return;
+
+        radeon_connector = to_radeon_connector(connector);
+        if (!radeon_connector->con_priv)
+                return;
+        dig_connector = radeon_connector->con_priv;
+
+        dig_connector->dp_clock =
+                dp_link_clock_for_mode_clock(dig_connector->dpcd, mode->clock);
+        dig_connector->dp_lane_count =
+                dp_lanes_for_mode_clock(dig_connector->dpcd, mode->clock);
+}
+
+int radeon_dp_mode_valid_helper(struct radeon_connector *radeon_connector,
+                                struct drm_display_mode *mode)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+
+        return dp_mode_valid(dig_connector->dpcd, mode->clock);
+}
+
+static bool atom_dp_get_link_status(struct radeon_connector *radeon_connector,
+                                    u8 link_status[DP_LINK_STATUS_SIZE])
+{
+        int ret;
+        ret = radeon_dp_aux_native_read(radeon_connector, DP_LANE0_1_STATUS, 100,
+                                        DP_LINK_STATUS_SIZE, link_status);
+        if (!ret) {
+                DRM_ERROR("displayport link status failed\n");
+                return false;
+        }
+
+        DRM_DEBUG("link status %02x %02x %02x %02x %02x %02x\n",
+                  link_status[0], link_status[1], link_status[2],
+                  link_status[3], link_status[4], link_status[5]);
+        return true;
+}
+
+bool radeon_dp_needs_link_train(struct radeon_connector *radeon_connector)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+        u8 link_status[DP_LINK_STATUS_SIZE];
+
+        if (!atom_dp_get_link_status(radeon_connector, link_status))
+                return false;
+        if (dp_channel_eq_ok(link_status, dig_connector->dp_lane_count))
+                return false;
+        return true;
+}
+
+static void dp_set_power(struct radeon_connector *radeon_connector, u8 power_state)
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+
+        if (dig_connector->dpcd[0] >= 0x11) {
+                radeon_dp_aux_native_write(radeon_connector, DP_SET_POWER, 1,
+                                           &power_state);
+        }
+}
+
+static void dp_set_downspread(struct radeon_connector *radeon_connector, u8 downspread)
+{
+        radeon_dp_aux_native_write(radeon_connector, DP_DOWNSPREAD_CTRL, 1,
+                                   &downspread);
+}
+
+static void dp_set_link_bw_lanes(struct radeon_connector *radeon_connector,
+                                 u8 link_configuration[DP_LINK_CONFIGURATION_SIZE])
+{
+        radeon_dp_aux_native_write(radeon_connector, DP_LINK_BW_SET, 2,
+                                   link_configuration);
+}
+
+static void dp_update_dpvs_emph(struct radeon_connector *radeon_connector,
+                                struct drm_encoder *encoder,
+                                u8 train_set[4])
+{
+        struct radeon_connector_atom_dig *dig_connector = radeon_connector->con_priv;
+        int i;
+
+        for (i = 0; i < dig_connector->dp_lane_count; i++)
+                atombios_dig_transmitter_setup(encoder,
+                                               ATOM_TRANSMITTER_ACTION_SETUP_VSEMPH,
+                                               i, train_set[i]);
+
+        radeon_dp_aux_native_write(radeon_connector, DP_TRAINING_LANE0_SET,
+                                   dig_connector->dp_lane_count, train_set);
+}
+
+static void dp_set_training(struct radeon_connector *radeon_connector,
+                            u8 training)
+{
+        radeon_dp_aux_native_write(radeon_connector, DP_TRAINING_PATTERN_SET,
+                                   1, &training);
+}
+
+void dp_link_train(struct drm_encoder *encoder,
+                   struct drm_connector *connector)
+{
+        struct drm_device *dev = encoder->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct radeon_encoder_atom_dig *dig;
+        struct radeon_connector *radeon_connector;
+        struct radeon_connector_atom_dig *dig_connector;
+        int enc_id = 0;
+        bool clock_recovery, channel_eq;
+        u8 link_status[DP_LINK_STATUS_SIZE];
+        u8 link_configuration[DP_LINK_CONFIGURATION_SIZE];
+        u8 tries, voltage;
+        u8 train_set[4];
+        int i;
+
+        if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
+                return;
+
+        if (!radeon_encoder->enc_priv)
+                return;
+        dig = radeon_encoder->enc_priv;
+
+        radeon_connector = to_radeon_connector(connector);
+        if (!radeon_connector->con_priv)
+                return;
+        dig_connector = radeon_connector->con_priv;
+
+        if (ASIC_IS_DCE32(rdev)) {
+                if (dig->dig_block)
+                        enc_id |= ATOM_DP_CONFIG_DIG2_ENCODER;
+                else
+                        enc_id |= ATOM_DP_CONFIG_DIG1_ENCODER;
+                if (dig_connector->linkb)
+                        enc_id |= ATOM_DP_CONFIG_LINK_B;
+                else
+                        enc_id |= ATOM_DP_CONFIG_LINK_A;
+        } else {
+                if (dig_connector->linkb)
+                        enc_id |= ATOM_DP_CONFIG_DIG2_ENCODER | ATOM_DP_CONFIG_LINK_B;
+                else
+                        enc_id |= ATOM_DP_CONFIG_DIG1_ENCODER | ATOM_DP_CONFIG_LINK_A;
+        }
+
+        memset(link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
+        if (dig_connector->dp_clock == 270000)
+                link_configuration[0] = DP_LINK_BW_2_7;
+        else
+                link_configuration[0] = DP_LINK_BW_1_62;
+        link_configuration[1] = dig_connector->dp_lane_count;
+        if (dig_connector->dpcd[0] >= 0x11)
+                link_configuration[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
+
+        /* power up the sink */
+        dp_set_power(radeon_connector, DP_SET_POWER_D0);
+        /* disable the training pattern on the sink */
+        dp_set_training(radeon_connector, DP_TRAINING_PATTERN_DISABLE);
+        /* set link bw and lanes on the sink */
+        dp_set_link_bw_lanes(radeon_connector, link_configuration);
+        /* disable downspread on the sink */
+        dp_set_downspread(radeon_connector, 0);
+        /* start training on the source */
+        radeon_dp_encoder_service(rdev, ATOM_DP_ACTION_TRAINING_START,
+                                  dig_connector->dp_clock, enc_id, 0);
+        /* set training pattern 1 on the source */
+        radeon_dp_encoder_service(rdev, ATOM_DP_ACTION_TRAINING_PATTERN_SEL,
+                                  dig_connector->dp_clock, enc_id, 0);
+
+        /* set initial vs/emph */
+        memset(train_set, 0, 4);
+        udelay(400);
+        /* set training pattern 1 on the sink */
+        dp_set_training(radeon_connector, DP_TRAINING_PATTERN_1);
+
+        dp_update_dpvs_emph(radeon_connector, encoder, train_set);
+
+        /* clock recovery loop */
+        clock_recovery = false;
+        tries = 0;
+        voltage = 0xff;
+        for (;;) {
+                udelay(100);
+                if (!atom_dp_get_link_status(radeon_connector, link_status))
+                        break;
+
+                if (dp_clock_recovery_ok(link_status, dig_connector->dp_lane_count)) {
+                        clock_recovery = true;
+                        break;
+                }
+
+                for (i = 0; i < dig_connector->dp_lane_count; i++) {
+                        if ((train_set[i] & DP_TRAIN_MAX_SWING_REACHED) == 0)
+                                break;
+                }
+                if (i == dig_connector->dp_lane_count) {
+                        DRM_ERROR("clock recovery reached max voltage\n");
+                        break;
+                }
+
+                if ((train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK) == voltage) {
+                        ++tries;
+                        if (tries == 5) {
+                                DRM_ERROR("clock recovery tried 5 times\n");
+                                break;
+                        }
+                } else
+                        tries = 0;
+
+                voltage = train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
+
+                /* Compute new train_set as requested by sink */
+                dp_get_adjust_train(link_status, dig_connector->dp_lane_count, train_set);
+                dp_update_dpvs_emph(radeon_connector, encoder, train_set);
+        }
+        if (!clock_recovery)
+                DRM_ERROR("clock recovery failed\n");
+        else
+                DRM_DEBUG("clock recovery at voltage %d pre-emphasis %d\n",
+                          train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK,
+                          (train_set[0] & DP_TRAIN_PRE_EMPHASIS_MASK) >>
+                          DP_TRAIN_PRE_EMPHASIS_SHIFT);
+
+
+        /* set training pattern 2 on the sink */
+        dp_set_training(radeon_connector, DP_TRAINING_PATTERN_2);
+        /* set training pattern 2 on the source */
+        radeon_dp_encoder_service(rdev, ATOM_DP_ACTION_TRAINING_PATTERN_SEL,
+                                  dig_connector->dp_clock, enc_id, 1);
+
+        /* channel equalization loop */
+        tries = 0;
+        channel_eq = false;
+        for (;;) {
+                udelay(400);
+                if (!atom_dp_get_link_status(radeon_connector, link_status))
+                        break;
+
+                if (dp_channel_eq_ok(link_status, dig_connector->dp_lane_count)) {
+                        channel_eq = true;
+                        break;
+                }
+
+                /* Try 5 times */
+                if (tries > 5) {
+                        DRM_ERROR("channel eq failed: 5 tries\n");
+                        break;
+                }
+
+                /* Compute new train_set as requested by sink */
+                dp_get_adjust_train(link_status, dig_connector->dp_lane_count, train_set);
+                dp_update_dpvs_emph(radeon_connector, encoder, train_set);
+
+                tries++;
+        }
+
+        if (!channel_eq)
+                DRM_ERROR("channel eq failed\n");
+        else
+                DRM_DEBUG("channel eq at voltage %d pre-emphasis %d\n",
+                          train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK,
+                          (train_set[0] & DP_TRAIN_PRE_EMPHASIS_MASK)
+                          >> DP_TRAIN_PRE_EMPHASIS_SHIFT);
+
+        /* disable the training pattern on the sink */
+        dp_set_training(radeon_connector, DP_TRAINING_PATTERN_DISABLE);
+
+        radeon_dp_encoder_service(rdev, ATOM_DP_ACTION_TRAINING_COMPLETE,
+                                  dig_connector->dp_clock, enc_id, 0);
+}
+
+int radeon_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 radeon_i2c_chan *auxch = (struct radeon_i2c_chan *)adapter;
+        int ret = 0;
+        uint16_t address = algo_data->address;
+        uint8_t msg[5];
+        uint8_t reply[2];
+        int msg_len, dp_msg_len;
+        int reply_bytes;
+
+        /* Set up the command byte */
+        if (mode & MODE_I2C_READ)
+                msg[2] = AUX_I2C_READ << 4;
+        else
+                msg[2] = AUX_I2C_WRITE << 4;
+
+        if (!(mode & MODE_I2C_STOP))
+                msg[2] |= AUX_I2C_MOT << 4;
+
+        msg[0] = address;
+        msg[1] = address >> 8;
+
+        reply_bytes = 1;
+
+        msg_len = 4;
+        dp_msg_len = 3;
+        switch (mode) {
+        case MODE_I2C_WRITE:
+                msg[4] = write_byte;
+                msg_len++;
+                dp_msg_len += 2;
+                break;
+        case MODE_I2C_READ:
+                dp_msg_len += 1;
+                break;
+        default:
+                break;
+        }
+
+        msg[3] = (dp_msg_len) << 4;
+        ret = radeon_process_aux_ch(auxch, msg, msg_len, reply, reply_bytes, 0);
+
+        if (ret) {
+                if (read_byte)
+                        *read_byte = reply[0];
+                return reply_bytes;
+        }
+        return -EREMOTEIO;
+}
+
diff --git a/drivers/gpu/drm/radeon/mkregtable.c b/drivers/gpu/drm/radeon/mkregtable.c
index fb211e585dea..0d79577c1576 100644
--- a/drivers/gpu/drm/radeon/mkregtable.c
+++ b/drivers/gpu/drm/radeon/mkregtable.c
@@ -561,7 +561,7 @@ struct table {
         char *gpu_prefix;
 };
 
-struct offset *offset_new(unsigned o)
+static struct offset *offset_new(unsigned o)
 {
         struct offset *offset;
 
@@ -573,12 +573,12 @@ struct offset *offset_new(unsigned o)
         return offset;
 }
 
-void table_offset_add(struct table *t, struct offset *offset)
+static void table_offset_add(struct table *t, struct offset *offset)
 {
         list_add_tail(&offset->list, &t->offsets);
 }
 
-void table_init(struct table *t)
+static void table_init(struct table *t)
 {
         INIT_LIST_HEAD(&t->offsets);
         t->offset_max = 0;
@@ -586,7 +586,7 @@ void table_init(struct table *t)
         t->table = NULL;
 }
 
-void table_print(struct table *t)
+static void table_print(struct table *t)
 {
         unsigned nlloop, i, j, n, c, id;
 
@@ -611,7 +611,7 @@ void table_print(struct table *t)
         printf("};\n");
 }
 
-int table_build(struct table *t)
+static int table_build(struct table *t)
 {
         struct offset *offset;
         unsigned i, m;
@@ -631,7 +631,7 @@ int table_build(struct table *t)
 }
 
 static char gpu_name[10];
-int parser_auth(struct table *t, const char *filename)
+static int parser_auth(struct table *t, const char *filename)
 {
         FILE *file;
         regex_t mask_rex;
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index c9e93eabcf16..b7baf16c11d7 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -65,6 +65,95 @@ MODULE_FIRMWARE(FIRMWARE_R520);
  * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280
  */
 
+/* hpd for digital panel detect/disconnect */
+bool r100_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd)
+{
+        bool connected = false;
+
+        switch (hpd) {
+        case RADEON_HPD_1:
+                if (RREG32(RADEON_FP_GEN_CNTL) & RADEON_FP_DETECT_SENSE)
+                        connected = true;
+                break;
+        case RADEON_HPD_2:
+                if (RREG32(RADEON_FP2_GEN_CNTL) & RADEON_FP2_DETECT_SENSE)
+                        connected = true;
+                break;
+        default:
+                break;
+        }
+        return connected;
+}
+
+void r100_hpd_set_polarity(struct radeon_device *rdev,
+                           enum radeon_hpd_id hpd)
+{
+        u32 tmp;
+        bool connected = r100_hpd_sense(rdev, hpd);
+
+        switch (hpd) {
+        case RADEON_HPD_1:
+                tmp = RREG32(RADEON_FP_GEN_CNTL);
+                if (connected)
+                        tmp &= ~RADEON_FP_DETECT_INT_POL;
+                else
+                        tmp |= RADEON_FP_DETECT_INT_POL;
+                WREG32(RADEON_FP_GEN_CNTL, tmp);
+                break;
+        case RADEON_HPD_2:
+                tmp = RREG32(RADEON_FP2_GEN_CNTL);
+                if (connected)
+                        tmp &= ~RADEON_FP2_DETECT_INT_POL;
+                else
+                        tmp |= RADEON_FP2_DETECT_INT_POL;
+                WREG32(RADEON_FP2_GEN_CNTL, tmp);
+                break;
+        default:
+                break;
+        }
+}
+
+void r100_hpd_init(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct drm_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                switch (radeon_connector->hpd.hpd) {
+                case RADEON_HPD_1:
+                        rdev->irq.hpd[0] = true;
+                        break;
+                case RADEON_HPD_2:
+                        rdev->irq.hpd[1] = true;
+                        break;
+                default:
+                        break;
+                }
+        }
+        r100_irq_set(rdev);
+}
+
+void r100_hpd_fini(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct drm_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                switch (radeon_connector->hpd.hpd) {
+                case RADEON_HPD_1:
+                        rdev->irq.hpd[0] = false;
+                        break;
+                case RADEON_HPD_2:
+                        rdev->irq.hpd[1] = false;
+                        break;
+                default:
+                        break;
+                }
+        }
+}
+
 /*
  * PCI GART
  */
@@ -94,6 +183,15 @@ int r100_pci_gart_init(struct radeon_device *rdev)
         return radeon_gart_table_ram_alloc(rdev);
 }
 
+/* required on r1xx, r2xx, r300, r(v)350, r420/r481, rs400/rs480 */
+void r100_enable_bm(struct radeon_device *rdev)
+{
+        uint32_t tmp;
+        /* Enable bus mastering */
+        tmp = RREG32(RADEON_BUS_CNTL) & ~RADEON_BUS_MASTER_DIS;
+        WREG32(RADEON_BUS_CNTL, tmp);
+}
+
 int r100_pci_gart_enable(struct radeon_device *rdev)
 {
         uint32_t tmp;
@@ -105,9 +203,6 @@ int r100_pci_gart_enable(struct radeon_device *rdev)
         WREG32(RADEON_AIC_LO_ADDR, rdev->mc.gtt_location);
         tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1;
         WREG32(RADEON_AIC_HI_ADDR, tmp);
-        /* Enable bus mastering */
-        tmp = RREG32(RADEON_BUS_CNTL) & ~RADEON_BUS_MASTER_DIS;
-        WREG32(RADEON_BUS_CNTL, tmp);
         /* set PCI GART page-table base address */
         WREG32(RADEON_AIC_PT_BASE, rdev->gart.table_addr);
         tmp = RREG32(RADEON_AIC_CNTL) | RADEON_PCIGART_TRANSLATE_EN;
@@ -157,6 +252,12 @@ int r100_irq_set(struct radeon_device *rdev)
         if (rdev->irq.crtc_vblank_int[1]) {
                 tmp |= RADEON_CRTC2_VBLANK_MASK;
         }
+        if (rdev->irq.hpd[0]) {
+                tmp |= RADEON_FP_DETECT_MASK;
+        }
+        if (rdev->irq.hpd[1]) {
+                tmp |= RADEON_FP2_DETECT_MASK;
+        }
         WREG32(RADEON_GEN_INT_CNTL, tmp);
         return 0;
 }
@@ -175,8 +276,9 @@ void r100_irq_disable(struct radeon_device *rdev)
 static inline uint32_t r100_irq_ack(struct radeon_device *rdev)
 {
         uint32_t irqs = RREG32(RADEON_GEN_INT_STATUS);
-        uint32_t irq_mask = RADEON_SW_INT_TEST | RADEON_CRTC_VBLANK_STAT |
-                RADEON_CRTC2_VBLANK_STAT;
+        uint32_t irq_mask = RADEON_SW_INT_TEST |
+                RADEON_CRTC_VBLANK_STAT | RADEON_CRTC2_VBLANK_STAT |
+                RADEON_FP_DETECT_STAT | RADEON_FP2_DETECT_STAT;
 
         if (irqs) {
                 WREG32(RADEON_GEN_INT_STATUS, irqs);
@@ -187,6 +289,7 @@ static inline uint32_t r100_irq_ack(struct radeon_device *rdev)
 int r100_irq_process(struct radeon_device *rdev)
 {
         uint32_t status, msi_rearm;
+        bool queue_hotplug = false;
 
         status = r100_irq_ack(rdev);
         if (!status) {
@@ -207,8 +310,18 @@ int r100_irq_process(struct radeon_device *rdev)
                 if (status & RADEON_CRTC2_VBLANK_STAT) {
                         drm_handle_vblank(rdev->ddev, 1);
                 }
+                if (status & RADEON_FP_DETECT_STAT) {
+                        queue_hotplug = true;
+                        DRM_DEBUG("HPD1\n");
+                }
+                if (status & RADEON_FP2_DETECT_STAT) {
+                        queue_hotplug = true;
+                        DRM_DEBUG("HPD2\n");
+                }
                 status = r100_irq_ack(rdev);
         }
+        if (queue_hotplug)
+                queue_work(rdev->wq, &rdev->hotplug_work);
         if (rdev->msi_enabled) {
                 switch (rdev->family) {
                 case CHIP_RS400:
@@ -255,24 +368,27 @@ int r100_wb_init(struct radeon_device *rdev)
         int r;
 
         if (rdev->wb.wb_obj == NULL) {
-                r = radeon_object_create(rdev, NULL, RADEON_GPU_PAGE_SIZE,
-                                         true,
-                                         RADEON_GEM_DOMAIN_GTT,
-                                         false, &rdev->wb.wb_obj);
+                r = radeon_bo_create(rdev, NULL, RADEON_GPU_PAGE_SIZE, true,
+                                        RADEON_GEM_DOMAIN_GTT,
+                                        &rdev->wb.wb_obj);
                 if (r) {
-                        DRM_ERROR("radeon: failed to create WB buffer (%d).\n", r);
+                        dev_err(rdev->dev, "(%d) create WB buffer failed\n", r);
                         return r;
                 }
-                r = radeon_object_pin(rdev->wb.wb_obj,
-                                      RADEON_GEM_DOMAIN_GTT,
-                                      &rdev->wb.gpu_addr);
+                r = radeon_bo_reserve(rdev->wb.wb_obj, false);
+                if (unlikely(r != 0))
+                        return r;
+                r = radeon_bo_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT,
+                                        &rdev->wb.gpu_addr);
                 if (r) {
-                        DRM_ERROR("radeon: failed to pin WB buffer (%d).\n", r);
+                        dev_err(rdev->dev, "(%d) pin WB buffer failed\n", r);
+                        radeon_bo_unreserve(rdev->wb.wb_obj);
                         return r;
                 }
-                r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb);
+                r = radeon_bo_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb);
+                radeon_bo_unreserve(rdev->wb.wb_obj);
                 if (r) {
-                        DRM_ERROR("radeon: failed to map WB buffer (%d).\n", r);
+                        dev_err(rdev->dev, "(%d) map WB buffer failed\n", r);
                         return r;
                 }
         }
@@ -290,11 +406,19 @@ void r100_wb_disable(struct radeon_device *rdev)
 
 void r100_wb_fini(struct radeon_device *rdev)
 {
+        int r;
+
         r100_wb_disable(rdev);
         if (rdev->wb.wb_obj) {
-                radeon_object_kunmap(rdev->wb.wb_obj);
-                radeon_object_unpin(rdev->wb.wb_obj);
-                radeon_object_unref(&rdev->wb.wb_obj);
+                r = radeon_bo_reserve(rdev->wb.wb_obj, false);
+                if (unlikely(r != 0)) {
+                        dev_err(rdev->dev, "(%d) can't finish WB\n", r);
+                        return;
+                }
+                radeon_bo_kunmap(rdev->wb.wb_obj);
+                radeon_bo_unpin(rdev->wb.wb_obj);
+                radeon_bo_unreserve(rdev->wb.wb_obj);
+                radeon_bo_unref(&rdev->wb.wb_obj);
                 rdev->wb.wb = NULL;
                 rdev->wb.wb_obj = NULL;
         }
@@ -1288,17 +1412,17 @@ static int r100_packet0_check(struct radeon_cs_parser *p,
 
 int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p,
                                          struct radeon_cs_packet *pkt,
-                                         struct radeon_object *robj)
+                                         struct radeon_bo *robj)
 {
         unsigned idx;
         u32 value;
         idx = pkt->idx + 1;
         value = radeon_get_ib_value(p, idx + 2);
-        if ((value + 1) > radeon_object_size(robj)) {
+        if ((value + 1) > radeon_bo_size(robj)) {
                 DRM_ERROR("[drm] Buffer too small for PACKET3 INDX_BUFFER "
                           "(need %u have %lu) !\n",
                           value + 1,
-                          radeon_object_size(robj));
+                          radeon_bo_size(robj));
                 return -EINVAL;
         }
         return 0;
@@ -1583,6 +1707,14 @@ void r100_gpu_init(struct radeon_device *rdev)
         r100_hdp_reset(rdev);
 }
 
+void r100_hdp_flush(struct radeon_device *rdev)
+{
+        u32 tmp;
+        tmp = RREG32(RADEON_HOST_PATH_CNTL);
+        tmp |= RADEON_HDP_READ_BUFFER_INVALIDATE;
+        WREG32(RADEON_HOST_PATH_CNTL, tmp);
+}
+
 void r100_hdp_reset(struct radeon_device *rdev)
 {
         uint32_t tmp;
@@ -1650,6 +1782,17 @@ int r100_gpu_reset(struct radeon_device *rdev)
         return 0;
 }
 
+void r100_set_common_regs(struct radeon_device *rdev)
+{
+        /* set these so they don't interfere with anything */
+        WREG32(RADEON_OV0_SCALE_CNTL, 0);
+        WREG32(RADEON_SUBPIC_CNTL, 0);
+        WREG32(RADEON_VIPH_CONTROL, 0);
+        WREG32(RADEON_I2C_CNTL_1, 0);
+        WREG32(RADEON_DVI_I2C_CNTL_1, 0);
+        WREG32(RADEON_CAP0_TRIG_CNTL, 0);
+        WREG32(RADEON_CAP1_TRIG_CNTL, 0);
+}
 
 /*
  * VRAM info
@@ -2594,7 +2737,7 @@ static int r100_cs_track_cube(struct radeon_device *rdev,
                               struct r100_cs_track *track, unsigned idx)
 {
         unsigned face, w, h;
-        struct radeon_object *cube_robj;
+        struct radeon_bo *cube_robj;
         unsigned long size;
 
         for (face = 0; face < 5; face++) {
@@ -2607,9 +2750,9 @@ static int r100_cs_track_cube(struct radeon_device *rdev,
 
                 size += track->textures[idx].cube_info[face].offset;
 
-                if (size > radeon_object_size(cube_robj)) {
+                if (size > radeon_bo_size(cube_robj)) {
                         DRM_ERROR("Cube texture offset greater than object size %lu %lu\n",
-                                  size, radeon_object_size(cube_robj));
+                                  size, radeon_bo_size(cube_robj));
                         r100_cs_track_texture_print(&track->textures[idx]);
                         return -1;
                 }
@@ -2620,7 +2763,7 @@ static int r100_cs_track_cube(struct radeon_device *rdev,
 static int r100_cs_track_texture_check(struct radeon_device *rdev,
                                        struct r100_cs_track *track)
 {
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         unsigned long size;
         unsigned u, i, w, h;
         int ret;
@@ -2676,9 +2819,9 @@ static int r100_cs_track_texture_check(struct radeon_device *rdev,
                                   "%u\n", track->textures[u].tex_coord_type, u);
                         return -EINVAL;
                 }
-                if (size > radeon_object_size(robj)) {
+                if (size > radeon_bo_size(robj)) {
                         DRM_ERROR("Texture of unit %u needs %lu bytes but is "
-                                  "%lu\n", u, size, radeon_object_size(robj));
+                                  "%lu\n", u, size, radeon_bo_size(robj));
                         r100_cs_track_texture_print(&track->textures[u]);
                         return -EINVAL;
                 }
@@ -2700,10 +2843,10 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
                 }
                 size = track->cb[i].pitch * track->cb[i].cpp * track->maxy;
                 size += track->cb[i].offset;
-                if (size > radeon_object_size(track->cb[i].robj)) {
+                if (size > radeon_bo_size(track->cb[i].robj)) {
                         DRM_ERROR("[drm] Buffer too small for color buffer %d "
                                   "(need %lu have %lu) !\n", i, size,
-                                  radeon_object_size(track->cb[i].robj));
+                                  radeon_bo_size(track->cb[i].robj));
                         DRM_ERROR("[drm] color buffer %d (%u %u %u %u)\n",
                                   i, track->cb[i].pitch, track->cb[i].cpp,
                                   track->cb[i].offset, track->maxy);
@@ -2717,10 +2860,10 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
                 }
                 size = track->zb.pitch * track->zb.cpp * track->maxy;
                 size += track->zb.offset;
-                if (size > radeon_object_size(track->zb.robj)) {
+                if (size > radeon_bo_size(track->zb.robj)) {
                         DRM_ERROR("[drm] Buffer too small for z buffer "
                                   "(need %lu have %lu) !\n", size,
-                                  radeon_object_size(track->zb.robj));
+                                  radeon_bo_size(track->zb.robj));
                         DRM_ERROR("[drm] zbuffer (%u %u %u %u)\n",
                                   track->zb.pitch, track->zb.cpp,
                                   track->zb.offset, track->maxy);
@@ -2738,11 +2881,12 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
                                           "bound\n", prim_walk, i);
                                 return -EINVAL;
                         }
-                        if (size > radeon_object_size(track->arrays[i].robj)) {
-                                DRM_ERROR("(PW %u) Vertex array %u need %lu dwords "
-                                           "have %lu dwords\n", prim_walk, i,
-                                           size >> 2,
-                                           radeon_object_size(track->arrays[i].robj) >> 2);
+                        if (size > radeon_bo_size(track->arrays[i].robj)) {
+                                dev_err(rdev->dev, "(PW %u) Vertex array %u "
+                                        "need %lu dwords have %lu dwords\n",
+                                        prim_walk, i, size >> 2,
+                                        radeon_bo_size(track->arrays[i].robj)
+                                        >> 2);
                                 DRM_ERROR("Max indices %u\n", track->max_indx);
                                 return -EINVAL;
                         }
@@ -2756,10 +2900,12 @@ int r100_cs_track_check(struct radeon_device *rdev, struct r100_cs_track *track)
                                           "bound\n", prim_walk, i);
                                 return -EINVAL;
                         }
-                        if (size > radeon_object_size(track->arrays[i].robj)) {
-                                DRM_ERROR("(PW %u) Vertex array %u need %lu dwords "
-                                           "have %lu dwords\n", prim_walk, i, size >> 2,
-                                           radeon_object_size(track->arrays[i].robj) >> 2);
+                        if (size > radeon_bo_size(track->arrays[i].robj)) {
+                                dev_err(rdev->dev, "(PW %u) Vertex array %u "
+                                        "need %lu dwords have %lu dwords\n",
+                                        prim_walk, i, size >> 2,
+                                        radeon_bo_size(track->arrays[i].robj)
+                                        >> 2);
                                 return -EINVAL;
                         }
                 }
@@ -3101,6 +3247,9 @@ static int r100_startup(struct radeon_device *rdev)
 {
         int r;
 
+        /* set common regs */
+        r100_set_common_regs(rdev);
+        /* program mc */
         r100_mc_program(rdev);
         /* Resume clock */
         r100_clock_startup(rdev);
@@ -3108,13 +3257,13 @@ static int r100_startup(struct radeon_device *rdev)
         r100_gpu_init(rdev);
         /* Initialize GART (initialize after TTM so we can allocate
          * memory through TTM but finalize after TTM) */
+        r100_enable_bm(rdev);
         if (rdev->flags & RADEON_IS_PCI) {
                 r = r100_pci_gart_enable(rdev);
                 if (r)
                         return r;
         }
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         r100_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -3174,7 +3323,7 @@ void r100_fini(struct radeon_device *rdev)
                 r100_pci_gart_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -3242,10 +3391,8 @@ int r100_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                radeon_combios_asic_init(rdev->ddev);
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
         /* Set asic errata */
         r100_errata(rdev);
         /* Initialize clocks */
@@ -3264,7 +3411,7 @@ int r100_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         if (rdev->flags & RADEON_IS_PCI) {
diff --git a/drivers/gpu/drm/radeon/r100_track.h b/drivers/gpu/drm/radeon/r100_track.h
index 0daf0d76a891..ca50903dd2bb 100644
--- a/drivers/gpu/drm/radeon/r100_track.h
+++ b/drivers/gpu/drm/radeon/r100_track.h
@@ -10,26 +10,26 @@
  * CS functions
  */
 struct r100_cs_track_cb {
-        struct radeon_object    *robj;
+        struct radeon_bo        *robj;
         unsigned                pitch;
         unsigned                cpp;
         unsigned                offset;
 };
 
 struct r100_cs_track_array {
-        struct radeon_object    *robj;
+        struct radeon_bo        *robj;
         unsigned                esize;
 };
 
 struct r100_cs_cube_info {
-        struct radeon_object    *robj;
-        unsigned                offset;
+        struct radeon_bo        *robj;
+        unsigned                offset;
         unsigned                width;
         unsigned                height;
 };
 
 struct r100_cs_track_texture {
-        struct radeon_object    *robj;
+        struct radeon_bo        *robj;
         struct r100_cs_cube_info cube_info[5]; /* info for 5 non-primary faces */
         unsigned                pitch;
         unsigned                width;
diff --git a/drivers/gpu/drm/radeon/r300.c b/drivers/gpu/drm/radeon/r300.c
index 2f43ee8e4048..86065dcc1982 100644
--- a/drivers/gpu/drm/radeon/r300.c
+++ b/drivers/gpu/drm/radeon/r300.c
@@ -137,14 +137,19 @@ int rv370_pcie_gart_enable(struct radeon_device *rdev)
 
 void rv370_pcie_gart_disable(struct radeon_device *rdev)
 {
-        uint32_t tmp;
+        u32 tmp;
+        int r;
 
         tmp = RREG32_PCIE(RADEON_PCIE_TX_GART_CNTL);
         tmp |= RADEON_PCIE_TX_GART_UNMAPPED_ACCESS_DISCARD;
         WREG32_PCIE(RADEON_PCIE_TX_GART_CNTL, tmp & ~RADEON_PCIE_TX_GART_EN);
         if (rdev->gart.table.vram.robj) {
-                radeon_object_kunmap(rdev->gart.table.vram.robj);
-                radeon_object_unpin(rdev->gart.table.vram.robj);
+                r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rdev->gart.table.vram.robj);
+                        radeon_bo_unpin(rdev->gart.table.vram.robj);
+                        radeon_bo_unreserve(rdev->gart.table.vram.robj);
+                }
         }
 }
 
@@ -1181,6 +1186,9 @@ static int r300_startup(struct radeon_device *rdev)
 {
         int r;
 
+        /* set common regs */
+        r100_set_common_regs(rdev);
+        /* program mc */
         r300_mc_program(rdev);
         /* Resume clock */
         r300_clock_startup(rdev);
@@ -1193,13 +1201,18 @@ static int r300_startup(struct radeon_device *rdev)
                 if (r)
                         return r;
         }
+
+        if (rdev->family == CHIP_R300 ||
+            rdev->family == CHIP_R350 ||
+            rdev->family == CHIP_RV350)
+                r100_enable_bm(rdev);
+
         if (rdev->flags & RADEON_IS_PCI) {
                 r = r100_pci_gart_enable(rdev);
                 if (r)
                         return r;
         }
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         r100_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -1265,7 +1278,7 @@ void r300_fini(struct radeon_device *rdev)
                 r100_pci_gart_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -1303,10 +1316,8 @@ int r300_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                radeon_combios_asic_init(rdev->ddev);
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
         /* Set asic errata */
         r300_errata(rdev);
         /* Initialize clocks */
@@ -1325,7 +1336,7 @@ int r300_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         if (rdev->flags & RADEON_IS_PCIE) {
diff --git a/drivers/gpu/drm/radeon/r420.c b/drivers/gpu/drm/radeon/r420.c
index 1cefdbcc0850..162c3902fe69 100644
--- a/drivers/gpu/drm/radeon/r420.c
+++ b/drivers/gpu/drm/radeon/r420.c
@@ -169,6 +169,9 @@ static int r420_startup(struct radeon_device *rdev)
 {
         int r;
 
+        /* set common regs */
+        r100_set_common_regs(rdev);
+        /* program mc */
         r300_mc_program(rdev);
         /* Resume clock */
         r420_clock_resume(rdev);
@@ -186,7 +189,6 @@ static int r420_startup(struct radeon_device *rdev)
         }
         r420_pipes_init(rdev);
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         r100_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -258,7 +260,7 @@ void r420_fini(struct radeon_device *rdev)
         radeon_agp_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         if (rdev->is_atom_bios) {
                 radeon_atombios_fini(rdev);
         } else {
@@ -301,14 +303,9 @@ int r420_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                if (rdev->is_atom_bios) {
-                        atom_asic_init(rdev->mode_info.atom_context);
-                } else {
-                        radeon_combios_asic_init(rdev->ddev);
-                }
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
+
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
         /* Initialize power management */
@@ -331,10 +328,13 @@ int r420_init(struct radeon_device *rdev)
                 return r;
         }
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r) {
                 return r;
         }
+        if (rdev->family == CHIP_R420)
+                r100_enable_bm(rdev);
+
         if (rdev->flags & RADEON_IS_PCIE) {
                 r = rv370_pcie_gart_init(rdev);
                 if (r)
diff --git a/drivers/gpu/drm/radeon/r500_reg.h b/drivers/gpu/drm/radeon/r500_reg.h
index 7baa73955563..74ad89bdf2b5 100644
--- a/drivers/gpu/drm/radeon/r500_reg.h
+++ b/drivers/gpu/drm/radeon/r500_reg.h
@@ -716,6 +716,8 @@
 
 #define AVIVO_DVOA_BIT_DEPTH_CONTROL                    0x7988
 
+#define AVIVO_DC_GPIO_HPD_A                 0x7e94
+
 #define AVIVO_GPIO_0                        0x7e30
 #define AVIVO_GPIO_1                        0x7e40
 #define AVIVO_GPIO_2                        0x7e50
diff --git a/drivers/gpu/drm/radeon/r520.c b/drivers/gpu/drm/radeon/r520.c
index f7435185c0a6..788eef5c2a08 100644
--- a/drivers/gpu/drm/radeon/r520.c
+++ b/drivers/gpu/drm/radeon/r520.c
@@ -185,7 +185,6 @@ static int r520_startup(struct radeon_device *rdev)
                         return r;
         }
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         rs600_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -254,6 +253,9 @@ int r520_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
+
         if (!radeon_card_posted(rdev) && rdev->bios) {
                 DRM_INFO("GPU not posted. posting now...\n");
                 atom_asic_init(rdev->mode_info.atom_context);
@@ -277,7 +279,7 @@ int r520_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         r = rv370_pcie_gart_init(rdev);
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c
index 278f646bc18e..250ec3fe1a16 100644
--- a/drivers/gpu/drm/radeon/r600.c
+++ b/drivers/gpu/drm/radeon/r600.c
@@ -38,8 +38,10 @@
 
 #define PFP_UCODE_SIZE 576
 #define PM4_UCODE_SIZE 1792
+#define RLC_UCODE_SIZE 768
 #define R700_PFP_UCODE_SIZE 848
 #define R700_PM4_UCODE_SIZE 1360
+#define R700_RLC_UCODE_SIZE 1024
 
 /* Firmware Names */
 MODULE_FIRMWARE("radeon/R600_pfp.bin");
@@ -62,6 +64,8 @@ MODULE_FIRMWARE("radeon/RV730_pfp.bin");
 MODULE_FIRMWARE("radeon/RV730_me.bin");
 MODULE_FIRMWARE("radeon/RV710_pfp.bin");
 MODULE_FIRMWARE("radeon/RV710_me.bin");
+MODULE_FIRMWARE("radeon/R600_rlc.bin");
+MODULE_FIRMWARE("radeon/R700_rlc.bin");
 
 int r600_debugfs_mc_info_init(struct radeon_device *rdev);
 
@@ -70,6 +74,281 @@ int r600_mc_wait_for_idle(struct radeon_device *rdev);
 void r600_gpu_init(struct radeon_device *rdev);
 void r600_fini(struct radeon_device *rdev);
 
+/* hpd for digital panel detect/disconnect */
+bool r600_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd)
+{
+        bool connected = false;
+
+        if (ASIC_IS_DCE3(rdev)) {
+                switch (hpd) {
+                case RADEON_HPD_1:
+                        if (RREG32(DC_HPD1_INT_STATUS) & DC_HPDx_SENSE)
+                                connected = true;
+                        break;
+                case RADEON_HPD_2:
+                        if (RREG32(DC_HPD2_INT_STATUS) & DC_HPDx_SENSE)
+                                connected = true;
+                        break;
+                case RADEON_HPD_3:
+                        if (RREG32(DC_HPD3_INT_STATUS) & DC_HPDx_SENSE)
+                                connected = true;
+                        break;
+                case RADEON_HPD_4:
+                        if (RREG32(DC_HPD4_INT_STATUS) & DC_HPDx_SENSE)
+                                connected = true;
+                        break;
+                        /* DCE 3.2 */
+                case RADEON_HPD_5:
+                        if (RREG32(DC_HPD5_INT_STATUS) & DC_HPDx_SENSE)
+                                connected = true;
+                        break;
+                case RADEON_HPD_6:
+                        if (RREG32(DC_HPD6_INT_STATUS) & DC_HPDx_SENSE)
+                                connected = true;
+                        break;
+                default:
+                        break;
+                }
+        } else {
+                switch (hpd) {
+                case RADEON_HPD_1:
+                        if (RREG32(DC_HOT_PLUG_DETECT1_INT_STATUS) & DC_HOT_PLUG_DETECTx_SENSE)
+                                connected = true;
+                        break;
+                case RADEON_HPD_2:
+                        if (RREG32(DC_HOT_PLUG_DETECT2_INT_STATUS) & DC_HOT_PLUG_DETECTx_SENSE)
+                                connected = true;
+                        break;
+                case RADEON_HPD_3:
+                        if (RREG32(DC_HOT_PLUG_DETECT3_INT_STATUS) & DC_HOT_PLUG_DETECTx_SENSE)
+                                connected = true;
+                        break;
+                default:
+                        break;
+                }
+        }
+        return connected;
+}
+
+void r600_hpd_set_polarity(struct radeon_device *rdev,
+                           enum radeon_hpd_id hpd)
+{
+        u32 tmp;
+        bool connected = r600_hpd_sense(rdev, hpd);
+
+        if (ASIC_IS_DCE3(rdev)) {
+                switch (hpd) {
+                case RADEON_HPD_1:
+                        tmp = RREG32(DC_HPD1_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HPDx_INT_POLARITY;
+                        else
+                                tmp |= DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD1_INT_CONTROL, tmp);
+                        break;
+                case RADEON_HPD_2:
+                        tmp = RREG32(DC_HPD2_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HPDx_INT_POLARITY;
+                        else
+                                tmp |= DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD2_INT_CONTROL, tmp);
+                        break;
+                case RADEON_HPD_3:
+                        tmp = RREG32(DC_HPD3_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HPDx_INT_POLARITY;
+                        else
+                                tmp |= DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD3_INT_CONTROL, tmp);
+                        break;
+                case RADEON_HPD_4:
+                        tmp = RREG32(DC_HPD4_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HPDx_INT_POLARITY;
+                        else
+                                tmp |= DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD4_INT_CONTROL, tmp);
+                        break;
+                case RADEON_HPD_5:
+                        tmp = RREG32(DC_HPD5_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HPDx_INT_POLARITY;
+                        else
+                                tmp |= DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD5_INT_CONTROL, tmp);
+                        break;
+                        /* DCE 3.2 */
+                case RADEON_HPD_6:
+                        tmp = RREG32(DC_HPD6_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HPDx_INT_POLARITY;
+                        else
+                                tmp |= DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD6_INT_CONTROL, tmp);
+                        break;
+                default:
+                        break;
+                }
+        } else {
+                switch (hpd) {
+                case RADEON_HPD_1:
+                        tmp = RREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                        else
+                                tmp |= DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                        WREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL, tmp);
+                        break;
+                case RADEON_HPD_2:
+                        tmp = RREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                        else
+                                tmp |= DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                        WREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL, tmp);
+                        break;
+                case RADEON_HPD_3:
+                        tmp = RREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL);
+                        if (connected)
+                                tmp &= ~DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                        else
+                                tmp |= DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                        WREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL, tmp);
+                        break;
+                default:
+                        break;
+                }
+        }
+}
+
+void r600_hpd_init(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct drm_connector *connector;
+
+        if (ASIC_IS_DCE3(rdev)) {
+                u32 tmp = DC_HPDx_CONNECTION_TIMER(0x9c4) | DC_HPDx_RX_INT_TIMER(0xfa);
+                if (ASIC_IS_DCE32(rdev))
+                        tmp |= DC_HPDx_EN;
+
+                list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                        switch (radeon_connector->hpd.hpd) {
+                        case RADEON_HPD_1:
+                                WREG32(DC_HPD1_CONTROL, tmp);
+                                rdev->irq.hpd[0] = true;
+                                break;
+                        case RADEON_HPD_2:
+                                WREG32(DC_HPD2_CONTROL, tmp);
+                                rdev->irq.hpd[1] = true;
+                                break;
+                        case RADEON_HPD_3:
+                                WREG32(DC_HPD3_CONTROL, tmp);
+                                rdev->irq.hpd[2] = true;
+                                break;
+                        case RADEON_HPD_4:
+                                WREG32(DC_HPD4_CONTROL, tmp);
+                                rdev->irq.hpd[3] = true;
+                                break;
+                                /* DCE 3.2 */
+                        case RADEON_HPD_5:
+                                WREG32(DC_HPD5_CONTROL, tmp);
+                                rdev->irq.hpd[4] = true;
+                                break;
+                        case RADEON_HPD_6:
+                                WREG32(DC_HPD6_CONTROL, tmp);
+                                rdev->irq.hpd[5] = true;
+                                break;
+                        default:
+                                break;
+                        }
+                }
+        } else {
+                list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                        switch (radeon_connector->hpd.hpd) {
+                        case RADEON_HPD_1:
+                                WREG32(DC_HOT_PLUG_DETECT1_CONTROL, DC_HOT_PLUG_DETECTx_EN);
+                                rdev->irq.hpd[0] = true;
+                                break;
+                        case RADEON_HPD_2:
+                                WREG32(DC_HOT_PLUG_DETECT2_CONTROL, DC_HOT_PLUG_DETECTx_EN);
+                                rdev->irq.hpd[1] = true;
+                                break;
+                        case RADEON_HPD_3:
+                                WREG32(DC_HOT_PLUG_DETECT3_CONTROL, DC_HOT_PLUG_DETECTx_EN);
+                                rdev->irq.hpd[2] = true;
+                                break;
+                        default:
+                                break;
+                        }
+                }
+        }
+        r600_irq_set(rdev);
+}
+
+void r600_hpd_fini(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct drm_connector *connector;
+
+        if (ASIC_IS_DCE3(rdev)) {
+                list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                        switch (radeon_connector->hpd.hpd) {
+                        case RADEON_HPD_1:
+                                WREG32(DC_HPD1_CONTROL, 0);
+                                rdev->irq.hpd[0] = false;
+                                break;
+                        case RADEON_HPD_2:
+                                WREG32(DC_HPD2_CONTROL, 0);
+                                rdev->irq.hpd[1] = false;
+                                break;
+                        case RADEON_HPD_3:
+                                WREG32(DC_HPD3_CONTROL, 0);
+                                rdev->irq.hpd[2] = false;
+                                break;
+                        case RADEON_HPD_4:
+                                WREG32(DC_HPD4_CONTROL, 0);
+                                rdev->irq.hpd[3] = false;
+                                break;
+                                /* DCE 3.2 */
+                        case RADEON_HPD_5:
+                                WREG32(DC_HPD5_CONTROL, 0);
+                                rdev->irq.hpd[4] = false;
+                                break;
+                        case RADEON_HPD_6:
+                                WREG32(DC_HPD6_CONTROL, 0);
+                                rdev->irq.hpd[5] = false;
+                                break;
+                        default:
+                                break;
+                        }
+                }
+        } else {
+                list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                        switch (radeon_connector->hpd.hpd) {
+                        case RADEON_HPD_1:
+                                WREG32(DC_HOT_PLUG_DETECT1_CONTROL, 0);
+                                rdev->irq.hpd[0] = false;
+                                break;
+                        case RADEON_HPD_2:
+                                WREG32(DC_HOT_PLUG_DETECT2_CONTROL, 0);
+                                rdev->irq.hpd[1] = false;
+                                break;
+                        case RADEON_HPD_3:
+                                WREG32(DC_HOT_PLUG_DETECT3_CONTROL, 0);
+                                rdev->irq.hpd[2] = false;
+                                break;
+                        default:
+                                break;
+                        }
+                }
+        }
+}
+
 /*
  * R600 PCIE GART
  */
@@ -180,7 +459,7 @@ int r600_pcie_gart_enable(struct radeon_device *rdev)
 void r600_pcie_gart_disable(struct radeon_device *rdev)
 {
         u32 tmp;
-        int i;
+        int i, r;
 
         /* Disable all tables */
         for (i = 0; i < 7; i++)
@@ -208,8 +487,12 @@ void r600_pcie_gart_disable(struct radeon_device *rdev)
         WREG32(MC_VM_L1_TLB_MCB_RD_HDP_CNTL, tmp);
         WREG32(MC_VM_L1_TLB_MCB_WR_HDP_CNTL, tmp);
         if (rdev->gart.table.vram.robj) {
-                radeon_object_kunmap(rdev->gart.table.vram.robj);
-                radeon_object_unpin(rdev->gart.table.vram.robj);
+                r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rdev->gart.table.vram.robj);
+                        radeon_bo_unpin(rdev->gart.table.vram.robj);
+                        radeon_bo_unreserve(rdev->gart.table.vram.robj);
+                }
         }
 }
 
@@ -1101,6 +1384,10 @@ void r600_pciep_wreg(struct radeon_device *rdev, u32 reg, u32 v)
         (void)RREG32(PCIE_PORT_DATA);
 }
 
+void r600_hdp_flush(struct radeon_device *rdev)
+{
+        WREG32(R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
+}
 
 /*
  * CP & Ring
@@ -1110,11 +1397,12 @@ void r600_cp_stop(struct radeon_device *rdev)
         WREG32(R_0086D8_CP_ME_CNTL, S_0086D8_CP_ME_HALT(1));
 }
 
-int r600_cp_init_microcode(struct radeon_device *rdev)
+int r600_init_microcode(struct radeon_device *rdev)
 {
         struct platform_device *pdev;
         const char *chip_name;
-        size_t pfp_req_size, me_req_size;
+        const char *rlc_chip_name;
+        size_t pfp_req_size, me_req_size, rlc_req_size;
         char fw_name[30];
         int err;
 
@@ -1128,30 +1416,62 @@ int r600_cp_init_microcode(struct radeon_device *rdev)
         }
 
         switch (rdev->family) {
-        case CHIP_R600: chip_name = "R600"; break;
-        case CHIP_RV610: chip_name = "RV610"; break;
-        case CHIP_RV630: chip_name = "RV630"; break;
-        case CHIP_RV620: chip_name = "RV620"; break;
-        case CHIP_RV635: chip_name = "RV635"; break;
-        case CHIP_RV670: chip_name = "RV670"; break;
+        case CHIP_R600:
+                chip_name = "R600";
+                rlc_chip_name = "R600";
+                break;
+        case CHIP_RV610:
+                chip_name = "RV610";
+                rlc_chip_name = "R600";
+                break;
+        case CHIP_RV630:
+                chip_name = "RV630";
+                rlc_chip_name = "R600";
+                break;
+        case CHIP_RV620:
+                chip_name = "RV620";
+                rlc_chip_name = "R600";
+                break;
+        case CHIP_RV635:
+                chip_name = "RV635";
+                rlc_chip_name = "R600";
+                break;
+        case CHIP_RV670:
+                chip_name = "RV670";
+                rlc_chip_name = "R600";
+                break;
         case CHIP_RS780:
-        case CHIP_RS880: chip_name = "RS780"; break;
-        case CHIP_RV770: chip_name = "RV770"; break;
+        case CHIP_RS880:
+                chip_name = "RS780";
+                rlc_chip_name = "R600";
+                break;
+        case CHIP_RV770:
+                chip_name = "RV770";
+                rlc_chip_name = "R700";
+                break;
         case CHIP_RV730:
-        case CHIP_RV740: chip_name = "RV730"; break;
-        case CHIP_RV710: chip_name = "RV710"; break;
+        case CHIP_RV740:
+                chip_name = "RV730";
+                rlc_chip_name = "R700";
+                break;
+        case CHIP_RV710:
+                chip_name = "RV710";
+                rlc_chip_name = "R700";
+                break;
         default: BUG();
         }
 
         if (rdev->family >= CHIP_RV770) {
                 pfp_req_size = R700_PFP_UCODE_SIZE * 4;
                 me_req_size = R700_PM4_UCODE_SIZE * 4;
+                rlc_req_size = R700_RLC_UCODE_SIZE * 4;
         } else {
                 pfp_req_size = PFP_UCODE_SIZE * 4;
                 me_req_size = PM4_UCODE_SIZE * 12;
+                rlc_req_size = RLC_UCODE_SIZE * 4;
         }
 
-        DRM_INFO("Loading %s CP Microcode\n", chip_name);
+        DRM_INFO("Loading %s Microcode\n", chip_name);
 
         snprintf(fw_name, sizeof(fw_name), "radeon/%s_pfp.bin", chip_name);
         err = request_firmware(&rdev->pfp_fw, fw_name, &pdev->dev);
@@ -1175,6 +1495,18 @@ int r600_cp_init_microcode(struct radeon_device *rdev)
                        rdev->me_fw->size, fw_name);
                 err = -EINVAL;
         }
+
+        snprintf(fw_name, sizeof(fw_name), "radeon/%s_rlc.bin", rlc_chip_name);
+        err = request_firmware(&rdev->rlc_fw, fw_name, &pdev->dev);
+        if (err)
+                goto out;
+        if (rdev->rlc_fw->size != rlc_req_size) {
+                printk(KERN_ERR
+                       "r600_rlc: Bogus length %zu in firmware \"%s\"\n",
+                       rdev->rlc_fw->size, fw_name);
+                err = -EINVAL;
+        }
+
 out:
         platform_device_unregister(pdev);
 
@@ -1187,6 +1519,8 @@ out:
                 rdev->pfp_fw = NULL;
                 release_firmware(rdev->me_fw);
                 rdev->me_fw = NULL;
+                release_firmware(rdev->rlc_fw);
+                rdev->rlc_fw = NULL;
         }
         return err;
 }
@@ -1381,10 +1715,16 @@ int r600_ring_test(struct radeon_device *rdev)
 
 void r600_wb_disable(struct radeon_device *rdev)
 {
+        int r;
+
         WREG32(SCRATCH_UMSK, 0);
         if (rdev->wb.wb_obj) {
-                radeon_object_kunmap(rdev->wb.wb_obj);
-                radeon_object_unpin(rdev->wb.wb_obj);
+                r = radeon_bo_reserve(rdev->wb.wb_obj, false);
+                if (unlikely(r != 0))
+                        return;
+                radeon_bo_kunmap(rdev->wb.wb_obj);
+                radeon_bo_unpin(rdev->wb.wb_obj);
+                radeon_bo_unreserve(rdev->wb.wb_obj);
         }
 }
 
@@ -1392,7 +1732,7 @@ void r600_wb_fini(struct radeon_device *rdev)
 {
         r600_wb_disable(rdev);
         if (rdev->wb.wb_obj) {
-                radeon_object_unref(&rdev->wb.wb_obj);
+                radeon_bo_unref(&rdev->wb.wb_obj);
                 rdev->wb.wb = NULL;
                 rdev->wb.wb_obj = NULL;
         }
@@ -1403,22 +1743,29 @@ int r600_wb_enable(struct radeon_device *rdev)
         int r;
 
         if (rdev->wb.wb_obj == NULL) {
-                r = radeon_object_create(rdev, NULL, RADEON_GPU_PAGE_SIZE, true,
-                                RADEON_GEM_DOMAIN_GTT, false, &rdev->wb.wb_obj);
+                r = radeon_bo_create(rdev, NULL, RADEON_GPU_PAGE_SIZE, true,
+                                RADEON_GEM_DOMAIN_GTT, &rdev->wb.wb_obj);
                 if (r) {
-                        dev_warn(rdev->dev, "failed to create WB buffer (%d).\n", r);
+                        dev_warn(rdev->dev, "(%d) create WB bo failed\n", r);
                         return r;
                 }
-                r = radeon_object_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT,
+                r = radeon_bo_reserve(rdev->wb.wb_obj, false);
+                if (unlikely(r != 0)) {
+                        r600_wb_fini(rdev);
+                        return r;
+                }
+                r = radeon_bo_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT,
                                 &rdev->wb.gpu_addr);
                 if (r) {
-                        dev_warn(rdev->dev, "failed to pin WB buffer (%d).\n", r);
+                        radeon_bo_unreserve(rdev->wb.wb_obj);
+                        dev_warn(rdev->dev, "(%d) pin WB bo failed\n", r);
                         r600_wb_fini(rdev);
                         return r;
                 }
-                r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb);
+                r = radeon_bo_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb);
+                radeon_bo_unreserve(rdev->wb.wb_obj);
                 if (r) {
-                        dev_warn(rdev->dev, "failed to map WB buffer (%d).\n", r);
+                        dev_warn(rdev->dev, "(%d) map WB bo failed\n", r);
                         r600_wb_fini(rdev);
                         return r;
                 }
@@ -1433,10 +1780,14 @@ int r600_wb_enable(struct radeon_device *rdev)
 void r600_fence_ring_emit(struct radeon_device *rdev,
                           struct radeon_fence *fence)
 {
+        /* Also consider EVENT_WRITE_EOP.  it handles the interrupts + timestamps + events */
         /* Emit fence sequence & fire IRQ */
         radeon_ring_write(rdev, PACKET3(PACKET3_SET_CONFIG_REG, 1));
         radeon_ring_write(rdev, ((rdev->fence_drv.scratch_reg - PACKET3_SET_CONFIG_REG_OFFSET) >> 2));
         radeon_ring_write(rdev, fence->seq);
+        /* CP_INTERRUPT packet 3 no longer exists, use packet 0 */
+        radeon_ring_write(rdev, PACKET0(CP_INT_STATUS, 0));
+        radeon_ring_write(rdev, RB_INT_STAT);
 }
 
 int r600_copy_dma(struct radeon_device *rdev,
@@ -1459,18 +1810,6 @@ int r600_copy_blit(struct radeon_device *rdev,
         return 0;
 }
 
-int r600_irq_process(struct radeon_device *rdev)
-{
-        /* FIXME: implement */
-        return 0;
-}
-
-int r600_irq_set(struct radeon_device *rdev)
-{
-        /* FIXME: implement */
-        return 0;
-}
-
 int r600_set_surface_reg(struct radeon_device *rdev, int reg,
                          uint32_t tiling_flags, uint32_t pitch,
                          uint32_t offset, uint32_t obj_size)
@@ -1516,13 +1855,26 @@ int r600_startup(struct radeon_device *rdev)
         }
         r600_gpu_init(rdev);
 
-        r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
-                              &rdev->r600_blit.shader_gpu_addr);
+        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
+                        &rdev->r600_blit.shader_gpu_addr);
+        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
         if (r) {
-                DRM_ERROR("failed to pin blit object %d\n", r);
+                dev_err(rdev->dev, "(%d) pin blit object failed\n", r);
                 return r;
         }
 
+        /* Enable IRQ */
+        r = r600_irq_init(rdev);
+        if (r) {
+                DRM_ERROR("radeon: IH init failed (%d).\n", r);
+                radeon_irq_kms_fini(rdev);
+                return r;
+        }
+        r600_irq_set(rdev);
+
         r = radeon_ring_init(rdev, rdev->cp.ring_size);
         if (r)
                 return r;
@@ -1583,13 +1935,19 @@ int r600_resume(struct radeon_device *rdev)
 
 int r600_suspend(struct radeon_device *rdev)
 {
+        int r;
+
         /* FIXME: we should wait for ring to be empty */
         r600_cp_stop(rdev);
         rdev->cp.ready = false;
         r600_wb_disable(rdev);
         r600_pcie_gart_disable(rdev);
         /* unpin shaders bo */
-        radeon_object_unpin(rdev->r600_blit.shader_obj);
+        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+        if (unlikely(r != 0))
+                return r;
+        radeon_bo_unpin(rdev->r600_blit.shader_obj);
+        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
         return 0;
 }
 
@@ -1627,7 +1985,11 @@ int r600_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Post card if necessary */
-        if (!r600_card_posted(rdev) && rdev->bios) {
+        if (!r600_card_posted(rdev)) {
+                if (!rdev->bios) {
+                        dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n");
+                        return -EINVAL;
+                }
                 DRM_INFO("GPU not posted. posting now...\n");
                 atom_asic_init(rdev->mode_info.atom_context);
         }
@@ -1650,14 +2012,22 @@ int r600_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
+        if (r)
+                return r;
+
+        r = radeon_irq_kms_init(rdev);
         if (r)
                 return r;
+
         rdev->cp.ring_obj = NULL;
         r600_ring_init(rdev, 1024 * 1024);
 
-        if (!rdev->me_fw || !rdev->pfp_fw) {
-                r = r600_cp_init_microcode(rdev);
+        rdev->ih.ring_obj = NULL;
+        r600_ih_ring_init(rdev, 64 * 1024);
+
+        if (!rdev->me_fw || !rdev->pfp_fw || !rdev->rlc_fw) {
+                r = r600_init_microcode(rdev);
                 if (r) {
                         DRM_ERROR("Failed to load firmware!\n");
                         return r;
@@ -1704,6 +2074,8 @@ void r600_fini(struct radeon_device *rdev)
         r600_suspend(rdev);
 
         r600_blit_fini(rdev);
+        r600_irq_fini(rdev);
+        radeon_irq_kms_fini(rdev);
         radeon_ring_fini(rdev);
         r600_wb_fini(rdev);
         r600_pcie_gart_fini(rdev);
@@ -1712,7 +2084,7 @@ void r600_fini(struct radeon_device *rdev)
         radeon_clocks_fini(rdev);
         if (rdev->flags & RADEON_IS_AGP)
                 radeon_agp_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -1798,8 +2170,657 @@ int r600_ib_test(struct radeon_device *rdev)
         return r;
 }
 
+/*
+ * Interrupts
+ *
+ * Interrupts use a ring buffer on r6xx/r7xx hardware.  It works pretty
+ * the same as the CP ring buffer, but in reverse.  Rather than the CPU
+ * writing to the ring and the GPU consuming, the GPU writes to the ring
+ * and host consumes.  As the host irq handler processes interrupts, it
+ * increments the rptr.  When the rptr catches up with the wptr, all the
+ * current interrupts have been processed.
+ */
+
+void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size)
+{
+        u32 rb_bufsz;
+
+        /* Align ring size */
+        rb_bufsz = drm_order(ring_size / 4);
+        ring_size = (1 << rb_bufsz) * 4;
+        rdev->ih.ring_size = ring_size;
+        rdev->ih.align_mask = 4 - 1;
+}
+
+static int r600_ih_ring_alloc(struct radeon_device *rdev, unsigned ring_size)
+{
+        int r;
+
+        rdev->ih.ring_size = ring_size;
+        /* Allocate ring buffer */
+        if (rdev->ih.ring_obj == NULL) {
+                r = radeon_bo_create(rdev, NULL, rdev->ih.ring_size,
+                                     true,
+                                     RADEON_GEM_DOMAIN_GTT,
+                                     &rdev->ih.ring_obj);
+                if (r) {
+                        DRM_ERROR("radeon: failed to create ih ring buffer (%d).\n", r);
+                        return r;
+                }
+                r = radeon_bo_reserve(rdev->ih.ring_obj, false);
+                if (unlikely(r != 0))
+                        return r;
+                r = radeon_bo_pin(rdev->ih.ring_obj,
+                                  RADEON_GEM_DOMAIN_GTT,
+                                  &rdev->ih.gpu_addr);
+                if (r) {
+                        radeon_bo_unreserve(rdev->ih.ring_obj);
+                        DRM_ERROR("radeon: failed to pin ih ring buffer (%d).\n", r);
+                        return r;
+                }
+                r = radeon_bo_kmap(rdev->ih.ring_obj,
+                                   (void **)&rdev->ih.ring);
+                radeon_bo_unreserve(rdev->ih.ring_obj);
+                if (r) {
+                        DRM_ERROR("radeon: failed to map ih ring buffer (%d).\n", r);
+                        return r;
+                }
+        }
+        rdev->ih.ptr_mask = (rdev->cp.ring_size / 4) - 1;
+        rdev->ih.rptr = 0;
+
+        return 0;
+}
+
+static void r600_ih_ring_fini(struct radeon_device *rdev)
+{
+        int r;
+        if (rdev->ih.ring_obj) {
+                r = radeon_bo_reserve(rdev->ih.ring_obj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rdev->ih.ring_obj);
+                        radeon_bo_unpin(rdev->ih.ring_obj);
+                        radeon_bo_unreserve(rdev->ih.ring_obj);
+                }
+                radeon_bo_unref(&rdev->ih.ring_obj);
+                rdev->ih.ring = NULL;
+                rdev->ih.ring_obj = NULL;
+        }
+}
+
+static void r600_rlc_stop(struct radeon_device *rdev)
+{
+
+        if (rdev->family >= CHIP_RV770) {
+                /* r7xx asics need to soft reset RLC before halting */
+                WREG32(SRBM_SOFT_RESET, SOFT_RESET_RLC);
+                RREG32(SRBM_SOFT_RESET);
+                udelay(15000);
+                WREG32(SRBM_SOFT_RESET, 0);
+                RREG32(SRBM_SOFT_RESET);
+        }
+
+        WREG32(RLC_CNTL, 0);
+}
+
+static void r600_rlc_start(struct radeon_device *rdev)
+{
+        WREG32(RLC_CNTL, RLC_ENABLE);
+}
+
+static int r600_rlc_init(struct radeon_device *rdev)
+{
+        u32 i;
+        const __be32 *fw_data;
+
+        if (!rdev->rlc_fw)
+                return -EINVAL;
+
+        r600_rlc_stop(rdev);
+
+        WREG32(RLC_HB_BASE, 0);
+        WREG32(RLC_HB_CNTL, 0);
+        WREG32(RLC_HB_RPTR, 0);
+        WREG32(RLC_HB_WPTR, 0);
+        WREG32(RLC_HB_WPTR_LSB_ADDR, 0);
+        WREG32(RLC_HB_WPTR_MSB_ADDR, 0);
+        WREG32(RLC_MC_CNTL, 0);
+        WREG32(RLC_UCODE_CNTL, 0);
+
+        fw_data = (const __be32 *)rdev->rlc_fw->data;
+        if (rdev->family >= CHIP_RV770) {
+                for (i = 0; i < R700_RLC_UCODE_SIZE; i++) {
+                        WREG32(RLC_UCODE_ADDR, i);
+                        WREG32(RLC_UCODE_DATA, be32_to_cpup(fw_data++));
+                }
+        } else {
+                for (i = 0; i < RLC_UCODE_SIZE; i++) {
+                        WREG32(RLC_UCODE_ADDR, i);
+                        WREG32(RLC_UCODE_DATA, be32_to_cpup(fw_data++));
+                }
+        }
+        WREG32(RLC_UCODE_ADDR, 0);
+
+        r600_rlc_start(rdev);
+
+        return 0;
+}
+
+static void r600_enable_interrupts(struct radeon_device *rdev)
+{
+        u32 ih_cntl = RREG32(IH_CNTL);
+        u32 ih_rb_cntl = RREG32(IH_RB_CNTL);
+
+        ih_cntl |= ENABLE_INTR;
+        ih_rb_cntl |= IH_RB_ENABLE;
+        WREG32(IH_CNTL, ih_cntl);
+        WREG32(IH_RB_CNTL, ih_rb_cntl);
+        rdev->ih.enabled = true;
+}
+
+static void r600_disable_interrupts(struct radeon_device *rdev)
+{
+        u32 ih_rb_cntl = RREG32(IH_RB_CNTL);
+        u32 ih_cntl = RREG32(IH_CNTL);
+
+        ih_rb_cntl &= ~IH_RB_ENABLE;
+        ih_cntl &= ~ENABLE_INTR;
+        WREG32(IH_RB_CNTL, ih_rb_cntl);
+        WREG32(IH_CNTL, ih_cntl);
+        /* set rptr, wptr to 0 */
+        WREG32(IH_RB_RPTR, 0);
+        WREG32(IH_RB_WPTR, 0);
+        rdev->ih.enabled = false;
+        rdev->ih.wptr = 0;
+        rdev->ih.rptr = 0;
+}
+
+static void r600_disable_interrupt_state(struct radeon_device *rdev)
+{
+        u32 tmp;
+
+        WREG32(CP_INT_CNTL, 0);
+        WREG32(GRBM_INT_CNTL, 0);
+        WREG32(DxMODE_INT_MASK, 0);
+        if (ASIC_IS_DCE3(rdev)) {
+                WREG32(DCE3_DACA_AUTODETECT_INT_CONTROL, 0);
+                WREG32(DCE3_DACB_AUTODETECT_INT_CONTROL, 0);
+                tmp = RREG32(DC_HPD1_INT_CONTROL) & DC_HPDx_INT_POLARITY;
+                WREG32(DC_HPD1_INT_CONTROL, tmp);
+                tmp = RREG32(DC_HPD2_INT_CONTROL) & DC_HPDx_INT_POLARITY;
+                WREG32(DC_HPD2_INT_CONTROL, tmp);
+                tmp = RREG32(DC_HPD3_INT_CONTROL) & DC_HPDx_INT_POLARITY;
+                WREG32(DC_HPD3_INT_CONTROL, tmp);
+                tmp = RREG32(DC_HPD4_INT_CONTROL) & DC_HPDx_INT_POLARITY;
+                WREG32(DC_HPD4_INT_CONTROL, tmp);
+                if (ASIC_IS_DCE32(rdev)) {
+                        tmp = RREG32(DC_HPD5_INT_CONTROL) & DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD5_INT_CONTROL, 0);
+                        tmp = RREG32(DC_HPD6_INT_CONTROL) & DC_HPDx_INT_POLARITY;
+                        WREG32(DC_HPD6_INT_CONTROL, 0);
+                }
+        } else {
+                WREG32(DACA_AUTODETECT_INT_CONTROL, 0);
+                WREG32(DACB_AUTODETECT_INT_CONTROL, 0);
+                tmp = RREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL) & DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                WREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL, 0);
+                tmp = RREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL) & DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                WREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL, 0);
+                tmp = RREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL) & DC_HOT_PLUG_DETECTx_INT_POLARITY;
+                WREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL, 0);
+        }
+}
+
+int r600_irq_init(struct radeon_device *rdev)
+{
+        int ret = 0;
+        int rb_bufsz;
+        u32 interrupt_cntl, ih_cntl, ih_rb_cntl;
+
+        /* allocate ring */
+        ret = r600_ih_ring_alloc(rdev, rdev->ih.ring_size);
+        if (ret)
+                return ret;
+
+        /* disable irqs */
+        r600_disable_interrupts(rdev);
+
+        /* init rlc */
+        ret = r600_rlc_init(rdev);
+        if (ret) {
+                r600_ih_ring_fini(rdev);
+                return ret;
+        }
+
+        /* setup interrupt control */
+        /* set dummy read address to ring address */
+        WREG32(INTERRUPT_CNTL2, rdev->ih.gpu_addr >> 8);
+        interrupt_cntl = RREG32(INTERRUPT_CNTL);
+        /* IH_DUMMY_RD_OVERRIDE=0 - dummy read disabled with msi, enabled without msi
+         * IH_DUMMY_RD_OVERRIDE=1 - dummy read controlled by IH_DUMMY_RD_EN
+         */
+        interrupt_cntl &= ~IH_DUMMY_RD_OVERRIDE;
+        /* IH_REQ_NONSNOOP_EN=1 if ring is in non-cacheable memory, e.g., vram */
+        interrupt_cntl &= ~IH_REQ_NONSNOOP_EN;
+        WREG32(INTERRUPT_CNTL, interrupt_cntl);
+
+        WREG32(IH_RB_BASE, rdev->ih.gpu_addr >> 8);
+        rb_bufsz = drm_order(rdev->ih.ring_size / 4);
+
+        ih_rb_cntl = (IH_WPTR_OVERFLOW_ENABLE |
+                      IH_WPTR_OVERFLOW_CLEAR |
+                      (rb_bufsz << 1));
+        /* WPTR writeback, not yet */
+        /*ih_rb_cntl |= IH_WPTR_WRITEBACK_ENABLE;*/
+        WREG32(IH_RB_WPTR_ADDR_LO, 0);
+        WREG32(IH_RB_WPTR_ADDR_HI, 0);
+
+        WREG32(IH_RB_CNTL, ih_rb_cntl);
+
+        /* set rptr, wptr to 0 */
+        WREG32(IH_RB_RPTR, 0);
+        WREG32(IH_RB_WPTR, 0);
+
+        /* Default settings for IH_CNTL (disabled at first) */
+        ih_cntl = MC_WRREQ_CREDIT(0x10) | MC_WR_CLEAN_CNT(0x10);
+        /* RPTR_REARM only works if msi's are enabled */
+        if (rdev->msi_enabled)
+                ih_cntl |= RPTR_REARM;
+
+#ifdef __BIG_ENDIAN
+        ih_cntl |= IH_MC_SWAP(IH_MC_SWAP_32BIT);
+#endif
+        WREG32(IH_CNTL, ih_cntl);
+
+        /* force the active interrupt state to all disabled */
+        r600_disable_interrupt_state(rdev);
+
+        /* enable irqs */
+        r600_enable_interrupts(rdev);
+
+        return ret;
+}
+
+void r600_irq_fini(struct radeon_device *rdev)
+{
+        r600_disable_interrupts(rdev);
+        r600_rlc_stop(rdev);
+        r600_ih_ring_fini(rdev);
+}
+
+int r600_irq_set(struct radeon_device *rdev)
+{
+        u32 cp_int_cntl = CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE;
+        u32 mode_int = 0;
+        u32 hpd1, hpd2, hpd3, hpd4 = 0, hpd5 = 0, hpd6 = 0;
+
+        /* don't enable anything if the ih is disabled */
+        if (!rdev->ih.enabled)
+                return 0;
+
+        if (ASIC_IS_DCE3(rdev)) {
+                hpd1 = RREG32(DC_HPD1_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                hpd2 = RREG32(DC_HPD2_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                hpd3 = RREG32(DC_HPD3_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                hpd4 = RREG32(DC_HPD4_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                if (ASIC_IS_DCE32(rdev)) {
+                        hpd5 = RREG32(DC_HPD5_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                        hpd6 = RREG32(DC_HPD6_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                }
+        } else {
+                hpd1 = RREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                hpd2 = RREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL) & ~DC_HPDx_INT_EN;
+                hpd3 = RREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL) & ~DC_HPDx_INT_EN;
+        }
+
+        if (rdev->irq.sw_int) {
+                DRM_DEBUG("r600_irq_set: sw int\n");
+                cp_int_cntl |= RB_INT_ENABLE;
+        }
+        if (rdev->irq.crtc_vblank_int[0]) {
+                DRM_DEBUG("r600_irq_set: vblank 0\n");
+                mode_int |= D1MODE_VBLANK_INT_MASK;
+        }
+        if (rdev->irq.crtc_vblank_int[1]) {
+                DRM_DEBUG("r600_irq_set: vblank 1\n");
+                mode_int |= D2MODE_VBLANK_INT_MASK;
+        }
+        if (rdev->irq.hpd[0]) {
+                DRM_DEBUG("r600_irq_set: hpd 1\n");
+                hpd1 |= DC_HPDx_INT_EN;
+        }
+        if (rdev->irq.hpd[1]) {
+                DRM_DEBUG("r600_irq_set: hpd 2\n");
+                hpd2 |= DC_HPDx_INT_EN;
+        }
+        if (rdev->irq.hpd[2]) {
+                DRM_DEBUG("r600_irq_set: hpd 3\n");
+                hpd3 |= DC_HPDx_INT_EN;
+        }
+        if (rdev->irq.hpd[3]) {
+                DRM_DEBUG("r600_irq_set: hpd 4\n");
+                hpd4 |= DC_HPDx_INT_EN;
+        }
+        if (rdev->irq.hpd[4]) {
+                DRM_DEBUG("r600_irq_set: hpd 5\n");
+                hpd5 |= DC_HPDx_INT_EN;
+        }
+        if (rdev->irq.hpd[5]) {
+                DRM_DEBUG("r600_irq_set: hpd 6\n");
+                hpd6 |= DC_HPDx_INT_EN;
+        }
+
+        WREG32(CP_INT_CNTL, cp_int_cntl);
+        WREG32(DxMODE_INT_MASK, mode_int);
+        if (ASIC_IS_DCE3(rdev)) {
+                WREG32(DC_HPD1_INT_CONTROL, hpd1);
+                WREG32(DC_HPD2_INT_CONTROL, hpd2);
+                WREG32(DC_HPD3_INT_CONTROL, hpd3);
+                WREG32(DC_HPD4_INT_CONTROL, hpd4);
+                if (ASIC_IS_DCE32(rdev)) {
+                        WREG32(DC_HPD5_INT_CONTROL, hpd5);
+                        WREG32(DC_HPD6_INT_CONTROL, hpd6);
+                }
+        } else {
+                WREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL, hpd1);
+                WREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL, hpd2);
+                WREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL, hpd3);
+        }
+
+        return 0;
+}
 
+static inline void r600_irq_ack(struct radeon_device *rdev,
+                                u32 *disp_int,
+                                u32 *disp_int_cont,
+                                u32 *disp_int_cont2)
+{
+        u32 tmp;
 
+        if (ASIC_IS_DCE3(rdev)) {
+                *disp_int = RREG32(DCE3_DISP_INTERRUPT_STATUS);
+                *disp_int_cont = RREG32(DCE3_DISP_INTERRUPT_STATUS_CONTINUE);
+                *disp_int_cont2 = RREG32(DCE3_DISP_INTERRUPT_STATUS_CONTINUE2);
+        } else {
+                *disp_int = RREG32(DISP_INTERRUPT_STATUS);
+                *disp_int_cont = RREG32(DISP_INTERRUPT_STATUS_CONTINUE);
+                *disp_int_cont2 = 0;
+        }
+
+        if (*disp_int & LB_D1_VBLANK_INTERRUPT)
+                WREG32(D1MODE_VBLANK_STATUS, DxMODE_VBLANK_ACK);
+        if (*disp_int & LB_D1_VLINE_INTERRUPT)
+                WREG32(D1MODE_VLINE_STATUS, DxMODE_VLINE_ACK);
+        if (*disp_int & LB_D2_VBLANK_INTERRUPT)
+                WREG32(D2MODE_VBLANK_STATUS, DxMODE_VBLANK_ACK);
+        if (*disp_int & LB_D2_VLINE_INTERRUPT)
+                WREG32(D2MODE_VLINE_STATUS, DxMODE_VLINE_ACK);
+        if (*disp_int & DC_HPD1_INTERRUPT) {
+                if (ASIC_IS_DCE3(rdev)) {
+                        tmp = RREG32(DC_HPD1_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HPD1_INT_CONTROL, tmp);
+                } else {
+                        tmp = RREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HOT_PLUG_DETECT1_INT_CONTROL, tmp);
+                }
+        }
+        if (*disp_int & DC_HPD2_INTERRUPT) {
+                if (ASIC_IS_DCE3(rdev)) {
+                        tmp = RREG32(DC_HPD2_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HPD2_INT_CONTROL, tmp);
+                } else {
+                        tmp = RREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HOT_PLUG_DETECT2_INT_CONTROL, tmp);
+                }
+        }
+        if (*disp_int_cont & DC_HPD3_INTERRUPT) {
+                if (ASIC_IS_DCE3(rdev)) {
+                        tmp = RREG32(DC_HPD3_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HPD3_INT_CONTROL, tmp);
+                } else {
+                        tmp = RREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HOT_PLUG_DETECT3_INT_CONTROL, tmp);
+                }
+        }
+        if (*disp_int_cont & DC_HPD4_INTERRUPT) {
+                tmp = RREG32(DC_HPD4_INT_CONTROL);
+                tmp |= DC_HPDx_INT_ACK;
+                WREG32(DC_HPD4_INT_CONTROL, tmp);
+        }
+        if (ASIC_IS_DCE32(rdev)) {
+                if (*disp_int_cont2 & DC_HPD5_INTERRUPT) {
+                        tmp = RREG32(DC_HPD5_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HPD5_INT_CONTROL, tmp);
+                }
+                if (*disp_int_cont2 & DC_HPD6_INTERRUPT) {
+                        tmp = RREG32(DC_HPD5_INT_CONTROL);
+                        tmp |= DC_HPDx_INT_ACK;
+                        WREG32(DC_HPD6_INT_CONTROL, tmp);
+                }
+        }
+}
+
+void r600_irq_disable(struct radeon_device *rdev)
+{
+        u32 disp_int, disp_int_cont, disp_int_cont2;
+
+        r600_disable_interrupts(rdev);
+        /* Wait and acknowledge irq */
+        mdelay(1);
+        r600_irq_ack(rdev, &disp_int, &disp_int_cont, &disp_int_cont2);
+        r600_disable_interrupt_state(rdev);
+}
+
+static inline u32 r600_get_ih_wptr(struct radeon_device *rdev)
+{
+        u32 wptr, tmp;
+
+        /* XXX use writeback */
+        wptr = RREG32(IH_RB_WPTR);
+
+        if (wptr & RB_OVERFLOW) {
+                WARN_ON(1);
+                /* XXX deal with overflow */
+                DRM_ERROR("IH RB overflow\n");
+                tmp = RREG32(IH_RB_CNTL);
+                tmp |= IH_WPTR_OVERFLOW_CLEAR;
+                WREG32(IH_RB_CNTL, tmp);
+        }
+        wptr = wptr & WPTR_OFFSET_MASK;
+
+        return wptr;
+}
+
+/*        r600 IV Ring
+ * Each IV ring entry is 128 bits:
+ * [7:0]    - interrupt source id
+ * [31:8]   - reserved
+ * [59:32]  - interrupt source data
+ * [127:60]  - reserved
+ *
+ * The basic interrupt vector entries
+ * are decoded as follows:
+ * src_id  src_data  description
+ *      1         0  D1 Vblank
+ *      1         1  D1 Vline
+ *      5         0  D2 Vblank
+ *      5         1  D2 Vline
+ *     19         0  FP Hot plug detection A
+ *     19         1  FP Hot plug detection B
+ *     19         2  DAC A auto-detection
+ *     19         3  DAC B auto-detection
+ *    176         -  CP_INT RB
+ *    177         -  CP_INT IB1
+ *    178         -  CP_INT IB2
+ *    181         -  EOP Interrupt
+ *    233         -  GUI Idle
+ *
+ * Note, these are based on r600 and may need to be
+ * adjusted or added to on newer asics
+ */
+
+int r600_irq_process(struct radeon_device *rdev)
+{
+        u32 wptr = r600_get_ih_wptr(rdev);
+        u32 rptr = rdev->ih.rptr;
+        u32 src_id, src_data;
+        u32 last_entry = rdev->ih.ring_size - 16;
+        u32 ring_index, disp_int, disp_int_cont, disp_int_cont2;
+        unsigned long flags;
+        bool queue_hotplug = false;
+
+        DRM_DEBUG("r600_irq_process start: rptr %d, wptr %d\n", rptr, wptr);
+
+        spin_lock_irqsave(&rdev->ih.lock, flags);
+
+        if (rptr == wptr) {
+                spin_unlock_irqrestore(&rdev->ih.lock, flags);
+                return IRQ_NONE;
+        }
+        if (rdev->shutdown) {
+                spin_unlock_irqrestore(&rdev->ih.lock, flags);
+                return IRQ_NONE;
+        }
+
+restart_ih:
+        /* display interrupts */
+        r600_irq_ack(rdev, &disp_int, &disp_int_cont, &disp_int_cont2);
+
+        rdev->ih.wptr = wptr;
+        while (rptr != wptr) {
+                /* wptr/rptr are in bytes! */
+                ring_index = rptr / 4;
+                src_id =  rdev->ih.ring[ring_index] & 0xff;
+                src_data = rdev->ih.ring[ring_index + 1] & 0xfffffff;
+
+                switch (src_id) {
+                case 1: /* D1 vblank/vline */
+                        switch (src_data) {
+                        case 0: /* D1 vblank */
+                                if (disp_int & LB_D1_VBLANK_INTERRUPT) {
+                                        drm_handle_vblank(rdev->ddev, 0);
+                                        disp_int &= ~LB_D1_VBLANK_INTERRUPT;
+                                        DRM_DEBUG("IH: D1 vblank\n");
+                                }
+                                break;
+                        case 1: /* D1 vline */
+                                if (disp_int & LB_D1_VLINE_INTERRUPT) {
+                                        disp_int &= ~LB_D1_VLINE_INTERRUPT;
+                                        DRM_DEBUG("IH: D1 vline\n");
+                                }
+                                break;
+                        default:
+                                DRM_ERROR("Unhandled interrupt: %d %d\n", src_id, src_data);
+                                break;
+                        }
+                        break;
+                case 5: /* D2 vblank/vline */
+                        switch (src_data) {
+                        case 0: /* D2 vblank */
+                                if (disp_int & LB_D2_VBLANK_INTERRUPT) {
+                                        drm_handle_vblank(rdev->ddev, 1);
+                                        disp_int &= ~LB_D2_VBLANK_INTERRUPT;
+                                        DRM_DEBUG("IH: D2 vblank\n");
+                                }
+                                break;
+                        case 1: /* D1 vline */
+                                if (disp_int & LB_D2_VLINE_INTERRUPT) {
+                                        disp_int &= ~LB_D2_VLINE_INTERRUPT;
+                                        DRM_DEBUG("IH: D2 vline\n");
+                                }
+                                break;
+                        default:
+                                DRM_ERROR("Unhandled interrupt: %d %d\n", src_id, src_data);
+                                break;
+                        }
+                        break;
+                case 19: /* HPD/DAC hotplug */
+                        switch (src_data) {
+                        case 0:
+                                if (disp_int & DC_HPD1_INTERRUPT) {
+                                        disp_int &= ~DC_HPD1_INTERRUPT;
+                                        queue_hotplug = true;
+                                        DRM_DEBUG("IH: HPD1\n");
+                                }
+                                break;
+                        case 1:
+                                if (disp_int & DC_HPD2_INTERRUPT) {
+                                        disp_int &= ~DC_HPD2_INTERRUPT;
+                                        queue_hotplug = true;
+                                        DRM_DEBUG("IH: HPD2\n");
+                                }
+                                break;
+                        case 4:
+                                if (disp_int_cont & DC_HPD3_INTERRUPT) {
+                                        disp_int_cont &= ~DC_HPD3_INTERRUPT;
+                                        queue_hotplug = true;
+                                        DRM_DEBUG("IH: HPD3\n");
+                                }
+                                break;
+                        case 5:
+                                if (disp_int_cont & DC_HPD4_INTERRUPT) {
+                                        disp_int_cont &= ~DC_HPD4_INTERRUPT;
+                                        queue_hotplug = true;
+                                        DRM_DEBUG("IH: HPD4\n");
+                                }
+                                break;
+                        case 10:
+                                if (disp_int_cont2 & DC_HPD5_INTERRUPT) {
+                                        disp_int_cont &= ~DC_HPD5_INTERRUPT;
+                                        queue_hotplug = true;
+                                        DRM_DEBUG("IH: HPD5\n");
+                                }
+                                break;
+                        case 12:
+                                if (disp_int_cont2 & DC_HPD6_INTERRUPT) {
+                                        disp_int_cont &= ~DC_HPD6_INTERRUPT;
+                                        queue_hotplug = true;
+                                        DRM_DEBUG("IH: HPD6\n");
+                                }
+                                break;
+                        default:
+                                DRM_ERROR("Unhandled interrupt: %d %d\n", src_id, src_data);
+                                break;
+                        }
+                        break;
+                case 176: /* CP_INT in ring buffer */
+                case 177: /* CP_INT in IB1 */
+                case 178: /* CP_INT in IB2 */
+                        DRM_DEBUG("IH: CP int: 0x%08x\n", src_data);
+                        radeon_fence_process(rdev);
+                        break;
+                case 181: /* CP EOP event */
+                        DRM_DEBUG("IH: CP EOP\n");
+                        break;
+                default:
+                        DRM_ERROR("Unhandled interrupt: %d %d\n", src_id, src_data);
+                        break;
+                }
+
+                /* wptr/rptr are in bytes! */
+                if (rptr == last_entry)
+                        rptr = 0;
+                else
+                        rptr += 16;
+        }
+        /* make sure wptr hasn't changed while processing */
+        wptr = r600_get_ih_wptr(rdev);
+        if (wptr != rdev->ih.wptr)
+                goto restart_ih;
+        if (queue_hotplug)
+                queue_work(rdev->wq, &rdev->hotplug_work);
+        rdev->ih.rptr = rptr;
+        WREG32(IH_RB_RPTR, rdev->ih.rptr);
+        spin_unlock_irqrestore(&rdev->ih.lock, flags);
+        return IRQ_HANDLED;
+}
 
 /*
  * Debugfs info
@@ -1811,21 +2832,21 @@ static int r600_debugfs_cp_ring_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;
         struct radeon_device *rdev = dev->dev_private;
-        uint32_t rdp, wdp;
         unsigned count, i, j;
 
         radeon_ring_free_size(rdev);
-        rdp = RREG32(CP_RB_RPTR);
-        wdp = RREG32(CP_RB_WPTR);
-        count = (rdp + rdev->cp.ring_size - wdp) & rdev->cp.ptr_mask;
+        count = (rdev->cp.ring_size / 4) - rdev->cp.ring_free_dw;
         seq_printf(m, "CP_STAT 0x%08x\n", RREG32(CP_STAT));
-        seq_printf(m, "CP_RB_WPTR 0x%08x\n", wdp);
-        seq_printf(m, "CP_RB_RPTR 0x%08x\n", rdp);
+        seq_printf(m, "CP_RB_WPTR 0x%08x\n", RREG32(CP_RB_WPTR));
+        seq_printf(m, "CP_RB_RPTR 0x%08x\n", RREG32(CP_RB_RPTR));
+        seq_printf(m, "driver's copy of the CP_RB_WPTR 0x%08x\n", rdev->cp.wptr);
+        seq_printf(m, "driver's copy of the CP_RB_RPTR 0x%08x\n", rdev->cp.rptr);
         seq_printf(m, "%u free dwords in ring\n", rdev->cp.ring_free_dw);
         seq_printf(m, "%u dwords in ring\n", count);
+        i = rdev->cp.rptr;
         for (j = 0; j <= count; j++) {
-                i = (rdp + j) & rdev->cp.ptr_mask;
                 seq_printf(m, "r[%04d]=0x%08x\n", i, rdev->cp.ring[i]);
+                i = (i + 1) & rdev->cp.ptr_mask;
         }
         return 0;
 }
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c
index dbf716e1fbf3..9aecafb51b66 100644
--- a/drivers/gpu/drm/radeon/r600_blit_kms.c
+++ b/drivers/gpu/drm/radeon/r600_blit_kms.c
@@ -473,9 +473,8 @@ int r600_blit_init(struct radeon_device *rdev)
         obj_size += r6xx_ps_size * 4;
         obj_size = ALIGN(obj_size, 256);
 
-        r = radeon_object_create(rdev, NULL, obj_size,
-                                 true, RADEON_GEM_DOMAIN_VRAM,
-                                 false, &rdev->r600_blit.shader_obj);
+        r = radeon_bo_create(rdev, NULL, obj_size, true, RADEON_GEM_DOMAIN_VRAM,
+                                &rdev->r600_blit.shader_obj);
         if (r) {
                 DRM_ERROR("r600 failed to allocate shader\n");
                 return r;
@@ -485,12 +484,14 @@ int r600_blit_init(struct radeon_device *rdev)
                   obj_size,
                   rdev->r600_blit.vs_offset, rdev->r600_blit.ps_offset);
 
-        r = radeon_object_kmap(rdev->r600_blit.shader_obj, &ptr);
+        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_kmap(rdev->r600_blit.shader_obj, &ptr);
         if (r) {
                 DRM_ERROR("failed to map blit object %d\n", r);
                 return r;
         }
-
         if (rdev->family >= CHIP_RV770)
                 memcpy_toio(ptr + rdev->r600_blit.state_offset,
                             r7xx_default_state, rdev->r600_blit.state_len * 4);
@@ -500,19 +501,26 @@ int r600_blit_init(struct radeon_device *rdev)
         if (num_packet2s)
                 memcpy_toio(ptr + rdev->r600_blit.state_offset + (rdev->r600_blit.state_len * 4),
                             packet2s, num_packet2s * 4);
-
-
         memcpy(ptr + rdev->r600_blit.vs_offset, r6xx_vs, r6xx_vs_size * 4);
         memcpy(ptr + rdev->r600_blit.ps_offset, r6xx_ps, r6xx_ps_size * 4);
-
-        radeon_object_kunmap(rdev->r600_blit.shader_obj);
+        radeon_bo_kunmap(rdev->r600_blit.shader_obj);
+        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
         return 0;
 }
 
 void r600_blit_fini(struct radeon_device *rdev)
 {
-        radeon_object_unpin(rdev->r600_blit.shader_obj);
-        radeon_object_unref(&rdev->r600_blit.shader_obj);
+        int r;
+
+        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+        if (unlikely(r != 0)) {
+                dev_err(rdev->dev, "(%d) can't finish r600 blit\n", r);
+                goto out_unref;
+        }
+        radeon_bo_unpin(rdev->r600_blit.shader_obj);
+        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+out_unref:
+        radeon_bo_unref(&rdev->r600_blit.shader_obj);
 }
 
 int r600_vb_ib_get(struct radeon_device *rdev)
@@ -569,9 +577,9 @@ int r600_blit_prepare_copy(struct radeon_device *rdev, int size_bytes)
         ring_size = num_loops * dwords_per_loop;
         /* set default  + shaders */
         ring_size += 40; /* shaders + def state */
-        ring_size += 3; /* fence emit for VB IB */
+        ring_size += 5; /* fence emit for VB IB */
         ring_size += 5; /* done copy */
-        ring_size += 3; /* fence emit for done copy */
+        ring_size += 5; /* fence emit for done copy */
         r = radeon_ring_lock(rdev, ring_size);
         WARN_ON(r);
 
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index 17e42195c632..0d820764f340 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -466,6 +466,23 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                 for (i = 0; i < pkt->count; i++) {
                         reg = start_reg + (4 * i);
                         switch (reg) {
+                        case SQ_ESGS_RING_BASE:
+                        case SQ_GSVS_RING_BASE:
+                        case SQ_ESTMP_RING_BASE:
+                        case SQ_GSTMP_RING_BASE:
+                        case SQ_VSTMP_RING_BASE:
+                        case SQ_PSTMP_RING_BASE:
+                        case SQ_FBUF_RING_BASE:
+                        case SQ_REDUC_RING_BASE:
+                        case SX_MEMORY_EXPORT_BASE:
+                                r = r600_cs_packet_next_reloc(p, &reloc);
+                                if (r) {
+                                        DRM_ERROR("bad SET_CONFIG_REG "
+                                                        "0x%04X\n", reg);
+                                        return -EINVAL;
+                                }
+                                ib[idx+1+i] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                break;
                         case CP_COHER_BASE:
                                 /* use PACKET3_SURFACE_SYNC */
                                 return -EINVAL;
@@ -487,6 +504,7 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                         reg = start_reg + (4 * i);
                         switch (reg) {
                         case DB_DEPTH_BASE:
+                        case DB_HTILE_DATA_BASE:
                         case CB_COLOR0_BASE:
                         case CB_COLOR1_BASE:
                         case CB_COLOR2_BASE:
diff --git a/drivers/gpu/drm/radeon/r600d.h b/drivers/gpu/drm/radeon/r600d.h
index 00d9642198a3..05894edadab4 100644
--- a/drivers/gpu/drm/radeon/r600d.h
+++ b/drivers/gpu/drm/radeon/r600d.h
@@ -119,6 +119,7 @@
 #define DB_DEBUG                                        0x9830
 #define         PREZ_MUST_WAIT_FOR_POSTZ_DONE                   (1 << 31)
 #define DB_DEPTH_BASE                                   0x2800C
+#define DB_HTILE_DATA_BASE                              0x28014
 #define DB_WATERMARKS                                   0x9838
 #define         DEPTH_FREE(x)                                   ((x) << 0)
 #define         DEPTH_FLUSH(x)                                  ((x) << 5)
@@ -171,6 +172,14 @@
 #define SQ_STACK_RESOURCE_MGMT_2                          0x8c14
 #       define NUM_GS_STACK_ENTRIES(x)                    ((x) << 0)
 #       define NUM_ES_STACK_ENTRIES(x)                    ((x) << 16)
+#define SQ_ESGS_RING_BASE                               0x8c40
+#define SQ_GSVS_RING_BASE                               0x8c48
+#define SQ_ESTMP_RING_BASE                              0x8c50
+#define SQ_GSTMP_RING_BASE                              0x8c58
+#define SQ_VSTMP_RING_BASE                              0x8c60
+#define SQ_PSTMP_RING_BASE                              0x8c68
+#define SQ_FBUF_RING_BASE                               0x8c70
+#define SQ_REDUC_RING_BASE                              0x8c78
 
 #define GRBM_CNTL                                       0x8000
 #       define GRBM_READ_TIMEOUT(x)                     ((x) << 0)
@@ -356,6 +365,7 @@
 
 
 #define SX_MISC                                         0x28350
+#define SX_MEMORY_EXPORT_BASE                           0x9010
 #define SX_DEBUG_1                                      0x9054
 #define         SMX_EVENT_RELEASE                               (1 << 0)
 #define         ENABLE_NEW_SMX_ADDRESS                          (1 << 16)
@@ -446,7 +456,215 @@
 #define         WAIT_2D_IDLECLEAN_bit                           (1 << 16)
 #define         WAIT_3D_IDLECLEAN_bit                           (1 << 17)
 
-
+#define IH_RB_CNTL                                        0x3e00
+#       define IH_RB_ENABLE                               (1 << 0)
+#       define IH_IB_SIZE(x)                              ((x) << 1) /* log2 */
+#       define IH_RB_FULL_DRAIN_ENABLE                    (1 << 6)
+#       define IH_WPTR_WRITEBACK_ENABLE                   (1 << 8)
+#       define IH_WPTR_WRITEBACK_TIMER(x)                 ((x) << 9) /* log2 */
+#       define IH_WPTR_OVERFLOW_ENABLE                    (1 << 16)
+#       define IH_WPTR_OVERFLOW_CLEAR                     (1 << 31)
+#define IH_RB_BASE                                        0x3e04
+#define IH_RB_RPTR                                        0x3e08
+#define IH_RB_WPTR                                        0x3e0c
+#       define RB_OVERFLOW                                (1 << 0)
+#       define WPTR_OFFSET_MASK                           0x3fffc
+#define IH_RB_WPTR_ADDR_HI                                0x3e10
+#define IH_RB_WPTR_ADDR_LO                                0x3e14
+#define IH_CNTL                                           0x3e18
+#       define ENABLE_INTR                                (1 << 0)
+#       define IH_MC_SWAP(x)                              ((x) << 2)
+#       define IH_MC_SWAP_NONE                            0
+#       define IH_MC_SWAP_16BIT                           1
+#       define IH_MC_SWAP_32BIT                           2
+#       define IH_MC_SWAP_64BIT                           3
+#       define RPTR_REARM                                 (1 << 4)
+#       define MC_WRREQ_CREDIT(x)                         ((x) << 15)
+#       define MC_WR_CLEAN_CNT(x)                         ((x) << 20)
+
+#define RLC_CNTL                                          0x3f00
+#       define RLC_ENABLE                                 (1 << 0)
+#define RLC_HB_BASE                                       0x3f10
+#define RLC_HB_CNTL                                       0x3f0c
+#define RLC_HB_RPTR                                       0x3f20
+#define RLC_HB_WPTR                                       0x3f1c
+#define RLC_HB_WPTR_LSB_ADDR                              0x3f14
+#define RLC_HB_WPTR_MSB_ADDR                              0x3f18
+#define RLC_MC_CNTL                                       0x3f44
+#define RLC_UCODE_CNTL                                    0x3f48
+#define RLC_UCODE_ADDR                                    0x3f2c
+#define RLC_UCODE_DATA                                    0x3f30
+
+#define SRBM_SOFT_RESET                                   0xe60
+#       define SOFT_RESET_RLC                             (1 << 13)
+
+#define CP_INT_CNTL                                       0xc124
+#       define CNTX_BUSY_INT_ENABLE                       (1 << 19)
+#       define CNTX_EMPTY_INT_ENABLE                      (1 << 20)
+#       define SCRATCH_INT_ENABLE                         (1 << 25)
+#       define TIME_STAMP_INT_ENABLE                      (1 << 26)
+#       define IB2_INT_ENABLE                             (1 << 29)
+#       define IB1_INT_ENABLE                             (1 << 30)
+#       define RB_INT_ENABLE                              (1 << 31)
+#define CP_INT_STATUS                                     0xc128
+#       define SCRATCH_INT_STAT                           (1 << 25)
+#       define TIME_STAMP_INT_STAT                        (1 << 26)
+#       define IB2_INT_STAT                               (1 << 29)
+#       define IB1_INT_STAT                               (1 << 30)
+#       define RB_INT_STAT                                (1 << 31)
+
+#define GRBM_INT_CNTL                                     0x8060
+#       define RDERR_INT_ENABLE                           (1 << 0)
+#       define WAIT_COUNT_TIMEOUT_INT_ENABLE              (1 << 1)
+#       define GUI_IDLE_INT_ENABLE                        (1 << 19)
+
+#define INTERRUPT_CNTL                                    0x5468
+#       define IH_DUMMY_RD_OVERRIDE                       (1 << 0)
+#       define IH_DUMMY_RD_EN                             (1 << 1)
+#       define IH_REQ_NONSNOOP_EN                         (1 << 3)
+#       define GEN_IH_INT_EN                              (1 << 8)
+#define INTERRUPT_CNTL2                                   0x546c
+
+#define D1MODE_VBLANK_STATUS                              0x6534
+#define D2MODE_VBLANK_STATUS                              0x6d34
+#       define DxMODE_VBLANK_OCCURRED                     (1 << 0)
+#       define DxMODE_VBLANK_ACK                          (1 << 4)
+#       define DxMODE_VBLANK_STAT                         (1 << 12)
+#       define DxMODE_VBLANK_INTERRUPT                    (1 << 16)
+#       define DxMODE_VBLANK_INTERRUPT_TYPE               (1 << 17)
+#define D1MODE_VLINE_STATUS                               0x653c
+#define D2MODE_VLINE_STATUS                               0x6d3c
+#       define DxMODE_VLINE_OCCURRED                      (1 << 0)
+#       define DxMODE_VLINE_ACK                           (1 << 4)
+#       define DxMODE_VLINE_STAT                          (1 << 12)
+#       define DxMODE_VLINE_INTERRUPT                     (1 << 16)
+#       define DxMODE_VLINE_INTERRUPT_TYPE                (1 << 17)
+#define DxMODE_INT_MASK                                   0x6540
+#       define D1MODE_VBLANK_INT_MASK                     (1 << 0)
+#       define D1MODE_VLINE_INT_MASK                      (1 << 4)
+#       define D2MODE_VBLANK_INT_MASK                     (1 << 8)
+#       define D2MODE_VLINE_INT_MASK                      (1 << 12)
+#define DCE3_DISP_INTERRUPT_STATUS                        0x7ddc
+#       define DC_HPD1_INTERRUPT                          (1 << 18)
+#       define DC_HPD2_INTERRUPT                          (1 << 19)
+#define DISP_INTERRUPT_STATUS                             0x7edc
+#       define LB_D1_VLINE_INTERRUPT                      (1 << 2)
+#       define LB_D2_VLINE_INTERRUPT                      (1 << 3)
+#       define LB_D1_VBLANK_INTERRUPT                     (1 << 4)
+#       define LB_D2_VBLANK_INTERRUPT                     (1 << 5)
+#       define DACA_AUTODETECT_INTERRUPT                  (1 << 16)
+#       define DACB_AUTODETECT_INTERRUPT                  (1 << 17)
+#       define DC_HOT_PLUG_DETECT1_INTERRUPT              (1 << 18)
+#       define DC_HOT_PLUG_DETECT2_INTERRUPT              (1 << 19)
+#       define DC_I2C_SW_DONE_INTERRUPT                   (1 << 20)
+#       define DC_I2C_HW_DONE_INTERRUPT                   (1 << 21)
+#define DISP_INTERRUPT_STATUS_CONTINUE                    0x7ee8
+#define DCE3_DISP_INTERRUPT_STATUS_CONTINUE               0x7de8
+#       define DC_HPD4_INTERRUPT                          (1 << 14)
+#       define DC_HPD4_RX_INTERRUPT                       (1 << 15)
+#       define DC_HPD3_INTERRUPT                          (1 << 28)
+#       define DC_HPD1_RX_INTERRUPT                       (1 << 29)
+#       define DC_HPD2_RX_INTERRUPT                       (1 << 30)
+#define DCE3_DISP_INTERRUPT_STATUS_CONTINUE2              0x7dec
+#       define DC_HPD3_RX_INTERRUPT                       (1 << 0)
+#       define DIGA_DP_VID_STREAM_DISABLE_INTERRUPT       (1 << 1)
+#       define DIGA_DP_STEER_FIFO_OVERFLOW_INTERRUPT      (1 << 2)
+#       define DIGB_DP_VID_STREAM_DISABLE_INTERRUPT       (1 << 3)
+#       define DIGB_DP_STEER_FIFO_OVERFLOW_INTERRUPT      (1 << 4)
+#       define AUX1_SW_DONE_INTERRUPT                     (1 << 5)
+#       define AUX1_LS_DONE_INTERRUPT                     (1 << 6)
+#       define AUX2_SW_DONE_INTERRUPT                     (1 << 7)
+#       define AUX2_LS_DONE_INTERRUPT                     (1 << 8)
+#       define AUX3_SW_DONE_INTERRUPT                     (1 << 9)
+#       define AUX3_LS_DONE_INTERRUPT                     (1 << 10)
+#       define AUX4_SW_DONE_INTERRUPT                     (1 << 11)
+#       define AUX4_LS_DONE_INTERRUPT                     (1 << 12)
+#       define DIGA_DP_FAST_TRAINING_COMPLETE_INTERRUPT   (1 << 13)
+#       define DIGB_DP_FAST_TRAINING_COMPLETE_INTERRUPT   (1 << 14)
+/* DCE 3.2 */
+#       define AUX5_SW_DONE_INTERRUPT                     (1 << 15)
+#       define AUX5_LS_DONE_INTERRUPT                     (1 << 16)
+#       define AUX6_SW_DONE_INTERRUPT                     (1 << 17)
+#       define AUX6_LS_DONE_INTERRUPT                     (1 << 18)
+#       define DC_HPD5_INTERRUPT                          (1 << 19)
+#       define DC_HPD5_RX_INTERRUPT                       (1 << 20)
+#       define DC_HPD6_INTERRUPT                          (1 << 21)
+#       define DC_HPD6_RX_INTERRUPT                       (1 << 22)
+
+#define DACA_AUTO_DETECT_CONTROL                          0x7828
+#define DACB_AUTO_DETECT_CONTROL                          0x7a28
+#define DCE3_DACA_AUTO_DETECT_CONTROL                     0x7028
+#define DCE3_DACB_AUTO_DETECT_CONTROL                     0x7128
+#       define DACx_AUTODETECT_MODE(x)                    ((x) << 0)
+#       define DACx_AUTODETECT_MODE_NONE                  0
+#       define DACx_AUTODETECT_MODE_CONNECT               1
+#       define DACx_AUTODETECT_MODE_DISCONNECT            2
+#       define DACx_AUTODETECT_FRAME_TIME_COUNTER(x)      ((x) << 8)
+/* bit 18 = R/C, 17 = G/Y, 16 = B/Comp */
+#       define DACx_AUTODETECT_CHECK_MASK(x)              ((x) << 16)
+
+#define DCE3_DACA_AUTODETECT_INT_CONTROL                  0x7038
+#define DCE3_DACB_AUTODETECT_INT_CONTROL                  0x7138
+#define DACA_AUTODETECT_INT_CONTROL                       0x7838
+#define DACB_AUTODETECT_INT_CONTROL                       0x7a38
+#       define DACx_AUTODETECT_ACK                        (1 << 0)
+#       define DACx_AUTODETECT_INT_ENABLE                 (1 << 16)
+
+#define DC_HOT_PLUG_DETECT1_CONTROL                       0x7d00
+#define DC_HOT_PLUG_DETECT2_CONTROL                       0x7d10
+#define DC_HOT_PLUG_DETECT3_CONTROL                       0x7d24
+#       define DC_HOT_PLUG_DETECTx_EN                     (1 << 0)
+
+#define DC_HOT_PLUG_DETECT1_INT_STATUS                    0x7d04
+#define DC_HOT_PLUG_DETECT2_INT_STATUS                    0x7d14
+#define DC_HOT_PLUG_DETECT3_INT_STATUS                    0x7d28
+#       define DC_HOT_PLUG_DETECTx_INT_STATUS             (1 << 0)
+#       define DC_HOT_PLUG_DETECTx_SENSE                  (1 << 1)
+
+/* DCE 3.0 */
+#define DC_HPD1_INT_STATUS                                0x7d00
+#define DC_HPD2_INT_STATUS                                0x7d0c
+#define DC_HPD3_INT_STATUS                                0x7d18
+#define DC_HPD4_INT_STATUS                                0x7d24
+/* DCE 3.2 */
+#define DC_HPD5_INT_STATUS                                0x7dc0
+#define DC_HPD6_INT_STATUS                                0x7df4
+#       define DC_HPDx_INT_STATUS                         (1 << 0)
+#       define DC_HPDx_SENSE                              (1 << 1)
+#       define DC_HPDx_RX_INT_STATUS                      (1 << 8)
+
+#define DC_HOT_PLUG_DETECT1_INT_CONTROL                   0x7d08
+#define DC_HOT_PLUG_DETECT2_INT_CONTROL                   0x7d18
+#define DC_HOT_PLUG_DETECT3_INT_CONTROL                   0x7d2c
+#       define DC_HOT_PLUG_DETECTx_INT_ACK                (1 << 0)
+#       define DC_HOT_PLUG_DETECTx_INT_POLARITY           (1 << 8)
+#       define DC_HOT_PLUG_DETECTx_INT_EN                 (1 << 16)
+/* DCE 3.0 */
+#define DC_HPD1_INT_CONTROL                               0x7d04
+#define DC_HPD2_INT_CONTROL                               0x7d10
+#define DC_HPD3_INT_CONTROL                               0x7d1c
+#define DC_HPD4_INT_CONTROL                               0x7d28
+/* DCE 3.2 */
+#define DC_HPD5_INT_CONTROL                               0x7dc4
+#define DC_HPD6_INT_CONTROL                               0x7df8
+#       define DC_HPDx_INT_ACK                            (1 << 0)
+#       define DC_HPDx_INT_POLARITY                       (1 << 8)
+#       define DC_HPDx_INT_EN                             (1 << 16)
+#       define DC_HPDx_RX_INT_ACK                         (1 << 20)
+#       define DC_HPDx_RX_INT_EN                          (1 << 24)
+
+/* DCE 3.0 */
+#define DC_HPD1_CONTROL                                   0x7d08
+#define DC_HPD2_CONTROL                                   0x7d14
+#define DC_HPD3_CONTROL                                   0x7d20
+#define DC_HPD4_CONTROL                                   0x7d2c
+/* DCE 3.2 */
+#define DC_HPD5_CONTROL                                   0x7dc8
+#define DC_HPD6_CONTROL                                   0x7dfc
+#       define DC_HPDx_CONNECTION_TIMER(x)                ((x) << 0)
+#       define DC_HPDx_RX_INT_TIMER(x)                    ((x) << 16)
+/* DCE 3.2 */
+#       define DC_HPDx_EN                                 (1 << 28)
 
 /*
  * PM4
@@ -490,7 +708,6 @@
 #define PACKET3_WAIT_REG_MEM                            0x3C
 #define PACKET3_MEM_WRITE                               0x3D
 #define PACKET3_INDIRECT_BUFFER                         0x32
-#define PACKET3_CP_INTERRUPT                            0x40
 #define PACKET3_SURFACE_SYNC                            0x43
 #              define PACKET3_CB0_DEST_BASE_ENA    (1 << 6)
 #              define PACKET3_TC_ACTION_ENA        (1 << 23)
@@ -664,4 +881,5 @@
 #define         S_000E60_SOFT_RESET_TSC(x)              (((x) & 1) << 16)
 #define         S_000E60_SOFT_RESET_VMC(x)              (((x) & 1) << 17)
 
+#define R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL           0x5480
 #endif
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 757f5cd37744..a15cf9ceb9a7 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -28,8 +28,6 @@
 #ifndef __RADEON_H__
 #define __RADEON_H__
 
-#include "radeon_object.h"
-
 /* TODO: Here are things that needs to be done :
  *      - surface allocator & initializer : (bit like scratch reg) should
  *        initialize HDP_ stuff on RS600, R600, R700 hw, well anythings
@@ -67,6 +65,11 @@
 #include <linux/list.h>
 #include <linux/kref.h>
 
+#include <ttm/ttm_bo_api.h>
+#include <ttm/ttm_bo_driver.h>
+#include <ttm/ttm_placement.h>
+#include <ttm/ttm_module.h>
+
 #include "radeon_family.h"
 #include "radeon_mode.h"
 #include "radeon_reg.h"
@@ -186,76 +189,60 @@ void radeon_fence_unref(struct radeon_fence **fence);
  * Tiling registers
  */
 struct radeon_surface_reg {
-        struct radeon_object *robj;
+        struct radeon_bo *bo;
 };
 
 #define RADEON_GEM_MAX_SURFACES 8
 
 /*
- * Radeon buffer.
+ * TTM.
  */
-struct radeon_object;
+struct radeon_mman {
+        struct ttm_bo_global_ref        bo_global_ref;
+        struct ttm_global_reference     mem_global_ref;
+        bool                            mem_global_referenced;
+        struct ttm_bo_device            bdev;
+};
+
+struct radeon_bo {
+        /* Protected by gem.mutex */
+        struct list_head                list;
+        /* Protected by tbo.reserved */
+        struct ttm_buffer_object        tbo;
+        struct ttm_bo_kmap_obj          kmap;
+        unsigned                        pin_count;
+        void                            *kptr;
+        u32                             tiling_flags;
+        u32                             pitch;
+        int                             surface_reg;
+        /* Constant after initialization */
+        struct radeon_device            *rdev;
+        struct drm_gem_object           *gobj;
+};
 
-struct radeon_object_list {
+struct radeon_bo_list {
         struct list_head        list;
-        struct radeon_object    *robj;
+        struct radeon_bo        *bo;
         uint64_t                gpu_offset;
         unsigned                rdomain;
         unsigned                wdomain;
-        uint32_t                tiling_flags;
+        u32                     tiling_flags;
 };
 
-int radeon_object_init(struct radeon_device *rdev);
-void radeon_object_fini(struct radeon_device *rdev);
-int radeon_object_create(struct radeon_device *rdev,
-                         struct drm_gem_object *gobj,
-                         unsigned long size,
-                         bool kernel,
-                         uint32_t domain,
-                         bool interruptible,
-                         struct radeon_object **robj_ptr);
-int radeon_object_kmap(struct radeon_object *robj, void **ptr);
-void radeon_object_kunmap(struct radeon_object *robj);
-void radeon_object_unref(struct radeon_object **robj);
-int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
-                      uint64_t *gpu_addr);
-void radeon_object_unpin(struct radeon_object *robj);
-int radeon_object_wait(struct radeon_object *robj);
-int radeon_object_busy_domain(struct radeon_object *robj, uint32_t *cur_placement);
-int radeon_object_evict_vram(struct radeon_device *rdev);
-int radeon_object_mmap(struct radeon_object *robj, uint64_t *offset);
-void radeon_object_force_delete(struct radeon_device *rdev);
-void radeon_object_list_add_object(struct radeon_object_list *lobj,
-                                   struct list_head *head);
-int radeon_object_list_validate(struct list_head *head, void *fence);
-void radeon_object_list_unvalidate(struct list_head *head);
-void radeon_object_list_clean(struct list_head *head);
-int radeon_object_fbdev_mmap(struct radeon_object *robj,
-                             struct vm_area_struct *vma);
-unsigned long radeon_object_size(struct radeon_object *robj);
-void radeon_object_clear_surface_reg(struct radeon_object *robj);
-int radeon_object_check_tiling(struct radeon_object *robj, bool has_moved,
-                               bool force_drop);
-void radeon_object_set_tiling_flags(struct radeon_object *robj,
-                                    uint32_t tiling_flags, uint32_t pitch);
-void radeon_object_get_tiling_flags(struct radeon_object *robj, uint32_t *tiling_flags, uint32_t *pitch);
-void radeon_bo_move_notify(struct ttm_buffer_object *bo,
-                           struct ttm_mem_reg *mem);
-void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo);
 /*
  * GEM objects.
  */
 struct radeon_gem {
+        struct mutex            mutex;
         struct list_head        objects;
 };
 
 int radeon_gem_init(struct radeon_device *rdev);
 void radeon_gem_fini(struct radeon_device *rdev);
 int radeon_gem_object_create(struct radeon_device *rdev, int size,
-                             int alignment, int initial_domain,
-                             bool discardable, bool kernel,
-                             bool interruptible,
-                             struct drm_gem_object **obj);
+                                int alignment, int initial_domain,
+                                bool discardable, bool kernel,
+                                struct drm_gem_object **obj);
 int radeon_gem_object_pin(struct drm_gem_object *obj, uint32_t pin_domain,
                           uint64_t *gpu_addr);
 void radeon_gem_object_unpin(struct drm_gem_object *obj);
@@ -271,7 +258,7 @@ struct radeon_gart_table_ram {
 };
 
 struct radeon_gart_table_vram {
-        struct radeon_object            *robj;
+        struct radeon_bo                *robj;
         volatile uint32_t               *ptr;
 };
 
@@ -352,11 +339,16 @@ struct radeon_irq {
         bool            sw_int;
         /* FIXME: use a define max crtc rather than hardcode it */
         bool            crtc_vblank_int[2];
+        /* FIXME: use defines for max hpd/dacs */
+        bool            hpd[6];
+        spinlock_t sw_lock;
+        int sw_refcount;
 };
 
 int radeon_irq_kms_init(struct radeon_device *rdev);
 void radeon_irq_kms_fini(struct radeon_device *rdev);
-
+void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev);
+void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev);
 
 /*
  * CP & ring.
@@ -376,7 +368,7 @@ struct radeon_ib {
  */
 struct radeon_ib_pool {
         struct mutex            mutex;
-        struct radeon_object    *robj;
+        struct radeon_bo        *robj;
         struct list_head        scheduled_ibs;
         struct radeon_ib        ibs[RADEON_IB_POOL_SIZE];
         bool                    ready;
@@ -384,7 +376,7 @@ struct radeon_ib_pool {
 };
 
 struct radeon_cp {
-        struct radeon_object    *ring_obj;
+        struct radeon_bo        *ring_obj;
         volatile uint32_t       *ring;
         unsigned                rptr;
         unsigned                wptr;
@@ -399,8 +391,25 @@ struct radeon_cp {
         bool                    ready;
 };
 
+/*
+ * R6xx+ IH ring
+ */
+struct r600_ih {
+        struct radeon_bo        *ring_obj;
+        volatile uint32_t       *ring;
+        unsigned                rptr;
+        unsigned                wptr;
+        unsigned                wptr_old;
+        unsigned                ring_size;
+        uint64_t                gpu_addr;
+        uint32_t                align_mask;
+        uint32_t                ptr_mask;
+        spinlock_t              lock;
+        bool                    enabled;
+};
+
 struct r600_blit {
-        struct radeon_object    *shader_obj;
+        struct radeon_bo        *shader_obj;
         u64 shader_gpu_addr;
         u32 vs_offset, ps_offset;
         u32 state_offset;
@@ -430,8 +439,8 @@ void radeon_ring_fini(struct radeon_device *rdev);
  */
 struct radeon_cs_reloc {
         struct drm_gem_object           *gobj;
-        struct radeon_object            *robj;
-        struct radeon_object_list       lobj;
+        struct radeon_bo                *robj;
+        struct radeon_bo_list           lobj;
         uint32_t                        handle;
         uint32_t                        flags;
 };
@@ -519,6 +528,7 @@ typedef int (*radeon_packet3_check_t)(struct radeon_cs_parser *p,
  * AGP
  */
 int radeon_agp_init(struct radeon_device *rdev);
+void radeon_agp_resume(struct radeon_device *rdev);
 void radeon_agp_fini(struct radeon_device *rdev);
 
 
@@ -526,7 +536,7 @@ void radeon_agp_fini(struct radeon_device *rdev);
  * Writeback
  */
 struct radeon_wb {
-        struct radeon_object    *wb_obj;
+        struct radeon_bo        *wb_obj;
         volatile uint32_t       *wb;
         uint64_t                gpu_addr;
 };
@@ -638,6 +648,11 @@ struct radeon_asic {
                                uint32_t offset, uint32_t obj_size);
         int (*clear_surface_reg)(struct radeon_device *rdev, int reg);
         void (*bandwidth_update)(struct radeon_device *rdev);
+        void (*hdp_flush)(struct radeon_device *rdev);
+        void (*hpd_init)(struct radeon_device *rdev);
+        void (*hpd_fini)(struct radeon_device *rdev);
+        bool (*hpd_sense)(struct radeon_device *rdev, enum radeon_hpd_id hpd);
+        void (*hpd_set_polarity)(struct radeon_device *rdev, enum radeon_hpd_id hpd);
 };
 
 /*
@@ -750,9 +765,9 @@ struct radeon_device {
         uint8_t                         *bios;
         bool                            is_atom_bios;
         uint16_t                        bios_header_start;
-        struct radeon_object            *stollen_vga_memory;
+        struct radeon_bo                *stollen_vga_memory;
         struct fb_info                  *fbdev_info;
-        struct radeon_object            *fbdev_robj;
+        struct radeon_bo                *fbdev_rbo;
         struct radeon_framebuffer       *fbdev_rfb;
         /* Register mmio */
         resource_size_t                 rmmio_base;
@@ -790,8 +805,12 @@ struct radeon_device {
         struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES];
         const struct firmware *me_fw;   /* all family ME firmware */
         const struct firmware *pfp_fw;  /* r6/700 PFP firmware */
+        const struct firmware *rlc_fw;  /* r6/700 RLC firmware */
         struct r600_blit r600_blit;
         int msi_enabled; /* msi enabled */
+        struct r600_ih ih; /* r6/700 interrupt ring */
+        struct workqueue_struct *wq;
+        struct work_struct hotplug_work;
 };
 
 int radeon_device_init(struct radeon_device *rdev,
@@ -828,6 +847,10 @@ static inline void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32
         }
 }
 
+/*
+ * Cast helper
+ */
+#define to_radeon_fence(p) ((struct radeon_fence *)(p))
 
 /*
  * Registers read & write functions.
@@ -964,18 +987,24 @@ static inline void radeon_ring_write(struct radeon_device *rdev, uint32_t v)
 #define radeon_get_engine_clock(rdev) (rdev)->asic->get_engine_clock((rdev))
 #define radeon_set_engine_clock(rdev, e) (rdev)->asic->set_engine_clock((rdev), (e))
 #define radeon_get_memory_clock(rdev) (rdev)->asic->get_memory_clock((rdev))
-#define radeon_set_memory_clock(rdev, e) (rdev)->asic->set_engine_clock((rdev), (e))
+#define radeon_set_memory_clock(rdev, e) (rdev)->asic->set_memory_clock((rdev), (e))
 #define radeon_set_pcie_lanes(rdev, l) (rdev)->asic->set_pcie_lanes((rdev), (l))
 #define radeon_set_clock_gating(rdev, e) (rdev)->asic->set_clock_gating((rdev), (e))
 #define radeon_set_surface_reg(rdev, r, f, p, o, s) ((rdev)->asic->set_surface_reg((rdev), (r), (f), (p), (o), (s)))
 #define radeon_clear_surface_reg(rdev, r) ((rdev)->asic->clear_surface_reg((rdev), (r)))
 #define radeon_bandwidth_update(rdev) (rdev)->asic->bandwidth_update((rdev))
+#define radeon_hdp_flush(rdev) (rdev)->asic->hdp_flush((rdev))
+#define radeon_hpd_init(rdev) (rdev)->asic->hpd_init((rdev))
+#define radeon_hpd_fini(rdev) (rdev)->asic->hpd_fini((rdev))
+#define radeon_hpd_sense(rdev, hpd) (rdev)->asic->hpd_sense((rdev), (hpd))
+#define radeon_hpd_set_polarity(rdev, hpd) (rdev)->asic->hpd_set_polarity((rdev), (hpd))
 
 /* Common functions */
 extern int radeon_gart_table_vram_pin(struct radeon_device *rdev);
 extern int radeon_modeset_init(struct radeon_device *rdev);
 extern void radeon_modeset_fini(struct radeon_device *rdev);
 extern bool radeon_card_posted(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);
@@ -1020,7 +1049,7 @@ extern int r100_cp_reset(struct radeon_device *rdev);
 extern void r100_vga_render_disable(struct radeon_device *rdev);
 extern int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p,
                                                 struct radeon_cs_packet *pkt,
-                                                struct radeon_object *robj);
+                                                struct radeon_bo *robj);
 extern int r100_cs_parse_packet0(struct radeon_cs_parser *p,
                                 struct radeon_cs_packet *pkt,
                                 const unsigned *auth, unsigned n,
@@ -1028,6 +1057,8 @@ extern int r100_cs_parse_packet0(struct radeon_cs_parser *p,
 extern int r100_cs_packet_parse(struct radeon_cs_parser *p,
                                 struct radeon_cs_packet *pkt,
                                 unsigned idx);
+extern void r100_enable_bm(struct radeon_device *rdev);
+extern void r100_set_common_regs(struct radeon_device *rdev);
 
 /* rv200,rv250,rv280 */
 extern void r200_set_safe_registers(struct radeon_device *rdev);
@@ -1103,7 +1134,14 @@ extern void r600_wb_disable(struct radeon_device *rdev);
 extern void r600_scratch_init(struct radeon_device *rdev);
 extern int r600_blit_init(struct radeon_device *rdev);
 extern void r600_blit_fini(struct radeon_device *rdev);
-extern int r600_cp_init_microcode(struct radeon_device *rdev);
+extern int r600_init_microcode(struct radeon_device *rdev);
 extern int r600_gpu_reset(struct radeon_device *rdev);
+/* r600 irq */
+extern int r600_irq_init(struct radeon_device *rdev);
+extern void r600_irq_fini(struct radeon_device *rdev);
+extern void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size);
+extern int r600_irq_set(struct radeon_device *rdev);
+
+#include "radeon_object.h"
 
 #endif
diff --git a/drivers/gpu/drm/radeon/radeon_agp.c b/drivers/gpu/drm/radeon/radeon_agp.c
index 23ea9955ac59..54bf49a6d676 100644
--- a/drivers/gpu/drm/radeon/radeon_agp.c
+++ b/drivers/gpu/drm/radeon/radeon_agp.c
@@ -237,6 +237,18 @@ int radeon_agp_init(struct radeon_device *rdev)
 #endif
 }
 
+void radeon_agp_resume(struct radeon_device *rdev)
+{
+#if __OS_HAS_AGP
+        int r;
+        if (rdev->flags & RADEON_IS_AGP) {
+                r = radeon_agp_init(rdev);
+                if (r)
+                        dev_warn(rdev->dev, "radeon AGP reinit failed\n");
+        }
+#endif
+}
+
 void radeon_agp_fini(struct radeon_device *rdev)
 {
 #if __OS_HAS_AGP
diff --git a/drivers/gpu/drm/radeon/radeon_asic.h b/drivers/gpu/drm/radeon/radeon_asic.h
index c18fbee387d7..636116bedcb4 100644
--- a/drivers/gpu/drm/radeon/radeon_asic.h
+++ b/drivers/gpu/drm/radeon/radeon_asic.h
@@ -76,6 +76,12 @@ int r100_clear_surface_reg(struct radeon_device *rdev, int reg);
 void r100_bandwidth_update(struct radeon_device *rdev);
 void r100_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib);
 int r100_ring_test(struct radeon_device *rdev);
+void r100_hdp_flush(struct radeon_device *rdev);
+void r100_hpd_init(struct radeon_device *rdev);
+void r100_hpd_fini(struct radeon_device *rdev);
+bool r100_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd);
+void r100_hpd_set_polarity(struct radeon_device *rdev,
+                           enum radeon_hpd_id hpd);
 
 static struct radeon_asic r100_asic = {
         .init = &r100_init,
@@ -107,6 +113,11 @@ static struct radeon_asic r100_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &r100_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &r100_hpd_init,
+        .hpd_fini = &r100_hpd_fini,
+        .hpd_sense = &r100_hpd_sense,
+        .hpd_set_polarity = &r100_hpd_set_polarity,
 };
 
 
@@ -162,6 +173,11 @@ static struct radeon_asic r300_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &r100_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &r100_hpd_init,
+        .hpd_fini = &r100_hpd_fini,
+        .hpd_sense = &r100_hpd_sense,
+        .hpd_set_polarity = &r100_hpd_set_polarity,
 };
 
 /*
@@ -201,6 +217,11 @@ static struct radeon_asic r420_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &r100_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &r100_hpd_init,
+        .hpd_fini = &r100_hpd_fini,
+        .hpd_sense = &r100_hpd_sense,
+        .hpd_set_polarity = &r100_hpd_set_polarity,
 };
 
 
@@ -245,6 +266,11 @@ static struct radeon_asic rs400_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &r100_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &r100_hpd_init,
+        .hpd_fini = &r100_hpd_fini,
+        .hpd_sense = &r100_hpd_sense,
+        .hpd_set_polarity = &r100_hpd_set_polarity,
 };
 
 
@@ -263,6 +289,12 @@ int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr);
 uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg);
 void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v);
 void rs600_bandwidth_update(struct radeon_device *rdev);
+void rs600_hpd_init(struct radeon_device *rdev);
+void rs600_hpd_fini(struct radeon_device *rdev);
+bool rs600_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd);
+void rs600_hpd_set_polarity(struct radeon_device *rdev,
+                            enum radeon_hpd_id hpd);
+
 static struct radeon_asic rs600_asic = {
         .init = &rs600_init,
         .fini = &rs600_fini,
@@ -291,6 +323,11 @@ static struct radeon_asic rs600_asic = {
         .set_pcie_lanes = NULL,
         .set_clock_gating = &radeon_atom_set_clock_gating,
         .bandwidth_update = &rs600_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &rs600_hpd_init,
+        .hpd_fini = &rs600_hpd_fini,
+        .hpd_sense = &rs600_hpd_sense,
+        .hpd_set_polarity = &rs600_hpd_set_polarity,
 };
 
 
@@ -334,6 +371,11 @@ static struct radeon_asic rs690_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &rs690_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &rs600_hpd_init,
+        .hpd_fini = &rs600_hpd_fini,
+        .hpd_sense = &rs600_hpd_sense,
+        .hpd_set_polarity = &rs600_hpd_set_polarity,
 };
 
 
@@ -381,6 +423,11 @@ static struct radeon_asic rv515_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &rv515_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &rs600_hpd_init,
+        .hpd_fini = &rs600_hpd_fini,
+        .hpd_sense = &rs600_hpd_sense,
+        .hpd_set_polarity = &rs600_hpd_set_polarity,
 };
 
 
@@ -419,6 +466,11 @@ static struct radeon_asic r520_asic = {
         .set_surface_reg = r100_set_surface_reg,
         .clear_surface_reg = r100_clear_surface_reg,
         .bandwidth_update = &rv515_bandwidth_update,
+        .hdp_flush = &r100_hdp_flush,
+        .hpd_init = &rs600_hpd_init,
+        .hpd_fini = &rs600_hpd_fini,
+        .hpd_sense = &rs600_hpd_sense,
+        .hpd_set_polarity = &rs600_hpd_set_polarity,
 };
 
 /*
@@ -455,6 +507,12 @@ int r600_ring_test(struct radeon_device *rdev);
 int r600_copy_blit(struct radeon_device *rdev,
                    uint64_t src_offset, uint64_t dst_offset,
                    unsigned num_pages, struct radeon_fence *fence);
+void r600_hdp_flush(struct radeon_device *rdev);
+void r600_hpd_init(struct radeon_device *rdev);
+void r600_hpd_fini(struct radeon_device *rdev);
+bool r600_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd);
+void r600_hpd_set_polarity(struct radeon_device *rdev,
+                           enum radeon_hpd_id hpd);
 
 static struct radeon_asic r600_asic = {
         .init = &r600_init,
@@ -470,6 +528,7 @@ static struct radeon_asic r600_asic = {
         .ring_ib_execute = &r600_ring_ib_execute,
         .irq_set = &r600_irq_set,
         .irq_process = &r600_irq_process,
+        .get_vblank_counter = &rs600_get_vblank_counter,
         .fence_ring_emit = &r600_fence_ring_emit,
         .cs_parse = &r600_cs_parse,
         .copy_blit = &r600_copy_blit,
@@ -484,6 +543,11 @@ static struct radeon_asic r600_asic = {
         .set_surface_reg = r600_set_surface_reg,
         .clear_surface_reg = r600_clear_surface_reg,
         .bandwidth_update = &rv515_bandwidth_update,
+        .hdp_flush = &r600_hdp_flush,
+        .hpd_init = &r600_hpd_init,
+        .hpd_fini = &r600_hpd_fini,
+        .hpd_sense = &r600_hpd_sense,
+        .hpd_set_polarity = &r600_hpd_set_polarity,
 };
 
 /*
@@ -509,6 +573,7 @@ static struct radeon_asic rv770_asic = {
         .ring_ib_execute = &r600_ring_ib_execute,
         .irq_set = &r600_irq_set,
         .irq_process = &r600_irq_process,
+        .get_vblank_counter = &rs600_get_vblank_counter,
         .fence_ring_emit = &r600_fence_ring_emit,
         .cs_parse = &r600_cs_parse,
         .copy_blit = &r600_copy_blit,
@@ -523,6 +588,11 @@ static struct radeon_asic rv770_asic = {
         .set_surface_reg = r600_set_surface_reg,
         .clear_surface_reg = r600_clear_surface_reg,
         .bandwidth_update = &rv515_bandwidth_update,
+        .hdp_flush = &r600_hdp_flush,
+        .hpd_init = &r600_hpd_init,
+        .hpd_fini = &r600_hpd_fini,
+        .hpd_sense = &r600_hpd_sense,
+        .hpd_set_polarity = &r600_hpd_set_polarity,
 };
 
 #endif
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 2ed88a820935..d7b0feb7d47f 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -47,7 +47,8 @@ radeon_add_atom_connector(struct drm_device *dev,
                           int connector_type,
                           struct radeon_i2c_bus_rec *i2c_bus,
                           bool linkb, uint32_t igp_lane_info,
-                          uint16_t connector_object_id);
+                          uint16_t connector_object_id,
+                          struct radeon_hpd *hpd);
 
 /* from radeon_legacy_encoder.c */
 extern void
@@ -60,12 +61,11 @@ union atom_supported_devices {
         struct _ATOM_SUPPORTED_DEVICES_INFO_2d1 info_2d1;
 };
 
-static inline struct radeon_i2c_bus_rec radeon_lookup_gpio(struct drm_device
-                                                           *dev, uint8_t id)
+static inline struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rdev,
+                                                               uint8_t id)
 {
-        struct radeon_device *rdev = dev->dev_private;
         struct atom_context *ctx = rdev->mode_info.atom_context;
-        ATOM_GPIO_I2C_ASSIGMENT gpio;
+        ATOM_GPIO_I2C_ASSIGMENT *gpio;
         struct radeon_i2c_bus_rec i2c;
         int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
         struct _ATOM_GPIO_I2C_INFO *i2c_info;
@@ -78,34 +78,116 @@ static inline struct radeon_i2c_bus_rec radeon_lookup_gpio(struct drm_device
 
         i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
 
-        gpio = i2c_info->asGPIO_Info[id];
-
-        i2c.mask_clk_reg = le16_to_cpu(gpio.usClkMaskRegisterIndex) * 4;
-        i2c.mask_data_reg = le16_to_cpu(gpio.usDataMaskRegisterIndex) * 4;
-        i2c.put_clk_reg = le16_to_cpu(gpio.usClkEnRegisterIndex) * 4;
-        i2c.put_data_reg = le16_to_cpu(gpio.usDataEnRegisterIndex) * 4;
-        i2c.get_clk_reg = le16_to_cpu(gpio.usClkY_RegisterIndex) * 4;
-        i2c.get_data_reg = le16_to_cpu(gpio.usDataY_RegisterIndex) * 4;
-        i2c.a_clk_reg = le16_to_cpu(gpio.usClkA_RegisterIndex) * 4;
-        i2c.a_data_reg = le16_to_cpu(gpio.usDataA_RegisterIndex) * 4;
-        i2c.mask_clk_mask = (1 << gpio.ucClkMaskShift);
-        i2c.mask_data_mask = (1 << gpio.ucDataMaskShift);
-        i2c.put_clk_mask = (1 << gpio.ucClkEnShift);
-        i2c.put_data_mask = (1 << gpio.ucDataEnShift);
-        i2c.get_clk_mask = (1 << gpio.ucClkY_Shift);
-        i2c.get_data_mask = (1 << gpio.ucDataY_Shift);
-        i2c.a_clk_mask = (1 << gpio.ucClkA_Shift);
-        i2c.a_data_mask = (1 << gpio.ucDataA_Shift);
+        gpio = &i2c_info->asGPIO_Info[id];
+
+        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;
+        i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
+        i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
+        i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
+        i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
+        i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
+        i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
+        i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
+        i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
+        i2c.en_data_mask = (1 << gpio->ucDataEnShift);
+        i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
+        i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
+        i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
+        i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
+
+        if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
+                i2c.hw_capable = true;
+        else
+                i2c.hw_capable = false;
+
+        if (gpio->sucI2cId.ucAccess == 0xa0)
+                i2c.mm_i2c = true;
+        else
+                i2c.mm_i2c = false;
+
+        i2c.i2c_id = gpio->sucI2cId.ucAccess;
+
         i2c.valid = true;
 
         return i2c;
 }
 
+static inline struct radeon_gpio_rec radeon_lookup_gpio(struct radeon_device *rdev,
+                                                        u8 id)
+{
+        struct atom_context *ctx = rdev->mode_info.atom_context;
+        struct radeon_gpio_rec gpio;
+        int index = GetIndexIntoMasterTable(DATA, GPIO_Pin_LUT);
+        struct _ATOM_GPIO_PIN_LUT *gpio_info;
+        ATOM_GPIO_PIN_ASSIGNMENT *pin;
+        u16 data_offset, size;
+        int i, num_indices;
+
+        memset(&gpio, 0, sizeof(struct radeon_gpio_rec));
+        gpio.valid = false;
+
+        atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset);
+
+        gpio_info = (struct _ATOM_GPIO_PIN_LUT *)(ctx->bios + data_offset);
+
+        num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) / sizeof(ATOM_GPIO_PIN_ASSIGNMENT);
+
+        for (i = 0; i < num_indices; i++) {
+                pin = &gpio_info->asGPIO_Pin[i];
+                if (id == pin->ucGPIO_ID) {
+                        gpio.id = pin->ucGPIO_ID;
+                        gpio.reg = pin->usGpioPin_AIndex * 4;
+                        gpio.mask = (1 << pin->ucGpioPinBitShift);
+                        gpio.valid = true;
+                        break;
+                }
+        }
+
+        return gpio;
+}
+
+static struct radeon_hpd radeon_atom_get_hpd_info_from_gpio(struct radeon_device *rdev,
+                                                            struct radeon_gpio_rec *gpio)
+{
+        struct radeon_hpd hpd;
+        hpd.gpio = *gpio;
+        if (gpio->reg == AVIVO_DC_GPIO_HPD_A) {
+                switch(gpio->mask) {
+                case (1 << 0):
+                        hpd.hpd = RADEON_HPD_1;
+                        break;
+                case (1 << 8):
+                        hpd.hpd = RADEON_HPD_2;
+                        break;
+                case (1 << 16):
+                        hpd.hpd = RADEON_HPD_3;
+                        break;
+                case (1 << 24):
+                        hpd.hpd = RADEON_HPD_4;
+                        break;
+                case (1 << 26):
+                        hpd.hpd = RADEON_HPD_5;
+                        break;
+                case (1 << 28):
+                        hpd.hpd = RADEON_HPD_6;
+                        break;
+                default:
+                        hpd.hpd = RADEON_HPD_NONE;
+                        break;
+                }
+        } else
+                hpd.hpd = RADEON_HPD_NONE;
+        return hpd;
+}
+
 static bool radeon_atom_apply_quirks(struct drm_device *dev,
                                      uint32_t supported_device,
                                      int *connector_type,
                                      struct radeon_i2c_bus_rec *i2c_bus,
-                                     uint16_t *line_mux)
+                                     uint16_t *line_mux,
+                                     struct radeon_hpd *hpd)
 {
 
         /* Asus M2A-VM HDMI board lists the DVI port as HDMI */
@@ -135,6 +217,23 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                 }
         }
 
+        /* HIS X1300 is DVI+VGA, not DVI+DVI */
+        if ((dev->pdev->device == 0x7146) &&
+            (dev->pdev->subsystem_vendor == 0x17af) &&
+            (dev->pdev->subsystem_device == 0x2058)) {
+                if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
+                        return false;
+        }
+
+        /* Gigabyte X1300 is DVI+VGA, not DVI+DVI */
+        if ((dev->pdev->device == 0x7142) &&
+            (dev->pdev->subsystem_vendor == 0x1458) &&
+            (dev->pdev->subsystem_device == 0x2134)) {
+                if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
+                        return false;
+        }
+
+
         /* Funky macbooks */
         if ((dev->pdev->device == 0x71C5) &&
             (dev->pdev->subsystem_vendor == 0x106b) &&
@@ -172,6 +271,15 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                 }
         }
 
+        /* Acer laptop reports DVI-D as DVI-I */
+        if ((dev->pdev->device == 0x95c4) &&
+            (dev->pdev->subsystem_vendor == 0x1025) &&
+            (dev->pdev->subsystem_device == 0x013c)) {
+                if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
+                    (supported_device == ATOM_DEVICE_DFP1_SUPPORT))
+                        *connector_type = DRM_MODE_CONNECTOR_DVID;
+        }
+
         return true;
 }
 
@@ -240,16 +348,18 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
         struct radeon_mode_info *mode_info = &rdev->mode_info;
         struct atom_context *ctx = mode_info->atom_context;
         int index = GetIndexIntoMasterTable(DATA, Object_Header);
-        uint16_t size, data_offset;
-        uint8_t frev, crev, line_mux = 0;
+        u16 size, data_offset;
+        u8 frev, crev;
         ATOM_CONNECTOR_OBJECT_TABLE *con_obj;
         ATOM_DISPLAY_OBJECT_PATH_TABLE *path_obj;
         ATOM_OBJECT_HEADER *obj_header;
         int i, j, path_size, device_support;
         int connector_type;
-        uint16_t igp_lane_info, conn_id, connector_object_id;
+        u16 igp_lane_info, conn_id, connector_object_id;
         bool linkb;
         struct radeon_i2c_bus_rec ddc_bus;
+        struct radeon_gpio_rec gpio;
+        struct radeon_hpd hpd;
 
         atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset);
 
@@ -276,7 +386,6 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                 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;
 
@@ -377,10 +486,9 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                 }
                         }
 
-                        /* look up gpio for ddc */
+                        /* look up gpio for ddc, hpd */
                         if ((le16_to_cpu(path->usDeviceTag) &
-                             (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT))
-                            == 0) {
+                             (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) == 0) {
                                 for (j = 0; j < con_obj->ucNumberOfObjects; j++) {
                                         if (le16_to_cpu(path->usConnObjectId) ==
                                             le16_to_cpu(con_obj->asObjects[j].
@@ -394,21 +502,31 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                                                  asObjects[j].
                                                                  usRecordOffset));
                                                 ATOM_I2C_RECORD *i2c_record;
+                                                ATOM_HPD_INT_RECORD *hpd_record;
+                                                hpd.hpd = RADEON_HPD_NONE;
 
                                                 while (record->ucRecordType > 0
                                                        && record->
                                                        ucRecordType <=
                                                        ATOM_MAX_OBJECT_RECORD_NUMBER) {
-                                                        switch (record->
-                                                                ucRecordType) {
+                                                        switch (record->ucRecordType) {
                                                         case ATOM_I2C_RECORD_TYPE:
                                                                 i2c_record =
-                                                                    (ATOM_I2C_RECORD
-                                                                     *) record;
-                                                                line_mux =
-                                                                    i2c_record->
-                                                                    sucI2cId.
-                                                                    bfI2C_LineMux;
+                                                                    (ATOM_I2C_RECORD *)
+                                                                        record;
+                                                                ddc_bus = radeon_lookup_i2c_gpio(rdev,
+                                                                                                 i2c_record->
+                                                                                                 sucI2cId.
+                                                                                                 bfI2C_LineMux);
+                                                                break;
+                                                        case ATOM_HPD_INT_RECORD_TYPE:
+                                                                hpd_record =
+                                                                        (ATOM_HPD_INT_RECORD *)
+                                                                        record;
+                                                                gpio = radeon_lookup_gpio(rdev,
+                                                                                          hpd_record->ucHPDIntGPIOID);
+                                                                hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
+                                                                hpd.plugged_state = hpd_record->ucPlugged_PinState;
                                                                 break;
                                                         }
                                                         record =
@@ -421,24 +539,16 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                                 break;
                                         }
                                 }
-                        } else
-                                line_mux = 0;
-
-                        if ((le16_to_cpu(path->usDeviceTag) ==
-                             ATOM_DEVICE_TV1_SUPPORT)
-                            || (le16_to_cpu(path->usDeviceTag) ==
-                                ATOM_DEVICE_TV2_SUPPORT)
-                            || (le16_to_cpu(path->usDeviceTag) ==
-                                ATOM_DEVICE_CV_SUPPORT))
+                        } else {
+                                hpd.hpd = RADEON_HPD_NONE;
                                 ddc_bus.valid = false;
-                        else
-                                ddc_bus = radeon_lookup_gpio(dev, line_mux);
+                        }
 
                         conn_id = le16_to_cpu(path->usConnObjectId);
 
                         if (!radeon_atom_apply_quirks
                             (dev, le16_to_cpu(path->usDeviceTag), &connector_type,
-                             &ddc_bus, &conn_id))
+                             &ddc_bus, &conn_id, &hpd))
                                 continue;
 
                         radeon_add_atom_connector(dev,
@@ -447,7 +557,8 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                                               usDeviceTag),
                                                   connector_type, &ddc_bus,
                                                   linkb, igp_lane_info,
-                                                  connector_object_id);
+                                                  connector_object_id,
+                                                  &hpd);
 
                 }
         }
@@ -502,6 +613,7 @@ struct bios_connector {
         uint16_t devices;
         int connector_type;
         struct radeon_i2c_bus_rec ddc_bus;
+        struct radeon_hpd hpd;
 };
 
 bool radeon_get_atom_connector_info_from_supported_devices_table(struct
@@ -517,7 +629,7 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
         uint16_t device_support;
         uint8_t dac;
         union atom_supported_devices *supported_devices;
-        int i, j;
+        int i, j, max_device;
         struct bios_connector bios_connectors[ATOM_MAX_SUPPORTED_DEVICE];
 
         atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset);
@@ -527,7 +639,12 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
 
         device_support = le16_to_cpu(supported_devices->info.usDeviceSupport);
 
-        for (i = 0; i < ATOM_MAX_SUPPORTED_DEVICE; i++) {
+        if (frev > 1)
+                max_device = ATOM_MAX_SUPPORTED_DEVICE;
+        else
+                max_device = ATOM_MAX_SUPPORTED_DEVICE_INFO;
+
+        for (i = 0; i < max_device; i++) {
                 ATOM_CONNECTOR_INFO_I2C ci =
                     supported_devices->info.asConnInfo[i];
 
@@ -582,8 +699,30 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
                         bios_connectors[i].line_mux = 52;
                 } else
                         bios_connectors[i].ddc_bus =
-                            radeon_lookup_gpio(dev,
-                                               bios_connectors[i].line_mux);
+                            radeon_lookup_i2c_gpio(rdev,
+                                                   bios_connectors[i].line_mux);
+
+                if ((crev > 1) && (frev > 1)) {
+                        u8 isb = supported_devices->info_2d1.asIntSrcInfo[i].ucIntSrcBitmap;
+                        switch (isb) {
+                        case 0x4:
+                                bios_connectors[i].hpd.hpd = RADEON_HPD_1;
+                                break;
+                        case 0xa:
+                                bios_connectors[i].hpd.hpd = RADEON_HPD_2;
+                                break;
+                        default:
+                                bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
+                                break;
+                        }
+                } else {
+                        if (i == ATOM_DEVICE_DFP1_INDEX)
+                                bios_connectors[i].hpd.hpd = RADEON_HPD_1;
+                        else if (i == ATOM_DEVICE_DFP2_INDEX)
+                                bios_connectors[i].hpd.hpd = RADEON_HPD_2;
+                        else
+                                bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
+                }
 
                 /* Always set the connector type to VGA for CRT1/CRT2. if they are
                  * shared with a DVI port, we'll pick up the DVI connector when we
@@ -595,7 +734,8 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
 
                 if (!radeon_atom_apply_quirks
                     (dev, (1 << i), &bios_connectors[i].connector_type,
-                     &bios_connectors[i].ddc_bus, &bios_connectors[i].line_mux))
+                     &bios_connectors[i].ddc_bus, &bios_connectors[i].line_mux,
+                     &bios_connectors[i].hpd))
                         continue;
 
                 bios_connectors[i].valid = true;
@@ -617,9 +757,9 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
         }
 
         /* combine shared connectors */
-        for (i = 0; i < ATOM_MAX_SUPPORTED_DEVICE; i++) {
+        for (i = 0; i < max_device; i++) {
                 if (bios_connectors[i].valid) {
-                        for (j = 0; j < ATOM_MAX_SUPPORTED_DEVICE; j++) {
+                        for (j = 0; j < max_device; j++) {
                                 if (bios_connectors[j].valid && (i != j)) {
                                         if (bios_connectors[i].line_mux ==
                                             bios_connectors[j].line_mux) {
@@ -643,6 +783,10 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
                                                         bios_connectors[i].
                                                             connector_type =
                                                             DRM_MODE_CONNECTOR_DVII;
+                                                        if (bios_connectors[j].devices &
+                                                            (ATOM_DEVICE_DFP_SUPPORT))
+                                                                bios_connectors[i].hpd =
+                                                                        bios_connectors[j].hpd;
                                                         bios_connectors[j].
                                                             valid = false;
                                                 }
@@ -653,7 +797,7 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
         }
 
         /* add the connectors */
-        for (i = 0; i < ATOM_MAX_SUPPORTED_DEVICE; i++) {
+        for (i = 0; i < max_device; i++) {
                 if (bios_connectors[i].valid) {
                         uint16_t connector_object_id =
                                 atombios_get_connector_object_id(dev,
@@ -666,7 +810,8 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
                                                   connector_type,
                                                   &bios_connectors[i].ddc_bus,
                                                   false, 0,
-                                                  connector_object_id);
+                                                  connector_object_id,
+                                                  &bios_connectors[i].hpd);
                 }
         }
 
@@ -901,7 +1046,7 @@ struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_mode_info *mode_info = &rdev->mode_info;
         int index = GetIndexIntoMasterTable(DATA, LVDS_Info);
-        uint16_t data_offset;
+        uint16_t data_offset, misc;
         union lvds_info *lvds_info;
         uint8_t frev, crev;
         struct radeon_encoder_atom_dig *lvds = NULL;
@@ -940,6 +1085,19 @@ struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
                 lvds->panel_pwr_delay =
                     le16_to_cpu(lvds_info->info.usOffDelayInMs);
                 lvds->lvds_misc = lvds_info->info.ucLVDS_Misc;
+
+                misc = le16_to_cpu(lvds_info->info.sLCDTiming.susModeMiscInfo.usAccess);
+                if (misc & ATOM_VSYNC_POLARITY)
+                        lvds->native_mode.flags |= DRM_MODE_FLAG_NVSYNC;
+                if (misc & ATOM_HSYNC_POLARITY)
+                        lvds->native_mode.flags |= DRM_MODE_FLAG_NHSYNC;
+                if (misc & ATOM_COMPOSITESYNC)
+                        lvds->native_mode.flags |= DRM_MODE_FLAG_CSYNC;
+                if (misc & ATOM_INTERLACE)
+                        lvds->native_mode.flags |= DRM_MODE_FLAG_INTERLACE;
+                if (misc & ATOM_DOUBLE_CLOCK_MODE)
+                        lvds->native_mode.flags |= DRM_MODE_FLAG_DBLSCAN;
+
                 /* set crtc values */
                 drm_mode_set_crtcinfo(&lvds->native_mode, CRTC_INTERLACE_HALVE_V);
 
diff --git a/drivers/gpu/drm/radeon/radeon_benchmark.c b/drivers/gpu/drm/radeon/radeon_benchmark.c
index 10bd50a7db87..4ddfd4b5bc51 100644
--- a/drivers/gpu/drm/radeon/radeon_benchmark.c
+++ b/drivers/gpu/drm/radeon/radeon_benchmark.c
@@ -29,8 +29,8 @@
 void radeon_benchmark_move(struct radeon_device *rdev, unsigned bsize,
                            unsigned sdomain, unsigned ddomain)
 {
-        struct radeon_object *dobj = NULL;
-        struct radeon_object *sobj = NULL;
+        struct radeon_bo *dobj = NULL;
+        struct radeon_bo *sobj = NULL;
         struct radeon_fence *fence = NULL;
         uint64_t saddr, daddr;
         unsigned long start_jiffies;
@@ -41,19 +41,27 @@ void radeon_benchmark_move(struct radeon_device *rdev, unsigned bsize,
 
         size = bsize;
         n = 1024;
-        r = radeon_object_create(rdev, NULL, size, true, sdomain, false, &sobj);
+        r = radeon_bo_create(rdev, NULL, size, true, sdomain, &sobj);
         if (r) {
                 goto out_cleanup;
         }
-        r = radeon_object_pin(sobj, sdomain, &saddr);
+        r = radeon_bo_reserve(sobj, false);
+        if (unlikely(r != 0))
+                goto out_cleanup;
+        r = radeon_bo_pin(sobj, sdomain, &saddr);
+        radeon_bo_unreserve(sobj);
         if (r) {
                 goto out_cleanup;
         }
-        r = radeon_object_create(rdev, NULL, size, true, ddomain, false, &dobj);
+        r = radeon_bo_create(rdev, NULL, size, true, ddomain, &dobj);
         if (r) {
                 goto out_cleanup;
         }
-        r = radeon_object_pin(dobj, ddomain, &daddr);
+        r = radeon_bo_reserve(dobj, false);
+        if (unlikely(r != 0))
+                goto out_cleanup;
+        r = radeon_bo_pin(dobj, ddomain, &daddr);
+        radeon_bo_unreserve(dobj);
         if (r) {
                 goto out_cleanup;
         }
@@ -109,12 +117,20 @@ void radeon_benchmark_move(struct radeon_device *rdev, unsigned bsize,
         }
 out_cleanup:
         if (sobj) {
-                radeon_object_unpin(sobj);
-                radeon_object_unref(&sobj);
+                r = radeon_bo_reserve(sobj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_unpin(sobj);
+                        radeon_bo_unreserve(sobj);
+                }
+                radeon_bo_unref(&sobj);
         }
         if (dobj) {
-                radeon_object_unpin(dobj);
-                radeon_object_unref(&dobj);
+                r = radeon_bo_reserve(dobj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_unpin(dobj);
+                        radeon_bo_unreserve(dobj);
+                }
+                radeon_bo_unref(&dobj);
         }
         if (fence) {
                 radeon_fence_unref(&fence);
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c
index a81354167621..b062109efbee 100644
--- a/drivers/gpu/drm/radeon/radeon_clocks.c
+++ b/drivers/gpu/drm/radeon/radeon_clocks.c
@@ -44,6 +44,10 @@ uint32_t radeon_legacy_get_engine_clock(struct radeon_device *rdev)
 
         ref_div =
             RREG32_PLL(RADEON_M_SPLL_REF_FB_DIV) & RADEON_M_SPLL_REF_DIV_MASK;
+
+        if (ref_div == 0)
+                return 0;
+
         sclk = fb_div / ref_div;
 
         post_div = RREG32_PLL(RADEON_SCLK_CNTL) & RADEON_SCLK_SRC_SEL_MASK;
@@ -70,6 +74,10 @@ static uint32_t radeon_legacy_get_memory_clock(struct radeon_device *rdev)
 
         ref_div =
             RREG32_PLL(RADEON_M_SPLL_REF_FB_DIV) & RADEON_M_SPLL_REF_DIV_MASK;
+
+        if (ref_div == 0)
+                return 0;
+
         mclk = fb_div / ref_div;
 
         post_div = RREG32_PLL(RADEON_MCLK_CNTL) & 0x7;
@@ -98,8 +106,19 @@ void radeon_get_clock_info(struct drm_device *dev)
                 ret = radeon_combios_get_clock_info(dev);
 
         if (ret) {
-                if (p1pll->reference_div < 2)
-                        p1pll->reference_div = 12;
+                if (p1pll->reference_div < 2) {
+                        if (!ASIC_IS_AVIVO(rdev)) {
+                                u32 tmp = RREG32_PLL(RADEON_PPLL_REF_DIV);
+                                if (ASIC_IS_R300(rdev))
+                                        p1pll->reference_div =
+                                                (tmp & R300_PPLL_REF_DIV_ACC_MASK) >> R300_PPLL_REF_DIV_ACC_SHIFT;
+                                else
+                                        p1pll->reference_div = tmp & RADEON_PPLL_REF_DIV_MASK;
+                                if (p1pll->reference_div < 2)
+                                        p1pll->reference_div = 12;
+                        } else
+                                p1pll->reference_div = 12;
+                }
                 if (p2pll->reference_div < 2)
                         p2pll->reference_div = 12;
                 if (rdev->family < CHIP_RS600) {
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index 5253cbf6db1f..c5021a3445de 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -50,7 +50,8 @@ radeon_add_legacy_connector(struct drm_device *dev,
                             uint32_t supported_device,
                             int connector_type,
                             struct radeon_i2c_bus_rec *i2c_bus,
-                            uint16_t connector_object_id);
+                            uint16_t connector_object_id,
+                            struct radeon_hpd *hpd);
 
 /* from radeon_legacy_encoder.c */
 extern void
@@ -442,38 +443,70 @@ static uint16_t combios_get_table_offset(struct drm_device *dev,
 
 }
 
-struct radeon_i2c_bus_rec combios_setup_i2c_bus(int ddc_line)
+static struct radeon_i2c_bus_rec combios_setup_i2c_bus(struct radeon_device *rdev,
+                                                       int ddc_line)
 {
         struct radeon_i2c_bus_rec i2c;
 
-        i2c.mask_clk_mask = RADEON_GPIO_EN_1;
-        i2c.mask_data_mask = RADEON_GPIO_EN_0;
-        i2c.a_clk_mask = RADEON_GPIO_A_1;
-        i2c.a_data_mask = RADEON_GPIO_A_0;
-        i2c.put_clk_mask = RADEON_GPIO_EN_1;
-        i2c.put_data_mask = RADEON_GPIO_EN_0;
-        i2c.get_clk_mask = RADEON_GPIO_Y_1;
-        i2c.get_data_mask = RADEON_GPIO_Y_0;
-        if ((ddc_line == RADEON_LCD_GPIO_MASK) ||
-            (ddc_line == RADEON_MDGPIO_EN_REG)) {
-                i2c.mask_clk_reg = ddc_line;
-                i2c.mask_data_reg = ddc_line;
-                i2c.a_clk_reg = ddc_line;
-                i2c.a_data_reg = ddc_line;
-                i2c.put_clk_reg = ddc_line;
-                i2c.put_data_reg = ddc_line;
-                i2c.get_clk_reg = ddc_line + 4;
-                i2c.get_data_reg = ddc_line + 4;
+        if (ddc_line == RADEON_GPIOPAD_MASK) {
+                i2c.mask_clk_reg = RADEON_GPIOPAD_MASK;
+                i2c.mask_data_reg = RADEON_GPIOPAD_MASK;
+                i2c.a_clk_reg = RADEON_GPIOPAD_A;
+                i2c.a_data_reg = RADEON_GPIOPAD_A;
+                i2c.en_clk_reg = RADEON_GPIOPAD_EN;
+                i2c.en_data_reg = RADEON_GPIOPAD_EN;
+                i2c.y_clk_reg = RADEON_GPIOPAD_Y;
+                i2c.y_data_reg = RADEON_GPIOPAD_Y;
+        } else if (ddc_line == RADEON_MDGPIO_MASK) {
+                i2c.mask_clk_reg = RADEON_MDGPIO_MASK;
+                i2c.mask_data_reg = RADEON_MDGPIO_MASK;
+                i2c.a_clk_reg = RADEON_MDGPIO_A;
+                i2c.a_data_reg = RADEON_MDGPIO_A;
+                i2c.en_clk_reg = RADEON_MDGPIO_EN;
+                i2c.en_data_reg = RADEON_MDGPIO_EN;
+                i2c.y_clk_reg = RADEON_MDGPIO_Y;
+                i2c.y_data_reg = RADEON_MDGPIO_Y;
         } else {
+                i2c.mask_clk_mask = RADEON_GPIO_EN_1;
+                i2c.mask_data_mask = RADEON_GPIO_EN_0;
+                i2c.a_clk_mask = RADEON_GPIO_A_1;
+                i2c.a_data_mask = RADEON_GPIO_A_0;
+                i2c.en_clk_mask = RADEON_GPIO_EN_1;
+                i2c.en_data_mask = RADEON_GPIO_EN_0;
+                i2c.y_clk_mask = RADEON_GPIO_Y_1;
+                i2c.y_data_mask = RADEON_GPIO_Y_0;
+
                 i2c.mask_clk_reg = ddc_line;
                 i2c.mask_data_reg = ddc_line;
                 i2c.a_clk_reg = ddc_line;
                 i2c.a_data_reg = ddc_line;
-                i2c.put_clk_reg = ddc_line;
-                i2c.put_data_reg = ddc_line;
-                i2c.get_clk_reg = ddc_line;
-                i2c.get_data_reg = ddc_line;
+                i2c.en_clk_reg = ddc_line;
+                i2c.en_data_reg = ddc_line;
+                i2c.y_clk_reg = ddc_line;
+                i2c.y_data_reg = ddc_line;
+        }
+
+        if (rdev->family < CHIP_R200)
+                i2c.hw_capable = false;
+        else {
+                switch (ddc_line) {
+                case RADEON_GPIO_VGA_DDC:
+                case RADEON_GPIO_DVI_DDC:
+                        i2c.hw_capable = true;
+                        break;
+                case RADEON_GPIO_MONID:
+                        /* hw i2c on RADEON_GPIO_MONID doesn't seem to work
+                         * reliably on some pre-r4xx hardware; not sure why.
+                         */
+                        i2c.hw_capable = false;
+                        break;
+                default:
+                        i2c.hw_capable = false;
+                        break;
+                }
         }
+        i2c.mm_i2c = false;
+        i2c.i2c_id = 0;
 
         if (ddc_line)
                 i2c.valid = true;
@@ -495,7 +528,7 @@ bool radeon_combios_get_clock_info(struct drm_device *dev)
         uint16_t sclk, mclk;
 
         if (rdev->bios == NULL)
-                return NULL;
+                return false;
 
         pll_info = combios_get_table_offset(dev, COMBIOS_PLL_INFO_TABLE);
         if (pll_info) {
@@ -993,8 +1026,8 @@ static const struct radeon_tmds_pll default_tmds_pll[CHIP_LAST][4] = {
         {{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}},        /* CHIP_R420  */
         {{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}},        /* CHIP_R423  */
         {{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}},        /* CHIP_RV410 */
-        {{15000, 0xb0155}, {0xffffffff, 0xb01cb}, {0, 0}, {0, 0}},      /* CHIP_RS400 */
-        {{15000, 0xb0155}, {0xffffffff, 0xb01cb}, {0, 0}, {0, 0}},      /* CHIP_RS480 */
+        { {0, 0}, {0, 0}, {0, 0}, {0, 0} },     /* CHIP_RS400 */
+        { {0, 0}, {0, 0}, {0, 0}, {0, 0} },     /* CHIP_RS480 */
 };
 
 bool radeon_legacy_get_tmds_info_from_table(struct radeon_encoder *encoder,
@@ -1028,7 +1061,6 @@ bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
         tmds_info = combios_get_table_offset(dev, COMBIOS_DFP_INFO_TABLE);
 
         if (tmds_info) {
-
                 ver = RBIOS8(tmds_info);
                 DRM_INFO("DFP table revision: %d\n", ver);
                 if (ver == 3) {
@@ -1063,51 +1095,139 @@ bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
                                           tmds->tmds_pll[i].value);
                         }
                 }
-        } else
+        } else {
                 DRM_INFO("No TMDS info found in BIOS\n");
+                return false;
+        }
         return true;
 }
 
-struct radeon_encoder_int_tmds *radeon_combios_get_tmds_info(struct radeon_encoder *encoder)
+bool radeon_legacy_get_ext_tmds_info_from_table(struct radeon_encoder *encoder,
+                                                struct radeon_encoder_ext_tmds *tmds)
 {
-        struct radeon_encoder_int_tmds *tmds = NULL;
-        bool ret;
+        struct drm_device *dev = encoder->base.dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_i2c_bus_rec i2c_bus;
 
-        tmds = kzalloc(sizeof(struct radeon_encoder_int_tmds), GFP_KERNEL);
+        /* default for macs */
+        i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
+        tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
 
-        if (!tmds)
-                return NULL;
-
-        ret = radeon_legacy_get_tmds_info_from_combios(encoder, tmds);
-        if (ret == false)
-                radeon_legacy_get_tmds_info_from_table(encoder, tmds);
+        /* XXX some macs have duallink chips */
+        switch (rdev->mode_info.connector_table) {
+        case CT_POWERBOOK_EXTERNAL:
+        case CT_MINI_EXTERNAL:
+        default:
+                tmds->dvo_chip = DVO_SIL164;
+                tmds->slave_addr = 0x70 >> 1; /* 7 bit addressing */
+                break;
+        }
 
-        return tmds;
+        return true;
 }
 
-void radeon_combios_get_ext_tmds_info(struct radeon_encoder *encoder)
+bool radeon_legacy_get_ext_tmds_info_from_combios(struct radeon_encoder *encoder,
+                                                  struct radeon_encoder_ext_tmds *tmds)
 {
         struct drm_device *dev = encoder->base.dev;
         struct radeon_device *rdev = dev->dev_private;
-        uint16_t ext_tmds_info;
-        uint8_t ver;
+        uint16_t offset;
+        uint8_t ver, id, blocks, clk, data;
+        int i;
+        enum radeon_combios_ddc gpio;
+        struct radeon_i2c_bus_rec i2c_bus;
 
         if (rdev->bios == NULL)
-                return;
+                return false;
 
-        ext_tmds_info =
-            combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
-        if (ext_tmds_info) {
-                ver = RBIOS8(ext_tmds_info);
-                DRM_INFO("External TMDS Table revision: %d\n", ver);
-                // TODO
+        tmds->i2c_bus = NULL;
+        if (rdev->flags & RADEON_IS_IGP) {
+                offset = combios_get_table_offset(dev, COMBIOS_I2C_INFO_TABLE);
+                if (offset) {
+                        ver = RBIOS8(offset);
+                        DRM_INFO("GPIO Table revision: %d\n", ver);
+                        blocks = RBIOS8(offset + 2);
+                        for (i = 0; i < blocks; i++) {
+                                id = RBIOS8(offset + 3 + (i * 5) + 0);
+                                if (id == 136) {
+                                        clk = RBIOS8(offset + 3 + (i * 5) + 3);
+                                        data = RBIOS8(offset + 3 + (i * 5) + 4);
+                                        i2c_bus.valid = true;
+                                        i2c_bus.mask_clk_mask = (1 << clk);
+                                        i2c_bus.mask_data_mask = (1 << data);
+                                        i2c_bus.a_clk_mask = (1 << clk);
+                                        i2c_bus.a_data_mask = (1 << data);
+                                        i2c_bus.en_clk_mask = (1 << clk);
+                                        i2c_bus.en_data_mask = (1 << data);
+                                        i2c_bus.y_clk_mask = (1 << clk);
+                                        i2c_bus.y_data_mask = (1 << data);
+                                        i2c_bus.mask_clk_reg = RADEON_GPIOPAD_MASK;
+                                        i2c_bus.mask_data_reg = RADEON_GPIOPAD_MASK;
+                                        i2c_bus.a_clk_reg = RADEON_GPIOPAD_A;
+                                        i2c_bus.a_data_reg = RADEON_GPIOPAD_A;
+                                        i2c_bus.en_clk_reg = RADEON_GPIOPAD_EN;
+                                        i2c_bus.en_data_reg = RADEON_GPIOPAD_EN;
+                                        i2c_bus.y_clk_reg = RADEON_GPIOPAD_Y;
+                                        i2c_bus.y_data_reg = RADEON_GPIOPAD_Y;
+                                        tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
+                                        tmds->dvo_chip = DVO_SIL164;
+                                        tmds->slave_addr = 0x70 >> 1; /* 7 bit addressing */
+                                        break;
+                                }
+                        }
+                }
+        } else {
+                offset = combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
+                if (offset) {
+                        ver = RBIOS8(offset);
+                        DRM_INFO("External TMDS Table revision: %d\n", ver);
+                        tmds->slave_addr = RBIOS8(offset + 4 + 2);
+                        tmds->slave_addr >>= 1; /* 7 bit addressing */
+                        gpio = RBIOS8(offset + 4 + 3);
+                        switch (gpio) {
+                        case DDC_MONID:
+                                i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
+                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
+                                break;
+                        case DDC_DVI:
+                                i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
+                                break;
+                        case DDC_VGA:
+                                i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
+                                break;
+                        case DDC_CRT2:
+                                /* R3xx+ chips don't have GPIO_CRT2_DDC gpio pad */
+                                if (rdev->family >= CHIP_R300)
+                                        i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
+                                else
+                                        i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
+                                break;
+                        case DDC_LCD: /* MM i2c */
+                                DRM_ERROR("MM i2c requires hw i2c engine\n");
+                                break;
+                        default:
+                                DRM_ERROR("Unsupported gpio %d\n", gpio);
+                                break;
+                        }
+                }
         }
+
+        if (!tmds->i2c_bus) {
+                DRM_INFO("No valid Ext TMDS info found in BIOS\n");
+                return false;
+        }
+
+        return true;
 }
 
 bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_i2c_bus_rec ddc_i2c;
+        struct radeon_hpd hpd;
 
         rdev->mode_info.connector_table = radeon_connector_table;
         if (rdev->mode_info.connector_table == CT_NONE) {
@@ -1168,7 +1288,8 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 /* these are the most common settings */
                 if (rdev->flags & RADEON_SINGLE_CRTC) {
                         /* VGA - primary dac */
-                        ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
@@ -1178,10 +1299,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     ATOM_DEVICE_CRT1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_VGA,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_VGA);
+                                                    CONNECTOR_OBJECT_ID_VGA,
+                                                    &hpd);
                 } else if (rdev->flags & RADEON_IS_MOBILITY) {
                         /* LVDS */
-                        ddc_i2c = combios_setup_i2c_bus(RADEON_LCD_GPIO_MASK);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, 0);
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
                                                                         ATOM_DEVICE_LCD1_SUPPORT,
@@ -1191,10 +1314,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     ATOM_DEVICE_LCD1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_LVDS,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_LVDS);
+                                                    CONNECTOR_OBJECT_ID_LVDS,
+                                                    &hpd);
 
                         /* VGA - primary dac */
-                        ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
@@ -1204,10 +1329,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     ATOM_DEVICE_CRT1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_VGA,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_VGA);
+                                                    CONNECTOR_OBJECT_ID_VGA,
+                                                    &hpd);
                 } else {
                         /* DVI-I - tv dac, int tmds */
-                        ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                        hpd.hpd = RADEON_HPD_1;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
                                                                         ATOM_DEVICE_DFP1_SUPPORT,
@@ -1223,10 +1350,12 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     ATOM_DEVICE_CRT2_SUPPORT,
                                                     DRM_MODE_CONNECTOR_DVII,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I);
+                                                    CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I,
+                                                    &hpd);
 
                         /* VGA - primary dac */
-                        ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
                                                                         ATOM_DEVICE_CRT1_SUPPORT,
@@ -1236,11 +1365,14 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     ATOM_DEVICE_CRT1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_VGA,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_VGA);
+                                                    CONNECTOR_OBJECT_ID_VGA,
+                                                    &hpd);
                 }
 
                 if (rdev->family != CHIP_R100 && rdev->family != CHIP_R200) {
                         /* TV - tv dac */
+                        ddc_i2c.valid = false;
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
                                                                         ATOM_DEVICE_TV1_SUPPORT,
@@ -1250,14 +1382,16 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     ATOM_DEVICE_TV1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_SVIDEO,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_SVIDEO);
+                                                    CONNECTOR_OBJECT_ID_SVIDEO,
+                                                    &hpd);
                 }
                 break;
         case CT_IBOOK:
                 DRM_INFO("Connector Table: %d (ibook)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
@@ -1265,9 +1399,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_LCD1_SUPPORT);
                 radeon_add_legacy_connector(dev, 0, ATOM_DEVICE_LCD1_SUPPORT,
                                             DRM_MODE_CONNECTOR_LVDS, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_LVDS);
+                                            CONNECTOR_OBJECT_ID_LVDS,
+                                            &hpd);
                 /* VGA - TV DAC */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
@@ -1275,8 +1411,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_CRT2_SUPPORT);
                 radeon_add_legacy_connector(dev, 1, ATOM_DEVICE_CRT2_SUPPORT,
                                             DRM_MODE_CONNECTOR_VGA, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_VGA);
+                                            CONNECTOR_OBJECT_ID_VGA,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1285,13 +1424,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 2, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_POWERBOOK_EXTERNAL:
                 DRM_INFO("Connector Table: %d (powerbook external tmds)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
@@ -1299,9 +1440,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_LCD1_SUPPORT);
                 radeon_add_legacy_connector(dev, 0, ATOM_DEVICE_LCD1_SUPPORT,
                                             DRM_MODE_CONNECTOR_LVDS, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_LVDS);
+                                            CONNECTOR_OBJECT_ID_LVDS,
+                                            &hpd);
                 /* DVI-I - primary dac, ext tmds */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                hpd.hpd = RADEON_HPD_2; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_DFP2_SUPPORT,
@@ -1317,8 +1460,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             ATOM_DEVICE_DFP2_SUPPORT |
                                             ATOM_DEVICE_CRT1_SUPPORT,
                                             DRM_MODE_CONNECTOR_DVII, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I);
+                                            CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1327,13 +1473,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 2, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_POWERBOOK_INTERNAL:
                 DRM_INFO("Connector Table: %d (powerbook internal tmds)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
@@ -1341,9 +1489,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_LCD1_SUPPORT);
                 radeon_add_legacy_connector(dev, 0, ATOM_DEVICE_LCD1_SUPPORT,
                                             DRM_MODE_CONNECTOR_LVDS, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_LVDS);
+                                            CONNECTOR_OBJECT_ID_LVDS,
+                                            &hpd);
                 /* DVI-I - primary dac, int tmds */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_DFP1_SUPPORT,
@@ -1358,8 +1508,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             ATOM_DEVICE_DFP1_SUPPORT |
                                             ATOM_DEVICE_CRT1_SUPPORT,
                                             DRM_MODE_CONNECTOR_DVII, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I);
+                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1368,13 +1521,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 2, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_POWERBOOK_VGA:
                 DRM_INFO("Connector Table: %d (powerbook vga)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_LCD1_SUPPORT,
@@ -1382,9 +1537,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_LCD1_SUPPORT);
                 radeon_add_legacy_connector(dev, 0, ATOM_DEVICE_LCD1_SUPPORT,
                                             DRM_MODE_CONNECTOR_LVDS, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_LVDS);
+                                            CONNECTOR_OBJECT_ID_LVDS,
+                                            &hpd);
                 /* VGA - primary dac */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
@@ -1392,8 +1549,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_CRT1_SUPPORT);
                 radeon_add_legacy_connector(dev, 1, ATOM_DEVICE_CRT1_SUPPORT,
                                             DRM_MODE_CONNECTOR_VGA, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_VGA);
+                                            CONNECTOR_OBJECT_ID_VGA,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1402,13 +1562,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 2, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_MINI_EXTERNAL:
                 DRM_INFO("Connector Table: %d (mini external tmds)\n",
                          rdev->mode_info.connector_table);
                 /* DVI-I - tv dac, ext tmds */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                hpd.hpd = RADEON_HPD_2; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_DFP2_SUPPORT,
@@ -1424,8 +1586,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             ATOM_DEVICE_DFP2_SUPPORT |
                                             ATOM_DEVICE_CRT2_SUPPORT,
                                             DRM_MODE_CONNECTOR_DVII, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I);
+                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1434,13 +1599,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 1, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_MINI_INTERNAL:
                 DRM_INFO("Connector Table: %d (mini internal tmds)\n",
                          rdev->mode_info.connector_table);
                 /* DVI-I - tv dac, int tmds */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_DFP1_SUPPORT,
@@ -1455,8 +1622,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             ATOM_DEVICE_DFP1_SUPPORT |
                                             ATOM_DEVICE_CRT2_SUPPORT,
                                             DRM_MODE_CONNECTOR_DVII, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I);
+                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1465,13 +1635,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 1, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_IMAC_G5_ISIGHT:
                 DRM_INFO("Connector Table: %d (imac g5 isight)\n",
                          rdev->mode_info.connector_table);
                 /* DVI-D - int tmds */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_MONID);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
+                hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_DFP1_SUPPORT,
@@ -1479,9 +1651,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_DFP1_SUPPORT);
                 radeon_add_legacy_connector(dev, 0, ATOM_DEVICE_DFP1_SUPPORT,
                                             DRM_MODE_CONNECTOR_DVID, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D);
+                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D,
+                                            &hpd);
                 /* VGA - tv dac */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
@@ -1489,8 +1663,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_CRT2_SUPPORT);
                 radeon_add_legacy_connector(dev, 1, ATOM_DEVICE_CRT2_SUPPORT,
                                             DRM_MODE_CONNECTOR_VGA, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_VGA);
+                                            CONNECTOR_OBJECT_ID_VGA,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1499,13 +1676,15 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 2, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         case CT_EMAC:
                 DRM_INFO("Connector Table: %d (emac)\n",
                          rdev->mode_info.connector_table);
                 /* VGA - primary dac */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_CRT1_SUPPORT,
@@ -1513,9 +1692,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_CRT1_SUPPORT);
                 radeon_add_legacy_connector(dev, 0, ATOM_DEVICE_CRT1_SUPPORT,
                                             DRM_MODE_CONNECTOR_VGA, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_VGA);
+                                            CONNECTOR_OBJECT_ID_VGA,
+                                            &hpd);
                 /* VGA - tv dac */
-                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_CRT2_SUPPORT,
@@ -1523,8 +1704,11 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                           ATOM_DEVICE_CRT2_SUPPORT);
                 radeon_add_legacy_connector(dev, 1, ATOM_DEVICE_CRT2_SUPPORT,
                                             DRM_MODE_CONNECTOR_VGA, &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_VGA);
+                                            CONNECTOR_OBJECT_ID_VGA,
+                                            &hpd);
                 /* TV - TV DAC */
+                ddc_i2c.valid = false;
+                hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
                                                                 ATOM_DEVICE_TV1_SUPPORT,
@@ -1533,7 +1717,8 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 radeon_add_legacy_connector(dev, 2, ATOM_DEVICE_TV1_SUPPORT,
                                             DRM_MODE_CONNECTOR_SVIDEO,
                                             &ddc_i2c,
-                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                            &hpd);
                 break;
         default:
                 DRM_INFO("Connector table: %d (invalid)\n",
@@ -1550,7 +1735,8 @@ static bool radeon_apply_legacy_quirks(struct drm_device *dev,
                                        int bios_index,
                                        enum radeon_combios_connector
                                        *legacy_connector,
-                                       struct radeon_i2c_bus_rec *ddc_i2c)
+                                       struct radeon_i2c_bus_rec *ddc_i2c,
+                                       struct radeon_hpd *hpd)
 {
         struct radeon_device *rdev = dev->dev_private;
 
@@ -1558,29 +1744,26 @@ static bool radeon_apply_legacy_quirks(struct drm_device *dev,
         if ((rdev->family == CHIP_RS400 ||
              rdev->family == CHIP_RS480) &&
             ddc_i2c->mask_clk_reg == RADEON_GPIO_CRT2_DDC)
-                *ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_MONID);
+                *ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
         else if ((rdev->family == CHIP_RS400 ||
                   rdev->family == CHIP_RS480) &&
                  ddc_i2c->mask_clk_reg == RADEON_GPIO_MONID) {
-                ddc_i2c->valid = true;
+                *ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIOPAD_MASK);
                 ddc_i2c->mask_clk_mask = (0x20 << 8);
                 ddc_i2c->mask_data_mask = 0x80;
                 ddc_i2c->a_clk_mask = (0x20 << 8);
                 ddc_i2c->a_data_mask = 0x80;
-                ddc_i2c->put_clk_mask = (0x20 << 8);
-                ddc_i2c->put_data_mask = 0x80;
-                ddc_i2c->get_clk_mask = (0x20 << 8);
-                ddc_i2c->get_data_mask = 0x80;
-                ddc_i2c->mask_clk_reg = RADEON_GPIOPAD_MASK;
-                ddc_i2c->mask_data_reg = RADEON_GPIOPAD_MASK;
-                ddc_i2c->a_clk_reg = RADEON_GPIOPAD_A;
-                ddc_i2c->a_data_reg = RADEON_GPIOPAD_A;
-                ddc_i2c->put_clk_reg = RADEON_GPIOPAD_EN;
-                ddc_i2c->put_data_reg = RADEON_GPIOPAD_EN;
-                ddc_i2c->get_clk_reg = RADEON_LCD_GPIO_Y_REG;
-                ddc_i2c->get_data_reg = RADEON_LCD_GPIO_Y_REG;
+                ddc_i2c->en_clk_mask = (0x20 << 8);
+                ddc_i2c->en_data_mask = 0x80;
+                ddc_i2c->y_clk_mask = (0x20 << 8);
+                ddc_i2c->y_data_mask = 0x80;
         }
 
+        /* R3xx+ chips don't have GPIO_CRT2_DDC gpio pad */
+        if ((rdev->family >= CHIP_R300) &&
+            ddc_i2c->mask_clk_reg == RADEON_GPIO_CRT2_DDC)
+                *ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+
         /* Certain IBM chipset RN50s have a BIOS reporting two VGAs,
            one with VGA DDC and one with CRT2 DDC. - kill the CRT2 DDC one */
         if (dev->pdev->device == 0x515e &&
@@ -1624,6 +1807,12 @@ static bool radeon_apply_legacy_tv_quirks(struct drm_device *dev)
             dev->pdev->subsystem_device == 0x280a)
                 return false;
 
+        /* MSI S270 has non-existent TV port */
+        if (dev->pdev->device == 0x5955 &&
+            dev->pdev->subsystem_vendor == 0x1462 &&
+            dev->pdev->subsystem_device == 0x0131)
+                return false;
+
         return true;
 }
 
@@ -1671,6 +1860,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
         enum radeon_combios_connector connector;
         int i = 0;
         struct radeon_i2c_bus_rec ddc_i2c;
+        struct radeon_hpd hpd;
 
         if (rdev->bios == NULL)
                 return false;
@@ -1691,26 +1881,40 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         switch (ddc_type) {
                         case DDC_MONID:
                                 ddc_i2c =
-                                    combios_setup_i2c_bus(RADEON_GPIO_MONID);
+                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
                                 break;
                         case DDC_DVI:
                                 ddc_i2c =
-                                    combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
                                 break;
                         case DDC_VGA:
                                 ddc_i2c =
-                                    combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
                                 break;
                         case DDC_CRT2:
                                 ddc_i2c =
-                                    combios_setup_i2c_bus(RADEON_GPIO_CRT2_DDC);
+                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
                                 break;
                         default:
                                 break;
                         }
 
+                        switch (connector) {
+                        case CONNECTOR_PROPRIETARY_LEGACY:
+                        case CONNECTOR_DVI_I_LEGACY:
+                        case CONNECTOR_DVI_D_LEGACY:
+                                if ((tmp >> 4) & 0x1)
+                                        hpd.hpd = RADEON_HPD_2;
+                                else
+                                        hpd.hpd = RADEON_HPD_1;
+                                break;
+                        default:
+                                hpd.hpd = RADEON_HPD_NONE;
+                                break;
+                        }
+
                         if (!radeon_apply_legacy_quirks(dev, i, &connector,
-                                                       &ddc_i2c))
+                                                        &ddc_i2c, &hpd))
                                 continue;
 
                         switch (connector) {
@@ -1727,7 +1931,8 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                             legacy_connector_convert
                                                             [connector],
                                                             &ddc_i2c,
-                                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D);
+                                                            CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D,
+                                                            &hpd);
                                 break;
                         case CONNECTOR_CRT_LEGACY:
                                 if (tmp & 0x1) {
@@ -1753,7 +1958,8 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                             legacy_connector_convert
                                                             [connector],
                                                             &ddc_i2c,
-                                                            CONNECTOR_OBJECT_ID_VGA);
+                                                            CONNECTOR_OBJECT_ID_VGA,
+                                                            &hpd);
                                 break;
                         case CONNECTOR_DVI_I_LEGACY:
                                 devices = 0;
@@ -1799,7 +2005,8 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                             legacy_connector_convert
                                                             [connector],
                                                             &ddc_i2c,
-                                                            connector_object_id);
+                                                            connector_object_id,
+                                                            &hpd);
                                 break;
                         case CONNECTOR_DVI_D_LEGACY:
                                 if ((tmp >> 4) & 0x1) {
@@ -1817,7 +2024,8 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                             legacy_connector_convert
                                                             [connector],
                                                             &ddc_i2c,
-                                                            connector_object_id);
+                                                            connector_object_id,
+                                                            &hpd);
                                 break;
                         case CONNECTOR_CTV_LEGACY:
                         case CONNECTOR_STV_LEGACY:
@@ -1832,7 +2040,8 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                             legacy_connector_convert
                                                             [connector],
                                                             &ddc_i2c,
-                                                            CONNECTOR_OBJECT_ID_SVIDEO);
+                                                            CONNECTOR_OBJECT_ID_SVIDEO,
+                                                            &hpd);
                                 break;
                         default:
                                 DRM_ERROR("Unknown connector type: %d\n",
@@ -1858,14 +2067,16 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                                         0),
                                                   ATOM_DEVICE_DFP1_SUPPORT);
 
-                        ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_DVI_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_connector(dev,
                                                     0,
                                                     ATOM_DEVICE_CRT1_SUPPORT |
                                                     ATOM_DEVICE_DFP1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_DVII,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I);
+                                                    CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I,
+                                                    &hpd);
                 } else {
                         uint16_t crt_info =
                                 combios_get_table_offset(dev, COMBIOS_CRT_INFO_TABLE);
@@ -1876,13 +2087,15 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                                 1),
                                                           ATOM_DEVICE_CRT1_SUPPORT);
-                                ddc_i2c = combios_setup_i2c_bus(RADEON_GPIO_VGA_DDC);
+                                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                                hpd.hpd = RADEON_HPD_NONE;
                                 radeon_add_legacy_connector(dev,
                                                             0,
                                                             ATOM_DEVICE_CRT1_SUPPORT,
                                                             DRM_MODE_CONNECTOR_VGA,
                                                             &ddc_i2c,
-                                                            CONNECTOR_OBJECT_ID_VGA);
+                                                            CONNECTOR_OBJECT_ID_VGA,
+                                                            &hpd);
                         } else {
                                 DRM_DEBUG("No connector info found\n");
                                 return false;
@@ -1910,27 +2123,27 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                 case DDC_MONID:
                                         ddc_i2c =
                                             combios_setup_i2c_bus
-                                            (RADEON_GPIO_MONID);
+                                                (rdev, RADEON_GPIO_MONID);
                                         break;
                                 case DDC_DVI:
                                         ddc_i2c =
                                             combios_setup_i2c_bus
-                                            (RADEON_GPIO_DVI_DDC);
+                                                (rdev, RADEON_GPIO_DVI_DDC);
                                         break;
                                 case DDC_VGA:
                                         ddc_i2c =
                                             combios_setup_i2c_bus
-                                            (RADEON_GPIO_VGA_DDC);
+                                                (rdev, RADEON_GPIO_VGA_DDC);
                                         break;
                                 case DDC_CRT2:
                                         ddc_i2c =
                                             combios_setup_i2c_bus
-                                            (RADEON_GPIO_CRT2_DDC);
+                                                (rdev, RADEON_GPIO_CRT2_DDC);
                                         break;
                                 case DDC_LCD:
                                         ddc_i2c =
                                             combios_setup_i2c_bus
-                                            (RADEON_LCD_GPIO_MASK);
+                                                (rdev, RADEON_GPIOPAD_MASK);
                                         ddc_i2c.mask_clk_mask =
                                             RBIOS32(lcd_ddc_info + 3);
                                         ddc_i2c.mask_data_mask =
@@ -1939,19 +2152,19 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                             RBIOS32(lcd_ddc_info + 3);
                                         ddc_i2c.a_data_mask =
                                             RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.put_clk_mask =
+                                        ddc_i2c.en_clk_mask =
                                             RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.put_data_mask =
+                                        ddc_i2c.en_data_mask =
                                             RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.get_clk_mask =
+                                        ddc_i2c.y_clk_mask =
                                             RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.get_data_mask =
+                                        ddc_i2c.y_data_mask =
                                             RBIOS32(lcd_ddc_info + 7);
                                         break;
                                 case DDC_GPIO:
                                         ddc_i2c =
                                             combios_setup_i2c_bus
-                                            (RADEON_MDGPIO_EN_REG);
+                                                (rdev, RADEON_MDGPIO_MASK);
                                         ddc_i2c.mask_clk_mask =
                                             RBIOS32(lcd_ddc_info + 3);
                                         ddc_i2c.mask_data_mask =
@@ -1960,13 +2173,13 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                             RBIOS32(lcd_ddc_info + 3);
                                         ddc_i2c.a_data_mask =
                                             RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.put_clk_mask =
+                                        ddc_i2c.en_clk_mask =
                                             RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.put_data_mask =
+                                        ddc_i2c.en_data_mask =
                                             RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.get_clk_mask =
+                                        ddc_i2c.y_clk_mask =
                                             RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.get_data_mask =
+                                        ddc_i2c.y_data_mask =
                                             RBIOS32(lcd_ddc_info + 7);
                                         break;
                                 default:
@@ -1977,12 +2190,14 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         } else
                                 ddc_i2c.valid = false;
 
+                        hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_connector(dev,
                                                     5,
                                                     ATOM_DEVICE_LCD1_SUPPORT,
                                                     DRM_MODE_CONNECTOR_LVDS,
                                                     &ddc_i2c,
-                                                    CONNECTOR_OBJECT_ID_LVDS);
+                                                    CONNECTOR_OBJECT_ID_LVDS,
+                                                    &hpd);
                 }
         }
 
@@ -1993,6 +2208,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                 if (tv_info) {
                         if (RBIOS8(tv_info + 6) == 'T') {
                                 if (radeon_apply_legacy_tv_quirks(dev)) {
+                                        hpd.hpd = RADEON_HPD_NONE;
                                         radeon_add_legacy_encoder(dev,
                                                                   radeon_get_encoder_id
                                                                   (dev,
@@ -2003,7 +2219,8 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                                     ATOM_DEVICE_TV1_SUPPORT,
                                                                     DRM_MODE_CONNECTOR_SVIDEO,
                                                                     &ddc_i2c,
-                                                                    CONNECTOR_OBJECT_ID_SVIDEO);
+                                                                    CONNECTOR_OBJECT_ID_SVIDEO,
+                                                                    &hpd);
                                 }
                         }
                 }
@@ -2014,6 +2231,193 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
         return true;
 }
 
+void radeon_external_tmds_setup(struct drm_encoder *encoder)
+{
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct radeon_encoder_ext_tmds *tmds = radeon_encoder->enc_priv;
+
+        if (!tmds)
+                return;
+
+        switch (tmds->dvo_chip) {
+        case DVO_SIL164:
+                /* sil 164 */
+                radeon_i2c_do_lock(tmds->i2c_bus, 1);
+                radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                       tmds->slave_addr,
+                                       0x08, 0x30);
+                radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                       tmds->slave_addr,
+                                       0x09, 0x00);
+                radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                       tmds->slave_addr,
+                                       0x0a, 0x90);
+                radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                       tmds->slave_addr,
+                                       0x0c, 0x89);
+                radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                       tmds->slave_addr,
+                                       0x08, 0x3b);
+                radeon_i2c_do_lock(tmds->i2c_bus, 0);
+                break;
+        case DVO_SIL1178:
+                /* sil 1178 - untested */
+                /*
+                 * 0x0f, 0x44
+                 * 0x0f, 0x4c
+                 * 0x0e, 0x01
+                 * 0x0a, 0x80
+                 * 0x09, 0x30
+                 * 0x0c, 0xc9
+                 * 0x0d, 0x70
+                 * 0x08, 0x32
+                 * 0x08, 0x33
+                 */
+                break;
+        default:
+                break;
+        }
+
+}
+
+bool radeon_combios_external_tmds_setup(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        uint16_t offset;
+        uint8_t blocks, slave_addr, rev;
+        uint32_t index, id;
+        uint32_t reg, val, and_mask, or_mask;
+        struct radeon_encoder_ext_tmds *tmds = radeon_encoder->enc_priv;
+
+        if (rdev->bios == NULL)
+                return false;
+
+        if (!tmds)
+                return false;
+
+        if (rdev->flags & RADEON_IS_IGP) {
+                offset = combios_get_table_offset(dev, COMBIOS_TMDS_POWER_ON_TABLE);
+                rev = RBIOS8(offset);
+                if (offset) {
+                        rev = RBIOS8(offset);
+                        if (rev > 1) {
+                                blocks = RBIOS8(offset + 3);
+                                index = offset + 4;
+                                while (blocks > 0) {
+                                        id = RBIOS16(index);
+                                        index += 2;
+                                        switch (id >> 13) {
+                                        case 0:
+                                                reg = (id & 0x1fff) * 4;
+                                                val = RBIOS32(index);
+                                                index += 4;
+                                                WREG32(reg, val);
+                                                break;
+                                        case 2:
+                                                reg = (id & 0x1fff) * 4;
+                                                and_mask = RBIOS32(index);
+                                                index += 4;
+                                                or_mask = RBIOS32(index);
+                                                index += 4;
+                                                val = RREG32(reg);
+                                                val = (val & and_mask) | or_mask;
+                                                WREG32(reg, val);
+                                                break;
+                                        case 3:
+                                                val = RBIOS16(index);
+                                                index += 2;
+                                                udelay(val);
+                                                break;
+                                        case 4:
+                                                val = RBIOS16(index);
+                                                index += 2;
+                                                udelay(val * 1000);
+                                                break;
+                                        case 6:
+                                                slave_addr = id & 0xff;
+                                                slave_addr >>= 1; /* 7 bit addressing */
+                                                index++;
+                                                reg = RBIOS8(index);
+                                                index++;
+                                                val = RBIOS8(index);
+                                                index++;
+                                                radeon_i2c_do_lock(tmds->i2c_bus, 1);
+                                                radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                                                       slave_addr,
+                                                                       reg, val);
+                                                radeon_i2c_do_lock(tmds->i2c_bus, 0);
+                                                break;
+                                        default:
+                                                DRM_ERROR("Unknown id %d\n", id >> 13);
+                                                break;
+                                        }
+                                        blocks--;
+                                }
+                                return true;
+                        }
+                }
+        } else {
+                offset = combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
+                if (offset) {
+                        index = offset + 10;
+                        id = RBIOS16(index);
+                        while (id != 0xffff) {
+                                index += 2;
+                                switch (id >> 13) {
+                                case 0:
+                                        reg = (id & 0x1fff) * 4;
+                                        val = RBIOS32(index);
+                                        WREG32(reg, val);
+                                        break;
+                                case 2:
+                                        reg = (id & 0x1fff) * 4;
+                                        and_mask = RBIOS32(index);
+                                        index += 4;
+                                        or_mask = RBIOS32(index);
+                                        index += 4;
+                                        val = RREG32(reg);
+                                        val = (val & and_mask) | or_mask;
+                                        WREG32(reg, val);
+                                        break;
+                                case 4:
+                                        val = RBIOS16(index);
+                                        index += 2;
+                                        udelay(val);
+                                        break;
+                                case 5:
+                                        reg = id & 0x1fff;
+                                        and_mask = RBIOS32(index);
+                                        index += 4;
+                                        or_mask = RBIOS32(index);
+                                        index += 4;
+                                        val = RREG32_PLL(reg);
+                                        val = (val & and_mask) | or_mask;
+                                        WREG32_PLL(reg, val);
+                                        break;
+                                case 6:
+                                        reg = id & 0x1fff;
+                                        val = RBIOS8(index);
+                                        index += 1;
+                                        radeon_i2c_do_lock(tmds->i2c_bus, 1);
+                                        radeon_i2c_sw_put_byte(tmds->i2c_bus,
+                                                               tmds->slave_addr,
+                                                               reg, val);
+                                        radeon_i2c_do_lock(tmds->i2c_bus, 0);
+                                        break;
+                                default:
+                                        DRM_ERROR("Unknown id %d\n", id >> 13);
+                                        break;
+                                }
+                                id = RBIOS16(index);
+                        }
+                        return true;
+                }
+        }
+        return false;
+}
+
 static void combios_parse_mmio_table(struct drm_device *dev, uint16_t offset)
 {
         struct radeon_device *rdev = dev->dev_private;
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index fce4c4087fda..cfa2ebb259fe 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -40,6 +40,26 @@ radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
                                        struct drm_encoder *encoder,
                                        bool connected);
 
+void radeon_connector_hotplug(struct drm_connector *connector)
+{
+        struct drm_device *dev = connector->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+
+        if (radeon_connector->hpd.hpd != RADEON_HPD_NONE)
+                radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
+
+        if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
+                if (radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
+                        if (radeon_dp_needs_link_train(radeon_connector)) {
+                                if (connector->encoder)
+                                        dp_link_train(connector->encoder, connector);
+                        }
+                }
+        }
+
+}
+
 static void radeon_property_change_mode(struct drm_encoder *encoder)
 {
         struct drm_crtc *crtc = encoder->crtc;
@@ -445,10 +465,10 @@ static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connec
                 ret = connector_status_connected;
         else {
                 if (radeon_connector->ddc_bus) {
-                        radeon_i2c_do_lock(radeon_connector, 1);
+                        radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
                                                               &radeon_connector->ddc_bus->adapter);
-                        radeon_i2c_do_lock(radeon_connector, 0);
+                        radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
                         if (radeon_connector->edid)
                                 ret = connector_status_connected;
                 }
@@ -553,21 +573,22 @@ static enum drm_connector_status radeon_vga_detect(struct drm_connector *connect
         if (!encoder)
                 ret = connector_status_disconnected;
 
-        radeon_i2c_do_lock(radeon_connector, 1);
+        radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
         dret = radeon_ddc_probe(radeon_connector);
-        radeon_i2c_do_lock(radeon_connector, 0);
+        radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
         if (dret) {
                 if (radeon_connector->edid) {
                         kfree(radeon_connector->edid);
                         radeon_connector->edid = NULL;
                 }
-                radeon_i2c_do_lock(radeon_connector, 1);
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
-                radeon_i2c_do_lock(radeon_connector, 0);
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 
                 if (!radeon_connector->edid) {
-                        DRM_ERROR("DDC responded but not EDID found for %s\n",
-                                  drm_get_connector_name(connector));
+                        DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
+                                        drm_get_connector_name(connector));
+                        ret = connector_status_connected;
                 } else {
                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 
@@ -707,21 +728,21 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
         enum drm_connector_status ret = connector_status_disconnected;
         bool dret;
 
-        radeon_i2c_do_lock(radeon_connector, 1);
+        radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
         dret = radeon_ddc_probe(radeon_connector);
-        radeon_i2c_do_lock(radeon_connector, 0);
+        radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
         if (dret) {
                 if (radeon_connector->edid) {
                         kfree(radeon_connector->edid);
                         radeon_connector->edid = NULL;
                 }
-                radeon_i2c_do_lock(radeon_connector, 1);
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
-                radeon_i2c_do_lock(radeon_connector, 0);
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
 
                 if (!radeon_connector->edid) {
-                        DRM_ERROR("DDC responded but not EDID found for %s\n",
-                                  drm_get_connector_name(connector));
+                        DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
+                                        drm_get_connector_name(connector));
                 } else {
                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
 
@@ -734,6 +755,39 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
                                 ret = connector_status_disconnected;
                         } else
                                 ret = connector_status_connected;
+
+                        /* multiple connectors on the same encoder with the same ddc line
+                         * This tends to be HDMI and DVI on the same encoder with the
+                         * same ddc line.  If the edid says HDMI, consider the HDMI port
+                         * connected and the DVI port disconnected.  If the edid doesn't
+                         * say HDMI, vice versa.
+                         */
+                        if (radeon_connector->shared_ddc && connector_status_connected) {
+                                struct drm_device *dev = connector->dev;
+                                struct drm_connector *list_connector;
+                                struct radeon_connector *list_radeon_connector;
+                                list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
+                                        if (connector == list_connector)
+                                                continue;
+                                        list_radeon_connector = to_radeon_connector(list_connector);
+                                        if (radeon_connector->devices == list_radeon_connector->devices) {
+                                                if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
+                                                        if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
+                                                                kfree(radeon_connector->edid);
+                                                                radeon_connector->edid = NULL;
+                                                                ret = connector_status_disconnected;
+                                                        }
+                                                } else {
+                                                        if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
+                                                            (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
+                                                                kfree(radeon_connector->edid);
+                                                                radeon_connector->edid = NULL;
+                                                                ret = connector_status_disconnected;
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
                 }
         }
 
@@ -862,6 +916,91 @@ struct drm_connector_funcs radeon_dvi_connector_funcs = {
         .force = radeon_dvi_force,
 };
 
+static void radeon_dp_connector_destroy(struct drm_connector *connector)
+{
+        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+        struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
+
+        if (radeon_connector->ddc_bus)
+                radeon_i2c_destroy(radeon_connector->ddc_bus);
+        if (radeon_connector->edid)
+                kfree(radeon_connector->edid);
+        if (radeon_dig_connector->dp_i2c_bus)
+                radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
+        kfree(radeon_connector->con_priv);
+        drm_sysfs_connector_remove(connector);
+        drm_connector_cleanup(connector);
+        kfree(connector);
+}
+
+static int radeon_dp_get_modes(struct drm_connector *connector)
+{
+        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+        int ret;
+
+        ret = radeon_ddc_get_modes(radeon_connector);
+        return ret;
+}
+
+static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
+{
+        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) {
+                if (radeon_dp_getdpcd(radeon_connector)) {
+                        radeon_dig_connector->dp_sink_type = sink_type;
+                        ret = connector_status_connected;
+                }
+        } else {
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
+                if (radeon_ddc_probe(radeon_connector)) {
+                        radeon_dig_connector->dp_sink_type = sink_type;
+                        ret = connector_status_connected;
+                }
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
+        }
+
+        return ret;
+}
+
+static int radeon_dp_mode_valid(struct drm_connector *connector,
+                                  struct drm_display_mode *mode)
+{
+        struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+        struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
+
+        /* XXX check mode bandwidth */
+
+        if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
+                return radeon_dp_mode_valid_helper(radeon_connector, mode);
+        else
+                return MODE_OK;
+}
+
+struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
+        .get_modes = radeon_dp_get_modes,
+        .mode_valid = radeon_dp_mode_valid,
+        .best_encoder = radeon_dvi_encoder,
+};
+
+struct drm_connector_funcs radeon_dp_connector_funcs = {
+        .dpms = drm_helper_connector_dpms,
+        .detect = radeon_dp_detect,
+        .fill_modes = drm_helper_probe_single_connector_modes,
+        .set_property = radeon_connector_set_property,
+        .destroy = radeon_dp_connector_destroy,
+        .force = radeon_dvi_force,
+};
+
 void
 radeon_add_atom_connector(struct drm_device *dev,
                           uint32_t connector_id,
@@ -870,7 +1009,8 @@ radeon_add_atom_connector(struct drm_device *dev,
                           struct radeon_i2c_bus_rec *i2c_bus,
                           bool linkb,
                           uint32_t igp_lane_info,
-                          uint16_t connector_object_id)
+                          uint16_t connector_object_id,
+                          struct radeon_hpd *hpd)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct drm_connector *connector;
@@ -910,6 +1050,7 @@ radeon_add_atom_connector(struct drm_device *dev,
         radeon_connector->devices = supported_device;
         radeon_connector->shared_ddc = shared_ddc;
         radeon_connector->connector_object_id = connector_object_id;
+        radeon_connector->hpd = *hpd;
         switch (connector_type) {
         case DRM_MODE_CONNECTOR_VGA:
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
@@ -996,10 +1137,12 @@ radeon_add_atom_connector(struct drm_device *dev,
                 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);
-                ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
+                drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
+                ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
                 if (ret)
                         goto failed;
+                /* add DP i2c bus */
+                radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
                 if (i2c_bus->valid) {
                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
                         if (!radeon_connector->ddc_bus)
@@ -1019,6 +1162,9 @@ radeon_add_atom_connector(struct drm_device *dev,
                         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,
+                                                      1);
                 }
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
@@ -1062,7 +1208,8 @@ radeon_add_legacy_connector(struct drm_device *dev,
                             uint32_t supported_device,
                             int connector_type,
                             struct radeon_i2c_bus_rec *i2c_bus,
-                            uint16_t connector_object_id)
+                            uint16_t connector_object_id,
+                            struct radeon_hpd *hpd)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct drm_connector *connector;
@@ -1092,6 +1239,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
         radeon_connector->connector_id = connector_id;
         radeon_connector->devices = supported_device;
         radeon_connector->connector_object_id = connector_object_id;
+        radeon_connector->hpd = *hpd;
         switch (connector_type) {
         case DRM_MODE_CONNECTOR_VGA:
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
@@ -1149,9 +1297,19 @@ radeon_add_legacy_connector(struct drm_device *dev,
                         if (ret)
                                 goto failed;
                         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,
                                                       1);
+                        drm_connector_attach_property(&radeon_connector->base,
+                                                      rdev->mode_info.tv_std_property,
+                                                      1);
                 }
                 break;
         case DRM_MODE_CONNECTOR_LVDS:
diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c
index 5ab2cf96a264..65590a0f1d93 100644
--- a/drivers/gpu/drm/radeon/radeon_cs.c
+++ b/drivers/gpu/drm/radeon/radeon_cs.c
@@ -76,17 +76,17 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p)
                         }
                         p->relocs_ptr[i] = &p->relocs[i];
                         p->relocs[i].robj = p->relocs[i].gobj->driver_private;
-                        p->relocs[i].lobj.robj = p->relocs[i].robj;
+                        p->relocs[i].lobj.bo = p->relocs[i].robj;
                         p->relocs[i].lobj.rdomain = r->read_domains;
                         p->relocs[i].lobj.wdomain = r->write_domain;
                         p->relocs[i].handle = r->handle;
                         p->relocs[i].flags = r->flags;
                         INIT_LIST_HEAD(&p->relocs[i].lobj.list);
-                        radeon_object_list_add_object(&p->relocs[i].lobj,
-                                                      &p->validated);
+                        radeon_bo_list_add_object(&p->relocs[i].lobj,
+                                                &p->validated);
                 }
         }
-        return radeon_object_list_validate(&p->validated, p->ib->fence);
+        return radeon_bo_list_validate(&p->validated, p->ib->fence);
 }
 
 int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)
@@ -190,9 +190,10 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error)
         unsigned i;
 
         if (error) {
-                radeon_object_list_unvalidate(&parser->validated);
+                radeon_bo_list_unvalidate(&parser->validated,
+                                                parser->ib->fence);
         } else {
-                radeon_object_list_clean(&parser->validated);
+                radeon_bo_list_unreserve(&parser->validated);
         }
         for (i = 0; i < parser->nrelocs; i++) {
                 if (parser->relocs[i].gobj) {
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index e3f9edfa40fe..7e55647f118e 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -208,6 +208,24 @@ bool radeon_card_posted(struct radeon_device *rdev)
 
 }
 
+bool radeon_boot_test_post_card(struct radeon_device *rdev)
+{
+        if (radeon_card_posted(rdev))
+                return true;
+
+        if (rdev->bios) {
+                DRM_INFO("GPU not posted. posting now...\n");
+                if (rdev->is_atom_bios)
+                        atom_asic_init(rdev->mode_info.atom_context);
+                else
+                        radeon_combios_asic_init(rdev->ddev);
+                return true;
+        } else {
+                dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n");
+                return false;
+        }
+}
+
 int radeon_dummy_page_init(struct radeon_device *rdev)
 {
         rdev->dummy_page.page = alloc_page(GFP_DMA32 | GFP_KERNEL | __GFP_ZERO);
@@ -463,11 +481,13 @@ int radeon_atombios_init(struct radeon_device *rdev)
 
         rdev->mode_info.atom_context = atom_parse(atom_card_info, rdev->bios);
         radeon_atom_initialize_bios_scratch_regs(rdev->ddev);
+        atom_allocate_fb_scratch(rdev->mode_info.atom_context);
         return 0;
 }
 
 void radeon_atombios_fini(struct radeon_device *rdev)
 {
+        kfree(rdev->mode_info.atom_context->scratch);
         kfree(rdev->mode_info.atom_context);
         kfree(rdev->mode_info.atom_card_info);
 }
@@ -544,16 +564,24 @@ int radeon_device_init(struct radeon_device *rdev,
         mutex_init(&rdev->cs_mutex);
         mutex_init(&rdev->ib_pool.mutex);
         mutex_init(&rdev->cp.mutex);
+        if (rdev->family >= CHIP_R600)
+                spin_lock_init(&rdev->ih.lock);
+        mutex_init(&rdev->gem.mutex);
         rwlock_init(&rdev->fence_drv.lock);
         INIT_LIST_HEAD(&rdev->gem.objects);
 
+        /* setup workqueue */
+        rdev->wq = create_workqueue("radeon");
+        if (rdev->wq == NULL)
+                return -ENOMEM;
+
         /* Set asic functions */
         r = radeon_asic_init(rdev);
         if (r) {
                 return r;
         }
 
-        if (radeon_agpmode == -1) {
+        if (rdev->flags & RADEON_IS_AGP && radeon_agpmode == -1) {
                 radeon_agp_disable(rdev);
         }
 
@@ -620,6 +648,7 @@ void radeon_device_fini(struct radeon_device *rdev)
         DRM_INFO("radeon: finishing device.\n");
         rdev->shutdown = true;
         radeon_fini(rdev);
+        destroy_workqueue(rdev->wq);
         vga_client_register(rdev->pdev, NULL, NULL, NULL);
         iounmap(rdev->rmmio);
         rdev->rmmio = NULL;
@@ -633,6 +662,7 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct drm_crtc *crtc;
+        int r;
 
         if (dev == NULL || rdev == NULL) {
                 return -ENODEV;
@@ -643,26 +673,31 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
         /* unpin the front buffers */
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
                 struct radeon_framebuffer *rfb = to_radeon_framebuffer(crtc->fb);
-                struct radeon_object *robj;
+                struct radeon_bo *robj;
 
                 if (rfb == NULL || rfb->obj == NULL) {
                         continue;
                 }
                 robj = rfb->obj->driver_private;
-                if (robj != rdev->fbdev_robj) {
-                        radeon_object_unpin(robj);
+                if (robj != rdev->fbdev_rbo) {
+                        r = radeon_bo_reserve(robj, false);
+                        if (unlikely(r == 0)) {
+                                radeon_bo_unpin(robj);
+                                radeon_bo_unreserve(robj);
+                        }
                 }
         }
         /* evict vram memory */
-        radeon_object_evict_vram(rdev);
+        radeon_bo_evict_vram(rdev);
         /* wait for gpu to finish processing current batch */
         radeon_fence_wait_last(rdev);
 
         radeon_save_bios_scratch_regs(rdev);
 
         radeon_suspend(rdev);
+        radeon_hpd_fini(rdev);
         /* evict remaining vram memory */
-        radeon_object_evict_vram(rdev);
+        radeon_bo_evict_vram(rdev);
 
         pci_save_state(dev->pdev);
         if (state.event == PM_EVENT_SUSPEND) {
@@ -688,11 +723,15 @@ int radeon_resume_kms(struct drm_device *dev)
                 return -1;
         }
         pci_set_master(dev->pdev);
+        /* resume AGP if in use */
+        radeon_agp_resume(rdev);
         radeon_resume(rdev);
         radeon_restore_bios_scratch_regs(rdev);
         fb_set_suspend(rdev->fbdev_info, 0);
         release_console_sem();
 
+        /* reset hpd state */
+        radeon_hpd_init(rdev);
         /* blat the mode back in */
         drm_helper_resume_force_mode(dev);
         return 0;
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index c85df4afcb7a..c115f2e442eb 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -250,6 +250,16 @@ static const char *connector_names[13] = {
         "HDMI-B",
 };
 
+static const char *hpd_names[7] = {
+        "NONE",
+        "HPD1",
+        "HPD2",
+        "HPD3",
+        "HPD4",
+        "HPD5",
+        "HPD6",
+};
+
 static void radeon_print_display_setup(struct drm_device *dev)
 {
         struct drm_connector *connector;
@@ -264,16 +274,18 @@ static void radeon_print_display_setup(struct drm_device *dev)
                 radeon_connector = to_radeon_connector(connector);
                 DRM_INFO("Connector %d:\n", i);
                 DRM_INFO("  %s\n", connector_names[connector->connector_type]);
+                if (radeon_connector->hpd.hpd != RADEON_HPD_NONE)
+                        DRM_INFO("  %s\n", hpd_names[radeon_connector->hpd.hpd]);
                 if (radeon_connector->ddc_bus)
                         DRM_INFO("  DDC: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                                  radeon_connector->ddc_bus->rec.mask_clk_reg,
                                  radeon_connector->ddc_bus->rec.mask_data_reg,
                                  radeon_connector->ddc_bus->rec.a_clk_reg,
                                  radeon_connector->ddc_bus->rec.a_data_reg,
-                                 radeon_connector->ddc_bus->rec.put_clk_reg,
-                                 radeon_connector->ddc_bus->rec.put_data_reg,
-                                 radeon_connector->ddc_bus->rec.get_clk_reg,
-                                 radeon_connector->ddc_bus->rec.get_data_reg);
+                                 radeon_connector->ddc_bus->rec.en_clk_reg,
+                                 radeon_connector->ddc_bus->rec.en_data_reg,
+                                 radeon_connector->ddc_bus->rec.y_clk_reg,
+                                 radeon_connector->ddc_bus->rec.y_data_reg);
                 DRM_INFO("  Encoders:\n");
                 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                         radeon_encoder = to_radeon_encoder(encoder);
@@ -324,6 +336,7 @@ static bool radeon_setup_enc_conn(struct drm_device *dev)
                         ret = radeon_get_legacy_connector_info_from_table(dev);
         }
         if (ret) {
+                radeon_setup_encoder_clones(dev);
                 radeon_print_display_setup(dev);
                 list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head)
                         radeon_ddc_dump(drm_connector);
@@ -336,12 +349,17 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
 {
         int ret = 0;
 
+        if (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
+                struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
+                if (dig->dp_i2c_bus)
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base, &dig->dp_i2c_bus->adapter);
+        }
         if (!radeon_connector->ddc_bus)
                 return -1;
         if (!radeon_connector->edid) {
-                radeon_i2c_do_lock(radeon_connector, 1);
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
-                radeon_i2c_do_lock(radeon_connector, 0);
+                radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
         }
 
         if (radeon_connector->edid) {
@@ -361,9 +379,9 @@ static int radeon_ddc_dump(struct drm_connector *connector)
 
         if (!radeon_connector->ddc_bus)
                 return -1;
-        radeon_i2c_do_lock(radeon_connector, 1);
+        radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
         edid = drm_get_edid(connector, &radeon_connector->ddc_bus->adapter);
-        radeon_i2c_do_lock(radeon_connector, 0);
+        radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
         if (edid) {
                 kfree(edid);
         }
@@ -723,6 +741,8 @@ int radeon_modeset_init(struct radeon_device *rdev)
         if (!ret) {
                 return ret;
         }
+        /* initialize hpd */
+        radeon_hpd_init(rdev);
         drm_helper_initial_config(rdev->ddev);
         return 0;
 }
@@ -730,6 +750,7 @@ int radeon_modeset_init(struct radeon_device *rdev)
 void radeon_modeset_fini(struct radeon_device *rdev)
 {
         if (rdev->mode_info.mode_config_initialized) {
+                radeon_hpd_fini(rdev);
                 drm_mode_config_cleanup(rdev->ddev);
                 rdev->mode_info.mode_config_initialized = false;
         }
@@ -750,9 +771,17 @@ bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
                 if (encoder->crtc != crtc)
                         continue;
                 if (first) {
-                        radeon_crtc->rmx_type = radeon_encoder->rmx_type;
+                        /* set scaling */
+                        if (radeon_encoder->rmx_type == RMX_OFF)
+                                radeon_crtc->rmx_type = RMX_OFF;
+                        else if (mode->hdisplay < radeon_encoder->native_mode.hdisplay ||
+                                 mode->vdisplay < radeon_encoder->native_mode.vdisplay)
+                                radeon_crtc->rmx_type = radeon_encoder->rmx_type;
+                        else
+                                radeon_crtc->rmx_type = RMX_OFF;
+                        /* copy native mode */
                         memcpy(&radeon_crtc->native_mode,
-                                &radeon_encoder->native_mode,
+                               &radeon_encoder->native_mode,
                                 sizeof(struct drm_display_mode));
                         first = false;
                 } else {
diff --git a/drivers/gpu/drm/radeon/radeon_drv.h b/drivers/gpu/drm/radeon/radeon_drv.h
index 350962e0f346..e13785282a82 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.h
+++ b/drivers/gpu/drm/radeon/radeon_drv.h
@@ -1104,7 +1104,6 @@ extern u32 radeon_get_scratch(drm_radeon_private_t *dev_priv, int index);
 #       define R600_IT_WAIT_REG_MEM             0x00003C00
 #       define R600_IT_MEM_WRITE                0x00003D00
 #       define R600_IT_INDIRECT_BUFFER          0x00003200
-#       define R600_IT_CP_INTERRUPT             0x00004000
 #       define R600_IT_SURFACE_SYNC             0x00004300
 #              define R600_CB0_DEST_BASE_ENA    (1 << 6)
 #              define R600_TC_ACTION_ENA        (1 << 23)
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c
index d42bc512d75a..b4f23ec93201 100644
--- a/drivers/gpu/drm/radeon/radeon_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_encoders.c
@@ -35,6 +35,51 @@ extern int atom_debug;
 bool radeon_atom_get_tv_timings(struct radeon_device *rdev, int index,
                                 struct drm_display_mode *mode);
 
+static uint32_t radeon_encoder_clones(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct drm_encoder *clone_encoder;
+        uint32_t index_mask = 0;
+        int count;
+
+        /* DIG routing gets problematic */
+        if (rdev->family >= CHIP_R600)
+                return index_mask;
+        /* LVDS/TV are too wacky */
+        if (radeon_encoder->devices & ATOM_DEVICE_LCD_SUPPORT)
+                return index_mask;
+        /* DVO requires 2x ppll clocks depending on tmds chip */
+        if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT)
+                return index_mask;
+        
+        count = -1;
+        list_for_each_entry(clone_encoder, &dev->mode_config.encoder_list, head) {
+                struct radeon_encoder *radeon_clone = to_radeon_encoder(clone_encoder);
+                count++;
+
+                if (clone_encoder == encoder)
+                        continue;
+                if (radeon_clone->devices & (ATOM_DEVICE_LCD_SUPPORT))
+                        continue;
+                if (radeon_clone->devices & ATOM_DEVICE_DFP2_SUPPORT)
+                        continue;
+                else
+                        index_mask |= (1 << count);
+        }
+        return index_mask;
+}
+
+void radeon_setup_encoder_clones(struct drm_device *dev)
+{
+        struct drm_encoder *encoder;
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+                encoder->possible_clones = radeon_encoder_clones(encoder);
+        }
+}
+
 uint32_t
 radeon_get_encoder_id(struct drm_device *dev, uint32_t supported_device, uint8_t dac)
 {
@@ -163,29 +208,6 @@ radeon_get_connector_for_encoder(struct drm_encoder *encoder)
         return NULL;
 }
 
-/* used for both atom and legacy */
-void radeon_rmx_mode_fixup(struct drm_encoder *encoder,
-                           struct drm_display_mode *mode,
-                           struct drm_display_mode *adjusted_mode)
-{
-        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
-        struct drm_device *dev = encoder->dev;
-        struct radeon_device *rdev = dev->dev_private;
-        struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
-
-        if (mode->hdisplay < native_mode->hdisplay ||
-            mode->vdisplay < native_mode->vdisplay) {
-                int mode_id = adjusted_mode->base.id;
-                *adjusted_mode = *native_mode;
-                if (!ASIC_IS_AVIVO(rdev)) {
-                        adjusted_mode->hdisplay = mode->hdisplay;
-                        adjusted_mode->vdisplay = mode->vdisplay;
-                }
-                adjusted_mode->base.id = mode_id;
-        }
-}
-
-
 static bool radeon_atom_mode_fixup(struct drm_encoder *encoder,
                                    struct drm_display_mode *mode,
                                    struct drm_display_mode *adjusted_mode)
@@ -198,14 +220,24 @@ static bool radeon_atom_mode_fixup(struct drm_encoder *encoder,
         radeon_encoder_set_active_device(encoder);
         drm_mode_set_crtcinfo(adjusted_mode, 0);
 
-        if (radeon_encoder->rmx_type != RMX_OFF)
-                radeon_rmx_mode_fixup(encoder, mode, adjusted_mode);
-
         /* hw bug */
         if ((mode->flags & DRM_MODE_FLAG_INTERLACE)
             && (mode->crtc_vsync_start < (mode->crtc_vdisplay + 2)))
                 adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + 2;
 
+        /* get the native mode for LVDS */
+        if (radeon_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT)) {
+                struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
+                int mode_id = adjusted_mode->base.id;
+                *adjusted_mode = *native_mode;
+                if (!ASIC_IS_AVIVO(rdev)) {
+                        adjusted_mode->hdisplay = mode->hdisplay;
+                        adjusted_mode->vdisplay = mode->vdisplay;
+                }
+                adjusted_mode->base.id = mode_id;
+        }
+
+        /* get the native mode for TV */
         if (radeon_encoder->active_device & (ATOM_DEVICE_TV_SUPPORT)) {
                 struct radeon_encoder_atom_dac *tv_dac = radeon_encoder->enc_priv;
                 if (tv_dac) {
@@ -218,6 +250,12 @@ static bool radeon_atom_mode_fixup(struct drm_encoder *encoder,
                 }
         }
 
+        if (ASIC_IS_DCE3(rdev) &&
+            (radeon_encoder->active_device & (ATOM_DEVICE_DFP_SUPPORT))) {
+                struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
+                radeon_dp_set_link_config(connector, mode);
+        }
+
         return true;
 }
 
@@ -392,7 +430,7 @@ union lvds_encoder_control {
         LVDS_ENCODER_CONTROL_PS_ALLOCATION_V2 v2;
 };
 
-static void
+void
 atombios_digital_setup(struct drm_encoder *encoder, int action)
 {
         struct drm_device *dev = encoder->dev;
@@ -522,6 +560,7 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
 {
         struct drm_connector *connector;
         struct radeon_connector *radeon_connector;
+        struct radeon_connector_atom_dig *radeon_dig_connector;
 
         connector = radeon_get_connector_for_encoder(encoder);
         if (!connector)
@@ -551,10 +590,10 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
                 return ATOM_ENCODER_MODE_LVDS;
                 break;
         case DRM_MODE_CONNECTOR_DisplayPort:
-                /*if (radeon_output->MonType == MT_DP)
-                  return ATOM_ENCODER_MODE_DP;
-                  else*/
-                if (drm_detect_hdmi_monitor(radeon_connector->edid))
+                radeon_dig_connector = radeon_connector->con_priv;
+                if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
+                        return ATOM_ENCODER_MODE_DP;
+                else if (drm_detect_hdmi_monitor(radeon_connector->edid))
                         return ATOM_ENCODER_MODE_HDMI;
                 else
                         return ATOM_ENCODER_MODE_DVI;
@@ -573,6 +612,30 @@ atombios_get_encoder_mode(struct drm_encoder *encoder)
         }
 }
 
+/*
+ * DIG Encoder/Transmitter Setup
+ *
+ * DCE 3.0/3.1
+ * - 2 DIG transmitter blocks. UNIPHY (links A and B) and LVTMA.
+ * Supports up to 3 digital outputs
+ * - 2 DIG encoder blocks.
+ * DIG1 can drive UNIPHY link A or link B
+ * DIG2 can drive UNIPHY link B or LVTMA
+ *
+ * DCE 3.2
+ * - 3 DIG transmitter blocks. UNIPHY0/1/2 (links A and B).
+ * Supports up to 5 digital outputs
+ * - 2 DIG encoder blocks.
+ * DIG1/2 can drive UNIPHY0/1/2 link A or link B
+ *
+ * Routing
+ * crtc -> dig encoder -> UNIPHY/LVTMA (1 or 2 links)
+ * Examples:
+ * crtc0 -> dig2 -> LVTMA   links A+B -> TMDS/HDMI
+ * crtc1 -> dig1 -> UNIPHY0 link  B   -> DP
+ * crtc0 -> dig1 -> UNIPHY2 link  A   -> LVDS
+ * crtc1 -> dig2 -> UNIPHY1 link  B+A -> TMDS/HDMI
+ */
 static void
 atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
 {
@@ -614,10 +677,17 @@ atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
         } else {
                 switch (radeon_encoder->encoder_id) {
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
-                        index = GetIndexIntoMasterTable(COMMAND, DIG1EncoderControl);
+                        /* XXX doesn't really matter which dig encoder we pick as long as it's
+                         * not already in use
+                         */
+                        if (dig_connector->linkb)
+                                index = GetIndexIntoMasterTable(COMMAND, DIG2EncoderControl);
+                        else
+                                index = GetIndexIntoMasterTable(COMMAND, DIG1EncoderControl);
                         num = 1;
                         break;
                 case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
+                        /* Only dig2 encoder can drive LVTMA */
                         index = GetIndexIntoMasterTable(COMMAND, DIG2EncoderControl);
                         num = 2;
                         break;
@@ -652,18 +722,21 @@ atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
                 }
         }
 
-        if (radeon_encoder->pixel_clock > 165000) {
-                args.ucConfig |= ATOM_ENCODER_CONFIG_LINKA_B;
+        args.ucEncoderMode = atombios_get_encoder_mode(encoder);
+
+        if (args.ucEncoderMode == ATOM_ENCODER_MODE_DP) {
+                if (dig_connector->dp_clock == 270000)
+                        args.ucConfig |= ATOM_ENCODER_CONFIG_DPLINKRATE_2_70GHZ;
+                args.ucLaneNum = dig_connector->dp_lane_count;
+        } else if (radeon_encoder->pixel_clock > 165000)
                 args.ucLaneNum = 8;
-        } else {
-                if (dig_connector->linkb)
-                        args.ucConfig |= ATOM_ENCODER_CONFIG_LINKB;
-                else
-                        args.ucConfig |= ATOM_ENCODER_CONFIG_LINKA;
+        else
                 args.ucLaneNum = 4;
-        }
 
-        args.ucEncoderMode = atombios_get_encoder_mode(encoder);
+        if (dig_connector->linkb)
+                args.ucConfig |= ATOM_ENCODER_CONFIG_LINKB;
+        else
+                args.ucConfig |= ATOM_ENCODER_CONFIG_LINKA;
 
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 
@@ -674,8 +747,8 @@ union dig_transmitter_control {
         DIG_TRANSMITTER_CONTROL_PARAMETERS_V2 v2;
 };
 
-static void
-atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
+void
+atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t lane_num, uint8_t lane_set)
 {
         struct drm_device *dev = encoder->dev;
         struct radeon_device *rdev = dev->dev_private;
@@ -687,6 +760,7 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
         struct drm_connector *connector;
         struct radeon_connector *radeon_connector;
         struct radeon_connector_atom_dig *dig_connector;
+        bool is_dp = false;
 
         connector = radeon_get_connector_for_encoder(encoder);
         if (!connector)
@@ -704,6 +778,9 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
 
         dig_connector = radeon_connector->con_priv;
 
+        if (atombios_get_encoder_mode(encoder) == ATOM_ENCODER_MODE_DP)
+                is_dp = true;
+
         memset(&args, 0, sizeof(args));
 
         if (ASIC_IS_DCE32(rdev))
@@ -724,17 +801,23 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
         args.v1.ucAction = action;
         if (action == ATOM_TRANSMITTER_ACTION_INIT) {
                 args.v1.usInitInfo = radeon_connector->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 (radeon_encoder->pixel_clock > 165000)
+                if (is_dp)
+                        args.v1.usPixelClock =
+                                cpu_to_le16(dig_connector->dp_clock / 10);
+                else if (radeon_encoder->pixel_clock > 165000)
                         args.v1.usPixelClock = cpu_to_le16((radeon_encoder->pixel_clock / 2) / 10);
                 else
                         args.v1.usPixelClock = cpu_to_le16(radeon_encoder->pixel_clock / 10);
         }
         if (ASIC_IS_DCE32(rdev)) {
-                if (radeon_encoder->pixel_clock > 165000)
-                        args.v2.usPixelClock = cpu_to_le16((radeon_encoder->pixel_clock / 2) / 10);
                 if (dig->dig_block)
                         args.v2.acConfig.ucEncoderSel = 1;
+                if (dig_connector->linkb)
+                        args.v2.acConfig.ucLinkSel = 1;
 
                 switch (radeon_encoder->encoder_id) {
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
@@ -751,7 +834,9 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
                         break;
                 }
 
-                if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) {
+                if (is_dp)
+                        args.v2.acConfig.fCoherentMode = 1;
+                else if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) {
                         if (dig->coherent_mode)
                                 args.v2.acConfig.fCoherentMode = 1;
                 }
@@ -760,17 +845,20 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
 
                 switch (radeon_encoder->encoder_id) {
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
-                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG1_ENCODER;
+                        /* XXX doesn't really matter which dig encoder we pick as long as it's
+                         * not already in use
+                         */
+                        if (dig_connector->linkb)
+                                args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG2_ENCODER;
+                        else
+                                args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG1_ENCODER;
                         if (rdev->flags & RADEON_IS_IGP) {
                                 if (radeon_encoder->pixel_clock > 165000) {
-                                        args.v1.ucConfig |= (ATOM_TRANSMITTER_CONFIG_8LANE_LINK |
-                                                             ATOM_TRANSMITTER_CONFIG_LINKA_B);
                                         if (dig_connector->igp_lane_info & 0x3)
                                                 args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_0_7;
                                         else if (dig_connector->igp_lane_info & 0xc)
                                                 args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_8_15;
                                 } else {
-                                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKA;
                                         if (dig_connector->igp_lane_info & 0x1)
                                                 args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_0_3;
                                         else if (dig_connector->igp_lane_info & 0x2)
@@ -780,35 +868,25 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action)
                                         else if (dig_connector->igp_lane_info & 0x8)
                                                 args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LANE_12_15;
                                 }
-                        } else {
-                                if (radeon_encoder->pixel_clock > 165000)
-                                        args.v1.ucConfig |= (ATOM_TRANSMITTER_CONFIG_8LANE_LINK |
-                                                             ATOM_TRANSMITTER_CONFIG_LINKA_B |
-                                                             ATOM_TRANSMITTER_CONFIG_LANE_0_7);
-                                else {
-                                        if (dig_connector->linkb)
-                                                args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKB | ATOM_TRANSMITTER_CONFIG_LANE_0_3;
-                                        else
-                                                args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKA | ATOM_TRANSMITTER_CONFIG_LANE_0_3;
-                                }
                         }
                         break;
                 case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
+                        /* Only dig2 encoder can drive LVTMA */
                         args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG2_ENCODER;
-                        if (radeon_encoder->pixel_clock > 165000)
-                                args.v1.ucConfig |= (ATOM_TRANSMITTER_CONFIG_8LANE_LINK |
-                                                     ATOM_TRANSMITTER_CONFIG_LINKA_B |
-                                                     ATOM_TRANSMITTER_CONFIG_LANE_0_7);
-                        else {
-                                if (dig_connector->linkb)
-                                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKB | ATOM_TRANSMITTER_CONFIG_LANE_0_3;
-                                else
-                                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKA | ATOM_TRANSMITTER_CONFIG_LANE_0_3;
-                        }
                         break;
                 }
 
-                if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) {
+                if (radeon_encoder->pixel_clock > 165000)
+                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_8LANE_LINK;
+
+                if (dig_connector->linkb)
+                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKB;
+                else
+                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_LINKA;
+
+                if (is_dp)
+                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_COHERENT;
+                else if (radeon_encoder->devices & (ATOM_DEVICE_DFP_SUPPORT)) {
                         if (dig->coherent_mode)
                                 args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_COHERENT;
                 }
@@ -918,12 +996,16 @@ radeon_atom_encoder_dpms(struct drm_encoder *encoder, int mode)
         if (is_dig) {
                 switch (mode) {
                 case DRM_MODE_DPMS_ON:
-                        atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE);
+                        atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE_OUTPUT, 0, 0);
+                        {
+                                struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
+                                dp_link_train(encoder, connector);
+                        }
                         break;
                 case DRM_MODE_DPMS_STANDBY:
                 case DRM_MODE_DPMS_SUSPEND:
                 case DRM_MODE_DPMS_OFF:
-                        atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_DISABLE);
+                        atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_DISABLE_OUTPUT, 0, 0);
                         break;
                 }
         } else {
@@ -1025,13 +1107,33 @@ atombios_set_encoder_crtc_source(struct drm_encoder *encoder)
                                                 args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
                                         else
                                                 args.v2.ucEncoderID = ASIC_INT_DIG1_ENCODER_ID;
-                                } else
-                                        args.v2.ucEncoderID = ASIC_INT_DIG1_ENCODER_ID;
+                                } else {
+                                        struct drm_connector *connector;
+                                        struct radeon_connector *radeon_connector;
+                                        struct radeon_connector_atom_dig *dig_connector;
+
+                                        connector = radeon_get_connector_for_encoder(encoder);
+                                        if (!connector)
+                                                return;
+                                        radeon_connector = to_radeon_connector(connector);
+                                        if (!radeon_connector->con_priv)
+                                                return;
+                                        dig_connector = radeon_connector->con_priv;
+
+                                        /* XXX doesn't really matter which dig encoder we pick as long as it's
+                                         * not already in use
+                                         */
+                                        if (dig_connector->linkb)
+                                                args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
+                                        else
+                                                args.v2.ucEncoderID = ASIC_INT_DIG1_ENCODER_ID;
+                                }
                                 break;
                         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1:
                                 args.v2.ucEncoderID = ASIC_INT_DVO_ENCODER_ID;
                                 break;
                         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
+                                /* Only dig2 encoder can drive LVTMA */
                                 args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
                                 break;
                         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1:
@@ -1104,11 +1206,14 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder,
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
         struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
 
-        if (radeon_encoder->enc_priv) {
-                struct radeon_encoder_atom_dig *dig;
+        if (radeon_encoder->active_device &
+            (ATOM_DEVICE_DFP_SUPPORT | ATOM_DEVICE_LCD_SUPPORT)) {
+                if (radeon_encoder->enc_priv) {
+                        struct radeon_encoder_atom_dig *dig;
 
-                dig = radeon_encoder->enc_priv;
-                dig->dig_block = radeon_crtc->crtc_id;
+                        dig = radeon_encoder->enc_priv;
+                        dig->dig_block = radeon_crtc->crtc_id;
+                }
         }
         radeon_encoder->pixel_clock = adjusted_mode->clock;
 
@@ -1134,14 +1239,14 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder,
         case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2:
         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
                 /* disable the encoder and transmitter */
-                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_DISABLE);
+                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_DISABLE, 0, 0);
                 atombios_dig_encoder_setup(encoder, ATOM_DISABLE);
 
                 /* setup and enable the encoder and transmitter */
                 atombios_dig_encoder_setup(encoder, ATOM_ENABLE);
-                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_INIT);
-                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_SETUP);
-                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE);
+                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_INIT, 0, 0);
+                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_SETUP, 0, 0);
+                atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE, 0, 0);
                 break;
         case ENCODER_OBJECT_ID_INTERNAL_DDI:
                 atombios_ddia_setup(encoder, ATOM_ENABLE);
@@ -1354,7 +1459,6 @@ radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t su
                 encoder->possible_crtcs = 0x1;
         else
                 encoder->possible_crtcs = 0x3;
-        encoder->possible_clones = 0;
 
         radeon_encoder->enc_priv = NULL;
 
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c
index b38c4c8e2c61..66055b3d8668 100644
--- a/drivers/gpu/drm/radeon/radeon_fb.c
+++ b/drivers/gpu/drm/radeon/radeon_fb.c
@@ -140,7 +140,7 @@ int radeonfb_create(struct drm_device *dev,
         struct radeon_framebuffer *rfb;
         struct drm_mode_fb_cmd mode_cmd;
         struct drm_gem_object *gobj = NULL;
-        struct radeon_object *robj = NULL;
+        struct radeon_bo *rbo = NULL;
         struct device *device = &rdev->pdev->dev;
         int size, aligned_size, ret;
         u64 fb_gpuaddr;
@@ -168,14 +168,14 @@ int radeonfb_create(struct drm_device *dev,
         ret = radeon_gem_object_create(rdev, aligned_size, 0,
                         RADEON_GEM_DOMAIN_VRAM,
                         false, ttm_bo_type_kernel,
-                        false, &gobj);
+                        &gobj);
         if (ret) {
                 printk(KERN_ERR "failed to allocate framebuffer (%d %d)\n",
                        surface_width, surface_height);
                 ret = -ENOMEM;
                 goto out;
         }
-        robj = gobj->driver_private;
+        rbo = gobj->driver_private;
 
         if (fb_tiled)
                 tiling_flags = RADEON_TILING_MACRO;
@@ -192,8 +192,13 @@ int radeonfb_create(struct drm_device *dev,
         }
 #endif
 
-        if (tiling_flags)
-                radeon_object_set_tiling_flags(robj, tiling_flags | RADEON_TILING_SURFACE, mode_cmd.pitch);
+        if (tiling_flags) {
+                ret = radeon_bo_set_tiling_flags(rbo,
+                                        tiling_flags | RADEON_TILING_SURFACE,
+                                        mode_cmd.pitch);
+                if (ret)
+                        dev_err(rdev->dev, "FB failed to set tiling flags\n");
+        }
         mutex_lock(&rdev->ddev->struct_mutex);
         fb = radeon_framebuffer_create(rdev->ddev, &mode_cmd, gobj);
         if (fb == NULL) {
@@ -201,10 +206,19 @@ int radeonfb_create(struct drm_device *dev,
                 ret = -ENOMEM;
                 goto out_unref;
         }
-        ret = radeon_object_pin(robj, RADEON_GEM_DOMAIN_VRAM, &fb_gpuaddr);
+        ret = radeon_bo_reserve(rbo, false);
+        if (unlikely(ret != 0))
+                goto out_unref;
+        ret = radeon_bo_pin(rbo, RADEON_GEM_DOMAIN_VRAM, &fb_gpuaddr);
+        if (ret) {
+                radeon_bo_unreserve(rbo);
+                goto out_unref;
+        }
+        if (fb_tiled)
+                radeon_bo_check_tiling(rbo, 0, 0);
+        ret = radeon_bo_kmap(rbo, &fbptr);
+        radeon_bo_unreserve(rbo);
         if (ret) {
-                printk(KERN_ERR "failed to pin framebuffer\n");
-                ret = -ENOMEM;
                 goto out_unref;
         }
 
@@ -213,7 +227,7 @@ int radeonfb_create(struct drm_device *dev,
         *fb_p = fb;
         rfb = to_radeon_framebuffer(fb);
         rdev->fbdev_rfb = rfb;
-        rdev->fbdev_robj = robj;
+        rdev->fbdev_rbo = rbo;
 
         info = framebuffer_alloc(sizeof(struct radeon_fb_device), device);
         if (info == NULL) {
@@ -234,15 +248,7 @@ int radeonfb_create(struct drm_device *dev,
         if (ret)
                 goto out_unref;
 
-        if (fb_tiled)
-                radeon_object_check_tiling(robj, 0, 0);
-
-        ret = radeon_object_kmap(robj, &fbptr);
-        if (ret) {
-                goto out_unref;
-        }
-
-        memset_io(fbptr, 0, aligned_size);
+        memset_io(fbptr, 0xff, aligned_size);
 
         strcpy(info->fix.id, "radeondrmfb");
 
@@ -288,8 +294,12 @@ int radeonfb_create(struct drm_device *dev,
         return 0;
 
 out_unref:
-        if (robj) {
-                radeon_object_kunmap(robj);
+        if (rbo) {
+                ret = radeon_bo_reserve(rbo, false);
+                if (likely(ret == 0)) {
+                        radeon_bo_kunmap(rbo);
+                        radeon_bo_unreserve(rbo);
+                }
         }
         if (fb && ret) {
                 list_del(&fb->filp_head);
@@ -321,14 +331,22 @@ int radeon_parse_options(char *options)
 
 int radeonfb_probe(struct drm_device *dev)
 {
-        return drm_fb_helper_single_fb_probe(dev, 32, &radeonfb_create);
+        struct radeon_device *rdev = dev->dev_private;
+        int bpp_sel = 32;
+
+        /* select 8 bpp console on RN50 or 16MB cards */
+        if (ASIC_IS_RN50(rdev) || rdev->mc.real_vram_size <= (32*1024*1024))
+                bpp_sel = 8;
+
+        return drm_fb_helper_single_fb_probe(dev, bpp_sel, &radeonfb_create);
 }
 
 int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb)
 {
         struct fb_info *info;
         struct radeon_framebuffer *rfb = to_radeon_framebuffer(fb);
-        struct radeon_object *robj;
+        struct radeon_bo *rbo;
+        int r;
 
         if (!fb) {
                 return -EINVAL;
@@ -336,10 +354,14 @@ int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb)
         info = fb->fbdev;
         if (info) {
                 struct radeon_fb_device *rfbdev = info->par;
-                robj = rfb->obj->driver_private;
+                rbo = rfb->obj->driver_private;
                 unregister_framebuffer(info);
-                radeon_object_kunmap(robj);
-                radeon_object_unpin(robj);
+                r = radeon_bo_reserve(rbo, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rbo);
+                        radeon_bo_unpin(rbo);
+                        radeon_bo_unreserve(rbo);
+                }
                 drm_fb_helper_free(&rfbdev->helper);
                 framebuffer_release(info);
         }
diff --git a/drivers/gpu/drm/radeon/radeon_fence.c b/drivers/gpu/drm/radeon/radeon_fence.c
index 3beb26d74719..2ac31633d72c 100644
--- a/drivers/gpu/drm/radeon/radeon_fence.c
+++ b/drivers/gpu/drm/radeon/radeon_fence.c
@@ -168,37 +168,6 @@ bool radeon_fence_signaled(struct radeon_fence *fence)
         return signaled;
 }
 
-int r600_fence_wait(struct radeon_fence *fence,  bool intr, bool lazy)
-{
-        struct radeon_device *rdev;
-        int ret = 0;
-
-        rdev = fence->rdev;
-
-        __set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
-
-        while (1) {
-                if (radeon_fence_signaled(fence))
-                        break;
-
-                if (time_after_eq(jiffies, fence->timeout)) {
-                        ret = -EBUSY;
-                        break;
-                }
-
-                if (lazy)
-                        schedule_timeout(1);
-
-                if (intr && signal_pending(current)) {
-                        ret = -ERESTARTSYS;
-                        break;
-                }
-        }
-        __set_current_state(TASK_RUNNING);
-        return ret;
-}
-
-
 int radeon_fence_wait(struct radeon_fence *fence, bool intr)
 {
         struct radeon_device *rdev;
@@ -216,13 +185,6 @@ int radeon_fence_wait(struct radeon_fence *fence, bool intr)
                 return 0;
         }
 
-        if (rdev->family >= CHIP_R600) {
-                r = r600_fence_wait(fence, intr, 0);
-                if (r == -ERESTARTSYS)
-                        return -EBUSY;
-                return r;
-        }
-
 retry:
         cur_jiffies = jiffies;
         timeout = HZ / 100;
@@ -231,14 +193,18 @@ retry:
         }
 
         if (intr) {
+                radeon_irq_kms_sw_irq_get(rdev);
                 r = wait_event_interruptible_timeout(rdev->fence_drv.queue,
                                 radeon_fence_signaled(fence), timeout);
+                radeon_irq_kms_sw_irq_put(rdev);
                 if (unlikely(r == -ERESTARTSYS)) {
                         return -EBUSY;
                 }
         } else {
+                radeon_irq_kms_sw_irq_get(rdev);
                 r = wait_event_timeout(rdev->fence_drv.queue,
                          radeon_fence_signaled(fence), timeout);
+                radeon_irq_kms_sw_irq_put(rdev);
         }
         if (unlikely(!radeon_fence_signaled(fence))) {
                 if (unlikely(r == 0)) {
diff --git a/drivers/gpu/drm/radeon/radeon_gart.c b/drivers/gpu/drm/radeon/radeon_gart.c
index a68d7566178c..e73d56e83fa6 100644
--- a/drivers/gpu/drm/radeon/radeon_gart.c
+++ b/drivers/gpu/drm/radeon/radeon_gart.c
@@ -78,11 +78,9 @@ int radeon_gart_table_vram_alloc(struct radeon_device *rdev)
         int r;
 
         if (rdev->gart.table.vram.robj == NULL) {
-                r = radeon_object_create(rdev, NULL,
-                                         rdev->gart.table_size,
-                                         true,
-                                         RADEON_GEM_DOMAIN_VRAM,
-                                         false, &rdev->gart.table.vram.robj);
+                r = radeon_bo_create(rdev, NULL, rdev->gart.table_size,
+                                        true, RADEON_GEM_DOMAIN_VRAM,
+                                        &rdev->gart.table.vram.robj);
                 if (r) {
                         return r;
                 }
@@ -95,32 +93,38 @@ int radeon_gart_table_vram_pin(struct radeon_device *rdev)
         uint64_t gpu_addr;
         int r;
 
-        r = radeon_object_pin(rdev->gart.table.vram.robj,
-                              RADEON_GEM_DOMAIN_VRAM, &gpu_addr);
-        if (r) {
-                radeon_object_unref(&rdev->gart.table.vram.robj);
+        r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
+        if (unlikely(r != 0))
                 return r;
-        }
-        r = radeon_object_kmap(rdev->gart.table.vram.robj,
-                               (void **)&rdev->gart.table.vram.ptr);
+        r = radeon_bo_pin(rdev->gart.table.vram.robj,
+                                RADEON_GEM_DOMAIN_VRAM, &gpu_addr);
         if (r) {
-                radeon_object_unpin(rdev->gart.table.vram.robj);
-                radeon_object_unref(&rdev->gart.table.vram.robj);
-                DRM_ERROR("radeon: failed to map gart vram table.\n");
+                radeon_bo_unreserve(rdev->gart.table.vram.robj);
                 return r;
         }
+        r = radeon_bo_kmap(rdev->gart.table.vram.robj,
+                                (void **)&rdev->gart.table.vram.ptr);
+        if (r)
+                radeon_bo_unpin(rdev->gart.table.vram.robj);
+        radeon_bo_unreserve(rdev->gart.table.vram.robj);
         rdev->gart.table_addr = gpu_addr;
-        return 0;
+        return r;
 }
 
 void radeon_gart_table_vram_free(struct radeon_device *rdev)
 {
+        int r;
+
         if (rdev->gart.table.vram.robj == NULL) {
                 return;
         }
-        radeon_object_kunmap(rdev->gart.table.vram.robj);
-        radeon_object_unpin(rdev->gart.table.vram.robj);
-        radeon_object_unref(&rdev->gart.table.vram.robj);
+        r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
+        if (likely(r == 0)) {
+                radeon_bo_kunmap(rdev->gart.table.vram.robj);
+                radeon_bo_unpin(rdev->gart.table.vram.robj);
+                radeon_bo_unreserve(rdev->gart.table.vram.robj);
+        }
+        radeon_bo_unref(&rdev->gart.table.vram.robj);
 }
 
 
diff --git a/drivers/gpu/drm/radeon/radeon_gem.c b/drivers/gpu/drm/radeon/radeon_gem.c
index d880edf254db..e927f998f76f 100644
--- a/drivers/gpu/drm/radeon/radeon_gem.c
+++ b/drivers/gpu/drm/radeon/radeon_gem.c
@@ -38,22 +38,21 @@ int radeon_gem_object_init(struct drm_gem_object *obj)
 
 void radeon_gem_object_free(struct drm_gem_object *gobj)
 {
-        struct radeon_object *robj = gobj->driver_private;
+        struct radeon_bo *robj = gobj->driver_private;
 
         gobj->driver_private = NULL;
         if (robj) {
-                radeon_object_unref(&robj);
+                radeon_bo_unref(&robj);
         }
 }
 
 int radeon_gem_object_create(struct radeon_device *rdev, int size,
-                             int alignment, int initial_domain,
-                             bool discardable, bool kernel,
-                             bool interruptible,
-                             struct drm_gem_object **obj)
+                                int alignment, int initial_domain,
+                                bool discardable, bool kernel,
+                                struct drm_gem_object **obj)
 {
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         int r;
 
         *obj = NULL;
@@ -65,8 +64,7 @@ int radeon_gem_object_create(struct radeon_device *rdev, int size,
         if (alignment < PAGE_SIZE) {
                 alignment = PAGE_SIZE;
         }
-        r = radeon_object_create(rdev, gobj, size, kernel, initial_domain,
-                                 interruptible, &robj);
+        r = radeon_bo_create(rdev, gobj, size, kernel, initial_domain, &robj);
         if (r) {
                 DRM_ERROR("Failed to allocate GEM object (%d, %d, %u)\n",
                           size, initial_domain, alignment);
@@ -83,33 +81,33 @@ int radeon_gem_object_create(struct radeon_device *rdev, int size,
 int radeon_gem_object_pin(struct drm_gem_object *obj, uint32_t pin_domain,
                           uint64_t *gpu_addr)
 {
-        struct radeon_object *robj = obj->driver_private;
-        uint32_t flags;
+        struct radeon_bo *robj = obj->driver_private;
+        int r;
 
-        switch (pin_domain) {
-        case RADEON_GEM_DOMAIN_VRAM:
-                flags = TTM_PL_FLAG_VRAM;
-                break;
-        case RADEON_GEM_DOMAIN_GTT:
-                flags = TTM_PL_FLAG_TT;
-                break;
-        default:
-                flags = TTM_PL_FLAG_SYSTEM;
-                break;
-        }
-        return radeon_object_pin(robj, flags, gpu_addr);
+        r = radeon_bo_reserve(robj, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(robj, pin_domain, gpu_addr);
+        radeon_bo_unreserve(robj);
+        return r;
 }
 
 void radeon_gem_object_unpin(struct drm_gem_object *obj)
 {
-        struct radeon_object *robj = obj->driver_private;
-        radeon_object_unpin(robj);
+        struct radeon_bo *robj = obj->driver_private;
+        int r;
+
+        r = radeon_bo_reserve(robj, false);
+        if (likely(r == 0)) {
+                radeon_bo_unpin(robj);
+                radeon_bo_unreserve(robj);
+        }
 }
 
 int radeon_gem_set_domain(struct drm_gem_object *gobj,
                           uint32_t rdomain, uint32_t wdomain)
 {
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         uint32_t domain;
         int r;
 
@@ -127,11 +125,12 @@ int radeon_gem_set_domain(struct drm_gem_object *gobj,
         }
         if (domain == RADEON_GEM_DOMAIN_CPU) {
                 /* Asking for cpu access wait for object idle */
-                r = radeon_object_wait(robj);
+                r = radeon_bo_wait(robj, NULL, false);
                 if (r) {
                         printk(KERN_ERR "Failed to wait for object !\n");
                         return r;
                 }
+                radeon_hdp_flush(robj->rdev);
         }
         return 0;
 }
@@ -144,7 +143,7 @@ int radeon_gem_init(struct radeon_device *rdev)
 
 void radeon_gem_fini(struct radeon_device *rdev)
 {
-        radeon_object_force_delete(rdev);
+        radeon_bo_force_delete(rdev);
 }
 
 
@@ -158,9 +157,13 @@ int radeon_gem_info_ioctl(struct drm_device *dev, void *data,
         struct drm_radeon_gem_info *args = data;
 
         args->vram_size = rdev->mc.real_vram_size;
-        /* FIXME: report somethings that makes sense */
-        args->vram_visible = rdev->mc.real_vram_size - (4 * 1024 * 1024);
-        args->gart_size = rdev->mc.gtt_size;
+        args->vram_visible = rdev->mc.real_vram_size;
+        if (rdev->stollen_vga_memory)
+                args->vram_visible -= radeon_bo_size(rdev->stollen_vga_memory);
+        if (rdev->fbdev_rbo)
+                args->vram_visible -= radeon_bo_size(rdev->fbdev_rbo);
+        args->gart_size = rdev->mc.gtt_size - rdev->cp.ring_size - 4096 -
+                RADEON_IB_POOL_SIZE*64*1024;
         return 0;
 }
 
@@ -192,8 +195,8 @@ int radeon_gem_create_ioctl(struct drm_device *dev, void *data,
         /* create a gem object to contain this object in */
         args->size = roundup(args->size, PAGE_SIZE);
         r = radeon_gem_object_create(rdev, args->size, args->alignment,
-                                     args->initial_domain, false,
-                                     false, true, &gobj);
+                                        args->initial_domain, false,
+                                        false, &gobj);
         if (r) {
                 return r;
         }
@@ -218,7 +221,7 @@ int radeon_gem_set_domain_ioctl(struct drm_device *dev, void *data,
          * just validate the BO into a certain domain */
         struct drm_radeon_gem_set_domain *args = data;
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         int r;
 
         /* for now if someone requests domain CPU -
@@ -244,19 +247,18 @@ int radeon_gem_mmap_ioctl(struct drm_device *dev, void *data,
 {
         struct drm_radeon_gem_mmap *args = data;
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
-        int r;
+        struct radeon_bo *robj;
 
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL) {
                 return -EINVAL;
         }
         robj = gobj->driver_private;
-        r = radeon_object_mmap(robj, &args->addr_ptr);
+        args->addr_ptr = radeon_bo_mmap_offset(robj);
         mutex_lock(&dev->struct_mutex);
         drm_gem_object_unreference(gobj);
         mutex_unlock(&dev->struct_mutex);
-        return r;
+        return 0;
 }
 
 int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
@@ -264,7 +266,7 @@ int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
 {
         struct drm_radeon_gem_busy *args = data;
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         int r;
         uint32_t cur_placement;
 
@@ -273,7 +275,7 @@ int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
                 return -EINVAL;
         }
         robj = gobj->driver_private;
-        r = radeon_object_busy_domain(robj, &cur_placement);
+        r = radeon_bo_wait(robj, &cur_placement, true);
         switch (cur_placement) {
         case TTM_PL_VRAM:
                 args->domain = RADEON_GEM_DOMAIN_VRAM;
@@ -297,7 +299,7 @@ int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
 {
         struct drm_radeon_gem_wait_idle *args = data;
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         int r;
 
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
@@ -305,10 +307,11 @@ int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
                 return -EINVAL;
         }
         robj = gobj->driver_private;
-        r = radeon_object_wait(robj);
+        r = radeon_bo_wait(robj, NULL, false);
         mutex_lock(&dev->struct_mutex);
         drm_gem_object_unreference(gobj);
         mutex_unlock(&dev->struct_mutex);
+        radeon_hdp_flush(robj->rdev);
         return r;
 }
 
@@ -317,7 +320,7 @@ int radeon_gem_set_tiling_ioctl(struct drm_device *dev, void *data,
 {
         struct drm_radeon_gem_set_tiling *args = data;
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
+        struct radeon_bo *robj;
         int r = 0;
 
         DRM_DEBUG("%d \n", args->handle);
@@ -325,7 +328,7 @@ int radeon_gem_set_tiling_ioctl(struct drm_device *dev, void *data,
         if (gobj == NULL)
                 return -EINVAL;
         robj = gobj->driver_private;
-        radeon_object_set_tiling_flags(robj, args->tiling_flags, args->pitch);
+        r = radeon_bo_set_tiling_flags(robj, args->tiling_flags, args->pitch);
         mutex_lock(&dev->struct_mutex);
         drm_gem_object_unreference(gobj);
         mutex_unlock(&dev->struct_mutex);
@@ -337,16 +340,19 @@ int radeon_gem_get_tiling_ioctl(struct drm_device *dev, void *data,
 {
         struct drm_radeon_gem_get_tiling *args = data;
         struct drm_gem_object *gobj;
-        struct radeon_object *robj;
+        struct radeon_bo *rbo;
         int r = 0;
 
         DRM_DEBUG("\n");
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL)
                 return -EINVAL;
-        robj = gobj->driver_private;
-        radeon_object_get_tiling_flags(robj, &args->tiling_flags,
-                                       &args->pitch);
+        rbo = gobj->driver_private;
+        r = radeon_bo_reserve(rbo, false);
+        if (unlikely(r != 0))
+                return r;
+        radeon_bo_get_tiling_flags(rbo, &args->tiling_flags, &args->pitch);
+        radeon_bo_unreserve(rbo);
         mutex_lock(&dev->struct_mutex);
         drm_gem_object_unreference(gobj);
         mutex_unlock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/radeon/radeon_i2c.c b/drivers/gpu/drm/radeon/radeon_i2c.c
index dd438d32e5c0..da3da1e89d00 100644
--- a/drivers/gpu/drm/radeon/radeon_i2c.c
+++ b/drivers/gpu/drm/radeon/radeon_i2c.c
@@ -59,35 +59,43 @@ bool radeon_ddc_probe(struct radeon_connector *radeon_connector)
 }
 
 
-void radeon_i2c_do_lock(struct radeon_connector *radeon_connector, int lock_state)
+void radeon_i2c_do_lock(struct radeon_i2c_chan *i2c, int lock_state)
 {
-        struct radeon_device *rdev = radeon_connector->base.dev->dev_private;
+        struct radeon_device *rdev = i2c->dev->dev_private;
+        struct radeon_i2c_bus_rec *rec = &i2c->rec;
         uint32_t temp;
-        struct radeon_i2c_bus_rec *rec = &radeon_connector->ddc_bus->rec;
 
         /* RV410 appears to have a bug where the hw i2c in reset
          * holds the i2c port in a bad state - switch hw i2c away before
          * doing DDC - do this for all r200s/r300s/r400s for safety sake
          */
-        if ((rdev->family >= CHIP_R200) && !ASIC_IS_AVIVO(rdev)) {
-                if (rec->a_clk_reg == RADEON_GPIO_MONID) {
-                        WREG32(RADEON_DVI_I2C_CNTL_0, (RADEON_I2C_SOFT_RST |
-                                                R200_DVI_I2C_PIN_SEL(R200_SEL_DDC1)));
-                } else {
-                        WREG32(RADEON_DVI_I2C_CNTL_0, (RADEON_I2C_SOFT_RST |
-                                                R200_DVI_I2C_PIN_SEL(R200_SEL_DDC3)));
+        if (rec->hw_capable) {
+                if ((rdev->family >= CHIP_R200) && !ASIC_IS_AVIVO(rdev)) {
+                        if (rec->a_clk_reg == RADEON_GPIO_MONID) {
+                                WREG32(RADEON_DVI_I2C_CNTL_0, (RADEON_I2C_SOFT_RST |
+                                                               R200_DVI_I2C_PIN_SEL(R200_SEL_DDC1)));
+                        } else {
+                                WREG32(RADEON_DVI_I2C_CNTL_0, (RADEON_I2C_SOFT_RST |
+                                                               R200_DVI_I2C_PIN_SEL(R200_SEL_DDC3)));
+                        }
                 }
         }
-        if (lock_state) {
-                temp = RREG32(rec->a_clk_reg);
-                temp &= ~(rec->a_clk_mask);
-                WREG32(rec->a_clk_reg, temp);
-
-                temp = RREG32(rec->a_data_reg);
-                temp &= ~(rec->a_data_mask);
-                WREG32(rec->a_data_reg, temp);
-        }
 
+        /* clear the output pin values */
+        temp = RREG32(rec->a_clk_reg) & ~rec->a_clk_mask;
+        WREG32(rec->a_clk_reg, temp);
+
+        temp = RREG32(rec->a_data_reg) & ~rec->a_data_mask;
+        WREG32(rec->a_data_reg, temp);
+
+        /* set the pins to input */
+        temp = RREG32(rec->en_clk_reg) & ~rec->en_clk_mask;
+        WREG32(rec->en_clk_reg, temp);
+
+        temp = RREG32(rec->en_data_reg) & ~rec->en_data_mask;
+        WREG32(rec->en_data_reg, temp);
+
+        /* mask the gpio pins for software use */
         temp = RREG32(rec->mask_clk_reg);
         if (lock_state)
                 temp |= rec->mask_clk_mask;
@@ -112,8 +120,9 @@ static int get_clock(void *i2c_priv)
         struct radeon_i2c_bus_rec *rec = &i2c->rec;
         uint32_t val;
 
-        val = RREG32(rec->get_clk_reg);
-        val &= rec->get_clk_mask;
+        /* read the value off the pin */
+        val = RREG32(rec->y_clk_reg);
+        val &= rec->y_clk_mask;
 
         return (val != 0);
 }
@@ -126,8 +135,10 @@ static int get_data(void *i2c_priv)
         struct radeon_i2c_bus_rec *rec = &i2c->rec;
         uint32_t val;
 
-        val = RREG32(rec->get_data_reg);
-        val &= rec->get_data_mask;
+        /* read the value off the pin */
+        val = RREG32(rec->y_data_reg);
+        val &= rec->y_data_mask;
+
         return (val != 0);
 }
 
@@ -138,9 +149,10 @@ static void set_clock(void *i2c_priv, int clock)
         struct radeon_i2c_bus_rec *rec = &i2c->rec;
         uint32_t val;
 
-        val = RREG32(rec->put_clk_reg) & (uint32_t)~(rec->put_clk_mask);
-        val |= clock ? 0 : rec->put_clk_mask;
-        WREG32(rec->put_clk_reg, val);
+        /* set pin direction */
+        val = RREG32(rec->en_clk_reg) & ~rec->en_clk_mask;
+        val |= clock ? 0 : rec->en_clk_mask;
+        WREG32(rec->en_clk_reg, val);
 }
 
 static void set_data(void *i2c_priv, int data)
@@ -150,14 +162,15 @@ static void set_data(void *i2c_priv, int data)
         struct radeon_i2c_bus_rec *rec = &i2c->rec;
         uint32_t val;
 
-        val = RREG32(rec->put_data_reg) & (uint32_t)~(rec->put_data_mask);
-        val |= data ? 0 : rec->put_data_mask;
-        WREG32(rec->put_data_reg, val);
+        /* set pin direction */
+        val = RREG32(rec->en_data_reg) & ~rec->en_data_mask;
+        val |= data ? 0 : rec->en_data_mask;
+        WREG32(rec->en_data_reg, val);
 }
 
 struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
-                struct radeon_i2c_bus_rec *rec,
-                const char *name)
+                                          struct radeon_i2c_bus_rec *rec,
+                                          const char *name)
 {
         struct radeon_i2c_chan *i2c;
         int ret;
@@ -167,20 +180,19 @@ struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
                 return NULL;
 
         i2c->adapter.owner = THIS_MODULE;
-        i2c->adapter.algo_data = &i2c->algo;
         i2c->dev = dev;
-        i2c->algo.setsda = set_data;
-        i2c->algo.setscl = set_clock;
-        i2c->algo.getsda = get_data;
-        i2c->algo.getscl = get_clock;
-        i2c->algo.udelay = 20;
+        i2c_set_adapdata(&i2c->adapter, i2c);
+        i2c->adapter.algo_data = &i2c->algo.bit;
+        i2c->algo.bit.setsda = set_data;
+        i2c->algo.bit.setscl = set_clock;
+        i2c->algo.bit.getsda = get_data;
+        i2c->algo.bit.getscl = get_clock;
+        i2c->algo.bit.udelay = 20;
         /* vesa says 2.2 ms is enough, 1 jiffy doesn't seem to always
          * make this, 2 jiffies is a lot more reliable */
-        i2c->algo.timeout = 2;
-        i2c->algo.data = i2c;
+        i2c->algo.bit.timeout = 2;
+        i2c->algo.bit.data = i2c;
         i2c->rec = *rec;
-        i2c_set_adapdata(&i2c->adapter, i2c);
-
         ret = i2c_bit_add_bus(&i2c->adapter);
         if (ret) {
                 DRM_INFO("Failed to register i2c %s\n", name);
@@ -194,6 +206,38 @@ out_free:
 
 }
 
+struct radeon_i2c_chan *radeon_i2c_create_dp(struct drm_device *dev,
+                                             struct radeon_i2c_bus_rec *rec,
+                                             const char *name)
+{
+        struct radeon_i2c_chan *i2c;
+        int ret;
+
+        i2c = kzalloc(sizeof(struct radeon_i2c_chan), GFP_KERNEL);
+        if (i2c == NULL)
+                return NULL;
+
+        i2c->rec = *rec;
+        i2c->adapter.owner = THIS_MODULE;
+        i2c->dev = dev;
+        i2c_set_adapdata(&i2c->adapter, i2c);
+        i2c->adapter.algo_data = &i2c->algo.dp;
+        i2c->algo.dp.aux_ch = radeon_dp_i2c_aux_ch;
+        i2c->algo.dp.address = 0;
+        ret = i2c_dp_aux_add_bus(&i2c->adapter);
+        if (ret) {
+                DRM_INFO("Failed to register i2c %s\n", name);
+                goto out_free;
+        }
+
+        return i2c;
+out_free:
+        kfree(i2c);
+        return NULL;
+
+}
+
+
 void radeon_i2c_destroy(struct radeon_i2c_chan *i2c)
 {
         if (!i2c)
@@ -207,3 +251,59 @@ struct drm_encoder *radeon_best_encoder(struct drm_connector *connector)
 {
         return NULL;
 }
+
+void radeon_i2c_sw_get_byte(struct radeon_i2c_chan *i2c_bus,
+                            u8 slave_addr,
+                            u8 addr,
+                            u8 *val)
+{
+        u8 out_buf[2];
+        u8 in_buf[2];
+        struct i2c_msg msgs[] = {
+                {
+                        .addr = slave_addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = out_buf,
+                },
+                {
+                        .addr = slave_addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = in_buf,
+                }
+        };
+
+        out_buf[0] = addr;
+        out_buf[1] = 0;
+
+        if (i2c_transfer(&i2c_bus->adapter, msgs, 2) == 2) {
+                *val = in_buf[0];
+                DRM_DEBUG("val = 0x%02x\n", *val);
+        } else {
+                DRM_ERROR("i2c 0x%02x 0x%02x read failed\n",
+                          addr, *val);
+        }
+}
+
+void radeon_i2c_sw_put_byte(struct radeon_i2c_chan *i2c_bus,
+                            u8 slave_addr,
+                            u8 addr,
+                            u8 val)
+{
+        uint8_t out_buf[2];
+        struct i2c_msg msg = {
+                .addr = slave_addr,
+                .flags = 0,
+                .len = 2,
+                .buf = out_buf,
+        };
+
+        out_buf[0] = addr;
+        out_buf[1] = val;
+
+        if (i2c_transfer(&i2c_bus->adapter, &msg, 1) != 1)
+                DRM_ERROR("i2c 0x%02x 0x%02x write failed\n",
+                          addr, val);
+}
+
diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c
index a0fe6232dcb6..9223296fe37b 100644
--- a/drivers/gpu/drm/radeon/radeon_irq_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c
@@ -39,11 +39,32 @@ irqreturn_t radeon_driver_irq_handler_kms(DRM_IRQ_ARGS)
         return radeon_irq_process(rdev);
 }
 
+/*
+ * Handle hotplug events outside the interrupt handler proper.
+ */
+static void radeon_hotplug_work_func(struct work_struct *work)
+{
+        struct radeon_device *rdev = container_of(work, struct radeon_device,
+                                                  hotplug_work);
+        struct drm_device *dev = rdev->ddev;
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_connector *connector;
+
+        if (mode_config->num_connector) {
+                list_for_each_entry(connector, &mode_config->connector_list, head)
+                        radeon_connector_hotplug(connector);
+        }
+        /* Just fire off a uevent and let userspace tell us what to do */
+        drm_sysfs_hotplug_event(dev);
+}
+
 void radeon_driver_irq_preinstall_kms(struct drm_device *dev)
 {
         struct radeon_device *rdev = dev->dev_private;
         unsigned i;
 
+        INIT_WORK(&rdev->hotplug_work, radeon_hotplug_work_func);
+
         /* Disable *all* interrupts */
         rdev->irq.sw_int = false;
         for (i = 0; i < 2; i++) {
@@ -87,17 +108,25 @@ int radeon_irq_kms_init(struct radeon_device *rdev)
 
         if (rdev->flags & RADEON_SINGLE_CRTC)
                 num_crtc = 1;
-
+        spin_lock_init(&rdev->irq.sw_lock);
         r = drm_vblank_init(rdev->ddev, num_crtc);
         if (r) {
                 return r;
         }
         /* enable msi */
         rdev->msi_enabled = 0;
-        if (rdev->family >= CHIP_RV380) {
+        /* MSIs don't seem to work on my rs780;
+         * not sure about rs880 or other rs780s.
+         * Needs more investigation.
+         */
+        if ((rdev->family >= CHIP_RV380) &&
+            (rdev->family != CHIP_RS780) &&
+            (rdev->family != CHIP_RS880)) {
                 int ret = pci_enable_msi(rdev->pdev);
-                if (!ret)
+                if (!ret) {
                         rdev->msi_enabled = 1;
+                        DRM_INFO("radeon: using MSI.\n");
+                }
         }
         drm_irq_install(rdev->ddev);
         rdev->irq.installed = true;
@@ -114,3 +143,29 @@ void radeon_irq_kms_fini(struct radeon_device *rdev)
                         pci_disable_msi(rdev->pdev);
         }
 }
+
+void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev)
+{
+        unsigned long irqflags;
+
+        spin_lock_irqsave(&rdev->irq.sw_lock, irqflags);
+        if (rdev->ddev->irq_enabled && (++rdev->irq.sw_refcount == 1)) {
+                rdev->irq.sw_int = true;
+                radeon_irq_set(rdev);
+        }
+        spin_unlock_irqrestore(&rdev->irq.sw_lock, irqflags);
+}
+
+void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev)
+{
+        unsigned long irqflags;
+
+        spin_lock_irqsave(&rdev->irq.sw_lock, irqflags);
+        BUG_ON(rdev->ddev->irq_enabled && rdev->irq.sw_refcount <= 0);
+        if (rdev->ddev->irq_enabled && (--rdev->irq.sw_refcount == 0)) {
+                rdev->irq.sw_int = false;
+                radeon_irq_set(rdev);
+        }
+        spin_unlock_irqrestore(&rdev->irq.sw_lock, irqflags);
+}
+
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
index 8d0b7aa87fa4..b82ede98e152 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
@@ -30,6 +30,18 @@
 #include "radeon.h"
 #include "atom.h"
 
+static void radeon_overscan_setup(struct drm_crtc *crtc,
+                                  struct drm_display_mode *mode)
+{
+        struct drm_device *dev = crtc->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+
+        WREG32(RADEON_OVR_CLR + radeon_crtc->crtc_offset, 0);
+        WREG32(RADEON_OVR_WID_LEFT_RIGHT + radeon_crtc->crtc_offset, 0);
+        WREG32(RADEON_OVR_WID_TOP_BOTTOM + radeon_crtc->crtc_offset, 0);
+}
+
 static void radeon_legacy_rmx_mode_set(struct drm_crtc *crtc,
                                        struct drm_display_mode *mode,
                                        struct drm_display_mode *adjusted_mode)
@@ -292,8 +304,7 @@ void radeon_crtc_dpms(struct drm_crtc *crtc, int mode)
         uint32_t mask;
 
         if (radeon_crtc->crtc_id)
-                mask = (RADEON_CRTC2_EN |
-                        RADEON_CRTC2_DISP_DIS |
+                mask = (RADEON_CRTC2_DISP_DIS |
                         RADEON_CRTC2_VSYNC_DIS |
                         RADEON_CRTC2_HSYNC_DIS |
                         RADEON_CRTC2_DISP_REQ_EN_B);
@@ -305,7 +316,7 @@ void radeon_crtc_dpms(struct drm_crtc *crtc, int mode)
         switch (mode) {
         case DRM_MODE_DPMS_ON:
                 if (radeon_crtc->crtc_id)
-                        WREG32_P(RADEON_CRTC2_GEN_CNTL, RADEON_CRTC2_EN, ~mask);
+                        WREG32_P(RADEON_CRTC2_GEN_CNTL, RADEON_CRTC2_EN, ~(RADEON_CRTC2_EN | mask));
                 else {
                         WREG32_P(RADEON_CRTC_GEN_CNTL, RADEON_CRTC_EN, ~(RADEON_CRTC_EN |
                                                                          RADEON_CRTC_DISP_REQ_EN_B));
@@ -319,7 +330,7 @@ void radeon_crtc_dpms(struct drm_crtc *crtc, int mode)
         case DRM_MODE_DPMS_OFF:
                 drm_vblank_pre_modeset(dev, radeon_crtc->crtc_id);
                 if (radeon_crtc->crtc_id)
-                        WREG32_P(RADEON_CRTC2_GEN_CNTL, mask, ~mask);
+                        WREG32_P(RADEON_CRTC2_GEN_CNTL, mask, ~(RADEON_CRTC2_EN | mask));
                 else {
                         WREG32_P(RADEON_CRTC_GEN_CNTL, RADEON_CRTC_DISP_REQ_EN_B, ~(RADEON_CRTC_EN |
                                                                                     RADEON_CRTC_DISP_REQ_EN_B));
@@ -400,14 +411,21 @@ int radeon_crtc_set_base(struct drm_crtc *crtc, int x, int y,
         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
         struct radeon_framebuffer *radeon_fb;
         struct drm_gem_object *obj;
+        struct radeon_bo *rbo;
         uint64_t base;
         uint32_t crtc_offset, crtc_offset_cntl, crtc_tile_x0_y0 = 0;
         uint32_t crtc_pitch, pitch_pixels;
         uint32_t tiling_flags;
         int format;
         uint32_t gen_cntl_reg, gen_cntl_val;
+        int r;
 
         DRM_DEBUG("\n");
+        /* no fb bound */
+        if (!crtc->fb) {
+                DRM_DEBUG("No FB bound\n");
+                return 0;
+        }
 
         radeon_fb = to_radeon_framebuffer(crtc->fb);
 
@@ -431,10 +449,22 @@ int radeon_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                 return false;
         }
 
+        /* Pin framebuffer & get tilling informations */
         obj = radeon_fb->obj;
-        if (radeon_gem_object_pin(obj, RADEON_GEM_DOMAIN_VRAM, &base)) {
+        rbo = obj->driver_private;
+        r = radeon_bo_reserve(rbo, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(rbo, RADEON_GEM_DOMAIN_VRAM, &base);
+        if (unlikely(r != 0)) {
+                radeon_bo_unreserve(rbo);
                 return -EINVAL;
         }
+        radeon_bo_get_tiling_flags(rbo, &tiling_flags, NULL);
+        radeon_bo_unreserve(rbo);
+        if (tiling_flags & RADEON_TILING_MICRO)
+                DRM_ERROR("trying to scanout microtiled buffer\n");
+
         /* if scanout was in GTT this really wouldn't work */
         /* crtc offset is from display base addr not FB location */
         radeon_crtc->legacy_display_base_addr = rdev->mc.vram_location;
@@ -449,10 +479,6 @@ int radeon_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                        (crtc->fb->bits_per_pixel * 8));
         crtc_pitch |= crtc_pitch << 16;
 
-        radeon_object_get_tiling_flags(obj->driver_private,
-                                       &tiling_flags, NULL);
-        if (tiling_flags & RADEON_TILING_MICRO)
-                DRM_ERROR("trying to scanout microtiled buffer\n");
 
         if (tiling_flags & RADEON_TILING_MACRO) {
                 if (ASIC_IS_R300(rdev))
@@ -530,7 +556,12 @@ int radeon_crtc_set_base(struct drm_crtc *crtc, int x, int y,
 
         if (old_fb && old_fb != crtc->fb) {
                 radeon_fb = to_radeon_framebuffer(old_fb);
-                radeon_gem_object_unpin(radeon_fb->obj);
+                rbo = radeon_fb->obj->driver_private;
+                r = radeon_bo_reserve(rbo, false);
+                if (unlikely(r != 0))
+                        return r;
+                radeon_bo_unpin(rbo);
+                radeon_bo_unreserve(rbo);
         }
 
         /* Bytes per pixel may have changed */
@@ -642,12 +673,8 @@ static bool radeon_set_crtc_timing(struct drm_crtc *crtc, struct drm_display_mod
                 uint32_t crtc2_gen_cntl;
                 uint32_t disp2_merge_cntl;
 
-                /* check to see if TV DAC is enabled for another crtc and keep it enabled */
-                if (RREG32(RADEON_CRTC2_GEN_CNTL) & RADEON_CRTC2_CRT2_ON)
-                        crtc2_gen_cntl = RADEON_CRTC2_CRT2_ON;
-                else
-                        crtc2_gen_cntl = 0;
-
+                /* if TV DAC is enabled for another crtc and keep it enabled */
+                crtc2_gen_cntl = RREG32(RADEON_CRTC2_GEN_CNTL) & 0x00718080;
                 crtc2_gen_cntl |= ((format << 8)
                                    | RADEON_CRTC2_VSYNC_DIS
                                    | RADEON_CRTC2_HSYNC_DIS
@@ -676,7 +703,8 @@ static bool radeon_set_crtc_timing(struct drm_crtc *crtc, struct drm_display_mod
                 uint32_t crtc_ext_cntl;
                 uint32_t disp_merge_cntl;
 
-                crtc_gen_cntl = (RADEON_CRTC_EXT_DISP_EN
+                crtc_gen_cntl = RREG32(RADEON_CRTC_GEN_CNTL) & 0x00718000;
+                crtc_gen_cntl |= (RADEON_CRTC_EXT_DISP_EN
                                  | (format << 8)
                                  | RADEON_CRTC_DISP_REQ_EN_B
                                  | ((mode->flags & DRM_MODE_FLAG_DBLSCAN)
@@ -779,15 +807,17 @@ static void radeon_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC)
                                 pll_flags |= RADEON_PLL_NO_ODD_POST_DIV;
                         if (encoder->encoder_type == DRM_MODE_ENCODER_LVDS) {
-                                struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
-                                struct radeon_encoder_lvds *lvds = (struct radeon_encoder_lvds *)radeon_encoder->enc_priv;
-                                if (lvds) {
-                                        if (lvds->use_bios_dividers) {
-                                                pll_ref_div = lvds->panel_ref_divider;
-                                                pll_fb_post_div   = (lvds->panel_fb_divider |
-                                                                     (lvds->panel_post_divider << 16));
-                                                htotal_cntl  = 0;
-                                                use_bios_divs = true;
+                                if (!rdev->is_atom_bios) {
+                                        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+                                        struct radeon_encoder_lvds *lvds = (struct radeon_encoder_lvds *)radeon_encoder->enc_priv;
+                                        if (lvds) {
+                                                if (lvds->use_bios_dividers) {
+                                                        pll_ref_div = lvds->panel_ref_divider;
+                                                        pll_fb_post_div   = (lvds->panel_fb_divider |
+                                                                             (lvds->panel_post_divider << 16));
+                                                        htotal_cntl  = 0;
+                                                        use_bios_divs = true;
+                                                }
                                         }
                                 }
                                 pll_flags |= RADEON_PLL_USE_REF_DIV;
@@ -1027,6 +1057,7 @@ static int radeon_crtc_mode_set(struct drm_crtc *crtc,
         radeon_crtc_set_base(crtc, x, y, old_fb);
         radeon_set_crtc_timing(crtc, adjusted_mode);
         radeon_set_pll(crtc, adjusted_mode);
+        radeon_overscan_setup(crtc, adjusted_mode);
         if (radeon_crtc->crtc_id == 0) {
                 radeon_legacy_rmx_mode_set(crtc, mode, adjusted_mode);
         } else {
@@ -1042,12 +1073,29 @@ static int radeon_crtc_mode_set(struct drm_crtc *crtc,
 
 static void radeon_crtc_prepare(struct drm_crtc *crtc)
 {
-        radeon_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
+        struct drm_device *dev = crtc->dev;
+        struct drm_crtc *crtci;
+
+        /*
+        * The hardware wedges sometimes if you reconfigure one CRTC
+        * whilst another is running (see fdo bug #24611).
+        */
+        list_for_each_entry(crtci, &dev->mode_config.crtc_list, head)
+                radeon_crtc_dpms(crtci, DRM_MODE_DPMS_OFF);
 }
 
 static void radeon_crtc_commit(struct drm_crtc *crtc)
 {
-        radeon_crtc_dpms(crtc, DRM_MODE_DPMS_ON);
+        struct drm_device *dev = crtc->dev;
+        struct drm_crtc *crtci;
+
+        /*
+        * Reenable the CRTCs that should be running.
+        */
+        list_for_each_entry(crtci, &dev->mode_config.crtc_list, head) {
+                if (crtci->enabled)
+                        radeon_crtc_dpms(crtci, DRM_MODE_DPMS_ON);
+        }
 }
 
 static const struct drm_crtc_helper_funcs legacy_helper_funcs = {
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
index 00382122869b..df00515e81fa 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
@@ -136,7 +136,14 @@ static void radeon_legacy_lvds_mode_set(struct drm_encoder *encoder,
         lvds_pll_cntl &= ~RADEON_LVDS_PLL_EN;
 
         lvds_ss_gen_cntl = RREG32(RADEON_LVDS_SS_GEN_CNTL);
-        if ((!rdev->is_atom_bios)) {
+        if (rdev->is_atom_bios) {
+                /* LVDS_GEN_CNTL parameters are computed in LVDSEncoderControl
+                 * need to call that on resume to set up the reg properly.
+                 */
+                radeon_encoder->pixel_clock = adjusted_mode->clock;
+                atombios_digital_setup(encoder, PANEL_ENCODER_ACTION_ENABLE);
+                lvds_gen_cntl = RREG32(RADEON_LVDS_GEN_CNTL);
+        } else {
                 struct radeon_encoder_lvds *lvds = (struct radeon_encoder_lvds *)radeon_encoder->enc_priv;
                 if (lvds) {
                         DRM_DEBUG("bios LVDS_GEN_CNTL: 0x%x\n", lvds->lvds_gen_cntl);
@@ -147,8 +154,7 @@ static void radeon_legacy_lvds_mode_set(struct drm_encoder *encoder,
                                              (lvds->panel_blon_delay << RADEON_LVDS_PWRSEQ_DELAY2_SHIFT));
                 } else
                         lvds_gen_cntl = RREG32(RADEON_LVDS_GEN_CNTL);
-        } else
-                lvds_gen_cntl = RREG32(RADEON_LVDS_GEN_CNTL);
+        }
         lvds_gen_cntl |= RADEON_LVDS_DISPLAY_DIS;
         lvds_gen_cntl &= ~(RADEON_LVDS_ON |
                            RADEON_LVDS_BLON |
@@ -184,9 +190,9 @@ static void radeon_legacy_lvds_mode_set(struct drm_encoder *encoder,
                 radeon_combios_encoder_crtc_scratch_regs(encoder, radeon_crtc->crtc_id);
 }
 
-static bool radeon_legacy_lvds_mode_fixup(struct drm_encoder *encoder,
-                                          struct drm_display_mode *mode,
-                                          struct drm_display_mode *adjusted_mode)
+static bool radeon_legacy_mode_fixup(struct drm_encoder *encoder,
+                                     struct drm_display_mode *mode,
+                                     struct drm_display_mode *adjusted_mode)
 {
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 
@@ -194,15 +200,22 @@ static bool radeon_legacy_lvds_mode_fixup(struct drm_encoder *encoder,
         radeon_encoder_set_active_device(encoder);
         drm_mode_set_crtcinfo(adjusted_mode, 0);
 
-        if (radeon_encoder->rmx_type != RMX_OFF)
-                radeon_rmx_mode_fixup(encoder, mode, adjusted_mode);
+        /* get the native mode for LVDS */
+        if (radeon_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT)) {
+                struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
+                int mode_id = adjusted_mode->base.id;
+                *adjusted_mode = *native_mode;
+                adjusted_mode->hdisplay = mode->hdisplay;
+                adjusted_mode->vdisplay = mode->vdisplay;
+                adjusted_mode->base.id = mode_id;
+        }
 
         return true;
 }
 
 static const struct drm_encoder_helper_funcs radeon_legacy_lvds_helper_funcs = {
         .dpms = radeon_legacy_lvds_dpms,
-        .mode_fixup = radeon_legacy_lvds_mode_fixup,
+        .mode_fixup = radeon_legacy_mode_fixup,
         .prepare = radeon_legacy_lvds_prepare,
         .mode_set = radeon_legacy_lvds_mode_set,
         .commit = radeon_legacy_lvds_commit,
@@ -214,17 +227,6 @@ static const struct drm_encoder_funcs radeon_legacy_lvds_enc_funcs = {
         .destroy = radeon_enc_destroy,
 };
 
-static bool radeon_legacy_primary_dac_mode_fixup(struct drm_encoder *encoder,
-                                                 struct drm_display_mode *mode,
-                                                 struct drm_display_mode *adjusted_mode)
-{
-        /* set the active encoder to connector routing */
-        radeon_encoder_set_active_device(encoder);
-        drm_mode_set_crtcinfo(adjusted_mode, 0);
-
-        return true;
-}
-
 static void radeon_legacy_primary_dac_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
@@ -410,7 +412,7 @@ static enum drm_connector_status radeon_legacy_primary_dac_detect(struct drm_enc
 
 static const struct drm_encoder_helper_funcs radeon_legacy_primary_dac_helper_funcs = {
         .dpms = radeon_legacy_primary_dac_dpms,
-        .mode_fixup = radeon_legacy_primary_dac_mode_fixup,
+        .mode_fixup = radeon_legacy_mode_fixup,
         .prepare = radeon_legacy_primary_dac_prepare,
         .mode_set = radeon_legacy_primary_dac_mode_set,
         .commit = radeon_legacy_primary_dac_commit,
@@ -423,16 +425,6 @@ static const struct drm_encoder_funcs radeon_legacy_primary_dac_enc_funcs = {
         .destroy = radeon_enc_destroy,
 };
 
-static bool radeon_legacy_tmds_int_mode_fixup(struct drm_encoder *encoder,
-                                              struct drm_display_mode *mode,
-                                              struct drm_display_mode *adjusted_mode)
-{
-
-        drm_mode_set_crtcinfo(adjusted_mode, 0);
-
-        return true;
-}
-
 static void radeon_legacy_tmds_int_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
@@ -584,7 +576,7 @@ static void radeon_legacy_tmds_int_mode_set(struct drm_encoder *encoder,
 
 static const struct drm_encoder_helper_funcs radeon_legacy_tmds_int_helper_funcs = {
         .dpms = radeon_legacy_tmds_int_dpms,
-        .mode_fixup = radeon_legacy_tmds_int_mode_fixup,
+        .mode_fixup = radeon_legacy_mode_fixup,
         .prepare = radeon_legacy_tmds_int_prepare,
         .mode_set = radeon_legacy_tmds_int_mode_set,
         .commit = radeon_legacy_tmds_int_commit,
@@ -596,17 +588,6 @@ static const struct drm_encoder_funcs radeon_legacy_tmds_int_enc_funcs = {
         .destroy = radeon_enc_destroy,
 };
 
-static bool radeon_legacy_tmds_ext_mode_fixup(struct drm_encoder *encoder,
-                                              struct drm_display_mode *mode,
-                                              struct drm_display_mode *adjusted_mode)
-{
-        /* set the active encoder to connector routing */
-        radeon_encoder_set_active_device(encoder);
-        drm_mode_set_crtcinfo(adjusted_mode, 0);
-
-        return true;
-}
-
 static void radeon_legacy_tmds_ext_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
@@ -697,6 +678,8 @@ static void radeon_legacy_tmds_ext_mode_set(struct drm_encoder *encoder,
                         /*if (mode->clock > 165000)
                           fp2_gen_cntl |= R300_FP2_DVO_DUAL_CHANNEL_EN;*/
                 }
+                if (!radeon_combios_external_tmds_setup(encoder))
+                        radeon_external_tmds_setup(encoder);
         }
 
         if (radeon_crtc->crtc_id == 0) {
@@ -724,9 +707,22 @@ static void radeon_legacy_tmds_ext_mode_set(struct drm_encoder *encoder,
                 radeon_combios_encoder_crtc_scratch_regs(encoder, radeon_crtc->crtc_id);
 }
 
+static void radeon_ext_tmds_enc_destroy(struct drm_encoder *encoder)
+{
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct radeon_encoder_ext_tmds *tmds = radeon_encoder->enc_priv;
+        if (tmds) {
+                if (tmds->i2c_bus)
+                        radeon_i2c_destroy(tmds->i2c_bus);
+        }
+        kfree(radeon_encoder->enc_priv);
+        drm_encoder_cleanup(encoder);
+        kfree(radeon_encoder);
+}
+
 static const struct drm_encoder_helper_funcs radeon_legacy_tmds_ext_helper_funcs = {
         .dpms = radeon_legacy_tmds_ext_dpms,
-        .mode_fixup = radeon_legacy_tmds_ext_mode_fixup,
+        .mode_fixup = radeon_legacy_mode_fixup,
         .prepare = radeon_legacy_tmds_ext_prepare,
         .mode_set = radeon_legacy_tmds_ext_mode_set,
         .commit = radeon_legacy_tmds_ext_commit,
@@ -735,20 +731,9 @@ static const struct drm_encoder_helper_funcs radeon_legacy_tmds_ext_helper_funcs
 
 
 static const struct drm_encoder_funcs radeon_legacy_tmds_ext_enc_funcs = {
-        .destroy = radeon_enc_destroy,
+        .destroy = radeon_ext_tmds_enc_destroy,
 };
 
-static bool radeon_legacy_tv_dac_mode_fixup(struct drm_encoder *encoder,
-                                            struct drm_display_mode *mode,
-                                            struct drm_display_mode *adjusted_mode)
-{
-        /* set the active encoder to connector routing */
-        radeon_encoder_set_active_device(encoder);
-        drm_mode_set_crtcinfo(adjusted_mode, 0);
-
-        return true;
-}
-
 static void radeon_legacy_tv_dac_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
@@ -1265,7 +1250,7 @@ static enum drm_connector_status radeon_legacy_tv_dac_detect(struct drm_encoder
 
 static const struct drm_encoder_helper_funcs radeon_legacy_tv_dac_helper_funcs = {
         .dpms = radeon_legacy_tv_dac_dpms,
-        .mode_fixup = radeon_legacy_tv_dac_mode_fixup,
+        .mode_fixup = radeon_legacy_mode_fixup,
         .prepare = radeon_legacy_tv_dac_prepare,
         .mode_set = radeon_legacy_tv_dac_mode_set,
         .commit = radeon_legacy_tv_dac_commit,
@@ -1302,6 +1287,29 @@ static struct radeon_encoder_int_tmds *radeon_legacy_get_tmds_info(struct radeon
         return tmds;
 }
 
+static struct radeon_encoder_ext_tmds *radeon_legacy_get_ext_tmds_info(struct radeon_encoder *encoder)
+{
+        struct drm_device *dev = encoder->base.dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_encoder_ext_tmds *tmds = NULL;
+        bool ret;
+
+        if (rdev->is_atom_bios)
+                return NULL;
+
+        tmds = kzalloc(sizeof(struct radeon_encoder_ext_tmds), GFP_KERNEL);
+
+        if (!tmds)
+                return NULL;
+
+        ret = radeon_legacy_get_ext_tmds_info_from_combios(encoder, tmds);
+
+        if (ret == false)
+                radeon_legacy_get_ext_tmds_info_from_table(encoder, tmds);
+
+        return tmds;
+}
+
 void
 radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device)
 {
@@ -1329,7 +1337,6 @@ radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t
                 encoder->possible_crtcs = 0x1;
         else
                 encoder->possible_crtcs = 0x3;
-        encoder->possible_clones = 0;
 
         radeon_encoder->enc_priv = NULL;
 
@@ -1373,7 +1380,7 @@ radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t
                 drm_encoder_init(dev, encoder, &radeon_legacy_tmds_ext_enc_funcs, DRM_MODE_ENCODER_TMDS);
                 drm_encoder_helper_add(encoder, &radeon_legacy_tmds_ext_helper_funcs);
                 if (!rdev->is_atom_bios)
-                        radeon_combios_get_ext_tmds_info(radeon_encoder);
+                        radeon_encoder->enc_priv = radeon_legacy_get_ext_tmds_info(radeon_encoder);
                 break;
         }
 }
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h
index ace726aa0d76..15ec7ca18a95 100644
--- a/drivers/gpu/drm/radeon/radeon_mode.h
+++ b/drivers/gpu/drm/radeon/radeon_mode.h
@@ -33,6 +33,7 @@
 #include <drm_crtc.h>
 #include <drm_mode.h>
 #include <drm_edid.h>
+#include <drm_dp_helper.h>
 #include <linux/i2c.h>
 #include <linux/i2c-id.h>
 #include <linux/i2c-algo-bit.h>
@@ -89,24 +90,45 @@ enum radeon_tv_std {
         TV_STD_PAL_CN,
 };
 
+/* radeon gpio-based i2c
+ * 1. "mask" reg and bits
+ *    grabs the gpio pins for software use
+ *    0=not held  1=held
+ * 2. "a" reg and bits
+ *    output pin value
+ *    0=low 1=high
+ * 3. "en" reg and bits
+ *    sets the pin direction
+ *    0=input 1=output
+ * 4. "y" reg and bits
+ *    input pin value
+ *    0=low 1=high
+ */
 struct radeon_i2c_bus_rec {
         bool valid;
+        /* id used by atom */
+        uint8_t i2c_id;
+        /* can be used with hw i2c engine */
+        bool hw_capable;
+        /* uses multi-media i2c engine */
+        bool mm_i2c;
+        /* regs and bits */
         uint32_t mask_clk_reg;
         uint32_t mask_data_reg;
         uint32_t a_clk_reg;
         uint32_t a_data_reg;
-        uint32_t put_clk_reg;
-        uint32_t put_data_reg;
-        uint32_t get_clk_reg;
-        uint32_t get_data_reg;
+        uint32_t en_clk_reg;
+        uint32_t en_data_reg;
+        uint32_t y_clk_reg;
+        uint32_t y_data_reg;
         uint32_t mask_clk_mask;
         uint32_t mask_data_mask;
-        uint32_t put_clk_mask;
-        uint32_t put_data_mask;
-        uint32_t get_clk_mask;
-        uint32_t get_data_mask;
         uint32_t a_clk_mask;
         uint32_t a_data_mask;
+        uint32_t en_clk_mask;
+        uint32_t en_data_mask;
+        uint32_t y_clk_mask;
+        uint32_t y_data_mask;
 };
 
 struct radeon_tmds_pll {
@@ -150,9 +172,12 @@ struct radeon_pll {
 };
 
 struct radeon_i2c_chan {
-        struct drm_device *dev;
         struct i2c_adapter adapter;
-        struct i2c_algo_bit_data algo;
+        struct drm_device *dev;
+        union {
+                struct i2c_algo_dp_aux_data dp;
+                struct i2c_algo_bit_data bit;
+        } algo;
         struct radeon_i2c_bus_rec rec;
 };
 
@@ -170,6 +195,11 @@ enum radeon_connector_table {
         CT_EMAC,
 };
 
+enum radeon_dvo_chip {
+        DVO_SIL164,
+        DVO_SIL1178,
+};
+
 struct radeon_mode_info {
         struct atom_context *atom_context;
         struct card_info *atom_card_info;
@@ -261,6 +291,13 @@ struct radeon_encoder_int_tmds {
         struct radeon_tmds_pll tmds_pll[4];
 };
 
+struct radeon_encoder_ext_tmds {
+        /* tmds over dvo */
+        struct radeon_i2c_chan *i2c_bus;
+        uint8_t slave_addr;
+        enum radeon_dvo_chip dvo_chip;
+};
+
 /* spread spectrum */
 struct radeon_atom_ss {
         uint16_t percentage;
@@ -302,6 +339,35 @@ 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];
+        u8 dp_sink_type;
+        int dp_clock;
+        int dp_lane_count;
+};
+
+struct radeon_gpio_rec {
+        bool valid;
+        u8 id;
+        u32 reg;
+        u32 mask;
+};
+
+enum radeon_hpd_id {
+        RADEON_HPD_NONE = 0,
+        RADEON_HPD_1,
+        RADEON_HPD_2,
+        RADEON_HPD_3,
+        RADEON_HPD_4,
+        RADEON_HPD_5,
+        RADEON_HPD_6,
+};
+
+struct radeon_hpd {
+        enum radeon_hpd_id hpd;
+        u8 plugged_state;
+        struct radeon_gpio_rec gpio;
 };
 
 struct radeon_connector {
@@ -318,6 +384,7 @@ struct radeon_connector {
         void *con_priv;
         bool dac_load_detect;
         uint16_t connector_object_id;
+        struct radeon_hpd hpd;
 };
 
 struct radeon_framebuffer {
@@ -325,10 +392,37 @@ struct radeon_framebuffer {
         struct drm_gem_object *obj;
 };
 
+extern void radeon_connector_hotplug(struct drm_connector *connector);
+extern bool radeon_dp_needs_link_train(struct radeon_connector *radeon_connector);
+extern int radeon_dp_mode_valid_helper(struct radeon_connector *radeon_connector,
+                                       struct drm_display_mode *mode);
+extern void radeon_dp_set_link_config(struct drm_connector *connector,
+                                      struct drm_display_mode *mode);
+extern void dp_link_train(struct drm_encoder *encoder,
+                          struct drm_connector *connector);
+extern u8 radeon_dp_getsinktype(struct radeon_connector *radeon_connector);
+extern bool radeon_dp_getdpcd(struct radeon_connector *radeon_connector);
+extern void atombios_dig_transmitter_setup(struct drm_encoder *encoder,
+                                           int action, uint8_t lane_num,
+                                           uint8_t lane_set);
+extern int radeon_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
+                                uint8_t write_byte, uint8_t *read_byte);
+
+extern struct radeon_i2c_chan *radeon_i2c_create_dp(struct drm_device *dev,
+                                                    struct radeon_i2c_bus_rec *rec,
+                                                    const char *name);
 extern struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
                                                  struct radeon_i2c_bus_rec *rec,
                                                  const char *name);
 extern void radeon_i2c_destroy(struct radeon_i2c_chan *i2c);
+extern void radeon_i2c_sw_get_byte(struct radeon_i2c_chan *i2c_bus,
+                                   u8 slave_addr,
+                                   u8 addr,
+                                   u8 *val);
+extern void radeon_i2c_sw_put_byte(struct radeon_i2c_chan *i2c,
+                                   u8 slave_addr,
+                                   u8 addr,
+                                   u8 val);
 extern bool radeon_ddc_probe(struct radeon_connector *radeon_connector);
 extern int radeon_ddc_get_modes(struct radeon_connector *radeon_connector);
 
@@ -343,12 +437,15 @@ extern void radeon_compute_pll(struct radeon_pll *pll,
                                uint32_t *post_div_p,
                                int flags);
 
+extern void radeon_setup_encoder_clones(struct drm_device *dev);
+
 struct drm_encoder *radeon_encoder_legacy_lvds_add(struct drm_device *dev, int bios_index);
 struct drm_encoder *radeon_encoder_legacy_primary_dac_add(struct drm_device *dev, int bios_index, int with_tv);
 struct drm_encoder *radeon_encoder_legacy_tv_dac_add(struct drm_device *dev, int bios_index, int with_tv);
 struct drm_encoder *radeon_encoder_legacy_tmds_int_add(struct drm_device *dev, int bios_index);
 struct drm_encoder *radeon_encoder_legacy_tmds_ext_add(struct drm_device *dev, int bios_index);
 extern void atombios_external_tmds_setup(struct drm_encoder *encoder, int action);
+extern void atombios_digital_setup(struct drm_encoder *encoder, int action);
 extern int atombios_get_encoder_mode(struct drm_encoder *encoder);
 extern void radeon_encoder_set_active_device(struct drm_encoder *encoder);
 
@@ -378,12 +475,16 @@ extern bool radeon_atom_get_clock_info(struct drm_device *dev);
 extern bool radeon_combios_get_clock_info(struct drm_device *dev);
 extern struct radeon_encoder_atom_dig *
 radeon_atombios_get_lvds_info(struct radeon_encoder *encoder);
-bool radeon_atombios_get_tmds_info(struct radeon_encoder *encoder,
-                                   struct radeon_encoder_int_tmds *tmds);
-bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
-                                           struct radeon_encoder_int_tmds *tmds);
-bool radeon_legacy_get_tmds_info_from_table(struct radeon_encoder *encoder,
-                                            struct radeon_encoder_int_tmds *tmds);
+extern bool radeon_atombios_get_tmds_info(struct radeon_encoder *encoder,
+                                          struct radeon_encoder_int_tmds *tmds);
+extern bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
+                                                     struct radeon_encoder_int_tmds *tmds);
+extern bool radeon_legacy_get_tmds_info_from_table(struct radeon_encoder *encoder,
+                                                   struct radeon_encoder_int_tmds *tmds);
+extern bool radeon_legacy_get_ext_tmds_info_from_combios(struct radeon_encoder *encoder,
+                                                         struct radeon_encoder_ext_tmds *tmds);
+extern bool radeon_legacy_get_ext_tmds_info_from_table(struct radeon_encoder *encoder,
+                                                       struct radeon_encoder_ext_tmds *tmds);
 extern struct radeon_encoder_primary_dac *
 radeon_atombios_get_primary_dac_info(struct radeon_encoder *encoder);
 extern struct radeon_encoder_tv_dac *
@@ -395,6 +496,8 @@ extern struct radeon_encoder_tv_dac *
 radeon_combios_get_tv_dac_info(struct radeon_encoder *encoder);
 extern struct radeon_encoder_primary_dac *
 radeon_combios_get_primary_dac_info(struct radeon_encoder *encoder);
+extern bool radeon_combios_external_tmds_setup(struct drm_encoder *encoder);
+extern void radeon_external_tmds_setup(struct drm_encoder *encoder);
 extern void radeon_combios_output_lock(struct drm_encoder *encoder, bool lock);
 extern void radeon_combios_initialize_bios_scratch_regs(struct drm_device *dev);
 extern void radeon_atom_output_lock(struct drm_encoder *encoder, bool lock);
@@ -426,16 +529,13 @@ void radeon_atombios_init_crtc(struct drm_device *dev,
                                struct radeon_crtc *radeon_crtc);
 void radeon_legacy_init_crtc(struct drm_device *dev,
                              struct radeon_crtc *radeon_crtc);
-void radeon_i2c_do_lock(struct radeon_connector *radeon_connector, int lock_state);
+extern void radeon_i2c_do_lock(struct radeon_i2c_chan *i2c, int lock_state);
 
 void radeon_get_clock_info(struct drm_device *dev);
 
 extern bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev);
 extern bool radeon_get_atom_connector_info_from_supported_devices_table(struct drm_device *dev);
 
-void radeon_rmx_mode_fixup(struct drm_encoder *encoder,
-                           struct drm_display_mode *mode,
-                           struct drm_display_mode *adjusted_mode);
 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);
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index 1f056dadc5c2..bec494384825 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -34,74 +34,32 @@
 #include "radeon_drm.h"
 #include "radeon.h"
 
-struct radeon_object {
-        struct ttm_buffer_object        tobj;
-        struct list_head                list;
-        struct radeon_device            *rdev;
-        struct drm_gem_object           *gobj;
-        struct ttm_bo_kmap_obj          kmap;
-        unsigned                        pin_count;
-        uint64_t                        gpu_addr;
-        void                            *kptr;
-        bool                            is_iomem;
-        uint32_t                        tiling_flags;
-        uint32_t                        pitch;
-        int                             surface_reg;
-};
 
 int radeon_ttm_init(struct radeon_device *rdev);
 void radeon_ttm_fini(struct radeon_device *rdev);
+static void radeon_bo_clear_surface_reg(struct radeon_bo *bo);
 
 /*
  * To exclude mutual BO access we rely on bo_reserve exclusion, as all
  * function are calling it.
  */
 
-static int radeon_object_reserve(struct radeon_object *robj, bool interruptible)
+static void radeon_ttm_bo_destroy(struct ttm_buffer_object *tbo)
 {
-        return ttm_bo_reserve(&robj->tobj, interruptible, false, false, 0);
-}
+        struct radeon_bo *bo;
 
-static void radeon_object_unreserve(struct radeon_object *robj)
-{
-        ttm_bo_unreserve(&robj->tobj);
+        bo = container_of(tbo, struct radeon_bo, tbo);
+        mutex_lock(&bo->rdev->gem.mutex);
+        list_del_init(&bo->list);
+        mutex_unlock(&bo->rdev->gem.mutex);
+        radeon_bo_clear_surface_reg(bo);
+        kfree(bo);
 }
 
-static void radeon_ttm_object_object_destroy(struct ttm_buffer_object *tobj)
+static inline u32 radeon_ttm_flags_from_domain(u32 domain)
 {
-        struct radeon_object *robj;
-
-        robj = container_of(tobj, struct radeon_object, tobj);
-        list_del_init(&robj->list);
-        radeon_object_clear_surface_reg(robj);
-        kfree(robj);
-}
-
-static inline void radeon_object_gpu_addr(struct radeon_object *robj)
-{
-        /* Default gpu address */
-        robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL;
-        if (robj->tobj.mem.mm_node == NULL) {
-                return;
-        }
-        robj->gpu_addr = ((u64)robj->tobj.mem.mm_node->start) << PAGE_SHIFT;
-        switch (robj->tobj.mem.mem_type) {
-        case TTM_PL_VRAM:
-                robj->gpu_addr += (u64)robj->rdev->mc.vram_location;
-                break;
-        case TTM_PL_TT:
-                robj->gpu_addr += (u64)robj->rdev->mc.gtt_location;
-                break;
-        default:
-                DRM_ERROR("Unknown placement %d\n", robj->tobj.mem.mem_type);
-                robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL;
-                return;
-        }
-}
+        u32 flags = 0;
 
-static inline uint32_t radeon_object_flags_from_domain(uint32_t domain)
-{
-        uint32_t flags = 0;
         if (domain & RADEON_GEM_DOMAIN_VRAM) {
                 flags |= TTM_PL_FLAG_VRAM | TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED;
         }
@@ -117,17 +75,13 @@ static inline uint32_t radeon_object_flags_from_domain(uint32_t domain)
         return flags;
 }
 
-int radeon_object_create(struct radeon_device *rdev,
-                         struct drm_gem_object *gobj,
-                         unsigned long size,
-                         bool kernel,
-                         uint32_t domain,
-                         bool interruptible,
-                         struct radeon_object **robj_ptr)
+int radeon_bo_create(struct radeon_device *rdev, struct drm_gem_object *gobj,
+                        unsigned long size, bool kernel, u32 domain,
+                        struct radeon_bo **bo_ptr)
 {
-        struct radeon_object *robj;
+        struct radeon_bo *bo;
         enum ttm_bo_type type;
-        uint32_t flags;
+        u32 flags;
         int r;
 
         if (unlikely(rdev->mman.bdev.dev_mapping == NULL)) {
@@ -138,206 +92,140 @@ int radeon_object_create(struct radeon_device *rdev,
         } else {
                 type = ttm_bo_type_device;
         }
-        *robj_ptr = NULL;
-        robj = kzalloc(sizeof(struct radeon_object), GFP_KERNEL);
-        if (robj == NULL) {
+        *bo_ptr = NULL;
+        bo = kzalloc(sizeof(struct radeon_bo), GFP_KERNEL);
+        if (bo == NULL)
                 return -ENOMEM;
-        }
-        robj->rdev = rdev;
-        robj->gobj = gobj;
-        robj->surface_reg = -1;
-        INIT_LIST_HEAD(&robj->list);
-
-        flags = radeon_object_flags_from_domain(domain);
-        r = ttm_buffer_object_init(&rdev->mman.bdev, &robj->tobj, size, type, flags,
-                                   0, 0, false, NULL, size,
-                                   &radeon_ttm_object_object_destroy);
+        bo->rdev = rdev;
+        bo->gobj = gobj;
+        bo->surface_reg = -1;
+        INIT_LIST_HEAD(&bo->list);
+
+        flags = radeon_ttm_flags_from_domain(domain);
+retry:
+        r = ttm_buffer_object_init(&rdev->mman.bdev, &bo->tbo, size, type,
+                                        flags, 0, 0, true, NULL, size,
+                                        &radeon_ttm_bo_destroy);
         if (unlikely(r != 0)) {
+                if (r == -ERESTART)
+                        goto retry;
                 /* ttm call radeon_ttm_object_object_destroy if error happen */
-                DRM_ERROR("Failed to allocate TTM object (%ld, 0x%08X, %u)\n",
-                          size, flags, 0);
+                dev_err(rdev->dev, "object_init failed for (%ld, 0x%08X)\n",
+                        size, flags);
                 return r;
         }
-        *robj_ptr = robj;
+        *bo_ptr = bo;
         if (gobj) {
-                list_add_tail(&robj->list, &rdev->gem.objects);
+                mutex_lock(&bo->rdev->gem.mutex);
+                list_add_tail(&bo->list, &rdev->gem.objects);
+                mutex_unlock(&bo->rdev->gem.mutex);
         }
         return 0;
 }
 
-int radeon_object_kmap(struct radeon_object *robj, void **ptr)
+int radeon_bo_kmap(struct radeon_bo *bo, void **ptr)
 {
+        bool is_iomem;
         int r;
 
-        spin_lock(&robj->tobj.lock);
-        if (robj->kptr) {
+        if (bo->kptr) {
                 if (ptr) {
-                        *ptr = robj->kptr;
+                        *ptr = bo->kptr;
                 }
-                spin_unlock(&robj->tobj.lock);
                 return 0;
         }
-        spin_unlock(&robj->tobj.lock);
-        r = ttm_bo_kmap(&robj->tobj, 0, robj->tobj.num_pages, &robj->kmap);
+        r = ttm_bo_kmap(&bo->tbo, 0, bo->tbo.num_pages, &bo->kmap);
         if (r) {
                 return r;
         }
-        spin_lock(&robj->tobj.lock);
-        robj->kptr = ttm_kmap_obj_virtual(&robj->kmap, &robj->is_iomem);
-        spin_unlock(&robj->tobj.lock);
+        bo->kptr = ttm_kmap_obj_virtual(&bo->kmap, &is_iomem);
         if (ptr) {
-                *ptr = robj->kptr;
+                *ptr = bo->kptr;
         }
-        radeon_object_check_tiling(robj, 0, 0);
+        radeon_bo_check_tiling(bo, 0, 0);
         return 0;
 }
 
-void radeon_object_kunmap(struct radeon_object *robj)
+void radeon_bo_kunmap(struct radeon_bo *bo)
 {
-        spin_lock(&robj->tobj.lock);
-        if (robj->kptr == NULL) {
-                spin_unlock(&robj->tobj.lock);
+        if (bo->kptr == NULL)
                 return;
-        }
-        robj->kptr = NULL;
-        spin_unlock(&robj->tobj.lock);
-        radeon_object_check_tiling(robj, 0, 0);
-        ttm_bo_kunmap(&robj->kmap);
+        bo->kptr = NULL;
+        radeon_bo_check_tiling(bo, 0, 0);
+        ttm_bo_kunmap(&bo->kmap);
 }
 
-void radeon_object_unref(struct radeon_object **robj)
+void radeon_bo_unref(struct radeon_bo **bo)
 {
-        struct ttm_buffer_object *tobj;
+        struct ttm_buffer_object *tbo;
 
-        if ((*robj) == NULL) {
+        if ((*bo) == NULL)
                 return;
-        }
-        tobj = &((*robj)->tobj);
-        ttm_bo_unref(&tobj);
-        if (tobj == NULL) {
-                *robj = NULL;
-        }
-}
-
-int radeon_object_mmap(struct radeon_object *robj, uint64_t *offset)
-{
-        *offset = robj->tobj.addr_space_offset;
-        return 0;
+        tbo = &((*bo)->tbo);
+        ttm_bo_unref(&tbo);
+        if (tbo == NULL)
+                *bo = NULL;
 }
 
-int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
-                      uint64_t *gpu_addr)
+int radeon_bo_pin(struct radeon_bo *bo, u32 domain, u64 *gpu_addr)
 {
-        uint32_t flags;
-        uint32_t tmp;
+        u32 flags;
+        u32 tmp;
         int r;
 
-        flags = radeon_object_flags_from_domain(domain);
-        spin_lock(&robj->tobj.lock);
-        if (robj->pin_count) {
-                robj->pin_count++;
-                if (gpu_addr != NULL) {
-                        *gpu_addr = robj->gpu_addr;
-                }
-                spin_unlock(&robj->tobj.lock);
+        flags = radeon_ttm_flags_from_domain(domain);
+        if (bo->pin_count) {
+                bo->pin_count++;
+                if (gpu_addr)
+                        *gpu_addr = radeon_bo_gpu_offset(bo);
                 return 0;
         }
-        spin_unlock(&robj->tobj.lock);
-        r = radeon_object_reserve(robj, false);
-        if (unlikely(r != 0)) {
-                DRM_ERROR("radeon: failed to reserve object for pinning it.\n");
-                return r;
-        }
-        tmp = robj->tobj.mem.placement;
+        tmp = bo->tbo.mem.placement;
         ttm_flag_masked(&tmp, flags, TTM_PL_MASK_MEM);
-        robj->tobj.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT | TTM_PL_MASK_CACHING;
-        r = ttm_buffer_object_validate(&robj->tobj,
-                                       robj->tobj.proposed_placement,
-                                       false, false);
-        radeon_object_gpu_addr(robj);
-        if (gpu_addr != NULL) {
-                *gpu_addr = robj->gpu_addr;
+        bo->tbo.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT |
+                                        TTM_PL_MASK_CACHING;
+retry:
+        r = ttm_buffer_object_validate(&bo->tbo, bo->tbo.proposed_placement,
+                                        true, false);
+        if (likely(r == 0)) {
+                bo->pin_count = 1;
+                if (gpu_addr != NULL)
+                        *gpu_addr = radeon_bo_gpu_offset(bo);
         }
-        robj->pin_count = 1;
         if (unlikely(r != 0)) {
-                DRM_ERROR("radeon: failed to pin object.\n");
+                if (r == -ERESTART)
+                        goto retry;
+                dev_err(bo->rdev->dev, "%p pin failed\n", bo);
         }
-        radeon_object_unreserve(robj);
         return r;
 }
 
-void radeon_object_unpin(struct radeon_object *robj)
+int radeon_bo_unpin(struct radeon_bo *bo)
 {
-        uint32_t flags;
         int r;
 
-        spin_lock(&robj->tobj.lock);
-        if (!robj->pin_count) {
-                spin_unlock(&robj->tobj.lock);
-                printk(KERN_WARNING "Unpin not necessary for %p !\n", robj);
-                return;
-        }
-        robj->pin_count--;
-        if (robj->pin_count) {
-                spin_unlock(&robj->tobj.lock);
-                return;
-        }
-        spin_unlock(&robj->tobj.lock);
-        r = radeon_object_reserve(robj, false);
-        if (unlikely(r != 0)) {
-                DRM_ERROR("radeon: failed to reserve object for unpinning it.\n");
-                return;
-        }
-        flags = robj->tobj.mem.placement;
-        robj->tobj.proposed_placement = flags & ~TTM_PL_FLAG_NO_EVICT;
-        r = ttm_buffer_object_validate(&robj->tobj,
-                                       robj->tobj.proposed_placement,
-                                       false, false);
-        if (unlikely(r != 0)) {
-                DRM_ERROR("radeon: failed to unpin buffer.\n");
-        }
-        radeon_object_unreserve(robj);
-}
-
-int radeon_object_wait(struct radeon_object *robj)
-{
-        int r = 0;
-
-        /* FIXME: should use block reservation instead */
-        r = radeon_object_reserve(robj, true);
-        if (unlikely(r != 0)) {
-                DRM_ERROR("radeon: failed to reserve object for waiting.\n");
-                return r;
-        }
-        spin_lock(&robj->tobj.lock);
-        if (robj->tobj.sync_obj) {
-                r = ttm_bo_wait(&robj->tobj, true, true, false);
+        if (!bo->pin_count) {
+                dev_warn(bo->rdev->dev, "%p unpin not necessary\n", bo);
+                return 0;
         }
-        spin_unlock(&robj->tobj.lock);
-        radeon_object_unreserve(robj);
-        return r;
-}
-
-int radeon_object_busy_domain(struct radeon_object *robj, uint32_t *cur_placement)
-{
-        int r = 0;
-
-        r = radeon_object_reserve(robj, true);
+        bo->pin_count--;
+        if (bo->pin_count)
+                return 0;
+        bo->tbo.proposed_placement = bo->tbo.mem.placement &
+                                        ~TTM_PL_FLAG_NO_EVICT;
+retry:
+        r = ttm_buffer_object_validate(&bo->tbo, bo->tbo.proposed_placement,
+                                        true, false);
         if (unlikely(r != 0)) {
-                DRM_ERROR("radeon: failed to reserve object for waiting.\n");
+                if (r == -ERESTART)
+                        goto retry;
+                dev_err(bo->rdev->dev, "%p validate failed for unpin\n", bo);
                 return r;
         }
-        spin_lock(&robj->tobj.lock);
-        *cur_placement = robj->tobj.mem.mem_type;
-        if (robj->tobj.sync_obj) {
-                r = ttm_bo_wait(&robj->tobj, true, true, true);
-        }
-        spin_unlock(&robj->tobj.lock);
-        radeon_object_unreserve(robj);
-        return r;
+        return 0;
 }
 
-int radeon_object_evict_vram(struct radeon_device *rdev)
+int radeon_bo_evict_vram(struct radeon_device *rdev)
 {
         if (rdev->flags & RADEON_IS_IGP) {
                 /* Useless to evict on IGP chips */
@@ -346,30 +234,32 @@ int radeon_object_evict_vram(struct radeon_device *rdev)
         return ttm_bo_evict_mm(&rdev->mman.bdev, TTM_PL_VRAM);
 }
 
-void radeon_object_force_delete(struct radeon_device *rdev)
+void radeon_bo_force_delete(struct radeon_device *rdev)
 {
-        struct radeon_object *robj, *n;
+        struct radeon_bo *bo, *n;
         struct drm_gem_object *gobj;
 
         if (list_empty(&rdev->gem.objects)) {
                 return;
         }
-        DRM_ERROR("Userspace still has active objects !\n");
-        list_for_each_entry_safe(robj, n, &rdev->gem.objects, list) {
+        dev_err(rdev->dev, "Userspace still has active objects !\n");
+        list_for_each_entry_safe(bo, n, &rdev->gem.objects, list) {
                 mutex_lock(&rdev->ddev->struct_mutex);
-                gobj = robj->gobj;
-                DRM_ERROR("Force free for (%p,%p,%lu,%lu)\n",
-                          gobj, robj, (unsigned long)gobj->size,
-                          *((unsigned long *)&gobj->refcount));
-                list_del_init(&robj->list);
-                radeon_object_unref(&robj);
+                gobj = bo->gobj;
+                dev_err(rdev->dev, "%p %p %lu %lu force free\n",
+                        gobj, bo, (unsigned long)gobj->size,
+                        *((unsigned long *)&gobj->refcount));
+                mutex_lock(&bo->rdev->gem.mutex);
+                list_del_init(&bo->list);
+                mutex_unlock(&bo->rdev->gem.mutex);
+                radeon_bo_unref(&bo);
                 gobj->driver_private = NULL;
                 drm_gem_object_unreference(gobj);
                 mutex_unlock(&rdev->ddev->struct_mutex);
         }
 }
 
-int radeon_object_init(struct radeon_device *rdev)
+int radeon_bo_init(struct radeon_device *rdev)
 {
         /* Add an MTRR for the VRAM */
         rdev->mc.vram_mtrr = mtrr_add(rdev->mc.aper_base, rdev->mc.aper_size,
@@ -382,13 +272,13 @@ int radeon_object_init(struct radeon_device *rdev)
         return radeon_ttm_init(rdev);
 }
 
-void radeon_object_fini(struct radeon_device *rdev)
+void radeon_bo_fini(struct radeon_device *rdev)
 {
         radeon_ttm_fini(rdev);
 }
 
-void radeon_object_list_add_object(struct radeon_object_list *lobj,
-                                   struct list_head *head)
+void radeon_bo_list_add_object(struct radeon_bo_list *lobj,
+                                struct list_head *head)
 {
         if (lobj->wdomain) {
                 list_add(&lobj->list, head);
@@ -397,72 +287,67 @@ void radeon_object_list_add_object(struct radeon_object_list *lobj,
         }
 }
 
-int radeon_object_list_reserve(struct list_head *head)
+int radeon_bo_list_reserve(struct list_head *head)
 {
-        struct radeon_object_list *lobj;
+        struct radeon_bo_list *lobj;
         int r;
 
         list_for_each_entry(lobj, head, list){
-                if (!lobj->robj->pin_count) {
-                        r = radeon_object_reserve(lobj->robj, true);
-                        if (unlikely(r != 0)) {
-                                DRM_ERROR("radeon: failed to reserve object.\n");
-                                return r;
-                        }
-                } else {
-                }
+                r = radeon_bo_reserve(lobj->bo, false);
+                if (unlikely(r != 0))
+                        return r;
         }
         return 0;
 }
 
-void radeon_object_list_unreserve(struct list_head *head)
+void radeon_bo_list_unreserve(struct list_head *head)
 {
-        struct radeon_object_list *lobj;
+        struct radeon_bo_list *lobj;
 
         list_for_each_entry(lobj, head, list) {
-                if (!lobj->robj->pin_count) {
-                        radeon_object_unreserve(lobj->robj);
-                }
+                /* only unreserve object we successfully reserved */
+                if (radeon_bo_is_reserved(lobj->bo))
+                        radeon_bo_unreserve(lobj->bo);
         }
 }
 
-int radeon_object_list_validate(struct list_head *head, void *fence)
+int radeon_bo_list_validate(struct list_head *head, void *fence)
 {
-        struct radeon_object_list *lobj;
-        struct radeon_object *robj;
+        struct radeon_bo_list *lobj;
+        struct radeon_bo *bo;
         struct radeon_fence *old_fence = NULL;
         int r;
 
-        r = radeon_object_list_reserve(head);
+        r = radeon_bo_list_reserve(head);
         if (unlikely(r != 0)) {
-                radeon_object_list_unreserve(head);
                 return r;
         }
         list_for_each_entry(lobj, head, list) {
-                robj = lobj->robj;
-                if (!robj->pin_count) {
+                bo = lobj->bo;
+                if (!bo->pin_count) {
                         if (lobj->wdomain) {
-                                robj->tobj.proposed_placement =
-                                        radeon_object_flags_from_domain(lobj->wdomain);
+                                bo->tbo.proposed_placement =
+                                        radeon_ttm_flags_from_domain(lobj->wdomain);
                         } else {
-                                robj->tobj.proposed_placement =
-                                        radeon_object_flags_from_domain(lobj->rdomain);
+                                bo->tbo.proposed_placement =
+                                        radeon_ttm_flags_from_domain(lobj->rdomain);
                         }
-                        r = ttm_buffer_object_validate(&robj->tobj,
-                                                       robj->tobj.proposed_placement,
-                                                       true, false);
+retry:
+                        r = ttm_buffer_object_validate(&bo->tbo,
+                                                bo->tbo.proposed_placement,
+                                                true, false);
                         if (unlikely(r)) {
-                                DRM_ERROR("radeon: failed to validate.\n");
+                                if (r == -ERESTART)
+                                        goto retry;
                                 return r;
                         }
-                        radeon_object_gpu_addr(robj);
                 }
-                lobj->gpu_offset = robj->gpu_addr;
-                lobj->tiling_flags = robj->tiling_flags;
+                lobj->gpu_offset = radeon_bo_gpu_offset(bo);
+                lobj->tiling_flags = bo->tiling_flags;
                 if (fence) {
-                        old_fence = (struct radeon_fence *)robj->tobj.sync_obj;
-                        robj->tobj.sync_obj = radeon_fence_ref(fence);
-                        robj->tobj.sync_obj_arg = NULL;
+                        old_fence = (struct radeon_fence *)bo->tbo.sync_obj;
+                        bo->tbo.sync_obj = radeon_fence_ref(fence);
+                        bo->tbo.sync_obj_arg = NULL;
                 }
                 if (old_fence) {
                         radeon_fence_unref(&old_fence);
@@ -471,51 +356,44 @@ int radeon_object_list_validate(struct list_head *head, void *fence)
         return 0;
 }
 
-void radeon_object_list_unvalidate(struct list_head *head)
+void radeon_bo_list_unvalidate(struct list_head *head, void *fence)
 {
-        struct radeon_object_list *lobj;
-        struct radeon_fence *old_fence = NULL;
+        struct radeon_bo_list *lobj;
+        struct radeon_fence *old_fence;
 
-        list_for_each_entry(lobj, head, list) {
-                old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj;
-                lobj->robj->tobj.sync_obj = NULL;
-                if (old_fence) {
-                        radeon_fence_unref(&old_fence);
+        if (fence)
+                list_for_each_entry(lobj, head, list) {
+                        old_fence = to_radeon_fence(lobj->bo->tbo.sync_obj);
+                        if (old_fence == fence) {
+                                lobj->bo->tbo.sync_obj = NULL;
+                                radeon_fence_unref(&old_fence);
+                        }
                 }
-        }
-        radeon_object_list_unreserve(head);
-}
-
-void radeon_object_list_clean(struct list_head *head)
-{
-        radeon_object_list_unreserve(head);
+        radeon_bo_list_unreserve(head);
 }
 
-int radeon_object_fbdev_mmap(struct radeon_object *robj,
+int radeon_bo_fbdev_mmap(struct radeon_bo *bo,
                              struct vm_area_struct *vma)
 {
-        return ttm_fbdev_mmap(vma, &robj->tobj);
+        return ttm_fbdev_mmap(vma, &bo->tbo);
 }
 
-unsigned long radeon_object_size(struct radeon_object *robj)
+static int radeon_bo_get_surface_reg(struct radeon_bo *bo)
 {
-        return robj->tobj.num_pages << PAGE_SHIFT;
-}
-
-int radeon_object_get_surface_reg(struct radeon_object *robj)
-{
-        struct radeon_device *rdev = robj->rdev;
+        struct radeon_device *rdev = bo->rdev;
         struct radeon_surface_reg *reg;
-        struct radeon_object *old_object;
+        struct radeon_bo *old_object;
         int steal;
         int i;
 
-        if (!robj->tiling_flags)
+        BUG_ON(!atomic_read(&bo->tbo.reserved));
+
+        if (!bo->tiling_flags)
                 return 0;
 
-        if (robj->surface_reg >= 0) {
-                reg = &rdev->surface_regs[robj->surface_reg];
-                i = robj->surface_reg;
+        if (bo->surface_reg >= 0) {
+                reg = &rdev->surface_regs[bo->surface_reg];
+                i = bo->surface_reg;
                 goto out;
         }
 
@@ -523,10 +401,10 @@ int radeon_object_get_surface_reg(struct radeon_object *robj)
         for (i = 0; i < RADEON_GEM_MAX_SURFACES; i++) {
 
                 reg = &rdev->surface_regs[i];
-                if (!reg->robj)
+                if (!reg->bo)
                         break;
 
-                old_object = reg->robj;
+                old_object = reg->bo;
                 if (old_object->pin_count == 0)
                         steal = i;
         }
@@ -537,91 +415,101 @@ int radeon_object_get_surface_reg(struct radeon_object *robj)
                         return -ENOMEM;
                 /* find someone with a surface reg and nuke their BO */
                 reg = &rdev->surface_regs[steal];
-                old_object = reg->robj;
+                old_object = reg->bo;
                 /* blow away the mapping */
                 DRM_DEBUG("stealing surface reg %d from %p\n", steal, old_object);
-                ttm_bo_unmap_virtual(&old_object->tobj);
+                ttm_bo_unmap_virtual(&old_object->tbo);
                 old_object->surface_reg = -1;
                 i = steal;
         }
 
-        robj->surface_reg = i;
-        reg->robj = robj;
+        bo->surface_reg = i;
+        reg->bo = bo;
 
 out:
-        radeon_set_surface_reg(rdev, i, robj->tiling_flags, robj->pitch,
-                               robj->tobj.mem.mm_node->start << PAGE_SHIFT,
-                               robj->tobj.num_pages << PAGE_SHIFT);
+        radeon_set_surface_reg(rdev, i, bo->tiling_flags, bo->pitch,
+                               bo->tbo.mem.mm_node->start << PAGE_SHIFT,
+                               bo->tbo.num_pages << PAGE_SHIFT);
         return 0;
 }
 
-void radeon_object_clear_surface_reg(struct radeon_object *robj)
+static void radeon_bo_clear_surface_reg(struct radeon_bo *bo)
 {
-        struct radeon_device *rdev = robj->rdev;
+        struct radeon_device *rdev = bo->rdev;
         struct radeon_surface_reg *reg;
 
-        if (robj->surface_reg == -1)
+        if (bo->surface_reg == -1)
                 return;
 
-        reg = &rdev->surface_regs[robj->surface_reg];
-        radeon_clear_surface_reg(rdev, robj->surface_reg);
+        reg = &rdev->surface_regs[bo->surface_reg];
+        radeon_clear_surface_reg(rdev, bo->surface_reg);
 
-        reg->robj = NULL;
-        robj->surface_reg = -1;
+        reg->bo = NULL;
+        bo->surface_reg = -1;
 }
 
-void radeon_object_set_tiling_flags(struct radeon_object *robj,
-                                    uint32_t tiling_flags, uint32_t pitch)
+int radeon_bo_set_tiling_flags(struct radeon_bo *bo,
+                                uint32_t tiling_flags, uint32_t pitch)
 {
-        robj->tiling_flags = tiling_flags;
-        robj->pitch = pitch;
+        int r;
+
+        r = radeon_bo_reserve(bo, false);
+        if (unlikely(r != 0))
+                return r;
+        bo->tiling_flags = tiling_flags;
+        bo->pitch = pitch;
+        radeon_bo_unreserve(bo);
+        return 0;
 }
 
-void radeon_object_get_tiling_flags(struct radeon_object *robj,
-                                    uint32_t *tiling_flags,
-                                    uint32_t *pitch)
+void radeon_bo_get_tiling_flags(struct radeon_bo *bo,
+                                uint32_t *tiling_flags,
+                                uint32_t *pitch)
 {
+        BUG_ON(!atomic_read(&bo->tbo.reserved));
         if (tiling_flags)
-                *tiling_flags = robj->tiling_flags;
+                *tiling_flags = bo->tiling_flags;
         if (pitch)
-                *pitch = robj->pitch;
+                *pitch = bo->pitch;
 }
 
-int radeon_object_check_tiling(struct radeon_object *robj, bool has_moved,
-                               bool force_drop)
+int radeon_bo_check_tiling(struct radeon_bo *bo, bool has_moved,
+                                bool force_drop)
 {
-        if (!(robj->tiling_flags & RADEON_TILING_SURFACE))
+        BUG_ON(!atomic_read(&bo->tbo.reserved));
+
+        if (!(bo->tiling_flags & RADEON_TILING_SURFACE))
                 return 0;
 
         if (force_drop) {
-                radeon_object_clear_surface_reg(robj);
+                radeon_bo_clear_surface_reg(bo);
                 return 0;
         }
 
-        if (robj->tobj.mem.mem_type != TTM_PL_VRAM) {
+        if (bo->tbo.mem.mem_type != TTM_PL_VRAM) {
                 if (!has_moved)
                         return 0;
 
-                if (robj->surface_reg >= 0)
-                        radeon_object_clear_surface_reg(robj);
+                if (bo->surface_reg >= 0)
+                        radeon_bo_clear_surface_reg(bo);
                 return 0;
         }
 
-        if ((robj->surface_reg >= 0) && !has_moved)
+        if ((bo->surface_reg >= 0) && !has_moved)
                 return 0;
 
-        return radeon_object_get_surface_reg(robj);
+        return radeon_bo_get_surface_reg(bo);
 }
 
 void radeon_bo_move_notify(struct ttm_buffer_object *bo,
-                          struct ttm_mem_reg *mem)
+                                struct ttm_mem_reg *mem)
 {
-        struct radeon_object *robj = container_of(bo, struct radeon_object, tobj);
-        radeon_object_check_tiling(robj, 0, 1);
+        struct radeon_bo *rbo = container_of(bo, struct radeon_bo, tbo);
+        radeon_bo_check_tiling(rbo, 0, 1);
 }
 
 void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo)
 {
-        struct radeon_object *robj = container_of(bo, struct radeon_object, tobj);
-        radeon_object_check_tiling(robj, 0, 0);
+        struct radeon_bo *rbo = container_of(bo, struct radeon_bo, tbo);
+        radeon_bo_check_tiling(rbo, 0, 0);
 }
diff --git a/drivers/gpu/drm/radeon/radeon_object.h b/drivers/gpu/drm/radeon/radeon_object.h
index 10e8af6bb456..e9da13077e2f 100644
--- a/drivers/gpu/drm/radeon/radeon_object.h
+++ b/drivers/gpu/drm/radeon/radeon_object.h
@@ -28,19 +28,152 @@
 #ifndef __RADEON_OBJECT_H__
 #define __RADEON_OBJECT_H__
 
-#include <ttm/ttm_bo_api.h>
-#include <ttm/ttm_bo_driver.h>
-#include <ttm/ttm_placement.h>
-#include <ttm/ttm_module.h>
+#include <drm/radeon_drm.h>
+#include "radeon.h"
 
-/*
- * TTM.
+/**
+ * radeon_mem_type_to_domain - return domain corresponding to mem_type
+ * @mem_type:   ttm memory type
+ *
+ * Returns corresponding domain of the ttm mem_type
+ */
+static inline unsigned radeon_mem_type_to_domain(u32 mem_type)
+{
+        switch (mem_type) {
+        case TTM_PL_VRAM:
+                return RADEON_GEM_DOMAIN_VRAM;
+        case TTM_PL_TT:
+                return RADEON_GEM_DOMAIN_GTT;
+        case TTM_PL_SYSTEM:
+                return RADEON_GEM_DOMAIN_CPU;
+        default:
+                break;
+        }
+        return 0;
+}
+
+/**
+ * radeon_bo_reserve - reserve bo
+ * @bo:         bo structure
+ * @no_wait:            don't sleep while trying to reserve (return -EBUSY)
+ *
+ * Returns:
+ * -EBUSY: buffer is busy and @no_wait is true
+ * -ERESTART: A wait for the buffer to become unreserved was interrupted by
+ * a signal. Release all buffer reservations and return to user-space.
+ */
+static inline int radeon_bo_reserve(struct radeon_bo *bo, bool no_wait)
+{
+        int r;
+
+retry:
+        r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0);
+        if (unlikely(r != 0)) {
+                if (r == -ERESTART)
+                        goto retry;
+                dev_err(bo->rdev->dev, "%p reserve failed\n", bo);
+                return r;
+        }
+        return 0;
+}
+
+static inline void radeon_bo_unreserve(struct radeon_bo *bo)
+{
+        ttm_bo_unreserve(&bo->tbo);
+}
+
+/**
+ * radeon_bo_gpu_offset - return GPU offset of bo
+ * @bo: radeon object for which we query the offset
+ *
+ * Returns current GPU offset of the object.
+ *
+ * Note: object should either be pinned or reserved when calling this
+ * function, it might be usefull to add check for this for debugging.
+ */
+static inline u64 radeon_bo_gpu_offset(struct radeon_bo *bo)
+{
+        return bo->tbo.offset;
+}
+
+static inline unsigned long radeon_bo_size(struct radeon_bo *bo)
+{
+        return bo->tbo.num_pages << PAGE_SHIFT;
+}
+
+static inline bool radeon_bo_is_reserved(struct radeon_bo *bo)
+{
+        return !!atomic_read(&bo->tbo.reserved);
+}
+
+/**
+ * radeon_bo_mmap_offset - return mmap offset of bo
+ * @bo: radeon object for which we query the offset
+ *
+ * Returns mmap offset of the object.
+ *
+ * Note: addr_space_offset is constant after ttm bo init thus isn't protected
+ * by any lock.
  */
-struct radeon_mman {
-        struct ttm_bo_global_ref        bo_global_ref;
-        struct ttm_global_reference     mem_global_ref;
-        bool                            mem_global_referenced;
-        struct ttm_bo_device            bdev;
-};
+static inline u64 radeon_bo_mmap_offset(struct radeon_bo *bo)
+{
+        return bo->tbo.addr_space_offset;
+}
+
+static inline int radeon_bo_wait(struct radeon_bo *bo, u32 *mem_type,
+                                        bool no_wait)
+{
+        int r;
+
+retry:
+        r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0);
+        if (unlikely(r != 0)) {
+                if (r == -ERESTART)
+                        goto retry;
+                dev_err(bo->rdev->dev, "%p reserve failed for wait\n", bo);
+                return r;
+        }
+        spin_lock(&bo->tbo.lock);
+        if (mem_type)
+                *mem_type = bo->tbo.mem.mem_type;
+        if (bo->tbo.sync_obj)
+                r = ttm_bo_wait(&bo->tbo, true, true, no_wait);
+        spin_unlock(&bo->tbo.lock);
+        ttm_bo_unreserve(&bo->tbo);
+        if (unlikely(r == -ERESTART))
+                goto retry;
+        return r;
+}
+
+extern int radeon_bo_create(struct radeon_device *rdev,
+                                struct drm_gem_object *gobj, unsigned long size,
+                                bool kernel, u32 domain,
+                                struct radeon_bo **bo_ptr);
+extern int radeon_bo_kmap(struct radeon_bo *bo, void **ptr);
+extern void radeon_bo_kunmap(struct radeon_bo *bo);
+extern void radeon_bo_unref(struct radeon_bo **bo);
+extern int radeon_bo_pin(struct radeon_bo *bo, u32 domain, u64 *gpu_addr);
+extern int radeon_bo_unpin(struct radeon_bo *bo);
+extern int radeon_bo_evict_vram(struct radeon_device *rdev);
+extern void radeon_bo_force_delete(struct radeon_device *rdev);
+extern int radeon_bo_init(struct radeon_device *rdev);
+extern void radeon_bo_fini(struct radeon_device *rdev);
+extern void radeon_bo_list_add_object(struct radeon_bo_list *lobj,
+                                struct list_head *head);
+extern int radeon_bo_list_reserve(struct list_head *head);
+extern void radeon_bo_list_unreserve(struct list_head *head);
+extern int radeon_bo_list_validate(struct list_head *head, void *fence);
+extern void radeon_bo_list_unvalidate(struct list_head *head, void *fence);
+extern int radeon_bo_fbdev_mmap(struct radeon_bo *bo,
+                                struct vm_area_struct *vma);
+extern int radeon_bo_set_tiling_flags(struct radeon_bo *bo,
+                                u32 tiling_flags, u32 pitch);
+extern void radeon_bo_get_tiling_flags(struct radeon_bo *bo,
+                                u32 *tiling_flags, u32 *pitch);
+extern int radeon_bo_check_tiling(struct radeon_bo *bo, bool has_moved,
+                                bool force_drop);
+extern void radeon_bo_move_notify(struct ttm_buffer_object *bo,
+                                        struct ttm_mem_reg *mem);
+extern void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo);
 
 #endif
diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c
index 46146c6a2a06..34b08d307c81 100644
--- a/drivers/gpu/drm/radeon/radeon_pm.c
+++ b/drivers/gpu/drm/radeon/radeon_pm.c
@@ -27,7 +27,7 @@ int radeon_debugfs_pm_init(struct radeon_device *rdev);
 int radeon_pm_init(struct radeon_device *rdev)
 {
         if (radeon_debugfs_pm_init(rdev)) {
-                DRM_ERROR("Failed to register debugfs file for CP !\n");
+                DRM_ERROR("Failed to register debugfs file for PM!\n");
         }
 
         return 0;
@@ -44,8 +44,8 @@ static int radeon_debugfs_pm_info(struct seq_file *m, void *data)
         struct drm_device *dev = node->minor->dev;
         struct radeon_device *rdev = dev->dev_private;
 
-        seq_printf(m, "engine clock: %u0 Hz\n", radeon_get_engine_clock(rdev));
-        seq_printf(m, "memory clock: %u0 Hz\n", radeon_get_memory_clock(rdev));
+        seq_printf(m, "engine clock: %u0 kHz\n", radeon_get_engine_clock(rdev));
+        seq_printf(m, "memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev));
 
         return 0;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_reg.h b/drivers/gpu/drm/radeon/radeon_reg.h
index 29ab75903ec1..6d0a009dd4a1 100644
--- a/drivers/gpu/drm/radeon/radeon_reg.h
+++ b/drivers/gpu/drm/radeon/radeon_reg.h
@@ -887,6 +887,7 @@
 #       define RADEON_FP_PANEL_FORMAT          (1 <<  3)
 #       define RADEON_FP_EN_TMDS               (1 <<  7)
 #       define RADEON_FP_DETECT_SENSE          (1 <<  8)
+#       define RADEON_FP_DETECT_INT_POL        (1 <<  9)
 #       define R200_FP_SOURCE_SEL_MASK         (3 <<  10)
 #       define R200_FP_SOURCE_SEL_CRTC1        (0 <<  10)
 #       define R200_FP_SOURCE_SEL_CRTC2        (1 <<  10)
@@ -894,6 +895,7 @@
 #       define R200_FP_SOURCE_SEL_TRANS        (3 <<  10)
 #       define RADEON_FP_SEL_CRTC1             (0 << 13)
 #       define RADEON_FP_SEL_CRTC2             (1 << 13)
+#       define R300_HPD_SEL(x)                 ((x) << 13)
 #       define RADEON_FP_CRTC_DONT_SHADOW_HPAR (1 << 15)
 #       define RADEON_FP_CRTC_DONT_SHADOW_VPAR (1 << 16)
 #       define RADEON_FP_CRTC_DONT_SHADOW_HEND (1 << 17)
@@ -909,6 +911,7 @@
 #       define RADEON_FP2_ON                   (1 <<  2)
 #       define RADEON_FP2_PANEL_FORMAT         (1 <<  3)
 #       define RADEON_FP2_DETECT_SENSE         (1 <<  8)
+#       define RADEON_FP2_DETECT_INT_POL       (1 <<  9)
 #       define R200_FP2_SOURCE_SEL_MASK        (3 << 10)
 #       define R200_FP2_SOURCE_SEL_CRTC1       (0 << 10)
 #       define R200_FP2_SOURCE_SEL_CRTC2       (1 << 10)
@@ -988,14 +991,20 @@
 
 #define RADEON_GEN_INT_CNTL                 0x0040
 #       define RADEON_CRTC_VBLANK_MASK          (1 << 0)
+#       define RADEON_FP_DETECT_MASK            (1 << 4)
 #       define RADEON_CRTC2_VBLANK_MASK         (1 << 9)
+#       define RADEON_FP2_DETECT_MASK           (1 << 10)
 #       define RADEON_SW_INT_ENABLE             (1 << 25)
 #define RADEON_GEN_INT_STATUS               0x0044
 #       define AVIVO_DISPLAY_INT_STATUS         (1 << 0)
 #       define RADEON_CRTC_VBLANK_STAT          (1 << 0)
 #       define RADEON_CRTC_VBLANK_STAT_ACK      (1 << 0)
+#       define RADEON_FP_DETECT_STAT            (1 << 4)
+#       define RADEON_FP_DETECT_STAT_ACK        (1 << 4)
 #       define RADEON_CRTC2_VBLANK_STAT         (1 << 9)
 #       define RADEON_CRTC2_VBLANK_STAT_ACK     (1 << 9)
+#       define RADEON_FP2_DETECT_STAT           (1 << 10)
+#       define RADEON_FP2_DETECT_STAT_ACK       (1 << 10)
 #       define RADEON_SW_INT_FIRE               (1 << 26)
 #       define RADEON_SW_INT_TEST               (1 << 25)
 #       define RADEON_SW_INT_TEST_ACK           (1 << 25)
@@ -1051,20 +1060,25 @@
 
        /* Multimedia I2C bus */
 #define RADEON_I2C_CNTL_0                   0x0090
-#define RADEON_I2C_DONE (1<<0)
-#define RADEON_I2C_NACK (1<<1)
-#define RADEON_I2C_HALT (1<<2)
-#define RADEON_I2C_SOFT_RST (1<<5)
-#define RADEON_I2C_DRIVE_EN (1<<6)
-#define RADEON_I2C_DRIVE_SEL (1<<7)
-#define RADEON_I2C_START (1<<8)
-#define RADEON_I2C_STOP (1<<9)
-#define RADEON_I2C_RECEIVE (1<<10)
-#define RADEON_I2C_ABORT (1<<11)
-#define RADEON_I2C_GO (1<<12)
+#define RADEON_I2C_DONE                     (1 << 0)
+#define RADEON_I2C_NACK                     (1 << 1)
+#define RADEON_I2C_HALT                     (1 << 2)
+#define RADEON_I2C_SOFT_RST                 (1 << 5)
+#define RADEON_I2C_DRIVE_EN                 (1 << 6)
+#define RADEON_I2C_DRIVE_SEL                (1 << 7)
+#define RADEON_I2C_START                    (1 << 8)
+#define RADEON_I2C_STOP                     (1 << 9)
+#define RADEON_I2C_RECEIVE                  (1 << 10)
+#define RADEON_I2C_ABORT                    (1 << 11)
+#define RADEON_I2C_GO                       (1 << 12)
+#define RADEON_I2C_PRESCALE_SHIFT           16
 #define RADEON_I2C_CNTL_1                   0x0094
-#define RADEON_I2C_SEL         (1<<16)
-#define RADEON_I2C_EN          (1<<17)
+#define RADEON_I2C_DATA_COUNT_SHIFT         0
+#define RADEON_I2C_ADDR_COUNT_SHIFT         4
+#define RADEON_I2C_INTRA_BYTE_DELAY_SHIFT   8
+#define RADEON_I2C_SEL                      (1 << 16)
+#define RADEON_I2C_EN                       (1 << 17)
+#define RADEON_I2C_TIME_LIMIT_SHIFT         24
 #define RADEON_I2C_DATA                     0x0098
 
 #define RADEON_DVI_I2C_CNTL_0               0x02e0
@@ -1072,7 +1086,7 @@
 #       define R200_SEL_DDC1                0 /* 0x60 - VGA_DDC */
 #       define R200_SEL_DDC2                1 /* 0x64 - DVI_DDC */
 #       define R200_SEL_DDC3                2 /* 0x68 - MONID_DDC */
-#define RADEON_DVI_I2C_CNTL_1               0x02e4 /* ? */
+#define RADEON_DVI_I2C_CNTL_1               0x02e4
 #define RADEON_DVI_I2C_DATA                 0x02e8
 
 #define RADEON_INTERRUPT_LINE               0x0f3c /* PCI */
@@ -1143,15 +1157,16 @@
 #       define RADEON_IO_MCLK_MAX_DYN_STOP_LAT (1 << 13)
 #       define RADEON_MC_MCLK_DYN_ENABLE    (1 << 14)
 #       define RADEON_IO_MCLK_DYN_ENABLE    (1 << 15)
-#define RADEON_LCD_GPIO_MASK                0x01a0
-#define RADEON_GPIOPAD_EN                   0x01a0
-#define RADEON_LCD_GPIO_Y_REG               0x01a4
-#define RADEON_MDGPIO_A_REG                 0x01ac
-#define RADEON_MDGPIO_EN_REG                0x01b0
-#define RADEON_MDGPIO_MASK                  0x0198
+
 #define RADEON_GPIOPAD_MASK                 0x0198
 #define RADEON_GPIOPAD_A                    0x019c
-#define RADEON_MDGPIO_Y_REG                 0x01b4
+#define RADEON_GPIOPAD_EN                   0x01a0
+#define RADEON_GPIOPAD_Y                    0x01a4
+#define RADEON_MDGPIO_MASK                  0x01a8
+#define RADEON_MDGPIO_A                     0x01ac
+#define RADEON_MDGPIO_EN                    0x01b0
+#define RADEON_MDGPIO_Y                     0x01b4
+
 #define RADEON_MEM_ADDR_CONFIG              0x0148
 #define RADEON_MEM_BASE                     0x0f10 /* PCI */
 #define RADEON_MEM_CNTL                     0x0140
@@ -1360,6 +1375,9 @@
 #define RADEON_OVR_CLR                      0x0230
 #define RADEON_OVR_WID_LEFT_RIGHT           0x0234
 #define RADEON_OVR_WID_TOP_BOTTOM           0x0238
+#define RADEON_OVR2_CLR                     0x0330
+#define RADEON_OVR2_WID_LEFT_RIGHT          0x0334
+#define RADEON_OVR2_WID_TOP_BOTTOM          0x0338
 
 /* first capture unit */
 
diff --git a/drivers/gpu/drm/radeon/radeon_ring.c b/drivers/gpu/drm/radeon/radeon_ring.c
index 747b4bffb84b..4d12b2d17b4d 100644
--- a/drivers/gpu/drm/radeon/radeon_ring.c
+++ b/drivers/gpu/drm/radeon/radeon_ring.c
@@ -165,19 +165,24 @@ int radeon_ib_pool_init(struct radeon_device *rdev)
                 return 0;
         /* Allocate 1M object buffer */
         INIT_LIST_HEAD(&rdev->ib_pool.scheduled_ibs);
-        r = radeon_object_create(rdev, NULL,  RADEON_IB_POOL_SIZE*64*1024,
-                                 true, RADEON_GEM_DOMAIN_GTT,
-                                 false, &rdev->ib_pool.robj);
+        r = radeon_bo_create(rdev, NULL,  RADEON_IB_POOL_SIZE*64*1024,
+                                true, RADEON_GEM_DOMAIN_GTT,
+                                &rdev->ib_pool.robj);
         if (r) {
                 DRM_ERROR("radeon: failed to ib pool (%d).\n", r);
                 return r;
         }
-        r = radeon_object_pin(rdev->ib_pool.robj, RADEON_GEM_DOMAIN_GTT, &gpu_addr);
+        r = radeon_bo_reserve(rdev->ib_pool.robj, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(rdev->ib_pool.robj, RADEON_GEM_DOMAIN_GTT, &gpu_addr);
         if (r) {
+                radeon_bo_unreserve(rdev->ib_pool.robj);
                 DRM_ERROR("radeon: failed to pin ib pool (%d).\n", r);
                 return r;
         }
-        r = radeon_object_kmap(rdev->ib_pool.robj, &ptr);
+        r = radeon_bo_kmap(rdev->ib_pool.robj, &ptr);
+        radeon_bo_unreserve(rdev->ib_pool.robj);
         if (r) {
                 DRM_ERROR("radeon: failed to map ib poll (%d).\n", r);
                 return r;
@@ -203,14 +208,21 @@ int radeon_ib_pool_init(struct radeon_device *rdev)
 
 void radeon_ib_pool_fini(struct radeon_device *rdev)
 {
+        int r;
+
         if (!rdev->ib_pool.ready) {
                 return;
         }
         mutex_lock(&rdev->ib_pool.mutex);
         bitmap_zero(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
         if (rdev->ib_pool.robj) {
-                radeon_object_kunmap(rdev->ib_pool.robj);
-                radeon_object_unref(&rdev->ib_pool.robj);
+                r = radeon_bo_reserve(rdev->ib_pool.robj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rdev->ib_pool.robj);
+                        radeon_bo_unpin(rdev->ib_pool.robj);
+                        radeon_bo_unreserve(rdev->ib_pool.robj);
+                }
+                radeon_bo_unref(&rdev->ib_pool.robj);
                 rdev->ib_pool.robj = NULL;
         }
         mutex_unlock(&rdev->ib_pool.mutex);
@@ -288,29 +300,28 @@ int radeon_ring_init(struct radeon_device *rdev, unsigned ring_size)
         rdev->cp.ring_size = ring_size;
         /* Allocate ring buffer */
         if (rdev->cp.ring_obj == NULL) {
-                r = radeon_object_create(rdev, NULL, rdev->cp.ring_size,
-                                         true,
-                                         RADEON_GEM_DOMAIN_GTT,
-                                         false,
-                                         &rdev->cp.ring_obj);
+                r = radeon_bo_create(rdev, NULL, rdev->cp.ring_size, true,
+                                        RADEON_GEM_DOMAIN_GTT,
+                                        &rdev->cp.ring_obj);
                 if (r) {
-                        DRM_ERROR("radeon: failed to create ring buffer (%d).\n", r);
-                        mutex_unlock(&rdev->cp.mutex);
+                        dev_err(rdev->dev, "(%d) ring create failed\n", r);
                         return r;
                 }
-                r = radeon_object_pin(rdev->cp.ring_obj,
-                                      RADEON_GEM_DOMAIN_GTT,
-                                      &rdev->cp.gpu_addr);
+                r = radeon_bo_reserve(rdev->cp.ring_obj, false);
+                if (unlikely(r != 0))
+                        return r;
+                r = radeon_bo_pin(rdev->cp.ring_obj, RADEON_GEM_DOMAIN_GTT,
+                                        &rdev->cp.gpu_addr);
                 if (r) {
-                        DRM_ERROR("radeon: failed to pin ring buffer (%d).\n", r);
-                        mutex_unlock(&rdev->cp.mutex);
+                        radeon_bo_unreserve(rdev->cp.ring_obj);
+                        dev_err(rdev->dev, "(%d) ring pin failed\n", r);
                         return r;
                 }
-                r = radeon_object_kmap(rdev->cp.ring_obj,
+                r = radeon_bo_kmap(rdev->cp.ring_obj,
                                        (void **)&rdev->cp.ring);
+                radeon_bo_unreserve(rdev->cp.ring_obj);
                 if (r) {
-                        DRM_ERROR("radeon: failed to map ring buffer (%d).\n", r);
-                        mutex_unlock(&rdev->cp.mutex);
+                        dev_err(rdev->dev, "(%d) ring map failed\n", r);
                         return r;
                 }
         }
@@ -321,11 +332,17 @@ int radeon_ring_init(struct radeon_device *rdev, unsigned ring_size)
 
 void radeon_ring_fini(struct radeon_device *rdev)
 {
+        int r;
+
         mutex_lock(&rdev->cp.mutex);
         if (rdev->cp.ring_obj) {
-                radeon_object_kunmap(rdev->cp.ring_obj);
-                radeon_object_unpin(rdev->cp.ring_obj);
-                radeon_object_unref(&rdev->cp.ring_obj);
+                r = radeon_bo_reserve(rdev->cp.ring_obj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rdev->cp.ring_obj);
+                        radeon_bo_unpin(rdev->cp.ring_obj);
+                        radeon_bo_unreserve(rdev->cp.ring_obj);
+                }
+                radeon_bo_unref(&rdev->cp.ring_obj);
                 rdev->cp.ring = NULL;
                 rdev->cp.ring_obj = NULL;
         }
diff --git a/drivers/gpu/drm/radeon/radeon_test.c b/drivers/gpu/drm/radeon/radeon_test.c
index f8a465d9a1cf..391c973ec4db 100644
--- a/drivers/gpu/drm/radeon/radeon_test.c
+++ b/drivers/gpu/drm/radeon/radeon_test.c
@@ -30,8 +30,8 @@
 /* Test BO GTT->VRAM and VRAM->GTT GPU copies across the whole GTT aperture */
 void radeon_test_moves(struct radeon_device *rdev)
 {
-        struct radeon_object *vram_obj = NULL;
-        struct radeon_object **gtt_obj = NULL;
+        struct radeon_bo *vram_obj = NULL;
+        struct radeon_bo **gtt_obj = NULL;
         struct radeon_fence *fence = NULL;
         uint64_t gtt_addr, vram_addr;
         unsigned i, n, size;
@@ -52,38 +52,42 @@ void radeon_test_moves(struct radeon_device *rdev)
                 goto out_cleanup;
         }
 
-        r = radeon_object_create(rdev, NULL, size, true, RADEON_GEM_DOMAIN_VRAM,
-                                 false, &vram_obj);
+        r = radeon_bo_create(rdev, NULL, size, true, RADEON_GEM_DOMAIN_VRAM,
+                                &vram_obj);
         if (r) {
                 DRM_ERROR("Failed to create VRAM object\n");
                 goto out_cleanup;
         }
-
-        r = radeon_object_pin(vram_obj, RADEON_GEM_DOMAIN_VRAM, &vram_addr);
+        r = radeon_bo_reserve(vram_obj, false);
+        if (unlikely(r != 0))
+                goto out_cleanup;
+        r = radeon_bo_pin(vram_obj, RADEON_GEM_DOMAIN_VRAM, &vram_addr);
         if (r) {
                 DRM_ERROR("Failed to pin VRAM object\n");
                 goto out_cleanup;
         }
-
         for (i = 0; i < n; i++) {
                 void *gtt_map, *vram_map;
                 void **gtt_start, **gtt_end;
                 void **vram_start, **vram_end;
 
-                r = radeon_object_create(rdev, NULL, size, true,
-                                         RADEON_GEM_DOMAIN_GTT, false, gtt_obj + i);
+                r = radeon_bo_create(rdev, NULL, size, true,
+                                         RADEON_GEM_DOMAIN_GTT, gtt_obj + i);
                 if (r) {
                         DRM_ERROR("Failed to create GTT object %d\n", i);
                         goto out_cleanup;
                 }
 
-                r = radeon_object_pin(gtt_obj[i], RADEON_GEM_DOMAIN_GTT, &gtt_addr);
+                r = radeon_bo_reserve(gtt_obj[i], false);
+                if (unlikely(r != 0))
+                        goto out_cleanup;
+                r = radeon_bo_pin(gtt_obj[i], RADEON_GEM_DOMAIN_GTT, &gtt_addr);
                 if (r) {
                         DRM_ERROR("Failed to pin GTT object %d\n", i);
                         goto out_cleanup;
                 }
 
-                r = radeon_object_kmap(gtt_obj[i], &gtt_map);
+                r = radeon_bo_kmap(gtt_obj[i], &gtt_map);
                 if (r) {
                         DRM_ERROR("Failed to map GTT object %d\n", i);
                         goto out_cleanup;
@@ -94,7 +98,7 @@ void radeon_test_moves(struct radeon_device *rdev)
                      gtt_start++)
                         *gtt_start = gtt_start;
 
-                radeon_object_kunmap(gtt_obj[i]);
+                radeon_bo_kunmap(gtt_obj[i]);
 
                 r = radeon_fence_create(rdev, &fence);
                 if (r) {
@@ -116,7 +120,7 @@ void radeon_test_moves(struct radeon_device *rdev)
 
                 radeon_fence_unref(&fence);
 
-                r = radeon_object_kmap(vram_obj, &vram_map);
+                r = radeon_bo_kmap(vram_obj, &vram_map);
                 if (r) {
                         DRM_ERROR("Failed to map VRAM object after copy %d\n", i);
                         goto out_cleanup;
@@ -131,13 +135,13 @@ void radeon_test_moves(struct radeon_device *rdev)
                                           "expected 0x%p (GTT map 0x%p-0x%p)\n",
                                           i, *vram_start, gtt_start, gtt_map,
                                           gtt_end);
-                                radeon_object_kunmap(vram_obj);
+                                radeon_bo_kunmap(vram_obj);
                                 goto out_cleanup;
                         }
                         *vram_start = vram_start;
                 }
 
-                radeon_object_kunmap(vram_obj);
+                radeon_bo_kunmap(vram_obj);
 
                 r = radeon_fence_create(rdev, &fence);
                 if (r) {
@@ -159,7 +163,7 @@ void radeon_test_moves(struct radeon_device *rdev)
 
                 radeon_fence_unref(&fence);
 
-                r = radeon_object_kmap(gtt_obj[i], &gtt_map);
+                r = radeon_bo_kmap(gtt_obj[i], &gtt_map);
                 if (r) {
                         DRM_ERROR("Failed to map GTT object after copy %d\n", i);
                         goto out_cleanup;
@@ -174,12 +178,12 @@ void radeon_test_moves(struct radeon_device *rdev)
                                           "expected 0x%p (VRAM map 0x%p-0x%p)\n",
                                           i, *gtt_start, vram_start, vram_map,
                                           vram_end);
-                                radeon_object_kunmap(gtt_obj[i]);
+                                radeon_bo_kunmap(gtt_obj[i]);
                                 goto out_cleanup;
                         }
                 }
 
-                radeon_object_kunmap(gtt_obj[i]);
+                radeon_bo_kunmap(gtt_obj[i]);
 
                 DRM_INFO("Tested GTT->VRAM and VRAM->GTT copy for GTT offset 0x%llx\n",
                          gtt_addr - rdev->mc.gtt_location);
@@ -187,14 +191,20 @@ void radeon_test_moves(struct radeon_device *rdev)
 
 out_cleanup:
         if (vram_obj) {
-                radeon_object_unpin(vram_obj);
-                radeon_object_unref(&vram_obj);
+                if (radeon_bo_is_reserved(vram_obj)) {
+                        radeon_bo_unpin(vram_obj);
+                        radeon_bo_unreserve(vram_obj);
+                }
+                radeon_bo_unref(&vram_obj);
         }
         if (gtt_obj) {
                 for (i = 0; i < n; i++) {
                         if (gtt_obj[i]) {
-                                radeon_object_unpin(gtt_obj[i]);
-                                radeon_object_unref(&gtt_obj[i]);
+                                if (radeon_bo_is_reserved(gtt_obj[i])) {
+                                        radeon_bo_unpin(gtt_obj[i]);
+                                        radeon_bo_unreserve(gtt_obj[i]);
+                                }
+                                radeon_bo_unref(&gtt_obj[i]);
                         }
                 }
                 kfree(gtt_obj);
@@ -206,4 +216,3 @@ out_cleanup:
                 printk(KERN_WARNING "Error while testing BO move.\n");
         }
 }
-
diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c
index 1381e06d6af3..bdb46c8cadd1 100644
--- a/drivers/gpu/drm/radeon/radeon_ttm.c
+++ b/drivers/gpu/drm/radeon/radeon_ttm.c
@@ -150,7 +150,7 @@ static int radeon_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
                 man->default_caching = TTM_PL_FLAG_CACHED;
                 break;
         case TTM_PL_TT:
-                man->gpu_offset = 0;
+                man->gpu_offset = rdev->mc.gtt_location;
                 man->available_caching = TTM_PL_MASK_CACHING;
                 man->default_caching = TTM_PL_FLAG_CACHED;
                 man->flags = TTM_MEMTYPE_FLAG_MAPPABLE | TTM_MEMTYPE_FLAG_CMA;
@@ -180,7 +180,7 @@ static int radeon_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
                 break;
         case TTM_PL_VRAM:
                 /* "On-card" video ram */
-                man->gpu_offset = 0;
+                man->gpu_offset = rdev->mc.vram_location;
                 man->flags = TTM_MEMTYPE_FLAG_FIXED |
                              TTM_MEMTYPE_FLAG_NEEDS_IOREMAP |
                              TTM_MEMTYPE_FLAG_MAPPABLE;
@@ -482,27 +482,31 @@ int radeon_ttm_init(struct radeon_device *rdev)
                 DRM_ERROR("failed initializing buffer object driver(%d).\n", r);
                 return r;
         }
-        r = ttm_bo_init_mm(&rdev->mman.bdev, TTM_PL_VRAM, 0,
-                           ((rdev->mc.real_vram_size) >> PAGE_SHIFT));
+        r = ttm_bo_init_mm(&rdev->mman.bdev, TTM_PL_VRAM,
+                                0, rdev->mc.real_vram_size >> PAGE_SHIFT);
         if (r) {
                 DRM_ERROR("Failed initializing VRAM heap.\n");
                 return r;
         }
-        r = radeon_object_create(rdev, NULL, 256 * 1024, true,
-                                 RADEON_GEM_DOMAIN_VRAM, false,
-                                 &rdev->stollen_vga_memory);
+        r = radeon_bo_create(rdev, NULL, 256 * 1024, true,
+                                RADEON_GEM_DOMAIN_VRAM,
+                                &rdev->stollen_vga_memory);
         if (r) {
                 return r;
         }
-        r = radeon_object_pin(rdev->stollen_vga_memory, RADEON_GEM_DOMAIN_VRAM, NULL);
+        r = radeon_bo_reserve(rdev->stollen_vga_memory, false);
+        if (r)
+                return r;
+        r = radeon_bo_pin(rdev->stollen_vga_memory, RADEON_GEM_DOMAIN_VRAM, NULL);
+        radeon_bo_unreserve(rdev->stollen_vga_memory);
         if (r) {
-                radeon_object_unref(&rdev->stollen_vga_memory);
+                radeon_bo_unref(&rdev->stollen_vga_memory);
                 return r;
         }
         DRM_INFO("radeon: %uM of VRAM memory ready\n",
                  (unsigned)rdev->mc.real_vram_size / (1024 * 1024));
-        r = ttm_bo_init_mm(&rdev->mman.bdev, TTM_PL_TT, 0,
-                           ((rdev->mc.gtt_size) >> PAGE_SHIFT));
+        r = ttm_bo_init_mm(&rdev->mman.bdev, TTM_PL_TT,
+                                0, rdev->mc.gtt_size >> PAGE_SHIFT);
         if (r) {
                 DRM_ERROR("Failed initializing GTT heap.\n");
                 return r;
@@ -523,9 +527,15 @@ int radeon_ttm_init(struct radeon_device *rdev)
 
 void radeon_ttm_fini(struct radeon_device *rdev)
 {
+        int r;
+
         if (rdev->stollen_vga_memory) {
-                radeon_object_unpin(rdev->stollen_vga_memory);
-                radeon_object_unref(&rdev->stollen_vga_memory);
+                r = radeon_bo_reserve(rdev->stollen_vga_memory, false);
+                if (r == 0) {
+                        radeon_bo_unpin(rdev->stollen_vga_memory);
+                        radeon_bo_unreserve(rdev->stollen_vga_memory);
+                }
+                radeon_bo_unref(&rdev->stollen_vga_memory);
         }
         ttm_bo_clean_mm(&rdev->mman.bdev, TTM_PL_VRAM);
         ttm_bo_clean_mm(&rdev->mman.bdev, TTM_PL_TT);
diff --git a/drivers/gpu/drm/radeon/rs400.c b/drivers/gpu/drm/radeon/rs400.c
index ca037160a582..eda6d757b5c4 100644
--- a/drivers/gpu/drm/radeon/rs400.c
+++ b/drivers/gpu/drm/radeon/rs400.c
@@ -352,7 +352,7 @@ static int rs400_mc_init(struct radeon_device *rdev)
         u32 tmp;
 
         /* Setup GPU memory space */
-        tmp = G_00015C_MC_FB_START(RREG32(R_00015C_NB_TOM));
+        tmp = RREG32(R_00015C_NB_TOM);
         rdev->mc.vram_location = G_00015C_MC_FB_START(tmp) << 16;
         rdev->mc.gtt_location = 0xFFFFFFFFUL;
         r = radeon_mc_setup(rdev);
@@ -387,13 +387,13 @@ static int rs400_startup(struct radeon_device *rdev)
         r300_clock_startup(rdev);
         /* Initialize GPU configuration (# pipes, ...) */
         rs400_gpu_init(rdev);
+        r100_enable_bm(rdev);
         /* Initialize GART (initialize after TTM so we can allocate
          * memory through TTM but finalize after TTM) */
         r = rs400_gart_enable(rdev);
         if (r)
                 return r;
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         r100_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -452,7 +452,7 @@ void rs400_fini(struct radeon_device *rdev)
         rs400_gart_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -490,10 +490,9 @@ int rs400_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                radeon_combios_asic_init(rdev->ddev);
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
+
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
         /* Get vram informations */
@@ -510,7 +509,7 @@ int rs400_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         r = rs400_gart_init(rdev);
diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c
index 5f117cd8736a..fd5ab01f6ad1 100644
--- a/drivers/gpu/drm/radeon/rs600.c
+++ b/drivers/gpu/drm/radeon/rs600.c
@@ -45,6 +45,122 @@
 void rs600_gpu_init(struct radeon_device *rdev);
 int rs600_mc_wait_for_idle(struct radeon_device *rdev);
 
+int rs600_mc_init(struct radeon_device *rdev)
+{
+        /* read back the MC value from the hw */
+        int r;
+        u32 tmp;
+
+        /* Setup GPU memory space */
+        tmp = RREG32_MC(R_000004_MC_FB_LOCATION);
+        rdev->mc.vram_location = G_000004_MC_FB_START(tmp) << 16;
+        rdev->mc.gtt_location = 0xffffffffUL;
+        r = radeon_mc_setup(rdev);
+        if (r)
+                return r;
+        return 0;
+}
+
+/* hpd for digital panel detect/disconnect */
+bool rs600_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd)
+{
+        u32 tmp;
+        bool connected = false;
+
+        switch (hpd) {
+        case RADEON_HPD_1:
+                tmp = RREG32(R_007D04_DC_HOT_PLUG_DETECT1_INT_STATUS);
+                if (G_007D04_DC_HOT_PLUG_DETECT1_SENSE(tmp))
+                        connected = true;
+                break;
+        case RADEON_HPD_2:
+                tmp = RREG32(R_007D14_DC_HOT_PLUG_DETECT2_INT_STATUS);
+                if (G_007D14_DC_HOT_PLUG_DETECT2_SENSE(tmp))
+                        connected = true;
+                break;
+        default:
+                break;
+        }
+        return connected;
+}
+
+void rs600_hpd_set_polarity(struct radeon_device *rdev,
+                            enum radeon_hpd_id hpd)
+{
+        u32 tmp;
+        bool connected = rs600_hpd_sense(rdev, hpd);
+
+        switch (hpd) {
+        case RADEON_HPD_1:
+                tmp = RREG32(R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL);
+                if (connected)
+                        tmp &= ~S_007D08_DC_HOT_PLUG_DETECT1_INT_POLARITY(1);
+                else
+                        tmp |= S_007D08_DC_HOT_PLUG_DETECT1_INT_POLARITY(1);
+                WREG32(R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL, tmp);
+                break;
+        case RADEON_HPD_2:
+                tmp = RREG32(R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL);
+                if (connected)
+                        tmp &= ~S_007D18_DC_HOT_PLUG_DETECT2_INT_POLARITY(1);
+                else
+                        tmp |= S_007D18_DC_HOT_PLUG_DETECT2_INT_POLARITY(1);
+                WREG32(R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL, tmp);
+                break;
+        default:
+                break;
+        }
+}
+
+void rs600_hpd_init(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct drm_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                switch (radeon_connector->hpd.hpd) {
+                case RADEON_HPD_1:
+                        WREG32(R_007D00_DC_HOT_PLUG_DETECT1_CONTROL,
+                               S_007D00_DC_HOT_PLUG_DETECT1_EN(1));
+                        rdev->irq.hpd[0] = true;
+                        break;
+                case RADEON_HPD_2:
+                        WREG32(R_007D10_DC_HOT_PLUG_DETECT2_CONTROL,
+                               S_007D10_DC_HOT_PLUG_DETECT2_EN(1));
+                        rdev->irq.hpd[1] = true;
+                        break;
+                default:
+                        break;
+                }
+        }
+        rs600_irq_set(rdev);
+}
+
+void rs600_hpd_fini(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct drm_connector *connector;
+
+        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+                struct radeon_connector *radeon_connector = to_radeon_connector(connector);
+                switch (radeon_connector->hpd.hpd) {
+                case RADEON_HPD_1:
+                        WREG32(R_007D00_DC_HOT_PLUG_DETECT1_CONTROL,
+                               S_007D00_DC_HOT_PLUG_DETECT1_EN(0));
+                        rdev->irq.hpd[0] = false;
+                        break;
+                case RADEON_HPD_2:
+                        WREG32(R_007D10_DC_HOT_PLUG_DETECT2_CONTROL,
+                               S_007D10_DC_HOT_PLUG_DETECT2_EN(0));
+                        rdev->irq.hpd[1] = false;
+                        break;
+                default:
+                        break;
+                }
+        }
+}
+
 /*
  * GART.
  */
@@ -100,40 +216,40 @@ int rs600_gart_enable(struct radeon_device *rdev)
         WREG32(R_00004C_BUS_CNTL, tmp);
         /* FIXME: setup default page */
         WREG32_MC(R_000100_MC_PT0_CNTL,
-                 (S_000100_EFFECTIVE_L2_CACHE_SIZE(6) |
-                  S_000100_EFFECTIVE_L2_QUEUE_SIZE(6)));
+                  (S_000100_EFFECTIVE_L2_CACHE_SIZE(6) |
+                   S_000100_EFFECTIVE_L2_QUEUE_SIZE(6)));
+
         for (i = 0; i < 19; i++) {
                 WREG32_MC(R_00016C_MC_PT0_CLIENT0_CNTL + i,
-                        S_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(1) |
-                        S_00016C_SYSTEM_ACCESS_MODE_MASK(
-                                V_00016C_SYSTEM_ACCESS_MODE_IN_SYS) |
-                        S_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS(
-                                V_00016C_SYSTEM_APERTURE_UNMAPPED_DEFAULT_PAGE) |
-                        S_00016C_EFFECTIVE_L1_CACHE_SIZE(1) |
-                        S_00016C_ENABLE_FRAGMENT_PROCESSING(1) |
-                        S_00016C_EFFECTIVE_L1_QUEUE_SIZE(1));
+                          S_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(1) |
+                          S_00016C_SYSTEM_ACCESS_MODE_MASK(
+                                  V_00016C_SYSTEM_ACCESS_MODE_NOT_IN_SYS) |
+                          S_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS(
+                                  V_00016C_SYSTEM_APERTURE_UNMAPPED_PASSTHROUGH) |
+                          S_00016C_EFFECTIVE_L1_CACHE_SIZE(3) |
+                          S_00016C_ENABLE_FRAGMENT_PROCESSING(1) |
+                          S_00016C_EFFECTIVE_L1_QUEUE_SIZE(3));
         }
-
-        /* System context map to GART space */
-        WREG32_MC(R_000112_MC_PT0_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.gtt_start);
-        WREG32_MC(R_000114_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR, rdev->mc.gtt_end);
-
         /* enable first context */
-        WREG32_MC(R_00013C_MC_PT0_CONTEXT0_FLAT_START_ADDR, rdev->mc.gtt_start);
-        WREG32_MC(R_00014C_MC_PT0_CONTEXT0_FLAT_END_ADDR, rdev->mc.gtt_end);
         WREG32_MC(R_000102_MC_PT0_CONTEXT0_CNTL,
-                        S_000102_ENABLE_PAGE_TABLE(1) |
-                        S_000102_PAGE_TABLE_DEPTH(V_000102_PAGE_TABLE_FLAT));
+                  S_000102_ENABLE_PAGE_TABLE(1) |
+                  S_000102_PAGE_TABLE_DEPTH(V_000102_PAGE_TABLE_FLAT));
+
         /* disable all other contexts */
-        for (i = 1; i < 8; i++) {
+        for (i = 1; i < 8; i++)
                 WREG32_MC(R_000102_MC_PT0_CONTEXT0_CNTL + i, 0);
-        }
 
         /* setup the page table */
         WREG32_MC(R_00012C_MC_PT0_CONTEXT0_FLAT_BASE_ADDR,
-                        rdev->gart.table_addr);
+                  rdev->gart.table_addr);
+        WREG32_MC(R_00013C_MC_PT0_CONTEXT0_FLAT_START_ADDR, rdev->mc.gtt_start);
+        WREG32_MC(R_00014C_MC_PT0_CONTEXT0_FLAT_END_ADDR, rdev->mc.gtt_end);
         WREG32_MC(R_00011C_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR, 0);
 
+        /* System context maps to VRAM space */
+        WREG32_MC(R_000112_MC_PT0_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start);
+        WREG32_MC(R_000114_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR, rdev->mc.vram_end);
+
         /* enable page tables */
         tmp = RREG32_MC(R_000100_MC_PT0_CNTL);
         WREG32_MC(R_000100_MC_PT0_CNTL, (tmp | S_000100_ENABLE_PT(1)));
@@ -146,15 +262,20 @@ int rs600_gart_enable(struct radeon_device *rdev)
 
 void rs600_gart_disable(struct radeon_device *rdev)
 {
-        uint32_t tmp;
+        u32 tmp;
+        int r;
 
         /* FIXME: disable out of gart access */
         WREG32_MC(R_000100_MC_PT0_CNTL, 0);
         tmp = RREG32_MC(R_000009_MC_CNTL1);
         WREG32_MC(R_000009_MC_CNTL1, tmp & C_000009_ENABLE_PAGE_TABLES);
         if (rdev->gart.table.vram.robj) {
-                radeon_object_kunmap(rdev->gart.table.vram.robj);
-                radeon_object_unpin(rdev->gart.table.vram.robj);
+                r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
+                if (r == 0) {
+                        radeon_bo_kunmap(rdev->gart.table.vram.robj);
+                        radeon_bo_unpin(rdev->gart.table.vram.robj);
+                        radeon_bo_unreserve(rdev->gart.table.vram.robj);
+                }
         }
 }
 
@@ -189,6 +310,10 @@ int rs600_irq_set(struct radeon_device *rdev)
 {
         uint32_t tmp = 0;
         uint32_t mode_int = 0;
+        u32 hpd1 = RREG32(R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL) &
+                ~S_007D08_DC_HOT_PLUG_DETECT1_INT_EN(1);
+        u32 hpd2 = RREG32(R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL) &
+                ~S_007D18_DC_HOT_PLUG_DETECT2_INT_EN(1);
 
         if (rdev->irq.sw_int) {
                 tmp |= S_000040_SW_INT_EN(1);
@@ -199,8 +324,16 @@ int rs600_irq_set(struct radeon_device *rdev)
         if (rdev->irq.crtc_vblank_int[1]) {
                 mode_int |= S_006540_D2MODE_VBLANK_INT_MASK(1);
         }
+        if (rdev->irq.hpd[0]) {
+                hpd1 |= S_007D08_DC_HOT_PLUG_DETECT1_INT_EN(1);
+        }
+        if (rdev->irq.hpd[1]) {
+                hpd2 |= S_007D18_DC_HOT_PLUG_DETECT2_INT_EN(1);
+        }
         WREG32(R_000040_GEN_INT_CNTL, tmp);
         WREG32(R_006540_DxMODE_INT_MASK, mode_int);
+        WREG32(R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL, hpd1);
+        WREG32(R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL, hpd2);
         return 0;
 }
 
@@ -208,6 +341,7 @@ static inline uint32_t rs600_irq_ack(struct radeon_device *rdev, u32 *r500_disp_
 {
         uint32_t irqs = RREG32(R_000044_GEN_INT_STATUS);
         uint32_t irq_mask = ~C_000044_SW_INT;
+        u32 tmp;
 
         if (G_000044_DISPLAY_INT_STAT(irqs)) {
                 *r500_disp_int = RREG32(R_007EDC_DISP_INTERRUPT_STATUS);
@@ -219,6 +353,16 @@ static inline uint32_t rs600_irq_ack(struct radeon_device *rdev, u32 *r500_disp_
                         WREG32(R_006D34_D2MODE_VBLANK_STATUS,
                                 S_006D34_D2MODE_VBLANK_ACK(1));
                 }
+                if (G_007EDC_DC_HOT_PLUG_DETECT1_INTERRUPT(*r500_disp_int)) {
+                        tmp = RREG32(R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL);
+                        tmp |= S_007D08_DC_HOT_PLUG_DETECT1_INT_ACK(1);
+                        WREG32(R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL, tmp);
+                }
+                if (G_007EDC_DC_HOT_PLUG_DETECT2_INTERRUPT(*r500_disp_int)) {
+                        tmp = RREG32(R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL);
+                        tmp |= S_007D18_DC_HOT_PLUG_DETECT2_INT_ACK(1);
+                        WREG32(R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL, tmp);
+                }
         } else {
                 *r500_disp_int = 0;
         }
@@ -244,6 +388,7 @@ int rs600_irq_process(struct radeon_device *rdev)
 {
         uint32_t status, msi_rearm;
         uint32_t r500_disp_int;
+        bool queue_hotplug = false;
 
         status = rs600_irq_ack(rdev, &r500_disp_int);
         if (!status && !r500_disp_int) {
@@ -258,8 +403,18 @@ int rs600_irq_process(struct radeon_device *rdev)
                         drm_handle_vblank(rdev->ddev, 0);
                 if (G_007EDC_LB_D2_VBLANK_INTERRUPT(r500_disp_int))
                         drm_handle_vblank(rdev->ddev, 1);
+                if (G_007EDC_DC_HOT_PLUG_DETECT1_INTERRUPT(r500_disp_int)) {
+                        queue_hotplug = true;
+                        DRM_DEBUG("HPD1\n");
+                }
+                if (G_007EDC_DC_HOT_PLUG_DETECT2_INTERRUPT(r500_disp_int)) {
+                        queue_hotplug = true;
+                        DRM_DEBUG("HPD2\n");
+                }
                 status = rs600_irq_ack(rdev, &r500_disp_int);
         }
+        if (queue_hotplug)
+                queue_work(rdev->wq, &rdev->hotplug_work);
         if (rdev->msi_enabled) {
                 switch (rdev->family) {
                 case CHIP_RS600:
@@ -301,9 +456,7 @@ int rs600_mc_wait_for_idle(struct radeon_device *rdev)
 
 void rs600_gpu_init(struct radeon_device *rdev)
 {
-        /* FIXME: HDP same place on rs600 ? */
         r100_hdp_reset(rdev);
-        /* FIXME: is this correct ? */
         r420_pipes_init(rdev);
         /* Wait for mc idle */
         if (rs600_mc_wait_for_idle(rdev))
@@ -312,9 +465,20 @@ void rs600_gpu_init(struct radeon_device *rdev)
 
 void rs600_vram_info(struct radeon_device *rdev)
 {
-        /* FIXME: to do or is these values sane ? */
         rdev->mc.vram_is_ddr = true;
         rdev->mc.vram_width = 128;
+
+        rdev->mc.real_vram_size = RREG32(RADEON_CONFIG_MEMSIZE);
+        rdev->mc.mc_vram_size = rdev->mc.real_vram_size;
+
+        rdev->mc.aper_base = drm_get_resource_start(rdev->ddev, 0);
+        rdev->mc.aper_size = drm_get_resource_len(rdev->ddev, 0);
+
+        if (rdev->mc.mc_vram_size > rdev->mc.aper_size)
+                rdev->mc.mc_vram_size = rdev->mc.aper_size;
+
+        if (rdev->mc.real_vram_size > rdev->mc.aper_size)
+                rdev->mc.real_vram_size = rdev->mc.aper_size;
 }
 
 void rs600_bandwidth_update(struct radeon_device *rdev)
@@ -388,7 +552,6 @@ static int rs600_startup(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         rs600_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -445,7 +608,7 @@ void rs600_fini(struct radeon_device *rdev)
         rs600_gart_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -482,10 +645,9 @@ int rs600_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                atom_asic_init(rdev->mode_info.atom_context);
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
+
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
         /* Initialize power management */
@@ -493,7 +655,7 @@ int rs600_init(struct radeon_device *rdev)
         /* Get vram informations */
         rs600_vram_info(rdev);
         /* Initialize memory controller (also test AGP) */
-        r = r420_mc_init(rdev);
+        r = rs600_mc_init(rdev);
         if (r)
                 return r;
         rs600_debugfs(rdev);
@@ -505,7 +667,7 @@ int rs600_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         r = rs600_gart_init(rdev);
diff --git a/drivers/gpu/drm/radeon/rs600d.h b/drivers/gpu/drm/radeon/rs600d.h
index 81308924859a..c1c8f5885cbb 100644
--- a/drivers/gpu/drm/radeon/rs600d.h
+++ b/drivers/gpu/drm/radeon/rs600d.h
@@ -30,27 +30,12 @@
 
 /* Registers */
 #define R_000040_GEN_INT_CNTL                        0x000040
-#define   S_000040_DISPLAY_INT_STATUS(x)               (((x) & 0x1) << 0)
-#define   G_000040_DISPLAY_INT_STATUS(x)               (((x) >> 0) & 0x1)
-#define   C_000040_DISPLAY_INT_STATUS                  0xFFFFFFFE
-#define   S_000040_DMA_VIPH0_INT_EN(x)                 (((x) & 0x1) << 12)
-#define   G_000040_DMA_VIPH0_INT_EN(x)                 (((x) >> 12) & 0x1)
-#define   C_000040_DMA_VIPH0_INT_EN                    0xFFFFEFFF
-#define   S_000040_CRTC2_VSYNC(x)                      (((x) & 0x1) << 6)
-#define   G_000040_CRTC2_VSYNC(x)                      (((x) >> 6) & 0x1)
-#define   C_000040_CRTC2_VSYNC                         0xFFFFFFBF
-#define   S_000040_SNAPSHOT2(x)                        (((x) & 0x1) << 7)
-#define   G_000040_SNAPSHOT2(x)                        (((x) >> 7) & 0x1)
-#define   C_000040_SNAPSHOT2                           0xFFFFFF7F
-#define   S_000040_CRTC2_VBLANK(x)                     (((x) & 0x1) << 9)
-#define   G_000040_CRTC2_VBLANK(x)                     (((x) >> 9) & 0x1)
-#define   C_000040_CRTC2_VBLANK                        0xFFFFFDFF
-#define   S_000040_FP2_DETECT(x)                       (((x) & 0x1) << 10)
-#define   G_000040_FP2_DETECT(x)                       (((x) >> 10) & 0x1)
-#define   C_000040_FP2_DETECT                          0xFFFFFBFF
-#define   S_000040_VSYNC_DIFF_OVER_LIMIT(x)            (((x) & 0x1) << 11)
-#define   G_000040_VSYNC_DIFF_OVER_LIMIT(x)            (((x) >> 11) & 0x1)
-#define   C_000040_VSYNC_DIFF_OVER_LIMIT               0xFFFFF7FF
+#define   S_000040_SCRATCH_INT_MASK(x)                 (((x) & 0x1) << 18)
+#define   G_000040_SCRATCH_INT_MASK(x)                 (((x) >> 18) & 0x1)
+#define   C_000040_SCRATCH_INT_MASK                    0xFFFBFFFF
+#define   S_000040_GUI_IDLE_MASK(x)                    (((x) & 0x1) << 19)
+#define   G_000040_GUI_IDLE_MASK(x)                    (((x) >> 19) & 0x1)
+#define   C_000040_GUI_IDLE_MASK                       0xFFF7FFFF
 #define   S_000040_DMA_VIPH1_INT_EN(x)                 (((x) & 0x1) << 13)
 #define   G_000040_DMA_VIPH1_INT_EN(x)                 (((x) >> 13) & 0x1)
 #define   C_000040_DMA_VIPH1_INT_EN                    0xFFFFDFFF
@@ -370,7 +355,90 @@
 #define   S_007EDC_LB_D2_VBLANK_INTERRUPT(x)           (((x) & 0x1) << 5)
 #define   G_007EDC_LB_D2_VBLANK_INTERRUPT(x)           (((x) >> 5) & 0x1)
 #define   C_007EDC_LB_D2_VBLANK_INTERRUPT              0xFFFFFFDF
-
+#define   S_007EDC_DACA_AUTODETECT_INTERRUPT(x)        (((x) & 0x1) << 16)
+#define   G_007EDC_DACA_AUTODETECT_INTERRUPT(x)        (((x) >> 16) & 0x1)
+#define   C_007EDC_DACA_AUTODETECT_INTERRUPT           0xFFFEFFFF
+#define   S_007EDC_DACB_AUTODETECT_INTERRUPT(x)        (((x) & 0x1) << 17)
+#define   G_007EDC_DACB_AUTODETECT_INTERRUPT(x)        (((x) >> 17) & 0x1)
+#define   C_007EDC_DACB_AUTODETECT_INTERRUPT           0xFFFDFFFF
+#define   S_007EDC_DC_HOT_PLUG_DETECT1_INTERRUPT(x)    (((x) & 0x1) << 18)
+#define   G_007EDC_DC_HOT_PLUG_DETECT1_INTERRUPT(x)    (((x) >> 18) & 0x1)
+#define   C_007EDC_DC_HOT_PLUG_DETECT1_INTERRUPT       0xFFFBFFFF
+#define   S_007EDC_DC_HOT_PLUG_DETECT2_INTERRUPT(x)    (((x) & 0x1) << 19)
+#define   G_007EDC_DC_HOT_PLUG_DETECT2_INTERRUPT(x)    (((x) >> 19) & 0x1)
+#define   C_007EDC_DC_HOT_PLUG_DETECT2_INTERRUPT       0xFFF7FFFF
+#define R_007828_DACA_AUTODETECT_CONTROL               0x007828
+#define   S_007828_DACA_AUTODETECT_MODE(x)             (((x) & 0x3) << 0)
+#define   G_007828_DACA_AUTODETECT_MODE(x)             (((x) >> 0) & 0x3)
+#define   C_007828_DACA_AUTODETECT_MODE                0xFFFFFFFC
+#define   S_007828_DACA_AUTODETECT_FRAME_TIME_COUNTER(x) (((x) & 0xff) << 8)
+#define   G_007828_DACA_AUTODETECT_FRAME_TIME_COUNTER(x) (((x) >> 8) & 0xff)
+#define   C_007828_DACA_AUTODETECT_FRAME_TIME_COUNTER  0xFFFF00FF
+#define   S_007828_DACA_AUTODETECT_CHECK_MASK(x)       (((x) & 0x3) << 16)
+#define   G_007828_DACA_AUTODETECT_CHECK_MASK(x)       (((x) >> 16) & 0x3)
+#define   C_007828_DACA_AUTODETECT_CHECK_MASK          0xFFFCFFFF
+#define R_007838_DACA_AUTODETECT_INT_CONTROL           0x007838
+#define   S_007838_DACA_AUTODETECT_ACK(x)              (((x) & 0x1) << 0)
+#define   C_007838_DACA_DACA_AUTODETECT_ACK            0xFFFFFFFE
+#define   S_007838_DACA_AUTODETECT_INT_ENABLE(x)       (((x) & 0x1) << 16)
+#define   G_007838_DACA_AUTODETECT_INT_ENABLE(x)       (((x) >> 16) & 0x1)
+#define   C_007838_DACA_AUTODETECT_INT_ENABLE          0xFFFCFFFF
+#define R_007A28_DACB_AUTODETECT_CONTROL               0x007A28
+#define   S_007A28_DACB_AUTODETECT_MODE(x)             (((x) & 0x3) << 0)
+#define   G_007A28_DACB_AUTODETECT_MODE(x)             (((x) >> 0) & 0x3)
+#define   C_007A28_DACB_AUTODETECT_MODE                0xFFFFFFFC
+#define   S_007A28_DACB_AUTODETECT_FRAME_TIME_COUNTER(x) (((x) & 0xff) << 8)
+#define   G_007A28_DACB_AUTODETECT_FRAME_TIME_COUNTER(x) (((x) >> 8) & 0xff)
+#define   C_007A28_DACB_AUTODETECT_FRAME_TIME_COUNTER  0xFFFF00FF
+#define   S_007A28_DACB_AUTODETECT_CHECK_MASK(x)       (((x) & 0x3) << 16)
+#define   G_007A28_DACB_AUTODETECT_CHECK_MASK(x)       (((x) >> 16) & 0x3)
+#define   C_007A28_DACB_AUTODETECT_CHECK_MASK          0xFFFCFFFF
+#define R_007A38_DACB_AUTODETECT_INT_CONTROL           0x007A38
+#define   S_007A38_DACB_AUTODETECT_ACK(x)              (((x) & 0x1) << 0)
+#define   C_007A38_DACB_DACA_AUTODETECT_ACK            0xFFFFFFFE
+#define   S_007A38_DACB_AUTODETECT_INT_ENABLE(x)       (((x) & 0x1) << 16)
+#define   G_007A38_DACB_AUTODETECT_INT_ENABLE(x)       (((x) >> 16) & 0x1)
+#define   C_007A38_DACB_AUTODETECT_INT_ENABLE          0xFFFCFFFF
+#define R_007D00_DC_HOT_PLUG_DETECT1_CONTROL           0x007D00
+#define   S_007D00_DC_HOT_PLUG_DETECT1_EN(x)           (((x) & 0x1) << 0)
+#define   G_007D00_DC_HOT_PLUG_DETECT1_EN(x)           (((x) >> 0) & 0x1)
+#define   C_007D00_DC_HOT_PLUG_DETECT1_EN              0xFFFFFFFE
+#define R_007D04_DC_HOT_PLUG_DETECT1_INT_STATUS        0x007D04
+#define   S_007D04_DC_HOT_PLUG_DETECT1_INT_STATUS(x)   (((x) & 0x1) << 0)
+#define   G_007D04_DC_HOT_PLUG_DETECT1_INT_STATUS(x)   (((x) >> 0) & 0x1)
+#define   C_007D04_DC_HOT_PLUG_DETECT1_INT_STATUS      0xFFFFFFFE
+#define   S_007D04_DC_HOT_PLUG_DETECT1_SENSE(x)        (((x) & 0x1) << 1)
+#define   G_007D04_DC_HOT_PLUG_DETECT1_SENSE(x)        (((x) >> 1) & 0x1)
+#define   C_007D04_DC_HOT_PLUG_DETECT1_SENSE           0xFFFFFFFD
+#define R_007D08_DC_HOT_PLUG_DETECT1_INT_CONTROL       0x007D08
+#define   S_007D08_DC_HOT_PLUG_DETECT1_INT_ACK(x)      (((x) & 0x1) << 0)
+#define   C_007D08_DC_HOT_PLUG_DETECT1_INT_ACK         0xFFFFFFFE
+#define   S_007D08_DC_HOT_PLUG_DETECT1_INT_POLARITY(x) (((x) & 0x1) << 8)
+#define   G_007D08_DC_HOT_PLUG_DETECT1_INT_POLARITY(x) (((x) >> 8) & 0x1)
+#define   C_007D08_DC_HOT_PLUG_DETECT1_INT_POLARITY    0xFFFFFEFF
+#define   S_007D08_DC_HOT_PLUG_DETECT1_INT_EN(x)       (((x) & 0x1) << 16)
+#define   G_007D08_DC_HOT_PLUG_DETECT1_INT_EN(x)       (((x) >> 16) & 0x1)
+#define   C_007D08_DC_HOT_PLUG_DETECT1_INT_EN          0xFFFEFFFF
+#define R_007D10_DC_HOT_PLUG_DETECT2_CONTROL           0x007D10
+#define   S_007D10_DC_HOT_PLUG_DETECT2_EN(x)           (((x) & 0x1) << 0)
+#define   G_007D10_DC_HOT_PLUG_DETECT2_EN(x)           (((x) >> 0) & 0x1)
+#define   C_007D10_DC_HOT_PLUG_DETECT2_EN              0xFFFFFFFE
+#define R_007D14_DC_HOT_PLUG_DETECT2_INT_STATUS        0x007D14
+#define   S_007D14_DC_HOT_PLUG_DETECT2_INT_STATUS(x)   (((x) & 0x1) << 0)
+#define   G_007D14_DC_HOT_PLUG_DETECT2_INT_STATUS(x)   (((x) >> 0) & 0x1)
+#define   C_007D14_DC_HOT_PLUG_DETECT2_INT_STATUS      0xFFFFFFFE
+#define   S_007D14_DC_HOT_PLUG_DETECT2_SENSE(x)        (((x) & 0x1) << 1)
+#define   G_007D14_DC_HOT_PLUG_DETECT2_SENSE(x)        (((x) >> 1) & 0x1)
+#define   C_007D14_DC_HOT_PLUG_DETECT2_SENSE           0xFFFFFFFD
+#define R_007D18_DC_HOT_PLUG_DETECT2_INT_CONTROL       0x007D18
+#define   S_007D18_DC_HOT_PLUG_DETECT2_INT_ACK(x)      (((x) & 0x1) << 0)
+#define   C_007D18_DC_HOT_PLUG_DETECT2_INT_ACK         0xFFFFFFFE
+#define   S_007D18_DC_HOT_PLUG_DETECT2_INT_POLARITY(x) (((x) & 0x1) << 8)
+#define   G_007D18_DC_HOT_PLUG_DETECT2_INT_POLARITY(x) (((x) >> 8) & 0x1)
+#define   C_007D18_DC_HOT_PLUG_DETECT2_INT_POLARITY    0xFFFFFEFF
+#define   S_007D18_DC_HOT_PLUG_DETECT2_INT_EN(x)       (((x) & 0x1) << 16)
+#define   G_007D18_DC_HOT_PLUG_DETECT2_INT_EN(x)       (((x) >> 16) & 0x1)
+#define   C_007D18_DC_HOT_PLUG_DETECT2_INT_EN          0xFFFEFFFF
 
 /* MC registers */
 #define R_000000_MC_STATUS                           0x000000
diff --git a/drivers/gpu/drm/radeon/rs690.c b/drivers/gpu/drm/radeon/rs690.c
index 27547175cf93..eb486ee7ea00 100644
--- a/drivers/gpu/drm/radeon/rs690.c
+++ b/drivers/gpu/drm/radeon/rs690.c
@@ -131,24 +131,25 @@ void rs690_pm_info(struct radeon_device *rdev)
 
 void rs690_vram_info(struct radeon_device *rdev)
 {
-        uint32_t tmp;
         fixed20_12 a;
 
         rs400_gart_adjust_size(rdev);
-        /* DDR for all card after R300 & IGP */
+
         rdev->mc.vram_is_ddr = true;
-        /* FIXME: is this correct for RS690/RS740 ? */
-        tmp = RREG32(RADEON_MEM_CNTL);
-        if (tmp & R300_MEM_NUM_CHANNELS_MASK) {
-                rdev->mc.vram_width = 128;
-        } else {
-                rdev->mc.vram_width = 64;
-        }
+        rdev->mc.vram_width = 128;
+
         rdev->mc.real_vram_size = RREG32(RADEON_CONFIG_MEMSIZE);
         rdev->mc.mc_vram_size = rdev->mc.real_vram_size;
 
         rdev->mc.aper_base = drm_get_resource_start(rdev->ddev, 0);
         rdev->mc.aper_size = drm_get_resource_len(rdev->ddev, 0);
+
+        if (rdev->mc.mc_vram_size > rdev->mc.aper_size)
+                rdev->mc.mc_vram_size = rdev->mc.aper_size;
+
+        if (rdev->mc.real_vram_size > rdev->mc.aper_size)
+                rdev->mc.real_vram_size = rdev->mc.aper_size;
+
         rs690_pm_info(rdev);
         /* FIXME: we should enforce default clock in case GPU is not in
          * default setup
@@ -161,6 +162,21 @@ void rs690_vram_info(struct radeon_device *rdev)
         rdev->pm.core_bandwidth.full = rfixed_div(rdev->pm.sclk, a);
 }
 
+static int rs690_mc_init(struct radeon_device *rdev)
+{
+        int r;
+        u32 tmp;
+
+        /* Setup GPU memory space */
+        tmp = RREG32_MC(R_000100_MCCFG_FB_LOCATION);
+        rdev->mc.vram_location = G_000100_MC_FB_START(tmp) << 16;
+        rdev->mc.gtt_location = 0xFFFFFFFFUL;
+        r = radeon_mc_setup(rdev);
+        if (r)
+                return r;
+        return 0;
+}
+
 void rs690_line_buffer_adjust(struct radeon_device *rdev,
                               struct drm_display_mode *mode1,
                               struct drm_display_mode *mode2)
@@ -605,7 +621,6 @@ static int rs690_startup(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         rs600_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -662,7 +677,7 @@ void rs690_fini(struct radeon_device *rdev)
         rs400_gart_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -700,10 +715,9 @@ int rs690_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                atom_asic_init(rdev->mode_info.atom_context);
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
+
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
         /* Initialize power management */
@@ -711,7 +725,7 @@ int rs690_init(struct radeon_device *rdev)
         /* Get vram informations */
         rs690_vram_info(rdev);
         /* Initialize memory controller (also test AGP) */
-        r = r420_mc_init(rdev);
+        r = rs690_mc_init(rdev);
         if (r)
                 return r;
         rv515_debugfs(rdev);
@@ -723,7 +737,7 @@ int rs690_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         r = rs400_gart_init(rdev);
diff --git a/drivers/gpu/drm/radeon/rv515.c b/drivers/gpu/drm/radeon/rv515.c
index 7935f793bf62..7793239e24b2 100644
--- a/drivers/gpu/drm/radeon/rv515.c
+++ b/drivers/gpu/drm/radeon/rv515.c
@@ -137,8 +137,6 @@ int rv515_mc_wait_for_idle(struct radeon_device *rdev)
 
 void rv515_vga_render_disable(struct radeon_device *rdev)
 {
-        WREG32(R_000330_D1VGA_CONTROL, 0);
-        WREG32(R_000338_D2VGA_CONTROL, 0);
         WREG32(R_000300_VGA_RENDER_CONTROL,
                 RREG32(R_000300_VGA_RENDER_CONTROL) & C_000300_VGA_VSTATUS_CNTL);
 }
@@ -382,7 +380,6 @@ void rv515_mc_stop(struct radeon_device *rdev, struct rv515_mc_save *save)
         save->d2crtc_control = RREG32(R_006880_D2CRTC_CONTROL);
 
         /* Stop all video */
-        WREG32(R_000330_D1VGA_CONTROL, 0);
         WREG32(R_0068E8_D2CRTC_UPDATE_LOCK, 0);
         WREG32(R_000300_VGA_RENDER_CONTROL, 0);
         WREG32(R_0060E8_D1CRTC_UPDATE_LOCK, 1);
@@ -391,6 +388,8 @@ void rv515_mc_stop(struct radeon_device *rdev, struct rv515_mc_save *save)
         WREG32(R_006880_D2CRTC_CONTROL, 0);
         WREG32(R_0060E8_D1CRTC_UPDATE_LOCK, 0);
         WREG32(R_0068E8_D2CRTC_UPDATE_LOCK, 0);
+        WREG32(R_000330_D1VGA_CONTROL, 0);
+        WREG32(R_000338_D2VGA_CONTROL, 0);
 }
 
 void rv515_mc_resume(struct radeon_device *rdev, struct rv515_mc_save *save)
@@ -404,14 +403,14 @@ void rv515_mc_resume(struct radeon_device *rdev, struct rv515_mc_save *save)
         WREG32(R_000328_VGA_HDP_CONTROL, save->vga_hdp_control);
         mdelay(1);
         /* Restore video state */
+        WREG32(R_000330_D1VGA_CONTROL, save->d1vga_control);
+        WREG32(R_000338_D2VGA_CONTROL, save->d2vga_control);
         WREG32(R_0060E8_D1CRTC_UPDATE_LOCK, 1);
         WREG32(R_0068E8_D2CRTC_UPDATE_LOCK, 1);
         WREG32(R_006080_D1CRTC_CONTROL, save->d1crtc_control);
         WREG32(R_006880_D2CRTC_CONTROL, save->d2crtc_control);
         WREG32(R_0060E8_D1CRTC_UPDATE_LOCK, 0);
         WREG32(R_0068E8_D2CRTC_UPDATE_LOCK, 0);
-        WREG32(R_000330_D1VGA_CONTROL, save->d1vga_control);
-        WREG32(R_000338_D2VGA_CONTROL, save->d2vga_control);
         WREG32(R_000300_VGA_RENDER_CONTROL, save->vga_render_control);
 }
 
@@ -479,7 +478,6 @@ static int rv515_startup(struct radeon_device *rdev)
                         return r;
         }
         /* Enable IRQ */
-        rdev->irq.sw_int = true;
         rs600_irq_set(rdev);
         /* 1M ring buffer */
         r = r100_cp_init(rdev, 1024 * 1024);
@@ -541,11 +539,11 @@ void rv515_fini(struct radeon_device *rdev)
         r100_wb_fini(rdev);
         r100_ib_fini(rdev);
         radeon_gem_fini(rdev);
-    rv370_pcie_gart_fini(rdev);
+        rv370_pcie_gart_fini(rdev);
         radeon_agp_fini(rdev);
         radeon_irq_kms_fini(rdev);
         radeon_fence_driver_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
@@ -581,10 +579,8 @@ int rv515_init(struct radeon_device *rdev)
                         RREG32(R_0007C0_CP_STAT));
         }
         /* check if cards are posted or not */
-        if (!radeon_card_posted(rdev) && rdev->bios) {
-                DRM_INFO("GPU not posted. posting now...\n");
-                atom_asic_init(rdev->mode_info.atom_context);
-        }
+        if (radeon_boot_test_post_card(rdev) == false)
+                return -EINVAL;
         /* Initialize clocks */
         radeon_get_clock_info(rdev->ddev);
         /* Initialize power management */
@@ -604,7 +600,7 @@ int rv515_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
         if (r)
                 return r;
         r = rv370_pcie_gart_init(rdev);
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index b0efd0ddae7a..dd4f02096a80 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -92,7 +92,7 @@ int rv770_pcie_gart_enable(struct radeon_device *rdev)
 void rv770_pcie_gart_disable(struct radeon_device *rdev)
 {
         u32 tmp;
-        int i;
+        int i, r;
 
         /* Disable all tables */
         for (i = 0; i < 7; i++)
@@ -113,8 +113,12 @@ void rv770_pcie_gart_disable(struct radeon_device *rdev)
         WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
         WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
         if (rdev->gart.table.vram.robj) {
-                radeon_object_kunmap(rdev->gart.table.vram.robj);
-                radeon_object_unpin(rdev->gart.table.vram.robj);
+                r = radeon_bo_reserve(rdev->gart.table.vram.robj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_kunmap(rdev->gart.table.vram.robj);
+                        radeon_bo_unpin(rdev->gart.table.vram.robj);
+                        radeon_bo_unreserve(rdev->gart.table.vram.robj);
+                }
         }
 }
 
@@ -880,13 +884,26 @@ static int rv770_startup(struct radeon_device *rdev)
         }
         rv770_gpu_init(rdev);
 
-        r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
-                              &rdev->r600_blit.shader_gpu_addr);
+        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+        if (unlikely(r != 0))
+                return r;
+        r = radeon_bo_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
+                        &rdev->r600_blit.shader_gpu_addr);
+        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
         if (r) {
                 DRM_ERROR("failed to pin blit object %d\n", r);
                 return r;
         }
 
+        /* Enable IRQ */
+        r = r600_irq_init(rdev);
+        if (r) {
+                DRM_ERROR("radeon: IH init failed (%d).\n", r);
+                radeon_irq_kms_fini(rdev);
+                return r;
+        }
+        r600_irq_set(rdev);
+
         r = radeon_ring_init(rdev, rdev->cp.ring_size);
         if (r)
                 return r;
@@ -934,13 +951,19 @@ int rv770_resume(struct radeon_device *rdev)
 
 int rv770_suspend(struct radeon_device *rdev)
 {
+        int r;
+
         /* FIXME: we should wait for ring to be empty */
         r700_cp_stop(rdev);
         rdev->cp.ready = false;
         r600_wb_disable(rdev);
         rv770_pcie_gart_disable(rdev);
         /* unpin shaders bo */
-        radeon_object_unpin(rdev->r600_blit.shader_obj);
+        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+        if (likely(r == 0)) {
+                radeon_bo_unpin(rdev->r600_blit.shader_obj);
+                radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+        }
         return 0;
 }
 
@@ -975,7 +998,11 @@ int rv770_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Post card if necessary */
-        if (!r600_card_posted(rdev) && rdev->bios) {
+        if (!r600_card_posted(rdev)) {
+                if (!rdev->bios) {
+                        dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n");
+                        return -EINVAL;
+                }
                 DRM_INFO("GPU not posted. posting now...\n");
                 atom_asic_init(rdev->mode_info.atom_context);
         }
@@ -998,14 +1025,22 @@ int rv770_init(struct radeon_device *rdev)
         if (r)
                 return r;
         /* Memory manager */
-        r = radeon_object_init(rdev);
+        r = radeon_bo_init(rdev);
+        if (r)
+                return r;
+
+        r = radeon_irq_kms_init(rdev);
         if (r)
                 return r;
+
         rdev->cp.ring_obj = NULL;
         r600_ring_init(rdev, 1024 * 1024);
 
-        if (!rdev->me_fw || !rdev->pfp_fw) {
-                r = r600_cp_init_microcode(rdev);
+        rdev->ih.ring_obj = NULL;
+        r600_ih_ring_init(rdev, 64 * 1024);
+
+        if (!rdev->me_fw || !rdev->pfp_fw || !rdev->rlc_fw) {
+                r = r600_init_microcode(rdev);
                 if (r) {
                         DRM_ERROR("Failed to load firmware!\n");
                         return r;
@@ -1051,6 +1086,8 @@ void rv770_fini(struct radeon_device *rdev)
         rv770_suspend(rdev);
 
         r600_blit_fini(rdev);
+        r600_irq_fini(rdev);
+        radeon_irq_kms_fini(rdev);
         radeon_ring_fini(rdev);
         r600_wb_fini(rdev);
         rv770_pcie_gart_fini(rdev);
@@ -1059,7 +1096,7 @@ void rv770_fini(struct radeon_device *rdev)
         radeon_clocks_fini(rdev);
         if (rdev->flags & RADEON_IS_AGP)
                 radeon_agp_fini(rdev);
-        radeon_object_fini(rdev);
+        radeon_bo_fini(rdev);
         radeon_atombios_fini(rdev);
         kfree(rdev->bios);
         rdev->bios = NULL;
diff --git a/drivers/gpu/drm/ttm/Makefile b/drivers/gpu/drm/ttm/Makefile
index b0a9de7a57c2..1e138f5bae09 100644
--- a/drivers/gpu/drm/ttm/Makefile
+++ b/drivers/gpu/drm/ttm/Makefile
@@ -3,6 +3,7 @@
 
 ccflags-y := -Iinclude/drm
 ttm-y := ttm_agp_backend.o ttm_memory.o ttm_tt.o ttm_bo.o \
-        ttm_bo_util.o ttm_bo_vm.o ttm_module.o ttm_global.o
+        ttm_bo_util.o ttm_bo_vm.o ttm_module.o ttm_global.o \
+        ttm_object.o ttm_lock.o ttm_execbuf_util.o
 
 obj-$(CONFIG_DRM_TTM) += ttm.o
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 87c06252d464..e13fd23f3334 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -275,9 +275,10 @@ static int ttm_bo_add_ttm(struct ttm_buffer_object *bo, bool zero_alloc)
                 bo->ttm = ttm_tt_create(bdev, bo->num_pages << PAGE_SHIFT,
                                         page_flags | TTM_PAGE_FLAG_USER,
                                         glob->dummy_read_page);
-                if (unlikely(bo->ttm == NULL))
+                if (unlikely(bo->ttm == NULL)) {
                         ret = -ENOMEM;
-                break;
+                        break;
+                }
 
                 ret = ttm_tt_set_user(bo->ttm, current,
                                       bo->buffer_start, bo->num_pages);
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index c70927ecda21..ceae52f45c39 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -369,6 +369,7 @@ pgprot_t ttm_io_prot(uint32_t caching_flags, pgprot_t tmp)
 #endif
         return tmp;
 }
+EXPORT_SYMBOL(ttm_io_prot);
 
 static int ttm_bo_ioremap(struct ttm_buffer_object *bo,
                           unsigned long bus_base,
diff --git a/drivers/gpu/drm/ttm/ttm_execbuf_util.c b/drivers/gpu/drm/ttm/ttm_execbuf_util.c
new file mode 100644
index 000000000000..c285c2902d15
--- /dev/null
+++ b/drivers/gpu/drm/ttm/ttm_execbuf_util.c
@@ -0,0 +1,117 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS 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 "ttm/ttm_execbuf_util.h"
+#include "ttm/ttm_bo_driver.h"
+#include "ttm/ttm_placement.h"
+#include <linux/wait.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+
+void ttm_eu_backoff_reservation(struct list_head *list)
+{
+        struct ttm_validate_buffer *entry;
+
+        list_for_each_entry(entry, list, head) {
+                struct ttm_buffer_object *bo = entry->bo;
+                if (!entry->reserved)
+                        continue;
+
+                entry->reserved = false;
+                ttm_bo_unreserve(bo);
+        }
+}
+EXPORT_SYMBOL(ttm_eu_backoff_reservation);
+
+/*
+ * Reserve buffers for validation.
+ *
+ * If a buffer in the list is marked for CPU access, we back off and
+ * wait for that buffer to become free for GPU access.
+ *
+ * If a buffer is reserved for another validation, the validator with
+ * the highest validation sequence backs off and waits for that buffer
+ * to become unreserved. This prevents deadlocks when validating multiple
+ * buffers in different orders.
+ */
+
+int ttm_eu_reserve_buffers(struct list_head *list, uint32_t val_seq)
+{
+        struct ttm_validate_buffer *entry;
+        int ret;
+
+retry:
+        list_for_each_entry(entry, list, head) {
+                struct ttm_buffer_object *bo = entry->bo;
+
+                entry->reserved = false;
+                ret = ttm_bo_reserve(bo, true, false, true, val_seq);
+                if (ret != 0) {
+                        ttm_eu_backoff_reservation(list);
+                        if (ret == -EAGAIN) {
+                                ret = ttm_bo_wait_unreserved(bo, true);
+                                if (unlikely(ret != 0))
+                                        return ret;
+                                goto retry;
+                        } else
+                                return ret;
+                }
+
+                entry->reserved = true;
+                if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
+                        ttm_eu_backoff_reservation(list);
+                        ret = ttm_bo_wait_cpu(bo, false);
+                        if (ret)
+                                return ret;
+                        goto retry;
+                }
+        }
+        return 0;
+}
+EXPORT_SYMBOL(ttm_eu_reserve_buffers);
+
+void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
+{
+        struct ttm_validate_buffer *entry;
+
+        list_for_each_entry(entry, list, head) {
+                struct ttm_buffer_object *bo = entry->bo;
+                struct ttm_bo_driver *driver = bo->bdev->driver;
+                void *old_sync_obj;
+
+                spin_lock(&bo->lock);
+                old_sync_obj = bo->sync_obj;
+                bo->sync_obj = driver->sync_obj_ref(sync_obj);
+                bo->sync_obj_arg = entry->new_sync_obj_arg;
+                spin_unlock(&bo->lock);
+                ttm_bo_unreserve(bo);
+                entry->reserved = false;
+                if (old_sync_obj)
+                        driver->sync_obj_unref(&old_sync_obj);
+        }
+}
+EXPORT_SYMBOL(ttm_eu_fence_buffer_objects);
diff --git a/drivers/gpu/drm/ttm/ttm_lock.c b/drivers/gpu/drm/ttm/ttm_lock.c
new file mode 100644
index 000000000000..f619ebcaa4ec
--- /dev/null
+++ b/drivers/gpu/drm/ttm/ttm_lock.c
@@ -0,0 +1,311 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2007-2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
+ */
+
+#include "ttm/ttm_lock.h"
+#include "ttm/ttm_module.h"
+#include <asm/atomic.h>
+#include <linux/errno.h>
+#include <linux/wait.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+
+#define TTM_WRITE_LOCK_PENDING    (1 << 0)
+#define TTM_VT_LOCK_PENDING       (1 << 1)
+#define TTM_SUSPEND_LOCK_PENDING  (1 << 2)
+#define TTM_VT_LOCK               (1 << 3)
+#define TTM_SUSPEND_LOCK          (1 << 4)
+
+void ttm_lock_init(struct ttm_lock *lock)
+{
+        spin_lock_init(&lock->lock);
+        init_waitqueue_head(&lock->queue);
+        lock->rw = 0;
+        lock->flags = 0;
+        lock->kill_takers = false;
+        lock->signal = SIGKILL;
+}
+EXPORT_SYMBOL(ttm_lock_init);
+
+void ttm_read_unlock(struct ttm_lock *lock)
+{
+        spin_lock(&lock->lock);
+        if (--lock->rw == 0)
+                wake_up_all(&lock->queue);
+        spin_unlock(&lock->lock);
+}
+EXPORT_SYMBOL(ttm_read_unlock);
+
+static bool __ttm_read_lock(struct ttm_lock *lock)
+{
+        bool locked = false;
+
+        spin_lock(&lock->lock);
+        if (unlikely(lock->kill_takers)) {
+                send_sig(lock->signal, current, 0);
+                spin_unlock(&lock->lock);
+                return false;
+        }
+        if (lock->rw >= 0 && lock->flags == 0) {
+                ++lock->rw;
+                locked = true;
+        }
+        spin_unlock(&lock->lock);
+        return locked;
+}
+
+int ttm_read_lock(struct ttm_lock *lock, bool interruptible)
+{
+        int ret = 0;
+
+        if (interruptible)
+                ret = wait_event_interruptible(lock->queue,
+                                               __ttm_read_lock(lock));
+        else
+                wait_event(lock->queue, __ttm_read_lock(lock));
+        return ret;
+}
+EXPORT_SYMBOL(ttm_read_lock);
+
+static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
+{
+        bool block = true;
+
+        *locked = false;
+
+        spin_lock(&lock->lock);
+        if (unlikely(lock->kill_takers)) {
+                send_sig(lock->signal, current, 0);
+                spin_unlock(&lock->lock);
+                return false;
+        }
+        if (lock->rw >= 0 && lock->flags == 0) {
+                ++lock->rw;
+                block = false;
+                *locked = true;
+        } else if (lock->flags == 0) {
+                block = false;
+        }
+        spin_unlock(&lock->lock);
+
+        return !block;
+}
+
+int ttm_read_trylock(struct ttm_lock *lock, bool interruptible)
+{
+        int ret = 0;
+        bool locked;
+
+        if (interruptible)
+                ret = wait_event_interruptible
+                        (lock->queue, __ttm_read_trylock(lock, &locked));
+        else
+                wait_event(lock->queue, __ttm_read_trylock(lock, &locked));
+
+        if (unlikely(ret != 0)) {
+                BUG_ON(locked);
+                return ret;
+        }
+
+        return (locked) ? 0 : -EBUSY;
+}
+
+void ttm_write_unlock(struct ttm_lock *lock)
+{
+        spin_lock(&lock->lock);
+        lock->rw = 0;
+        wake_up_all(&lock->queue);
+        spin_unlock(&lock->lock);
+}
+EXPORT_SYMBOL(ttm_write_unlock);
+
+static bool __ttm_write_lock(struct ttm_lock *lock)
+{
+        bool locked = false;
+
+        spin_lock(&lock->lock);
+        if (unlikely(lock->kill_takers)) {
+                send_sig(lock->signal, current, 0);
+                spin_unlock(&lock->lock);
+                return false;
+        }
+        if (lock->rw == 0 && ((lock->flags & ~TTM_WRITE_LOCK_PENDING) == 0)) {
+                lock->rw = -1;
+                lock->flags &= ~TTM_WRITE_LOCK_PENDING;
+                locked = true;
+        } else {
+                lock->flags |= TTM_WRITE_LOCK_PENDING;
+        }
+        spin_unlock(&lock->lock);
+        return locked;
+}
+
+int ttm_write_lock(struct ttm_lock *lock, bool interruptible)
+{
+        int ret = 0;
+
+        if (interruptible) {
+                ret = wait_event_interruptible(lock->queue,
+                                               __ttm_write_lock(lock));
+                if (unlikely(ret != 0)) {
+                        spin_lock(&lock->lock);
+                        lock->flags &= ~TTM_WRITE_LOCK_PENDING;
+                        wake_up_all(&lock->queue);
+                        spin_unlock(&lock->lock);
+                }
+        } else
+                wait_event(lock->queue, __ttm_read_lock(lock));
+
+        return ret;
+}
+EXPORT_SYMBOL(ttm_write_lock);
+
+void ttm_write_lock_downgrade(struct ttm_lock *lock)
+{
+        spin_lock(&lock->lock);
+        lock->rw = 1;
+        wake_up_all(&lock->queue);
+        spin_unlock(&lock->lock);
+}
+
+static int __ttm_vt_unlock(struct ttm_lock *lock)
+{
+        int ret = 0;
+
+        spin_lock(&lock->lock);
+        if (unlikely(!(lock->flags & TTM_VT_LOCK)))
+                ret = -EINVAL;
+        lock->flags &= ~TTM_VT_LOCK;
+        wake_up_all(&lock->queue);
+        spin_unlock(&lock->lock);
+        printk(KERN_INFO TTM_PFX "vt unlock.\n");
+
+        return ret;
+}
+
+static void ttm_vt_lock_remove(struct ttm_base_object **p_base)
+{
+        struct ttm_base_object *base = *p_base;
+        struct ttm_lock *lock = container_of(base, struct ttm_lock, base);
+        int ret;
+
+        *p_base = NULL;
+        ret = __ttm_vt_unlock(lock);
+        BUG_ON(ret != 0);
+}
+
+static bool __ttm_vt_lock(struct ttm_lock *lock)
+{
+        bool locked = false;
+
+        spin_lock(&lock->lock);
+        if (lock->rw == 0) {
+                lock->flags &= ~TTM_VT_LOCK_PENDING;
+                lock->flags |= TTM_VT_LOCK;
+                locked = true;
+        } else {
+                lock->flags |= TTM_VT_LOCK_PENDING;
+        }
+        spin_unlock(&lock->lock);
+        return locked;
+}
+
+int ttm_vt_lock(struct ttm_lock *lock,
+                bool interruptible,
+                struct ttm_object_file *tfile)
+{
+        int ret = 0;
+
+        if (interruptible) {
+                ret = wait_event_interruptible(lock->queue,
+                                               __ttm_vt_lock(lock));
+                if (unlikely(ret != 0)) {
+                        spin_lock(&lock->lock);
+                        lock->flags &= ~TTM_VT_LOCK_PENDING;
+                        wake_up_all(&lock->queue);
+                        spin_unlock(&lock->lock);
+                        return ret;
+                }
+        } else
+                wait_event(lock->queue, __ttm_vt_lock(lock));
+
+        /*
+         * Add a base-object, the destructor of which will
+         * make sure the lock is released if the client dies
+         * while holding it.
+         */
+
+        ret = ttm_base_object_init(tfile, &lock->base, false,
+                                   ttm_lock_type, &ttm_vt_lock_remove, NULL);
+        if (ret)
+                (void)__ttm_vt_unlock(lock);
+        else {
+                lock->vt_holder = tfile;
+                printk(KERN_INFO TTM_PFX "vt lock.\n");
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(ttm_vt_lock);
+
+int ttm_vt_unlock(struct ttm_lock *lock)
+{
+        return ttm_ref_object_base_unref(lock->vt_holder,
+                                         lock->base.hash.key, TTM_REF_USAGE);
+}
+EXPORT_SYMBOL(ttm_vt_unlock);
+
+void ttm_suspend_unlock(struct ttm_lock *lock)
+{
+        spin_lock(&lock->lock);
+        lock->flags &= ~TTM_SUSPEND_LOCK;
+        wake_up_all(&lock->queue);
+        spin_unlock(&lock->lock);
+}
+
+static bool __ttm_suspend_lock(struct ttm_lock *lock)
+{
+        bool locked = false;
+
+        spin_lock(&lock->lock);
+        if (lock->rw == 0) {
+                lock->flags &= ~TTM_SUSPEND_LOCK_PENDING;
+                lock->flags |= TTM_SUSPEND_LOCK;
+                locked = true;
+        } else {
+                lock->flags |= TTM_SUSPEND_LOCK_PENDING;
+        }
+        spin_unlock(&lock->lock);
+        return locked;
+}
+
+void ttm_suspend_lock(struct ttm_lock *lock)
+{
+        wait_event(lock->queue, __ttm_suspend_lock(lock));
+}
diff --git a/drivers/gpu/drm/ttm/ttm_memory.c b/drivers/gpu/drm/ttm/ttm_memory.c
index 072c281a6bb5..8bfde5f40841 100644
--- a/drivers/gpu/drm/ttm/ttm_memory.c
+++ b/drivers/gpu/drm/ttm/ttm_memory.c
@@ -274,16 +274,17 @@ static int ttm_mem_init_kernel_zone(struct ttm_mem_global *glob,
 static int ttm_mem_init_highmem_zone(struct ttm_mem_global *glob,
                                      const struct sysinfo *si)
 {
-        struct ttm_mem_zone *zone = kzalloc(sizeof(*zone), GFP_KERNEL);
+        struct ttm_mem_zone *zone;
         uint64_t mem;
         int ret;
 
-        if (unlikely(!zone))
-                return -ENOMEM;
-
         if (si->totalhigh == 0)
                 return 0;
 
+        zone = kzalloc(sizeof(*zone), GFP_KERNEL);
+        if (unlikely(!zone))
+                return -ENOMEM;
+
         mem = si->totalram;
         mem *= si->mem_unit;
 
@@ -460,6 +461,7 @@ void ttm_mem_global_free(struct ttm_mem_global *glob,
 {
         return ttm_mem_global_free_zone(glob, NULL, amount);
 }
+EXPORT_SYMBOL(ttm_mem_global_free);
 
 static int ttm_mem_global_reserve(struct ttm_mem_global *glob,
                                   struct ttm_mem_zone *single_zone,
@@ -533,6 +535,7 @@ int ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
         return ttm_mem_global_alloc_zone(glob, NULL, memory, no_wait,
                                          interruptible);
 }
+EXPORT_SYMBOL(ttm_mem_global_alloc);
 
 int ttm_mem_global_alloc_page(struct ttm_mem_global *glob,
                               struct page *page,
@@ -588,3 +591,4 @@ size_t ttm_round_pot(size_t size)
         }
         return 0;
 }
+EXPORT_SYMBOL(ttm_round_pot);
diff --git a/drivers/gpu/drm/ttm/ttm_object.c b/drivers/gpu/drm/ttm/ttm_object.c
new file mode 100644
index 000000000000..1099abac824b
--- /dev/null
+++ b/drivers/gpu/drm/ttm/ttm_object.c
@@ -0,0 +1,452 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
+ */
+/** @file ttm_ref_object.c
+ *
+ * Base- and reference object implementation for the various
+ * ttm objects. Implements reference counting, minimal security checks
+ * and release on file close.
+ */
+
+/**
+ * struct ttm_object_file
+ *
+ * @tdev: Pointer to the ttm_object_device.
+ *
+ * @lock: Lock that protects the ref_list list and the
+ * ref_hash hash tables.
+ *
+ * @ref_list: List of ttm_ref_objects to be destroyed at
+ * file release.
+ *
+ * @ref_hash: Hash tables of ref objects, one per ttm_ref_type,
+ * for fast lookup of ref objects given a base object.
+ */
+
+#include "ttm/ttm_object.h"
+#include "ttm/ttm_module.h"
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <asm/atomic.h>
+
+struct ttm_object_file {
+        struct ttm_object_device *tdev;
+        rwlock_t lock;
+        struct list_head ref_list;
+        struct drm_open_hash ref_hash[TTM_REF_NUM];
+        struct kref refcount;
+};
+
+/**
+ * struct ttm_object_device
+ *
+ * @object_lock: lock that protects the object_hash hash table.
+ *
+ * @object_hash: hash table for fast lookup of object global names.
+ *
+ * @object_count: Per device object count.
+ *
+ * This is the per-device data structure needed for ttm object management.
+ */
+
+struct ttm_object_device {
+        rwlock_t object_lock;
+        struct drm_open_hash object_hash;
+        atomic_t object_count;
+        struct ttm_mem_global *mem_glob;
+};
+
+/**
+ * struct ttm_ref_object
+ *
+ * @hash: Hash entry for the per-file object reference hash.
+ *
+ * @head: List entry for the per-file list of ref-objects.
+ *
+ * @kref: Ref count.
+ *
+ * @obj: Base object this ref object is referencing.
+ *
+ * @ref_type: Type of ref object.
+ *
+ * This is similar to an idr object, but it also has a hash table entry
+ * that allows lookup with a pointer to the referenced object as a key. In
+ * that way, one can easily detect whether a base object is referenced by
+ * a particular ttm_object_file. It also carries a ref count to avoid creating
+ * multiple ref objects if a ttm_object_file references the same base
+ * object more than once.
+ */
+
+struct ttm_ref_object {
+        struct drm_hash_item hash;
+        struct list_head head;
+        struct kref kref;
+        struct ttm_base_object *obj;
+        enum ttm_ref_type ref_type;
+        struct ttm_object_file *tfile;
+};
+
+static inline struct ttm_object_file *
+ttm_object_file_ref(struct ttm_object_file *tfile)
+{
+        kref_get(&tfile->refcount);
+        return tfile;
+}
+
+static void ttm_object_file_destroy(struct kref *kref)
+{
+        struct ttm_object_file *tfile =
+                container_of(kref, struct ttm_object_file, refcount);
+
+        kfree(tfile);
+}
+
+
+static inline void ttm_object_file_unref(struct ttm_object_file **p_tfile)
+{
+        struct ttm_object_file *tfile = *p_tfile;
+
+        *p_tfile = NULL;
+        kref_put(&tfile->refcount, ttm_object_file_destroy);
+}
+
+
+int ttm_base_object_init(struct ttm_object_file *tfile,
+                         struct ttm_base_object *base,
+                         bool shareable,
+                         enum ttm_object_type object_type,
+                         void (*refcount_release) (struct ttm_base_object **),
+                         void (*ref_obj_release) (struct ttm_base_object *,
+                                                  enum ttm_ref_type ref_type))
+{
+        struct ttm_object_device *tdev = tfile->tdev;
+        int ret;
+
+        base->shareable = shareable;
+        base->tfile = ttm_object_file_ref(tfile);
+        base->refcount_release = refcount_release;
+        base->ref_obj_release = ref_obj_release;
+        base->object_type = object_type;
+        write_lock(&tdev->object_lock);
+        kref_init(&base->refcount);
+        ret = drm_ht_just_insert_please(&tdev->object_hash,
+                                        &base->hash,
+                                        (unsigned long)base, 31, 0, 0);
+        write_unlock(&tdev->object_lock);
+        if (unlikely(ret != 0))
+                goto out_err0;
+
+        ret = ttm_ref_object_add(tfile, base, TTM_REF_USAGE, NULL);
+        if (unlikely(ret != 0))
+                goto out_err1;
+
+        ttm_base_object_unref(&base);
+
+        return 0;
+out_err1:
+        (void)drm_ht_remove_item(&tdev->object_hash, &base->hash);
+out_err0:
+        return ret;
+}
+EXPORT_SYMBOL(ttm_base_object_init);
+
+static void ttm_release_base(struct kref *kref)
+{
+        struct ttm_base_object *base =
+            container_of(kref, struct ttm_base_object, refcount);
+        struct ttm_object_device *tdev = base->tfile->tdev;
+
+        (void)drm_ht_remove_item(&tdev->object_hash, &base->hash);
+        write_unlock(&tdev->object_lock);
+        if (base->refcount_release) {
+                ttm_object_file_unref(&base->tfile);
+                base->refcount_release(&base);
+        }
+        write_lock(&tdev->object_lock);
+}
+
+void ttm_base_object_unref(struct ttm_base_object **p_base)
+{
+        struct ttm_base_object *base = *p_base;
+        struct ttm_object_device *tdev = base->tfile->tdev;
+
+        *p_base = NULL;
+
+        /*
+         * Need to take the lock here to avoid racing with
+         * users trying to look up the object.
+         */
+
+        write_lock(&tdev->object_lock);
+        (void)kref_put(&base->refcount, &ttm_release_base);
+        write_unlock(&tdev->object_lock);
+}
+EXPORT_SYMBOL(ttm_base_object_unref);
+
+struct ttm_base_object *ttm_base_object_lookup(struct ttm_object_file *tfile,
+                                               uint32_t key)
+{
+        struct ttm_object_device *tdev = tfile->tdev;
+        struct ttm_base_object *base;
+        struct drm_hash_item *hash;
+        int ret;
+
+        read_lock(&tdev->object_lock);
+        ret = drm_ht_find_item(&tdev->object_hash, key, &hash);
+
+        if (likely(ret == 0)) {
+                base = drm_hash_entry(hash, struct ttm_base_object, hash);
+                kref_get(&base->refcount);
+        }
+        read_unlock(&tdev->object_lock);
+
+        if (unlikely(ret != 0))
+                return NULL;
+
+        if (tfile != base->tfile && !base->shareable) {
+                printk(KERN_ERR TTM_PFX
+                       "Attempted access of non-shareable object.\n");
+                ttm_base_object_unref(&base);
+                return NULL;
+        }
+
+        return base;
+}
+EXPORT_SYMBOL(ttm_base_object_lookup);
+
+int ttm_ref_object_add(struct ttm_object_file *tfile,
+                       struct ttm_base_object *base,
+                       enum ttm_ref_type ref_type, bool *existed)
+{
+        struct drm_open_hash *ht = &tfile->ref_hash[ref_type];
+        struct ttm_ref_object *ref;
+        struct drm_hash_item *hash;
+        struct ttm_mem_global *mem_glob = tfile->tdev->mem_glob;
+        int ret = -EINVAL;
+
+        if (existed != NULL)
+                *existed = true;
+
+        while (ret == -EINVAL) {
+                read_lock(&tfile->lock);
+                ret = drm_ht_find_item(ht, base->hash.key, &hash);
+
+                if (ret == 0) {
+                        ref = drm_hash_entry(hash, struct ttm_ref_object, hash);
+                        kref_get(&ref->kref);
+                        read_unlock(&tfile->lock);
+                        break;
+                }
+
+                read_unlock(&tfile->lock);
+                ret = ttm_mem_global_alloc(mem_glob, sizeof(*ref),
+                                           false, false);
+                if (unlikely(ret != 0))
+                        return ret;
+                ref = kmalloc(sizeof(*ref), GFP_KERNEL);
+                if (unlikely(ref == NULL)) {
+                        ttm_mem_global_free(mem_glob, sizeof(*ref));
+                        return -ENOMEM;
+                }
+
+                ref->hash.key = base->hash.key;
+                ref->obj = base;
+                ref->tfile = tfile;
+                ref->ref_type = ref_type;
+                kref_init(&ref->kref);
+
+                write_lock(&tfile->lock);
+                ret = drm_ht_insert_item(ht, &ref->hash);
+
+                if (likely(ret == 0)) {
+                        list_add_tail(&ref->head, &tfile->ref_list);
+                        kref_get(&base->refcount);
+                        write_unlock(&tfile->lock);
+                        if (existed != NULL)
+                                *existed = false;
+                        break;
+                }
+
+                write_unlock(&tfile->lock);
+                BUG_ON(ret != -EINVAL);
+
+                ttm_mem_global_free(mem_glob, sizeof(*ref));
+                kfree(ref);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(ttm_ref_object_add);
+
+static void ttm_ref_object_release(struct kref *kref)
+{
+        struct ttm_ref_object *ref =
+            container_of(kref, struct ttm_ref_object, kref);
+        struct ttm_base_object *base = ref->obj;
+        struct ttm_object_file *tfile = ref->tfile;
+        struct drm_open_hash *ht;
+        struct ttm_mem_global *mem_glob = tfile->tdev->mem_glob;
+
+        ht = &tfile->ref_hash[ref->ref_type];
+        (void)drm_ht_remove_item(ht, &ref->hash);
+        list_del(&ref->head);
+        write_unlock(&tfile->lock);
+
+        if (ref->ref_type != TTM_REF_USAGE && base->ref_obj_release)
+                base->ref_obj_release(base, ref->ref_type);
+
+        ttm_base_object_unref(&ref->obj);
+        ttm_mem_global_free(mem_glob, sizeof(*ref));
+        kfree(ref);
+        write_lock(&tfile->lock);
+}
+
+int ttm_ref_object_base_unref(struct ttm_object_file *tfile,
+                              unsigned long key, enum ttm_ref_type ref_type)
+{
+        struct drm_open_hash *ht = &tfile->ref_hash[ref_type];
+        struct ttm_ref_object *ref;
+        struct drm_hash_item *hash;
+        int ret;
+
+        write_lock(&tfile->lock);
+        ret = drm_ht_find_item(ht, key, &hash);
+        if (unlikely(ret != 0)) {
+                write_unlock(&tfile->lock);
+                return -EINVAL;
+        }
+        ref = drm_hash_entry(hash, struct ttm_ref_object, hash);
+        kref_put(&ref->kref, ttm_ref_object_release);
+        write_unlock(&tfile->lock);
+        return 0;
+}
+EXPORT_SYMBOL(ttm_ref_object_base_unref);
+
+void ttm_object_file_release(struct ttm_object_file **p_tfile)
+{
+        struct ttm_ref_object *ref;
+        struct list_head *list;
+        unsigned int i;
+        struct ttm_object_file *tfile = *p_tfile;
+
+        *p_tfile = NULL;
+        write_lock(&tfile->lock);
+
+        /*
+         * Since we release the lock within the loop, we have to
+         * restart it from the beginning each time.
+         */
+
+        while (!list_empty(&tfile->ref_list)) {
+                list = tfile->ref_list.next;
+                ref = list_entry(list, struct ttm_ref_object, head);
+                ttm_ref_object_release(&ref->kref);
+        }
+
+        for (i = 0; i < TTM_REF_NUM; ++i)
+                drm_ht_remove(&tfile->ref_hash[i]);
+
+        write_unlock(&tfile->lock);
+        ttm_object_file_unref(&tfile);
+}
+EXPORT_SYMBOL(ttm_object_file_release);
+
+struct ttm_object_file *ttm_object_file_init(struct ttm_object_device *tdev,
+                                             unsigned int hash_order)
+{
+        struct ttm_object_file *tfile = kmalloc(sizeof(*tfile), GFP_KERNEL);
+        unsigned int i;
+        unsigned int j = 0;
+        int ret;
+
+        if (unlikely(tfile == NULL))
+                return NULL;
+
+        rwlock_init(&tfile->lock);
+        tfile->tdev = tdev;
+        kref_init(&tfile->refcount);
+        INIT_LIST_HEAD(&tfile->ref_list);
+
+        for (i = 0; i < TTM_REF_NUM; ++i) {
+                ret = drm_ht_create(&tfile->ref_hash[i], hash_order);
+                if (ret) {
+                        j = i;
+                        goto out_err;
+                }
+        }
+
+        return tfile;
+out_err:
+        for (i = 0; i < j; ++i)
+                drm_ht_remove(&tfile->ref_hash[i]);
+
+        kfree(tfile);
+
+        return NULL;
+}
+EXPORT_SYMBOL(ttm_object_file_init);
+
+struct ttm_object_device *ttm_object_device_init(struct ttm_mem_global
+                                                 *mem_glob,
+                                                 unsigned int hash_order)
+{
+        struct ttm_object_device *tdev = kmalloc(sizeof(*tdev), GFP_KERNEL);
+        int ret;
+
+        if (unlikely(tdev == NULL))
+                return NULL;
+
+        tdev->mem_glob = mem_glob;
+        rwlock_init(&tdev->object_lock);
+        atomic_set(&tdev->object_count, 0);
+        ret = drm_ht_create(&tdev->object_hash, hash_order);
+
+        if (likely(ret == 0))
+                return tdev;
+
+        kfree(tdev);
+        return NULL;
+}
+EXPORT_SYMBOL(ttm_object_device_init);
+
+void ttm_object_device_release(struct ttm_object_device **p_tdev)
+{
+        struct ttm_object_device *tdev = *p_tdev;
+
+        *p_tdev = NULL;
+
+        write_lock(&tdev->object_lock);
+        drm_ht_remove(&tdev->object_hash);
+        write_unlock(&tdev->object_lock);
+
+        kfree(tdev);
+}
+EXPORT_SYMBOL(ttm_object_device_release);
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index 7bcb89f39ce8..9c2b1cc5dba5 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -192,6 +192,7 @@ int ttm_tt_populate(struct ttm_tt *ttm)
         ttm->state = tt_unbound;
         return 0;
 }
+EXPORT_SYMBOL(ttm_tt_populate);
 
 #ifdef CONFIG_X86
 static inline int ttm_tt_set_page_caching(struct page *p,