Merge remote-tracking branch 'airlied/drm-next' into for-airlied

Manually resolve the conflict between the new enum drm property
helpers in drm-next and the new "force-dvi" option that the "audio" output
property gained in drm-intel-next.

While resolving this conflict, switch the new drm_prop_enum_list to
use the newly introduced enum defines instead of magic values.

Conflicts:
	drivers/gpu/drm/i915/intel_modes.c

Signed-Off-by: Daniel Vetter <daniel.vetter@ffwll.ch>

63 files changed, 2531 insertions, 706 deletions

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 5e818a808ace..6fdaf6fe94eb 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -38,11 +38,6 @@
 #include "drm_edid.h"
 #include "drm_fourcc.h"
 
-struct drm_prop_enum_list {
-        int type;
-        char *name;
-};
-
 /* Avoid boilerplate.  I'm tired of typing. */
 #define DRM_ENUM_NAME_FN(fnname, list)                          \
         char *fnname(int val)                                   \
@@ -442,7 +437,7 @@ void drm_mode_remove(struct drm_connector *connector,
                      struct drm_display_mode *mode)
 {
         list_del(&mode->head);
-        kfree(mode);
+        drm_mode_destroy(connector->dev, mode);
 }
 EXPORT_SYMBOL(drm_mode_remove);
 
@@ -454,7 +449,7 @@ EXPORT_SYMBOL(drm_mode_remove);
  * @name: user visible name of the connector
  *
  * LOCKING:
- * Caller must hold @dev's mode_config lock.
+ * Takes mode config lock.
  *
  * Initialises a preallocated connector. Connectors should be
  * subclassed as part of driver connector objects.
@@ -497,7 +492,7 @@ EXPORT_SYMBOL(drm_connector_init);
  * @connector: connector to cleanup
  *
  * LOCKING:
- * Caller must hold @dev's mode_config lock.
+ * Takes mode config lock.
  *
  * Cleans up the connector but doesn't free the object.
  */
@@ -658,7 +653,6 @@ static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
 {
         struct drm_property *edid;
         struct drm_property *dpms;
-        int i;
 
         /*
          * Standard properties (apply to all connectors)
@@ -668,11 +662,9 @@ static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
                                    "EDID", 0);
         dev->mode_config.edid_property = edid;
 
-        dpms = drm_property_create(dev, DRM_MODE_PROP_ENUM,
-                                   "DPMS", ARRAY_SIZE(drm_dpms_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_dpms_enum_list); i++)
-                drm_property_add_enum(dpms, i, drm_dpms_enum_list[i].type,
-                                      drm_dpms_enum_list[i].name);
+        dpms = drm_property_create_enum(dev, 0,
+                                   "DPMS", drm_dpms_enum_list,
+                                   ARRAY_SIZE(drm_dpms_enum_list));
         dev->mode_config.dpms_property = dpms;
 
         return 0;
@@ -688,30 +680,21 @@ int drm_mode_create_dvi_i_properties(struct drm_device *dev)
 {
         struct drm_property *dvi_i_selector;
         struct drm_property *dvi_i_subconnector;
-        int i;
 
         if (dev->mode_config.dvi_i_select_subconnector_property)
                 return 0;
 
         dvi_i_selector =
-                drm_property_create(dev, DRM_MODE_PROP_ENUM,
+                drm_property_create_enum(dev, 0,
                                     "select subconnector",
+                                    drm_dvi_i_select_enum_list,
                                     ARRAY_SIZE(drm_dvi_i_select_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_dvi_i_select_enum_list); i++)
-                drm_property_add_enum(dvi_i_selector, i,
-                                      drm_dvi_i_select_enum_list[i].type,
-                                      drm_dvi_i_select_enum_list[i].name);
         dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
 
-        dvi_i_subconnector =
-                drm_property_create(dev, DRM_MODE_PROP_ENUM |
-                                    DRM_MODE_PROP_IMMUTABLE,
+        dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
                                     "subconnector",
+                                    drm_dvi_i_subconnector_enum_list,
                                     ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_dvi_i_subconnector_enum_list); i++)
-                drm_property_add_enum(dvi_i_subconnector, i,
-                                      drm_dvi_i_subconnector_enum_list[i].type,
-                                      drm_dvi_i_subconnector_enum_list[i].name);
         dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
 
         return 0;
@@ -742,51 +725,33 @@ int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
         /*
          * Basic connector properties
          */
-        tv_selector = drm_property_create(dev, DRM_MODE_PROP_ENUM,
+        tv_selector = drm_property_create_enum(dev, 0,
                                           "select subconnector",
+                                          drm_tv_select_enum_list,
                                           ARRAY_SIZE(drm_tv_select_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_tv_select_enum_list); i++)
-                drm_property_add_enum(tv_selector, i,
-                                      drm_tv_select_enum_list[i].type,
-                                      drm_tv_select_enum_list[i].name);
         dev->mode_config.tv_select_subconnector_property = tv_selector;
 
         tv_subconnector =
-                drm_property_create(dev, DRM_MODE_PROP_ENUM |
-                                    DRM_MODE_PROP_IMMUTABLE, "subconnector",
+                drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
+                                    "subconnector",
+                                    drm_tv_subconnector_enum_list,
                                     ARRAY_SIZE(drm_tv_subconnector_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_tv_subconnector_enum_list); i++)
-                drm_property_add_enum(tv_subconnector, i,
-                                      drm_tv_subconnector_enum_list[i].type,
-                                      drm_tv_subconnector_enum_list[i].name);
         dev->mode_config.tv_subconnector_property = tv_subconnector;
 
         /*
          * Other, TV specific properties: margins & TV modes.
          */
         dev->mode_config.tv_left_margin_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "left margin", 2);
-        dev->mode_config.tv_left_margin_property->values[0] = 0;
-        dev->mode_config.tv_left_margin_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "left margin", 0, 100);
 
         dev->mode_config.tv_right_margin_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "right margin", 2);
-        dev->mode_config.tv_right_margin_property->values[0] = 0;
-        dev->mode_config.tv_right_margin_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "right margin", 0, 100);
 
         dev->mode_config.tv_top_margin_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "top margin", 2);
-        dev->mode_config.tv_top_margin_property->values[0] = 0;
-        dev->mode_config.tv_top_margin_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "top margin", 0, 100);
 
         dev->mode_config.tv_bottom_margin_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "bottom margin", 2);
-        dev->mode_config.tv_bottom_margin_property->values[0] = 0;
-        dev->mode_config.tv_bottom_margin_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "bottom margin", 0, 100);
 
         dev->mode_config.tv_mode_property =
                 drm_property_create(dev, DRM_MODE_PROP_ENUM,
@@ -796,40 +761,22 @@ int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
                                       i, modes[i]);
 
         dev->mode_config.tv_brightness_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "brightness", 2);
-        dev->mode_config.tv_brightness_property->values[0] = 0;
-        dev->mode_config.tv_brightness_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "brightness", 0, 100);
 
         dev->mode_config.tv_contrast_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "contrast", 2);
-        dev->mode_config.tv_contrast_property->values[0] = 0;
-        dev->mode_config.tv_contrast_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "contrast", 0, 100);
 
         dev->mode_config.tv_flicker_reduction_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "flicker reduction", 2);
-        dev->mode_config.tv_flicker_reduction_property->values[0] = 0;
-        dev->mode_config.tv_flicker_reduction_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
 
         dev->mode_config.tv_overscan_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "overscan", 2);
-        dev->mode_config.tv_overscan_property->values[0] = 0;
-        dev->mode_config.tv_overscan_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "overscan", 0, 100);
 
         dev->mode_config.tv_saturation_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "saturation", 2);
-        dev->mode_config.tv_saturation_property->values[0] = 0;
-        dev->mode_config.tv_saturation_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "saturation", 0, 100);
 
         dev->mode_config.tv_hue_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "hue", 2);
-        dev->mode_config.tv_hue_property->values[0] = 0;
-        dev->mode_config.tv_hue_property->values[1] = 100;
+                drm_property_create_range(dev, 0, "hue", 0, 100);
 
         return 0;
 }
@@ -845,18 +792,14 @@ EXPORT_SYMBOL(drm_mode_create_tv_properties);
 int drm_mode_create_scaling_mode_property(struct drm_device *dev)
 {
         struct drm_property *scaling_mode;
-        int i;
 
         if (dev->mode_config.scaling_mode_property)
                 return 0;
 
         scaling_mode =
-                drm_property_create(dev, DRM_MODE_PROP_ENUM, "scaling mode",
+                drm_property_create_enum(dev, 0, "scaling mode",
+                                drm_scaling_mode_enum_list,
                                     ARRAY_SIZE(drm_scaling_mode_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_scaling_mode_enum_list); i++)
-                drm_property_add_enum(scaling_mode, i,
-                                      drm_scaling_mode_enum_list[i].type,
-                                      drm_scaling_mode_enum_list[i].name);
 
         dev->mode_config.scaling_mode_property = scaling_mode;
 
@@ -874,18 +817,14 @@ EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
 int drm_mode_create_dithering_property(struct drm_device *dev)
 {
         struct drm_property *dithering_mode;
-        int i;
 
         if (dev->mode_config.dithering_mode_property)
                 return 0;
 
         dithering_mode =
-                drm_property_create(dev, DRM_MODE_PROP_ENUM, "dithering",
+                drm_property_create_enum(dev, 0, "dithering",
+                                drm_dithering_mode_enum_list,
                                     ARRAY_SIZE(drm_dithering_mode_enum_list));
-        for (i = 0; i < ARRAY_SIZE(drm_dithering_mode_enum_list); i++)
-                drm_property_add_enum(dithering_mode, i,
-                                      drm_dithering_mode_enum_list[i].type,
-                                      drm_dithering_mode_enum_list[i].name);
         dev->mode_config.dithering_mode_property = dithering_mode;
 
         return 0;
@@ -902,20 +841,15 @@ EXPORT_SYMBOL(drm_mode_create_dithering_property);
 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,
+                drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
                                     "dirty",
+                                    drm_dirty_info_enum_list,
                                     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;
@@ -1048,6 +982,9 @@ void drm_mode_config_cleanup(struct drm_device *dev)
                                  head) {
                 plane->funcs->destroy(plane);
         }
+
+        idr_remove_all(&dev->mode_config.crtc_idr);
+        idr_destroy(&dev->mode_config.crtc_idr);
 }
 EXPORT_SYMBOL(drm_mode_config_cleanup);
 
@@ -1311,7 +1248,7 @@ out:
  * @arg: arg from ioctl
  *
  * LOCKING:
- * Caller? (FIXME)
+ * Takes mode config lock.
  *
  * Construct a CRTC configuration structure to return to the user.
  *
@@ -1371,7 +1308,7 @@ out:
  * @arg: arg from ioctl
  *
  * LOCKING:
- * Caller? (FIXME)
+ * Takes mode config lock.
  *
  * Construct a connector configuration structure to return to the user.
  *
@@ -1553,6 +1490,9 @@ out:
  * @data: ioctl data
  * @file_priv: DRM file info
  *
+ * LOCKING:
+ * Takes mode config lock.
+ *
  * Return an plane count and set of IDs.
  */
 int drm_mode_getplane_res(struct drm_device *dev, void *data,
@@ -1599,6 +1539,9 @@ out:
  * @data: ioctl data
  * @file_priv: DRM file info
  *
+ * LOCKING:
+ * Takes mode config lock.
+ *
  * Return plane info, including formats supported, gamma size, any
  * current fb, etc.
  */
@@ -1664,6 +1607,9 @@ out:
  * @data: ioctl data*
  * @file_prive: DRM file info
  *
+ * LOCKING:
+ * Takes mode config lock.
+ *
  * Set plane info, including placement, fb, scaling, and other factors.
  * Or pass a NULL fb to disable.
  */
@@ -1794,7 +1740,7 @@ out:
  * @arg: arg from ioctl
  *
  * LOCKING:
- * Caller? (FIXME)
+ * Takes mode config lock.
  *
  * Build a new CRTC configuration based on user request.
  *
@@ -2275,7 +2221,7 @@ out:
  * @arg: arg from ioctl
  *
  * LOCKING:
- * Caller? (FIXME)
+ * Takes mode config lock.
  *
  * Lookup the FB given its ID and return info about it.
  *
@@ -2617,6 +2563,53 @@ fail:
 }
 EXPORT_SYMBOL(drm_property_create);
 
+struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
+                                         const char *name,
+                                         const struct drm_prop_enum_list *props,
+                                         int num_values)
+{
+        struct drm_property *property;
+        int i, ret;
+
+        flags |= DRM_MODE_PROP_ENUM;
+
+        property = drm_property_create(dev, flags, name, num_values);
+        if (!property)
+                return NULL;
+
+        for (i = 0; i < num_values; i++) {
+                ret = drm_property_add_enum(property, i,
+                                      props[i].type,
+                                      props[i].name);
+                if (ret) {
+                        drm_property_destroy(dev, property);
+                        return NULL;
+                }
+        }
+
+        return property;
+}
+EXPORT_SYMBOL(drm_property_create_enum);
+
+struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
+                                         const char *name,
+                                         uint64_t min, uint64_t max)
+{
+        struct drm_property *property;
+
+        flags |= DRM_MODE_PROP_RANGE;
+
+        property = drm_property_create(dev, flags, name, 2);
+        if (!property)
+                return NULL;
+
+        property->values[0] = min;
+        property->values[1] = max;
+
+        return property;
+}
+EXPORT_SYMBOL(drm_property_create_range);
+
 int drm_property_add_enum(struct drm_property *property, int index,
                           uint64_t value, const char *name)
 {
@@ -3021,7 +3014,7 @@ void drm_mode_connector_detach_encoder(struct drm_connector *connector,
 }
 EXPORT_SYMBOL(drm_mode_connector_detach_encoder);
 
-bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
+int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
                                   int gamma_size)
 {
         crtc->gamma_size = gamma_size;
@@ -3029,10 +3022,10 @@ bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
         crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL);
         if (!crtc->gamma_store) {
                 crtc->gamma_size = 0;
-                return false;
+                return -ENOMEM;
         }
 
-        return true;
+        return 0;
 }
 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
 
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index 84a4a809793f..d761d1241152 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -44,12 +44,12 @@ module_param_named(poll, drm_kms_helper_poll, bool, 0600);
 static void drm_mode_validate_flag(struct drm_connector *connector,
                                    int flags)
 {
-        struct drm_display_mode *mode, *t;
+        struct drm_display_mode *mode;
 
         if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
                 return;
 
-        list_for_each_entry_safe(mode, t, &connector->modes, head) {
+        list_for_each_entry(mode, &connector->modes, head) {
                 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
                                 !(flags & DRM_MODE_FLAG_INTERLACE))
                         mode->status = MODE_NO_INTERLACE;
@@ -87,7 +87,7 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
                                             uint32_t maxX, uint32_t maxY)
 {
         struct drm_device *dev = connector->dev;
-        struct drm_display_mode *mode, *t;
+        struct drm_display_mode *mode;
         struct drm_connector_helper_funcs *connector_funcs =
                 connector->helper_private;
         int count = 0;
@@ -96,7 +96,7 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
                         drm_get_connector_name(connector));
         /* set all modes to the unverified state */
-        list_for_each_entry_safe(mode, t, &connector->modes, head)
+        list_for_each_entry(mode, &connector->modes, head)
                 mode->status = MODE_UNVERIFIED;
 
         if (connector->force) {
@@ -136,7 +136,7 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
                 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
         drm_mode_validate_flag(connector, mode_flags);
 
-        list_for_each_entry_safe(mode, t, &connector->modes, head) {
+        list_for_each_entry(mode, &connector->modes, head) {
                 if (mode->status == MODE_OK)
                         mode->status = connector_funcs->mode_valid(connector,
                                                                    mode);
@@ -152,7 +152,7 @@ prune:
 
         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
                         drm_get_connector_name(connector));
-        list_for_each_entry_safe(mode, t, &connector->modes, head) {
+        list_for_each_entry(mode, &connector->modes, head) {
                 mode->vrefresh = drm_mode_vrefresh(mode);
 
                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index ebf7d3f68fc4..d166bd080400 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -135,23 +135,23 @@ static struct drm_ioctl_desc drm_ioctls[] = {
         DRM_IOCTL_DEF(DRM_IOCTL_GEM_FLINK, drm_gem_flink_ioctl, DRM_AUTH|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_GEM_OPEN, drm_gem_open_ioctl, DRM_AUTH|DRM_UNLOCKED),
 
-        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETRESOURCES, drm_mode_getresources, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETRESOURCES, drm_mode_getresources, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC, drm_mode_setcrtc, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR, drm_mode_cursor_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_MASTER|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETGAMMA, drm_mode_gamma_set_ioctl, DRM_MASTER|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETENCODER, drm_mode_getencoder, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCONNECTOR, drm_mode_getconnector, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETENCODER, drm_mode_getencoder, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCONNECTOR, drm_mode_getconnector, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATTACHMODE, drm_mode_attachmode_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_DETACHMODE, drm_mode_detachmode_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPERTY, drm_mode_getproperty_ioctl, DRM_MASTER | DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPROPERTY, drm_mode_connector_property_set_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPROPBLOB, drm_mode_getblob_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
-        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+        DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETFB, drm_mode_getfb, DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB, drm_mode_addfb, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_ADDFB2, drm_mode_addfb2, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
         DRM_IOCTL_DEF(DRM_IOCTL_MODE_RMFB, drm_mode_rmfb, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index ece03fc2d386..7ee7be1e5ce6 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -266,6 +266,11 @@ drm_do_probe_ddc_edid(struct i2c_adapter *adapter, unsigned char *buf,
                         }
                 };
                 ret = i2c_transfer(adapter, msgs, 2);
+                if (ret == -ENXIO) {
+                        DRM_DEBUG_KMS("drm: skipping non-existent adapter %s\n",
+                                        adapter->name);
+                        break;
+                }
         } while (ret != 2 && --retries);
 
         return ret == 2 ? 0 : -1;
@@ -745,7 +750,7 @@ drm_mode_std(struct drm_connector *connector, struct edid *edid,
                  */
                 mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
                 if (drm_mode_hsync(mode) > drm_gtf2_hbreak(edid)) {
-                        kfree(mode);
+                        drm_mode_destroy(dev, mode);
                         mode = drm_gtf_mode_complex(dev, hsize, vsize,
                                                     vrefresh_rate, 0, 0,
                                                     drm_gtf2_m(edid),
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index aada26f63dec..7740dd26f007 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -306,91 +306,31 @@ static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
 static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
 #endif
 
-static void drm_fb_helper_on(struct fb_info *info)
+static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
 {
         struct drm_fb_helper *fb_helper = info->par;
         struct drm_device *dev = fb_helper->dev;
         struct drm_crtc *crtc;
-        struct drm_crtc_helper_funcs *crtc_funcs;
-        struct drm_connector *connector;
-        struct drm_encoder *encoder;
-        int i, j;
-
-        /*
-         * For each CRTC in this fb, turn the crtc on then,
-         * find all associated encoders and turn them on.
-         */
-        mutex_lock(&dev->mode_config.mutex);
-        for (i = 0; i < fb_helper->crtc_count; i++) {
-                crtc = fb_helper->crtc_info[i].mode_set.crtc;
-                crtc_funcs = crtc->helper_private;
-
-                if (!crtc->enabled)
-                        continue;
-
-                crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
-
-                /* Walk the connectors & encoders on this fb turning them on */
-                for (j = 0; j < fb_helper->connector_count; j++) {
-                        connector = fb_helper->connector_info[j]->connector;
-                        connector->dpms = DRM_MODE_DPMS_ON;
-                        drm_connector_property_set_value(connector,
-                                                         dev->mode_config.dpms_property,
-                                                         DRM_MODE_DPMS_ON);
-                }
-                /* Found a CRTC on this fb, now find encoders */
-                list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-                        if (encoder->crtc == crtc) {
-                                struct drm_encoder_helper_funcs *encoder_funcs;
-
-                                encoder_funcs = encoder->helper_private;
-                                encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
-                        }
-                }
-        }
-        mutex_unlock(&dev->mode_config.mutex);
-}
-
-static void drm_fb_helper_off(struct fb_info *info, int dpms_mode)
-{
-        struct drm_fb_helper *fb_helper = info->par;
-        struct drm_device *dev = fb_helper->dev;
-        struct drm_crtc *crtc;
-        struct drm_crtc_helper_funcs *crtc_funcs;
         struct drm_connector *connector;
-        struct drm_encoder *encoder;
         int i, j;
 
         /*
-         * For each CRTC in this fb, find all associated encoders
-         * and turn them off, then turn off the CRTC.
+         * For each CRTC in this fb, turn the connectors on/off.
          */
         mutex_lock(&dev->mode_config.mutex);
         for (i = 0; i < fb_helper->crtc_count; i++) {
                 crtc = fb_helper->crtc_info[i].mode_set.crtc;
-                crtc_funcs = crtc->helper_private;
 
                 if (!crtc->enabled)
                         continue;
 
-                /* Walk the connectors on this fb and mark them off */
+                /* Walk the connectors & encoders on this fb turning them on/off */
                 for (j = 0; j < fb_helper->connector_count; j++) {
                         connector = fb_helper->connector_info[j]->connector;
-                        connector->dpms = dpms_mode;
+                        drm_helper_connector_dpms(connector, dpms_mode);
                         drm_connector_property_set_value(connector,
-                                                         dev->mode_config.dpms_property,
-                                                         dpms_mode);
-                }
-                /* Found a CRTC on this fb, now find encoders */
-                list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-                        if (encoder->crtc == crtc) {
-                                struct drm_encoder_helper_funcs *encoder_funcs;
-
-                                encoder_funcs = encoder->helper_private;
-                                encoder_funcs->dpms(encoder, dpms_mode);
-                        }
+                                dev->mode_config.dpms_property, dpms_mode);
                 }
-                crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
         }
         mutex_unlock(&dev->mode_config.mutex);
 }
@@ -400,23 +340,23 @@ 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);
+                drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
                 break;
         /* Display: Off; HSync: On, VSync: On */
         case FB_BLANK_NORMAL:
-                drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
+                drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
                 break;
         /* Display: Off; HSync: Off, VSync: On */
         case FB_BLANK_HSYNC_SUSPEND:
-                drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
+                drm_fb_helper_dpms(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);
+                drm_fb_helper_dpms(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);
+                drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
                 break;
         }
         return 0;
@@ -430,8 +370,11 @@ static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
         for (i = 0; i < helper->connector_count; i++)
                 kfree(helper->connector_info[i]);
         kfree(helper->connector_info);
-        for (i = 0; i < helper->crtc_count; i++)
+        for (i = 0; i < helper->crtc_count; i++) {
                 kfree(helper->crtc_info[i].mode_set.connectors);
+                if (helper->crtc_info[i].mode_set.mode)
+                        drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
+        }
         kfree(helper->crtc_info);
 }
 
@@ -474,11 +417,10 @@ int drm_fb_helper_init(struct drm_device *dev,
 
         i = 0;
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                fb_helper->crtc_info[i].crtc_id = crtc->base.id;
                 fb_helper->crtc_info[i].mode_set.crtc = crtc;
                 i++;
         }
-        fb_helper->conn_limit = max_conn_count;
+
         return 0;
 out_free:
         drm_fb_helper_crtc_free(fb_helper);
diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c
index 2300ab1a2a77..cf85155da2a0 100644
--- a/drivers/gpu/drm/drm_ioctl.c
+++ b/drivers/gpu/drm/drm_ioctl.c
@@ -277,6 +277,12 @@ int drm_getcap(struct drm_device *dev, void *data, struct drm_file *file_priv)
         case DRM_CAP_VBLANK_HIGH_CRTC:
                 req->value = 1;
                 break;
+        case DRM_CAP_DUMB_PREFERRED_DEPTH:
+                req->value = dev->mode_config.preferred_depth;
+                break;
+        case DRM_CAP_DUMB_PREFER_SHADOW:
+                req->value = dev->mode_config.prefer_shadow;
+                break;
         default:
                 return -EINVAL;
         }
diff --git a/drivers/gpu/drm/drm_modes.c b/drivers/gpu/drm/drm_modes.c
index fb8e46b4e8bc..7ff13bc47ca2 100644
--- a/drivers/gpu/drm/drm_modes.c
+++ b/drivers/gpu/drm/drm_modes.c
@@ -686,8 +686,6 @@ void drm_mode_set_crtcinfo(struct drm_display_mode *p, int adjust_flags)
                         p->crtc_vsync_end /= 2;
                         p->crtc_vtotal /= 2;
                 }
-
-                p->crtc_vtotal |= 1;
         }
 
         if (p->flags & DRM_MODE_FLAG_DBLSCAN) {
diff --git a/drivers/gpu/drm/drm_pci.c b/drivers/gpu/drm/drm_pci.c
index d4d10b7880cf..13f3d936472f 100644
--- a/drivers/gpu/drm/drm_pci.c
+++ b/drivers/gpu/drm/drm_pci.c
@@ -324,8 +324,6 @@ int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
         if (ret)
                 goto err_g1;
 
-        pci_set_master(pdev);
-
         dev->pdev = pdev;
         dev->dev = &pdev->dev;
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
index d7ae29d2f3d6..5737bc5e6ed2 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
@@ -46,39 +46,13 @@ struct exynos_drm_fbdev {
         struct exynos_drm_gem_obj       *exynos_gem_obj;
 };
 
-static int exynos_drm_fbdev_set_par(struct fb_info *info)
-{
-        struct fb_var_screeninfo *var = &info->var;
-
-        switch (var->bits_per_pixel) {
-        case 32:
-        case 24:
-        case 18:
-        case 16:
-        case 12:
-                info->fix.visual = FB_VISUAL_TRUECOLOR;
-                break;
-        case 1:
-                info->fix.visual = FB_VISUAL_MONO01;
-                break;
-        default:
-                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
-                break;
-        }
-
-        info->fix.line_length = (var->xres_virtual * var->bits_per_pixel) / 8;
-
-        return drm_fb_helper_set_par(info);
-}
-
-
 static struct fb_ops exynos_drm_fb_ops = {
         .owner          = THIS_MODULE,
         .fb_fillrect    = cfb_fillrect,
         .fb_copyarea    = cfb_copyarea,
         .fb_imageblit   = cfb_imageblit,
         .fb_check_var   = drm_fb_helper_check_var,
-        .fb_set_par     = exynos_drm_fbdev_set_par,
+        .fb_set_par     = drm_fb_helper_set_par,
         .fb_blank       = drm_fb_helper_blank,
         .fb_pan_display = drm_fb_helper_pan_display,
         .fb_setcmap     = drm_fb_helper_setcmap,
diff --git a/drivers/gpu/drm/gma500/framebuffer.c b/drivers/gpu/drm/gma500/framebuffer.c
index 830dfdd6bf15..c1c4dc174fa2 100644
--- a/drivers/gpu/drm/gma500/framebuffer.c
+++ b/drivers/gpu/drm/gma500/framebuffer.c
@@ -507,11 +507,7 @@ static int psbfb_create(struct psb_fbdev *fbdev,
         info->fix.mmio_start = pci_resource_start(dev->pdev, 0);
         info->fix.mmio_len = pci_resource_len(dev->pdev, 0);
 
-        info->pixmap.size = 64 * 1024;
-        info->pixmap.buf_align = 8;
-        info->pixmap.access_align = 32;
-        info->pixmap.flags = FB_PIXMAP_SYSTEM;
-        info->pixmap.scan_align = 1;
+        /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
         dev_info(dev->dev, "allocated %dx%d fb\n",
                                         psbfb->base.width, psbfb->base.height);
@@ -725,10 +721,7 @@ static int psb_create_backlight_property(struct drm_device *dev)
         if (dev_priv->backlight_property)
                 return 0;
 
-        backlight = drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                        "backlight", 2);
-        backlight->values[0] = 0;
-        backlight->values[1] = 100;
+        backlight = drm_property_create_range(dev, 0, "backlight", 0, 100);
 
         dev_priv->backlight_property = backlight;
 
diff --git a/drivers/gpu/drm/gma500/intel_gmbus.c b/drivers/gpu/drm/gma500/intel_gmbus.c
index 147584ac8d02..9db90527bf0f 100644
--- a/drivers/gpu/drm/gma500/intel_gmbus.c
+++ b/drivers/gpu/drm/gma500/intel_gmbus.c
@@ -395,7 +395,7 @@ int gma_intel_setup_gmbus(struct drm_device *dev)
         struct drm_psb_private *dev_priv = dev->dev_private;
         int ret, i;
 
-        dev_priv->gmbus = kcalloc(sizeof(struct intel_gmbus), GMBUS_NUM_PORTS,
+        dev_priv->gmbus = kcalloc(GMBUS_NUM_PORTS, sizeof(struct intel_gmbus),
                                   GFP_KERNEL);
         if (dev_priv->gmbus == NULL)
                 return -ENOMEM;
diff --git a/drivers/gpu/drm/gma500/psb_drv.c b/drivers/gpu/drm/gma500/psb_drv.c
index f14768f2b364..1f57aac2cf80 100644
--- a/drivers/gpu/drm/gma500/psb_drv.c
+++ b/drivers/gpu/drm/gma500/psb_drv.c
@@ -283,6 +283,8 @@ static int psb_driver_load(struct drm_device *dev, unsigned long chipset)
         dev_priv->dev = dev;
         dev->dev_private = (void *) dev_priv;
 
+        pci_set_master(dev->pdev);
+
         if (!IS_PSB(dev)) {
                 if (pci_enable_msi(dev->pdev))
                         dev_warn(dev->dev, "Enabling MSI failed!\n");
diff --git a/drivers/gpu/drm/gma500/psb_intel_sdvo.c b/drivers/gpu/drm/gma500/psb_intel_sdvo.c
index 88b42971c0fd..41b55d7a7bf8 100644
--- a/drivers/gpu/drm/gma500/psb_intel_sdvo.c
+++ b/drivers/gpu/drm/gma500/psb_intel_sdvo.c
@@ -2312,10 +2312,8 @@ static bool psb_intel_sdvo_tv_create_property(struct psb_intel_sdvo *psb_intel_s
                 psb_intel_sdvo_connector->max_##name = data_value[0]; \
                 psb_intel_sdvo_connector->cur_##name = response; \
                 psb_intel_sdvo_connector->name = \
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE, #name, 2); \
+                        drm_property_create_range(dev, 0, #name, 0, data_value[0]); \
                 if (!psb_intel_sdvo_connector->name) return false; \
-                psb_intel_sdvo_connector->name->values[0] = 0; \
-                psb_intel_sdvo_connector->name->values[1] = data_value[0]; \
                 drm_connector_attach_property(connector, \
                                               psb_intel_sdvo_connector->name, \
                                               psb_intel_sdvo_connector->cur_##name); \
@@ -2349,25 +2347,19 @@ psb_intel_sdvo_create_enhance_property_tv(struct psb_intel_sdvo *psb_intel_sdvo,
                 psb_intel_sdvo_connector->left_margin = data_value[0] - response;
                 psb_intel_sdvo_connector->right_margin = psb_intel_sdvo_connector->left_margin;
                 psb_intel_sdvo_connector->left =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "left_margin", 2);
+                        drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]);
                 if (!psb_intel_sdvo_connector->left)
                         return false;
 
-                psb_intel_sdvo_connector->left->values[0] = 0;
-                psb_intel_sdvo_connector->left->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               psb_intel_sdvo_connector->left,
                                               psb_intel_sdvo_connector->left_margin);
 
                 psb_intel_sdvo_connector->right =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "right_margin", 2);
+                        drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]);
                 if (!psb_intel_sdvo_connector->right)
                         return false;
 
-                psb_intel_sdvo_connector->right->values[0] = 0;
-                psb_intel_sdvo_connector->right->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               psb_intel_sdvo_connector->right,
                                               psb_intel_sdvo_connector->right_margin);
