191 files changed, 3353 insertions, 3238 deletions

diff --git a/drivers/bluetooth/bluecard_cs.c b/drivers/bluetooth/bluecard_cs.c
index 6f907ebed2d5..6d34f405a2f3 100644
--- a/drivers/bluetooth/bluecard_cs.c
+++ b/drivers/bluetooth/bluecard_cs.c
@@ -37,7 +37,7 @@
 #include <linux/wait.h>
 
 #include <linux/skbuff.h>
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
diff --git a/drivers/bluetooth/hci_bcsp.c b/drivers/bluetooth/hci_bcsp.c
index 40aec0fb8596..42d69d4de05c 100644
--- a/drivers/bluetooth/hci_bcsp.c
+++ b/drivers/bluetooth/hci_bcsp.c
@@ -244,7 +244,7 @@ static struct sk_buff *bcsp_prepare_pkt(struct bcsp_struct *bcsp, u8 *data,
         if (rel) {
                 hdr[0] |= 0x80 + bcsp->msgq_txseq;
                 BT_DBG("Sending packet with seqno %u", bcsp->msgq_txseq);
-                bcsp->msgq_txseq = ++(bcsp->msgq_txseq) & 0x07;
+                bcsp->msgq_txseq = (bcsp->msgq_txseq + 1) & 0x07;
         }
 
         if (bcsp->use_crc)
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 5d64e3acb000..878ac0c2cc68 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -493,7 +493,7 @@ static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
                 sysrq_key_table[i] = op_p;
 }
 
-static void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
+void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
 {
         struct sysrq_key_op *op_p;
         int orig_log_level;
diff --git a/drivers/clocksource/cs5535-clockevt.c b/drivers/clocksource/cs5535-clockevt.c
index d7be69f13154..b7dab32ce63c 100644
--- a/drivers/clocksource/cs5535-clockevt.c
+++ b/drivers/clocksource/cs5535-clockevt.c
@@ -194,6 +194,6 @@ err_timer:
 
 module_init(cs5535_mfgpt_init);
 
-MODULE_AUTHOR("Andres Salomon <dilinger@collabora.co.uk>");
+MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
 MODULE_DESCRIPTION("CS5535/CS5536 MFGPT clock event driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index 637c105f53d2..bd78acf3c365 100644
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -1183,10 +1183,14 @@ static size_t sg_copy_end_to_buffer(struct scatterlist *sgl, unsigned int nents,
                                 /* Copy part of this segment */
                                 ignore = skip - offset;
                                 len = miter.length - ignore;
+                                if (boffset + len > buflen)
+                                        len = buflen - boffset;
                                 memcpy(buf + boffset, miter.addr + ignore, len);
                         } else {
-                                /* Copy all of this segment */
+                                /* Copy all of this segment (up to buflen) */
                                 len = miter.length;
+                                if (boffset + len > buflen)
+                                        len = buflen - boffset;
                                 memcpy(buf + boffset, miter.addr, len);
                         }
                         boffset += len;
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index aedef7941b22..0d2f9dbb47e4 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -209,7 +209,7 @@ config EDAC_I5100
 
 config EDAC_MPC85XX
         tristate "Freescale MPC83xx / MPC85xx"
-        depends on EDAC_MM_EDAC && FSL_SOC && (PPC_83xx || MPC85xx)
+        depends on EDAC_MM_EDAC && FSL_SOC && (PPC_83xx || PPC_85xx)
         help
           Support for error detection and correction on the Freescale
           MPC8349, MPC8560, MPC8540, MPC8548
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index 52ca09bf4726..f39b00a46eda 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -1120,6 +1120,7 @@ static struct of_device_id mpc85xx_mc_err_of_match[] = {
         { .compatible = "fsl,mpc8555-memory-controller", },
         { .compatible = "fsl,mpc8560-memory-controller", },
         { .compatible = "fsl,mpc8568-memory-controller", },
+        { .compatible = "fsl,mpc8569-memory-controller", },
         { .compatible = "fsl,mpc8572-memory-controller", },
         { .compatible = "fsl,mpc8349-memory-controller", },
         { .compatible = "fsl,p2020-memory-controller", },
diff --git a/drivers/gpio/cs5535-gpio.c b/drivers/gpio/cs5535-gpio.c
index f73a1555e49d..e23c06893d19 100644
--- a/drivers/gpio/cs5535-gpio.c
+++ b/drivers/gpio/cs5535-gpio.c
@@ -352,6 +352,6 @@ static void __exit cs5535_gpio_exit(void)
 module_init(cs5535_gpio_init);
 module_exit(cs5535_gpio_exit);
 
-MODULE_AUTHOR("Andres Salomon <dilinger@collabora.co.uk>");
+MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
 MODULE_DESCRIPTION("AMD CS5535/CS5536 GPIO driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 5b7a1a4692a0..4cab0c6397e3 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -61,6 +61,7 @@ config DRM_RADEON
         select DRM_KMS_HELPER
         select DRM_TTM
         select POWER_SUPPLY
+        select HWMON
         help
           Choose this option if you have an ATI Radeon graphics card.  There
           are both PCI and AGP versions.  You don't need to choose this to
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 57cea01c4ffb..4c68f76993d8 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -80,6 +80,7 @@ static struct drm_prop_enum_list drm_dithering_mode_enum_list[] =
 {
         { DRM_MODE_DITHERING_OFF, "Off" },
         { DRM_MODE_DITHERING_ON, "On" },
+        { DRM_MODE_DITHERING_AUTO, "Automatic" },
 };
 
 /*
@@ -1126,7 +1127,7 @@ int drm_mode_getresources(struct drm_device *dev, void *data,
                 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
                         list_for_each_entry(crtc, &dev->mode_config.crtc_list,
                                             head) {
-                                DRM_DEBUG_KMS("CRTC ID is %d\n", crtc->base.id);
+                                DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
                                 if (put_user(crtc->base.id, crtc_id + copied)) {
                                         ret = -EFAULT;
                                         goto out;
@@ -1154,8 +1155,8 @@ int drm_mode_getresources(struct drm_device *dev, void *data,
                         list_for_each_entry(encoder,
                                             &dev->mode_config.encoder_list,
                                             head) {
-                                DRM_DEBUG_KMS("ENCODER ID is %d\n",
-                                          encoder->base.id);
+                                DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
+                                                drm_get_encoder_name(encoder));
                                 if (put_user(encoder->base.id, encoder_id +
                                              copied)) {
                                         ret = -EFAULT;
@@ -1185,8 +1186,9 @@ int drm_mode_getresources(struct drm_device *dev, void *data,
                         list_for_each_entry(connector,
                                             &dev->mode_config.connector_list,
                                             head) {
-                                DRM_DEBUG_KMS("CONNECTOR ID is %d\n",
-                                          connector->base.id);
+                                DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+                                        connector->base.id,
+                                        drm_get_connector_name(connector));
                                 if (put_user(connector->base.id,
                                              connector_id + copied)) {
                                         ret = -EFAULT;
@@ -1209,7 +1211,7 @@ int drm_mode_getresources(struct drm_device *dev, void *data,
         }
         card_res->count_connectors = connector_count;
 
-        DRM_DEBUG_KMS("Counted %d %d %d\n", card_res->count_crtcs,
+        DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
                   card_res->count_connectors, card_res->count_encoders);
 
 out:
@@ -1312,7 +1314,7 @@ int drm_mode_getconnector(struct drm_device *dev, void *data,
 
         memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
 
-        DRM_DEBUG_KMS("connector id %d:\n", out_resp->connector_id);
+        DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
 
         mutex_lock(&dev->mode_config.mutex);
 
@@ -1493,6 +1495,7 @@ int drm_mode_setcrtc(struct drm_device *dev, void *data,
                 goto out;
         }
         crtc = obj_to_crtc(obj);
+        DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 
         if (crtc_req->mode_valid) {
                 /* If we have a mode we need a framebuffer. */
@@ -1569,6 +1572,9 @@ int drm_mode_setcrtc(struct drm_device *dev, void *data,
                                 goto out;
                         }
                         connector = obj_to_connector(obj);
+                        DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+                                        connector->base.id,
+                                        drm_get_connector_name(connector));
 
                         connector_set[i] = connector;
                 }
@@ -1684,6 +1690,7 @@ int drm_mode_addfb(struct drm_device *dev,
 
         r->fb_id = fb->base.id;
         list_add(&fb->filp_head, &file_priv->fbs);
+        DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
 
 out:
         mutex_unlock(&dev->mode_config.mutex);
@@ -2610,6 +2617,15 @@ int drm_mode_page_flip_ioctl(struct drm_device *dev,
                 goto out;
         crtc = obj_to_crtc(obj);
 
+        if (crtc->fb == NULL) {
+                /* The framebuffer is currently unbound, presumably
+                 * due to a hotplug event, that userspace has not
+                 * yet discovered.
+                 */
+                ret = -EBUSY;
+                goto out;
+        }
+
         if (crtc->funcs->page_flip == NULL)
                 goto out;
 
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index 774d21e4dcdd..11fe9c870d17 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -86,7 +86,8 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
         int count = 0;
         int mode_flags = 0;
 
-        DRM_DEBUG_KMS("%s\n", drm_get_connector_name(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)
                 mode->status = MODE_UNVERIFIED;
@@ -102,8 +103,8 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
                 connector->status = connector->funcs->detect(connector);
 
         if (connector->status == connector_status_disconnected) {
-                DRM_DEBUG_KMS("%s is disconnected\n",
-                          drm_get_connector_name(connector));
+                DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
+                        connector->base.id, drm_get_connector_name(connector));
                 drm_mode_connector_update_edid_property(connector, NULL);
                 goto prune;
         }
@@ -141,8 +142,8 @@ prune:
 
         drm_mode_sort(&connector->modes);
 
-        DRM_DEBUG_KMS("Probed modes for %s\n",
-                                drm_get_connector_name(connector));
+        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) {
                 mode->vrefresh = drm_mode_vrefresh(mode);
 
@@ -374,6 +375,7 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
         if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
                 goto done;
         }
+        DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 
         /* Prepare the encoders and CRTCs before setting the mode. */
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
@@ -401,8 +403,9 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
                 if (encoder->crtc != crtc)
                         continue;
 
-                DRM_DEBUG("%s: set mode %s %x\n", drm_get_encoder_name(encoder),
-                         mode->name, mode->base.id);
+                DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
+                        encoder->base.id, drm_get_encoder_name(encoder),
+                        mode->base.id, mode->name);
                 encoder_funcs = encoder->helper_private;
                 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
         }
@@ -478,10 +481,15 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
 
         crtc_funcs = set->crtc->helper_private;
 
-        DRM_DEBUG_KMS("crtc: %p %d fb: %p connectors: %p num_connectors:"
-                        " %d (x, y) (%i, %i)\n",
-                  set->crtc, set->crtc->base.id, set->fb, set->connectors,
-                  (int)set->num_connectors, set->x, set->y);
+        if (set->fb) {
+                DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
+                                set->crtc->base.id, set->fb->base.id,
+                                (int)set->num_connectors, set->x, set->y);
+        } else {
+                DRM_DEBUG_KMS("[CRTC:%d] [NOFB] #connectors=%d (x y) (%i %i)\n",
+                                set->crtc->base.id, (int)set->num_connectors,
+                                set->x, set->y);
+        }
 
         dev = set->crtc->dev;
 
@@ -610,8 +618,14 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
                         mode_changed = true;
                         connector->encoder->crtc = new_crtc;
                 }
-                DRM_DEBUG_KMS("setting connector %d crtc to %p\n",
-                          connector->base.id, new_crtc);
+                if (new_crtc) {
+                        DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
+                                connector->base.id, drm_get_connector_name(connector),
+                                new_crtc->base.id);
+                } else {
+                        DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
+                                connector->base.id, drm_get_connector_name(connector));
+                }
         }
 
         /* mode_set_base is not a required function */
@@ -629,8 +643,8 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
                         if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
                                                       set->x, set->y,
                                                       old_fb)) {
-                                DRM_ERROR("failed to set mode on crtc %p\n",
-                                          set->crtc);
+                                DRM_ERROR("failed to set mode on [CRTC:%d]\n",
+                                          set->crtc->base.id);
                                 ret = -EINVAL;
                                 goto fail;
                         }
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 510bc87d98f6..b5a51686f492 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -335,6 +335,7 @@ static void __exit drm_core_exit(void)
 
         unregister_chrdev(DRM_MAJOR, "drm");
 
+        idr_remove_all(&drm_minors_idr);
         idr_destroy(&drm_minors_idr);
 }
 
diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
index 8601b72b6f26..4f1b86714489 100644
--- a/drivers/gpu/drm/drm_gem.c
+++ b/drivers/gpu/drm/drm_gem.c
@@ -429,6 +429,7 @@ drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
         idr_for_each(&file_private->object_idr,
                      &drm_gem_object_release_handle, NULL);
 
+        idr_remove_all(&file_private->object_idr);
         idr_destroy(&file_private->object_idr);
 }
 
diff --git a/drivers/gpu/drm/drm_stub.c b/drivers/gpu/drm/drm_stub.c
index 63575e2fa882..d1ad57450df1 100644
--- a/drivers/gpu/drm/drm_stub.c
+++ b/drivers/gpu/drm/drm_stub.c
@@ -156,6 +156,9 @@ static void drm_master_destroy(struct kref *kref)
                 master->unique_len = 0;
         }
 
+        kfree(dev->devname);
+        dev->devname = NULL;
+
         list_for_each_entry_safe(pt, next, &master->magicfree, head) {
                 list_del(&pt->head);
                 drm_ht_remove_item(&master->magiclist, &pt->hash_item);
diff --git a/drivers/gpu/drm/i2c/Makefile b/drivers/gpu/drm/i2c/Makefile
index 6d2abaf35ba2..92862563e7ee 100644
--- a/drivers/gpu/drm/i2c/Makefile
+++ b/drivers/gpu/drm/i2c/Makefile
@@ -2,3 +2,6 @@ ccflags-y := -Iinclude/drm
 
 ch7006-y := ch7006_drv.o ch7006_mode.o
 obj-$(CONFIG_DRM_I2C_CH7006) += ch7006.o
+
+sil164-y := sil164_drv.o
+obj-$(CONFIG_DRM_I2C_SIL164) += sil164.o
diff --git a/drivers/gpu/drm/i2c/sil164_drv.c b/drivers/gpu/drm/i2c/sil164_drv.c
new file mode 100644
index 000000000000..0b6773290c08
--- /dev/null
+++ b/drivers/gpu/drm/i2c/sil164_drv.c
@@ -0,0 +1,462 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, 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 OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "drmP.h"
+#include "drm_crtc_helper.h"
+#include "drm_encoder_slave.h"
+#include "i2c/sil164.h"
+
+struct sil164_priv {
+        struct sil164_encoder_params config;
+        struct i2c_client *duallink_slave;
+
+        uint8_t saved_state[0x10];
+        uint8_t saved_slave_state[0x10];
+};
+
+#define to_sil164_priv(x) \
+        ((struct sil164_priv *)to_encoder_slave(x)->slave_priv)
+
+#define sil164_dbg(client, format, ...) do {                            \
+                if (drm_debug & DRM_UT_KMS)                             \
+                        dev_printk(KERN_DEBUG, &client->dev,            \
+                                   "%s: " format, __func__, ## __VA_ARGS__); \
+        } while (0)
+#define sil164_info(client, format, ...)                \
+        dev_info(&client->dev, format, __VA_ARGS__)
+#define sil164_err(client, format, ...)                 \
+        dev_err(&client->dev, format, __VA_ARGS__)
+
+#define SIL164_I2C_ADDR_MASTER                  0x38
+#define SIL164_I2C_ADDR_SLAVE                   0x39
+
+/* HW register definitions */
+
+#define SIL164_VENDOR_LO                        0x0
+#define SIL164_VENDOR_HI                        0x1
+#define SIL164_DEVICE_LO                        0x2
+#define SIL164_DEVICE_HI                        0x3
+#define SIL164_REVISION                         0x4
+#define SIL164_FREQ_MIN                         0x6
+#define SIL164_FREQ_MAX                         0x7
+#define SIL164_CONTROL0                         0x8
+#  define SIL164_CONTROL0_POWER_ON              0x01
+#  define SIL164_CONTROL0_EDGE_RISING           0x02
+#  define SIL164_CONTROL0_INPUT_24BIT           0x04
+#  define SIL164_CONTROL0_DUAL_EDGE             0x08
+#  define SIL164_CONTROL0_HSYNC_ON              0x10
+#  define SIL164_CONTROL0_VSYNC_ON              0x20
+#define SIL164_DETECT                           0x9
+#  define SIL164_DETECT_INTR_STAT               0x01
+#  define SIL164_DETECT_HOTPLUG_STAT            0x02
+#  define SIL164_DETECT_RECEIVER_STAT           0x04
+#  define SIL164_DETECT_INTR_MODE_RECEIVER      0x00
+#  define SIL164_DETECT_INTR_MODE_HOTPLUG       0x08
+#  define SIL164_DETECT_OUT_MODE_HIGH           0x00
+#  define SIL164_DETECT_OUT_MODE_INTR           0x10
+#  define SIL164_DETECT_OUT_MODE_RECEIVER       0x20
+#  define SIL164_DETECT_OUT_MODE_HOTPLUG        0x30
+#  define SIL164_DETECT_VSWING_STAT             0x80
+#define SIL164_CONTROL1                         0xa
+#  define SIL164_CONTROL1_DESKEW_ENABLE         0x10
+#  define SIL164_CONTROL1_DESKEW_INCR_SHIFT     5
+#define SIL164_GPIO                             0xb
+#define SIL164_CONTROL2                         0xc
+#  define SIL164_CONTROL2_FILTER_ENABLE         0x01
+#  define SIL164_CONTROL2_FILTER_SETTING_SHIFT  1
+#  define SIL164_CONTROL2_DUALLINK_MASTER       0x40
+#  define SIL164_CONTROL2_SYNC_CONT             0x80
+#define SIL164_DUALLINK                         0xd
+#  define SIL164_DUALLINK_ENABLE                0x10
+#  define SIL164_DUALLINK_SKEW_SHIFT            5
+#define SIL164_PLLZONE                          0xe
+#  define SIL164_PLLZONE_STAT                   0x08
+#  define SIL164_PLLZONE_FORCE_ON               0x10
+#  define SIL164_PLLZONE_FORCE_HIGH             0x20
+
+/* HW access functions */
+
+static void
+sil164_write(struct i2c_client *client, uint8_t addr, uint8_t val)
+{
+        uint8_t buf[] = {addr, val};
+        int ret;
+
+        ret = i2c_master_send(client, buf, ARRAY_SIZE(buf));
+        if (ret < 0)
+                sil164_err(client, "Error %d writing to subaddress 0x%x\n",
+                           ret, addr);
+}
+
+static uint8_t
+sil164_read(struct i2c_client *client, uint8_t addr)
+{
+        uint8_t val;
+        int ret;
+
+        ret = i2c_master_send(client, &addr, sizeof(addr));
+        if (ret < 0)
+                goto fail;
+
+        ret = i2c_master_recv(client, &val, sizeof(val));
+        if (ret < 0)
+                goto fail;
+
+        return val;
+
+fail:
+        sil164_err(client, "Error %d reading from subaddress 0x%x\n",
+                   ret, addr);
+        return 0;
+}
+
+static void
+sil164_save_state(struct i2c_client *client, uint8_t *state)
+{
+        int i;
+
+        for (i = 0x8; i <= 0xe; i++)
+                state[i] = sil164_read(client, i);
+}
+
+static void
+sil164_restore_state(struct i2c_client *client, uint8_t *state)
+{
+        int i;
+
+        for (i = 0x8; i <= 0xe; i++)
+                sil164_write(client, i, state[i]);
+}
+
+static void
+sil164_set_power_state(struct i2c_client *client, bool on)
+{
+        uint8_t control0 = sil164_read(client, SIL164_CONTROL0);
+
+        if (on)
+                control0 |= SIL164_CONTROL0_POWER_ON;
+        else
+                control0 &= ~SIL164_CONTROL0_POWER_ON;
+
+        sil164_write(client, SIL164_CONTROL0, control0);
+}
+
+static void
+sil164_init_state(struct i2c_client *client,
+                  struct sil164_encoder_params *config,
+                  bool duallink)
+{
+        sil164_write(client, SIL164_CONTROL0,
+                     SIL164_CONTROL0_HSYNC_ON |
+                     SIL164_CONTROL0_VSYNC_ON |
+                     (config->input_edge ? SIL164_CONTROL0_EDGE_RISING : 0) |
+                     (config->input_width ? SIL164_CONTROL0_INPUT_24BIT : 0) |
+                     (config->input_dual ? SIL164_CONTROL0_DUAL_EDGE : 0));
+
+        sil164_write(client, SIL164_DETECT,
+                     SIL164_DETECT_INTR_STAT |
+                     SIL164_DETECT_OUT_MODE_RECEIVER);
+
+        sil164_write(client, SIL164_CONTROL1,
+                     (config->input_skew ? SIL164_CONTROL1_DESKEW_ENABLE : 0) |
+                     (((config->input_skew + 4) & 0x7)
+                      << SIL164_CONTROL1_DESKEW_INCR_SHIFT));
+
+        sil164_write(client, SIL164_CONTROL2,
+                     SIL164_CONTROL2_SYNC_CONT |
+                     (config->pll_filter ? 0 : SIL164_CONTROL2_FILTER_ENABLE) |
+                     (4 << SIL164_CONTROL2_FILTER_SETTING_SHIFT));
+
+        sil164_write(client, SIL164_PLLZONE, 0);
+
+        if (duallink)
+                sil164_write(client, SIL164_DUALLINK,
+                             SIL164_DUALLINK_ENABLE |
+                             (((config->duallink_skew + 4) & 0x7)
+                              << SIL164_DUALLINK_SKEW_SHIFT));
+        else
+                sil164_write(client, SIL164_DUALLINK, 0);
+}
+
+/* DRM encoder functions */
+
+static void
+sil164_encoder_set_config(struct drm_encoder *encoder, void *params)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+
+        priv->config = *(struct sil164_encoder_params *)params;
+}
+
+static void
+sil164_encoder_dpms(struct drm_encoder *encoder, int mode)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+        bool on = (mode == DRM_MODE_DPMS_ON);
+        bool duallink = (on && encoder->crtc->mode.clock > 165000);
+
+        sil164_set_power_state(drm_i2c_encoder_get_client(encoder), on);
+
+        if (priv->duallink_slave)
+                sil164_set_power_state(priv->duallink_slave, duallink);
+}
+
+static void
+sil164_encoder_save(struct drm_encoder *encoder)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+
+        sil164_save_state(drm_i2c_encoder_get_client(encoder),
+                          priv->saved_state);
+
+        if (priv->duallink_slave)
+                sil164_save_state(priv->duallink_slave,
+                                  priv->saved_slave_state);
+}
+
+static void
+sil164_encoder_restore(struct drm_encoder *encoder)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+
+        sil164_restore_state(drm_i2c_encoder_get_client(encoder),
+                             priv->saved_state);
+
+        if (priv->duallink_slave)
+                sil164_restore_state(priv->duallink_slave,
+                                     priv->saved_slave_state);
+}
+
+static bool
+sil164_encoder_mode_fixup(struct drm_encoder *encoder,
+                          struct drm_display_mode *mode,
+                          struct drm_display_mode *adjusted_mode)
+{
+        return true;
+}
+
+static int
+sil164_encoder_mode_valid(struct drm_encoder *encoder,
+                          struct drm_display_mode *mode)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+
+        if (mode->clock < 32000)
+                return MODE_CLOCK_LOW;
+
+        if (mode->clock > 330000 ||
+            (mode->clock > 165000 && !priv->duallink_slave))
+                return MODE_CLOCK_HIGH;
+
+        return MODE_OK;
+}
+
+static void
+sil164_encoder_mode_set(struct drm_encoder *encoder,
+                        struct drm_display_mode *mode,
+                        struct drm_display_mode *adjusted_mode)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+        bool duallink = adjusted_mode->clock > 165000;
+
+        sil164_init_state(drm_i2c_encoder_get_client(encoder),
+                          &priv->config, duallink);
+
+        if (priv->duallink_slave)
+                sil164_init_state(priv->duallink_slave,
+                                  &priv->config, duallink);
+
+        sil164_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
+}
+
+static enum drm_connector_status
+sil164_encoder_detect(struct drm_encoder *encoder,
+                      struct drm_connector *connector)
+{
+        struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
+
+        if (sil164_read(client, SIL164_DETECT) & SIL164_DETECT_HOTPLUG_STAT)
+                return connector_status_connected;
+        else
+                return connector_status_disconnected;
+}
+
+static int
+sil164_encoder_get_modes(struct drm_encoder *encoder,
+                         struct drm_connector *connector)
+{
+        return 0;
+}
+
+static int
+sil164_encoder_create_resources(struct drm_encoder *encoder,
+                                struct drm_connector *connector)
+{
+        return 0;
+}
+
+static int
+sil164_encoder_set_property(struct drm_encoder *encoder,
+                            struct drm_connector *connector,
+                            struct drm_property *property,
+                            uint64_t val)
+{
+        return 0;
+}
+
+static void
+sil164_encoder_destroy(struct drm_encoder *encoder)
+{
+        struct sil164_priv *priv = to_sil164_priv(encoder);
+
+        if (priv->duallink_slave)
+                i2c_unregister_device(priv->duallink_slave);
+
+        kfree(priv);
+        drm_i2c_encoder_destroy(encoder);
+}
+
+static struct drm_encoder_slave_funcs sil164_encoder_funcs = {
+        .set_config = sil164_encoder_set_config,
+        .destroy = sil164_encoder_destroy,
+        .dpms = sil164_encoder_dpms,
+        .save = sil164_encoder_save,
+        .restore = sil164_encoder_restore,
+        .mode_fixup = sil164_encoder_mode_fixup,
+        .mode_valid = sil164_encoder_mode_valid,
+        .mode_set = sil164_encoder_mode_set,
+        .detect = sil164_encoder_detect,
+        .get_modes = sil164_encoder_get_modes,
+        .create_resources = sil164_encoder_create_resources,
+        .set_property = sil164_encoder_set_property,
+};
+
+/* I2C driver functions */
+
+static int
+sil164_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        int vendor = sil164_read(client, SIL164_VENDOR_HI) << 8 |
+                sil164_read(client, SIL164_VENDOR_LO);
+        int device = sil164_read(client, SIL164_DEVICE_HI) << 8 |
+                sil164_read(client, SIL164_DEVICE_LO);
+        int rev = sil164_read(client, SIL164_REVISION);
+
+        if (vendor != 0x1 || device != 0x6) {
+                sil164_dbg(client, "Unknown device %x:%x.%x\n",
+                           vendor, device, rev);
+                return -ENODEV;
+        }
+
+        sil164_info(client, "Detected device %x:%x.%x\n",
+                    vendor, device, rev);
+
+        return 0;
+}
+
+static int
+sil164_remove(struct i2c_client *client)
+{
+        return 0;
+}
+
+static struct i2c_client *
+sil164_detect_slave(struct i2c_client *client)
+{
+        struct i2c_adapter *adap = client->adapter;
+        struct i2c_msg msg = {
+                .addr = SIL164_I2C_ADDR_SLAVE,
+                .len = 0,
+        };
+        const struct i2c_board_info info = {
+                I2C_BOARD_INFO("sil164", SIL164_I2C_ADDR_SLAVE)
+        };
+
+        if (i2c_transfer(adap, &msg, 1) != 1) {
+                sil164_dbg(adap, "No dual-link slave found.");
+                return NULL;
+        }
+
+        return i2c_new_device(adap, &info);
+}
+
+static int
+sil164_encoder_init(struct i2c_client *client,
+                    struct drm_device *dev,
+                    struct drm_encoder_slave *encoder)
+{
+        struct sil164_priv *priv;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        encoder->slave_priv = priv;
+        encoder->slave_funcs = &sil164_encoder_funcs;
+
+        priv->duallink_slave = sil164_detect_slave(client);
+
+        return 0;
+}
+
+static struct i2c_device_id sil164_ids[] = {
+        { "sil164", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, sil164_ids);
+
+static struct drm_i2c_encoder_driver sil164_driver = {
+        .i2c_driver = {
+                .probe = sil164_probe,
+                .remove = sil164_remove,
+                .driver = {
+                        .name = "sil164",
+                },
+                .id_table = sil164_ids,
+        },
+        .encoder_init = sil164_encoder_init,
+};
+
+/* Module initialization */
+
+static int __init
+sil164_init(void)
+{
+        return drm_i2c_encoder_register(THIS_MODULE, &sil164_driver);
+}
+
+static void __exit
+sil164_exit(void)
+{
+        drm_i2c_encoder_unregister(&sil164_driver);
+}
+
+MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>");
+MODULE_DESCRIPTION("Silicon Image sil164 TMDS transmitter driver");
+MODULE_LICENSE("GPL and additional rights");
+
+module_init(sil164_init);
+module_exit(sil164_exit);
diff --git a/drivers/gpu/drm/i810/i810_dma.c b/drivers/gpu/drm/i810/i810_dma.c
index 997d91707ad2..09c86ed89927 100644
--- a/drivers/gpu/drm/i810/i810_dma.c
+++ b/drivers/gpu/drm/i810/i810_dma.c
@@ -60,9 +60,8 @@ static struct drm_buf *i810_freelist_get(struct drm_device * dev)
                 /* In use is already a pointer */
                 used = cmpxchg(buf_priv->in_use, I810_BUF_FREE,
                                I810_BUF_CLIENT);
-                if (used == I810_BUF_FREE) {
+                if (used == I810_BUF_FREE)
                         return buf;
-                }
         }
         return NULL;
 }
@@ -71,7 +70,7 @@ static struct drm_buf *i810_freelist_get(struct drm_device * dev)
  * yet, the hardware updates in use for us once its on the ring buffer.
  */
 
-static int i810_freelist_put(struct drm_device * dev, struct drm_buf * buf)
+static int i810_freelist_put(struct drm_device *dev, struct drm_buf *buf)
 {
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         int used;
@@ -121,7 +120,7 @@ static const struct file_operations i810_buffer_fops = {
         .fasync = drm_fasync,
 };
 
-static int i810_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
+static int i810_map_buffer(struct drm_buf *buf, struct drm_file *file_priv)
 {
         struct drm_device *dev = file_priv->minor->dev;
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
@@ -152,7 +151,7 @@ static int i810_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
         return retcode;
 }
 
-static int i810_unmap_buffer(struct drm_buf * buf)
+static int i810_unmap_buffer(struct drm_buf *buf)
 {
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         int retcode = 0;
@@ -172,7 +171,7 @@ static int i810_unmap_buffer(struct drm_buf * buf)
         return retcode;
 }
 
-static int i810_dma_get_buffer(struct drm_device * dev, drm_i810_dma_t * d,
+static int i810_dma_get_buffer(struct drm_device *dev, drm_i810_dma_t *d,
                                struct drm_file *file_priv)
 {
         struct drm_buf *buf;
@@ -202,7 +201,7 @@ static int i810_dma_get_buffer(struct drm_device * dev, drm_i810_dma_t * d,
         return retcode;
 }
 
-static int i810_dma_cleanup(struct drm_device * dev)
+static int i810_dma_cleanup(struct drm_device *dev)
 {
         struct drm_device_dma *dma = dev->dma;
 
@@ -218,9 +217,8 @@ static int i810_dma_cleanup(struct drm_device * dev)
                 drm_i810_private_t *dev_priv =
                     (drm_i810_private_t *) dev->dev_private;
 
-                if (dev_priv->ring.virtual_start) {
+                if (dev_priv->ring.virtual_start)
                         drm_core_ioremapfree(&dev_priv->ring.map, dev);
-                }
                 if (dev_priv->hw_status_page) {
                         pci_free_consistent(dev->pdev, PAGE_SIZE,
                                             dev_priv->hw_status_page,
@@ -242,7 +240,7 @@ static int i810_dma_cleanup(struct drm_device * dev)
         return 0;
 }
 
-static int i810_wait_ring(struct drm_device * dev, int n)
+static int i810_wait_ring(struct drm_device *dev, int n)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
@@ -271,11 +269,11 @@ static int i810_wait_ring(struct drm_device * dev, int n)
                 udelay(1);
         }
 
-      out_wait_ring:
+out_wait_ring:
         return iters;
 }
 
-static void i810_kernel_lost_context(struct drm_device * dev)
+static void i810_kernel_lost_context(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
@@ -287,7 +285,7 @@ static void i810_kernel_lost_context(struct drm_device * dev)
                 ring->space += ring->Size;
 }
 
-static int i810_freelist_init(struct drm_device * dev, drm_i810_private_t * dev_priv)
+static int i810_freelist_init(struct drm_device *dev, drm_i810_private_t *dev_priv)
 {
         struct drm_device_dma *dma = dev->dma;
         int my_idx = 24;
@@ -322,9 +320,9 @@ static int i810_freelist_init(struct drm_device * dev, drm_i810_private_t * dev_
         return 0;
 }
 
-static int i810_dma_initialize(struct drm_device * dev,
-                               drm_i810_private_t * dev_priv,
-                               drm_i810_init_t * init)
+static int i810_dma_initialize(struct drm_device *dev,
+                               drm_i810_private_t *dev_priv,
+                               drm_i810_init_t *init)
 {
         struct drm_map_list *r_list;
         memset(dev_priv, 0, sizeof(drm_i810_private_t));
@@ -462,7 +460,7 @@ static int i810_dma_init(struct drm_device *dev, void *data,
  * Use 'volatile' & local var tmp to force the emitted values to be
  * identical to the verified ones.
  */
-static void i810EmitContextVerified(struct drm_device * dev,
+static void i810EmitContextVerified(struct drm_device *dev,
                                     volatile unsigned int *code)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
@@ -495,7 +493,7 @@ static void i810EmitContextVerified(struct drm_device * dev,
         ADVANCE_LP_RING();
 }
 
-static void i810EmitTexVerified(struct drm_device * dev, volatile unsigned int *code)
+static void i810EmitTexVerified(struct drm_device *dev, volatile unsigned int *code)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         int i, j = 0;
@@ -528,7 +526,7 @@ static void i810EmitTexVerified(struct drm_device * dev, volatile unsigned int *
 
 /* Need to do some additional checking when setting the dest buffer.
  */
-static void i810EmitDestVerified(struct drm_device * dev,
+static void i810EmitDestVerified(struct drm_device *dev,
                                  volatile unsigned int *code)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
@@ -563,7 +561,7 @@ static void i810EmitDestVerified(struct drm_device * dev,
         ADVANCE_LP_RING();
 }
 
-static void i810EmitState(struct drm_device * dev)
+static void i810EmitState(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -594,7 +592,7 @@ static void i810EmitState(struct drm_device * dev)
 
 /* need to verify
  */
-static void i810_dma_dispatch_clear(struct drm_device * dev, int flags,
+static void i810_dma_dispatch_clear(struct drm_device *dev, int flags,
                                     unsigned int clear_color,
                                     unsigned int clear_zval)
 {
@@ -669,7 +667,7 @@ static void i810_dma_dispatch_clear(struct drm_device * dev, int flags,
         }
 }
 
-static void i810_dma_dispatch_swap(struct drm_device * dev)
+static void i810_dma_dispatch_swap(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -715,8 +713,8 @@ static void i810_dma_dispatch_swap(struct drm_device * dev)
         }
 }
 
-static void i810_dma_dispatch_vertex(struct drm_device * dev,
-                                     struct drm_buf * buf, int discard, int used)
+static void i810_dma_dispatch_vertex(struct drm_device *dev,
+                                     struct drm_buf *buf, int discard, int used)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
@@ -795,7 +793,7 @@ static void i810_dma_dispatch_vertex(struct drm_device * dev,
         }
 }
 
-static void i810_dma_dispatch_flip(struct drm_device * dev)
+static void i810_dma_dispatch_flip(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         int pitch = dev_priv->pitch;
@@ -841,7 +839,7 @@ static void i810_dma_dispatch_flip(struct drm_device * dev)
 
 }
 
-static void i810_dma_quiescent(struct drm_device * dev)
+static void i810_dma_quiescent(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -858,7 +856,7 @@ static void i810_dma_quiescent(struct drm_device * dev)
         i810_wait_ring(dev, dev_priv->ring.Size - 8);
 }
 
-static int i810_flush_queue(struct drm_device * dev)
+static int i810_flush_queue(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         struct drm_device_dma *dma = dev->dma;
@@ -891,7 +889,7 @@ static int i810_flush_queue(struct drm_device * dev)
 }
 
 /* Must be called with the lock held */
-static void i810_reclaim_buffers(struct drm_device * dev,
+static void i810_reclaim_buffers(struct drm_device *dev,
                                  struct drm_file *file_priv)
 {
         struct drm_device_dma *dma = dev->dma;
@@ -969,9 +967,8 @@ static int i810_clear_bufs(struct drm_device *dev, void *data,
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         /* GH: Someone's doing nasty things... */
-        if (!dev->dev_private) {
+        if (!dev->dev_private)
                 return -EINVAL;
-        }
 
         i810_dma_dispatch_clear(dev, clear->flags,
                                 clear->clear_color, clear->clear_depth);
@@ -1039,7 +1036,7 @@ static int i810_docopy(struct drm_device *dev, void *data,
         return 0;
 }
 
-static void i810_dma_dispatch_mc(struct drm_device * dev, struct drm_buf * buf, int used,
+static void i810_dma_dispatch_mc(struct drm_device *dev, struct drm_buf *buf, int used,
                                  unsigned int last_render)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
@@ -1053,9 +1050,8 @@ static void i810_dma_dispatch_mc(struct drm_device * dev, struct drm_buf * buf,
         i810_kernel_lost_context(dev);
 
         u = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT, I810_BUF_HARDWARE);
-        if (u != I810_BUF_CLIENT) {
+        if (u != I810_BUF_CLIENT)
                 DRM_DEBUG("MC found buffer that isn't mine!\n");
-        }
 
         if (used > 4 * 1024)
                 used = 0;
@@ -1160,7 +1156,7 @@ static int i810_ov0_flip(struct drm_device *dev, void *data,
 
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-        //Tell the overlay to update
+        /* Tell the overlay to update */
         I810_WRITE(0x30000, dev_priv->overlay_physical | 0x80000000);
 
         return 0;
@@ -1168,7 +1164,7 @@ static int i810_ov0_flip(struct drm_device *dev, void *data,
 
 /* Not sure why this isn't set all the time:
  */
-static void i810_do_init_pageflip(struct drm_device * dev)
+static void i810_do_init_pageflip(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
 
@@ -1178,7 +1174,7 @@ static void i810_do_init_pageflip(struct drm_device * dev)
         dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 }
 
-static int i810_do_cleanup_pageflip(struct drm_device * dev)
+static int i810_do_cleanup_pageflip(struct drm_device *dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
 
@@ -1218,28 +1214,27 @@ int i810_driver_load(struct drm_device *dev, unsigned long flags)
         return 0;
 }
 
-void i810_driver_lastclose(struct drm_device * dev)
+void i810_driver_lastclose(struct drm_device *dev)
 {
         i810_dma_cleanup(dev);
 }
 
-void i810_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
+void i810_driver_preclose(struct drm_device *dev, struct drm_file *file_priv)
 {
         if (dev->dev_private) {
                 drm_i810_private_t *dev_priv = dev->dev_private;
-                if (dev_priv->page_flipping) {
+                if (dev_priv->page_flipping)
                         i810_do_cleanup_pageflip(dev);
-                }
         }
 }
 
-void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
+void i810_driver_reclaim_buffers_locked(struct drm_device *dev,
                                         struct drm_file *file_priv)
 {
         i810_reclaim_buffers(dev, file_priv);
 }
 
-int i810_driver_dma_quiescent(struct drm_device * dev)
+int i810_driver_dma_quiescent(struct drm_device *dev)
 {
         i810_dma_quiescent(dev);
         return 0;
@@ -1276,7 +1271,7 @@ int i810_max_ioctl = DRM_ARRAY_SIZE(i810_ioctls);
  * \returns
  * A value of 1 is always retured to indictate every i810 is AGP.
  */
-int i810_driver_device_is_agp(struct drm_device * dev)
+int i810_driver_device_is_agp(struct drm_device *dev)
 {
         return 1;
 }
diff --git a/drivers/gpu/drm/i810/i810_drv.h b/drivers/gpu/drm/i810/i810_drv.h
index 21e2691f28f9..0743fe90f1e3 100644
--- a/drivers/gpu/drm/i810/i810_drv.h
+++ b/drivers/gpu/drm/i810/i810_drv.h
@@ -115,16 +115,16 @@ typedef struct drm_i810_private {
 } drm_i810_private_t;
 
                                 /* i810_dma.c */
-extern int i810_driver_dma_quiescent(struct drm_device * dev);
-extern void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
+extern int i810_driver_dma_quiescent(struct drm_device *dev);
+extern void i810_driver_reclaim_buffers_locked(struct drm_device *dev,
                                                struct drm_file *file_priv);
 extern int i810_driver_load(struct drm_device *, unsigned long flags);
-extern void i810_driver_lastclose(struct drm_device * dev);
-extern void i810_driver_preclose(struct drm_device * dev,
+extern void i810_driver_lastclose(struct drm_device *dev);
+extern void i810_driver_preclose(struct drm_device *dev,
                                  struct drm_file *file_priv);
-extern void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
+extern void i810_driver_reclaim_buffers_locked(struct drm_device *dev,
                                                struct drm_file *file_priv);
-extern int i810_driver_device_is_agp(struct drm_device * dev);
+extern int i810_driver_device_is_agp(struct drm_device *dev);
 
 extern struct drm_ioctl_desc i810_ioctls[];
 extern int i810_max_ioctl;
@@ -132,39 +132,41 @@ extern int i810_max_ioctl;
 #define I810_BASE(reg)          ((unsigned long) \
                                 dev_priv->mmio_map->handle)
 #define I810_ADDR(reg)          (I810_BASE(reg) + reg)
-#define I810_DEREF(reg)         *(__volatile__ int *)I810_ADDR(reg)
+#define I810_DEREF(reg)         (*(__volatile__ int *)I810_ADDR(reg))
 #define I810_READ(reg)          I810_DEREF(reg)
-#define I810_WRITE(reg,val)     do { I810_DEREF(reg) = val; } while (0)
-#define I810_DEREF16(reg)       *(__volatile__ u16 *)I810_ADDR(reg)
+#define I810_WRITE(reg, val)    do { I810_DEREF(reg) = val; } while (0)
+#define I810_DEREF16(reg)       (*(__volatile__ u16 *)I810_ADDR(reg))
 #define I810_READ16(reg)        I810_DEREF16(reg)
-#define I810_WRITE16(reg,val)   do { I810_DEREF16(reg) = val; } while (0)
+#define I810_WRITE16(reg, val)  do { I810_DEREF16(reg) = val; } while (0)
 
 #define I810_VERBOSE 0
 #define RING_LOCALS     unsigned int outring, ringmask; \
-                        volatile char *virt;
-
-#define BEGIN_LP_RING(n) do {                                           \
-        if (I810_VERBOSE)                                               \
-                DRM_DEBUG("BEGIN_LP_RING(%d)\n", n);                    \
-        if (dev_priv->ring.space < n*4)                                 \
-                i810_wait_ring(dev, n*4);                               \
-        dev_priv->ring.space -= n*4;                                    \
-        outring = dev_priv->ring.tail;                                  \
-        ringmask = dev_priv->ring.tail_mask;                            \
-        virt = dev_priv->ring.virtual_start;                            \
+                        volatile char *virt;
+
+#define BEGIN_LP_RING(n) do {                                   \
+        if (I810_VERBOSE)                                       \
+                DRM_DEBUG("BEGIN_LP_RING(%d)\n", n);            \
+        if (dev_priv->ring.space < n*4)                         \
+                i810_wait_ring(dev, n*4);                       \
+        dev_priv->ring.space -= n*4;                            \
+        outring = dev_priv->ring.tail;                          \
+        ringmask = dev_priv->ring.tail_mask;                    \
+        virt = dev_priv->ring.virtual_start;                    \
 } while (0)
 
-#define ADVANCE_LP_RING() do {                                  \
-        if (I810_VERBOSE) DRM_DEBUG("ADVANCE_LP_RING\n");       \
+#define ADVANCE_LP_RING() do {                                  \
+        if (I810_VERBOSE)                                       \
+                DRM_DEBUG("ADVANCE_LP_RING\n");                 \
         dev_priv->ring.tail = outring;                          \
-        I810_WRITE(LP_RING + RING_TAIL, outring);               \
-} while(0)
-
-#define OUT_RING(n) do {                                                \
-        if (I810_VERBOSE) DRM_DEBUG("   OUT_RING %x\n", (int)(n));      \
-        *(volatile unsigned int *)(virt + outring) = n;                 \
-        outring += 4;                                                   \
-        outring &= ringmask;                                            \
+        I810_WRITE(LP_RING + RING_TAIL, outring);               \
+} while (0)
+
+#define OUT_RING(n) do {                                        \
+        if (I810_VERBOSE)                                       \
+                DRM_DEBUG("   OUT_RING %x\n", (int)(n));        \
+        *(volatile unsigned int *)(virt + outring) = n;         \
+        outring += 4;                                           \
+        outring &= ringmask;                                    \
 } while (0)
 
 #define GFX_OP_USER_INTERRUPT           ((0<<29)|(2<<23))
diff --git a/drivers/gpu/drm/i830/i830_dma.c b/drivers/gpu/drm/i830/i830_dma.c
index 65759a9a85c8..7ee85ea507ce 100644
--- a/drivers/gpu/drm/i830/i830_dma.c
+++ b/drivers/gpu/drm/i830/i830_dma.c
@@ -62,9 +62,8 @@ static struct drm_buf *i830_freelist_get(struct drm_device * dev)
                 /* In use is already a pointer */
                 used = cmpxchg(buf_priv->in_use, I830_BUF_FREE,
                                I830_BUF_CLIENT);
-                if (used == I830_BUF_FREE) {
+                if (used == I830_BUF_FREE)
                         return buf;
-                }
         }
         return NULL;
 }
@@ -73,7 +72,7 @@ static struct drm_buf *i830_freelist_get(struct drm_device * dev)
  * yet, the hardware updates in use for us once its on the ring buffer.
  */
 
-static int i830_freelist_put(struct drm_device * dev, struct drm_buf * buf)
+static int i830_freelist_put(struct drm_device *dev, struct drm_buf *buf)
 {
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         int used;
@@ -123,7 +122,7 @@ static const struct file_operations i830_buffer_fops = {
         .fasync = drm_fasync,
 };
 
-static int i830_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
+static int i830_map_buffer(struct drm_buf *buf, struct drm_file *file_priv)
 {
         struct drm_device *dev = file_priv->minor->dev;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
@@ -156,7 +155,7 @@ static int i830_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
         return retcode;
 }
 
-static int i830_unmap_buffer(struct drm_buf * buf)
+static int i830_unmap_buffer(struct drm_buf *buf)
 {
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         int retcode = 0;
@@ -176,7 +175,7 @@ static int i830_unmap_buffer(struct drm_buf * buf)
         return retcode;
 }
 
-static int i830_dma_get_buffer(struct drm_device * dev, drm_i830_dma_t * d,
+static int i830_dma_get_buffer(struct drm_device *dev, drm_i830_dma_t *d,
                                struct drm_file *file_priv)
 {
         struct drm_buf *buf;
@@ -206,7 +205,7 @@ static int i830_dma_get_buffer(struct drm_device * dev, drm_i830_dma_t * d,
         return retcode;
 }
 
-static int i830_dma_cleanup(struct drm_device * dev)
+static int i830_dma_cleanup(struct drm_device *dev)
 {
         struct drm_device_dma *dma = dev->dma;
 
@@ -222,9 +221,8 @@ static int i830_dma_cleanup(struct drm_device * dev)
                 drm_i830_private_t *dev_priv =
                     (drm_i830_private_t *) dev->dev_private;
 
-                if (dev_priv->ring.virtual_start) {
+                if (dev_priv->ring.virtual_start)
                         drm_core_ioremapfree(&dev_priv->ring.map, dev);
-                }
                 if (dev_priv->hw_status_page) {
                         pci_free_consistent(dev->pdev, PAGE_SIZE,
                                             dev_priv->hw_status_page,
@@ -246,7 +244,7 @@ static int i830_dma_cleanup(struct drm_device * dev)
         return 0;
 }
 
-int i830_wait_ring(struct drm_device * dev, int n, const char *caller)
+int i830_wait_ring(struct drm_device *dev, int n, const char *caller)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_ring_buffer_t *ring = &(dev_priv->ring);
@@ -276,11 +274,11 @@ int i830_wait_ring(struct drm_device * dev, int n, const char *caller)
                 dev_priv->sarea_priv->perf_boxes |= I830_BOX_WAIT;
         }
 
-      out_wait_ring:
+out_wait_ring:
         return iters;
 }
 
-static void i830_kernel_lost_context(struct drm_device * dev)
+static void i830_kernel_lost_context(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_ring_buffer_t *ring = &(dev_priv->ring);
@@ -295,7 +293,7 @@ static void i830_kernel_lost_context(struct drm_device * dev)
                 dev_priv->sarea_priv->perf_boxes |= I830_BOX_RING_EMPTY;
 }
 
-static int i830_freelist_init(struct drm_device * dev, drm_i830_private_t * dev_priv)
+static int i830_freelist_init(struct drm_device *dev, drm_i830_private_t *dev_priv)
 {
         struct drm_device_dma *dma = dev->dma;
         int my_idx = 36;
@@ -329,9 +327,9 @@ static int i830_freelist_init(struct drm_device * dev, drm_i830_private_t * dev_
         return 0;
 }
 
-static int i830_dma_initialize(struct drm_device * dev,
-                               drm_i830_private_t * dev_priv,
-                               drm_i830_init_t * init)
+static int i830_dma_initialize(struct drm_device *dev,
+                               drm_i830_private_t *dev_priv,
+                               drm_i830_init_t *init)
 {
         struct drm_map_list *r_list;
 
@@ -482,7 +480,7 @@ static int i830_dma_init(struct drm_device *dev, void *data,
 /* Most efficient way to verify state for the i830 is as it is
  * emitted.  Non-conformant state is silently dropped.
  */
-static void i830EmitContextVerified(struct drm_device * dev, unsigned int *code)
+static void i830EmitContextVerified(struct drm_device *dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         int i, j = 0;
@@ -527,7 +525,7 @@ static void i830EmitContextVerified(struct drm_device * dev, unsigned int *code)
         ADVANCE_LP_RING();
 }
 
-static void i830EmitTexVerified(struct drm_device * dev, unsigned int *code)
+static void i830EmitTexVerified(struct drm_device *dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         int i, j = 0;
@@ -561,7 +559,7 @@ static void i830EmitTexVerified(struct drm_device * dev, unsigned int *code)
                 printk("rejected packet %x\n", code[0]);
 }
 
-static void i830EmitTexBlendVerified(struct drm_device * dev,
+static void i830EmitTexBlendVerified(struct drm_device *dev,
                                      unsigned int *code, unsigned int num)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
@@ -586,7 +584,7 @@ static void i830EmitTexBlendVerified(struct drm_device * dev,
         ADVANCE_LP_RING();
 }
 
-static void i830EmitTexPalette(struct drm_device * dev,
+static void i830EmitTexPalette(struct drm_device *dev,
                                unsigned int *palette, int number, int is_shared)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
@@ -603,9 +601,8 @@ static void i830EmitTexPalette(struct drm_device * dev,
         } else {
                 OUT_RING(CMD_OP_MAP_PALETTE_LOAD | MAP_PALETTE_NUM(number));
         }
-        for (i = 0; i < 256; i++) {
+        for (i = 0; i < 256; i++)
                 OUT_RING(palette[i]);
-        }
         OUT_RING(0);
         /* KW:  WHERE IS THE ADVANCE_LP_RING?  This is effectively a noop!
          */
@@ -613,7 +610,7 @@ static void i830EmitTexPalette(struct drm_device * dev,
 
 /* Need to do some additional checking when setting the dest buffer.
  */
-static void i830EmitDestVerified(struct drm_device * dev, unsigned int *code)
+static void i830EmitDestVerified(struct drm_device *dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         unsigned int tmp;
@@ -674,7 +671,7 @@ static void i830EmitDestVerified(struct drm_device * dev, unsigned int *code)
         ADVANCE_LP_RING();
 }
 
-static void i830EmitStippleVerified(struct drm_device * dev, unsigned int *code)
+static void i830EmitStippleVerified(struct drm_device *dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -685,7 +682,7 @@ static void i830EmitStippleVerified(struct drm_device * dev, unsigned int *code)
         ADVANCE_LP_RING();
 }
 
-static void i830EmitState(struct drm_device * dev)
+static void i830EmitState(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -788,7 +785,7 @@ static void i830EmitState(struct drm_device * dev)
  * Performance monitoring functions
  */
 
-static void i830_fill_box(struct drm_device * dev,
+static void i830_fill_box(struct drm_device *dev,
                           int x, int y, int w, int h, int r, int g, int b)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
@@ -816,17 +813,16 @@ static void i830_fill_box(struct drm_device * dev,
         OUT_RING((y << 16) | x);
         OUT_RING(((y + h) << 16) | (x + w));
 
-        if (dev_priv->current_page == 1) {
+        if (dev_priv->current_page == 1)
                 OUT_RING(dev_priv->front_offset);
-        } else {
+        else
                 OUT_RING(dev_priv->back_offset);
-        }
 
         OUT_RING(color);
         ADVANCE_LP_RING();
 }
 
-static void i830_cp_performance_boxes(struct drm_device * dev)
+static void i830_cp_performance_boxes(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
 
@@ -871,7 +867,7 @@ static void i830_cp_performance_boxes(struct drm_device * dev)
         dev_priv->sarea_priv->perf_boxes = 0;
 }
 
-static void i830_dma_dispatch_clear(struct drm_device * dev, int flags,
+static void i830_dma_dispatch_clear(struct drm_device *dev, int flags,
                                     unsigned int clear_color,
                                     unsigned int clear_zval,
                                     unsigned int clear_depthmask)
@@ -966,7 +962,7 @@ static void i830_dma_dispatch_clear(struct drm_device * dev, int flags,
         }
 }
 
-static void i830_dma_dispatch_swap(struct drm_device * dev)
+static void i830_dma_dispatch_swap(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -1036,7 +1032,7 @@ static void i830_dma_dispatch_swap(struct drm_device * dev)
         }
 }
 
-static void i830_dma_dispatch_flip(struct drm_device * dev)
+static void i830_dma_dispatch_flip(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -1079,8 +1075,8 @@ static void i830_dma_dispatch_flip(struct drm_device * dev)
         dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 }
 
-static void i830_dma_dispatch_vertex(struct drm_device * dev,
-                                     struct drm_buf * buf, int discard, int used)
+static void i830_dma_dispatch_vertex(struct drm_device *dev,
+                                     struct drm_buf *buf, int discard, int used)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
@@ -1100,9 +1096,8 @@ static void i830_dma_dispatch_vertex(struct drm_device * dev,
         if (discard) {
                 u = cmpxchg(buf_priv->in_use, I830_BUF_CLIENT,
                             I830_BUF_HARDWARE);
-                if (u != I830_BUF_CLIENT) {
+                if (u != I830_BUF_CLIENT)
                         DRM_DEBUG("xxxx 2\n");
-                }
         }
 
         if (used > 4 * 1023)
@@ -1191,7 +1186,7 @@ static void i830_dma_dispatch_vertex(struct drm_device * dev,
         }
 }
 
-static void i830_dma_quiescent(struct drm_device * dev)
+static void i830_dma_quiescent(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -1208,7 +1203,7 @@ static void i830_dma_quiescent(struct drm_device * dev)
         i830_wait_ring(dev, dev_priv->ring.Size - 8, __func__);
 }
 
-static int i830_flush_queue(struct drm_device * dev)
+static int i830_flush_queue(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         struct drm_device_dma *dma = dev->dma;
@@ -1241,7 +1236,7 @@ static int i830_flush_queue(struct drm_device * dev)
 }
 
 /* Must be called with the lock held */
-static void i830_reclaim_buffers(struct drm_device * dev, struct drm_file *file_priv)
+static void i830_reclaim_buffers(struct drm_device *dev, struct drm_file *file_priv)
 {
         struct drm_device_dma *dma = dev->dma;
         int i;
@@ -1316,9 +1311,8 @@ static int i830_clear_bufs(struct drm_device *dev, void *data,
         LOCK_TEST_WITH_RETURN(dev, file_priv);
 
         /* GH: Someone's doing nasty things... */
-        if (!dev->dev_private) {
+        if (!dev->dev_private)
                 return -EINVAL;
-        }
 
         i830_dma_dispatch_clear(dev, clear->flags,
                                 clear->clear_color,
@@ -1339,7 +1333,7 @@ static int i830_swap_bufs(struct drm_device *dev, void *data,
 
 /* Not sure why this isn't set all the time:
  */
-static void i830_do_init_pageflip(struct drm_device * dev)
+static void i830_do_init_pageflip(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
 
@@ -1349,7 +1343,7 @@ static void i830_do_init_pageflip(struct drm_device * dev)
         dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 }
 
-static int i830_do_cleanup_pageflip(struct drm_device * dev)
+static int i830_do_cleanup_pageflip(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
 
@@ -1490,27 +1484,26 @@ int i830_driver_load(struct drm_device *dev, unsigned long flags)
         return 0;
 }
 
-void i830_driver_lastclose(struct drm_device * dev)
+void i830_driver_lastclose(struct drm_device *dev)
 {
         i830_dma_cleanup(dev);
 }
 
-void i830_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
+void i830_driver_preclose(struct drm_device *dev, struct drm_file *file_priv)
 {
         if (dev->dev_private) {
                 drm_i830_private_t *dev_priv = dev->dev_private;
-                if (dev_priv->page_flipping) {
+                if (dev_priv->page_flipping)
                         i830_do_cleanup_pageflip(dev);
-                }
         }
 }
 
-void i830_driver_reclaim_buffers_locked(struct drm_device * dev, struct drm_file *file_priv)
+void i830_driver_reclaim_buffers_locked(struct drm_device *dev, struct drm_file *file_priv)
 {
         i830_reclaim_buffers(dev, file_priv);
 }
 
-int i830_driver_dma_quiescent(struct drm_device * dev)
+int i830_driver_dma_quiescent(struct drm_device *dev)
 {
         i830_dma_quiescent(dev);
         return 0;
@@ -1546,7 +1539,7 @@ int i830_max_ioctl = DRM_ARRAY_SIZE(i830_ioctls);
  * \returns
  * A value of 1 is always retured to indictate every i8xx is AGP.
  */
-int i830_driver_device_is_agp(struct drm_device * dev)
+int i830_driver_device_is_agp(struct drm_device *dev)
 {
         return 1;
 }
diff --git a/drivers/gpu/drm/i830/i830_drv.h b/drivers/gpu/drm/i830/i830_drv.h
index da82afe4ded5..ecfd25a35da3 100644
--- a/drivers/gpu/drm/i830/i830_drv.h
+++ b/drivers/gpu/drm/i830/i830_drv.h
@@ -132,33 +132,33 @@ extern int i830_irq_wait(struct drm_device *dev, void *data,
                          struct drm_file *file_priv);
 
 extern irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS);
-extern void i830_driver_irq_preinstall(struct drm_device * dev);
-extern void i830_driver_irq_postinstall(struct drm_device * dev);
-extern void i830_driver_irq_uninstall(struct drm_device * dev);
+extern void i830_driver_irq_preinstall(struct drm_device *dev);
+extern void i830_driver_irq_postinstall(struct drm_device *dev);
+extern void i830_driver_irq_uninstall(struct drm_device *dev);
 extern int i830_driver_load(struct drm_device *, unsigned long flags);
-extern void i830_driver_preclose(struct drm_device * dev,
+extern void i830_driver_preclose(struct drm_device *dev,
                                  struct drm_file *file_priv);
-extern void i830_driver_lastclose(struct drm_device * dev);
-extern void i830_driver_reclaim_buffers_locked(struct drm_device * dev,
+extern void i830_driver_lastclose(struct drm_device *dev);
+extern void i830_driver_reclaim_buffers_locked(struct drm_device *dev,
                                                struct drm_file *file_priv);
-extern int i830_driver_dma_quiescent(struct drm_device * dev);
-extern int i830_driver_device_is_agp(struct drm_device * dev);
+extern int i830_driver_dma_quiescent(struct drm_device *dev);
+extern int i830_driver_device_is_agp(struct drm_device *dev);
 
-#define I830_READ(reg)          DRM_READ32(dev_priv->mmio_map, reg)
-#define I830_WRITE(reg,val)     DRM_WRITE32(dev_priv->mmio_map, reg, val)
-#define I830_READ16(reg)        DRM_READ16(dev_priv->mmio_map, reg)
-#define I830_WRITE16(reg,val)   DRM_WRITE16(dev_priv->mmio_map, reg, val)
+#define I830_READ(reg)          DRM_READ32(dev_priv->mmio_map, reg)
+#define I830_WRITE(reg, val)    DRM_WRITE32(dev_priv->mmio_map, reg, val)
+#define I830_READ16(reg)        DRM_READ16(dev_priv->mmio_map, reg)
+#define I830_WRITE16(reg, val)  DRM_WRITE16(dev_priv->mmio_map, reg, val)
 
 #define I830_VERBOSE 0
 
 #define RING_LOCALS     unsigned int outring, ringmask, outcount; \
-                        volatile char *virt;
+                        volatile char *virt;
 
 #define BEGIN_LP_RING(n) do {                           \
         if (I830_VERBOSE)                               \
                 printk("BEGIN_LP_RING(%d)\n", (n));     \
         if (dev_priv->ring.space < n*4)                 \
-                i830_wait_ring(dev, n*4, __func__);             \
+                i830_wait_ring(dev, n*4, __func__);     \
         outcount = 0;                                   \
         outring = dev_priv->ring.tail;                  \
         ringmask = dev_priv->ring.tail_mask;            \
@@ -166,21 +166,23 @@ extern int i830_driver_device_is_agp(struct drm_device * dev);
 } while (0)
 
 #define OUT_RING(n) do {                                        \
-        if (I830_VERBOSE) printk("   OUT_RING %x\n", (int)(n)); \
+        if (I830_VERBOSE)                                       \
+                printk("   OUT_RING %x\n", (int)(n));           \
         *(volatile unsigned int *)(virt + outring) = n;         \
-        outcount++;                                             \
+        outcount++;                                             \
         outring += 4;                                           \
         outring &= ringmask;                                    \
 } while (0)
 
-#define ADVANCE_LP_RING() do {                                          \
-        if (I830_VERBOSE) printk("ADVANCE_LP_RING %x\n", outring);      \
-        dev_priv->ring.tail = outring;                                  \
-        dev_priv->ring.space -= outcount * 4;                           \
-        I830_WRITE(LP_RING + RING_TAIL, outring);                       \
-} while(0)
+#define ADVANCE_LP_RING() do {                                  \
+        if (I830_VERBOSE)                                       \
+                printk("ADVANCE_LP_RING %x\n", outring);        \
+        dev_priv->ring.tail = outring;                          \
+        dev_priv->ring.space -= outcount * 4;                   \
+        I830_WRITE(LP_RING + RING_TAIL, outring);               \
+} while (0)
 
-extern int i830_wait_ring(struct drm_device * dev, int n, const char *caller);
+extern int i830_wait_ring(struct drm_device *dev, int n, const char *caller);
 
 #define GFX_OP_USER_INTERRUPT           ((0<<29)|(2<<23))
 #define GFX_OP_BREAKPOINT_INTERRUPT     ((0<<29)|(1<<23))
diff --git a/drivers/gpu/drm/i830/i830_irq.c b/drivers/gpu/drm/i830/i830_irq.c
index 91ec2bb497e9..d1a6b95d631d 100644
--- a/drivers/gpu/drm/i830/i830_irq.c
+++ b/drivers/gpu/drm/i830/i830_irq.c
@@ -53,7 +53,7 @@ irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_HANDLED;
 }
 
-static int i830_emit_irq(struct drm_device * dev)
+static int i830_emit_irq(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -70,7 +70,7 @@ static int i830_emit_irq(struct drm_device * dev)
         return atomic_read(&dev_priv->irq_emitted);
 }
 
-static int i830_wait_irq(struct drm_device * dev, int irq_nr)
+static int i830_wait_irq(struct drm_device *dev, int irq_nr)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
         DECLARE_WAITQUEUE(entry, current);
@@ -156,7 +156,7 @@ int i830_irq_wait(struct drm_device *dev, void *data,
 
 /* drm_dma.h hooks
 */
-void i830_driver_irq_preinstall(struct drm_device * dev)
+void i830_driver_irq_preinstall(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
 
@@ -168,14 +168,14 @@ void i830_driver_irq_preinstall(struct drm_device * dev)
         init_waitqueue_head(&dev_priv->irq_queue);
 }
 
-void i830_driver_irq_postinstall(struct drm_device * dev)
+void i830_driver_irq_postinstall(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
 
         I830_WRITE16(I830REG_INT_ENABLE_R, 0x2);
 }
 
-void i830_driver_irq_uninstall(struct drm_device * dev)
+void i830_driver_irq_uninstall(struct drm_device *dev)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
         if (!dev_priv)
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 75061b305b8c..15d2d93aaca9 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -2241,6 +2241,7 @@ i915_gem_object_get_pages(struct drm_gem_object *obj,
                 page = read_cache_page_gfp(mapping, i,
                                            GFP_HIGHUSER |
                                            __GFP_COLD |
+                                           __GFP_RECLAIMABLE |
                                            gfpmask);
                 if (IS_ERR(page))
                         goto err_pages;
@@ -4739,6 +4740,16 @@ i915_gem_load(struct drm_device *dev)
         list_add(&dev_priv->mm.shrink_list, &shrink_list);
         spin_unlock(&shrink_list_lock);
 
+        /* On GEN3 we really need to make sure the ARB C3 LP bit is set */
+        if (IS_GEN3(dev)) {
+                u32 tmp = I915_READ(MI_ARB_STATE);
+                if (!(tmp & MI_ARB_C3_LP_WRITE_ENABLE)) {
+                        /* arb state is a masked write, so set bit + bit in mask */
+                        tmp = MI_ARB_C3_LP_WRITE_ENABLE | (MI_ARB_C3_LP_WRITE_ENABLE << MI_ARB_MASK_SHIFT);
+                        I915_WRITE(MI_ARB_STATE, tmp);
+                }
+        }
+
         /* Old X drivers will take 0-2 for front, back, depth buffers */
         if (!drm_core_check_feature(dev, DRIVER_MODESET))
                 dev_priv->fence_reg_start = 3;
@@ -4975,7 +4986,7 @@ i915_gpu_is_active(struct drm_device *dev)
 }
 
 static int
-i915_gem_shrink(int nr_to_scan, gfp_t gfp_mask)
+i915_gem_shrink(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask)
 {
         drm_i915_private_t *dev_priv, *next_dev;
         struct drm_i915_gem_object *obj_priv, *next_obj;
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index 150400f40534..6d9b0288272a 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -359,6 +359,70 @@
 #define LM_BURST_LENGTH     0x00000700
 #define LM_FIFO_WATERMARK   0x0000001F
 #define MI_ARB_STATE    0x020e4 /* 915+ only */
+#define   MI_ARB_MASK_SHIFT       16    /* shift for enable bits */
+
+/* Make render/texture TLB fetches lower priorty than associated data
+ *   fetches. This is not turned on by default
+ */
+#define   MI_ARB_RENDER_TLB_LOW_PRIORITY        (1 << 15)
+
+/* Isoch request wait on GTT enable (Display A/B/C streams).
+ * Make isoch requests stall on the TLB update. May cause
+ * display underruns (test mode only)
+ */
+#define   MI_ARB_ISOCH_WAIT_GTT                 (1 << 14)
+
+/* Block grant count for isoch requests when block count is
+ * set to a finite value.
+ */
+#define   MI_ARB_BLOCK_GRANT_MASK               (3 << 12)
+#define   MI_ARB_BLOCK_GRANT_8                  (0 << 12)       /* for 3 display planes */
+#define   MI_ARB_BLOCK_GRANT_4                  (1 << 12)       /* for 2 display planes */
+#define   MI_ARB_BLOCK_GRANT_2                  (2 << 12)       /* for 1 display plane */
+#define   MI_ARB_BLOCK_GRANT_0                  (3 << 12)       /* don't use */
+
+/* Enable render writes to complete in C2/C3/C4 power states.
+ * If this isn't enabled, render writes are prevented in low
+ * power states. That seems bad to me.
+ */
+#define   MI_ARB_C3_LP_WRITE_ENABLE             (1 << 11)
+
+/* This acknowledges an async flip immediately instead
+ * of waiting for 2TLB fetches.
+ */
+#define   MI_ARB_ASYNC_FLIP_ACK_IMMEDIATE       (1 << 10)
+
+/* Enables non-sequential data reads through arbiter
+ */
+#define   MI_ARB_DUAL_DATA_PHASE_DISABLE        (1 << 9)
+
+/* Disable FSB snooping of cacheable write cycles from binner/render
+ * command stream
+ */
+#define   MI_ARB_CACHE_SNOOP_DISABLE            (1 << 8)
+
+/* Arbiter time slice for non-isoch streams */
+#define   MI_ARB_TIME_SLICE_MASK                (7 << 5)
+#define   MI_ARB_TIME_SLICE_1                   (0 << 5)
+#define   MI_ARB_TIME_SLICE_2                   (1 << 5)
+#define   MI_ARB_TIME_SLICE_4                   (2 << 5)
+#define   MI_ARB_TIME_SLICE_6                   (3 << 5)
+#define   MI_ARB_TIME_SLICE_8                   (4 << 5)
+#define   MI_ARB_TIME_SLICE_10                  (5 << 5)
+#define   MI_ARB_TIME_SLICE_14                  (6 << 5)
+#define   MI_ARB_TIME_SLICE_16                  (7 << 5)
+
+/* Low priority grace period page size */
+#define   MI_ARB_LOW_PRIORITY_GRACE_4KB         (0 << 4)        /* default */
+#define   MI_ARB_LOW_PRIORITY_GRACE_8KB         (1 << 4)
+
+/* Disable display A/B trickle feed */
+#define   MI_ARB_DISPLAY_TRICKLE_FEED_DISABLE   (1 << 2)
+
+/* Set display plane priority */
+#define   MI_ARB_DISPLAY_PRIORITY_A_B           (0 << 0)        /* display A > display B */
+#define   MI_ARB_DISPLAY_PRIORITY_B_A           (1 << 0)        /* display B > display A */
+
 #define CACHE_MODE_0    0x02120 /* 915+ only */
 #define   CM0_MASK_SHIFT          16
 #define   CM0_IZ_OPT_DISABLE      (1<<6)
diff --git a/drivers/gpu/drm/mga/mga_dma.c b/drivers/gpu/drm/mga/mga_dma.c
index ccc129c328a4..08868ac3048a 100644
--- a/drivers/gpu/drm/mga/mga_dma.c
+++ b/drivers/gpu/drm/mga/mga_dma.c
@@ -52,7 +52,7 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup);
  * Engine control
  */
 
-int mga_do_wait_for_idle(drm_mga_private_t * dev_priv)
+int mga_do_wait_for_idle(drm_mga_private_t *dev_priv)
 {
         u32 status = 0;
         int i;
@@ -74,7 +74,7 @@ int mga_do_wait_for_idle(drm_mga_private_t * dev_priv)
         return -EBUSY;
 }
 
-static int mga_do_dma_reset(drm_mga_private_t * dev_priv)
+static int mga_do_dma_reset(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
@@ -102,7 +102,7 @@ static int mga_do_dma_reset(drm_mga_private_t * dev_priv)
  * Primary DMA stream
  */
 
-void mga_do_dma_flush(drm_mga_private_t * dev_priv)
+void mga_do_dma_flush(drm_mga_private_t *dev_priv)
 {
         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
         u32 head, tail;
@@ -142,11 +142,10 @@ void mga_do_dma_flush(drm_mga_private_t * dev_priv)
 
         head = MGA_READ(MGA_PRIMADDRESS);
 
-        if (head <= tail) {
+        if (head <= tail)
                 primary->space = primary->size - primary->tail;
-        } else {
+        else
                 primary->space = head - tail;
-        }
 
         DRM_DEBUG("   head = 0x%06lx\n", (unsigned long)(head - dev_priv->primary->offset));
         DRM_DEBUG("   tail = 0x%06lx\n", (unsigned long)(tail - dev_priv->primary->offset));
@@ -158,7 +157,7 @@ void mga_do_dma_flush(drm_mga_private_t * dev_priv)
         DRM_DEBUG("done.\n");
 }
 
-void mga_do_dma_wrap_start(drm_mga_private_t * dev_priv)
+void mga_do_dma_wrap_start(drm_mga_private_t *dev_priv)
 {
         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
         u32 head, tail;
@@ -181,11 +180,10 @@ void mga_do_dma_wrap_start(drm_mga_private_t * dev_priv)
 
         head = MGA_READ(MGA_PRIMADDRESS);
 
-        if (head == dev_priv->primary->offset) {
+        if (head == dev_priv->primary->offset)
                 primary->space = primary->size;
-        } else {
+        else
                 primary->space = head - dev_priv->primary->offset;
-        }
 
         DRM_DEBUG("   head = 0x%06lx\n", (unsigned long)(head - dev_priv->primary->offset));
         DRM_DEBUG("   tail = 0x%06x\n", primary->tail);
@@ -199,7 +197,7 @@ void mga_do_dma_wrap_start(drm_mga_private_t * dev_priv)
         DRM_DEBUG("done.\n");
 }
 
-void mga_do_dma_wrap_end(drm_mga_private_t * dev_priv)
+void mga_do_dma_wrap_end(drm_mga_private_t *dev_priv)
 {
         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -220,11 +218,11 @@ void mga_do_dma_wrap_end(drm_mga_private_t * dev_priv)
  * Freelist management
  */
 
-#define MGA_BUFFER_USED         ~0
+#define MGA_BUFFER_USED         (~0)
 #define MGA_BUFFER_FREE         0
 
 #if MGA_FREELIST_DEBUG
-static void mga_freelist_print(struct drm_device * dev)
+static void mga_freelist_print(struct drm_device *dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_freelist_t *entry;
@@ -245,7 +243,7 @@ static void mga_freelist_print(struct drm_device * dev)
 }
 #endif
 
-static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_priv)
+static int mga_freelist_init(struct drm_device *dev, drm_mga_private_t *dev_priv)
 {
         struct drm_device_dma *dma = dev->dma;
         struct drm_buf *buf;
@@ -288,7 +286,7 @@ static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_pr
         return 0;
 }
 
-static void mga_freelist_cleanup(struct drm_device * dev)
+static void mga_freelist_cleanup(struct drm_device *dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_freelist_t *entry;
@@ -308,7 +306,7 @@ static void mga_freelist_cleanup(struct drm_device * dev)
 #if 0
 /* FIXME: Still needed?
  */
-static void mga_freelist_reset(struct drm_device * dev)
+static void mga_freelist_reset(struct drm_device *dev)
 {
         struct drm_device_dma *dma = dev->dma;
         struct drm_buf *buf;
@@ -356,7 +354,7 @@ static struct drm_buf *mga_freelist_get(struct drm_device * dev)
         return NULL;
 }
 
-int mga_freelist_put(struct drm_device * dev, struct drm_buf * buf)
+int mga_freelist_put(struct drm_device *dev, struct drm_buf *buf)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_buf_priv_t *buf_priv = buf->dev_private;
@@ -391,7 +389,7 @@ int mga_freelist_put(struct drm_device * dev, struct drm_buf * buf)
  * DMA initialization, cleanup
  */
 
-int mga_driver_load(struct drm_device * dev, unsigned long flags)
+int mga_driver_load(struct drm_device *dev, unsigned long flags)
 {
         drm_mga_private_t *dev_priv;
         int ret;
@@ -439,8 +437,8 @@ int mga_driver_load(struct drm_device * dev, unsigned long flags)
  *
  * \sa mga_do_dma_bootstrap, mga_do_pci_dma_bootstrap
  */
-static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
-                                    drm_mga_dma_bootstrap_t * dma_bs)
+static int mga_do_agp_dma_bootstrap(struct drm_device *dev,
+                                    drm_mga_dma_bootstrap_t *dma_bs)
 {
         drm_mga_private_t *const dev_priv =
             (drm_mga_private_t *) dev->dev_private;
@@ -481,11 +479,10 @@ static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
          */
 
         if (dev_priv->chipset == MGA_CARD_TYPE_G200) {
-                if (mode.mode & 0x02) {
+                if (mode.mode & 0x02)
                         MGA_WRITE(MGA_AGP_PLL, MGA_AGP2XPLL_ENABLE);
-                } else {
+                else
                         MGA_WRITE(MGA_AGP_PLL, MGA_AGP2XPLL_DISABLE);
-                }
         }
 
         /* Allocate and bind AGP memory. */
@@ -593,8 +590,8 @@ static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
         return 0;
 }
 #else
-static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
-                                    drm_mga_dma_bootstrap_t * dma_bs)
+static int mga_do_agp_dma_bootstrap(struct drm_device *dev,
+                                    drm_mga_dma_bootstrap_t *dma_bs)
 {
         return -EINVAL;
 }
@@ -614,8 +611,8 @@ static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
  *
  * \sa mga_do_dma_bootstrap, mga_do_agp_dma_bootstrap
  */
-static int mga_do_pci_dma_bootstrap(struct drm_device * dev,
-                                    drm_mga_dma_bootstrap_t * dma_bs)
+static int mga_do_pci_dma_bootstrap(struct drm_device *dev,
+                                    drm_mga_dma_bootstrap_t *dma_bs)
 {
         drm_mga_private_t *const dev_priv =
             (drm_mga_private_t *) dev->dev_private;
@@ -678,9 +675,8 @@ static int mga_do_pci_dma_bootstrap(struct drm_device * dev,
                 req.size = dma_bs->secondary_bin_size;
 
                 err = drm_addbufs_pci(dev, &req);
-                if (!err) {
+                if (!err)
                         break;
-                }
         }
 
         if (bin_count == 0) {
@@ -704,8 +700,8 @@ static int mga_do_pci_dma_bootstrap(struct drm_device * dev,
         return 0;
 }
 
-static int mga_do_dma_bootstrap(struct drm_device * dev,
-                                drm_mga_dma_bootstrap_t * dma_bs)
+static int mga_do_dma_bootstrap(struct drm_device *dev,
+                                drm_mga_dma_bootstrap_t *dma_bs)
 {
         const int is_agp = (dma_bs->agp_mode != 0) && drm_device_is_agp(dev);
         int err;
@@ -737,17 +733,15 @@ static int mga_do_dma_bootstrap(struct drm_device * dev,
          * carve off portions of it for internal uses.  The remaining memory
          * is returned to user-mode to be used for AGP textures.
          */
-        if (is_agp) {
+        if (is_agp)
                 err = mga_do_agp_dma_bootstrap(dev, dma_bs);
-        }
 
         /* If we attempted to initialize the card for AGP DMA but failed,
          * clean-up any mess that may have been created.
          */
 
-        if (err) {
+        if (err)
                 mga_do_cleanup_dma(dev, MINIMAL_CLEANUP);
-        }
 
         /* Not only do we want to try and initialized PCI cards for PCI DMA,
          * but we also try to initialized AGP cards that could not be
@@ -757,9 +751,8 @@ static int mga_do_dma_bootstrap(struct drm_device * dev,
          * AGP memory, etc.
          */
 
-        if (!is_agp || err) {
+        if (!is_agp || err)
                 err = mga_do_pci_dma_bootstrap(dev, dma_bs);
-        }
 
         return err;
 }
@@ -792,7 +785,7 @@ int mga_dma_bootstrap(struct drm_device *dev, void *data,
         return err;
 }
 
-static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
+static int mga_do_init_dma(struct drm_device *dev, drm_mga_init_t *init)
 {
         drm_mga_private_t *dev_priv;
         int ret;
@@ -800,11 +793,10 @@ static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
 
         dev_priv = dev->dev_private;
 
-        if (init->sgram) {
+        if (init->sgram)
                 dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_BLK;
-        } else {
+        else
                 dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_RSTR;
-        }
         dev_priv->maccess = init->maccess;
 
         dev_priv->fb_cpp = init->fb_cpp;
@@ -975,9 +967,8 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
                                 dev_priv->agp_handle = 0;
                         }
 
-                        if ((dev->agp != NULL) && dev->agp->acquired) {
+                        if ((dev->agp != NULL) && dev->agp->acquired)
                                 err = drm_agp_release(dev);
-                        }
 #endif
                 }
 
@@ -998,9 +989,8 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
                 memset(dev_priv->warp_pipe_phys, 0,
                        sizeof(dev_priv->warp_pipe_phys));
 
-                if (dev_priv->head != NULL) {
+                if (dev_priv->head != NULL)
                         mga_freelist_cleanup(dev);
-                }
         }
 
         return err;
@@ -1017,9 +1007,8 @@ int mga_dma_init(struct drm_device *dev, void *data,
         switch (init->func) {
         case MGA_INIT_DMA:
                 err = mga_do_init_dma(dev, init);
-                if (err) {
+                if (err)
                         (void)mga_do_cleanup_dma(dev, FULL_CLEANUP);
-                }
                 return err;
         case MGA_CLEANUP_DMA:
                 return mga_do_cleanup_dma(dev, FULL_CLEANUP);
@@ -1047,9 +1036,8 @@ int mga_dma_flush(struct drm_device *dev, void *data,
 
         WRAP_WAIT_WITH_RETURN(dev_priv);
 
-        if (lock->flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL)) {
+        if (lock->flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL))
                 mga_do_dma_flush(dev_priv);
-        }
 
         if (lock->flags & _DRM_LOCK_QUIESCENT) {
 #if MGA_DMA_DEBUG
@@ -1079,8 +1067,8 @@ int mga_dma_reset(struct drm_device *dev, void *data,
  * DMA buffer management
  */
 
-static int mga_dma_get_buffers(struct drm_device * dev,
-                               struct drm_file *file_priv, struct drm_dma * d)
+static int mga_dma_get_buffers(struct drm_device *dev,
+                               struct drm_file *file_priv, struct drm_dma *d)
 {
         struct drm_buf *buf;
         int i;
@@ -1134,9 +1122,8 @@ int mga_dma_buffers(struct drm_device *dev, void *data,
 
         d->granted_count = 0;
 
-        if (d->request_count) {
+        if (d->request_count)
                 ret = mga_dma_get_buffers(dev, file_priv, d);
-        }
 
         return ret;
 }
@@ -1144,7 +1131,7 @@ int mga_dma_buffers(struct drm_device *dev, void *data,
 /**
  * Called just before the module is unloaded.
  */
-int mga_driver_unload(struct drm_device * dev)
+int mga_driver_unload(struct drm_device *dev)
 {
         kfree(dev->dev_private);
         dev->dev_private = NULL;
@@ -1155,12 +1142,12 @@ int mga_driver_unload(struct drm_device * dev)
 /**
  * Called when the last opener of the device is closed.
  */
-void mga_driver_lastclose(struct drm_device * dev)
+void mga_driver_lastclose(struct drm_device *dev)
 {
         mga_do_cleanup_dma(dev, FULL_CLEANUP);
 }
 
-int mga_driver_dma_quiescent(struct drm_device * dev)
+int mga_driver_dma_quiescent(struct drm_device *dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         return mga_do_wait_for_idle(dev_priv);
diff --git a/drivers/gpu/drm/mga/mga_drv.c b/drivers/gpu/drm/mga/mga_drv.c
index ddfe16197b59..26d0d8ced80d 100644
--- a/drivers/gpu/drm/mga/mga_drv.c
+++ b/drivers/gpu/drm/mga/mga_drv.c
@@ -36,7 +36,7 @@
 
 #include "drm_pciids.h"
 
-static int mga_driver_device_is_agp(struct drm_device * dev);
+static int mga_driver_device_is_agp(struct drm_device *dev);
 
 static struct pci_device_id pciidlist[] = {
         mga_PCI_IDS
@@ -119,7 +119,7 @@ MODULE_LICENSE("GPL and additional rights");
  * \returns
  * If the device is a PCI G450, zero is returned.  Otherwise 2 is returned.
  */
-static int mga_driver_device_is_agp(struct drm_device * dev)
+static int mga_driver_device_is_agp(struct drm_device *dev)
 {
         const struct pci_dev *const pdev = dev->pdev;
 
diff --git a/drivers/gpu/drm/mga/mga_drv.h b/drivers/gpu/drm/mga/mga_drv.h
index be6c6b9b0e89..1084fa4d261b 100644
--- a/drivers/gpu/drm/mga/mga_drv.h
+++ b/drivers/gpu/drm/mga/mga_drv.h
@@ -164,59 +164,59 @@ extern int mga_dma_reset(struct drm_device *dev, void *data,
 extern int mga_dma_buffers(struct drm_device *dev, void *data,
                            struct drm_file *file_priv);
 extern int mga_driver_load(struct drm_device *dev, unsigned long flags);
-extern int mga_driver_unload(struct drm_device * dev);
-extern void mga_driver_lastclose(struct drm_device * dev);
-extern int mga_driver_dma_quiescent(struct drm_device * dev);
+extern int mga_driver_unload(struct drm_device *dev);
+extern void mga_driver_lastclose(struct drm_device *dev);
+extern int mga_driver_dma_quiescent(struct drm_device *dev);
 
-extern int mga_do_wait_for_idle(drm_mga_private_t * dev_priv);
+extern int mga_do_wait_for_idle(drm_mga_private_t *dev_priv);
 
-extern void mga_do_dma_flush(drm_mga_private_t * dev_priv);
-extern void mga_do_dma_wrap_start(drm_mga_private_t * dev_priv);
-extern void mga_do_dma_wrap_end(drm_mga_private_t * dev_priv);
+extern void mga_do_dma_flush(drm_mga_private_t *dev_priv);
+extern void mga_do_dma_wrap_start(drm_mga_private_t *dev_priv);
+extern void mga_do_dma_wrap_end(drm_mga_private_t *dev_priv);
 
-extern int mga_freelist_put(struct drm_device * dev, struct drm_buf * buf);
+extern int mga_freelist_put(struct drm_device *dev, struct drm_buf *buf);
 
                                 /* mga_warp.c */
-extern int mga_warp_install_microcode(drm_mga_private_t * dev_priv);
-extern int mga_warp_init(drm_mga_private_t * dev_priv);
+extern int mga_warp_install_microcode(drm_mga_private_t *dev_priv);
+extern int mga_warp_init(drm_mga_private_t *dev_priv);
 
                                 /* mga_irq.c */
 extern int mga_enable_vblank(struct drm_device *dev, int crtc);
 extern void mga_disable_vblank(struct drm_device *dev, int crtc);
 extern u32 mga_get_vblank_counter(struct drm_device *dev, int crtc);
-extern int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence);
-extern int mga_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
+extern int mga_driver_fence_wait(struct drm_device *dev, unsigned int *sequence);
+extern int mga_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence);
 extern irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS);
-extern void mga_driver_irq_preinstall(struct drm_device * dev);
+extern void mga_driver_irq_preinstall(struct drm_device *dev);
 extern int mga_driver_irq_postinstall(struct drm_device *dev);
-extern void mga_driver_irq_uninstall(struct drm_device * dev);
+extern void mga_driver_irq_uninstall(struct drm_device *dev);
 extern long mga_compat_ioctl(struct file *filp, unsigned int cmd,
                              unsigned long arg);
 
 #define mga_flush_write_combine()       DRM_WRITEMEMORYBARRIER()
 
 #if defined(__linux__) && defined(__alpha__)
-#define MGA_BASE( reg )         ((unsigned long)(dev_priv->mmio->handle))
-#define MGA_ADDR( reg )         (MGA_BASE(reg) + reg)
+#define MGA_BASE(reg)           ((unsigned long)(dev_priv->mmio->handle))
+#define MGA_ADDR(reg)           (MGA_BASE(reg) + reg)
 
-#define MGA_DEREF( reg )        *(volatile u32 *)MGA_ADDR( reg )
-#define MGA_DEREF8( reg )       *(volatile u8 *)MGA_ADDR( reg )
+#define MGA_DEREF(reg)          (*(volatile u32 *)MGA_ADDR(reg))
+#define MGA_DEREF8(reg)         (*(volatile u8 *)MGA_ADDR(reg))
 
-#define MGA_READ( reg )         (_MGA_READ((u32 *)MGA_ADDR(reg)))
-#define MGA_READ8( reg )        (_MGA_READ((u8 *)MGA_ADDR(reg)))
-#define MGA_WRITE( reg, val )   do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF( reg ) = val; } while (0)
-#define MGA_WRITE8( reg, val )  do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF8( reg ) = val; } while (0)
+#define MGA_READ(reg)           (_MGA_READ((u32 *)MGA_ADDR(reg)))
+#define MGA_READ8(reg)          (_MGA_READ((u8 *)MGA_ADDR(reg)))
+#define MGA_WRITE(reg, val)     do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF(reg) = val; } while (0)
+#define MGA_WRITE8(reg, val)    do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF8(reg) = val; } while (0)
 
-static inline u32 _MGA_READ(u32 * addr)
+static inline u32 _MGA_READ(u32 *addr)
 {
         DRM_MEMORYBARRIER();
         return *(volatile u32 *)addr;
 }
 #else
-#define MGA_READ8( reg )        DRM_READ8(dev_priv->mmio, (reg))
-#define MGA_READ( reg )         DRM_READ32(dev_priv->mmio, (reg))
-#define MGA_WRITE8( reg, val )  DRM_WRITE8(dev_priv->mmio, (reg), (val))
-#define MGA_WRITE( reg, val )   DRM_WRITE32(dev_priv->mmio, (reg), (val))
+#define MGA_READ8(reg)          DRM_READ8(dev_priv->mmio, (reg))
+#define MGA_READ(reg)           DRM_READ32(dev_priv->mmio, (reg))
+#define MGA_WRITE8(reg, val)    DRM_WRITE8(dev_priv->mmio, (reg), (val))
+#define MGA_WRITE(reg, val)     DRM_WRITE32(dev_priv->mmio, (reg), (val))
 #endif
 
 #define DWGREG0         0x1c00
@@ -233,40 +233,39 @@ static inline u32 _MGA_READ(u32 * addr)
  * Helper macross...
  */
 
-#define MGA_EMIT_STATE( dev_priv, dirty )                               \
+#define MGA_EMIT_STATE(dev_priv, dirty)                                 \
 do {                                                                    \
-        if ( (dirty) & ~MGA_UPLOAD_CLIPRECTS ) {                        \
-                if ( dev_priv->chipset >= MGA_CARD_TYPE_G400 ) {        \
-                        mga_g400_emit_state( dev_priv );                \
-                } else {                                                \
-                        mga_g200_emit_state( dev_priv );                \
-                }                                                       \
+        if ((dirty) & ~MGA_UPLOAD_CLIPRECTS) {                          \
+                if (dev_priv->chipset >= MGA_CARD_TYPE_G400)            \
+                        mga_g400_emit_state(dev_priv);                  \
+                else                                                    \
+                        mga_g200_emit_state(dev_priv);                  \
         }                                                               \
 } while (0)
 
-#define WRAP_TEST_WITH_RETURN( dev_priv )                               \
+#define WRAP_TEST_WITH_RETURN(dev_priv)                                 \
 do {                                                                    \
-        if ( test_bit( 0, &dev_priv->prim.wrapped ) ) {                 \
-                if ( mga_is_idle( dev_priv ) ) {                        \
-                        mga_do_dma_wrap_end( dev_priv );                \
-                } else if ( dev_priv->prim.space <                      \
-                            dev_priv->prim.high_mark ) {                \
-                        if ( MGA_DMA_DEBUG )                            \
-                                DRM_INFO( "wrap...\n");         \
-                        return -EBUSY;                  \
+        if (test_bit(0, &dev_priv->prim.wrapped)) {                     \
+                if (mga_is_idle(dev_priv)) {                            \
+                        mga_do_dma_wrap_end(dev_priv);                  \
+                } else if (dev_priv->prim.space <                       \
+                           dev_priv->prim.high_mark) {                  \
+                        if (MGA_DMA_DEBUG)                              \
+                                DRM_INFO("wrap...\n");                  \
+                        return -EBUSY;                                  \
                 }                                                       \
         }                                                               \
 } while (0)
 
-#define WRAP_WAIT_WITH_RETURN( dev_priv )                               \
+#define WRAP_WAIT_WITH_RETURN(dev_priv)                                 \
 do {                                                                    \
-        if ( test_bit( 0, &dev_priv->prim.wrapped ) ) {                 \
-                if ( mga_do_wait_for_idle( dev_priv ) < 0 ) {           \
-                        if ( MGA_DMA_DEBUG )                            \
-                                DRM_INFO( "wrap...\n");         \
-                        return -EBUSY;                  \
+        if (test_bit(0, &dev_priv->prim.wrapped)) {                     \
+                if (mga_do_wait_for_idle(dev_priv) < 0) {               \
+                        if (MGA_DMA_DEBUG)                              \
+                                DRM_INFO("wrap...\n");                  \
+                        return -EBUSY;                                  \
                 }                                                       \
-                mga_do_dma_wrap_end( dev_priv );                        \
+                mga_do_dma_wrap_end(dev_priv);                          \
         }                                                               \
 } while (0)
 
@@ -280,12 +279,12 @@ do {									\
 
 #define DMA_BLOCK_SIZE  (5 * sizeof(u32))
 
-#define BEGIN_DMA( n )                                                  \
+#define BEGIN_DMA(n)                                                    \
 do {                                                                    \
-        if ( MGA_VERBOSE ) {                                            \
-                DRM_INFO( "BEGIN_DMA( %d )\n", (n) );           \
-                DRM_INFO( "   space=0x%x req=0x%Zx\n",                  \
-                          dev_priv->prim.space, (n) * DMA_BLOCK_SIZE ); \
+        if (MGA_VERBOSE) {                                              \
+                DRM_INFO("BEGIN_DMA(%d)\n", (n));                       \
+                DRM_INFO("   space=0x%x req=0x%Zx\n",                   \
+                         dev_priv->prim.space, (n) * DMA_BLOCK_SIZE);   \
         }                                                               \
         prim = dev_priv->prim.start;                                    \
         write = dev_priv->prim.tail;                                    \
@@ -293,9 +292,9 @@ do {									\
 
 #define BEGIN_DMA_WRAP()                                                \
 do {                                                                    \
-        if ( MGA_VERBOSE ) {                                            \
-                DRM_INFO( "BEGIN_DMA()\n" );                            \
-                DRM_INFO( "   space=0x%x\n", dev_priv->prim.space );    \
+        if (MGA_VERBOSE) {                                              \
+                DRM_INFO("BEGIN_DMA()\n");                              \
+                DRM_INFO("   space=0x%x\n", dev_priv->prim.space);      \
         }                                                               \
         prim = dev_priv->prim.start;                                    \
         write = dev_priv->prim.tail;                                    \
@@ -304,72 +303,68 @@ do {									\
 #define ADVANCE_DMA()                                                   \
 do {                                                                    \
         dev_priv->prim.tail = write;                                    \
-        if ( MGA_VERBOSE ) {                                            \
-                DRM_INFO( "ADVANCE_DMA() tail=0x%05x sp=0x%x\n",        \
-                          write, dev_priv->prim.space );                \
-        }                                                               \
+        if (MGA_VERBOSE)                                                \
+                DRM_INFO("ADVANCE_DMA() tail=0x%05x sp=0x%x\n",         \
+                         write, dev_priv->prim.space);                  \
 } while (0)
 
 #define FLUSH_DMA()                                                     \
 do {                                                                    \
-        if ( 0 ) {                                                      \
-                DRM_INFO( "\n" );                                       \
-                DRM_INFO( "   tail=0x%06x head=0x%06lx\n",              \
-                          dev_priv->prim.tail,                          \
-                          (unsigned long)(MGA_READ(MGA_PRIMADDRESS) -   \
-                                          dev_priv->primary->offset));  \
+        if (0) {                                                        \
+                DRM_INFO("\n");                                         \
+                DRM_INFO("   tail=0x%06x head=0x%06lx\n",               \
+                         dev_priv->prim.tail,                           \
+                         (unsigned long)(MGA_READ(MGA_PRIMADDRESS) -    \
+                                         dev_priv->primary->offset));   \
         }                                                               \
-        if ( !test_bit( 0, &dev_priv->prim.wrapped ) ) {                \
-                if ( dev_priv->prim.space <                             \
-                     dev_priv->prim.high_mark ) {                       \
-                        mga_do_dma_wrap_start( dev_priv );              \
-                } else {                                                \
-                        mga_do_dma_flush( dev_priv );                   \
-                }                                                       \
+        if (!test_bit(0, &dev_priv->prim.wrapped)) {                    \
+                if (dev_priv->prim.space < dev_priv->prim.high_mark)    \
+                        mga_do_dma_wrap_start(dev_priv);                \
+                else                                                    \
+                        mga_do_dma_flush(dev_priv);                     \
         }                                                               \
 } while (0)
 
 /* Never use this, always use DMA_BLOCK(...) for primary DMA output.
  */
-#define DMA_WRITE( offset, val )                                        \
+#define DMA_WRITE(offset, val)                                          \
 do {                                                                    \
-        if ( MGA_VERBOSE ) {                                            \
-                DRM_INFO( "   DMA_WRITE( 0x%08x ) at 0x%04Zx\n",        \
-                          (u32)(val), write + (offset) * sizeof(u32) ); \
-        }                                                               \
+        if (MGA_VERBOSE)                                                \
+                DRM_INFO("   DMA_WRITE( 0x%08x ) at 0x%04Zx\n",         \
+                         (u32)(val), write + (offset) * sizeof(u32));   \
         *(volatile u32 *)(prim + write + (offset) * sizeof(u32)) = val; \
 } while (0)
 
-#define DMA_BLOCK( reg0, val0, reg1, val1, reg2, val2, reg3, val3 )     \
+#define DMA_BLOCK(reg0, val0, reg1, val1, reg2, val2, reg3, val3)       \
 do {                                                                    \
-        DMA_WRITE( 0, ((DMAREG( reg0 ) << 0) |                          \
-                       (DMAREG( reg1 ) << 8) |                          \
-                       (DMAREG( reg2 ) << 16) |                         \
-                       (DMAREG( reg3 ) << 24)) );                       \
-        DMA_WRITE( 1, val0 );                                           \
-        DMA_WRITE( 2, val1 );                                           \
-        DMA_WRITE( 3, val2 );                                           \
-        DMA_WRITE( 4, val3 );                                           \
+        DMA_WRITE(0, ((DMAREG(reg0) << 0) |                             \
+                      (DMAREG(reg1) << 8) |                             \
+                      (DMAREG(reg2) << 16) |                            \
+                      (DMAREG(reg3) << 24)));                           \
+        DMA_WRITE(1, val0);                                             \
+        DMA_WRITE(2, val1);                                             \
+        DMA_WRITE(3, val2);                                             \
+        DMA_WRITE(4, val3);                                             \
         write += DMA_BLOCK_SIZE;                                        \
 } while (0)
 
 /* Buffer aging via primary DMA stream head pointer.
  */
 
-#define SET_AGE( age, h, w )                                            \
+#define SET_AGE(age, h, w)                                              \
 do {                                                                    \
         (age)->head = h;                                                \
         (age)->wrap = w;                                                \
 } while (0)
 
-#define TEST_AGE( age, h, w )           ( (age)->wrap < w ||            \
-                                          ( (age)->wrap == w &&         \
-                                            (age)->head < h ) )
+#define TEST_AGE(age, h, w)             ((age)->wrap < w ||             \
+                                         ((age)->wrap == w &&           \
+                                          (age)->head < h))
 
-#define AGE_BUFFER( buf_priv )                                          \
+#define AGE_BUFFER(buf_priv)                                            \
 do {                                                                    \
         drm_mga_freelist_t *entry = (buf_priv)->list_entry;             \
-        if ( (buf_priv)->dispatched ) {                                 \
+        if ((buf_priv)->dispatched) {                                   \
                 entry->age.head = (dev_priv->prim.tail +                \
                                    dev_priv->primary->offset);          \
                 entry->age.wrap = dev_priv->sarea_priv->last_wrap;      \
@@ -681,7 +676,7 @@ do {									\
 
 /* Simple idle test.
  */
-static __inline__ int mga_is_idle(drm_mga_private_t * dev_priv)
+static __inline__ int mga_is_idle(drm_mga_private_t *dev_priv)
 {
         u32 status = MGA_READ(MGA_STATUS) & MGA_ENGINE_IDLE_MASK;
         return (status == MGA_ENDPRDMASTS);
diff --git a/drivers/gpu/drm/mga/mga_irq.c b/drivers/gpu/drm/mga/mga_irq.c
index daa6041a483a..2581202297e4 100644
--- a/drivers/gpu/drm/mga/mga_irq.c
+++ b/drivers/gpu/drm/mga/mga_irq.c
@@ -76,9 +76,8 @@ irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS)
                 /* In addition to clearing the interrupt-pending bit, we
                  * have to write to MGA_PRIMEND to re-start the DMA operation.
                  */
-                if ((prim_start & ~0x03) != (prim_end & ~0x03)) {
+                if ((prim_start & ~0x03) != (prim_end & ~0x03))
                         MGA_WRITE(MGA_PRIMEND, prim_end);
-                }
 
                 atomic_inc(&dev_priv->last_fence_retired);
                 DRM_WAKEUP(&dev_priv->fence_queue);
@@ -120,7 +119,7 @@ void mga_disable_vblank(struct drm_device *dev, int crtc)
         /* MGA_WRITE(MGA_IEN, MGA_VLINEIEN | MGA_SOFTRAPEN); */
 }
 
-int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence)
+int mga_driver_fence_wait(struct drm_device *dev, unsigned int *sequence)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
         unsigned int cur_fence;
@@ -139,7 +138,7 @@ int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence)
         return ret;
 }
 
-void mga_driver_irq_preinstall(struct drm_device * dev)
+void mga_driver_irq_preinstall(struct drm_device *dev)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
 
@@ -162,7 +161,7 @@ int mga_driver_irq_postinstall(struct drm_device *dev)
         return 0;
 }
 
-void mga_driver_irq_uninstall(struct drm_device * dev)
+void mga_driver_irq_uninstall(struct drm_device *dev)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
         if (!dev_priv)
diff --git a/drivers/gpu/drm/mga/mga_state.c b/drivers/gpu/drm/mga/mga_state.c
index a53b848e0f17..fff82045c427 100644
--- a/drivers/gpu/drm/mga/mga_state.c
+++ b/drivers/gpu/drm/mga/mga_state.c
@@ -41,8 +41,8 @@
  * DMA hardware state programming functions
  */
 
-static void mga_emit_clip_rect(drm_mga_private_t * dev_priv,
-                               struct drm_clip_rect * box)
+static void mga_emit_clip_rect(drm_mga_private_t *dev_priv,
+                               struct drm_clip_rect *box)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
@@ -66,7 +66,7 @@ static void mga_emit_clip_rect(drm_mga_private_t * dev_priv,
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g200_emit_context(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g200_emit_context(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
@@ -89,7 +89,7 @@ static __inline__ void mga_g200_emit_context(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g400_emit_context(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_context(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
@@ -116,7 +116,7 @@ static __inline__ void mga_g400_emit_context(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g200_emit_tex0(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g200_emit_tex0(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[0];
@@ -144,7 +144,7 @@ static __inline__ void mga_g200_emit_tex0(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g400_emit_tex0(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_tex0(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[0];
@@ -184,7 +184,7 @@ static __inline__ void mga_g400_emit_tex0(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g400_emit_tex1(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_tex1(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[1];
@@ -223,7 +223,7 @@ static __inline__ void mga_g400_emit_tex1(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g200_emit_pipe(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g200_emit_pipe(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int pipe = sarea_priv->warp_pipe;
@@ -250,7 +250,7 @@ static __inline__ void mga_g200_emit_pipe(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static __inline__ void mga_g400_emit_pipe(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_pipe(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int pipe = sarea_priv->warp_pipe;
@@ -327,7 +327,7 @@ static __inline__ void mga_g400_emit_pipe(drm_mga_private_t * dev_priv)
         ADVANCE_DMA();
 }
 
-static void mga_g200_emit_state(drm_mga_private_t * dev_priv)
+static void mga_g200_emit_state(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int dirty = sarea_priv->dirty;
@@ -348,7 +348,7 @@ static void mga_g200_emit_state(drm_mga_private_t * dev_priv)
         }
 }
 
-static void mga_g400_emit_state(drm_mga_private_t * dev_priv)
+static void mga_g400_emit_state(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int dirty = sarea_priv->dirty;
@@ -381,7 +381,7 @@ static void mga_g400_emit_state(drm_mga_private_t * dev_priv)
 
 /* Disallow all write destinations except the front and backbuffer.
  */
-static int mga_verify_context(drm_mga_private_t * dev_priv)
+static int mga_verify_context(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
@@ -400,7 +400,7 @@ static int mga_verify_context(drm_mga_private_t * dev_priv)
 
 /* Disallow texture reads from PCI space.
  */
-static int mga_verify_tex(drm_mga_private_t * dev_priv, int unit)
+static int mga_verify_tex(drm_mga_private_t *dev_priv, int unit)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[unit];
@@ -417,7 +417,7 @@ static int mga_verify_tex(drm_mga_private_t * dev_priv, int unit)
         return 0;
 }
 
-static int mga_verify_state(drm_mga_private_t * dev_priv)
+static int mga_verify_state(drm_mga_private_t *dev_priv)
 {
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int dirty = sarea_priv->dirty;
@@ -446,7 +446,7 @@ static int mga_verify_state(drm_mga_private_t * dev_priv)
         return (ret == 0);
 }
 
-static int mga_verify_iload(drm_mga_private_t * dev_priv,
+static int mga_verify_iload(drm_mga_private_t *dev_priv,
                             unsigned int dstorg, unsigned int length)
 {
         if (dstorg < dev_priv->texture_offset ||
@@ -465,7 +465,7 @@ static int mga_verify_iload(drm_mga_private_t * dev_priv,
         return 0;
 }
 
-static int mga_verify_blit(drm_mga_private_t * dev_priv,
+static int mga_verify_blit(drm_mga_private_t *dev_priv,
                            unsigned int srcorg, unsigned int dstorg)
 {
         if ((srcorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM) ||
@@ -480,7 +480,7 @@ static int mga_verify_blit(drm_mga_private_t * dev_priv,
  *
  */
 
-static void mga_dma_dispatch_clear(struct drm_device * dev, drm_mga_clear_t * clear)
+static void mga_dma_dispatch_clear(struct drm_device *dev, drm_mga_clear_t *clear)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -568,7 +568,7 @@ static void mga_dma_dispatch_clear(struct drm_device * dev, drm_mga_clear_t * cl
         FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_swap(struct drm_device * dev)
+static void mga_dma_dispatch_swap(struct drm_device *dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -622,7 +622,7 @@ static void mga_dma_dispatch_swap(struct drm_device * dev)
         DRM_DEBUG("... done.\n");
 }
 
-static void mga_dma_dispatch_vertex(struct drm_device * dev, struct drm_buf * buf)
+static void mga_dma_dispatch_vertex(struct drm_device *dev, struct drm_buf *buf)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_buf_priv_t *buf_priv = buf->dev_private;
@@ -669,7 +669,7 @@ static void mga_dma_dispatch_vertex(struct drm_device * dev, struct drm_buf * bu
         FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_indices(struct drm_device * dev, struct drm_buf * buf,
+static void mga_dma_dispatch_indices(struct drm_device *dev, struct drm_buf *buf,
                                      unsigned int start, unsigned int end)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
@@ -718,7 +718,7 @@ static void mga_dma_dispatch_indices(struct drm_device * dev, struct drm_buf * b
 /* This copies a 64 byte aligned agp region to the frambuffer with a
  * standard blit, the ioctl needs to do checking.
  */
-static void mga_dma_dispatch_iload(struct drm_device * dev, struct drm_buf * buf,
+static void mga_dma_dispatch_iload(struct drm_device *dev, struct drm_buf *buf,
                                    unsigned int dstorg, unsigned int length)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
@@ -766,7 +766,7 @@ static void mga_dma_dispatch_iload(struct drm_device * dev, struct drm_buf * buf
         FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_blit(struct drm_device * dev, drm_mga_blit_t * blit)
+static void mga_dma_dispatch_blit(struct drm_device *dev, drm_mga_blit_t *blit)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -801,9 +801,8 @@ static void mga_dma_dispatch_blit(struct drm_device * dev, drm_mga_blit_t * blit
                 int w = pbox[i].x2 - pbox[i].x1 - 1;
                 int start;
 
-                if (blit->ydir == -1) {
+                if (blit->ydir == -1)
                         srcy = blit->height - srcy - 1;
-                }
 
                 start = srcy * blit->src_pitch + srcx;
 
diff --git a/drivers/gpu/drm/mga/mga_warp.c b/drivers/gpu/drm/mga/mga_warp.c
index 9aad4847afdf..f172bd5c257f 100644
--- a/drivers/gpu/drm/mga/mga_warp.c
+++ b/drivers/gpu/drm/mga/mga_warp.c
@@ -46,7 +46,7 @@ MODULE_FIRMWARE(FIRMWARE_G400);
 
 #define WARP_UCODE_SIZE(size)           ALIGN(size, MGA_WARP_CODE_ALIGN)
 
-int mga_warp_install_microcode(drm_mga_private_t * dev_priv)
+int mga_warp_install_microcode(drm_mga_private_t *dev_priv)
 {
         unsigned char *vcbase = dev_priv->warp->handle;
         unsigned long pcbase = dev_priv->warp->offset;
@@ -133,7 +133,7 @@ out:
 
 #define WMISC_EXPECTED          (MGA_WUCODECACHE_ENABLE | MGA_WMASTER_ENABLE)
 
-int mga_warp_init(drm_mga_private_t * dev_priv)
+int mga_warp_init(drm_mga_private_t *dev_priv)
 {
         u32 wmisc;
 
diff --git a/drivers/gpu/drm/nouveau/Kconfig b/drivers/gpu/drm/nouveau/Kconfig
index b6f5239c2efb..d2d28048efb2 100644
--- a/drivers/gpu/drm/nouveau/Kconfig
+++ b/drivers/gpu/drm/nouveau/Kconfig
@@ -41,4 +41,13 @@ config DRM_I2C_CH7006
 
           This driver is currently only useful if you're also using
           the nouveau driver.
+
+config DRM_I2C_SIL164
+        tristate "Silicon Image sil164 TMDS transmitter"
+        default m if DRM_NOUVEAU
+        help
+          Support for sil164 and similar single-link (or dual-link
+          when used in pairs) TMDS transmitters, used in some nVidia
+          video cards.
+
 endmenu
diff --git a/drivers/gpu/drm/r128/r128_cce.c b/drivers/gpu/drm/r128/r128_cce.c
index e671d0e74d4c..570e190710bd 100644
--- a/drivers/gpu/drm/r128/r128_cce.c
+++ b/drivers/gpu/drm/r128/r128_cce.c
@@ -44,7 +44,7 @@
 
 MODULE_FIRMWARE(FIRMWARE_NAME);
 
-static int R128_READ_PLL(struct drm_device * dev, int addr)
+static int R128_READ_PLL(struct drm_device *dev, int addr)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
 
@@ -53,7 +53,7 @@ static int R128_READ_PLL(struct drm_device * dev, int addr)
 }
 
 #if R128_FIFO_DEBUG
-static void r128_status(drm_r128_private_t * dev_priv)
+static void r128_status(drm_r128_private_t *dev_priv)
 {
         printk("GUI_STAT           = 0x%08x\n",
                (unsigned int)R128_READ(R128_GUI_STAT));
@@ -74,7 +74,7 @@ static void r128_status(drm_r128_private_t * dev_priv)
  * Engine, FIFO control
  */
 
-static int r128_do_pixcache_flush(drm_r128_private_t * dev_priv)
+static int r128_do_pixcache_flush(drm_r128_private_t *dev_priv)
 {
         u32 tmp;
         int i;
@@ -83,9 +83,8 @@ static int r128_do_pixcache_flush(drm_r128_private_t * dev_priv)
         R128_WRITE(R128_PC_NGUI_CTLSTAT, tmp);
 
         for (i = 0; i < dev_priv->usec_timeout; i++) {
-                if (!(R128_READ(R128_PC_NGUI_CTLSTAT) & R128_PC_BUSY)) {
+                if (!(R128_READ(R128_PC_NGUI_CTLSTAT) & R128_PC_BUSY))
                         return 0;
-                }
                 DRM_UDELAY(1);
         }
 
@@ -95,7 +94,7 @@ static int r128_do_pixcache_flush(drm_r128_private_t * dev_priv)
         return -EBUSY;
 }
 
-static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries)
+static int r128_do_wait_for_fifo(drm_r128_private_t *dev_priv, int entries)
 {
         int i;
 
@@ -112,7 +111,7 @@ static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries)
         return -EBUSY;
 }
 
-static int r128_do_wait_for_idle(drm_r128_private_t * dev_priv)
+static int r128_do_wait_for_idle(drm_r128_private_t *dev_priv)
 {
         int i, ret;
 
@@ -189,7 +188,7 @@ out_release:
  * prior to a wait for idle, as it informs the engine that the command
  * stream is ending.
  */
-static void r128_do_cce_flush(drm_r128_private_t * dev_priv)
+static void r128_do_cce_flush(drm_r128_private_t *dev_priv)
 {
         u32 tmp;
 
@@ -199,7 +198,7 @@ static void r128_do_cce_flush(drm_r128_private_t * dev_priv)
 
 /* Wait for the CCE to go idle.
  */
-int r128_do_cce_idle(drm_r128_private_t * dev_priv)
+int r128_do_cce_idle(drm_r128_private_t *dev_priv)
 {
         int i;
 
@@ -225,7 +224,7 @@ int r128_do_cce_idle(drm_r128_private_t * dev_priv)
 
 /* Start the Concurrent Command Engine.
  */
-static void r128_do_cce_start(drm_r128_private_t * dev_priv)
+static void r128_do_cce_start(drm_r128_private_t *dev_priv)
 {
         r128_do_wait_for_idle(dev_priv);
 
@@ -242,7 +241,7 @@ static void r128_do_cce_start(drm_r128_private_t * dev_priv)
  * commands, so you must wait for the CCE command stream to complete
  * before calling this routine.
  */
-static void r128_do_cce_reset(drm_r128_private_t * dev_priv)
+static void r128_do_cce_reset(drm_r128_private_t *dev_priv)
 {
         R128_WRITE(R128_PM4_BUFFER_DL_WPTR, 0);
         R128_WRITE(R128_PM4_BUFFER_DL_RPTR, 0);
@@ -253,7 +252,7 @@ static void r128_do_cce_reset(drm_r128_private_t * dev_priv)
  * commands, so you must flush the command stream and wait for the CCE
  * to go idle before calling this routine.
  */
-static void r128_do_cce_stop(drm_r128_private_t * dev_priv)
+static void r128_do_cce_stop(drm_r128_private_t *dev_priv)
 {
         R128_WRITE(R128_PM4_MICRO_CNTL, 0);
         R128_WRITE(R128_PM4_BUFFER_CNTL,
@@ -264,7 +263,7 @@ static void r128_do_cce_stop(drm_r128_private_t * dev_priv)
 
 /* Reset the engine.  This will stop the CCE if it is running.
  */
-static int r128_do_engine_reset(struct drm_device * dev)
+static int r128_do_engine_reset(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         u32 clock_cntl_index, mclk_cntl, gen_reset_cntl;
@@ -301,8 +300,8 @@ static int r128_do_engine_reset(struct drm_device * dev)
         return 0;
 }
 
-static void r128_cce_init_ring_buffer(struct drm_device * dev,
-                                      drm_r128_private_t * dev_priv)
+static void r128_cce_init_ring_buffer(struct drm_device *dev,
+                                      drm_r128_private_t *dev_priv)
 {
         u32 ring_start;
         u32 tmp;
@@ -340,7 +339,7 @@ static void r128_cce_init_ring_buffer(struct drm_device * dev,
         R128_WRITE(R128_BUS_CNTL, tmp);
 }
 
-static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
+static int r128_do_init_cce(struct drm_device *dev, drm_r128_init_t *init)
 {
         drm_r128_private_t *dev_priv;
         int rc;
@@ -588,7 +587,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
         return rc;
 }
 
-int r128_do_cleanup_cce(struct drm_device * dev)
+int r128_do_cleanup_cce(struct drm_device *dev)
 {
 
         /* Make sure interrupts are disabled here because the uninstall ioctl
@@ -682,9 +681,8 @@ int r128_cce_stop(struct drm_device *dev, void *data, struct drm_file *file_priv
         /* Flush any pending CCE commands.  This ensures any outstanding
          * commands are exectuted by the engine before we turn it off.
          */
-        if (stop->flush) {
+        if (stop->flush)
                 r128_do_cce_flush(dev_priv);
-        }
 
         /* If we fail to make the engine go idle, we return an error
          * code so that the DRM ioctl wrapper can try again.
@@ -735,9 +733,8 @@ int r128_cce_idle(struct drm_device *dev, void *data, struct drm_file *file_priv
 
         DEV_INIT_TEST_WITH_RETURN(dev_priv);
 
-        if (dev_priv->cce_running) {
+        if (dev_priv->cce_running)
                 r128_do_cce_flush(dev_priv);
-        }
 
         return r128_do_cce_idle(dev_priv);
 }
@@ -765,7 +762,7 @@ int r128_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_pr
 #define R128_BUFFER_FREE        0
 
 #if 0
-static int r128_freelist_init(struct drm_device * dev)
+static int r128_freelist_init(struct drm_device *dev)
 {
         struct drm_device_dma *dma = dev->dma;
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -848,7 +845,7 @@ static struct drm_buf *r128_freelist_get(struct drm_device * dev)
         return NULL;
 }
 
-void r128_freelist_reset(struct drm_device * dev)
+void r128_freelist_reset(struct drm_device *dev)
 {
         struct drm_device_dma *dma = dev->dma;
         int i;
@@ -864,7 +861,7 @@ void r128_freelist_reset(struct drm_device * dev)
  * CCE command submission
  */
 
-int r128_wait_ring(drm_r128_private_t * dev_priv, int n)
+int r128_wait_ring(drm_r128_private_t *dev_priv, int n)
 {
         drm_r128_ring_buffer_t *ring = &dev_priv->ring;
         int i;
@@ -881,9 +878,9 @@ int r128_wait_ring(drm_r128_private_t * dev_priv, int n)
         return -EBUSY;
 }
 
-static int r128_cce_get_buffers(struct drm_device * dev,
+static int r128_cce_get_buffers(struct drm_device *dev,
                                 struct drm_file *file_priv,
-                                struct drm_dma * d)
+                                struct drm_dma *d)
 {
         int i;
         struct drm_buf *buf;
@@ -933,9 +930,8 @@ int r128_cce_buffers(struct drm_device *dev, void *data, struct drm_file *file_p
 
         d->granted_count = 0;
 
-        if (d->request_count) {
+        if (d->request_count)
                 ret = r128_cce_get_buffers(dev, file_priv, d);
-        }
 
         return ret;
 }
diff --git a/drivers/gpu/drm/r128/r128_drv.c b/drivers/gpu/drm/r128/r128_drv.c
index b806fdcc7170..1e2971f13aa1 100644
--- a/drivers/gpu/drm/r128/r128_drv.c
+++ b/drivers/gpu/drm/r128/r128_drv.c
@@ -85,7 +85,7 @@ static struct drm_driver driver = {
         .patchlevel = DRIVER_PATCHLEVEL,
 };
 
-int r128_driver_load(struct drm_device * dev, unsigned long flags)
+int r128_driver_load(struct drm_device *dev, unsigned long flags)
 {
         return drm_vblank_init(dev, 1);
 }
diff --git a/drivers/gpu/drm/r128/r128_drv.h b/drivers/gpu/drm/r128/r128_drv.h
index 3c60829d82e9..930c71b2fb5e 100644
--- a/drivers/gpu/drm/r128/r128_drv.h
+++ b/drivers/gpu/drm/r128/r128_drv.h
@@ -53,7 +53,7 @@
 #define DRIVER_MINOR            5
 #define DRIVER_PATCHLEVEL       0
 
-#define GET_RING_HEAD(dev_priv)         R128_READ( R128_PM4_BUFFER_DL_RPTR )
+#define GET_RING_HEAD(dev_priv)         R128_READ(R128_PM4_BUFFER_DL_RPTR)
 
 typedef struct drm_r128_freelist {
         unsigned int age;
@@ -144,23 +144,23 @@ extern int r128_engine_reset(struct drm_device *dev, void *data, struct drm_file
 extern int r128_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv);
 extern int r128_cce_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv);
 
-extern void r128_freelist_reset(struct drm_device * dev);
+extern void r128_freelist_reset(struct drm_device *dev);
 
-extern int r128_wait_ring(drm_r128_private_t * dev_priv, int n);
+extern int r128_wait_ring(drm_r128_private_t *dev_priv, int n);
 
-extern int r128_do_cce_idle(drm_r128_private_t * dev_priv);
-extern int r128_do_cleanup_cce(struct drm_device * dev);
+extern int r128_do_cce_idle(drm_r128_private_t *dev_priv);
+extern int r128_do_cleanup_cce(struct drm_device *dev);
 
 extern int r128_enable_vblank(struct drm_device *dev, int crtc);
 extern void r128_disable_vblank(struct drm_device *dev, int crtc);
 extern u32 r128_get_vblank_counter(struct drm_device *dev, int crtc);
 extern irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS);
-extern void r128_driver_irq_preinstall(struct drm_device * dev);
+extern void r128_driver_irq_preinstall(struct drm_device *dev);
 extern int r128_driver_irq_postinstall(struct drm_device *dev);
-extern void r128_driver_irq_uninstall(struct drm_device * dev);
-extern void r128_driver_lastclose(struct drm_device * dev);
-extern int r128_driver_load(struct drm_device * dev, unsigned long flags);
-extern void r128_driver_preclose(struct drm_device * dev,
+extern void r128_driver_irq_uninstall(struct drm_device *dev);
+extern void r128_driver_lastclose(struct drm_device *dev);
+extern int r128_driver_load(struct drm_device *dev, unsigned long flags);
+extern void r128_driver_preclose(struct drm_device *dev,
                                  struct drm_file *file_priv);
 
 extern long r128_compat_ioctl(struct file *filp, unsigned int cmd,
@@ -390,27 +390,27 @@ extern long r128_compat_ioctl(struct file *filp, unsigned int cmd,
 
 #define R128_PCIGART_TABLE_SIZE         32768
 
-#define R128_READ(reg)          DRM_READ32(  dev_priv->mmio, (reg) )
-#define R128_WRITE(reg,val)     DRM_WRITE32( dev_priv->mmio, (reg), (val) )
-#define R128_READ8(reg)         DRM_READ8(   dev_priv->mmio, (reg) )
-#define R128_WRITE8(reg,val)    DRM_WRITE8(  dev_priv->mmio, (reg), (val) )
+#define R128_READ(reg)          DRM_READ32(dev_priv->mmio, (reg))
+#define R128_WRITE(reg, val)    DRM_WRITE32(dev_priv->mmio, (reg), (val))
+#define R128_READ8(reg)         DRM_READ8(dev_priv->mmio, (reg))
+#define R128_WRITE8(reg, val)   DRM_WRITE8(dev_priv->mmio, (reg), (val))
 
-#define R128_WRITE_PLL(addr,val)                                        \
+#define R128_WRITE_PLL(addr, val)                                       \
 do {                                                                    \
         R128_WRITE8(R128_CLOCK_CNTL_INDEX,                              \
                     ((addr) & 0x1f) | R128_PLL_WR_EN);                  \
         R128_WRITE(R128_CLOCK_CNTL_DATA, (val));                        \
 } while (0)
 
-#define CCE_PACKET0( reg, n )           (R128_CCE_PACKET0 |             \
+#define CCE_PACKET0(reg, n)             (R128_CCE_PACKET0 |             \
                                          ((n) << 16) | ((reg) >> 2))
-#define CCE_PACKET1( reg0, reg1 )       (R128_CCE_PACKET1 |             \
+#define CCE_PACKET1(reg0, reg1)         (R128_CCE_PACKET1 |             \
                                          (((reg1) >> 2) << 11) | ((reg0) >> 2))
 #define CCE_PACKET2()                   (R128_CCE_PACKET2)
-#define CCE_PACKET3( pkt, n )           (R128_CCE_PACKET3 |             \
+#define CCE_PACKET3(pkt, n)             (R128_CCE_PACKET3 |             \
                                          (pkt) | ((n) << 16))
 
-static __inline__ void r128_update_ring_snapshot(drm_r128_private_t * dev_priv)
+static __inline__ void r128_update_ring_snapshot(drm_r128_private_t *dev_priv)
 {
         drm_r128_ring_buffer_t *ring = &dev_priv->ring;
         ring->space = (GET_RING_HEAD(dev_priv) - ring->tail) * sizeof(u32);
@@ -430,37 +430,38 @@ do {									\
         }                                                               \
 } while (0)
 
-#define RING_SPACE_TEST_WITH_RETURN( dev_priv )                         \
+#define RING_SPACE_TEST_WITH_RETURN(dev_priv)                           \
 do {                                                                    \
         drm_r128_ring_buffer_t *ring = &dev_priv->ring; int i;          \
-        if ( ring->space < ring->high_mark ) {                          \
-                for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {      \
-                        r128_update_ring_snapshot( dev_priv );          \
-                        if ( ring->space >= ring->high_mark )           \
+        if (ring->space < ring->high_mark) {                            \
+                for (i = 0 ; i < dev_priv->usec_timeout ; i++) {        \
+                        r128_update_ring_snapshot(dev_priv);            \
+                        if (ring->space >= ring->high_mark)             \
                                 goto __ring_space_done;                 \
-                        DRM_UDELAY(1);                          \
+                        DRM_UDELAY(1);                                  \
                 }                                                       \
-                DRM_ERROR( "ring space check failed!\n" );              \
-                return -EBUSY;                          \
+                DRM_ERROR("ring space check failed!\n");                \
+                return -EBUSY;                                          \
         }                                                               \
  __ring_space_done:                                                     \
         ;                                                               \
 } while (0)
 
-#define VB_AGE_TEST_WITH_RETURN( dev_priv )                             \
+#define VB_AGE_TEST_WITH_RETURN(dev_priv)                               \
 do {                                                                    \
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;            \
-        if ( sarea_priv->last_dispatch >= R128_MAX_VB_AGE ) {           \
-                int __ret = r128_do_cce_idle( dev_priv );               \
-                if ( __ret ) return __ret;                              \
+        if (sarea_priv->last_dispatch >= R128_MAX_VB_AGE) {             \
+                int __ret = r128_do_cce_idle(dev_priv);                 \
+                if (__ret)                                              \
+                        return __ret;                                   \
                 sarea_priv->last_dispatch = 0;                          \
-                r128_freelist_reset( dev );                             \
+                r128_freelist_reset(dev);                               \
         }                                                               \
 } while (0)
 
 #define R128_WAIT_UNTIL_PAGE_FLIPPED() do {                             \
-        OUT_RING( CCE_PACKET0( R128_WAIT_UNTIL, 0 ) );                  \
-        OUT_RING( R128_EVENT_CRTC_OFFSET );                             \
+        OUT_RING(CCE_PACKET0(R128_WAIT_UNTIL, 0));                      \
+        OUT_RING(R128_EVENT_CRTC_OFFSET);                               \
 } while (0)
 
 /* ================================================================
@@ -472,13 +473,12 @@ do {									\
 #define RING_LOCALS                                                     \
         int write, _nr; unsigned int tail_mask; volatile u32 *ring;
 
-#define BEGIN_RING( n ) do {                                            \
-        if ( R128_VERBOSE ) {                                           \
-                DRM_INFO( "BEGIN_RING( %d )\n", (n));                   \
-        }                                                               \
-        if ( dev_priv->ring.space <= (n) * sizeof(u32) ) {              \
+#define BEGIN_RING(n) do {                                              \
+        if (R128_VERBOSE)                                               \
+                DRM_INFO("BEGIN_RING(%d)\n", (n));                      \
+        if (dev_priv->ring.space <= (n) * sizeof(u32)) {                \
                 COMMIT_RING();                                          \
-                r128_wait_ring( dev_priv, (n) * sizeof(u32) );          \
+                r128_wait_ring(dev_priv, (n) * sizeof(u32));            \
         }                                                               \
         _nr = n; dev_priv->ring.space -= (n) * sizeof(u32);             \
         ring = dev_priv->ring.start;                                    \
@@ -494,40 +494,36 @@ do {									\
 #define R128_BROKEN_CCE 1
 
 #define ADVANCE_RING() do {                                             \
-        if ( R128_VERBOSE ) {                                           \
-                DRM_INFO( "ADVANCE_RING() wr=0x%06x tail=0x%06x\n",     \
-                          write, dev_priv->ring.tail );                 \
-        }                                                               \
-        if ( R128_BROKEN_CCE && write < 32 ) {                          \
-                memcpy( dev_priv->ring.end,                             \
-                        dev_priv->ring.start,                           \
-                        write * sizeof(u32) );                          \
-        }                                                               \
-        if (((dev_priv->ring.tail + _nr) & tail_mask) != write) {       \
+        if (R128_VERBOSE)                                               \
+                DRM_INFO("ADVANCE_RING() wr=0x%06x tail=0x%06x\n",      \
+                         write, dev_priv->ring.tail);                   \
+        if (R128_BROKEN_CCE && write < 32)                              \
+                memcpy(dev_priv->ring.end,                              \
+                       dev_priv->ring.start,                            \
+                       write * sizeof(u32));                            \
+        if (((dev_priv->ring.tail + _nr) & tail_mask) != write)         \
                 DRM_ERROR(                                              \
                         "ADVANCE_RING(): mismatch: nr: %x write: %x line: %d\n",        \
                         ((dev_priv->ring.tail + _nr) & tail_mask),      \
                         write, __LINE__);                               \
-        } else                                                          \
+        else                                                            \
                 dev_priv->ring.tail = write;                            \
 } while (0)
 
 #define COMMIT_RING() do {                                              \
-        if ( R128_VERBOSE ) {                                           \
-                DRM_INFO( "COMMIT_RING() tail=0x%06x\n",                \
-                        dev_priv->ring.tail );                          \
-        }                                                               \
+        if (R128_VERBOSE)                                               \
+                DRM_INFO("COMMIT_RING() tail=0x%06x\n",                 \
+                         dev_priv->ring.tail);                          \
         DRM_MEMORYBARRIER();                                            \
-        R128_WRITE( R128_PM4_BUFFER_DL_WPTR, dev_priv->ring.tail );     \
-        R128_READ( R128_PM4_BUFFER_DL_WPTR );                           \
+        R128_WRITE(R128_PM4_BUFFER_DL_WPTR, dev_priv->ring.tail);       \
+        R128_READ(R128_PM4_BUFFER_DL_WPTR);                             \
 } while (0)
 
-#define OUT_RING( x ) do {                                              \
-        if ( R128_VERBOSE ) {                                           \
-                DRM_INFO( "   OUT_RING( 0x%08x ) at 0x%x\n",            \
-                           (unsigned int)(x), write );                  \
-        }                                                               \
-        ring[write++] = cpu_to_le32( x );                               \
+#define OUT_RING(x) do {                                                \
+        if (R128_VERBOSE)                                               \
+                DRM_INFO("   OUT_RING( 0x%08x ) at 0x%x\n",             \
+                         (unsigned int)(x), write);                     \
+        ring[write++] = cpu_to_le32(x);                                 \
         write &= tail_mask;                                             \
 } while (0)
 
diff --git a/drivers/gpu/drm/r128/r128_irq.c b/drivers/gpu/drm/r128/r128_irq.c
index 69810fb8ac49..429d5a02695f 100644
--- a/drivers/gpu/drm/r128/r128_irq.c
+++ b/drivers/gpu/drm/r128/r128_irq.c
@@ -90,7 +90,7 @@ void r128_disable_vblank(struct drm_device *dev, int crtc)
          */
 }
 
-void r128_driver_irq_preinstall(struct drm_device * dev)
+void r128_driver_irq_preinstall(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
 
@@ -105,7 +105,7 @@ int r128_driver_irq_postinstall(struct drm_device *dev)
         return 0;
 }
 
-void r128_driver_irq_uninstall(struct drm_device * dev)
+void r128_driver_irq_uninstall(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
         if (!dev_priv)
diff --git a/drivers/gpu/drm/r128/r128_state.c b/drivers/gpu/drm/r128/r128_state.c
index af2665cf4718..077af1f2f9b4 100644
--- a/drivers/gpu/drm/r128/r128_state.c
+++ b/drivers/gpu/drm/r128/r128_state.c
@@ -37,8 +37,8 @@
  * CCE hardware state programming functions
  */
 
-static void r128_emit_clip_rects(drm_r128_private_t * dev_priv,
-                                 struct drm_clip_rect * boxes, int count)
+static void r128_emit_clip_rects(drm_r128_private_t *dev_priv,
+                                 struct drm_clip_rect *boxes, int count)
 {
         u32 aux_sc_cntl = 0x00000000;
         RING_LOCALS;
@@ -80,7 +80,7 @@ static void r128_emit_clip_rects(drm_r128_private_t * dev_priv,
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_core(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_core(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
@@ -95,7 +95,7 @@ static __inline__ void r128_emit_core(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_context(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_context(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
@@ -121,7 +121,7 @@ static __inline__ void r128_emit_context(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_setup(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_setup(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
@@ -137,7 +137,7 @@ static __inline__ void r128_emit_setup(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_masks(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_masks(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
@@ -156,7 +156,7 @@ static __inline__ void r128_emit_masks(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_window(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_window(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
@@ -171,7 +171,7 @@ static __inline__ void r128_emit_window(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_tex0(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_tex0(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
@@ -187,9 +187,8 @@ static __inline__ void r128_emit_tex0(drm_r128_private_t * dev_priv)
         OUT_RING(tex->tex_cntl);
         OUT_RING(tex->tex_combine_cntl);
         OUT_RING(ctx->tex_size_pitch_c);
-        for (i = 0; i < R128_MAX_TEXTURE_LEVELS; i++) {
+        for (i = 0; i < R128_MAX_TEXTURE_LEVELS; i++)
                 OUT_RING(tex->tex_offset[i]);
-        }
 
         OUT_RING(CCE_PACKET0(R128_CONSTANT_COLOR_C, 1));
         OUT_RING(ctx->constant_color_c);
@@ -198,7 +197,7 @@ static __inline__ void r128_emit_tex0(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static __inline__ void r128_emit_tex1(drm_r128_private_t * dev_priv)
+static __inline__ void r128_emit_tex1(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[1];
@@ -211,9 +210,8 @@ static __inline__ void r128_emit_tex1(drm_r128_private_t * dev_priv)
         OUT_RING(CCE_PACKET0(R128_SEC_TEX_CNTL_C, 1 + R128_MAX_TEXTURE_LEVELS));
         OUT_RING(tex->tex_cntl);
         OUT_RING(tex->tex_combine_cntl);
-        for (i = 0; i < R128_MAX_TEXTURE_LEVELS; i++) {
+        for (i = 0; i < R128_MAX_TEXTURE_LEVELS; i++)
                 OUT_RING(tex->tex_offset[i]);
-        }
 
         OUT_RING(CCE_PACKET0(R128_SEC_TEXTURE_BORDER_COLOR_C, 0));
         OUT_RING(tex->tex_border_color);
@@ -221,7 +219,7 @@ static __inline__ void r128_emit_tex1(drm_r128_private_t * dev_priv)
         ADVANCE_RING();
 }
 
-static void r128_emit_state(drm_r128_private_t * dev_priv)
+static void r128_emit_state(drm_r128_private_t *dev_priv)
 {
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
         unsigned int dirty = sarea_priv->dirty;
@@ -274,7 +272,7 @@ static void r128_emit_state(drm_r128_private_t * dev_priv)
  * Performance monitoring functions
  */
 
-static void r128_clear_box(drm_r128_private_t * dev_priv,
+static void r128_clear_box(drm_r128_private_t *dev_priv,
                            int x, int y, int w, int h, int r, int g, int b)
 {
         u32 pitch, offset;
@@ -321,13 +319,12 @@ static void r128_clear_box(drm_r128_private_t * dev_priv,
         ADVANCE_RING();
 }
 
-static void r128_cce_performance_boxes(drm_r128_private_t * dev_priv)
+static void r128_cce_performance_boxes(drm_r128_private_t *dev_priv)
 {
-        if (atomic_read(&dev_priv->idle_count) == 0) {
+        if (atomic_read(&dev_priv->idle_count) == 0)
                 r128_clear_box(dev_priv, 64, 4, 8, 8, 0, 255, 0);
-        } else {
+        else
                 atomic_set(&dev_priv->idle_count, 0);
-        }
 }
 
 #endif
@@ -352,8 +349,8 @@ static void r128_print_dirty(const char *msg, unsigned int flags)
                  (flags & R128_REQUIRE_QUIESCENCE) ? "quiescence, " : "");
 }
 
-static void r128_cce_dispatch_clear(struct drm_device * dev,
-                                    drm_r128_clear_t * clear)
+static void r128_cce_dispatch_clear(struct drm_device *dev,
+                                    drm_r128_clear_t *clear)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -458,7 +455,7 @@ static void r128_cce_dispatch_clear(struct drm_device * dev,
         }
 }
 
-static void r128_cce_dispatch_swap(struct drm_device * dev)
+static void r128_cce_dispatch_swap(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -524,7 +521,7 @@ static void r128_cce_dispatch_swap(struct drm_device * dev)
         ADVANCE_RING();
 }
 
-static void r128_cce_dispatch_flip(struct drm_device * dev)
+static void r128_cce_dispatch_flip(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -542,11 +539,10 @@ static void r128_cce_dispatch_flip(struct drm_device * dev)
         R128_WAIT_UNTIL_PAGE_FLIPPED();
         OUT_RING(CCE_PACKET0(R128_CRTC_OFFSET, 0));
 
-        if (dev_priv->current_page == 0) {
+        if (dev_priv->current_page == 0)
                 OUT_RING(dev_priv->back_offset);
-        } else {
+        else
                 OUT_RING(dev_priv->front_offset);
-        }
 
         ADVANCE_RING();
 
@@ -566,7 +562,7 @@ static void r128_cce_dispatch_flip(struct drm_device * dev)
         ADVANCE_RING();
 }
 
-static void r128_cce_dispatch_vertex(struct drm_device * dev, struct drm_buf * buf)
+static void r128_cce_dispatch_vertex(struct drm_device *dev, struct drm_buf *buf)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         drm_r128_buf_priv_t *buf_priv = buf->dev_private;
@@ -585,9 +581,8 @@ static void r128_cce_dispatch_vertex(struct drm_device * dev, struct drm_buf * b
         if (buf->used) {
                 buf_priv->dispatched = 1;
 
-                if (sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS) {
+                if (sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS)
                         r128_emit_state(dev_priv);
-                }
 
                 do {
                         /* Emit the next set of up to three cliprects */
@@ -636,8 +631,8 @@ static void r128_cce_dispatch_vertex(struct drm_device * dev, struct drm_buf * b
         sarea_priv->nbox = 0;
 }
 
-static void r128_cce_dispatch_indirect(struct drm_device * dev,
-                                       struct drm_buf * buf, int start, int end)
+static void r128_cce_dispatch_indirect(struct drm_device *dev,
+                                       struct drm_buf *buf, int start, int end)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         drm_r128_buf_priv_t *buf_priv = buf->dev_private;
@@ -691,8 +686,8 @@ static void r128_cce_dispatch_indirect(struct drm_device * dev,
         dev_priv->sarea_priv->last_dispatch++;
 }
 
-static void r128_cce_dispatch_indices(struct drm_device * dev,
-                                      struct drm_buf * buf,
+static void r128_cce_dispatch_indices(struct drm_device *dev,
+                                      struct drm_buf *buf,
                                       int start, int end, int count)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -713,9 +708,8 @@ static void r128_cce_dispatch_indices(struct drm_device * dev,
         if (start != end) {
                 buf_priv->dispatched = 1;
 
-                if (sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS) {
+                if (sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS)
                         r128_emit_state(dev_priv);
-                }
 
                 dwords = (end - start + 3) / sizeof(u32);
 
@@ -775,9 +769,9 @@ static void r128_cce_dispatch_indices(struct drm_device * dev,
         sarea_priv->nbox = 0;
 }
 
-static int r128_cce_dispatch_blit(struct drm_device * dev,
+static int r128_cce_dispatch_blit(struct drm_device *dev,
                                   struct drm_file *file_priv,
-                                  drm_r128_blit_t * blit)
+                                  drm_r128_blit_t *blit)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         struct drm_device_dma *dma = dev->dma;
@@ -887,8 +881,8 @@ static int r128_cce_dispatch_blit(struct drm_device * dev,
  * have hardware stencil support.
  */
 
-static int r128_cce_dispatch_write_span(struct drm_device * dev,
-                                        drm_r128_depth_t * depth)
+static int r128_cce_dispatch_write_span(struct drm_device *dev,
+                                        drm_r128_depth_t *depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         int count, x, y;
@@ -902,12 +896,10 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
         if (count > 4096 || count <= 0)
                 return -EMSGSIZE;
 
-        if (DRM_COPY_FROM_USER(&x, depth->x, sizeof(x))) {
+        if (DRM_COPY_FROM_USER(&x, depth->x, sizeof(x)))
                 return -EFAULT;
-        }
-        if (DRM_COPY_FROM_USER(&y, depth->y, sizeof(y))) {
+        if (DRM_COPY_FROM_USER(&y, depth->y, sizeof(y)))
                 return -EFAULT;
-        }
 
         buffer_size = depth->n * sizeof(u32);
         buffer = kmalloc(buffer_size, GFP_KERNEL);
@@ -983,8 +975,8 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
         return 0;
 }
 
-static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
-                                          drm_r128_depth_t * depth)
+static int r128_cce_dispatch_write_pixels(struct drm_device *dev,
+                                          drm_r128_depth_t *depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         int count, *x, *y;
@@ -1001,9 +993,8 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
         xbuf_size = count * sizeof(*x);
         ybuf_size = count * sizeof(*y);
         x = kmalloc(xbuf_size, GFP_KERNEL);
-        if (x == NULL) {
+        if (x == NULL)
                 return -ENOMEM;
-        }
         y = kmalloc(ybuf_size, GFP_KERNEL);
         if (y == NULL) {
                 kfree(x);
@@ -1105,8 +1096,8 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
         return 0;
 }
 
-static int r128_cce_dispatch_read_span(struct drm_device * dev,
-                                       drm_r128_depth_t * depth)
+static int r128_cce_dispatch_read_span(struct drm_device *dev,
+                                       drm_r128_depth_t *depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         int count, x, y;
@@ -1117,12 +1108,10 @@ static int r128_cce_dispatch_read_span(struct drm_device * dev,
         if (count > 4096 || count <= 0)
                 return -EMSGSIZE;
 
-        if (DRM_COPY_FROM_USER(&x, depth->x, sizeof(x))) {
+        if (DRM_COPY_FROM_USER(&x, depth->x, sizeof(x)))
                 return -EFAULT;
-        }
-        if (DRM_COPY_FROM_USER(&y, depth->y, sizeof(y))) {
+        if (DRM_COPY_FROM_USER(&y, depth->y, sizeof(y)))
                 return -EFAULT;
-        }
 
         BEGIN_RING(7);
 
@@ -1148,8 +1137,8 @@ static int r128_cce_dispatch_read_span(struct drm_device * dev,
         return 0;
 }
 
-static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
-                                         drm_r128_depth_t * depth)
+static int r128_cce_dispatch_read_pixels(struct drm_device *dev,
+                                         drm_r128_depth_t *depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         int count, *x, *y;
@@ -1161,16 +1150,14 @@ static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
         if (count > 4096 || count <= 0)
                 return -EMSGSIZE;
 
-        if (count > dev_priv->depth_pitch) {
+        if (count > dev_priv->depth_pitch)
                 count = dev_priv->depth_pitch;
-        }
 
         xbuf_size = count * sizeof(*x);
         ybuf_size = count * sizeof(*y);
         x = kmalloc(xbuf_size, GFP_KERNEL);
-        if (x == NULL) {
+        if (x == NULL)
                 return -ENOMEM;
-        }
         y = kmalloc(ybuf_size, GFP_KERNEL);
         if (y == NULL) {
                 kfree(x);
@@ -1220,7 +1207,7 @@ static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
  * Polygon stipple
  */
 
-static void r128_cce_dispatch_stipple(struct drm_device * dev, u32 * stipple)
+static void r128_cce_dispatch_stipple(struct drm_device *dev, u32 *stipple)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         int i;
@@ -1230,9 +1217,8 @@ static void r128_cce_dispatch_stipple(struct drm_device * dev, u32 * stipple)
         BEGIN_RING(33);
 
         OUT_RING(CCE_PACKET0(R128_BRUSH_DATA0, 31));
-        for (i = 0; i < 32; i++) {
+        for (i = 0; i < 32; i++)
                 OUT_RING(stipple[i]);
-        }
 
         ADVANCE_RING();
 }
@@ -1269,7 +1255,7 @@ static int r128_cce_clear(struct drm_device *dev, void *data, struct drm_file *f
         return 0;
 }
 
-static int r128_do_init_pageflip(struct drm_device * dev)
+static int r128_do_init_pageflip(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
@@ -1288,7 +1274,7 @@ static int r128_do_init_pageflip(struct drm_device * dev)
         return 0;
 }
 
-static int r128_do_cleanup_pageflip(struct drm_device * dev)
+static int r128_do_cleanup_pageflip(struct drm_device *dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
@@ -1645,17 +1631,16 @@ static int r128_getparam(struct drm_device *dev, void *data, struct drm_file *fi
         return 0;
 }
 
-void r128_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
+void r128_driver_preclose(struct drm_device *dev, struct drm_file *file_priv)
 {
         if (dev->dev_private) {
                 drm_r128_private_t *dev_priv = dev->dev_private;
-                if (dev_priv->page_flipping) {
+                if (dev_priv->page_flipping)
                         r128_do_cleanup_pageflip(dev);
-                }
         }
 }
 
-void r128_driver_lastclose(struct drm_device * dev)
+void r128_driver_lastclose(struct drm_device *dev)
 {
         r128_do_cleanup_cce(dev);
 }
diff --git a/drivers/gpu/drm/radeon/Makefile b/drivers/gpu/drm/radeon/Makefile
index 84b1f2729d43..aebe00875041 100644
--- a/drivers/gpu/drm/radeon/Makefile
+++ b/drivers/gpu/drm/radeon/Makefile
@@ -69,5 +69,6 @@ radeon-y += radeon_device.o radeon_asic.o radeon_kms.o \
 
 radeon-$(CONFIG_COMPAT) += radeon_ioc32.o
 radeon-$(CONFIG_VGA_SWITCHEROO) += radeon_atpx_handler.o
+radeon-$(CONFIG_ACPI) += radeon_acpi.o
 
 obj-$(CONFIG_DRM_RADEON)+= radeon.o
diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
index 1d569830ed99..8e421f644a54 100644
--- a/drivers/gpu/drm/radeon/atom.c
+++ b/drivers/gpu/drm/radeon/atom.c
@@ -108,12 +108,11 @@ static uint32_t atom_iio_execute(struct atom_context *ctx, int base,
                         base++;
                         break;
                 case ATOM_IIO_READ:
-                        temp = ctx->card->reg_read(ctx->card, CU16(base + 1));
+                        temp = ctx->card->ioreg_read(ctx->card, CU16(base + 1));
                         base += 3;
                         break;
                 case ATOM_IIO_WRITE:
-                        (void)ctx->card->reg_read(ctx->card, CU16(base + 1));
-                        ctx->card->reg_write(ctx->card, CU16(base + 1), temp);
+                        ctx->card->ioreg_write(ctx->card, CU16(base + 1), temp);
                         base += 3;
                         break;
                 case ATOM_IIO_CLEAR:
@@ -715,8 +714,8 @@ static void atom_op_jump(atom_exec_context *ctx, int *ptr, int arg)
                         cjiffies = jiffies;
                         if (time_after(cjiffies, ctx->last_jump_jiffies)) {
                                 cjiffies -= ctx->last_jump_jiffies;
-                                if ((jiffies_to_msecs(cjiffies) > 1000)) {
-                                        DRM_ERROR("atombios stuck in loop for more than 1sec aborting\n");
+                                if ((jiffies_to_msecs(cjiffies) > 5000)) {
+                                        DRM_ERROR("atombios stuck in loop for more than 5secs aborting\n");
                                         ctx->abort = true;
                                 }
                         } else {
diff --git a/drivers/gpu/drm/radeon/atom.h b/drivers/gpu/drm/radeon/atom.h
index cd1b64ab5ca7..a589a55b223e 100644
--- a/drivers/gpu/drm/radeon/atom.h
+++ b/drivers/gpu/drm/radeon/atom.h
@@ -113,6 +113,8 @@ struct card_info {
         struct drm_device *dev;
         void (* reg_write)(struct card_info *, uint32_t, uint32_t);   /*  filled by driver */
         uint32_t (* reg_read)(struct card_info *, uint32_t);          /*  filled by driver */
+        void (* ioreg_write)(struct card_info *, uint32_t, uint32_t);   /*  filled by driver */
+        uint32_t (* ioreg_read)(struct card_info *, uint32_t);          /*  filled by driver */
         void (* mc_write)(struct card_info *, uint32_t, uint32_t);   /*  filled by driver */
         uint32_t (* mc_read)(struct card_info *, uint32_t);          /*  filled by driver */
         void (* pll_write)(struct card_info *, uint32_t, uint32_t);   /*  filled by driver */
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 8c2d6478a221..ec702345d70e 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -669,56 +669,25 @@ static void atombios_crtc_set_dcpll(struct drm_crtc *crtc)
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 }
 
-static void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
+static void atombios_crtc_program_pll(struct drm_crtc *crtc,
+                                      int crtc_id,
+                                      int pll_id,
+                                      u32 encoder_mode,
+                                      u32 encoder_id,
+                                      u32 clock,
+                                      u32 ref_div,
+                                      u32 fb_div,
+                                      u32 frac_fb_div,
+                                      u32 post_div)
 {
-        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
         struct drm_device *dev = crtc->dev;
         struct radeon_device *rdev = dev->dev_private;
-        struct drm_encoder *encoder = NULL;
-        struct radeon_encoder *radeon_encoder = NULL;
         u8 frev, crev;
-        int index;
+        int index = GetIndexIntoMasterTable(COMMAND, SetPixelClock);
         union set_pixel_clock args;
-        u32 pll_clock = mode->clock;
-        u32 ref_div = 0, fb_div = 0, frac_fb_div = 0, post_div = 0;
-        struct radeon_pll *pll;
-        u32 adjusted_clock;
-        int encoder_mode = 0;
 
         memset(&args, 0, sizeof(args));
 
-        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-                if (encoder->crtc == crtc) {
-                        radeon_encoder = to_radeon_encoder(encoder);
-                        encoder_mode = atombios_get_encoder_mode(encoder);
-                        break;
-                }
-        }
-
-        if (!radeon_encoder)
-                return;
-
-        switch (radeon_crtc->pll_id) {
-        case ATOM_PPLL1:
-                pll = &rdev->clock.p1pll;
-                break;
-        case ATOM_PPLL2:
-                pll = &rdev->clock.p2pll;
-                break;
-        case ATOM_DCPLL:
-        case ATOM_PPLL_INVALID:
-        default:
-                pll = &rdev->clock.dcpll;
-                break;
-        }
-
-        /* adjust pixel clock as needed */
-        adjusted_clock = atombios_adjust_pll(crtc, mode, pll);
-
-        radeon_compute_pll(pll, adjusted_clock, &pll_clock, &fb_div, &frac_fb_div,
-                           &ref_div, &post_div);
-
-        index = GetIndexIntoMasterTable(COMMAND, SetPixelClock);
         if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev,
                                    &crev))
                 return;
@@ -727,47 +696,49 @@ static void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode
         case 1:
                 switch (crev) {
                 case 1:
-                        args.v1.usPixelClock = cpu_to_le16(mode->clock / 10);
+                        if (clock == ATOM_DISABLE)
+                                return;
+                        args.v1.usPixelClock = cpu_to_le16(clock / 10);
                         args.v1.usRefDiv = cpu_to_le16(ref_div);
                         args.v1.usFbDiv = cpu_to_le16(fb_div);
                         args.v1.ucFracFbDiv = frac_fb_div;
                         args.v1.ucPostDiv = post_div;
-                        args.v1.ucPpll = radeon_crtc->pll_id;
-                        args.v1.ucCRTC = radeon_crtc->crtc_id;
+                        args.v1.ucPpll = pll_id;
+                        args.v1.ucCRTC = crtc_id;
                         args.v1.ucRefDivSrc = 1;
                         break;
                 case 2:
-                        args.v2.usPixelClock = cpu_to_le16(mode->clock / 10);
+                        args.v2.usPixelClock = cpu_to_le16(clock / 10);
                         args.v2.usRefDiv = cpu_to_le16(ref_div);
                         args.v2.usFbDiv = cpu_to_le16(fb_div);
                         args.v2.ucFracFbDiv = frac_fb_div;
                         args.v2.ucPostDiv = post_div;
-                        args.v2.ucPpll = radeon_crtc->pll_id;
-                        args.v2.ucCRTC = radeon_crtc->crtc_id;
+                        args.v2.ucPpll = pll_id;
+                        args.v2.ucCRTC = crtc_id;
                         args.v2.ucRefDivSrc = 1;
                         break;
                 case 3:
-                        args.v3.usPixelClock = cpu_to_le16(mode->clock / 10);
+                        args.v3.usPixelClock = cpu_to_le16(clock / 10);
                         args.v3.usRefDiv = cpu_to_le16(ref_div);
                         args.v3.usFbDiv = cpu_to_le16(fb_div);
                         args.v3.ucFracFbDiv = frac_fb_div;
                         args.v3.ucPostDiv = post_div;
-                        args.v3.ucPpll = radeon_crtc->pll_id;
-                        args.v3.ucMiscInfo = (radeon_crtc->pll_id << 2);
-                        args.v3.ucTransmitterId = radeon_encoder->encoder_id;
+                        args.v3.ucPpll = pll_id;
+                        args.v3.ucMiscInfo = (pll_id << 2);
+                        args.v3.ucTransmitterId = encoder_id;
                         args.v3.ucEncoderMode = encoder_mode;
                         break;
                 case 5:
-                        args.v5.ucCRTC = radeon_crtc->crtc_id;
-                        args.v5.usPixelClock = cpu_to_le16(mode->clock / 10);
+                        args.v5.ucCRTC = crtc_id;
+                        args.v5.usPixelClock = cpu_to_le16(clock / 10);
                         args.v5.ucRefDiv = ref_div;
                         args.v5.usFbDiv = cpu_to_le16(fb_div);
                         args.v5.ulFbDivDecFrac = cpu_to_le32(frac_fb_div * 100000);
                         args.v5.ucPostDiv = post_div;
                         args.v5.ucMiscInfo = 0; /* HDMI depth, etc. */
-                        args.v5.ucTransmitterID = radeon_encoder->encoder_id;
+                        args.v5.ucTransmitterID = encoder_id;
                         args.v5.ucEncoderMode = encoder_mode;
-                        args.v5.ucPpll = radeon_crtc->pll_id;
+                        args.v5.ucPpll = pll_id;
                         break;
                 default:
                         DRM_ERROR("Unknown table version %d %d\n", frev, crev);
@@ -782,6 +753,56 @@ static void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 }
 
+static void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
+{
+        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+        struct drm_device *dev = crtc->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct drm_encoder *encoder = NULL;
+        struct radeon_encoder *radeon_encoder = NULL;
+        u32 pll_clock = mode->clock;
+        u32 ref_div = 0, fb_div = 0, frac_fb_div = 0, post_div = 0;
+        struct radeon_pll *pll;
+        u32 adjusted_clock;
+        int encoder_mode = 0;
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+                if (encoder->crtc == crtc) {
+                        radeon_encoder = to_radeon_encoder(encoder);
+                        encoder_mode = atombios_get_encoder_mode(encoder);
+                        break;
+                }
+        }
+
+        if (!radeon_encoder)
+                return;
+
+        switch (radeon_crtc->pll_id) {
+        case ATOM_PPLL1:
+                pll = &rdev->clock.p1pll;
+                break;
+        case ATOM_PPLL2:
+                pll = &rdev->clock.p2pll;
+                break;
+        case ATOM_DCPLL:
+        case ATOM_PPLL_INVALID:
+        default:
+                pll = &rdev->clock.dcpll;
+                break;
+        }
+
+        /* adjust pixel clock as needed */
+        adjusted_clock = atombios_adjust_pll(crtc, mode, pll);
+
+        radeon_compute_pll(pll, adjusted_clock, &pll_clock, &fb_div, &frac_fb_div,
+                           &ref_div, &post_div);
+
+        atombios_crtc_program_pll(crtc, radeon_crtc->crtc_id, radeon_crtc->pll_id,
+                                  encoder_mode, radeon_encoder->encoder_id, mode->clock,
+                                  ref_div, fb_div, frac_fb_div, post_div);
+
+}
+
 static int evergreen_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                                    struct drm_framebuffer *old_fb)
 {
@@ -841,6 +862,11 @@ static int evergreen_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                 return -EINVAL;
         }
 
+        if (tiling_flags & RADEON_TILING_MACRO)
+                fb_format |= EVERGREEN_GRPH_ARRAY_MODE(EVERGREEN_GRPH_ARRAY_2D_TILED_THIN1);
+        else if (tiling_flags & RADEON_TILING_MICRO)
+                fb_format |= EVERGREEN_GRPH_ARRAY_MODE(EVERGREEN_GRPH_ARRAY_1D_TILED_THIN1);
+
         switch (radeon_crtc->crtc_id) {
         case 0:
                 WREG32(AVIVO_D1VGA_CONTROL, 0);
@@ -979,11 +1005,18 @@ static int avivo_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                 return -EINVAL;
         }
 
-        if (tiling_flags & RADEON_TILING_MACRO)
-                fb_format |= AVIVO_D1GRPH_MACRO_ADDRESS_MODE;
+        if (rdev->family >= CHIP_R600) {
+                if (tiling_flags & RADEON_TILING_MACRO)
+                        fb_format |= R600_D1GRPH_ARRAY_MODE_2D_TILED_THIN1;
+                else if (tiling_flags & RADEON_TILING_MICRO)
+                        fb_format |= R600_D1GRPH_ARRAY_MODE_1D_TILED_THIN1;
+        } else {
+                if (tiling_flags & RADEON_TILING_MACRO)
+                        fb_format |= AVIVO_D1GRPH_MACRO_ADDRESS_MODE;
 
-        if (tiling_flags & RADEON_TILING_MICRO)
-                fb_format |= AVIVO_D1GRPH_TILED;
+                if (tiling_flags & RADEON_TILING_MICRO)
+                        fb_format |= AVIVO_D1GRPH_TILED;
+        }
 
         if (radeon_crtc->crtc_id == 0)
                 WREG32(AVIVO_D1VGA_CONTROL, 0);
@@ -1191,6 +1224,24 @@ static void atombios_crtc_commit(struct drm_crtc *crtc)
         atombios_lock_crtc(crtc, ATOM_DISABLE);
 }
 
+static void atombios_crtc_disable(struct drm_crtc *crtc)
+{
+        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+        atombios_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
+
+        switch (radeon_crtc->pll_id) {
+        case ATOM_PPLL1:
+        case ATOM_PPLL2:
+                /* disable the ppll */
+                atombios_crtc_program_pll(crtc, radeon_crtc->crtc_id, radeon_crtc->pll_id,
+                                          0, 0, ATOM_DISABLE, 0, 0, 0, 0);
+                break;
+        default:
+                break;
+        }
+        radeon_crtc->pll_id = -1;
+}
+
 static const struct drm_crtc_helper_funcs atombios_helper_funcs = {
         .dpms = atombios_crtc_dpms,
         .mode_fixup = atombios_crtc_mode_fixup,
@@ -1199,6 +1250,7 @@ static const struct drm_crtc_helper_funcs atombios_helper_funcs = {
         .prepare = atombios_crtc_prepare,
         .commit = atombios_crtc_commit,
         .load_lut = radeon_crtc_load_lut,
+        .disable = atombios_crtc_disable,
 };
 
 void radeon_atombios_init_crtc(struct drm_device *dev,
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 057192acdd36..957d5067ad9c 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -39,6 +39,23 @@
 static void evergreen_gpu_init(struct radeon_device *rdev);
 void evergreen_fini(struct radeon_device *rdev);
 
+/* get temperature in millidegrees */
+u32 evergreen_get_temp(struct radeon_device *rdev)
+{
+        u32 temp = (RREG32(CG_MULT_THERMAL_STATUS) & ASIC_T_MASK) >>
+                ASIC_T_SHIFT;
+        u32 actual_temp = 0;
+
+        if ((temp >> 10) & 1)
+                actual_temp = 0;
+        else if ((temp >> 9) & 1)
+                actual_temp = 255;
+        else
+                actual_temp = (temp >> 1) & 0xff;
+
+        return actual_temp * 1000;
+}
+
 void evergreen_pm_misc(struct radeon_device *rdev)
 {
         int req_ps_idx = rdev->pm.requested_power_state_index;
@@ -1115,6 +1132,7 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
                                                                  rdev->config.evergreen.max_backends) &
                                                                 EVERGREEN_MAX_BACKENDS_MASK));
 
+        rdev->config.evergreen.tile_config = gb_addr_config;
         WREG32(GB_BACKEND_MAP, gb_backend_map);
         WREG32(GB_ADDR_CONFIG, gb_addr_config);
         WREG32(DMIF_ADDR_CONFIG, gb_addr_config);
diff --git a/drivers/gpu/drm/radeon/evergreen_cs.c b/drivers/gpu/drm/radeon/evergreen_cs.c
index 010963d4570f..345a75a03c96 100644
--- a/drivers/gpu/drm/radeon/evergreen_cs.c
+++ b/drivers/gpu/drm/radeon/evergreen_cs.c
@@ -333,7 +333,6 @@ static int evergreen_cs_packet_parse_vline(struct radeon_cs_parser *p)
         header = radeon_get_ib_value(p, h_idx);
         crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1);
         reg = CP_PACKET0_GET_REG(header);
-        mutex_lock(&p->rdev->ddev->mode_config.mutex);
         obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC);
         if (!obj) {
                 DRM_ERROR("cannot find crtc %d\n", crtc_id);
@@ -368,7 +367,6 @@ static int evergreen_cs_packet_parse_vline(struct radeon_cs_parser *p)
                 }
         }
 out:
-        mutex_unlock(&p->rdev->ddev->mode_config.mutex);
         return r;
 }
 
diff --git a/drivers/gpu/drm/radeon/evergreen_reg.h b/drivers/gpu/drm/radeon/evergreen_reg.h
index e028c1cd9d9b..2330f3a36fd5 100644
--- a/drivers/gpu/drm/radeon/evergreen_reg.h
+++ b/drivers/gpu/drm/radeon/evergreen_reg.h
@@ -61,6 +61,11 @@
 #       define EVERGREEN_GRPH_FORMAT_8B_BGRA1010102     5
 #       define EVERGREEN_GRPH_FORMAT_RGB111110          6
 #       define EVERGREEN_GRPH_FORMAT_BGR101111          7
+#       define EVERGREEN_GRPH_ARRAY_MODE(x)             (((x) & 0x7) << 20)
+#       define EVERGREEN_GRPH_ARRAY_LINEAR_GENERAL      0
+#       define EVERGREEN_GRPH_ARRAY_LINEAR_ALIGNED      1
+#       define EVERGREEN_GRPH_ARRAY_1D_TILED_THIN1      2
+#       define EVERGREEN_GRPH_ARRAY_2D_TILED_THIN1      4
 #define EVERGREEN_GRPH_SWAP_CONTROL                     0x680c
 #       define EVERGREEN_GRPH_ENDIAN_SWAP(x)            (((x) & 0x3) << 0)
 #       define EVERGREEN_GRPH_ENDIAN_NONE               0
diff --git a/drivers/gpu/drm/radeon/evergreend.h b/drivers/gpu/drm/radeon/evergreend.h
index a1cd621780e2..9b7532dd30f7 100644
--- a/drivers/gpu/drm/radeon/evergreend.h
+++ b/drivers/gpu/drm/radeon/evergreend.h
@@ -165,6 +165,11 @@
 #define         SE_DB_BUSY                                      (1 << 30)
 #define         SE_CB_BUSY                                      (1 << 31)
 
+#define CG_MULT_THERMAL_STATUS                          0x740
+#define         ASIC_T(x)                               ((x) << 16)
+#define         ASIC_T_MASK                             0x7FF0000
+#define         ASIC_T_SHIFT                            16
+
 #define HDP_HOST_PATH_CNTL                              0x2C00
 #define HDP_NONSURFACE_BASE                             0x2C04
 #define HDP_NONSURFACE_INFO                             0x2C08
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index ab37717a5d39..e115583f84fb 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -1230,7 +1230,6 @@ int r100_cs_packet_parse_vline(struct radeon_cs_parser *p)
         header = radeon_get_ib_value(p, h_idx);
         crtc_id = radeon_get_ib_value(p, h_idx + 5);
         reg = CP_PACKET0_GET_REG(header);
-        mutex_lock(&p->rdev->ddev->mode_config.mutex);
         obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC);
         if (!obj) {
                 DRM_ERROR("cannot find crtc %d\n", crtc_id);
@@ -1264,7 +1263,6 @@ int r100_cs_packet_parse_vline(struct radeon_cs_parser *p)
                 ib[h_idx + 3] |= RADEON_ENG_DISPLAY_SELECT_CRTC1;
         }
 out:
-        mutex_unlock(&p->rdev->ddev->mode_config.mutex);
         return r;
 }
 
@@ -2354,6 +2352,7 @@ void r100_mc_init(struct radeon_device *rdev)
         if (rdev->flags & RADEON_IS_IGP)
                 base = (RREG32(RADEON_NB_TOM) & 0xffff) << 16;
         radeon_vram_location(rdev, &rdev->mc, base);
+        rdev->mc.gtt_base_align = 0;
         if (!(rdev->flags & RADEON_IS_AGP))
                 radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
@@ -2365,11 +2364,10 @@ void r100_mc_init(struct radeon_device *rdev)
  */
 void r100_pll_errata_after_index(struct radeon_device *rdev)
 {
-        if (!(rdev->pll_errata & CHIP_ERRATA_PLL_DUMMYREADS)) {
-                return;
+        if (rdev->pll_errata & CHIP_ERRATA_PLL_DUMMYREADS) {
+                (void)RREG32(RADEON_CLOCK_CNTL_DATA);
+                (void)RREG32(RADEON_CRTC_GEN_CNTL);
         }
-        (void)RREG32(RADEON_CLOCK_CNTL_DATA);
-        (void)RREG32(RADEON_CRTC_GEN_CNTL);
 }
 
 static void r100_pll_errata_after_data(struct radeon_device *rdev)
@@ -3810,6 +3808,31 @@ void r100_fini(struct radeon_device *rdev)
         rdev->bios = NULL;
 }
 
+/*
+ * Due to how kexec works, it can leave the hw fully initialised when it
+ * boots the new kernel. However doing our init sequence with the CP and
+ * WB stuff setup causes GPU hangs on the RN50 at least. So at startup
+ * do some quick sanity checks and restore sane values to avoid this
+ * problem.
+ */
+void r100_restore_sanity(struct radeon_device *rdev)
+{
+        u32 tmp;
+
+        tmp = RREG32(RADEON_CP_CSQ_CNTL);
+        if (tmp) {
+                WREG32(RADEON_CP_CSQ_CNTL, 0);
+        }
+        tmp = RREG32(RADEON_CP_RB_CNTL);
+        if (tmp) {
+                WREG32(RADEON_CP_RB_CNTL, 0);
+        }
+        tmp = RREG32(RADEON_SCRATCH_UMSK);
+        if (tmp) {
+                WREG32(RADEON_SCRATCH_UMSK, 0);
+        }
+}
+
 int r100_init(struct radeon_device *rdev)
 {
         int r;
@@ -3822,6 +3845,8 @@ int r100_init(struct radeon_device *rdev)
         radeon_scratch_init(rdev);
         /* Initialize surface registers */
         radeon_surface_init(rdev);
+        /* sanity check some register to avoid hangs like after kexec */
+        r100_restore_sanity(rdev);
         /* TODO: disable VGA need to use VGA request */
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
diff --git a/drivers/gpu/drm/radeon/r300.c b/drivers/gpu/drm/radeon/r300.c
index 7e81db5eb804..58eab5d47305 100644
--- a/drivers/gpu/drm/radeon/r300.c
+++ b/drivers/gpu/drm/radeon/r300.c
@@ -481,6 +481,7 @@ void r300_mc_init(struct radeon_device *rdev)
         if (rdev->flags & RADEON_IS_IGP)
                 base = (RREG32(RADEON_NB_TOM) & 0xffff) << 16;
         radeon_vram_location(rdev, &rdev->mc, base);
+        rdev->mc.gtt_base_align = 0;
         if (!(rdev->flags & RADEON_IS_AGP))
                 radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
@@ -1176,6 +1177,8 @@ int r300_cs_parse(struct radeon_cs_parser *p)
         int r;
 
         track = kzalloc(sizeof(*track), GFP_KERNEL);
+        if (track == NULL)
+                return -ENOMEM;
         r100_cs_track_clear(p->rdev, track);
         p->track = track;
         do {
@@ -1377,6 +1380,8 @@ int r300_init(struct radeon_device *rdev)
         /* Initialize surface registers */
         radeon_surface_init(rdev);
         /* TODO: disable VGA need to use VGA request */
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
                 if (ASIC_IS_AVIVO(rdev))
diff --git a/drivers/gpu/drm/radeon/r420.c b/drivers/gpu/drm/radeon/r420.c
index e6c89142bb4d..59f7bccc5be0 100644
--- a/drivers/gpu/drm/radeon/r420.c
+++ b/drivers/gpu/drm/radeon/r420.c
@@ -343,6 +343,8 @@ int r420_init(struct radeon_device *rdev)
         /* Initialize surface registers */
         radeon_surface_init(rdev);
         /* TODO: disable VGA need to use VGA request */
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
                 if (ASIC_IS_AVIVO(rdev))
diff --git a/drivers/gpu/drm/radeon/r500_reg.h b/drivers/gpu/drm/radeon/r500_reg.h
index 93c9a2bbccf8..6ac1f604e29b 100644
--- a/drivers/gpu/drm/radeon/r500_reg.h
+++ b/drivers/gpu/drm/radeon/r500_reg.h
@@ -386,6 +386,11 @@
 #       define AVIVO_D1GRPH_TILED                               (1 << 20)
 #       define AVIVO_D1GRPH_MACRO_ADDRESS_MODE                  (1 << 21)
 
+#       define R600_D1GRPH_ARRAY_MODE_LINEAR_GENERAL            (0 << 20)
+#       define R600_D1GRPH_ARRAY_MODE_LINEAR_ALIGNED            (1 << 20)
+#       define R600_D1GRPH_ARRAY_MODE_1D_TILED_THIN1            (2 << 20)
+#       define R600_D1GRPH_ARRAY_MODE_2D_TILED_THIN1            (4 << 20)
+
 /* The R7xx *_HIGH surface regs are backwards; the D1 regs are in the D2
  * block and vice versa.  This applies to GRPH, CUR, etc.
  */
diff --git a/drivers/gpu/drm/radeon/r520.c b/drivers/gpu/drm/radeon/r520.c
index 34330df28483..1458dee902dd 100644
--- a/drivers/gpu/drm/radeon/r520.c
+++ b/drivers/gpu/drm/radeon/r520.c
@@ -125,6 +125,7 @@ void r520_mc_init(struct radeon_device *rdev)
         r520_vram_get_type(rdev);
         r100_vram_init_sizes(rdev);
         radeon_vram_location(rdev, &rdev->mc, 0);
+        rdev->mc.gtt_base_align = 0;
         if (!(rdev->flags & RADEON_IS_AGP))
                 radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
@@ -230,6 +231,8 @@ int r520_init(struct radeon_device *rdev)
         radeon_scratch_init(rdev);
         /* Initialize surface registers */
         radeon_surface_init(rdev);
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* TODO: disable VGA need to use VGA request */
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c
index a73a6e17588d..28e39bc6768b 100644
--- a/drivers/gpu/drm/radeon/r600.c
+++ b/drivers/gpu/drm/radeon/r600.c
@@ -92,6 +92,21 @@ void r600_gpu_init(struct radeon_device *rdev);
 void r600_fini(struct radeon_device *rdev);
 void r600_irq_disable(struct radeon_device *rdev);
 
+/* get temperature in millidegrees */
+u32 rv6xx_get_temp(struct radeon_device *rdev)
+{
+        u32 temp = (RREG32(CG_THERMAL_STATUS) & ASIC_T_MASK) >>
+                ASIC_T_SHIFT;
+        u32 actual_temp = 0;
+
+        if ((temp >> 7) & 1)
+                actual_temp = 0;
+        else
+                actual_temp = (temp >> 1) & 0xff;
+
+        return actual_temp * 1000;
+}
+
 void r600_pm_get_dynpm_state(struct radeon_device *rdev)
 {
         int i;
@@ -869,7 +884,17 @@ void r600_pcie_gart_tlb_flush(struct radeon_device *rdev)
         u32 tmp;
 
         /* flush hdp cache so updates hit vram */
-        WREG32(R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
+        if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740)) {
+                void __iomem *ptr = (void *)rdev->gart.table.vram.ptr;
+                u32 tmp;
+
+                /* r7xx hw bug.  write to HDP_DEBUG1 followed by fb read
+                 * rather than write to HDP_REG_COHERENCY_FLUSH_CNTL
+                 */
+                WREG32(HDP_DEBUG1, 0);
+                tmp = readl((void __iomem *)ptr);
+        } else
+                WREG32(R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
 
         WREG32(VM_CONTEXT0_INVALIDATION_LOW_ADDR, rdev->mc.gtt_start >> 12);
         WREG32(VM_CONTEXT0_INVALIDATION_HIGH_ADDR, (rdev->mc.gtt_end - 1) >> 12);
@@ -1179,6 +1204,7 @@ void r600_vram_gtt_location(struct radeon_device *rdev, struct radeon_mc *mc)
                 if (rdev->flags & RADEON_IS_IGP)
                         base = (RREG32(MC_VM_FB_LOCATION) & 0xFFFF) << 24;
                 radeon_vram_location(rdev, &rdev->mc, base);
+                rdev->mc.gtt_base_align = 0;
                 radeon_gtt_location(rdev, mc);
         }
 }
@@ -1608,7 +1634,7 @@ void r600_gpu_init(struct radeon_device *rdev)
                                                          r600_count_pipe_bits((cc_rb_backend_disable &
                                                                                R6XX_MAX_BACKENDS_MASK) >> 16)),
                                                         (cc_rb_backend_disable >> 16));
-
+        rdev->config.r600.tile_config = tiling_config;
         tiling_config |= BACKEND_MAP(backend_map);
         WREG32(GB_TILING_CONFIG, tiling_config);
         WREG32(DCP_TILING_CONFIG, tiling_config & 0xffff);
@@ -3511,5 +3537,15 @@ int r600_debugfs_mc_info_init(struct radeon_device *rdev)
  */
 void r600_ioctl_wait_idle(struct radeon_device *rdev, struct radeon_bo *bo)
 {
-        WREG32(R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
+        /* r7xx hw bug.  write to HDP_DEBUG1 followed by fb read
+         * rather than write to HDP_REG_COHERENCY_FLUSH_CNTL
+         */
+        if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740)) {
+                void __iomem *ptr = (void *)rdev->gart.table.vram.ptr;
+                u32 tmp;
+
+                WREG32(HDP_DEBUG1, 0);
+                tmp = readl((void __iomem *)ptr);
+        } else
+                WREG32(R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
 }
diff --git a/drivers/gpu/drm/radeon/r600_audio.c b/drivers/gpu/drm/radeon/r600_audio.c
index 2b26553c352c..b5443fe1c1d1 100644
--- a/drivers/gpu/drm/radeon/r600_audio.c
+++ b/drivers/gpu/drm/radeon/r600_audio.c
@@ -63,7 +63,8 @@ int r600_audio_bits_per_sample(struct radeon_device *rdev)
         case 0x4: return 32;
         }
 
-        DRM_ERROR("Unknown bits per sample 0x%x using 16 instead.\n", (int)value);
+        dev_err(rdev->dev, "Unknown bits per sample 0x%x using 16 instead\n",
+                (int)value);
 
         return 16;
 }
@@ -150,7 +151,8 @@ static void r600_audio_update_hdmi(unsigned long param)
                         r600_hdmi_update_audio_settings(encoder);
         }
 
-        if(still_going) r600_audio_schedule_polling(rdev);
+        if (still_going)
+                r600_audio_schedule_polling(rdev);
 }
 
 /*
@@ -158,8 +160,9 @@ static void r600_audio_update_hdmi(unsigned long param)
  */
 static void r600_audio_engine_enable(struct radeon_device *rdev, bool enable)
 {
-        DRM_INFO("%s audio support", enable ? "Enabling" : "Disabling");
+        DRM_INFO("%s audio support\n", enable ? "Enabling" : "Disabling");
         WREG32_P(R600_AUDIO_ENABLE, enable ? 0x81000000 : 0x0, ~0x81000000);
+        rdev->audio_enabled = enable;
 }
 
 /*
@@ -195,12 +198,14 @@ void r600_audio_enable_polling(struct drm_encoder *encoder)
         struct radeon_device *rdev = dev->dev_private;
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
 
-        DRM_DEBUG("r600_audio_enable_polling: %d", radeon_encoder->audio_polling_active);
+        DRM_DEBUG("r600_audio_enable_polling: %d\n",
+                radeon_encoder->audio_polling_active);
         if (radeon_encoder->audio_polling_active)
                 return;
 
         radeon_encoder->audio_polling_active = 1;
-        mod_timer(&rdev->audio_timer, jiffies + 1);
+        if (rdev->audio_enabled)
+                mod_timer(&rdev->audio_timer, jiffies + 1);
 }
 
 /*
@@ -209,7 +214,8 @@ void r600_audio_enable_polling(struct drm_encoder *encoder)
 void r600_audio_disable_polling(struct drm_encoder *encoder)
 {
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
-        DRM_DEBUG("r600_audio_disable_polling: %d", radeon_encoder->audio_polling_active);
+        DRM_DEBUG("r600_audio_disable_polling: %d\n",
+                radeon_encoder->audio_polling_active);
         radeon_encoder->audio_polling_active = 0;
 }
 
@@ -236,7 +242,7 @@ void r600_audio_set_clock(struct drm_encoder *encoder, int clock)
                 WREG32_P(R600_AUDIO_TIMING, 0x100, ~0x301);
                 break;
         default:
-                DRM_ERROR("Unsupported encoder type 0x%02X\n",
+                dev_err(rdev->dev, "Unsupported encoder type 0x%02X\n",
                           radeon_encoder->encoder_id);
                 return;
         }
@@ -266,7 +272,7 @@ void r600_audio_set_clock(struct drm_encoder *encoder, int clock)
  */
 void r600_audio_fini(struct radeon_device *rdev)
 {
-        if (!radeon_audio || !r600_audio_chipset_supported(rdev))
+        if (!rdev->audio_enabled)
                 return;
 
         del_timer(&rdev->audio_timer);
diff --git a/drivers/gpu/drm/radeon/r600_blit.c b/drivers/gpu/drm/radeon/r600_blit.c
index f4fb88ece2bb..ca5c29f70779 100644
--- a/drivers/gpu/drm/radeon/r600_blit.c
+++ b/drivers/gpu/drm/radeon/r600_blit.c
@@ -538,9 +538,12 @@ int
 r600_prepare_blit_copy(struct drm_device *dev, struct drm_file *file_priv)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
+        int ret;
         DRM_DEBUG("\n");
 
-        r600_nomm_get_vb(dev);
+        ret = r600_nomm_get_vb(dev);
+        if (ret)
+                return ret;
 
         dev_priv->blit_vb->file_priv = file_priv;
 
diff --git a/drivers/gpu/drm/radeon/r600_blit_shaders.c b/drivers/gpu/drm/radeon/r600_blit_shaders.c
index 0271b53fa2dd..e8151c1d55b2 100644
--- a/drivers/gpu/drm/radeon/r600_blit_shaders.c
+++ b/drivers/gpu/drm/radeon/r600_blit_shaders.c
@@ -39,37 +39,45 @@
 
 const u32 r6xx_default_state[] =
 {
-        0xc0002400,
+        0xc0002400, /* START_3D_CMDBUF */
         0x00000000,
-        0xc0012800,
+
+        0xc0012800, /* CONTEXT_CONTROL */
         0x80000000,
         0x80000000,
+
         0xc0016800,
         0x00000010,
-        0x00008000,
+        0x00008000, /* WAIT_UNTIL */
+
         0xc0016800,
         0x00000542,
-        0x07000003,
+        0x07000003, /* TA_CNTL_AUX */
+
         0xc0016800,
         0x000005c5,
-        0x00000000,
+        0x00000000, /* VC_ENHANCE */
+
         0xc0016800,
         0x00000363,
-        0x00000000,
+        0x00000000, /* SQ_DYN_GPR_CNTL_PS_FLUSH_REQ */
+
         0xc0016800,
         0x0000060c,
-        0x82000000,
+        0x82000000, /* DB_DEBUG */
+
         0xc0016800,
         0x0000060e,
-        0x01020204,
-        0xc0016f00,
-        0x00000000,
-        0x00000000,
-        0xc0016f00,
-        0x00000001,
+        0x01020204, /* DB_WATERMARKS */
+
+        0xc0026f00,
         0x00000000,
+        0x00000000, /* SQ_VTX_BASE_VTX_LOC */
+        0x00000000, /* SQ_VTX_START_INST_LOC */
+
         0xc0096900,
         0x0000022a,
+        0x00000000, /* SQ_ESGS_RING_ITEMSIZE */
         0x00000000,
         0x00000000,
         0x00000000,
@@ -78,515 +86,317 @@ const u32 r6xx_default_state[] =
         0x00000000,
         0x00000000,
         0x00000000,
-        0x00000000,
+
         0xc0016900,
         0x00000004,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* DB_DEPTH_INFO */
+
+        0xc0026900,
         0x0000000a,
-        0x00000000,
-        0xc0016900,
-        0x0000000b,
-        0x00000000,
-        0xc0016900,
-        0x0000010c,
-        0x00000000,
-        0xc0016900,
-        0x0000010d,
-        0x00000000,
+        0x00000000, /* DB_STENCIL_CLEAR */
+        0x00000000, /* DB_DEPTH_CLEAR */
+
         0xc0016900,
         0x00000200,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* DB_DEPTH_CONTROL */
+
+        0xc0026900,
         0x00000343,
-        0x00000060,
-        0xc0016900,
-        0x00000344,
-        0x00000040,
+        0x00000060, /* DB_RENDER_CONTROL */
+        0x00000040, /* DB_RENDER_OVERRIDE */
+
         0xc0016900,
         0x00000351,
-        0x0000aa00,
-        0xc0016900,
-        0x00000104,
-        0x00000000,
-        0xc0016900,
-        0x0000010e,
-        0x00000000,
-        0xc0046900,
-        0x00000105,
-        0x00000000,
-        0x00000000,
+        0x0000aa00, /* DB_ALPHA_TO_MASK */
+
+        0xc00f6900,
+        0x00000100,
+        0x00000800, /* VGT_MAX_VTX_INDX */
+        0x00000000, /* VGT_MIN_VTX_INDX */
+        0x00000000, /* VGT_INDX_OFFSET */
+        0x00000000, /* VGT_MULTI_PRIM_IB_RESET_INDX */
+        0x00000000, /* SX_ALPHA_TEST_CONTROL */
+        0x00000000, /* CB_BLEND_RED */
         0x00000000,
         0x00000000,
-        0xc0036900,
-        0x00000109,
         0x00000000,
+        0x00000000, /* CB_FOG_RED */
         0x00000000,
         0x00000000,
+        0x00000000, /* DB_STENCILREFMASK */
+        0x00000000, /* DB_STENCILREFMASK_BF */
+        0x00000000, /* SX_ALPHA_REF */
+
         0xc0046900,
         0x0000030c,
-        0x01000000,
+        0x01000000, /* CB_CLRCMP_CNTL */
         0x00000000,
         0x00000000,
         0x00000000,
+
         0xc0046900,
         0x00000048,
-        0x3f800000,
+        0x3f800000, /* CB_CLEAR_RED */
         0x00000000,
         0x3f800000,
         0x3f800000,
-        0xc0016900,
-        0x0000008e,
-        0x0000000f,
+
         0xc0016900,
         0x00000080,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* PA_SC_WINDOW_OFFSET */
+
+        0xc00a6900,
         0x00000083,
-        0x0000ffff,
-        0xc0016900,
-        0x00000084,
-        0x00000000,
-        0xc0016900,
-        0x00000085,
+        0x0000ffff, /* PA_SC_CLIP_RECT_RULE */
+        0x00000000, /* PA_SC_CLIPRECT_0_TL */
         0x20002000,
-        0xc0016900,
-        0x00000086,
         0x00000000,
-        0xc0016900,
-        0x00000087,
         0x20002000,
-        0xc0016900,
-        0x00000088,
         0x00000000,
-        0xc0016900,
-        0x00000089,
         0x20002000,
-        0xc0016900,
-        0x0000008a,
         0x00000000,
-        0xc0016900,
-        0x0000008b,
         0x20002000,
-        0xc0016900,
-        0x0000008c,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* PA_SC_EDGERULE */
+
+        0xc0406900,
         0x00000094,
-        0x80000000,
-        0xc0016900,
-        0x00000095,
+        0x80000000, /* PA_SC_VPORT_SCISSOR_0_TL */
+        0x20002000, /* PA_SC_VPORT_SCISSOR_0_BR */
+        0x80000000, /* PA_SC_VPORT_SCISSOR_1_TL */
         0x20002000,
-        0xc0026900,
-        0x000000b4,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x00000096,
         0x80000000,
-        0xc0016900,
-        0x00000097,
         0x20002000,
-        0xc0026900,
-        0x000000b6,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x00000098,
         0x80000000,
-        0xc0016900,
-        0x00000099,
         0x20002000,
-        0xc0026900,
-        0x000000b8,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x0000009a,
         0x80000000,
-        0xc0016900,
-        0x0000009b,
         0x20002000,
-        0xc0026900,
-        0x000000ba,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x0000009c,
         0x80000000,
-        0xc0016900,
-        0x0000009d,
         0x20002000,
-        0xc0026900,
-        0x000000bc,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x0000009e,
         0x80000000,
-        0xc0016900,
-        0x0000009f,
         0x20002000,
-        0xc0026900,
-        0x000000be,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a0,
         0x80000000,
-        0xc0016900,
-        0x000000a1,
         0x20002000,
-        0xc0026900,
-        0x000000c0,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a2,
         0x80000000,
-        0xc0016900,
-        0x000000a3,
         0x20002000,
-        0xc0026900,
-        0x000000c2,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a4,
         0x80000000,
-        0xc0016900,
-        0x000000a5,
         0x20002000,
-        0xc0026900,
-        0x000000c4,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a6,
         0x80000000,
-        0xc0016900,
-        0x000000a7,
         0x20002000,
-        0xc0026900,
-        0x000000c6,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a8,
         0x80000000,
-        0xc0016900,
-        0x000000a9,
         0x20002000,
-        0xc0026900,
-        0x000000c8,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000aa,
         0x80000000,
-        0xc0016900,
-        0x000000ab,
         0x20002000,
-        0xc0026900,
-        0x000000ca,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000ac,
         0x80000000,
-        0xc0016900,
-        0x000000ad,
         0x20002000,
-        0xc0026900,
-        0x000000cc,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000ae,
         0x80000000,
-        0xc0016900,
-        0x000000af,
         0x20002000,
-        0xc0026900,
-        0x000000ce,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000b0,
         0x80000000,
-        0xc0016900,
-        0x000000b1,
         0x20002000,
-        0xc0026900,
-        0x000000d0,
-        0x00000000,
+        0x00000000, /* PA_SC_VPORT_ZMIN_0 */
         0x3f800000,
-        0xc0016900,
-        0x000000b2,
-        0x80000000,
-        0xc0016900,
-        0x000000b3,
-        0x20002000,
-        0xc0026900,
-        0x000000d2,
         0x00000000,
         0x3f800000,
-        0xc0016900,
-        0x00000293,
-        0x00004010,
-        0xc0016900,
-        0x00000300,
         0x00000000,
-        0xc0016900,
-        0x00000301,
-        0x00000000,
-        0xc0016900,
-        0x00000312,
-        0xffffffff,
-        0xc0016900,
-        0x00000307,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000308,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000283,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000292,
+        0x3f800000,
         0x00000000,
-        0xc0066900,
-        0x0000010f,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000206,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000207,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000208,
+        0x3f800000,
         0x00000000,
-        0xc0046900,
-        0x00000303,
         0x3f800000,
+
+        0xc0026900,
+        0x00000292,
+        0x00000000, /* PA_SC_MPASS_PS_CNTL */
+        0x00004010, /* PA_SC_MODE_CNTL */
+
+        0xc0096900,
+        0x00000300,
+        0x00000000, /* PA_SC_LINE_CNTL */
+        0x00000000, /* PA_SC_AA_CONFIG */
+        0x0000002d, /* PA_SU_VTX_CNTL */
+        0x3f800000, /* PA_CL_GB_VERT_CLIP_ADJ */
         0x3f800000,
         0x3f800000,
         0x3f800000,
-        0xc0016900,
-        0x00000205,
-        0x00000004,
-        0xc0016900,
-        0x00000280,
-        0x00000000,
-        0xc0016900,
-        0x00000281,
+        0x00000000, /* PA_SC_SAMPLE_LOCS_MCTX */
         0x00000000,
+
         0xc0016900,
+        0x00000312,
+        0xffffffff, /* PA_SC_AA_MASK */
+
+        0xc0066900,
         0x0000037e,
-        0x00000000,
-        0xc0016900,
-        0x00000382,
-        0x00000000,
-        0xc0016900,
-        0x00000380,
-        0x00000000,
-        0xc0016900,
-        0x00000383,
-        0x00000000,
-        0xc0016900,
-        0x00000381,
-        0x00000000,
-        0xc0016900,
-        0x00000282,
-        0x00000008,
-        0xc0016900,
-        0x00000302,
-        0x0000002d,
-        0xc0016900,
-        0x0000037f,
-        0x00000000,
-        0xc0016900,
-        0x000001b2,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* PA_SU_POLY_OFFSET_DB_FMT_CNTL */
+        0x00000000, /* PA_SU_POLY_OFFSET_CLAMP */
+        0x00000000, /* PA_SU_POLY_OFFSET_FRONT_SCALE */
+        0x00000000, /* PA_SU_POLY_OFFSET_FRONT_OFFSET */
+        0x00000000, /* PA_SU_POLY_OFFSET_BACK_SCALE */
+        0x00000000, /* PA_SU_POLY_OFFSET_BACK_OFFSET */
+
+        0xc0046900,
         0x000001b6,
-        0x00000000,
-        0xc0016900,
-        0x000001b7,
-        0x00000000,
-        0xc0016900,
-        0x000001b8,
-        0x00000000,
-        0xc0016900,
-        0x000001b9,
-        0x00000000,
+        0x00000000, /* SPI_INPUT_Z */
+        0x00000000, /* SPI_FOG_CNTL */
+        0x00000000, /* SPI_FOG_FUNC_SCALE */
+        0x00000000, /* SPI_FOG_FUNC_BIAS */
+
         0xc0016900,
         0x00000225,
-        0x00000000,
+        0x00000000, /* SQ_PGM_START_FS */
+
         0xc0016900,
         0x00000229,
-        0x00000000,
+        0x00000000, /* SQ_PGM_RESOURCES_FS */
+
         0xc0016900,
         0x00000237,
-        0x00000000,
-        0xc0016900,
-        0x00000100,
-        0x00000800,
-        0xc0016900,
-        0x00000101,
-        0x00000000,
-        0xc0016900,
-        0x00000102,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* SQ_PGM_CF_OFFSET_FS */
+
+        0xc0026900,
         0x000002a8,
-        0x00000000,
-        0xc0016900,
-        0x000002a9,
-        0x00000000,
-        0xc0016900,
-        0x00000103,
-        0x00000000,
-        0xc0016900,
-        0x00000284,
-        0x00000000,
-        0xc0016900,
-        0x00000290,
-        0x00000000,
-        0xc0016900,
-        0x00000285,
-        0x00000000,
-        0xc0016900,
-        0x00000286,
-        0x00000000,
-        0xc0016900,
-        0x00000287,
-        0x00000000,
-        0xc0016900,
-        0x00000288,
-        0x00000000,
-        0xc0016900,
-        0x00000289,
-        0x00000000,
-        0xc0016900,
-        0x0000028a,
-        0x00000000,
-        0xc0016900,
-        0x0000028b,
-        0x00000000,
-        0xc0016900,
-        0x0000028c,
-        0x00000000,
-        0xc0016900,
-        0x0000028d,
-        0x00000000,
-        0xc0016900,
-        0x0000028e,
-        0x00000000,
-        0xc0016900,
-        0x0000028f,
-        0x00000000,
+        0x00000000, /* VGT_INSTANCE_STEP_RATE_0 */
+        0x00000000, /* VGT_INSTANCE_STEP_RATE_1 */
+
+        0xc0116900,
+        0x00000280,
+        0x00000000, /* PA_SU_POINT_SIZE */
+        0x00000000, /* PA_SU_POINT_MINMAX */
+        0x00000008, /* PA_SU_LINE_CNTL */
+        0x00000000, /* PA_SC_LINE_STIPPLE */
+        0x00000000, /* VGT_OUTPUT_PATH_CNTL */
+        0x00000000, /* VGT_HOS_CNTL */
+        0x00000000, /* VGT_HOS_MAX_TESS_LEVEL */
+        0x00000000, /* VGT_HOS_MIN_TESS_LEVEL */
+        0x00000000, /* VGT_HOS_REUSE_DEPTH */
+        0x00000000, /* VGT_GROUP_PRIM_TYPE */
+        0x00000000, /* VGT_GROUP_FIRST_DECR */
+        0x00000000, /* VGT_GROUP_DECR */
+        0x00000000, /* VGT_GROUP_VECT_0_CNTL */
+        0x00000000, /* VGT_GROUP_VECT_1_CNTL */
+        0x00000000, /* VGT_GROUP_VECT_0_FMT_CNTL */
+        0x00000000, /* VGT_GROUP_VECT_1_FMT_CNTL */
+        0x00000000, /* VGT_GS_MODE */
+
         0xc0016900,
         0x000002a1,
-        0x00000000,
+        0x00000000, /* VGT_PRIMITIVEID_EN */
+
         0xc0016900,
         0x000002a5,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* VGT_MULTI_PRIM_ID_RESET_EN */
+
+        0xc0036900,
         0x000002ac,
-        0x00000000,
-        0xc0016900,
-        0x000002ad,
-        0x00000000,
-        0xc0016900,
-        0x000002ae,
-        0x00000000,
+        0x00000000, /* VGT_STRMOUT_EN */
+        0x00000000, /* VGT_REUSE_OFF */
+        0x00000000, /* VGT_VTX_CNT_EN */
+
         0xc0016900,
         0x000002c8,
-        0x00000000,
-        0xc0016900,
-        0x00000206,
-        0x00000100,
-        0xc0016900,
-        0x00000204,
-        0x00010000,
-        0xc0036e00,
-        0x00000000,
-        0x00000012,
-        0x00000000,
-        0x00000000,
-        0xc0016900,
-        0x0000008f,
-        0x0000000f,
-        0xc0016900,
-        0x000001e8,
-        0x00000001,
-        0xc0016900,
+        0x00000000, /* VGT_STRMOUT_BUFFER_EN */
+
+        0xc0076900,
         0x00000202,
-        0x00cc0000,
+        0x00cc0000, /* CB_COLOR_CONTROL */
+        0x00000210, /* DB_SHADER_CNTL */
+        0x00010000, /* PA_CL_CLIP_CNTL */
+        0x00000244, /* PA_SU_SC_MODE_CNTL */
+        0x00000100, /* PA_CL_VTE_CNTL */
+        0x00000000, /* PA_CL_VS_OUT_CNTL */
+        0x00000000, /* PA_CL_NANINF_CNTL */
+
+        0xc0026900,
+        0x0000008e,
+        0x0000000f, /* CB_TARGET_MASK */
+        0x0000000f, /* CB_SHADER_MASK */
+
         0xc0016900,
-        0x00000205,
-        0x00000244,
+        0x000001e8,
+        0x00000001, /* CB_SHADER_CONTROL */
+
         0xc0016900,
-        0x00000203,
-        0x00000210,
+        0x00000185,
+        0x00000000, /* SPI_VS_OUT_ID_0 */
+
         0xc0016900,
+        0x00000191,
+        0x00000b00, /* SPI_PS_INPUT_CNTL_0 */
+
+        0xc0056900,
         0x000001b1,
+        0x00000000, /* SPI_VS_OUT_CONFIG */
+        0x00000000, /* SPI_THREAD_GROUPING */
+        0x00000001, /* SPI_PS_IN_CONTROL_0 */
+        0x00000000, /* SPI_PS_IN_CONTROL_1 */
+        0x00000000, /* SPI_INTERP_CONTROL_0 */
+
+        0xc0036e00, /* SET_SAMPLER */
         0x00000000,
-        0xc0016900,
-        0x00000185,
-        0x00000000,
-        0xc0016900,
-        0x000001b3,
-        0x00000001,
-        0xc0016900,
-        0x000001b4,
+        0x00000012,
         0x00000000,
-        0xc0016900,
-        0x00000191,
-        0x00000b00,
-        0xc0016900,
-        0x000001b5,
         0x00000000,
 };
 
 const u32 r7xx_default_state[] =
 {
-        0xc0012800,
+        0xc0012800, /* CONTEXT_CONTROL */
         0x80000000,
         0x80000000,
+
         0xc0016800,
         0x00000010,
-        0x00008000,
+        0x00008000, /* WAIT_UNTIL */
+
         0xc0016800,
         0x00000542,
-        0x07000002,
+        0x07000002, /* TA_CNTL_AUX */
+
         0xc0016800,
         0x000005c5,
-        0x00000000,
+        0x00000000, /* VC_ENHANCE */
+
         0xc0016800,
         0x00000363,
-        0x00004000,
+        0x00004000, /* SQ_DYN_GPR_CNTL_PS_FLUSH_REQ */
+
         0xc0016800,
         0x0000060c,
-        0x00000000,
+        0x00000000, /* DB_DEBUG */
+
         0xc0016800,
         0x0000060e,
-        0x00420204,
-        0xc0016f00,
-        0x00000000,
-        0x00000000,
-        0xc0016f00,
-        0x00000001,
+        0x00420204, /* DB_WATERMARKS */
+
+        0xc0026f00,
         0x00000000,
+        0x00000000, /* SQ_VTX_BASE_VTX_LOC */
+        0x00000000, /* SQ_VTX_START_INST_LOC */
+
         0xc0096900,
         0x0000022a,
+        0x00000000, /* SQ_ESGS_RING_ITEMSIZE */
         0x00000000,
         0x00000000,
         0x00000000,
@@ -595,470 +405,269 @@ const u32 r7xx_default_state[] =
         0x00000000,
         0x00000000,
         0x00000000,
-        0x00000000,
+
         0xc0016900,
         0x00000004,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* DB_DEPTH_INFO */
+
+        0xc0026900,
         0x0000000a,
-        0x00000000,
-        0xc0016900,
-        0x0000000b,
-        0x00000000,
-        0xc0016900,
-        0x0000010c,
-        0x00000000,
-        0xc0016900,
-        0x0000010d,
-        0x00000000,
+        0x00000000, /* DB_STENCIL_CLEAR */
+        0x00000000, /* DB_DEPTH_CLEAR */
+
         0xc0016900,
         0x00000200,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* DB_DEPTH_CONTROL */
+
+        0xc0026900,
         0x00000343,
-        0x00000060,
-        0xc0016900,
-        0x00000344,
-        0x00000000,
+        0x00000060, /* DB_RENDER_CONTROL */
+        0x00000000, /* DB_RENDER_OVERRIDE */
+
         0xc0016900,
         0x00000351,
-        0x0000aa00,
-        0xc0016900,
-        0x00000104,
-        0x00000000,
-        0xc0016900,
-        0x0000010e,
-        0x00000000,
-        0xc0046900,
-        0x00000105,
-        0x00000000,
+        0x0000aa00, /* DB_ALPHA_TO_MASK */
+
+        0xc0096900,
+        0x00000100,
+        0x00000800, /* VGT_MAX_VTX_INDX */
+        0x00000000, /* VGT_MIN_VTX_INDX */
+        0x00000000, /* VGT_INDX_OFFSET */
+        0x00000000, /* VGT_MULTI_PRIM_IB_RESET_INDX */
+        0x00000000, /* SX_ALPHA_TEST_CONTROL */
+        0x00000000, /* CB_BLEND_RED */
         0x00000000,
         0x00000000,
         0x00000000,
+
+        0xc0036900,
+        0x0000010c,
+        0x00000000, /* DB_STENCILREFMASK */
+        0x00000000, /* DB_STENCILREFMASK_BF */
+        0x00000000, /* SX_ALPHA_REF */
+
         0xc0046900,
-        0x0000030c,
+        0x0000030c, /* CB_CLRCMP_CNTL */
         0x01000000,
         0x00000000,
         0x00000000,
         0x00000000,
-        0xc0016900,
-        0x0000008e,
-        0x0000000f,
+
         0xc0016900,
         0x00000080,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* PA_SC_WINDOW_OFFSET */
+
+        0xc00a6900,
         0x00000083,
-        0x0000ffff,
-        0xc0016900,
-        0x00000084,
-        0x00000000,
-        0xc0016900,
-        0x00000085,
+        0x0000ffff, /* PA_SC_CLIP_RECT_RULE */
+        0x00000000, /* PA_SC_CLIPRECT_0_TL */
         0x20002000,
-        0xc0016900,
-        0x00000086,
         0x00000000,
-        0xc0016900,
-        0x00000087,
         0x20002000,
-        0xc0016900,
-        0x00000088,
         0x00000000,
-        0xc0016900,
-        0x00000089,
         0x20002000,
-        0xc0016900,
-        0x0000008a,
         0x00000000,
-        0xc0016900,
-        0x0000008b,
         0x20002000,
-        0xc0016900,
-        0x0000008c,
-        0xaaaaaaaa,
-        0xc0016900,
+        0xaaaaaaaa, /* PA_SC_EDGERULE */
+
+        0xc0406900,
         0x00000094,
-        0x80000000,
-        0xc0016900,
-        0x00000095,
+        0x80000000, /* PA_SC_VPORT_SCISSOR_0_TL */
+        0x20002000, /* PA_SC_VPORT_SCISSOR_0_BR */
+        0x80000000, /* PA_SC_VPORT_SCISSOR_1_TL */
         0x20002000,
-        0xc0026900,
-        0x000000b4,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x00000096,
         0x80000000,
-        0xc0016900,
-        0x00000097,
         0x20002000,
-        0xc0026900,
-        0x000000b6,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x00000098,
         0x80000000,
-        0xc0016900,
-        0x00000099,
         0x20002000,
-        0xc0026900,
-        0x000000b8,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x0000009a,
         0x80000000,
-        0xc0016900,
-        0x0000009b,
         0x20002000,
-        0xc0026900,
-        0x000000ba,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x0000009c,
         0x80000000,
-        0xc0016900,
-        0x0000009d,
         0x20002000,
-        0xc0026900,
-        0x000000bc,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x0000009e,
         0x80000000,
-        0xc0016900,
-        0x0000009f,
         0x20002000,
-        0xc0026900,
-        0x000000be,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a0,
         0x80000000,
-        0xc0016900,
-        0x000000a1,
         0x20002000,
-        0xc0026900,
-        0x000000c0,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a2,
         0x80000000,
-        0xc0016900,
-        0x000000a3,
         0x20002000,
-        0xc0026900,
-        0x000000c2,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a4,
         0x80000000,
-        0xc0016900,
-        0x000000a5,
         0x20002000,
-        0xc0026900,
-        0x000000c4,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a6,
         0x80000000,
-        0xc0016900,
-        0x000000a7,
         0x20002000,
-        0xc0026900,
-        0x000000c6,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000a8,
         0x80000000,
-        0xc0016900,
-        0x000000a9,
         0x20002000,
-        0xc0026900,
-        0x000000c8,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000aa,
         0x80000000,
-        0xc0016900,
-        0x000000ab,
         0x20002000,
-        0xc0026900,
-        0x000000ca,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000ac,
         0x80000000,
-        0xc0016900,
-        0x000000ad,
         0x20002000,
-        0xc0026900,
-        0x000000cc,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000ae,
         0x80000000,
-        0xc0016900,
-        0x000000af,
         0x20002000,
-        0xc0026900,
-        0x000000ce,
-        0x00000000,
-        0x3f800000,
-        0xc0016900,
-        0x000000b0,
         0x80000000,
-        0xc0016900,
-        0x000000b1,
         0x20002000,
-        0xc0026900,
-        0x000000d0,
-        0x00000000,
+        0x00000000, /* PA_SC_VPORT_ZMIN_0 */
         0x3f800000,
-        0xc0016900,
-        0x000000b2,
-        0x80000000,
-        0xc0016900,
-        0x000000b3,
-        0x20002000,
-        0xc0026900,
-        0x000000d2,
         0x00000000,
         0x3f800000,
-        0xc0016900,
-        0x00000293,
-        0x00514000,
-        0xc0016900,
-        0x00000300,
-        0x00000000,
-        0xc0016900,
-        0x00000301,
         0x00000000,
-        0xc0016900,
-        0x00000312,
-        0xffffffff,
-        0xc0016900,
-        0x00000307,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000308,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000283,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000292,
+        0x3f800000,
         0x00000000,
-        0xc0066900,
-        0x0000010f,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000206,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000207,
+        0x3f800000,
         0x00000000,
-        0xc0016900,
-        0x00000208,
+        0x3f800000,
         0x00000000,
-        0xc0046900,
-        0x00000303,
         0x3f800000,
+
+        0xc0026900,
+        0x00000292,
+        0x00000000, /* PA_SC_MPASS_PS_CNTL */
+        0x00514000, /* PA_SC_MODE_CNTL */
+
+        0xc0096900,
+        0x00000300,
+        0x00000000, /* PA_SC_LINE_CNTL */
+        0x00000000, /* PA_SC_AA_CONFIG */
+        0x0000002d, /* PA_SU_VTX_CNTL */
+        0x3f800000, /* PA_CL_GB_VERT_CLIP_ADJ */
         0x3f800000,
         0x3f800000,
         0x3f800000,
-        0xc0016900,
-        0x00000205,
-        0x00000004,
-        0xc0016900,
-        0x00000280,
-        0x00000000,
-        0xc0016900,
-        0x00000281,
+        0x00000000, /* PA_SC_SAMPLE_LOCS_MCTX */
         0x00000000,
+
         0xc0016900,
+        0x00000312,
+        0xffffffff, /* PA_SC_AA_MASK */
+
+        0xc0066900,
         0x0000037e,
-        0x00000000,
-        0xc0016900,
-        0x00000382,
-        0x00000000,
-        0xc0016900,
-        0x00000380,
-        0x00000000,
-        0xc0016900,
-        0x00000383,
-        0x00000000,
-        0xc0016900,
-        0x00000381,
-        0x00000000,
-        0xc0016900,
-        0x00000282,
-        0x00000008,
-        0xc0016900,
-        0x00000302,
-        0x0000002d,
-        0xc0016900,
-        0x0000037f,
-        0x00000000,
-        0xc0016900,
-        0x000001b2,
-        0x00000001,
-        0xc0016900,
+        0x00000000, /* PA_SU_POLY_OFFSET_DB_FMT_CNTL */
+        0x00000000, /* PA_SU_POLY_OFFSET_CLAMP */
+        0x00000000, /* PA_SU_POLY_OFFSET_FRONT_SCALE */
+        0x00000000, /* PA_SU_POLY_OFFSET_FRONT_OFFSET */
+        0x00000000, /* PA_SU_POLY_OFFSET_BACK_SCALE */
+        0x00000000, /* PA_SU_POLY_OFFSET_BACK_OFFSET */
+
+        0xc0046900,
         0x000001b6,
-        0x00000000,
-        0xc0016900,
-        0x000001b7,
-        0x00000000,
-        0xc0016900,
-        0x000001b8,
-        0x00000000,
-        0xc0016900,
-        0x000001b9,
-        0x00000000,
+        0x00000000, /* SPI_INPUT_Z */
+        0x00000000, /* SPI_FOG_CNTL */
+        0x00000000, /* SPI_FOG_FUNC_SCALE */
+        0x00000000, /* SPI_FOG_FUNC_BIAS */
+
         0xc0016900,
         0x00000225,
-        0x00000000,
+        0x00000000, /* SQ_PGM_START_FS */
+
         0xc0016900,
         0x00000229,
-        0x00000000,
+        0x00000000, /* SQ_PGM_RESOURCES_FS */
+
         0xc0016900,
         0x00000237,
-        0x00000000,
-        0xc0016900,
-        0x00000100,
-        0x00000800,
-        0xc0016900,
-        0x00000101,
-        0x00000000,
-        0xc0016900,
-        0x00000102,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* SQ_PGM_CF_OFFSET_FS */
+
+        0xc0026900,
         0x000002a8,
-        0x00000000,
-        0xc0016900,
-        0x000002a9,
-        0x00000000,
-        0xc0016900,
-        0x00000103,
-        0x00000000,
-        0xc0016900,
-        0x00000284,
-        0x00000000,
-        0xc0016900,
-        0x00000290,
-        0x00000000,
-        0xc0016900,
-        0x00000285,
-        0x00000000,
-        0xc0016900,
-        0x00000286,
-        0x00000000,
-        0xc0016900,
-        0x00000287,
-        0x00000000,
-        0xc0016900,
-        0x00000288,
-        0x00000000,
-        0xc0016900,
-        0x00000289,
-        0x00000000,
-        0xc0016900,
-        0x0000028a,
-        0x00000000,
-        0xc0016900,
-        0x0000028b,
-        0x00000000,
-        0xc0016900,
-        0x0000028c,
-        0x00000000,
-        0xc0016900,
-        0x0000028d,
-        0x00000000,
-        0xc0016900,
-        0x0000028e,
-        0x00000000,
-        0xc0016900,
-        0x0000028f,
-        0x00000000,
+        0x00000000, /* VGT_INSTANCE_STEP_RATE_0 */
+        0x00000000, /* VGT_INSTANCE_STEP_RATE_1 */
+
+        0xc0116900,
+        0x00000280,
+        0x00000000, /* PA_SU_POINT_SIZE */
+        0x00000000, /* PA_SU_POINT_MINMAX */
+        0x00000008, /* PA_SU_LINE_CNTL */
+        0x00000000, /* PA_SC_LINE_STIPPLE */
+        0x00000000, /* VGT_OUTPUT_PATH_CNTL */
+        0x00000000, /* VGT_HOS_CNTL */
+        0x00000000, /* VGT_HOS_MAX_TESS_LEVEL */
+        0x00000000, /* VGT_HOS_MIN_TESS_LEVEL */
+        0x00000000, /* VGT_HOS_REUSE_DEPTH */
+        0x00000000, /* VGT_GROUP_PRIM_TYPE */
+        0x00000000, /* VGT_GROUP_FIRST_DECR */
+        0x00000000, /* VGT_GROUP_DECR */
+        0x00000000, /* VGT_GROUP_VECT_0_CNTL */
+        0x00000000, /* VGT_GROUP_VECT_1_CNTL */
+        0x00000000, /* VGT_GROUP_VECT_0_FMT_CNTL */
+        0x00000000, /* VGT_GROUP_VECT_1_FMT_CNTL */
+        0x00000000, /* VGT_GS_MODE */
+
         0xc0016900,
         0x000002a1,
-        0x00000000,
+        0x00000000, /* VGT_PRIMITIVEID_EN */
+
         0xc0016900,
         0x000002a5,
-        0x00000000,
-        0xc0016900,
+        0x00000000, /* VGT_MULTI_PRIM_ID_RESET_EN */
+
+        0xc0036900,
         0x000002ac,
-        0x00000000,
-        0xc0016900,
-        0x000002ad,
-        0x00000000,
-        0xc0016900,
-        0x000002ae,
-        0x00000000,
+        0x00000000, /* VGT_STRMOUT_EN */
+        0x00000000, /* VGT_REUSE_OFF */
+        0x00000000, /* VGT_VTX_CNT_EN */
+
         0xc0016900,
         0x000002c8,
-        0x00000000,
-        0xc0016900,
-        0x00000206,
-        0x00000100,
-        0xc0016900,
-        0x00000204,
-        0x00010000,
-        0xc0036e00,
-        0x00000000,
-        0x00000012,
-        0x00000000,
-        0x00000000,
-        0xc0016900,
-        0x0000008f,
-        0x0000000f,
-        0xc0016900,
-        0x000001e8,
-        0x00000001,
-        0xc0016900,
+        0x00000000, /* VGT_STRMOUT_BUFFER_EN */
+
+        0xc0076900,
         0x00000202,
-        0x00cc0000,
+        0x00cc0000, /* CB_COLOR_CONTROL */
+        0x00000210, /* DB_SHADER_CNTL */
+        0x00010000, /* PA_CL_CLIP_CNTL */
+        0x00000244, /* PA_SU_SC_MODE_CNTL */
+        0x00000100, /* PA_CL_VTE_CNTL */
+        0x00000000, /* PA_CL_VS_OUT_CNTL */
+        0x00000000, /* PA_CL_NANINF_CNTL */
+
+        0xc0026900,
+        0x0000008e,
+        0x0000000f, /* CB_TARGET_MASK */
+        0x0000000f, /* CB_SHADER_MASK */
+
         0xc0016900,
-        0x00000205,
-        0x00000244,
+        0x000001e8,
+        0x00000001, /* CB_SHADER_CONTROL */
+
         0xc0016900,
-        0x00000203,
-        0x00000210,
+        0x00000185,
+        0x00000000, /* SPI_VS_OUT_ID_0 */
+
         0xc0016900,
+        0x00000191,
+        0x00000b00, /* SPI_PS_INPUT_CNTL_0 */
+
+        0xc0056900,
         0x000001b1,
+        0x00000000, /* SPI_VS_OUT_CONFIG */
+        0x00000001, /* SPI_THREAD_GROUPING */
+        0x00000001, /* SPI_PS_IN_CONTROL_0 */
+        0x00000000, /* SPI_PS_IN_CONTROL_1 */
+        0x00000000, /* SPI_INTERP_CONTROL_0 */
+
+        0xc0036e00, /* SET_SAMPLER */
         0x00000000,
-        0xc0016900,
-        0x00000185,
-        0x00000000,
-        0xc0016900,
-        0x000001b3,
-        0x00000001,
-        0xc0016900,
-        0x000001b4,
+        0x00000012,
         0x00000000,
-        0xc0016900,
-        0x00000191,
-        0x00000b00,
-        0xc0016900,
-        0x000001b5,
         0x00000000,
 };
 
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index c39c1bc13016..c3ea212e0c3c 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -25,6 +25,7 @@
  *          Alex Deucher
  *          Jerome Glisse
  */
+#include <linux/kernel.h>
 #include "drmP.h"
 #include "radeon.h"
 #include "r600d.h"
@@ -166,7 +167,7 @@ static void r600_cs_track_init(struct r600_cs_track *track)
 static inline int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
 {
         struct r600_cs_track *track = p->track;
-        u32 bpe = 0, pitch, slice_tile_max, size, tmp, height;
+        u32 bpe = 0, pitch, slice_tile_max, size, tmp, height, pitch_align;
         volatile u32 *ib = p->ib->ptr;
 
         if (G_0280A0_TILE_MODE(track->cb_color_info[i])) {
@@ -180,56 +181,57 @@ static inline int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
                         i, track->cb_color_info[i]);
                 return -EINVAL;
         }
-        pitch = (G_028060_PITCH_TILE_MAX(track->cb_color_size[i]) + 1) << 3;
+        /* pitch is the number of 8x8 tiles per row */
+        pitch = G_028060_PITCH_TILE_MAX(track->cb_color_size[i]) + 1;
         slice_tile_max = G_028060_SLICE_TILE_MAX(track->cb_color_size[i]) + 1;
-        if (!pitch) {
-                dev_warn(p->dev, "%s:%d cb pitch (%d) for %d invalid (0x%08X)\n",
-                        __func__, __LINE__, pitch, i, track->cb_color_size[i]);
-                return -EINVAL;
-        }
-        height = size / (pitch * bpe);
+        height = size / (pitch * 8 * bpe);
         if (height > 8192)
                 height = 8192;
+        if (height > 7)
+                height &= ~0x7;
         switch (G_0280A0_ARRAY_MODE(track->cb_color_info[i])) {
         case V_0280A0_ARRAY_LINEAR_GENERAL:
+                /* technically height & 0x7 */
+                break;
         case V_0280A0_ARRAY_LINEAR_ALIGNED:
-                if (pitch & 0x3f) {
-                        dev_warn(p->dev, "%s:%d cb pitch (%d x %d = %d) invalid\n",
-                                __func__, __LINE__, pitch, bpe, pitch * bpe);
+                pitch_align = max((u32)64, (u32)(track->group_size / bpe)) / 8;
+                if (!IS_ALIGNED(pitch, pitch_align)) {
+                        dev_warn(p->dev, "%s:%d cb pitch (%d) invalid\n",
+                                 __func__, __LINE__, pitch);
                         return -EINVAL;
                 }
-                if ((pitch * bpe) & (track->group_size - 1)) {
-                        dev_warn(p->dev, "%s:%d cb pitch (%d) invalid\n",
-                                __func__, __LINE__, pitch);
+                if (!IS_ALIGNED(height, 8)) {
+                        dev_warn(p->dev, "%s:%d cb height (%d) invalid\n",
+                                 __func__, __LINE__, height);
                         return -EINVAL;
                 }
                 break;
         case V_0280A0_ARRAY_1D_TILED_THIN1:
-                if ((pitch * 8 * bpe * track->nsamples) & (track->group_size - 1)) {
+                pitch_align = max((u32)8, (u32)(track->group_size / (8 * bpe * track->nsamples))) / 8;
+                if (!IS_ALIGNED(pitch, pitch_align)) {
                         dev_warn(p->dev, "%s:%d cb pitch (%d) invalid\n",
-                                __func__, __LINE__, pitch);
+                                 __func__, __LINE__, pitch);
+                        return -EINVAL;
+                }
+                if (!IS_ALIGNED(height, 8)) {
+                        dev_warn(p->dev, "%s:%d cb height (%d) invalid\n",
+                                 __func__, __LINE__, height);
                         return -EINVAL;
                 }
-                height &= ~0x7;
-                if (!height)
-                        height = 8;
                 break;
         case V_0280A0_ARRAY_2D_TILED_THIN1:
-                if (pitch & ((8 * track->nbanks) - 1)) {
+                pitch_align = max((u32)track->nbanks,
+                                  (u32)(((track->group_size / 8) / (bpe * track->nsamples)) * track->nbanks));
+                if (!IS_ALIGNED(pitch, pitch_align)) {
                         dev_warn(p->dev, "%s:%d cb pitch (%d) invalid\n",
                                 __func__, __LINE__, pitch);
                         return -EINVAL;
                 }
-                tmp = pitch * 8 * bpe * track->nsamples;
-                tmp = tmp / track->nbanks;
-                if (tmp & (track->group_size - 1)) {
-                        dev_warn(p->dev, "%s:%d cb pitch (%d) invalid\n",
-                                __func__, __LINE__, pitch);
+                if (!IS_ALIGNED((height / 8), track->nbanks)) {
+                        dev_warn(p->dev, "%s:%d cb height (%d) invalid\n",
+                                 __func__, __LINE__, height);
                         return -EINVAL;
                 }
-                height &= ~((16 * track->npipes) - 1);
-                if (!height)
-                        height = 16 * track->npipes;
                 break;
         default:
                 dev_warn(p->dev, "%s invalid tiling %d for %d (0x%08X)\n", __func__,
@@ -238,16 +240,20 @@ static inline int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
                 return -EINVAL;
         }
         /* check offset */
-        tmp = height * pitch;
+        tmp = height * pitch * 8 * bpe;
         if ((tmp + track->cb_color_bo_offset[i]) > radeon_bo_size(track->cb_color_bo[i])) {
-                dev_warn(p->dev, "%s offset[%d] %d to big\n", __func__, i, track->cb_color_bo_offset[i]);
+                dev_warn(p->dev, "%s offset[%d] %d too big\n", __func__, i, track->cb_color_bo_offset[i]);
+                return -EINVAL;
+        }
+        if (!IS_ALIGNED(track->cb_color_bo_offset[i], track->group_size)) {
+                dev_warn(p->dev, "%s offset[%d] %d not aligned\n", __func__, i, track->cb_color_bo_offset[i]);
                 return -EINVAL;
         }
         /* limit max tile */
-        tmp = (height * pitch) >> 6;
+        tmp = (height * pitch * 8) >> 6;
         if (tmp < slice_tile_max)
                 slice_tile_max = tmp;
-        tmp = S_028060_PITCH_TILE_MAX((pitch >> 3) - 1) |
+        tmp = S_028060_PITCH_TILE_MAX(pitch - 1) |
                 S_028060_SLICE_TILE_MAX(slice_tile_max - 1);
         ib[track->cb_color_size_idx[i]] = tmp;
         return 0;
@@ -289,7 +295,7 @@ static int r600_cs_track_check(struct radeon_cs_parser *p)
         /* Check depth buffer */
         if (G_028800_STENCIL_ENABLE(track->db_depth_control) ||
                 G_028800_Z_ENABLE(track->db_depth_control)) {
-                u32 nviews, bpe, ntiles;
+                u32 nviews, bpe, ntiles, pitch, pitch_align, height, size;
                 if (track->db_bo == NULL) {
                         dev_warn(p->dev, "z/stencil with no depth buffer\n");
                         return -EINVAL;
@@ -332,6 +338,51 @@ static int r600_cs_track_check(struct radeon_cs_parser *p)
                         }
                         ib[track->db_depth_size_idx] = S_028000_SLICE_TILE_MAX(tmp - 1) | (track->db_depth_size & 0x3FF);
                 } else {
+                        size = radeon_bo_size(track->db_bo);
+                        pitch = G_028000_PITCH_TILE_MAX(track->db_depth_size) + 1;
+                        height = size / (pitch * 8 * bpe);
+                        height &= ~0x7;
+                        if (!height)
+                                height = 8;
+
+                        switch (G_028010_ARRAY_MODE(track->db_depth_info)) {
+                        case V_028010_ARRAY_1D_TILED_THIN1:
+                                pitch_align = (max((u32)8, (u32)(track->group_size / (8 * bpe))) / 8);
+                                if (!IS_ALIGNED(pitch, pitch_align)) {
+                                        dev_warn(p->dev, "%s:%d db pitch (%d) invalid\n",
+                                                 __func__, __LINE__, pitch);
+                                        return -EINVAL;
+                                }
+                                if (!IS_ALIGNED(height, 8)) {
+                                        dev_warn(p->dev, "%s:%d db height (%d) invalid\n",
+                                                 __func__, __LINE__, height);
+                                        return -EINVAL;
+                                }
+                                break;
+                        case V_028010_ARRAY_2D_TILED_THIN1:
+                                pitch_align = max((u32)track->nbanks,
+                                                  (u32)(((track->group_size / 8) / bpe) * track->nbanks));
+                                if (!IS_ALIGNED(pitch, pitch_align)) {
+                                        dev_warn(p->dev, "%s:%d db pitch (%d) invalid\n",
+                                                 __func__, __LINE__, pitch);
+                                        return -EINVAL;
+                                }
+                                if ((height / 8) & (track->nbanks - 1)) {
+                                        dev_warn(p->dev, "%s:%d db height (%d) invalid\n",
+                                                 __func__, __LINE__, height);
+                                        return -EINVAL;
+                                }
+                                break;
+                        default:
+                                dev_warn(p->dev, "%s invalid tiling %d (0x%08X)\n", __func__,
+                                         G_028010_ARRAY_MODE(track->db_depth_info),
+                                         track->db_depth_info);
+                                return -EINVAL;
+                        }
+                        if (!IS_ALIGNED(track->db_offset, track->group_size)) {
+                                dev_warn(p->dev, "%s offset[%d] %d not aligned\n", __func__, i, track->db_offset);
+                                return -EINVAL;
+                        }
                         ntiles = G_028000_SLICE_TILE_MAX(track->db_depth_size) + 1;
                         nviews = G_028004_SLICE_MAX(track->db_depth_view) + 1;
                         tmp = ntiles * bpe * 64 * nviews;
@@ -585,7 +636,7 @@ static int r600_cs_packet_parse_vline(struct radeon_cs_parser *p)
         header = radeon_get_ib_value(p, h_idx);
         crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1);
         reg = CP_PACKET0_GET_REG(header);
-        mutex_lock(&p->rdev->ddev->mode_config.mutex);
+
         obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC);
         if (!obj) {
                 DRM_ERROR("cannot find crtc %d\n", crtc_id);
@@ -620,7 +671,6 @@ static int r600_cs_packet_parse_vline(struct radeon_cs_parser *p)
                 ib[h_idx + 4] = AVIVO_D2MODE_VLINE_STATUS >> 2;
         }
 out:
-        mutex_unlock(&p->rdev->ddev->mode_config.mutex);
         return r;
 }
 
@@ -725,7 +775,25 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
                 track->db_depth_control = radeon_get_ib_value(p, idx);
                 break;
         case R_028010_DB_DEPTH_INFO:
-                track->db_depth_info = radeon_get_ib_value(p, idx);
+                if (r600_cs_packet_next_is_pkt3_nop(p)) {
+                        r = r600_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                dev_warn(p->dev, "bad SET_CONTEXT_REG "
+                                         "0x%04X\n", reg);
+                                return -EINVAL;
+                        }
+                        track->db_depth_info = radeon_get_ib_value(p, idx);
+                        ib[idx] &= C_028010_ARRAY_MODE;
+                        track->db_depth_info &= C_028010_ARRAY_MODE;
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
+                                ib[idx] |= S_028010_ARRAY_MODE(V_028010_ARRAY_2D_TILED_THIN1);
+                                track->db_depth_info |= S_028010_ARRAY_MODE(V_028010_ARRAY_2D_TILED_THIN1);
+                        } else {
+                                ib[idx] |= S_028010_ARRAY_MODE(V_028010_ARRAY_1D_TILED_THIN1);
+                                track->db_depth_info |= S_028010_ARRAY_MODE(V_028010_ARRAY_1D_TILED_THIN1);
+                        }
+                } else
+                        track->db_depth_info = radeon_get_ib_value(p, idx);
                 break;
         case R_028004_DB_DEPTH_VIEW:
                 track->db_depth_view = radeon_get_ib_value(p, idx);
@@ -758,8 +826,25 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
         case R_0280B4_CB_COLOR5_INFO:
         case R_0280B8_CB_COLOR6_INFO:
         case R_0280BC_CB_COLOR7_INFO:
-                tmp = (reg - R_0280A0_CB_COLOR0_INFO) / 4;
-                track->cb_color_info[tmp] = radeon_get_ib_value(p, idx);
+                if (r600_cs_packet_next_is_pkt3_nop(p)) {
+                        r = r600_cs_packet_next_reloc(p, &reloc);
+                        if (r) {
+                                dev_err(p->dev, "bad SET_CONTEXT_REG 0x%04X\n", reg);
+                                return -EINVAL;
+                        }
+                        tmp = (reg - R_0280A0_CB_COLOR0_INFO) / 4;
+                        track->cb_color_info[tmp] = radeon_get_ib_value(p, idx);
+                        if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) {
+                                ib[idx] |= S_0280A0_ARRAY_MODE(V_0280A0_ARRAY_2D_TILED_THIN1);
+                                track->cb_color_info[tmp] |= S_0280A0_ARRAY_MODE(V_0280A0_ARRAY_2D_TILED_THIN1);
+                        } else if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO) {
+                                ib[idx] |= S_0280A0_ARRAY_MODE(V_0280A0_ARRAY_1D_TILED_THIN1);
+                                track->cb_color_info[tmp] |= S_0280A0_ARRAY_MODE(V_0280A0_ARRAY_1D_TILED_THIN1);
+                        }
+                } else {
+                        tmp = (reg - R_0280A0_CB_COLOR0_INFO) / 4;
+                        track->cb_color_info[tmp] = radeon_get_ib_value(p, idx);
+                }
                 break;
         case R_028060_CB_COLOR0_SIZE:
         case R_028064_CB_COLOR1_SIZE:
@@ -947,8 +1032,9 @@ static inline unsigned minify(unsigned size, unsigned levels)
 }
 
 static void r600_texture_size(unsigned nfaces, unsigned blevel, unsigned nlevels,
-                                unsigned w0, unsigned h0, unsigned d0, unsigned bpe,
-                                unsigned *l0_size, unsigned *mipmap_size)
+                              unsigned w0, unsigned h0, unsigned d0, unsigned bpe,
+                              unsigned pitch_align,
+                              unsigned *l0_size, unsigned *mipmap_size)
 {
         unsigned offset, i, level, face;
         unsigned width, height, depth, rowstride, size;
@@ -961,13 +1047,13 @@ static void r600_texture_size(unsigned nfaces, unsigned blevel, unsigned nlevels
                 height = minify(h0, i);
                 depth = minify(d0, i);
                 for(face = 0; face < nfaces; face++) {
-                        rowstride = ((width * bpe) + 255) & ~255;
+                        rowstride = ALIGN((width * bpe), pitch_align);
                         size = height * rowstride * depth;
                         offset += size;
                         offset = (offset + 0x1f) & ~0x1f;
                 }
         }
-        *l0_size = (((w0 * bpe) + 255) & ~255) * h0 * d0;
+        *l0_size = ALIGN((w0 * bpe), pitch_align) * h0 * d0;
         *mipmap_size = offset;
         if (!blevel)
                 *mipmap_size -= *l0_size;
@@ -986,16 +1072,23 @@ static void r600_texture_size(unsigned nfaces, unsigned blevel, unsigned nlevels
  * the texture and mipmap bo object are big enough to cover this resource.
  */
 static inline int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 idx,
-                                                struct radeon_bo *texture,
-                                                struct radeon_bo *mipmap)
+                                              struct radeon_bo *texture,
+                                              struct radeon_bo *mipmap,
+                                              u32 tiling_flags)
 {
+        struct r600_cs_track *track = p->track;
         u32 nfaces, nlevels, blevel, w0, h0, d0, bpe = 0;
-        u32 word0, word1, l0_size, mipmap_size;
+        u32 word0, word1, l0_size, mipmap_size, pitch, pitch_align;
 
         /* on legacy kernel we don't perform advanced check */
         if (p->rdev == NULL)
                 return 0;
+
         word0 = radeon_get_ib_value(p, idx + 0);
+        if (tiling_flags & RADEON_TILING_MACRO)
+                word0 |= S_038000_TILE_MODE(V_038000_ARRAY_2D_TILED_THIN1);
+        else if (tiling_flags & RADEON_TILING_MICRO)
+                word0 |= S_038000_TILE_MODE(V_038000_ARRAY_1D_TILED_THIN1);
         word1 = radeon_get_ib_value(p, idx + 1);
         w0 = G_038000_TEX_WIDTH(word0) + 1;
         h0 = G_038004_TEX_HEIGHT(word1) + 1;
@@ -1022,11 +1115,55 @@ static inline int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 i
                          __func__, __LINE__, G_038004_DATA_FORMAT(word1));
                 return -EINVAL;
         }
+
+        pitch = G_038000_PITCH(word0) + 1;
+        switch (G_038000_TILE_MODE(word0)) {
+        case V_038000_ARRAY_LINEAR_GENERAL:
+                pitch_align = 1;
+                /* XXX check height align */
+                break;
+        case V_038000_ARRAY_LINEAR_ALIGNED:
+                pitch_align = max((u32)64, (u32)(track->group_size / bpe)) / 8;
+                if (!IS_ALIGNED(pitch, pitch_align)) {
+                        dev_warn(p->dev, "%s:%d tex pitch (%d) invalid\n",
+                                 __func__, __LINE__, pitch);
+                        return -EINVAL;
+                }
+                /* XXX check height align */
+                break;
+        case V_038000_ARRAY_1D_TILED_THIN1:
+                pitch_align = max((u32)8, (u32)(track->group_size / (8 * bpe))) / 8;
+                if (!IS_ALIGNED(pitch, pitch_align)) {
+                        dev_warn(p->dev, "%s:%d tex pitch (%d) invalid\n",
+                                 __func__, __LINE__, pitch);
+                        return -EINVAL;
+                }
+                /* XXX check height align */
+                break;
+        case V_038000_ARRAY_2D_TILED_THIN1:
+                pitch_align = max((u32)track->nbanks,
+                                  (u32)(((track->group_size / 8) / bpe) * track->nbanks));
+                if (!IS_ALIGNED(pitch, pitch_align)) {
+                        dev_warn(p->dev, "%s:%d tex pitch (%d) invalid\n",
+                                __func__, __LINE__, pitch);
+                        return -EINVAL;
+                }
+                /* XXX check height align */
+                break;
+        default:
+                dev_warn(p->dev, "%s invalid tiling %d (0x%08X)\n", __func__,
+                         G_038000_TILE_MODE(word0), word0);
+                return -EINVAL;
+        }
+        /* XXX check offset align */
+
         word0 = radeon_get_ib_value(p, idx + 4);
         word1 = radeon_get_ib_value(p, idx + 5);
         blevel = G_038010_BASE_LEVEL(word0);
         nlevels = G_038014_LAST_LEVEL(word1);
-        r600_texture_size(nfaces, blevel, nlevels, w0, h0, d0, bpe, &l0_size, &mipmap_size);
+        r600_texture_size(nfaces, blevel, nlevels, w0, h0, d0, bpe,
+                          (pitch_align * bpe),
+                          &l0_size, &mipmap_size);
         /* using get ib will give us the offset into the texture bo */
         word0 = radeon_get_ib_value(p, idx + 2);
         if ((l0_size + word0) > radeon_bo_size(texture)) {
@@ -1240,6 +1377,10 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                                         return -EINVAL;
                                 }
                                 ib[idx+1+(i*7)+2] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
+                                        ib[idx+1+(i*7)+0] |= S_038000_TILE_MODE(V_038000_ARRAY_2D_TILED_THIN1);
+                                else if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
+                                        ib[idx+1+(i*7)+0] |= S_038000_TILE_MODE(V_038000_ARRAY_1D_TILED_THIN1);
                                 texture = reloc->robj;
                                 /* tex mip base */
                                 r = r600_cs_packet_next_reloc(p, &reloc);
@@ -1250,7 +1391,7 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                                 ib[idx+1+(i*7)+3] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                                 mipmap = reloc->robj;
                                 r = r600_check_texture_resource(p,  idx+(i*7)+1,
-                                                texture, mipmap);
+                                                                texture, mipmap, reloc->lobj.tiling_flags);
                                 if (r)
                                         return r;
                                 break;
diff --git a/drivers/gpu/drm/radeon/r600_hdmi.c b/drivers/gpu/drm/radeon/r600_hdmi.c
index 26b4bc9d89a5..e6a58ed48dcf 100644
--- a/drivers/gpu/drm/radeon/r600_hdmi.c
+++ b/drivers/gpu/drm/radeon/r600_hdmi.c
@@ -435,7 +435,8 @@ static int r600_hdmi_find_free_block(struct drm_device *dev)
                 }
         }
 
-        if (rdev->family == CHIP_RS600 || rdev->family == CHIP_RS690) {
+        if (rdev->family == CHIP_RS600 || rdev->family == CHIP_RS690 ||
+            rdev->family == CHIP_RS740) {
                 return free_blocks[0] ? R600_HDMI_BLOCK1 : 0;
         } else if (rdev->family >= CHIP_R600) {
                 if (free_blocks[0])
@@ -466,7 +467,8 @@ static void r600_hdmi_assign_block(struct drm_encoder *encoder)
                 if (ASIC_IS_DCE32(rdev))
                         radeon_encoder->hdmi_config_offset = dig->dig_encoder ?
                                 R600_HDMI_CONFIG2 : R600_HDMI_CONFIG1;
-        } else if (rdev->family >= CHIP_R600) {
+        } else if (rdev->family >= CHIP_R600 || rdev->family == CHIP_RS600 ||
+                   rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) {
                 radeon_encoder->hdmi_offset = r600_hdmi_find_free_block(dev);
         }
 }
diff --git a/drivers/gpu/drm/radeon/r600d.h b/drivers/gpu/drm/radeon/r600d.h
index 59c1f8793e60..858a1920c0d7 100644
--- a/drivers/gpu/drm/radeon/r600d.h
+++ b/drivers/gpu/drm/radeon/r600d.h
@@ -239,12 +239,18 @@
 #define GRBM_SOFT_RESET                                 0x8020
 #define         SOFT_RESET_CP                                   (1<<0)
 
+#define CG_THERMAL_STATUS                               0x7F4
+#define         ASIC_T(x)                               ((x) << 0)
+#define         ASIC_T_MASK                             0x1FF
+#define         ASIC_T_SHIFT                            0
+
 #define HDP_HOST_PATH_CNTL                              0x2C00
 #define HDP_NONSURFACE_BASE                             0x2C04
 #define HDP_NONSURFACE_INFO                             0x2C08
 #define HDP_NONSURFACE_SIZE                             0x2C0C
 #define HDP_REG_COHERENCY_FLUSH_CNTL                    0x54A0
 #define HDP_TILING_CONFIG                               0x2F3C
+#define HDP_DEBUG1                                      0x2F34
 
 #define MC_VM_AGP_TOP                                   0x2184
 #define MC_VM_AGP_BOT                                   0x2188
@@ -1154,6 +1160,10 @@
 #define   S_038000_TILE_MODE(x)                        (((x) & 0xF) << 3)
 #define   G_038000_TILE_MODE(x)                        (((x) >> 3) & 0xF)
 #define   C_038000_TILE_MODE                           0xFFFFFF87
+#define     V_038000_ARRAY_LINEAR_GENERAL              0x00000000
+#define     V_038000_ARRAY_LINEAR_ALIGNED              0x00000001
+#define     V_038000_ARRAY_1D_TILED_THIN1              0x00000002
+#define     V_038000_ARRAY_2D_TILED_THIN1              0x00000004
 #define   S_038000_TILE_TYPE(x)                        (((x) & 0x1) << 7)
 #define   G_038000_TILE_TYPE(x)                        (((x) >> 7) & 0x1)
 #define   C_038000_TILE_TYPE                           0xFFFFFF7F
@@ -1357,6 +1367,8 @@
 #define   S_028010_ARRAY_MODE(x)                       (((x) & 0xF) << 15)
 #define   G_028010_ARRAY_MODE(x)                       (((x) >> 15) & 0xF)
 #define   C_028010_ARRAY_MODE                          0xFFF87FFF
+#define     V_028010_ARRAY_1D_TILED_THIN1              0x00000002
+#define     V_028010_ARRAY_2D_TILED_THIN1              0x00000004
 #define   S_028010_TILE_SURFACE_ENABLE(x)              (((x) & 0x1) << 25)
 #define   G_028010_TILE_SURFACE_ENABLE(x)              (((x) >> 25) & 0x1)
 #define   C_028010_TILE_SURFACE_ENABLE                 0xFDFFFFFF
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index ab61aaa887bb..c84f9a311550 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -178,6 +178,9 @@ void radeon_combios_get_power_modes(struct radeon_device *rdev);
 void radeon_atombios_get_power_modes(struct radeon_device *rdev);
 void radeon_atom_set_voltage(struct radeon_device *rdev, u16 level);
 void rs690_pm_info(struct radeon_device *rdev);
+extern u32 rv6xx_get_temp(struct radeon_device *rdev);
+extern u32 rv770_get_temp(struct radeon_device *rdev);
+extern u32 evergreen_get_temp(struct radeon_device *rdev);
 
 /*
  * Fences.
@@ -351,6 +354,7 @@ struct radeon_mc {
         int                     vram_mtrr;
         bool                    vram_is_ddr;
         bool                    igp_sideport_enabled;
+        u64                     gtt_base_align;
 };
 
 bool radeon_combios_sideport_present(struct radeon_device *rdev);
@@ -670,6 +674,13 @@ struct radeon_pm_profile {
         int dpms_on_cm_idx;
 };
 
+enum radeon_int_thermal_type {
+        THERMAL_TYPE_NONE,
+        THERMAL_TYPE_RV6XX,
+        THERMAL_TYPE_RV770,
+        THERMAL_TYPE_EVERGREEN,
+};
+
 struct radeon_voltage {
         enum radeon_voltage_type type;
         /* gpio voltage */
@@ -765,6 +776,9 @@ struct radeon_pm {
         enum radeon_pm_profile_type profile;
         int                     profile_index;
         struct radeon_pm_profile profiles[PM_PROFILE_MAX];
+        /* internal thermal controller on rv6xx+ */
+        enum radeon_int_thermal_type int_thermal_type;
+        struct device           *int_hwmon_dev;
 };
 
 
@@ -901,6 +915,7 @@ struct r600_asic {
         unsigned                tiling_nbanks;
         unsigned                tiling_npipes;
         unsigned                tiling_group_size;
+        unsigned                tile_config;
         struct r100_gpu_lockup  lockup;
 };
 
@@ -925,6 +940,7 @@ struct rv770_asic {
         unsigned                tiling_nbanks;
         unsigned                tiling_npipes;
         unsigned                tiling_group_size;
+        unsigned                tile_config;
         struct r100_gpu_lockup  lockup;
 };
 
@@ -950,6 +966,7 @@ struct evergreen_asic {
         unsigned tiling_nbanks;
         unsigned tiling_npipes;
         unsigned tiling_group_size;
+        unsigned tile_config;
 };
 
 union radeon_asic_config {
@@ -1032,6 +1049,9 @@ struct radeon_device {
         uint32_t                        pcie_reg_mask;
         radeon_rreg_t                   pciep_rreg;
         radeon_wreg_t                   pciep_wreg;
+        /* io port */
+        void __iomem                    *rio_mem;
+        resource_size_t                 rio_mem_size;
         struct radeon_clock             clock;
         struct radeon_mc                mc;
         struct radeon_gart              gart;
@@ -1068,6 +1088,7 @@ struct radeon_device {
         struct mutex vram_mutex;
 
         /* audio stuff */
+        bool                    audio_enabled;
         struct timer_list       audio_timer;
         int                     audio_channels;
         int                     audio_rate;
@@ -1113,6 +1134,26 @@ static inline void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32
         }
 }
 
+static inline u32 r100_io_rreg(struct radeon_device *rdev, u32 reg)
+{
+        if (reg < rdev->rio_mem_size)
+                return ioread32(rdev->rio_mem + reg);
+        else {
+                iowrite32(reg, rdev->rio_mem + RADEON_MM_INDEX);
+                return ioread32(rdev->rio_mem + RADEON_MM_DATA);
+        }
+}
+
+static inline void r100_io_wreg(struct radeon_device *rdev, u32 reg, u32 v)
+{
+        if (reg < rdev->rio_mem_size)
+                iowrite32(v, rdev->rio_mem + reg);
+        else {
+                iowrite32(reg, rdev->rio_mem + RADEON_MM_INDEX);
+                iowrite32(v, rdev->rio_mem + RADEON_MM_DATA);
+        }
+}
+
 /*
  * Cast helper
  */
@@ -1151,6 +1192,8 @@ static inline void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32
                 WREG32_PLL(reg, tmp_);                          \
         } while (0)
 #define DREG32_SYS(sqf, rdev, reg) seq_printf((sqf), #reg " : 0x%08X\n", r100_mm_rreg((rdev), (reg)))
+#define RREG32_IO(reg) r100_io_rreg(rdev, (reg))
+#define WREG32_IO(reg, v) r100_io_wreg(rdev, (reg), (v))
 
 /*
  * Indirect registers accessor
@@ -1414,6 +1457,13 @@ extern void r700_cp_fini(struct radeon_device *rdev);
 extern void evergreen_disable_interrupt_state(struct radeon_device *rdev);
 extern int evergreen_irq_set(struct radeon_device *rdev);
 
+/* radeon_acpi.c */ 
+#if defined(CONFIG_ACPI) 
+extern int radeon_acpi_init(struct radeon_device *rdev); 
+#else 
+static inline int radeon_acpi_init(struct radeon_device *rdev) { return 0; } 
+#endif 
+
 /* evergreen */
 struct evergreen_mc_save {
         u32 vga_control[6];
diff --git a/drivers/gpu/drm/radeon/radeon_acpi.c b/drivers/gpu/drm/radeon/radeon_acpi.c
new file mode 100644
index 000000000000..e366434035cb
--- /dev/null
+++ b/drivers/gpu/drm/radeon/radeon_acpi.c
@@ -0,0 +1,67 @@
+#include <linux/pci.h>
+#include <linux/acpi.h>
+#include <linux/slab.h>
+#include <acpi/acpi_drivers.h>
+#include <acpi/acpi_bus.h>
+
+#include "drmP.h"
+#include "drm.h"
+#include "drm_sarea.h"
+#include "drm_crtc_helper.h"
+#include "radeon.h"
+
+#include <linux/vga_switcheroo.h>
+
+/* Call the ATIF method
+ *
+ * Note: currently we discard the output
+ */
+static int radeon_atif_call(acpi_handle handle)
+{
+        acpi_status status;
+        union acpi_object atif_arg_elements[2];
+        struct acpi_object_list atif_arg;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
+
+        atif_arg.count = 2;
+        atif_arg.pointer = &atif_arg_elements[0];
+
+        atif_arg_elements[0].type = ACPI_TYPE_INTEGER;
+        atif_arg_elements[0].integer.value = 0;
+        atif_arg_elements[1].type = ACPI_TYPE_INTEGER;
+        atif_arg_elements[1].integer.value = 0;
+
+        status = acpi_evaluate_object(handle, "ATIF", &atif_arg, &buffer);
+
+        /* Fail only if calling the method fails and ATIF is supported */
+        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+                printk(KERN_INFO "failed to evaluate ATIF got %s\n", acpi_format_exception(status));
+                kfree(buffer.pointer);
+                return 1;
+        }
+
+        kfree(buffer.pointer);
+        return 0;
+}
+
+/* Call all ACPI methods here */
+int radeon_acpi_init(struct radeon_device *rdev)
+{
+        acpi_handle handle;
+        int ret;
+
+        /* No need to proceed if we're sure that ATIF is not supported */
+        if (!ASIC_IS_AVIVO(rdev) || !rdev->bios)
+                return 0;
+
+        /* Get the device handle */
+        handle = DEVICE_ACPI_HANDLE(&rdev->pdev->dev);
+
+        /* Call the ATIF method */
+        ret = radeon_atif_call(handle);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
diff --git a/drivers/gpu/drm/radeon/radeon_asic.h b/drivers/gpu/drm/radeon/radeon_asic.h
index c0bbaa64157a..a5aff755f0d2 100644
--- a/drivers/gpu/drm/radeon/radeon_asic.h
+++ b/drivers/gpu/drm/radeon/radeon_asic.h
@@ -113,6 +113,7 @@ void r100_wb_fini(struct radeon_device *rdev);
 int r100_wb_init(struct radeon_device *rdev);
 int r100_cp_reset(struct radeon_device *rdev);
 void r100_vga_render_disable(struct radeon_device *rdev);
+void r100_restore_sanity(struct radeon_device *rdev);
 int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p,
                                          struct radeon_cs_packet *pkt,
                                          struct radeon_bo *robj);
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 99bd8a9c56b3..0a97aeb083dd 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -280,6 +280,15 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                 }
         }
 
+        /* ASUS HD 3600 board lists the DVI port as HDMI */
+        if ((dev->pdev->device == 0x9598) &&
+            (dev->pdev->subsystem_vendor == 0x1043) &&
+            (dev->pdev->subsystem_device == 0x01e4)) {
+                if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
+                        *connector_type = DRM_MODE_CONNECTOR_DVII;
+                }
+        }
+
         /* ASUS HD 3450 board lists the DVI port as HDMI */
         if ((dev->pdev->device == 0x95C5) &&
             (dev->pdev->subsystem_vendor == 0x1043) &&
@@ -1029,8 +1038,15 @@ bool radeon_atombios_sideport_present(struct radeon_device *rdev)
                                       data_offset);
                 switch (crev) {
                 case 1:
-                        if (igp_info->info.ucMemoryType & 0xf0)
-                                return true;
+                        /* AMD IGPS */
+                        if ((rdev->family == CHIP_RS690) ||
+                            (rdev->family == CHIP_RS740)) {
+                                if (igp_info->info.ulBootUpMemoryClock)
+                                        return true;
+                        } else {
+                                if (igp_info->info.ucMemoryType & 0xf0)
+                                        return true;
+                        }
                         break;
                 case 2:
                         if (igp_info->info_2.ucMemoryType & 0x0f)
@@ -1773,14 +1789,22 @@ void radeon_atombios_get_power_modes(struct radeon_device *rdev)
                         }
 
                         /* add the i2c bus for thermal/fan chip */
-                        /* no support for internal controller yet */
                         if (controller->ucType > 0) {
-                                if ((controller->ucType == ATOM_PP_THERMALCONTROLLER_RV6xx) ||
-                                    (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV770) ||
-                                    (controller->ucType == ATOM_PP_THERMALCONTROLLER_EVERGREEN)) {
+                                if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV6xx) {
+                                        DRM_INFO("Internal thermal controller %s fan control\n",
+                                                 (controller->ucFanParameters &
+                                                  ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
+                                        rdev->pm.int_thermal_type = THERMAL_TYPE_RV6XX;
+                                } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV770) {
+                                        DRM_INFO("Internal thermal controller %s fan control\n",
+                                                 (controller->ucFanParameters &
+                                                  ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
+                                        rdev->pm.int_thermal_type = THERMAL_TYPE_RV770;
+                                } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_EVERGREEN) {
                                         DRM_INFO("Internal thermal controller %s fan control\n",
                                                  (controller->ucFanParameters &
                                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
+                                        rdev->pm.int_thermal_type = THERMAL_TYPE_EVERGREEN;
                                 } else if ((controller->ucType ==
                                             ATOM_PP_THERMALCONTROLLER_EXTERNAL_GPIO) ||
                                            (controller->ucType ==
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index d1c1d8dd93ce..5e45cb27eb98 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -2941,9 +2941,8 @@ static void combios_write_ram_size(struct drm_device *dev)
                 if (rev < 3) {
                         mem_cntl = RBIOS32(offset + 1);
                         mem_size = RBIOS16(offset + 5);
-                        if (((rdev->flags & RADEON_FAMILY_MASK) < CHIP_R200) &&
-                            ((dev->pdev->device != 0x515e)
-                             && (dev->pdev->device != 0x5969)))
+                        if ((rdev->family < CHIP_R200) &&
+                            !ASIC_IS_RN50(rdev))
                                 WREG32(RADEON_MEM_CNTL, mem_cntl);
                 }
         }
@@ -2954,10 +2953,8 @@ static void combios_write_ram_size(struct drm_device *dev)
                 if (offset) {
                         rev = RBIOS8(offset - 1);
                         if (rev < 1) {
-                                if (((rdev->flags & RADEON_FAMILY_MASK) <
-                                     CHIP_R200)
-                                    && ((dev->pdev->device != 0x515e)
-                                        && (dev->pdev->device != 0x5969))) {
+                                if ((rdev->family < CHIP_R200)
+                                    && !ASIC_IS_RN50(rdev)) {
                                         int ram = 0;
                                         int mem_addr_mapping = 0;
 
@@ -3050,6 +3047,14 @@ void radeon_combios_asic_init(struct drm_device *dev)
             rdev->pdev->subsystem_device == 0x308b)
                 return;
 
+        /* quirk for rs4xx HP dv5000 laptop to make it resume
+         * - it hangs on resume inside the dynclk 1 table.
+         */
+        if (rdev->family == CHIP_RS480 &&
+            rdev->pdev->subsystem_vendor == 0x103c &&
+            rdev->pdev->subsystem_device == 0x30a4)
+                return;
+
         /* DYN CLK 1 */
         table = combios_get_table_offset(dev, COMBIOS_DYN_CLK_1_TABLE);
         if (table)
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index f58f8bd8f77b..adccbc2c202c 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -771,14 +771,14 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
                         } else
                                 ret = connector_status_connected;
 
-                        /* multiple connectors on the same encoder with the same ddc line
-                         * This tends to be HDMI and DVI on the same encoder with the
-                         * same ddc line.  If the edid says HDMI, consider the HDMI port
-                         * connected and the DVI port disconnected.  If the edid doesn't
-                         * say HDMI, vice versa.
+                        /* This gets complicated.  We have boards with VGA + HDMI with a
+                         * shared DDC line and we have boards with DVI-D + HDMI with a shared
+                         * DDC line.  The latter is more complex because with DVI<->HDMI adapters
+                         * you don't really know what's connected to which port as both are digital.
                          */
                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
                                 struct drm_device *dev = connector->dev;
+                                struct radeon_device *rdev = dev->dev_private;
                                 struct drm_connector *list_connector;
                                 struct radeon_connector *list_radeon_connector;
                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
@@ -788,15 +788,10 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
                                         if (list_radeon_connector->shared_ddc &&
                                             (list_radeon_connector->ddc_bus->rec.i2c_id ==
                                              radeon_connector->ddc_bus->rec.i2c_id)) {
-                                                if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
-                                                        if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
-                                                                kfree(radeon_connector->edid);
-                                                                radeon_connector->edid = NULL;
-                                                                ret = connector_status_disconnected;
-                                                        }
-                                                } else {
-                                                        if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
-                                                            (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
+                                                /* cases where both connectors are digital */
+                                                if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
+                                                        /* hpd is our only option in this case */
+                                                        if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
                                                                 kfree(radeon_connector->edid);
                                                                 radeon_connector->edid = NULL;
                                                                 ret = connector_status_disconnected;
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 37533bec1f25..0fea894fc127 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -226,20 +226,20 @@ void radeon_gtt_location(struct radeon_device *rdev, struct radeon_mc *mc)
 {
         u64 size_af, size_bf;
 
-        size_af = 0xFFFFFFFF - mc->vram_end;
-        size_bf = mc->vram_start;
+        size_af = ((0xFFFFFFFF - mc->vram_end) + mc->gtt_base_align) & ~mc->gtt_base_align;
+        size_bf = mc->vram_start & ~mc->gtt_base_align;
         if (size_bf > size_af) {
                 if (mc->gtt_size > size_bf) {
                         dev_warn(rdev->dev, "limiting GTT\n");
                         mc->gtt_size = size_bf;
                 }
-                mc->gtt_start = mc->vram_start - mc->gtt_size;
+                mc->gtt_start = (mc->vram_start & ~mc->gtt_base_align) - mc->gtt_size;
         } else {
                 if (mc->gtt_size > size_af) {
                         dev_warn(rdev->dev, "limiting GTT\n");
                         mc->gtt_size = size_af;
                 }
-                mc->gtt_start = mc->vram_end + 1;
+                mc->gtt_start = (mc->vram_end + 1 + mc->gtt_base_align) & ~mc->gtt_base_align;
         }
         mc->gtt_end = mc->gtt_start + mc->gtt_size - 1;
         dev_info(rdev->dev, "GTT: %lluM 0x%08llX - 0x%08llX\n",
@@ -415,6 +415,22 @@ static uint32_t cail_reg_read(struct card_info *info, uint32_t reg)
         return r;
 }
 
+static void cail_ioreg_write(struct card_info *info, uint32_t reg, uint32_t val)
+{
+        struct radeon_device *rdev = info->dev->dev_private;
+
+        WREG32_IO(reg*4, val);
+}
+
+static uint32_t cail_ioreg_read(struct card_info *info, uint32_t reg)
+{
+        struct radeon_device *rdev = info->dev->dev_private;
+        uint32_t r;
+
+        r = RREG32_IO(reg*4);
+        return r;
+}
+
 int radeon_atombios_init(struct radeon_device *rdev)
 {
         struct card_info *atom_card_info =
@@ -427,6 +443,15 @@ int radeon_atombios_init(struct radeon_device *rdev)
         atom_card_info->dev = rdev->ddev;
         atom_card_info->reg_read = cail_reg_read;
         atom_card_info->reg_write = cail_reg_write;
+        /* needed for iio ops */
+        if (rdev->rio_mem) {
+                atom_card_info->ioreg_read = cail_ioreg_read;
+                atom_card_info->ioreg_write = cail_ioreg_write;
+        } else {
+                DRM_ERROR("Unable to find PCI I/O BAR; using MMIO for ATOM IIO\n");
+                atom_card_info->ioreg_read = cail_reg_read;
+                atom_card_info->ioreg_write = cail_reg_write;
+        }
         atom_card_info->mc_read = cail_mc_read;
         atom_card_info->mc_write = cail_mc_write;
         atom_card_info->pll_read = cail_pll_read;
@@ -573,7 +598,7 @@ int radeon_device_init(struct radeon_device *rdev,
                        struct pci_dev *pdev,
                        uint32_t flags)
 {
-        int r;
+        int r, i;
         int dma_bits;
 
         rdev->shutdown = false;
@@ -659,6 +684,17 @@ int radeon_device_init(struct radeon_device *rdev,
         DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)rdev->rmmio_base);
         DRM_INFO("register mmio size: %u\n", (unsigned)rdev->rmmio_size);
 
+        /* io port mapping */
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                if (pci_resource_flags(rdev->pdev, i) & IORESOURCE_IO) {
+                        rdev->rio_mem_size = pci_resource_len(rdev->pdev, i);
+                        rdev->rio_mem = pci_iomap(rdev->pdev, i, rdev->rio_mem_size);
+                        break;
+                }
+        }
+        if (rdev->rio_mem == NULL)
+                DRM_ERROR("Unable to find PCI I/O BAR\n");
+
         /* if we have > 1 VGA cards, then disable the radeon VGA resources */
         /* this will fail for cards that aren't VGA class devices, just
          * ignore it */
@@ -701,6 +737,8 @@ void radeon_device_fini(struct radeon_device *rdev)
         destroy_workqueue(rdev->wq);
         vga_switcheroo_unregister_client(rdev->pdev);
         vga_client_register(rdev->pdev, NULL, NULL, NULL);
+        pci_iounmap(rdev->pdev, rdev->rio_mem);
+        rdev->rio_mem = NULL;
         iounmap(rdev->rmmio);
         rdev->rmmio = NULL;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 8154cdf796e4..a68728dbd41d 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -558,15 +558,17 @@ static void radeon_compute_pll_legacy(struct radeon_pll *pll,
                                         current_freq = radeon_div(tmp, ref_div * post_div);
 
                                         if (pll->flags & RADEON_PLL_PREFER_CLOSEST_LOWER) {
-                                                error = freq - current_freq;
-                                                error = error < 0 ? 0xffffffff : error;
+                                                if (freq < current_freq)
+                                                        error = 0xffffffff;
+                                                else
+                                                        error = freq - current_freq;
                                         } else
                                                 error = abs(current_freq - freq);
                                         vco_diff = abs(vco - best_vco);
 
                                         if ((best_vco == 0 && error < best_error) ||
                                             (best_vco != 0 &&
-                                             (error < best_error - 100 ||
+                                             ((best_error > 100 && error < best_error - 100) ||
                                               (abs(error - best_error) < 100 && vco_diff < best_vco_diff)))) {
                                                 best_post_div = post_div;
                                                 best_ref_div = ref_div;
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index ed0ceb3fc40a..6f8a2e572878 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -46,9 +46,10 @@
  * - 2.3.0 - add MSPOS + 3D texture + r500 VAP regs
  * - 2.4.0 - add crtc id query
  * - 2.5.0 - add get accel 2 to work around ddx breakage for evergreen
+ * - 2.6.0 - add tiling config query (r6xx+)
  */
 #define KMS_DRIVER_MAJOR        2
-#define KMS_DRIVER_MINOR        5
+#define KMS_DRIVER_MINOR        6
 #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_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c
index 6a70c0dc7f92..8931c8e78101 100644
--- a/drivers/gpu/drm/radeon/radeon_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_kms.c
@@ -49,7 +49,7 @@ int radeon_driver_unload_kms(struct drm_device *dev)
 int radeon_driver_load_kms(struct drm_device *dev, unsigned long flags)
 {
         struct radeon_device *rdev;
-        int r;
+        int r, acpi_status;
 
         rdev = kzalloc(sizeof(struct radeon_device), GFP_KERNEL);
         if (rdev == NULL) {
@@ -77,6 +77,12 @@ int radeon_driver_load_kms(struct drm_device *dev, unsigned long flags)
                 dev_err(&dev->pdev->dev, "Fatal error during GPU init\n");
                 goto out;
         }
+
+        /* Call ACPI methods */
+        acpi_status = radeon_acpi_init(rdev);
+        if (acpi_status)
+                dev_err(&dev->pdev->dev, "Error during ACPI methods call\n");
+
         /* Again modeset_init should fail only on fatal error
          * otherwise it should provide enough functionalities
          * for shadowfb to run
@@ -128,7 +134,8 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
                 for (i = 0, found = 0; i < rdev->num_crtc; i++) {
                         crtc = (struct drm_crtc *)minfo->crtcs[i];
                         if (crtc && crtc->base.id == value) {
-                                value = i;
+                                struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+                                value = radeon_crtc->crtc_id;
                                 found = 1;
                                 break;
                         }
@@ -141,6 +148,18 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
         case RADEON_INFO_ACCEL_WORKING2:
                 value = rdev->accel_working;
                 break;
+        case RADEON_INFO_TILING_CONFIG:
+                if (rdev->family >= CHIP_CEDAR)
+                        value = rdev->config.evergreen.tile_config;
+                else if (rdev->family >= CHIP_RV770)
+                        value = rdev->config.rv770.tile_config;
+                else if (rdev->family >= CHIP_R600)
+                        value = rdev->config.r600.tile_config;
+                else {
+                        DRM_DEBUG("tiling config is r6xx+ only!\n");
+                        return -EINVAL;
+                }
+                break;
         default:
                 DRM_DEBUG("Invalid request %d\n", info->request);
                 return -EINVAL;
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
index bad77f40a9da..5688a0cf6bbe 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c
@@ -108,6 +108,7 @@ static void radeon_legacy_lvds_dpms(struct drm_encoder *encoder, int mode)
                 udelay(panel_pwr_delay * 1000);
                 WREG32(RADEON_LVDS_GEN_CNTL, lvds_gen_cntl);
                 WREG32_PLL(RADEON_PIXCLKS_CNTL, pixclks_cntl);
+                udelay(panel_pwr_delay * 1000);
                 break;
         }
 
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_tv.c b/drivers/gpu/drm/radeon/radeon_legacy_tv.c
index f2ed27c8055b..032040397743 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_tv.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_tv.c
@@ -642,8 +642,8 @@ void radeon_legacy_tv_mode_set(struct drm_encoder *encoder,
         }
         flicker_removal = (tmp + 500) / 1000;
 
-        if (flicker_removal < 2)
-                flicker_removal = 2;
+        if (flicker_removal < 3)
+                flicker_removal = 3;
         for (i = 0; i < ARRAY_SIZE(SLOPE_limit); ++i) {
                 if (flicker_removal == SLOPE_limit[i])
                         break;
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index d5b9373ce06c..0afd1e62347d 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -110,6 +110,7 @@ int radeon_bo_create(struct radeon_device *rdev, struct drm_gem_object *gobj,
         bo->surface_reg = -1;
         INIT_LIST_HEAD(&bo->list);
 
+retry:
         radeon_ttm_placement_from_domain(bo, domain);
         /* Kernel allocation are uninterruptible */
         mutex_lock(&rdev->vram_mutex);
@@ -118,10 +119,15 @@ int radeon_bo_create(struct radeon_device *rdev, struct drm_gem_object *gobj,
                         &radeon_ttm_bo_destroy);
         mutex_unlock(&rdev->vram_mutex);
         if (unlikely(r != 0)) {
-                if (r != -ERESTARTSYS)
+                if (r != -ERESTARTSYS) {
+                        if (domain == RADEON_GEM_DOMAIN_VRAM) {
+                                domain |= RADEON_GEM_DOMAIN_GTT;
+                                goto retry;
+                        }
                         dev_err(rdev->dev,
                                 "object_init failed for (%lu, 0x%08X)\n",
                                 size, domain);
+                }
                 return r;
         }
         *bo_ptr = bo;
@@ -321,6 +327,7 @@ int radeon_bo_list_validate(struct list_head *head)
 {
         struct radeon_bo_list *lobj;
         struct radeon_bo *bo;
+        u32 domain;
         int r;
 
         list_for_each_entry(lobj, head, list) {
@@ -333,17 +340,19 @@ int radeon_bo_list_validate(struct list_head *head)
         list_for_each_entry(lobj, head, list) {
                 bo = lobj->bo;
                 if (!bo->pin_count) {
-                        if (lobj->wdomain) {
-                                radeon_ttm_placement_from_domain(bo,
-                                                                lobj->wdomain);
-                        } else {
-                                radeon_ttm_placement_from_domain(bo,
-                                                                lobj->rdomain);
-                        }
+                        domain = lobj->wdomain ? lobj->wdomain : lobj->rdomain;
+                        
+                retry:
+                        radeon_ttm_placement_from_domain(bo, domain);
                         r = ttm_bo_validate(&bo->tbo, &bo->placement,
                                                 true, false, false);
-                        if (unlikely(r))
+                        if (unlikely(r)) {
+                                if (r != -ERESTARTSYS && domain == RADEON_GEM_DOMAIN_VRAM) {
+                                        domain |= RADEON_GEM_DOMAIN_GTT;
+                                        goto retry;
+                                }
                                 return r;
+                        }
                 }
                 lobj->gpu_offset = radeon_bo_gpu_offset(bo);
                 lobj->tiling_flags = bo->tiling_flags;
diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c
index 115d26b762cc..ed66062ae9d0 100644
--- a/drivers/gpu/drm/radeon/radeon_pm.c
+++ b/drivers/gpu/drm/radeon/radeon_pm.c
@@ -27,6 +27,8 @@
 #include <linux/acpi.h>
 #endif
 #include <linux/power_supply.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
 
 #define RADEON_IDLE_LOOP_MS 100
 #define RADEON_RECLOCK_DELAY_MS 200
@@ -423,6 +425,82 @@ fail:
 static DEVICE_ATTR(power_profile, S_IRUGO | S_IWUSR, radeon_get_pm_profile, radeon_set_pm_profile);
 static DEVICE_ATTR(power_method, S_IRUGO | S_IWUSR, radeon_get_pm_method, radeon_set_pm_method);
 
+static ssize_t radeon_hwmon_show_temp(struct device *dev,
+                                      struct device_attribute *attr,
+                                      char *buf)
+{
+        struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
+        struct radeon_device *rdev = ddev->dev_private;
+        u32 temp;
+
+        switch (rdev->pm.int_thermal_type) {
+        case THERMAL_TYPE_RV6XX:
+                temp = rv6xx_get_temp(rdev);
+                break;
+        case THERMAL_TYPE_RV770:
+                temp = rv770_get_temp(rdev);
+                break;
+        case THERMAL_TYPE_EVERGREEN:
+                temp = evergreen_get_temp(rdev);
+                break;
+        default:
+                temp = 0;
+                break;
+        }
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", temp);
+}
+
+static ssize_t radeon_hwmon_show_name(struct device *dev,
+                                      struct device_attribute *attr,
+                                      char *buf)
+{
+        return sprintf(buf, "radeon\n");
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, radeon_hwmon_show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(name, S_IRUGO, radeon_hwmon_show_name, NULL, 0);
+
+static struct attribute *hwmon_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_name.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group hwmon_attrgroup = {
+        .attrs = hwmon_attributes,
+};
+
+static void radeon_hwmon_init(struct radeon_device *rdev)
+{
+        int err;
+
+        rdev->pm.int_hwmon_dev = NULL;
+
+        switch (rdev->pm.int_thermal_type) {
+        case THERMAL_TYPE_RV6XX:
+        case THERMAL_TYPE_RV770:
+        case THERMAL_TYPE_EVERGREEN:
+                rdev->pm.int_hwmon_dev = hwmon_device_register(rdev->dev);
+                dev_set_drvdata(rdev->pm.int_hwmon_dev, rdev->ddev);
+                err = sysfs_create_group(&rdev->pm.int_hwmon_dev->kobj,
+                                         &hwmon_attrgroup);
+                if (err)
+                        DRM_ERROR("Unable to create hwmon sysfs file: %d\n", err);
+                break;
+        default:
+                break;
+        }
+}
+
+static void radeon_hwmon_fini(struct radeon_device *rdev)
+{
+        if (rdev->pm.int_hwmon_dev) {
+                sysfs_remove_group(&rdev->pm.int_hwmon_dev->kobj, &hwmon_attrgroup);
+                hwmon_device_unregister(rdev->pm.int_hwmon_dev);
+        }
+}
+
 void radeon_pm_suspend(struct radeon_device *rdev)
 {
         bool flush_wq = false;
@@ -470,6 +548,7 @@ int radeon_pm_init(struct radeon_device *rdev)
         rdev->pm.dynpm_can_downclock = true;
         rdev->pm.current_sclk = rdev->clock.default_sclk;
         rdev->pm.current_mclk = rdev->clock.default_mclk;
+        rdev->pm.int_thermal_type = THERMAL_TYPE_NONE;
 
         if (rdev->bios) {
                 if (rdev->is_atom_bios)
@@ -480,6 +559,8 @@ int radeon_pm_init(struct radeon_device *rdev)
                 radeon_pm_init_profile(rdev);
         }
 
+        /* set up the internal thermal sensor if applicable */
+        radeon_hwmon_init(rdev);
         if (rdev->pm.num_power_states > 1) {
                 /* where's the best place to put these? */
                 ret = device_create_file(rdev->dev, &dev_attr_power_profile);
@@ -535,6 +616,7 @@ void radeon_pm_fini(struct radeon_device *rdev)
 #endif
         }
 
+        radeon_hwmon_fini(rdev);
         if (rdev->pm.i2c_bus)
                 radeon_i2c_destroy(rdev->pm.i2c_bus);
 }
diff --git a/drivers/gpu/drm/radeon/rs400.c b/drivers/gpu/drm/radeon/rs400.c
index 9e4240b3bf0b..ae2b76b9a388 100644
--- a/drivers/gpu/drm/radeon/rs400.c
+++ b/drivers/gpu/drm/radeon/rs400.c
@@ -55,12 +55,6 @@ void rs400_gart_adjust_size(struct radeon_device *rdev)
                 rdev->mc.gtt_size = 32 * 1024 * 1024;
                 return;
         }
-        if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480) {
-                /* FIXME: RS400 & RS480 seems to have issue with GART size
-                 * if 4G of system memory (needs more testing) */
-                rdev->mc.gtt_size = 32 * 1024 * 1024;
-                DRM_ERROR("Forcing to 32M GART size (because of ASIC bug ?)\n");
-        }
 }
 
 void rs400_gart_tlb_flush(struct radeon_device *rdev)
@@ -263,6 +257,7 @@ void rs400_mc_init(struct radeon_device *rdev)
         r100_vram_init_sizes(rdev);
         base = (RREG32(RADEON_NB_TOM) & 0xffff) << 16;
         radeon_vram_location(rdev, &rdev->mc, base);
+        rdev->mc.gtt_base_align = rdev->mc.gtt_size - 1;
         radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
 }
@@ -480,6 +475,8 @@ int rs400_init(struct radeon_device *rdev)
         /* Initialize surface registers */
         radeon_surface_init(rdev);
         /* TODO: disable VGA need to use VGA request */
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
                 if (ASIC_IS_AVIVO(rdev))
diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c
index 5ce3ccc7a423..85cd911952c1 100644
--- a/drivers/gpu/drm/radeon/rs600.c
+++ b/drivers/gpu/drm/radeon/rs600.c
@@ -698,6 +698,7 @@ void rs600_mc_init(struct radeon_device *rdev)
         base = G_000004_MC_FB_START(base) << 16;
         rdev->mc.igp_sideport_enabled = radeon_atombios_sideport_present(rdev);
         radeon_vram_location(rdev, &rdev->mc, base);
+        rdev->mc.gtt_base_align = 0;
         radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
 }
@@ -812,6 +813,13 @@ static int rs600_startup(struct radeon_device *rdev)
                 dev_err(rdev->dev, "failled initializing IB (%d).\n", r);
                 return r;
         }
+
+        r = r600_audio_init(rdev);
+        if (r) {
+                dev_err(rdev->dev, "failed initializing audio\n");
+                return r;
+        }
+
         return 0;
 }
 
@@ -838,6 +846,7 @@ int rs600_resume(struct radeon_device *rdev)
 
 int rs600_suspend(struct radeon_device *rdev)
 {
+        r600_audio_fini(rdev);
         r100_cp_disable(rdev);
         r100_wb_disable(rdev);
         rs600_irq_disable(rdev);
@@ -847,6 +856,7 @@ int rs600_suspend(struct radeon_device *rdev)
 
 void rs600_fini(struct radeon_device *rdev)
 {
+        r600_audio_fini(rdev);
         r100_cp_fini(rdev);
         r100_wb_fini(rdev);
         r100_ib_fini(rdev);
@@ -870,6 +880,8 @@ int rs600_init(struct radeon_device *rdev)
         radeon_scratch_init(rdev);
         /* Initialize surface registers */
         radeon_surface_init(rdev);
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* BIOS */
         if (!radeon_get_bios(rdev)) {
                 if (ASIC_IS_AVIVO(rdev))
diff --git a/drivers/gpu/drm/radeon/rs690.c b/drivers/gpu/drm/radeon/rs690.c
index 5fea094ed8cb..f3a8c9344c64 100644
--- a/drivers/gpu/drm/radeon/rs690.c
+++ b/drivers/gpu/drm/radeon/rs690.c
@@ -162,6 +162,7 @@ void rs690_mc_init(struct radeon_device *rdev)
         rs690_pm_info(rdev);
         rdev->mc.igp_sideport_enabled = radeon_atombios_sideport_present(rdev);
         radeon_vram_location(rdev, &rdev->mc, base);
+        rdev->mc.gtt_base_align = rdev->mc.gtt_size - 1;
         radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
 }
@@ -640,6 +641,13 @@ static int rs690_startup(struct radeon_device *rdev)
                 dev_err(rdev->dev, "failled initializing IB (%d).\n", r);
                 return r;
         }
+
+        r = r600_audio_init(rdev);
+        if (r) {
+                dev_err(rdev->dev, "failed initializing audio\n");
+                return r;
+        }
+
         return 0;
 }
 
@@ -666,6 +674,7 @@ int rs690_resume(struct radeon_device *rdev)
 
 int rs690_suspend(struct radeon_device *rdev)
 {
+        r600_audio_fini(rdev);
         r100_cp_disable(rdev);
         r100_wb_disable(rdev);
         rs600_irq_disable(rdev);
@@ -675,6 +684,7 @@ int rs690_suspend(struct radeon_device *rdev)
 
 void rs690_fini(struct radeon_device *rdev)
 {
+        r600_audio_fini(rdev);
         r100_cp_fini(rdev);
         r100_wb_fini(rdev);
         r100_ib_fini(rdev);
@@ -698,6 +708,8 @@ int rs690_init(struct radeon_device *rdev)
         radeon_scratch_init(rdev);
         /* Initialize surface registers */
         radeon_surface_init(rdev);
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* TODO: disable VGA need to use VGA request */
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
diff --git a/drivers/gpu/drm/radeon/rv515.c b/drivers/gpu/drm/radeon/rv515.c
index 7d9a7b0a180a..b951b8790175 100644
--- a/drivers/gpu/drm/radeon/rv515.c
+++ b/drivers/gpu/drm/radeon/rv515.c
@@ -195,6 +195,7 @@ void rv515_mc_init(struct radeon_device *rdev)
         rv515_vram_get_type(rdev);
         r100_vram_init_sizes(rdev);
         radeon_vram_location(rdev, &rdev->mc, 0);
+        rdev->mc.gtt_base_align = 0;
         if (!(rdev->flags & RADEON_IS_AGP))
                 radeon_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
@@ -468,6 +469,8 @@ int rv515_init(struct radeon_device *rdev)
         /* Initialize surface registers */
         radeon_surface_init(rdev);
         /* TODO: disable VGA need to use VGA request */
+        /* restore some register to sane defaults */
+        r100_restore_sanity(rdev);
         /* BIOS*/
         if (!radeon_get_bios(rdev)) {
                 if (ASIC_IS_AVIVO(rdev))
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index 6a7bf1091971..f1c796810117 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -42,6 +42,21 @@
 static void rv770_gpu_init(struct radeon_device *rdev);
 void rv770_fini(struct radeon_device *rdev);
 
+/* get temperature in millidegrees */
+u32 rv770_get_temp(struct radeon_device *rdev)
+{
+        u32 temp = (RREG32(CG_MULT_THERMAL_STATUS) & ASIC_T_MASK) >>
+                ASIC_T_SHIFT;
+        u32 actual_temp = 0;
+
+        if ((temp >> 9) & 1)
+                actual_temp = 0;
+        else
+                actual_temp = (temp >> 1) & 0xff;
+
+        return actual_temp * 1000;
+}
+
 void rv770_pm_misc(struct radeon_device *rdev)
 {
         int req_ps_idx = rdev->pm.requested_power_state_index;
@@ -189,7 +204,10 @@ static void rv770_mc_program(struct radeon_device *rdev)
                 WREG32((0x2c20 + j), 0x00000000);
                 WREG32((0x2c24 + j), 0x00000000);
         }
-        WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0);
+        /* r7xx hw bug.  Read from HDP_DEBUG1 rather
+         * than writing to HDP_REG_COHERENCY_FLUSH_CNTL
+         */
+        tmp = RREG32(HDP_DEBUG1);
 
         rv515_mc_stop(rdev, &save);
         if (r600_mc_wait_for_idle(rdev)) {
@@ -659,8 +677,9 @@ static void rv770_gpu_init(struct radeon_device *rdev)
                                                                  r600_count_pipe_bits((cc_rb_backend_disable &
                                                                                        R7XX_MAX_BACKENDS_MASK) >> 16)),
                                                                 (cc_rb_backend_disable >> 16));
-        gb_tiling_config |= BACKEND_MAP(backend_map);
 
+        rdev->config.rv770.tile_config = gb_tiling_config;
+        gb_tiling_config |= BACKEND_MAP(backend_map);
 
         WREG32(GB_TILING_CONFIG, gb_tiling_config);
         WREG32(DCP_TILING_CONFIG, (gb_tiling_config & 0xffff));
diff --git a/drivers/gpu/drm/radeon/rv770d.h b/drivers/gpu/drm/radeon/rv770d.h
index 9506f8cb99e0..b7a5a20e81dc 100644
--- a/drivers/gpu/drm/radeon/rv770d.h
+++ b/drivers/gpu/drm/radeon/rv770d.h
@@ -122,12 +122,18 @@
 #define         GUI_ACTIVE                                      (1<<31)
 #define GRBM_STATUS2                                    0x8014
 
+#define CG_MULT_THERMAL_STATUS                          0x740
+#define         ASIC_T(x)                               ((x) << 16)
+#define         ASIC_T_MASK                             0x3FF0000
+#define         ASIC_T_SHIFT                            16
+
 #define HDP_HOST_PATH_CNTL                              0x2C00
 #define HDP_NONSURFACE_BASE                             0x2C04
 #define HDP_NONSURFACE_INFO                             0x2C08
 #define HDP_NONSURFACE_SIZE                             0x2C0C
 #define HDP_REG_COHERENCY_FLUSH_CNTL                    0x54A0
 #define HDP_TILING_CONFIG                               0x2F3C
+#define HDP_DEBUG1                                      0x2F34
 
 #define MC_SHARED_CHMAP                                         0x2004
 #define         NOOFCHAN_SHIFT                                  12
diff --git a/drivers/gpu/drm/sis/sis_drv.c b/drivers/gpu/drm/sis/sis_drv.c
index 4fd1f067d380..776bf9e9ea1a 100644
--- a/drivers/gpu/drm/sis/sis_drv.c
+++ b/drivers/gpu/drm/sis/sis_drv.c
@@ -47,9 +47,8 @@ static int sis_driver_load(struct drm_device *dev, unsigned long chipset)
         dev->dev_private = (void *)dev_priv;
         dev_priv->chipset = chipset;
         ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
-        if (ret) {
+        if (ret)
                 kfree(dev_priv);
-        }
 
         return ret;
 }
diff --git a/drivers/gpu/drm/sis/sis_mm.c b/drivers/gpu/drm/sis/sis_mm.c
index af22111397d8..07d0f2979cac 100644
--- a/drivers/gpu/drm/sis/sis_mm.c
+++ b/drivers/gpu/drm/sis/sis_mm.c
@@ -78,7 +78,7 @@ static unsigned long sis_sman_mm_offset(void *private, void *ref)
 #else /* CONFIG_FB_SIS[_MODULE] */
 
 #define SIS_MM_ALIGN_SHIFT 4
-#define SIS_MM_ALIGN_MASK ( (1 << SIS_MM_ALIGN_SHIFT) - 1)
+#define SIS_MM_ALIGN_MASK ((1 << SIS_MM_ALIGN_SHIFT) - 1)
 
 #endif /* CONFIG_FB_SIS[_MODULE] */
 
@@ -225,9 +225,8 @@ static drm_local_map_t *sis_reg_init(struct drm_device *dev)
                 map = entry->map;
                 if (!map)
                         continue;
-                if (map->type == _DRM_REGISTERS) {
+                if (map->type == _DRM_REGISTERS)
                         return map;
-                }
         }
         return NULL;
 }
@@ -264,10 +263,10 @@ int sis_idle(struct drm_device *dev)
 
         end = jiffies + (DRM_HZ * 3);
 
-        for (i=0; i<4; ++i) {
+        for (i = 0; i < 4; ++i) {
                 do {
                         idle_reg = SIS_READ(0x85cc);
-                } while ( !time_after_eq(jiffies, end) &&
+                } while (!time_after_eq(jiffies, end) &&
                           ((idle_reg & 0x80000000) != 0x80000000));
         }
 
@@ -301,7 +300,7 @@ void sis_lastclose(struct drm_device *dev)
         mutex_unlock(&dev->struct_mutex);
 }
 
-void sis_reclaim_buffers_locked(struct drm_device * dev,
+void sis_reclaim_buffers_locked(struct drm_device *dev,
                                 struct drm_file *file_priv)
 {
         drm_sis_private_t *dev_priv = dev->dev_private;
@@ -312,9 +311,8 @@ void sis_reclaim_buffers_locked(struct drm_device * dev,
                 return;
         }
 
-        if (dev->driver->dma_quiescent) {
+        if (dev->driver->dma_quiescent)
                 dev->driver->dma_quiescent(dev);
-        }
 
         drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)file_priv);
         mutex_unlock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc.c b/drivers/gpu/drm/ttm/ttm_page_alloc.c
index b1d67dc973dc..ca904799f018 100644
--- a/drivers/gpu/drm/ttm/ttm_page_alloc.c
+++ b/drivers/gpu/drm/ttm/ttm_page_alloc.c
@@ -40,11 +40,13 @@
 #include <linux/slab.h>
 
 #include <asm/atomic.h>
-#include <asm/agp.h>
 
 #include "ttm/ttm_bo_driver.h"
 #include "ttm/ttm_page_alloc.h"
 
+#ifdef TTM_HAS_AGP
+#include <asm/agp.h>
+#endif
 
 #define NUM_PAGES_TO_ALLOC              (PAGE_SIZE/sizeof(struct page *))
 #define SMALL_ALLOCATION                16
@@ -392,7 +394,7 @@ static int ttm_pool_get_num_unused_pages(void)
 /**
  * Callback for mm to request pool to reduce number of page held.
  */
-static int ttm_pool_mm_shrink(int shrink_pages, gfp_t gfp_mask)
+static int ttm_pool_mm_shrink(struct shrinker *shrink, int shrink_pages, gfp_t gfp_mask)
 {
         static atomic_t start_pool = ATOMIC_INIT(0);
         unsigned i;
diff --git a/drivers/gpu/drm/via/via_dma.c b/drivers/gpu/drm/via/via_dma.c
index bfb92d283260..68dda74a50ae 100644
--- a/drivers/gpu/drm/via/via_dma.c
+++ b/drivers/gpu/drm/via/via_dma.c
@@ -58,28 +58,29 @@
         *((uint32_t *)(vb)) = ((nReg) >> 2) | HALCYON_HEADER1;  \
         *((uint32_t *)(vb) + 1) = (nData);                      \
         vb = ((uint32_t *)vb) + 2;                              \
-        dev_priv->dma_low +=8;                                  \
+        dev_priv->dma_low += 8;                                 \
 }
 
 #define via_flush_write_combine() DRM_MEMORYBARRIER()
 
-#define VIA_OUT_RING_QW(w1,w2)                  \
+#define VIA_OUT_RING_QW(w1, w2) do {            \
         *vb++ = (w1);                           \
         *vb++ = (w2);                           \
-        dev_priv->dma_low += 8;
+        dev_priv->dma_low += 8;                 \
+} while (0)
 
-static void via_cmdbuf_start(drm_via_private_t * dev_priv);
-static void via_cmdbuf_pause(drm_via_private_t * dev_priv);
-static void via_cmdbuf_reset(drm_via_private_t * dev_priv);
-static void via_cmdbuf_rewind(drm_via_private_t * dev_priv);
-static int via_wait_idle(drm_via_private_t * dev_priv);
-static void via_pad_cache(drm_via_private_t * dev_priv, int qwords);
+static void via_cmdbuf_start(drm_via_private_t *dev_priv);
+static void via_cmdbuf_pause(drm_via_private_t *dev_priv);
+static void via_cmdbuf_reset(drm_via_private_t *dev_priv);
+static void via_cmdbuf_rewind(drm_via_private_t *dev_priv);
+static int via_wait_idle(drm_via_private_t *dev_priv);
+static void via_pad_cache(drm_via_private_t *dev_priv, int qwords);
 
 /*
  * Free space in command buffer.
  */
 
-static uint32_t via_cmdbuf_space(drm_via_private_t * dev_priv)
+static uint32_t via_cmdbuf_space(drm_via_private_t *dev_priv)
 {
         uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
         uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
@@ -93,7 +94,7 @@ static uint32_t via_cmdbuf_space(drm_via_private_t * dev_priv)
  * How much does the command regulator lag behind?
  */
 
-static uint32_t via_cmdbuf_lag(drm_via_private_t * dev_priv)
+static uint32_t via_cmdbuf_lag(drm_via_private_t *dev_priv)
 {
         uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
         uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
@@ -108,7 +109,7 @@ static uint32_t via_cmdbuf_lag(drm_via_private_t * dev_priv)
  */
 
 static inline int
-via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
+via_cmdbuf_wait(drm_via_private_t *dev_priv, unsigned int size)
 {
         uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
         uint32_t cur_addr, hw_addr, next_addr;
@@ -146,14 +147,13 @@ static inline uint32_t *via_check_dma(drm_via_private_t * dev_priv,
             dev_priv->dma_high) {
                 via_cmdbuf_rewind(dev_priv);
         }
-        if (via_cmdbuf_wait(dev_priv, size) != 0) {
+        if (via_cmdbuf_wait(dev_priv, size) != 0)
                 return NULL;
-        }
 
         return (uint32_t *) (dev_priv->dma_ptr + dev_priv->dma_low);
 }
 
-int via_dma_cleanup(struct drm_device * dev)
+int via_dma_cleanup(struct drm_device *dev)
 {
         if (dev->dev_private) {
                 drm_via_private_t *dev_priv =
@@ -171,9 +171,9 @@ int via_dma_cleanup(struct drm_device * dev)
         return 0;
 }
 
-static int via_initialize(struct drm_device * dev,
-                          drm_via_private_t * dev_priv,
-                          drm_via_dma_init_t * init)
+static int via_initialize(struct drm_device *dev,
+                          drm_via_private_t *dev_priv,
+                          drm_via_dma_init_t *init)
 {
         if (!dev_priv || !dev_priv->mmio) {
                 DRM_ERROR("via_dma_init called before via_map_init\n");
@@ -258,7 +258,7 @@ static int via_dma_init(struct drm_device *dev, void *data, struct drm_file *fil
         return retcode;
 }
 
-static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t * cmd)
+static int via_dispatch_cmdbuffer(struct drm_device *dev, drm_via_cmdbuffer_t *cmd)
 {
         drm_via_private_t *dev_priv;
         uint32_t *vb;
@@ -271,9 +271,8 @@ static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t *
                 return -EFAULT;
         }
 
-        if (cmd->size > VIA_PCI_BUF_SIZE) {
+        if (cmd->size > VIA_PCI_BUF_SIZE)
                 return -ENOMEM;
-        }
 
         if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
                 return -EFAULT;
@@ -291,9 +290,8 @@ static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t *
         }
 
         vb = via_check_dma(dev_priv, (cmd->size < 0x100) ? 0x102 : cmd->size);
-        if (vb == NULL) {
+        if (vb == NULL)
                 return -EAGAIN;
-        }
 
         memcpy(vb, dev_priv->pci_buf, cmd->size);
 
@@ -311,13 +309,12 @@ static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t *
         return 0;
 }
 
-int via_driver_dma_quiescent(struct drm_device * dev)
+int via_driver_dma_quiescent(struct drm_device *dev)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
 
-        if (!via_wait_idle(dev_priv)) {
+        if (!via_wait_idle(dev_priv))
                 return -EBUSY;
-        }
         return 0;
 }
 
@@ -339,22 +336,17 @@ static int via_cmdbuffer(struct drm_device *dev, void *data, struct drm_file *fi
         DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size);
 
         ret = via_dispatch_cmdbuffer(dev, cmdbuf);
-        if (ret) {
-                return ret;
-        }
-
-        return 0;
+        return ret;
 }
 
-static int via_dispatch_pci_cmdbuffer(struct drm_device * dev,
-                                      drm_via_cmdbuffer_t * cmd)
+static int via_dispatch_pci_cmdbuffer(struct drm_device *dev,
+                                      drm_via_cmdbuffer_t *cmd)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
         int ret;
 
-        if (cmd->size > VIA_PCI_BUF_SIZE) {
+        if (cmd->size > VIA_PCI_BUF_SIZE)
                 return -ENOMEM;
-        }
         if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
                 return -EFAULT;
 
@@ -380,19 +372,14 @@ static int via_pci_cmdbuffer(struct drm_device *dev, void *data, struct drm_file
         DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size);
 
         ret = via_dispatch_pci_cmdbuffer(dev, cmdbuf);
-        if (ret) {
-                return ret;
-        }
-
-        return 0;
+        return ret;
 }
 
-static inline uint32_t *via_align_buffer(drm_via_private_t * dev_priv,
+static inline uint32_t *via_align_buffer(drm_via_private_t *dev_priv,
                                          uint32_t * vb, int qw_count)
 {
-        for (; qw_count > 0; --qw_count) {
+        for (; qw_count > 0; --qw_count)
                 VIA_OUT_RING_QW(HC_DUMMY, HC_DUMMY);
-        }
         return vb;
 }
 
@@ -401,7 +388,7 @@ static inline uint32_t *via_align_buffer(drm_via_private_t * dev_priv,
  *
  * Returns virtual pointer to ring buffer.
  */
-static inline uint32_t *via_get_dma(drm_via_private_t * dev_priv)
+static inline uint32_t *via_get_dma(drm_via_private_t *dev_priv)
 {
         return (uint32_t *) (dev_priv->dma_ptr + dev_priv->dma_low);
 }
@@ -411,18 +398,18 @@ static inline uint32_t *via_get_dma(drm_via_private_t * dev_priv)
  * modifying the pause address stored in the buffer itself. If
  * the regulator has already paused, restart it.
  */
-static int via_hook_segment(drm_via_private_t * dev_priv,
+static int via_hook_segment(drm_via_private_t *dev_priv,
                             uint32_t pause_addr_hi, uint32_t pause_addr_lo,
                             int no_pci_fire)
 {
         int paused, count;
         volatile uint32_t *paused_at = dev_priv->last_pause_ptr;
-        uint32_t reader,ptr;
+        uint32_t reader, ptr;
         uint32_t diff;
 
         paused = 0;
         via_flush_write_combine();
-        (void) *(volatile uint32_t *)(via_get_dma(dev_priv) -1);
+        (void) *(volatile uint32_t *)(via_get_dma(dev_priv) - 1);
 
         *paused_at = pause_addr_lo;
         via_flush_write_combine();
@@ -435,7 +422,7 @@ static int via_hook_segment(drm_via_private_t * dev_priv,
         dev_priv->last_pause_ptr = via_get_dma(dev_priv) - 1;
 
         /*
-         * If there is a possibility that the command reader will 
+         * If there is a possibility that the command reader will
          * miss the new pause address and pause on the old one,
          * In that case we need to program the new start address
          * using PCI.
@@ -443,9 +430,9 @@ static int via_hook_segment(drm_via_private_t * dev_priv,
 
         diff = (uint32_t) (ptr - reader) - dev_priv->dma_diff;
         count = 10000000;
-        while(diff == 0 && count--) {
+        while (diff == 0 && count--) {
                 paused = (VIA_READ(0x41c) & 0x80000000);
-                if (paused) 
+                if (paused)
                         break;
                 reader = *(dev_priv->hw_addr_ptr);
                 diff = (uint32_t) (ptr - reader) - dev_priv->dma_diff;
@@ -477,7 +464,7 @@ static int via_hook_segment(drm_via_private_t * dev_priv,
         return paused;
 }
 
-static int via_wait_idle(drm_via_private_t * dev_priv)
+static int via_wait_idle(drm_via_private_t *dev_priv)
 {
         int count = 10000000;
 
@@ -491,9 +478,9 @@ static int via_wait_idle(drm_via_private_t * dev_priv)
         return count;
 }
 
-static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
-                               uint32_t addr, uint32_t * cmd_addr_hi,
-                               uint32_t * cmd_addr_lo, int skip_wait)
+static uint32_t *via_align_cmd(drm_via_private_t *dev_priv, uint32_t cmd_type,
+                               uint32_t addr, uint32_t *cmd_addr_hi,
+                               uint32_t *cmd_addr_lo, int skip_wait)
 {
         uint32_t agp_base;
         uint32_t cmd_addr, addr_lo, addr_hi;
@@ -521,7 +508,7 @@ static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
         return vb;
 }
 
-static void via_cmdbuf_start(drm_via_private_t * dev_priv)
+static void via_cmdbuf_start(drm_via_private_t *dev_priv)
 {
         uint32_t pause_addr_lo, pause_addr_hi;
         uint32_t start_addr, start_addr_lo;
@@ -580,7 +567,7 @@ static void via_cmdbuf_start(drm_via_private_t * dev_priv)
         dev_priv->dma_diff = ptr - reader;
 }
 
-static void via_pad_cache(drm_via_private_t * dev_priv, int qwords)
+static void via_pad_cache(drm_via_private_t *dev_priv, int qwords)
 {
         uint32_t *vb;
 
@@ -590,7 +577,7 @@ static void via_pad_cache(drm_via_private_t * dev_priv, int qwords)
         via_align_buffer(dev_priv, vb, qwords);
 }
 
-static inline void via_dummy_bitblt(drm_via_private_t * dev_priv)
+static inline void via_dummy_bitblt(drm_via_private_t *dev_priv)
 {
         uint32_t *vb = via_get_dma(dev_priv);
         SetReg2DAGP(0x0C, (0 | (0 << 16)));
@@ -598,7 +585,7 @@ static inline void via_dummy_bitblt(drm_via_private_t * dev_priv)
         SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xAA000000);
 }
 
-static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
+static void via_cmdbuf_jump(drm_via_private_t *dev_priv)
 {
         uint32_t agp_base;
         uint32_t pause_addr_lo, pause_addr_hi;
@@ -617,9 +604,8 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
          */
 
         dev_priv->dma_low = 0;
-        if (via_cmdbuf_wait(dev_priv, CMDBUF_ALIGNMENT_SIZE) != 0) {
+        if (via_cmdbuf_wait(dev_priv, CMDBUF_ALIGNMENT_SIZE) != 0)
                 DRM_ERROR("via_cmdbuf_jump failed\n");
-        }
 
         via_dummy_bitblt(dev_priv);
         via_dummy_bitblt(dev_priv);
@@ -657,12 +643,12 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
 }
 
 
-static void via_cmdbuf_rewind(drm_via_private_t * dev_priv)
+static void via_cmdbuf_rewind(drm_via_private_t *dev_priv)
 {
         via_cmdbuf_jump(dev_priv);
 }
 
-static void via_cmdbuf_flush(drm_via_private_t * dev_priv, uint32_t cmd_type)
+static void via_cmdbuf_flush(drm_via_private_t *dev_priv, uint32_t cmd_type)
 {
         uint32_t pause_addr_lo, pause_addr_hi;
 
@@ -670,12 +656,12 @@ static void via_cmdbuf_flush(drm_via_private_t * dev_priv, uint32_t cmd_type)
         via_hook_segment(dev_priv, pause_addr_hi, pause_addr_lo, 0);
 }
 
-static void via_cmdbuf_pause(drm_via_private_t * dev_priv)
+static void via_cmdbuf_pause(drm_via_private_t *dev_priv)
 {
         via_cmdbuf_flush(dev_priv, HC_HAGPBpID_PAUSE);
 }
 
-static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
+static void via_cmdbuf_reset(drm_via_private_t *dev_priv)
 {
         via_cmdbuf_flush(dev_priv, HC_HAGPBpID_STOP);
         via_wait_idle(dev_priv);
@@ -708,9 +694,8 @@ static int via_cmdbuf_size(struct drm_device *dev, void *data, struct drm_file *
         case VIA_CMDBUF_SPACE:
                 while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz->size)
                        && --count) {
-                        if (!d_siz->wait) {
+                        if (!d_siz->wait)
                                 break;
-                        }
                 }
                 if (!count) {
                         DRM_ERROR("VIA_CMDBUF_SPACE timed out.\n");
@@ -720,9 +705,8 @@ static int via_cmdbuf_size(struct drm_device *dev, void *data, struct drm_file *
         case VIA_CMDBUF_LAG:
                 while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz->size)
                        && --count) {
-                        if (!d_siz->wait) {
+                        if (!d_siz->wait)
                                 break;
-                        }
                 }
                 if (!count) {
                         DRM_ERROR("VIA_CMDBUF_LAG timed out.\n");
diff --git a/drivers/gpu/drm/via/via_dmablit.c b/drivers/gpu/drm/via/via_dmablit.c
index 4c54f043068e..9b5b4d9dd62c 100644
--- a/drivers/gpu/drm/via/via_dmablit.c
+++ b/drivers/gpu/drm/via/via_dmablit.c
@@ -70,7 +70,7 @@ via_unmap_blit_from_device(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
                 descriptor_this_page;
         dma_addr_t next = vsg->chain_start;
 
-        while(num_desc--) {
+        while (num_desc--) {
                 if (descriptor_this_page-- == 0) {
                         cur_descriptor_page--;
                         descriptor_this_page = vsg->descriptors_per_page - 1;
@@ -174,19 +174,19 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
         struct page *page;
         int i;
 
-        switch(vsg->state) {
+        switch (vsg->state) {
         case dr_via_device_mapped:
                 via_unmap_blit_from_device(pdev, vsg);
         case dr_via_desc_pages_alloc:
-                for (i=0; i<vsg->num_desc_pages; ++i) {
+                for (i = 0; i < vsg->num_desc_pages; ++i) {
                         if (vsg->desc_pages[i] != NULL)
-                          free_page((unsigned long)vsg->desc_pages[i]);
+                                free_page((unsigned long)vsg->desc_pages[i]);
                 }
                 kfree(vsg->desc_pages);
         case dr_via_pages_locked:
-                for (i=0; i<vsg->num_pages; ++i) {
-                        if ( NULL != (page = vsg->pages[i])) {
-                                if (! PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction))
+                for (i = 0; i < vsg->num_pages; ++i) {
+                        if (NULL != (page = vsg->pages[i])) {
+                                if (!PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction))
                                         SetPageDirty(page);
                                 page_cache_release(page);
                         }
@@ -232,7 +232,7 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg,  drm_via_dmablit_t *xfer)
 {
         int ret;
         unsigned long first_pfn = VIA_PFN(xfer->mem_addr);
-        vsg->num_pages = VIA_PFN(xfer->mem_addr + (xfer->num_lines * xfer->mem_stride -1)) -
+        vsg->num_pages = VIA_PFN(xfer->mem_addr + (xfer->num_lines * xfer->mem_stride - 1)) -
                 first_pfn + 1;
 
         if (NULL == (vsg->pages = vmalloc(sizeof(struct page *) * vsg->num_pages)))
@@ -268,7 +268,7 @@ via_alloc_desc_pages(drm_via_sg_info_t *vsg)
 {
         int i;
 
-        vsg->descriptors_per_page = PAGE_SIZE / sizeof( drm_via_descriptor_t);
+        vsg->descriptors_per_page = PAGE_SIZE / sizeof(drm_via_descriptor_t);
         vsg->num_desc_pages = (vsg->num_desc + vsg->descriptors_per_page - 1) /
                 vsg->descriptors_per_page;
 
@@ -276,7 +276,7 @@ via_alloc_desc_pages(drm_via_sg_info_t *vsg)
                 return -ENOMEM;
 
         vsg->state = dr_via_desc_pages_alloc;
-        for (i=0; i<vsg->num_desc_pages; ++i) {
+        for (i = 0; i < vsg->num_desc_pages; ++i) {
                 if (NULL == (vsg->desc_pages[i] =
                              (drm_via_descriptor_t *) __get_free_page(GFP_KERNEL)))
                         return -ENOMEM;
@@ -318,21 +318,20 @@ via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
         drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
         int cur;
         int done_transfer;
-        unsigned long irqsave=0;
+        unsigned long irqsave = 0;
         uint32_t status = 0;
 
         DRM_DEBUG("DMA blit handler called. engine = %d, from_irq = %d, blitq = 0x%lx\n",
                   engine, from_irq, (unsigned long) blitq);
 
-        if (from_irq) {
+        if (from_irq)
                 spin_lock(&blitq->blit_lock);
-        } else {
+        else
                 spin_lock_irqsave(&blitq->blit_lock, irqsave);
-        }
 
         done_transfer = blitq->is_active &&
-          (( status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) & VIA_DMA_CSR_TD);
-        done_transfer = done_transfer || ( blitq->aborting && !(status & VIA_DMA_CSR_DE));
+          ((status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) & VIA_DMA_CSR_TD);
+        done_transfer = done_transfer || (blitq->aborting && !(status & VIA_DMA_CSR_DE));
 
         cur = blitq->cur;
         if (done_transfer) {
@@ -377,18 +376,16 @@ via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
                         if (!timer_pending(&blitq->poll_timer))
                                 mod_timer(&blitq->poll_timer, jiffies + 1);
                 } else {
-                        if (timer_pending(&blitq->poll_timer)) {
+                        if (timer_pending(&blitq->poll_timer))
                                 del_timer(&blitq->poll_timer);
-                        }
                         via_dmablit_engine_off(dev, engine);
                 }
         }
 
-        if (from_irq) {
+        if (from_irq)
                 spin_unlock(&blitq->blit_lock);
-        } else {
+        else
                 spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
-        }
 }
 
 
@@ -414,10 +411,9 @@ via_dmablit_active(drm_via_blitq_t *blitq, int engine, uint32_t handle, wait_que
                 ((blitq->cur_blit_handle - handle) <= (1 << 23));
 
         if (queue && active) {
-                slot = handle - blitq->done_blit_handle + blitq->cur -1;
-                if (slot >= VIA_NUM_BLIT_SLOTS) {
+                slot = handle - blitq->done_blit_handle + blitq->cur - 1;
+                if (slot >= VIA_NUM_BLIT_SLOTS)
                         slot -= VIA_NUM_BLIT_SLOTS;
-                }
                 *queue = blitq->blit_queue + slot;
         }
 
@@ -506,12 +502,12 @@ via_dmablit_workqueue(struct work_struct *work)
         int cur_released;
 
 
-        DRM_DEBUG("Workqueue task called for blit engine %ld\n",(unsigned long)
+        DRM_DEBUG("Workqueue task called for blit engine %ld\n", (unsigned long)
                   (blitq - ((drm_via_private_t *)dev->dev_private)->blit_queues));
 
         spin_lock_irqsave(&blitq->blit_lock, irqsave);
 
-        while(blitq->serviced != blitq->cur) {
+        while (blitq->serviced != blitq->cur) {
 
                 cur_released = blitq->serviced++;
 
@@ -545,13 +541,13 @@ via_dmablit_workqueue(struct work_struct *work)
 void
 via_init_dmablit(struct drm_device *dev)
 {
-        int i,j;
+        int i, j;
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
         drm_via_blitq_t *blitq;
 
         pci_set_master(dev->pdev);
 
-        for (i=0; i< VIA_NUM_BLIT_ENGINES; ++i) {
+        for (i = 0; i < VIA_NUM_BLIT_ENGINES; ++i) {
                 blitq = dev_priv->blit_queues + i;
                 blitq->dev = dev;
                 blitq->cur_blit_handle = 0;
@@ -564,9 +560,8 @@ via_init_dmablit(struct drm_device *dev)
                 blitq->is_active = 0;
                 blitq->aborting = 0;
                 spin_lock_init(&blitq->blit_lock);
-                for (j=0; j<VIA_NUM_BLIT_SLOTS; ++j) {
+                for (j = 0; j < VIA_NUM_BLIT_SLOTS; ++j)
                         DRM_INIT_WAITQUEUE(blitq->blit_queue + j);
-                }
                 DRM_INIT_WAITQUEUE(&blitq->busy_queue);
                 INIT_WORK(&blitq->wq, via_dmablit_workqueue);
                 setup_timer(&blitq->poll_timer, via_dmablit_timer,
@@ -685,18 +680,17 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
 static int
 via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
 {
-        int ret=0;
+        int ret = 0;
         unsigned long irqsave;
 
         DRM_DEBUG("Num free is %d\n", blitq->num_free);
         spin_lock_irqsave(&blitq->blit_lock, irqsave);
-        while(blitq->num_free == 0) {
+        while (blitq->num_free == 0) {
                 spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 
                 DRM_WAIT_ON(ret, blitq->busy_queue, DRM_HZ, blitq->num_free > 0);
-                if (ret) {
+                if (ret)
                         return (-EINTR == ret) ? -EAGAIN : ret;
-                }
 
                 spin_lock_irqsave(&blitq->blit_lock, irqsave);
         }
@@ -719,7 +713,7 @@ via_dmablit_release_slot(drm_via_blitq_t *blitq)
         spin_lock_irqsave(&blitq->blit_lock, irqsave);
         blitq->num_free++;
         spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
-        DRM_WAKEUP( &blitq->busy_queue );
+        DRM_WAKEUP(&blitq->busy_queue);
 }
 
 /*
@@ -744,9 +738,8 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
 
         engine = (xfer->to_fb) ? 0 : 1;
         blitq = dev_priv->blit_queues + engine;
-        if (0 != (ret = via_dmablit_grab_slot(blitq, engine))) {
+        if (0 != (ret = via_dmablit_grab_slot(blitq, engine)))
                 return ret;
-        }
         if (NULL == (vsg = kmalloc(sizeof(*vsg), GFP_KERNEL))) {
                 via_dmablit_release_slot(blitq);
                 return -ENOMEM;
@@ -780,7 +773,7 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
  */
 
 int
-via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_priv )
+via_dma_blit_sync(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
         drm_via_blitsync_t *sync = data;
         int err;
@@ -804,7 +797,7 @@ via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_pri
  */
 
 int
-via_dma_blit( struct drm_device *dev, void *data, struct drm_file *file_priv )
+via_dma_blit(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
         drm_via_dmablit_t *xfer = data;
         int err;
diff --git a/drivers/gpu/drm/via/via_dmablit.h b/drivers/gpu/drm/via/via_dmablit.h
index 7408a547a036..9b662a327cef 100644
--- a/drivers/gpu/drm/via/via_dmablit.h
+++ b/drivers/gpu/drm/via/via_dmablit.h
@@ -45,12 +45,12 @@ typedef struct _drm_via_sg_info {
         int num_desc;
         enum dma_data_direction direction;
         unsigned char *bounce_buffer;
-        dma_addr_t chain_start;
+        dma_addr_t chain_start;
         uint32_t free_on_sequence;
-        unsigned int descriptors_per_page;
+        unsigned int descriptors_per_page;
         int aborted;
         enum {
-                dr_via_device_mapped,
+                dr_via_device_mapped,
                 dr_via_desc_pages_alloc,
                 dr_via_pages_locked,
                 dr_via_pages_alloc,
@@ -68,7 +68,7 @@ typedef struct _drm_via_blitq {
         unsigned num_free;
         unsigned num_outstanding;
         unsigned long end;
-        int aborting;
+        int aborting;
         int is_active;
         drm_via_sg_info_t *blits[VIA_NUM_BLIT_SLOTS];
         spinlock_t blit_lock;
diff --git a/drivers/gpu/drm/via/via_drv.h b/drivers/gpu/drm/via/via_drv.h
index cafcb844a223..9cf87d912325 100644
--- a/drivers/gpu/drm/via/via_drv.h
+++ b/drivers/gpu/drm/via/via_drv.h
@@ -107,9 +107,9 @@ enum via_family {
 #define VIA_BASE ((dev_priv->mmio))
 
 #define VIA_READ(reg)           DRM_READ32(VIA_BASE, reg)
-#define VIA_WRITE(reg,val)      DRM_WRITE32(VIA_BASE, reg, val)
+#define VIA_WRITE(reg, val)     DRM_WRITE32(VIA_BASE, reg, val)
 #define VIA_READ8(reg)          DRM_READ8(VIA_BASE, reg)
-#define VIA_WRITE8(reg,val)     DRM_WRITE8(VIA_BASE, reg, val)
+#define VIA_WRITE8(reg, val)    DRM_WRITE8(VIA_BASE, reg, val)
 
 extern struct drm_ioctl_desc via_ioctls[];
 extern int via_max_ioctl;
@@ -121,28 +121,28 @@ extern int via_agp_init(struct drm_device *dev, void *data, struct drm_file *fil
 extern int via_map_init(struct drm_device *dev, void *data, struct drm_file *file_priv);
 extern int via_decoder_futex(struct drm_device *dev, void *data, struct drm_file *file_priv);
 extern int via_wait_irq(struct drm_device *dev, void *data, struct drm_file *file_priv);
-extern int via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_priv );
-extern int via_dma_blit( struct drm_device *dev, void *data, struct drm_file *file_priv );
+extern int via_dma_blit_sync(struct drm_device *dev, void *data, struct drm_file *file_priv);
+extern int via_dma_blit(struct drm_device *dev, void *data, struct drm_file *file_priv);
 
 extern int via_driver_load(struct drm_device *dev, unsigned long chipset);
 extern int via_driver_unload(struct drm_device *dev);
 
-extern int via_init_context(struct drm_device * dev, int context);
-extern int via_final_context(struct drm_device * dev, int context);
+extern int via_init_context(struct drm_device *dev, int context);
+extern int via_final_context(struct drm_device *dev, int context);
 
-extern int via_do_cleanup_map(struct drm_device * dev);
+extern int via_do_cleanup_map(struct drm_device *dev);
 extern u32 via_get_vblank_counter(struct drm_device *dev, int crtc);
 extern int via_enable_vblank(struct drm_device *dev, int crtc);
 extern void via_disable_vblank(struct drm_device *dev, int crtc);
 
 extern irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS);
-extern void via_driver_irq_preinstall(struct drm_device * dev);
+extern void via_driver_irq_preinstall(struct drm_device *dev);
 extern int via_driver_irq_postinstall(struct drm_device *dev);
-extern void via_driver_irq_uninstall(struct drm_device * dev);
+extern void via_driver_irq_uninstall(struct drm_device *dev);
 
-extern int via_dma_cleanup(struct drm_device * dev);
+extern int via_dma_cleanup(struct drm_device *dev);
 extern void via_init_command_verifier(void);
-extern int via_driver_dma_quiescent(struct drm_device * dev);
+extern int via_driver_dma_quiescent(struct drm_device *dev);
 extern void via_init_futex(drm_via_private_t *dev_priv);
 extern void via_cleanup_futex(drm_via_private_t *dev_priv);
 extern void via_release_futex(drm_via_private_t *dev_priv, int context);
diff --git a/drivers/gpu/drm/via/via_irq.c b/drivers/gpu/drm/via/via_irq.c
index 34079f251cd4..d391f48ef87a 100644
--- a/drivers/gpu/drm/via/via_irq.c
+++ b/drivers/gpu/drm/via/via_irq.c
@@ -141,11 +141,10 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
                         atomic_inc(&cur_irq->irq_received);
                         DRM_WAKEUP(&cur_irq->irq_queue);
                         handled = 1;
-                        if (dev_priv->irq_map[drm_via_irq_dma0_td] == i) {
+                        if (dev_priv->irq_map[drm_via_irq_dma0_td] == i)
                                 via_dmablit_handler(dev, 0, 1);
-                        } else if (dev_priv->irq_map[drm_via_irq_dma1_td] == i) {
+                        else if (dev_priv->irq_map[drm_via_irq_dma1_td] == i)
                                 via_dmablit_handler(dev, 1, 1);
-                        }
                 }
                 cur_irq++;
         }
@@ -160,7 +159,7 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
                 return IRQ_NONE;
 }
 
-static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t * dev_priv)
+static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t *dev_priv)
 {
         u32 status;
 
@@ -207,7 +206,7 @@ void via_disable_vblank(struct drm_device *dev, int crtc)
 }
 
 static int
-via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequence,
+via_driver_irq_wait(struct drm_device *dev, unsigned int irq, int force_sequence,
                     unsigned int *sequence)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -260,7 +259,7 @@ via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequenc
  * drm_dma.h hooks
  */
 
-void via_driver_irq_preinstall(struct drm_device * dev)
+void via_driver_irq_preinstall(struct drm_device *dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
@@ -329,7 +328,7 @@ int via_driver_irq_postinstall(struct drm_device *dev)
         return 0;
 }
 
-void via_driver_irq_uninstall(struct drm_device * dev)
+void via_driver_irq_uninstall(struct drm_device *dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
diff --git a/drivers/gpu/drm/via/via_map.c b/drivers/gpu/drm/via/via_map.c
index 6e6f91591639..6cca9a709f7a 100644
--- a/drivers/gpu/drm/via/via_map.c
+++ b/drivers/gpu/drm/via/via_map.c
@@ -25,7 +25,7 @@
 #include "via_drm.h"
 #include "via_drv.h"
 
-static int via_do_init_map(struct drm_device * dev, drm_via_init_t * init)
+static int via_do_init_map(struct drm_device *dev, drm_via_init_t *init)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
 
@@ -68,7 +68,7 @@ static int via_do_init_map(struct drm_device * dev, drm_via_init_t * init)
         return 0;
 }
 
-int via_do_cleanup_map(struct drm_device * dev)
+int via_do_cleanup_map(struct drm_device *dev)
 {
         via_dma_cleanup(dev);
 
diff --git a/drivers/gpu/drm/via/via_mm.c b/drivers/gpu/drm/via/via_mm.c
index f694cb5ededc..6cc2dadae3ef 100644
--- a/drivers/gpu/drm/via/via_mm.c
+++ b/drivers/gpu/drm/via/via_mm.c
@@ -31,7 +31,7 @@
 #include "drm_sman.h"
 
 #define VIA_MM_ALIGN_SHIFT 4
-#define VIA_MM_ALIGN_MASK ( (1 << VIA_MM_ALIGN_SHIFT) - 1)
+#define VIA_MM_ALIGN_MASK ((1 << VIA_MM_ALIGN_SHIFT) - 1)
 
 int via_agp_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
@@ -172,7 +172,7 @@ int via_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
 }
 
 
-void via_reclaim_buffers_locked(struct drm_device * dev,
+void via_reclaim_buffers_locked(struct drm_device *dev,
                                 struct drm_file *file_priv)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
@@ -183,9 +183,8 @@ void via_reclaim_buffers_locked(struct drm_device * dev,
                 return;
         }
 
-        if (dev->driver->dma_quiescent) {
+        if (dev->driver->dma_quiescent)
                 dev->driver->dma_quiescent(dev);
-        }
 
         drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)file_priv);
         mutex_unlock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/via/via_verifier.c b/drivers/gpu/drm/via/via_verifier.c
index 46a579198747..48957b856d41 100644
--- a/drivers/gpu/drm/via/via_verifier.c
+++ b/drivers/gpu/drm/via/via_verifier.c
@@ -235,7 +235,7 @@ static hazard_t table2[256];
 static hazard_t table3[256];
 
 static __inline__ int
-eat_words(const uint32_t ** buf, const uint32_t * buf_end, unsigned num_words)
+eat_words(const uint32_t **buf, const uint32_t *buf_end, unsigned num_words)
 {
         if ((buf_end - *buf) >= num_words) {
                 *buf += num_words;
@@ -252,7 +252,7 @@ eat_words(const uint32_t ** buf, const uint32_t * buf_end, unsigned num_words)
 static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t *seq,
                                                     unsigned long offset,
                                                     unsigned long size,
-                                                    struct drm_device * dev)
+                                                    struct drm_device *dev)
 {
         struct drm_map_list *r_list;
         drm_local_map_t *map = seq->map_cache;
@@ -344,7 +344,7 @@ static __inline__ int finish_current_sequence(drm_via_state_t * cur_seq)
 }
 
 static __inline__ int
-investigate_hazard(uint32_t cmd, hazard_t hz, drm_via_state_t * cur_seq)
+investigate_hazard(uint32_t cmd, hazard_t hz, drm_via_state_t *cur_seq)
 {
         register uint32_t tmp, *tmp_addr;
 
@@ -518,7 +518,7 @@ investigate_hazard(uint32_t cmd, hazard_t hz, drm_via_state_t * cur_seq)
 
 static __inline__ int
 via_check_prim_list(uint32_t const **buffer, const uint32_t * buf_end,
-                    drm_via_state_t * cur_seq)
+                    drm_via_state_t *cur_seq)
 {
         drm_via_private_t *dev_priv =
             (drm_via_private_t *) cur_seq->dev->dev_private;
@@ -621,8 +621,8 @@ via_check_prim_list(uint32_t const **buffer, const uint32_t * buf_end,
 }
 
 static __inline__ verifier_state_t
-via_check_header2(uint32_t const **buffer, const uint32_t * buf_end,
-                  drm_via_state_t * hc_state)
+via_check_header2(uint32_t const **buffer, const uint32_t *buf_end,
+                  drm_via_state_t *hc_state)
 {
         uint32_t cmd;
         int hz_mode;
@@ -706,16 +706,15 @@ via_check_header2(uint32_t const **buffer, const uint32_t * buf_end,
                         return state_error;
                 }
         }
-        if (hc_state->unfinished && finish_current_sequence(hc_state)) {
+        if (hc_state->unfinished && finish_current_sequence(hc_state))
                 return state_error;
-        }
         *buffer = buf;
         return state_command;
 }
 
 static __inline__ verifier_state_t
-via_parse_header2(drm_via_private_t * dev_priv, uint32_t const **buffer,
-                  const uint32_t * buf_end, int *fire_count)
+via_parse_header2(drm_via_private_t *dev_priv, uint32_t const **buffer,
+                  const uint32_t *buf_end, int *fire_count)
 {
         uint32_t cmd;
         const uint32_t *buf = *buffer;
@@ -833,8 +832,8 @@ via_check_header1(uint32_t const **buffer, const uint32_t * buf_end)
 }
 
 static __inline__ verifier_state_t
-via_parse_header1(drm_via_private_t * dev_priv, uint32_t const **buffer,
-                  const uint32_t * buf_end)
+via_parse_header1(drm_via_private_t *dev_priv, uint32_t const **buffer,
+                  const uint32_t *buf_end)
 {
         register uint32_t cmd;
         const uint32_t *buf = *buffer;
@@ -851,7 +850,7 @@ via_parse_header1(drm_via_private_t * dev_priv, uint32_t const **buffer,
 }
 
 static __inline__ verifier_state_t
-via_check_vheader5(uint32_t const **buffer, const uint32_t * buf_end)
+via_check_vheader5(uint32_t const **buffer, const uint32_t *buf_end)
 {
         uint32_t data;
         const uint32_t *buf = *buffer;
@@ -884,8 +883,8 @@ via_check_vheader5(uint32_t const **buffer, const uint32_t * buf_end)
 }
 
 static __inline__ verifier_state_t
-via_parse_vheader5(drm_via_private_t * dev_priv, uint32_t const **buffer,
-                   const uint32_t * buf_end)
+via_parse_vheader5(drm_via_private_t *dev_priv, uint32_t const **buffer,
+                   const uint32_t *buf_end)
 {
         uint32_t addr, count, i;
         const uint32_t *buf = *buffer;
@@ -893,9 +892,8 @@ via_parse_vheader5(drm_via_private_t * dev_priv, uint32_t const **buffer,
         addr = *buf++ & ~VIA_VIDEOMASK;
         i = count = *buf;
         buf += 3;
-        while (i--) {
+        while (i--)
                 VIA_WRITE(addr, *buf++);
-        }
         if (count & 3)
                 buf += 4 - (count & 3);
         *buffer = buf;
@@ -940,8 +938,8 @@ via_check_vheader6(uint32_t const **buffer, const uint32_t * buf_end)
 }
 
 static __inline__ verifier_state_t
-via_parse_vheader6(drm_via_private_t * dev_priv, uint32_t const **buffer,
-                   const uint32_t * buf_end)
+via_parse_vheader6(drm_via_private_t *dev_priv, uint32_t const **buffer,
+                   const uint32_t *buf_end)
 {
 
         uint32_t addr, count, i;
@@ -1037,7 +1035,7 @@ via_verify_command_stream(const uint32_t * buf, unsigned int size,
 }
 
 int
-via_parse_command_stream(struct drm_device * dev, const uint32_t * buf,
+via_parse_command_stream(struct drm_device *dev, const uint32_t *buf,
                          unsigned int size)
 {
 
@@ -1085,9 +1083,8 @@ via_parse_command_stream(struct drm_device * dev, const uint32_t * buf,
                         return -EINVAL;
                 }
         }
-        if (state == state_error) {
+        if (state == state_error)
                 return -EINVAL;
-        }
         return 0;
 }
 
@@ -1096,13 +1093,11 @@ setup_hazard_table(hz_init_t init_table[], hazard_t table[], int size)
 {
         int i;
 
-        for (i = 0; i < 256; ++i) {
+        for (i = 0; i < 256; ++i)
                 table[i] = forbidden_command;
-        }
 
-        for (i = 0; i < size; ++i) {
+        for (i = 0; i < size; ++i)
                 table[init_table[i].code] = init_table[i].hz;
-        }
 }
 
 void via_init_command_verifier(void)
diff --git a/drivers/gpu/drm/via/via_verifier.h b/drivers/gpu/drm/via/via_verifier.h
index d6f8214b69f5..26b6d361ab95 100644
--- a/drivers/gpu/drm/via/via_verifier.h
+++ b/drivers/gpu/drm/via/via_verifier.h
@@ -54,8 +54,8 @@ typedef struct {
         const uint32_t *buf_start;
 } drm_via_state_t;
 
-extern int via_verify_command_stream(const uint32_t * buf, unsigned int size,
-                                     struct drm_device * dev, int agp);
+extern int via_verify_command_stream(const uint32_t *buf, unsigned int size,
+                                     struct drm_device *dev, int agp);
 extern int via_parse_command_stream(struct drm_device *dev, const uint32_t *buf,
                                     unsigned int size);
 
diff --git a/drivers/gpu/drm/via/via_video.c b/drivers/gpu/drm/via/via_video.c
index 6efac8117c93..675d311f038f 100644
--- a/drivers/gpu/drm/via/via_video.c
+++ b/drivers/gpu/drm/via/via_video.c
@@ -29,7 +29,7 @@
 #include "via_drm.h"
 #include "via_drv.h"
 
-void via_init_futex(drm_via_private_t * dev_priv)
+void via_init_futex(drm_via_private_t *dev_priv)
 {
         unsigned int i;
 
@@ -41,11 +41,11 @@ void via_init_futex(drm_via_private_t * dev_priv)
         }
 }
 
-void via_cleanup_futex(drm_via_private_t * dev_priv)
+void via_cleanup_futex(drm_via_private_t *dev_priv)
 {
 }
 
-void via_release_futex(drm_via_private_t * dev_priv, int context)
+void via_release_futex(drm_via_private_t *dev_priv, int context)
 {
         unsigned int i;
         volatile int *lock;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
index b0866f04ec76..870967a97c15 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
@@ -528,7 +528,7 @@ int vmw_fb_init(struct vmw_private *vmw_priv)
          * Dirty & Deferred IO
          */
         par->dirty.x1 = par->dirty.x2 = 0;
-        par->dirty.y1 = par->dirty.y1 = 0;
+        par->dirty.y1 = par->dirty.y2 = 0;
         par->dirty.active = true;
         spin_lock_init(&par->dirty.lock);
         info->fbdefio = &vmw_defio;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index f1d626112415..437ac786277a 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -972,6 +972,7 @@ int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
         ret = copy_from_user(rects, user_rects, rects_size);
         if (unlikely(ret != 0)) {
                 DRM_ERROR("Failed to get rects.\n");
+                ret = -EFAULT;
                 goto out_free;
         }
 
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 132278fa6240..434099369058 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -358,6 +358,7 @@ config HID_ROCCAT
 config HID_ROCCAT_KONE
         tristate "Roccat Kone Mouse support"
         depends on USB_HID
+        select HID_ROCCAT
         ---help---
         Support for Roccat Kone mouse.
 
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index aa0f7dcabcd7..866e54ec5fb2 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1337,6 +1337,24 @@ static const struct hid_device_id hid_blacklist[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
         { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
         { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
@@ -1760,7 +1778,8 @@ int hid_add_device(struct hid_device *hdev)
 
         /* we need to kill them here, otherwise they will stay allocated to
          * wait for coming driver */
-        if (!(hdev->quirks & HID_QUIRK_NO_IGNORE) && hid_ignore(hdev))
+        if (!(hdev->quirks & HID_QUIRK_NO_IGNORE)
+            && (hid_ignore(hdev) || (hdev->quirks & HID_QUIRK_IGNORE)))
                 return -ENODEV;
 
         /* XXX hack, any other cleaner solution after the driver core
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index c94026768570..850d02a7a925 100644
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -949,8 +949,8 @@ static ssize_t hid_debug_events_read(struct file *file, char __user *buffer,
         int ret = 0, len;
         DECLARE_WAITQUEUE(wait, current);
 
+        mutex_lock(&list->read_mutex);
         while (ret == 0) {
-                mutex_lock(&list->read_mutex);
                 if (list->head == list->tail) {
                         add_wait_queue(&list->hdev->debug_wait, &wait);
                         set_current_state(TASK_INTERRUPTIBLE);
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 6af77ed0b555..31601eef25dd 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -134,6 +134,7 @@
 #define USB_VENDOR_ID_CH                0x068e
 #define USB_DEVICE_ID_CH_PRO_PEDALS     0x00f2
 #define USB_DEVICE_ID_CH_COMBATSTICK    0x00f4
+#define USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE       0x0051
 #define USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE        0x00ff
 #define USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK    0x00d3
 
@@ -369,6 +370,8 @@
 #define USB_DEVICE_ID_MS_PRESENTER_8K_BT        0x0701
 #define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
 
+#define USB_VENDOR_ID_MOJO              0x8282
+#define USB_DEVICE_ID_RETRO_ADAPTER     0x3201
 
 #define USB_VENDOR_ID_MONTEREY          0x0566
 #define USB_DEVICE_ID_GENIUS_KB29E      0x3004
@@ -391,6 +394,24 @@
 
 #define USB_VENDOR_ID_NTRIG                0x1b96
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN   0x0001
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1   0x0003
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2   0x0004
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3   0x0005
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4   0x0006
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5   0x0007
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6   0x0008
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7   0x0009
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8   0x000A
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9   0x000B
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10   0x000C
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11   0x000D
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12   0x000E
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13   0x000F
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14   0x0010
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15   0x0011
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16   0x0012
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17   0x0013
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
 
 #define USB_VENDOR_ID_ONTRAK            0x0a07
 #define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
diff --git a/drivers/hid/hid-ntrig.c b/drivers/hid/hid-ntrig.c
index b6b0caeeac58..fb69b8c4953f 100644
--- a/drivers/hid/hid-ntrig.c
+++ b/drivers/hid/hid-ntrig.c
@@ -868,6 +868,42 @@ static void ntrig_remove(struct hid_device *hdev)
 static const struct hid_device_id ntrig_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
                 .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),
+                .driver_data = NTRIG_DUPLICATE_USAGES },
         { }
 };
 MODULE_DEVICE_TABLE(hid, ntrig_devices);
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 1ebd3244eb85..b729c0286679 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -827,14 +827,21 @@ static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t co
                                 ret++;
                 }
         } else {
+                int skipped_report_id = 0;
+                if (buf[0] == 0x0) {
+                        /* Don't send the Report ID */
+                        buf++;
+                        count--;
+                        skipped_report_id = 1;
+                }
                 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                         HID_REQ_SET_REPORT,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         ((report_type + 1) << 8) | *buf,
-                        interface->desc.bInterfaceNumber, buf + 1, count - 1,
+                        interface->desc.bInterfaceNumber, buf, count,
                         USB_CTRL_SET_TIMEOUT);
-                /* count also the report id */
-                if (ret > 0)
+                /* count also the report id, if this was a numbered report. */
+                if (ret > 0 && skipped_report_id)
                         ret++;
         }
 
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 5ff8d327f33a..5f5aa39b3988 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -34,6 +34,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_MOJO, USB_DEVICE_ID_RETRO_ADAPTER, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
@@ -56,6 +57,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_COMBATSTICK, HID_QUIRK_NOGET },
+        { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_PRO_PEDALS, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK, HID_QUIRK_NOGET },
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 2988da150ed6..05344af50734 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -53,6 +53,7 @@ struct coretemp_data {
         struct mutex update_lock;
         const char *name;
         u32 id;
+        u16 core_id;
         char valid;             /* zero until following fields are valid */
         unsigned long last_updated;     /* in jiffies */
         int temp;
@@ -75,7 +76,7 @@ static ssize_t show_name(struct device *dev, struct device_attribute
         if (attr->index == SHOW_NAME)
                 ret = sprintf(buf, "%s\n", data->name);
         else    /* show label */
-                ret = sprintf(buf, "Core %d\n", data->id);
+                ret = sprintf(buf, "Core %d\n", data->core_id);
         return ret;
 }
 
@@ -304,6 +305,9 @@ static int __devinit coretemp_probe(struct platform_device *pdev)
         }
 
         data->id = pdev->id;
+#ifdef CONFIG_SMP
+        data->core_id = c->cpu_core_id;
+#endif
         data->name = "coretemp";
         mutex_init(&data->update_lock);
 
@@ -405,6 +409,10 @@ struct pdev_entry {
         struct list_head list;
         struct platform_device *pdev;
         unsigned int cpu;
+#ifdef CONFIG_SMP
+        u16 phys_proc_id;
+        u16 cpu_core_id;
+#endif
 };
 
 static LIST_HEAD(pdev_list);
@@ -415,6 +423,22 @@ static int __cpuinit coretemp_device_add(unsigned int cpu)
         int err;
         struct platform_device *pdev;
         struct pdev_entry *pdev_entry;
+#ifdef CONFIG_SMP
+        struct cpuinfo_x86 *c = &cpu_data(cpu);
+#endif
+
+        mutex_lock(&pdev_list_mutex);
+
+#ifdef CONFIG_SMP
+        /* Skip second HT entry of each core */
+        list_for_each_entry(pdev_entry, &pdev_list, list) {
+                if (c->phys_proc_id == pdev_entry->phys_proc_id &&
+                    c->cpu_core_id == pdev_entry->cpu_core_id) {
+                        err = 0;        /* Not an error */
+                        goto exit;
+                }
+        }
+#endif
 
         pdev = platform_device_alloc(DRVNAME, cpu);
         if (!pdev) {
@@ -438,7 +462,10 @@ static int __cpuinit coretemp_device_add(unsigned int cpu)
 
         pdev_entry->pdev = pdev;
         pdev_entry->cpu = cpu;
-        mutex_lock(&pdev_list_mutex);
+#ifdef CONFIG_SMP
+        pdev_entry->phys_proc_id = c->phys_proc_id;
+        pdev_entry->cpu_core_id = c->cpu_core_id;
+#endif
         list_add_tail(&pdev_entry->list, &pdev_list);
         mutex_unlock(&pdev_list_mutex);
 
@@ -449,6 +476,7 @@ exit_device_free:
 exit_device_put:
         platform_device_put(pdev);
 exit:
+        mutex_unlock(&pdev_list_mutex);
         return err;
 }
 
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 5be09c048c5f..25763d2223b6 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -80,6 +80,13 @@ superio_inb(int reg)
         return inb(VAL);
 }
 
+static inline void
+superio_outb(int reg, int val)
+{
+        outb(reg, REG);
+        outb(val, VAL);
+}
+
 static int superio_inw(int reg)
 {
         int val;
@@ -1517,6 +1524,21 @@ static int __init it87_find(unsigned short *address,
                         sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
 
                 reg = superio_inb(IT87_SIO_PINX2_REG);
+                /*
+                 * The IT8720F has no VIN7 pin, so VCCH should always be
+                 * routed internally to VIN7 with an internal divider.
+                 * Curiously, there still is a configuration bit to control
+                 * this, which means it can be set incorrectly. And even
+                 * more curiously, many boards out there are improperly
+                 * configured, even though the IT8720F datasheet claims
+                 * that the internal routing of VCCH to VIN7 is the default
+                 * setting. So we force the internal routing in this case.
+                 */
+                if (sio_data->type == it8720 && !(reg & (1 << 1))) {
+                        reg |= (1 << 1);
+                        superio_outb(IT87_SIO_PINX2_REG, reg);
+                        pr_notice("it87: Routing internal VCCH to in7\n");
+                }
                 if (reg & (1 << 0))
                         pr_info("it87: in3 is VCC (+5V)\n");
                 if (reg & (1 << 1))
diff --git a/drivers/hwmon/k8temp.c b/drivers/hwmon/k8temp.c
index f26acdb11681..8bdf80d91598 100644
--- a/drivers/hwmon/k8temp.c
+++ b/drivers/hwmon/k8temp.c
@@ -180,11 +180,13 @@ static int __devinit k8temp_probe(struct pci_dev *pdev,
                 }
 
                 if ((model >= 0x69) &&
-                    !(model == 0xc1 || model == 0x6c || model == 0x7c)) {
+                    !(model == 0xc1 || model == 0x6c || model == 0x7c ||
+                      model == 0x6b || model == 0x6f || model == 0x7f)) {
                         /*
-                         * RevG desktop CPUs (i.e. no socket S1G1 parts)
-                         * need additional offset, otherwise reported
-                         * temperature is below ambient temperature
+                         * RevG desktop CPUs (i.e. no socket S1G1 or
+                         * ASB1 parts) need additional offset,
+                         * otherwise reported temperature is below
+                         * ambient temperature
                          */
                         data->temp_offset = 21000;
                 }
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index f4b21f2bb8ed..c60081169cc3 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -655,7 +655,7 @@ static void __devinit dmi_check_onboard_device(u8 type, const char *name,
                 /* & ~0x80, ignore enabled/disabled bit */
                 if ((type & ~0x80) != dmi_devices[i].type)
                         continue;
-                if (strcmp(name, dmi_devices[i].name))
+                if (strcasecmp(name, dmi_devices[i].name))
                         continue;
 
                 memset(&info, 0, sizeof(struct i2c_board_info));
@@ -704,9 +704,6 @@ static int __devinit i801_probe(struct pci_dev *dev,
 {
         unsigned char temp;
         int err, i;
-#if defined CONFIG_SENSORS_FSCHMD || defined CONFIG_SENSORS_FSCHMD_MODULE
-        const char *vendor;
-#endif
 
         I801_dev = dev;
         i801_features = 0;
@@ -808,8 +805,7 @@ static int __devinit i801_probe(struct pci_dev *dev,
         }
 #endif
 #if defined CONFIG_SENSORS_FSCHMD || defined CONFIG_SENSORS_FSCHMD_MODULE
-        vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
-        if (vendor && !strcmp(vendor, "FUJITSU SIEMENS"))
+        if (dmi_name_in_vendors("FUJITSU"))
                 dmi_walk(dmi_check_onboard_devices, &i801_adapter);
 #endif
 
diff --git a/drivers/i2c/busses/i2c-sibyte.c b/drivers/i2c/busses/i2c-sibyte.c
index 3d76a188e42f..0fe505d7abe9 100644
--- a/drivers/i2c/busses/i2c-sibyte.c
+++ b/drivers/i2c/busses/i2c-sibyte.c
@@ -94,7 +94,7 @@ static int smbus_xfer(struct i2c_adapter *i2c_adap, u16 addr,
                 }
                 break;
         default:
-                return -1;      /* XXXKW better error code? */
+                return -EOPNOTSUPP;
         }
 
         while (csr_in32(SMB_CSR(adap, R_SMB_STATUS)) & M_SMB_BUSY)
@@ -104,7 +104,7 @@ static int smbus_xfer(struct i2c_adapter *i2c_adap, u16 addr,
         if (error & M_SMB_ERROR) {
                 /* Clear error bit by writing a 1 */
                 csr_out32(M_SMB_ERROR, SMB_CSR(adap, R_SMB_STATUS));
-                return -1;      /* XXXKW better error code? */
+                return (error & M_SMB_ERROR_TYPE) ? -EIO : -ENXIO;
         }
 
         if (data_bytes == 1)
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 1cca2631e5b3..0815e10da7c6 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -1428,13 +1428,12 @@ static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
         if (!(adapter->class & driver->class))
                 goto exit_free;
 
-        /* Stop here if we can't use SMBUS_QUICK */
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
+        /* Stop here if the bus doesn't support probing */
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE)) {
                 if (address_list[0] == I2C_CLIENT_END)
                         goto exit_free;
 
-                dev_warn(&adapter->dev, "SMBus Quick command not supported, "
-                         "can't probe for chips\n");
+                dev_warn(&adapter->dev, "Probing not supported\n");
                 err = -EOPNOTSUPP;
                 goto exit_free;
         }
diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c
index 30ce0a8eca09..855ee44fdb52 100644
--- a/drivers/infiniband/hw/cxgb4/cm.c
+++ b/drivers/infiniband/hw/cxgb4/cm.c
@@ -969,7 +969,8 @@ static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
                 goto err;
         goto out;
 err:
-        abort_connection(ep, skb, GFP_KERNEL);
+        state_set(&ep->com, ABORTING);
+        send_abort(ep, skb, GFP_KERNEL);
 out:
         connect_reply_upcall(ep, err);
         return;
@@ -1372,7 +1373,7 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
                                     pdev, 0);
                 mtu = pdev->mtu;
                 tx_chan = cxgb4_port_chan(pdev);
-                smac_idx = tx_chan << 1;
+                smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
                 step = dev->rdev.lldi.ntxq / dev->rdev.lldi.nchan;
                 txq_idx = cxgb4_port_idx(pdev) * step;
                 step = dev->rdev.lldi.nrxq / dev->rdev.lldi.nchan;
@@ -1383,7 +1384,7 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
                                         dst->neighbour->dev, 0);
                 mtu = dst_mtu(dst);
                 tx_chan = cxgb4_port_chan(dst->neighbour->dev);
-                smac_idx = tx_chan << 1;
+                smac_idx = (cxgb4_port_viid(dst->neighbour->dev) & 0x7F) << 1;
                 step = dev->rdev.lldi.ntxq / dev->rdev.lldi.nchan;
                 txq_idx = cxgb4_port_idx(dst->neighbour->dev) * step;
                 step = dev->rdev.lldi.nrxq / dev->rdev.lldi.nchan;
@@ -1950,7 +1951,7 @@ int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                                         pdev, 0);
                 ep->mtu = pdev->mtu;
                 ep->tx_chan = cxgb4_port_chan(pdev);
-                ep->smac_idx = ep->tx_chan << 1;
+                ep->smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
                 step = ep->com.dev->rdev.lldi.ntxq /
                        ep->com.dev->rdev.lldi.nchan;
                 ep->txq_idx = cxgb4_port_idx(pdev) * step;
@@ -1965,7 +1966,8 @@ int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                                         ep->dst->neighbour->dev, 0);
                 ep->mtu = dst_mtu(ep->dst);
                 ep->tx_chan = cxgb4_port_chan(ep->dst->neighbour->dev);
-                ep->smac_idx = ep->tx_chan << 1;
+                ep->smac_idx = (cxgb4_port_viid(ep->dst->neighbour->dev) &
+                                0x7F) << 1;
                 step = ep->com.dev->rdev.lldi.ntxq /
                        ep->com.dev->rdev.lldi.nchan;
                 ep->txq_idx = cxgb4_port_idx(ep->dst->neighbour->dev) * step;
diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c
index 2447f5295482..fac5c6e68011 100644
--- a/drivers/infiniband/hw/cxgb4/cq.c
+++ b/drivers/infiniband/hw/cxgb4/cq.c
@@ -77,7 +77,7 @@ static int destroy_cq(struct c4iw_rdev *rdev, struct t4_cq *cq,
         kfree(cq->sw_queue);
         dma_free_coherent(&(rdev->lldi.pdev->dev),
                           cq->memsize, cq->queue,
-                          pci_unmap_addr(cq, mapping));
+                          dma_unmap_addr(cq, mapping));
         c4iw_put_cqid(rdev, cq->cqid, uctx);
         return ret;
 }
@@ -112,7 +112,7 @@ static int create_cq(struct c4iw_rdev *rdev, struct t4_cq *cq,
                 ret = -ENOMEM;
                 goto err3;
         }
-        pci_unmap_addr_set(cq, mapping, cq->dma_addr);
+        dma_unmap_addr_set(cq, mapping, cq->dma_addr);
         memset(cq->queue, 0, cq->memsize);
 
         /* build fw_ri_res_wr */
@@ -179,7 +179,7 @@ static int create_cq(struct c4iw_rdev *rdev, struct t4_cq *cq,
         return 0;
 err4:
         dma_free_coherent(&rdev->lldi.pdev->dev, cq->memsize, cq->queue,
-                          pci_unmap_addr(cq, mapping));
+                          dma_unmap_addr(cq, mapping));
 err3:
         kfree(cq->sw_queue);
 err2:
@@ -764,7 +764,7 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
         struct c4iw_create_cq_resp uresp;
         struct c4iw_ucontext *ucontext = NULL;
         int ret;
-        size_t memsize;
+        size_t memsize, hwentries;
         struct c4iw_mm_entry *mm, *mm2;
 
         PDBG("%s ib_dev %p entries %d\n", __func__, ibdev, entries);
@@ -788,14 +788,29 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
          * entries must be multiple of 16 for HW.
          */
         entries = roundup(entries, 16);
-        memsize = entries * sizeof *chp->cq.queue;
+
+        /*
+         * Make actual HW queue 2x to avoid cdix_inc overflows.
+         */
+        hwentries = entries * 2;
+
+        /*
+         * Make HW queue at least 64 entries so GTS updates aren't too
+         * frequent.
+         */
+        if (hwentries < 64)
+                hwentries = 64;
+
+        memsize = hwentries * sizeof *chp->cq.queue;
 
         /*
          * memsize must be a multiple of the page size if its a user cq.
          */
-        if (ucontext)
+        if (ucontext) {
                 memsize = roundup(memsize, PAGE_SIZE);
-        chp->cq.size = entries;
+                hwentries = memsize / sizeof *chp->cq.queue;
+        }
+        chp->cq.size = hwentries;
         chp->cq.memsize = memsize;
 
         ret = create_cq(&rhp->rdev, &chp->cq,
@@ -805,7 +820,7 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
 
         chp->rhp = rhp;
         chp->cq.size--;                         /* status page */
-        chp->ibcq.cqe = chp->cq.size - 1;
+        chp->ibcq.cqe = entries - 2;
         spin_lock_init(&chp->lock);
         atomic_set(&chp->refcnt, 1);
         init_waitqueue_head(&chp->wait);
diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
index 277ab589b44d..d33e1a668811 100644
--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
@@ -261,7 +261,7 @@ static inline struct c4iw_mw *to_c4iw_mw(struct ib_mw *ibmw)
 
 struct c4iw_fr_page_list {
         struct ib_fast_reg_page_list ibpl;
-        DECLARE_PCI_UNMAP_ADDR(mapping);
+        DEFINE_DMA_UNMAP_ADDR(mapping);
         dma_addr_t dma_addr;
         struct c4iw_dev *dev;
         int size;
diff --git a/drivers/infiniband/hw/cxgb4/mem.c b/drivers/infiniband/hw/cxgb4/mem.c
index 7f94da1a2437..82b5703b8947 100644
--- a/drivers/infiniband/hw/cxgb4/mem.c
+++ b/drivers/infiniband/hw/cxgb4/mem.c
@@ -764,7 +764,7 @@ struct ib_fast_reg_page_list *c4iw_alloc_fastreg_pbl(struct ib_device *device,
         if (!c4pl)
                 return ERR_PTR(-ENOMEM);
 
-        pci_unmap_addr_set(c4pl, mapping, dma_addr);
+        dma_unmap_addr_set(c4pl, mapping, dma_addr);
         c4pl->dma_addr = dma_addr;
         c4pl->dev = dev;
         c4pl->size = size;
@@ -779,7 +779,7 @@ void c4iw_free_fastreg_pbl(struct ib_fast_reg_page_list *ibpl)
         struct c4iw_fr_page_list *c4pl = to_c4iw_fr_page_list(ibpl);
 
         dma_free_coherent(&c4pl->dev->rdev.lldi.pdev->dev, c4pl->size,
-                          c4pl, pci_unmap_addr(c4pl, mapping));
+                          c4pl, dma_unmap_addr(c4pl, mapping));
 }
 
 int c4iw_dereg_mr(struct ib_mr *ib_mr)
diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
index 0c28ed1eafa6..7065cb310553 100644
--- a/drivers/infiniband/hw/cxgb4/qp.c
+++ b/drivers/infiniband/hw/cxgb4/qp.c
@@ -40,10 +40,10 @@ static int destroy_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
          */
         dma_free_coherent(&(rdev->lldi.pdev->dev),
                           wq->rq.memsize, wq->rq.queue,
-                          pci_unmap_addr(&wq->rq, mapping));
+                          dma_unmap_addr(&wq->rq, mapping));
         dma_free_coherent(&(rdev->lldi.pdev->dev),
                           wq->sq.memsize, wq->sq.queue,
-                          pci_unmap_addr(&wq->sq, mapping));
+                          dma_unmap_addr(&wq->sq, mapping));
         c4iw_rqtpool_free(rdev, wq->rq.rqt_hwaddr, wq->rq.rqt_size);
         kfree(wq->rq.sw_rq);
         kfree(wq->sq.sw_sq);
@@ -99,7 +99,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
         if (!wq->sq.queue)
                 goto err5;
         memset(wq->sq.queue, 0, wq->sq.memsize);
-        pci_unmap_addr_set(&wq->sq, mapping, wq->sq.dma_addr);
+        dma_unmap_addr_set(&wq->sq, mapping, wq->sq.dma_addr);
 
         wq->rq.queue = dma_alloc_coherent(&(rdev->lldi.pdev->dev),
                                           wq->rq.memsize, &(wq->rq.dma_addr),
@@ -112,7 +112,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
                 wq->rq.queue,
                 (unsigned long long)virt_to_phys(wq->rq.queue));
         memset(wq->rq.queue, 0, wq->rq.memsize);
-        pci_unmap_addr_set(&wq->rq, mapping, wq->rq.dma_addr);
+        dma_unmap_addr_set(&wq->rq, mapping, wq->rq.dma_addr);
 
         wq->db = rdev->lldi.db_reg;
         wq->gts = rdev->lldi.gts_reg;
@@ -217,11 +217,11 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
 err7:
         dma_free_coherent(&(rdev->lldi.pdev->dev),
                           wq->rq.memsize, wq->rq.queue,
-                          pci_unmap_addr(&wq->rq, mapping));
+                          dma_unmap_addr(&wq->rq, mapping));
 err6:
         dma_free_coherent(&(rdev->lldi.pdev->dev),
                           wq->sq.memsize, wq->sq.queue,
-                          pci_unmap_addr(&wq->sq, mapping));
+                          dma_unmap_addr(&wq->sq, mapping));
 err5:
         c4iw_rqtpool_free(rdev, wq->rq.rqt_hwaddr, wq->rq.rqt_size);
 err4:
diff --git a/drivers/infiniband/hw/cxgb4/t4.h b/drivers/infiniband/hw/cxgb4/t4.h
index 1057cb96302e..9cf8d85bfcff 100644
--- a/drivers/infiniband/hw/cxgb4/t4.h
+++ b/drivers/infiniband/hw/cxgb4/t4.h
@@ -279,7 +279,7 @@ struct t4_swsqe {
 struct t4_sq {
         union t4_wr *queue;
         dma_addr_t dma_addr;
-        DECLARE_PCI_UNMAP_ADDR(mapping);
+        DEFINE_DMA_UNMAP_ADDR(mapping);
         struct t4_swsqe *sw_sq;
         struct t4_swsqe *oldest_read;
         u64 udb;
@@ -298,7 +298,7 @@ struct t4_swrqe {
 struct t4_rq {
         union  t4_recv_wr *queue;
         dma_addr_t dma_addr;
-        DECLARE_PCI_UNMAP_ADDR(mapping);
+        DEFINE_DMA_UNMAP_ADDR(mapping);
         struct t4_swrqe *sw_rq;
         u64 udb;
         size_t memsize;
@@ -429,7 +429,7 @@ static inline int t4_wq_db_enabled(struct t4_wq *wq)
 struct t4_cq {
         struct t4_cqe *queue;
         dma_addr_t dma_addr;
-        DECLARE_PCI_UNMAP_ADDR(mapping);
+        DEFINE_DMA_UNMAP_ADDR(mapping);
         struct t4_cqe *sw_queue;
         void __iomem *gts;
         struct c4iw_rdev *rdev;
diff --git a/drivers/infiniband/hw/qib/Makefile b/drivers/infiniband/hw/qib/Makefile
index c6515a1b9a6a..f12d7bb8b39f 100644
--- a/drivers/infiniband/hw/qib/Makefile
+++ b/drivers/infiniband/hw/qib/Makefile
@@ -6,7 +6,7 @@ ib_qib-y := qib_cq.o qib_diag.o qib_dma.o qib_driver.o qib_eeprom.o \
         qib_qp.o qib_qsfp.o qib_rc.o qib_ruc.o qib_sdma.o qib_srq.o \
         qib_sysfs.o qib_twsi.o qib_tx.o qib_uc.o qib_ud.o \
         qib_user_pages.o qib_user_sdma.o qib_verbs_mcast.o qib_iba7220.o \
-        qib_sd7220.o qib_sd7220_img.o qib_iba7322.o qib_verbs.o
+        qib_sd7220.o qib_iba7322.o qib_verbs.o
 
 # 6120 has no fallback if no MSI interrupts, others can do INTx
 ib_qib-$(CONFIG_PCI_MSI) += qib_iba6120.o
diff --git a/drivers/infiniband/hw/qib/qib.h b/drivers/infiniband/hw/qib/qib.h
index 32d9208efcff..3593983df7ba 100644
--- a/drivers/infiniband/hw/qib/qib.h
+++ b/drivers/infiniband/hw/qib/qib.h
@@ -686,6 +686,7 @@ struct qib_devdata {
         void __iomem *piobase;
         /* mem-mapped pointer to base of user chip regs (if using WC PAT) */
         u64 __iomem *userbase;
+        void __iomem *piovl15base; /* base of VL15 buffers, if not WC */
         /*
          * points to area where PIOavail registers will be DMA'ed.
          * Has to be on a page of it's own, because the page will be
diff --git a/drivers/infiniband/hw/qib/qib_7220.h b/drivers/infiniband/hw/qib/qib_7220.h
index ea0bfd896f92..21f374aa0631 100644
--- a/drivers/infiniband/hw/qib/qib_7220.h
+++ b/drivers/infiniband/hw/qib/qib_7220.h
@@ -109,10 +109,6 @@ struct qib_chippport_specific {
  */
 int qib_sd7220_presets(struct qib_devdata *dd);
 int qib_sd7220_init(struct qib_devdata *dd);
-int qib_sd7220_prog_ld(struct qib_devdata *dd, int sdnum, u8 *img,
-                       int len, int offset);
-int qib_sd7220_prog_vfy(struct qib_devdata *dd, int sdnum, const u8 *img,
-                        int len, int offset);
 void qib_sd7220_clr_ibpar(struct qib_devdata *);
 /*
  * Below used for sdnum parameter, selecting one of the two sections
@@ -121,9 +117,6 @@ void qib_sd7220_clr_ibpar(struct qib_devdata *);
  */
 #define IB_7220_SERDES 2
 
-int qib_sd7220_ib_load(struct qib_devdata *dd);
-int qib_sd7220_ib_vfy(struct qib_devdata *dd);
-
 static inline u32 qib_read_kreg32(const struct qib_devdata *dd,
                                   const u16 regno)
 {
diff --git a/drivers/infiniband/hw/qib/qib_7322_regs.h b/drivers/infiniband/hw/qib/qib_7322_regs.h
index a97440ba924c..32dc81ff8d4a 100644
--- a/drivers/infiniband/hw/qib/qib_7322_regs.h
+++ b/drivers/infiniband/hw/qib/qib_7322_regs.h
@@ -742,15 +742,15 @@
 #define QIB_7322_HwErrMask_IBCBusFromSPCParityErrMask_1_LSB 0xF
 #define QIB_7322_HwErrMask_IBCBusFromSPCParityErrMask_1_MSB 0xF
 #define QIB_7322_HwErrMask_IBCBusFromSPCParityErrMask_1_RMASK 0x1
-#define QIB_7322_HwErrMask_statusValidNoEopMask_1_LSB 0xE
-#define QIB_7322_HwErrMask_statusValidNoEopMask_1_MSB 0xE
-#define QIB_7322_HwErrMask_statusValidNoEopMask_1_RMASK 0x1
+#define QIB_7322_HwErrMask_IBCBusToSPCParityErrMask_1_LSB 0xE
+#define QIB_7322_HwErrMask_IBCBusToSPCParityErrMask_1_MSB 0xE
+#define QIB_7322_HwErrMask_IBCBusToSPCParityErrMask_1_RMASK 0x1
 #define QIB_7322_HwErrMask_IBCBusFromSPCParityErrMask_0_LSB 0xD
 #define QIB_7322_HwErrMask_IBCBusFromSPCParityErrMask_0_MSB 0xD
 #define QIB_7322_HwErrMask_IBCBusFromSPCParityErrMask_0_RMASK 0x1
-#define QIB_7322_HwErrMask_statusValidNoEopMask_0_LSB 0xC
-#define QIB_7322_HwErrMask_statusValidNoEopMask_0_MSB 0xC
-#define QIB_7322_HwErrMask_statusValidNoEopMask_0_RMASK 0x1
+#define QIB_7322_HwErrMask_statusValidNoEopMask_LSB 0xC
+#define QIB_7322_HwErrMask_statusValidNoEopMask_MSB 0xC
+#define QIB_7322_HwErrMask_statusValidNoEopMask_RMASK 0x1
 #define QIB_7322_HwErrMask_LATriggeredMask_LSB 0xB
 #define QIB_7322_HwErrMask_LATriggeredMask_MSB 0xB
 #define QIB_7322_HwErrMask_LATriggeredMask_RMASK 0x1
@@ -796,15 +796,15 @@
 #define QIB_7322_HwErrStatus_IBCBusFromSPCParityErr_1_LSB 0xF
 #define QIB_7322_HwErrStatus_IBCBusFromSPCParityErr_1_MSB 0xF
 #define QIB_7322_HwErrStatus_IBCBusFromSPCParityErr_1_RMASK 0x1
-#define QIB_7322_HwErrStatus_statusValidNoEop_1_LSB 0xE
-#define QIB_7322_HwErrStatus_statusValidNoEop_1_MSB 0xE
-#define QIB_7322_HwErrStatus_statusValidNoEop_1_RMASK 0x1
+#define QIB_7322_HwErrStatus_IBCBusToSPCParityErr_1_LSB 0xE
+#define QIB_7322_HwErrStatus_IBCBusToSPCParityErr_1_MSB 0xE
+#define QIB_7322_HwErrStatus_IBCBusToSPCParityErr_1_RMASK 0x1
 #define QIB_7322_HwErrStatus_IBCBusFromSPCParityErr_0_LSB 0xD
 #define QIB_7322_HwErrStatus_IBCBusFromSPCParityErr_0_MSB 0xD
 #define QIB_7322_HwErrStatus_IBCBusFromSPCParityErr_0_RMASK 0x1
-#define QIB_7322_HwErrStatus_statusValidNoEop_0_LSB 0xC
-#define QIB_7322_HwErrStatus_statusValidNoEop_0_MSB 0xC
-#define QIB_7322_HwErrStatus_statusValidNoEop_0_RMASK 0x1
+#define QIB_7322_HwErrStatus_statusValidNoEop_LSB 0xC
+#define QIB_7322_HwErrStatus_statusValidNoEop_MSB 0xC
+#define QIB_7322_HwErrStatus_statusValidNoEop_RMASK 0x1
 #define QIB_7322_HwErrStatus_LATriggered_LSB 0xB
 #define QIB_7322_HwErrStatus_LATriggered_MSB 0xB
 #define QIB_7322_HwErrStatus_LATriggered_RMASK 0x1
@@ -850,15 +850,15 @@
 #define QIB_7322_HwErrClear_IBCBusFromSPCParityErrClear_1_LSB 0xF
 #define QIB_7322_HwErrClear_IBCBusFromSPCParityErrClear_1_MSB 0xF
 #define QIB_7322_HwErrClear_IBCBusFromSPCParityErrClear_1_RMASK 0x1
-#define QIB_7322_HwErrClear_IBCBusToSPCparityErrClear_1_LSB 0xE
-#define QIB_7322_HwErrClear_IBCBusToSPCparityErrClear_1_MSB 0xE
-#define QIB_7322_HwErrClear_IBCBusToSPCparityErrClear_1_RMASK 0x1
+#define QIB_7322_HwErrClear_IBCBusToSPCParityErrClear_1_LSB 0xE
+#define QIB_7322_HwErrClear_IBCBusToSPCParityErrClear_1_MSB 0xE
+#define QIB_7322_HwErrClear_IBCBusToSPCParityErrClear_1_RMASK 0x1
 #define QIB_7322_HwErrClear_IBCBusFromSPCParityErrClear_0_LSB 0xD
 #define QIB_7322_HwErrClear_IBCBusFromSPCParityErrClear_0_MSB 0xD
 #define QIB_7322_HwErrClear_IBCBusFromSPCParityErrClear_0_RMASK 0x1
-#define QIB_7322_HwErrClear_IBCBusToSPCparityErrClear_0_LSB 0xC
-#define QIB_7322_HwErrClear_IBCBusToSPCparityErrClear_0_MSB 0xC
-#define QIB_7322_HwErrClear_IBCBusToSPCparityErrClear_0_RMASK 0x1
+#define QIB_7322_HwErrClear_statusValidNoEopClear_LSB 0xC
+#define QIB_7322_HwErrClear_statusValidNoEopClear_MSB 0xC
+#define QIB_7322_HwErrClear_statusValidNoEopClear_RMASK 0x1
 #define QIB_7322_HwErrClear_LATriggeredClear_LSB 0xB
 #define QIB_7322_HwErrClear_LATriggeredClear_MSB 0xB
 #define QIB_7322_HwErrClear_LATriggeredClear_RMASK 0x1
@@ -880,15 +880,15 @@
 #define QIB_7322_HwDiagCtrl_ForceIBCBusFromSPCParityErr_1_LSB 0xF
 #define QIB_7322_HwDiagCtrl_ForceIBCBusFromSPCParityErr_1_MSB 0xF
 #define QIB_7322_HwDiagCtrl_ForceIBCBusFromSPCParityErr_1_RMASK 0x1
-#define QIB_7322_HwDiagCtrl_ForcestatusValidNoEop_1_LSB 0xE
-#define QIB_7322_HwDiagCtrl_ForcestatusValidNoEop_1_MSB 0xE
-#define QIB_7322_HwDiagCtrl_ForcestatusValidNoEop_1_RMASK 0x1
+#define QIB_7322_HwDiagCtrl_ForceIBCBusToSPCParityErr_1_LSB 0xE
+#define QIB_7322_HwDiagCtrl_ForceIBCBusToSPCParityErr_1_MSB 0xE
+#define QIB_7322_HwDiagCtrl_ForceIBCBusToSPCParityErr_1_RMASK 0x1
 #define QIB_7322_HwDiagCtrl_ForceIBCBusFromSPCParityErr_0_LSB 0xD
 #define QIB_7322_HwDiagCtrl_ForceIBCBusFromSPCParityErr_0_MSB 0xD
 #define QIB_7322_HwDiagCtrl_ForceIBCBusFromSPCParityErr_0_RMASK 0x1
-#define QIB_7322_HwDiagCtrl_ForcestatusValidNoEop_0_LSB 0xC
-#define QIB_7322_HwDiagCtrl_ForcestatusValidNoEop_0_MSB 0xC
-#define QIB_7322_HwDiagCtrl_ForcestatusValidNoEop_0_RMASK 0x1
+#define QIB_7322_HwDiagCtrl_ForceIBCBusToSPCParityErr_0_LSB 0xC
+#define QIB_7322_HwDiagCtrl_ForceIBCBusToSPCParityErr_0_MSB 0xC
+#define QIB_7322_HwDiagCtrl_ForceIBCBusToSPCParityErr_0_RMASK 0x1
 
 #define QIB_7322_EXTStatus_OFFS 0xC0
 #define QIB_7322_EXTStatus_DEF 0x000000000000X000
diff --git a/drivers/infiniband/hw/qib/qib_diag.c b/drivers/infiniband/hw/qib/qib_diag.c
index ca98dd523752..05dcf0d9a7d3 100644
--- a/drivers/infiniband/hw/qib/qib_diag.c
+++ b/drivers/infiniband/hw/qib/qib_diag.c
@@ -233,6 +233,7 @@ static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
         u32 __iomem *krb32 = (u32 __iomem *)dd->kregbase;
         u32 __iomem *map = NULL;
         u32 cnt = 0;
+        u32 tot4k, offs4k;
 
         /* First, simplest case, offset is within the first map. */
         kreglen = (dd->kregend - dd->kregbase) * sizeof(u64);
@@ -250,7 +251,8 @@ static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
         if (dd->userbase) {
                 /* If user regs mapped, they are after send, so set limit. */
                 u32 ulim = (dd->cfgctxts * dd->ureg_align) + dd->uregbase;
-                snd_lim = dd->uregbase;
+                if (!dd->piovl15base)
+                        snd_lim = dd->uregbase;
                 krb32 = (u32 __iomem *)dd->userbase;
                 if (offset >= dd->uregbase && offset < ulim) {
                         map = krb32 + (offset - dd->uregbase) / sizeof(u32);
@@ -277,14 +279,14 @@ static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
         /* If 4k buffers exist, account for them by bumping
          * appropriate limit.
          */
+        tot4k = dd->piobcnt4k * dd->align4k;
+        offs4k = dd->piobufbase >> 32;
         if (dd->piobcnt4k) {
-                u32 tot4k = dd->piobcnt4k * dd->align4k;
-                u32 offs4k = dd->piobufbase >> 32;
                 if (snd_bottom > offs4k)
                         snd_bottom = offs4k;
                 else {
                         /* 4k above 2k. Bump snd_lim, if needed*/
-                        if (!dd->userbase)
+                        if (!dd->userbase || dd->piovl15base)
                                 snd_lim = offs4k + tot4k;
                 }
         }
@@ -298,6 +300,15 @@ static u32 __iomem *qib_remap_ioaddr32(struct qib_devdata *dd, u32 offset,
                 cnt = snd_lim - offset;
         }
 
+        if (!map && offs4k && dd->piovl15base) {
+                snd_lim = offs4k + tot4k + 2 * dd->align4k;
+                if (offset >= (offs4k + tot4k) && offset < snd_lim) {
+                        map = (u32 __iomem *)dd->piovl15base +
+                                ((offset - (offs4k + tot4k)) / sizeof(u32));
+                        cnt = snd_lim - offset;
+                }
+        }
+
 mapped:
         if (cntp)
                 *cntp = cnt;
diff --git a/drivers/infiniband/hw/qib/qib_iba6120.c b/drivers/infiniband/hw/qib/qib_iba6120.c
index 1eadadc13da8..a5e29dbb9537 100644
--- a/drivers/infiniband/hw/qib/qib_iba6120.c
+++ b/drivers/infiniband/hw/qib/qib_iba6120.c
@@ -1355,8 +1355,7 @@ static int qib_6120_bringup_serdes(struct qib_pportdata *ppd)
         hwstat = qib_read_kreg64(dd, kr_hwerrstatus);
         if (hwstat) {
                 /* should just have PLL, clear all set, in an case */
-                if (hwstat & ~QLOGIC_IB_HWE_SERDESPLLFAILED)
-                        qib_write_kreg(dd, kr_hwerrclear, hwstat);
+                qib_write_kreg(dd, kr_hwerrclear, hwstat);
                 qib_write_kreg(dd, kr_errclear, ERR_MASK(HardwareErr));
         }
 
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index 503992d9c5ce..5eedf83e2c3b 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -543,7 +543,7 @@ struct vendor_txdds_ent {
 static void write_tx_serdes_param(struct qib_pportdata *, struct txdds_ent *);
 
 #define TXDDS_TABLE_SZ 16 /* number of entries per speed in onchip table */
-#define TXDDS_EXTRA_SZ 11 /* number of extra tx settings entries */
+#define TXDDS_EXTRA_SZ 13 /* number of extra tx settings entries */
 #define SERDES_CHANS 4 /* yes, it's obvious, but one less magic number */
 
 #define H1_FORCE_VAL 8
@@ -1100,9 +1100,9 @@ static const struct qib_hwerror_msgs qib_7322_hwerror_msgs[] = {
         HWE_AUTO_P(SDmaMemReadErr, 1),
         HWE_AUTO_P(SDmaMemReadErr, 0),
         HWE_AUTO_P(IBCBusFromSPCParityErr, 1),
+        HWE_AUTO_P(IBCBusToSPCParityErr, 1),
         HWE_AUTO_P(IBCBusFromSPCParityErr, 0),
-        HWE_AUTO_P(statusValidNoEop, 1),
-        HWE_AUTO_P(statusValidNoEop, 0),
+        HWE_AUTO(statusValidNoEop),
         HWE_AUTO(LATriggered),
         { .mask = 0 }
 };
@@ -4763,6 +4763,8 @@ static void qib_7322_mini_pcs_reset(struct qib_pportdata *ppd)
                 SYM_MASK(IBPCSConfig_0, tx_rx_reset);
 
         val = qib_read_kreg_port(ppd, krp_ib_pcsconfig);
+        qib_write_kreg(dd, kr_hwerrmask,
+                       dd->cspec->hwerrmask & ~HWE_MASK(statusValidNoEop));
         qib_write_kreg_port(ppd, krp_ibcctrl_a,
                             ppd->cpspec->ibcctrl_a &
                             ~SYM_MASK(IBCCtrlA_0, IBLinkEn));
@@ -4772,6 +4774,9 @@ static void qib_7322_mini_pcs_reset(struct qib_pportdata *ppd)
         qib_write_kreg_port(ppd, krp_ib_pcsconfig, val & ~reset_bits);
         qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a);
         qib_write_kreg(dd, kr_scratch, 0ULL);
+        qib_write_kreg(dd, kr_hwerrclear,
+                       SYM_MASK(HwErrClear, statusValidNoEopClear));
+        qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
 }
 
 /*
@@ -5624,6 +5629,8 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
                         if (ppd->port != port || !ppd->link_speed_supported)
                                 continue;
                         ppd->cpspec->no_eep = val;
+                        if (seth1)
+                                ppd->cpspec->h1_val = h1;
                         /* now change the IBC and serdes, overriding generic */
                         init_txdds_table(ppd, 1);
                         any++;
@@ -6064,9 +6071,9 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                  * the "cable info" setup here.  Can be overridden
                  * in adapter-specific routines.
                  */
-                if (!(ppd->dd->flags & QIB_HAS_QSFP)) {
-                        if (!IS_QMH(ppd->dd) && !IS_QME(ppd->dd))
-                                qib_devinfo(ppd->dd->pcidev, "IB%u:%u: "
+                if (!(dd->flags & QIB_HAS_QSFP)) {
+                        if (!IS_QMH(dd) && !IS_QME(dd))
+                                qib_devinfo(dd->pcidev, "IB%u:%u: "
                                             "Unknown mezzanine card type\n",
                                             dd->unit, ppd->port);
                         cp->h1_val = IS_QMH(dd) ? H1_FORCE_QMH : H1_FORCE_QME;
@@ -6119,9 +6126,25 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
         qib_set_ctxtcnt(dd);
 
         if (qib_wc_pat) {
-                ret = init_chip_wc_pat(dd, NUM_VL15_BUFS * dd->align4k);
+                resource_size_t vl15off;
+                /*
+                 * We do not set WC on the VL15 buffers to avoid
+                 * a rare problem with unaligned writes from
+                 * interrupt-flushed store buffers, so we need
+                 * to map those separately here.  We can't solve
+                 * this for the rarely used mtrr case.
+                 */
+                ret = init_chip_wc_pat(dd, 0);
                 if (ret)
                         goto bail;
+
+                /* vl15 buffers start just after the 4k buffers */
+                vl15off = dd->physaddr + (dd->piobufbase >> 32) +
+                        dd->piobcnt4k * dd->align4k;
+                dd->piovl15base = ioremap_nocache(vl15off,
+                                                  NUM_VL15_BUFS * dd->align4k);
+                if (!dd->piovl15base)
+                        goto bail;
         }
         qib_7322_set_baseaddrs(dd); /* set chip access pointers now */
 
@@ -6932,6 +6955,8 @@ static const struct txdds_ent txdds_extra_sdr[TXDDS_EXTRA_SZ] = {
         {  0, 0, 0, 11 },       /* QME7342 backplane settings */
         {  0, 0, 0, 11 },       /* QME7342 backplane settings */
         {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0,  3 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  4 },       /* QMH7342 backplane settings */
 };
 
 static const struct txdds_ent txdds_extra_ddr[TXDDS_EXTRA_SZ] = {
@@ -6947,6 +6972,8 @@ static const struct txdds_ent txdds_extra_ddr[TXDDS_EXTRA_SZ] = {
         {  0, 0, 0, 13 },       /* QME7342 backplane settings */
         {  0, 0, 0, 13 },       /* QME7342 backplane settings */
         {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0,  9 },       /* QMH7342 backplane settings */
+        {  0, 0, 0, 10 },       /* QMH7342 backplane settings */
 };
 
 static const struct txdds_ent txdds_extra_qdr[TXDDS_EXTRA_SZ] = {
@@ -6962,6 +6989,8 @@ static const struct txdds_ent txdds_extra_qdr[TXDDS_EXTRA_SZ] = {
         {  0, 1, 12,  6 },      /* QME7342 backplane setting */
         {  0, 1, 12,  7 },      /* QME7342 backplane setting */
         {  0, 1, 12,  8 },      /* QME7342 backplane setting */
+        {  0, 1,  0, 10 },      /* QMH7342 backplane settings */
+        {  0, 1,  0, 12 },      /* QMH7342 backplane settings */
 };
 
 static const struct txdds_ent *get_atten_table(const struct txdds_ent *txdds,
diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c
index 9b40f345ac3f..a873dd596e81 100644
--- a/drivers/infiniband/hw/qib/qib_init.c
+++ b/drivers/infiniband/hw/qib/qib_init.c
@@ -1059,7 +1059,7 @@ static int __init qlogic_ib_init(void)
                 goto bail_dev;
         }
 
-        qib_cq_wq = create_workqueue("qib_cq");
+        qib_cq_wq = create_singlethread_workqueue("qib_cq");
         if (!qib_cq_wq) {
                 ret = -ENOMEM;
                 goto bail_wq;
@@ -1289,8 +1289,18 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
 
         if (qib_mini_init || initfail || ret) {
                 qib_stop_timers(dd);
+                flush_scheduled_work();
                 for (pidx = 0; pidx < dd->num_pports; ++pidx)
                         dd->f_quiet_serdes(dd->pport + pidx);
+                if (qib_mini_init)
+                        goto bail;
+                if (!j) {
+                        (void) qibfs_remove(dd);
+                        qib_device_remove(dd);
+                }
+                if (!ret)
+                        qib_unregister_ib_device(dd);
+                qib_postinit_cleanup(dd);
                 if (initfail)
                         ret = initfail;
                 goto bail;
@@ -1472,6 +1482,9 @@ int qib_setup_eagerbufs(struct qib_ctxtdata *rcd)
                 dma_addr_t pa = rcd->rcvegrbuf_phys[chunk];
                 unsigned i;
 
+                /* clear for security and sanity on each use */
+                memset(rcd->rcvegrbuf[chunk], 0, size);
+
                 for (i = 0; e < egrcnt && i < egrperchunk; e++, i++) {
                         dd->f_put_tid(dd, e + egroff +
                                           (u64 __iomem *)
@@ -1499,6 +1512,12 @@ bail:
         return -ENOMEM;
 }
 
+/*
+ * Note: Changes to this routine should be mirrored
+ * for the diagnostics routine qib_remap_ioaddr32().
+ * There is also related code for VL15 buffers in qib_init_7322_variables().
+ * The teardown code that unmaps is in qib_pcie_ddcleanup()
+ */
 int init_chip_wc_pat(struct qib_devdata *dd, u32 vl15buflen)
 {
         u64 __iomem *qib_kregbase = NULL;
diff --git a/drivers/infiniband/hw/qib/qib_pcie.c b/drivers/infiniband/hw/qib/qib_pcie.c
index c926bf4541df..7fa6e5592630 100644
--- a/drivers/infiniband/hw/qib/qib_pcie.c
+++ b/drivers/infiniband/hw/qib/qib_pcie.c
@@ -179,6 +179,8 @@ void qib_pcie_ddcleanup(struct qib_devdata *dd)
                 iounmap(dd->piobase);
         if (dd->userbase)
                 iounmap(dd->userbase);
+        if (dd->piovl15base)
+                iounmap(dd->piovl15base);
 
         pci_disable_device(dd->pcidev);
         pci_release_regions(dd->pcidev);
diff --git a/drivers/infiniband/hw/qib/qib_sd7220.c b/drivers/infiniband/hw/qib/qib_sd7220.c
index 0aeed0e74cb6..e9f9f8bc3204 100644
--- a/drivers/infiniband/hw/qib/qib_sd7220.c
+++ b/drivers/infiniband/hw/qib/qib_sd7220.c
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -37,10 +38,14 @@
 
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/firmware.h>
 
 #include "qib.h"
 #include "qib_7220.h"
 
+#define SD7220_FW_NAME "qlogic/sd7220.fw"
+MODULE_FIRMWARE(SD7220_FW_NAME);
+
 /*
  * Same as in qib_iba7220.c, but just the registers needed here.
  * Could move whole set to qib_7220.h, but decided better to keep
@@ -102,6 +107,10 @@ static int qib_internal_presets(struct qib_devdata *dd);
 /* Tweak the register (CMUCTRL5) that contains the TRIMSELF controls */
 static int qib_sd_trimself(struct qib_devdata *dd, int val);
 static int epb_access(struct qib_devdata *dd, int sdnum, int claim);
+static int qib_sd7220_ib_load(struct qib_devdata *dd,
+                              const struct firmware *fw);
+static int qib_sd7220_ib_vfy(struct qib_devdata *dd,
+                             const struct firmware *fw);
 
 /*
  * Below keeps track of whether the "once per power-on" initialization has
@@ -110,10 +119,13 @@ static int epb_access(struct qib_devdata *dd, int sdnum, int claim);
  * state of the reset "pin", is no longer valid. Instead, we check for the
  * actual uC code having been loaded.
  */
-static int qib_ibsd_ucode_loaded(struct qib_pportdata *ppd)
+static int qib_ibsd_ucode_loaded(struct qib_pportdata *ppd,
+                                 const struct firmware *fw)
 {
         struct qib_devdata *dd = ppd->dd;
-        if (!dd->cspec->serdes_first_init_done && (qib_sd7220_ib_vfy(dd) > 0))
+
+        if (!dd->cspec->serdes_first_init_done &&
+            qib_sd7220_ib_vfy(dd, fw) > 0)
                 dd->cspec->serdes_first_init_done = 1;
         return dd->cspec->serdes_first_init_done;
 }
@@ -377,6 +389,7 @@ static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
  */
 int qib_sd7220_init(struct qib_devdata *dd)
 {
+        const struct firmware *fw;
         int ret = 1; /* default to failure */
         int first_reset, was_reset;
 
@@ -387,8 +400,15 @@ int qib_sd7220_init(struct qib_devdata *dd)
                 qib_ibsd_reset(dd, 1);
                 qib_sd_trimdone_monitor(dd, "Driver-reload");
         }
+
+        ret = request_firmware(&fw, SD7220_FW_NAME, &dd->pcidev->dev);
+        if (ret) {
+                qib_dev_err(dd, "Failed to load IB SERDES image\n");
+                goto done;
+        }
+
         /* Substitute our deduced value for was_reset */
-        ret = qib_ibsd_ucode_loaded(dd->pport);
+        ret = qib_ibsd_ucode_loaded(dd->pport, fw);
         if (ret < 0)
                 goto bail;
 
@@ -437,13 +457,13 @@ int qib_sd7220_init(struct qib_devdata *dd)
                 int vfy;
                 int trim_done;
 
-                ret = qib_sd7220_ib_load(dd);
+                ret = qib_sd7220_ib_load(dd, fw);
                 if (ret < 0) {
                         qib_dev_err(dd, "Failed to load IB SERDES image\n");
                         goto bail;
                 } else {
                         /* Loaded image, try to verify */
-                        vfy = qib_sd7220_ib_vfy(dd);
+                        vfy = qib_sd7220_ib_vfy(dd, fw);
                         if (vfy != ret) {
                                 qib_dev_err(dd, "SERDES PRAM VFY failed\n");
                                 goto bail;
@@ -506,6 +526,8 @@ bail:
 done:
         /* start relock timer regardless, but start at 1 second */
         set_7220_relock_poll(dd, -1);
+
+        release_firmware(fw);
         return ret;
 }
 
@@ -829,8 +851,8 @@ static int qib_sd7220_ram_xfer(struct qib_devdata *dd, int sdnum, u32 loc,
 
 #define PROG_CHUNK 64
 
-int qib_sd7220_prog_ld(struct qib_devdata *dd, int sdnum,
-                       u8 *img, int len, int offset)
+static int qib_sd7220_prog_ld(struct qib_devdata *dd, int sdnum,
+                              const u8 *img, int len, int offset)
 {
         int cnt, sofar, req;
 
@@ -840,7 +862,7 @@ int qib_sd7220_prog_ld(struct qib_devdata *dd, int sdnum,
                 if (req > PROG_CHUNK)
                         req = PROG_CHUNK;
                 cnt = qib_sd7220_ram_xfer(dd, sdnum, offset + sofar,
-                                          img + sofar, req, 0);
+                                          (u8 *)img + sofar, req, 0);
                 if (cnt < req) {
                         sofar = -1;
                         break;
@@ -853,8 +875,8 @@ int qib_sd7220_prog_ld(struct qib_devdata *dd, int sdnum,
 #define VFY_CHUNK 64
 #define SD_PRAM_ERROR_LIMIT 42
 
-int qib_sd7220_prog_vfy(struct qib_devdata *dd, int sdnum,
-                        const u8 *img, int len, int offset)
+static int qib_sd7220_prog_vfy(struct qib_devdata *dd, int sdnum,
+                               const u8 *img, int len, int offset)
 {
         int cnt, sofar, req, idx, errors;
         unsigned char readback[VFY_CHUNK];
@@ -881,6 +903,18 @@ int qib_sd7220_prog_vfy(struct qib_devdata *dd, int sdnum,
         return errors ? -errors : sofar;
 }
 
+static int
+qib_sd7220_ib_load(struct qib_devdata *dd, const struct firmware *fw)
+{
+        return qib_sd7220_prog_ld(dd, IB_7220_SERDES, fw->data, fw->size, 0);
+}
+
+static int
+qib_sd7220_ib_vfy(struct qib_devdata *dd, const struct firmware *fw)
+{
+        return qib_sd7220_prog_vfy(dd, IB_7220_SERDES, fw->data, fw->size, 0);
+}
+
 /*
  * IRQ not set up at this point in init, so we poll.
  */
diff --git a/drivers/infiniband/hw/qib/qib_sd7220_img.c b/drivers/infiniband/hw/qib/qib_sd7220_img.c
deleted file mode 100644
index a1118fbd2370..000000000000
--- a/drivers/infiniband/hw/qib/qib_sd7220_img.c
+++ /dev/null
@@ -1,1081 +0,0 @@
-/*
- * Copyright (c) 2007, 2008 QLogic Corporation. All rights reserved.
- *
- * This software is available to you under a choice of one of two
- * licenses.  You may choose to be licensed under the terms of the GNU
- * General Public License (GPL) Version 2, available from the file
- * COPYING in the main directory of this source tree, or the
- * OpenIB.org BSD license below:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      - Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *
- *      - Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * This file contains the memory image from the vendor, to be copied into
- * the IB SERDES of the IBA7220 during initialization.
- * The file also includes the two functions which use this image.
- */
-#include <linux/pci.h>
-#include <linux/delay.h>
-
-#include "qib.h"
-#include "qib_7220.h"
-
-static unsigned char qib_sd7220_ib_img[] = {
-/*0000*/0x02, 0x0A, 0x29, 0x02, 0x0A, 0x87, 0xE5, 0xE6,
-        0x30, 0xE6, 0x04, 0x7F, 0x01, 0x80, 0x02, 0x7F,
-/*0010*/0x00, 0xE5, 0xE2, 0x30, 0xE4, 0x04, 0x7E, 0x01,
-        0x80, 0x02, 0x7E, 0x00, 0xEE, 0x5F, 0x60, 0x08,
-/*0020*/0x53, 0xF9, 0xF7, 0xE4, 0xF5, 0xFE, 0x80, 0x08,
-        0x7F, 0x0A, 0x12, 0x17, 0x31, 0x12, 0x0E, 0xA2,
-/*0030*/0x75, 0xFC, 0x08, 0xE4, 0xF5, 0xFD, 0xE5, 0xE7,
-        0x20, 0xE7, 0x03, 0x43, 0xF9, 0x08, 0x22, 0x00,
-/*0040*/0x01, 0x20, 0x11, 0x00, 0x04, 0x20, 0x00, 0x75,
-        0x51, 0x01, 0xE4, 0xF5, 0x52, 0xF5, 0x53, 0xF5,
-/*0050*/0x52, 0xF5, 0x7E, 0x7F, 0x04, 0x02, 0x04, 0x38,
-        0xC2, 0x36, 0x05, 0x52, 0xE5, 0x52, 0xD3, 0x94,
-/*0060*/0x0C, 0x40, 0x05, 0x75, 0x52, 0x01, 0xD2, 0x36,
-        0x90, 0x07, 0x0C, 0x74, 0x07, 0xF0, 0xA3, 0x74,
-/*0070*/0xFF, 0xF0, 0xE4, 0xF5, 0x0C, 0xA3, 0xF0, 0x90,
-        0x07, 0x14, 0xF0, 0xA3, 0xF0, 0x75, 0x0B, 0x20,
-/*0080*/0xF5, 0x09, 0xE4, 0xF5, 0x08, 0xE5, 0x08, 0xD3,
-        0x94, 0x30, 0x40, 0x03, 0x02, 0x04, 0x04, 0x12,
-/*0090*/0x00, 0x06, 0x15, 0x0B, 0xE5, 0x08, 0x70, 0x04,
-        0x7F, 0x01, 0x80, 0x02, 0x7F, 0x00, 0xE5, 0x09,
-/*00A0*/0x70, 0x04, 0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00,
-        0xEE, 0x5F, 0x60, 0x05, 0x12, 0x18, 0x71, 0xD2,
-/*00B0*/0x35, 0x53, 0xE1, 0xF7, 0xE5, 0x08, 0x45, 0x09,
-        0xFF, 0xE5, 0x0B, 0x25, 0xE0, 0x25, 0xE0, 0x24,
-/*00C0*/0x83, 0xF5, 0x82, 0xE4, 0x34, 0x07, 0xF5, 0x83,
-        0xEF, 0xF0, 0x85, 0xE2, 0x20, 0xE5, 0x52, 0xD3,
-/*00D0*/0x94, 0x01, 0x40, 0x0D, 0x12, 0x19, 0xF3, 0xE0,
-        0x54, 0xA0, 0x64, 0x40, 0x70, 0x03, 0x02, 0x03,
-/*00E0*/0xFB, 0x53, 0xF9, 0xF8, 0x90, 0x94, 0x70, 0xE4,
-        0xF0, 0xE0, 0xF5, 0x10, 0xAF, 0x09, 0x12, 0x1E,
-/*00F0*/0xB3, 0xAF, 0x08, 0xEF, 0x44, 0x08, 0xF5, 0x82,
-        0x75, 0x83, 0x80, 0xE0, 0xF5, 0x29, 0xEF, 0x44,
-/*0100*/0x07, 0x12, 0x1A, 0x3C, 0xF5, 0x22, 0x54, 0x40,
-        0xD3, 0x94, 0x00, 0x40, 0x1E, 0xE5, 0x29, 0x54,
-/*0110*/0xF0, 0x70, 0x21, 0x12, 0x19, 0xF3, 0xE0, 0x44,
-        0x80, 0xF0, 0xE5, 0x22, 0x54, 0x30, 0x65, 0x08,
-/*0120*/0x70, 0x09, 0x12, 0x19, 0xF3, 0xE0, 0x54, 0xBF,
-        0xF0, 0x80, 0x09, 0x12, 0x19, 0xF3, 0x74, 0x40,
-/*0130*/0xF0, 0x02, 0x03, 0xFB, 0x12, 0x1A, 0x12, 0x75,
-        0x83, 0xAE, 0x74, 0xFF, 0xF0, 0xAF, 0x08, 0x7E,
-/*0140*/0x00, 0xEF, 0x44, 0x07, 0xF5, 0x82, 0xE0, 0xFD,
-        0xE5, 0x0B, 0x25, 0xE0, 0x25, 0xE0, 0x24, 0x81,
-/*0150*/0xF5, 0x82, 0xE4, 0x34, 0x07, 0xF5, 0x83, 0xED,
-        0xF0, 0x90, 0x07, 0x0E, 0xE0, 0x04, 0xF0, 0xEF,
-/*0160*/0x44, 0x07, 0xF5, 0x82, 0x75, 0x83, 0x98, 0xE0,
-        0xF5, 0x28, 0x12, 0x1A, 0x23, 0x40, 0x0C, 0x12,
-/*0170*/0x19, 0xF3, 0xE0, 0x44, 0x01, 0x12, 0x1A, 0x32,
-        0x02, 0x03, 0xF6, 0xAF, 0x08, 0x7E, 0x00, 0x74,
-/*0180*/0x80, 0xCD, 0xEF, 0xCD, 0x8D, 0x82, 0xF5, 0x83,
-        0xE0, 0x30, 0xE0, 0x0A, 0x12, 0x19, 0xF3, 0xE0,
-/*0190*/0x44, 0x20, 0xF0, 0x02, 0x03, 0xFB, 0x12, 0x19,
-        0xF3, 0xE0, 0x54, 0xDF, 0xF0, 0xEE, 0x44, 0xAE,
-/*01A0*/0x12, 0x1A, 0x43, 0x30, 0xE4, 0x03, 0x02, 0x03,
-        0xFB, 0x74, 0x9E, 0x12, 0x1A, 0x05, 0x20, 0xE0,
-/*01B0*/0x03, 0x02, 0x03, 0xFB, 0x8F, 0x82, 0x8E, 0x83,
-        0xE0, 0x20, 0xE0, 0x03, 0x02, 0x03, 0xFB, 0x12,
-/*01C0*/0x19, 0xF3, 0xE0, 0x44, 0x10, 0xF0, 0xE5, 0xE3,
-        0x20, 0xE7, 0x08, 0xE5, 0x08, 0x12, 0x1A, 0x3A,
-/*01D0*/0x44, 0x04, 0xF0, 0xAF, 0x08, 0x7E, 0x00, 0xEF,
-        0x12, 0x1A, 0x3A, 0x20, 0xE2, 0x34, 0x12, 0x19,
-/*01E0*/0xF3, 0xE0, 0x44, 0x08, 0xF0, 0xE5, 0xE4, 0x30,
-        0xE6, 0x04, 0x7D, 0x01, 0x80, 0x02, 0x7D, 0x00,
-/*01F0*/0xE5, 0x7E, 0xC3, 0x94, 0x04, 0x50, 0x04, 0x7C,
-        0x01, 0x80, 0x02, 0x7C, 0x00, 0xEC, 0x4D, 0x60,
-/*0200*/0x05, 0xC2, 0x35, 0x02, 0x03, 0xFB, 0xEE, 0x44,
-        0xD2, 0x12, 0x1A, 0x43, 0x44, 0x40, 0xF0, 0x02,
-/*0210*/0x03, 0xFB, 0x12, 0x19, 0xF3, 0xE0, 0x54, 0xF7,
-        0xF0, 0x12, 0x1A, 0x12, 0x75, 0x83, 0xD2, 0xE0,
-/*0220*/0x54, 0xBF, 0xF0, 0x90, 0x07, 0x14, 0xE0, 0x04,
-        0xF0, 0xE5, 0x7E, 0x70, 0x03, 0x75, 0x7E, 0x01,
-/*0230*/0xAF, 0x08, 0x7E, 0x00, 0x12, 0x1A, 0x23, 0x40,
-        0x12, 0x12, 0x19, 0xF3, 0xE0, 0x44, 0x01, 0x12,
-/*0240*/0x19, 0xF2, 0xE0, 0x54, 0x02, 0x12, 0x1A, 0x32,
-        0x02, 0x03, 0xFB, 0x12, 0x19, 0xF3, 0xE0, 0x44,
-/*0250*/0x02, 0x12, 0x19, 0xF2, 0xE0, 0x54, 0xFE, 0xF0,
-        0xC2, 0x35, 0xEE, 0x44, 0x8A, 0x8F, 0x82, 0xF5,
-/*0260*/0x83, 0xE0, 0xF5, 0x17, 0x54, 0x8F, 0x44, 0x40,
-        0xF0, 0x74, 0x90, 0xFC, 0xE5, 0x08, 0x44, 0x07,
-/*0270*/0xFD, 0xF5, 0x82, 0x8C, 0x83, 0xE0, 0x54, 0x3F,
-        0x90, 0x07, 0x02, 0xF0, 0xE0, 0x54, 0xC0, 0x8D,
-/*0280*/0x82, 0x8C, 0x83, 0xF0, 0x74, 0x92, 0x12, 0x1A,
-        0x05, 0x90, 0x07, 0x03, 0x12, 0x1A, 0x19, 0x74,
-/*0290*/0x82, 0x12, 0x1A, 0x05, 0x90, 0x07, 0x04, 0x12,
-        0x1A, 0x19, 0x74, 0xB4, 0x12, 0x1A, 0x05, 0x90,
-/*02A0*/0x07, 0x05, 0x12, 0x1A, 0x19, 0x74, 0x94, 0xFE,
-        0xE5, 0x08, 0x44, 0x06, 0x12, 0x1A, 0x0A, 0xF5,
-/*02B0*/0x10, 0x30, 0xE0, 0x04, 0xD2, 0x37, 0x80, 0x02,
-        0xC2, 0x37, 0xE5, 0x10, 0x54, 0x7F, 0x8F, 0x82,
-/*02C0*/0x8E, 0x83, 0xF0, 0x30, 0x44, 0x30, 0x12, 0x1A,
-        0x03, 0x54, 0x80, 0xD3, 0x94, 0x00, 0x40, 0x04,
-/*02D0*/0xD2, 0x39, 0x80, 0x02, 0xC2, 0x39, 0x8F, 0x82,
-        0x8E, 0x83, 0xE0, 0x44, 0x80, 0xF0, 0x12, 0x1A,
-/*02E0*/0x03, 0x54, 0x40, 0xD3, 0x94, 0x00, 0x40, 0x04,
-        0xD2, 0x3A, 0x80, 0x02, 0xC2, 0x3A, 0x8F, 0x82,
-/*02F0*/0x8E, 0x83, 0xE0, 0x44, 0x40, 0xF0, 0x74, 0x92,
-        0xFE, 0xE5, 0x08, 0x44, 0x06, 0x12, 0x1A, 0x0A,
-/*0300*/0x30, 0xE7, 0x04, 0xD2, 0x38, 0x80, 0x02, 0xC2,
-        0x38, 0x8F, 0x82, 0x8E, 0x83, 0xE0, 0x54, 0x7F,
-/*0310*/0xF0, 0x12, 0x1E, 0x46, 0xE4, 0xF5, 0x0A, 0x20,
-        0x03, 0x02, 0x80, 0x03, 0x30, 0x43, 0x03, 0x12,
-/*0320*/0x19, 0x95, 0x20, 0x02, 0x02, 0x80, 0x03, 0x30,
-        0x42, 0x03, 0x12, 0x0C, 0x8F, 0x30, 0x30, 0x06,
-/*0330*/0x12, 0x19, 0x95, 0x12, 0x0C, 0x8F, 0x12, 0x0D,
-        0x47, 0x12, 0x19, 0xF3, 0xE0, 0x54, 0xFB, 0xF0,
-/*0340*/0xE5, 0x0A, 0xC3, 0x94, 0x01, 0x40, 0x46, 0x43,
-        0xE1, 0x08, 0x12, 0x19, 0xF3, 0xE0, 0x44, 0x04,
-/*0350*/0xF0, 0xE5, 0xE4, 0x20, 0xE7, 0x2A, 0x12, 0x1A,
-        0x12, 0x75, 0x83, 0xD2, 0xE0, 0x54, 0x08, 0xD3,
-/*0360*/0x94, 0x00, 0x40, 0x04, 0x7F, 0x01, 0x80, 0x02,
-        0x7F, 0x00, 0xE5, 0x0A, 0xC3, 0x94, 0x01, 0x40,
-/*0370*/0x04, 0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00, 0xEF,
-        0x5E, 0x60, 0x05, 0x12, 0x1D, 0xD7, 0x80, 0x17,
-/*0380*/0x12, 0x1A, 0x12, 0x75, 0x83, 0xD2, 0xE0, 0x44,
-        0x08, 0xF0, 0x02, 0x03, 0xFB, 0x12, 0x1A, 0x12,
-/*0390*/0x75, 0x83, 0xD2, 0xE0, 0x54, 0xF7, 0xF0, 0x12,
-        0x1E, 0x46, 0x7F, 0x08, 0x12, 0x17, 0x31, 0x74,
-/*03A0*/0x8E, 0xFE, 0x12, 0x1A, 0x12, 0x8E, 0x83, 0xE0,
-        0xF5, 0x10, 0x54, 0xFE, 0xF0, 0xE5, 0x10, 0x44,
-/*03B0*/0x01, 0xFF, 0xE5, 0x08, 0xFD, 0xED, 0x44, 0x07,
-        0xF5, 0x82, 0xEF, 0xF0, 0xE5, 0x10, 0x54, 0xFE,
-/*03C0*/0xFF, 0xED, 0x44, 0x07, 0xF5, 0x82, 0xEF, 0x12,
-        0x1A, 0x11, 0x75, 0x83, 0x86, 0xE0, 0x44, 0x10,
-/*03D0*/0x12, 0x1A, 0x11, 0xE0, 0x44, 0x10, 0xF0, 0x12,
-        0x19, 0xF3, 0xE0, 0x54, 0xFD, 0x44, 0x01, 0xFF,
-/*03E0*/0x12, 0x19, 0xF3, 0xEF, 0x12, 0x1A, 0x32, 0x30,
-        0x32, 0x0C, 0xE5, 0x08, 0x44, 0x08, 0xF5, 0x82,
-/*03F0*/0x75, 0x83, 0x82, 0x74, 0x05, 0xF0, 0xAF, 0x0B,
-        0x12, 0x18, 0xD7, 0x74, 0x10, 0x25, 0x08, 0xF5,
-/*0400*/0x08, 0x02, 0x00, 0x85, 0x05, 0x09, 0xE5, 0x09,
-        0xD3, 0x94, 0x07, 0x50, 0x03, 0x02, 0x00, 0x82,
-/*0410*/0xE5, 0x7E, 0xD3, 0x94, 0x00, 0x40, 0x04, 0x7F,
-        0x01, 0x80, 0x02, 0x7F, 0x00, 0xE5, 0x7E, 0xC3,
-/*0420*/0x94, 0xFA, 0x50, 0x04, 0x7E, 0x01, 0x80, 0x02,
-        0x7E, 0x00, 0xEE, 0x5F, 0x60, 0x02, 0x05, 0x7E,
-/*0430*/0x30, 0x35, 0x0B, 0x43, 0xE1, 0x01, 0x7F, 0x09,
-        0x12, 0x17, 0x31, 0x02, 0x00, 0x58, 0x53, 0xE1,
-/*0440*/0xFE, 0x02, 0x00, 0x58, 0x8E, 0x6A, 0x8F, 0x6B,
-        0x8C, 0x6C, 0x8D, 0x6D, 0x75, 0x6E, 0x01, 0x75,
-/*0450*/0x6F, 0x01, 0x75, 0x70, 0x01, 0xE4, 0xF5, 0x73,
-        0xF5, 0x74, 0xF5, 0x75, 0x90, 0x07, 0x2F, 0xF0,
-/*0460*/0xF5, 0x3C, 0xF5, 0x3E, 0xF5, 0x46, 0xF5, 0x47,
-        0xF5, 0x3D, 0xF5, 0x3F, 0xF5, 0x6F, 0xE5, 0x6F,
-/*0470*/0x70, 0x0F, 0xE5, 0x6B, 0x45, 0x6A, 0x12, 0x07,
-        0x2A, 0x75, 0x83, 0x80, 0x74, 0x3A, 0xF0, 0x80,
-/*0480*/0x09, 0x12, 0x07, 0x2A, 0x75, 0x83, 0x80, 0x74,
-        0x1A, 0xF0, 0xE4, 0xF5, 0x6E, 0xC3, 0x74, 0x3F,
-/*0490*/0x95, 0x6E, 0xFF, 0x12, 0x08, 0x65, 0x75, 0x83,
-        0x82, 0xEF, 0xF0, 0x12, 0x1A, 0x4D, 0x12, 0x08,
-/*04A0*/0xC6, 0xE5, 0x33, 0xF0, 0x12, 0x08, 0xFA, 0x12,
-        0x08, 0xB1, 0x40, 0xE1, 0xE5, 0x6F, 0x70, 0x0B,
-/*04B0*/0x12, 0x07, 0x2A, 0x75, 0x83, 0x80, 0x74, 0x36,
-        0xF0, 0x80, 0x09, 0x12, 0x07, 0x2A, 0x75, 0x83,
-/*04C0*/0x80, 0x74, 0x16, 0xF0, 0x75, 0x6E, 0x01, 0x12,
-        0x07, 0x2A, 0x75, 0x83, 0xB4, 0xE5, 0x6E, 0xF0,
-/*04D0*/0x12, 0x1A, 0x4D, 0x74, 0x3F, 0x25, 0x6E, 0xF5,
-        0x82, 0xE4, 0x34, 0x00, 0xF5, 0x83, 0xE5, 0x33,
-/*04E0*/0xF0, 0x74, 0xBF, 0x25, 0x6E, 0xF5, 0x82, 0xE4,
-        0x34, 0x00, 0x12, 0x08, 0xB1, 0x40, 0xD8, 0xE4,
-/*04F0*/0xF5, 0x70, 0xF5, 0x46, 0xF5, 0x47, 0xF5, 0x6E,
-        0x12, 0x08, 0xFA, 0xF5, 0x83, 0xE0, 0xFE, 0x12,
-/*0500*/0x08, 0xC6, 0xE0, 0x7C, 0x00, 0x24, 0x00, 0xFF,
-        0xEC, 0x3E, 0xFE, 0xAD, 0x3B, 0xD3, 0xEF, 0x9D,
-/*0510*/0xEE, 0x9C, 0x50, 0x04, 0x7B, 0x01, 0x80, 0x02,
-        0x7B, 0x00, 0xE5, 0x70, 0x70, 0x04, 0x7A, 0x01,
-/*0520*/0x80, 0x02, 0x7A, 0x00, 0xEB, 0x5A, 0x60, 0x06,
-        0x85, 0x6E, 0x46, 0x75, 0x70, 0x01, 0xD3, 0xEF,
-/*0530*/0x9D, 0xEE, 0x9C, 0x50, 0x04, 0x7F, 0x01, 0x80,
-        0x02, 0x7F, 0x00, 0xE5, 0x70, 0xB4, 0x01, 0x04,
-/*0540*/0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00, 0xEF, 0x5E,
-        0x60, 0x03, 0x85, 0x6E, 0x47, 0x05, 0x6E, 0xE5,
-/*0550*/0x6E, 0x64, 0x7F, 0x70, 0xA3, 0xE5, 0x46, 0x60,
-        0x05, 0xE5, 0x47, 0xB4, 0x7E, 0x03, 0x85, 0x46,
-/*0560*/0x47, 0xE5, 0x6F, 0x70, 0x08, 0x85, 0x46, 0x76,
-        0x85, 0x47, 0x77, 0x80, 0x0E, 0xC3, 0x74, 0x7F,
-/*0570*/0x95, 0x46, 0xF5, 0x78, 0xC3, 0x74, 0x7F, 0x95,
-        0x47, 0xF5, 0x79, 0xE5, 0x6F, 0x70, 0x37, 0xE5,
-/*0580*/0x46, 0x65, 0x47, 0x70, 0x0C, 0x75, 0x73, 0x01,
-        0x75, 0x74, 0x01, 0xF5, 0x3C, 0xF5, 0x3D, 0x80,
-/*0590*/0x35, 0xE4, 0xF5, 0x4E, 0xC3, 0xE5, 0x47, 0x95,
-        0x46, 0xF5, 0x3C, 0xC3, 0x13, 0xF5, 0x71, 0x25,
-/*05A0*/0x46, 0xF5, 0x72, 0xC3, 0x94, 0x3F, 0x40, 0x05,
-        0xE4, 0xF5, 0x3D, 0x80, 0x40, 0xC3, 0x74, 0x3F,
-/*05B0*/0x95, 0x72, 0xF5, 0x3D, 0x80, 0x37, 0xE5, 0x46,
-        0x65, 0x47, 0x70, 0x0F, 0x75, 0x73, 0x01, 0x75,
-/*05C0*/0x75, 0x01, 0xF5, 0x3E, 0xF5, 0x3F, 0x75, 0x4E,
-        0x01, 0x80, 0x22, 0xE4, 0xF5, 0x4E, 0xC3, 0xE5,
-/*05D0*/0x47, 0x95, 0x46, 0xF5, 0x3E, 0xC3, 0x13, 0xF5,
-        0x71, 0x25, 0x46, 0xF5, 0x72, 0xD3, 0x94, 0x3F,
-/*05E0*/0x50, 0x05, 0xE4, 0xF5, 0x3F, 0x80, 0x06, 0xE5,
-        0x72, 0x24, 0xC1, 0xF5, 0x3F, 0x05, 0x6F, 0xE5,
-/*05F0*/0x6F, 0xC3, 0x94, 0x02, 0x50, 0x03, 0x02, 0x04,
-        0x6E, 0xE5, 0x6D, 0x45, 0x6C, 0x70, 0x02, 0x80,
-/*0600*/0x04, 0xE5, 0x74, 0x45, 0x75, 0x90, 0x07, 0x2F,
-        0xF0, 0x7F, 0x01, 0xE5, 0x3E, 0x60, 0x04, 0xE5,
-/*0610*/0x3C, 0x70, 0x14, 0xE4, 0xF5, 0x3C, 0xF5, 0x3D,
-        0xF5, 0x3E, 0xF5, 0x3F, 0x12, 0x08, 0xD2, 0x70,
-/*0620*/0x04, 0xF0, 0x02, 0x06, 0xA4, 0x80, 0x7A, 0xE5,
-        0x3C, 0xC3, 0x95, 0x3E, 0x40, 0x07, 0xE5, 0x3C,
-/*0630*/0x95, 0x3E, 0xFF, 0x80, 0x06, 0xC3, 0xE5, 0x3E,
-        0x95, 0x3C, 0xFF, 0xE5, 0x76, 0xD3, 0x95, 0x79,
-/*0640*/0x40, 0x05, 0x85, 0x76, 0x7A, 0x80, 0x03, 0x85,
-        0x79, 0x7A, 0xE5, 0x77, 0xC3, 0x95, 0x78, 0x50,
-/*0650*/0x05, 0x85, 0x77, 0x7B, 0x80, 0x03, 0x85, 0x78,
-        0x7B, 0xE5, 0x7B, 0xD3, 0x95, 0x7A, 0x40, 0x30,
-/*0660*/0xE5, 0x7B, 0x95, 0x7A, 0xF5, 0x3C, 0xF5, 0x3E,
-        0xC3, 0xE5, 0x7B, 0x95, 0x7A, 0x90, 0x07, 0x19,
-/*0670*/0xF0, 0xE5, 0x3C, 0xC3, 0x13, 0xF5, 0x71, 0x25,
-        0x7A, 0xF5, 0x72, 0xC3, 0x94, 0x3F, 0x40, 0x05,
-/*0680*/0xE4, 0xF5, 0x3D, 0x80, 0x1F, 0xC3, 0x74, 0x3F,
-        0x95, 0x72, 0xF5, 0x3D, 0xF5, 0x3F, 0x80, 0x14,
-/*0690*/0xE4, 0xF5, 0x3C, 0xF5, 0x3E, 0x90, 0x07, 0x19,
-        0xF0, 0x12, 0x08, 0xD2, 0x70, 0x03, 0xF0, 0x80,
-/*06A0*/0x03, 0x74, 0x01, 0xF0, 0x12, 0x08, 0x65, 0x75,
-        0x83, 0xD0, 0xE0, 0x54, 0x0F, 0xFE, 0xAD, 0x3C,
-/*06B0*/0x70, 0x02, 0x7E, 0x07, 0xBE, 0x0F, 0x02, 0x7E,
-        0x80, 0xEE, 0xFB, 0xEF, 0xD3, 0x9B, 0x74, 0x80,
-/*06C0*/0xF8, 0x98, 0x40, 0x1F, 0xE4, 0xF5, 0x3C, 0xF5,
-        0x3E, 0x12, 0x08, 0xD2, 0x70, 0x03, 0xF0, 0x80,
-/*06D0*/0x12, 0x74, 0x01, 0xF0, 0xE5, 0x08, 0xFB, 0xEB,
-        0x44, 0x07, 0xF5, 0x82, 0x75, 0x83, 0xD2, 0xE0,
-/*06E0*/0x44, 0x10, 0xF0, 0xE5, 0x08, 0xFB, 0xEB, 0x44,
-        0x09, 0xF5, 0x82, 0x75, 0x83, 0x9E, 0xED, 0xF0,
-/*06F0*/0xEB, 0x44, 0x07, 0xF5, 0x82, 0x75, 0x83, 0xCA,
-        0xED, 0xF0, 0x12, 0x08, 0x65, 0x75, 0x83, 0xCC,
-/*0700*/0xEF, 0xF0, 0x22, 0xE5, 0x08, 0x44, 0x07, 0xF5,
-        0x82, 0x75, 0x83, 0xBC, 0xE0, 0x54, 0xF0, 0xF0,
-/*0710*/0xE5, 0x08, 0x44, 0x07, 0xF5, 0x82, 0x75, 0x83,
-        0xBE, 0xE0, 0x54, 0xF0, 0xF0, 0xE5, 0x08, 0x44,
-/*0720*/0x07, 0xF5, 0x82, 0x75, 0x83, 0xC0, 0xE0, 0x54,
-        0xF0, 0xF0, 0xE5, 0x08, 0x44, 0x07, 0xF5, 0x82,
-/*0730*/0x22, 0xF0, 0x90, 0x07, 0x28, 0xE0, 0xFE, 0xA3,
-        0xE0, 0xF5, 0x82, 0x8E, 0x83, 0x22, 0x85, 0x42,
-/*0740*/0x42, 0x85, 0x41, 0x41, 0x85, 0x40, 0x40, 0x74,
-        0xC0, 0x2F, 0xF5, 0x82, 0x74, 0x02, 0x3E, 0xF5,
-/*0750*/0x83, 0xE5, 0x42, 0xF0, 0x74, 0xE0, 0x2F, 0xF5,
-        0x82, 0x74, 0x02, 0x3E, 0xF5, 0x83, 0x22, 0xE5,
-/*0760*/0x42, 0x29, 0xFD, 0xE4, 0x33, 0xFC, 0xE5, 0x3C,
-        0xC3, 0x9D, 0xEC, 0x64, 0x80, 0xF8, 0x74, 0x80,
-/*0770*/0x98, 0x22, 0xF5, 0x83, 0xE0, 0x90, 0x07, 0x22,
-        0x54, 0x1F, 0xFD, 0xE0, 0xFA, 0xA3, 0xE0, 0xF5,
-/*0780*/0x82, 0x8A, 0x83, 0xED, 0xF0, 0x22, 0x90, 0x07,
-        0x22, 0xE0, 0xFC, 0xA3, 0xE0, 0xF5, 0x82, 0x8C,
-/*0790*/0x83, 0x22, 0x90, 0x07, 0x24, 0xFF, 0xED, 0x44,
-        0x07, 0xCF, 0xF0, 0xA3, 0xEF, 0xF0, 0x22, 0x85,
-/*07A0*/0x38, 0x38, 0x85, 0x39, 0x39, 0x85, 0x3A, 0x3A,
-        0x74, 0xC0, 0x2F, 0xF5, 0x82, 0x74, 0x02, 0x3E,
-/*07B0*/0xF5, 0x83, 0x22, 0x90, 0x07, 0x26, 0xFF, 0xED,
-        0x44, 0x07, 0xCF, 0xF0, 0xA3, 0xEF, 0xF0, 0x22,
-/*07C0*/0xF0, 0x74, 0xA0, 0x2F, 0xF5, 0x82, 0x74, 0x02,
-        0x3E, 0xF5, 0x83, 0x22, 0x74, 0xC0, 0x25, 0x11,
-/*07D0*/0xF5, 0x82, 0xE4, 0x34, 0x01, 0xF5, 0x83, 0x22,
-        0x74, 0x00, 0x25, 0x11, 0xF5, 0x82, 0xE4, 0x34,
-/*07E0*/0x02, 0xF5, 0x83, 0x22, 0x74, 0x60, 0x25, 0x11,
-        0xF5, 0x82, 0xE4, 0x34, 0x03, 0xF5, 0x83, 0x22,
-/*07F0*/0x74, 0x80, 0x25, 0x11, 0xF5, 0x82, 0xE4, 0x34,
-        0x03, 0xF5, 0x83, 0x22, 0x74, 0xE0, 0x25, 0x11,
-/*0800*/0xF5, 0x82, 0xE4, 0x34, 0x03, 0xF5, 0x83, 0x22,
-        0x74, 0x40, 0x25, 0x11, 0xF5, 0x82, 0xE4, 0x34,
-/*0810*/0x06, 0xF5, 0x83, 0x22, 0x74, 0x80, 0x2F, 0xF5,
-        0x82, 0x74, 0x02, 0x3E, 0xF5, 0x83, 0x22, 0xAF,
-/*0820*/0x08, 0x7E, 0x00, 0xEF, 0x44, 0x07, 0xF5, 0x82,
-        0x22, 0xF5, 0x83, 0xE5, 0x82, 0x44, 0x07, 0xF5,
-/*0830*/0x82, 0xE5, 0x40, 0xF0, 0x22, 0x74, 0x40, 0x25,
-        0x11, 0xF5, 0x82, 0xE4, 0x34, 0x02, 0xF5, 0x83,
-/*0840*/0x22, 0x74, 0xC0, 0x25, 0x11, 0xF5, 0x82, 0xE4,
-        0x34, 0x03, 0xF5, 0x83, 0x22, 0x74, 0x00, 0x25,
-/*0850*/0x11, 0xF5, 0x82, 0xE4, 0x34, 0x06, 0xF5, 0x83,
-        0x22, 0x74, 0x20, 0x25, 0x11, 0xF5, 0x82, 0xE4,
-/*0860*/0x34, 0x06, 0xF5, 0x83, 0x22, 0xE5, 0x08, 0xFD,
-        0xED, 0x44, 0x07, 0xF5, 0x82, 0x22, 0xE5, 0x41,
-/*0870*/0xF0, 0xE5, 0x65, 0x64, 0x01, 0x45, 0x64, 0x22,
-        0x7E, 0x00, 0xFB, 0x7A, 0x00, 0xFD, 0x7C, 0x00,
-/*0880*/0x22, 0x74, 0x20, 0x25, 0x11, 0xF5, 0x82, 0xE4,
-        0x34, 0x02, 0x22, 0x74, 0xA0, 0x25, 0x11, 0xF5,
-/*0890*/0x82, 0xE4, 0x34, 0x03, 0x22, 0x85, 0x3E, 0x42,
-        0x85, 0x3F, 0x41, 0x8F, 0x40, 0x22, 0x85, 0x3C,
-/*08A0*/0x42, 0x85, 0x3D, 0x41, 0x8F, 0x40, 0x22, 0x75,
-        0x45, 0x3F, 0x90, 0x07, 0x20, 0xE4, 0xF0, 0xA3,
-/*08B0*/0x22, 0xF5, 0x83, 0xE5, 0x32, 0xF0, 0x05, 0x6E,
-        0xE5, 0x6E, 0xC3, 0x94, 0x40, 0x22, 0xF0, 0xE5,
-/*08C0*/0x08, 0x44, 0x06, 0xF5, 0x82, 0x22, 0x74, 0x00,
-        0x25, 0x6E, 0xF5, 0x82, 0xE4, 0x34, 0x00, 0xF5,
-/*08D0*/0x83, 0x22, 0xE5, 0x6D, 0x45, 0x6C, 0x90, 0x07,
-        0x2F, 0x22, 0xE4, 0xF9, 0xE5, 0x3C, 0xD3, 0x95,
-/*08E0*/0x3E, 0x22, 0x74, 0x80, 0x2E, 0xF5, 0x82, 0xE4,
-        0x34, 0x02, 0xF5, 0x83, 0xE0, 0x22, 0x74, 0xA0,
-/*08F0*/0x2E, 0xF5, 0x82, 0xE4, 0x34, 0x02, 0xF5, 0x83,
-        0xE0, 0x22, 0x74, 0x80, 0x25, 0x6E, 0xF5, 0x82,
-/*0900*/0xE4, 0x34, 0x00, 0x22, 0x25, 0x42, 0xFD, 0xE4,
-        0x33, 0xFC, 0x22, 0x85, 0x42, 0x42, 0x85, 0x41,
-/*0910*/0x41, 0x85, 0x40, 0x40, 0x22, 0xED, 0x4C, 0x60,
-        0x03, 0x02, 0x09, 0xE5, 0xEF, 0x4E, 0x70, 0x37,
-/*0920*/0x90, 0x07, 0x26, 0x12, 0x07, 0x89, 0xE0, 0xFD,
-        0x12, 0x07, 0xCC, 0xED, 0xF0, 0x90, 0x07, 0x28,
-/*0930*/0x12, 0x07, 0x89, 0xE0, 0xFD, 0x12, 0x07, 0xD8,
-        0xED, 0xF0, 0x12, 0x07, 0x86, 0xE0, 0x54, 0x1F,
-/*0940*/0xFD, 0x12, 0x08, 0x81, 0xF5, 0x83, 0xED, 0xF0,
-        0x90, 0x07, 0x24, 0x12, 0x07, 0x89, 0xE0, 0x54,
-/*0950*/0x1F, 0xFD, 0x12, 0x08, 0x35, 0xED, 0xF0, 0xEF,
-        0x64, 0x04, 0x4E, 0x70, 0x37, 0x90, 0x07, 0x26,
-/*0960*/0x12, 0x07, 0x89, 0xE0, 0xFD, 0x12, 0x07, 0xE4,
-        0xED, 0xF0, 0x90, 0x07, 0x28, 0x12, 0x07, 0x89,
-/*0970*/0xE0, 0xFD, 0x12, 0x07, 0xF0, 0xED, 0xF0, 0x12,
-        0x07, 0x86, 0xE0, 0x54, 0x1F, 0xFD, 0x12, 0x08,
-/*0980*/0x8B, 0xF5, 0x83, 0xED, 0xF0, 0x90, 0x07, 0x24,
-        0x12, 0x07, 0x89, 0xE0, 0x54, 0x1F, 0xFD, 0x12,
-/*0990*/0x08, 0x41, 0xED, 0xF0, 0xEF, 0x64, 0x01, 0x4E,
-        0x70, 0x04, 0x7D, 0x01, 0x80, 0x02, 0x7D, 0x00,
-/*09A0*/0xEF, 0x64, 0x02, 0x4E, 0x70, 0x04, 0x7F, 0x01,
-        0x80, 0x02, 0x7F, 0x00, 0xEF, 0x4D, 0x60, 0x78,
-/*09B0*/0x90, 0x07, 0x26, 0x12, 0x07, 0x35, 0xE0, 0xFF,
-        0x12, 0x07, 0xFC, 0xEF, 0x12, 0x07, 0x31, 0xE0,
-/*09C0*/0xFF, 0x12, 0x08, 0x08, 0xEF, 0xF0, 0x90, 0x07,
-        0x22, 0x12, 0x07, 0x35, 0xE0, 0x54, 0x1F, 0xFF,
-/*09D0*/0x12, 0x08, 0x4D, 0xEF, 0xF0, 0x90, 0x07, 0x24,
-        0x12, 0x07, 0x35, 0xE0, 0x54, 0x1F, 0xFF, 0x12,
-/*09E0*/0x08, 0x59, 0xEF, 0xF0, 0x22, 0x12, 0x07, 0xCC,
-        0xE4, 0xF0, 0x12, 0x07, 0xD8, 0xE4, 0xF0, 0x12,
-/*09F0*/0x08, 0x81, 0xF5, 0x83, 0xE4, 0xF0, 0x12, 0x08,
-        0x35, 0x74, 0x14, 0xF0, 0x12, 0x07, 0xE4, 0xE4,
-/*0A00*/0xF0, 0x12, 0x07, 0xF0, 0xE4, 0xF0, 0x12, 0x08,
-        0x8B, 0xF5, 0x83, 0xE4, 0xF0, 0x12, 0x08, 0x41,
-/*0A10*/0x74, 0x14, 0xF0, 0x12, 0x07, 0xFC, 0xE4, 0xF0,
-        0x12, 0x08, 0x08, 0xE4, 0xF0, 0x12, 0x08, 0x4D,
-/*0A20*/0xE4, 0xF0, 0x12, 0x08, 0x59, 0x74, 0x14, 0xF0,
-        0x22, 0x53, 0xF9, 0xF7, 0x75, 0xFC, 0x10, 0xE4,
-/*0A30*/0xF5, 0xFD, 0x75, 0xFE, 0x30, 0xF5, 0xFF, 0xE5,
-        0xE7, 0x20, 0xE7, 0x03, 0x43, 0xF9, 0x08, 0xE5,
-/*0A40*/0xE6, 0x20, 0xE7, 0x0B, 0x78, 0xFF, 0xE4, 0xF6,
-        0xD8, 0xFD, 0x53, 0xE6, 0xFE, 0x80, 0x09, 0x78,
-/*0A50*/0x08, 0xE4, 0xF6, 0xD8, 0xFD, 0x53, 0xE6, 0xFE,
-        0x75, 0x81, 0x80, 0xE4, 0xF5, 0xA8, 0xD2, 0xA8,
-/*0A60*/0xC2, 0xA9, 0xD2, 0xAF, 0xE5, 0xE2, 0x20, 0xE5,
-        0x05, 0x20, 0xE6, 0x02, 0x80, 0x03, 0x43, 0xE1,
-/*0A70*/0x02, 0xE5, 0xE2, 0x20, 0xE0, 0x0E, 0x90, 0x00,
-        0x00, 0x7F, 0x00, 0x7E, 0x08, 0xE4, 0xF0, 0xA3,
-/*0A80*/0xDF, 0xFC, 0xDE, 0xFA, 0x02, 0x0A, 0xDB, 0x43,
-        0xFA, 0x01, 0xC0, 0xE0, 0xC0, 0xF0, 0xC0, 0x83,
-/*0A90*/0xC0, 0x82, 0xC0, 0xD0, 0x12, 0x1C, 0xE7, 0xD0,
-        0xD0, 0xD0, 0x82, 0xD0, 0x83, 0xD0, 0xF0, 0xD0,
-/*0AA0*/0xE0, 0x53, 0xFA, 0xFE, 0x32, 0x02, 0x1B, 0x55,
-        0xE4, 0x93, 0xA3, 0xF8, 0xE4, 0x93, 0xA3, 0xF6,
-/*0AB0*/0x08, 0xDF, 0xF9, 0x80, 0x29, 0xE4, 0x93, 0xA3,
-        0xF8, 0x54, 0x07, 0x24, 0x0C, 0xC8, 0xC3, 0x33,
-/*0AC0*/0xC4, 0x54, 0x0F, 0x44, 0x20, 0xC8, 0x83, 0x40,
-        0x04, 0xF4, 0x56, 0x80, 0x01, 0x46, 0xF6, 0xDF,
-/*0AD0*/0xE4, 0x80, 0x0B, 0x01, 0x02, 0x04, 0x08, 0x10,
-        0x20, 0x40, 0x80, 0x90, 0x00, 0x3F, 0xE4, 0x7E,
-/*0AE0*/0x01, 0x93, 0x60, 0xC1, 0xA3, 0xFF, 0x54, 0x3F,
-        0x30, 0xE5, 0x09, 0x54, 0x1F, 0xFE, 0xE4, 0x93,
-/*0AF0*/0xA3, 0x60, 0x01, 0x0E, 0xCF, 0x54, 0xC0, 0x25,
-        0xE0, 0x60, 0xAD, 0x40, 0xB8, 0x80, 0xFE, 0x8C,
-/*0B00*/0x64, 0x8D, 0x65, 0x8A, 0x66, 0x8B, 0x67, 0xE4,
-        0xF5, 0x69, 0xEF, 0x4E, 0x70, 0x03, 0x02, 0x1D,
-/*0B10*/0x55, 0xE4, 0xF5, 0x68, 0xE5, 0x67, 0x45, 0x66,
-        0x70, 0x32, 0x12, 0x07, 0x2A, 0x75, 0x83, 0x90,
-/*0B20*/0xE4, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC2, 0xE4,
-        0x12, 0x07, 0x29, 0x75, 0x83, 0xC4, 0xE4, 0x12,
-/*0B30*/0x08, 0x70, 0x70, 0x29, 0x12, 0x07, 0x2A, 0x75,
-        0x83, 0x92, 0xE4, 0x12, 0x07, 0x29, 0x75, 0x83,
-/*0B40*/0xC6, 0xE4, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC8,
-        0xE4, 0xF0, 0x80, 0x11, 0x90, 0x07, 0x26, 0x12,
-/*0B50*/0x07, 0x35, 0xE4, 0x12, 0x08, 0x70, 0x70, 0x05,
-        0x12, 0x07, 0x32, 0xE4, 0xF0, 0x12, 0x1D, 0x55,
-/*0B60*/0x12, 0x1E, 0xBF, 0xE5, 0x67, 0x45, 0x66, 0x70,
-        0x33, 0x12, 0x07, 0x2A, 0x75, 0x83, 0x90, 0xE5,
-/*0B70*/0x41, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC2, 0xE5,
-        0x41, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC4, 0x12,
-/*0B80*/0x08, 0x6E, 0x70, 0x29, 0x12, 0x07, 0x2A, 0x75,
-        0x83, 0x92, 0xE5, 0x40, 0x12, 0x07, 0x29, 0x75,
-/*0B90*/0x83, 0xC6, 0xE5, 0x40, 0x12, 0x07, 0x29, 0x75,
-        0x83, 0xC8, 0x80, 0x0E, 0x90, 0x07, 0x26, 0x12,
-/*0BA0*/0x07, 0x35, 0x12, 0x08, 0x6E, 0x70, 0x06, 0x12,
-        0x07, 0x32, 0xE5, 0x40, 0xF0, 0xAF, 0x69, 0x7E,
-/*0BB0*/0x00, 0xAD, 0x67, 0xAC, 0x66, 0x12, 0x04, 0x44,
-        0x12, 0x07, 0x2A, 0x75, 0x83, 0xCA, 0xE0, 0xD3,
-/*0BC0*/0x94, 0x00, 0x50, 0x0C, 0x05, 0x68, 0xE5, 0x68,
-        0xC3, 0x94, 0x05, 0x50, 0x03, 0x02, 0x0B, 0x14,
-/*0BD0*/0x22, 0x8C, 0x60, 0x8D, 0x61, 0x12, 0x08, 0xDA,
-        0x74, 0x20, 0x40, 0x0D, 0x2F, 0xF5, 0x82, 0x74,
-/*0BE0*/0x03, 0x3E, 0xF5, 0x83, 0xE5, 0x3E, 0xF0, 0x80,
-        0x0B, 0x2F, 0xF5, 0x82, 0x74, 0x03, 0x3E, 0xF5,
-/*0BF0*/0x83, 0xE5, 0x3C, 0xF0, 0xE5, 0x3C, 0xD3, 0x95,
-        0x3E, 0x40, 0x3C, 0xE5, 0x61, 0x45, 0x60, 0x70,
-/*0C00*/0x10, 0xE9, 0x12, 0x09, 0x04, 0xE5, 0x3E, 0x12,
-        0x07, 0x68, 0x40, 0x3B, 0x12, 0x08, 0x95, 0x80,
-/*0C10*/0x18, 0xE5, 0x3E, 0xC3, 0x95, 0x38, 0x40, 0x1D,
-        0x85, 0x3E, 0x38, 0xE5, 0x3E, 0x60, 0x05, 0x85,
-/*0C20*/0x3F, 0x39, 0x80, 0x03, 0x85, 0x39, 0x39, 0x8F,
-        0x3A, 0x12, 0x08, 0x14, 0xE5, 0x3E, 0x12, 0x07,
-/*0C30*/0xC0, 0xE5, 0x3F, 0xF0, 0x22, 0x80, 0x43, 0xE5,
-        0x61, 0x45, 0x60, 0x70, 0x19, 0x12, 0x07, 0x5F,
-/*0C40*/0x40, 0x05, 0x12, 0x08, 0x9E, 0x80, 0x27, 0x12,
-        0x09, 0x0B, 0x12, 0x08, 0x14, 0xE5, 0x42, 0x12,
-/*0C50*/0x07, 0xC0, 0xE5, 0x41, 0xF0, 0x22, 0xE5, 0x3C,
-        0xC3, 0x95, 0x38, 0x40, 0x1D, 0x85, 0x3C, 0x38,
-/*0C60*/0xE5, 0x3C, 0x60, 0x05, 0x85, 0x3D, 0x39, 0x80,
-        0x03, 0x85, 0x39, 0x39, 0x8F, 0x3A, 0x12, 0x08,
-/*0C70*/0x14, 0xE5, 0x3C, 0x12, 0x07, 0xC0, 0xE5, 0x3D,
-        0xF0, 0x22, 0x85, 0x38, 0x38, 0x85, 0x39, 0x39,
-/*0C80*/0x85, 0x3A, 0x3A, 0x12, 0x08, 0x14, 0xE5, 0x38,
-        0x12, 0x07, 0xC0, 0xE5, 0x39, 0xF0, 0x22, 0x7F,
-/*0C90*/0x06, 0x12, 0x17, 0x31, 0x12, 0x1D, 0x23, 0x12,
-        0x0E, 0x04, 0x12, 0x0E, 0x33, 0xE0, 0x44, 0x0A,
-/*0CA0*/0xF0, 0x74, 0x8E, 0xFE, 0x12, 0x0E, 0x04, 0x12,
-        0x0E, 0x0B, 0xEF, 0xF0, 0xE5, 0x28, 0x30, 0xE5,
-/*0CB0*/0x03, 0xD3, 0x80, 0x01, 0xC3, 0x40, 0x05, 0x75,
-        0x14, 0x20, 0x80, 0x03, 0x75, 0x14, 0x08, 0x12,
-/*0CC0*/0x0E, 0x04, 0x75, 0x83, 0x8A, 0xE5, 0x14, 0xF0,
-        0xB4, 0xFF, 0x05, 0x75, 0x12, 0x80, 0x80, 0x06,
-/*0CD0*/0xE5, 0x14, 0xC3, 0x13, 0xF5, 0x12, 0xE4, 0xF5,
-        0x16, 0xF5, 0x7F, 0x12, 0x19, 0x36, 0x12, 0x13,
-/*0CE0*/0xA3, 0xE5, 0x0A, 0xC3, 0x94, 0x01, 0x50, 0x09,
-        0x05, 0x16, 0xE5, 0x16, 0xC3, 0x94, 0x14, 0x40,
-/*0CF0*/0xEA, 0xE5, 0xE4, 0x20, 0xE7, 0x28, 0x12, 0x0E,
-        0x04, 0x75, 0x83, 0xD2, 0xE0, 0x54, 0x08, 0xD3,
-/*0D00*/0x94, 0x00, 0x40, 0x04, 0x7F, 0x01, 0x80, 0x02,
-        0x7F, 0x00, 0xE5, 0x0A, 0xC3, 0x94, 0x01, 0x40,
-/*0D10*/0x04, 0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00, 0xEF,
-        0x5E, 0x60, 0x03, 0x12, 0x1D, 0xD7, 0xE5, 0x7F,
-/*0D20*/0xC3, 0x94, 0x11, 0x40, 0x14, 0x12, 0x0E, 0x04,
-        0x75, 0x83, 0xD2, 0xE0, 0x44, 0x80, 0xF0, 0xE5,
-/*0D30*/0xE4, 0x20, 0xE7, 0x0F, 0x12, 0x1D, 0xD7, 0x80,
-        0x0A, 0x12, 0x0E, 0x04, 0x75, 0x83, 0xD2, 0xE0,
-/*0D40*/0x54, 0x7F, 0xF0, 0x12, 0x1D, 0x23, 0x22, 0x74,
-        0x8A, 0x85, 0x08, 0x82, 0xF5, 0x83, 0xE5, 0x17,
-/*0D50*/0xF0, 0x12, 0x0E, 0x3A, 0xE4, 0xF0, 0x90, 0x07,
-        0x02, 0xE0, 0x12, 0x0E, 0x17, 0x75, 0x83, 0x90,
-/*0D60*/0xEF, 0xF0, 0x74, 0x92, 0xFE, 0xE5, 0x08, 0x44,
-        0x07, 0xFF, 0xF5, 0x82, 0x8E, 0x83, 0xE0, 0x54,
-/*0D70*/0xC0, 0xFD, 0x90, 0x07, 0x03, 0xE0, 0x54, 0x3F,
-        0x4D, 0x8F, 0x82, 0x8E, 0x83, 0xF0, 0x90, 0x07,
-/*0D80*/0x04, 0xE0, 0x12, 0x0E, 0x17, 0x75, 0x83, 0x82,
-        0xEF, 0xF0, 0x90, 0x07, 0x05, 0xE0, 0xFF, 0xED,
-/*0D90*/0x44, 0x07, 0xF5, 0x82, 0x75, 0x83, 0xB4, 0xEF,
-        0x12, 0x0E, 0x03, 0x75, 0x83, 0x80, 0xE0, 0x54,
-/*0DA0*/0xBF, 0xF0, 0x30, 0x37, 0x0A, 0x12, 0x0E, 0x91,
-        0x75, 0x83, 0x94, 0xE0, 0x44, 0x80, 0xF0, 0x30,
-/*0DB0*/0x38, 0x0A, 0x12, 0x0E, 0x91, 0x75, 0x83, 0x92,
-        0xE0, 0x44, 0x80, 0xF0, 0xE5, 0x28, 0x30, 0xE4,
-/*0DC0*/0x1A, 0x20, 0x39, 0x0A, 0x12, 0x0E, 0x04, 0x75,
-        0x83, 0x88, 0xE0, 0x54, 0x7F, 0xF0, 0x20, 0x3A,
-/*0DD0*/0x0A, 0x12, 0x0E, 0x04, 0x75, 0x83, 0x88, 0xE0,
-        0x54, 0xBF, 0xF0, 0x74, 0x8C, 0xFE, 0x12, 0x0E,
-/*0DE0*/0x04, 0x8E, 0x83, 0xE0, 0x54, 0x0F, 0x12, 0x0E,
-        0x03, 0x75, 0x83, 0x86, 0xE0, 0x54, 0xBF, 0xF0,
-/*0DF0*/0xE5, 0x08, 0x44, 0x06, 0x12, 0x0D, 0xFD, 0x75,
-        0x83, 0x8A, 0xE4, 0xF0, 0x22, 0xF5, 0x82, 0x75,
-/*0E00*/0x83, 0x82, 0xE4, 0xF0, 0xE5, 0x08, 0x44, 0x07,
-        0xF5, 0x82, 0x22, 0x8E, 0x83, 0xE0, 0xF5, 0x10,
-/*0E10*/0x54, 0xFE, 0xF0, 0xE5, 0x10, 0x44, 0x01, 0xFF,
-        0xE5, 0x08, 0xFD, 0xED, 0x44, 0x07, 0xF5, 0x82,
-/*0E20*/0x22, 0xE5, 0x15, 0xC4, 0x54, 0x07, 0xFF, 0xE5,
-        0x08, 0xFD, 0xED, 0x44, 0x08, 0xF5, 0x82, 0x75,
-/*0E30*/0x83, 0x82, 0x22, 0x75, 0x83, 0x80, 0xE0, 0x44,
-        0x40, 0xF0, 0xE5, 0x08, 0x44, 0x08, 0xF5, 0x82,
-/*0E40*/0x75, 0x83, 0x8A, 0x22, 0xE5, 0x16, 0x25, 0xE0,
-        0x25, 0xE0, 0x24, 0xAF, 0xF5, 0x82, 0xE4, 0x34,
-/*0E50*/0x1A, 0xF5, 0x83, 0xE4, 0x93, 0xF5, 0x0D, 0x22,
-        0x43, 0xE1, 0x10, 0x43, 0xE1, 0x80, 0x53, 0xE1,
-/*0E60*/0xFD, 0x85, 0xE1, 0x10, 0x22, 0xE5, 0x16, 0x25,
-        0xE0, 0x25, 0xE0, 0x24, 0xB2, 0xF5, 0x82, 0xE4,
-/*0E70*/0x34, 0x1A, 0xF5, 0x83, 0xE4, 0x93, 0x22, 0x85,
-        0x55, 0x82, 0x85, 0x54, 0x83, 0xE5, 0x15, 0xF0,
-/*0E80*/0x22, 0xE5, 0xE2, 0x54, 0x20, 0xD3, 0x94, 0x00,
-        0x22, 0xE5, 0xE2, 0x54, 0x40, 0xD3, 0x94, 0x00,
-/*0E90*/0x22, 0xE5, 0x08, 0x44, 0x06, 0xF5, 0x82, 0x22,
-        0xFD, 0xE5, 0x08, 0xFB, 0xEB, 0x44, 0x07, 0xF5,
-/*0EA0*/0x82, 0x22, 0x53, 0xF9, 0xF7, 0x75, 0xFE, 0x30,
-        0x22, 0xEF, 0x4E, 0x70, 0x26, 0x12, 0x07, 0xCC,
-/*0EB0*/0xE0, 0xFD, 0x90, 0x07, 0x26, 0x12, 0x07, 0x7B,
-        0x12, 0x07, 0xD8, 0xE0, 0xFD, 0x90, 0x07, 0x28,
-/*0EC0*/0x12, 0x07, 0x7B, 0x12, 0x08, 0x81, 0x12, 0x07,
-        0x72, 0x12, 0x08, 0x35, 0xE0, 0x90, 0x07, 0x24,
-/*0ED0*/0x12, 0x07, 0x78, 0xEF, 0x64, 0x04, 0x4E, 0x70,
-        0x29, 0x12, 0x07, 0xE4, 0xE0, 0xFD, 0x90, 0x07,
-/*0EE0*/0x26, 0x12, 0x07, 0x7B, 0x12, 0x07, 0xF0, 0xE0,
-        0xFD, 0x90, 0x07, 0x28, 0x12, 0x07, 0x7B, 0x12,
-/*0EF0*/0x08, 0x8B, 0x12, 0x07, 0x72, 0x12, 0x08, 0x41,
-        0xE0, 0x54, 0x1F, 0xFD, 0x90, 0x07, 0x24, 0x12,
-/*0F00*/0x07, 0x7B, 0xEF, 0x64, 0x01, 0x4E, 0x70, 0x04,
-        0x7D, 0x01, 0x80, 0x02, 0x7D, 0x00, 0xEF, 0x64,
-/*0F10*/0x02, 0x4E, 0x70, 0x04, 0x7F, 0x01, 0x80, 0x02,
-        0x7F, 0x00, 0xEF, 0x4D, 0x60, 0x35, 0x12, 0x07,
-/*0F20*/0xFC, 0xE0, 0xFF, 0x90, 0x07, 0x26, 0x12, 0x07,
-        0x89, 0xEF, 0xF0, 0x12, 0x08, 0x08, 0xE0, 0xFF,
-/*0F30*/0x90, 0x07, 0x28, 0x12, 0x07, 0x89, 0xEF, 0xF0,
-        0x12, 0x08, 0x4D, 0xE0, 0x54, 0x1F, 0xFF, 0x12,
-/*0F40*/0x07, 0x86, 0xEF, 0xF0, 0x12, 0x08, 0x59, 0xE0,
-        0x54, 0x1F, 0xFF, 0x90, 0x07, 0x24, 0x12, 0x07,
-/*0F50*/0x89, 0xEF, 0xF0, 0x22, 0xE4, 0xF5, 0x53, 0x12,
-        0x0E, 0x81, 0x40, 0x04, 0x7F, 0x01, 0x80, 0x02,
-/*0F60*/0x7F, 0x00, 0x12, 0x0E, 0x89, 0x40, 0x04, 0x7E,
-        0x01, 0x80, 0x02, 0x7E, 0x00, 0xEE, 0x4F, 0x70,
-/*0F70*/0x03, 0x02, 0x0F, 0xF6, 0x85, 0xE1, 0x10, 0x43,
-        0xE1, 0x02, 0x53, 0xE1, 0x0F, 0x85, 0xE1, 0x10,
-/*0F80*/0xE4, 0xF5, 0x51, 0xE5, 0xE3, 0x54, 0x3F, 0xF5,
-        0x52, 0x12, 0x0E, 0x89, 0x40, 0x1D, 0xAD, 0x52,
-/*0F90*/0xAF, 0x51, 0x12, 0x11, 0x18, 0xEF, 0x60, 0x08,
-        0x85, 0xE1, 0x10, 0x43, 0xE1, 0x40, 0x80, 0x0B,
-/*0FA0*/0x53, 0xE1, 0xBF, 0x12, 0x0E, 0x58, 0x12, 0x00,
-        0x06, 0x80, 0xFB, 0xE5, 0xE3, 0x54, 0x3F, 0xF5,
-/*0FB0*/0x51, 0xE5, 0xE4, 0x54, 0x3F, 0xF5, 0x52, 0x12,
-        0x0E, 0x81, 0x40, 0x1D, 0xAD, 0x52, 0xAF, 0x51,
-/*0FC0*/0x12, 0x11, 0x18, 0xEF, 0x60, 0x08, 0x85, 0xE1,
-        0x10, 0x43, 0xE1, 0x20, 0x80, 0x0B, 0x53, 0xE1,
-/*0FD0*/0xDF, 0x12, 0x0E, 0x58, 0x12, 0x00, 0x06, 0x80,
-        0xFB, 0x12, 0x0E, 0x81, 0x40, 0x04, 0x7F, 0x01,
-/*0FE0*/0x80, 0x02, 0x7F, 0x00, 0x12, 0x0E, 0x89, 0x40,
-        0x04, 0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00, 0xEE,
-/*0FF0*/0x4F, 0x60, 0x03, 0x12, 0x0E, 0x5B, 0x22, 0x12,
-        0x0E, 0x21, 0xEF, 0xF0, 0x12, 0x10, 0x91, 0x22,
-/*1000*/0x02, 0x11, 0x00, 0x02, 0x10, 0x40, 0x02, 0x10,
-        0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1010*/0x01, 0x20, 0x01, 0x20, 0xE4, 0xF5, 0x57, 0x12,
-        0x16, 0xBD, 0x12, 0x16, 0x44, 0xE4, 0x12, 0x10,
-/*1020*/0x56, 0x12, 0x14, 0xB7, 0x90, 0x07, 0x26, 0x12,
-        0x07, 0x35, 0xE4, 0x12, 0x07, 0x31, 0xE4, 0xF0,
-/*1030*/0x12, 0x10, 0x56, 0x12, 0x14, 0xB7, 0x90, 0x07,
-        0x26, 0x12, 0x07, 0x35, 0xE5, 0x41, 0x12, 0x07,
-/*1040*/0x31, 0xE5, 0x40, 0xF0, 0xAF, 0x57, 0x7E, 0x00,
-        0xAD, 0x56, 0x7C, 0x00, 0x12, 0x04, 0x44, 0xAF,
-/*1050*/0x56, 0x7E, 0x00, 0x02, 0x11, 0xEE, 0xFF, 0x90,
-        0x07, 0x20, 0xA3, 0xE0, 0xFD, 0xE4, 0xF5, 0x56,
-/*1060*/0xF5, 0x40, 0xFE, 0xFC, 0xAB, 0x56, 0xFA, 0x12,
-        0x11, 0x51, 0x7F, 0x0F, 0x7D, 0x18, 0xE4, 0xF5,
-/*1070*/0x56, 0xF5, 0x40, 0xFE, 0xFC, 0xAB, 0x56, 0xFA,
-        0x12, 0x15, 0x41, 0xAF, 0x56, 0x7E, 0x00, 0x12,
-/*1080*/0x1A, 0xFF, 0xE4, 0xFF, 0xF5, 0x56, 0x7D, 0x1F,
-        0xF5, 0x40, 0xFE, 0xFC, 0xAB, 0x56, 0xFA, 0x22,
-/*1090*/0x22, 0xE4, 0xF5, 0x55, 0xE5, 0x08, 0xFD, 0x74,
-        0xA0, 0xF5, 0x56, 0xED, 0x44, 0x07, 0xF5, 0x57,
-/*10A0*/0xE5, 0x28, 0x30, 0xE5, 0x03, 0xD3, 0x80, 0x01,
-        0xC3, 0x40, 0x05, 0x7F, 0x28, 0xEF, 0x80, 0x04,
-/*10B0*/0x7F, 0x14, 0xEF, 0xC3, 0x13, 0xF5, 0x54, 0xE4,
-        0xF9, 0x12, 0x0E, 0x18, 0x75, 0x83, 0x8E, 0xE0,
-/*10C0*/0xF5, 0x10, 0xCE, 0xEF, 0xCE, 0xEE, 0xD3, 0x94,
-        0x00, 0x40, 0x26, 0xE5, 0x10, 0x54, 0xFE, 0x12,
-/*10D0*/0x0E, 0x98, 0x75, 0x83, 0x8E, 0xED, 0xF0, 0xE5,
-        0x10, 0x44, 0x01, 0xFD, 0xEB, 0x44, 0x07, 0xF5,
-/*10E0*/0x82, 0xED, 0xF0, 0x85, 0x57, 0x82, 0x85, 0x56,
-        0x83, 0xE0, 0x30, 0xE3, 0x01, 0x09, 0x1E, 0x80,
-/*10F0*/0xD4, 0xC2, 0x34, 0xE9, 0xC3, 0x95, 0x54, 0x40,
-        0x02, 0xD2, 0x34, 0x22, 0x02, 0x00, 0x06, 0x22,
-/*1100*/0x30, 0x30, 0x11, 0x90, 0x10, 0x00, 0xE4, 0x93,
-        0xF5, 0x10, 0x90, 0x10, 0x10, 0xE4, 0x93, 0xF5,
-/*1110*/0x10, 0x12, 0x10, 0x90, 0x12, 0x11, 0x50, 0x22,
-        0xE4, 0xFC, 0xC3, 0xED, 0x9F, 0xFA, 0xEF, 0xF5,
-/*1120*/0x83, 0x75, 0x82, 0x00, 0x79, 0xFF, 0xE4, 0x93,
-        0xCC, 0x6C, 0xCC, 0xA3, 0xD9, 0xF8, 0xDA, 0xF6,
-/*1130*/0xE5, 0xE2, 0x30, 0xE4, 0x02, 0x8C, 0xE5, 0xED,
-        0x24, 0xFF, 0xFF, 0xEF, 0x75, 0x82, 0xFF, 0xF5,
-/*1140*/0x83, 0xE4, 0x93, 0x6C, 0x70, 0x03, 0x7F, 0x01,
-        0x22, 0x7F, 0x00, 0x22, 0x22, 0x11, 0x00, 0x00,
-/*1150*/0x22, 0x8E, 0x58, 0x8F, 0x59, 0x8C, 0x5A, 0x8D,
-        0x5B, 0x8A, 0x5C, 0x8B, 0x5D, 0x75, 0x5E, 0x01,
-/*1160*/0xE4, 0xF5, 0x5F, 0xF5, 0x60, 0xF5, 0x62, 0x12,
-        0x07, 0x2A, 0x75, 0x83, 0xD0, 0xE0, 0xFF, 0xC4,
-/*1170*/0x54, 0x0F, 0xF5, 0x61, 0x12, 0x1E, 0xA5, 0x85,
-        0x59, 0x5E, 0xD3, 0xE5, 0x5E, 0x95, 0x5B, 0xE5,
-/*1180*/0x5A, 0x12, 0x07, 0x6B, 0x50, 0x4B, 0x12, 0x07,
-        0x03, 0x75, 0x83, 0xBC, 0xE0, 0x45, 0x5E, 0x12,
-/*1190*/0x07, 0x29, 0x75, 0x83, 0xBE, 0xE0, 0x45, 0x5E,
-        0x12, 0x07, 0x29, 0x75, 0x83, 0xC0, 0xE0, 0x45,
-/*11A0*/0x5E, 0xF0, 0xAF, 0x5F, 0xE5, 0x60, 0x12, 0x08,
-        0x78, 0x12, 0x0A, 0xFF, 0xAF, 0x62, 0x7E, 0x00,
-/*11B0*/0xAD, 0x5D, 0xAC, 0x5C, 0x12, 0x04, 0x44, 0xE5,
-        0x61, 0xAF, 0x5E, 0x7E, 0x00, 0xB4, 0x03, 0x05,
-/*11C0*/0x12, 0x1E, 0x21, 0x80, 0x07, 0xAD, 0x5D, 0xAC,
-        0x5C, 0x12, 0x13, 0x17, 0x05, 0x5E, 0x02, 0x11,
-/*11D0*/0x7A, 0x12, 0x07, 0x03, 0x75, 0x83, 0xBC, 0xE0,
-        0x45, 0x40, 0x12, 0x07, 0x29, 0x75, 0x83, 0xBE,
-/*11E0*/0xE0, 0x45, 0x40, 0x12, 0x07, 0x29, 0x75, 0x83,
-        0xC0, 0xE0, 0x45, 0x40, 0xF0, 0x22, 0x8E, 0x58,
-/*11F0*/0x8F, 0x59, 0x75, 0x5A, 0x01, 0x79, 0x01, 0x75,
-        0x5B, 0x01, 0xE4, 0xFB, 0x12, 0x07, 0x2A, 0x75,
-/*1200*/0x83, 0xAE, 0xE0, 0x54, 0x1A, 0xFF, 0x12, 0x08,
-        0x65, 0xE0, 0xC4, 0x13, 0x54, 0x07, 0xFE, 0xEF,
-/*1210*/0x70, 0x0C, 0xEE, 0x65, 0x35, 0x70, 0x07, 0x90,
-        0x07, 0x2F, 0xE0, 0xB4, 0x01, 0x0D, 0xAF, 0x35,
-/*1220*/0x7E, 0x00, 0x12, 0x0E, 0xA9, 0xCF, 0xEB, 0xCF,
-        0x02, 0x1E, 0x60, 0xE5, 0x59, 0x64, 0x02, 0x45,
-/*1230*/0x58, 0x70, 0x04, 0x7F, 0x01, 0x80, 0x02, 0x7F,
-        0x00, 0xE5, 0x59, 0x45, 0x58, 0x70, 0x04, 0x7E,
-/*1240*/0x01, 0x80, 0x02, 0x7E, 0x00, 0xEE, 0x4F, 0x60,
-        0x23, 0x85, 0x41, 0x49, 0x85, 0x40, 0x4B, 0xE5,
-/*1250*/0x59, 0x45, 0x58, 0x70, 0x2C, 0xAF, 0x5A, 0xFE,
-        0xCD, 0xE9, 0xCD, 0xFC, 0xAB, 0x59, 0xAA, 0x58,
-/*1260*/0x12, 0x0A, 0xFF, 0xAF, 0x5B, 0x7E, 0x00, 0x12,
-        0x1E, 0x60, 0x80, 0x15, 0xAF, 0x5B, 0x7E, 0x00,
-/*1270*/0x12, 0x1E, 0x60, 0x90, 0x07, 0x26, 0x12, 0x07,
-        0x35, 0xE5, 0x49, 0x12, 0x07, 0x31, 0xE5, 0x4B,
-/*1280*/0xF0, 0xE4, 0xFD, 0xAF, 0x35, 0xFE, 0xFC, 0x12,
-        0x09, 0x15, 0x22, 0x8C, 0x64, 0x8D, 0x65, 0x12,
-/*1290*/0x08, 0xDA, 0x40, 0x3C, 0xE5, 0x65, 0x45, 0x64,
-        0x70, 0x10, 0x12, 0x09, 0x04, 0xC3, 0xE5, 0x3E,
-/*12A0*/0x12, 0x07, 0x69, 0x40, 0x3B, 0x12, 0x08, 0x95,
-        0x80, 0x18, 0xE5, 0x3E, 0xC3, 0x95, 0x38, 0x40,
-/*12B0*/0x1D, 0x85, 0x3E, 0x38, 0xE5, 0x3E, 0x60, 0x05,
-        0x85, 0x3F, 0x39, 0x80, 0x03, 0x85, 0x39, 0x39,
-/*12C0*/0x8F, 0x3A, 0x12, 0x07, 0xA8, 0xE5, 0x3E, 0x12,
-        0x07, 0x53, 0xE5, 0x3F, 0xF0, 0x22, 0x80, 0x3B,
-/*12D0*/0xE5, 0x65, 0x45, 0x64, 0x70, 0x11, 0x12, 0x07,
-        0x5F, 0x40, 0x05, 0x12, 0x08, 0x9E, 0x80, 0x1F,
-/*12E0*/0x12, 0x07, 0x3E, 0xE5, 0x41, 0xF0, 0x22, 0xE5,
-        0x3C, 0xC3, 0x95, 0x38, 0x40, 0x1D, 0x85, 0x3C,
-/*12F0*/0x38, 0xE5, 0x3C, 0x60, 0x05, 0x85, 0x3D, 0x39,
-        0x80, 0x03, 0x85, 0x39, 0x39, 0x8F, 0x3A, 0x12,
-/*1300*/0x07, 0xA8, 0xE5, 0x3C, 0x12, 0x07, 0x53, 0xE5,
-        0x3D, 0xF0, 0x22, 0x12, 0x07, 0x9F, 0xE5, 0x38,
-/*1310*/0x12, 0x07, 0x53, 0xE5, 0x39, 0xF0, 0x22, 0x8C,
-        0x63, 0x8D, 0x64, 0x12, 0x08, 0xDA, 0x40, 0x3C,
-/*1320*/0xE5, 0x64, 0x45, 0x63, 0x70, 0x10, 0x12, 0x09,
-        0x04, 0xC3, 0xE5, 0x3E, 0x12, 0x07, 0x69, 0x40,
-/*1330*/0x3B, 0x12, 0x08, 0x95, 0x80, 0x18, 0xE5, 0x3E,
-        0xC3, 0x95, 0x38, 0x40, 0x1D, 0x85, 0x3E, 0x38,
-/*1340*/0xE5, 0x3E, 0x60, 0x05, 0x85, 0x3F, 0x39, 0x80,
-        0x03, 0x85, 0x39, 0x39, 0x8F, 0x3A, 0x12, 0x07,
-/*1350*/0xA8, 0xE5, 0x3E, 0x12, 0x07, 0x53, 0xE5, 0x3F,
-        0xF0, 0x22, 0x80, 0x3B, 0xE5, 0x64, 0x45, 0x63,
-/*1360*/0x70, 0x11, 0x12, 0x07, 0x5F, 0x40, 0x05, 0x12,
-        0x08, 0x9E, 0x80, 0x1F, 0x12, 0x07, 0x3E, 0xE5,
-/*1370*/0x41, 0xF0, 0x22, 0xE5, 0x3C, 0xC3, 0x95, 0x38,
-        0x40, 0x1D, 0x85, 0x3C, 0x38, 0xE5, 0x3C, 0x60,
-/*1380*/0x05, 0x85, 0x3D, 0x39, 0x80, 0x03, 0x85, 0x39,
-        0x39, 0x8F, 0x3A, 0x12, 0x07, 0xA8, 0xE5, 0x3C,
-/*1390*/0x12, 0x07, 0x53, 0xE5, 0x3D, 0xF0, 0x22, 0x12,
-        0x07, 0x9F, 0xE5, 0x38, 0x12, 0x07, 0x53, 0xE5,
-/*13A0*/0x39, 0xF0, 0x22, 0xE5, 0x0D, 0xFE, 0xE5, 0x08,
-        0x8E, 0x54, 0x44, 0x05, 0xF5, 0x55, 0x75, 0x15,
-/*13B0*/0x0F, 0xF5, 0x82, 0x12, 0x0E, 0x7A, 0x12, 0x17,
-        0xA3, 0x20, 0x31, 0x05, 0x75, 0x15, 0x03, 0x80,
-/*13C0*/0x03, 0x75, 0x15, 0x0B, 0xE5, 0x0A, 0xC3, 0x94,
-        0x01, 0x50, 0x38, 0x12, 0x14, 0x20, 0x20, 0x31,
-/*13D0*/0x06, 0x05, 0x15, 0x05, 0x15, 0x80, 0x04, 0x15,
-        0x15, 0x15, 0x15, 0xE5, 0x0A, 0xC3, 0x94, 0x01,
-/*13E0*/0x50, 0x21, 0x12, 0x14, 0x20, 0x20, 0x31, 0x04,
-        0x05, 0x15, 0x80, 0x02, 0x15, 0x15, 0xE5, 0x0A,
-/*13F0*/0xC3, 0x94, 0x01, 0x50, 0x0E, 0x12, 0x0E, 0x77,
-        0x12, 0x17, 0xA3, 0x20, 0x31, 0x05, 0x05, 0x15,
-/*1400*/0x12, 0x0E, 0x77, 0xE5, 0x15, 0xB4, 0x08, 0x04,
-        0x7F, 0x01, 0x80, 0x02, 0x7F, 0x00, 0xE5, 0x15,
-/*1410*/0xB4, 0x07, 0x04, 0x7E, 0x01, 0x80, 0x02, 0x7E,
-        0x00, 0xEE, 0x4F, 0x60, 0x02, 0x05, 0x7F, 0x22,
-/*1420*/0x85, 0x55, 0x82, 0x85, 0x54, 0x83, 0xE5, 0x15,
-        0xF0, 0x12, 0x17, 0xA3, 0x22, 0x12, 0x07, 0x2A,
-/*1430*/0x75, 0x83, 0xAE, 0x74, 0xFF, 0x12, 0x07, 0x29,
-        0xE0, 0x54, 0x1A, 0xF5, 0x34, 0xE0, 0xC4, 0x13,
-/*1440*/0x54, 0x07, 0xF5, 0x35, 0x24, 0xFE, 0x60, 0x24,
-        0x24, 0xFE, 0x60, 0x3C, 0x24, 0x04, 0x70, 0x63,
-/*1450*/0x75, 0x31, 0x2D, 0xE5, 0x08, 0xFD, 0x74, 0xB6,
-        0x12, 0x07, 0x92, 0x74, 0xBC, 0x90, 0x07, 0x22,
-/*1460*/0x12, 0x07, 0x95, 0x74, 0x90, 0x12, 0x07, 0xB3,
-        0x74, 0x92, 0x80, 0x3C, 0x75, 0x31, 0x3A, 0xE5,
-/*1470*/0x08, 0xFD, 0x74, 0xBA, 0x12, 0x07, 0x92, 0x74,
-        0xC0, 0x90, 0x07, 0x22, 0x12, 0x07, 0xB6, 0x74,
-/*1480*/0xC4, 0x12, 0x07, 0xB3, 0x74, 0xC8, 0x80, 0x20,
-        0x75, 0x31, 0x35, 0xE5, 0x08, 0xFD, 0x74, 0xB8,
-/*1490*/0x12, 0x07, 0x92, 0x74, 0xBE, 0xFF, 0xED, 0x44,
-        0x07, 0x90, 0x07, 0x22, 0xCF, 0xF0, 0xA3, 0xEF,
-/*14A0*/0xF0, 0x74, 0xC2, 0x12, 0x07, 0xB3, 0x74, 0xC6,
-        0xFF, 0xED, 0x44, 0x07, 0xA3, 0xCF, 0xF0, 0xA3,
-/*14B0*/0xEF, 0xF0, 0x22, 0x75, 0x34, 0x01, 0x22, 0x8E,
-        0x58, 0x8F, 0x59, 0x8C, 0x5A, 0x8D, 0x5B, 0x8A,
-/*14C0*/0x5C, 0x8B, 0x5D, 0x75, 0x5E, 0x01, 0xE4, 0xF5,
-        0x5F, 0x12, 0x1E, 0xA5, 0x85, 0x59, 0x5E, 0xD3,
-/*14D0*/0xE5, 0x5E, 0x95, 0x5B, 0xE5, 0x5A, 0x12, 0x07,
-        0x6B, 0x50, 0x57, 0xE5, 0x5D, 0x45, 0x5C, 0x70,
-/*14E0*/0x30, 0x12, 0x07, 0x2A, 0x75, 0x83, 0x92, 0xE5,
-        0x5E, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC6, 0xE5,
-/*14F0*/0x5E, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC8, 0xE5,
-        0x5E, 0x12, 0x07, 0x29, 0x75, 0x83, 0x90, 0xE5,
-/*1500*/0x5E, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC2, 0xE5,
-        0x5E, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC4, 0x80,
-/*1510*/0x03, 0x12, 0x07, 0x32, 0xE5, 0x5E, 0xF0, 0xAF,
-        0x5F, 0x7E, 0x00, 0xAD, 0x5D, 0xAC, 0x5C, 0x12,
-/*1520*/0x04, 0x44, 0xAF, 0x5E, 0x7E, 0x00, 0xAD, 0x5D,
-        0xAC, 0x5C, 0x12, 0x0B, 0xD1, 0x05, 0x5E, 0x02,
-/*1530*/0x14, 0xCF, 0xAB, 0x5D, 0xAA, 0x5C, 0xAD, 0x5B,
-        0xAC, 0x5A, 0xAF, 0x59, 0xAE, 0x58, 0x02, 0x1B,
-/*1540*/0xFB, 0x8C, 0x5C, 0x8D, 0x5D, 0x8A, 0x5E, 0x8B,
-        0x5F, 0x75, 0x60, 0x01, 0xE4, 0xF5, 0x61, 0xF5,
-/*1550*/0x62, 0xF5, 0x63, 0x12, 0x1E, 0xA5, 0x8F, 0x60,
-        0xD3, 0xE5, 0x60, 0x95, 0x5D, 0xE5, 0x5C, 0x12,
-/*1560*/0x07, 0x6B, 0x50, 0x61, 0xE5, 0x5F, 0x45, 0x5E,
-        0x70, 0x27, 0x12, 0x07, 0x2A, 0x75, 0x83, 0xB6,
-/*1570*/0xE5, 0x60, 0x12, 0x07, 0x29, 0x75, 0x83, 0xB8,
-        0xE5, 0x60, 0x12, 0x07, 0x29, 0x75, 0x83, 0xBA,
-/*1580*/0xE5, 0x60, 0xF0, 0xAF, 0x61, 0x7E, 0x00, 0xE5,
-        0x62, 0x12, 0x08, 0x7A, 0x12, 0x0A, 0xFF, 0x80,
-/*1590*/0x19, 0x90, 0x07, 0x24, 0x12, 0x07, 0x35, 0xE5,
-        0x60, 0x12, 0x07, 0x29, 0x75, 0x83, 0x8E, 0xE4,
-/*15A0*/0x12, 0x07, 0x29, 0x74, 0x01, 0x12, 0x07, 0x29,
-        0xE4, 0xF0, 0xAF, 0x63, 0x7E, 0x00, 0xAD, 0x5F,
-/*15B0*/0xAC, 0x5E, 0x12, 0x04, 0x44, 0xAF, 0x60, 0x7E,
-        0x00, 0xAD, 0x5F, 0xAC, 0x5E, 0x12, 0x12, 0x8B,
-/*15C0*/0x05, 0x60, 0x02, 0x15, 0x58, 0x22, 0x90, 0x11,
-        0x4D, 0xE4, 0x93, 0x90, 0x07, 0x2E, 0xF0, 0x12,
-/*15D0*/0x08, 0x1F, 0x75, 0x83, 0xAE, 0xE0, 0x54, 0x1A,
-        0xF5, 0x34, 0x70, 0x67, 0xEF, 0x44, 0x07, 0xF5,
-/*15E0*/0x82, 0x75, 0x83, 0xCE, 0xE0, 0xFF, 0x13, 0x13,
-        0x13, 0x54, 0x07, 0xF5, 0x36, 0x54, 0x0F, 0xD3,
-/*15F0*/0x94, 0x00, 0x40, 0x06, 0x12, 0x14, 0x2D, 0x12,
-        0x1B, 0xA9, 0xE5, 0x36, 0x54, 0x0F, 0x24, 0xFE,
-/*1600*/0x60, 0x0C, 0x14, 0x60, 0x0C, 0x14, 0x60, 0x19,
-        0x24, 0x03, 0x70, 0x37, 0x80, 0x10, 0x02, 0x1E,
-/*1610*/0x91, 0x12, 0x1E, 0x91, 0x12, 0x07, 0x2A, 0x75,
-        0x83, 0xCE, 0xE0, 0x54, 0xEF, 0xF0, 0x02, 0x1D,
-/*1620*/0xAE, 0x12, 0x10, 0x14, 0xE4, 0xF5, 0x55, 0x12,
-        0x1D, 0x85, 0x05, 0x55, 0xE5, 0x55, 0xC3, 0x94,
-/*1630*/0x05, 0x40, 0xF4, 0x12, 0x07, 0x2A, 0x75, 0x83,
-        0xCE, 0xE0, 0x54, 0xC7, 0x12, 0x07, 0x29, 0xE0,
-/*1640*/0x44, 0x08, 0xF0, 0x22, 0xE4, 0xF5, 0x58, 0xF5,
-        0x59, 0xAF, 0x08, 0xEF, 0x44, 0x07, 0xF5, 0x82,
-/*1650*/0x75, 0x83, 0xD0, 0xE0, 0xFD, 0xC4, 0x54, 0x0F,
-        0xF5, 0x5A, 0xEF, 0x44, 0x07, 0xF5, 0x82, 0x75,
-/*1660*/0x83, 0x80, 0x74, 0x01, 0xF0, 0x12, 0x08, 0x21,
-        0x75, 0x83, 0x82, 0xE5, 0x45, 0xF0, 0xEF, 0x44,
-/*1670*/0x07, 0xF5, 0x82, 0x75, 0x83, 0x8A, 0x74, 0xFF,
-        0xF0, 0x12, 0x1A, 0x4D, 0x12, 0x07, 0x2A, 0x75,
-/*1680*/0x83, 0xBC, 0xE0, 0x54, 0xEF, 0x12, 0x07, 0x29,
-        0x75, 0x83, 0xBE, 0xE0, 0x54, 0xEF, 0x12, 0x07,
-/*1690*/0x29, 0x75, 0x83, 0xC0, 0xE0, 0x54, 0xEF, 0x12,
-        0x07, 0x29, 0x75, 0x83, 0xBC, 0xE0, 0x44, 0x10,
-/*16A0*/0x12, 0x07, 0x29, 0x75, 0x83, 0xBE, 0xE0, 0x44,
-        0x10, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC0, 0xE0,
-/*16B0*/0x44, 0x10, 0xF0, 0xAF, 0x58, 0xE5, 0x59, 0x12,
-        0x08, 0x78, 0x02, 0x0A, 0xFF, 0xE4, 0xF5, 0x58,
-/*16C0*/0x7D, 0x01, 0xF5, 0x59, 0xAF, 0x35, 0xFE, 0xFC,
-        0x12, 0x09, 0x15, 0x12, 0x07, 0x2A, 0x75, 0x83,
-/*16D0*/0xB6, 0x74, 0x10, 0x12, 0x07, 0x29, 0x75, 0x83,
-        0xB8, 0x74, 0x10, 0x12, 0x07, 0x29, 0x75, 0x83,
-/*16E0*/0xBA, 0x74, 0x10, 0x12, 0x07, 0x29, 0x75, 0x83,
-        0xBC, 0x74, 0x10, 0x12, 0x07, 0x29, 0x75, 0x83,
-/*16F0*/0xBE, 0x74, 0x10, 0x12, 0x07, 0x29, 0x75, 0x83,
-        0xC0, 0x74, 0x10, 0x12, 0x07, 0x29, 0x75, 0x83,
-/*1700*/0x90, 0xE4, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC2,
-        0xE4, 0x12, 0x07, 0x29, 0x75, 0x83, 0xC4, 0xE4,
-/*1710*/0x12, 0x07, 0x29, 0x75, 0x83, 0x92, 0xE4, 0x12,
-        0x07, 0x29, 0x75, 0x83, 0xC6, 0xE4, 0x12, 0x07,
-/*1720*/0x29, 0x75, 0x83, 0xC8, 0xE4, 0xF0, 0xAF, 0x58,
-        0xFE, 0xE5, 0x59, 0x12, 0x08, 0x7A, 0x02, 0x0A,
-/*1730*/0xFF, 0xE5, 0xE2, 0x30, 0xE4, 0x6C, 0xE5, 0xE7,
-        0x54, 0xC0, 0x64, 0x40, 0x70, 0x64, 0xE5, 0x09,
-/*1740*/0xC4, 0x54, 0x30, 0xFE, 0xE5, 0x08, 0x25, 0xE0,
-        0x25, 0xE0, 0x54, 0xC0, 0x4E, 0xFE, 0xEF, 0x54,
-/*1750*/0x3F, 0x4E, 0xFD, 0xE5, 0x2B, 0xAE, 0x2A, 0x78,
-        0x02, 0xC3, 0x33, 0xCE, 0x33, 0xCE, 0xD8, 0xF9,
-/*1760*/0xF5, 0x82, 0x8E, 0x83, 0xED, 0xF0, 0xE5, 0x2B,
-        0xAE, 0x2A, 0x78, 0x02, 0xC3, 0x33, 0xCE, 0x33,
-/*1770*/0xCE, 0xD8, 0xF9, 0xFF, 0xF5, 0x82, 0x8E, 0x83,
-        0xA3, 0xE5, 0xFE, 0xF0, 0x8F, 0x82, 0x8E, 0x83,
-/*1780*/0xA3, 0xA3, 0xE5, 0xFD, 0xF0, 0x8F, 0x82, 0x8E,
-        0x83, 0xA3, 0xA3, 0xA3, 0xE5, 0xFC, 0xF0, 0xC3,
-/*1790*/0xE5, 0x2B, 0x94, 0xFA, 0xE5, 0x2A, 0x94, 0x00,
-        0x50, 0x08, 0x05, 0x2B, 0xE5, 0x2B, 0x70, 0x02,
-/*17A0*/0x05, 0x2A, 0x22, 0xE4, 0xFF, 0xE4, 0xF5, 0x58,
-        0xF5, 0x56, 0xF5, 0x57, 0x74, 0x82, 0xFC, 0x12,
-/*17B0*/0x0E, 0x04, 0x8C, 0x83, 0xE0, 0xF5, 0x10, 0x54,
-        0x7F, 0xF0, 0xE5, 0x10, 0x44, 0x80, 0x12, 0x0E,
-/*17C0*/0x98, 0xED, 0xF0, 0x7E, 0x0A, 0x12, 0x0E, 0x04,
-        0x75, 0x83, 0xA0, 0xE0, 0x20, 0xE0, 0x26, 0xDE,
-/*17D0*/0xF4, 0x05, 0x57, 0xE5, 0x57, 0x70, 0x02, 0x05,
-        0x56, 0xE5, 0x14, 0x24, 0x01, 0xFD, 0xE4, 0x33,
-/*17E0*/0xFC, 0xD3, 0xE5, 0x57, 0x9D, 0xE5, 0x56, 0x9C,
-        0x40, 0xD9, 0xE5, 0x0A, 0x94, 0x20, 0x50, 0x02,
-/*17F0*/0x05, 0x0A, 0x43, 0xE1, 0x08, 0xC2, 0x31, 0x12,
-        0x0E, 0x04, 0x75, 0x83, 0xA6, 0xE0, 0x55, 0x12,
-/*1800*/0x65, 0x12, 0x70, 0x03, 0xD2, 0x31, 0x22, 0xC2,
-        0x31, 0x22, 0x90, 0x07, 0x26, 0xE0, 0xFA, 0xA3,
-/*1810*/0xE0, 0xF5, 0x82, 0x8A, 0x83, 0xE0, 0xF5, 0x41,
-        0xE5, 0x39, 0xC3, 0x95, 0x41, 0x40, 0x26, 0xE5,
-/*1820*/0x39, 0x95, 0x41, 0xC3, 0x9F, 0xEE, 0x12, 0x07,
-        0x6B, 0x40, 0x04, 0x7C, 0x01, 0x80, 0x02, 0x7C,
-/*1830*/0x00, 0xE5, 0x41, 0x64, 0x3F, 0x60, 0x04, 0x7B,
-        0x01, 0x80, 0x02, 0x7B, 0x00, 0xEC, 0x5B, 0x60,
-/*1840*/0x29, 0x05, 0x41, 0x80, 0x28, 0xC3, 0xE5, 0x41,
-        0x95, 0x39, 0xC3, 0x9F, 0xEE, 0x12, 0x07, 0x6B,
-/*1850*/0x40, 0x04, 0x7F, 0x01, 0x80, 0x02, 0x7F, 0x00,
-        0xE5, 0x41, 0x60, 0x04, 0x7E, 0x01, 0x80, 0x02,
-/*1860*/0x7E, 0x00, 0xEF, 0x5E, 0x60, 0x04, 0x15, 0x41,
-        0x80, 0x03, 0x85, 0x39, 0x41, 0x85, 0x3A, 0x40,
-/*1870*/0x22, 0xE5, 0xE2, 0x30, 0xE4, 0x60, 0xE5, 0xE1,
-        0x30, 0xE2, 0x5B, 0xE5, 0x09, 0x70, 0x04, 0x7F,
-/*1880*/0x01, 0x80, 0x02, 0x7F, 0x00, 0xE5, 0x08, 0x70,
-        0x04, 0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00, 0xEE,
-/*1890*/0x5F, 0x60, 0x43, 0x53, 0xF9, 0xF8, 0xE5, 0xE2,
-        0x30, 0xE4, 0x3B, 0xE5, 0xE1, 0x30, 0xE2, 0x2E,
-/*18A0*/0x43, 0xFA, 0x02, 0x53, 0xFA, 0xFB, 0xE4, 0xF5,
-        0x10, 0x90, 0x94, 0x70, 0xE5, 0x10, 0xF0, 0xE5,
-/*18B0*/0xE1, 0x30, 0xE2, 0xE7, 0x90, 0x94, 0x70, 0xE0,
-        0x65, 0x10, 0x60, 0x03, 0x43, 0xFA, 0x04, 0x05,
-/*18C0*/0x10, 0x90, 0x94, 0x70, 0xE5, 0x10, 0xF0, 0x70,
-        0xE6, 0x12, 0x00, 0x06, 0x80, 0xE1, 0x53, 0xFA,
-/*18D0*/0xFD, 0x53, 0xFA, 0xFB, 0x80, 0xC0, 0x22, 0x8F,
-        0x54, 0x12, 0x00, 0x06, 0xE5, 0xE1, 0x30, 0xE0,
-/*18E0*/0x04, 0x7F, 0x01, 0x80, 0x02, 0x7F, 0x00, 0xE5,
-        0x7E, 0xD3, 0x94, 0x05, 0x40, 0x04, 0x7E, 0x01,
-/*18F0*/0x80, 0x02, 0x7E, 0x00, 0xEE, 0x4F, 0x60, 0x3D,
-        0x85, 0x54, 0x11, 0xE5, 0xE2, 0x20, 0xE1, 0x32,
-/*1900*/0x74, 0xCE, 0x12, 0x1A, 0x05, 0x30, 0xE7, 0x04,
-        0x7D, 0x01, 0x80, 0x02, 0x7D, 0x00, 0x8F, 0x82,
-/*1910*/0x8E, 0x83, 0xE0, 0x30, 0xE6, 0x04, 0x7F, 0x01,
-        0x80, 0x02, 0x7F, 0x00, 0xEF, 0x5D, 0x70, 0x15,
-/*1920*/0x12, 0x15, 0xC6, 0x74, 0xCE, 0x12, 0x1A, 0x05,
-        0x30, 0xE6, 0x07, 0xE0, 0x44, 0x80, 0xF0, 0x43,
-/*1930*/0xF9, 0x80, 0x12, 0x18, 0x71, 0x22, 0x12, 0x0E,
-        0x44, 0xE5, 0x16, 0x25, 0xE0, 0x25, 0xE0, 0x24,
-/*1940*/0xB0, 0xF5, 0x82, 0xE4, 0x34, 0x1A, 0xF5, 0x83,
-        0xE4, 0x93, 0xF5, 0x0F, 0xE5, 0x16, 0x25, 0xE0,
-/*1950*/0x25, 0xE0, 0x24, 0xB1, 0xF5, 0x82, 0xE4, 0x34,
-        0x1A, 0xF5, 0x83, 0xE4, 0x93, 0xF5, 0x0E, 0x12,
-/*1960*/0x0E, 0x65, 0xF5, 0x10, 0xE5, 0x0F, 0x54, 0xF0,
-        0x12, 0x0E, 0x17, 0x75, 0x83, 0x8C, 0xEF, 0xF0,
-/*1970*/0xE5, 0x0F, 0x30, 0xE0, 0x0C, 0x12, 0x0E, 0x04,
-        0x75, 0x83, 0x86, 0xE0, 0x44, 0x40, 0xF0, 0x80,
-/*1980*/0x0A, 0x12, 0x0E, 0x04, 0x75, 0x83, 0x86, 0xE0,
-        0x54, 0xBF, 0xF0, 0x12, 0x0E, 0x91, 0x75, 0x83,
-/*1990*/0x82, 0xE5, 0x0E, 0xF0, 0x22, 0x7F, 0x05, 0x12,
-        0x17, 0x31, 0x12, 0x0E, 0x04, 0x12, 0x0E, 0x33,
-/*19A0*/0x74, 0x02, 0xF0, 0x74, 0x8E, 0xFE, 0x12, 0x0E,
-        0x04, 0x12, 0x0E, 0x0B, 0xEF, 0xF0, 0x75, 0x15,
-/*19B0*/0x70, 0x12, 0x0F, 0xF7, 0x20, 0x34, 0x05, 0x75,
-        0x15, 0x10, 0x80, 0x03, 0x75, 0x15, 0x50, 0x12,
-/*19C0*/0x0F, 0xF7, 0x20, 0x34, 0x04, 0x74, 0x10, 0x80,
-        0x02, 0x74, 0xF0, 0x25, 0x15, 0xF5, 0x15, 0x12,
-/*19D0*/0x0E, 0x21, 0xEF, 0xF0, 0x12, 0x10, 0x91, 0x20,
-        0x34, 0x17, 0xE5, 0x15, 0x64, 0x30, 0x60, 0x0C,
-/*19E0*/0x74, 0x10, 0x25, 0x15, 0xF5, 0x15, 0xB4, 0x80,
-        0x03, 0xE4, 0xF5, 0x15, 0x12, 0x0E, 0x21, 0xEF,
-/*19F0*/0xF0, 0x22, 0xF0, 0xE5, 0x0B, 0x25, 0xE0, 0x25,
-        0xE0, 0x24, 0x82, 0xF5, 0x82, 0xE4, 0x34, 0x07,
-/*1A00*/0xF5, 0x83, 0x22, 0x74, 0x88, 0xFE, 0xE5, 0x08,
-        0x44, 0x07, 0xFF, 0xF5, 0x82, 0x8E, 0x83, 0xE0,
-/*1A10*/0x22, 0xF0, 0xE5, 0x08, 0x44, 0x07, 0xF5, 0x82,
-        0x22, 0xF0, 0xE0, 0x54, 0xC0, 0x8F, 0x82, 0x8E,
-/*1A20*/0x83, 0xF0, 0x22, 0xEF, 0x44, 0x07, 0xF5, 0x82,
-        0x75, 0x83, 0x86, 0xE0, 0x54, 0x10, 0xD3, 0x94,
-/*1A30*/0x00, 0x22, 0xF0, 0x90, 0x07, 0x15, 0xE0, 0x04,
-        0xF0, 0x22, 0x44, 0x06, 0xF5, 0x82, 0x75, 0x83,
-/*1A40*/0x9E, 0xE0, 0x22, 0xFE, 0xEF, 0x44, 0x07, 0xF5,
-        0x82, 0x8E, 0x83, 0xE0, 0x22, 0xE4, 0x90, 0x07,
-/*1A50*/0x2A, 0xF0, 0xA3, 0xF0, 0x12, 0x07, 0x2A, 0x75,
-        0x83, 0x82, 0xE0, 0x54, 0x7F, 0x12, 0x07, 0x29,
-/*1A60*/0xE0, 0x44, 0x80, 0xF0, 0x12, 0x10, 0xFC, 0x12,
-        0x08, 0x1F, 0x75, 0x83, 0xA0, 0xE0, 0x20, 0xE0,
-/*1A70*/0x1A, 0x90, 0x07, 0x2B, 0xE0, 0x04, 0xF0, 0x70,
-        0x06, 0x90, 0x07, 0x2A, 0xE0, 0x04, 0xF0, 0x90,
-/*1A80*/0x07, 0x2A, 0xE0, 0xB4, 0x10, 0xE1, 0xA3, 0xE0,
-        0xB4, 0x00, 0xDC, 0xEE, 0x44, 0xA6, 0xFC, 0xEF,
-/*1A90*/0x44, 0x07, 0xF5, 0x82, 0x8C, 0x83, 0xE0, 0xF5,
-        0x32, 0xEE, 0x44, 0xA8, 0xFE, 0xEF, 0x44, 0x07,
-/*1AA0*/0xF5, 0x82, 0x8E, 0x83, 0xE0, 0xF5, 0x33, 0x22,
-        0x01, 0x20, 0x11, 0x00, 0x04, 0x20, 0x00, 0x90,
-/*1AB0*/0x00, 0x20, 0x0F, 0x92, 0x00, 0x21, 0x0F, 0x94,
-        0x00, 0x22, 0x0F, 0x96, 0x00, 0x23, 0x0F, 0x98,
-/*1AC0*/0x00, 0x24, 0x0F, 0x9A, 0x00, 0x25, 0x0F, 0x9C,
-        0x00, 0x26, 0x0F, 0x9E, 0x00, 0x27, 0x0F, 0xA0,
-/*1AD0*/0x01, 0x20, 0x01, 0xA2, 0x01, 0x21, 0x01, 0xA4,
-        0x01, 0x22, 0x01, 0xA6, 0x01, 0x23, 0x01, 0xA8,
-/*1AE0*/0x01, 0x24, 0x01, 0xAA, 0x01, 0x25, 0x01, 0xAC,
-        0x01, 0x26, 0x01, 0xAE, 0x01, 0x27, 0x01, 0xB0,
-/*1AF0*/0x01, 0x28, 0x01, 0xB4, 0x00, 0x28, 0x0F, 0xB6,
-        0x40, 0x28, 0x0F, 0xB8, 0x61, 0x28, 0x01, 0xCB,
-/*1B00*/0xEF, 0xCB, 0xCA, 0xEE, 0xCA, 0x7F, 0x01, 0xE4,
-        0xFD, 0xEB, 0x4A, 0x70, 0x24, 0xE5, 0x08, 0xF5,
-/*1B10*/0x82, 0x74, 0xB6, 0x12, 0x08, 0x29, 0xE5, 0x08,
-        0xF5, 0x82, 0x74, 0xB8, 0x12, 0x08, 0x29, 0xE5,
-/*1B20*/0x08, 0xF5, 0x82, 0x74, 0xBA, 0x12, 0x08, 0x29,
-        0x7E, 0x00, 0x7C, 0x00, 0x12, 0x0A, 0xFF, 0x80,
-/*1B30*/0x12, 0x90, 0x07, 0x26, 0x12, 0x07, 0x35, 0xE5,
-        0x41, 0xF0, 0x90, 0x07, 0x24, 0x12, 0x07, 0x35,
-/*1B40*/0xE5, 0x40, 0xF0, 0x12, 0x07, 0x2A, 0x75, 0x83,
-        0x8E, 0xE4, 0x12, 0x07, 0x29, 0x74, 0x01, 0x12,
-/*1B50*/0x07, 0x29, 0xE4, 0xF0, 0x22, 0xE4, 0xF5, 0x26,
-        0xF5, 0x27, 0x53, 0xE1, 0xFE, 0xF5, 0x2A, 0x75,
-/*1B60*/0x2B, 0x01, 0xF5, 0x08, 0x7F, 0x01, 0x12, 0x17,
-        0x31, 0x30, 0x30, 0x1C, 0x90, 0x1A, 0xA9, 0xE4,
-/*1B70*/0x93, 0xF5, 0x10, 0x90, 0x1F, 0xF9, 0xE4, 0x93,
-        0xF5, 0x10, 0x90, 0x00, 0x41, 0xE4, 0x93, 0xF5,
-/*1B80*/0x10, 0x90, 0x1E, 0xCA, 0xE4, 0x93, 0xF5, 0x10,
-        0x7F, 0x02, 0x12, 0x17, 0x31, 0x12, 0x0F, 0x54,
-/*1B90*/0x7F, 0x03, 0x12, 0x17, 0x31, 0x12, 0x00, 0x06,
-        0xE5, 0xE2, 0x30, 0xE7, 0x09, 0x12, 0x10, 0x00,
-/*1BA0*/0x30, 0x30, 0x03, 0x12, 0x11, 0x00, 0x02, 0x00,
-        0x47, 0x12, 0x08, 0x1F, 0x75, 0x83, 0xD0, 0xE0,
-/*1BB0*/0xC4, 0x54, 0x0F, 0xFD, 0x75, 0x43, 0x01, 0x75,
-        0x44, 0xFF, 0x12, 0x08, 0xAA, 0x74, 0x04, 0xF0,
-/*1BC0*/0x75, 0x3B, 0x01, 0xED, 0x14, 0x60, 0x0C, 0x14,
-        0x60, 0x0B, 0x14, 0x60, 0x0F, 0x24, 0x03, 0x70,
-/*1BD0*/0x0B, 0x80, 0x09, 0x80, 0x00, 0x12, 0x08, 0xA7,
-        0x04, 0xF0, 0x80, 0x06, 0x12, 0x08, 0xA7, 0x74,
-/*1BE0*/0x04, 0xF0, 0xEE, 0x44, 0x82, 0xFE, 0xEF, 0x44,
-        0x07, 0xF5, 0x82, 0x8E, 0x83, 0xE5, 0x45, 0x12,
-/*1BF0*/0x08, 0xBE, 0x75, 0x83, 0x82, 0xE5, 0x31, 0xF0,
-        0x02, 0x11, 0x4C, 0x8E, 0x60, 0x8F, 0x61, 0x12,
-/*1C00*/0x1E, 0xA5, 0xE4, 0xFF, 0xCE, 0xED, 0xCE, 0xEE,
-        0xD3, 0x95, 0x61, 0xE5, 0x60, 0x12, 0x07, 0x6B,
-/*1C10*/0x40, 0x39, 0x74, 0x20, 0x2E, 0xF5, 0x82, 0xE4,
-        0x34, 0x03, 0xF5, 0x83, 0xE0, 0x70, 0x03, 0xFF,
-/*1C20*/0x80, 0x26, 0x12, 0x08, 0xE2, 0xFD, 0xC3, 0x9F,
-        0x40, 0x1E, 0xCF, 0xED, 0xCF, 0xEB, 0x4A, 0x70,
-/*1C30*/0x0B, 0x8D, 0x42, 0x12, 0x08, 0xEE, 0xF5, 0x41,
-        0x8E, 0x40, 0x80, 0x0C, 0x12, 0x08, 0xE2, 0xF5,
-/*1C40*/0x38, 0x12, 0x08, 0xEE, 0xF5, 0x39, 0x8E, 0x3A,
-        0x1E, 0x80, 0xBC, 0x22, 0x75, 0x58, 0x01, 0xE5,
-/*1C50*/0x35, 0x70, 0x0C, 0x12, 0x07, 0xCC, 0xE0, 0xF5,
-        0x4A, 0x12, 0x07, 0xD8, 0xE0, 0xF5, 0x4C, 0xE5,
-/*1C60*/0x35, 0xB4, 0x04, 0x0C, 0x12, 0x07, 0xE4, 0xE0,
-        0xF5, 0x4A, 0x12, 0x07, 0xF0, 0xE0, 0xF5, 0x4C,
-/*1C70*/0xE5, 0x35, 0xB4, 0x01, 0x04, 0x7F, 0x01, 0x80,
-        0x02, 0x7F, 0x00, 0xE5, 0x35, 0xB4, 0x02, 0x04,
-/*1C80*/0x7E, 0x01, 0x80, 0x02, 0x7E, 0x00, 0xEE, 0x4F,
-        0x60, 0x0C, 0x12, 0x07, 0xFC, 0xE0, 0xF5, 0x4A,
-/*1C90*/0x12, 0x08, 0x08, 0xE0, 0xF5, 0x4C, 0x85, 0x41,
-        0x49, 0x85, 0x40, 0x4B, 0x22, 0x75, 0x5B, 0x01,
-/*1CA0*/0x90, 0x07, 0x24, 0x12, 0x07, 0x35, 0xE0, 0x54,
-        0x1F, 0xFF, 0xD3, 0x94, 0x02, 0x50, 0x04, 0x8F,
-/*1CB0*/0x58, 0x80, 0x05, 0xEF, 0x24, 0xFE, 0xF5, 0x58,
-        0xEF, 0xC3, 0x94, 0x18, 0x40, 0x05, 0x75, 0x59,
-/*1CC0*/0x18, 0x80, 0x04, 0xEF, 0x04, 0xF5, 0x59, 0x85,
-        0x43, 0x5A, 0xAF, 0x58, 0x7E, 0x00, 0xAD, 0x59,
-/*1CD0*/0x7C, 0x00, 0xAB, 0x5B, 0x7A, 0x00, 0x12, 0x15,
-        0x41, 0xAF, 0x5A, 0x7E, 0x00, 0x12, 0x18, 0x0A,
-/*1CE0*/0xAF, 0x5B, 0x7E, 0x00, 0x02, 0x1A, 0xFF, 0xE5,
-        0xE2, 0x30, 0xE7, 0x0E, 0x12, 0x10, 0x03, 0xC2,
-/*1CF0*/0x30, 0x30, 0x30, 0x03, 0x12, 0x10, 0xFF, 0x20,
-        0x33, 0x28, 0xE5, 0xE7, 0x30, 0xE7, 0x05, 0x12,
-/*1D00*/0x0E, 0xA2, 0x80, 0x0D, 0xE5, 0xFE, 0xC3, 0x94,
-        0x20, 0x50, 0x06, 0x12, 0x0E, 0xA2, 0x43, 0xF9,
-/*1D10*/0x08, 0xE5, 0xF2, 0x30, 0xE7, 0x03, 0x53, 0xF9,
-        0x7F, 0xE5, 0xF1, 0x54, 0x70, 0xD3, 0x94, 0x00,
-/*1D20*/0x50, 0xD8, 0x22, 0x12, 0x0E, 0x04, 0x75, 0x83,
-        0x80, 0xE4, 0xF0, 0xE5, 0x08, 0x44, 0x07, 0x12,
-/*1D30*/0x0D, 0xFD, 0x75, 0x83, 0x84, 0x12, 0x0E, 0x02,
-        0x75, 0x83, 0x86, 0x12, 0x0E, 0x02, 0x75, 0x83,
-/*1D40*/0x8C, 0xE0, 0x54, 0xF3, 0x12, 0x0E, 0x03, 0x75,
-        0x83, 0x8E, 0x12, 0x0E, 0x02, 0x75, 0x83, 0x94,
-/*1D50*/0xE0, 0x54, 0xFB, 0xF0, 0x22, 0x12, 0x07, 0x2A,
-        0x75, 0x83, 0x8E, 0xE4, 0x12, 0x07, 0x29, 0x74,
-/*1D60*/0x01, 0x12, 0x07, 0x29, 0xE4, 0x12, 0x08, 0xBE,
-        0x75, 0x83, 0x8C, 0xE0, 0x44, 0x20, 0x12, 0x08,
-/*1D70*/0xBE, 0xE0, 0x54, 0xDF, 0xF0, 0x74, 0x84, 0x85,
-        0x08, 0x82, 0xF5, 0x83, 0xE0, 0x54, 0x7F, 0xF0,
-/*1D80*/0xE0, 0x44, 0x80, 0xF0, 0x22, 0x75, 0x56, 0x01,
-        0xE4, 0xFD, 0xF5, 0x57, 0xAF, 0x35, 0xFE, 0xFC,
-/*1D90*/0x12, 0x09, 0x15, 0x12, 0x1C, 0x9D, 0x12, 0x1E,
-        0x7A, 0x12, 0x1C, 0x4C, 0xAF, 0x57, 0x7E, 0x00,
-/*1DA0*/0xAD, 0x56, 0x7C, 0x00, 0x12, 0x04, 0x44, 0xAF,
-        0x56, 0x7E, 0x00, 0x02, 0x11, 0xEE, 0x75, 0x56,
-/*1DB0*/0x01, 0xE4, 0xFD, 0xF5, 0x57, 0xAF, 0x35, 0xFE,
-        0xFC, 0x12, 0x09, 0x15, 0x12, 0x1C, 0x9D, 0x12,
-/*1DC0*/0x1E, 0x7A, 0x12, 0x1C, 0x4C, 0xAF, 0x57, 0x7E,
-        0x00, 0xAD, 0x56, 0x7C, 0x00, 0x12, 0x04, 0x44,
-/*1DD0*/0xAF, 0x56, 0x7E, 0x00, 0x02, 0x11, 0xEE, 0xE4,
-        0xF5, 0x16, 0x12, 0x0E, 0x44, 0xFE, 0xE5, 0x08,
-/*1DE0*/0x44, 0x05, 0xFF, 0x12, 0x0E, 0x65, 0x8F, 0x82,
-        0x8E, 0x83, 0xF0, 0x05, 0x16, 0xE5, 0x16, 0xC3,
-/*1DF0*/0x94, 0x14, 0x40, 0xE6, 0xE5, 0x08, 0x12, 0x0E,
-        0x2B, 0xE4, 0xF0, 0x22, 0xE4, 0xF5, 0x58, 0xF5,
-/*1E00*/0x59, 0xF5, 0x5A, 0xFF, 0xFE, 0xAD, 0x58, 0xFC,
-        0x12, 0x09, 0x15, 0x7F, 0x04, 0x7E, 0x00, 0xAD,
-/*1E10*/0x58, 0x7C, 0x00, 0x12, 0x09, 0x15, 0x7F, 0x02,
-        0x7E, 0x00, 0xAD, 0x58, 0x7C, 0x00, 0x02, 0x09,
-/*1E20*/0x15, 0xE5, 0x3C, 0x25, 0x3E, 0xFC, 0xE5, 0x42,
-        0x24, 0x00, 0xFB, 0xE4, 0x33, 0xFA, 0xEC, 0xC3,
-/*1E30*/0x9B, 0xEA, 0x12, 0x07, 0x6B, 0x40, 0x0B, 0x8C,
-        0x42, 0xE5, 0x3D, 0x25, 0x3F, 0xF5, 0x41, 0x8F,
-/*1E40*/0x40, 0x22, 0x12, 0x09, 0x0B, 0x22, 0x74, 0x84,
-        0xF5, 0x18, 0x85, 0x08, 0x19, 0x85, 0x19, 0x82,
-/*1E50*/0x85, 0x18, 0x83, 0xE0, 0x54, 0x7F, 0xF0, 0xE0,
-        0x44, 0x80, 0xF0, 0xE0, 0x44, 0x80, 0xF0, 0x22,
-/*1E60*/0xEF, 0x4E, 0x70, 0x0B, 0x12, 0x07, 0x2A, 0x75,
-        0x83, 0xD2, 0xE0, 0x54, 0xDF, 0xF0, 0x22, 0x12,
-/*1E70*/0x07, 0x2A, 0x75, 0x83, 0xD2, 0xE0, 0x44, 0x20,
-        0xF0, 0x22, 0x75, 0x58, 0x01, 0x90, 0x07, 0x26,
-/*1E80*/0x12, 0x07, 0x35, 0xE0, 0x54, 0x3F, 0xF5, 0x41,
-        0x12, 0x07, 0x32, 0xE0, 0x54, 0x3F, 0xF5, 0x40,
-/*1E90*/0x22, 0x75, 0x56, 0x02, 0xE4, 0xF5, 0x57, 0x12,
-        0x1D, 0xFC, 0xAF, 0x57, 0x7E, 0x00, 0xAD, 0x56,
-/*1EA0*/0x7C, 0x00, 0x02, 0x04, 0x44, 0xE4, 0xF5, 0x42,
-        0xF5, 0x41, 0xF5, 0x40, 0xF5, 0x38, 0xF5, 0x39,
-/*1EB0*/0xF5, 0x3A, 0x22, 0xEF, 0x54, 0x07, 0xFF, 0xE5,
-        0xF9, 0x54, 0xF8, 0x4F, 0xF5, 0xF9, 0x22, 0x7F,
-/*1EC0*/0x01, 0xE4, 0xFE, 0x0F, 0x0E, 0xBE, 0xFF, 0xFB,
-        0x22, 0x01, 0x20, 0x00, 0x01, 0x04, 0x20, 0x00,
-/*1ED0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1EE0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1EF0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F00*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F10*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F20*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F30*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F40*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F50*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F60*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F70*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F80*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1F90*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1FA0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1FB0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1FC0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1FD0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1FE0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-/*1FF0*/0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x01, 0x20, 0x11, 0x00, 0x04, 0x20, 0x00, 0x81
-};
-
-int qib_sd7220_ib_load(struct qib_devdata *dd)
-{
-        return qib_sd7220_prog_ld(dd, IB_7220_SERDES, qib_sd7220_ib_img,
-                sizeof(qib_sd7220_ib_img), 0);
-}
-
-int qib_sd7220_ib_vfy(struct qib_devdata *dd)
-{
-        return qib_sd7220_prog_vfy(dd, IB_7220_SERDES, qib_sd7220_ib_img,
-                sizeof(qib_sd7220_ib_img), 0);
-}
diff --git a/drivers/infiniband/hw/qib/qib_tx.c b/drivers/infiniband/hw/qib/qib_tx.c
index f7eb1ddff5f3..af30232b6831 100644
--- a/drivers/infiniband/hw/qib/qib_tx.c
+++ b/drivers/infiniband/hw/qib/qib_tx.c
@@ -340,9 +340,13 @@ rescan:
                 if (i < dd->piobcnt2k)
                         buf = (u32 __iomem *)(dd->pio2kbase +
                                 i * dd->palign);
-                else
+                else if (i < dd->piobcnt2k + dd->piobcnt4k || !dd->piovl15base)
                         buf = (u32 __iomem *)(dd->pio4kbase +
                                 (i - dd->piobcnt2k) * dd->align4k);
+                else
+                        buf = (u32 __iomem *)(dd->piovl15base +
+                                (i - (dd->piobcnt2k + dd->piobcnt4k)) *
+                                dd->align4k);
                 if (pbufnum)
                         *pbufnum = i;
                 dd->upd_pio_shadow = 0;
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index df3eb8c9fd96..b4b22576f12a 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -1163,7 +1163,7 @@ static ssize_t create_child(struct device *dev,
 
         return ret ? ret : count;
 }
-static DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child);
+static DEVICE_ATTR(create_child, S_IWUSR, NULL, create_child);
 
 static ssize_t delete_child(struct device *dev,
                             struct device_attribute *attr,
@@ -1183,7 +1183,7 @@ static ssize_t delete_child(struct device *dev,
         return ret ? ret : count;
 
 }
-static DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child);
+static DEVICE_ATTR(delete_child, S_IWUSR, NULL, delete_child);
 
 int ipoib_add_pkey_attr(struct net_device *dev)
 {
diff --git a/drivers/input/joystick/gamecon.c b/drivers/input/joystick/gamecon.c
index fbd62abb66f9..0ffaf2c77a19 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -89,7 +89,6 @@ struct gc_pad {
 struct gc {
         struct pardevice *pd;
         struct gc_pad pads[GC_MAX_DEVICES];
-        struct input_dev *dev[GC_MAX_DEVICES];
         struct timer_list timer;
         int pad_count[GC_MAX];
         int used;
@@ -387,7 +386,7 @@ static void gc_nes_process_packet(struct gc *gc)
         for (i = 0; i < GC_MAX_DEVICES; i++) {
 
                 pad = &gc->pads[i];
-                dev = gc->dev[i];
+                dev = pad->dev;
                 s = gc_status_bit[i];
 
                 switch (pad->type) {
@@ -579,7 +578,7 @@ static void gc_psx_command(struct gc *gc, int b, unsigned char *data)
                 read = parport_read_status(port) ^ 0x80;
 
                 for (j = 0; j < GC_MAX_DEVICES; j++) {
-                        struct gc_pad *pad = &gc->pads[i];
+                        struct gc_pad *pad = &gc->pads[j];
 
                         if (pad->type == GC_PSX || pad->type == GC_DDR)
                                 data[j] |= (read & gc_status_bit[j]) ? (1 << i) : 0;
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 0f9a4785d798..1ba25145b333 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -69,11 +69,11 @@ config KEYBOARD_ATARI
           module will be called atakbd.
 
 config KEYBOARD_ATKBD
-        tristate "AT keyboard" if EMBEDDED || !X86 || X86_MRST
+        tristate "AT keyboard" if EMBEDDED || !X86
         default y
         select SERIO
         select SERIO_LIBPS2
-        select SERIO_I8042 if X86 && !X86_MRST
+        select SERIO_I8042 if X86
         select SERIO_GSCPS2 if GSC
         help
           Say Y here if you want to use a standard AT or PS/2 keyboard. Usually
@@ -124,7 +124,7 @@ config KEYBOARD_ATKBD_RDI_KEYCODES
           right-hand column will be interpreted as the key shown in the
           left-hand column.
 
-config QT2160
+config KEYBOARD_QT2160
         tristate "Atmel AT42QT2160 Touch Sensor Chip"
         depends on I2C && EXPERIMENTAL
         help
diff --git a/drivers/input/keyboard/twl4030_keypad.c b/drivers/input/keyboard/twl4030_keypad.c
index 7aa59e07b689..fb16b5e5ea13 100644
--- a/drivers/input/keyboard/twl4030_keypad.c
+++ b/drivers/input/keyboard/twl4030_keypad.c
@@ -51,8 +51,12 @@
  */
 #define TWL4030_MAX_ROWS        8       /* TWL4030 hard limit */
 #define TWL4030_MAX_COLS        8
-#define TWL4030_ROW_SHIFT       3
-#define TWL4030_KEYMAP_SIZE     (TWL4030_MAX_ROWS * TWL4030_MAX_COLS)
+/*
+ * Note that we add space for an extra column so that we can handle
+ * row lines connected to the gnd (see twl4030_col_xlate()).
+ */
+#define TWL4030_ROW_SHIFT       4
+#define TWL4030_KEYMAP_SIZE     (TWL4030_MAX_ROWS << TWL4030_ROW_SHIFT)
 
 struct twl4030_keypad {
         unsigned short  keymap[TWL4030_KEYMAP_SIZE];
@@ -182,7 +186,7 @@ static int twl4030_read_kp_matrix_state(struct twl4030_keypad *kp, u16 *state)
         return ret;
 }
 
-static int twl4030_is_in_ghost_state(struct twl4030_keypad *kp, u16 *key_state)
+static bool twl4030_is_in_ghost_state(struct twl4030_keypad *kp, u16 *key_state)
 {
         int i;
         u16 check = 0;
@@ -191,12 +195,12 @@ static int twl4030_is_in_ghost_state(struct twl4030_keypad *kp, u16 *key_state)
                 u16 col = key_state[i];
 
                 if ((col & check) && hweight16(col) > 1)
-                        return 1;
+                        return true;
 
                 check |= col;
         }
 
-        return 0;
+        return false;
 }
 
 static void twl4030_kp_scan(struct twl4030_keypad *kp, bool release_all)
@@ -225,7 +229,8 @@ static void twl4030_kp_scan(struct twl4030_keypad *kp, bool release_all)
                 if (!changed)
                         continue;
 
-                for (col = 0; col < kp->n_cols; col++) {
+                /* Extra column handles "all gnd" rows */
+                for (col = 0; col < kp->n_cols + 1; col++) {
                         int code;
 
                         if (!(changed & (1 << col)))
diff --git a/drivers/input/keyboard/w90p910_keypad.c b/drivers/input/keyboard/w90p910_keypad.c
index 4ef764cc493c..ee2bf6bcf291 100644
--- a/drivers/input/keyboard/w90p910_keypad.c
+++ b/drivers/input/keyboard/w90p910_keypad.c
@@ -258,7 +258,7 @@ static struct platform_driver w90p910_keypad_driver = {
         .probe          = w90p910_keypad_probe,
         .remove         = __devexit_p(w90p910_keypad_remove),
         .driver         = {
-                .name   = "nuc900-keypad",
+                .name   = "nuc900-kpi",
                 .owner  = THIS_MODULE,
         },
 };
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index eeb58c1cac16..c714ca2407f8 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -17,7 +17,7 @@ config MOUSE_PS2
         default y
         select SERIO
         select SERIO_LIBPS2
-        select SERIO_I8042 if X86 && !X86_MRST
+        select SERIO_I8042 if X86
         select SERIO_GSCPS2 if GSC
         help
           Say Y here if you have a PS/2 mouse connected to your system. This
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index 40cea334ad13..705589dc9ac5 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -141,8 +141,13 @@ static int synaptics_capability(struct psmouse *psmouse)
         priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
         priv->ext_cap = priv->ext_cap_0c = 0;
 
-        if (!SYN_CAP_VALID(priv->capabilities))
+        /*
+         * Older firmwares had submodel ID fixed to 0x47
+         */
+        if (SYN_ID_FULL(priv->identity) < 0x705 &&
+            SYN_CAP_SUBMODEL_ID(priv->capabilities) != 0x47) {
                 return -1;
+        }
 
         /*
          * Unless capExtended is set the rest of the flags should be ignored
@@ -206,6 +211,7 @@ static int synaptics_resolution(struct psmouse *psmouse)
         unsigned char max[3];
 
         if (SYN_ID_MAJOR(priv->identity) < 4)
+                return 0;
 
         if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
                 if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index 7d4d5e12c0df..b6aa7d20d8a3 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -47,7 +47,7 @@
 #define SYN_CAP_FOUR_BUTTON(c)          ((c) & (1 << 3))
 #define SYN_CAP_MULTIFINGER(c)          ((c) & (1 << 1))
 #define SYN_CAP_PALMDETECT(c)           ((c) & (1 << 0))
-#define SYN_CAP_VALID(c)                ((((c) & 0x00ff00) >> 8) == 0x47)
+#define SYN_CAP_SUBMODEL_ID(c)          (((c) & 0x00ff00) >> 8)
 #define SYN_EXT_CAP_REQUESTS(c)         (((c) & 0x700000) >> 20)
 #define SYN_CAP_MULTI_BUTTON_NO(ec)     (((ec) & 0x00f000) >> 12)
 #define SYN_CAP_PRODUCT_ID(ec)          (((ec) & 0xff0000) >> 16)
@@ -66,6 +66,7 @@
 #define SYN_ID_MODEL(i)                 (((i) >> 4) & 0x0f)
 #define SYN_ID_MAJOR(i)                 ((i) & 0x0f)
 #define SYN_ID_MINOR(i)                 (((i) >> 16) & 0xff)
+#define SYN_ID_FULL(i)                  ((SYN_ID_MAJOR(i) << 8) | SYN_ID_MINOR(i))
 #define SYN_ID_IS_SYNAPTICS(i)          ((((i) >> 8) & 0xff) == 0x47)
 
 /* synaptics special commands */
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index 256b9e9394dc..3bfe8fafc6ad 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -22,7 +22,7 @@ config SERIO_I8042
         tristate "i8042 PC Keyboard controller" if EMBEDDED || !X86
         default y
         depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \
-                   (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN && !X86_MRST
+                   (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN
         help
           i8042 is the chip over which the standard AT keyboard and PS/2
           mouse are connected to the computer. If you use these devices,
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 6168469ad1a6..ed7ad7416b24 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -7,6 +7,10 @@
  * the Free Software Foundation.
  */
 
+#ifdef CONFIG_X86
+#include <asm/x86_init.h>
+#endif
+
 /*
  * Names.
  */
@@ -166,6 +170,13 @@ static const struct dmi_system_id __initconst i8042_dmi_noloop_table[] = {
                 },
         },
         {
+                /* Gigabyte Spring Peak - defines wrong chassis type */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Spring Peak"),
+                },
+        },
+        {
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv9700"),
@@ -840,6 +851,12 @@ static int __init i8042_platform_init(void)
 {
         int retval;
 
+#ifdef CONFIG_X86
+        /* Just return if pre-detection shows no i8042 controller exist */
+        if (!x86_platform.i8042_detect())
+                return -ENODEV;
+#endif
+
 /*
  * On ix86 platforms touching the i8042 data register region can do really
  * bad things. Because of this the region is always reserved on ix86 boxes.
diff --git a/drivers/input/touchscreen/w90p910_ts.c b/drivers/input/touchscreen/w90p910_ts.c
index cc18265be1a8..7a45d68c3516 100644
--- a/drivers/input/touchscreen/w90p910_ts.c
+++ b/drivers/input/touchscreen/w90p910_ts.c
@@ -233,7 +233,7 @@ static int __devinit w90x900ts_probe(struct platform_device *pdev)
         w90p910_ts->state = TS_IDLE;
         spin_lock_init(&w90p910_ts->lock);
         setup_timer(&w90p910_ts->timer, w90p910_check_pen_up,
-                    (unsigned long)&w90p910_ts);
+                    (unsigned long)w90p910_ts);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
diff --git a/drivers/media/common/tuners/tuner-simple.c b/drivers/media/common/tuners/tuner-simple.c
index 8abbcc5fcf95..8cf2ab609d5e 100644
--- a/drivers/media/common/tuners/tuner-simple.c
+++ b/drivers/media/common/tuners/tuner-simple.c
@@ -524,6 +524,7 @@ static int simple_radio_bandswitch(struct dvb_frontend *fe, u8 *buffer)
                 buffer[3] = 0x39;
                 break;
         case TUNER_PHILIPS_FQ1216LME_MK3:
+        case TUNER_PHILIPS_FQ1236_MK5:
                 tuner_err("This tuner doesn't have FM\n");
                 /* Set the low band for sanity, since it covers 88-108 MHz */
                 buffer[3] = 0x01;
diff --git a/drivers/media/common/tuners/tuner-types.c b/drivers/media/common/tuners/tuner-types.c
index d9aaaca620c9..58a513bcd747 100644
--- a/drivers/media/common/tuners/tuner-types.c
+++ b/drivers/media/common/tuners/tuner-types.c
@@ -1353,6 +1353,17 @@ static struct tuner_params tuner_sony_btf_pxn01z_params[] = {
         },
 };
 
+/* ------------ TUNER_PHILIPS_FQ1236_MK5 - Philips NTSC ------------ */
+
+static struct tuner_params tuner_philips_fq1236_mk5_params[] = {
+        {
+                .type   = TUNER_PARAM_TYPE_NTSC,
+                .ranges = tuner_fm1236_mk3_ntsc_ranges,
+                .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
+                .has_tda9887 = 1, /* TDA9885, no FM radio */
+        },
+};
+
 /* --------------------------------------------------------------------- */
 
 struct tunertype tuners[] = {
@@ -1826,6 +1837,11 @@ struct tunertype tuners[] = {
                 .params = tuner_sony_btf_pxn01z_params,
                 .count  = ARRAY_SIZE(tuner_sony_btf_pxn01z_params),
         },
+        [TUNER_PHILIPS_FQ1236_MK5] = { /* NTSC, TDA9885, no FM radio */
+                .name   = "Philips FQ1236 MK5",
+                .params = tuner_philips_fq1236_mk5_params,
+                .count  = ARRAY_SIZE(tuner_philips_fq1236_mk5_params),
+        },
 };
 EXPORT_SYMBOL(tuners);
 
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index 9ecacab4b89b..a937e2ff9b6e 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -912,6 +912,9 @@ int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
         clear_bit(IVTV_F_S_STREAMING, &s->s_flags);
         ivtv_flush_queues(s);
 
+        /* decoder needs time to settle */
+        ivtv_msleep_timeout(40, 0);
+
         /* decrement decoding */
         atomic_dec(&itv->decoding);
 
diff --git a/drivers/media/video/mem2mem_testdev.c b/drivers/media/video/mem2mem_testdev.c
index 554eaf140128..10ddeccc70eb 100644
--- a/drivers/media/video/mem2mem_testdev.c
+++ b/drivers/media/video/mem2mem_testdev.c
@@ -988,6 +988,9 @@ static int m2mtest_probe(struct platform_device *pdev)
                 goto err_m2m;
         }
 
+        q_data[V4L2_M2M_SRC].fmt = &formats[0];
+        q_data[V4L2_M2M_DST].fmt = &formats[0];
+
         return 0;
 
 err_m2m:
diff --git a/drivers/media/video/omap/Kconfig b/drivers/media/video/omap/Kconfig
index 97c53949ca89..e63233fd2aaa 100644
--- a/drivers/media/video/omap/Kconfig
+++ b/drivers/media/video/omap/Kconfig
@@ -1,8 +1,8 @@
 config VIDEO_OMAP2_VOUT
         tristate "OMAP2/OMAP3 V4L2-Display driver"
-        depends on ARCH_OMAP24XX || ARCH_OMAP34XX
+        depends on ARCH_OMAP2 || ARCH_OMAP3
         select VIDEOBUF_GEN
-        select VIDEOBUF_DMA_SG
+        select VIDEOBUF_DMA_CONTIG
         select OMAP2_DSS
         select OMAP2_VRAM
         select OMAP2_VRFB
diff --git a/drivers/media/video/omap/Makefile b/drivers/media/video/omap/Makefile
index b8bab00ad010..b28788070ae1 100644
--- a/drivers/media/video/omap/Makefile
+++ b/drivers/media/video/omap/Makefile
@@ -3,5 +3,5 @@
 #
 
 # OMAP2/3 Display driver
-omap-vout-mod-objs := omap_vout.o omap_voutlib.o
-obj-$(CONFIG_VIDEO_OMAP2_VOUT) += omap-vout-mod.o
+omap-vout-y := omap_vout.o omap_voutlib.o
+obj-$(CONFIG_VIDEO_OMAP2_VOUT) += omap-vout.o
diff --git a/drivers/media/video/omap/omap_vout.c b/drivers/media/video/omap/omap_vout.c
index e7db0554949a..929073e792c9 100644
--- a/drivers/media/video/omap/omap_vout.c
+++ b/drivers/media/video/omap/omap_vout.c
@@ -38,8 +38,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/irq.h>
 #include <linux/videodev2.h>
+#include <linux/slab.h>
 
-#include <media/videobuf-dma-sg.h>
+#include <media/videobuf-dma-contig.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
 
@@ -1053,9 +1054,9 @@ static int omap_vout_buffer_prepare(struct videobuf_queue *q,
                             struct videobuf_buffer *vb,
                             enum v4l2_field field)
 {
+        dma_addr_t dmabuf;
         struct vid_vrfb_dma *tx;
         enum dss_rotation rotation;
-        struct videobuf_dmabuf *dmabuf = NULL;
         struct omap_vout_device *vout = q->priv_data;
         u32 dest_frame_index = 0, src_element_index = 0;
         u32 dest_element_index = 0, src_frame_index = 0;
@@ -1074,24 +1075,17 @@ static int omap_vout_buffer_prepare(struct videobuf_queue *q,
         if (V4L2_MEMORY_USERPTR == vb->memory) {
                 if (0 == vb->baddr)
                         return -EINVAL;
-                /* Virtual address */
-                /* priv points to struct videobuf_pci_sg_memory. But we went
-                 * pointer to videobuf_dmabuf, which is member of
-                 * videobuf_pci_sg_memory */
-                dmabuf = videobuf_to_dma(q->bufs[vb->i]);
-                dmabuf->vmalloc = (void *) vb->baddr;
-
                 /* Physical address */
-                dmabuf->bus_addr =
-                        (dma_addr_t) omap_vout_uservirt_to_phys(vb->baddr);
+                vout->queued_buf_addr[vb->i] = (u8 *)
+                        omap_vout_uservirt_to_phys(vb->baddr);
+        } else {
+                vout->queued_buf_addr[vb->i] = (u8 *)vout->buf_phy_addr[vb->i];
         }
 
-        if (!rotation_enabled(vout)) {
-                dmabuf = videobuf_to_dma(q->bufs[vb->i]);
-                vout->queued_buf_addr[vb->i] = (u8 *) dmabuf->bus_addr;
+        if (!rotation_enabled(vout))
                 return 0;
-        }
-        dmabuf = videobuf_to_dma(q->bufs[vb->i]);
+
+        dmabuf = vout->buf_phy_addr[vb->i];
         /* If rotation is enabled, copy input buffer into VRFB
          * memory space using DMA. We are copying input buffer
          * into VRFB memory space of desired angle and DSS will
@@ -1120,7 +1114,7 @@ static int omap_vout_buffer_prepare(struct videobuf_queue *q,
                         tx->dev_id, 0x0);
         /* src_port required only for OMAP1 */
         omap_set_dma_src_params(tx->dma_ch, 0, OMAP_DMA_AMODE_POST_INC,
-                        dmabuf->bus_addr, src_element_index, src_frame_index);
+                        dmabuf, src_element_index, src_frame_index);
         /*set dma source burst mode for VRFB */
         omap_set_dma_src_burst_mode(tx->dma_ch, OMAP_DMA_DATA_BURST_16);
         rotation = calc_rotation(vout);
@@ -1211,7 +1205,6 @@ static int omap_vout_mmap(struct file *file, struct vm_area_struct *vma)
         void *pos;
         unsigned long start = vma->vm_start;
         unsigned long size = (vma->vm_end - vma->vm_start);
-        struct videobuf_dmabuf *dmabuf = NULL;
         struct omap_vout_device *vout = file->private_data;
         struct videobuf_queue *q = &vout->vbq;
 
@@ -1241,8 +1234,7 @@ static int omap_vout_mmap(struct file *file, struct vm_area_struct *vma)
         vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
         vma->vm_ops = &omap_vout_vm_ops;
         vma->vm_private_data = (void *) vout;
-        dmabuf = videobuf_to_dma(q->bufs[i]);
-        pos = dmabuf->vmalloc;
+        pos = (void *)vout->buf_virt_addr[i];
         vma->vm_pgoff = virt_to_phys((void *)pos) >> PAGE_SHIFT;
         while (size > 0) {
                 unsigned long pfn;
@@ -1347,8 +1339,8 @@ static int omap_vout_open(struct file *file)
         video_vbq_ops.buf_queue = omap_vout_buffer_queue;
         spin_lock_init(&vout->vbq_lock);
 
-        videobuf_queue_sg_init(q, &video_vbq_ops, NULL, &vout->vbq_lock,
-                        vout->type, V4L2_FIELD_NONE,
+        videobuf_queue_dma_contig_init(q, &video_vbq_ops, q->dev,
+                        &vout->vbq_lock, vout->type, V4L2_FIELD_NONE,
                         sizeof(struct videobuf_buffer), vout);
 
         v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "Exiting %s\n", __func__);
@@ -1799,7 +1791,6 @@ static int vidioc_reqbufs(struct file *file, void *fh,
         unsigned int i, num_buffers = 0;
         struct omap_vout_device *vout = fh;
         struct videobuf_queue *q = &vout->vbq;
-        struct videobuf_dmabuf *dmabuf = NULL;
 
         if ((req->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) || (req->count < 0))
                 return -EINVAL;
@@ -1825,8 +1816,7 @@ static int vidioc_reqbufs(struct file *file, void *fh,
                 num_buffers = (vout->vid == OMAP_VIDEO1) ?
                         video1_numbuffers : video2_numbuffers;
                 for (i = num_buffers; i < vout->buffer_allocated; i++) {
-                        dmabuf = videobuf_to_dma(q->bufs[i]);
-                        omap_vout_free_buffer((u32)dmabuf->vmalloc,
+                        omap_vout_free_buffer(vout->buf_virt_addr[i],
                                         vout->buffer_size);
                         vout->buf_virt_addr[i] = 0;
                         vout->buf_phy_addr[i] = 0;
@@ -1855,12 +1845,7 @@ static int vidioc_reqbufs(struct file *file, void *fh,
                 goto reqbuf_err;
 
         vout->buffer_allocated = req->count;
-        for (i = 0; i < req->count; i++) {
-                dmabuf = videobuf_to_dma(q->bufs[i]);
-                dmabuf->vmalloc = (void *) vout->buf_virt_addr[i];
-                dmabuf->bus_addr = (dma_addr_t) vout->buf_phy_addr[i];
-                dmabuf->sglen = 1;
-        }
+
 reqbuf_err:
         mutex_unlock(&vout->lock);
         return ret;
@@ -2488,7 +2473,7 @@ static int omap_vout_remove(struct platform_device *pdev)
 
         for (k = 0; k < vid_dev->num_displays; k++) {
                 if (vid_dev->displays[k]->state != OMAP_DSS_DISPLAY_DISABLED)
-                        vid_dev->displays[k]->disable(vid_dev->displays[k]);
+                        vid_dev->displays[k]->driver->disable(vid_dev->displays[k]);
 
                 omap_dss_put_device(vid_dev->displays[k]);
         }
@@ -2545,7 +2530,9 @@ static int __init omap_vout_probe(struct platform_device *pdev)
                         def_display = NULL;
                 }
                 if (def_display) {
-                        ret = def_display->enable(def_display);
+                        struct omap_dss_driver *dssdrv = def_display->driver;
+
+                        ret = dssdrv->enable(def_display);
                         if (ret) {
                                 /* Here we are not considering a error
                                  *  as display may be enabled by frame
@@ -2559,21 +2546,21 @@ static int __init omap_vout_probe(struct platform_device *pdev)
                         if (def_display->caps &
                                         OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
 #ifdef CONFIG_FB_OMAP2_FORCE_AUTO_UPDATE
-                                if (def_display->enable_te)
-                                        def_display->enable_te(def_display, 1);
-                                if (def_display->set_update_mode)
-                                        def_display->set_update_mode(def_display,
+                                if (dssdrv->enable_te)
+                                        dssdrv->enable_te(def_display, 1);
+                                if (dssdrv->set_update_mode)
+                                        dssdrv->set_update_mode(def_display,
                                                         OMAP_DSS_UPDATE_AUTO);
 #else   /* MANUAL_UPDATE */
-                                if (def_display->enable_te)
-                                        def_display->enable_te(def_display, 0);
-                                if (def_display->set_update_mode)
-                                        def_display->set_update_mode(def_display,
+                                if (dssdrv->enable_te)
+                                        dssdrv->enable_te(def_display, 0);
+                                if (dssdrv->set_update_mode)
+                                        dssdrv->set_update_mode(def_display,
                                                         OMAP_DSS_UPDATE_MANUAL);
 #endif
                         } else {
-                                if (def_display->set_update_mode)
-                                        def_display->set_update_mode(def_display,
+                                if (dssdrv->set_update_mode)
+                                        dssdrv->set_update_mode(def_display,
                                                         OMAP_DSS_UPDATE_AUTO);
                         }
                 }
@@ -2592,8 +2579,8 @@ static int __init omap_vout_probe(struct platform_device *pdev)
         for (i = 0; i < vid_dev->num_displays; i++) {
                 struct omap_dss_device *display = vid_dev->displays[i];
 
-                if (display->update)
-                        display->update(display, 0, 0,
+                if (display->driver->update)
+                        display->driver->update(display, 0, 0,
                                         display->panel.timings.x_res,
                                         display->panel.timings.y_res);
         }
@@ -2608,8 +2595,8 @@ probe_err1:
                 if (ovl->manager && ovl->manager->device)
                         def_display = ovl->manager->device;
 
-                if (def_display)
-                        def_display->disable(def_display);
+                if (def_display && def_display->driver)
+                        def_display->driver->disable(def_display);
         }
 probe_err0:
         kfree(vid_dev);
diff --git a/drivers/media/video/tveeprom.c b/drivers/media/video/tveeprom.c
index 0a877497b93f..07fabdd9b465 100644
--- a/drivers/media/video/tveeprom.c
+++ b/drivers/media/video/tveeprom.c
@@ -267,6 +267,21 @@ hauppauge_tuner[] =
         { TUNER_ABSENT,                 "Xceive XC4000"},
         { TUNER_ABSENT,                 "Dibcom 7070"},
         { TUNER_PHILIPS_TDA8290,        "NXP 18271C2"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        /* 160-169 */
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_ABSENT,                 "unknown"},
+        { TUNER_PHILIPS_FQ1236_MK5,     "TCL M30WTP-4N-E"},
+        { TUNER_ABSENT,                 "unknown"},
 };
 
 /* Use V4L2_IDENT_AMBIGUOUS for those audio 'chips' that are
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
index aa0720af07a0..27a79f087b15 100644
--- a/drivers/media/video/uvc/uvc_ctrl.c
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -122,8 +122,8 @@ static struct uvc_control_info uvc_ctrls[] = {
                 .selector       = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
                 .index          = 10,
                 .size           = 1,
-                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
-                                | UVC_CONTROL_RESTORE,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
         },
         {
                 .entity         = UVC_GUID_UVC_PROCESSING,
diff --git a/drivers/misc/cs5535-mfgpt.c b/drivers/misc/cs5535-mfgpt.c
index 9bec24db4d41..2d44b3300104 100644
--- a/drivers/misc/cs5535-mfgpt.c
+++ b/drivers/misc/cs5535-mfgpt.c
@@ -366,6 +366,6 @@ static int __init cs5535_mfgpt_init(void)
 
 module_init(cs5535_mfgpt_init);
 
-MODULE_AUTHOR("Andres Salomon <dilinger@collabora.co.uk>");
+MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
 MODULE_DESCRIPTION("CS5535/CS5536 MFGPT timer driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index af217924a76e..ad30f074ee15 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -365,6 +365,26 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 
 static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
 {
+        struct sdhci_host *host =  platform_get_drvdata(pdev);
+        struct sdhci_s3c *sc = sdhci_priv(host);
+        int ptr;
+
+        sdhci_remove_host(host, 1);
+
+        for (ptr = 0; ptr < 3; ptr++) {
+                clk_disable(sc->clk_bus[ptr]);
+                clk_put(sc->clk_bus[ptr]);
+        }
+        clk_disable(sc->clk_io);
+        clk_put(sc->clk_io);
+
+        iounmap(host->ioaddr);
+        release_resource(sc->ioarea);
+        kfree(sc->ioarea);
+
+        sdhci_free_host(host);
+        platform_set_drvdata(pdev, NULL);
+
         return 0;
 }
 
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index 40fdc41446cc..df483076eda6 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -340,7 +340,8 @@ static void rlb_update_entry_from_arp(struct bonding *bond, struct arp_pkt *arp)
 
         if ((client_info->assigned) &&
             (client_info->ip_src == arp->ip_dst) &&
-            (client_info->ip_dst == arp->ip_src)) {
+            (client_info->ip_dst == arp->ip_src) &&
+            (compare_ether_addr_64bits(client_info->mac_dst, arp->mac_src))) {
                 /* update the clients MAC address */
                 memcpy(client_info->mac_dst, arp->mac_src, ETH_ALEN);
                 client_info->ntt = 1;
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 5e12462a9d5e..c3d98dde2f86 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -168,7 +168,7 @@ static int arp_ip_count;
 static int bond_mode    = BOND_MODE_ROUNDROBIN;
 static int xmit_hashtype = BOND_XMIT_POLICY_LAYER2;
 static int lacp_fast;
-
+static int disable_netpoll = 1;
 
 const struct bond_parm_tbl bond_lacp_tbl[] = {
 {       "slow",         AD_LACP_SLOW},
@@ -1742,15 +1742,23 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
         bond_set_carrier(bond);
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
-        if (slaves_support_netpoll(bond_dev)) {
-                bond_dev->priv_flags &= ~IFF_DISABLE_NETPOLL;
-                if (bond_dev->npinfo)
-                        slave_dev->npinfo = bond_dev->npinfo;
-        } else if (!(bond_dev->priv_flags & IFF_DISABLE_NETPOLL)) {
+        /*
+         * Netpoll and bonding is broken, make sure it is not initialized
+         * until it is fixed.
+         */
+        if (disable_netpoll) {
                 bond_dev->priv_flags |= IFF_DISABLE_NETPOLL;
-                pr_info("New slave device %s does not support netpoll\n",
-                        slave_dev->name);
-                pr_info("Disabling netpoll support for %s\n", bond_dev->name);
+        } else {
+                if (slaves_support_netpoll(bond_dev)) {
+                        bond_dev->priv_flags &= ~IFF_DISABLE_NETPOLL;
+                        if (bond_dev->npinfo)
+                                slave_dev->npinfo = bond_dev->npinfo;
+                } else if (!(bond_dev->priv_flags & IFF_DISABLE_NETPOLL)) {
+                        bond_dev->priv_flags |= IFF_DISABLE_NETPOLL;
+                        pr_info("New slave device %s does not support netpoll\n",
+                                slave_dev->name);
+                        pr_info("Disabling netpoll support for %s\n", bond_dev->name);
+                }
         }
 #endif
         read_unlock(&bond->lock);
@@ -1950,8 +1958,11 @@ int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
         read_lock_bh(&bond->lock);
-        if (slaves_support_netpoll(bond_dev))
-                bond_dev->priv_flags &= ~IFF_DISABLE_NETPOLL;
+
+         /* Make sure netpoll over stays disabled until fixed. */
+        if (!disable_netpoll)
+                if (slaves_support_netpoll(bond_dev))
+                                bond_dev->priv_flags &= ~IFF_DISABLE_NETPOLL;
         read_unlock_bh(&bond->lock);
         if (slave_dev->netdev_ops->ndo_netpoll_cleanup)
                 slave_dev->netdev_ops->ndo_netpoll_cleanup(slave_dev);
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index 7acb3edc47ef..2602852cc55a 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -677,7 +677,7 @@ static int ibmveth_close(struct net_device *netdev)
         if (!adapter->pool_config)
                 netif_stop_queue(netdev);
 
-        free_irq(netdev->irq, netdev);
+        h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
 
         do {
                 lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
@@ -689,6 +689,8 @@ static int ibmveth_close(struct net_device *netdev)
                                      lpar_rc);
         }
 
+        free_irq(netdev->irq, netdev);
+
         adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
 
         ibmveth_cleanup(adapter);
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index ce30c62a97f7..7b5d9764f317 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -3684,10 +3684,6 @@ void ixgbe_down(struct ixgbe_adapter *adapter)
         /* signal that we are down to the interrupt handler */
         set_bit(__IXGBE_DOWN, &adapter->state);
 
-        /* power down the optics */
-        if (hw->phy.multispeed_fiber)
-                hw->mac.ops.disable_tx_laser(hw);
-
         /* disable receive for all VFs and wait one second */
         if (adapter->num_vfs) {
                 /* ping all the active vfs to let them know we are going down */
@@ -3742,6 +3738,10 @@ void ixgbe_down(struct ixgbe_adapter *adapter)
                                 (IXGBE_READ_REG(hw, IXGBE_DMATXCTL) &
                                  ~IXGBE_DMATXCTL_TE));
 
+        /* power down the optics */
+        if (hw->phy.multispeed_fiber)
+                hw->mac.ops.disable_tx_laser(hw);
+
         /* clear n-tuple filters that are cached */
         ethtool_ntuple_flush(netdev);
 
@@ -4001,7 +4001,7 @@ static void ixgbe_set_num_queues(struct ixgbe_adapter *adapter)
 
 done:
         /* Notify the stack of the (possibly) reduced Tx Queue count. */
-        adapter->netdev->real_num_tx_queues = adapter->num_tx_queues;
+        netif_set_real_num_tx_queues(adapter->netdev, adapter->num_tx_queues);
 }
 
 static void ixgbe_acquire_msix_vectors(struct ixgbe_adapter *adapter,
@@ -5195,7 +5195,6 @@ static int __ixgbe_shutdown(struct pci_dev *pdev, bool *enable_wake)
                 ixgbe_free_all_tx_resources(adapter);
                 ixgbe_free_all_rx_resources(adapter);
         }
-        ixgbe_clear_interrupt_scheme(adapter);
 
 #ifdef CONFIG_PM
         retval = pci_save_state(pdev);
@@ -5230,6 +5229,8 @@ static int __ixgbe_shutdown(struct pci_dev *pdev, bool *enable_wake)
 
         *enable_wake = !!wufc;
 
+        ixgbe_clear_interrupt_scheme(adapter);
+
         ixgbe_release_hw_control(adapter);
 
         pci_disable_device(pdev);
@@ -6023,7 +6024,6 @@ static void ixgbe_tx_queue(struct ixgbe_adapter *adapter,
 static void ixgbe_atr(struct ixgbe_adapter *adapter, struct sk_buff *skb,
                       int queue, u32 tx_flags)
 {
-        /* Right now, we support IPv4 only */
         struct ixgbe_atr_input atr_input;
         struct tcphdr *th;
         struct iphdr *iph = ip_hdr(skb);
@@ -6032,6 +6032,9 @@ static void ixgbe_atr(struct ixgbe_adapter *adapter, struct sk_buff *skb,
         u32 src_ipv4_addr, dst_ipv4_addr;
         u8 l4type = 0;
 
+        /* Right now, we support IPv4 only */
+        if (skb->protocol != htons(ETH_P_IP))
+                return;
         /* check if we're UDP or TCP */
         if (iph->protocol == IPPROTO_TCP) {
                 th = tcp_hdr(skb);
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index 52dcc8495647..6474c4973d3a 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -964,7 +964,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         np = of_parse_phandle(op->dev.of_node, "llink-connected", 0);
         if (!np) {
                 dev_err(&op->dev, "could not find DMA node\n");
-                goto nodev;
+                goto err_iounmap;
         }
 
         /* Setup the DMA register accesses, could be DCR or memory mapped */
@@ -978,7 +978,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
                         dev_dbg(&op->dev, "MEM base: %p\n", lp->sdma_regs);
                 } else {
                         dev_err(&op->dev, "unable to map DMA registers\n");
-                        goto nodev;
+                        goto err_iounmap;
                 }
         }
 
@@ -987,7 +987,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         if ((lp->rx_irq == NO_IRQ) || (lp->tx_irq == NO_IRQ)) {
                 dev_err(&op->dev, "could not determine irqs\n");
                 rc = -ENOMEM;
-                goto nodev;
+                goto err_iounmap_2;
         }
 
         of_node_put(np); /* Finished with the DMA node; drop the reference */
@@ -997,7 +997,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         if ((!addr) || (size != 6)) {
                 dev_err(&op->dev, "could not find MAC address\n");
                 rc = -ENODEV;
-                goto nodev;
+                goto err_iounmap_2;
         }
         temac_set_mac_address(ndev, (void *)addr);
 
@@ -1013,7 +1013,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         rc = sysfs_create_group(&lp->dev->kobj, &temac_attr_group);
         if (rc) {
                 dev_err(lp->dev, "Error creating sysfs files\n");
-                goto nodev;
+                goto err_iounmap_2;
         }
 
         rc = register_netdev(lp->ndev);
@@ -1026,6 +1026,11 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
 
  err_register_ndev:
         sysfs_remove_group(&lp->dev->kobj, &temac_attr_group);
+ err_iounmap_2:
+        if (lp->sdma_regs)
+                iounmap(lp->sdma_regs);
+ err_iounmap:
+        iounmap(lp->regs);
  nodev:
         free_netdev(ndev);
         ndev = NULL;
@@ -1044,6 +1049,9 @@ static int __devexit temac_of_remove(struct of_device *op)
                 of_node_put(lp->phy_node);
         lp->phy_node = NULL;
         dev_set_drvdata(&op->dev, NULL);
+        iounmap(lp->regs);
+        if (lp->sdma_regs)
+                iounmap(lp->sdma_regs);
         free_netdev(ndev);
         return 0;
 }
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index e345ec8cb473..73bb8ea6f54a 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -289,6 +289,7 @@ struct mv643xx_eth_shared_private {
         unsigned int t_clk;
         int extended_rx_coal_limit;
         int tx_bw_control;
+        int tx_csum_limit;
 };
 
 #define TX_BW_CONTROL_ABSENT            0
@@ -776,13 +777,16 @@ static int txq_submit_skb(struct tx_queue *txq, struct sk_buff *skb)
         l4i_chk = 0;
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
+                int hdr_len;
                 int tag_bytes;
 
                 BUG_ON(skb->protocol != htons(ETH_P_IP) &&
                        skb->protocol != htons(ETH_P_8021Q));
 
-                tag_bytes = (void *)ip_hdr(skb) - (void *)skb->data - ETH_HLEN;
-                if (unlikely(tag_bytes & ~12)) {
+                hdr_len = (void *)ip_hdr(skb) - (void *)skb->data;
+                tag_bytes = hdr_len - ETH_HLEN;
+                if (skb->len - hdr_len > mp->shared->tx_csum_limit ||
+                    unlikely(tag_bytes & ~12)) {
                         if (skb_checksum_help(skb) == 0)
                                 goto no_csum;
                         kfree_skb(skb);
@@ -2666,6 +2670,7 @@ static int mv643xx_eth_shared_probe(struct platform_device *pdev)
          * Detect hardware parameters.
          */
         msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
+        msp->tx_csum_limit = pd->tx_csum_limit ? pd->tx_csum_limit : 9 * 1024;
         infer_hw_params(msp);
 
         platform_set_drvdata(pdev, msp);
diff --git a/drivers/net/ne.c b/drivers/net/ne.c
index b8e2923a1d69..1063093b3afc 100644
--- a/drivers/net/ne.c
+++ b/drivers/net/ne.c
@@ -806,8 +806,10 @@ static int __init ne_drv_probe(struct platform_device *pdev)
                 dev->base_addr = res->start;
                 dev->irq = platform_get_irq(pdev, 0);
         } else {
-                if (this_dev < 0 || this_dev >= MAX_NE_CARDS)
+                if (this_dev < 0 || this_dev >= MAX_NE_CARDS) {
+                        free_netdev(dev);
                         return -EINVAL;
+                }
                 dev->base_addr = io[this_dev];
                 dev->irq = irq[this_dev];
                 dev->mem_end = bad[this_dev];
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index 5b3dfb4ab279..33525bf2a3d3 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -1168,6 +1168,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
         int interrupts, nr_serviced = 0, i;
         struct ei_device *ei_local;
         int handled = 0;
+        unsigned long flags;
 
         e8390_base = dev->base_addr;
         ei_local = netdev_priv(dev);
@@ -1176,7 +1177,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
          *      Protect the irq test too.
          */
          
-        spin_lock(&ei_local->page_lock);
+        spin_lock_irqsave(&ei_local->page_lock, flags);
 
         if (ei_local->irqlock) 
         {
@@ -1188,7 +1189,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
                            dev->name, inb_p(e8390_base + EN0_ISR),
                            inb_p(e8390_base + EN0_IMR));
 #endif
-                spin_unlock(&ei_local->page_lock);
+                spin_unlock_irqrestore(&ei_local->page_lock, flags);
                 return IRQ_NONE;
         }
     
@@ -1261,7 +1262,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
         ei_local->irqlock = 0;
         outb_p(ENISR_ALL, e8390_base + EN0_IMR);
 
-        spin_unlock(&ei_local->page_lock);
+        spin_unlock_irqrestore(&ei_local->page_lock, flags);
         return IRQ_RETVAL(handled);
 }
 
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index fa4b24c49f42..d10bcefc0e45 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -4611,8 +4611,7 @@ static void ql_timer(unsigned long data)
                 return;
         }
 
-        qdev->timer.expires = jiffies + (5*HZ);
-        add_timer(&qdev->timer);
+        mod_timer(&qdev->timer, jiffies + (5*HZ));
 }
 
 static int __devinit qlge_probe(struct pci_dev *pdev,
@@ -4713,6 +4712,8 @@ static void ql_eeh_close(struct net_device *ndev)
                 netif_stop_queue(ndev);
         }
 
+        /* Disabling the timer */
+        del_timer_sync(&qdev->timer);
         if (test_bit(QL_ADAPTER_UP, &qdev->flags))
                 cancel_delayed_work_sync(&qdev->asic_reset_work);
         cancel_delayed_work_sync(&qdev->mpi_reset_work);
@@ -4808,8 +4809,7 @@ static void qlge_io_resume(struct pci_dev *pdev)
                 netif_err(qdev, ifup, qdev->ndev,
                           "Device was not running prior to EEH.\n");
         }
-        qdev->timer.expires = jiffies + (5*HZ);
-        add_timer(&qdev->timer);
+        mod_timer(&qdev->timer, jiffies + (5*HZ));
         netif_device_attach(ndev);
 }
 
@@ -4871,8 +4871,7 @@ static int qlge_resume(struct pci_dev *pdev)
                         return err;
         }
 
-        qdev->timer.expires = jiffies + (5*HZ);
-        add_timer(&qdev->timer);
+        mod_timer(&qdev->timer, jiffies + (5*HZ));
         netif_device_attach(ndev);
 
         return 0;
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 96b6cfbf0a3a..cdc6a5c2e70d 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -1316,7 +1316,7 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
                 { 0x7c800000, 0x28000000,       RTL_GIGA_MAC_VER_26 },
 
                 /* 8168C family. */
-                { 0x7cf00000, 0x3ca00000,       RTL_GIGA_MAC_VER_24 },
+                { 0x7cf00000, 0x3cb00000,       RTL_GIGA_MAC_VER_24 },
                 { 0x7cf00000, 0x3c900000,       RTL_GIGA_MAC_VER_23 },
                 { 0x7cf00000, 0x3c800000,       RTL_GIGA_MAC_VER_18 },
                 { 0x7c800000, 0x3c800000,       RTL_GIGA_MAC_VER_24 },
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 668327ccd8d0..1d37f0c310ca 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -3130,7 +3130,6 @@ static void tx_intr_handler(struct fifo_info *fifo_data)
                 pkt_cnt++;
 
                 /* Updating the statistics block */
-                nic->dev->stats.tx_bytes += skb->len;
                 swstats->mem_freed += skb->truesize;
                 dev_kfree_skb_irq(skb);
 
@@ -4901,48 +4900,81 @@ static void s2io_updt_stats(struct s2io_nic *sp)
  *  Return value:
  *  pointer to the updated net_device_stats structure.
  */
-
 static struct net_device_stats *s2io_get_stats(struct net_device *dev)
 {
         struct s2io_nic *sp = netdev_priv(dev);
-        struct config_param *config = &sp->config;
         struct mac_info *mac_control = &sp->mac_control;
         struct stat_block *stats = mac_control->stats_info;
-        int i;
+        u64 delta;
 
         /* Configure Stats for immediate updt */
         s2io_updt_stats(sp);
 
-        /* Using sp->stats as a staging area, because reset (due to mtu
-           change, for example) will clear some hardware counters */
-        dev->stats.tx_packets += le32_to_cpu(stats->tmac_frms) -
-                sp->stats.tx_packets;
-        sp->stats.tx_packets = le32_to_cpu(stats->tmac_frms);
-
-        dev->stats.tx_errors += le32_to_cpu(stats->tmac_any_err_frms) -
-                sp->stats.tx_errors;
-        sp->stats.tx_errors = le32_to_cpu(stats->tmac_any_err_frms);
-
-        dev->stats.rx_errors += le64_to_cpu(stats->rmac_drop_frms) -
-                sp->stats.rx_errors;
-        sp->stats.rx_errors = le64_to_cpu(stats->rmac_drop_frms);
-
-        dev->stats.multicast = le32_to_cpu(stats->rmac_vld_mcst_frms) -
-                sp->stats.multicast;
-        sp->stats.multicast = le32_to_cpu(stats->rmac_vld_mcst_frms);
-
-        dev->stats.rx_length_errors = le64_to_cpu(stats->rmac_long_frms) -
-                sp->stats.rx_length_errors;
-        sp->stats.rx_length_errors = le64_to_cpu(stats->rmac_long_frms);
+        /* A device reset will cause the on-adapter statistics to be zero'ed.
+         * This can be done while running by changing the MTU.  To prevent the
+         * system from having the stats zero'ed, the driver keeps a copy of the
+         * last update to the system (which is also zero'ed on reset).  This
+         * enables the driver to accurately know the delta between the last
+         * update and the current update.
+         */
+        delta = ((u64) le32_to_cpu(stats->rmac_vld_frms_oflow) << 32 |
+                le32_to_cpu(stats->rmac_vld_frms)) - sp->stats.rx_packets;
+        sp->stats.rx_packets += delta;
+        dev->stats.rx_packets += delta;
+
+        delta = ((u64) le32_to_cpu(stats->tmac_frms_oflow) << 32 |
+                le32_to_cpu(stats->tmac_frms)) - sp->stats.tx_packets;
+        sp->stats.tx_packets += delta;
+        dev->stats.tx_packets += delta;
+
+        delta = ((u64) le32_to_cpu(stats->rmac_data_octets_oflow) << 32 |
+                le32_to_cpu(stats->rmac_data_octets)) - sp->stats.rx_bytes;
+        sp->stats.rx_bytes += delta;
+        dev->stats.rx_bytes += delta;
+
+        delta = ((u64) le32_to_cpu(stats->tmac_data_octets_oflow) << 32 |
+                le32_to_cpu(stats->tmac_data_octets)) - sp->stats.tx_bytes;
+        sp->stats.tx_bytes += delta;
+        dev->stats.tx_bytes += delta;
+
+        delta = le64_to_cpu(stats->rmac_drop_frms) - sp->stats.rx_errors;
+        sp->stats.rx_errors += delta;
+        dev->stats.rx_errors += delta;
+
+        delta = ((u64) le32_to_cpu(stats->tmac_any_err_frms_oflow) << 32 |
+                le32_to_cpu(stats->tmac_any_err_frms)) - sp->stats.tx_errors;
+        sp->stats.tx_errors += delta;
+        dev->stats.tx_errors += delta;
+
+        delta = le64_to_cpu(stats->rmac_drop_frms) - sp->stats.rx_dropped;
+        sp->stats.rx_dropped += delta;
+        dev->stats.rx_dropped += delta;
+
+        delta = le64_to_cpu(stats->tmac_drop_frms) - sp->stats.tx_dropped;
+        sp->stats.tx_dropped += delta;
+        dev->stats.tx_dropped += delta;
+
+        /* The adapter MAC interprets pause frames as multicast packets, but
+         * does not pass them up.  This erroneously increases the multicast
+         * packet count and needs to be deducted when the multicast frame count
+         * is queried.
+         */
+        delta = (u64) le32_to_cpu(stats->rmac_vld_mcst_frms_oflow) << 32 |
+                le32_to_cpu(stats->rmac_vld_mcst_frms);
+        delta -= le64_to_cpu(stats->rmac_pause_ctrl_frms);
+        delta -= sp->stats.multicast;
+        sp->stats.multicast += delta;
+        dev->stats.multicast += delta;
 
-        /* collect per-ring rx_packets and rx_bytes */
-        dev->stats.rx_packets = dev->stats.rx_bytes = 0;
-        for (i = 0; i < config->rx_ring_num; i++) {
-                struct ring_info *ring = &mac_control->rings[i];
+        delta = ((u64) le32_to_cpu(stats->rmac_usized_frms_oflow) << 32 |
+                le32_to_cpu(stats->rmac_usized_frms)) +
+                le64_to_cpu(stats->rmac_long_frms) - sp->stats.rx_length_errors;
+        sp->stats.rx_length_errors += delta;
+        dev->stats.rx_length_errors += delta;
 
-                dev->stats.rx_packets += ring->rx_packets;
-                dev->stats.rx_bytes += ring->rx_bytes;
-        }
+        delta = le64_to_cpu(stats->rmac_fcs_err_frms) - sp->stats.rx_crc_errors;
+        sp->stats.rx_crc_errors += delta;
+        dev->stats.rx_crc_errors += delta;
 
         return &dev->stats;
 }
@@ -7455,15 +7487,11 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
                 }
         }
 
-        /* Updating statistics */
-        ring_data->rx_packets++;
         rxdp->Host_Control = 0;
         if (sp->rxd_mode == RXD_MODE_1) {
                 int len = RXD_GET_BUFFER0_SIZE_1(rxdp->Control_2);
 
-                ring_data->rx_bytes += len;
                 skb_put(skb, len);
-
         } else if (sp->rxd_mode == RXD_MODE_3B) {
                 int get_block = ring_data->rx_curr_get_info.block_index;
                 int get_off = ring_data->rx_curr_get_info.offset;
@@ -7472,7 +7500,6 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
                 unsigned char *buff = skb_push(skb, buf0_len);
 
                 struct buffAdd *ba = &ring_data->ba[get_block][get_off];
-                ring_data->rx_bytes += buf0_len + buf2_len;
                 memcpy(buff, ba->ba_0, buf0_len);
                 skb_put(skb, buf2_len);
         }
diff --git a/drivers/net/s2io.h b/drivers/net/s2io.h
index 47c36e0994f5..5e52c75892df 100644
--- a/drivers/net/s2io.h
+++ b/drivers/net/s2io.h
@@ -745,10 +745,6 @@ struct ring_info {
 
         /* Buffer Address store. */
         struct buffAdd **ba;
-
-        /* per-Ring statistics */
-        unsigned long rx_packets;
-        unsigned long rx_bytes;
 } ____cacheline_aligned;
 
 /* Fifo specific structure */
diff --git a/drivers/net/sb1250-mac.c b/drivers/net/sb1250-mac.c
index 1f3acc3a5dfd..79eee3062083 100644
--- a/drivers/net/sb1250-mac.c
+++ b/drivers/net/sb1250-mac.c
@@ -2671,6 +2671,7 @@ static struct platform_driver sbmac_driver = {
         .remove = __exit_p(sbmac_remove),
         .driver = {
                 .name = sbmac_string,
+                .owner  = THIS_MODULE,
         },
 };
 
diff --git a/drivers/net/usb/rndis_host.c b/drivers/net/usb/rndis_host.c
index 28d3ee175e7b..dd8a4adf48ca 100644
--- a/drivers/net/usb/rndis_host.c
+++ b/drivers/net/usb/rndis_host.c
@@ -104,10 +104,8 @@ static void rndis_msg_indicate(struct usbnet *dev, struct rndis_indicate *msg,
 int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
 {
         struct cdc_state        *info = (void *) &dev->data;
-        struct usb_cdc_notification notification;
         int                     master_ifnum;
         int                     retval;
-        int                     partial;
         unsigned                count;
         __le32                  rsp;
         u32                     xid = 0, msg_len, request_id;
@@ -135,17 +133,13 @@ int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
         if (unlikely(retval < 0 || xid == 0))
                 return retval;
 
-        /* Some devices don't respond on the control channel until
-         * polled on the status channel, so do that first. */
-        retval = usb_interrupt_msg(
-                dev->udev,
-                usb_rcvintpipe(dev->udev, dev->status->desc.bEndpointAddress),
-                &notification, sizeof(notification), &partial,
-                RNDIS_CONTROL_TIMEOUT_MS);
-        if (unlikely(retval < 0))
-                return retval;
+        // FIXME Seems like some devices discard responses when
+        // we time out and cancel our "get response" requests...
+        // so, this is fragile.  Probably need to poll for status.
 
-        /* Poll the control channel; the request probably completed immediately */
+        /* ignore status endpoint, just poll the control channel;
+         * the request probably completed immediately
+         */
         rsp = buf->msg_type | RNDIS_MSG_COMPLETION;
         for (count = 0; count < 10; count++) {
                 memset(buf, 0, CONTROL_BUFFER_SIZE);
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index a95c73de5824..81c76ada8e56 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -1293,6 +1293,9 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
                 goto out;
         }
 
+        /* netdev_printk() needs this so do it as early as possible */
+        SET_NETDEV_DEV(net, &udev->dev);
+
         dev = netdev_priv(net);
         dev->udev = xdev;
         dev->intf = udev;
@@ -1377,8 +1380,6 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
                 dev->rx_urb_size = dev->hard_mtu;
         dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
 
-        SET_NETDEV_DEV(net, &udev->dev);
-
         if ((dev->driver_info->flags & FLAG_WLAN) != 0)
                 SET_NETDEV_DEVTYPE(net, &wlan_type);
         if ((dev->driver_info->flags & FLAG_WWAN) != 0)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 1edb7a61983c..bb6b67f6b0cc 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -415,7 +415,7 @@ static int add_recvbuf_mergeable(struct virtnet_info *vi, gfp_t gfp)
 static bool try_fill_recv(struct virtnet_info *vi, gfp_t gfp)
 {
         int err;
-        bool oom = false;
+        bool oom;
 
         do {
                 if (vi->mergeable_rx_bufs)
@@ -425,10 +425,9 @@ static bool try_fill_recv(struct virtnet_info *vi, gfp_t gfp)
                 else
                         err = add_recvbuf_small(vi, gfp);
 
-                if (err < 0) {
-                        oom = true;
+                oom = err == -ENOMEM;
+                if (err < 0)
                         break;
-                }
                 ++vi->num;
         } while (err > 0);
         if (unlikely(vi->num > vi->max))
@@ -563,7 +562,6 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct virtnet_info *vi = netdev_priv(dev);
         int capacity;
 
-again:
         /* Free up any pending old buffers before queueing new ones. */
         free_old_xmit_skbs(vi);
 
@@ -572,14 +570,20 @@ again:
 
         /* This can happen with OOM and indirect buffers. */
         if (unlikely(capacity < 0)) {
-                netif_stop_queue(dev);
-                dev_warn(&dev->dev, "Unexpected full queue\n");
-                if (unlikely(!virtqueue_enable_cb(vi->svq))) {
-                        virtqueue_disable_cb(vi->svq);
-                        netif_start_queue(dev);
-                        goto again;
+                if (net_ratelimit()) {
+                        if (likely(capacity == -ENOMEM)) {
+                                dev_warn(&dev->dev,
+                                         "TX queue failure: out of memory\n");
+                        } else {
+                                dev->stats.tx_fifo_errors++;
+                                dev_warn(&dev->dev,
+                                         "Unexpected TX queue failure: %d\n",
+                                         capacity);
+                        }
                 }
-                return NETDEV_TX_BUSY;
+                dev->stats.tx_dropped++;
+                kfree_skb(skb);
+                return NETDEV_TX_OK;
         }
         virtqueue_kick(vi->svq);
 
diff --git a/drivers/net/vxge/vxge-main.c b/drivers/net/vxge/vxge-main.c
index d14e207de1df..fc8b2d7a0919 100644
--- a/drivers/net/vxge/vxge-main.c
+++ b/drivers/net/vxge/vxge-main.c
@@ -4517,9 +4517,9 @@ vxge_starter(void)
         char version[32];
         snprintf(version, 32, "%s", DRV_VERSION);
 
-        printk(KERN_CRIT "%s: Copyright(c) 2002-2009 Neterion Inc\n",
+        printk(KERN_INFO "%s: Copyright(c) 2002-2009 Neterion Inc\n",
                 VXGE_DRIVER_NAME);
-        printk(KERN_CRIT "%s: Driver version: %s\n",
+        printk(KERN_INFO "%s: Driver version: %s\n",
                         VXGE_DRIVER_NAME, version);
 
         verify_bandwidth();
diff --git a/drivers/net/wireless/ath/ath9k/ath9k.h b/drivers/net/wireless/ath/ath9k/ath9k.h
index fbb7dec6ddeb..5ea87736a6ae 100644
--- a/drivers/net/wireless/ath/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath/ath9k/ath9k.h
@@ -445,6 +445,7 @@ void ath_deinit_leds(struct ath_softc *sc);
 #define SC_OP_TSF_RESET              BIT(11)
 #define SC_OP_BT_PRIORITY_DETECTED   BIT(12)
 #define SC_OP_BT_SCAN                BIT(13)
+#define SC_OP_ANI_RUN                BIT(14)
 
 /* Powersave flags */
 #define PS_WAIT_FOR_BEACON        BIT(0)
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c
index 77b359162d6c..23c15aa9fbd5 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.c
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.c
@@ -730,13 +730,17 @@ static int ath9k_hif_usb_alloc_urbs(struct hif_device_usb *hif_dev)
 
         /* RX */
         if (ath9k_hif_usb_alloc_rx_urbs(hif_dev) < 0)
-                goto err;
+                goto err_rx;
 
         /* Register Read */
         if (ath9k_hif_usb_alloc_reg_in_urb(hif_dev) < 0)
-                goto err;
+                goto err_reg;
 
         return 0;
+err_reg:
+        ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
+err_rx:
+        ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
 err:
         return -ENOMEM;
 }
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index abfa0493236f..1e2a68ea9355 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -336,6 +336,10 @@ set_timer:
 static void ath_start_ani(struct ath_common *common)
 {
         unsigned long timestamp = jiffies_to_msecs(jiffies);
+        struct ath_softc *sc = (struct ath_softc *) common->priv;
+
+        if (!(sc->sc_flags & SC_OP_ANI_RUN))
+                return;
 
         common->ani.longcal_timer = timestamp;
         common->ani.shortcal_timer = timestamp;
@@ -872,11 +876,13 @@ static void ath9k_bss_assoc_info(struct ath_softc *sc,
                 /* Reset rssi stats */
                 sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
 
+                sc->sc_flags |= SC_OP_ANI_RUN;
                 ath_start_ani(common);
         } else {
                 ath_print(common, ATH_DBG_CONFIG, "Bss Info DISASSOC\n");
                 common->curaid = 0;
                 /* Stop ANI */
+                sc->sc_flags &= ~SC_OP_ANI_RUN;
                 del_timer_sync(&common->ani.timer);
         }
 }
@@ -1478,8 +1484,10 @@ static int ath9k_add_interface(struct ieee80211_hw *hw,
 
         if (vif->type == NL80211_IFTYPE_AP    ||
             vif->type == NL80211_IFTYPE_ADHOC ||
-            vif->type == NL80211_IFTYPE_MONITOR)
+            vif->type == NL80211_IFTYPE_MONITOR) {
+                sc->sc_flags |= SC_OP_ANI_RUN;
                 ath_start_ani(common);
+        }
 
 out:
         mutex_unlock(&sc->mutex);
@@ -1500,6 +1508,7 @@ static void ath9k_remove_interface(struct ieee80211_hw *hw,
         mutex_lock(&sc->mutex);
 
         /* Stop ANI */
+        sc->sc_flags &= ~SC_OP_ANI_RUN;
         del_timer_sync(&common->ani.timer);
 
         /* Reclaim beacon resources */
diff --git a/drivers/net/wireless/hostap/hostap_pci.c b/drivers/net/wireless/hostap/hostap_pci.c
index d24dc7dc0723..972a9c3af39e 100644
--- a/drivers/net/wireless/hostap/hostap_pci.c
+++ b/drivers/net/wireless/hostap/hostap_pci.c
@@ -330,6 +330,7 @@ static int prism2_pci_probe(struct pci_dev *pdev,
 
         dev->irq = pdev->irq;
         hw_priv->mem_start = mem;
+        dev->base_addr = (unsigned long) mem;
 
         prism2_pci_cor_sreset(local);
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c b/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c
index 44ef5d93befc..01658cf82d39 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c
@@ -212,11 +212,7 @@ static void iwlagn_chain_noise_reset(struct iwl_priv *priv)
 static void iwlagn_rts_tx_cmd_flag(struct ieee80211_tx_info *info,
                         __le32 *tx_flags)
 {
-        if ((info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
-            (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
-                *tx_flags |= TX_CMD_FLG_RTS_CTS_MSK;
-        else
-                *tx_flags &= ~TX_CMD_FLG_RTS_CTS_MSK;
+        *tx_flags |= TX_CMD_FLG_RTS_CTS_MSK;
 }
 
 /* Calc max signal level (dBm) among 3 possible receivers */
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index 426e95567de3..5bbc5298ef96 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -1314,7 +1314,6 @@ void iwl_configure_filter(struct ieee80211_hw *hw,
                         changed_flags, *total_flags);
 
         CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
-        CHK(FIF_ALLMULTI, RXON_FILTER_ACCEPT_GRP_MSK);
         CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK);
         CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
 
@@ -1329,6 +1328,12 @@ void iwl_configure_filter(struct ieee80211_hw *hw,
 
         mutex_unlock(&priv->mutex);
 
+        /*
+         * Receiving all multicast frames is always enabled by the
+         * default flags setup in iwl_connection_init_rx_config()
+         * since we currently do not support programming multicast
+         * filters into the device.
+         */
         *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
                         FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
 }
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.h b/drivers/net/wireless/iwlwifi/iwl-sta.h
index c2a453a1a991..dc43ebd1f1fd 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.h
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.h
@@ -97,6 +97,17 @@ static inline void iwl_clear_driver_stations(struct iwl_priv *priv)
         spin_lock_irqsave(&priv->sta_lock, flags);
         memset(priv->stations, 0, sizeof(priv->stations));
         priv->num_stations = 0;
+
+        /*
+         * Remove all key information that is not stored as part of station
+         * information since mac80211 may not have had a
+         * chance to remove all the keys. When device is reconfigured by
+         * mac80211 after an error all keys will be reconfigured.
+         */
+        priv->ucode_key_table = 0;
+        priv->key_mapping_key = 0;
+        memset(priv->wep_keys, 0, sizeof(priv->wep_keys));
+
         spin_unlock_irqrestore(&priv->sta_lock, flags);
 }
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index 3ae468c4d760..f20d3eeeea7f 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -854,6 +854,11 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
                     BIT(NL80211_IFTYPE_WDS);
 
         /*
+         * Initialize configuration work.
+         */
+        INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
+
+        /*
          * Let the driver probe the device to detect the capabilities.
          */
         retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
@@ -863,11 +868,6 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
         }
 
         /*
-         * Initialize configuration work.
-         */
-        INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
-
-        /*
          * Allocate queue array.
          */
         retval = rt2x00queue_allocate(rt2x00dev);
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 92379e2d37e7..2aaa13150de3 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -156,6 +156,38 @@ static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
                                              pcibios_align_resource, dev);
         }
 
+        if (ret < 0 && dev->fw_addr[resno]) {
+                struct resource *root, *conflict;
+                resource_size_t start, end;
+
+                /*
+                 * If we failed to assign anything, let's try the address
+                 * where firmware left it.  That at least has a chance of
+                 * working, which is better than just leaving it disabled.
+                 */
+
+                if (res->flags & IORESOURCE_IO)
+                        root = &ioport_resource;
+                else
+                        root = &iomem_resource;
+
+                start = res->start;
+                end = res->end;
+                res->start = dev->fw_addr[resno];
+                res->end = res->start + size - 1;
+                dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
+                         resno, res);
+                conflict = request_resource_conflict(root, res);
+                if (conflict) {
+                        dev_info(&dev->dev,
+                                 "BAR %d: %pR conflicts with %s %pR\n", resno,
+                                 res, conflict->name, conflict);
+                        res->start = start;
+                        res->end = end;
+                } else
+                        ret = 0;
+        }
+
         if (!ret) {
                 res->flags &= ~IORESOURCE_STARTALIGN;
                 dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index 9fc339845538..eac961463be2 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -1356,6 +1356,7 @@ static int __devinit pcmcia_bus_add_socket(struct device *dev,
         INIT_LIST_HEAD(&socket->devices_list);
         memset(&socket->pcmcia_state, 0, sizeof(u8));
         socket->device_count = 0;
+        atomic_set(&socket->present, 0);
 
         ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
         if (ret) {
@@ -1364,8 +1365,6 @@ static int __devinit pcmcia_bus_add_socket(struct device *dev,
                 return ret;
         }
 
-        atomic_set(&socket->present, 0);
-
         return 0;
 }
 
diff --git a/drivers/pcmcia/pcmcia_resource.c b/drivers/pcmcia/pcmcia_resource.c
index 29f91fac1dff..a4cd9adfcbc0 100644
--- a/drivers/pcmcia/pcmcia_resource.c
+++ b/drivers/pcmcia/pcmcia_resource.c
@@ -857,8 +857,10 @@ void pcmcia_disable_device(struct pcmcia_device *p_dev)
 {
         pcmcia_release_configuration(p_dev);
         pcmcia_release_io(p_dev, &p_dev->io);
-        if (p_dev->_irq)
+        if (p_dev->_irq) {
                 free_irq(p_dev->irq, p_dev->priv);
+                p_dev->_irq = 0;
+        }
         if (p_dev->win)
                 pcmcia_release_window(p_dev, p_dev->win);
 }
diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c
index 40658e3385b4..bb2f1fba637b 100644
--- a/drivers/platform/x86/intel_scu_ipc.c
+++ b/drivers/platform/x86/intel_scu_ipc.c
@@ -489,7 +489,7 @@ int intel_scu_ipc_simple_command(int cmd, int sub)
                 mutex_unlock(&ipclock);
                 return -ENODEV;
         }
-        ipc_command(cmd << 12 | sub);
+        ipc_command(sub << 12 | cmd);
         err = busy_loop();
         mutex_unlock(&ipclock);
         return err;
@@ -501,9 +501,9 @@ EXPORT_SYMBOL(intel_scu_ipc_simple_command);
  *      @cmd: command
  *      @sub: sub type
  *      @in: input data
- *      @inlen: input length
+ *      @inlen: input length in dwords
  *      @out: output data
- *      @outlein: output length
+ *      @outlein: output length in dwords
  *
  *      Issue a command to the SCU which involves data transfers. Do the
  *      data copies under the lock but leave it for the caller to interpret
@@ -524,7 +524,7 @@ int intel_scu_ipc_command(int cmd, int sub, u32 *in, int inlen,
         for (i = 0; i < inlen; i++)
                 ipc_data_writel(*in++, 4 * i);
 
-        ipc_command((cmd << 12) | sub | (inlen << 18));
+        ipc_command((sub << 12) | cmd | (inlen << 18));
         err = busy_loop();
 
         for (i = 0; i < outlen; i++)
@@ -556,6 +556,10 @@ int intel_scu_ipc_i2c_cntrl(u32 addr, u32 *data)
         u32 cmd = 0;
 
         mutex_lock(&ipclock);
+        if (ipcdev.pdev == NULL) {
+                mutex_unlock(&ipclock);
+                return -ENODEV;
+        }
         cmd = (addr >> 24) & 0xFF;
         if (cmd == IPC_I2C_READ) {
                 writel(addr, ipcdev.i2c_base + IPC_I2C_CNTRL_ADDR);
diff --git a/drivers/power/ds2782_battery.c b/drivers/power/ds2782_battery.c
index d762a0cbc6af..2afbeec8b791 100644
--- a/drivers/power/ds2782_battery.c
+++ b/drivers/power/ds2782_battery.c
@@ -163,7 +163,7 @@ static int ds2782_get_capacity(struct ds278x_info *info, int *capacity)
         if (err)
                 return err;
         *capacity = raw;
-        return raw;
+        return 0;
 }
 
 static int ds2786_get_current(struct ds278x_info *info, int *current_uA)
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 34d51dd4c539..bed7b4634ccd 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -948,8 +948,10 @@ static ssize_t dasd_alias_show(struct device *dev,
         if (device->discipline && device->discipline->get_uid &&
             !device->discipline->get_uid(device, &uid)) {
                 if (uid.type == UA_BASE_PAV_ALIAS ||
-                    uid.type == UA_HYPER_PAV_ALIAS)
+                    uid.type == UA_HYPER_PAV_ALIAS) {
+                        dasd_put_device(device);
                         return sprintf(buf, "1\n");
+                }
         }
         dasd_put_device(device);
 
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index ce7cb87479fe..407d0e9adfaf 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -713,7 +713,7 @@ int chsc_determine_base_channel_path_desc(struct chp_id chpid,
         ret = chsc_determine_channel_path_desc(chpid, 0, 0, 0, 0, chsc_resp);
         if (ret)
                 goto out_free;
-        memcpy(desc, &chsc_resp->data, chsc_resp->length);
+        memcpy(desc, &chsc_resp->data, sizeof(*desc));
 out_free:
         kfree(chsc_resp);
         return ret;
diff --git a/drivers/sbus/char/openprom.c b/drivers/sbus/char/openprom.c
index d53e62ab09da..aacbe14e2e7a 100644
--- a/drivers/sbus/char/openprom.c
+++ b/drivers/sbus/char/openprom.c
@@ -554,7 +554,7 @@ static int opiocgetnext(unsigned int cmd, void __user *argp)
 static int openprom_bsd_ioctl(struct file * file,
                               unsigned int cmd, unsigned long arg)
 {
-        DATA *data = (DATA *) file->private_data;
+        DATA *data = file->private_data;
         void __user *argp = (void __user *)arg;
         int err;
 
@@ -601,7 +601,7 @@ static int openprom_bsd_ioctl(struct file * file,
 static long openprom_ioctl(struct file * file,
                            unsigned int cmd, unsigned long arg)
 {
-        DATA *data = (DATA *) file->private_data;
+        DATA *data = file->private_data;
 
         switch (cmd) {
         case OPROMGETOPT:
diff --git a/drivers/serial/suncore.c b/drivers/serial/suncore.c
index ed7d958b0a01..544f2e25d0e5 100644
--- a/drivers/serial/suncore.c
+++ b/drivers/serial/suncore.c
@@ -71,7 +71,9 @@ int sunserial_console_match(struct console *con, struct device_node *dp,
 
         con->index = line;
         drv->cons = con;
-        add_preferred_console(con->name, line, NULL);
+
+        if (!console_set_on_cmdline)
+                add_preferred_console(con->name, line, NULL);
 
         return 1;
 }
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 234459c2f012..ffbf4553f665 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -1500,20 +1500,25 @@ out_unmap:
 static int __devexit su_remove(struct of_device *op)
 {
         struct uart_sunsu_port *up = dev_get_drvdata(&op->dev);
+        bool kbdms = false;
 
         if (up->su_type == SU_PORT_MS ||
-            up->su_type == SU_PORT_KBD) {
+            up->su_type == SU_PORT_KBD)
+                kbdms = true;
+
+        if (kbdms) {
 #ifdef CONFIG_SERIO
                 serio_unregister_port(&up->serio);
 #endif
-                kfree(up);
-        } else if (up->port.type != PORT_UNKNOWN) {
+        } else if (up->port.type != PORT_UNKNOWN)
                 uart_remove_one_port(&sunsu_reg, &up->port);
-        }
 
         if (up->port.membase)
                 of_iounmap(&op->resource[0], up->port.membase, up->reg_size);
 
+        if (kbdms)
+                kfree(up);
+
         dev_set_drvdata(&op->dev, NULL);
 
         return 0;
diff --git a/drivers/spi/spi_mpc8xxx.c b/drivers/spi/spi_mpc8xxx.c
index ffa111a7e9d4..97ab0a81338a 100644
--- a/drivers/spi/spi_mpc8xxx.c
+++ b/drivers/spi/spi_mpc8xxx.c
@@ -66,28 +66,6 @@ struct mpc8xxx_spi_reg {
         __be32 receive;
 };
 
-/* SPI Parameter RAM */
-struct spi_pram {
-        __be16  rbase;  /* Rx Buffer descriptor base address */
-        __be16  tbase;  /* Tx Buffer descriptor base address */
-        u8      rfcr;   /* Rx function code */
-        u8      tfcr;   /* Tx function code */
-        __be16  mrblr;  /* Max receive buffer length */
-        __be32  rstate; /* Internal */
-        __be32  rdp;    /* Internal */
-        __be16  rbptr;  /* Internal */
-        __be16  rbc;    /* Internal */
-        __be32  rxtmp;  /* Internal */
-        __be32  tstate; /* Internal */
-        __be32  tdp;    /* Internal */
-        __be16  tbptr;  /* Internal */
-        __be16  tbc;    /* Internal */
-        __be32  txtmp;  /* Internal */
-        __be32  res;    /* Tx temp. */
-        __be16  rpbase; /* Relocation pointer (CPM1 only) */
-        __be16  res1;   /* Reserved */
-};
-
 /* SPI Controller mode register definitions */
 #define SPMODE_LOOP             (1 << 30)
 #define SPMODE_CI_INACTIVEHIGH  (1 << 29)
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index d69eccf5f197..2aaa0f75c6cf 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -136,7 +136,7 @@ struct ffs_data {
          * handling setup requests immidiatelly user space may be so
          * slow that another setup will be sent to the gadget but this
          * time not to us but another function and then there could be
-         * a race.  Is taht the case? Or maybe we can use cdev->req
+         * a race.  Is that the case? Or maybe we can use cdev->req
          * after all, maybe we just need some spinlock for that? */
         struct usb_request              *ep0req;                /* P: mutex */
         struct completion               ep0req_completion;      /* P: mutex */
diff --git a/drivers/usb/gadget/f_uvc.c b/drivers/usb/gadget/f_uvc.c
index fc2611f8b326..dbe6db0184fd 100644
--- a/drivers/usb/gadget/f_uvc.c
+++ b/drivers/usb/gadget/f_uvc.c
@@ -28,7 +28,7 @@
 
 #include "uvc.h"
 
-unsigned int uvc_trace_param;
+unsigned int uvc_gadget_trace_param;
 
 /* --------------------------------------------------------------------------
  * Function descriptors
@@ -656,6 +656,6 @@ error:
         return ret;
 }
 
-module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
+module_param_named(trace, uvc_gadget_trace_param, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(trace, "Trace level bitmask");
 
diff --git a/drivers/usb/gadget/uvc.h b/drivers/usb/gadget/uvc.h
index 0a705e63c936..e92454cddd7d 100644
--- a/drivers/usb/gadget/uvc.h
+++ b/drivers/usb/gadget/uvc.h
@@ -107,11 +107,11 @@ struct uvc_streaming_control {
 #define UVC_WARN_MINMAX                         0
 #define UVC_WARN_PROBE_DEF                      1
 
-extern unsigned int uvc_trace_param;
+extern unsigned int uvc_gadget_trace_param;
 
 #define uvc_trace(flag, msg...) \
         do { \
-                if (uvc_trace_param & flag) \
+                if (uvc_gadget_trace_param & flag) \
                         printk(KERN_DEBUG "uvcvideo: " msg); \
         } while (0)
 
@@ -220,16 +220,10 @@ struct uvc_file_handle
 #define to_uvc_file_handle(handle) \
         container_of(handle, struct uvc_file_handle, vfh)
 
-extern struct v4l2_file_operations uvc_v4l2_fops;
-
 /* ------------------------------------------------------------------------
  * Functions
  */
 
-extern int uvc_video_enable(struct uvc_video *video, int enable);
-extern int uvc_video_init(struct uvc_video *video);
-extern int uvc_video_pump(struct uvc_video *video);
-
 extern void uvc_endpoint_stream(struct uvc_device *dev);
 
 extern void uvc_function_connect(struct uvc_device *uvc);
diff --git a/drivers/usb/gadget/uvc_queue.c b/drivers/usb/gadget/uvc_queue.c
index 43891991bf21..f7395ac5dc17 100644
--- a/drivers/usb/gadget/uvc_queue.c
+++ b/drivers/usb/gadget/uvc_queue.c
@@ -78,7 +78,8 @@
  *
  */
 
-void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type)
+static void
+uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type)
 {
         mutex_init(&queue->mutex);
         spin_lock_init(&queue->irqlock);
@@ -88,6 +89,28 @@ void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type)
 }
 
 /*
+ * Free the video buffers.
+ *
+ * This function must be called with the queue lock held.
+ */
+static int uvc_free_buffers(struct uvc_video_queue *queue)
+{
+        unsigned int i;
+
+        for (i = 0; i < queue->count; ++i) {
+                if (queue->buffer[i].vma_use_count != 0)
+                        return -EBUSY;
+        }
+
+        if (queue->count) {
+                vfree(queue->mem);
+                queue->count = 0;
+        }
+
+        return 0;
+}
+
+/*
  * Allocate the video buffers.
  *
  * Pages are reserved to make sure they will not be swapped, as they will be
@@ -95,8 +118,9 @@ void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type)
  *
  * Buffers will be individually mapped, so they must all be page aligned.
  */
-int uvc_alloc_buffers(struct uvc_video_queue *queue, unsigned int nbuffers,
-                unsigned int buflength)
+static int
+uvc_alloc_buffers(struct uvc_video_queue *queue, unsigned int nbuffers,
+                  unsigned int buflength)
 {
         unsigned int bufsize = PAGE_ALIGN(buflength);
         unsigned int i;
@@ -150,28 +174,6 @@ done:
         return ret;
 }
 
-/*
- * Free the video buffers.
- *
- * This function must be called with the queue lock held.
- */
-int uvc_free_buffers(struct uvc_video_queue *queue)
-{
-        unsigned int i;
-
-        for (i = 0; i < queue->count; ++i) {
-                if (queue->buffer[i].vma_use_count != 0)
-                        return -EBUSY;
-        }
-
-        if (queue->count) {
-                vfree(queue->mem);
-                queue->count = 0;
-        }
-
-        return 0;
-}
-
 static void __uvc_query_buffer(struct uvc_buffer *buf,
                 struct v4l2_buffer *v4l2_buf)
 {
@@ -195,8 +197,8 @@ static void __uvc_query_buffer(struct uvc_buffer *buf,
         }
 }
 
-int uvc_query_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf)
+static int
+uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *v4l2_buf)
 {
         int ret = 0;
 
@@ -217,8 +219,8 @@ done:
  * Queue a video buffer. Attempting to queue a buffer that has already been
  * queued will return -EINVAL.
  */
-int uvc_queue_buffer(struct uvc_video_queue *queue,
-        struct v4l2_buffer *v4l2_buf)
+static int
+uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *v4l2_buf)
 {
         struct uvc_buffer *buf;
         unsigned long flags;
@@ -298,8 +300,9 @@ static int uvc_queue_waiton(struct uvc_buffer *buf, int nonblocking)
  * Dequeue a video buffer. If nonblocking is false, block until a buffer is
  * available.
  */
-int uvc_dequeue_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf, int nonblocking)
+static int
+uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *v4l2_buf,
+                   int nonblocking)
 {
         struct uvc_buffer *buf;
         int ret = 0;
@@ -359,8 +362,9 @@ done:
  * This function implements video queue polling and is intended to be used by
  * the device poll handler.
  */
-unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
-                poll_table *wait)
+static unsigned int
+uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
+               poll_table *wait)
 {
         struct uvc_buffer *buf;
         unsigned int mask = 0;
@@ -407,7 +411,8 @@ static struct vm_operations_struct uvc_vm_ops = {
  * This function implements video buffer memory mapping and is intended to be
  * used by the device mmap handler.
  */
-int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
+static int
+uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
 {
         struct uvc_buffer *uninitialized_var(buffer);
         struct page *page;
@@ -458,6 +463,42 @@ done:
 }
 
 /*
+ * Cancel the video buffers queue.
+ *
+ * Cancelling the queue marks all buffers on the irq queue as erroneous,
+ * wakes them up and removes them from the queue.
+ *
+ * If the disconnect parameter is set, further calls to uvc_queue_buffer will
+ * fail with -ENODEV.
+ *
+ * This function acquires the irq spinlock and can be called from interrupt
+ * context.
+ */
+static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
+{
+        struct uvc_buffer *buf;
+        unsigned long flags;
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        while (!list_empty(&queue->irqqueue)) {
+                buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
+                                       queue);
+                list_del(&buf->queue);
+                buf->state = UVC_BUF_STATE_ERROR;
+                wake_up(&buf->wait);
+        }
+        /* This must be protected by the irqlock spinlock to avoid race
+         * conditions between uvc_queue_buffer and the disconnection event that
+         * could result in an interruptible wait in uvc_dequeue_buffer. Do not
+         * blindly replace this logic by checking for the UVC_DEV_DISCONNECTED
+         * state outside the queue code.
+         */
+        if (disconnect)
+                queue->flags |= UVC_QUEUE_DISCONNECTED;
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+}
+
+/*
  * Enable or disable the video buffers queue.
  *
  * The queue must be enabled before starting video acquisition and must be
@@ -474,7 +515,7 @@ done:
  * This function can't be called from interrupt context. Use
  * uvc_queue_cancel() instead.
  */
-int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
+static int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
 {
         unsigned int i;
         int ret = 0;
@@ -503,44 +544,8 @@ done:
         return ret;
 }
 
-/*
- * Cancel the video buffers queue.
- *
- * Cancelling the queue marks all buffers on the irq queue as erroneous,
- * wakes them up and removes them from the queue.
- *
- * If the disconnect parameter is set, further calls to uvc_queue_buffer will
- * fail with -ENODEV.
- *
- * This function acquires the irq spinlock and can be called from interrupt
- * context.
- */
-void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
-{
-        struct uvc_buffer *buf;
-        unsigned long flags;
-
-        spin_lock_irqsave(&queue->irqlock, flags);
-        while (!list_empty(&queue->irqqueue)) {
-                buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
-                                       queue);
-                list_del(&buf->queue);
-                buf->state = UVC_BUF_STATE_ERROR;
-                wake_up(&buf->wait);
-        }
-        /* This must be protected by the irqlock spinlock to avoid race
-         * conditions between uvc_queue_buffer and the disconnection event that
-         * could result in an interruptible wait in uvc_dequeue_buffer. Do not
-         * blindly replace this logic by checking for the UVC_DEV_DISCONNECTED
-         * state outside the queue code.
-         */
-        if (disconnect)
-                queue->flags |= UVC_QUEUE_DISCONNECTED;
-        spin_unlock_irqrestore(&queue->irqlock, flags);
-}
-
-struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
-                struct uvc_buffer *buf)
+static struct uvc_buffer *
+uvc_queue_next_buffer(struct uvc_video_queue *queue, struct uvc_buffer *buf)
 {
         struct uvc_buffer *nextbuf;
         unsigned long flags;
@@ -568,7 +573,7 @@ struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         return nextbuf;
 }
 
-struct uvc_buffer *uvc_queue_head(struct uvc_video_queue *queue)
+static struct uvc_buffer *uvc_queue_head(struct uvc_video_queue *queue)
 {
         struct uvc_buffer *buf = NULL;
 
diff --git a/drivers/usb/gadget/uvc_queue.h b/drivers/usb/gadget/uvc_queue.h
index 7f5a33fe7ae2..1812a8ecc5d0 100644
--- a/drivers/usb/gadget/uvc_queue.h
+++ b/drivers/usb/gadget/uvc_queue.h
@@ -58,30 +58,10 @@ struct uvc_video_queue {
         struct list_head irqqueue;
 };
 
-extern void uvc_queue_init(struct uvc_video_queue *queue,
-                enum v4l2_buf_type type);
-extern int uvc_alloc_buffers(struct uvc_video_queue *queue,
-                unsigned int nbuffers, unsigned int buflength);
-extern int uvc_free_buffers(struct uvc_video_queue *queue);
-extern int uvc_query_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf);
-extern int uvc_queue_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf);
-extern int uvc_dequeue_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf, int nonblocking);
-extern int uvc_queue_enable(struct uvc_video_queue *queue, int enable);
-extern void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect);
-extern struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
-                struct uvc_buffer *buf);
-extern unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
-                struct file *file, poll_table *wait);
-extern int uvc_queue_mmap(struct uvc_video_queue *queue,
-                struct vm_area_struct *vma);
 static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
 {
         return queue->flags & UVC_QUEUE_STREAMING;
 }
-extern struct uvc_buffer *uvc_queue_head(struct uvc_video_queue *queue);
 
 #endif /* __KERNEL__ */
 
diff --git a/drivers/usb/gadget/uvc_v4l2.c b/drivers/usb/gadget/uvc_v4l2.c
index a7989f29837e..2dcffdac86d2 100644
--- a/drivers/usb/gadget/uvc_v4l2.c
+++ b/drivers/usb/gadget/uvc_v4l2.c
@@ -363,7 +363,7 @@ uvc_v4l2_poll(struct file *file, poll_table *wait)
         return mask;
 }
 
-struct v4l2_file_operations uvc_v4l2_fops = {
+static struct v4l2_file_operations uvc_v4l2_fops = {
         .owner          = THIS_MODULE,
         .open           = uvc_v4l2_open,
         .release        = uvc_v4l2_release,
diff --git a/drivers/usb/gadget/uvc_video.c b/drivers/usb/gadget/uvc_video.c
index de8cbc46518d..b08f35438d70 100644
--- a/drivers/usb/gadget/uvc_video.c
+++ b/drivers/usb/gadget/uvc_video.c
@@ -271,7 +271,7 @@ error:
  * This function fills the available USB requests (listed in req_free) with
  * video data from the queued buffers.
  */
-int
+static int
 uvc_video_pump(struct uvc_video *video)
 {
         struct usb_request *req;
@@ -328,7 +328,7 @@ uvc_video_pump(struct uvc_video *video)
 /*
  * Enable or disable the video stream.
  */
-int
+static int
 uvc_video_enable(struct uvc_video *video, int enable)
 {
         unsigned int i;
@@ -367,7 +367,7 @@ uvc_video_enable(struct uvc_video *video, int enable)
 /*
  * Initialize the UVC video stream.
  */
-int
+static int
 uvc_video_init(struct uvc_video *video)
 {
         INIT_LIST_HEAD(&video->req_free);
diff --git a/drivers/usb/gadget/webcam.c b/drivers/usb/gadget/webcam.c
index 417fd6887698..f5f3030cc416 100644
--- a/drivers/usb/gadget/webcam.c
+++ b/drivers/usb/gadget/webcam.c
@@ -28,10 +28,10 @@
 #include "config.c"
 #include "epautoconf.c"
 
-#include "f_uvc.c"
 #include "uvc_queue.c"
-#include "uvc_v4l2.c"
 #include "uvc_video.c"
+#include "uvc_v4l2.c"
+#include "f_uvc.c"
 
 /* --------------------------------------------------------------------------
  * Device descriptor
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index df5b6b971f26..d219070fed3d 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -98,7 +98,8 @@ static void tx_poll_start(struct vhost_net *net, struct socket *sock)
 static void handle_tx(struct vhost_net *net)
 {
         struct vhost_virtqueue *vq = &net->dev.vqs[VHOST_NET_VQ_TX];
-        unsigned head, out, in, s;
+        unsigned out, in, s;
+        int head;
         struct msghdr msg = {
                 .msg_name = NULL,
                 .msg_namelen = 0,
@@ -135,6 +136,9 @@ static void handle_tx(struct vhost_net *net)
                                          ARRAY_SIZE(vq->iov),
                                          &out, &in,
                                          NULL, NULL);
+                /* On error, stop handling until the next kick. */
+                if (unlikely(head < 0))
+                        break;
                 /* Nothing new?  Wait for eventfd to tell us they refilled. */
                 if (head == vq->num) {
                         wmem = atomic_read(&sock->sk->sk_wmem_alloc);
@@ -173,8 +177,8 @@ static void handle_tx(struct vhost_net *net)
                         break;
                 }
                 if (err != len)
-                        pr_err("Truncated TX packet: "
-                               " len %d != %zd\n", err, len);
+                        pr_debug("Truncated TX packet: "
+                                 " len %d != %zd\n", err, len);
                 vhost_add_used_and_signal(&net->dev, vq, head, 0);
                 total_len += len;
                 if (unlikely(total_len >= VHOST_NET_WEIGHT)) {
@@ -192,7 +196,8 @@ static void handle_tx(struct vhost_net *net)
 static void handle_rx(struct vhost_net *net)
 {
         struct vhost_virtqueue *vq = &net->dev.vqs[VHOST_NET_VQ_RX];
-        unsigned head, out, in, log, s;
+        unsigned out, in, log, s;
+        int head;
         struct vhost_log *vq_log;
         struct msghdr msg = {
                 .msg_name = NULL,
@@ -228,6 +233,9 @@ static void handle_rx(struct vhost_net *net)
                                          ARRAY_SIZE(vq->iov),
                                          &out, &in,
                                          vq_log, &log);
+                /* On error, stop handling until the next kick. */
+                if (unlikely(head < 0))
+                        break;
                 /* OK, now we need to know about added descriptors. */
                 if (head == vq->num) {
                         if (unlikely(vhost_enable_notify(vq))) {
@@ -267,8 +275,8 @@ static void handle_rx(struct vhost_net *net)
                 }
                 /* TODO: Should check and handle checksum. */
                 if (err > len) {
-                        pr_err("Discarded truncated rx packet: "
-                               " len %d > %zd\n", err, len);
+                        pr_debug("Discarded truncated rx packet: "
+                                 " len %d > %zd\n", err, len);
                         vhost_discard_vq_desc(vq);
                         continue;
                 }
@@ -526,11 +534,16 @@ static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd)
         rcu_assign_pointer(vq->private_data, sock);
         vhost_net_enable_vq(n, vq);
 done:
+        mutex_unlock(&vq->mutex);
+
         if (oldsock) {
                 vhost_net_flush_vq(n, index);
                 fput(oldsock->file);
         }
 
+        mutex_unlock(&n->dev.mutex);
+        return 0;
+
 err_vq:
         mutex_unlock(&vq->mutex);
 err:
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index 3b83382e06eb..0b99783083f6 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -736,12 +736,12 @@ static int translate_desc(struct vhost_dev *dev, u64 addr, u32 len,
         mem = rcu_dereference(dev->memory);
         while ((u64)len > s) {
                 u64 size;
-                if (ret >= iov_size) {
+                if (unlikely(ret >= iov_size)) {
                         ret = -ENOBUFS;
                         break;
                 }
                 reg = find_region(mem, addr, len);
-                if (!reg) {
+                if (unlikely(!reg)) {
                         ret = -EFAULT;
                         break;
                 }
@@ -780,18 +780,18 @@ static unsigned next_desc(struct vring_desc *desc)
         return next;
 }
 
-static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
-                             struct iovec iov[], unsigned int iov_size,
-                             unsigned int *out_num, unsigned int *in_num,
-                             struct vhost_log *log, unsigned int *log_num,
-                             struct vring_desc *indirect)
+static int get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
+                        struct iovec iov[], unsigned int iov_size,
+                        unsigned int *out_num, unsigned int *in_num,
+                        struct vhost_log *log, unsigned int *log_num,
+                        struct vring_desc *indirect)
 {
         struct vring_desc desc;
         unsigned int i = 0, count, found = 0;
         int ret;
 
         /* Sanity check */
-        if (indirect->len % sizeof desc) {
+        if (unlikely(indirect->len % sizeof desc)) {
                 vq_err(vq, "Invalid length in indirect descriptor: "
                        "len 0x%llx not multiple of 0x%zx\n",
                        (unsigned long long)indirect->len,
@@ -801,7 +801,7 @@ static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
 
         ret = translate_desc(dev, indirect->addr, indirect->len, vq->indirect,
                              ARRAY_SIZE(vq->indirect));
-        if (ret < 0) {
+        if (unlikely(ret < 0)) {
                 vq_err(vq, "Translation failure %d in indirect.\n", ret);
                 return ret;
         }
@@ -813,7 +813,7 @@ static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
         count = indirect->len / sizeof desc;
         /* Buffers are chained via a 16 bit next field, so
          * we can have at most 2^16 of these. */
-        if (count > USHRT_MAX + 1) {
+        if (unlikely(count > USHRT_MAX + 1)) {
                 vq_err(vq, "Indirect buffer length too big: %d\n",
                        indirect->len);
                 return -E2BIG;
@@ -821,19 +821,19 @@ static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
 
         do {
                 unsigned iov_count = *in_num + *out_num;
-                if (++found > count) {
+                if (unlikely(++found > count)) {
                         vq_err(vq, "Loop detected: last one at %u "
                                "indirect size %u\n",
                                i, count);
                         return -EINVAL;
                 }
-                if (memcpy_fromiovec((unsigned char *)&desc, vq->indirect,
-                                     sizeof desc)) {
+                if (unlikely(memcpy_fromiovec((unsigned char *)&desc, vq->indirect,
+                                              sizeof desc))) {
                         vq_err(vq, "Failed indirect descriptor: idx %d, %zx\n",
                                i, (size_t)indirect->addr + i * sizeof desc);
                         return -EINVAL;
                 }
-                if (desc.flags & VRING_DESC_F_INDIRECT) {
+                if (unlikely(desc.flags & VRING_DESC_F_INDIRECT)) {
                         vq_err(vq, "Nested indirect descriptor: idx %d, %zx\n",
                                i, (size_t)indirect->addr + i * sizeof desc);
                         return -EINVAL;
@@ -841,7 +841,7 @@ static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
 
                 ret = translate_desc(dev, desc.addr, desc.len, iov + iov_count,
                                      iov_size - iov_count);
-                if (ret < 0) {
+                if (unlikely(ret < 0)) {
                         vq_err(vq, "Translation failure %d indirect idx %d\n",
                                ret, i);
                         return ret;
@@ -857,7 +857,7 @@ static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
                 } else {
                         /* If it's an output descriptor, they're all supposed
                          * to come before any input descriptors. */
-                        if (*in_num) {
+                        if (unlikely(*in_num)) {
                                 vq_err(vq, "Indirect descriptor "
                                        "has out after in: idx %d\n", i);
                                 return -EINVAL;
@@ -873,12 +873,13 @@ static unsigned get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
  * number of output then some number of input descriptors, it's actually two
  * iovecs, but we pack them into one and note how many of each there were.
  *
- * This function returns the descriptor number found, or vq->num (which
- * is never a valid descriptor number) if none was found. */
-unsigned vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
-                           struct iovec iov[], unsigned int iov_size,
-                           unsigned int *out_num, unsigned int *in_num,
-                           struct vhost_log *log, unsigned int *log_num)
+ * This function returns the descriptor number found, or vq->num (which is
+ * never a valid descriptor number) if none was found.  A negative code is
+ * returned on error. */
+int vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
+                      struct iovec iov[], unsigned int iov_size,
+                      unsigned int *out_num, unsigned int *in_num,
+                      struct vhost_log *log, unsigned int *log_num)
 {
         struct vring_desc desc;
         unsigned int i, head, found = 0;
@@ -887,16 +888,16 @@ unsigned vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
 
         /* Check it isn't doing very strange things with descriptor numbers. */
         last_avail_idx = vq->last_avail_idx;
-        if (get_user(vq->avail_idx, &vq->avail->idx)) {
+        if (unlikely(get_user(vq->avail_idx, &vq->avail->idx))) {
                 vq_err(vq, "Failed to access avail idx at %p\n",
                        &vq->avail->idx);
-                return vq->num;
+                return -EFAULT;
         }
 
-        if ((u16)(vq->avail_idx - last_avail_idx) > vq->num) {
+        if (unlikely((u16)(vq->avail_idx - last_avail_idx) > vq->num)) {
                 vq_err(vq, "Guest moved used index from %u to %u",
                        last_avail_idx, vq->avail_idx);
-                return vq->num;
+                return -EFAULT;
         }
 
         /* If there's nothing new since last we looked, return invalid. */
@@ -908,18 +909,19 @@ unsigned vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
 
         /* Grab the next descriptor number they're advertising, and increment
          * the index we've seen. */
-        if (get_user(head, &vq->avail->ring[last_avail_idx % vq->num])) {
+        if (unlikely(get_user(head,
+                              &vq->avail->ring[last_avail_idx % vq->num]))) {
                 vq_err(vq, "Failed to read head: idx %d address %p\n",
                        last_avail_idx,
                        &vq->avail->ring[last_avail_idx % vq->num]);
-                return vq->num;
+                return -EFAULT;
         }
 
         /* If their number is silly, that's an error. */
-        if (head >= vq->num) {
+        if (unlikely(head >= vq->num)) {
                 vq_err(vq, "Guest says index %u > %u is available",
                        head, vq->num);
-                return vq->num;
+                return -EINVAL;
         }
 
         /* When we start there are none of either input nor output. */
@@ -930,41 +932,41 @@ unsigned vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
         i = head;
         do {
                 unsigned iov_count = *in_num + *out_num;
-                if (i >= vq->num) {
+                if (unlikely(i >= vq->num)) {
                         vq_err(vq, "Desc index is %u > %u, head = %u",
                                i, vq->num, head);
-                        return vq->num;
+                        return -EINVAL;
                 }
-                if (++found > vq->num) {
+                if (unlikely(++found > vq->num)) {
                         vq_err(vq, "Loop detected: last one at %u "
                                "vq size %u head %u\n",
                                i, vq->num, head);
-                        return vq->num;
+                        return -EINVAL;
                 }
                 ret = copy_from_user(&desc, vq->desc + i, sizeof desc);
-                if (ret) {
+                if (unlikely(ret)) {
                         vq_err(vq, "Failed to get descriptor: idx %d addr %p\n",
                                i, vq->desc + i);
-                        return vq->num;
+                        return -EFAULT;
                 }
                 if (desc.flags & VRING_DESC_F_INDIRECT) {
                         ret = get_indirect(dev, vq, iov, iov_size,
                                            out_num, in_num,
                                            log, log_num, &desc);
-                        if (ret < 0) {
+                        if (unlikely(ret < 0)) {
                                 vq_err(vq, "Failure detected "
                                        "in indirect descriptor at idx %d\n", i);
-                                return vq->num;
+                                return ret;
                         }
                         continue;
                 }
 
                 ret = translate_desc(dev, desc.addr, desc.len, iov + iov_count,
                                      iov_size - iov_count);
-                if (ret < 0) {
+                if (unlikely(ret < 0)) {
                         vq_err(vq, "Translation failure %d descriptor idx %d\n",
                                ret, i);
-                        return vq->num;
+                        return ret;
                 }
                 if (desc.flags & VRING_DESC_F_WRITE) {
                         /* If this is an input descriptor,
@@ -978,10 +980,10 @@ unsigned vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
                 } else {
                         /* If it's an output descriptor, they're all supposed
                          * to come before any input descriptors. */
-                        if (*in_num) {
+                        if (unlikely(*in_num)) {
                                 vq_err(vq, "Descriptor has out after in: "
                                        "idx %d\n", i);
-                                return vq->num;
+                                return -EINVAL;
                         }
                         *out_num += ret;
                 }
diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h
index 44591ba9b07a..11ee13dba0f7 100644
--- a/drivers/vhost/vhost.h
+++ b/drivers/vhost/vhost.h
@@ -120,10 +120,10 @@ long vhost_dev_ioctl(struct vhost_dev *, unsigned int ioctl, unsigned long arg);
 int vhost_vq_access_ok(struct vhost_virtqueue *vq);
 int vhost_log_access_ok(struct vhost_dev *);
 
-unsigned vhost_get_vq_desc(struct vhost_dev *, struct vhost_virtqueue *,
-                           struct iovec iov[], unsigned int iov_count,
-                           unsigned int *out_num, unsigned int *in_num,
-                           struct vhost_log *log, unsigned int *log_num);
+int vhost_get_vq_desc(struct vhost_dev *, struct vhost_virtqueue *,
+                      struct iovec iov[], unsigned int iov_count,
+                      unsigned int *out_num, unsigned int *in_num,
+                      struct vhost_log *log, unsigned int *log_num);
 void vhost_discard_vq_desc(struct vhost_virtqueue *);
 
 int vhost_add_used(struct vhost_virtqueue *, unsigned int head, int len);
diff --git a/drivers/video/aty/radeon_pm.c b/drivers/video/aty/radeon_pm.c
index 515cf1978d19..c4e17642d9c5 100644
--- a/drivers/video/aty/radeon_pm.c
+++ b/drivers/video/aty/radeon_pm.c
@@ -2872,7 +2872,7 @@ void radeonfb_pm_init(struct radeonfb_info *rinfo, int dynclk, int ignore_devlis
                 }
 
 #if 0
-                /* Power down TV DAC, taht saves a significant amount of power,
+                /* Power down TV DAC, that saves a significant amount of power,
                  * we'll have something better once we actually have some TVOut
                  * support
                  */