@@ -2391,25 +2383,19 @@ psb_intel_sdvo_create_enhance_property_tv(struct psb_intel_sdvo *psb_intel_sdvo,
                 psb_intel_sdvo_connector->top_margin = data_value[0] - response;
                 psb_intel_sdvo_connector->bottom_margin = psb_intel_sdvo_connector->top_margin;
                 psb_intel_sdvo_connector->top =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "top_margin", 2);
+                        drm_property_create_range(dev, 0, "top_margin", 0, data_value[0]);
                 if (!psb_intel_sdvo_connector->top)
                         return false;
 
-                psb_intel_sdvo_connector->top->values[0] = 0;
-                psb_intel_sdvo_connector->top->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               psb_intel_sdvo_connector->top,
                                               psb_intel_sdvo_connector->top_margin);
 
                 psb_intel_sdvo_connector->bottom =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "bottom_margin", 2);
+                        drm_property_create_range(dev, 0, "bottom_margin", 0, data_value[0]);
                 if (!psb_intel_sdvo_connector->bottom)
                         return false;
 
-                psb_intel_sdvo_connector->bottom->values[0] = 0;
-                psb_intel_sdvo_connector->bottom->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               psb_intel_sdvo_connector->bottom,
                                               psb_intel_sdvo_connector->bottom_margin);
@@ -2438,12 +2424,10 @@ psb_intel_sdvo_create_enhance_property_tv(struct psb_intel_sdvo *psb_intel_sdvo,
                 psb_intel_sdvo_connector->max_dot_crawl = 1;
                 psb_intel_sdvo_connector->cur_dot_crawl = response & 0x1;
                 psb_intel_sdvo_connector->dot_crawl =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE, "dot_crawl", 2);
+                        drm_property_create_range(dev, 0, "dot_crawl", 0, 1);
                 if (!psb_intel_sdvo_connector->dot_crawl)
                         return false;
 
-                psb_intel_sdvo_connector->dot_crawl->values[0] = 0;
-                psb_intel_sdvo_connector->dot_crawl->values[1] = 1;
                 drm_connector_attach_property(connector,
                                               psb_intel_sdvo_connector->dot_crawl,
                                               psb_intel_sdvo_connector->cur_dot_crawl);
diff --git a/drivers/gpu/drm/i2c/ch7006_drv.c b/drivers/gpu/drm/i2c/ch7006_drv.c
index 07d55df6623e..d3f2e8785010 100644
--- a/drivers/gpu/drm/i2c/ch7006_drv.c
+++ b/drivers/gpu/drm/i2c/ch7006_drv.c
@@ -252,10 +252,7 @@ static int ch7006_encoder_create_resources(struct drm_encoder *encoder,
 
         drm_mode_create_tv_properties(dev, NUM_TV_NORMS, ch7006_tv_norm_names);
 
-        priv->scale_property = drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                                   "scale", 2);
-        priv->scale_property->values[0] = 0;
-        priv->scale_property->values[1] = 2;
+        priv->scale_property = drm_property_create_range(dev, 0, "scale", 0, 2);
 
         drm_connector_attach_property(connector, conf->tv_select_subconnector_property,
                                       priv->select_subconnector);
diff --git a/drivers/gpu/drm/i810/i810_dma.c b/drivers/gpu/drm/i810/i810_dma.c
index 7f4b4e10246e..64a989ed5b8f 100644
--- a/drivers/gpu/drm/i810/i810_dma.c
+++ b/drivers/gpu/drm/i810/i810_dma.c
@@ -1208,6 +1208,8 @@ int i810_driver_load(struct drm_device *dev, unsigned long flags)
         dev->types[8] = _DRM_STAT_SECONDARY;
         dev->types[9] = _DRM_STAT_DMA;
 
+        pci_set_master(dev->pdev);
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index 39728fbb3f07..9341eb8ce93b 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -1951,6 +1951,8 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 goto free_priv;
         }
 
+        pci_set_master(dev->pdev);
+
         /* overlay on gen2 is broken and can't address above 1G */
         if (IS_GEN2(dev))
                 dma_set_coherent_mask(&dev->pdev->dev, DMA_BIT_MASK(30));
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index cdcf99bf9de8..b65dc04f1289 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -9098,6 +9098,9 @@ void intel_modeset_init(struct drm_device *dev)
         dev->mode_config.min_width = 0;
         dev->mode_config.min_height = 0;
 
+        dev->mode_config.preferred_depth = 24;
+        dev->mode_config.prefer_shadow = 1;
+
         dev->mode_config.funcs = (void *)&intel_mode_funcs;
 
         intel_init_quirks(dev);
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c
index 571375a3eef4..2d8766978388 100644
--- a/drivers/gpu/drm/i915/intel_fb.c
+++ b/drivers/gpu/drm/i915/intel_fb.c
@@ -152,11 +152,7 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
         drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
         drm_fb_helper_fill_var(info, &ifbdev->helper, sizes->fb_width, sizes->fb_height);
 
-        info->pixmap.size = 64*1024;
-        info->pixmap.buf_align = 8;
-        info->pixmap.access_align = 32;
-        info->pixmap.flags = FB_PIXMAP_SYSTEM;
-        info->pixmap.scan_align = 1;
+        /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
         DRM_DEBUG_KMS("allocated %dx%d fb: 0x%08x, bo %p\n",
                       fb->width, fb->height,
diff --git a/drivers/gpu/drm/i915/intel_i2c.c b/drivers/gpu/drm/i915/intel_i2c.c
index fc75d71de53b..068617f7256a 100644
--- a/drivers/gpu/drm/i915/intel_i2c.c
+++ b/drivers/gpu/drm/i915/intel_i2c.c
@@ -37,7 +37,7 @@
 
 /* Intel GPIO access functions */
 
-#define I2C_RISEFALL_TIME 20
+#define I2C_RISEFALL_TIME 10
 
 static inline struct intel_gmbus *
 to_intel_gmbus(struct i2c_adapter *i2c)
@@ -383,7 +383,7 @@ int intel_setup_gmbus(struct drm_device *dev)
         struct drm_i915_private *dev_priv = dev->dev_private;
         int ret, i;
 
-        dev_priv->gmbus = kcalloc(sizeof(struct intel_gmbus), GMBUS_NUM_PORTS,
+        dev_priv->gmbus = kcalloc(GMBUS_NUM_PORTS, sizeof(struct intel_gmbus),
                                   GFP_KERNEL);
         if (dev_priv->gmbus == NULL)
                 return -ENOMEM;
diff --git a/drivers/gpu/drm/i915/intel_modes.c b/drivers/gpu/drm/i915/intel_modes.c
index 7be46163f421..2978a3f61b58 100644
--- a/drivers/gpu/drm/i915/intel_modes.c
+++ b/drivers/gpu/drm/i915/intel_modes.c
@@ -83,11 +83,11 @@ int intel_ddc_get_modes(struct drm_connector *connector,
         return ret;
 }
 
-static const char *force_audio_names[] = {
-        "force-dvi",
-        "off",
-        "auto",
-        "on",
+static const struct drm_prop_enum_list force_audio_names[] = {
+        { HDMI_AUDIO_OFF_DVI, "force-dvi" },
+        { HDMI_AUDIO_OFF, "off" },
+        { HDMI_AUDIO_AUTO, "auto" },
+        { HDMI_AUDIO_ON, "on" },
 };
 
 void
@@ -96,28 +96,24 @@ intel_attach_force_audio_property(struct drm_connector *connector)
         struct drm_device *dev = connector->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_property *prop;
-        int i;
 
         prop = dev_priv->force_audio_property;
         if (prop == NULL) {
-                prop = drm_property_create(dev, DRM_MODE_PROP_ENUM,
+                prop = drm_property_create_enum(dev, 0,
                                            "audio",
+                                           force_audio_names,
                                            ARRAY_SIZE(force_audio_names));
                 if (prop == NULL)
                         return;
 
-                for (i = 0; i < ARRAY_SIZE(force_audio_names); i++)
-                        drm_property_add_enum(prop, i, i-2,
-                                              force_audio_names[i]);
-
                 dev_priv->force_audio_property = prop;
         }
         drm_connector_attach_property(connector, prop, 0);
 }
 
-static const char *broadcast_rgb_names[] = {
-        "Full",
-        "Limited 16:235",
+static const struct drm_prop_enum_list broadcast_rgb_names[] = {
+        { 0, "Full" },
+        { 1, "Limited 16:235" },
 };
 
 void
@@ -126,19 +122,16 @@ intel_attach_broadcast_rgb_property(struct drm_connector *connector)
         struct drm_device *dev = connector->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_property *prop;
-        int i;
 
         prop = dev_priv->broadcast_rgb_property;
         if (prop == NULL) {
-                prop = drm_property_create(dev, DRM_MODE_PROP_ENUM,
+                prop = drm_property_create_enum(dev, DRM_MODE_PROP_ENUM,
                                            "Broadcast RGB",
+                                           broadcast_rgb_names,
                                            ARRAY_SIZE(broadcast_rgb_names));
                 if (prop == NULL)
                         return;
 
-                for (i = 0; i < ARRAY_SIZE(broadcast_rgb_names); i++)
-                        drm_property_add_enum(prop, i, i, broadcast_rgb_names[i]);
-
                 dev_priv->broadcast_rgb_property = prop;
         }
 
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 80fb5da421f8..724190ec496b 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -2276,10 +2276,8 @@ static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
                 intel_sdvo_connector->max_##name = data_value[0]; \
                 intel_sdvo_connector->cur_##name = response; \
                 intel_sdvo_connector->name = \
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE, #name, 2); \
+                        drm_property_create_range(dev, 0, #name, 0, data_value[0]); \
                 if (!intel_sdvo_connector->name) return false; \
-                intel_sdvo_connector->name->values[0] = 0; \
-                intel_sdvo_connector->name->values[1] = data_value[0]; \
                 drm_connector_attach_property(connector, \
                                               intel_sdvo_connector->name, \
                                               intel_sdvo_connector->cur_##name); \
@@ -2313,25 +2311,19 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
                 intel_sdvo_connector->left_margin = data_value[0] - response;
                 intel_sdvo_connector->right_margin = intel_sdvo_connector->left_margin;
                 intel_sdvo_connector->left =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "left_margin", 2);
+                        drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]);
                 if (!intel_sdvo_connector->left)
                         return false;
 
-                intel_sdvo_connector->left->values[0] = 0;
-                intel_sdvo_connector->left->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               intel_sdvo_connector->left,
                                               intel_sdvo_connector->left_margin);
 
                 intel_sdvo_connector->right =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "right_margin", 2);
+                        drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]);
                 if (!intel_sdvo_connector->right)
                         return false;
 
-                intel_sdvo_connector->right->values[0] = 0;
-                intel_sdvo_connector->right->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               intel_sdvo_connector->right,
                                               intel_sdvo_connector->right_margin);
@@ -2355,25 +2347,21 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
                 intel_sdvo_connector->top_margin = data_value[0] - response;
                 intel_sdvo_connector->bottom_margin = intel_sdvo_connector->top_margin;
                 intel_sdvo_connector->top =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "top_margin", 2);
+                        drm_property_create_range(dev, 0,
+                                            "top_margin", 0, data_value[0]);
                 if (!intel_sdvo_connector->top)
                         return false;
 
-                intel_sdvo_connector->top->values[0] = 0;
-                intel_sdvo_connector->top->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               intel_sdvo_connector->top,
                                               intel_sdvo_connector->top_margin);
 
                 intel_sdvo_connector->bottom =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                            "bottom_margin", 2);
+                        drm_property_create_range(dev, 0,
+                                            "bottom_margin", 0, data_value[0]);
                 if (!intel_sdvo_connector->bottom)
                         return false;
 
-                intel_sdvo_connector->bottom->values[0] = 0;
-                intel_sdvo_connector->bottom->values[1] = data_value[0];
                 drm_connector_attach_property(connector,
                                               intel_sdvo_connector->bottom,
                                               intel_sdvo_connector->bottom_margin);
@@ -2402,12 +2390,10 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
                 intel_sdvo_connector->max_dot_crawl = 1;
                 intel_sdvo_connector->cur_dot_crawl = response & 0x1;
                 intel_sdvo_connector->dot_crawl =
-                        drm_property_create(dev, DRM_MODE_PROP_RANGE, "dot_crawl", 2);
+                        drm_property_create_range(dev, 0, "dot_crawl", 0, 1);
                 if (!intel_sdvo_connector->dot_crawl)
                         return false;
 
-                intel_sdvo_connector->dot_crawl->values[0] = 0;
-                intel_sdvo_connector->dot_crawl->values[1] = 1;
                 drm_connector_attach_property(connector,
                                               intel_sdvo_connector->dot_crawl,
                                               intel_sdvo_connector->cur_dot_crawl);
diff --git a/drivers/gpu/drm/mga/mga_dma.c b/drivers/gpu/drm/mga/mga_dma.c
index 5ccb65deb83c..507aa3df0168 100644
--- a/drivers/gpu/drm/mga/mga_dma.c
+++ b/drivers/gpu/drm/mga/mga_dma.c
@@ -403,6 +403,8 @@ int mga_driver_load(struct drm_device *dev, unsigned long flags)
         dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT;
         dev_priv->chipset = flags;
 
+        pci_set_master(dev->pdev);
+
         dev_priv->mmio_base = pci_resource_start(dev->pdev, 1);
         dev_priv->mmio_size = pci_resource_len(dev->pdev, 1);
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_display.c b/drivers/gpu/drm/nouveau/nouveau_display.c
index 795a9e3c990a..5565e5056ba1 100644
--- a/drivers/gpu/drm/nouveau/nouveau_display.c
+++ b/drivers/gpu/drm/nouveau/nouveau_display.c
@@ -155,20 +155,20 @@ static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
 };
 
 
-struct drm_prop_enum_list {
+struct nouveau_drm_prop_enum_list {
         u8 gen_mask;
         int type;
         char *name;
 };
 
-static struct drm_prop_enum_list underscan[] = {
+static struct nouveau_drm_prop_enum_list underscan[] = {
         { 6, UNDERSCAN_AUTO, "auto" },
         { 6, UNDERSCAN_OFF, "off" },
         { 6, UNDERSCAN_ON, "on" },
         {}
 };
 
-static struct drm_prop_enum_list dither_mode[] = {
+static struct nouveau_drm_prop_enum_list dither_mode[] = {
         { 7, DITHERING_MODE_AUTO, "auto" },
         { 7, DITHERING_MODE_OFF, "off" },
         { 1, DITHERING_MODE_ON, "on" },
@@ -178,7 +178,7 @@ static struct drm_prop_enum_list dither_mode[] = {
         {}
 };
 
-static struct drm_prop_enum_list dither_depth[] = {
+static struct nouveau_drm_prop_enum_list dither_depth[] = {
         { 6, DITHERING_DEPTH_AUTO, "auto" },
         { 6, DITHERING_DEPTH_6BPC, "6 bpc" },
         { 6, DITHERING_DEPTH_8BPC, "8 bpc" },
@@ -186,7 +186,7 @@ static struct drm_prop_enum_list dither_depth[] = {
 };
 
 #define PROP_ENUM(p,gen,n,list) do {                                           \
-        struct drm_prop_enum_list *l = (list);                                 \
+        struct nouveau_drm_prop_enum_list *l = (list);                         \
         int c = 0;                                                             \
         while (l->gen_mask) {                                                  \
                 if (l->gen_mask & (1 << (gen)))                                \
@@ -281,16 +281,10 @@ nouveau_display_create(struct drm_device *dev)
         PROP_ENUM(disp->underscan_property, gen, "underscan", underscan);
 
         disp->underscan_hborder_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "underscan hborder", 2);
-        disp->underscan_hborder_property->values[0] = 0;
-        disp->underscan_hborder_property->values[1] = 128;
+                drm_property_create_range(dev, 0, "underscan hborder", 0, 128);
 
         disp->underscan_vborder_property =
-                drm_property_create(dev, DRM_MODE_PROP_RANGE,
-                                    "underscan vborder", 2);
-        disp->underscan_vborder_property->values[0] = 0;
-        disp->underscan_vborder_property->values[1] = 128;
+                drm_property_create_range(dev, 0, "underscan vborder", 0, 128);
 
         dev->mode_config.funcs = (void *)&nouveau_mode_config_funcs;
         dev->mode_config.fb_base = pci_resource_start(dev->pdev, 1);
diff --git a/drivers/gpu/drm/nouveau/nouveau_fbcon.c b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
index 9892218d7452..8113e9201ed9 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
@@ -381,11 +381,7 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
                 goto out_unref;
         }
 
-        info->pixmap.size = 64*1024;
-        info->pixmap.buf_align = 8;
-        info->pixmap.access_align = 32;
-        info->pixmap.flags = FB_PIXMAP_SYSTEM;
-        info->pixmap.scan_align = 1;
+        /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
         mutex_unlock(&dev->struct_mutex);
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_state.c b/drivers/gpu/drm/nouveau/nouveau_state.c
index f80c5e0762ff..912839c2bc16 100644
--- a/drivers/gpu/drm/nouveau/nouveau_state.c
+++ b/drivers/gpu/drm/nouveau/nouveau_state.c
@@ -1002,6 +1002,8 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
         dev->dev_private = dev_priv;
         dev_priv->dev = dev;
 
+        pci_set_master(dev->pdev);
+
         dev_priv->flags = flags & NOUVEAU_FLAGS;
 
         NV_DEBUG(dev, "vendor: 0x%X device: 0x%X class: 0x%X\n",
diff --git a/drivers/gpu/drm/r128/r128_drv.c b/drivers/gpu/drm/r128/r128_drv.c
index 6a5f4395838f..88718fad5d6d 100644
--- a/drivers/gpu/drm/r128/r128_drv.c
+++ b/drivers/gpu/drm/r128/r128_drv.c
@@ -85,6 +85,7 @@ static struct drm_driver driver = {
 
 int r128_driver_load(struct drm_device *dev, unsigned long flags)
 {
+        pci_set_master(dev->pdev);
         return drm_vblank_init(dev, 1);
 }
 
diff --git a/drivers/gpu/drm/radeon/Makefile b/drivers/gpu/drm/radeon/Makefile
index 2139fe893ec5..84104153a684 100644
--- a/drivers/gpu/drm/radeon/Makefile
+++ b/drivers/gpu/drm/radeon/Makefile
@@ -71,7 +71,7 @@ radeon-y += radeon_device.o radeon_asic.o radeon_kms.o \
         r600_blit_kms.o radeon_pm.o atombios_dp.o r600_audio.o r600_hdmi.o \
         evergreen.o evergreen_cs.o evergreen_blit_shaders.o evergreen_blit_kms.o \
         radeon_trace_points.o ni.o cayman_blit_shaders.o atombios_encoders.o \
-        radeon_semaphore.o radeon_sa.o
+        radeon_semaphore.o radeon_sa.o atombios_i2c.o
 
 radeon-$(CONFIG_COMPAT) += radeon_ioc32.o
 radeon-$(CONFIG_VGA_SWITCHEROO) += radeon_atpx_handler.o
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 742f17f009a9..72672ea3f6d3 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -1031,6 +1031,7 @@ static int dce4_crtc_do_set_base(struct drm_crtc *crtc,
         struct radeon_bo *rbo;
         uint64_t fb_location;
         uint32_t fb_format, fb_pitch_pixels, tiling_flags;
+        unsigned bankw, bankh, mtaspect, tile_split;
         u32 fb_swap = EVERGREEN_GRPH_ENDIAN_SWAP(EVERGREEN_GRPH_ENDIAN_NONE);
         u32 tmp, viewport_w, viewport_h;
         int r;
@@ -1121,20 +1122,13 @@ static int dce4_crtc_do_set_base(struct drm_crtc *crtc,
                         break;
                 }
 
-                switch ((tmp & 0xf000) >> 12) {
-                case 0: /* 1KB rows */
-                default:
-                        fb_format |= EVERGREEN_GRPH_TILE_SPLIT(EVERGREEN_ADDR_SURF_TILE_SPLIT_1KB);
-                        break;
-                case 1: /* 2KB rows */
-                        fb_format |= EVERGREEN_GRPH_TILE_SPLIT(EVERGREEN_ADDR_SURF_TILE_SPLIT_2KB);
-                        break;
-                case 2: /* 4KB rows */
-                        fb_format |= EVERGREEN_GRPH_TILE_SPLIT(EVERGREEN_ADDR_SURF_TILE_SPLIT_4KB);
-                        break;
-                }
-
                 fb_format |= EVERGREEN_GRPH_ARRAY_MODE(EVERGREEN_GRPH_ARRAY_2D_TILED_THIN1);
+
+                evergreen_tiling_fields(tiling_flags, &bankw, &bankh, &mtaspect, &tile_split);
+                fb_format |= EVERGREEN_GRPH_TILE_SPLIT(tile_split);
+                fb_format |= EVERGREEN_GRPH_BANK_WIDTH(bankw);
+                fb_format |= EVERGREEN_GRPH_BANK_HEIGHT(bankh);
+                fb_format |= EVERGREEN_GRPH_MACRO_TILE_ASPECT(mtaspect);
         } else if (tiling_flags & RADEON_TILING_MICRO)
                 fb_format |= EVERGREEN_GRPH_ARRAY_MODE(EVERGREEN_GRPH_ARRAY_1D_TILED_THIN1);
 
diff --git a/drivers/gpu/drm/radeon/atombios_i2c.c b/drivers/gpu/drm/radeon/atombios_i2c.c
new file mode 100644
index 000000000000..44d87b6b4220
--- /dev/null
+++ b/drivers/gpu/drm/radeon/atombios_i2c.c
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2011 Advanced Micro Devices, 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: Alex Deucher
+ *
+ */
+#include "drmP.h"
+#include "radeon_drm.h"
+#include "radeon.h"
+#include "atom.h"
+
+#define TARGET_HW_I2C_CLOCK 50
+
+/* these are a limitation of ProcessI2cChannelTransaction not the hw */
+#define ATOM_MAX_HW_I2C_WRITE 2
+#define ATOM_MAX_HW_I2C_READ  255
+
+static int radeon_process_i2c_ch(struct radeon_i2c_chan *chan,
+                                 u8 slave_addr, u8 flags,
+                                 u8 *buf, u8 num)
+{
+        struct drm_device *dev = chan->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        PROCESS_I2C_CHANNEL_TRANSACTION_PS_ALLOCATION args;
+        int index = GetIndexIntoMasterTable(COMMAND, ProcessI2cChannelTransaction);
+        unsigned char *base;
+        u16 out;
+
+        memset(&args, 0, sizeof(args));
+
+        base = (unsigned char *)rdev->mode_info.atom_context->scratch;
+
+        if (flags & HW_I2C_WRITE) {
+                if (num > ATOM_MAX_HW_I2C_WRITE) {
+                        DRM_ERROR("hw i2c: tried to write too many bytes (%d vs 2)\n", num);
+                        return -EINVAL;
+                }
+                memcpy(&out, buf, num);
+                args.lpI2CDataOut = cpu_to_le16(out);
+        } else {
+                if (num > ATOM_MAX_HW_I2C_READ) {
+                        DRM_ERROR("hw i2c: tried to read too many bytes (%d vs 255)\n", num);
+                        return -EINVAL;
+                }
+        }
+
+        args.ucI2CSpeed = TARGET_HW_I2C_CLOCK;
+        args.ucRegIndex = 0;
+        args.ucTransBytes = num;
+        args.ucSlaveAddr = slave_addr << 1;
+        args.ucLineNumber = chan->rec.i2c_id;
+
+        atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
+
+        /* error */
+        if (args.ucStatus != HW_ASSISTED_I2C_STATUS_SUCCESS) {
+                DRM_DEBUG_KMS("hw_i2c error\n");
+                return -EIO;
+        }
+
+        if (!(flags & HW_I2C_WRITE))
+                memcpy(buf, base, num);
+
+        return 0;
+}
+
+int radeon_atom_hw_i2c_xfer(struct i2c_adapter *i2c_adap,
+                            struct i2c_msg *msgs, int num)
+{
+        struct radeon_i2c_chan *i2c = i2c_get_adapdata(i2c_adap);
+        struct i2c_msg *p;
+        int i, remaining, current_count, buffer_offset, max_bytes, ret;
+        u8 buf = 0, flags;
+
+        /* check for bus probe */
+        p = &msgs[0];
+        if ((num == 1) && (p->len == 0)) {
+                ret = radeon_process_i2c_ch(i2c,
+                                            p->addr, HW_I2C_WRITE,
+                                            &buf, 1);
+                if (ret)
+                        return ret;
+                else
+                        return num;
+        }
+
+        for (i = 0; i < num; i++) {
+                p = &msgs[i];
+                remaining = p->len;
+                buffer_offset = 0;
+                /* max_bytes are a limitation of ProcessI2cChannelTransaction not the hw */
+                if (p->flags & I2C_M_RD) {
+                        max_bytes = ATOM_MAX_HW_I2C_READ;
+                        flags = HW_I2C_READ;
+                } else {
+                        max_bytes = ATOM_MAX_HW_I2C_WRITE;
+                        flags = HW_I2C_WRITE;
+                }
+                while (remaining) {
+                        if (remaining > max_bytes)
+                                current_count = max_bytes;
+                        else
+                                current_count = remaining;
+                        ret = radeon_process_i2c_ch(i2c,
+                                                    p->addr, flags,
+                                                    &p->buf[buffer_offset], current_count);
+                        if (ret)
+                                return ret;
+                        remaining -= current_count;
+                        buffer_offset += current_count;
+                }
+        }
+
+        return num;
+}
+
+u32 radeon_atom_hw_i2c_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+}
+
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 9be353b894cc..1a816ea51226 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -43,6 +43,37 @@ void evergreen_pcie_gen2_enable(struct radeon_device *rdev);
 extern void cayman_cp_int_cntl_setup(struct radeon_device *rdev,
                                      int ring, u32 cp_int_cntl);
 
+void evergreen_tiling_fields(unsigned tiling_flags, unsigned *bankw,
+                             unsigned *bankh, unsigned *mtaspect,
+                             unsigned *tile_split)
+{
+        *bankw = (tiling_flags >> RADEON_TILING_EG_BANKW_SHIFT) & RADEON_TILING_EG_BANKW_MASK;
+        *bankh = (tiling_flags >> RADEON_TILING_EG_BANKH_SHIFT) & RADEON_TILING_EG_BANKH_MASK;
+        *mtaspect = (tiling_flags >> RADEON_TILING_EG_MACRO_TILE_ASPECT_SHIFT) & RADEON_TILING_EG_MACRO_TILE_ASPECT_MASK;
+        *tile_split = (tiling_flags >> RADEON_TILING_EG_TILE_SPLIT_SHIFT) & RADEON_TILING_EG_TILE_SPLIT_MASK;
+        switch (*bankw) {
+        default:
+        case 1: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_1; break;
+        case 2: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_2; break;
+        case 4: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_4; break;
+        case 8: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_8; break;
+        }
+        switch (*bankh) {
+        default:
+        case 1: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_1; break;
+        case 2: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_2; break;
+        case 4: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_4; break;
+        case 8: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_8; break;
+        }
+        switch (*mtaspect) {
+        default:
+        case 1: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_1; break;
+        case 2: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_2; break;
+        case 4: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_4; break;
+        case 8: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_8; break;
+        }
+}
+
 void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
 {
         u16 ctl, v;
diff --git a/drivers/gpu/drm/radeon/evergreen_blit_kms.c b/drivers/gpu/drm/radeon/evergreen_blit_kms.c
index 2379849515c7..4e83fdcf4bc5 100644
--- a/drivers/gpu/drm/radeon/evergreen_blit_kms.c
+++ b/drivers/gpu/drm/radeon/evergreen_blit_kms.c
@@ -32,17 +32,7 @@
 #include "evergreend.h"
 #include "evergreen_blit_shaders.h"
 #include "cayman_blit_shaders.h"
-
-#define DI_PT_RECTLIST        0x11
-#define DI_INDEX_SIZE_16_BIT  0x0
-#define DI_SRC_SEL_AUTO_INDEX 0x2
-
-#define FMT_8                 0x1
-#define FMT_5_6_5             0x8
-#define FMT_8_8_8_8           0x1a
-#define COLOR_8               0x1
-#define COLOR_5_6_5           0x8
-#define COLOR_8_8_8_8         0x1a
+#include "radeon_blit_common.h"
 
 /* emits 17 */
 static void
diff --git a/drivers/gpu/drm/radeon/evergreen_cs.c b/drivers/gpu/drm/radeon/evergreen_cs.c
index 8e8cd85e5c00..49203b67b81b 100644
--- a/drivers/gpu/drm/radeon/evergreen_cs.c
+++ b/drivers/gpu/drm/radeon/evergreen_cs.c
@@ -31,6 +31,9 @@
 #include "evergreen_reg_safe.h"
 #include "cayman_reg_safe.h"
 
+#define MAX(a,b)                   (((a)>(b))?(a):(b))
+#define MIN(a,b)                   (((a)<(b))?(a):(b))
+
 static int evergreen_cs_packet_next_reloc(struct radeon_cs_parser *p,
                                           struct radeon_cs_reloc **cs_reloc);
 
@@ -54,14 +57,20 @@ struct evergreen_cs_track {
         u32                     cb_color_dim[12];
         u32                     cb_color_pitch[12];
         u32                     cb_color_slice[12];
+        u32                     cb_color_attrib[12];
         u32                     cb_color_cmask_slice[8];
         u32                     cb_color_fmask_slice[8];
         u32                     cb_target_mask;
         u32                     cb_shader_mask;
         u32                     vgt_strmout_config;
         u32                     vgt_strmout_buffer_config;
+        struct radeon_bo        *vgt_strmout_bo[4];
+        u64                     vgt_strmout_bo_mc[4];
+        u32                     vgt_strmout_bo_offset[4];
+        u32                     vgt_strmout_size[4];
         u32                     db_depth_control;
         u32                     db_depth_view;
+        u32                     db_depth_slice;
         u32                     db_depth_size;
         u32                     db_depth_size_idx;
         u32                     db_z_info;
@@ -103,19 +112,6 @@ static u32 evergreen_cs_get_num_banks(u32 nbanks)
         }
 }
 
-static u32 evergreen_cs_get_tile_split(u32 row_size)
-{
-        switch (row_size) {
-        case 1:
-        default:
-                return ADDR_SURF_TILE_SPLIT_1KB;
-        case 2:
-                return ADDR_SURF_TILE_SPLIT_2KB;
-        case 4:
-                return ADDR_SURF_TILE_SPLIT_4KB;
-        }
-}
-
 static void evergreen_cs_track_init(struct evergreen_cs_track *track)
 {
         int i;
@@ -132,7 +128,7 @@ static void evergreen_cs_track_init(struct evergreen_cs_track *track)
                 track->cb_color_bo[i] = NULL;
                 track->cb_color_bo_offset[i] = 0xFFFFFFFF;
                 track->cb_color_info[i] = 0;
-                track->cb_color_view[i] = 0;
+                track->cb_color_view[i] = 0xFFFFFFFF;
                 track->cb_color_pitch_idx[i] = 0;
                 track->cb_color_slice_idx[i] = 0;
                 track->cb_color_dim[i] = 0;
@@ -159,19 +155,704 @@ static void evergreen_cs_track_init(struct evergreen_cs_track *track)
         track->db_s_write_offset = 0xFFFFFFFF;
         track->db_s_read_bo = NULL;
         track->db_s_write_bo = NULL;
+
+        for (i = 0; i < 4; i++) {
+                track->vgt_strmout_size[i] = 0;
+                track->vgt_strmout_bo[i] = NULL;
+                track->vgt_strmout_bo_offset[i] = 0xFFFFFFFF;
+                track->vgt_strmout_bo_mc[i] = 0xFFFFFFFF;
+        }
 }
 
-static int evergreen_cs_track_check(struct radeon_cs_parser *p)
+struct eg_surface {
+        /* value gathered from cs */
+        unsigned        nbx;
+        unsigned        nby;
+        unsigned        format;
+        unsigned        mode;
+        unsigned        nbanks;
+        unsigned        bankw;
+        unsigned        bankh;
+        unsigned        tsplit;
+        unsigned        mtilea;
+        unsigned        nsamples;
+        /* output value */
+        unsigned        bpe;
+        unsigned        layer_size;
+        unsigned        palign;
+        unsigned        halign;
+        unsigned long   base_align;
+};
+
+static int evergreen_surface_check_linear(struct radeon_cs_parser *p,
+                                          struct eg_surface *surf,
+                                          const char *prefix)
+{
+        surf->layer_size = surf->nbx * surf->nby * surf->bpe * surf->nsamples;
+        surf->base_align = surf->bpe;
+        surf->palign = 1;
+        surf->halign = 1;
+        return 0;
+}
+
+static int evergreen_surface_check_linear_aligned(struct radeon_cs_parser *p,
+                                                  struct eg_surface *surf,
+                                                  const char *prefix)
+{
+        struct evergreen_cs_track *track = p->track;
+        unsigned palign;
+
+        palign = MAX(64, track->group_size / surf->bpe);
+        surf->layer_size = surf->nbx * surf->nby * surf->bpe * surf->nsamples;
+        surf->base_align = track->group_size;
+        surf->palign = palign;
+        surf->halign = 1;
+        if (surf->nbx & (palign - 1)) {
+                if (prefix) {
+                        dev_warn(p->dev, "%s:%d %s pitch %d invalid must be aligned with %d\n",
+                                 __func__, __LINE__, prefix, surf->nbx, palign);
+                }
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int evergreen_surface_check_1d(struct radeon_cs_parser *p,
+                                      struct eg_surface *surf,
+                                      const char *prefix)
+{
+        struct evergreen_cs_track *track = p->track;
+        unsigned palign;
+
+        palign = track->group_size / (8 * surf->bpe * surf->nsamples);
+        palign = MAX(8, palign);
+        surf->layer_size = surf->nbx * surf->nby * surf->bpe;
+        surf->base_align = track->group_size;
+        surf->palign = palign;
+        surf->halign = 8;
+        if ((surf->nbx & (palign - 1))) {
+                if (prefix) {
+                        dev_warn(p->dev, "%s:%d %s pitch %d invalid must be aligned with %d (%d %d %d)\n",
+                                 __func__, __LINE__, prefix, surf->nbx, palign,
+                                 track->group_size, surf->bpe, surf->nsamples);
+                }
+                return -EINVAL;
+        }
+        if ((surf->nby & (8 - 1))) {
+                if (prefix) {
+                        dev_warn(p->dev, "%s:%d %s height %d invalid must be aligned with 8\n",
+                                 __func__, __LINE__, prefix, surf->nby);
+                }
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int evergreen_surface_check_2d(struct radeon_cs_parser *p,
+                                      struct eg_surface *surf,
+                                      const char *prefix)
+{
+        struct evergreen_cs_track *track = p->track;
+        unsigned palign, halign, tileb, slice_pt;
+
+        tileb = 64 * surf->bpe * surf->nsamples;
+        palign = track->group_size / (8 * surf->bpe * surf->nsamples);
+        palign = MAX(8, palign);
+        slice_pt = 1;
+        if (tileb > surf->tsplit) {
+                slice_pt = tileb / surf->tsplit;
+        }
+        tileb = tileb / slice_pt;
+        /* macro tile width & height */
+        palign = (8 * surf->bankw * track->npipes) * surf->mtilea;
+        halign = (8 * surf->bankh * surf->nbanks) / surf->mtilea;
+        surf->layer_size = surf->nbx * surf->nby * surf->bpe * slice_pt;
+        surf->base_align = (palign / 8) * (halign / 8) * tileb;
+        surf->palign = palign;
+        surf->halign = halign;
+
+        if ((surf->nbx & (palign - 1))) {
+                if (prefix) {
+                        dev_warn(p->dev, "%s:%d %s pitch %d invalid must be aligned with %d\n",
+                                 __func__, __LINE__, prefix, surf->nbx, palign);
+                }
+                return -EINVAL;
+        }
+        if ((surf->nby & (halign - 1))) {
+                if (prefix) {
+                        dev_warn(p->dev, "%s:%d %s height %d invalid must be aligned with %d\n",
+                                 __func__, __LINE__, prefix, surf->nby, halign);
+                }
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int evergreen_surface_check(struct radeon_cs_parser *p,
+                                   struct eg_surface *surf,
+                                   const char *prefix)
+{
+        /* some common value computed here */
+        surf->bpe = r600_fmt_get_blocksize(surf->format);
+
+        switch (surf->mode) {
+        case ARRAY_LINEAR_GENERAL:
+                return evergreen_surface_check_linear(p, surf, prefix);
+        case ARRAY_LINEAR_ALIGNED:
+                return evergreen_surface_check_linear_aligned(p, surf, prefix);
+        case ARRAY_1D_TILED_THIN1:
+                return evergreen_surface_check_1d(p, surf, prefix);
+        case ARRAY_2D_TILED_THIN1:
+                return evergreen_surface_check_2d(p, surf, prefix);
+        default:
+                dev_warn(p->dev, "%s:%d invalid array mode %d\n",
+                                __func__, __LINE__, surf->mode);
+                return -EINVAL;
+        }
+        return -EINVAL;
+}
+
+static int evergreen_surface_value_conv_check(struct radeon_cs_parser *p,
+                                              struct eg_surface *surf,
+                                              const char *prefix)
+{
+        switch (surf->mode) {
+        case ARRAY_2D_TILED_THIN1:
+                break;
+        case ARRAY_LINEAR_GENERAL:
+        case ARRAY_LINEAR_ALIGNED:
+        case ARRAY_1D_TILED_THIN1:
+                return 0;
+        default:
+                dev_warn(p->dev, "%s:%d invalid array mode %d\n",
+                                __func__, __LINE__, surf->mode);
+                return -EINVAL;
+        }
+
+        switch (surf->nbanks) {
+        case 0: surf->nbanks = 2; break;
+        case 1: surf->nbanks = 4; break;
+        case 2: surf->nbanks = 8; break;
+        case 3: surf->nbanks = 16; break;
+        default:
+                dev_warn(p->dev, "%s:%d %s invalid number of banks %d\n",
+                         __func__, __LINE__, prefix, surf->nbanks);
+                return -EINVAL;
+        }
+        switch (surf->bankw) {
+        case 0: surf->bankw = 1; break;
+        case 1: surf->bankw = 2; break;
+        case 2: surf->bankw = 4; break;
+        case 3: surf->bankw = 8; break;
+        default:
+                dev_warn(p->dev, "%s:%d %s invalid bankw %d\n",
+                         __func__, __LINE__, prefix, surf->bankw);
+                return -EINVAL;
+        }
+        switch (surf->bankh) {
+        case 0: surf->bankh = 1; break;
+        case 1: surf->bankh = 2; break;
+        case 2: surf->bankh = 4; break;
+        case 3: surf->bankh = 8; break;
+        default:
+                dev_warn(p->dev, "%s:%d %s invalid bankh %d\n",
+                         __func__, __LINE__, prefix, surf->bankh);
+                return -EINVAL;
+        }
+        switch (surf->mtilea) {
+        case 0: surf->mtilea = 1; break;
+        case 1: surf->mtilea = 2; break;
+        case 2: surf->mtilea = 4; break;
+        case 3: surf->mtilea = 8; break;
+        default:
+                dev_warn(p->dev, "%s:%d %s invalid macro tile aspect %d\n",
+                         __func__, __LINE__, prefix, surf->mtilea);
+                return -EINVAL;
+        }
+        switch (surf->tsplit) {
+        case 0: surf->tsplit = 64; break;
+        case 1: surf->tsplit = 128; break;
+        case 2: surf->tsplit = 256; break;
+        case 3: surf->tsplit = 512; break;
+        case 4: surf->tsplit = 1024; break;
+        case 5: surf->tsplit = 2048; break;
+        case 6: surf->tsplit = 4096; break;
+        default:
+                dev_warn(p->dev, "%s:%d %s invalid tile split %d\n",
+                         __func__, __LINE__, prefix, surf->tsplit);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int evergreen_cs_track_validate_cb(struct radeon_cs_parser *p, unsigned id)
+{
+        struct evergreen_cs_track *track = p->track;
+        struct eg_surface surf;
+        unsigned pitch, slice, mslice;
+        unsigned long offset;
+        int r;
+
+        mslice = G_028C6C_SLICE_MAX(track->cb_color_view[id]) + 1;
+        pitch = track->cb_color_pitch[id];
+        slice = track->cb_color_slice[id];
+        surf.nbx = (pitch + 1) * 8;
+        surf.nby = ((slice + 1) * 64) / surf.nbx;
+        surf.mode = G_028C70_ARRAY_MODE(track->cb_color_info[id]);
+        surf.format = G_028C70_FORMAT(track->cb_color_info[id]);
+        surf.tsplit = G_028C74_TILE_SPLIT(track->cb_color_attrib[id]);
+        surf.nbanks = G_028C74_NUM_BANKS(track->cb_color_attrib[id]);
+        surf.bankw = G_028C74_BANK_WIDTH(track->cb_color_attrib[id]);
+        surf.bankh = G_028C74_BANK_HEIGHT(track->cb_color_attrib[id]);
+        surf.mtilea = G_028C74_MACRO_TILE_ASPECT(track->cb_color_attrib[id]);
+        surf.nsamples = 1;
+
+        if (!r600_fmt_is_valid_color(surf.format)) {
+                dev_warn(p->dev, "%s:%d cb invalid format %d for %d (0x%08x)\n",
+                         __func__, __LINE__, surf.format,
+                        id, track->cb_color_info[id]);
+                return -EINVAL;
+        }
+
+        r = evergreen_surface_value_conv_check(p, &surf, "cb");
+        if (r) {
+                return r;
+        }
+
+        r = evergreen_surface_check(p, &surf, "cb");
+        if (r) {
+                dev_warn(p->dev, "%s:%d cb[%d] invalid (0x%08x 0x%08x 0x%08x 0x%08x)\n",
+                         __func__, __LINE__, id, track->cb_color_pitch[id],
+                         track->cb_color_slice[id], track->cb_color_attrib[id],
+                         track->cb_color_info[id]);
+                return r;
+        }
+
+        offset = track->cb_color_bo_offset[id] << 8;
+        if (offset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d cb[%d] bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, id, offset, surf.base_align);
+                return -EINVAL;
+        }
+
+        offset += surf.layer_size * mslice;
+        if (offset > radeon_bo_size(track->cb_color_bo[id])) {
+                dev_warn(p->dev, "%s:%d cb[%d] bo too small (layer size %d, "
+                         "offset %d, max layer %d, bo size %ld, slice %d)\n",
+                         __func__, __LINE__, id, surf.layer_size,
+                        track->cb_color_bo_offset[id] << 8, mslice,
+                        radeon_bo_size(track->cb_color_bo[id]), slice);
+                dev_warn(p->dev, "%s:%d problematic surf: (%d %d) (%d %d %d %d %d %d %d)\n",
+                         __func__, __LINE__, surf.nbx, surf.nby,
+                        surf.mode, surf.bpe, surf.nsamples,
+                        surf.bankw, surf.bankh,
+                        surf.tsplit, surf.mtilea);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int evergreen_cs_track_validate_stencil(struct radeon_cs_parser *p)
 {
         struct evergreen_cs_track *track = p->track;
+        struct eg_surface surf;
+        unsigned pitch, slice, mslice;
+        unsigned long offset;
+        int r;
+
+        mslice = G_028008_SLICE_MAX(track->db_depth_view) + 1;
+        pitch = G_028058_PITCH_TILE_MAX(track->db_depth_size);
+        slice = track->db_depth_slice;
+        surf.nbx = (pitch + 1) * 8;
+        surf.nby = ((slice + 1) * 64) / surf.nbx;
+        surf.mode = G_028040_ARRAY_MODE(track->db_z_info);
+        surf.format = G_028044_FORMAT(track->db_s_info);
+        surf.tsplit = G_028044_TILE_SPLIT(track->db_s_info);
+        surf.nbanks = G_028040_NUM_BANKS(track->db_z_info);
+        surf.bankw = G_028040_BANK_WIDTH(track->db_z_info);
+        surf.bankh = G_028040_BANK_HEIGHT(track->db_z_info);
+        surf.mtilea = G_028040_MACRO_TILE_ASPECT(track->db_z_info);
+        surf.nsamples = 1;
+
+        if (surf.format != 1) {
+                dev_warn(p->dev, "%s:%d stencil invalid format %d\n",
+                         __func__, __LINE__, surf.format);
+                return -EINVAL;
+        }
+        /* replace by color format so we can use same code */
+        surf.format = V_028C70_COLOR_8;
+
+        r = evergreen_surface_value_conv_check(p, &surf, "stencil");
+        if (r) {
+                return r;
+        }
+
+        r = evergreen_surface_check(p, &surf, NULL);
+        if (r) {
+                /* old userspace doesn't compute proper depth/stencil alignment
+                 * check that alignment against a bigger byte per elements and
+                 * only report if that alignment is wrong too.
+                 */
+                surf.format = V_028C70_COLOR_8_8_8_8;
+                r = evergreen_surface_check(p, &surf, "stencil");
+                if (r) {
+                        dev_warn(p->dev, "%s:%d stencil invalid (0x%08x 0x%08x 0x%08x 0x%08x)\n",
+                                 __func__, __LINE__, track->db_depth_size,
+                                 track->db_depth_slice, track->db_s_info, track->db_z_info);
+                }
+                return r;
+        }
+
+        offset = track->db_s_read_offset << 8;
+        if (offset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d stencil read bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, offset, surf.base_align);
+                return -EINVAL;
+        }
+        offset += surf.layer_size * mslice;
+        if (offset > radeon_bo_size(track->db_s_read_bo)) {
+                dev_warn(p->dev, "%s:%d stencil read bo too small (layer size %d, "
+                         "offset %ld, max layer %d, bo size %ld)\n",
+                         __func__, __LINE__, surf.layer_size,
+                        (unsigned long)track->db_s_read_offset << 8, mslice,
+                        radeon_bo_size(track->db_s_read_bo));
+                dev_warn(p->dev, "%s:%d stencil invalid (0x%08x 0x%08x 0x%08x 0x%08x)\n",
+                         __func__, __LINE__, track->db_depth_size,
+                         track->db_depth_slice, track->db_s_info, track->db_z_info);
+                return -EINVAL;
+        }
+
+        offset = track->db_s_write_offset << 8;
+        if (offset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d stencil write bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, offset, surf.base_align);
+                return -EINVAL;
+        }
+        offset += surf.layer_size * mslice;
+        if (offset > radeon_bo_size(track->db_s_write_bo)) {
+                dev_warn(p->dev, "%s:%d stencil write bo too small (layer size %d, "
+                         "offset %ld, max layer %d, bo size %ld)\n",
+                         __func__, __LINE__, surf.layer_size,
+                        (unsigned long)track->db_s_write_offset << 8, mslice,
+                        radeon_bo_size(track->db_s_write_bo));
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int evergreen_cs_track_validate_depth(struct radeon_cs_parser *p)
+{
+        struct evergreen_cs_track *track = p->track;
+        struct eg_surface surf;
+        unsigned pitch, slice, mslice;
+        unsigned long offset;
+        int r;
+
+        mslice = G_028008_SLICE_MAX(track->db_depth_view) + 1;
+        pitch = G_028058_PITCH_TILE_MAX(track->db_depth_size);
+        slice = track->db_depth_slice;
+        surf.nbx = (pitch + 1) * 8;
+        surf.nby = ((slice + 1) * 64) / surf.nbx;
+        surf.mode = G_028040_ARRAY_MODE(track->db_z_info);
+        surf.format = G_028040_FORMAT(track->db_z_info);
+        surf.tsplit = G_028040_TILE_SPLIT(track->db_z_info);
+        surf.nbanks = G_028040_NUM_BANKS(track->db_z_info);
+        surf.bankw = G_028040_BANK_WIDTH(track->db_z_info);
+        surf.bankh = G_028040_BANK_HEIGHT(track->db_z_info);
+        surf.mtilea = G_028040_MACRO_TILE_ASPECT(track->db_z_info);
+        surf.nsamples = 1;
+
+        switch (surf.format) {
+        case V_028040_Z_16:
+                surf.format = V_028C70_COLOR_16;
+                break;
+        case V_028040_Z_24:
+        case V_028040_Z_32_FLOAT:
+                surf.format = V_028C70_COLOR_8_8_8_8;
+                break;
+        default:
+                dev_warn(p->dev, "%s:%d depth invalid format %d\n",
+                         __func__, __LINE__, surf.format);
+                return -EINVAL;
+        }
+
+        r = evergreen_surface_value_conv_check(p, &surf, "depth");
+        if (r) {
+                dev_warn(p->dev, "%s:%d depth invalid (0x%08x 0x%08x 0x%08x)\n",
+                         __func__, __LINE__, track->db_depth_size,
+                         track->db_depth_slice, track->db_z_info);
+                return r;
+        }
+
+        r = evergreen_surface_check(p, &surf, "depth");
+        if (r) {
+                dev_warn(p->dev, "%s:%d depth invalid (0x%08x 0x%08x 0x%08x)\n",
+                         __func__, __LINE__, track->db_depth_size,
+                         track->db_depth_slice, track->db_z_info);
+                return r;
+        }
+
+        offset = track->db_z_read_offset << 8;
+        if (offset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d stencil read bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, offset, surf.base_align);
+                return -EINVAL;
+        }
+        offset += surf.layer_size * mslice;
+        if (offset > radeon_bo_size(track->db_z_read_bo)) {
+                dev_warn(p->dev, "%s:%d depth read bo too small (layer size %d, "
+                         "offset %ld, max layer %d, bo size %ld)\n",
+                         __func__, __LINE__, surf.layer_size,
+                        (unsigned long)track->db_z_read_offset << 8, mslice,
+                        radeon_bo_size(track->db_z_read_bo));
+                return -EINVAL;
+        }
+
+        offset = track->db_z_write_offset << 8;
+        if (offset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d stencil write bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, offset, surf.base_align);
+                return -EINVAL;
+        }
+        offset += surf.layer_size * mslice;
+        if (offset > radeon_bo_size(track->db_z_write_bo)) {
+                dev_warn(p->dev, "%s:%d depth write bo too small (layer size %d, "
+                         "offset %ld, max layer %d, bo size %ld)\n",
+                         __func__, __LINE__, surf.layer_size,
+                        (unsigned long)track->db_z_write_offset << 8, mslice,
+                        radeon_bo_size(track->db_z_write_bo));
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int evergreen_cs_track_validate_texture(struct radeon_cs_parser *p,
+                                               struct radeon_bo *texture,
+                                               struct radeon_bo *mipmap,
+                                               unsigned idx)
+{
+        struct eg_surface surf;
+        unsigned long toffset, moffset;
+        unsigned dim, llevel, mslice, width, height, depth, i;
+        u32 texdw[8];
+        int r;
+
+        texdw[0] = radeon_get_ib_value(p, idx + 0);
+        texdw[1] = radeon_get_ib_value(p, idx + 1);
+        texdw[2] = radeon_get_ib_value(p, idx + 2);
+        texdw[3] = radeon_get_ib_value(p, idx + 3);
+        texdw[4] = radeon_get_ib_value(p, idx + 4);
+        texdw[5] = radeon_get_ib_value(p, idx + 5);
+        texdw[6] = radeon_get_ib_value(p, idx + 6);
+        texdw[7] = radeon_get_ib_value(p, idx + 7);
+        dim = G_030000_DIM(texdw[0]);
+        llevel = G_030014_LAST_LEVEL(texdw[5]);
+        mslice = G_030014_LAST_ARRAY(texdw[5]) + 1;
+        width = G_030000_TEX_WIDTH(texdw[0]) + 1;
+        height =  G_030004_TEX_HEIGHT(texdw[1]) + 1;
+        depth = G_030004_TEX_DEPTH(texdw[1]) + 1;
+        surf.format = G_03001C_DATA_FORMAT(texdw[7]);
+        surf.nbx = (G_030000_PITCH(texdw[0]) + 1) * 8;
+        surf.nbx = r600_fmt_get_nblocksx(surf.format, surf.nbx);
+        surf.nby = r600_fmt_get_nblocksy(surf.format, height);
+        surf.mode = G_030004_ARRAY_MODE(texdw[1]);
+        surf.tsplit = G_030018_TILE_SPLIT(texdw[6]);
+        surf.nbanks = G_03001C_NUM_BANKS(texdw[7]);
+        surf.bankw = G_03001C_BANK_WIDTH(texdw[7]);
+        surf.bankh = G_03001C_BANK_HEIGHT(texdw[7]);
+        surf.mtilea = G_03001C_MACRO_TILE_ASPECT(texdw[7]);
+        surf.nsamples = 1;
+        toffset = texdw[2] << 8;
+        moffset = texdw[3] << 8;
 
-        /* we don't support stream out buffer yet */
-        if (track->vgt_strmout_config || track->vgt_strmout_buffer_config) {
-                dev_warn(p->dev, "this kernel doesn't support SMX output buffer\n");
+        if (!r600_fmt_is_valid_texture(surf.format, p->family)) {
+                dev_warn(p->dev, "%s:%d texture invalid format %d\n",
+                         __func__, __LINE__, surf.format);
                 return -EINVAL;
         }
+        switch (dim) {
+        case V_030000_SQ_TEX_DIM_1D:
+        case V_030000_SQ_TEX_DIM_2D:
+        case V_030000_SQ_TEX_DIM_CUBEMAP:
+        case V_030000_SQ_TEX_DIM_1D_ARRAY:
+        case V_030000_SQ_TEX_DIM_2D_ARRAY:
+                depth = 1;
+        case V_030000_SQ_TEX_DIM_3D:
+                break;
+        default:
+                dev_warn(p->dev, "%s:%d texture invalid dimension %d\n",
+                         __func__, __LINE__, dim);
+                return -EINVAL;
+        }
+
+        r = evergreen_surface_value_conv_check(p, &surf, "texture");
+        if (r) {
+                return r;
+        }
+
+        /* align height */
+        evergreen_surface_check(p, &surf, NULL);
+        surf.nby = ALIGN(surf.nby, surf.halign);
+
+        r = evergreen_surface_check(p, &surf, "texture");
+        if (r) {
+                dev_warn(p->dev, "%s:%d texture invalid 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
+                         __func__, __LINE__, texdw[0], texdw[1], texdw[4],
+                         texdw[5], texdw[6], texdw[7]);
+                return r;
+        }
+
+        /* check texture size */
+        if (toffset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d texture bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, toffset, surf.base_align);
+                return -EINVAL;
+        }
+        if (moffset & (surf.base_align - 1)) {
+                dev_warn(p->dev, "%s:%d mipmap bo base %ld not aligned with %ld\n",
+                         __func__, __LINE__, moffset, surf.base_align);
+                return -EINVAL;
+        }
+        if (dim == SQ_TEX_DIM_3D) {
+                toffset += surf.layer_size * depth;
+        } else {
+                toffset += surf.layer_size * mslice;
+        }
+        if (toffset > radeon_bo_size(texture)) {
+                dev_warn(p->dev, "%s:%d texture bo too small (layer size %d, "
+                         "offset %ld, max layer %d, depth %d, bo size %ld) (%d %d)\n",
+                         __func__, __LINE__, surf.layer_size,
+                        (unsigned long)texdw[2] << 8, mslice,
+                        depth, radeon_bo_size(texture),
+                        surf.nbx, surf.nby);
+                return -EINVAL;
+        }
+
+        /* check mipmap size */
+        for (i = 1; i <= llevel; i++) {
+                unsigned w, h, d;
+
+                w = r600_mip_minify(width, i);
+                h = r600_mip_minify(height, i);
+                d = r600_mip_minify(depth, i);
+                surf.nbx = r600_fmt_get_nblocksx(surf.format, w);
+                surf.nby = r600_fmt_get_nblocksy(surf.format, h);
+
+                switch (surf.mode) {
+                case ARRAY_2D_TILED_THIN1:
+                        if (surf.nbx < surf.palign || surf.nby < surf.halign) {
+                                surf.mode = ARRAY_1D_TILED_THIN1;
+                        }
+                        /* recompute alignment */
+                        evergreen_surface_check(p, &surf, NULL);
+                        break;
+                case ARRAY_LINEAR_GENERAL:
+                case ARRAY_LINEAR_ALIGNED:
+                case ARRAY_1D_TILED_THIN1:
+                        break;
+                default:
+                        dev_warn(p->dev, "%s:%d invalid array mode %d\n",
+                                 __func__, __LINE__, surf.mode);
+                        return -EINVAL;
+                }
+                surf.nbx = ALIGN(surf.nbx, surf.palign);
+                surf.nby = ALIGN(surf.nby, surf.halign);
+
+                r = evergreen_surface_check(p, &surf, "mipmap");
+                if (r) {
+                        return r;
+                }
+
+                if (dim == SQ_TEX_DIM_3D) {
+                        moffset += surf.layer_size * d;
+                } else {
+                        moffset += surf.layer_size * mslice;
+                }
+                if (moffset > radeon_bo_size(mipmap)) {
+                        dev_warn(p->dev, "%s:%d mipmap [%d] bo too small (layer size %d, "
+                                        "offset %ld, coffset %ld, max layer %d, depth %d, "
+                                        "bo size %ld) level0 (%d %d %d)\n",
+                                        __func__, __LINE__, i, surf.layer_size,
+                                        (unsigned long)texdw[3] << 8, moffset, mslice,
+                                        d, radeon_bo_size(mipmap),
+                                        width, height, depth);
+                        dev_warn(p->dev, "%s:%d problematic surf: (%d %d) (%d %d %d %d %d %d %d)\n",
+                                 __func__, __LINE__, surf.nbx, surf.nby,
+                                surf.mode, surf.bpe, surf.nsamples,
+                                surf.bankw, surf.bankh,
+                                surf.tsplit, surf.mtilea);
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
+static int evergreen_cs_track_check(struct radeon_cs_parser *p)
+{
+        struct evergreen_cs_track *track = p->track;
+        unsigned tmp, i, j;
+        int r;
+
+        /* check streamout */
+        for (i = 0; i < 4; i++) {
+                if (track->vgt_strmout_config & (1 << i)) {
+                        for (j = 0; j < 4; j++) {
+                                if ((track->vgt_strmout_buffer_config >> (i * 4)) & (1 << j)) {
+                                        if (track->vgt_strmout_bo[j]) {
+                                                u64 offset = (u64)track->vgt_strmout_bo_offset[j] +
+                                                        (u64)track->vgt_strmout_size[j];
+                                                if (offset > radeon_bo_size(track->vgt_strmout_bo[i])) {
+                                                        DRM_ERROR("streamout %d bo too small: 0x%llx, 0x%lx\n",
+                                                                  j, offset,
+                                                                  radeon_bo_size(track->vgt_strmout_bo[j]));
+                                                        return -EINVAL;
+                                                }
+                                        } else {
+                                                dev_warn(p->dev, "No buffer for streamout %d\n", j);
+                                                return -EINVAL;
+                                        }
+                                }
+                        }
+                }
+        }
+
+        /* check that we have a cb for each enabled target
+         */
+        tmp = track->cb_target_mask;
+        for (i = 0; i < 8; i++) {
+                if ((tmp >> (i * 4)) & 0xF) {
+                        /* at least one component is enabled */
+                        if (track->cb_color_bo[i] == NULL) {
+                                dev_warn(p->dev, "%s:%d mask 0x%08X | 0x%08X no cb for %d\n",
+                                        __func__, __LINE__, track->cb_target_mask, track->cb_shader_mask, i);
+                                return -EINVAL;
+                        }
+                        /* check cb */
+                        r = evergreen_cs_track_validate_cb(p, i);
+                        if (r) {
+                                return r;
+                        }
+                }
+        }
+
+        /* Check stencil buffer */
+        if (G_028800_STENCIL_ENABLE(track->db_depth_control)) {
+                r = evergreen_cs_track_validate_stencil(p);
+                if (r)
+                        return r;
+        }
+        /* Check depth buffer */
+        if (G_028800_Z_WRITE_ENABLE(track->db_depth_control)) {
+                r = evergreen_cs_track_validate_depth(p);
+                if (r)
+                        return r;
+        }
 
-        /* XXX fill in */
         return 0;
 }
 
@@ -532,8 +1213,16 @@ static int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
                         ib[idx] |= Z_ARRAY_MODE(evergreen_cs_get_aray_mode(reloc->lobj.tiling_flags));
                         track->db_z_info |= Z_ARRAY_MODE(evergreen_cs_get_aray_mode(reloc->lobj.tiling_flags));
                         if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
+                                unsigned bankw, bankh, mtaspect, tile_split;
+
+                                evergreen_tiling_fields(reloc->lobj.tiling_flags,
+                                                        &bankw, &bankh, &mtaspect,
+                                                        &tile_split);
                                 ib[idx] |= DB_NUM_BANKS(evergreen_cs_get_num_banks(track->nbanks));
-                                ib[idx] |= DB_TILE_SPLIT(evergreen_cs_get_tile_split(track->row_size));
+                                ib[idx] |= DB_TILE_SPLIT(tile_split) |
+                                                DB_BANK_WIDTH(bankw) |
+                                                DB_BANK_HEIGHT(bankh) |
+                                                DB_MACRO_TILE_ASPECT(mtaspect);
                         }
                 }
                 break;
@@ -547,6 +1236,9 @@ static int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
                 track->db_depth_size = radeon_get_ib_value(p, idx);
                 track->db_depth_size_idx = idx;
                 break;
+        case R_02805C_DB_DEPTH_SLICE:
+                track->db_depth_slice = radeon_get_ib_value(p, idx);
+                break;
         case DB_Z_READ_BASE:
                 r = evergreen_cs_packet_next_reloc(p, &reloc);
                 if (r) {
@@ -597,6 +1289,38 @@ static int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
         case VGT_STRMOUT_BUFFER_CONFIG:
                 track->vgt_strmout_buffer_config = radeon_get_ib_value(p, idx);
                 break;
+        case VGT_STRMOUT_BUFFER_BASE_0:
+        case VGT_STRMOUT_BUFFER_BASE_1:
+        case VGT_STRMOUT_BUFFER_BASE_2:
+        case VGT_STRMOUT_BUFFER_BASE_3:
+                r = evergreen_cs_packet_next_reloc(p, &reloc);
+                if (r) {
+                        dev_warn(p->dev, "bad SET_CONTEXT_REG "
+                                        "0x%04X\n", reg);
+                        return -EINVAL;
+                }
+                tmp = (reg - VGT_STRMOUT_BUFFER_BASE_0) / 16;
+                track->vgt_strmout_bo_offset[tmp] = radeon_get_ib_value(p, idx) << 8;
+                ib[idx] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                track->vgt_strmout_bo[tmp] = reloc->robj;
+                track->vgt_strmout_bo_mc[tmp] = reloc->lobj.gpu_offset;
+                break;
+        case VGT_STRMOUT_BUFFER_SIZE_0:
+        case VGT_STRMOUT_BUFFER_SIZE_1:
+        case VGT_STRMOUT_BUFFER_SIZE_2:
+        case VGT_STRMOUT_BUFFER_SIZE_3:
+                tmp = (reg - VGT_STRMOUT_BUFFER_SIZE_0) / 16;
+                /* size in register is DWs, convert to bytes */
+                track->vgt_strmout_size[tmp] = radeon_get_ib_value(p, idx) * 4;
+                break;
+        case CP_COHER_BASE:
+                r = evergreen_cs_packet_next_reloc(p, &reloc);
+                if (r) {
+                        dev_warn(p->dev, "missing reloc for CP_COHER_BASE "
+                                        "0x%04X\n", reg);
+                        return -EINVAL;
+                }
+                ib[idx] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
         case CB_TARGET_MASK:
                 track->cb_target_mask = radeon_get_ib_value(p, idx);
                 break;
@@ -725,6 +1449,29 @@ static int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
         case CB_COLOR5_ATTRIB:
         case CB_COLOR6_ATTRIB:
         case CB_COLOR7_ATTRIB:
+                r = evergreen_cs_packet_next_reloc(p, &reloc);
+                if (r) {
+                        dev_warn(p->dev, "bad SET_CONTEXT_REG "
+                                        "0x%04X\n", reg);
+                        return -EINVAL;
+                }
+                if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
+                                unsigned bankw, bankh, mtaspect, tile_split;
+
+                                evergreen_tiling_fields(reloc->lobj.tiling_flags,
+                                                        &bankw, &bankh, &mtaspect,
+                                                        &tile_split);
+                                ib[idx] |= CB_NUM_BANKS(evergreen_cs_get_num_banks(track->nbanks));
+                                ib[idx] |= CB_TILE_SPLIT(tile_split) |
+                                           CB_BANK_WIDTH(bankw) |
+                                           CB_BANK_HEIGHT(bankh) |
+                                           CB_MACRO_TILE_ASPECT(mtaspect);
+                        }
+                }
+                tmp = ((reg - CB_COLOR0_ATTRIB) / 0x3c);
+                track->cb_color_attrib[tmp] = ib[idx];
+                break;
         case CB_COLOR8_ATTRIB:
         case CB_COLOR9_ATTRIB:
         case CB_COLOR10_ATTRIB:
@@ -735,10 +1482,22 @@ static int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
                                         "0x%04X\n", reg);
                         return -EINVAL;
                 }
-                if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
-                        ib[idx] |= CB_NUM_BANKS(evergreen_cs_get_num_banks(track->nbanks));
-                        ib[idx] |= CB_TILE_SPLIT(evergreen_cs_get_tile_split(track->row_size));
+                if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
+                                unsigned bankw, bankh, mtaspect, tile_split;
+
+                                evergreen_tiling_fields(reloc->lobj.tiling_flags,
+                                                        &bankw, &bankh, &mtaspect,
+                                                        &tile_split);
+                                ib[idx] |= CB_NUM_BANKS(evergreen_cs_get_num_banks(track->nbanks));
+                                ib[idx] |= CB_TILE_SPLIT(tile_split) |
+                                           CB_BANK_WIDTH(bankw) |
+                                           CB_BANK_HEIGHT(bankh) |
+                                           CB_MACRO_TILE_ASPECT(mtaspect);
+                        }
                 }
+                tmp = ((reg - CB_COLOR8_ATTRIB) / 0x1c) + 8;
+                track->cb_color_attrib[tmp] = ib[idx];
                 break;
         case CB_COLOR0_DIM:
         case CB_COLOR1_DIM:
@@ -996,22 +1755,30 @@ static int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
         return 0;
 }
 
-/**
- * evergreen_check_texture_resource() - check if register is authorized or not
- * @p: parser structure holding parsing context
- * @idx: index into the cs buffer
- * @texture: texture's bo structure
- * @mipmap: mipmap's bo structure
- *
- * This function will check that the resource has valid field and that
- * the texture and mipmap bo object are big enough to cover this resource.
- */
-static int evergreen_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
-                                                   struct radeon_bo *texture,
-                                                   struct radeon_bo *mipmap)
+static bool evergreen_is_safe_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
 {
-        /* XXX fill in */
-        return 0;
+        u32 last_reg, m, i;
+
+        if (p->rdev->family >= CHIP_CAYMAN)
+                last_reg = ARRAY_SIZE(cayman_reg_safe_bm);
+        else
+                last_reg = ARRAY_SIZE(evergreen_reg_safe_bm);
+
+        i = (reg >> 7);
+        if (i >= last_reg) {
+                dev_warn(p->dev, "forbidden register 0x%08x at %d\n", reg, idx);
+                return false;
+        }
+        m = 1 << ((reg >> 2) & 31);
+        if (p->rdev->family >= CHIP_CAYMAN) {
+                if (!(cayman_reg_safe_bm[i] & m))
+                        return true;
+        } else {
+                if (!(evergreen_reg_safe_bm[i] & m))
+                        return true;
+        }
+        dev_warn(p->dev, "forbidden register 0x%08x at %d\n", reg, idx);
+        return false;
 }
 
 static int evergreen_packet3_check(struct radeon_cs_parser *p,
@@ -1344,6 +2111,7 @@ static int evergreen_packet3_check(struct radeon_cs_parser *p,
                 }
                 for (i = 0; i < (pkt->count / 8); i++) {
                         struct radeon_bo *texture, *mipmap;
+                        u32 toffset, moffset;
                         u32 size, offset;
 
                         switch (G__SQ_CONSTANT_TYPE(radeon_get_ib_value(p, idx+1+(i*8)+7))) {
@@ -1354,30 +2122,38 @@ static int evergreen_packet3_check(struct radeon_cs_parser *p,
                                         DRM_ERROR("bad SET_RESOURCE (tex)\n");
                                         return -EINVAL;
                                 }
-                                ib[idx+1+(i*8)+2] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                                 if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
                                         ib[idx+1+(i*8)+1] |=
                                                 TEX_ARRAY_MODE(evergreen_cs_get_aray_mode(reloc->lobj.tiling_flags));
                                         if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
-                                                ib[idx+1+(i*8)+6] |=
-                                                        TEX_TILE_SPLIT(evergreen_cs_get_tile_split(track->row_size));
+                                                unsigned bankw, bankh, mtaspect, tile_split;
+
+                                                evergreen_tiling_fields(reloc->lobj.tiling_flags,
+                                                                        &bankw, &bankh, &mtaspect,
+                                                                        &tile_split);
+                                                ib[idx+1+(i*8)+6] |= TEX_TILE_SPLIT(tile_split);
                                                 ib[idx+1+(i*8)+7] |=
+                                                        TEX_BANK_WIDTH(bankw) |
+                                                        TEX_BANK_HEIGHT(bankh) |
+                                                        MACRO_TILE_ASPECT(mtaspect) |
                                                         TEX_NUM_BANKS(evergreen_cs_get_num_banks(track->nbanks));
                                         }
                                 }
                                 texture = reloc->robj;
+                                toffset = (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                                 /* tex mip base */
                                 r = evergreen_cs_packet_next_reloc(p, &reloc);
                                 if (r) {
                                         DRM_ERROR("bad SET_RESOURCE (tex)\n");
                                         return -EINVAL;
                                 }
-                                ib[idx+1+(i*8)+3] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                moffset = (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                                 mipmap = reloc->robj;
-                                r = evergreen_check_texture_resource(p,  idx+1+(i*8),
-                                                texture, mipmap);
+                                r = evergreen_cs_track_validate_texture(p, texture, mipmap, idx+1+(i*8));
                                 if (r)
                                         return r;
+                                ib[idx+1+(i*8)+2] += toffset;
+                                ib[idx+1+(i*8)+3] += moffset;
                                 break;
                         case SQ_TEX_VTX_VALID_BUFFER:
                                 /* vtx base */
@@ -1451,6 +2227,100 @@ static int evergreen_packet3_check(struct radeon_cs_parser *p,
                         return -EINVAL;
                 }
                 break;
+        case PACKET3_STRMOUT_BUFFER_UPDATE:
+                if (pkt->count != 4) {
+                        DRM_ERROR("bad STRMOUT_BUFFER_UPDATE (invalid count)\n");
+                        return -EINVAL;
+                }
+                /* Updating memory at DST_ADDRESS. */
+                if (idx_value & 0x1) {
+                        u64 offset;
+                        r = evergreen_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE (missing dst reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+1);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+2) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE dst bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+1] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+2] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                }
+                /* Reading data from SRC_ADDRESS. */
+                if (((idx_value >> 1) & 0x3) == 2) {
+                        u64 offset;
+                        r = evergreen_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE (missing src reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+3);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+4) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE src bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+3] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+4] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                }
+                break;
+        case PACKET3_COPY_DW:
+                if (pkt->count != 4) {
+                        DRM_ERROR("bad COPY_DW (invalid count)\n");
+                        return -EINVAL;
+                }
+                if (idx_value & 0x1) {
+                        u64 offset;
+                        /* SRC is memory. */
+                        r = evergreen_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad COPY_DW (missing src reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+1);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+2) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad COPY_DW src bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+1] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+2] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                } else {
+                        /* SRC is a reg. */
+                        reg = radeon_get_ib_value(p, idx+1) << 2;
+                        if (!evergreen_is_safe_reg(p, reg, idx+1))
+                                return -EINVAL;
+                }
+                if (idx_value & 0x2) {
+                        u64 offset;
+                        /* DST is memory. */
+                        r = evergreen_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad COPY_DW (missing dst reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+3);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+4) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad COPY_DW dst bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+3] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+4] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                } else {
+                        /* DST is a reg. */
+                        reg = radeon_get_ib_value(p, idx+3) << 2;
+                        if (!evergreen_is_safe_reg(p, reg, idx+3))
+                                return -EINVAL;
+                }
+                break;
         case PACKET3_NOP:
                 break;
         default:
diff --git a/drivers/gpu/drm/radeon/evergreend.h b/drivers/gpu/drm/radeon/evergreend.h
index 74713d42df29..eb5708c7159d 100644
--- a/drivers/gpu/drm/radeon/evergreend.h
+++ b/drivers/gpu/drm/radeon/evergreend.h
@@ -77,6 +77,7 @@
 
 #define CONFIG_MEMSIZE                                  0x5428
 
+#define CP_COHER_BASE                                   0x85F8
 #define CP_ME_CNTL                                      0x86D8
 #define         CP_ME_HALT                                      (1 << 28)
 #define         CP_PFP_HALT                                     (1 << 26)
@@ -925,7 +926,70 @@
 #define DB_DEBUG4                                       0x983C
 #define DB_WATERMARKS                                   0x9854
 #define DB_DEPTH_CONTROL                                0x28800
+#define R_028800_DB_DEPTH_CONTROL                    0x028800
+#define   S_028800_STENCIL_ENABLE(x)                   (((x) & 0x1) << 0)
+#define   G_028800_STENCIL_ENABLE(x)                   (((x) >> 0) & 0x1)
+#define   C_028800_STENCIL_ENABLE                      0xFFFFFFFE
+#define   S_028800_Z_ENABLE(x)                         (((x) & 0x1) << 1)
+#define   G_028800_Z_ENABLE(x)                         (((x) >> 1) & 0x1)
+#define   C_028800_Z_ENABLE                            0xFFFFFFFD
+#define   S_028800_Z_WRITE_ENABLE(x)                   (((x) & 0x1) << 2)
+#define   G_028800_Z_WRITE_ENABLE(x)                   (((x) >> 2) & 0x1)
+#define   C_028800_Z_WRITE_ENABLE                      0xFFFFFFFB
+#define   S_028800_ZFUNC(x)                            (((x) & 0x7) << 4)
+#define   G_028800_ZFUNC(x)                            (((x) >> 4) & 0x7)
+#define   C_028800_ZFUNC                               0xFFFFFF8F
+#define   S_028800_BACKFACE_ENABLE(x)                  (((x) & 0x1) << 7)
+#define   G_028800_BACKFACE_ENABLE(x)                  (((x) >> 7) & 0x1)
+#define   C_028800_BACKFACE_ENABLE                     0xFFFFFF7F
+#define   S_028800_STENCILFUNC(x)                      (((x) & 0x7) << 8)
+#define   G_028800_STENCILFUNC(x)                      (((x) >> 8) & 0x7)
+#define   C_028800_STENCILFUNC                         0xFFFFF8FF
+#define     V_028800_STENCILFUNC_NEVER                 0x00000000
+#define     V_028800_STENCILFUNC_LESS                  0x00000001
+#define     V_028800_STENCILFUNC_EQUAL                 0x00000002
+#define     V_028800_STENCILFUNC_LEQUAL                0x00000003
+#define     V_028800_STENCILFUNC_GREATER               0x00000004
+#define     V_028800_STENCILFUNC_NOTEQUAL              0x00000005
+#define     V_028800_STENCILFUNC_GEQUAL                0x00000006
+#define     V_028800_STENCILFUNC_ALWAYS                0x00000007
+#define   S_028800_STENCILFAIL(x)                      (((x) & 0x7) << 11)
+#define   G_028800_STENCILFAIL(x)                      (((x) >> 11) & 0x7)
+#define   C_028800_STENCILFAIL                         0xFFFFC7FF
+#define     V_028800_STENCIL_KEEP                      0x00000000
+#define     V_028800_STENCIL_ZERO                      0x00000001
+#define     V_028800_STENCIL_REPLACE                   0x00000002
+#define     V_028800_STENCIL_INCR                      0x00000003
+#define     V_028800_STENCIL_DECR                      0x00000004
+#define     V_028800_STENCIL_INVERT                    0x00000005
+#define     V_028800_STENCIL_INCR_WRAP                 0x00000006
+#define     V_028800_STENCIL_DECR_WRAP                 0x00000007
+#define   S_028800_STENCILZPASS(x)                     (((x) & 0x7) << 14)
+#define   G_028800_STENCILZPASS(x)                     (((x) >> 14) & 0x7)
+#define   C_028800_STENCILZPASS                        0xFFFE3FFF
+#define   S_028800_STENCILZFAIL(x)                     (((x) & 0x7) << 17)
+#define   G_028800_STENCILZFAIL(x)                     (((x) >> 17) & 0x7)
+#define   C_028800_STENCILZFAIL                        0xFFF1FFFF
+#define   S_028800_STENCILFUNC_BF(x)                   (((x) & 0x7) << 20)
+#define   G_028800_STENCILFUNC_BF(x)                   (((x) >> 20) & 0x7)
+#define   C_028800_STENCILFUNC_BF                      0xFF8FFFFF
+#define   S_028800_STENCILFAIL_BF(x)                   (((x) & 0x7) << 23)
+#define   G_028800_STENCILFAIL_BF(x)                   (((x) >> 23) & 0x7)
+#define   C_028800_STENCILFAIL_BF                      0xFC7FFFFF
+#define   S_028800_STENCILZPASS_BF(x)                  (((x) & 0x7) << 26)
+#define   G_028800_STENCILZPASS_BF(x)                  (((x) >> 26) & 0x7)
+#define   C_028800_STENCILZPASS_BF                     0xE3FFFFFF
+#define   S_028800_STENCILZFAIL_BF(x)                  (((x) & 0x7) << 29)
+#define   G_028800_STENCILZFAIL_BF(x)                  (((x) >> 29) & 0x7)
+#define   C_028800_STENCILZFAIL_BF                     0x1FFFFFFF
 #define DB_DEPTH_VIEW                                   0x28008
+#define R_028008_DB_DEPTH_VIEW                       0x00028008
+#define   S_028008_SLICE_START(x)                      (((x) & 0x7FF) << 0)
+#define   G_028008_SLICE_START(x)                      (((x) >> 0) & 0x7FF)
+#define   C_028008_SLICE_START                         0xFFFFF800
+#define   S_028008_SLICE_MAX(x)                        (((x) & 0x7FF) << 13)
+#define   G_028008_SLICE_MAX(x)                        (((x) >> 13) & 0x7FF)
+#define   C_028008_SLICE_MAX                           0xFF001FFF
 #define DB_HTILE_DATA_BASE                              0x28014
 #define DB_Z_INFO                                       0x28040
 #       define Z_ARRAY_MODE(x)                          ((x) << 4)
@@ -933,12 +997,59 @@
 #       define DB_NUM_BANKS(x)                          (((x) & 0x3) << 12)
 #       define DB_BANK_WIDTH(x)                         (((x) & 0x3) << 16)
 #       define DB_BANK_HEIGHT(x)                        (((x) & 0x3) << 20)
+#       define DB_MACRO_TILE_ASPECT(x)                  (((x) & 0x3) << 24)
+#define R_028040_DB_Z_INFO                       0x028040
+#define   S_028040_FORMAT(x)                           (((x) & 0x3) << 0)
+#define   G_028040_FORMAT(x)                           (((x) >> 0) & 0x3)
+#define   C_028040_FORMAT                              0xFFFFFFFC
+#define     V_028040_Z_INVALID                     0x00000000
+#define     V_028040_Z_16                          0x00000001
+#define     V_028040_Z_24                          0x00000002
+#define     V_028040_Z_32_FLOAT                    0x00000003
+#define   S_028040_ARRAY_MODE(x)                       (((x) & 0xF) << 4)
+#define   G_028040_ARRAY_MODE(x)                       (((x) >> 4) & 0xF)
+#define   C_028040_ARRAY_MODE                          0xFFFFFF0F
+#define   S_028040_READ_SIZE(x)                        (((x) & 0x1) << 28)
+#define   G_028040_READ_SIZE(x)                        (((x) >> 28) & 0x1)
+#define   C_028040_READ_SIZE                           0xEFFFFFFF
+#define   S_028040_TILE_SURFACE_ENABLE(x)              (((x) & 0x1) << 29)
+#define   G_028040_TILE_SURFACE_ENABLE(x)              (((x) >> 29) & 0x1)
+#define   C_028040_TILE_SURFACE_ENABLE                 0xDFFFFFFF
+#define   S_028040_ZRANGE_PRECISION(x)                 (((x) & 0x1) << 31)
+#define   G_028040_ZRANGE_PRECISION(x)                 (((x) >> 31) & 0x1)
+#define   C_028040_ZRANGE_PRECISION                    0x7FFFFFFF
+#define   S_028040_TILE_SPLIT(x)                       (((x) & 0x7) << 8)
+#define   G_028040_TILE_SPLIT(x)                       (((x) >> 8) & 0x7)
+#define   S_028040_NUM_BANKS(x)                        (((x) & 0x3) << 12)
+#define   G_028040_NUM_BANKS(x)                        (((x) >> 12) & 0x3)
+#define   S_028040_BANK_WIDTH(x)                       (((x) & 0x3) << 16)
+#define   G_028040_BANK_WIDTH(x)                       (((x) >> 16) & 0x3)
+#define   S_028040_BANK_HEIGHT(x)                      (((x) & 0x3) << 20)
+#define   G_028040_BANK_HEIGHT(x)                      (((x) >> 20) & 0x3)
+#define   S_028040_MACRO_TILE_ASPECT(x)                (((x) & 0x3) << 24)
+#define   G_028040_MACRO_TILE_ASPECT(x)                (((x) >> 24) & 0x3)
 #define DB_STENCIL_INFO                                 0x28044
+#define R_028044_DB_STENCIL_INFO                     0x028044
+#define   S_028044_FORMAT(x)                           (((x) & 0x1) << 0)
+#define   G_028044_FORMAT(x)                           (((x) >> 0) & 0x1)
+#define   C_028044_FORMAT                              0xFFFFFFFE
+#define   G_028044_TILE_SPLIT(x)                       (((x) >> 8) & 0x7)
 #define DB_Z_READ_BASE                                  0x28048
 #define DB_STENCIL_READ_BASE                            0x2804c
 #define DB_Z_WRITE_BASE                                 0x28050
 #define DB_STENCIL_WRITE_BASE                           0x28054
 #define DB_DEPTH_SIZE                                   0x28058
+#define R_028058_DB_DEPTH_SIZE                       0x028058
+#define   S_028058_PITCH_TILE_MAX(x)                   (((x) & 0x7FF) << 0)
+#define   G_028058_PITCH_TILE_MAX(x)                   (((x) >> 0) & 0x7FF)
+#define   C_028058_PITCH_TILE_MAX                      0xFFFFF800
+#define   S_028058_HEIGHT_TILE_MAX(x)                   (((x) & 0x7FF) << 11)
+#define   G_028058_HEIGHT_TILE_MAX(x)                   (((x) >> 11) & 0x7FF)
+#define   C_028058_HEIGHT_TILE_MAX                      0xFFC007FF
+#define R_02805C_DB_DEPTH_SLICE                      0x02805C
+#define   S_02805C_SLICE_TILE_MAX(x)                   (((x) & 0x3FFFFF) << 0)
+#define   G_02805C_SLICE_TILE_MAX(x)                   (((x) >> 0) & 0x3FFFFF)
+#define   C_02805C_SLICE_TILE_MAX                      0xFFC00000
 
 #define SQ_PGM_START_PS                                 0x28840
 #define SQ_PGM_START_VS                                 0x2885c
@@ -948,6 +1059,14 @@
 #define SQ_PGM_START_HS                                 0x288b8
 #define SQ_PGM_START_LS                                 0x288d0
 
+#define VGT_STRMOUT_BUFFER_BASE_0                       0x28AD8
+#define VGT_STRMOUT_BUFFER_BASE_1                       0x28AE8
+#define VGT_STRMOUT_BUFFER_BASE_2                       0x28AF8
+#define VGT_STRMOUT_BUFFER_BASE_3                       0x28B08
+#define VGT_STRMOUT_BUFFER_SIZE_0                       0x28AD0
+#define VGT_STRMOUT_BUFFER_SIZE_1                       0x28AE0
+#define VGT_STRMOUT_BUFFER_SIZE_2                       0x28AF0
+#define VGT_STRMOUT_BUFFER_SIZE_3                       0x28B00
 #define VGT_STRMOUT_CONFIG                              0x28b94
 #define VGT_STRMOUT_BUFFER_CONFIG                       0x28b98
 
@@ -974,6 +1093,114 @@
 #define CB_COLOR0_PITCH                                 0x28c64
 #define CB_COLOR0_SLICE                                 0x28c68
 #define CB_COLOR0_VIEW                                  0x28c6c
+#define R_028C6C_CB_COLOR0_VIEW                      0x00028C6C
+#define   S_028C6C_SLICE_START(x)                      (((x) & 0x7FF) << 0)
+#define   G_028C6C_SLICE_START(x)                      (((x) >> 0) & 0x7FF)
+#define   C_028C6C_SLICE_START                         0xFFFFF800
+#define   S_028C6C_SLICE_MAX(x)                        (((x) & 0x7FF) << 13)
+#define   G_028C6C_SLICE_MAX(x)                        (((x) >> 13) & 0x7FF)
+#define   C_028C6C_SLICE_MAX                           0xFF001FFF
+#define R_028C70_CB_COLOR0_INFO                      0x028C70
+#define   S_028C70_ENDIAN(x)                           (((x) & 0x3) << 0)
+#define   G_028C70_ENDIAN(x)                           (((x) >> 0) & 0x3)
+#define   C_028C70_ENDIAN                              0xFFFFFFFC
+#define   S_028C70_FORMAT(x)                           (((x) & 0x3F) << 2)
+#define   G_028C70_FORMAT(x)                           (((x) >> 2) & 0x3F)
+#define   C_028C70_FORMAT                              0xFFFFFF03
+#define     V_028C70_COLOR_INVALID                     0x00000000
+#define     V_028C70_COLOR_8                           0x00000001
+#define     V_028C70_COLOR_4_4                         0x00000002
+#define     V_028C70_COLOR_3_3_2                       0x00000003
+#define     V_028C70_COLOR_16                          0x00000005
+#define     V_028C70_COLOR_16_FLOAT                    0x00000006
+#define     V_028C70_COLOR_8_8                         0x00000007
+#define     V_028C70_COLOR_5_6_5                       0x00000008
+#define     V_028C70_COLOR_6_5_5                       0x00000009
+#define     V_028C70_COLOR_1_5_5_5                     0x0000000A
+#define     V_028C70_COLOR_4_4_4_4                     0x0000000B
+#define     V_028C70_COLOR_5_5_5_1                     0x0000000C
+#define     V_028C70_COLOR_32                          0x0000000D
+#define     V_028C70_COLOR_32_FLOAT                    0x0000000E
+#define     V_028C70_COLOR_16_16                       0x0000000F
+#define     V_028C70_COLOR_16_16_FLOAT                 0x00000010
+#define     V_028C70_COLOR_8_24                        0x00000011
+#define     V_028C70_COLOR_8_24_FLOAT                  0x00000012
+#define     V_028C70_COLOR_24_8                        0x00000013
+#define     V_028C70_COLOR_24_8_FLOAT                  0x00000014
+#define     V_028C70_COLOR_10_11_11                    0x00000015
+#define     V_028C70_COLOR_10_11_11_FLOAT              0x00000016
+#define     V_028C70_COLOR_11_11_10                    0x00000017
+#define     V_028C70_COLOR_11_11_10_FLOAT              0x00000018
+#define     V_028C70_COLOR_2_10_10_10                  0x00000019
+#define     V_028C70_COLOR_8_8_8_8                     0x0000001A
+#define     V_028C70_COLOR_10_10_10_2                  0x0000001B
+#define     V_028C70_COLOR_X24_8_32_FLOAT              0x0000001C
+#define     V_028C70_COLOR_32_32                       0x0000001D
+#define     V_028C70_COLOR_32_32_FLOAT                 0x0000001E
+#define     V_028C70_COLOR_16_16_16_16                 0x0000001F
+#define     V_028C70_COLOR_16_16_16_16_FLOAT           0x00000020
+#define     V_028C70_COLOR_32_32_32_32                 0x00000022
+#define     V_028C70_COLOR_32_32_32_32_FLOAT           0x00000023
+#define     V_028C70_COLOR_32_32_32_FLOAT              0x00000030
+#define   S_028C70_ARRAY_MODE(x)                       (((x) & 0xF) << 8)
+#define   G_028C70_ARRAY_MODE(x)                       (((x) >> 8) & 0xF)
+#define   C_028C70_ARRAY_MODE                          0xFFFFF0FF
+#define     V_028C70_ARRAY_LINEAR_GENERAL              0x00000000
+#define     V_028C70_ARRAY_LINEAR_ALIGNED              0x00000001
+#define     V_028C70_ARRAY_1D_TILED_THIN1              0x00000002
+#define     V_028C70_ARRAY_2D_TILED_THIN1              0x00000004
+#define   S_028C70_NUMBER_TYPE(x)                      (((x) & 0x7) << 12)
+#define   G_028C70_NUMBER_TYPE(x)                      (((x) >> 12) & 0x7)
+#define   C_028C70_NUMBER_TYPE                         0xFFFF8FFF
+#define     V_028C70_NUMBER_UNORM                      0x00000000
+#define     V_028C70_NUMBER_SNORM                      0x00000001
+#define     V_028C70_NUMBER_USCALED                    0x00000002
+#define     V_028C70_NUMBER_SSCALED                    0x00000003
+#define     V_028C70_NUMBER_UINT                       0x00000004
+#define     V_028C70_NUMBER_SINT                       0x00000005
+#define     V_028C70_NUMBER_SRGB                       0x00000006
+#define     V_028C70_NUMBER_FLOAT                      0x00000007
+#define   S_028C70_COMP_SWAP(x)                        (((x) & 0x3) << 15)
+#define   G_028C70_COMP_SWAP(x)                        (((x) >> 15) & 0x3)
+#define   C_028C70_COMP_SWAP                           0xFFFE7FFF
+#define     V_028C70_SWAP_STD                          0x00000000
+#define     V_028C70_SWAP_ALT                          0x00000001
+#define     V_028C70_SWAP_STD_REV                      0x00000002
+#define     V_028C70_SWAP_ALT_REV                      0x00000003
+#define   S_028C70_FAST_CLEAR(x)                       (((x) & 0x1) << 17)
+#define   G_028C70_FAST_CLEAR(x)                       (((x) >> 17) & 0x1)
+#define   C_028C70_FAST_CLEAR                          0xFFFDFFFF
+#define   S_028C70_COMPRESSION(x)                      (((x) & 0x3) << 18)
+#define   G_028C70_COMPRESSION(x)                      (((x) >> 18) & 0x3)
+#define   C_028C70_COMPRESSION                         0xFFF3FFFF
+#define   S_028C70_BLEND_CLAMP(x)                      (((x) & 0x1) << 19)
+#define   G_028C70_BLEND_CLAMP(x)                      (((x) >> 19) & 0x1)
+#define   C_028C70_BLEND_CLAMP                         0xFFF7FFFF
+#define   S_028C70_BLEND_BYPASS(x)                     (((x) & 0x1) << 20)
+#define   G_028C70_BLEND_BYPASS(x)                     (((x) >> 20) & 0x1)
+#define   C_028C70_BLEND_BYPASS                        0xFFEFFFFF
+#define   S_028C70_SIMPLE_FLOAT(x)                     (((x) & 0x1) << 21)
+#define   G_028C70_SIMPLE_FLOAT(x)                     (((x) >> 21) & 0x1)
+#define   C_028C70_SIMPLE_FLOAT                        0xFFDFFFFF
+#define   S_028C70_ROUND_MODE(x)                       (((x) & 0x1) << 22)
+#define   G_028C70_ROUND_MODE(x)                       (((x) >> 22) & 0x1)
+#define   C_028C70_ROUND_MODE                          0xFFBFFFFF
+#define   S_028C70_TILE_COMPACT(x)                     (((x) & 0x1) << 23)
+#define   G_028C70_TILE_COMPACT(x)                     (((x) >> 23) & 0x1)
+#define   C_028C70_TILE_COMPACT                        0xFF7FFFFF
+#define   S_028C70_SOURCE_FORMAT(x)                    (((x) & 0x3) << 24)
+#define   G_028C70_SOURCE_FORMAT(x)                    (((x) >> 24) & 0x3)
+#define   C_028C70_SOURCE_FORMAT                       0xFCFFFFFF
+#define     V_028C70_EXPORT_4C_32BPC                   0x0
+#define     V_028C70_EXPORT_4C_16BPC                   0x1
+#define     V_028C70_EXPORT_2C_32BPC                   0x2 /* Do not use */
+#define   S_028C70_RAT(x)                              (((x) & 0x1) << 26)
+#define   G_028C70_RAT(x)                              (((x) >> 26) & 0x1)
+#define   C_028C70_RAT                                 0xFBFFFFFF
+#define   S_028C70_RESOURCE_TYPE(x)                    (((x) & 0x7) << 27)
+#define   G_028C70_RESOURCE_TYPE(x)                    (((x) >> 27) & 0x7)
+#define   C_028C70_RESOURCE_TYPE                       0xC7FFFFFF
+
 #define CB_COLOR0_INFO                                  0x28c70
 #       define CB_FORMAT(x)                             ((x) << 2)
 #       define CB_ARRAY_MODE(x)                         ((x) << 8)
@@ -984,6 +1211,20 @@
 #       define CB_SOURCE_FORMAT(x)                      ((x) << 24)
 #       define CB_SF_EXPORT_FULL                        0
 #       define CB_SF_EXPORT_NORM                        1
+#define R_028C74_CB_COLOR0_ATTRIB                      0x028C74
+#define   S_028C74_NON_DISP_TILING_ORDER(x)            (((x) & 0x1) << 4)
+#define   G_028C74_NON_DISP_TILING_ORDER(x)            (((x) >> 4) & 0x1)
+#define   C_028C74_NON_DISP_TILING_ORDER               0xFFFFFFEF
+#define   S_028C74_TILE_SPLIT(x)                       (((x) & 0xf) << 5)
+#define   G_028C74_TILE_SPLIT(x)                       (((x) >> 5) & 0xf)
+#define   S_028C74_NUM_BANKS(x)                        (((x) & 0x3) << 10)
+#define   G_028C74_NUM_BANKS(x)                        (((x) >> 10) & 0x3)
+#define   S_028C74_BANK_WIDTH(x)                       (((x) & 0x3) << 13)
+#define   G_028C74_BANK_WIDTH(x)                       (((x) >> 13) & 0x3)
+#define   S_028C74_BANK_HEIGHT(x)                      (((x) & 0x3) << 16)
+#define   G_028C74_BANK_HEIGHT(x)                      (((x) >> 16) & 0x3)
+#define   S_028C74_MACRO_TILE_ASPECT(x)                (((x) & 0x3) << 19)
+#define   G_028C74_MACRO_TILE_ASPECT(x)                (((x) >> 19) & 0x3)
 #define CB_COLOR0_ATTRIB                                0x28c74
 #       define CB_TILE_SPLIT(x)                         (((x) & 0x7) << 5)
 #       define ADDR_SURF_TILE_SPLIT_64B                 0
@@ -1008,6 +1249,7 @@
 #       define ADDR_SURF_BANK_HEIGHT_2                  1
 #       define ADDR_SURF_BANK_HEIGHT_4                  2
 #       define ADDR_SURF_BANK_HEIGHT_8                  3
+#       define CB_MACRO_TILE_ASPECT(x)                  (((x) & 0x3) << 19)
 #define CB_COLOR0_DIM                                   0x28c78
 /* only CB0-7 blocks have these regs */
 #define CB_COLOR0_CMASK                                 0x28c7c
@@ -1196,9 +1438,144 @@
 #define SQ_TEX_RESOURCE_WORD6_0                         0x30018
 #       define TEX_TILE_SPLIT(x)                        (((x) & 0x7) << 29)
 #define SQ_TEX_RESOURCE_WORD7_0                         0x3001c
+#       define MACRO_TILE_ASPECT(x)                     (((x) & 0x3) << 6)
 #       define TEX_BANK_WIDTH(x)                        (((x) & 0x3) << 8)
 #       define TEX_BANK_HEIGHT(x)                       (((x) & 0x3) << 10)
 #       define TEX_NUM_BANKS(x)                         (((x) & 0x3) << 16)
+#define R_030000_SQ_TEX_RESOURCE_WORD0_0             0x030000
+#define   S_030000_DIM(x)                              (((x) & 0x7) << 0)
+#define   G_030000_DIM(x)                              (((x) >> 0) & 0x7)
+#define   C_030000_DIM                                 0xFFFFFFF8
+#define     V_030000_SQ_TEX_DIM_1D                     0x00000000
+#define     V_030000_SQ_TEX_DIM_2D                     0x00000001
+#define     V_030000_SQ_TEX_DIM_3D                     0x00000002
+#define     V_030000_SQ_TEX_DIM_CUBEMAP                0x00000003
+#define     V_030000_SQ_TEX_DIM_1D_ARRAY               0x00000004
+#define     V_030000_SQ_TEX_DIM_2D_ARRAY               0x00000005
+#define     V_030000_SQ_TEX_DIM_2D_MSAA                0x00000006
+#define     V_030000_SQ_TEX_DIM_2D_ARRAY_MSAA          0x00000007
+#define   S_030000_NON_DISP_TILING_ORDER(x)            (((x) & 0x1) << 5)
+#define   G_030000_NON_DISP_TILING_ORDER(x)            (((x) >> 5) & 0x1)
+#define   C_030000_NON_DISP_TILING_ORDER               0xFFFFFFDF
+#define   S_030000_PITCH(x)                            (((x) & 0xFFF) << 6)
+#define   G_030000_PITCH(x)                            (((x) >> 6) & 0xFFF)
+#define   C_030000_PITCH                               0xFFFC003F
+#define   S_030000_TEX_WIDTH(x)                        (((x) & 0x3FFF) << 18)
+#define   G_030000_TEX_WIDTH(x)                        (((x) >> 18) & 0x3FFF)
+#define   C_030000_TEX_WIDTH                           0x0003FFFF
+#define R_030004_SQ_TEX_RESOURCE_WORD1_0             0x030004
+#define   S_030004_TEX_HEIGHT(x)                       (((x) & 0x3FFF) << 0)
+#define   G_030004_TEX_HEIGHT(x)                       (((x) >> 0) & 0x3FFF)
+#define   C_030004_TEX_HEIGHT                          0xFFFFC000
+#define   S_030004_TEX_DEPTH(x)                        (((x) & 0x1FFF) << 14)
+#define   G_030004_TEX_DEPTH(x)                        (((x) >> 14) & 0x1FFF)
+#define   C_030004_TEX_DEPTH                           0xF8003FFF
+#define   S_030004_ARRAY_MODE(x)                       (((x) & 0xF) << 28)
+#define   G_030004_ARRAY_MODE(x)                       (((x) >> 28) & 0xF)
+#define   C_030004_ARRAY_MODE                          0x0FFFFFFF
+#define R_030008_SQ_TEX_RESOURCE_WORD2_0             0x030008
+#define   S_030008_BASE_ADDRESS(x)                     (((x) & 0xFFFFFFFF) << 0)
+#define   G_030008_BASE_ADDRESS(x)                     (((x) >> 0) & 0xFFFFFFFF)
+#define   C_030008_BASE_ADDRESS                        0x00000000
+#define R_03000C_SQ_TEX_RESOURCE_WORD3_0             0x03000C
+#define   S_03000C_MIP_ADDRESS(x)                      (((x) & 0xFFFFFFFF) << 0)
+#define   G_03000C_MIP_ADDRESS(x)                      (((x) >> 0) & 0xFFFFFFFF)
+#define   C_03000C_MIP_ADDRESS                         0x00000000
+#define R_030010_SQ_TEX_RESOURCE_WORD4_0             0x030010
+#define   S_030010_FORMAT_COMP_X(x)                    (((x) & 0x3) << 0)
+#define   G_030010_FORMAT_COMP_X(x)                    (((x) >> 0) & 0x3)
+#define   C_030010_FORMAT_COMP_X                       0xFFFFFFFC
+#define     V_030010_SQ_FORMAT_COMP_UNSIGNED           0x00000000
+#define     V_030010_SQ_FORMAT_COMP_SIGNED             0x00000001
+#define     V_030010_SQ_FORMAT_COMP_UNSIGNED_BIASED    0x00000002
+#define   S_030010_FORMAT_COMP_Y(x)                    (((x) & 0x3) << 2)
+#define   G_030010_FORMAT_COMP_Y(x)                    (((x) >> 2) & 0x3)
+#define   C_030010_FORMAT_COMP_Y                       0xFFFFFFF3
+#define   S_030010_FORMAT_COMP_Z(x)                    (((x) & 0x3) << 4)
+#define   G_030010_FORMAT_COMP_Z(x)                    (((x) >> 4) & 0x3)
+#define   C_030010_FORMAT_COMP_Z                       0xFFFFFFCF
+#define   S_030010_FORMAT_COMP_W(x)                    (((x) & 0x3) << 6)
+#define   G_030010_FORMAT_COMP_W(x)                    (((x) >> 6) & 0x3)
+#define   C_030010_FORMAT_COMP_W                       0xFFFFFF3F
+#define   S_030010_NUM_FORMAT_ALL(x)                   (((x) & 0x3) << 8)
+#define   G_030010_NUM_FORMAT_ALL(x)                   (((x) >> 8) & 0x3)
+#define   C_030010_NUM_FORMAT_ALL                      0xFFFFFCFF
+#define     V_030010_SQ_NUM_FORMAT_NORM                0x00000000
+#define     V_030010_SQ_NUM_FORMAT_INT                 0x00000001
+#define     V_030010_SQ_NUM_FORMAT_SCALED              0x00000002
+#define   S_030010_SRF_MODE_ALL(x)                     (((x) & 0x1) << 10)
+#define   G_030010_SRF_MODE_ALL(x)                     (((x) >> 10) & 0x1)
+#define   C_030010_SRF_MODE_ALL                        0xFFFFFBFF
+#define     V_030010_SRF_MODE_ZERO_CLAMP_MINUS_ONE     0x00000000
+#define     V_030010_SRF_MODE_NO_ZERO                  0x00000001
+#define   S_030010_FORCE_DEGAMMA(x)                    (((x) & 0x1) << 11)
+#define   G_030010_FORCE_DEGAMMA(x)                    (((x) >> 11) & 0x1)
+#define   C_030010_FORCE_DEGAMMA                       0xFFFFF7FF
+#define   S_030010_ENDIAN_SWAP(x)                      (((x) & 0x3) << 12)
+#define   G_030010_ENDIAN_SWAP(x)                      (((x) >> 12) & 0x3)
+#define   C_030010_ENDIAN_SWAP                         0xFFFFCFFF
+#define   S_030010_DST_SEL_X(x)                        (((x) & 0x7) << 16)
+#define   G_030010_DST_SEL_X(x)                        (((x) >> 16) & 0x7)
+#define   C_030010_DST_SEL_X                           0xFFF8FFFF
+#define     V_030010_SQ_SEL_X                          0x00000000
+#define     V_030010_SQ_SEL_Y                          0x00000001
+#define     V_030010_SQ_SEL_Z                          0x00000002
+#define     V_030010_SQ_SEL_W                          0x00000003
+#define     V_030010_SQ_SEL_0                          0x00000004
+#define     V_030010_SQ_SEL_1                          0x00000005
+#define   S_030010_DST_SEL_Y(x)                        (((x) & 0x7) << 19)
+#define   G_030010_DST_SEL_Y(x)                        (((x) >> 19) & 0x7)
+#define   C_030010_DST_SEL_Y                           0xFFC7FFFF
+#define   S_030010_DST_SEL_Z(x)                        (((x) & 0x7) << 22)
+#define   G_030010_DST_SEL_Z(x)                        (((x) >> 22) & 0x7)
+#define   C_030010_DST_SEL_Z                           0xFE3FFFFF
+#define   S_030010_DST_SEL_W(x)                        (((x) & 0x7) << 25)
+#define   G_030010_DST_SEL_W(x)                        (((x) >> 25) & 0x7)
+#define   C_030010_DST_SEL_W                           0xF1FFFFFF
+#define   S_030010_BASE_LEVEL(x)                       (((x) & 0xF) << 28)
+#define   G_030010_BASE_LEVEL(x)                       (((x) >> 28) & 0xF)
+#define   C_030010_BASE_LEVEL                          0x0FFFFFFF
+#define R_030014_SQ_TEX_RESOURCE_WORD5_0             0x030014
+#define   S_030014_LAST_LEVEL(x)                       (((x) & 0xF) << 0)
+#define   G_030014_LAST_LEVEL(x)                       (((x) >> 0) & 0xF)
+#define   C_030014_LAST_LEVEL                          0xFFFFFFF0
+#define   S_030014_BASE_ARRAY(x)                       (((x) & 0x1FFF) << 4)
+#define   G_030014_BASE_ARRAY(x)                       (((x) >> 4) & 0x1FFF)
+#define   C_030014_BASE_ARRAY                          0xFFFE000F
+#define   S_030014_LAST_ARRAY(x)                       (((x) & 0x1FFF) << 17)
+#define   G_030014_LAST_ARRAY(x)                       (((x) >> 17) & 0x1FFF)
+#define   C_030014_LAST_ARRAY                          0xC001FFFF
+#define R_030018_SQ_TEX_RESOURCE_WORD6_0             0x030018
+#define   S_030018_MAX_ANISO(x)                        (((x) & 0x7) << 0)
+#define   G_030018_MAX_ANISO(x)                        (((x) >> 0) & 0x7)
+#define   C_030018_MAX_ANISO                           0xFFFFFFF8
+#define   S_030018_PERF_MODULATION(x)                  (((x) & 0x7) << 3)
+#define   G_030018_PERF_MODULATION(x)                  (((x) >> 3) & 0x7)
+#define   C_030018_PERF_MODULATION                     0xFFFFFFC7
+#define   S_030018_INTERLACED(x)                       (((x) & 0x1) << 6)
+#define   G_030018_INTERLACED(x)                       (((x) >> 6) & 0x1)
+#define   C_030018_INTERLACED                          0xFFFFFFBF
+#define   S_030018_TILE_SPLIT(x)                       (((x) & 0x7) << 29)
+#define   G_030018_TILE_SPLIT(x)                       (((x) >> 29) & 0x7)
+#define R_03001C_SQ_TEX_RESOURCE_WORD7_0             0x03001C
+#define   S_03001C_MACRO_TILE_ASPECT(x)                (((x) & 0x3) << 6)
+#define   G_03001C_MACRO_TILE_ASPECT(x)                (((x) >> 6) & 0x3)
+#define   S_03001C_BANK_WIDTH(x)                       (((x) & 0x3) << 8)
+#define   G_03001C_BANK_WIDTH(x)                       (((x) >> 8) & 0x3)
+#define   S_03001C_BANK_HEIGHT(x)                      (((x) & 0x3) << 10)
+#define   G_03001C_BANK_HEIGHT(x)                      (((x) >> 10) & 0x3)
+#define   S_03001C_NUM_BANKS(x)                        (((x) & 0x3) << 16)
+#define   G_03001C_NUM_BANKS(x)                        (((x) >> 16) & 0x3)
+#define   S_03001C_TYPE(x)                             (((x) & 0x3) << 30)
+#define   G_03001C_TYPE(x)                             (((x) >> 30) & 0x3)
+#define   C_03001C_TYPE                                0x3FFFFFFF
+#define     V_03001C_SQ_TEX_VTX_INVALID_TEXTURE        0x00000000
+#define     V_03001C_SQ_TEX_VTX_INVALID_BUFFER         0x00000001
+#define     V_03001C_SQ_TEX_VTX_VALID_TEXTURE          0x00000002
+#define     V_03001C_SQ_TEX_VTX_VALID_BUFFER           0x00000003
+#define   S_03001C_DATA_FORMAT(x)                      (((x) & 0x3F) << 0)
+#define   G_03001C_DATA_FORMAT(x)                      (((x) >> 0) & 0x3F)
+#define   C_03001C_DATA_FORMAT                         0xFFFFFFC0
 
 #define SQ_VTX_CONSTANT_WORD0_0                         0x30000
 #define SQ_VTX_CONSTANT_WORD1_0                         0x30004
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index bfd36ab643a6..99bb00649357 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -87,23 +87,27 @@ int r100_reloc_pitch_offset(struct radeon_cs_parser *p,
                 r100_cs_dump_packet(p, pkt);
                 return r;
         }
+
         value = radeon_get_ib_value(p, idx);
         tmp = value & 0x003fffff;
         tmp += (((u32)reloc->lobj.gpu_offset) >> 10);
 
-        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
-                tile_flags |= RADEON_DST_TILE_MACRO;
-        if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO) {
-                if (reg == RADEON_SRC_PITCH_OFFSET) {
-                        DRM_ERROR("Cannot src blit from microtiled surface\n");
-                        r100_cs_dump_packet(p, pkt);
-                        return -EINVAL;
+        if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
+                        tile_flags |= RADEON_DST_TILE_MACRO;
+                if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO) {
+                        if (reg == RADEON_SRC_PITCH_OFFSET) {
+                                DRM_ERROR("Cannot src blit from microtiled surface\n");
+                                r100_cs_dump_packet(p, pkt);
+                                return -EINVAL;
+                        }
+                        tile_flags |= RADEON_DST_TILE_MICRO;
                 }
-                tile_flags |= RADEON_DST_TILE_MICRO;
-        }
 
-        tmp |= tile_flags;
-        p->ib->ptr[idx] = (value & 0x3fc00000) | tmp;
+                tmp |= tile_flags;
+                p->ib->ptr[idx] = (value & 0x3fc00000) | tmp;
+        } else
+                p->ib->ptr[idx] = (value & 0xffc00000) | tmp;
         return 0;
 }
 
@@ -1554,7 +1558,17 @@ static int r100_packet0_check(struct radeon_cs_parser *p,
                         r100_cs_dump_packet(p, pkt);
                         return r;
                 }
-                ib[idx] = idx_value + ((u32)reloc->lobj.gpu_offset);
+                if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
+                                tile_flags |= RADEON_TXO_MACRO_TILE;
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
+                                tile_flags |= RADEON_TXO_MICRO_TILE_X2;
+
+                        tmp = idx_value & ~(0x7 << 2);
+                        tmp |= tile_flags;
+                        ib[idx] = tmp + ((u32)reloc->lobj.gpu_offset);
+                } else
+                        ib[idx] = idx_value + ((u32)reloc->lobj.gpu_offset);
                 track->textures[i].robj = reloc->robj;
                 track->tex_dirty = true;
                 break;
@@ -1625,15 +1639,17 @@ static int r100_packet0_check(struct radeon_cs_parser *p,
                         r100_cs_dump_packet(p, pkt);
                         return r;
                 }
-
-                if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
-                        tile_flags |= RADEON_COLOR_TILE_ENABLE;
-                if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
-                        tile_flags |= RADEON_COLOR_MICROTILE_ENABLE;
-
-                tmp = idx_value & ~(0x7 << 16);
-                tmp |= tile_flags;
-                ib[idx] = tmp;
+                if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
+                                tile_flags |= RADEON_COLOR_TILE_ENABLE;
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
+                                tile_flags |= RADEON_COLOR_MICROTILE_ENABLE;
+
+                        tmp = idx_value & ~(0x7 << 16);
+                        tmp |= tile_flags;
+                        ib[idx] = tmp;
+                } else
+                        ib[idx] = idx_value;
 
                 track->cb[0].pitch = idx_value & RADEON_COLORPITCH_MASK;
                 track->cb_dirty = true;
diff --git a/drivers/gpu/drm/radeon/r200.c b/drivers/gpu/drm/radeon/r200.c
index eba4cbfa78f6..a59cc474d537 100644
--- a/drivers/gpu/drm/radeon/r200.c
+++ b/drivers/gpu/drm/radeon/r200.c
@@ -215,7 +215,17 @@ int r200_packet0_check(struct radeon_cs_parser *p,
                         r100_cs_dump_packet(p, pkt);
                         return r;
                 }
-                ib[idx] = idx_value + ((u32)reloc->lobj.gpu_offset);
+                if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
+                                tile_flags |= R200_TXO_MACRO_TILE;
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
+                                tile_flags |= R200_TXO_MICRO_TILE;
+
+                        tmp = idx_value & ~(0x7 << 2);
+                        tmp |= tile_flags;
+                        ib[idx] = tmp + ((u32)reloc->lobj.gpu_offset);
+                } else
+                        ib[idx] = idx_value + ((u32)reloc->lobj.gpu_offset);
                 track->textures[i].robj = reloc->robj;
                 track->tex_dirty = true;
                 break;
@@ -277,14 +287,17 @@ int r200_packet0_check(struct radeon_cs_parser *p,
                         return r;
                 }
 
-                if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
-                        tile_flags |= RADEON_COLOR_TILE_ENABLE;
-                if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
-                        tile_flags |= RADEON_COLOR_MICROTILE_ENABLE;
+                if (!(p->cs_flags & RADEON_CS_KEEP_TILING_FLAGS)) {
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
+                                tile_flags |= RADEON_COLOR_TILE_ENABLE;
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
+                                tile_flags |= RADEON_COLOR_MICROTILE_ENABLE;
 
-                tmp = idx_value & ~(0x7 << 16);
-                tmp |= tile_flags;
-                ib[idx] = tmp;
+                        tmp = idx_value & ~(0x7 << 16);
+                        tmp |= tile_flags;
+                        ib[idx] = tmp;
+                } else
+                        ib[idx] = idx_value;
 
                 track->cb[0].pitch = idx_value & RADEON_COLORPITCH_MASK;
                 track->cb_dirty = true;
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c
index accc032c103f..db38f587f27a 100644
--- a/drivers/gpu/drm/radeon/r600_blit_kms.c
+++ b/drivers/gpu/drm/radeon/r600_blit_kms.c
@@ -30,20 +30,7 @@
 
 #include "r600d.h"
 #include "r600_blit_shaders.h"
-
-#define DI_PT_RECTLIST        0x11
-#define DI_INDEX_SIZE_16_BIT  0x0
-#define DI_SRC_SEL_AUTO_INDEX 0x2
-
-#define FMT_8                 0x1
-#define FMT_5_6_5             0x8
-#define FMT_8_8_8_8           0x1a
-#define COLOR_8               0x1
-#define COLOR_5_6_5           0x8
-#define COLOR_8_8_8_8         0x1a
-
-#define RECT_UNIT_H           32
-#define RECT_UNIT_W           (RADEON_GPU_PAGE_SIZE / 4 / RECT_UNIT_H)
+#include "radeon_blit_common.h"
 
 /* emits 21 on rv770+, 23 on r600 */
 static void
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index 38ce5d0427e3..5cbe948ef16e 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -55,12 +55,17 @@ struct r600_cs_track {
         struct radeon_bo        *cb_color_frag_bo[8];
         struct radeon_bo        *cb_color_tile_bo[8];
         u32                     cb_color_info[8];
+        u32                     cb_color_view[8];
         u32                     cb_color_size_idx[8];
         u32                     cb_target_mask;
         u32                     cb_shader_mask;
         u32                     cb_color_size[8];
         u32                     vgt_strmout_en;
         u32                     vgt_strmout_buffer_en;
+        struct radeon_bo        *vgt_strmout_bo[4];
+        u64                     vgt_strmout_bo_mc[4];
+        u32                     vgt_strmout_bo_offset[4];
+        u32                     vgt_strmout_size[4];
         u32                     db_depth_control;
         u32                     db_depth_info;
         u32                     db_depth_size_idx;
@@ -73,9 +78,9 @@ struct r600_cs_track {
 
 #define FMT_8_BIT(fmt, vc)   [fmt] = { 1, 1, 1, vc, CHIP_R600 }
 #define FMT_16_BIT(fmt, vc)  [fmt] = { 1, 1, 2, vc, CHIP_R600 }
-#define FMT_24_BIT(fmt)      [fmt] = { 1, 1, 3,  0, CHIP_R600 }
+#define FMT_24_BIT(fmt)      [fmt] = { 1, 1, 4,  0, CHIP_R600 }
 #define FMT_32_BIT(fmt, vc)  [fmt] = { 1, 1, 4, vc, CHIP_R600 }
-#define FMT_48_BIT(fmt)      [fmt] = { 1, 1, 6,  0, CHIP_R600 }
+#define FMT_48_BIT(fmt)      [fmt] = { 1, 1, 8,  0, CHIP_R600 }
 #define FMT_64_BIT(fmt, vc)  [fmt] = { 1, 1, 8, vc, CHIP_R600 }
 #define FMT_96_BIT(fmt)      [fmt] = { 1, 1, 12, 0, CHIP_R600 }
 #define FMT_128_BIT(fmt, vc) [fmt] = { 1, 1, 16,vc, CHIP_R600 }
@@ -107,7 +112,7 @@ static const struct gpu_formats color_formats_table[] = {
 
         /* 24-bit */
         FMT_24_BIT(V_038004_FMT_8_8_8),
-                                               
+
         /* 32-bit */
         FMT_32_BIT(V_038004_COLOR_32, 1),
         FMT_32_BIT(V_038004_COLOR_32_FLOAT, 1),
@@ -162,22 +167,22 @@ static const struct gpu_formats color_formats_table[] = {
         [V_038004_FMT_32_AS_32_32_32_32] = { 1, 1, 4, 0, CHIP_CEDAR},
 };
 
-static bool fmt_is_valid_color(u32 format)
+bool r600_fmt_is_valid_color(u32 format)
 {
         if (format >= ARRAY_SIZE(color_formats_table))
                 return false;
-        
+
         if (color_formats_table[format].valid_color)
                 return true;
 
         return false;
 }
 
-static bool fmt_is_valid_texture(u32 format, enum radeon_family family)
+bool r600_fmt_is_valid_texture(u32 format, enum radeon_family family)
 {
         if (format >= ARRAY_SIZE(color_formats_table))
                 return false;
-        
+
         if (family < color_formats_table[format].min_family)
                 return false;
 
@@ -187,7 +192,7 @@ static bool fmt_is_valid_texture(u32 format, enum radeon_family family)
         return false;
 }
 
-static int fmt_get_blocksize(u32 format)
+int r600_fmt_get_blocksize(u32 format)
 {
         if (format >= ARRAY_SIZE(color_formats_table))
                 return 0;
@@ -195,7 +200,7 @@ static int fmt_get_blocksize(u32 format)
         return color_formats_table[format].blocksize;
 }
 
-static int fmt_get_nblocksx(u32 format, u32 w)
+int r600_fmt_get_nblocksx(u32 format, u32 w)
 {
         unsigned bw;
 
@@ -209,7 +214,7 @@ static int fmt_get_nblocksx(u32 format, u32 w)
         return (w + bw - 1) / bw;
 }
 
-static int fmt_get_nblocksy(u32 format, u32 h)
+int r600_fmt_get_nblocksy(u32 format, u32 h)
 {
         unsigned bh;
 
@@ -256,7 +261,7 @@ static int r600_get_array_mode_alignment(struct array_mode_checker *values,
                 break;
         case ARRAY_LINEAR_ALIGNED:
                 *pitch_align = max((u32)64, (u32)(values->group_size / values->blocksize));
-                *height_align = tile_height;
+                *height_align = 1;
                 *depth_align = 1;
                 *base_align = values->group_size;
                 break;
@@ -269,10 +274,9 @@ static int r600_get_array_mode_alignment(struct array_mode_checker *values,
                 *base_align = values->group_size;
                 break;
         case ARRAY_2D_TILED_THIN1:
-                *pitch_align = max((u32)macro_tile_width,
-                                  (u32)(((values->group_size / tile_height) /
-                                         (values->blocksize * values->nsamples)) *
-                                        values->nbanks)) * tile_width;
+                *pitch_align = max((u32)macro_tile_width * tile_width,
+                                (u32)((values->group_size * values->nbanks) /
+                                (values->blocksize * values->nsamples * tile_width)));
                 *height_align = macro_tile_height * tile_height;
                 *depth_align = 1;
                 *base_align = max(macro_tile_bytes,
@@ -296,6 +300,7 @@ static void r600_cs_track_init(struct r600_cs_track *track)
                 track->cb_color_size[i] = 0;
                 track->cb_color_size_idx[i] = 0;
                 track->cb_color_info[i] = 0;
+                track->cb_color_view[i] = 0xFFFFFFFF;
                 track->cb_color_bo[i] = NULL;
                 track->cb_color_bo_offset[i] = 0xFFFFFFFF;
                 track->cb_color_bo_mc[i] = 0xFFFFFFFF;
@@ -310,6 +315,13 @@ static void r600_cs_track_init(struct r600_cs_track *track)
         track->db_depth_size = 0xFFFFFFFF;
         track->db_depth_size_idx = 0;
         track->db_depth_control = 0xFFFFFFFF;
+
+        for (i = 0; i < 4; i++) {
+                track->vgt_strmout_size[i] = 0;
+                track->vgt_strmout_bo[i] = NULL;
+                track->vgt_strmout_bo_offset[i] = 0xFFFFFFFF;
+                track->vgt_strmout_bo_mc[i] = 0xFFFFFFFF;
+        }
 }
 
 static int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
@@ -322,13 +334,14 @@ static int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
         volatile u32 *ib = p->ib->ptr;
         unsigned array_mode;
         u32 format;
+
         if (G_0280A0_TILE_MODE(track->cb_color_info[i])) {
                 dev_warn(p->dev, "FMASK or CMASK buffer are not supported by this kernel\n");
                 return -EINVAL;
         }
         size = radeon_bo_size(track->cb_color_bo[i]) - track->cb_color_bo_offset[i];
         format = G_0280A0_FORMAT(track->cb_color_info[i]);
-        if (!fmt_is_valid_color(format)) {
+        if (!r600_fmt_is_valid_color(format)) {
                 dev_warn(p->dev, "%s:%d cb invalid format %d for %d (0x%08X)\n",
                          __func__, __LINE__, format,
                         i, track->cb_color_info[i]);
@@ -349,7 +362,7 @@ static int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
         array_check.nbanks = track->nbanks;
         array_check.npipes = track->npipes;
         array_check.nsamples = track->nsamples;
-        array_check.blocksize = fmt_get_blocksize(format);
+        array_check.blocksize = r600_fmt_get_blocksize(format);
         if (r600_get_array_mode_alignment(&array_check,
                                           &pitch_align, &height_align, &depth_align, &base_align)) {
                 dev_warn(p->dev, "%s invalid tiling %d for %d (0x%08X)\n", __func__,
@@ -393,7 +406,18 @@ static int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
         }
 
         /* check offset */
-        tmp = fmt_get_nblocksy(format, height) * fmt_get_nblocksx(format, pitch) * fmt_get_blocksize(format);
+        tmp = r600_fmt_get_nblocksy(format, height) * r600_fmt_get_nblocksx(format, pitch) * r600_fmt_get_blocksize(format);
+        switch (array_mode) {
+        default:
+        case V_0280A0_ARRAY_LINEAR_GENERAL:
+        case V_0280A0_ARRAY_LINEAR_ALIGNED:
+                tmp += track->cb_color_view[i] & 0xFF;
+                break;
+        case V_0280A0_ARRAY_1D_TILED_THIN1:
+        case V_0280A0_ARRAY_2D_TILED_THIN1:
+                tmp += G_028080_SLICE_MAX(track->cb_color_view[i]) * tmp;
+                break;
+        }
         if ((tmp + track->cb_color_bo_offset[i]) > radeon_bo_size(track->cb_color_bo[i])) {
                 if (array_mode == V_0280A0_ARRAY_LINEAR_GENERAL) {
                         /* the initial DDX does bad things with the CB size occasionally */
@@ -403,10 +427,13 @@ static int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
                          * broken userspace.
                          */
                 } else {
-                        dev_warn(p->dev, "%s offset[%d] %d %d %d %lu too big\n", __func__, i,
-                                 array_mode,
+                        dev_warn(p->dev, "%s offset[%d] %d %d %d %lu too big (%d %d) (%d %d %d)\n",
+                                 __func__, i, array_mode,
                                  track->cb_color_bo_offset[i], tmp,
-                                 radeon_bo_size(track->cb_color_bo[i]));
+                                 radeon_bo_size(track->cb_color_bo[i]),
+                                 pitch, height, r600_fmt_get_nblocksx(format, pitch),
+                                 r600_fmt_get_nblocksy(format, height),
+                                 r600_fmt_get_blocksize(format));
                         return -EINVAL;
                 }
         }
@@ -430,11 +457,28 @@ static int r600_cs_track_check(struct radeon_cs_parser *p)
         /* on legacy kernel we don't perform advanced check */
         if (p->rdev == NULL)
                 return 0;
-        /* we don't support out buffer yet */
-        if (track->vgt_strmout_en || track->vgt_strmout_buffer_en) {
-                dev_warn(p->dev, "this kernel doesn't support SMX output buffer\n");
-                return -EINVAL;
+
+        /* check streamout */
+        if (track->vgt_strmout_en) {
+                for (i = 0; i < 4; i++) {
+                        if (track->vgt_strmout_buffer_en & (1 << i)) {
+                                if (track->vgt_strmout_bo[i]) {
+                                        u64 offset = (u64)track->vgt_strmout_bo_offset[i] +
+                                                (u64)track->vgt_strmout_size[i];
+                                        if (offset > radeon_bo_size(track->vgt_strmout_bo[i])) {
+                                                DRM_ERROR("streamout %d bo too small: 0x%llx, 0x%lx\n",
+                                                          i, offset,
+                                                          radeon_bo_size(track->vgt_strmout_bo[i]));
+                                                return -EINVAL;
+                                        }
+                                } else {
+                                        dev_warn(p->dev, "No buffer for streamout %d\n", i);
+                                        return -EINVAL;
+                                }
+                        }
+                }
         }
+
         /* check that we have a cb for each enabled target, we don't check
          * shader_mask because it seems mesa isn't always setting it :(
          */
@@ -975,6 +1019,39 @@ static int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
         case R_028B20_VGT_STRMOUT_BUFFER_EN:
                 track->vgt_strmout_buffer_en = radeon_get_ib_value(p, idx);
                 break;
+        case VGT_STRMOUT_BUFFER_BASE_0:
+        case VGT_STRMOUT_BUFFER_BASE_1:
+        case VGT_STRMOUT_BUFFER_BASE_2:
+        case VGT_STRMOUT_BUFFER_BASE_3:
+                r = r600_cs_packet_next_reloc(p, &reloc);
+                if (r) {
+                        dev_warn(p->dev, "bad SET_CONTEXT_REG "
+                                        "0x%04X\n", reg);
+                        return -EINVAL;
+                }
+                tmp = (reg - VGT_STRMOUT_BUFFER_BASE_0) / 16;
+                track->vgt_strmout_bo_offset[tmp] = radeon_get_ib_value(p, idx) << 8;
+                ib[idx] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                track->vgt_strmout_bo[tmp] = reloc->robj;
+                track->vgt_strmout_bo_mc[tmp] = reloc->lobj.gpu_offset;
+                break;
+        case VGT_STRMOUT_BUFFER_SIZE_0:
+        case VGT_STRMOUT_BUFFER_SIZE_1:
+        case VGT_STRMOUT_BUFFER_SIZE_2:
+        case VGT_STRMOUT_BUFFER_SIZE_3:
+                tmp = (reg - VGT_STRMOUT_BUFFER_SIZE_0) / 16;
+                /* size in register is DWs, convert to bytes */
+                track->vgt_strmout_size[tmp] = radeon_get_ib_value(p, idx) * 4;
+                break;
+        case CP_COHER_BASE:
+                r = r600_cs_packet_next_reloc(p, &reloc);
+                if (r) {
+                        dev_warn(p->dev, "missing reloc for CP_COHER_BASE "
+                                        "0x%04X\n", reg);
+                        return -EINVAL;
+                }
+                ib[idx] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                break;
         case R_028238_CB_TARGET_MASK:
                 track->cb_target_mask = radeon_get_ib_value(p, idx);
                 break;
@@ -1014,6 +1091,17 @@ static int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
                         track->cb_color_info[tmp] = radeon_get_ib_value(p, idx);
                 }
                 break;
+        case R_028080_CB_COLOR0_VIEW:
+        case R_028084_CB_COLOR1_VIEW:
+        case R_028088_CB_COLOR2_VIEW:
+        case R_02808C_CB_COLOR3_VIEW:
+        case R_028090_CB_COLOR4_VIEW:
+        case R_028094_CB_COLOR5_VIEW:
+        case R_028098_CB_COLOR6_VIEW:
+        case R_02809C_CB_COLOR7_VIEW:
+                tmp = (reg - R_028080_CB_COLOR0_VIEW) / 4;
+                track->cb_color_view[tmp] = radeon_get_ib_value(p, idx);
+                break;
         case R_028060_CB_COLOR0_SIZE:
         case R_028064_CB_COLOR1_SIZE:
         case R_028068_CB_COLOR2_SIZE:
@@ -1198,7 +1286,7 @@ static int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
         return 0;
 }
 
-static unsigned mip_minify(unsigned size, unsigned level)
+unsigned r600_mip_minify(unsigned size, unsigned level)
 {
         unsigned val;
 
@@ -1220,22 +1308,22 @@ static void r600_texture_size(unsigned nfaces, unsigned blevel, unsigned llevel,
         unsigned nlevels = llevel - blevel + 1;
 
         *l0_size = -1;
-        blocksize = fmt_get_blocksize(format);
+        blocksize = r600_fmt_get_blocksize(format);
 
-        w0 = mip_minify(w0, 0);
-        h0 = mip_minify(h0, 0);
-        d0 = mip_minify(d0, 0);
+        w0 = r600_mip_minify(w0, 0);
+        h0 = r600_mip_minify(h0, 0);
+        d0 = r600_mip_minify(d0, 0);
         for(i = 0, offset = 0, level = blevel; i < nlevels; i++, level++) {
-                width = mip_minify(w0, i);
-                nbx = fmt_get_nblocksx(format, width);
+                width = r600_mip_minify(w0, i);
+                nbx = r600_fmt_get_nblocksx(format, width);
 
                 nbx = round_up(nbx, block_align);
 
-                height = mip_minify(h0, i);
-                nby = fmt_get_nblocksy(format, height);
+                height = r600_mip_minify(h0, i);
+                nby = r600_fmt_get_nblocksy(format, height);
                 nby = round_up(nby, height_align);
 
-                depth = mip_minify(d0, i);
+                depth = r600_mip_minify(d0, i);
 
                 size = nbx * nby * blocksize;
                 if (nfaces)
@@ -1326,7 +1414,7 @@ static int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
                 return -EINVAL;
         }
         format = G_038004_DATA_FORMAT(word1);
-        if (!fmt_is_valid_texture(format, p->family)) {
+        if (!r600_fmt_is_valid_texture(format, p->family)) {
                 dev_warn(p->dev, "%s:%d texture invalid format %d\n",
                          __func__, __LINE__, format);
                 return -EINVAL;
@@ -1339,7 +1427,7 @@ static int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
         array_check.nbanks = track->nbanks;
         array_check.npipes = track->npipes;
         array_check.nsamples = 1;
-        array_check.blocksize = fmt_get_blocksize(format);
+        array_check.blocksize = r600_fmt_get_blocksize(format);
         if (r600_get_array_mode_alignment(&array_check,
                                           &pitch_align, &height_align, &depth_align, &base_align)) {
                 dev_warn(p->dev, "%s:%d tex array mode (%d) invalid\n",
@@ -1372,6 +1460,10 @@ static int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
         word1 = radeon_get_ib_value(p, idx + 5);
         blevel = G_038010_BASE_LEVEL(word0);
         llevel = G_038014_LAST_LEVEL(word1);
+        if (blevel > llevel) {
+                dev_warn(p->dev, "texture blevel %d > llevel %d\n",
+                         blevel, llevel);
+        }
         if (array == 1) {
                 barray = G_038014_BASE_ARRAY(word1);
                 larray = G_038014_LAST_ARRAY(word1);
@@ -1383,8 +1475,10 @@ static int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
                           &l0_size, &mipmap_size);
         /* using get ib will give us the offset into the texture bo */
         if ((l0_size + word2) > radeon_bo_size(texture)) {
-                dev_warn(p->dev, "texture bo too small (%d %d %d %d -> %d have %ld)\n",
-                        w0, h0, format, word2, l0_size, radeon_bo_size(texture));
+                dev_warn(p->dev, "texture bo too small ((%d %d) (%d %d) %d %d %d -> %d have %ld)\n",
+                         w0, h0, pitch_align, height_align,
+                         array_check.array_mode, format, word2,
+                         l0_size, radeon_bo_size(texture));
                 dev_warn(p->dev, "alignments %d %d %d %lld\n", pitch, pitch_align, height_align, base_align);
                 return -EINVAL;
         }
@@ -1397,6 +1491,22 @@ static int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
         return 0;
 }
 
+static bool r600_is_safe_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
+{
+        u32 m, i;
+
+        i = (reg >> 7);
+        if (i >= ARRAY_SIZE(r600_reg_safe_bm)) {
+                dev_warn(p->dev, "forbidden register 0x%08x at %d\n", reg, idx);
+                return false;
+        }
+        m = 1 << ((reg >> 2) & 31);
+        if (!(r600_reg_safe_bm[i] & m))
+                return true;
+        dev_warn(p->dev, "forbidden register 0x%08x at %d\n", reg, idx);
+        return false;
+}
+
 static int r600_packet3_check(struct radeon_cs_parser *p,
                                 struct radeon_cs_packet *pkt)
 {
@@ -1742,6 +1852,100 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                         return -EINVAL;
                 }
                 break;
+        case PACKET3_STRMOUT_BUFFER_UPDATE:
+                if (pkt->count != 4) {
+                        DRM_ERROR("bad STRMOUT_BUFFER_UPDATE (invalid count)\n");
+                        return -EINVAL;
+                }
+                /* Updating memory at DST_ADDRESS. */
+                if (idx_value & 0x1) {
+                        u64 offset;
+                        r = r600_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE (missing dst reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+1);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+2) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE dst bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+1] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+2] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                }
+                /* Reading data from SRC_ADDRESS. */
+                if (((idx_value >> 1) & 0x3) == 2) {
+                        u64 offset;
+                        r = r600_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE (missing src reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+3);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+4) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad STRMOUT_BUFFER_UPDATE src bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+3] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+4] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                }
+                break;
+        case PACKET3_COPY_DW:
+                if (pkt->count != 4) {
+                        DRM_ERROR("bad COPY_DW (invalid count)\n");
+                        return -EINVAL;
+                }
+                if (idx_value & 0x1) {
+                        u64 offset;
+                        /* SRC is memory. */
+                        r = r600_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad COPY_DW (missing src reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+1);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+2) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad COPY_DW src bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+1] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+2] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                } else {
+                        /* SRC is a reg. */
+                        reg = radeon_get_ib_value(p, idx+1) << 2;
+                        if (!r600_is_safe_reg(p, reg, idx+1))
+                                return -EINVAL;
+                }
+                if (idx_value & 0x2) {
+                        u64 offset;
+                        /* DST is memory. */
+                        r = r600_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                DRM_ERROR("bad COPY_DW (missing dst reloc)\n");
+                                return -EINVAL;
+                        }
+                        offset = radeon_get_ib_value(p, idx+3);
+                        offset += ((u64)(radeon_get_ib_value(p, idx+4) & 0xff)) << 32;
+                        if ((offset + 4) > radeon_bo_size(reloc->robj)) {
+                                DRM_ERROR("bad COPY_DW dst bo too small: 0x%llx, 0x%lx\n",
+                                          offset + 4, radeon_bo_size(reloc->robj));
+                                return -EINVAL;
+                        }
+                        ib[idx+3] += (u32)(reloc->lobj.gpu_offset & 0xffffffff);
+                        ib[idx+4] += upper_32_bits(reloc->lobj.gpu_offset) & 0xff;
+                } else {
+                        /* DST is a reg. */
+                        reg = radeon_get_ib_value(p, idx+3) << 2;
+                        if (!r600_is_safe_reg(p, reg, idx+3))
+                                return -EINVAL;
+                }
+                break;
         case PACKET3_NOP:
                 break;
         default:
diff --git a/drivers/gpu/drm/radeon/r600d.h b/drivers/gpu/drm/radeon/r600d.h
index 3ee1fd7ef394..2ba460b5b62f 100644
--- a/drivers/gpu/drm/radeon/r600d.h
+++ b/drivers/gpu/drm/radeon/r600d.h
@@ -78,6 +78,20 @@
 
 #define CB_COLOR0_SIZE                                  0x28060
 #define CB_COLOR0_VIEW                                  0x28080
+#define R_028080_CB_COLOR0_VIEW                      0x028080
+#define   S_028080_SLICE_START(x)                      (((x) & 0x7FF) << 0)
+#define   G_028080_SLICE_START(x)                      (((x) >> 0) & 0x7FF)
+#define   C_028080_SLICE_START                         0xFFFFF800
+#define   S_028080_SLICE_MAX(x)                        (((x) & 0x7FF) << 13)
+#define   G_028080_SLICE_MAX(x)                        (((x) >> 13) & 0x7FF)
+#define   C_028080_SLICE_MAX                           0xFF001FFF
+#define R_028084_CB_COLOR1_VIEW                      0x028084
+#define R_028088_CB_COLOR2_VIEW                      0x028088
+#define R_02808C_CB_COLOR3_VIEW                      0x02808C
+#define R_028090_CB_COLOR4_VIEW                      0x028090
+#define R_028094_CB_COLOR5_VIEW                      0x028094
+#define R_028098_CB_COLOR6_VIEW                      0x028098
+#define R_02809C_CB_COLOR7_VIEW                      0x02809C
 #define CB_COLOR0_INFO                                  0x280a0
 #       define CB_FORMAT(x)                             ((x) << 2)
 #       define CB_ARRAY_MODE(x)                         ((x) << 8)
@@ -493,6 +507,11 @@
 #define VGT_STRMOUT_BUFFER_OFFSET_1                     0x28AEC
 #define VGT_STRMOUT_BUFFER_OFFSET_2                     0x28AFC
 #define VGT_STRMOUT_BUFFER_OFFSET_3                     0x28B0C
+#define VGT_STRMOUT_BUFFER_SIZE_0                       0x28AD0
+#define VGT_STRMOUT_BUFFER_SIZE_1                       0x28AE0
+#define VGT_STRMOUT_BUFFER_SIZE_2                       0x28AF0
+#define VGT_STRMOUT_BUFFER_SIZE_3                       0x28B00
+
 #define VGT_STRMOUT_EN                                  0x28AB0
 #define VGT_VERTEX_REUSE_BLOCK_CNTL                     0x28C58
 #define         VTX_REUSE_DEPTH_MASK                            0x000000FF
@@ -834,6 +853,7 @@
 #              define PACKET3_SEM_SEL_SIGNAL        (0x6 << 29)
 #              define PACKET3_SEM_SEL_WAIT          (0x7 << 29)
 #define PACKET3_MPEG_INDEX                              0x3A
+#define PACKET3_COPY_DW                                 0x3B
 #define PACKET3_WAIT_REG_MEM                            0x3C
 #define PACKET3_MEM_WRITE                               0x3D
 #define PACKET3_INDIRECT_BUFFER                         0x32
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 1668ec1ee770..884e0d4b114f 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -242,6 +242,9 @@ extern int rv6xx_get_temp(struct radeon_device *rdev);
 extern int rv770_get_temp(struct radeon_device *rdev);
 extern int evergreen_get_temp(struct radeon_device *rdev);
 extern int sumo_get_temp(struct radeon_device *rdev);
+extern void evergreen_tiling_fields(unsigned tiling_flags, unsigned *bankw,
+                                    unsigned *bankh, unsigned *mtaspect,
+                                    unsigned *tile_split);
 
 /*
  * Fences.
@@ -1750,6 +1753,16 @@ int r600_vram_scratch_init(struct radeon_device *rdev);
 void r600_vram_scratch_fini(struct radeon_device *rdev);
 
 /*
+ * r600 cs checking helper
+ */
+unsigned r600_mip_minify(unsigned size, unsigned level);
+bool r600_fmt_is_valid_color(u32 format);
+bool r600_fmt_is_valid_texture(u32 format, enum radeon_family family);
+int r600_fmt_get_blocksize(u32 format);
+int r600_fmt_get_nblocksx(u32 format, u32 w);
+int r600_fmt_get_nblocksy(u32 format, u32 h);
+
+/*
  * r600 functions used by radeon_encoder.c
  */
 extern void r600_hdmi_enable(struct drm_encoder *encoder);
diff --git a/drivers/gpu/drm/radeon/radeon_benchmark.c b/drivers/gpu/drm/radeon/radeon_benchmark.c
index 815f2341ab94..58cee89215c7 100644
--- a/drivers/gpu/drm/radeon/radeon_benchmark.c
+++ b/drivers/gpu/drm/radeon/radeon_benchmark.c
@@ -208,22 +208,22 @@ void radeon_benchmark(struct radeon_device *rdev, int test_number)
                 break;
         case 3:
                 /* GTT to VRAM, buffer size sweep, powers of 2 */
-                for (i = 1; i <= 65536; i <<= 1)
-                        radeon_benchmark_move(rdev, i*1024,
+                for (i = 1; i <= 16384; i <<= 1)
+                        radeon_benchmark_move(rdev, i * RADEON_GPU_PAGE_SIZE,
                                               RADEON_GEM_DOMAIN_GTT,
                                               RADEON_GEM_DOMAIN_VRAM);
                 break;
         case 4:
                 /* VRAM to GTT, buffer size sweep, powers of 2 */
-                for (i = 1; i <= 65536; i <<= 1)
-                        radeon_benchmark_move(rdev, i*1024,
+                for (i = 1; i <= 16384; i <<= 1)
+                        radeon_benchmark_move(rdev, i * RADEON_GPU_PAGE_SIZE,
                                               RADEON_GEM_DOMAIN_VRAM,
                                               RADEON_GEM_DOMAIN_GTT);
                 break;
         case 5:
                 /* VRAM to VRAM, buffer size sweep, powers of 2 */
-                for (i = 1; i <= 65536; i <<= 1)
-                        radeon_benchmark_move(rdev, i*1024,
+                for (i = 1; i <= 16384; i <<= 1)
+                        radeon_benchmark_move(rdev, i * RADEON_GPU_PAGE_SIZE,
                                               RADEON_GEM_DOMAIN_VRAM,
                                               RADEON_GEM_DOMAIN_VRAM);
                 break;
diff --git a/drivers/gpu/drm/radeon/radeon_blit_common.h b/drivers/gpu/drm/radeon/radeon_blit_common.h
new file mode 100644
index 000000000000..4ecbe72c9d2d
--- /dev/null
+++ b/drivers/gpu/drm/radeon/radeon_blit_common.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009 Advanced Micro Devices, Inc.
+ * Copyright 2009 Red Hat Inc.
+ * Copyright 2012 Alcatel-Lucent, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef __RADEON_BLIT_COMMON_H__
+
+#define DI_PT_RECTLIST        0x11
+#define DI_INDEX_SIZE_16_BIT  0x0
+#define DI_SRC_SEL_AUTO_INDEX 0x2
+
+#define FMT_8                 0x1
+#define FMT_5_6_5             0x8
+#define FMT_8_8_8_8           0x1a
+#define COLOR_8               0x1
+#define COLOR_5_6_5           0x8
+#define COLOR_8_8_8_8         0x1a
+
+#define RECT_UNIT_H           32
+#define RECT_UNIT_W           (RADEON_GPU_PAGE_SIZE / 4 / RECT_UNIT_H)
+
+#define __RADEON_BLIT_COMMON_H__
+#endif
diff --git a/drivers/gpu/drm/radeon/radeon_cp.c b/drivers/gpu/drm/radeon/radeon_cp.c
index 72ae8266b8e9..0ebb7d4796fa 100644
--- a/drivers/gpu/drm/radeon/radeon_cp.c
+++ b/drivers/gpu/drm/radeon/radeon_cp.c
@@ -2115,6 +2115,8 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
                 break;
         }
 
+        pci_set_master(dev->pdev);
+
         if (drm_pci_device_is_agp(dev))
                 dev_priv->flags |= RADEON_IS_AGP;
         else if (pci_is_pcie(dev->pdev))
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 8c49fef1ce78..7cb062daa71e 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -1124,11 +1124,6 @@ static const struct drm_mode_config_funcs radeon_mode_funcs = {
         .output_poll_changed = radeon_output_poll_changed
 };
 
-struct drm_prop_enum_list {
-        int type;
-        char *name;
-};
-
 static struct drm_prop_enum_list radeon_tmds_pll_enum_list[] =
 {       { 0, "driver" },
         { 1, "bios" },
@@ -1153,86 +1148,53 @@ static struct drm_prop_enum_list radeon_underscan_enum_list[] =
 
 static int radeon_modeset_create_props(struct radeon_device *rdev)
 {
-        int i, sz;
+        int sz;
 
         if (rdev->is_atom_bios) {
                 rdev->mode_info.coherent_mode_property =
-                        drm_property_create(rdev->ddev,
-                                            DRM_MODE_PROP_RANGE,
-                                            "coherent", 2);
+                        drm_property_create_range(rdev->ddev, 0 , "coherent", 0, 1);
                 if (!rdev->mode_info.coherent_mode_property)
                         return -ENOMEM;
-
-                rdev->mode_info.coherent_mode_property->values[0] = 0;
-                rdev->mode_info.coherent_mode_property->values[1] = 1;
         }
 
         if (!ASIC_IS_AVIVO(rdev)) {
                 sz = ARRAY_SIZE(radeon_tmds_pll_enum_list);
                 rdev->mode_info.tmds_pll_property =
-                        drm_property_create(rdev->ddev,
-                                            DRM_MODE_PROP_ENUM,
-                                            "tmds_pll", sz);
-                for (i = 0; i < sz; i++) {
-                        drm_property_add_enum(rdev->mode_info.tmds_pll_property,
-                                              i,
-                                              radeon_tmds_pll_enum_list[i].type,
-                                              radeon_tmds_pll_enum_list[i].name);
-                }
+                        drm_property_create_enum(rdev->ddev, 0,
+                                            "tmds_pll",
+                                            radeon_tmds_pll_enum_list, sz);
         }
 
         rdev->mode_info.load_detect_property =
-                drm_property_create(rdev->ddev,
-                                    DRM_MODE_PROP_RANGE,
-                                    "load detection", 2);
+                drm_property_create_range(rdev->ddev, 0, "load detection", 0, 1);
         if (!rdev->mode_info.load_detect_property)
                 return -ENOMEM;
-        rdev->mode_info.load_detect_property->values[0] = 0;
-        rdev->mode_info.load_detect_property->values[1] = 1;
 
         drm_mode_create_scaling_mode_property(rdev->ddev);
 
         sz = ARRAY_SIZE(radeon_tv_std_enum_list);
         rdev->mode_info.tv_std_property =
-                drm_property_create(rdev->ddev,
-                                    DRM_MODE_PROP_ENUM,
-                                    "tv standard", sz);
-        for (i = 0; i < sz; i++) {
-                drm_property_add_enum(rdev->mode_info.tv_std_property,
-                                      i,
-                                      radeon_tv_std_enum_list[i].type,
-                                      radeon_tv_std_enum_list[i].name);
-        }
+                drm_property_create_enum(rdev->ddev, 0,
+                                    "tv standard",
+                                    radeon_tv_std_enum_list, sz);
 
         sz = ARRAY_SIZE(radeon_underscan_enum_list);
         rdev->mode_info.underscan_property =
-                drm_property_create(rdev->ddev,
-                                    DRM_MODE_PROP_ENUM,
-                                    "underscan", sz);
-        for (i = 0; i < sz; i++) {
-                drm_property_add_enum(rdev->mode_info.underscan_property,
-                                      i,
-                                      radeon_underscan_enum_list[i].type,
-                                      radeon_underscan_enum_list[i].name);
-        }
+                drm_property_create_enum(rdev->ddev, 0,
+                                    "underscan",
+                                    radeon_underscan_enum_list, sz);
 
         rdev->mode_info.underscan_hborder_property =
-                drm_property_create(rdev->ddev,
-                                        DRM_MODE_PROP_RANGE,
-                                        "underscan hborder", 2);
+                drm_property_create_range(rdev->ddev, 0,
+                                        "underscan hborder", 0, 128);
         if (!rdev->mode_info.underscan_hborder_property)
                 return -ENOMEM;
-        rdev->mode_info.underscan_hborder_property->values[0] = 0;
-        rdev->mode_info.underscan_hborder_property->values[1] = 128;
 
         rdev->mode_info.underscan_vborder_property =
-                drm_property_create(rdev->ddev,
-                                        DRM_MODE_PROP_RANGE,
-                                        "underscan vborder", 2);
+                drm_property_create_range(rdev->ddev, 0,
+                                        "underscan vborder", 0, 128);
         if (!rdev->mode_info.underscan_vborder_property)
                 return -ENOMEM;
-        rdev->mode_info.underscan_vborder_property->values[0] = 0;
-        rdev->mode_info.underscan_vborder_property->values[1] = 128;
 
         return 0;
 }
@@ -1278,6 +1240,9 @@ int radeon_modeset_init(struct radeon_device *rdev)
                 rdev->ddev->mode_config.max_height = 4096;
         }
 
+        rdev->ddev->mode_config.preferred_depth = 24;
+        rdev->ddev->mode_config.prefer_shadow = 1;
+
         rdev->ddev->mode_config.fb_base = rdev->mc.aper_base;
 
         ret = radeon_modeset_create_props(rdev);
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index 8032f1fedb11..498d21d50ba3 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -54,10 +54,11 @@
  *   2.10.0 - fusion 2D tiling
  *   2.11.0 - backend map, initial compute support for the CS checker
  *   2.12.0 - RADEON_CS_KEEP_TILING_FLAGS
- *   2.13.0 - virtual memory support
+ *   2.13.0 - virtual memory support, streamout
+ *   2.14.0 - add evergreen tiling informations
  */
 #define KMS_DRIVER_MAJOR        2
-#define KMS_DRIVER_MINOR        13
+#define KMS_DRIVER_MINOR        14
 #define KMS_DRIVER_PATCHLEVEL   0
 int radeon_driver_load_kms(struct drm_device *dev, unsigned long flags);
 int radeon_driver_unload_kms(struct drm_device *dev);
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c
index cf2bf35b56b8..a5692d5f415d 100644
--- a/drivers/gpu/drm/radeon/radeon_fb.c
+++ b/drivers/gpu/drm/radeon/radeon_fb.c
@@ -254,11 +254,7 @@ static int radeonfb_create(struct radeon_fbdev *rfbdev,
         info->apertures->ranges[0].base = rdev->ddev->mode_config.fb_base;
         info->apertures->ranges[0].size = rdev->mc.aper_size;
 
-        info->pixmap.size = 64*1024;
-        info->pixmap.buf_align = 8;
-        info->pixmap.access_align = 32;
-        info->pixmap.flags = FB_PIXMAP_SYSTEM;
-        info->pixmap.scan_align = 1;
+        /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
         if (info->screen_base == NULL) {
                 ret = -ENOSPC;
diff --git a/drivers/gpu/drm/radeon/radeon_i2c.c b/drivers/gpu/drm/radeon/radeon_i2c.c
index 98a8ad680109..3265a7a57977 100644
--- a/drivers/gpu/drm/radeon/radeon_i2c.c
+++ b/drivers/gpu/drm/radeon/radeon_i2c.c
@@ -30,6 +30,10 @@
 #include "radeon.h"
 #include "atom.h"
 
+extern int radeon_atom_hw_i2c_xfer(struct i2c_adapter *i2c_adap,
+                                   struct i2c_msg *msgs, int num);
+extern u32 radeon_atom_hw_i2c_func(struct i2c_adapter *adap);
+
 /**
  * radeon_ddc_probe
  *
@@ -882,6 +886,11 @@ static const struct i2c_algorithm radeon_i2c_algo = {
         .functionality = radeon_hw_i2c_func,
 };
 
+static const struct i2c_algorithm radeon_atom_i2c_algo = {
+        .master_xfer = radeon_atom_hw_i2c_xfer,
+        .functionality = radeon_atom_hw_i2c_func,
+};
+
 struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
                                           struct radeon_i2c_bus_rec *rec,
                                           const char *name)
@@ -914,6 +923,18 @@ struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
                         DRM_ERROR("Failed to register hw i2c %s\n", name);
                         goto out_free;
                 }
+        } else if (rec->hw_capable &&
+                   radeon_hw_i2c &&
+                   ASIC_IS_DCE3(rdev)) {
+                /* hw i2c using atom */
+                snprintf(i2c->adapter.name, sizeof(i2c->adapter.name),
+                         "Radeon i2c hw bus %s", name);
+                i2c->adapter.algo = &radeon_atom_i2c_algo;
+                ret = i2c_add_adapter(&i2c->adapter);
+                if (ret) {
+                        DRM_ERROR("Failed to register hw i2c %s\n", name);
+                        goto out_free;
+                }
         } else {
                 /* set the radeon bit adapter */
                 snprintf(i2c->adapter.name, sizeof(i2c->adapter.name),
@@ -925,10 +946,8 @@ struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
                 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.bit.timeout = 2;
+                i2c->algo.bit.udelay = 10;
+                i2c->algo.bit.timeout = usecs_to_jiffies(2200); /* from VESA */
                 i2c->algo.bit.data = i2c;
                 ret = i2c_bit_add_bus(&i2c->adapter);
                 if (ret) {
diff --git a/drivers/gpu/drm/radeon/radeon_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c
index d3352889a870..1986ebae1ef2 100644
--- a/drivers/gpu/drm/radeon/radeon_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_kms.c
@@ -57,6 +57,8 @@ int radeon_driver_load_kms(struct drm_device *dev, unsigned long flags)
         }
         dev->dev_private = (void *)rdev;
 
+        pci_set_master(dev->pdev);
+
         /* update BUS flag */
         if (drm_pci_device_is_agp(dev)) {
                 flags |= RADEON_IS_AGP;
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index d45df1763598..342deaccc152 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -445,8 +445,54 @@ static void radeon_bo_clear_surface_reg(struct radeon_bo *bo)
 int radeon_bo_set_tiling_flags(struct radeon_bo *bo,
                                 uint32_t tiling_flags, uint32_t pitch)
 {
+        struct radeon_device *rdev = bo->rdev;
         int r;
 
+        if (rdev->family >= CHIP_CEDAR) {
+                unsigned bankw, bankh, mtaspect, tilesplit, stilesplit;
+
+                bankw = (tiling_flags >> RADEON_TILING_EG_BANKW_SHIFT) & RADEON_TILING_EG_BANKW_MASK;
+                bankh = (tiling_flags >> RADEON_TILING_EG_BANKH_SHIFT) & RADEON_TILING_EG_BANKH_MASK;
+                mtaspect = (tiling_flags >> RADEON_TILING_EG_MACRO_TILE_ASPECT_SHIFT) & RADEON_TILING_EG_MACRO_TILE_ASPECT_MASK;
+                tilesplit = (tiling_flags >> RADEON_TILING_EG_TILE_SPLIT_SHIFT) & RADEON_TILING_EG_TILE_SPLIT_MASK;
+                stilesplit = (tiling_flags >> RADEON_TILING_EG_STENCIL_TILE_SPLIT_SHIFT) & RADEON_TILING_EG_STENCIL_TILE_SPLIT_MASK;
+                switch (bankw) {
+                case 0:
+                case 1:
+                case 2:
+                case 4:
+                case 8:
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                switch (bankh) {
+                case 0:
+                case 1:
+                case 2:
+                case 4:
+                case 8:
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                switch (mtaspect) {
+                case 0:
+                case 1:
+                case 2:
+                case 4:
+                case 8:
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                if (tilesplit > 6) {
+                        return -EINVAL;
+                }
+                if (stilesplit > 6) {
+                        return -EINVAL;
+                }
+        }
         r = radeon_bo_reserve(bo, false);
         if (unlikely(r != 0))
                 return r;
diff --git a/drivers/gpu/drm/radeon/reg_srcs/cayman b/drivers/gpu/drm/radeon/reg_srcs/cayman
index 2316977eb924..7b526d3ceac1 100644
--- a/drivers/gpu/drm/radeon/reg_srcs/cayman
+++ b/drivers/gpu/drm/radeon/reg_srcs/cayman
@@ -1,5 +1,8 @@
 cayman 0x9400
 0x0000802C GRBM_GFX_INDEX
+0x000084FC CP_STRMOUT_CNTL
+0x000085F0 CP_COHER_CNTL
+0x000085F4 CP_COHER_SIZE
 0x000088B0 VGT_VTX_VECT_EJECT_REG
 0x000088C4 VGT_CACHE_INVALIDATION
 0x000088D4 VGT_GS_VERTEX_REUSE
@@ -77,7 +80,6 @@ cayman 0x9400
 0x0002802C DB_DEPTH_CLEAR
 0x00028030 PA_SC_SCREEN_SCISSOR_TL
 0x00028034 PA_SC_SCREEN_SCISSOR_BR
-0x0002805C DB_DEPTH_SLICE
 0x00028140 SQ_ALU_CONST_BUFFER_SIZE_PS_0
 0x00028144 SQ_ALU_CONST_BUFFER_SIZE_PS_1
 0x00028148 SQ_ALU_CONST_BUFFER_SIZE_PS_2
@@ -512,6 +514,13 @@ cayman 0x9400
 0x00028AC0 DB_SRESULTS_COMPARE_STATE0
 0x00028AC4 DB_SRESULTS_COMPARE_STATE1
 0x00028AC8 DB_PRELOAD_CONTROL
+0x00028AD4 VGT_STRMOUT_VTX_STRIDE_0
+0x00028AE4 VGT_STRMOUT_VTX_STRIDE_1
+0x00028AF4 VGT_STRMOUT_VTX_STRIDE_2
+0x00028B04 VGT_STRMOUT_VTX_STRIDE_3
+0x00028B28 VGT_STRMOUT_DRAW_OPAQUE_OFFSET
+0x00028B2C VGT_STRMOUT_DRAW_OPAQUE_BUFFER_FILLED_SIZE
+0x00028B30 VGT_STRMOUT_DRAW_OPAQUE_VERTEX_STRIDE
 0x00028B38 VGT_GS_MAX_VERT_OUT
 0x00028B54 VGT_SHADER_STAGES_EN
 0x00028B58 VGT_LS_HS_CONFIG
diff --git a/drivers/gpu/drm/radeon/reg_srcs/evergreen b/drivers/gpu/drm/radeon/reg_srcs/evergreen
index 161737a28c23..7f4339463e31 100644
--- a/drivers/gpu/drm/radeon/reg_srcs/evergreen
+++ b/drivers/gpu/drm/radeon/reg_srcs/evergreen
@@ -4,6 +4,9 @@ evergreen 0x9400
 0x00008044 WAIT_UNTIL_POLL_CNTL
 0x00008048 WAIT_UNTIL_POLL_MASK
 0x0000804c WAIT_UNTIL_POLL_REFDATA
+0x000084FC CP_STRMOUT_CNTL
+0x000085F0 CP_COHER_CNTL
+0x000085F4 CP_COHER_SIZE
 0x000088B0 VGT_VTX_VECT_EJECT_REG
 0x000088C4 VGT_CACHE_INVALIDATION
 0x000088D4 VGT_GS_VERTEX_REUSE
@@ -93,7 +96,6 @@ evergreen 0x9400
 0x0002802C DB_DEPTH_CLEAR
 0x00028030 PA_SC_SCREEN_SCISSOR_TL
 0x00028034 PA_SC_SCREEN_SCISSOR_BR
-0x0002805C DB_DEPTH_SLICE
 0x00028140 SQ_ALU_CONST_BUFFER_SIZE_PS_0
 0x00028144 SQ_ALU_CONST_BUFFER_SIZE_PS_1
 0x00028148 SQ_ALU_CONST_BUFFER_SIZE_PS_2
@@ -522,6 +524,13 @@ evergreen 0x9400
 0x00028AC0 DB_SRESULTS_COMPARE_STATE0
 0x00028AC4 DB_SRESULTS_COMPARE_STATE1
 0x00028AC8 DB_PRELOAD_CONTROL
+0x00028AD4 VGT_STRMOUT_VTX_STRIDE_0
+0x00028AE4 VGT_STRMOUT_VTX_STRIDE_1
+0x00028AF4 VGT_STRMOUT_VTX_STRIDE_2
+0x00028B04 VGT_STRMOUT_VTX_STRIDE_3
+0x00028B28 VGT_STRMOUT_DRAW_OPAQUE_OFFSET
+0x00028B2C VGT_STRMOUT_DRAW_OPAQUE_BUFFER_FILLED_SIZE
+0x00028B30 VGT_STRMOUT_DRAW_OPAQUE_VERTEX_STRIDE
 0x00028B38 VGT_GS_MAX_VERT_OUT
 0x00028B54 VGT_SHADER_STAGES_EN
 0x00028B58 VGT_LS_HS_CONFIG
diff --git a/drivers/gpu/drm/radeon/reg_srcs/r600 b/drivers/gpu/drm/radeon/reg_srcs/r600
index 0380c5c15f80..79d245527ba8 100644
--- a/drivers/gpu/drm/radeon/reg_srcs/r600
+++ b/drivers/gpu/drm/radeon/reg_srcs/r600
@@ -3,6 +3,9 @@ r600 0x9400
 0x00028230 R7xx_PA_SC_EDGERULE
 0x000286C8 R7xx_SPI_THREAD_GROUPING
 0x00008D8C R7xx_SQ_DYN_GPR_CNTL_PS_FLUSH_REQ
+0x00008490 CP_STRMOUT_CNTL
+0x000085F0 CP_COHER_CNTL
+0x000085F4 CP_COHER_SIZE
 0x000088C4 VGT_CACHE_INVALIDATION
 0x00028A50 VGT_ENHANCE
 0x000088CC VGT_ES_PER_GS
@@ -38,6 +41,13 @@ r600 0x9400
 0x00028AB4 VGT_REUSE_OFF
 0x00028AB8 VGT_VTX_CNT_EN
 0x000088B0 VGT_VTX_VECT_EJECT_REG
+0x00028AD4 VGT_STRMOUT_VTX_STRIDE_0
+0x00028AE4 VGT_STRMOUT_VTX_STRIDE_1
+0x00028AF4 VGT_STRMOUT_VTX_STRIDE_2
+0x00028B04 VGT_STRMOUT_VTX_STRIDE_3
+0x00028B28 VGT_STRMOUT_DRAW_OPAQUE_OFFSET
+0x00028B2C VGT_STRMOUT_DRAW_OPAQUE_BUFFER_FILLED_SIZE
+0x00028B30 VGT_STRMOUT_DRAW_OPAQUE_VERTEX_STRIDE
 0x00028810 PA_CL_CLIP_CNTL
 0x00008A14 PA_CL_ENHANCE
 0x00028C14 PA_CL_GB_HORZ_CLIP_ADJ
@@ -429,6 +439,7 @@ r600 0x9400
 0x00028438 SX_ALPHA_REF
 0x00028410 SX_ALPHA_TEST_CONTROL
 0x00028350 SX_MISC
+0x00028354 SX_SURFACE_SYNC
 0x00009014 SX_MEMORY_EXPORT_SIZE
 0x00009604 TC_INVALIDATE
 0x00009400 TD_FILTER4
@@ -743,14 +754,6 @@ r600 0x9400
 0x00028114 CB_COLOR5_MASK
 0x00028118 CB_COLOR6_MASK
 0x0002811C CB_COLOR7_MASK
-0x00028080 CB_COLOR0_VIEW
-0x00028084 CB_COLOR1_VIEW
-0x00028088 CB_COLOR2_VIEW
-0x0002808C CB_COLOR3_VIEW
-0x00028090 CB_COLOR4_VIEW
-0x00028094 CB_COLOR5_VIEW
-0x00028098 CB_COLOR6_VIEW
-0x0002809C CB_COLOR7_VIEW
 0x00028808 CB_COLOR_CONTROL
 0x0002842C CB_FOG_BLUE
 0x00028428 CB_FOG_GREEN
diff --git a/drivers/gpu/drm/sis/sis_drv.c b/drivers/gpu/drm/sis/sis_drv.c
index 573220cc5269..30d98d14b5c5 100644
--- a/drivers/gpu/drm/sis/sis_drv.c
+++ b/drivers/gpu/drm/sis/sis_drv.c
@@ -41,6 +41,8 @@ static int sis_driver_load(struct drm_device *dev, unsigned long chipset)
 {
         drm_sis_private_t *dev_priv;
 
+        pci_set_master(dev->pdev);
+
         dev_priv = kzalloc(sizeof(drm_sis_private_t), GFP_KERNEL);
         if (dev_priv == NULL)
                 return -ENOMEM;
diff --git a/drivers/gpu/drm/via/via_map.c b/drivers/gpu/drm/via/via_map.c
index a2ab34365151..1f182254e81e 100644
--- a/drivers/gpu/drm/via/via_map.c
+++ b/drivers/gpu/drm/via/via_map.c
@@ -106,6 +106,8 @@ int via_driver_load(struct drm_device *dev, unsigned long chipset)
 
         idr_init(&dev->object_name_idr);
 
+        pci_set_master(dev->pdev);
+
         ret = drm_vblank_init(dev, 1);
         if (ret) {
                 kfree(dev_priv);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index f390f5f9cb68..1760aba9ecef 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -38,6 +38,10 @@
 #define VMWGFX_CHIP_SVGAII 0
 #define VMW_FB_RESERVATION 0
 
+#define VMW_MIN_INITIAL_WIDTH 800
+#define VMW_MIN_INITIAL_HEIGHT 600
+
+
 /**
  * Fully encoded drm commands. Might move to vmw_drm.h
  */
@@ -387,6 +391,41 @@ void vmw_3d_resource_dec(struct vmw_private *dev_priv,
         BUG_ON(n3d < 0);
 }
 
+/**
+ * Sets the initial_[width|height] fields on the given vmw_private.
+ *
+ * It does so by reading SVGA_REG_[WIDTH|HEIGHT] regs and then
+ * clamping the value to fb_max_[width|height] fields and the
+ * VMW_MIN_INITIAL_[WIDTH|HEIGHT].
+ * If the values appear to be invalid, set them to
+ * VMW_MIN_INITIAL_[WIDTH|HEIGHT].
+ */
+static void vmw_get_initial_size(struct vmw_private *dev_priv)
+{
+        uint32_t width;
+        uint32_t height;
+
+        width = vmw_read(dev_priv, SVGA_REG_WIDTH);
+        height = vmw_read(dev_priv, SVGA_REG_HEIGHT);
+
+        width = max_t(uint32_t, width, VMW_MIN_INITIAL_WIDTH);
+        height = max_t(uint32_t, height, VMW_MIN_INITIAL_HEIGHT);
+
+        if (width > dev_priv->fb_max_width ||
+            height > dev_priv->fb_max_height) {
+
+                /*
+                 * This is a host error and shouldn't occur.
+                 */
+
+                width = VMW_MIN_INITIAL_WIDTH;
+                height = VMW_MIN_INITIAL_HEIGHT;
+        }
+
+        dev_priv->initial_width = width;
+        dev_priv->initial_height = height;
+}
+
 static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
 {
         struct vmw_private *dev_priv;
@@ -400,6 +439,8 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         }
         memset(dev_priv, 0, sizeof(*dev_priv));
 
+        pci_set_master(dev->pdev);
+
         dev_priv->dev = dev;
         dev_priv->vmw_chipset = chipset;
         dev_priv->last_read_seqno = (uint32_t) -100;
@@ -441,6 +482,9 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         dev_priv->mmio_size = vmw_read(dev_priv, SVGA_REG_MEM_SIZE);
         dev_priv->fb_max_width = vmw_read(dev_priv, SVGA_REG_MAX_WIDTH);
         dev_priv->fb_max_height = vmw_read(dev_priv, SVGA_REG_MAX_HEIGHT);
+
+        vmw_get_initial_size(dev_priv);
+
         if (dev_priv->capabilities & SVGA_CAP_GMR) {
                 dev_priv->max_gmr_descriptors =
                         vmw_read(dev_priv,
@@ -688,6 +732,15 @@ static int vmw_driver_unload(struct drm_device *dev)
         return 0;
 }
 
+static void vmw_preclose(struct drm_device *dev,
+                         struct drm_file *file_priv)
+{
+        struct vmw_fpriv *vmw_fp = vmw_fpriv(file_priv);
+        struct vmw_private *dev_priv = vmw_priv(dev);
+
+        vmw_event_fence_fpriv_gone(dev_priv->fman, &vmw_fp->fence_events);
+}
+
 static void vmw_postclose(struct drm_device *dev,
                          struct drm_file *file_priv)
 {
@@ -710,6 +763,7 @@ static int vmw_driver_open(struct drm_device *dev, struct drm_file *file_priv)
         if (unlikely(vmw_fp == NULL))
                 return ret;
 
+        INIT_LIST_HEAD(&vmw_fp->fence_events);
         vmw_fp->tfile = ttm_object_file_init(dev_priv->tdev, 10);
         if (unlikely(vmw_fp->tfile == NULL))
                 goto out_no_tfile;
@@ -1102,6 +1156,7 @@ static struct drm_driver driver = {
         .master_set = vmw_master_set,
         .master_drop = vmw_master_drop,
         .open = vmw_driver_open,
+        .preclose = vmw_preclose,
         .postclose = vmw_postclose,
         .fops = &vmwgfx_driver_fops,
         .name = VMWGFX_DRIVER_NAME,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index dc279706ca70..d0f2c079ee27 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -40,9 +40,9 @@
 #include "ttm/ttm_module.h"
 #include "vmwgfx_fence.h"
 
-#define VMWGFX_DRIVER_DATE "20111025"
+#define VMWGFX_DRIVER_DATE "20120209"
 #define VMWGFX_DRIVER_MAJOR 2
-#define VMWGFX_DRIVER_MINOR 3
+#define VMWGFX_DRIVER_MINOR 4
 #define VMWGFX_DRIVER_PATCHLEVEL 0
 #define VMWGFX_FILE_PAGE_OFFSET 0x00100000
 #define VMWGFX_FIFO_STATIC_SIZE (1024*1024)
@@ -62,6 +62,7 @@
 struct vmw_fpriv {
         struct drm_master *locked_master;
         struct ttm_object_file *tfile;
+        struct list_head fence_events;
 };
 
 struct vmw_dma_buffer {
@@ -202,6 +203,8 @@ struct vmw_private {
         uint32_t mmio_size;
         uint32_t fb_max_width;
         uint32_t fb_max_height;
+        uint32_t initial_width;
+        uint32_t initial_height;
         __le32 __iomem *mmio_virt;
         int mmio_mtrr;
         uint32_t capabilities;
@@ -533,7 +536,8 @@ extern int vmw_execbuf_process(struct drm_file *file_priv,
                                uint32_t command_size,
                                uint64_t throttle_us,
                                struct drm_vmw_fence_rep __user
-                               *user_fence_rep);
+                               *user_fence_rep,
+                               struct vmw_fence_obj **out_fence);
 
 extern void
 vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
index 40932fbdac0f..4acced44a623 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
@@ -1109,10 +1109,11 @@ int vmw_execbuf_process(struct drm_file *file_priv,
                         void *kernel_commands,
                         uint32_t command_size,
                         uint64_t throttle_us,
-                        struct drm_vmw_fence_rep __user *user_fence_rep)
+                        struct drm_vmw_fence_rep __user *user_fence_rep,
+                        struct vmw_fence_obj **out_fence)
 {
         struct vmw_sw_context *sw_context = &dev_priv->ctx;
-        struct vmw_fence_obj *fence;
+        struct vmw_fence_obj *fence = NULL;
         uint32_t handle;
         void *cmd;
         int ret;
@@ -1208,8 +1209,13 @@ int vmw_execbuf_process(struct drm_file *file_priv,
         vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv), ret,
                                     user_fence_rep, fence, handle);
 
-        if (likely(fence != NULL))
+        /* Don't unreference when handing fence out */
+        if (unlikely(out_fence != NULL)) {
+                *out_fence = fence;
+                fence = NULL;
+        } else if (likely(fence != NULL)) {
                 vmw_fence_obj_unreference(&fence);
+        }
 
         mutex_unlock(&dev_priv->cmdbuf_mutex);
         return 0;
@@ -1362,7 +1368,8 @@ int vmw_execbuf_ioctl(struct drm_device *dev, void *data,
         ret = vmw_execbuf_process(file_priv, dev_priv,
                                   (void __user *)(unsigned long)arg->commands,
                                   NULL, arg->command_size, arg->throttle_us,
-                                  (void __user *)(unsigned long)arg->fence_rep);
+                                  (void __user *)(unsigned long)arg->fence_rep,
+                                  NULL);
 
         if (unlikely(ret != 0))
                 goto out_unlock;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
index 34e51a1695b8..3c447bf317cb 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
@@ -414,10 +414,6 @@ int vmw_fb_init(struct vmw_private *vmw_priv)
         unsigned fb_bpp, fb_depth, fb_offset, fb_pitch, fb_size;
         int ret;
 
-        /* XXX These shouldn't be hardcoded. */
-        initial_width = 800;
-        initial_height = 600;
-
         fb_bpp = 32;
         fb_depth = 24;
 
@@ -425,8 +421,8 @@ int vmw_fb_init(struct vmw_private *vmw_priv)
         fb_width = min(vmw_priv->fb_max_width, (unsigned)2048);
         fb_height = min(vmw_priv->fb_max_height, (unsigned)2048);
 
-        initial_width = min(fb_width, initial_width);
-        initial_height = min(fb_height, initial_height);
+        initial_width = min(vmw_priv->initial_width, fb_width);
+        initial_height = min(vmw_priv->initial_height, fb_height);
 
         fb_pitch = fb_width * fb_bpp / 8;
         fb_size = fb_pitch * fb_height;
@@ -515,19 +511,7 @@ int vmw_fb_init(struct vmw_private *vmw_priv)
         info->var.xres = initial_width;
         info->var.yres = initial_height;
 
-#if 0
-        info->pixmap.size = 64*1024;
-        info->pixmap.buf_align = 8;
-        info->pixmap.access_align = 32;
-        info->pixmap.flags = FB_PIXMAP_SYSTEM;
-        info->pixmap.scan_align = 1;
-#else
-        info->pixmap.size = 0;
-        info->pixmap.buf_align = 8;
-        info->pixmap.access_align = 32;
-        info->pixmap.flags = FB_PIXMAP_SYSTEM;
-        info->pixmap.scan_align = 1;
-#endif
+        /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
         info->apertures = alloc_apertures(1);
         if (!info->apertures) {
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
index 15fb26088d68..f2fb8f15e2f1 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
@@ -69,12 +69,13 @@ struct vmw_user_fence {
  * be assigned the current time tv_usec val when the fence signals.
  */
 struct vmw_event_fence_action {
-        struct drm_pending_event e;
         struct vmw_fence_action action;
+        struct list_head fpriv_head;
+
+        struct drm_pending_event *event;
         struct vmw_fence_obj *fence;
         struct drm_device *dev;
-        struct kref kref;
-        uint32_t size;
+
         uint32_t *tv_sec;
         uint32_t *tv_usec;
 };
@@ -784,46 +785,40 @@ int vmw_fence_obj_unref_ioctl(struct drm_device *dev, void *data,
 }
 
 /**
- * vmw_event_fence_action_destroy
- *
- * @kref: The struct kref embedded in a struct vmw_event_fence_action.
- *
- * The vmw_event_fence_action destructor that may be called either after
- * the fence action cleanup, or when the event is delivered.
- * It frees both the vmw_event_fence_action struct and the actual
- * event structure copied to user-space.
- */
-static void vmw_event_fence_action_destroy(struct kref *kref)
-{
-        struct vmw_event_fence_action *eaction =
-                container_of(kref, struct vmw_event_fence_action, kref);
-        struct ttm_mem_global *mem_glob =
-                vmw_mem_glob(vmw_priv(eaction->dev));
-        uint32_t size = eaction->size;
-
-        kfree(eaction->e.event);
-        kfree(eaction);
-        ttm_mem_global_free(mem_glob, size);
-}
-
-
-/**
- * vmw_event_fence_action_delivered
+ * vmw_event_fence_fpriv_gone - Remove references to struct drm_file objects
  *
- * @e: The struct drm_pending_event embedded in a struct
- * vmw_event_fence_action.
+ * @fman: Pointer to a struct vmw_fence_manager
+ * @event_list: Pointer to linked list of struct vmw_event_fence_action objects
+ * with pointers to a struct drm_file object about to be closed.
  *
- * The struct drm_pending_event destructor that is called by drm
- * once the event is delivered. Since we don't know whether this function
- * will be called before or after the fence action destructor, we
- * free a refcount and destroy if it becomes zero.
+ * This function removes all pending fence events with references to a
+ * specific struct drm_file object about to be closed. The caller is required
+ * to pass a list of all struct vmw_event_fence_action objects with such
+ * events attached. This function is typically called before the
+ * struct drm_file object's event management is taken down.
  */
-static void vmw_event_fence_action_delivered(struct drm_pending_event *e)
+void vmw_event_fence_fpriv_gone(struct vmw_fence_manager *fman,
+                                struct list_head *event_list)
 {
-        struct vmw_event_fence_action *eaction =
-                container_of(e, struct vmw_event_fence_action, e);
+        struct vmw_event_fence_action *eaction;
+        struct drm_pending_event *event;
+        unsigned long irq_flags;
 
-        kref_put(&eaction->kref, vmw_event_fence_action_destroy);
+        while (1) {
+                spin_lock_irqsave(&fman->lock, irq_flags);
+                if (list_empty(event_list))
+                        goto out_unlock;
+                eaction = list_first_entry(event_list,
+                                           struct vmw_event_fence_action,
+                                           fpriv_head);
+                list_del_init(&eaction->fpriv_head);
+                event = eaction->event;
+                eaction->event = NULL;
+                spin_unlock_irqrestore(&fman->lock, irq_flags);
+                event->destroy(event);
+        }
+out_unlock:
+        spin_unlock_irqrestore(&fman->lock, irq_flags);
 }
 
 
@@ -836,18 +831,21 @@ static void vmw_event_fence_action_delivered(struct drm_pending_event *e)
  * This function is called when the seqno of the fence where @action is
  * attached has passed. It queues the event on the submitter's event list.
  * This function is always called from atomic context, and may be called
- * from irq context. It ups a refcount reflecting that we now have two
- * destructors.
+ * from irq context.
  */
 static void vmw_event_fence_action_seq_passed(struct vmw_fence_action *action)
 {
         struct vmw_event_fence_action *eaction =
                 container_of(action, struct vmw_event_fence_action, action);
         struct drm_device *dev = eaction->dev;
-        struct drm_file *file_priv = eaction->e.file_priv;
+        struct drm_pending_event *event = eaction->event;
+        struct drm_file *file_priv;
         unsigned long irq_flags;
 
-        kref_get(&eaction->kref);
+        if (unlikely(event == NULL))
+                return;
+
+        file_priv = event->file_priv;
         spin_lock_irqsave(&dev->event_lock, irq_flags);
 
         if (likely(eaction->tv_sec != NULL)) {
@@ -858,7 +856,9 @@ static void vmw_event_fence_action_seq_passed(struct vmw_fence_action *action)
                 *eaction->tv_usec = tv.tv_usec;
         }
 
-        list_add_tail(&eaction->e.link, &file_priv->event_list);
+        list_del_init(&eaction->fpriv_head);
+        list_add_tail(&eaction->event->link, &file_priv->event_list);
+        eaction->event = NULL;
         wake_up_all(&file_priv->event_wait);
         spin_unlock_irqrestore(&dev->event_lock, irq_flags);
 }
@@ -876,9 +876,15 @@ static void vmw_event_fence_action_cleanup(struct vmw_fence_action *action)
 {
         struct vmw_event_fence_action *eaction =
                 container_of(action, struct vmw_event_fence_action, action);
+        struct vmw_fence_manager *fman = eaction->fence->fman;
+        unsigned long irq_flags;
+
+        spin_lock_irqsave(&fman->lock, irq_flags);
+        list_del(&eaction->fpriv_head);
+        spin_unlock_irqrestore(&fman->lock, irq_flags);
 
         vmw_fence_obj_unreference(&eaction->fence);
-        kref_put(&eaction->kref, vmw_event_fence_action_destroy);
+        kfree(eaction);
 }
 
 
@@ -946,39 +952,23 @@ void vmw_fence_obj_add_action(struct vmw_fence_obj *fence,
  * an error code, the caller needs to free that object.
  */
 
-int vmw_event_fence_action_create(struct drm_file *file_priv,
-                                  struct vmw_fence_obj *fence,
-                                  struct drm_event *event,
-                                  uint32_t *tv_sec,
-                                  uint32_t *tv_usec,
-                                  bool interruptible)
+int vmw_event_fence_action_queue(struct drm_file *file_priv,
+                                 struct vmw_fence_obj *fence,
+                                 struct drm_pending_event *event,
+                                 uint32_t *tv_sec,
+                                 uint32_t *tv_usec,
+                                 bool interruptible)
 {
         struct vmw_event_fence_action *eaction;
-        struct ttm_mem_global *mem_glob =
-                vmw_mem_glob(fence->fman->dev_priv);
         struct vmw_fence_manager *fman = fence->fman;
-        uint32_t size = fman->event_fence_action_size +
-                ttm_round_pot(event->length);
-        int ret;
-
-        /*
-         * Account for internal structure size as well as the
-         * event size itself.
-         */
-
-        ret = ttm_mem_global_alloc(mem_glob, size, false, interruptible);
-        if (unlikely(ret != 0))
-                return ret;
+        struct vmw_fpriv *vmw_fp = vmw_fpriv(file_priv);
+        unsigned long irq_flags;
 
         eaction = kzalloc(sizeof(*eaction), GFP_KERNEL);
-        if (unlikely(eaction == NULL)) {
-                ttm_mem_global_free(mem_glob, size);
+        if (unlikely(eaction == NULL))
                 return -ENOMEM;
-        }
 
-        eaction->e.event = event;
-        eaction->e.file_priv = file_priv;
-        eaction->e.destroy = vmw_event_fence_action_delivered;
+        eaction->event = event;
 
         eaction->action.seq_passed = vmw_event_fence_action_seq_passed;
         eaction->action.cleanup = vmw_event_fence_action_cleanup;
@@ -986,16 +976,89 @@ int vmw_event_fence_action_create(struct drm_file *file_priv,
 
         eaction->fence = vmw_fence_obj_reference(fence);
         eaction->dev = fman->dev_priv->dev;
-        eaction->size = size;
         eaction->tv_sec = tv_sec;
         eaction->tv_usec = tv_usec;
 
-        kref_init(&eaction->kref);
+        spin_lock_irqsave(&fman->lock, irq_flags);
+        list_add_tail(&eaction->fpriv_head, &vmw_fp->fence_events);
+        spin_unlock_irqrestore(&fman->lock, irq_flags);
+
         vmw_fence_obj_add_action(fence, &eaction->action);
 
         return 0;
 }
 
+struct vmw_event_fence_pending {
+        struct drm_pending_event base;
+        struct drm_vmw_event_fence event;
+};
+
+int vmw_event_fence_action_create(struct drm_file *file_priv,
+                                  struct vmw_fence_obj *fence,
+                                  uint32_t flags,
+                                  uint64_t user_data,
+                                  bool interruptible)
+{
+        struct vmw_event_fence_pending *event;
+        struct drm_device *dev = fence->fman->dev_priv->dev;
+        unsigned long irq_flags;
+        int ret;
+
+        spin_lock_irqsave(&dev->event_lock, irq_flags);
+
+        ret = (file_priv->event_space < sizeof(event->event)) ? -EBUSY : 0;
+        if (likely(ret == 0))
+                file_priv->event_space -= sizeof(event->event);
+
+        spin_unlock_irqrestore(&dev->event_lock, irq_flags);
+
+        if (unlikely(ret != 0)) {
+                DRM_ERROR("Failed to allocate event space for this file.\n");
+                goto out_no_space;
+        }
+
+
+        event = kzalloc(sizeof(event->event), GFP_KERNEL);
+        if (unlikely(event == NULL)) {
+                DRM_ERROR("Failed to allocate an event.\n");
+                ret = -ENOMEM;
+                goto out_no_event;
+        }
+
+        event->event.base.type = DRM_VMW_EVENT_FENCE_SIGNALED;
+        event->event.base.length = sizeof(*event);
+        event->event.user_data = user_data;
+
+        event->base.event = &event->event.base;
+        event->base.file_priv = file_priv;
+        event->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
+
+
+        if (flags & DRM_VMW_FE_FLAG_REQ_TIME)
+                ret = vmw_event_fence_action_queue(file_priv, fence,
+                                                   &event->base,
+                                                   &event->event.tv_sec,
+                                                   &event->event.tv_usec,
+                                                   interruptible);
+        else
+                ret = vmw_event_fence_action_queue(file_priv, fence,
+                                                   &event->base,
+                                                   NULL,
+                                                   NULL,
+                                                   interruptible);
+        if (ret != 0)
+                goto out_no_queue;
+
+out_no_queue:
+        event->base.destroy(&event->base);
+out_no_event:
+        spin_lock_irqsave(&dev->event_lock, irq_flags);
+        file_priv->event_space += sizeof(*event);
+        spin_unlock_irqrestore(&dev->event_lock, irq_flags);
+out_no_space:
+        return ret;
+}
+
 int vmw_fence_event_ioctl(struct drm_device *dev, void *data,
                           struct drm_file *file_priv)
 {
@@ -1008,8 +1071,6 @@ int vmw_fence_event_ioctl(struct drm_device *dev, void *data,
                 (struct drm_vmw_fence_rep __user *)(unsigned long)
                 arg->fence_rep;
         uint32_t handle;
-        unsigned long irq_flags;
-        struct drm_vmw_event_fence *event;
         int ret;
 
         /*
@@ -1062,59 +1123,28 @@ int vmw_fence_event_ioctl(struct drm_device *dev, void *data,
 
         BUG_ON(fence == NULL);
 
-        spin_lock_irqsave(&dev->event_lock, irq_flags);
-
-        ret = (file_priv->event_space < sizeof(*event)) ? -EBUSY : 0;
-        if (likely(ret == 0))
-                file_priv->event_space -= sizeof(*event);
-
-        spin_unlock_irqrestore(&dev->event_lock, irq_flags);
-
-        if (unlikely(ret != 0)) {
-                DRM_ERROR("Failed to allocate event space for this file.\n");
-                goto out_no_event_space;
-        }
-
-        event = kzalloc(sizeof(*event), GFP_KERNEL);
-        if (unlikely(event == NULL)) {
-                DRM_ERROR("Failed to allocate an event.\n");
-                goto out_no_event;
-        }
-
-        event->base.type = DRM_VMW_EVENT_FENCE_SIGNALED;
-        event->base.length = sizeof(*event);
-        event->user_data = arg->user_data;
-
         if (arg->flags & DRM_VMW_FE_FLAG_REQ_TIME)
                 ret = vmw_event_fence_action_create(file_priv, fence,
-                                                    &event->base,
-                                                    &event->tv_sec,
-                                                    &event->tv_usec,
+                                                    arg->flags,
+                                                    arg->user_data,
                                                     true);
         else
                 ret = vmw_event_fence_action_create(file_priv, fence,
-                                                    &event->base,
-                                                    NULL,
-                                                    NULL,
+                                                    arg->flags,
+                                                    arg->user_data,
                                                     true);
 
         if (unlikely(ret != 0)) {
                 if (ret != -ERESTARTSYS)
                         DRM_ERROR("Failed to attach event to fence.\n");
-                goto out_no_attach;
+                goto out_no_create;
         }
 
         vmw_execbuf_copy_fence_user(dev_priv, vmw_fp, 0, user_fence_rep, fence,
                                     handle);
         vmw_fence_obj_unreference(&fence);
         return 0;
-out_no_attach:
-        kfree(event);
-out_no_event:
-        spin_lock_irqsave(&dev->event_lock, irq_flags);
-        file_priv->event_space += sizeof(*event);
-        spin_unlock_irqrestore(&dev->event_lock, irq_flags);
-out_no_event_space:
+out_no_create:
         if (user_fence_rep != NULL)
                 ttm_ref_object_base_unref(vmw_fpriv(file_priv)->tfile,
                                           handle, TTM_REF_USAGE);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h
index 0854a2096b55..faf2e7873860 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.h
@@ -109,5 +109,12 @@ extern int vmw_fence_obj_unref_ioctl(struct drm_device *dev, void *data,
                                      struct drm_file *file_priv);
 extern int vmw_fence_event_ioctl(struct drm_device *dev, void *data,
                                  struct drm_file *file_priv);
-
+extern void vmw_event_fence_fpriv_gone(struct vmw_fence_manager *fman,
+                                       struct list_head *event_list);
+extern int vmw_event_fence_action_queue(struct drm_file *filee_priv,
+                                        struct vmw_fence_obj *fence,
+                                        struct drm_pending_event *event,
+                                        uint32_t *tv_sec,
+                                        uint32_t *tv_usec,
+                                        bool interruptible);
 #endif /* _VMWGFX_FENCE_H_ */
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index b66ef0e3cde1..2286d47e5022 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -422,7 +422,8 @@ static int do_surface_dirty_sou(struct vmw_private *dev_priv,
                                 struct vmw_framebuffer *framebuffer,
                                 unsigned flags, unsigned color,
                                 struct drm_clip_rect *clips,
-                                unsigned num_clips, int inc)
+                                unsigned num_clips, int inc,
+                                struct vmw_fence_obj **out_fence)
 {
         struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
         struct drm_clip_rect *clips_ptr;
@@ -542,12 +543,15 @@ static int do_surface_dirty_sou(struct vmw_private *dev_priv,
                 if (num == 0)
                         continue;
 
+                /* only return the last fence */
+                if (out_fence && *out_fence)
+                        vmw_fence_obj_unreference(out_fence);
 
                 /* recalculate package length */
                 fifo_size = sizeof(*cmd) + sizeof(SVGASignedRect) * num;
                 cmd->header.size = cpu_to_le32(fifo_size - sizeof(cmd->header));
                 ret = vmw_execbuf_process(file_priv, dev_priv, NULL, cmd,
-                                          fifo_size, 0, NULL);
+                                          fifo_size, 0, NULL, out_fence);
 
                 if (unlikely(ret != 0))
                         break;
@@ -598,7 +602,7 @@ int vmw_framebuffer_surface_dirty(struct drm_framebuffer *framebuffer,
 
         ret = do_surface_dirty_sou(dev_priv, file_priv, &vfbs->base,
                                    flags, color,
-                                   clips, num_clips, inc);
+                                   clips, num_clips, inc, NULL);
 
         ttm_read_unlock(&vmaster->lock);
         return 0;
@@ -809,7 +813,7 @@ static int do_dmabuf_define_gmrfb(struct drm_file *file_priv,
         cmd->body.ptr.offset = 0;
 
         ret = vmw_execbuf_process(file_priv, dev_priv, NULL, cmd,
-                                  fifo_size, 0, NULL);
+                                  fifo_size, 0, NULL, NULL);
 
         kfree(cmd);
 
@@ -821,7 +825,8 @@ static int do_dmabuf_dirty_sou(struct drm_file *file_priv,
                                struct vmw_framebuffer *framebuffer,
                                unsigned flags, unsigned color,
                                struct drm_clip_rect *clips,
-                               unsigned num_clips, int increment)
+                               unsigned num_clips, int increment,
+                               struct vmw_fence_obj **out_fence)
 {
         struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
         struct drm_clip_rect *clips_ptr;
@@ -894,9 +899,13 @@ static int do_dmabuf_dirty_sou(struct drm_file *file_priv,
                 if (hit_num == 0)
                         continue;
 
+                /* only return the last fence */
+                if (out_fence && *out_fence)
+                        vmw_fence_obj_unreference(out_fence);
+
                 fifo_size = sizeof(*blits) * hit_num;
                 ret = vmw_execbuf_process(file_priv, dev_priv, NULL, blits,
-                                          fifo_size, 0, NULL);
+                                          fifo_size, 0, NULL, out_fence);
 
                 if (unlikely(ret != 0))
                         break;
@@ -942,7 +951,7 @@ int vmw_framebuffer_dmabuf_dirty(struct drm_framebuffer *framebuffer,
         } else {
                 ret = do_dmabuf_dirty_sou(file_priv, dev_priv, &vfbd->base,
                                           flags, color,
-                                          clips, num_clips, increment);
+                                          clips, num_clips, increment, NULL);
         }
 
         ttm_read_unlock(&vmaster->lock);
@@ -1296,7 +1305,7 @@ int vmw_kms_present(struct vmw_private *dev_priv,
                 fifo_size = sizeof(*cmd) + sizeof(SVGASignedRect) * num;
                 cmd->header.size = cpu_to_le32(fifo_size - sizeof(cmd->header));
                 ret = vmw_execbuf_process(file_priv, dev_priv, NULL, cmd,
-                                          fifo_size, 0, NULL);
+                                          fifo_size, 0, NULL, NULL);
 
                 if (unlikely(ret != 0))
                         break;
@@ -1409,7 +1418,7 @@ int vmw_kms_readback(struct vmw_private *dev_priv,
         fifo_size = sizeof(*cmd) + sizeof(*blits) * blits_pos;
 
         ret = vmw_execbuf_process(file_priv, dev_priv, NULL, cmd, fifo_size,
-                                  0, user_fence_rep);
+                                  0, user_fence_rep, NULL);
 
         kfree(cmd);
 
@@ -1672,6 +1681,70 @@ int vmw_du_update_layout(struct vmw_private *dev_priv, unsigned num,
         return 0;
 }
 
+int vmw_du_page_flip(struct drm_crtc *crtc,
+                     struct drm_framebuffer *fb,
+                     struct drm_pending_vblank_event *event)
+{
+        struct vmw_private *dev_priv = vmw_priv(crtc->dev);
+        struct drm_framebuffer *old_fb = crtc->fb;
+        struct vmw_framebuffer *vfb = vmw_framebuffer_to_vfb(fb);
+        struct drm_file *file_priv = event->base.file_priv;
+        struct vmw_fence_obj *fence = NULL;
+        struct drm_clip_rect clips;
+        int ret;
+
+        /* require ScreenObject support for page flipping */
+        if (!dev_priv->sou_priv)
+                return -ENOSYS;
+
+        if (!vmw_kms_screen_object_flippable(dev_priv, crtc))
+                return -EINVAL;
+
+        crtc->fb = fb;
+
+        /* do a full screen dirty update */
+        clips.x1 = clips.y1 = 0;
+        clips.x2 = fb->width;
+        clips.y2 = fb->height;
+
+        if (vfb->dmabuf)
+                ret = do_dmabuf_dirty_sou(file_priv, dev_priv, vfb,
+                                          0, 0, &clips, 1, 1, &fence);
+        else
+                ret = do_surface_dirty_sou(dev_priv, file_priv, vfb,
+                                           0, 0, &clips, 1, 1, &fence);
+
+
+        if (ret != 0)
+                goto out_no_fence;
+        if (!fence) {
+                ret = -EINVAL;
+                goto out_no_fence;
+        }
+
+        ret = vmw_event_fence_action_queue(file_priv, fence,
+                                           &event->base,
+                                           &event->event.tv_sec,
+                                           &event->event.tv_usec,
+                                           true);
+
+        /*
+         * No need to hold on to this now. The only cleanup
+         * we need to do if we fail is unref the fence.
+         */
+        vmw_fence_obj_unreference(&fence);
+
+        if (vmw_crtc_to_du(crtc)->is_implicit)
+                vmw_kms_screen_object_update_implicit_fb(dev_priv, crtc);
+
+        return ret;
+
+out_no_fence:
+        crtc->fb = old_fb;
+        return ret;
+}
+
+
 void vmw_du_crtc_save(struct drm_crtc *crtc)
 {
 }
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h
index a4f7f034996a..8184bc5b1730 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h
@@ -121,6 +121,9 @@ struct vmw_display_unit {
  * Shared display unit functions - vmwgfx_kms.c
  */
 void vmw_display_unit_cleanup(struct vmw_display_unit *du);
+int vmw_du_page_flip(struct drm_crtc *crtc,
+                     struct drm_framebuffer *fb,
+                     struct drm_pending_vblank_event *event);
 void vmw_du_crtc_save(struct drm_crtc *crtc);
 void vmw_du_crtc_restore(struct drm_crtc *crtc);
 void vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
@@ -154,5 +157,10 @@ int vmw_kms_init_screen_object_display(struct vmw_private *dev_priv);
 int vmw_kms_close_screen_object_display(struct vmw_private *dev_priv);
 int vmw_kms_sou_update_layout(struct vmw_private *dev_priv, unsigned num,
                               struct drm_vmw_rect *rects);
+bool vmw_kms_screen_object_flippable(struct vmw_private *dev_priv,
+                                     struct drm_crtc *crtc);
+void vmw_kms_screen_object_update_implicit_fb(struct vmw_private *dev_priv,
+                                              struct drm_crtc *crtc);
+
 
 #endif
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
index f77b184be807..070fb239c5af 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
@@ -354,8 +354,8 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
         INIT_LIST_HEAD(&ldu->active);
 
         ldu->base.pref_active = (unit == 0);
-        ldu->base.pref_width = 800;
-        ldu->base.pref_height = 600;
+        ldu->base.pref_width = dev_priv->initial_width;
+        ldu->base.pref_height = dev_priv->initial_height;
         ldu->base.pref_mode = NULL;
         ldu->base.is_implicit = true;
 
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
index 4defdcf1c72e..6deaf2f8bab1 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c
@@ -394,6 +394,7 @@ static struct drm_crtc_funcs vmw_screen_object_crtc_funcs = {
         .gamma_set = vmw_du_crtc_gamma_set,
         .destroy = vmw_sou_crtc_destroy,
         .set_config = vmw_sou_crtc_set_config,
+        .page_flip = vmw_du_page_flip,
 };
 
 /*
@@ -448,8 +449,8 @@ static int vmw_sou_init(struct vmw_private *dev_priv, unsigned unit)
         sou->active_implicit = false;
 
         sou->base.pref_active = (unit == 0);
-        sou->base.pref_width = 800;
-        sou->base.pref_height = 600;
+        sou->base.pref_width = dev_priv->initial_width;
+        sou->base.pref_height = dev_priv->initial_height;
         sou->base.pref_mode = NULL;
         sou->base.is_implicit = true;
 
@@ -535,3 +536,36 @@ int vmw_kms_close_screen_object_display(struct vmw_private *dev_priv)
 
         return 0;
 }
+
+/**
+ * Returns if this unit can be page flipped.
+ * Must be called with the mode_config mutex held.
+ */
+bool vmw_kms_screen_object_flippable(struct vmw_private *dev_priv,
+                                     struct drm_crtc *crtc)
+{
+        struct vmw_screen_object_unit *sou = vmw_crtc_to_sou(crtc);
+
+        if (!sou->base.is_implicit)
+                return true;
+
+        if (dev_priv->sou_priv->num_implicit != 1)
+                return false;
+
+        return true;
+}
+
+/**
+ * Update the implicit fb to the current fb of this crtc.
+ * Must be called with the mode_config mutex held.
+ */
+void vmw_kms_screen_object_update_implicit_fb(struct vmw_private *dev_priv,
+                                              struct drm_crtc *crtc)
+{
+        struct vmw_screen_object_unit *sou = vmw_crtc_to_sou(crtc);
+
+        BUG_ON(!sou->base.is_implicit);
+
+        dev_priv->sou_priv->implicit_fb =
+                vmw_framebuffer_to_vfb(sou->base.crtc.fb);
+}