192 files changed, 2741 insertions, 1396 deletions

diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index e898ad9eb1c3..ab871e00ffc5 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -2973,7 +2973,6 @@ struct drbd_conf *drbd_new_device(unsigned int minor)
                 goto out_no_q;
         mdev->rq_queue = q;
         q->queuedata   = mdev;
-        blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
 
         disk = alloc_disk(1);
         if (!disk)
@@ -2997,6 +2996,7 @@ struct drbd_conf *drbd_new_device(unsigned int minor)
         q->backing_dev_info.congested_data = mdev;
 
         blk_queue_make_request(q, drbd_make_request_26);
+        blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
         blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
         blk_queue_merge_bvec(q, drbd_merge_bvec);
         q->queue_lock = &mdev->req_lock; /* needed since we use */
diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index f22a5283128a..d065c646b35a 100644
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -1224,7 +1224,7 @@ static int receive_Barrier(struct drbd_conf *mdev, struct p_header *h)
         epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
         if (!epoch) {
                 dev_warn(DEV, "Allocation of an epoch failed, slowing down\n");
-                issue_flush = !test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags);
+                issue_flush = !test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags);
                 drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
                 if (issue_flush) {
                         rv = drbd_flush_after_epoch(mdev, mdev->current_epoch);
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 2ddf03ae034e..68b5957f107c 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -322,7 +322,7 @@ static void pkt_sysfs_dev_remove(struct pktcdvd_device *pd)
         pkt_kobj_remove(pd->kobj_stat);
         pkt_kobj_remove(pd->kobj_wqueue);
         if (class_pktcdvd)
-                device_destroy(class_pktcdvd, pd->pkt_dev);
+                device_unregister(pd->dev);
 }
 
 
diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig
index 652367aa6546..058fbccf2f52 100644
--- a/drivers/bluetooth/Kconfig
+++ b/drivers/bluetooth/Kconfig
@@ -195,5 +195,16 @@ config BT_MRVL_SDIO
           Say Y here to compile support for Marvell BT-over-SDIO driver
           into the kernel or say M to compile it as module.
 
-endmenu
+config BT_ATH3K
+        tristate "Atheros firmware download driver"
+        depends on BT_HCIBTUSB
+        select FW_LOADER
+        help
+          Bluetooth firmware download driver.
+          This driver loads the firmware into the Atheros Bluetooth
+          chipset.
 
+          Say Y here to compile support for "Atheros firmware download driver"
+          into the kernel or say M to compile it as module (ath3k).
+
+endmenu
diff --git a/drivers/bluetooth/Makefile b/drivers/bluetooth/Makefile
index b3f57d2d4eb0..7e5aed598121 100644
--- a/drivers/bluetooth/Makefile
+++ b/drivers/bluetooth/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_BT_HCIBTUART)	+= btuart_cs.o
 obj-$(CONFIG_BT_HCIBTUSB)       += btusb.o
 obj-$(CONFIG_BT_HCIBTSDIO)      += btsdio.o
 
+obj-$(CONFIG_BT_ATH3K)          += ath3k.o
 obj-$(CONFIG_BT_MRVL)           += btmrvl.o
 obj-$(CONFIG_BT_MRVL_SDIO)      += btmrvl_sdio.o
 
diff --git a/drivers/bluetooth/ath3k.c b/drivers/bluetooth/ath3k.c
new file mode 100644
index 000000000000..add9485ca5b6
--- /dev/null
+++ b/drivers/bluetooth/ath3k.c
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2008-2009 Atheros Communications Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/firmware.h>
+#include <linux/usb.h>
+#include <net/bluetooth/bluetooth.h>
+
+#define VERSION "1.0"
+
+
+static struct usb_device_id ath3k_table[] = {
+        /* Atheros AR3011 */
+        { USB_DEVICE(0x0CF3, 0x3000) },
+        { }     /* Terminating entry */
+};
+
+MODULE_DEVICE_TABLE(usb, ath3k_table);
+
+#define USB_REQ_DFU_DNLOAD      1
+#define BULK_SIZE               4096
+
+struct ath3k_data {
+        struct usb_device *udev;
+        u8 *fw_data;
+        u32 fw_size;
+        u32 fw_sent;
+};
+
+static int ath3k_load_firmware(struct ath3k_data *data,
+                                unsigned char *firmware,
+                                int count)
+{
+        u8 *send_buf;
+        int err, pipe, len, size, sent = 0;
+
+        BT_DBG("ath3k %p udev %p", data, data->udev);
+
+        pipe = usb_sndctrlpipe(data->udev, 0);
+
+        if ((usb_control_msg(data->udev, pipe,
+                                USB_REQ_DFU_DNLOAD,
+                                USB_TYPE_VENDOR, 0, 0,
+                                firmware, 20, USB_CTRL_SET_TIMEOUT)) < 0) {
+                BT_ERR("Can't change to loading configuration err");
+                return -EBUSY;
+        }
+        sent += 20;
+        count -= 20;
+
+        send_buf = kmalloc(BULK_SIZE, GFP_ATOMIC);
+        if (!send_buf) {
+                BT_ERR("Can't allocate memory chunk for firmware");
+                return -ENOMEM;
+        }
+
+        while (count) {
+                size = min_t(uint, count, BULK_SIZE);
+                pipe = usb_sndbulkpipe(data->udev, 0x02);
+                memcpy(send_buf, firmware + sent, size);
+
+                err = usb_bulk_msg(data->udev, pipe, send_buf, size,
+                                        &len, 3000);
+
+                if (err || (len != size)) {
+                        BT_ERR("Error in firmware loading err = %d,"
+                                "len = %d, size = %d", err, len, size);
+                        goto error;
+                }
+
+                sent  += size;
+                count -= size;
+        }
+
+        kfree(send_buf);
+        return 0;
+
+error:
+        kfree(send_buf);
+        return err;
+}
+
+static int ath3k_probe(struct usb_interface *intf,
+                        const struct usb_device_id *id)
+{
+        const struct firmware *firmware;
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct ath3k_data *data;
+        int size;
+
+        BT_DBG("intf %p id %p", intf, id);
+
+        if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
+                return -ENODEV;
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        data->udev = udev;
+
+        if (request_firmware(&firmware, "ath3k-1.fw", &udev->dev) < 0) {
+                kfree(data);
+                return -EIO;
+        }
+
+        size = max_t(uint, firmware->size, 4096);
+        data->fw_data = kmalloc(size, GFP_KERNEL);
+        if (!data->fw_data) {
+                release_firmware(firmware);
+                kfree(data);
+                return -ENOMEM;
+        }
+
+        memcpy(data->fw_data, firmware->data, firmware->size);
+        data->fw_size = firmware->size;
+        data->fw_sent = 0;
+        release_firmware(firmware);
+
+        usb_set_intfdata(intf, data);
+        if (ath3k_load_firmware(data, data->fw_data, data->fw_size)) {
+                usb_set_intfdata(intf, NULL);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static void ath3k_disconnect(struct usb_interface *intf)
+{
+        struct ath3k_data *data = usb_get_intfdata(intf);
+
+        BT_DBG("ath3k_disconnect intf %p", intf);
+
+        kfree(data->fw_data);
+        kfree(data);
+}
+
+static struct usb_driver ath3k_driver = {
+        .name           = "ath3k",
+        .probe          = ath3k_probe,
+        .disconnect     = ath3k_disconnect,
+        .id_table       = ath3k_table,
+};
+
+static int __init ath3k_init(void)
+{
+        BT_INFO("Atheros AR30xx firmware driver ver %s", VERSION);
+        return usb_register(&ath3k_driver);
+}
+
+static void __exit ath3k_exit(void)
+{
+        usb_deregister(&ath3k_driver);
+}
+
+module_init(ath3k_init);
+module_exit(ath3k_exit);
+
+MODULE_AUTHOR("Atheros Communications");
+MODULE_DESCRIPTION("Atheros AR30xx firmware driver");
+MODULE_VERSION(VERSION);
+MODULE_LICENSE("GPL");
+MODULE_FIRMWARE("ath3k-1.fw");
diff --git a/drivers/bluetooth/bluecard_cs.c b/drivers/bluetooth/bluecard_cs.c
index 2acdc605cb4b..c2cf81144715 100644
--- a/drivers/bluetooth/bluecard_cs.c
+++ b/drivers/bluetooth/bluecard_cs.c
@@ -503,7 +503,9 @@ static irqreturn_t bluecard_interrupt(int irq, void *dev_inst)
         unsigned int iobase;
         unsigned char reg;
 
-        BUG_ON(!info->hdev);
+        if (!info || !info->hdev)
+                /* our irq handler is shared */
+                return IRQ_NONE;
 
         if (!test_bit(CARD_READY, &(info->hw_state)))
                 return IRQ_HANDLED;
diff --git a/drivers/bluetooth/bt3c_cs.c b/drivers/bluetooth/bt3c_cs.c
index d814a2755ccb..9f5926aaf57f 100644
--- a/drivers/bluetooth/bt3c_cs.c
+++ b/drivers/bluetooth/bt3c_cs.c
@@ -345,7 +345,9 @@ static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
         int iir;
         irqreturn_t r = IRQ_NONE;
 
-        BUG_ON(!info->hdev);
+        if (!info || !info->hdev)
+                /* our irq handler is shared */
+                return IRQ_NONE;
 
         iobase = info->p_dev->io.BasePort1;
 
diff --git a/drivers/bluetooth/btuart_cs.c b/drivers/bluetooth/btuart_cs.c
index d339464dc15e..91c523099804 100644
--- a/drivers/bluetooth/btuart_cs.c
+++ b/drivers/bluetooth/btuart_cs.c
@@ -295,7 +295,9 @@ static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
         int iir, lsr;
         irqreturn_t r = IRQ_NONE;
 
-        BUG_ON(!info->hdev);
+        if (!info || !info->hdev)
+                /* our irq handler is shared */
+                return IRQ_NONE;
 
         iobase = info->p_dev->io.BasePort1;
 
diff --git a/drivers/bluetooth/dtl1_cs.c b/drivers/bluetooth/dtl1_cs.c
index 4f02a6f3c980..697591941e17 100644
--- a/drivers/bluetooth/dtl1_cs.c
+++ b/drivers/bluetooth/dtl1_cs.c
@@ -299,7 +299,9 @@ static irqreturn_t dtl1_interrupt(int irq, void *dev_inst)
         int iir, lsr;
         irqreturn_t r = IRQ_NONE;
 
-        BUG_ON(!info->hdev);
+        if (!info || !info->hdev)
+                /* our irq handler is shared */
+                return IRQ_NONE;
 
         iobase = info->p_dev->io.BasePort1;
 
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 1afb8968a342..34cf04e21795 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -729,9 +729,6 @@ int __init agp_amd64_init(void)
         if (agp_off)
                 return -EINVAL;
 
-        if (gart_iommu_aperture)
-                return agp_bridges_found ? 0 : -ENODEV;
-
         err = pci_register_driver(&agp_amd64_pci_driver);
         if (err < 0)
                 return err;
@@ -768,6 +765,14 @@ int __init agp_amd64_init(void)
         return err;
 }
 
+static int __init agp_amd64_mod_init(void)
+{
+        if (gart_iommu_aperture)
+                return agp_bridges_found ? 0 : -ENODEV;
+
+        return agp_amd64_init();
+}
+
 static void __exit agp_amd64_cleanup(void)
 {
         if (gart_iommu_aperture)
@@ -777,7 +782,7 @@ static void __exit agp_amd64_cleanup(void)
         pci_unregister_driver(&agp_amd64_pci_driver);
 }
 
-module_init(agp_amd64_init);
+module_init(agp_amd64_mod_init);
 module_exit(agp_amd64_cleanup);
 
 MODULE_AUTHOR("Dave Jones <davej@redhat.com>, Andi Kleen");
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index be832b6f8279..48788db4e280 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -395,6 +395,7 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
         unsigned long p = *ppos;
         ssize_t low_count, read, sz;
         char * kbuf; /* k-addr because vread() takes vmlist_lock rwlock */
+        int err = 0;
 
         read = 0;
         if (p < (unsigned long) high_memory) {
@@ -441,12 +442,16 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
                         return -ENOMEM;
                 while (count > 0) {
                         sz = size_inside_page(p, count);
+                        if (!is_vmalloc_or_module_addr((void *)p)) {
+                                err = -ENXIO;
+                                break;
+                        }
                         sz = vread(kbuf, (char *)p, sz);
                         if (!sz)
                                 break;
                         if (copy_to_user(buf, kbuf, sz)) {
-                                free_page((unsigned long)kbuf);
-                                return -EFAULT;
+                                err = -EFAULT;
+                                break;
                         }
                         count -= sz;
                         buf += sz;
@@ -455,8 +460,8 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
                 }
                 free_page((unsigned long)kbuf);
         }
-        *ppos = p;
-        return read;
+        *ppos = p;
+        return read ? read : err;
 }
 
 
@@ -520,6 +525,7 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
         ssize_t wrote = 0;
         ssize_t virtr = 0;
         char * kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */
+        int err = 0;
 
         if (p < (unsigned long) high_memory) {
                 unsigned long to_write = min_t(unsigned long, count,
@@ -540,14 +546,16 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
                         unsigned long sz = size_inside_page(p, count);
                         unsigned long n;
 
+                        if (!is_vmalloc_or_module_addr((void *)p)) {
+                                err = -ENXIO;
+                                break;
+                        }
                         n = copy_from_user(kbuf, buf, sz);
                         if (n) {
-                                if (wrote + virtr)
-                                        break;
-                                free_page((unsigned long)kbuf);
-                                return -EFAULT;
+                                err = -EFAULT;
+                                break;
                         }
-                        sz = vwrite(kbuf, (char *)p, sz);
+                        vwrite(kbuf, (char *)p, sz);
                         count -= sz;
                         buf += sz;
                         virtr += sz;
@@ -556,8 +564,8 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
                 free_page((unsigned long)kbuf);
         }
 
-        *ppos = p;
-        return virtr + wrote;
+        *ppos = p;
+        return virtr + wrote ? : err;
 }
 #endif
 
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 8258982b49ec..2849713d2231 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1051,12 +1051,6 @@ random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
                                 /* like a named pipe */
         }
 
-        /*
-         * If we gave the user some bytes, update the access time.
-         */
-        if (count)
-                file_accessed(file);
-
         return (count ? count : retval);
 }
 
@@ -1107,7 +1101,6 @@ static ssize_t random_write(struct file *file, const char __user *buffer,
                             size_t count, loff_t *ppos)
 {
         size_t ret;
-        struct inode *inode = file->f_path.dentry->d_inode;
 
         ret = write_pool(&blocking_pool, buffer, count);
         if (ret)
@@ -1116,8 +1109,6 @@ static ssize_t random_write(struct file *file, const char __user *buffer,
         if (ret)
                 return ret;
 
-        inode->i_mtime = current_fs_time(inode->i_sb);
-        mark_inode_dirty(inode);
         return (ssize_t)count;
 }
 
diff --git a/drivers/char/uv_mmtimer.c b/drivers/char/uv_mmtimer.c
index 867b67be9f0a..c7072ba14f48 100644
--- a/drivers/char/uv_mmtimer.c
+++ b/drivers/char/uv_mmtimer.c
@@ -89,13 +89,17 @@ static long uv_mmtimer_ioctl(struct file *file, unsigned int cmd,
         switch (cmd) {
         case MMTIMER_GETOFFSET: /* offset of the counter */
                 /*
-                 * UV RTC register is on its own page
+                 * Starting with HUB rev 2.0, the UV RTC register is
+                 * replicated across all cachelines of it's own page.
+                 * This allows faster simultaneous reads from a given socket.
+                 *
+                 * The offset returned is in 64 bit units.
                  */
-                if (PAGE_SIZE <= (1 << 16))
-                        ret = ((UV_LOCAL_MMR_BASE | UVH_RTC) & (PAGE_SIZE-1))
-                                / 8;
+                if (uv_get_min_hub_revision_id() == 1)
+                        ret = 0;
                 else
-                        ret = -ENOSYS;
+                        ret = ((uv_blade_processor_id() * L1_CACHE_BYTES) %
+                                        PAGE_SIZE) / 8;
                 break;
 
         case MMTIMER_GETRES: /* resolution of the clock in 10^-15 s */
@@ -115,8 +119,8 @@ static long uv_mmtimer_ioctl(struct file *file, unsigned int cmd,
                 ret = hweight64(UVH_RTC_REAL_TIME_CLOCK_MASK);
                 break;
 
-        case MMTIMER_MMAPAVAIL: /* can we mmap the clock into userspace? */
-                ret = (PAGE_SIZE <= (1 << 16)) ? 1 : 0;
+        case MMTIMER_MMAPAVAIL:
+                ret = 1;
                 break;
 
         case MMTIMER_GETCOUNTER:
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c
index f06024668f99..537c29ac4487 100644
--- a/drivers/connector/connector.c
+++ b/drivers/connector/connector.c
@@ -36,17 +36,6 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
 
-static u32 cn_idx = CN_IDX_CONNECTOR;
-static u32 cn_val = CN_VAL_CONNECTOR;
-
-module_param(cn_idx, uint, 0);
-module_param(cn_val, uint, 0);
-MODULE_PARM_DESC(cn_idx, "Connector's main device idx.");
-MODULE_PARM_DESC(cn_val, "Connector's main device val.");
-
-static DEFINE_MUTEX(notify_lock);
-static LIST_HEAD(notify_list);
-
 static struct cn_dev cdev;
 
 static int cn_already_initialized;
@@ -210,54 +199,6 @@ static void cn_rx_skb(struct sk_buff *__skb)
 }
 
 /*
- * Notification routing.
- *
- * Gets id and checks if there are notification request for it's idx
- * and val.  If there are such requests notify the listeners with the
- * given notify event.
- *
- */
-static void cn_notify(struct cb_id *id, u32 notify_event)
-{
-        struct cn_ctl_entry *ent;
-
-        mutex_lock(&notify_lock);
-        list_for_each_entry(ent, &notify_list, notify_entry) {
-                int i;
-                struct cn_notify_req *req;
-                struct cn_ctl_msg *ctl = ent->msg;
-                int idx_found, val_found;
-
-                idx_found = val_found = 0;
-
-                req = (struct cn_notify_req *)ctl->data;
-                for (i = 0; i < ctl->idx_notify_num; ++i, ++req) {
-                        if (id->idx >= req->first &&
-                                        id->idx < req->first + req->range) {
-                                idx_found = 1;
-                                break;
-                        }
-                }
-
-                for (i = 0; i < ctl->val_notify_num; ++i, ++req) {
-                        if (id->val >= req->first &&
-                                        id->val < req->first + req->range) {
-                                val_found = 1;
-                                break;
-                        }
-                }
-
-                if (idx_found && val_found) {
-                        struct cn_msg m = { .ack = notify_event, };
-
-                        memcpy(&m.id, id, sizeof(m.id));
-                        cn_netlink_send(&m, ctl->group, GFP_KERNEL);
-                }
-        }
-        mutex_unlock(&notify_lock);
-}
-
-/*
  * Callback add routing - adds callback with given ID and name.
  * If there is registered callback with the same ID it will not be added.
  *
@@ -276,8 +217,6 @@ int cn_add_callback(struct cb_id *id, char *name,
         if (err)
                 return err;
 
-        cn_notify(id, 0);
-
         return 0;
 }
 EXPORT_SYMBOL_GPL(cn_add_callback);
@@ -295,111 +234,9 @@ void cn_del_callback(struct cb_id *id)
         struct cn_dev *dev = &cdev;
 
         cn_queue_del_callback(dev->cbdev, id);
-        cn_notify(id, 1);
 }
 EXPORT_SYMBOL_GPL(cn_del_callback);
 
-/*
- * Checks two connector's control messages to be the same.
- * Returns 1 if they are the same or if the first one is corrupted.
- */
-static int cn_ctl_msg_equals(struct cn_ctl_msg *m1, struct cn_ctl_msg *m2)
-{
-        int i;
-        struct cn_notify_req *req1, *req2;
-
-        if (m1->idx_notify_num != m2->idx_notify_num)
-                return 0;
-
-        if (m1->val_notify_num != m2->val_notify_num)
-                return 0;
-
-        if (m1->len != m2->len)
-                return 0;
-
-        if ((m1->idx_notify_num + m1->val_notify_num) * sizeof(*req1) !=
-            m1->len)
-                return 1;
-
-        req1 = (struct cn_notify_req *)m1->data;
-        req2 = (struct cn_notify_req *)m2->data;
-
-        for (i = 0; i < m1->idx_notify_num; ++i) {
-                if (req1->first != req2->first || req1->range != req2->range)
-                        return 0;
-                req1++;
-                req2++;
-        }
-
-        for (i = 0; i < m1->val_notify_num; ++i) {
-                if (req1->first != req2->first || req1->range != req2->range)
-                        return 0;
-                req1++;
-                req2++;
-        }
-
-        return 1;
-}
-
-/*
- * Main connector device's callback.
- *
- * Used for notification of a request's processing.
- */
-static void cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
-{
-        struct cn_ctl_msg *ctl;
-        struct cn_ctl_entry *ent;
-        u32 size;
-
-        if (msg->len < sizeof(*ctl))
-                return;
-
-        ctl = (struct cn_ctl_msg *)msg->data;
-
-        size = (sizeof(*ctl) + ((ctl->idx_notify_num +
-                                 ctl->val_notify_num) *
-                                sizeof(struct cn_notify_req)));
-
-        if (msg->len != size)
-                return;
-
-        if (ctl->len + sizeof(*ctl) != msg->len)
-                return;
-
-        /*
-         * Remove notification.
-         */
-        if (ctl->group == 0) {
-                struct cn_ctl_entry *n;
-
-                mutex_lock(&notify_lock);
-                list_for_each_entry_safe(ent, n, &notify_list, notify_entry) {
-                        if (cn_ctl_msg_equals(ent->msg, ctl)) {
-                                list_del(&ent->notify_entry);
-                                kfree(ent);
-                        }
-                }
-                mutex_unlock(&notify_lock);
-
-                return;
-        }
-
-        size += sizeof(*ent);
-
-        ent = kzalloc(size, GFP_KERNEL);
-        if (!ent)
-                return;
-
-        ent->msg = (struct cn_ctl_msg *)(ent + 1);
-
-        memcpy(ent->msg, ctl, size - sizeof(*ent));
-
-        mutex_lock(&notify_lock);
-        list_add(&ent->notify_entry, &notify_list);
-        mutex_unlock(&notify_lock);
-}
-
 static int cn_proc_show(struct seq_file *m, void *v)
 {
         struct cn_queue_dev *dev = cdev.cbdev;
@@ -437,11 +274,8 @@ static const struct file_operations cn_file_ops = {
 static int __devinit cn_init(void)
 {
         struct cn_dev *dev = &cdev;
-        int err;
 
         dev->input = cn_rx_skb;
-        dev->id.idx = cn_idx;
-        dev->id.val = cn_val;
 
         dev->nls = netlink_kernel_create(&init_net, NETLINK_CONNECTOR,
                                          CN_NETLINK_USERS + 0xf,
@@ -457,14 +291,6 @@ static int __devinit cn_init(void)
 
         cn_already_initialized = 1;
 
-        err = cn_add_callback(&dev->id, "connector", &cn_callback);
-        if (err) {
-                cn_already_initialized = 0;
-                cn_queue_free_dev(dev->cbdev);
-                netlink_kernel_release(dev->nls);
-                return -EINVAL;
-        }
-
         proc_net_fops_create(&init_net, "connector", S_IRUGO, &cn_file_ops);
 
         return 0;
@@ -478,7 +304,6 @@ static void __devexit cn_fini(void)
 
         proc_net_remove(&init_net, "connector");
 
-        cn_del_callback(&dev->id);
         cn_queue_free_dev(dev->cbdev);
         netlink_kernel_release(dev->nls);
 }
diff --git a/drivers/crypto/padlock-sha.c b/drivers/crypto/padlock-sha.c
index 0af80577dc7b..d3a27e0119bc 100644
--- a/drivers/crypto/padlock-sha.c
+++ b/drivers/crypto/padlock-sha.c
@@ -57,6 +57,23 @@ static int padlock_sha_update(struct shash_desc *desc,
         return crypto_shash_update(&dctx->fallback, data, length);
 }
 
+static int padlock_sha_export(struct shash_desc *desc, void *out)
+{
+        struct padlock_sha_desc *dctx = shash_desc_ctx(desc);
+
+        return crypto_shash_export(&dctx->fallback, out);
+}
+
+static int padlock_sha_import(struct shash_desc *desc, const void *in)
+{
+        struct padlock_sha_desc *dctx = shash_desc_ctx(desc);
+        struct padlock_sha_ctx *ctx = crypto_shash_ctx(desc->tfm);
+
+        dctx->fallback.tfm = ctx->fallback;
+        dctx->fallback.flags = desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
+        return crypto_shash_import(&dctx->fallback, in);
+}
+
 static inline void padlock_output_block(uint32_t *src,
                         uint32_t *dst, size_t count)
 {
@@ -235,7 +252,10 @@ static struct shash_alg sha1_alg = {
         .update         =       padlock_sha_update,
         .finup          =       padlock_sha1_finup,
         .final          =       padlock_sha1_final,
+        .export         =       padlock_sha_export,
+        .import         =       padlock_sha_import,
         .descsize       =       sizeof(struct padlock_sha_desc),
+        .statesize      =       sizeof(struct sha1_state),
         .base           =       {
                 .cra_name               =       "sha1",
                 .cra_driver_name        =       "sha1-padlock",
@@ -256,7 +276,10 @@ static struct shash_alg sha256_alg = {
         .update         =       padlock_sha_update,
         .finup          =       padlock_sha256_finup,
         .final          =       padlock_sha256_final,
+        .export         =       padlock_sha_export,
+        .import         =       padlock_sha_import,
         .descsize       =       sizeof(struct padlock_sha_desc),
+        .statesize      =       sizeof(struct sha256_state),
         .base           =       {
                 .cra_name               =       "sha256",
                 .cra_driver_name        =       "sha256-padlock",
diff --git a/drivers/firewire/core-card.c b/drivers/firewire/core-card.c
index 7083bcc1b9c7..5045156c5313 100644
--- a/drivers/firewire/core-card.c
+++ b/drivers/firewire/core-card.c
@@ -57,6 +57,8 @@ static LIST_HEAD(descriptor_list);
 static int descriptor_count;
 
 static __be32 tmp_config_rom[256];
+/* ROM header, bus info block, root dir header, capabilities = 7 quadlets */
+static size_t config_rom_length = 1 + 4 + 1 + 1;
 
 #define BIB_CRC(v)              ((v) <<  0)
 #define BIB_CRC_LENGTH(v)       ((v) << 16)
@@ -73,7 +75,7 @@ static __be32 tmp_config_rom[256];
 #define BIB_CMC                 ((1) << 30)
 #define BIB_IMC                 ((1) << 31)
 
-static size_t generate_config_rom(struct fw_card *card, __be32 *config_rom)
+static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
 {
         struct fw_descriptor *desc;
         int i, j, k, length;
@@ -130,23 +132,30 @@ static size_t generate_config_rom(struct fw_card *card, __be32 *config_rom)
         for (i = 0; i < j; i += length + 1)
                 length = fw_compute_block_crc(config_rom + i);
 
-        return j;
+        WARN_ON(j != config_rom_length);
 }
 
 static void update_config_roms(void)
 {
         struct fw_card *card;
-        size_t length;
 
         list_for_each_entry (card, &card_list, link) {
-                length = generate_config_rom(card, tmp_config_rom);
-                card->driver->set_config_rom(card, tmp_config_rom, length);
+                generate_config_rom(card, tmp_config_rom);
+                card->driver->set_config_rom(card, tmp_config_rom,
+                                             config_rom_length);
         }
 }
 
+static size_t required_space(struct fw_descriptor *desc)
+{
+        /* descriptor + entry into root dir + optional immediate entry */
+        return desc->length + 1 + (desc->immediate > 0 ? 1 : 0);
+}
+
 int fw_core_add_descriptor(struct fw_descriptor *desc)
 {
         size_t i;
+        int ret;
 
         /*
          * Check descriptor is valid; the length of all blocks in the
@@ -162,15 +171,21 @@ int fw_core_add_descriptor(struct fw_descriptor *desc)
 
         mutex_lock(&card_mutex);
 
-        list_add_tail(&desc->link, &descriptor_list);
-        descriptor_count++;
-        if (desc->immediate > 0)
+        if (config_rom_length + required_space(desc) > 256) {
+                ret = -EBUSY;
+        } else {
+                list_add_tail(&desc->link, &descriptor_list);
+                config_rom_length += required_space(desc);
                 descriptor_count++;
-        update_config_roms();
+                if (desc->immediate > 0)
+                        descriptor_count++;
+                update_config_roms();
+                ret = 0;
+        }
 
         mutex_unlock(&card_mutex);
 
-        return 0;
+        return ret;
 }
 EXPORT_SYMBOL(fw_core_add_descriptor);
 
@@ -179,6 +194,7 @@ void fw_core_remove_descriptor(struct fw_descriptor *desc)
         mutex_lock(&card_mutex);
 
         list_del(&desc->link);
+        config_rom_length -= required_space(desc);
         descriptor_count--;
         if (desc->immediate > 0)
                 descriptor_count--;
@@ -428,7 +444,6 @@ EXPORT_SYMBOL(fw_card_initialize);
 int fw_card_add(struct fw_card *card,
                 u32 max_receive, u32 link_speed, u64 guid)
 {
-        size_t length;
         int ret;
 
         card->max_receive = max_receive;
@@ -437,8 +452,8 @@ int fw_card_add(struct fw_card *card,
 
         mutex_lock(&card_mutex);
 
-        length = generate_config_rom(card, tmp_config_rom);
-        ret = card->driver->enable(card, tmp_config_rom, length);
+        generate_config_rom(card, tmp_config_rom);
+        ret = card->driver->enable(card, tmp_config_rom, config_rom_length);
         if (ret == 0)
                 list_add_tail(&card->link, &card_list);
 
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c
index e6d63849e78e..4eeaed57e219 100644
--- a/drivers/firewire/core-cdev.c
+++ b/drivers/firewire/core-cdev.c
@@ -35,6 +35,7 @@
 #include <linux/preempt.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
+#include <linux/string.h>
 #include <linux/time.h>
 #include <linux/uaccess.h>
 #include <linux/vmalloc.h>
@@ -595,13 +596,20 @@ static int ioctl_send_request(struct client *client, void *buffer)
                             client->device->max_speed);
 }
 
+static inline bool is_fcp_request(struct fw_request *request)
+{
+        return request == NULL;
+}
+
 static void release_request(struct client *client,
                             struct client_resource *resource)
 {
         struct inbound_transaction_resource *r = container_of(resource,
                         struct inbound_transaction_resource, resource);
 
-        if (r->request)
+        if (is_fcp_request(r->request))
+                kfree(r->data);
+        else
                 fw_send_response(client->device->card, r->request,
                                  RCODE_CONFLICT_ERROR);
         kfree(r);
@@ -616,6 +624,7 @@ static void handle_request(struct fw_card *card, struct fw_request *request,
         struct address_handler_resource *handler = callback_data;
         struct inbound_transaction_resource *r;
         struct inbound_transaction_event *e;
+        void *fcp_frame = NULL;
         int ret;
 
         r = kmalloc(sizeof(*r), GFP_ATOMIC);
@@ -627,6 +636,18 @@ static void handle_request(struct fw_card *card, struct fw_request *request,
         r->data    = payload;
         r->length  = length;
 
+        if (is_fcp_request(request)) {
+                /*
+                 * FIXME: Let core-transaction.c manage a
+                 * single reference-counted copy?
+                 */
+                fcp_frame = kmemdup(payload, length, GFP_ATOMIC);
+                if (fcp_frame == NULL)
+                        goto failed;
+
+                r->data = fcp_frame;
+        }
+
         r->resource.release = release_request;
         ret = add_client_resource(handler->client, &r->resource, GFP_ATOMIC);
         if (ret < 0)
@@ -640,13 +661,15 @@ static void handle_request(struct fw_card *card, struct fw_request *request,
         e->request.closure = handler->closure;
 
         queue_event(handler->client, &e->event,
-                    &e->request, sizeof(e->request), payload, length);
+                    &e->request, sizeof(e->request), r->data, length);
         return;
 
  failed:
         kfree(r);
         kfree(e);
-        if (request)
+        kfree(fcp_frame);
+
+        if (!is_fcp_request(request))
                 fw_send_response(card, request, RCODE_CONFLICT_ERROR);
 }
 
@@ -717,18 +740,17 @@ static int ioctl_send_response(struct client *client, void *buffer)
 
         r = container_of(resource, struct inbound_transaction_resource,
                          resource);
-        if (r->request) {
-                if (request->length < r->length)
-                        r->length = request->length;
-                if (copy_from_user(r->data, u64_to_uptr(request->data),
-                                   r->length)) {
-                        ret = -EFAULT;
-                        kfree(r->request);
-                        goto out;
-                }
-                fw_send_response(client->device->card, r->request,
-                                 request->rcode);
+        if (is_fcp_request(r->request))
+                goto out;
+
+        if (request->length < r->length)
+                r->length = request->length;
+        if (copy_from_user(r->data, u64_to_uptr(request->data), r->length)) {
+                ret = -EFAULT;
+                kfree(r->request);
+                goto out;
         }
+        fw_send_response(client->device->card, r->request, request->rcode);
  out:
         kfree(r);
 
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index a61571c63c59..2345d4103fe6 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -2420,6 +2420,7 @@ static void ohci_pmac_off(struct pci_dev *dev)
 
 #define PCI_VENDOR_ID_AGERE             PCI_VENDOR_ID_ATT
 #define PCI_DEVICE_ID_AGERE_FW643       0x5901
+#define PCI_DEVICE_ID_TI_TSB43AB23      0x8024
 
 static int __devinit pci_probe(struct pci_dev *dev,
                                const struct pci_device_id *ent)
@@ -2488,7 +2489,8 @@ static int __devinit pci_probe(struct pci_dev *dev,
 #if !defined(CONFIG_X86_32)
         /* dual-buffer mode is broken with descriptor addresses above 2G */
         if (dev->vendor == PCI_VENDOR_ID_TI &&
-            dev->device == PCI_DEVICE_ID_TI_TSB43AB22)
+            (dev->device == PCI_DEVICE_ID_TI_TSB43AB22 ||
+             dev->device == PCI_DEVICE_ID_TI_TSB43AB23))
                 ohci->use_dualbuffer = false;
 #endif
 
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 96eddd17e050..305c59003963 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -66,6 +66,8 @@ config DRM_RADEON
 
           If M is selected, the module will be called radeon.
 
+source "drivers/gpu/drm/radeon/Kconfig"
+
 config DRM_I810
         tristate "Intel I810"
         depends on DRM && AGP && AGP_INTEL
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index defcaf108460..f665b05592f3 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -633,8 +633,7 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
                 return NULL;
         }
         if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) {
-                printk(KERN_WARNING "integrated sync not supported\n");
-                return NULL;
+                printk(KERN_WARNING "composite sync not supported\n");
         }
 
         /* it is incorrect if hsync/vsync width is zero */
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 1c2b7d44ec05..0f9e90552dc4 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -389,7 +389,7 @@ int drm_fb_helper_blank(int blank, struct fb_info *info)
                 break;
         /* Display: Off; HSync: On, VSync: On */
         case FB_BLANK_NORMAL:
-                drm_fb_helper_off(info, DRM_MODE_DPMS_ON);
+                drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
                 break;
         /* Display: Off; HSync: Off, VSync: On */
         case FB_BLANK_HSYNC_SUSPEND:
diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
index e9dbb481c469..8bf3770f294e 100644
--- a/drivers/gpu/drm/drm_gem.c
+++ b/drivers/gpu/drm/drm_gem.c
@@ -142,19 +142,6 @@ drm_gem_object_alloc(struct drm_device *dev, size_t size)
         if (IS_ERR(obj->filp))
                 goto free;
 
-        /* Basically we want to disable the OOM killer and handle ENOMEM
-         * ourselves by sacrificing pages from cached buffers.
-         * XXX shmem_file_[gs]et_gfp_mask()
-         */
-        mapping_set_gfp_mask(obj->filp->f_path.dentry->d_inode->i_mapping,
-                             GFP_HIGHUSER |
-                             __GFP_COLD |
-                             __GFP_FS |
-                             __GFP_RECLAIMABLE |
-                             __GFP_NORETRY |
-                             __GFP_NOWARN |
-                             __GFP_NOMEMALLOC);
-
         kref_init(&obj->refcount);
         kref_init(&obj->handlecount);
         obj->size = size;
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 9c9998c4dceb..a894ade03093 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -290,7 +290,7 @@ static int i915_batchbuffer_info(struct seq_file *m, void *data)
         list_for_each_entry(obj_priv, &dev_priv->mm.active_list, list) {
                 obj = obj_priv->obj;
                 if (obj->read_domains & I915_GEM_DOMAIN_COMMAND) {
-                    ret = i915_gem_object_get_pages(obj);
+                    ret = i915_gem_object_get_pages(obj, 0);
                     if (ret) {
                             DRM_ERROR("Failed to get pages: %d\n", ret);
                             spin_unlock(&dev_priv->mm.active_list_lock);
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 2c1669488b5a..aaf934d96f21 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -872,7 +872,7 @@ int i915_gem_attach_phys_object(struct drm_device *dev,
 void i915_gem_detach_phys_object(struct drm_device *dev,
                                  struct drm_gem_object *obj);
 void i915_gem_free_all_phys_object(struct drm_device *dev);
-int i915_gem_object_get_pages(struct drm_gem_object *obj);
+int i915_gem_object_get_pages(struct drm_gem_object *obj, gfp_t gfpmask);
 void i915_gem_object_put_pages(struct drm_gem_object *obj);
 void i915_gem_release(struct drm_device * dev, struct drm_file *file_priv);
 void i915_gem_object_flush_write_domain(struct drm_gem_object *obj);
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 0c67924ca80c..dda787aafcc6 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -277,7 +277,7 @@ i915_gem_shmem_pread_fast(struct drm_device *dev, struct drm_gem_object *obj,
 
         mutex_lock(&dev->struct_mutex);
 
-        ret = i915_gem_object_get_pages(obj);
+        ret = i915_gem_object_get_pages(obj, 0);
         if (ret != 0)
                 goto fail_unlock;
 
@@ -321,40 +321,24 @@ fail_unlock:
         return ret;
 }
 
-static inline gfp_t
-i915_gem_object_get_page_gfp_mask (struct drm_gem_object *obj)
-{
-        return mapping_gfp_mask(obj->filp->f_path.dentry->d_inode->i_mapping);
-}
-
-static inline void
-i915_gem_object_set_page_gfp_mask (struct drm_gem_object *obj, gfp_t gfp)
-{
-        mapping_set_gfp_mask(obj->filp->f_path.dentry->d_inode->i_mapping, gfp);
-}
-
 static int
 i915_gem_object_get_pages_or_evict(struct drm_gem_object *obj)
 {
         int ret;
 
-        ret = i915_gem_object_get_pages(obj);
+        ret = i915_gem_object_get_pages(obj, __GFP_NORETRY | __GFP_NOWARN);
 
         /* If we've insufficient memory to map in the pages, attempt
          * to make some space by throwing out some old buffers.
          */
         if (ret == -ENOMEM) {
                 struct drm_device *dev = obj->dev;
-                gfp_t gfp;
 
                 ret = i915_gem_evict_something(dev, obj->size);
                 if (ret)
                         return ret;
 
-                gfp = i915_gem_object_get_page_gfp_mask(obj);
-                i915_gem_object_set_page_gfp_mask(obj, gfp & ~__GFP_NORETRY);
-                ret = i915_gem_object_get_pages(obj);
-                i915_gem_object_set_page_gfp_mask (obj, gfp);
+                ret = i915_gem_object_get_pages(obj, 0);
         }
 
         return ret;
@@ -790,7 +774,7 @@ i915_gem_shmem_pwrite_fast(struct drm_device *dev, struct drm_gem_object *obj,
 
         mutex_lock(&dev->struct_mutex);
 
-        ret = i915_gem_object_get_pages(obj);
+        ret = i915_gem_object_get_pages(obj, 0);
         if (ret != 0)
                 goto fail_unlock;
 
@@ -2230,7 +2214,8 @@ i915_gem_evict_something(struct drm_device *dev, int min_size)
 }
 
 int
-i915_gem_object_get_pages(struct drm_gem_object *obj)
+i915_gem_object_get_pages(struct drm_gem_object *obj,
+                          gfp_t gfpmask)
 {
         struct drm_i915_gem_object *obj_priv = obj->driver_private;
         int page_count, i;
@@ -2256,7 +2241,10 @@ i915_gem_object_get_pages(struct drm_gem_object *obj)
         inode = obj->filp->f_path.dentry->d_inode;
         mapping = inode->i_mapping;
         for (i = 0; i < page_count; i++) {
-                page = read_mapping_page(mapping, i, NULL);
+                page = read_cache_page_gfp(mapping, i,
+                                           mapping_gfp_mask (mapping) |
+                                           __GFP_COLD |
+                                           gfpmask);
                 if (IS_ERR(page)) {
                         ret = PTR_ERR(page);
                         i915_gem_object_put_pages(obj);
@@ -2579,7 +2567,7 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
         drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_gem_object *obj_priv = obj->driver_private;
         struct drm_mm_node *free_space;
-        bool retry_alloc = false;
+        gfp_t gfpmask =  __GFP_NORETRY | __GFP_NOWARN;
         int ret;
 
         if (obj_priv->madv != I915_MADV_WILLNEED) {
@@ -2623,15 +2611,7 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
         DRM_INFO("Binding object of size %zd at 0x%08x\n",
                  obj->size, obj_priv->gtt_offset);
 #endif
-        if (retry_alloc) {
-                i915_gem_object_set_page_gfp_mask (obj,
-                                                   i915_gem_object_get_page_gfp_mask (obj) & ~__GFP_NORETRY);
-        }
-        ret = i915_gem_object_get_pages(obj);
-        if (retry_alloc) {
-                i915_gem_object_set_page_gfp_mask (obj,
-                                                   i915_gem_object_get_page_gfp_mask (obj) | __GFP_NORETRY);
-        }
+        ret = i915_gem_object_get_pages(obj, gfpmask);
         if (ret) {
                 drm_mm_put_block(obj_priv->gtt_space);
                 obj_priv->gtt_space = NULL;
@@ -2641,9 +2621,9 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
                         ret = i915_gem_evict_something(dev, obj->size);
                         if (ret) {
                                 /* now try to shrink everyone else */
-                                if (! retry_alloc) {
-                                    retry_alloc = true;
-                                    goto search_free;
+                                if (gfpmask) {
+                                        gfpmask = 0;
+                                        goto search_free;
                                 }
 
                                 return ret;
@@ -4946,7 +4926,7 @@ void i915_gem_detach_phys_object(struct drm_device *dev,
         if (!obj_priv->phys_obj)
                 return;
 
-        ret = i915_gem_object_get_pages(obj);
+        ret = i915_gem_object_get_pages(obj, 0);
         if (ret)
                 goto out;
 
@@ -5004,7 +4984,7 @@ i915_gem_attach_phys_object(struct drm_device *dev,
         obj_priv->phys_obj = dev_priv->mm.phys_objs[id - 1];
         obj_priv->phys_obj->cur_obj = obj;
 
-        ret = i915_gem_object_get_pages(obj);
+        ret = i915_gem_object_get_pages(obj, 0);
         if (ret) {
                 DRM_ERROR("failed to get page list\n");
                 goto out;
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.c b/drivers/gpu/drm/nouveau/nouveau_bios.c
index ba143972769f..d7f8d8b4a4b8 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.c
@@ -310,63 +310,22 @@ valid_reg(struct nvbios *bios, uint32_t reg)
         struct drm_device *dev = bios->dev;
 
         /* C51 has misaligned regs on purpose. Marvellous */
-        if (reg & 0x2 || (reg & 0x1 && dev_priv->VBIOS.pub.chip_version != 0x51)) {
-                NV_ERROR(dev, "========== misaligned reg 0x%08X ==========\n",
-                         reg);
-                return 0;
-        }
-        /*
-         * Warn on C51 regs that have not been verified accessible in
-         * mmiotracing
-         */
+        if (reg & 0x2 ||
+            (reg & 0x1 && dev_priv->VBIOS.pub.chip_version != 0x51))
+                NV_ERROR(dev, "======= misaligned reg 0x%08X =======\n", reg);
+
+        /* warn on C51 regs that haven't been verified accessible in tracing */
         if (reg & 0x1 && dev_priv->VBIOS.pub.chip_version == 0x51 &&
             reg != 0x130d && reg != 0x1311 && reg != 0x60081d)
                 NV_WARN(dev, "=== C51 misaligned reg 0x%08X not verified ===\n",
                         reg);
 
-        /* Trust the init scripts on G80 */
-        if (dev_priv->card_type >= NV_50)
-                return 1;
-
-        #define WITHIN(x, y, z) ((x >= y) && (x < y + z))
-        if (WITHIN(reg, NV_PMC_OFFSET, NV_PMC_SIZE))
-                return 1;
-        if (WITHIN(reg, NV_PBUS_OFFSET, NV_PBUS_SIZE))
-                return 1;
-        if (WITHIN(reg, NV_PFIFO_OFFSET, NV_PFIFO_SIZE))
-                return 1;
-        if (dev_priv->VBIOS.pub.chip_version >= 0x30 &&
-            (WITHIN(reg, 0x4000, 0x600) || reg == 0x00004600))
-                return 1;
-        if (dev_priv->VBIOS.pub.chip_version >= 0x40 &&
-                                                WITHIN(reg, 0xc000, 0x48))
-                return 1;
-        if (dev_priv->VBIOS.pub.chip_version >= 0x17 && reg == 0x0000d204)
-                return 1;
-        if (dev_priv->VBIOS.pub.chip_version >= 0x40) {
-                if (reg == 0x00011014 || reg == 0x00020328)
-                        return 1;
-                if (WITHIN(reg, 0x88000, NV_PBUS_SIZE)) /* new PBUS */
-                        return 1;
+        if (reg >= (8*1024*1024)) {
+                NV_ERROR(dev, "=== reg 0x%08x out of mapped bounds ===\n", reg);
+                return 0;
         }
-        if (WITHIN(reg, NV_PFB_OFFSET, NV_PFB_SIZE))
-                return 1;
-        if (WITHIN(reg, NV_PEXTDEV_OFFSET, NV_PEXTDEV_SIZE))
-                return 1;
-        if (WITHIN(reg, NV_PCRTC0_OFFSET, NV_PCRTC0_SIZE * 2))
-                return 1;
-        if (WITHIN(reg, NV_PRAMDAC0_OFFSET, NV_PRAMDAC0_SIZE * 2))
-                return 1;
-        if (dev_priv->VBIOS.pub.chip_version >= 0x17 && reg == 0x0070fff0)
-                return 1;
-        if (dev_priv->VBIOS.pub.chip_version == 0x51 &&
-                                WITHIN(reg, NV_PRAMIN_OFFSET, NV_PRAMIN_SIZE))
-                return 1;
-        #undef WITHIN
 
-        NV_ERROR(dev, "========== unknown reg 0x%08X ==========\n", reg);
-
-        return 0;
+        return 1;
 }
 
 static bool
@@ -3196,16 +3155,25 @@ static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_entr
         }
 #ifdef __powerpc__
         /* Powerbook specific quirks */
-        if (script == LVDS_RESET && ((dev->pci_device & 0xffff) == 0x0179 || (dev->pci_device & 0xffff) == 0x0329))
-                nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
-        if ((dev->pci_device & 0xffff) == 0x0179 || (dev->pci_device & 0xffff) == 0x0189 || (dev->pci_device & 0xffff) == 0x0329) {
-                if (script == LVDS_PANEL_ON) {
-                        bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL, bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL) | (1 << 31));
-                        bios_wr32(bios, NV_PCRTC_GPIO_EXT, bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1);
-                }
-                if (script == LVDS_PANEL_OFF) {
-                        bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL, bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL) & ~(1 << 31));
-                        bios_wr32(bios, NV_PCRTC_GPIO_EXT, bios_rd32(bios, NV_PCRTC_GPIO_EXT) & ~3);
+        if ((dev->pci_device & 0xffff) == 0x0179 ||
+            (dev->pci_device & 0xffff) == 0x0189 ||
+            (dev->pci_device & 0xffff) == 0x0329) {
+                if (script == LVDS_RESET) {
+                        nv_write_tmds(dev, dcbent->or, 0, 0x02, 0x72);
+
+                } else if (script == LVDS_PANEL_ON) {
+                        bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
+                                  bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
+                                  | (1 << 31));
+                        bios_wr32(bios, NV_PCRTC_GPIO_EXT,
+                                  bios_rd32(bios, NV_PCRTC_GPIO_EXT) | 1);
+
+                } else if (script == LVDS_PANEL_OFF) {
+                        bios_wr32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL,
+                                  bios_rd32(bios, NV_PBUS_DEBUG_DUALHEAD_CTL)
+                                  & ~(1 << 31));
+                        bios_wr32(bios, NV_PCRTC_GPIO_EXT,
+                                  bios_rd32(bios, NV_PCRTC_GPIO_EXT) & ~3);
                 }
         }
 #endif
@@ -5434,52 +5402,49 @@ static bool
 parse_dcb15_entry(struct drm_device *dev, struct parsed_dcb *dcb,
                   uint32_t conn, uint32_t conf, struct dcb_entry *entry)
 {
-        if (conn != 0xf0003f00 && conn != 0xf2247f10 && conn != 0xf2204001 &&
-            conn != 0xf2204301 && conn != 0xf2204311 && conn != 0xf2208001 &&
-            conn != 0xf2244001 && conn != 0xf2244301 && conn != 0xf2244311 &&
-            conn != 0xf4204011 && conn != 0xf4208011 && conn != 0xf4248011 &&
-            conn != 0xf2045ff2 && conn != 0xf2045f14 && conn != 0xf207df14 &&
-            conn != 0xf2205004 && conn != 0xf2209004) {
-                NV_ERROR(dev, "Unknown DCB 1.5 entry, please report\n");
-
-                /* cause output setting to fail for !TV, so message is seen */
-                if ((conn & 0xf) != 0x1)
-                        dcb->entries = 0;
-
-                return false;
-        }
-        /* most of the below is a "best guess" atm */
-        entry->type = conn & 0xf;
-        if (entry->type == 2)
-                /* another way of specifying straps based lvds... */
+        switch (conn & 0x0000000f) {
+        case 0:
+                entry->type = OUTPUT_ANALOG;
+                break;
+        case 1:
+                entry->type = OUTPUT_TV;
+                break;
+        case 2:
+        case 3:
                 entry->type = OUTPUT_LVDS;
-        if (entry->type == 4) { /* digital */
-                if (conn & 0x10)
-                        entry->type = OUTPUT_LVDS;
-                else
+                break;
+        case 4:
+                switch ((conn & 0x000000f0) >> 4) {
+                case 0:
                         entry->type = OUTPUT_TMDS;
+                        break;
+                case 1:
+                        entry->type = OUTPUT_LVDS;
+                        break;
+                default:
+                        NV_ERROR(dev, "Unknown DCB subtype 4/%d\n",
+                                 (conn & 0x000000f0) >> 4);
+                        return false;
+                }
+                break;
+        default:
+                NV_ERROR(dev, "Unknown DCB type %d\n", conn & 0x0000000f);
+                return false;
         }
-        /* what's in bits 5-13? could be some encoder maker thing, in tv case */
-        entry->i2c_index = (conn >> 14) & 0xf;
-        /* raw heads field is in range 0-1, so move to 1-2 */
-        entry->heads = ((conn >> 18) & 0x7) + 1;
-        entry->location = (conn >> 21) & 0xf;
-        /* unused: entry->bus = (conn >> 25) & 0x7; */
-        /* set or to be same as heads -- hopefully safe enough */
-        entry->or = entry->heads;
+
+        entry->i2c_index = (conn & 0x0003c000) >> 14;
+        entry->heads = ((conn & 0x001c0000) >> 18) + 1;
+        entry->or = entry->heads; /* same as heads, hopefully safe enough */
+        entry->location = (conn & 0x01e00000) >> 21;
+        entry->bus = (conn & 0x0e000000) >> 25;
         entry->duallink_possible = false;
 
         switch (entry->type) {
         case OUTPUT_ANALOG:
                 entry->crtconf.maxfreq = (conf & 0xffff) * 10;
                 break;
-        case OUTPUT_LVDS:
-                /*
-                 * This is probably buried in conn's unknown bits.
-                 * This will upset EDID-ful models, if they exist
-                 */
-                entry->lvdsconf.use_straps_for_mode = true;
-                entry->lvdsconf.use_power_scripts = true;
+        case OUTPUT_TV:
+                entry->tvconf.has_component_output = false;
                 break;
         case OUTPUT_TMDS:
                 /*
@@ -5488,8 +5453,12 @@ parse_dcb15_entry(struct drm_device *dev, struct parsed_dcb *dcb,
                  */
                 fabricate_vga_output(dcb, entry->i2c_index, entry->heads);
                 break;
-        case OUTPUT_TV:
-                entry->tvconf.has_component_output = false;
+        case OUTPUT_LVDS:
+                if ((conn & 0x00003f00) != 0x10)
+                        entry->lvdsconf.use_straps_for_mode = true;
+                entry->lvdsconf.use_power_scripts = true;
+                break;
+        default:
                 break;
         }
 
@@ -5564,11 +5533,13 @@ void merge_like_dcb_entries(struct drm_device *dev, struct parsed_dcb *dcb)
         dcb->entries = newentries;
 }
 
-static int parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool twoHeads)
+static int
+parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool twoHeads)
 {
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct bios_parsed_dcb *bdcb = &bios->bdcb;
         struct parsed_dcb *dcb;
-        uint16_t dcbptr, i2ctabptr = 0;
+        uint16_t dcbptr = 0, i2ctabptr = 0;
         uint8_t *dcbtable;
         uint8_t headerlen = 0x4, entries = DCB_MAX_NUM_ENTRIES;
         bool configblock = true;
@@ -5579,16 +5550,18 @@ static int parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool two
         dcb->entries = 0;
 
         /* get the offset from 0x36 */
-        dcbptr = ROM16(bios->data[0x36]);
+        if (dev_priv->card_type > NV_04) {
+                dcbptr = ROM16(bios->data[0x36]);
+                if (dcbptr == 0x0000)
+                        NV_WARN(dev, "No output data (DCB) found in BIOS\n");
+        }
 
+        /* this situation likely means a really old card, pre DCB */
         if (dcbptr == 0x0) {
-                NV_WARN(dev, "No output data (DCB) found in BIOS, "
-                               "assuming a CRT output exists\n");
-                /* this situation likely means a really old card, pre DCB */
+                NV_INFO(dev, "Assuming a CRT output exists\n");
                 fabricate_vga_output(dcb, LEGACY_I2C_CRT, 1);
 
-                if (nv04_tv_identify(dev,
-                                     bios->legacy.i2c_indices.tv) >= 0)
+                if (nv04_tv_identify(dev, bios->legacy.i2c_indices.tv) >= 0)
                         fabricate_tv_output(dcb, twoHeads);
 
                 return 0;
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.c b/drivers/gpu/drm/nouveau/nouveau_bo.c
index e342a418d434..db0ed4c13f98 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bo.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bo.c
@@ -469,6 +469,8 @@ nouveau_bo_move_accel_cleanup(struct nouveau_channel *chan,
 
         ret = ttm_bo_move_accel_cleanup(&nvbo->bo, fence, NULL,
                                         evict, no_wait, new_mem);
+        if (nvbo->channel && nvbo->channel != chan)
+                ret = nouveau_fence_wait(fence, NULL, false, false);
         nouveau_fence_unref((void *)&fence);
         return ret;
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index 5a10deb8bdbd..7e6d673f3a23 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
@@ -24,9 +24,12 @@
  *
  */
 
+#include <acpi/button.h>
+
 #include "drmP.h"
 #include "drm_edid.h"
 #include "drm_crtc_helper.h"
+
 #include "nouveau_reg.h"
 #include "nouveau_drv.h"
 #include "nouveau_encoder.h"
@@ -83,14 +86,16 @@ nouveau_encoder_connector_get(struct nouveau_encoder *encoder)
 static void
 nouveau_connector_destroy(struct drm_connector *drm_connector)
 {
-        struct nouveau_connector *connector = nouveau_connector(drm_connector);
-        struct drm_device *dev = connector->base.dev;
+        struct nouveau_connector *nv_connector =
+                nouveau_connector(drm_connector);
+        struct drm_device *dev = nv_connector->base.dev;
 
         NV_DEBUG_KMS(dev, "\n");
 
-        if (!connector)
+        if (!nv_connector)
                 return;
 
+        kfree(nv_connector->edid);
         drm_sysfs_connector_remove(drm_connector);
         drm_connector_cleanup(drm_connector);
         kfree(drm_connector);
@@ -233,10 +238,21 @@ nouveau_connector_detect(struct drm_connector *connector)
         if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
                 nv_encoder = find_encoder_by_type(connector, OUTPUT_LVDS);
         if (nv_encoder && nv_connector->native_mode) {
+#ifdef CONFIG_ACPI
+                if (!nouveau_ignorelid && !acpi_lid_open())
+                        return connector_status_disconnected;
+#endif
                 nouveau_connector_set_encoder(connector, nv_encoder);
                 return connector_status_connected;
         }
 
+        /* Cleanup the previous EDID block. */
+        if (nv_connector->edid) {
+                drm_mode_connector_update_edid_property(connector, NULL);
+                kfree(nv_connector->edid);
+                nv_connector->edid = NULL;
+        }
+
         i2c = nouveau_connector_ddc_detect(connector, &nv_encoder);
         if (i2c) {
                 nouveau_connector_ddc_prepare(connector, &flags);
@@ -247,7 +263,7 @@ nouveau_connector_detect(struct drm_connector *connector)
                 if (!nv_connector->edid) {
                         NV_ERROR(dev, "DDC responded, but no EDID for %s\n",
                                  drm_get_connector_name(connector));
-                        return connector_status_disconnected;
+                        goto detect_analog;
                 }
 
                 if (nv_encoder->dcb->type == OUTPUT_DP &&
@@ -281,6 +297,7 @@ nouveau_connector_detect(struct drm_connector *connector)
                 return connector_status_connected;
         }
 
+detect_analog:
         nv_encoder = find_encoder_by_type(connector, OUTPUT_ANALOG);
         if (!nv_encoder)
                 nv_encoder = find_encoder_by_type(connector, OUTPUT_TV);
@@ -687,8 +704,12 @@ nouveau_connector_create_lvds(struct drm_device *dev,
          */
         if (!nv_connector->edid && !nv_connector->native_mode &&
             !dev_priv->VBIOS.pub.fp_no_ddc) {
-                nv_connector->edid =
+                struct edid *edid =
                         (struct edid *)nouveau_bios_embedded_edid(dev);
+                if (edid) {
+                        nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
+                        *(nv_connector->edid) = *edid;
+                }
         }
 
         if (!nv_connector->edid)
diff --git a/drivers/gpu/drm/nouveau/nouveau_dma.c b/drivers/gpu/drm/nouveau/nouveau_dma.c
index 7afbe8b40d51..50d9e67745af 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dma.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dma.c
@@ -126,47 +126,52 @@ OUT_RINGp(struct nouveau_channel *chan, const void *data, unsigned nr_dwords)
         chan->dma.cur += nr_dwords;
 }
 
-static inline bool
-READ_GET(struct nouveau_channel *chan, uint32_t *get)
+/* Fetch and adjust GPU GET pointer
+ *
+ * Returns:
+ *  value >= 0, the adjusted GET pointer
+ *  -EINVAL if GET pointer currently outside main push buffer
+ *  -EBUSY if timeout exceeded
+ */
+static inline int
+READ_GET(struct nouveau_channel *chan, uint32_t *prev_get, uint32_t *timeout)
 {
         uint32_t val;
 
         val = nvchan_rd32(chan, chan->user_get);
-        if (val < chan->pushbuf_base ||
-            val > chan->pushbuf_base + (chan->dma.max << 2)) {
-                /* meaningless to dma_wait() except to know whether the
-                 * GPU has stalled or not
-                 */
-                *get = val;
-                return false;
+
+        /* reset counter as long as GET is still advancing, this is
+         * to avoid misdetecting a GPU lockup if the GPU happens to
+         * just be processing an operation that takes a long time
+         */
+        if (val != *prev_get) {
+                *prev_get = val;
+                *timeout = 0;
+        }
+
+        if ((++*timeout & 0xff) == 0) {
+                DRM_UDELAY(1);
+                if (*timeout > 100000)
+                        return -EBUSY;
         }
 
-        *get = (val - chan->pushbuf_base) >> 2;
-        return true;
+        if (val < chan->pushbuf_base ||
+            val > chan->pushbuf_base + (chan->dma.max << 2))
+                return -EINVAL;
+
+        return (val - chan->pushbuf_base) >> 2;
 }
 
 int
 nouveau_dma_wait(struct nouveau_channel *chan, int size)
 {
-        uint32_t get, prev_get = 0, cnt = 0;
-        bool get_valid;
+        uint32_t prev_get = 0, cnt = 0;
+        int get;
 
         while (chan->dma.free < size) {
-                /* reset counter as long as GET is still advancing, this is
-                 * to avoid misdetecting a GPU lockup if the GPU happens to
-                 * just be processing an operation that takes a long time
-                 */
-                get_valid = READ_GET(chan, &get);
-                if (get != prev_get) {
-                        prev_get = get;
-                        cnt = 0;
-                }
-
-                if ((++cnt & 0xff) == 0) {
-                        DRM_UDELAY(1);
-                        if (cnt > 100000)
-                                return -EBUSY;
-                }
+                get = READ_GET(chan, &prev_get, &cnt);
+                if (unlikely(get == -EBUSY))
+                        return -EBUSY;
 
                 /* loop until we have a usable GET pointer.  the value
                  * we read from the GPU may be outside the main ring if
@@ -177,7 +182,7 @@ nouveau_dma_wait(struct nouveau_channel *chan, int size)
                  * from the SKIPS area, so the code below doesn't have to deal
                  * with some fun corner cases.
                  */
-                if (!get_valid || get < NOUVEAU_DMA_SKIPS)
+                if (unlikely(get == -EINVAL) || get < NOUVEAU_DMA_SKIPS)
                         continue;
 
                 if (get <= chan->dma.cur) {
@@ -203,6 +208,19 @@ nouveau_dma_wait(struct nouveau_channel *chan, int size)
                          * after processing the currently pending commands.
                          */
                         OUT_RING(chan, chan->pushbuf_base | 0x20000000);
+
+                        /* wait for GET to depart from the skips area.
+                         * prevents writing GET==PUT and causing a race
+                         * condition that causes us to think the GPU is
+                         * idle when it's not.
+                         */
+                        do {
+                                get = READ_GET(chan, &prev_get, &cnt);
+                                if (unlikely(get == -EBUSY))
+                                        return -EBUSY;
+                                if (unlikely(get == -EINVAL))
+                                        continue;
+                        } while (get <= NOUVEAU_DMA_SKIPS);
                         WRITE_PUT(NOUVEAU_DMA_SKIPS);
 
                         /* we're now submitting commands at the start of
diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index 9e2926c48579..dd4937224220 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dp.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dp.c
@@ -490,7 +490,8 @@ nouveau_dp_auxch(struct nouveau_i2c_chan *auxch, int cmd, int addr,
                 if (!nv_wait(NV50_AUXCH_CTRL(index), 0x00010000, 0x00000000)) {
                         NV_ERROR(dev, "expected bit 16 == 0, got 0x%08x\n",
                                  nv_rd32(dev, NV50_AUXCH_CTRL(index)));
-                        return -EBUSY;
+                        ret = -EBUSY;
+                        goto out;
                 }
 
                 udelay(400);
@@ -501,6 +502,11 @@ nouveau_dp_auxch(struct nouveau_i2c_chan *auxch, int cmd, int addr,
                         break;
         }
 
+        if ((stat & NV50_AUXCH_STAT_COUNT) != data_nr) {
+                ret = -EREMOTEIO;
+                goto out;
+        }
+
         if (cmd & 1) {
                 for (i = 0; i < 4; i++) {
                         data32[i] = nv_rd32(dev, NV50_AUXCH_DATA_IN(index, i));
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.c b/drivers/gpu/drm/nouveau/nouveau_drv.c
index 06eb993e0883..343ab7f17ccc 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drv.c
+++ b/drivers/gpu/drm/nouveau/nouveau_drv.c
@@ -71,6 +71,10 @@ MODULE_PARM_DESC(uscript_tmds, "TMDS output script table ID (>=GeForce 8)");
 int nouveau_uscript_tmds = -1;
 module_param_named(uscript_tmds, nouveau_uscript_tmds, int, 0400);
 
+MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
+int nouveau_ignorelid = 0;
+module_param_named(ignorelid, nouveau_ignorelid, int, 0400);
+
 MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
                  "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, NTSC-M, NTSC-J,\n"
                  "\t\t\thd480i, hd480p, hd576i, hd576p, hd720p, hd1080i.\n"
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h
index 026419fe8791..6b9690418bc7 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drv.h
+++ b/drivers/gpu/drm/nouveau/nouveau_drv.h
@@ -509,6 +509,8 @@ struct drm_nouveau_private {
         void __iomem *ramin;
         uint32_t ramin_size;
 
+        struct nouveau_bo *vga_ram;
+
         struct workqueue_struct *wq;
         struct work_struct irq_work;
 
@@ -675,6 +677,7 @@ extern char *nouveau_tv_norm;
 extern int nouveau_reg_debug;
 extern char *nouveau_vbios;
 extern int nouveau_ctxfw;
+extern int nouveau_ignorelid;
 
 /* nouveau_state.c */
 extern void nouveau_preclose(struct drm_device *dev, struct drm_file *);
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c
index 2009db2426c3..6ac804b0c9f9 100644
--- a/drivers/gpu/drm/nouveau/nouveau_gem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_gem.c
@@ -321,6 +321,7 @@ retry:
                 else {
                         NV_ERROR(dev, "invalid valid domains: 0x%08x\n",
                                  b->valid_domains);
+                        list_add_tail(&nvbo->entry, &op->both_list);
                         validate_fini(op, NULL);
                         return -EINVAL;
                 }
@@ -466,13 +467,14 @@ u_memcpya(uint64_t user, unsigned nmemb, unsigned size)
 static int
 nouveau_gem_pushbuf_reloc_apply(struct nouveau_channel *chan, int nr_bo,
                                 struct drm_nouveau_gem_pushbuf_bo *bo,
-                                int nr_relocs, uint64_t ptr_relocs,
-                                int nr_dwords, int first_dword,
+                                unsigned nr_relocs, uint64_t ptr_relocs,
+                                unsigned nr_dwords, unsigned first_dword,
                                 uint32_t *pushbuf, bool is_iomem)
 {
         struct drm_nouveau_gem_pushbuf_reloc *reloc = NULL;
         struct drm_device *dev = chan->dev;
-        int ret = 0, i;
+        int ret = 0;
+        unsigned i;
 
         reloc = u_memcpya(ptr_relocs, nr_relocs, sizeof(*reloc));
         if (IS_ERR(reloc))
@@ -667,6 +669,18 @@ nouveau_gem_ioctl_pushbuf_call(struct drm_device *dev, void *data,
         }
         pbbo = nouveau_gem_object(gem);
 
+        if ((req->offset & 3) || req->nr_dwords < 2 ||
+            (unsigned long)req->offset > (unsigned long)pbbo->bo.mem.size ||
+            (unsigned long)req->nr_dwords >
+             ((unsigned long)(pbbo->bo.mem.size - req->offset ) >> 2)) {
+                NV_ERROR(dev, "pb call misaligned or out of bounds: "
+                              "%d + %d * 4 > %ld\n",
+                         req->offset, req->nr_dwords, pbbo->bo.mem.size);
+                ret = -EINVAL;
+                drm_gem_object_unreference(gem);
+                goto out;
+        }
+
         ret = ttm_bo_reserve(&pbbo->bo, false, false, true,
                              chan->fence.sequence);
         if (ret) {
diff --git a/drivers/gpu/drm/nouveau/nouveau_irq.c b/drivers/gpu/drm/nouveau/nouveau_irq.c
index 919a619ca7fa..3b9bad66162a 100644
--- a/drivers/gpu/drm/nouveau/nouveau_irq.c
+++ b/drivers/gpu/drm/nouveau/nouveau_irq.c
@@ -483,6 +483,13 @@ nouveau_pgraph_intr_error(struct drm_device *dev, uint32_t nsource)
         if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
                 if (nouveau_pgraph_intr_swmthd(dev, &trap))
                         unhandled = 1;
+        } else if (nsource & NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION) {
+                uint32_t v = nv_rd32(dev, 0x402000);
+                nv_wr32(dev, 0x402000, v);
+
+                /* dump the error anyway for now: it's useful for
+                   Gallium development */
+                unhandled = 1;
         } else {
                 unhandled = 1;
         }
diff --git a/drivers/gpu/drm/nouveau/nouveau_mem.c b/drivers/gpu/drm/nouveau/nouveau_mem.c
index fb9bdd6edf1f..8f3a12f614ed 100644
--- a/drivers/gpu/drm/nouveau/nouveau_mem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_mem.c
@@ -383,9 +383,8 @@ void nouveau_mem_close(struct drm_device *dev)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
 
-        if (dev_priv->ttm.bdev.man[TTM_PL_PRIV0].has_type)
-                ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_PRIV0);
-        ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
+        nouveau_bo_unpin(dev_priv->vga_ram);
+        nouveau_bo_ref(NULL, &dev_priv->vga_ram);
 
         ttm_bo_device_release(&dev_priv->ttm.bdev);
 
@@ -622,6 +621,15 @@ nouveau_mem_init(struct drm_device *dev)
                 return ret;
         }
 
+        ret = nouveau_bo_new(dev, NULL, 256*1024, 0, TTM_PL_FLAG_VRAM,
+                             0, 0, true, true, &dev_priv->vga_ram);
+        if (ret == 0)
+                ret = nouveau_bo_pin(dev_priv->vga_ram, TTM_PL_FLAG_VRAM);
+        if (ret) {
+                NV_WARN(dev, "failed to reserve VGA memory\n");
+                nouveau_bo_ref(NULL, &dev_priv->vga_ram);
+        }
+
         /* GART */
 #if !defined(__powerpc__) && !defined(__ia64__)
         if (drm_device_is_agp(dev) && dev->agp) {
@@ -653,6 +661,7 @@ nouveau_mem_init(struct drm_device *dev)
         dev_priv->fb_mtrr = drm_mtrr_add(drm_get_resource_start(dev, 1),
                                          drm_get_resource_len(dev, 1),
                                          DRM_MTRR_WC);
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_state.c b/drivers/gpu/drm/nouveau/nouveau_state.c
index 09b9a46dfc0e..f2d0187ba152 100644
--- a/drivers/gpu/drm/nouveau/nouveau_state.c
+++ b/drivers/gpu/drm/nouveau/nouveau_state.c
@@ -525,6 +525,7 @@ static void nouveau_card_takedown(struct drm_device *dev)
                 engine->mc.takedown(dev);
 
                 mutex_lock(&dev->struct_mutex);
+                ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
                 ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_TT);
                 mutex_unlock(&dev->struct_mutex);
                 nouveau_sgdma_takedown(dev);
diff --git a/drivers/gpu/drm/nouveau/nv04_instmem.c b/drivers/gpu/drm/nouveau/nv04_instmem.c
index a20c206625a2..a3b9563a6f60 100644
--- a/drivers/gpu/drm/nouveau/nv04_instmem.c
+++ b/drivers/gpu/drm/nouveau/nv04_instmem.c
@@ -30,7 +30,7 @@ nv04_instmem_determine_amount(struct drm_device *dev)
                  * of vram.  For now, only reserve a small piece until we know
                  * more about what each chipset requires.
                  */
-                switch (dev_priv->chipset & 0xf0) {
+                switch (dev_priv->chipset) {
                 case 0x40:
                 case 0x47:
                 case 0x49:
diff --git a/drivers/gpu/drm/nouveau/nv50_crtc.c b/drivers/gpu/drm/nouveau/nv50_crtc.c
index 118d3285fd8c..40b7360841f8 100644
--- a/drivers/gpu/drm/nouveau/nv50_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv50_crtc.c
@@ -432,6 +432,7 @@ nv50_crtc_prepare(struct drm_crtc *crtc)
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_device *dev = crtc->dev;
         struct drm_encoder *encoder;
+        uint32_t dac = 0, sor = 0;
 
         NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
 
@@ -439,9 +440,28 @@ nv50_crtc_prepare(struct drm_crtc *crtc)
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 
-                if (drm_helper_encoder_in_use(encoder))
+                if (!drm_helper_encoder_in_use(encoder))
                         continue;
 
+                if (nv_encoder->dcb->type == OUTPUT_ANALOG ||
+                    nv_encoder->dcb->type == OUTPUT_TV)
+                        dac |= (1 << nv_encoder->or);
+                else
+                        sor |= (1 << nv_encoder->or);
+        }
+
+        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+                struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+
+                if (nv_encoder->dcb->type == OUTPUT_ANALOG ||
+                    nv_encoder->dcb->type == OUTPUT_TV) {
+                        if (dac & (1 << nv_encoder->or))
+                                continue;
+                } else {
+                        if (sor & (1 << nv_encoder->or))
+                                continue;
+                }
+
                 nv_encoder->disconnect(nv_encoder);
         }
 
diff --git a/drivers/gpu/drm/nouveau/nv50_fifo.c b/drivers/gpu/drm/nouveau/nv50_fifo.c
index 39caf167587d..32b244bcb482 100644
--- a/drivers/gpu/drm/nouveau/nv50_fifo.c
+++ b/drivers/gpu/drm/nouveau/nv50_fifo.c
@@ -272,7 +272,7 @@ nv50_fifo_create_context(struct nouveau_channel *chan)
                         return ret;
                 ramfc = chan->ramfc->gpuobj;
 
-                ret = nouveau_gpuobj_new_ref(dev, chan, NULL, 0, 4096, 256,
+                ret = nouveau_gpuobj_new_ref(dev, chan, NULL, 0, 4096, 1024,
                                              0, &chan->cache);
                 if (ret)
                         return ret;
diff --git a/drivers/gpu/drm/nouveau/nv50_graph.c b/drivers/gpu/drm/nouveau/nv50_graph.c
index ca79f32be44c..20319e59d368 100644
--- a/drivers/gpu/drm/nouveau/nv50_graph.c
+++ b/drivers/gpu/drm/nouveau/nv50_graph.c
@@ -84,7 +84,7 @@ nv50_graph_init_regs__nv(struct drm_device *dev)
         nv_wr32(dev, 0x400804, 0xc0000000);
         nv_wr32(dev, 0x406800, 0xc0000000);
         nv_wr32(dev, 0x400c04, 0xc0000000);
-        nv_wr32(dev, 0x401804, 0xc0000000);
+        nv_wr32(dev, 0x401800, 0xc0000000);
         nv_wr32(dev, 0x405018, 0xc0000000);
         nv_wr32(dev, 0x402000, 0xc0000000);
 
@@ -282,6 +282,7 @@ nv50_graph_unload_context(struct drm_device *dev)
                 return 0;
         inst &= NV50_PGRAPH_CTXCTL_CUR_INSTANCE;
 
+        nouveau_wait_for_idle(dev);
         nv_wr32(dev, 0x400500, fifo & ~1);
         nv_wr32(dev, 0x400784, inst);
         nv_wr32(dev, 0x400824, nv_rd32(dev, 0x400824) | 0x20);
diff --git a/drivers/gpu/drm/nouveau/nv50_sor.c b/drivers/gpu/drm/nouveau/nv50_sor.c
index e395c16d30f5..ecf1936b8224 100644
--- a/drivers/gpu/drm/nouveau/nv50_sor.c
+++ b/drivers/gpu/drm/nouveau/nv50_sor.c
@@ -90,11 +90,24 @@ nv50_sor_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct drm_encoder *enc;
         uint32_t val;
         int or = nv_encoder->or;
 
         NV_DEBUG_KMS(dev, "or %d mode %d\n", or, mode);
 
+        nv_encoder->last_dpms = mode;
+        list_for_each_entry(enc, &dev->mode_config.encoder_list, head) {
+                struct nouveau_encoder *nvenc = nouveau_encoder(enc);
+
+                if (nvenc == nv_encoder ||
+                    nvenc->dcb->or != nv_encoder->dcb->or)
+                        continue;
+
+                if (nvenc->last_dpms == DRM_MODE_DPMS_ON)
+                        return;
+        }
+
         /* wait for it to be done */
         if (!nv_wait(NV50_PDISPLAY_SOR_DPMS_CTRL(or),
                      NV50_PDISPLAY_SOR_DPMS_CTRL_PENDING, 0)) {
diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
index 388140a7e651..e3b44562d265 100644
--- a/drivers/gpu/drm/radeon/atom.c
+++ b/drivers/gpu/drm/radeon/atom.c
@@ -246,6 +246,9 @@ static uint32_t atom_get_src_int(atom_exec_context *ctx, uint8_t attr,
                 case ATOM_WS_ATTRIBUTES:
                         val = gctx->io_attr;
                         break;
+                case ATOM_WS_REGPTR:
+                        val = gctx->reg_block;
+                        break;
                 default:
                         val = ctx->ws[idx];
                 }
@@ -385,6 +388,32 @@ static uint32_t atom_get_src(atom_exec_context *ctx, uint8_t attr, int *ptr)
         return atom_get_src_int(ctx, attr, ptr, NULL, 1);
 }
 
+static uint32_t atom_get_src_direct(atom_exec_context *ctx, uint8_t align, int *ptr)
+{
+        uint32_t val = 0xCDCDCDCD;
+
+        switch (align) {
+        case ATOM_SRC_DWORD:
+                val = U32(*ptr);
+                (*ptr) += 4;
+                break;
+        case ATOM_SRC_WORD0:
+        case ATOM_SRC_WORD8:
+        case ATOM_SRC_WORD16:
+                val = U16(*ptr);
+                (*ptr) += 2;
+                break;
+        case ATOM_SRC_BYTE0:
+        case ATOM_SRC_BYTE8:
+        case ATOM_SRC_BYTE16:
+        case ATOM_SRC_BYTE24:
+                val = U8(*ptr);
+                (*ptr)++;
+                break;
+        }
+        return val;
+}
+
 static uint32_t atom_get_dst(atom_exec_context *ctx, int arg, uint8_t attr,
                              int *ptr, uint32_t *saved, int print)
 {
@@ -482,6 +511,9 @@ static void atom_put_dst(atom_exec_context *ctx, int arg, uint8_t attr,
                 case ATOM_WS_ATTRIBUTES:
                         gctx->io_attr = val;
                         break;
+                case ATOM_WS_REGPTR:
+                        gctx->reg_block = val;
+                        break;
                 default:
                         ctx->ws[idx] = val;
                 }
@@ -677,7 +709,7 @@ static void atom_op_mask(atom_exec_context *ctx, int *ptr, int arg)
         SDEBUG("   dst: ");
         dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
         SDEBUG("   src1: ");
-        src1 = atom_get_src(ctx, attr, ptr);
+        src1 = atom_get_src_direct(ctx, ((attr >> 3) & 7), ptr);
         SDEBUG("   src2: ");
         src2 = atom_get_src(ctx, attr, ptr);
         dst &= src1;
@@ -809,6 +841,38 @@ static void atom_op_setregblock(atom_exec_context *ctx, int *ptr, int arg)
         SDEBUG("   base: 0x%04X\n", ctx->ctx->reg_block);
 }
 
+static void atom_op_shift_left(atom_exec_context *ctx, int *ptr, int arg)
+{
+        uint8_t attr = U8((*ptr)++), shift;
+        uint32_t saved, dst;
+        int dptr = *ptr;
+        attr &= 0x38;
+        attr |= atom_def_dst[attr >> 3] << 6;
+        SDEBUG("   dst: ");
+        dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
+        shift = atom_get_src_direct(ctx, ATOM_SRC_BYTE0, ptr);
+        SDEBUG("   shift: %d\n", shift);
+        dst <<= shift;
+        SDEBUG("   dst: ");
+        atom_put_dst(ctx, arg, attr, &dptr, dst, saved);
+}
+
+static void atom_op_shift_right(atom_exec_context *ctx, int *ptr, int arg)
+{
+        uint8_t attr = U8((*ptr)++), shift;
+        uint32_t saved, dst;
+        int dptr = *ptr;
+        attr &= 0x38;
+        attr |= atom_def_dst[attr >> 3] << 6;
+        SDEBUG("   dst: ");
+        dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
+        shift = atom_get_src_direct(ctx, ATOM_SRC_BYTE0, ptr);
+        SDEBUG("   shift: %d\n", shift);
+        dst >>= shift;
+        SDEBUG("   dst: ");
+        atom_put_dst(ctx, arg, attr, &dptr, dst, saved);
+}
+
 static void atom_op_shl(atom_exec_context *ctx, int *ptr, int arg)
 {
         uint8_t attr = U8((*ptr)++), shift;
@@ -818,7 +882,7 @@ static void atom_op_shl(atom_exec_context *ctx, int *ptr, int arg)
         attr |= atom_def_dst[attr >> 3] << 6;
         SDEBUG("   dst: ");
         dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
-        shift = U8((*ptr)++);
+        shift = atom_get_src(ctx, attr, ptr);
         SDEBUG("   shift: %d\n", shift);
         dst <<= shift;
         SDEBUG("   dst: ");
@@ -834,7 +898,7 @@ static void atom_op_shr(atom_exec_context *ctx, int *ptr, int arg)
         attr |= atom_def_dst[attr >> 3] << 6;
         SDEBUG("   dst: ");
         dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
-        shift = U8((*ptr)++);
+        shift = atom_get_src(ctx, attr, ptr);
         SDEBUG("   shift: %d\n", shift);
         dst >>= shift;
         SDEBUG("   dst: ");
@@ -937,18 +1001,18 @@ static struct {
         atom_op_or, ATOM_ARG_FB}, {
         atom_op_or, ATOM_ARG_PLL}, {
         atom_op_or, ATOM_ARG_MC}, {
-        atom_op_shl, ATOM_ARG_REG}, {
-        atom_op_shl, ATOM_ARG_PS}, {
-        atom_op_shl, ATOM_ARG_WS}, {
-        atom_op_shl, ATOM_ARG_FB}, {
-        atom_op_shl, ATOM_ARG_PLL}, {
-        atom_op_shl, ATOM_ARG_MC}, {
-        atom_op_shr, ATOM_ARG_REG}, {
-        atom_op_shr, ATOM_ARG_PS}, {
-        atom_op_shr, ATOM_ARG_WS}, {
-        atom_op_shr, ATOM_ARG_FB}, {
-        atom_op_shr, ATOM_ARG_PLL}, {
-        atom_op_shr, ATOM_ARG_MC}, {
+        atom_op_shift_left, ATOM_ARG_REG}, {
+        atom_op_shift_left, ATOM_ARG_PS}, {
+        atom_op_shift_left, ATOM_ARG_WS}, {
+        atom_op_shift_left, ATOM_ARG_FB}, {
+        atom_op_shift_left, ATOM_ARG_PLL}, {
+        atom_op_shift_left, ATOM_ARG_MC}, {
+        atom_op_shift_right, ATOM_ARG_REG}, {
+        atom_op_shift_right, ATOM_ARG_PS}, {
+        atom_op_shift_right, ATOM_ARG_WS}, {
+        atom_op_shift_right, ATOM_ARG_FB}, {
+        atom_op_shift_right, ATOM_ARG_PLL}, {
+        atom_op_shift_right, ATOM_ARG_MC}, {
         atom_op_mul, ATOM_ARG_REG}, {
         atom_op_mul, ATOM_ARG_PS}, {
         atom_op_mul, ATOM_ARG_WS}, {
@@ -1058,8 +1122,6 @@ static void atom_execute_table_locked(struct atom_context *ctx, int index, uint3
 
         SDEBUG(">> execute %04X (len %d, WS %d, PS %d)\n", base, len, ws, ps);
 
-        /* reset reg block */
-        ctx->reg_block = 0;
         ectx.ctx = ctx;
         ectx.ps_shift = ps / 4;
         ectx.start = base;
@@ -1096,6 +1158,12 @@ static void atom_execute_table_locked(struct atom_context *ctx, int index, uint3
 void atom_execute_table(struct atom_context *ctx, int index, uint32_t * params)
 {
         mutex_lock(&ctx->mutex);
+        /* reset reg block */
+        ctx->reg_block = 0;
+        /* reset fb window */
+        ctx->fb_base = 0;
+        /* reset io mode */
+        ctx->io_mode = ATOM_IO_MM;
         atom_execute_table_locked(ctx, index, params);
         mutex_unlock(&ctx->mutex);
 }
diff --git a/drivers/gpu/drm/radeon/atom.h b/drivers/gpu/drm/radeon/atom.h
index 47fd943f6d14..bc73781423a1 100644
--- a/drivers/gpu/drm/radeon/atom.h
+++ b/drivers/gpu/drm/radeon/atom.h
@@ -91,6 +91,7 @@
 #define ATOM_WS_AND_MASK        0x45
 #define ATOM_WS_FB_WINDOW       0x46
 #define ATOM_WS_ATTRIBUTES      0x47
+#define ATOM_WS_REGPTR          0x48
 
 #define ATOM_IIO_NOP            0
 #define ATOM_IIO_START          1
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 260fcf59f00c..af464e351fbd 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -307,7 +307,6 @@ atombios_set_crtc_dtd_timing(struct drm_crtc *crtc,
         args.susModeMiscInfo.usAccess = cpu_to_le16(misc);
         args.ucCRTC = radeon_crtc->crtc_id;
 
-        printk("executing set crtc dtd timing\n");
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 }
 
@@ -347,7 +346,6 @@ static void atombios_crtc_set_timing(struct drm_crtc *crtc,
         args.susModeMiscInfo.usAccess = cpu_to_le16(misc);
         args.ucCRTC = radeon_crtc->crtc_id;
 
-        printk("executing set crtc timing\n");
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 }
 
@@ -409,59 +407,57 @@ static void atombios_set_ss(struct drm_crtc *crtc, int enable)
         }
 }
 
-void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
+union adjust_pixel_clock {
+        ADJUST_DISPLAY_PLL_PS_ALLOCATION v1;
+};
+
+static u32 atombios_adjust_pll(struct drm_crtc *crtc,
+                               struct drm_display_mode *mode,
+                               struct radeon_pll *pll)
 {
-        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;
-        uint8_t frev, crev;
-        int index;
-        SET_PIXEL_CLOCK_PS_ALLOCATION args;
-        PIXEL_CLOCK_PARAMETERS *spc1_ptr;
-        PIXEL_CLOCK_PARAMETERS_V2 *spc2_ptr;
-        PIXEL_CLOCK_PARAMETERS_V3 *spc3_ptr;
-        uint32_t pll_clock = mode->clock;
-        uint32_t adjusted_clock;
-        uint32_t ref_div = 0, fb_div = 0, frac_fb_div = 0, post_div = 0;
-        struct radeon_pll *pll;
-        int pll_flags = 0;
+        u32 adjusted_clock = mode->clock;
 
-        memset(&args, 0, sizeof(args));
+        /* reset the pll flags */
+        pll->flags = 0;
 
         if (ASIC_IS_AVIVO(rdev)) {
                 if ((rdev->family == CHIP_RS600) ||
                     (rdev->family == CHIP_RS690) ||
                     (rdev->family == CHIP_RS740))
-                        pll_flags |= (RADEON_PLL_USE_FRAC_FB_DIV |
-                                      RADEON_PLL_PREFER_CLOSEST_LOWER);
+                        pll->flags |= (RADEON_PLL_USE_FRAC_FB_DIV |
+                                       RADEON_PLL_PREFER_CLOSEST_LOWER);
 
                 if (ASIC_IS_DCE32(rdev) && mode->clock > 200000)        /* range limits??? */
-                        pll_flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
+                        pll->flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
                 else
-                        pll_flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
+                        pll->flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
         } else {
-                pll_flags |= RADEON_PLL_LEGACY;
+                pll->flags |= RADEON_PLL_LEGACY;
 
                 if (mode->clock > 200000)       /* range limits??? */
-                        pll_flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
+                        pll->flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
                 else
-                        pll_flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
+                        pll->flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
 
         }
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                 if (encoder->crtc == crtc) {
-                        if (!ASIC_IS_AVIVO(rdev)) {
-                                if (encoder->encoder_type !=
-                                    DRM_MODE_ENCODER_DAC)
-                                        pll_flags |= RADEON_PLL_NO_ODD_POST_DIV;
-                                if (encoder->encoder_type ==
-                                        DRM_MODE_ENCODER_LVDS)
-                                        pll_flags |= RADEON_PLL_USE_REF_DIV;
-                        }
                         radeon_encoder = to_radeon_encoder(encoder);
+                        if (ASIC_IS_AVIVO(rdev)) {
+                                /* DVO wants 2x pixel clock if the DVO chip is in 12 bit mode */
+                                if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1)
+                                        adjusted_clock = mode->clock * 2;
+                        } else {
+                                if (encoder->encoder_type != DRM_MODE_ENCODER_DAC)
+                                        pll->flags |= RADEON_PLL_NO_ODD_POST_DIV;
+                                if (encoder->encoder_type == DRM_MODE_ENCODER_LVDS)
+                                        pll->flags |= RADEON_PLL_USE_REF_DIV;
+                        }
                         break;
                 }
         }
@@ -471,46 +467,101 @@ void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
          * special hw requirements.
          */
         if (ASIC_IS_DCE3(rdev)) {
-                ADJUST_DISPLAY_PLL_PS_ALLOCATION adjust_pll_args;
+                union adjust_pixel_clock args;
+                struct radeon_encoder_atom_dig *dig;
+                u8 frev, crev;
+                int index;
 
-                if (!encoder)
-                        return;
-
-                memset(&adjust_pll_args, 0, sizeof(adjust_pll_args));
-                adjust_pll_args.usPixelClock = cpu_to_le16(mode->clock / 10);
-                adjust_pll_args.ucTransmitterID = radeon_encoder->encoder_id;
-                adjust_pll_args.ucEncodeMode = atombios_get_encoder_mode(encoder);
+                if (!radeon_encoder->enc_priv)
+                        return adjusted_clock;
+                dig = radeon_encoder->enc_priv;
 
                 index = GetIndexIntoMasterTable(COMMAND, AdjustDisplayPll);
-                atom_execute_table(rdev->mode_info.atom_context,
-                                   index, (uint32_t *)&adjust_pll_args);
-                adjusted_clock = le16_to_cpu(adjust_pll_args.usPixelClock) * 10;
-        } else {
-                /* DVO wants 2x pixel clock if the DVO chip is in 12 bit mode */
-                if (ASIC_IS_AVIVO(rdev) &&
-                    (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1))
-                        adjusted_clock = mode->clock * 2;
-                else
-                        adjusted_clock = mode->clock;
+                atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev,
+                                      &crev);
+
+                memset(&args, 0, sizeof(args));
+
+                switch (frev) {
+                case 1:
+                        switch (crev) {
+                        case 1:
+                        case 2:
+                                args.v1.usPixelClock = cpu_to_le16(mode->clock / 10);
+                                args.v1.ucTransmitterID = radeon_encoder->encoder_id;
+                                args.v1.ucEncodeMode = atombios_get_encoder_mode(encoder);
+
+                                atom_execute_table(rdev->mode_info.atom_context,
+                                                   index, (uint32_t *)&args);
+                                adjusted_clock = le16_to_cpu(args.v1.usPixelClock) * 10;
+                                break;
+                        default:
+                                DRM_ERROR("Unknown table version %d %d\n", frev, crev);
+                                return adjusted_clock;
+                        }
+                        break;
+                default:
+                        DRM_ERROR("Unknown table version %d %d\n", frev, crev);
+                        return adjusted_clock;
+                }
         }
+        return adjusted_clock;
+}
+
+union set_pixel_clock {
+        SET_PIXEL_CLOCK_PS_ALLOCATION base;
+        PIXEL_CLOCK_PARAMETERS v1;
+        PIXEL_CLOCK_PARAMETERS_V2 v2;
+        PIXEL_CLOCK_PARAMETERS_V3 v3;
+};
+
+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;
+        u8 frev, crev;
+        int index;
+        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;
+
+        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);
+                        break;
+                }
+        }
+
+        if (!radeon_encoder)
+                return;
 
         if (radeon_crtc->crtc_id == 0)
                 pll = &rdev->clock.p1pll;
         else
                 pll = &rdev->clock.p2pll;
 
+        /* adjust pixel clock as needed */
+        adjusted_clock = atombios_adjust_pll(crtc, mode, pll);
+
         if (ASIC_IS_AVIVO(rdev)) {
                 if (radeon_new_pll)
                         radeon_compute_pll_avivo(pll, adjusted_clock, &pll_clock,
                                                  &fb_div, &frac_fb_div,
-                                                 &ref_div, &post_div, pll_flags);
+                                                 &ref_div, &post_div);
                 else
                         radeon_compute_pll(pll, adjusted_clock, &pll_clock,
                                            &fb_div, &frac_fb_div,
-                                           &ref_div, &post_div, pll_flags);
+                                           &ref_div, &post_div);
         } else
                 radeon_compute_pll(pll, adjusted_clock, &pll_clock, &fb_div, &frac_fb_div,
-                                   &ref_div, &post_div, pll_flags);
+                                   &ref_div, &post_div);
 
         index = GetIndexIntoMasterTable(COMMAND, SetPixelClock);
         atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev,
@@ -520,45 +571,38 @@ void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
         case 1:
                 switch (crev) {
                 case 1:
-                        spc1_ptr = (PIXEL_CLOCK_PARAMETERS *) & args.sPCLKInput;
-                        spc1_ptr->usPixelClock = cpu_to_le16(mode->clock / 10);
-                        spc1_ptr->usRefDiv = cpu_to_le16(ref_div);
-                        spc1_ptr->usFbDiv = cpu_to_le16(fb_div);
-                        spc1_ptr->ucFracFbDiv = frac_fb_div;
-                        spc1_ptr->ucPostDiv = post_div;
-                        spc1_ptr->ucPpll =
+                        args.v1.usPixelClock = cpu_to_le16(mode->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->crtc_id ? ATOM_PPLL2 : ATOM_PPLL1;
-                        spc1_ptr->ucCRTC = radeon_crtc->crtc_id;
-                        spc1_ptr->ucRefDivSrc = 1;
+                        args.v1.ucCRTC = radeon_crtc->crtc_id;
+                        args.v1.ucRefDivSrc = 1;
                         break;
                 case 2:
-                        spc2_ptr =
-                            (PIXEL_CLOCK_PARAMETERS_V2 *) & args.sPCLKInput;
-                        spc2_ptr->usPixelClock = cpu_to_le16(mode->clock / 10);
-                        spc2_ptr->usRefDiv = cpu_to_le16(ref_div);
-                        spc2_ptr->usFbDiv = cpu_to_le16(fb_div);
-                        spc2_ptr->ucFracFbDiv = frac_fb_div;
-                        spc2_ptr->ucPostDiv = post_div;
-                        spc2_ptr->ucPpll =
+                        args.v2.usPixelClock = cpu_to_le16(mode->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->crtc_id ? ATOM_PPLL2 : ATOM_PPLL1;
-                        spc2_ptr->ucCRTC = radeon_crtc->crtc_id;
-                        spc2_ptr->ucRefDivSrc = 1;
+                        args.v2.ucCRTC = radeon_crtc->crtc_id;
+                        args.v2.ucRefDivSrc = 1;
                         break;
                 case 3:
-                        if (!encoder)
-                                return;
-                        spc3_ptr =
-                            (PIXEL_CLOCK_PARAMETERS_V3 *) & args.sPCLKInput;
-                        spc3_ptr->usPixelClock = cpu_to_le16(mode->clock / 10);
-                        spc3_ptr->usRefDiv = cpu_to_le16(ref_div);
-                        spc3_ptr->usFbDiv = cpu_to_le16(fb_div);
-                        spc3_ptr->ucFracFbDiv = frac_fb_div;
-                        spc3_ptr->ucPostDiv = post_div;
-                        spc3_ptr->ucPpll =
+                        args.v3.usPixelClock = cpu_to_le16(mode->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->crtc_id ? ATOM_PPLL2 : ATOM_PPLL1;
-                        spc3_ptr->ucMiscInfo = (radeon_crtc->crtc_id << 2);
-                        spc3_ptr->ucTransmitterId = radeon_encoder->encoder_id;
-                        spc3_ptr->ucEncoderMode =
+                        args.v3.ucMiscInfo = (radeon_crtc->crtc_id << 2);
+                        args.v3.ucTransmitterId = radeon_encoder->encoder_id;
+                        args.v3.ucEncoderMode =
                             atombios_get_encoder_mode(encoder);
                         break;
                 default:
@@ -571,12 +615,11 @@ void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
                 return;
         }
 
-        printk("executing set pll\n");
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 }
 
-int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
-                           struct drm_framebuffer *old_fb)
+static int avivo_crtc_set_base(struct drm_crtc *crtc, int x, int y,
+                               struct drm_framebuffer *old_fb)
 {
         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
         struct drm_device *dev = crtc->dev;
@@ -706,6 +749,42 @@ int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
         return 0;
 }
 
+int atombios_crtc_set_base(struct drm_crtc *crtc, int x, int y,
+                           struct drm_framebuffer *old_fb)
+{
+        struct drm_device *dev = crtc->dev;
+        struct radeon_device *rdev = dev->dev_private;
+
+        if (ASIC_IS_AVIVO(rdev))
+                return avivo_crtc_set_base(crtc, x, y, old_fb);
+        else
+                return radeon_crtc_set_base(crtc, x, y, old_fb);
+}
+
+/* properly set additional regs when using atombios */
+static void radeon_legacy_atom_fixup(struct drm_crtc *crtc)
+{
+        struct drm_device *dev = crtc->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+        u32 disp_merge_cntl;
+
+        switch (radeon_crtc->crtc_id) {
+        case 0:
+                disp_merge_cntl = RREG32(RADEON_DISP_MERGE_CNTL);
+                disp_merge_cntl &= ~RADEON_DISP_RGB_OFFSET_EN;
+                WREG32(RADEON_DISP_MERGE_CNTL, disp_merge_cntl);
+                break;
+        case 1:
+                disp_merge_cntl = RREG32(RADEON_DISP2_MERGE_CNTL);
+                disp_merge_cntl &= ~RADEON_DISP2_RGB_OFFSET_EN;
+                WREG32(RADEON_DISP2_MERGE_CNTL, disp_merge_cntl);
+                WREG32(RADEON_FP_H2_SYNC_STRT_WID,   RREG32(RADEON_CRTC2_H_SYNC_STRT_WID));
+                WREG32(RADEON_FP_V2_SYNC_STRT_WID,   RREG32(RADEON_CRTC2_V_SYNC_STRT_WID));
+                break;
+        }
+}
+
 int atombios_crtc_mode_set(struct drm_crtc *crtc,
                            struct drm_display_mode *mode,
                            struct drm_display_mode *adjusted_mode,
@@ -727,8 +806,8 @@ int atombios_crtc_mode_set(struct drm_crtc *crtc,
         else {
                 if (radeon_crtc->crtc_id == 0)
                         atombios_set_crtc_dtd_timing(crtc, adjusted_mode);
-                radeon_crtc_set_base(crtc, x, y, old_fb);
-                radeon_legacy_atom_set_surface(crtc);
+                atombios_crtc_set_base(crtc, x, y, old_fb);
+                radeon_legacy_atom_fixup(crtc);
         }
         atombios_overscan_setup(crtc, mode, adjusted_mode);
         atombios_scaler_setup(crtc);
@@ -746,8 +825,8 @@ static bool atombios_crtc_mode_fixup(struct drm_crtc *crtc,
 
 static void atombios_crtc_prepare(struct drm_crtc *crtc)
 {
-        atombios_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
         atombios_lock_crtc(crtc, 1);
+        atombios_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
 }
 
 static void atombios_crtc_commit(struct drm_crtc *crtc)
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
index 3eb0ca5b3d73..71060114d5de 100644
--- a/drivers/gpu/drm/radeon/atombios_dp.c
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -468,7 +468,7 @@ void radeon_dp_set_link_config(struct drm_connector *connector,
         struct radeon_connector *radeon_connector;
         struct radeon_connector_atom_dig *dig_connector;
 
-        if ((connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) ||
+        if ((connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) &&
             (connector->connector_type != DRM_MODE_CONNECTOR_eDP))
                 return;
 
@@ -583,7 +583,7 @@ void dp_link_train(struct drm_encoder *encoder,
         u8 train_set[4];
         int i;
 
-        if ((connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) ||
+        if ((connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) &&
             (connector->connector_type != DRM_MODE_CONNECTOR_eDP))
                 return;
 
@@ -596,21 +596,14 @@ void dp_link_train(struct drm_encoder *encoder,
                 return;
         dig_connector = radeon_connector->con_priv;
 
-        if (ASIC_IS_DCE32(rdev)) {
-                if (dig->dig_block)
-                        enc_id |= ATOM_DP_CONFIG_DIG2_ENCODER;
-                else
-                        enc_id |= ATOM_DP_CONFIG_DIG1_ENCODER;
-                if (dig_connector->linkb)
-                        enc_id |= ATOM_DP_CONFIG_LINK_B;
-                else
-                        enc_id |= ATOM_DP_CONFIG_LINK_A;
-        } else {
-                if (dig_connector->linkb)
-                        enc_id |= ATOM_DP_CONFIG_DIG2_ENCODER | ATOM_DP_CONFIG_LINK_B;
-                else
-                        enc_id |= ATOM_DP_CONFIG_DIG1_ENCODER | ATOM_DP_CONFIG_LINK_A;
-        }
+        if (dig->dig_encoder)
+                enc_id |= ATOM_DP_CONFIG_DIG2_ENCODER;
+        else
+                enc_id |= ATOM_DP_CONFIG_DIG1_ENCODER;
+        if (dig_connector->linkb)
+                enc_id |= ATOM_DP_CONFIG_LINK_B;
+        else
+                enc_id |= ATOM_DP_CONFIG_LINK_A;
 
         memset(link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
         if (dig_connector->dp_clock == 270000)
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index 8760d66e058a..11c9a3fe6810 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -1504,6 +1504,7 @@ static int r100_packet3_check(struct radeon_cs_parser *p,
                         DRM_ERROR("PRIM_WALK must be 3 for IMMD draw\n");
                         return -EINVAL;
                 }
+                track->vtx_size = r100_get_vtx_size(radeon_get_ib_value(p, idx + 0));
                 track->vap_vf_cntl = radeon_get_ib_value(p, idx + 1);
                 track->immd_dwords = pkt->count - 1;
                 r = r100_cs_track_check(p->rdev, track);
@@ -3399,9 +3400,7 @@ int r100_mc_init(struct radeon_device *rdev)
         if (rdev->flags & RADEON_IS_AGP) {
                 r = radeon_agp_init(rdev);
                 if (r) {
-                        printk(KERN_WARNING "[drm] Disabling AGP\n");
-                        rdev->flags &= ~RADEON_IS_AGP;
-                        rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024;
+                        radeon_agp_disable(rdev);
                 } else {
                         rdev->mc.gtt_location = rdev->mc.agp_base;
                 }
diff --git a/drivers/gpu/drm/radeon/r200.c b/drivers/gpu/drm/radeon/r200.c
index 20942127c46b..ff1e0cd608bf 100644
--- a/drivers/gpu/drm/radeon/r200.c
+++ b/drivers/gpu/drm/radeon/r200.c
@@ -371,13 +371,16 @@ int r200_packet0_check(struct radeon_cs_parser *p,
                 case 5:
                 case 6:
                 case 7:
+                        /* 1D/2D */
                         track->textures[i].tex_coord_type = 0;
                         break;
                 case 1:
-                        track->textures[i].tex_coord_type = 1;
+                        /* CUBE */
+                        track->textures[i].tex_coord_type = 2;
                         break;
                 case 2:
-                        track->textures[i].tex_coord_type = 2;
+                        /* 3D */
+                        track->textures[i].tex_coord_type = 1;
                         break;
                 }
                 break;
diff --git a/drivers/gpu/drm/radeon/r420.c b/drivers/gpu/drm/radeon/r420.c
index 053404e71a9d..4526faaacca8 100644
--- a/drivers/gpu/drm/radeon/r420.c
+++ b/drivers/gpu/drm/radeon/r420.c
@@ -50,9 +50,7 @@ int r420_mc_init(struct radeon_device *rdev)
         if (rdev->flags & RADEON_IS_AGP) {
                 r = radeon_agp_init(rdev);
                 if (r) {
-                        printk(KERN_WARNING "[drm] Disabling AGP\n");
-                        rdev->flags &= ~RADEON_IS_AGP;
-                        rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024;
+                        radeon_agp_disable(rdev);
                 } else {
                         rdev->mc.gtt_location = rdev->mc.agp_base;
                 }
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c
index f5ff3490929f..1b6d0001b20e 100644
--- a/drivers/gpu/drm/radeon/r600.c
+++ b/drivers/gpu/drm/radeon/r600.c
@@ -624,7 +624,6 @@ int r600_mc_init(struct radeon_device *rdev)
         fixed20_12 a;
         u32 tmp;
         int chansize, numchan;
-        int r;
 
         /* Get VRAM informations */
         rdev->mc.vram_is_ddr = true;
@@ -667,9 +666,6 @@ int r600_mc_init(struct radeon_device *rdev)
                 rdev->mc.real_vram_size = rdev->mc.aper_size;
 
         if (rdev->flags & RADEON_IS_AGP) {
-                r = radeon_agp_init(rdev);
-                if (r)
-                        return r;
                 /* gtt_size is setup by radeon_agp_init */
                 rdev->mc.gtt_location = rdev->mc.agp_base;
                 tmp = 0xFFFFFFFFUL - rdev->mc.agp_base - rdev->mc.gtt_size;
@@ -1792,23 +1788,24 @@ void r600_fence_ring_emit(struct radeon_device *rdev,
         radeon_ring_write(rdev, RB_INT_STAT);
 }
 
-int r600_copy_dma(struct radeon_device *rdev,
-                  uint64_t src_offset,
-                  uint64_t dst_offset,
-                  unsigned num_pages,
-                  struct radeon_fence *fence)
-{
-        /* FIXME: implement */
-        return 0;
-}
-
 int r600_copy_blit(struct radeon_device *rdev,
                    uint64_t src_offset, uint64_t dst_offset,
                    unsigned num_pages, struct radeon_fence *fence)
 {
-        r600_blit_prepare_copy(rdev, num_pages * RADEON_GPU_PAGE_SIZE);
+        int r;
+
+        mutex_lock(&rdev->r600_blit.mutex);
+        rdev->r600_blit.vb_ib = NULL;
+        r = r600_blit_prepare_copy(rdev, num_pages * RADEON_GPU_PAGE_SIZE);
+        if (r) {
+                if (rdev->r600_blit.vb_ib)
+                        radeon_ib_free(rdev, &rdev->r600_blit.vb_ib);
+                mutex_unlock(&rdev->r600_blit.mutex);
+                return r;
+        }
         r600_kms_blit_copy(rdev, src_offset, dst_offset, num_pages * RADEON_GPU_PAGE_SIZE);
         r600_blit_done_copy(rdev, fence);
+        mutex_unlock(&rdev->r600_blit.mutex);
         return 0;
 }
 
@@ -1864,26 +1861,19 @@ int r600_startup(struct radeon_device *rdev)
                         return r;
         }
         r600_gpu_init(rdev);
-
-        if (!rdev->r600_blit.shader_obj) {
-                r = r600_blit_init(rdev);
+        /* pin copy shader into vram */
+        if (rdev->r600_blit.shader_obj) {
+                r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+                if (unlikely(r != 0))
+                        return r;
+                r = radeon_bo_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
+                                &rdev->r600_blit.shader_gpu_addr);
+                radeon_bo_unreserve(rdev->r600_blit.shader_obj);
                 if (r) {
-                        DRM_ERROR("radeon: failed blitter (%d).\n", r);
+                        dev_err(rdev->dev, "(%d) pin blit object failed\n", r);
                         return r;
                 }
         }
-
-        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
-        if (unlikely(r != 0))
-                return r;
-        r = radeon_bo_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
-                        &rdev->r600_blit.shader_gpu_addr);
-        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
-        if (r) {
-                dev_err(rdev->dev, "(%d) pin blit object failed\n", r);
-                return r;
-        }
-
         /* Enable IRQ */
         r = r600_irq_init(rdev);
         if (r) {
@@ -1958,14 +1948,17 @@ int r600_suspend(struct radeon_device *rdev)
         /* FIXME: we should wait for ring to be empty */
         r600_cp_stop(rdev);
         rdev->cp.ready = false;
+        r600_irq_suspend(rdev);
         r600_wb_disable(rdev);
         r600_pcie_gart_disable(rdev);
         /* unpin shaders bo */
-        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
-        if (unlikely(r != 0))
-                return r;
-        radeon_bo_unpin(rdev->r600_blit.shader_obj);
-        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+        if (rdev->r600_blit.shader_obj) {
+                r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+                if (!r) {
+                        radeon_bo_unpin(rdev->r600_blit.shader_obj);
+                        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+                }
+        }
         return 0;
 }
 
@@ -2026,6 +2019,11 @@ int r600_init(struct radeon_device *rdev)
         r = radeon_fence_driver_init(rdev);
         if (r)
                 return r;
+        if (rdev->flags & RADEON_IS_AGP) {
+                r = radeon_agp_init(rdev);
+                if (r)
+                        radeon_agp_disable(rdev);
+        }
         r = r600_mc_init(rdev);
         if (r)
                 return r;
@@ -2047,6 +2045,12 @@ int r600_init(struct radeon_device *rdev)
         r = r600_pcie_gart_init(rdev);
         if (r)
                 return r;
+        r = r600_blit_init(rdev);
+        if (r) {
+                r600_blit_fini(rdev);
+                rdev->asic->copy = NULL;
+                dev_warn(rdev->dev, "failed blitter (%d) falling back to memcpy\n", r);
+        }
 
         rdev->accel_working = true;
         r = r600_startup(rdev);
@@ -2060,13 +2064,14 @@ int r600_init(struct radeon_device *rdev)
         if (rdev->accel_working) {
                 r = radeon_ib_pool_init(rdev);
                 if (r) {
-                        DRM_ERROR("radeon: failed initializing IB pool (%d).\n", r);
-                        rdev->accel_working = false;
-                }
-                r = r600_ib_test(rdev);
-                if (r) {
-                        DRM_ERROR("radeon: failed testing IB (%d).\n", r);
+                        dev_err(rdev->dev, "IB initialization failed (%d).\n", r);
                         rdev->accel_working = false;
+                } else {
+                        r = r600_ib_test(rdev);
+                        if (r) {
+                                dev_err(rdev->dev, "IB test failed (%d).\n", r);
+                                rdev->accel_working = false;
+                        }
                 }
         }
 
@@ -2197,14 +2202,14 @@ void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size)
         rb_bufsz = drm_order(ring_size / 4);
         ring_size = (1 << rb_bufsz) * 4;
         rdev->ih.ring_size = ring_size;
-        rdev->ih.align_mask = 4 - 1;
+        rdev->ih.ptr_mask = rdev->ih.ring_size - 1;
+        rdev->ih.rptr = 0;
 }
 
-static int r600_ih_ring_alloc(struct radeon_device *rdev, unsigned ring_size)
+static int r600_ih_ring_alloc(struct radeon_device *rdev)
 {
         int r;
 
-        rdev->ih.ring_size = ring_size;
         /* Allocate ring buffer */
         if (rdev->ih.ring_obj == NULL) {
                 r = radeon_bo_create(rdev, NULL, rdev->ih.ring_size,
@@ -2234,9 +2239,6 @@ static int r600_ih_ring_alloc(struct radeon_device *rdev, unsigned ring_size)
                         return r;
                 }
         }
-        rdev->ih.ptr_mask = (rdev->cp.ring_size / 4) - 1;
-        rdev->ih.rptr = 0;
-
         return 0;
 }
 
@@ -2386,7 +2388,7 @@ int r600_irq_init(struct radeon_device *rdev)
         u32 interrupt_cntl, ih_cntl, ih_rb_cntl;
 
         /* allocate ring */
-        ret = r600_ih_ring_alloc(rdev, rdev->ih.ring_size);
+        ret = r600_ih_ring_alloc(rdev);
         if (ret)
                 return ret;
 
@@ -2449,10 +2451,15 @@ int r600_irq_init(struct radeon_device *rdev)
         return ret;
 }
 
-void r600_irq_fini(struct radeon_device *rdev)
+void r600_irq_suspend(struct radeon_device *rdev)
 {
         r600_disable_interrupts(rdev);
         r600_rlc_stop(rdev);
+}
+
+void r600_irq_fini(struct radeon_device *rdev)
+{
+        r600_irq_suspend(rdev);
         r600_ih_ring_fini(rdev);
 }
 
@@ -2467,8 +2474,12 @@ int r600_irq_set(struct radeon_device *rdev)
                 return -EINVAL;
         }
         /* don't enable anything if the ih is disabled */
-        if (!rdev->ih.enabled)
+        if (!rdev->ih.enabled) {
+                r600_disable_interrupts(rdev);
+                /* force the active interrupt state to all disabled */
+                r600_disable_interrupt_state(rdev);
                 return 0;
+        }
 
         if (ASIC_IS_DCE3(rdev)) {
                 hpd1 = RREG32(DC_HPD1_INT_CONTROL) & ~DC_HPDx_INT_EN;
@@ -2638,16 +2649,18 @@ static inline u32 r600_get_ih_wptr(struct radeon_device *rdev)
         wptr = RREG32(IH_RB_WPTR);
 
         if (wptr & RB_OVERFLOW) {
-                WARN_ON(1);
-                /* XXX deal with overflow */
-                DRM_ERROR("IH RB overflow\n");
+                /* When a ring buffer overflow happen start parsing interrupt
+                 * from the last not overwritten vector (wptr + 16). Hopefully
+                 * this should allow us to catchup.
+                 */
+                dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, %d, %d)\n",
+                        wptr, rdev->ih.rptr, (wptr + 16) + rdev->ih.ptr_mask);
+                rdev->ih.rptr = (wptr + 16) & rdev->ih.ptr_mask;
                 tmp = RREG32(IH_RB_CNTL);
                 tmp |= IH_WPTR_OVERFLOW_CLEAR;
                 WREG32(IH_RB_CNTL, tmp);
         }
-        wptr = wptr & WPTR_OFFSET_MASK;
-
-        return wptr;
+        return (wptr & rdev->ih.ptr_mask);
 }
 
 /*        r600 IV Ring
@@ -2683,12 +2696,13 @@ int r600_irq_process(struct radeon_device *rdev)
         u32 wptr = r600_get_ih_wptr(rdev);
         u32 rptr = rdev->ih.rptr;
         u32 src_id, src_data;
-        u32 last_entry = rdev->ih.ring_size - 16;
         u32 ring_index, disp_int, disp_int_cont, disp_int_cont2;
         unsigned long flags;
         bool queue_hotplug = false;
 
         DRM_DEBUG("r600_irq_process start: rptr %d, wptr %d\n", rptr, wptr);
+        if (!rdev->ih.enabled)
+                return IRQ_NONE;
 
         spin_lock_irqsave(&rdev->ih.lock, flags);
 
@@ -2817,10 +2831,8 @@ restart_ih:
                 }
 
                 /* wptr/rptr are in bytes! */
-                if (rptr == last_entry)
-                        rptr = 0;
-                else
-                        rptr += 16;
+                rptr += 16;
+                rptr &= rdev->ih.ptr_mask;
         }
         /* make sure wptr hasn't changed while processing */
         wptr = r600_get_ih_wptr(rdev);
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c
index 8787ea89dc6e..af1c3ca8a4cb 100644
--- a/drivers/gpu/drm/radeon/r600_blit_kms.c
+++ b/drivers/gpu/drm/radeon/r600_blit_kms.c
@@ -449,6 +449,7 @@ int r600_blit_init(struct radeon_device *rdev)
         u32 packet2s[16];
         int num_packet2s = 0;
 
+        mutex_init(&rdev->r600_blit.mutex);
         rdev->r600_blit.state_offset = 0;
 
         if (rdev->family >= CHIP_RV770)
@@ -512,14 +513,16 @@ void r600_blit_fini(struct radeon_device *rdev)
 {
         int r;
 
+        if (rdev->r600_blit.shader_obj == NULL)
+                return;
+        /* If we can't reserve the bo, unref should be enough to destroy
+         * it when it becomes idle.
+         */
         r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
-        if (unlikely(r != 0)) {
-                dev_err(rdev->dev, "(%d) can't finish r600 blit\n", r);
-                goto out_unref;
+        if (!r) {
+                radeon_bo_unpin(rdev->r600_blit.shader_obj);
+                radeon_bo_unreserve(rdev->r600_blit.shader_obj);
         }
-        radeon_bo_unpin(rdev->r600_blit.shader_obj);
-        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
-out_unref:
         radeon_bo_unref(&rdev->r600_blit.shader_obj);
 }
 
@@ -555,7 +558,8 @@ int r600_blit_prepare_copy(struct radeon_device *rdev, int size_bytes)
         int dwords_per_loop = 76, num_loops;
 
         r = r600_vb_ib_get(rdev);
-        WARN_ON(r);
+        if (r)
+                return r;
 
         /* set_render_target emits 2 extra dwords on rv6xx */
         if (rdev->family > CHIP_R600 && rdev->family < CHIP_RV770)
@@ -581,7 +585,8 @@ int r600_blit_prepare_copy(struct radeon_device *rdev, int size_bytes)
         ring_size += 5; /* done copy */
         ring_size += 7; /* fence emit for done copy */
         r = radeon_ring_lock(rdev, ring_size);
-        WARN_ON(r);
+        if (r)
+                return r;
 
         set_default_state(rdev); /* 14 */
         set_shaders(rdev); /* 26 */
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index 44060b92d9e6..e4c45ec16507 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -36,6 +36,10 @@ static int r600_cs_packet_next_reloc_nomm(struct radeon_cs_parser *p,
 typedef int (*next_reloc_t)(struct radeon_cs_parser*, struct radeon_cs_reloc**);
 static next_reloc_t r600_cs_packet_next_reloc = &r600_cs_packet_next_reloc_mm;
 
+struct r600_cs_track {
+        u32     cb_color0_base_last;
+};
+
 /**
  * r600_cs_packet_parse() - parse cp packet and point ib index to next packet
  * @parser:     parser structure holding parsing context.
@@ -177,6 +181,28 @@ static int r600_cs_packet_next_reloc_nomm(struct radeon_cs_parser *p,
 }
 
 /**
+ * r600_cs_packet_next_is_pkt3_nop() - test if next packet is packet3 nop for reloc
+ * @parser:             parser structure holding parsing context.
+ *
+ * Check next packet is relocation packet3, do bo validation and compute
+ * GPU offset using the provided start.
+ **/
+static inline int r600_cs_packet_next_is_pkt3_nop(struct radeon_cs_parser *p)
+{
+        struct radeon_cs_packet p3reloc;
+        int r;
+
+        r = r600_cs_packet_parse(p, &p3reloc, p->idx);
+        if (r) {
+                return 0;
+        }
+        if (p3reloc.type != PACKET_TYPE3 || p3reloc.opcode != PACKET3_NOP) {
+                return 0;
+        }
+        return 1;
+}
+
+/**
  * r600_cs_packet_next_vline() - parse userspace VLINE packet
  * @parser:             parser structure holding parsing context.
  *
@@ -337,6 +363,7 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                                 struct radeon_cs_packet *pkt)
 {
         struct radeon_cs_reloc *reloc;
+        struct r600_cs_track *track;
         volatile u32 *ib;
         unsigned idx;
         unsigned i;
@@ -344,6 +371,7 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
         int r;
         u32 idx_value;
 
+        track = (struct r600_cs_track *)p->track;
         ib = p->ib->ptr;
         idx = pkt->idx + 1;
         idx_value = radeon_get_ib_value(p, idx);
@@ -503,9 +531,60 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                 for (i = 0; i < pkt->count; i++) {
                         reg = start_reg + (4 * i);
                         switch (reg) {
+                        /* This register were added late, there is userspace
+                         * which does provide relocation for those but set
+                         * 0 offset. In order to avoid breaking old userspace
+                         * we detect this and set address to point to last
+                         * CB_COLOR0_BASE, note that if userspace doesn't set
+                         * CB_COLOR0_BASE before this register we will report
+                         * error. Old userspace always set CB_COLOR0_BASE
+                         * before any of this.
+                         */
+                        case R_0280E0_CB_COLOR0_FRAG:
+                        case R_0280E4_CB_COLOR1_FRAG:
+                        case R_0280E8_CB_COLOR2_FRAG:
+                        case R_0280EC_CB_COLOR3_FRAG:
+                        case R_0280F0_CB_COLOR4_FRAG:
+                        case R_0280F4_CB_COLOR5_FRAG:
+                        case R_0280F8_CB_COLOR6_FRAG:
+                        case R_0280FC_CB_COLOR7_FRAG:
+                        case R_0280C0_CB_COLOR0_TILE:
+                        case R_0280C4_CB_COLOR1_TILE:
+                        case R_0280C8_CB_COLOR2_TILE:
+                        case R_0280CC_CB_COLOR3_TILE:
+                        case R_0280D0_CB_COLOR4_TILE:
+                        case R_0280D4_CB_COLOR5_TILE:
+                        case R_0280D8_CB_COLOR6_TILE:
+                        case R_0280DC_CB_COLOR7_TILE:
+                                if (!r600_cs_packet_next_is_pkt3_nop(p)) {
+                                        if (!track->cb_color0_base_last) {
+                                                dev_err(p->dev, "Broken old userspace ? no cb_color0_base supplied before trying to write 0x%08X\n", reg);
+                                                return -EINVAL;
+                                        }
+                                        ib[idx+1+i] = track->cb_color0_base_last;
+                                        printk_once(KERN_WARNING "radeon: You have old & broken userspace "
+                                                "please consider updating mesa & xf86-video-ati\n");
+                                } else {
+                                        r = r600_cs_packet_next_reloc(p, &reloc);
+                                        if (r) {
+                                                dev_err(p->dev, "bad SET_CONTEXT_REG 0x%04X\n", reg);
+                                                return -EINVAL;
+                                        }
+                                        ib[idx+1+i] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                }
+                                break;
                         case DB_DEPTH_BASE:
                         case DB_HTILE_DATA_BASE:
                         case CB_COLOR0_BASE:
+                                r = r600_cs_packet_next_reloc(p, &reloc);
+                                if (r) {
+                                        DRM_ERROR("bad SET_CONTEXT_REG "
+                                                        "0x%04X\n", reg);
+                                        return -EINVAL;
+                                }
+                                ib[idx+1+i] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                track->cb_color0_base_last = ib[idx+1+i];
+                                break;
                         case CB_COLOR1_BASE:
                         case CB_COLOR2_BASE:
                         case CB_COLOR3_BASE:
@@ -678,8 +757,11 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
 int r600_cs_parse(struct radeon_cs_parser *p)
 {
         struct radeon_cs_packet pkt;
+        struct r600_cs_track *track;
         int r;
 
+        track = kzalloc(sizeof(*track), GFP_KERNEL);
+        p->track = track;
         do {
                 r = r600_cs_packet_parse(p, &pkt, p->idx);
                 if (r) {
@@ -757,6 +839,7 @@ int r600_cs_legacy(struct drm_device *dev, void *data, struct drm_file *filp,
         /* initialize parser */
         memset(&parser, 0, sizeof(struct radeon_cs_parser));
         parser.filp = filp;
+        parser.dev = &dev->pdev->dev;
         parser.rdev = NULL;
         parser.family = family;
         parser.ib = &fake_ib;
diff --git a/drivers/gpu/drm/radeon/r600d.h b/drivers/gpu/drm/radeon/r600d.h
index 05894edadab4..30480881aed1 100644
--- a/drivers/gpu/drm/radeon/r600d.h
+++ b/drivers/gpu/drm/radeon/r600d.h
@@ -882,4 +882,29 @@
 #define         S_000E60_SOFT_RESET_VMC(x)              (((x) & 1) << 17)
 
 #define R_005480_HDP_MEM_COHERENCY_FLUSH_CNTL           0x5480
+
+#define R_0280E0_CB_COLOR0_FRAG                      0x0280E0
+#define   S_0280E0_BASE_256B(x)                        (((x) & 0xFFFFFFFF) << 0)
+#define   G_0280E0_BASE_256B(x)                        (((x) >> 0) & 0xFFFFFFFF)
+#define   C_0280E0_BASE_256B                           0x00000000
+#define R_0280E4_CB_COLOR1_FRAG                      0x0280E4
+#define R_0280E8_CB_COLOR2_FRAG                      0x0280E8
+#define R_0280EC_CB_COLOR3_FRAG                      0x0280EC
+#define R_0280F0_CB_COLOR4_FRAG                      0x0280F0
+#define R_0280F4_CB_COLOR5_FRAG                      0x0280F4
+#define R_0280F8_CB_COLOR6_FRAG                      0x0280F8
+#define R_0280FC_CB_COLOR7_FRAG                      0x0280FC
+#define R_0280C0_CB_COLOR0_TILE                      0x0280C0
+#define   S_0280C0_BASE_256B(x)                        (((x) & 0xFFFFFFFF) << 0)
+#define   G_0280C0_BASE_256B(x)                        (((x) >> 0) & 0xFFFFFFFF)
+#define   C_0280C0_BASE_256B                           0x00000000
+#define R_0280C4_CB_COLOR1_TILE                      0x0280C4
+#define R_0280C8_CB_COLOR2_TILE                      0x0280C8
+#define R_0280CC_CB_COLOR3_TILE                      0x0280CC
+#define R_0280D0_CB_COLOR4_TILE                      0x0280D0
+#define R_0280D4_CB_COLOR5_TILE                      0x0280D4
+#define R_0280D8_CB_COLOR6_TILE                      0x0280D8
+#define R_0280DC_CB_COLOR7_TILE                      0x0280DC
+
+
 #endif
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index eb5f99b9469d..2d5f2bfa7201 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -410,13 +410,13 @@ struct r600_ih {
         unsigned                wptr_old;
         unsigned                ring_size;
         uint64_t                gpu_addr;
-        uint32_t                align_mask;
         uint32_t                ptr_mask;
         spinlock_t              lock;
         bool                    enabled;
 };
 
 struct r600_blit {
+        struct mutex            mutex;
         struct radeon_bo        *shader_obj;
         u64 shader_gpu_addr;
         u32 vs_offset, ps_offset;
@@ -465,6 +465,7 @@ struct radeon_cs_chunk {
 };
 
 struct radeon_cs_parser {
+        struct device           *dev;
         struct radeon_device    *rdev;
         struct drm_file         *filp;
         /* chunks */
@@ -847,7 +848,7 @@ void r600_kms_blit_copy(struct radeon_device *rdev,
 
 static inline uint32_t r100_mm_rreg(struct radeon_device *rdev, uint32_t reg)
 {
-        if (reg < 0x10000)
+        if (reg < rdev->rmmio_size)
                 return readl(((void __iomem *)rdev->rmmio) + reg);
         else {
                 writel(reg, ((void __iomem *)rdev->rmmio) + RADEON_MM_INDEX);
@@ -857,7 +858,7 @@ static inline uint32_t r100_mm_rreg(struct radeon_device *rdev, uint32_t reg)
 
 static inline void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v)
 {
-        if (reg < 0x10000)
+        if (reg < rdev->rmmio_size)
                 writel(v, ((void __iomem *)rdev->rmmio) + reg);
         else {
                 writel(reg, ((void __iomem *)rdev->rmmio) + RADEON_MM_INDEX);
@@ -1017,6 +1018,8 @@ static inline void radeon_ring_write(struct radeon_device *rdev, uint32_t v)
 #define radeon_hpd_set_polarity(rdev, hpd) (rdev)->asic->hpd_set_polarity((rdev), (hpd))
 
 /* Common functions */
+/* AGP */
+extern void radeon_agp_disable(struct radeon_device *rdev);
 extern int radeon_gart_table_vram_pin(struct radeon_device *rdev);
 extern int radeon_modeset_init(struct radeon_device *rdev);
 extern void radeon_modeset_fini(struct radeon_device *rdev);
@@ -1160,7 +1163,8 @@ extern int r600_irq_init(struct radeon_device *rdev);
 extern void r600_irq_fini(struct radeon_device *rdev);
 extern void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size);
 extern int r600_irq_set(struct radeon_device *rdev);
-
+extern void r600_irq_suspend(struct radeon_device *rdev);
+/* r600 audio */
 extern int r600_audio_init(struct radeon_device *rdev);
 extern int r600_audio_tmds_index(struct drm_encoder *encoder);
 extern void r600_audio_set_clock(struct drm_encoder *encoder, int clock);
diff --git a/drivers/gpu/drm/radeon/radeon_agp.c b/drivers/gpu/drm/radeon/radeon_agp.c
index 220f454ea9fa..c0681a5556dc 100644
--- a/drivers/gpu/drm/radeon/radeon_agp.c
+++ b/drivers/gpu/drm/radeon/radeon_agp.c
@@ -144,9 +144,19 @@ int radeon_agp_init(struct radeon_device *rdev)
 
         ret = drm_agp_info(rdev->ddev, &info);
         if (ret) {
+                drm_agp_release(rdev->ddev);
                 DRM_ERROR("Unable to get AGP info: %d\n", ret);
                 return ret;
         }
+
+        if (rdev->ddev->agp->agp_info.aper_size < 32) {
+                drm_agp_release(rdev->ddev);
+                dev_warn(rdev->dev, "AGP aperture too small (%zuM) "
+                        "need at least 32M, disabling AGP\n",
+                        rdev->ddev->agp->agp_info.aper_size);
+                return -EINVAL;
+        }
+
         mode.mode = info.mode;
         agp_status = (RREG32(RADEON_AGP_STATUS) | RADEON_AGPv3_MODE) & mode.mode;
         is_v3 = !!(agp_status & RADEON_AGPv3_MODE);
@@ -221,6 +231,7 @@ int radeon_agp_init(struct radeon_device *rdev)
         ret = drm_agp_enable(rdev->ddev, mode);
         if (ret) {
                 DRM_ERROR("Unable to enable AGP (mode = 0x%lx)\n", mode.mode);
+                drm_agp_release(rdev->ddev);
                 return ret;
         }
 
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c
index 812f24dbc2a8..73c4405bf42f 100644
--- a/drivers/gpu/drm/radeon/radeon_clocks.c
+++ b/drivers/gpu/drm/radeon/radeon_clocks.c
@@ -56,7 +56,7 @@ uint32_t radeon_legacy_get_engine_clock(struct radeon_device *rdev)
         else if (post_div == 3)
                 sclk >>= 2;
         else if (post_div == 4)
-                sclk >>= 4;
+                sclk >>= 3;
 
         return sclk;
 }
@@ -86,7 +86,7 @@ uint32_t radeon_legacy_get_memory_clock(struct radeon_device *rdev)
         else if (post_div == 3)
                 mclk >>= 2;
         else if (post_div == 4)
-                mclk >>= 4;
+                mclk >>= 3;
 
         return mclk;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c
index 65590a0f1d93..1190148cf5e6 100644
--- a/drivers/gpu/drm/radeon/radeon_cs.c
+++ b/drivers/gpu/drm/radeon/radeon_cs.c
@@ -189,7 +189,7 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error)
 {
         unsigned i;
 
-        if (error) {
+        if (error && parser->ib) {
                 radeon_bo_list_unvalidate(&parser->validated,
                                                 parser->ib->fence);
         } else {
@@ -231,6 +231,7 @@ int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
         memset(&parser, 0, sizeof(struct radeon_cs_parser));
         parser.filp = filp;
         parser.rdev = rdev;
+        parser.dev = rdev->dev;
         r = radeon_cs_parser_init(&parser, data);
         if (r) {
                 DRM_ERROR("Failed to initialize parser !\n");
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 0c51f8e46613..768b1509fa03 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -544,6 +544,7 @@ void radeon_agp_disable(struct radeon_device *rdev)
                 rdev->asic->gart_tlb_flush = &r100_pci_gart_tlb_flush;
                 rdev->asic->gart_set_page = &r100_pci_gart_set_page;
         }
+        rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024;
 }
 
 void radeon_check_arguments(struct radeon_device *rdev)
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 0ec491ead2ff..6a92f994cc26 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -357,7 +357,8 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
         if ((radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
             (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP)) {
                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
-                if (dig->dp_i2c_bus)
+                if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
+                     dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) && dig->dp_i2c_bus)
                         radeon_connector->edid = drm_get_edid(&radeon_connector->base, &dig->dp_i2c_bus->adapter);
         }
         if (!radeon_connector->ddc_bus)
@@ -410,11 +411,12 @@ void radeon_compute_pll(struct radeon_pll *pll,
                         uint32_t *fb_div_p,
                         uint32_t *frac_fb_div_p,
                         uint32_t *ref_div_p,
-                        uint32_t *post_div_p,
-                        int flags)
+                        uint32_t *post_div_p)
 {
         uint32_t min_ref_div = pll->min_ref_div;
         uint32_t max_ref_div = pll->max_ref_div;
+        uint32_t min_post_div = pll->min_post_div;
+        uint32_t max_post_div = pll->max_post_div;
         uint32_t min_fractional_feed_div = 0;
         uint32_t max_fractional_feed_div = 0;
         uint32_t best_vco = pll->best_vco;
@@ -430,7 +432,7 @@ void radeon_compute_pll(struct radeon_pll *pll,
         DRM_DEBUG("PLL freq %llu %u %u\n", freq, pll->min_ref_div, pll->max_ref_div);
         freq = freq * 1000;
 
-        if (flags & RADEON_PLL_USE_REF_DIV)
+        if (pll->flags & RADEON_PLL_USE_REF_DIV)
                 min_ref_div = max_ref_div = pll->reference_div;
         else {
                 while (min_ref_div < max_ref_div-1) {
@@ -445,19 +447,22 @@ void radeon_compute_pll(struct radeon_pll *pll,
                 }
         }
 
-        if (flags & RADEON_PLL_USE_FRAC_FB_DIV) {
+        if (pll->flags & RADEON_PLL_USE_POST_DIV)
+                min_post_div = max_post_div = pll->post_div;
+
+        if (pll->flags & RADEON_PLL_USE_FRAC_FB_DIV) {
                 min_fractional_feed_div = pll->min_frac_feedback_div;
                 max_fractional_feed_div = pll->max_frac_feedback_div;
         }
 
-        for (post_div = pll->min_post_div; post_div <= pll->max_post_div; ++post_div) {
+        for (post_div = min_post_div; post_div <= max_post_div; ++post_div) {
                 uint32_t ref_div;
 
-                if ((flags & RADEON_PLL_NO_ODD_POST_DIV) && (post_div & 1))
+                if ((pll->flags & RADEON_PLL_NO_ODD_POST_DIV) && (post_div & 1))
                         continue;
 
                 /* legacy radeons only have a few post_divs */
-                if (flags & RADEON_PLL_LEGACY) {
+                if (pll->flags & RADEON_PLL_LEGACY) {
                         if ((post_div == 5) ||
                             (post_div == 7) ||
                             (post_div == 9) ||
@@ -504,7 +509,7 @@ void radeon_compute_pll(struct radeon_pll *pll,
                                         tmp += (uint64_t)pll->reference_freq * 1000 * frac_feedback_div;
                                         current_freq = radeon_div(tmp, ref_div * post_div);
 
-                                        if (flags & RADEON_PLL_PREFER_CLOSEST_LOWER) {
+                                        if (pll->flags & RADEON_PLL_PREFER_CLOSEST_LOWER) {
                                                 error = freq - current_freq;
                                                 error = error < 0 ? 0xffffffff : error;
                                         } else
@@ -531,12 +536,12 @@ void radeon_compute_pll(struct radeon_pll *pll,
                                                         best_freq = current_freq;
                                                         best_error = error;
                                                         best_vco_diff = vco_diff;
-                                                } else if (((flags & RADEON_PLL_PREFER_LOW_REF_DIV) && (ref_div < best_ref_div)) ||
-                                                           ((flags & RADEON_PLL_PREFER_HIGH_REF_DIV) && (ref_div > best_ref_div)) ||
-                                                           ((flags & RADEON_PLL_PREFER_LOW_FB_DIV) && (feedback_div < best_feedback_div)) ||
-                                                           ((flags & RADEON_PLL_PREFER_HIGH_FB_DIV) && (feedback_div > best_feedback_div)) ||
-                                                           ((flags & RADEON_PLL_PREFER_LOW_POST_DIV) && (post_div < best_post_div)) ||
-                                                           ((flags & RADEON_PLL_PREFER_HIGH_POST_DIV) && (post_div > best_post_div))) {
+                                                } else if (((pll->flags & RADEON_PLL_PREFER_LOW_REF_DIV) && (ref_div < best_ref_div)) ||
+                                                           ((pll->flags & RADEON_PLL_PREFER_HIGH_REF_DIV) && (ref_div > best_ref_div)) ||
+                                                           ((pll->flags & RADEON_PLL_PREFER_LOW_FB_DIV) && (feedback_div < best_feedback_div)) ||
+                                                           ((pll->flags & RADEON_PLL_PREFER_HIGH_FB_DIV) && (feedback_div > best_feedback_div)) ||
+                                                           ((pll->flags & RADEON_PLL_PREFER_LOW_POST_DIV) && (post_div < best_post_div)) ||
+                                                           ((pll->flags & RADEON_PLL_PREFER_HIGH_POST_DIV) && (post_div > best_post_div))) {
                                                         best_post_div = post_div;
                                                         best_ref_div = ref_div;
                                                         best_feedback_div = feedback_div;
@@ -572,8 +577,7 @@ void radeon_compute_pll_avivo(struct radeon_pll *pll,
                               uint32_t *fb_div_p,
                               uint32_t *frac_fb_div_p,
                               uint32_t *ref_div_p,
-                              uint32_t *post_div_p,
-                              int flags)
+                              uint32_t *post_div_p)
 {
         fixed20_12 m, n, frac_n, p, f_vco, f_pclk, best_freq;
         fixed20_12 pll_out_max, pll_out_min;
@@ -667,7 +671,6 @@ static void radeon_user_framebuffer_destroy(struct drm_framebuffer *fb)
                 radeonfb_remove(dev, fb);
 
         if (radeon_fb->obj) {
-                radeon_gem_object_unpin(radeon_fb->obj);
                 mutex_lock(&dev->struct_mutex);
                 drm_gem_object_unreference(radeon_fb->obj);
                 mutex_unlock(&dev->struct_mutex);
@@ -715,7 +718,11 @@ radeon_user_framebuffer_create(struct drm_device *dev,
         struct drm_gem_object *obj;
 
         obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle);
-
+        if (obj ==  NULL) {
+                dev_err(&dev->pdev->dev, "No GEM object associated to handle 0x%08X, "
+                        "can't create framebuffer\n", mode_cmd->handle);
+                return NULL;
+        }
         return radeon_framebuffer_create(dev, mode_cmd, obj);
 }
 
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c
index 82eb551970b9..3c91724457ca 100644
--- a/drivers/gpu/drm/radeon/radeon_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_encoders.c
@@ -156,6 +156,26 @@ radeon_get_encoder_id(struct drm_device *dev, uint32_t supported_device, uint8_t
         return ret;
 }
 
+static inline bool radeon_encoder_is_digital(struct drm_encoder *encoder)
+{
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        switch (radeon_encoder->encoder_id) {
+        case ENCODER_OBJECT_ID_INTERNAL_LVDS:
+        case ENCODER_OBJECT_ID_INTERNAL_TMDS1:
+        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1:
+        case ENCODER_OBJECT_ID_INTERNAL_LVTM1:
+        case ENCODER_OBJECT_ID_INTERNAL_DVO1:
+        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1:
+        case ENCODER_OBJECT_ID_INTERNAL_DDI:
+        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
+        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
+        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1:
+        case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2:
+                return true;
+        default:
+                return false;
+        }
+}
 void
 radeon_link_encoder_connector(struct drm_device *dev)
 {
@@ -202,7 +222,7 @@ radeon_get_connector_for_encoder(struct drm_encoder *encoder)
 
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 radeon_connector = to_radeon_connector(connector);
-                if (radeon_encoder->devices & radeon_connector->devices)
+                if (radeon_encoder->active_device & radeon_connector->devices)
                         return connector;
         }
         return NULL;
@@ -676,31 +696,11 @@ atombios_dig_encoder_setup(struct drm_encoder *encoder, int action)
 
         memset(&args, 0, sizeof(args));
 
-        if (ASIC_IS_DCE32(rdev)) {
-                if (dig->dig_block)
-                        index = GetIndexIntoMasterTable(COMMAND, DIG2EncoderControl);
-                else
-                        index = GetIndexIntoMasterTable(COMMAND, DIG1EncoderControl);
-                num = dig->dig_block + 1;
-        } else {
-                switch (radeon_encoder->encoder_id) {
-                case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
-                        /* XXX doesn't really matter which dig encoder we pick as long as it's
-                         * not already in use
-                         */
-                        if (dig_connector->linkb)
-                                index = GetIndexIntoMasterTable(COMMAND, DIG2EncoderControl);
-                        else
-                                index = GetIndexIntoMasterTable(COMMAND, DIG1EncoderControl);
-                        num = 1;
-                        break;
-                case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
-                        /* Only dig2 encoder can drive LVTMA */
-                        index = GetIndexIntoMasterTable(COMMAND, DIG2EncoderControl);
-                        num = 2;
-                        break;
-                }
-        }
+        if (dig->dig_encoder)
+                index = GetIndexIntoMasterTable(COMMAND, DIG2EncoderControl);
+        else
+                index = GetIndexIntoMasterTable(COMMAND, DIG1EncoderControl);
+        num = dig->dig_encoder + 1;
 
         atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev);
 
@@ -822,7 +822,7 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
                         args.v1.usPixelClock = cpu_to_le16(radeon_encoder->pixel_clock / 10);
         }
         if (ASIC_IS_DCE32(rdev)) {
-                if (dig->dig_block)
+                if (dig->dig_encoder == 1)
                         args.v2.acConfig.ucEncoderSel = 1;
                 if (dig_connector->linkb)
                         args.v2.acConfig.ucLinkSel = 1;
@@ -849,17 +849,16 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
                                 args.v2.acConfig.fCoherentMode = 1;
                 }
         } else {
+
                 args.v1.ucConfig = ATOM_TRANSMITTER_CONFIG_CLKSRC_PPLL;
 
+                if (dig->dig_encoder)
+                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG2_ENCODER;
+                else
+                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG1_ENCODER;
+
                 switch (radeon_encoder->encoder_id) {
                 case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
-                        /* XXX doesn't really matter which dig encoder we pick as long as it's
-                         * not already in use
-                         */
-                        if (dig_connector->linkb)
-                                args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG2_ENCODER;
-                        else
-                                args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG1_ENCODER;
                         if (rdev->flags & RADEON_IS_IGP) {
                                 if (radeon_encoder->pixel_clock > 165000) {
                                         if (dig_connector->igp_lane_info & 0x3)
@@ -878,10 +877,6 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t
                                 }
                         }
                         break;
-                case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
-                        /* Only dig2 encoder can drive LVTMA */
-                        args.v1.ucConfig |= ATOM_TRANSMITTER_CONFIG_DIG2_ENCODER;
-                        break;
                 }
 
                 if (radeon_encoder->pixel_clock > 165000)
@@ -1046,6 +1041,7 @@ atombios_set_encoder_crtc_source(struct drm_encoder *encoder)
         union crtc_sourc_param args;
         int index = GetIndexIntoMasterTable(COMMAND, SelectCRTC_Source);
         uint8_t frev, crev;
+        struct radeon_encoder_atom_dig *dig;
 
         memset(&args, 0, sizeof(args));
 
@@ -1109,40 +1105,16 @@ atombios_set_encoder_crtc_source(struct drm_encoder *encoder)
                         case ENCODER_OBJECT_ID_INTERNAL_UNIPHY:
                         case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1:
                         case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2:
-                                if (ASIC_IS_DCE32(rdev)) {
-                                        if (radeon_crtc->crtc_id)
-                                                args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
-                                        else
-                                                args.v2.ucEncoderID = ASIC_INT_DIG1_ENCODER_ID;
-                                } else {
-                                        struct drm_connector *connector;
-                                        struct radeon_connector *radeon_connector;
-                                        struct radeon_connector_atom_dig *dig_connector;
-
-                                        connector = radeon_get_connector_for_encoder(encoder);
-                                        if (!connector)
-                                                return;
-                                        radeon_connector = to_radeon_connector(connector);
-                                        if (!radeon_connector->con_priv)
-                                                return;
-                                        dig_connector = radeon_connector->con_priv;
-
-                                        /* XXX doesn't really matter which dig encoder we pick as long as it's
-                                         * not already in use
-                                         */
-                                        if (dig_connector->linkb)
-                                                args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
-                                        else
-                                                args.v2.ucEncoderID = ASIC_INT_DIG1_ENCODER_ID;
-                                }
+                        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
+                                dig = radeon_encoder->enc_priv;
+                                if (dig->dig_encoder)
+                                        args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
+                                else
+                                        args.v2.ucEncoderID = ASIC_INT_DIG1_ENCODER_ID;
                                 break;
                         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1:
                                 args.v2.ucEncoderID = ASIC_INT_DVO_ENCODER_ID;
                                 break;
-                        case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA:
-                                /* Only dig2 encoder can drive LVTMA */
-                                args.v2.ucEncoderID = ASIC_INT_DIG2_ENCODER_ID;
-                                break;
                         case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1:
                                 if (radeon_encoder->active_device & (ATOM_DEVICE_TV_SUPPORT))
                                         args.v2.ucEncoderID = ASIC_INT_TV_ENCODER_ID;
@@ -1202,6 +1174,47 @@ atombios_apply_encoder_quirks(struct drm_encoder *encoder,
         }
 }
 
+static int radeon_atom_pick_dig_encoder(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct radeon_device *rdev = dev->dev_private;
+        struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
+        struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct drm_encoder *test_encoder;
+        struct radeon_encoder_atom_dig *dig;
+        uint32_t dig_enc_in_use = 0;
+        /* on DCE32 and encoder can driver any block so just crtc id */
+        if (ASIC_IS_DCE32(rdev)) {
+                return radeon_crtc->crtc_id;
+        }
+
+        /* on DCE3 - LVTMA can only be driven by DIGB */
+        list_for_each_entry(test_encoder, &dev->mode_config.encoder_list, head) {
+                struct radeon_encoder *radeon_test_encoder;
+
+                if (encoder == test_encoder)
+                        continue;
+
+                if (!radeon_encoder_is_digital(test_encoder))
+                        continue;
+
+                radeon_test_encoder = to_radeon_encoder(test_encoder);
+                dig = radeon_test_encoder->enc_priv;
+
+                if (dig->dig_encoder >= 0)
+                        dig_enc_in_use |= (1 << dig->dig_encoder);
+        }
+
+        if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA) {
+                if (dig_enc_in_use & 0x2)
+                        DRM_ERROR("LVDS required digital encoder 2 but it was in use - stealing\n");
+                return 1;
+        }
+        if (!(dig_enc_in_use & 1))
+                return 0;
+        return 1;
+}
+
 static void
 radeon_atom_encoder_mode_set(struct drm_encoder *encoder,
                              struct drm_display_mode *mode,
@@ -1214,12 +1227,9 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder,
 
         if (radeon_encoder->active_device &
             (ATOM_DEVICE_DFP_SUPPORT | ATOM_DEVICE_LCD_SUPPORT)) {
-                if (radeon_encoder->enc_priv) {
-                        struct radeon_encoder_atom_dig *dig;
-
-                        dig = radeon_encoder->enc_priv;
-                        dig->dig_block = radeon_crtc->crtc_id;
-                }
+                struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
+                if (dig)
+                        dig->dig_encoder = radeon_atom_pick_dig_encoder(encoder);
         }
         radeon_encoder->pixel_clock = adjusted_mode->clock;
 
@@ -1379,7 +1389,13 @@ static void radeon_atom_encoder_commit(struct drm_encoder *encoder)
 static void radeon_atom_encoder_disable(struct drm_encoder *encoder)
 {
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
+        struct radeon_encoder_atom_dig *dig;
         radeon_atom_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
+
+        if (radeon_encoder_is_digital(encoder)) {
+                dig = radeon_encoder->enc_priv;
+                dig->dig_encoder = -1;
+        }
         radeon_encoder->active_device = 0;
 }
 
@@ -1436,6 +1452,7 @@ radeon_atombios_set_dig_info(struct radeon_encoder *radeon_encoder)
 
         /* coherent mode by default */
         dig->coherent_mode = true;
+        dig->dig_encoder = -1;
 
         return dig;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
index cc27485a07ad..b6d8081e1246 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
@@ -339,69 +339,6 @@ void radeon_crtc_dpms(struct drm_crtc *crtc, int mode)
         }
 }
 
-/* properly set crtc bpp when using atombios */
-void radeon_legacy_atom_set_surface(struct drm_crtc *crtc)
-{
-        struct drm_device *dev = crtc->dev;
-        struct radeon_device *rdev = dev->dev_private;
-        struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
-        int format;
-        uint32_t crtc_gen_cntl;
-        uint32_t disp_merge_cntl;
-        uint32_t crtc_pitch;
-
-        switch (crtc->fb->bits_per_pixel) {
-        case 8:
-                format = 2;
-                break;
-        case 15:      /*  555 */
-                format = 3;
-                break;
-        case 16:      /*  565 */
-                format = 4;
-                break;
-        case 24:      /*  RGB */
-                format = 5;
-                break;
-        case 32:      /* xRGB */
-                format = 6;
-                break;
-        default:
-                return;
-        }
-
-        crtc_pitch  = ((((crtc->fb->pitch / (crtc->fb->bits_per_pixel / 8)) * crtc->fb->bits_per_pixel) +
-                        ((crtc->fb->bits_per_pixel * 8) - 1)) /
-                       (crtc->fb->bits_per_pixel * 8));
-        crtc_pitch |= crtc_pitch << 16;
-
-        WREG32(RADEON_CRTC_PITCH + radeon_crtc->crtc_offset, crtc_pitch);
-
-        switch (radeon_crtc->crtc_id) {
-        case 0:
-                disp_merge_cntl = RREG32(RADEON_DISP_MERGE_CNTL);
-                disp_merge_cntl &= ~RADEON_DISP_RGB_OFFSET_EN;
-                WREG32(RADEON_DISP_MERGE_CNTL, disp_merge_cntl);
-
-                crtc_gen_cntl = RREG32(RADEON_CRTC_GEN_CNTL) & 0xfffff0ff;
-                crtc_gen_cntl |= (format << 8);
-                crtc_gen_cntl |= RADEON_CRTC_EXT_DISP_EN;
-                WREG32(RADEON_CRTC_GEN_CNTL, crtc_gen_cntl);
-                break;
-        case 1:
-                disp_merge_cntl = RREG32(RADEON_DISP2_MERGE_CNTL);
-                disp_merge_cntl &= ~RADEON_DISP2_RGB_OFFSET_EN;
-                WREG32(RADEON_DISP2_MERGE_CNTL, disp_merge_cntl);
-
-                crtc_gen_cntl = RREG32(RADEON_CRTC2_GEN_CNTL) & 0xfffff0ff;
-                crtc_gen_cntl |= (format << 8);
-                WREG32(RADEON_CRTC2_GEN_CNTL, crtc_gen_cntl);
-                WREG32(RADEON_FP_H2_SYNC_STRT_WID,   RREG32(RADEON_CRTC2_H_SYNC_STRT_WID));
-                WREG32(RADEON_FP_V2_SYNC_STRT_WID,   RREG32(RADEON_CRTC2_V_SYNC_STRT_WID));
-                break;
-        }
-}
-
 int radeon_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                          struct drm_framebuffer *old_fb)
 {
@@ -755,7 +692,6 @@ static void radeon_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
         uint32_t post_divider = 0;
         uint32_t freq = 0;
         uint8_t pll_gain;
-        int pll_flags = RADEON_PLL_LEGACY;
         bool use_bios_divs = false;
         /* PLL registers */
         uint32_t pll_ref_div = 0;
@@ -789,10 +725,12 @@ static void radeon_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
         else
                 pll = &rdev->clock.p1pll;
 
+        pll->flags = RADEON_PLL_LEGACY;
+
         if (mode->clock > 200000) /* range limits??? */
-                pll_flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
+                pll->flags |= RADEON_PLL_PREFER_HIGH_FB_DIV;
         else
-                pll_flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
+                pll->flags |= RADEON_PLL_PREFER_LOW_REF_DIV;
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                 if (encoder->crtc == crtc) {
@@ -804,7 +742,7 @@ static void radeon_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
                         }
 
                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC)
-                                pll_flags |= RADEON_PLL_NO_ODD_POST_DIV;
+                                pll->flags |= RADEON_PLL_NO_ODD_POST_DIV;
                         if (encoder->encoder_type == DRM_MODE_ENCODER_LVDS) {
                                 if (!rdev->is_atom_bios) {
                                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
@@ -819,7 +757,7 @@ static void radeon_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
                                                 }
                                         }
                                 }
-                                pll_flags |= RADEON_PLL_USE_REF_DIV;
+                                pll->flags |= RADEON_PLL_USE_REF_DIV;
                         }
                 }
         }
@@ -829,8 +767,7 @@ static void radeon_set_pll(struct drm_crtc *crtc, struct drm_display_mode *mode)
         if (!use_bios_divs) {
                 radeon_compute_pll(pll, mode->clock,
                                    &freq, &feedback_div, &frac_fb_div,
-                                   &reference_div, &post_divider,
-                                   pll_flags);
+                                   &reference_div, &post_divider);
 
                 for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
                         if (post_div->divider == post_divider)
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h
index 91cb041cb40d..e81b2aeb6a8f 100644
--- a/drivers/gpu/drm/radeon/radeon_mode.h
+++ b/drivers/gpu/drm/radeon/radeon_mode.h
@@ -125,16 +125,24 @@ struct radeon_tmds_pll {
 #define RADEON_PLL_PREFER_HIGH_POST_DIV (1 << 9)
 #define RADEON_PLL_USE_FRAC_FB_DIV      (1 << 10)
 #define RADEON_PLL_PREFER_CLOSEST_LOWER (1 << 11)
+#define RADEON_PLL_USE_POST_DIV         (1 << 12)
 
 struct radeon_pll {
-        uint16_t reference_freq;
-        uint16_t reference_div;
+        /* reference frequency */
+        uint32_t reference_freq;
+
+        /* fixed dividers */
+        uint32_t reference_div;
+        uint32_t post_div;
+
+        /* pll in/out limits */
         uint32_t pll_in_min;
         uint32_t pll_in_max;
         uint32_t pll_out_min;
         uint32_t pll_out_max;
-        uint16_t xclk;
+        uint32_t best_vco;
 
+        /* divider limits */
         uint32_t min_ref_div;
         uint32_t max_ref_div;
         uint32_t min_post_div;
@@ -143,7 +151,12 @@ struct radeon_pll {
         uint32_t max_feedback_div;
         uint32_t min_frac_feedback_div;
         uint32_t max_frac_feedback_div;
-        uint32_t best_vco;
+
+        /* flags for the current clock */
+        uint32_t flags;
+
+        /* pll id */
+        uint32_t id;
 };
 
 struct radeon_i2c_chan {
@@ -286,7 +299,7 @@ struct radeon_atom_ss {
 struct radeon_encoder_atom_dig {
         /* atom dig */
         bool coherent_mode;
-        int dig_block;
+        int dig_encoder; /* -1 disabled, 0 DIGA, 1 DIGB */
         /* atom lvds */
         uint32_t lvds_misc;
         uint16_t panel_pwr_delay;
@@ -417,8 +430,7 @@ extern void radeon_compute_pll(struct radeon_pll *pll,
                                uint32_t *fb_div_p,
                                uint32_t *frac_fb_div_p,
                                uint32_t *ref_div_p,
-                               uint32_t *post_div_p,
-                               int flags);
+                               uint32_t *post_div_p);
 
 extern void radeon_compute_pll_avivo(struct radeon_pll *pll,
                                      uint64_t freq,
@@ -426,8 +438,7 @@ extern void radeon_compute_pll_avivo(struct radeon_pll *pll,
                                      uint32_t *fb_div_p,
                                      uint32_t *frac_fb_div_p,
                                      uint32_t *ref_div_p,
-                                     uint32_t *post_div_p,
-                                     int flags);
+                                     uint32_t *post_div_p);
 
 extern void radeon_setup_encoder_clones(struct drm_device *dev);
 
@@ -453,7 +464,6 @@ extern void atombios_crtc_dpms(struct drm_crtc *crtc, int mode);
 
 extern int radeon_crtc_set_base(struct drm_crtc *crtc, int x, int y,
                                  struct drm_framebuffer *old_fb);
-extern void radeon_legacy_atom_set_surface(struct drm_crtc *crtc);
 
 extern int radeon_crtc_cursor_set(struct drm_crtc *crtc,
                                   struct drm_file *file_priv,
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index 4e636de877b2..d72a71bff218 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -220,7 +220,8 @@ int radeon_bo_unpin(struct radeon_bo *bo)
 
 int radeon_bo_evict_vram(struct radeon_device *rdev)
 {
-        if (rdev->flags & RADEON_IS_IGP) {
+        /* late 2.6.33 fix IGP hibernate - we need pm ops to do this correct */
+        if (0 && (rdev->flags & RADEON_IS_IGP)) {
                 if (rdev->mc.igp_sideport_enabled == false)
                         /* Useless to evict on IGP chips */
                         return 0;
diff --git a/drivers/gpu/drm/radeon/reg_srcs/r200 b/drivers/gpu/drm/radeon/reg_srcs/r200
index 6021c8849a16..c29ac434ac9c 100644
--- a/drivers/gpu/drm/radeon/reg_srcs/r200
+++ b/drivers/gpu/drm/radeon/reg_srcs/r200
@@ -91,6 +91,8 @@ r200 0x3294
 0x22b8 SE_TCL_TEX_CYL_WRAP_CTL
 0x22c0 SE_TCL_UCP_VERT_BLEND_CNTL
 0x22c4 SE_TCL_POINT_SPRITE_CNTL
+0x22d0 SE_PVS_CNTL
+0x22d4 SE_PVS_CONST_CNTL
 0x2648 RE_POINTSIZE
 0x26c0 RE_TOP_LEFT
 0x26c4 RE_MISC
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index 59c71245fb91..afd9e8213c29 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -779,7 +779,6 @@ int rv770_mc_init(struct radeon_device *rdev)
         fixed20_12 a;
         u32 tmp;
         int chansize, numchan;
-        int r;
 
         /* Get VRAM informations */
         rdev->mc.vram_is_ddr = true;
@@ -822,9 +821,6 @@ int rv770_mc_init(struct radeon_device *rdev)
                 rdev->mc.real_vram_size = rdev->mc.aper_size;
 
         if (rdev->flags & RADEON_IS_AGP) {
-                r = radeon_agp_init(rdev);
-                if (r)
-                        return r;
                 /* gtt_size is setup by radeon_agp_init */
                 rdev->mc.gtt_location = rdev->mc.agp_base;
                 tmp = 0xFFFFFFFFUL - rdev->mc.agp_base - rdev->mc.gtt_size;
@@ -891,26 +887,19 @@ static int rv770_startup(struct radeon_device *rdev)
                         return r;
         }
         rv770_gpu_init(rdev);
-
-        if (!rdev->r600_blit.shader_obj) {
-                r = r600_blit_init(rdev);
+        /* pin copy shader into vram */
+        if (rdev->r600_blit.shader_obj) {
+                r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+                if (unlikely(r != 0))
+                        return r;
+                r = radeon_bo_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
+                                &rdev->r600_blit.shader_gpu_addr);
+                radeon_bo_unreserve(rdev->r600_blit.shader_obj);
                 if (r) {
-                        DRM_ERROR("radeon: failed blitter (%d).\n", r);
+                        DRM_ERROR("failed to pin blit object %d\n", r);
                         return r;
                 }
         }
-
-        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
-        if (unlikely(r != 0))
-                return r;
-        r = radeon_bo_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM,
-                        &rdev->r600_blit.shader_gpu_addr);
-        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
-        if (r) {
-                DRM_ERROR("failed to pin blit object %d\n", r);
-                return r;
-        }
-
         /* Enable IRQ */
         r = r600_irq_init(rdev);
         if (r) {
@@ -972,13 +961,16 @@ int rv770_suspend(struct radeon_device *rdev)
         /* FIXME: we should wait for ring to be empty */
         r700_cp_stop(rdev);
         rdev->cp.ready = false;
+        r600_irq_suspend(rdev);
         r600_wb_disable(rdev);
         rv770_pcie_gart_disable(rdev);
         /* unpin shaders bo */
-        r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
-        if (likely(r == 0)) {
-                radeon_bo_unpin(rdev->r600_blit.shader_obj);
-                radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+        if (rdev->r600_blit.shader_obj) {
+                r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false);
+                if (likely(r == 0)) {
+                        radeon_bo_unpin(rdev->r600_blit.shader_obj);
+                        radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+                }
         }
         return 0;
 }
@@ -1037,6 +1029,11 @@ int rv770_init(struct radeon_device *rdev)
         r = radeon_fence_driver_init(rdev);
         if (r)
                 return r;
+        if (rdev->flags & RADEON_IS_AGP) {
+                r = radeon_agp_init(rdev);
+                if (r)
+                        radeon_agp_disable(rdev);
+        }
         r = rv770_mc_init(rdev);
         if (r)
                 return r;
@@ -1058,6 +1055,12 @@ int rv770_init(struct radeon_device *rdev)
         r = r600_pcie_gart_init(rdev);
         if (r)
                 return r;
+        r = r600_blit_init(rdev);
+        if (r) {
+                r600_blit_fini(rdev);
+                rdev->asic->copy = NULL;
+                dev_warn(rdev->dev, "failed blitter (%d) falling back to memcpy\n", r);
+        }
 
         rdev->accel_working = true;
         r = rv770_startup(rdev);
@@ -1071,13 +1074,14 @@ int rv770_init(struct radeon_device *rdev)
         if (rdev->accel_working) {
                 r = radeon_ib_pool_init(rdev);
                 if (r) {
-                        DRM_ERROR("radeon: failed initializing IB pool (%d).\n", r);
-                        rdev->accel_working = false;
-                }
-                r = r600_ib_test(rdev);
-                if (r) {
-                        DRM_ERROR("radeon: failed testing IB (%d).\n", r);
+                        dev_err(rdev->dev, "IB initialization failed (%d).\n", r);
                         rdev->accel_working = false;
+                } else {
+                        r = r600_ib_test(rdev);
+                        if (r) {
+                                dev_err(rdev->dev, "IB test failed (%d).\n", r);
+                                rdev->accel_working = false;
+                        }
                 }
         }
         return 0;
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 2920f9a279e1..1a3e909b7bba 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -426,7 +426,8 @@ moved:
                     bdev->man[bo->mem.mem_type].gpu_offset;
                 bo->cur_placement = bo->mem.placement;
                 spin_unlock(&bo->lock);
-        }
+        } else
+                bo->offset = 0;
 
         return 0;
 
@@ -523,52 +524,44 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, bool remove_all)
 static int ttm_bo_delayed_delete(struct ttm_bo_device *bdev, bool remove_all)
 {
         struct ttm_bo_global *glob = bdev->glob;
-        struct ttm_buffer_object *entry, *nentry;
-        struct list_head *list, *next;
-        int ret;
+        struct ttm_buffer_object *entry = NULL;
+        int ret = 0;
 
         spin_lock(&glob->lru_lock);
-        list_for_each_safe(list, next, &bdev->ddestroy) {
-                entry = list_entry(list, struct ttm_buffer_object, ddestroy);
-                nentry = NULL;
+        if (list_empty(&bdev->ddestroy))
+                goto out_unlock;
 
-                /*
-                 * Protect the next list entry from destruction while we
-                 * unlock the lru_lock.
-                 */
+        entry = list_first_entry(&bdev->ddestroy,
+                struct ttm_buffer_object, ddestroy);
+        kref_get(&entry->list_kref);
 
-                if (next != &bdev->ddestroy) {
-                        nentry = list_entry(next, struct ttm_buffer_object,
-                                            ddestroy);
+        for (;;) {
+                struct ttm_buffer_object *nentry = NULL;
+
+                if (entry->ddestroy.next != &bdev->ddestroy) {
+                        nentry = list_first_entry(&entry->ddestroy,
+                                struct ttm_buffer_object, ddestroy);
                         kref_get(&nentry->list_kref);
                 }
-                kref_get(&entry->list_kref);
 
                 spin_unlock(&glob->lru_lock);
                 ret = ttm_bo_cleanup_refs(entry, remove_all);
                 kref_put(&entry->list_kref, ttm_bo_release_list);
+                entry = nentry;
+
+                if (ret || !entry)
+                        goto out;
 
                 spin_lock(&glob->lru_lock);
-                if (nentry) {
-                        bool next_onlist = !list_empty(next);
-                        spin_unlock(&glob->lru_lock);
-                        kref_put(&nentry->list_kref, ttm_bo_release_list);
-                        spin_lock(&glob->lru_lock);
-                        /*
-                         * Someone might have raced us and removed the
-                         * next entry from the list. We don't bother restarting
-                         * list traversal.
-                         */
-
-                        if (!next_onlist)
-                                break;
-                }
-                if (ret)
+                if (list_empty(&entry->ddestroy))
                         break;
         }
-        ret = !list_empty(&bdev->ddestroy);
-        spin_unlock(&glob->lru_lock);
 
+out_unlock:
+        spin_unlock(&glob->lru_lock);
+out:
+        if (entry)
+                kref_put(&entry->list_kref, ttm_bo_release_list);
         return ret;
 }
 
@@ -950,6 +943,14 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo,
                 ttm_flag_masked(&cur_flags, placement->busy_placement[i],
                                 ~TTM_PL_MASK_MEMTYPE);
 
+
+                if (mem_type == TTM_PL_SYSTEM) {
+                        mem->mem_type = mem_type;
+                        mem->placement = cur_flags;
+                        mem->mm_node = NULL;
+                        return 0;
+                }
+
                 ret = ttm_bo_mem_force_space(bo, mem_type, placement, mem,
                                                 interruptible, no_wait);
                 if (ret == 0 && mem->mm_node) {
@@ -1844,6 +1845,9 @@ static int ttm_bo_swapout(struct ttm_mem_shrink *shrink)
          * anyone tries to access a ttm page.
          */
 
+        if (bo->bdev->driver->swap_notify)
+                bo->bdev->driver->swap_notify(bo);
+
         ret = ttm_tt_swapout(bo->ttm, bo->persistant_swap_storage);
 out:
 
@@ -1864,3 +1868,4 @@ void ttm_bo_swapout_all(struct ttm_bo_device *bdev)
         while (ttm_bo_swapout(&bdev->glob->shrink) == 0)
                 ;
 }
+EXPORT_SYMBOL(ttm_bo_swapout_all);
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 2ecf7d0c64f6..5ca37a58a98c 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -53,7 +53,6 @@ int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
 {
         struct ttm_tt *ttm = bo->ttm;
         struct ttm_mem_reg *old_mem = &bo->mem;
-        uint32_t save_flags = old_mem->placement;
         int ret;
 
         if (old_mem->mem_type != TTM_PL_SYSTEM) {
@@ -62,7 +61,6 @@ int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
                 ttm_flag_masked(&old_mem->placement, TTM_PL_FLAG_SYSTEM,
                                 TTM_PL_MASK_MEM);
                 old_mem->mem_type = TTM_PL_SYSTEM;
-                save_flags = old_mem->placement;
         }
 
         ret = ttm_tt_set_placement_caching(ttm, new_mem->placement);
@@ -77,7 +75,7 @@ int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
 
         *old_mem = *new_mem;
         new_mem->mm_node = NULL;
-        ttm_flag_masked(&save_flags, new_mem->placement, TTM_PL_MASK_MEMTYPE);
+
         return 0;
 }
 EXPORT_SYMBOL(ttm_bo_move_ttm);
@@ -219,7 +217,6 @@ int ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
         void *old_iomap;
         void *new_iomap;
         int ret;
-        uint32_t save_flags = old_mem->placement;
         unsigned long i;
         unsigned long page;
         unsigned long add = 0;
@@ -270,7 +267,6 @@ out2:
 
         *old_mem = *new_mem;
         new_mem->mm_node = NULL;
-        ttm_flag_masked(&save_flags, new_mem->placement, TTM_PL_MASK_MEMTYPE);
 
         if ((man->flags & TTM_MEMTYPE_FLAG_FIXED) && (ttm != NULL)) {
                 ttm_tt_unbind(ttm);
@@ -537,7 +533,6 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
         struct ttm_mem_type_manager *man = &bdev->man[new_mem->mem_type];
         struct ttm_mem_reg *old_mem = &bo->mem;
         int ret;
-        uint32_t save_flags = old_mem->placement;
         struct ttm_buffer_object *ghost_obj;
         void *tmp_obj = NULL;
 
@@ -598,7 +593,7 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
 
         *old_mem = *new_mem;
         new_mem->mm_node = NULL;
-        ttm_flag_masked(&save_flags, new_mem->placement, TTM_PL_MASK_MEMTYPE);
+
         return 0;
 }
 EXPORT_SYMBOL(ttm_bo_move_accel_cleanup);
diff --git a/drivers/gpu/drm/ttm/ttm_lock.c b/drivers/gpu/drm/ttm/ttm_lock.c
index f619ebcaa4ec..3d172ef04ee1 100644
--- a/drivers/gpu/drm/ttm/ttm_lock.c
+++ b/drivers/gpu/drm/ttm/ttm_lock.c
@@ -288,6 +288,7 @@ void ttm_suspend_unlock(struct ttm_lock *lock)
         wake_up_all(&lock->queue);
         spin_unlock(&lock->lock);
 }
+EXPORT_SYMBOL(ttm_suspend_unlock);
 
 static bool __ttm_suspend_lock(struct ttm_lock *lock)
 {
@@ -309,3 +310,4 @@ void ttm_suspend_lock(struct ttm_lock *lock)
 {
         wait_event(lock->queue, __ttm_suspend_lock(lock));
 }
+EXPORT_SYMBOL(ttm_suspend_lock);
diff --git a/drivers/gpu/drm/ttm/ttm_object.c b/drivers/gpu/drm/ttm/ttm_object.c
index 1099abac824b..75e9d6f86ba4 100644
--- a/drivers/gpu/drm/ttm/ttm_object.c
+++ b/drivers/gpu/drm/ttm/ttm_object.c
@@ -109,8 +109,8 @@ struct ttm_ref_object {
         struct drm_hash_item hash;
         struct list_head head;
         struct kref kref;
-        struct ttm_base_object *obj;
         enum ttm_ref_type ref_type;
+        struct ttm_base_object *obj;
         struct ttm_object_file *tfile;
 };
 
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index 9c2b1cc5dba5..e2123af7775a 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -198,17 +198,26 @@ EXPORT_SYMBOL(ttm_tt_populate);
 static inline int ttm_tt_set_page_caching(struct page *p,
                                           enum ttm_caching_state c_state)
 {
+        int ret = 0;
+
         if (PageHighMem(p))
                 return 0;
 
-        switch (c_state) {
-        case tt_cached:
-                return set_pages_wb(p, 1);
-        case tt_wc:
-            return set_memory_wc((unsigned long) page_address(p), 1);
-        default:
-                return set_pages_uc(p, 1);
+        if (get_page_memtype(p) != -1) {
+                /* p isn't in the default caching state, set it to
+                 * writeback first to free its current memtype. */
+
+                ret = set_pages_wb(p, 1);
+                if (ret)
+                        return ret;
         }
+
+        if (c_state == tt_wc)
+                ret = set_memory_wc((unsigned long) page_address(p), 1);
+        else if (c_state == tt_uncached)
+                ret = set_pages_uc(p, 1);
+
+        return ret;
 }
 #else /* CONFIG_X86 */
 static inline int ttm_tt_set_page_caching(struct page *p,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c b/drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c
index d6f2d2b882e9..825ebe3d89d5 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c
@@ -48,6 +48,15 @@ struct ttm_placement vmw_vram_placement = {
         .busy_placement = &vram_placement_flags
 };
 
+struct ttm_placement vmw_vram_sys_placement = {
+        .fpfn = 0,
+        .lpfn = 0,
+        .num_placement = 1,
+        .placement = &vram_placement_flags,
+        .num_busy_placement = 1,
+        .busy_placement = &sys_placement_flags
+};
+
 struct ttm_placement vmw_vram_ne_placement = {
         .fpfn = 0,
         .lpfn = 0,
@@ -172,6 +181,18 @@ static int vmw_verify_access(struct ttm_buffer_object *bo, struct file *filp)
         return 0;
 }
 
+static void vmw_move_notify(struct ttm_buffer_object *bo,
+                     struct ttm_mem_reg *new_mem)
+{
+        if (new_mem->mem_type != TTM_PL_SYSTEM)
+                vmw_dmabuf_gmr_unbind(bo);
+}
+
+static void vmw_swap_notify(struct ttm_buffer_object *bo)
+{
+        vmw_dmabuf_gmr_unbind(bo);
+}
+
 /**
  * FIXME: We're using the old vmware polling method to sync.
  * Do this with fences instead.
@@ -225,5 +246,7 @@ struct ttm_bo_driver vmw_bo_driver = {
         .sync_obj_wait = vmw_sync_obj_wait,
         .sync_obj_flush = vmw_sync_obj_flush,
         .sync_obj_unref = vmw_sync_obj_unref,
-        .sync_obj_ref = vmw_sync_obj_ref
+        .sync_obj_ref = vmw_sync_obj_ref,
+        .move_notify = vmw_move_notify,
+        .swap_notify = vmw_swap_notify
 };
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index 1db1ef30be2b..a6e8f687fa64 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -147,6 +147,8 @@ static char *vmw_devname = "vmwgfx";
 
 static int vmw_probe(struct pci_dev *, const struct pci_device_id *);
 static void vmw_master_init(struct vmw_master *);
+static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
+                              void *ptr);
 
 static void vmw_print_capabilities(uint32_t capabilities)
 {
@@ -207,6 +209,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
 {
         struct vmw_private *dev_priv;
         int ret;
+        uint32_t svga_id;
 
         dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
         if (unlikely(dev_priv == NULL)) {
@@ -217,6 +220,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
 
         dev_priv->dev = dev;
         dev_priv->vmw_chipset = chipset;
+        dev_priv->last_read_sequence = (uint32_t) -100;
         mutex_init(&dev_priv->hw_mutex);
         mutex_init(&dev_priv->cmdbuf_mutex);
         rwlock_init(&dev_priv->resource_lock);
@@ -236,6 +240,16 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
         dev_priv->mmio_start = pci_resource_start(dev->pdev, 2);
 
         mutex_lock(&dev_priv->hw_mutex);
+
+        vmw_write(dev_priv, SVGA_REG_ID, SVGA_ID_2);
+        svga_id = vmw_read(dev_priv, SVGA_REG_ID);
+        if (svga_id != SVGA_ID_2) {
+                ret = -ENOSYS;
+                DRM_ERROR("Unsuported SVGA ID 0x%x\n", svga_id);
+                mutex_unlock(&dev_priv->hw_mutex);
+                goto out_err0;
+        }
+
         dev_priv->capabilities = vmw_read(dev_priv, SVGA_REG_CAPABILITIES);
 
         if (dev_priv->capabilities & SVGA_CAP_GMR) {
@@ -351,6 +365,11 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
                 vmw_fb_init(dev_priv);
         }
 
+        dev_priv->pm_nb.notifier_call = vmwgfx_pm_notifier;
+        register_pm_notifier(&dev_priv->pm_nb);
+
+        DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ? "Have 3D\n" : "No 3D\n");
+
         return 0;
 
 out_no_device:
@@ -385,6 +404,8 @@ static int vmw_driver_unload(struct drm_device *dev)
 
         DRM_INFO(VMWGFX_DRIVER_NAME " unload.\n");
 
+        unregister_pm_notifier(&dev_priv->pm_nb);
+
         if (!dev_priv->stealth) {
                 vmw_fb_close(dev_priv);
                 vmw_kms_close(dev_priv);
@@ -650,6 +671,57 @@ static void vmw_remove(struct pci_dev *pdev)
         drm_put_dev(dev);
 }
 
+static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
+                              void *ptr)
+{
+        struct vmw_private *dev_priv =
+                container_of(nb, struct vmw_private, pm_nb);
+        struct vmw_master *vmaster = dev_priv->active_master;
+
+        switch (val) {
+        case PM_HIBERNATION_PREPARE:
+        case PM_SUSPEND_PREPARE:
+                ttm_suspend_lock(&vmaster->lock);
+
+                /**
+                 * This empties VRAM and unbinds all GMR bindings.
+                 * Buffer contents is moved to swappable memory.
+                 */
+                ttm_bo_swapout_all(&dev_priv->bdev);
+                break;
+        case PM_POST_HIBERNATION:
+        case PM_POST_SUSPEND:
+                ttm_suspend_unlock(&vmaster->lock);
+                break;
+        case PM_RESTORE_PREPARE:
+                break;
+        case PM_POST_RESTORE:
+                break;
+        default:
+                break;
+        }
+        return 0;
+}
+
+/**
+ * These might not be needed with the virtual SVGA device.
+ */
+
+int vmw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        pci_save_state(pdev);
+        pci_disable_device(pdev);
+        pci_set_power_state(pdev, PCI_D3hot);
+        return 0;
+}
+
+int vmw_pci_resume(struct pci_dev *pdev)
+{
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+        return pci_enable_device(pdev);
+}
+
 static struct drm_driver driver = {
         .driver_features = DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
         DRIVER_MODESET,
@@ -689,7 +761,9 @@ static struct drm_driver driver = {
                        .name = VMWGFX_DRIVER_NAME,
                        .id_table = vmw_pci_id_list,
                        .probe = vmw_probe,
-                       .remove = vmw_remove
+                       .remove = vmw_remove,
+                       .suspend = vmw_pci_suspend,
+                       .resume = vmw_pci_resume
                        },
         .name = VMWGFX_DRIVER_NAME,
         .desc = VMWGFX_DRIVER_DESC,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index e61bd85b6975..135be9688c90 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -32,6 +32,7 @@
 #include "drmP.h"
 #include "vmwgfx_drm.h"
 #include "drm_hashtab.h"
+#include "linux/suspend.h"
 #include "ttm/ttm_bo_driver.h"
 #include "ttm/ttm_object.h"
 #include "ttm/ttm_lock.h"
@@ -95,6 +96,8 @@ struct vmw_surface {
         struct drm_vmw_size *sizes;
         uint32_t num_sizes;
 
+        bool scanout;
+
         /* TODO so far just a extra pointer */
         struct vmw_cursor_snooper snooper;
 };
@@ -258,6 +261,7 @@ struct vmw_private {
 
         struct vmw_master *active_master;
         struct vmw_master fbdev_master;
+        struct notifier_block pm_nb;
 };
 
 static inline struct vmw_private *vmw_priv(struct drm_device *dev)
@@ -353,6 +357,7 @@ extern int vmw_dmabuf_to_start_of_vram(struct vmw_private *vmw_priv,
                                        struct vmw_dma_buffer *bo);
 extern int vmw_dmabuf_from_vram(struct vmw_private *vmw_priv,
                                 struct vmw_dma_buffer *bo);
+extern void vmw_dmabuf_gmr_unbind(struct ttm_buffer_object *bo);
 extern int vmw_stream_claim_ioctl(struct drm_device *dev, void *data,
                                   struct drm_file *file_priv);
 extern int vmw_stream_unref_ioctl(struct drm_device *dev, void *data,
@@ -386,6 +391,7 @@ extern int vmw_fifo_send_fence(struct vmw_private *dev_priv,
                                uint32_t *sequence);
 extern void vmw_fifo_ping_host(struct vmw_private *dev_priv, uint32_t reason);
 extern int vmw_fifo_mmap(struct file *filp, struct vm_area_struct *vma);
+extern bool vmw_fifo_have_3d(struct vmw_private *dev_priv);
 
 /**
  * TTM glue - vmwgfx_ttm_glue.c
@@ -401,6 +407,7 @@ extern int vmw_mmap(struct file *filp, struct vm_area_struct *vma);
 
 extern struct ttm_placement vmw_vram_placement;
 extern struct ttm_placement vmw_vram_ne_placement;
+extern struct ttm_placement vmw_vram_sys_placement;
 extern struct ttm_placement vmw_sys_placement;
 extern struct ttm_bo_driver vmw_bo_driver;
 extern int vmw_dma_quiescent(struct drm_device *dev);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
index 2e92da567403..d69caf92ffe7 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
@@ -490,10 +490,29 @@ static int vmw_validate_single_buffer(struct vmw_private *dev_priv,
         if (vmw_dmabuf_gmr(bo) != SVGA_GMR_NULL)
                 return 0;
 
+        /**
+         * Put BO in VRAM, only if there is space.
+         */
+
+        ret = ttm_bo_validate(bo, &vmw_vram_sys_placement, true, false);
+        if (unlikely(ret == -ERESTARTSYS))
+                return ret;
+
+        /**
+         * Otherwise, set it up as GMR.
+         */
+
+        if (vmw_dmabuf_gmr(bo) != SVGA_GMR_NULL)
+                return 0;
+
         ret = vmw_gmr_bind(dev_priv, bo);
         if (likely(ret == 0 || ret == -ERESTARTSYS))
                 return ret;
 
+        /**
+         * If that failed, try VRAM again, this time evicting
+         * previous contents.
+         */
 
         ret = ttm_bo_validate(bo, &vmw_vram_placement, true, false);
         return ret;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
index 641dde76ada1..4f4f6432be8b 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
@@ -649,14 +649,6 @@ int vmw_dmabuf_to_start_of_vram(struct vmw_private *vmw_priv,
         if (unlikely(ret != 0))
                 goto err_unlock;
 
-        if (vmw_bo->gmr_bound) {
-                vmw_gmr_unbind(vmw_priv, vmw_bo->gmr_id);
-                spin_lock(&bo->glob->lru_lock);
-                ida_remove(&vmw_priv->gmr_ida, vmw_bo->gmr_id);
-                spin_unlock(&bo->glob->lru_lock);
-                vmw_bo->gmr_bound = NULL;
-        }
-
         ret = ttm_bo_validate(bo, &ne_placement, false, false);
         ttm_bo_unreserve(bo);
 err_unlock:
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
index 01feb48af333..4157547cc6e4 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fifo.c
@@ -29,6 +29,25 @@
 #include "drmP.h"
 #include "ttm/ttm_placement.h"
 
+bool vmw_fifo_have_3d(struct vmw_private *dev_priv)
+{
+        __le32 __iomem *fifo_mem = dev_priv->mmio_virt;
+        uint32_t fifo_min, hwversion;
+
+        fifo_min = ioread32(fifo_mem  + SVGA_FIFO_MIN);
+        if (fifo_min <= SVGA_FIFO_3D_HWVERSION * sizeof(unsigned int))
+                return false;
+
+        hwversion = ioread32(fifo_mem + SVGA_FIFO_3D_HWVERSION);
+        if (hwversion == 0)
+                return false;
+
+        if (hwversion < SVGA3D_HWVERSION_WS65_B1)
+                return false;
+
+        return true;
+}
+
 int vmw_fifo_init(struct vmw_private *dev_priv, struct vmw_fifo_state *fifo)
 {
         __le32 __iomem *fifo_mem = dev_priv->mmio_virt;
@@ -98,8 +117,7 @@ int vmw_fifo_init(struct vmw_private *dev_priv, struct vmw_fifo_state *fifo)
                  (unsigned int) min,
                  (unsigned int) fifo->capabilities);
 
-        dev_priv->fence_seq = (uint32_t) -100;
-        dev_priv->last_read_sequence = (uint32_t) -100;
+        dev_priv->fence_seq = dev_priv->last_read_sequence;
         iowrite32(dev_priv->last_read_sequence, fifo_mem + SVGA_FIFO_FENCE);
 
         return vmw_fifo_send_fence(dev_priv, &dummy);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
index 5fa6a4ed238a..778851f9f1d6 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
@@ -43,7 +43,7 @@ int vmw_getparam_ioctl(struct drm_device *dev, void *data,
                 param->value = vmw_overlay_num_free_overlays(dev_priv);
                 break;
         case DRM_VMW_PARAM_3D:
-                param->value = dev_priv->capabilities & SVGA_CAP_3D ? 1 : 0;
+                param->value = vmw_fifo_have_3d(dev_priv) ? 1 : 0;
                 break;
         case DRM_VMW_PARAM_FIFO_OFFSET:
                 param->value = dev_priv->mmio_start;
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index b1af76e371c3..eeba6d1d06e4 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -553,9 +553,7 @@ int vmw_framebuffer_dmabuf_dirty(struct drm_framebuffer *framebuffer,
         } *cmd;
         int i, increment = 1;
 
-        if (!num_clips ||
-            !(dev_priv->fifo.capabilities &
-              SVGA_FIFO_CAP_SCREEN_OBJECT)) {
+        if (!num_clips) {
                 num_clips = 1;
                 clips = &norect;
                 norect.x1 = norect.y1 = 0;
@@ -574,10 +572,10 @@ int vmw_framebuffer_dmabuf_dirty(struct drm_framebuffer *framebuffer,
 
         for (i = 0; i < num_clips; i++, clips += increment) {
                 cmd[i].header = cpu_to_le32(SVGA_CMD_UPDATE);
-                cmd[i].body.x = cpu_to_le32(clips[i].x1);
-                cmd[i].body.y = cpu_to_le32(clips[i].y1);
-                cmd[i].body.width = cpu_to_le32(clips[i].x2 - clips[i].x1);
-                cmd[i].body.height = cpu_to_le32(clips[i].y2 - clips[i].y1);
+                cmd[i].body.x = cpu_to_le32(clips->x1);
+                cmd[i].body.y = cpu_to_le32(clips->y1);
+                cmd[i].body.width = cpu_to_le32(clips->x2 - clips->x1);
+                cmd[i].body.height = cpu_to_le32(clips->y2 - clips->y1);
         }
 
         vmw_fifo_commit(dev_priv, sizeof(*cmd) * num_clips);
@@ -709,6 +707,9 @@ static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
         if (ret)
                 goto try_dmabuf;
 
+        if (!surface->scanout)
+                goto err_not_scanout;
+
         ret = vmw_kms_new_framebuffer_surface(dev_priv, surface, &vfb,
                                               mode_cmd->width, mode_cmd->height);
 
@@ -742,6 +743,13 @@ try_dmabuf:
         }
 
         return &vfb->base;
+
+err_not_scanout:
+        DRM_ERROR("surface not marked as scanout\n");
+        /* vmw_user_surface_lookup takes one ref */
+        vmw_surface_unreference(&surface);
+
+        return NULL;
 }
 
 static int vmw_kms_fb_changed(struct drm_device *dev)
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c b/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c
index bb6e6a096d25..5b6eabeb7f51 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c
@@ -104,7 +104,6 @@ static int vmw_dmabuf_pin_in_vram(struct vmw_private *dev_priv,
                                   bool pin, bool interruptible)
 {
         struct ttm_buffer_object *bo = &buf->base;
-        struct ttm_bo_global *glob = bo->glob;
         struct ttm_placement *overlay_placement = &vmw_vram_placement;
         int ret;
 
@@ -116,14 +115,6 @@ static int vmw_dmabuf_pin_in_vram(struct vmw_private *dev_priv,
         if (unlikely(ret != 0))
                 goto err;
 
-        if (buf->gmr_bound) {
-                vmw_gmr_unbind(dev_priv, buf->gmr_id);
-                spin_lock(&glob->lru_lock);
-                ida_remove(&dev_priv->gmr_ida, buf->gmr_id);
-                spin_unlock(&glob->lru_lock);
-                buf->gmr_bound = NULL;
-        }
-
         if (pin)
                 overlay_placement = &vmw_vram_ne_placement;
 
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
index c012d5927f65..c7efbd47ab84 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c
@@ -35,6 +35,11 @@
 #define VMW_RES_SURFACE ttm_driver_type1
 #define VMW_RES_STREAM ttm_driver_type2
 
+/* XXX: This isn't a real hardware flag, but just a hack for kernel to
+ * know about primary surfaces. Find a better way to accomplish this.
+ */
+#define SVGA3D_SURFACE_HINT_SCANOUT (1 << 9)
+
 struct vmw_user_context {
         struct ttm_base_object base;
         struct vmw_resource res;
@@ -599,6 +604,36 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
         if (unlikely(ret != 0))
                 goto out_err1;
 
+        if (srf->flags & SVGA3D_SURFACE_HINT_SCANOUT) {
+                /* we should not send this flag down to hardware since
+                 * its not a official one
+                 */
+                srf->flags &= ~SVGA3D_SURFACE_HINT_SCANOUT;
+                srf->scanout = true;
+        } else {
+                srf->scanout = false;
+        }
+
+        if (srf->scanout &&
+            srf->num_sizes == 1 &&
+            srf->sizes[0].width == 64 &&
+            srf->sizes[0].height == 64 &&
+            srf->format == SVGA3D_A8R8G8B8) {
+
+                srf->snooper.image = kmalloc(64 * 64 * 4, GFP_KERNEL);
+                /* clear the image */
+                if (srf->snooper.image) {
+                        memset(srf->snooper.image, 0x00, 64 * 64 * 4);
+                } else {
+                        DRM_ERROR("Failed to allocate cursor_image\n");
+                        ret = -ENOMEM;
+                        goto out_err1;
+                }
+        } else {
+                srf->snooper.image = NULL;
+        }
+        srf->snooper.crtc = NULL;
+
         user_srf->base.shareable = false;
         user_srf->base.tfile = NULL;
 
@@ -622,24 +657,6 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
                 return ret;
         }
 
-        if (srf->flags & (1 << 9) &&
-            srf->num_sizes == 1 &&
-            srf->sizes[0].width == 64 &&
-            srf->sizes[0].height == 64 &&
-            srf->format == SVGA3D_A8R8G8B8) {
-
-                srf->snooper.image = kmalloc(64 * 64 * 4, GFP_KERNEL);
-                /* clear the image */
-                if (srf->snooper.image)
-                        memset(srf->snooper.image, 0x00, 64 * 64 * 4);
-                else
-                        DRM_ERROR("Failed to allocate cursor_image\n");
-
-        } else {
-                srf->snooper.image = NULL;
-        }
-        srf->snooper.crtc = NULL;
-
         rep->sid = user_srf->base.hash.key;
         if (rep->sid == SVGA3D_INVALID_ID)
                 DRM_ERROR("Created bad Surface ID.\n");
@@ -754,20 +771,29 @@ static size_t vmw_dmabuf_acc_size(struct ttm_bo_global *glob,
         return bo_user_size + page_array_size;
 }
 
-void vmw_dmabuf_bo_free(struct ttm_buffer_object *bo)
+void vmw_dmabuf_gmr_unbind(struct ttm_buffer_object *bo)
 {
         struct vmw_dma_buffer *vmw_bo = vmw_dma_buffer(bo);
         struct ttm_bo_global *glob = bo->glob;
         struct vmw_private *dev_priv =
                 container_of(bo->bdev, struct vmw_private, bdev);
 
-        ttm_mem_global_free(glob->mem_glob, bo->acc_size);
         if (vmw_bo->gmr_bound) {
                 vmw_gmr_unbind(dev_priv, vmw_bo->gmr_id);
                 spin_lock(&glob->lru_lock);
                 ida_remove(&dev_priv->gmr_ida, vmw_bo->gmr_id);
                 spin_unlock(&glob->lru_lock);
+                vmw_bo->gmr_bound = false;
         }
+}
+
+void vmw_dmabuf_bo_free(struct ttm_buffer_object *bo)
+{
+        struct vmw_dma_buffer *vmw_bo = vmw_dma_buffer(bo);
+        struct ttm_bo_global *glob = bo->glob;
+
+        vmw_dmabuf_gmr_unbind(bo);
+        ttm_mem_global_free(glob->mem_glob, bo->acc_size);
         kfree(vmw_bo);
 }
 
@@ -813,18 +839,10 @@ int vmw_dmabuf_init(struct vmw_private *dev_priv,
 static void vmw_user_dmabuf_destroy(struct ttm_buffer_object *bo)
 {
         struct vmw_user_dma_buffer *vmw_user_bo = vmw_user_dma_buffer(bo);
-        struct vmw_dma_buffer *vmw_bo = &vmw_user_bo->dma;
         struct ttm_bo_global *glob = bo->glob;
-        struct vmw_private *dev_priv =
-                container_of(bo->bdev, struct vmw_private, bdev);
 
+        vmw_dmabuf_gmr_unbind(bo);
         ttm_mem_global_free(glob->mem_glob, bo->acc_size);
-        if (vmw_bo->gmr_bound) {
-                vmw_gmr_unbind(dev_priv, vmw_bo->gmr_id);
-                spin_lock(&glob->lru_lock);
-                ida_remove(&dev_priv->gmr_ida, vmw_bo->gmr_id);
-                spin_unlock(&glob->lru_lock);
-        }
         kfree(vmw_user_bo);
 }
 
@@ -868,7 +886,7 @@ int vmw_dmabuf_alloc_ioctl(struct drm_device *dev, void *data,
         }
 
         ret = vmw_dmabuf_init(dev_priv, &vmw_user_bo->dma, req->size,
-                              &vmw_vram_placement, true,
+                              &vmw_vram_sys_placement, true,
                               &vmw_user_dmabuf_destroy);
         if (unlikely(ret != 0))
                 return ret;
diff --git a/drivers/hwmon/amc6821.c b/drivers/hwmon/amc6821.c
index 1c89d922d619..fa9708c2d723 100644
--- a/drivers/hwmon/amc6821.c
+++ b/drivers/hwmon/amc6821.c
@@ -686,7 +686,6 @@ static ssize_t set_fan1_div(
                 data->fan1_div = 4;
                 break;
         default:
-                mutex_unlock(&data->update_lock);
                 count = -EINVAL;
                 goto EXIT;
         }
diff --git a/drivers/hwmon/asus_atk0110.c b/drivers/hwmon/asus_atk0110.c
index 6811346c1c62..028284f544e3 100644
--- a/drivers/hwmon/asus_atk0110.c
+++ b/drivers/hwmon/asus_atk0110.c
@@ -1329,17 +1329,16 @@ static int atk_add(struct acpi_device *device)
                         &buf, ACPI_TYPE_PACKAGE);
         if (ret != AE_OK) {
                 dev_dbg(&device->dev, "atk: method MBIF not found\n");
-                err = -ENODEV;
-                goto out;
-        }
-
-        obj = buf.pointer;
-        if (obj->package.count >= 2 &&
-                        obj->package.elements[1].type == ACPI_TYPE_STRING) {
-                dev_dbg(&device->dev, "board ID = %s\n",
-                                obj->package.elements[1].string.pointer);
+        } else {
+                obj = buf.pointer;
+                if (obj->package.count >= 2) {
+                        union acpi_object *id = &obj->package.elements[1];
+                        if (id->type == ACPI_TYPE_STRING)
+                                dev_dbg(&device->dev, "board ID = %s\n",
+                                        id->string.pointer);
+                }
+                ACPI_FREE(buf.pointer);
         }
-        ACPI_FREE(buf.pointer);
 
         err = atk_probe_if(data);
         if (err) {
diff --git a/drivers/hwmon/fschmd.c b/drivers/hwmon/fschmd.c
index bd0fc67e804b..fa0728232e71 100644
--- a/drivers/hwmon/fschmd.c
+++ b/drivers/hwmon/fschmd.c
@@ -768,6 +768,7 @@ leave:
 static int watchdog_open(struct inode *inode, struct file *filp)
 {
         struct fschmd_data *pos, *data = NULL;
+        int watchdog_is_open;
 
         /* We get called from drivers/char/misc.c with misc_mtx hold, and we
            call misc_register() from fschmd_probe() with watchdog_data_mutex
@@ -782,10 +783,12 @@ static int watchdog_open(struct inode *inode, struct file *filp)
                 }
         }
         /* Note we can never not have found data, so we don't check for this */
-        kref_get(&data->kref);
+        watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
+        if (!watchdog_is_open)
+                kref_get(&data->kref);
         mutex_unlock(&watchdog_data_mutex);
 
-        if (test_and_set_bit(0, &data->watchdog_is_open))
+        if (watchdog_is_open)
                 return -EBUSY;
 
         /* Start the watchdog */
diff --git a/drivers/hwmon/smsc47m1.c b/drivers/hwmon/smsc47m1.c
index 9ca97818bd4b..8fa462f2b570 100644
--- a/drivers/hwmon/smsc47m1.c
+++ b/drivers/hwmon/smsc47m1.c
@@ -488,7 +488,7 @@ static int __init smsc47m1_find(unsigned short *addr,
 }
 
 /* Restore device to its initial state */
-static void __init smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
+static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
 {
         if ((sio_data->activate & 0x01) == 0) {
                 superio_enter();
diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index e3654d683e15..75bf820e7ccb 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -226,7 +226,6 @@ static void i2c_imx_stop(struct imx_i2c_struct *i2c_imx)
                 temp = readb(i2c_imx->base + IMX_I2C_I2CR);
                 temp &= ~(I2CR_MSTA | I2CR_MTX);
                 writeb(temp, i2c_imx->base + IMX_I2C_I2CR);
-                i2c_imx->stopped = 1;
         }
         if (cpu_is_mx1()) {
                 /*
@@ -236,8 +235,10 @@ static void i2c_imx_stop(struct imx_i2c_struct *i2c_imx)
                 udelay(i2c_imx->disable_delay);
         }
 
-        if (!i2c_imx->stopped)
+        if (!i2c_imx->stopped) {
                 i2c_imx_bus_busy(i2c_imx, 0);
+                i2c_imx->stopped = 1;
+        }
 
         /* Disable I2C controller */
         writeb(0, i2c_imx->base + IMX_I2C_I2CR);
@@ -496,22 +497,23 @@ static int __init i2c_imx_probe(struct platform_device *pdev)
         }
 
         res_size = resource_size(res);
+
+        if (!request_mem_region(res->start, res_size, DRIVER_NAME)) {
+                ret = -EBUSY;
+                goto fail0;
+        }
+
         base = ioremap(res->start, res_size);
         if (!base) {
                 dev_err(&pdev->dev, "ioremap failed\n");
                 ret = -EIO;
-                goto fail0;
+                goto fail1;
         }
 
         i2c_imx = kzalloc(sizeof(struct imx_i2c_struct), GFP_KERNEL);
         if (!i2c_imx) {
                 dev_err(&pdev->dev, "can't allocate interface\n");
                 ret = -ENOMEM;
-                goto fail1;
-        }
-
-        if (!request_mem_region(res->start, res_size, DRIVER_NAME)) {
-                ret = -EBUSY;
                 goto fail2;
         }
 
@@ -582,11 +584,11 @@ fail5:
 fail4:
         clk_put(i2c_imx->clk);
 fail3:
-        release_mem_region(i2c_imx->res->start, resource_size(res));
-fail2:
         kfree(i2c_imx);
-fail1:
+fail2:
         iounmap(base);
+fail1:
+        release_mem_region(res->start, resource_size(res));
 fail0:
         if (pdata && pdata->exit)
                 pdata->exit(&pdev->dev);
@@ -618,8 +620,8 @@ static int __exit i2c_imx_remove(struct platform_device *pdev)
 
         clk_put(i2c_imx->clk);
 
-        release_mem_region(i2c_imx->res->start, resource_size(i2c_imx->res));
         iounmap(i2c_imx->base);
+        release_mem_region(i2c_imx->res->start, resource_size(i2c_imx->res));
         kfree(i2c_imx);
         return 0;
 }
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index b3684060465e..100da8542bba 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -346,10 +346,8 @@ static int ipathfs_fill_super(struct super_block *sb, void *data,
         list_for_each_entry_safe(dd, tmp, &ipath_dev_list, ipath_list) {
                 spin_unlock_irqrestore(&ipath_devs_lock, flags);
                 ret = create_device_files(sb, dd);
-                if (ret) {
-                        deactivate_locked_super(sb);
+                if (ret)
                         goto bail;
-                }
                 spin_lock_irqsave(&ipath_devs_lock, flags);
         }
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 30b503b8d67b..86cb2d2196ff 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -46,6 +46,7 @@ static unsigned int input_abs_bypass_init_data[] __initdata = {
         ABS_MT_TOOL_TYPE,
         ABS_MT_BLOB_ID,
         ABS_MT_TRACKING_ID,
+        ABS_MT_PRESSURE,
         0
 };
 static unsigned long input_abs_bypass[BITS_TO_LONGS(ABS_CNT)];
diff --git a/drivers/input/misc/winbond-cir.c b/drivers/input/misc/winbond-cir.c
index 33309fe44e20..c8f5a9a3fa14 100644
--- a/drivers/input/misc/winbond-cir.c
+++ b/drivers/input/misc/winbond-cir.c
@@ -768,7 +768,7 @@ wbcir_parse_rc6(struct device *dev, struct wbcir_data *data)
                 return;
         }
 
-        dev_info(dev, "IR-RC6 ad 0x%02X cm 0x%02X cu 0x%04X "
+        dev_dbg(dev, "IR-RC6 ad 0x%02X cm 0x%02X cu 0x%04X "
                 "toggle %u mode %u scan 0x%08X\n",
                 address,
                 command,
diff --git a/drivers/input/mouse/lifebook.c b/drivers/input/mouse/lifebook.c
index 6d7aa10d10f0..7c1d7d420ae3 100644
--- a/drivers/input/mouse/lifebook.c
+++ b/drivers/input/mouse/lifebook.c
@@ -53,6 +53,12 @@ static const struct dmi_system_id __initconst lifebook_dmi_table[] = {
         {
                 /* LifeBook B */
                 .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Lifebook B Series"),
+                },
+        },
+        {
+                /* LifeBook B */
+                .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook B Series"),
                 },
         },
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index c21e6d3a8844..794d070c6900 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -47,6 +47,7 @@
 #include <linux/workqueue.h>
 #include <linux/spi/spi.h>
 #include <linux/i2c.h>
+#include <linux/gpio.h>
 
 #include <linux/spi/ad7879.h>
 
@@ -132,7 +133,9 @@ struct ad7879 {
         struct input_dev        *input;
         struct work_struct      work;
         struct timer_list       timer;
-
+#ifdef CONFIG_GPIOLIB
+        struct gpio_chip        gc;
+#endif
         struct mutex            mutex;
         unsigned                disabled:1;     /* P: mutex */
 
@@ -150,11 +153,9 @@ struct ad7879 {
         u8                      median;
         u16                     x_plate_ohms;
         u16                     pressure_max;
-        u16                     gpio_init;
         u16                     cmd_crtl1;
         u16                     cmd_crtl2;
         u16                     cmd_crtl3;
-        unsigned                gpio:1;
 };
 
 static int ad7879_read(bus_device *, u8);
@@ -237,24 +238,6 @@ static irqreturn_t ad7879_irq(int irq, void *handle)
 
 static void ad7879_setup(struct ad7879 *ts)
 {
-        ts->cmd_crtl3 = AD7879_YPLUS_BIT |
-                        AD7879_XPLUS_BIT |
-                        AD7879_Z2_BIT |
-                        AD7879_Z1_BIT |
-                        AD7879_TEMPMASK_BIT |
-                        AD7879_AUXVBATMASK_BIT |
-                        AD7879_GPIOALERTMASK_BIT;
-
-        ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
-                        AD7879_AVG(ts->averaging) |
-                        AD7879_MFS(ts->median) |
-                        AD7879_FCD(ts->first_conversion_delay) |
-                        ts->gpio_init;
-
-        ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
-                        AD7879_ACQ(ts->acquisition_time) |
-                        AD7879_TMR(ts->pen_down_acc_interval);
-
         ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
         ad7879_write(ts->bus, AD7879_REG_CTRL3, ts->cmd_crtl3);
         ad7879_write(ts->bus, AD7879_REG_CTRL1, ts->cmd_crtl1);
@@ -324,48 +307,132 @@ static ssize_t ad7879_disable_store(struct device *dev,
 
 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store);
 
-static ssize_t ad7879_gpio_show(struct device *dev,
-                                     struct device_attribute *attr, char *buf)
+static struct attribute *ad7879_attributes[] = {
+        &dev_attr_disable.attr,
+        NULL
+};
+
+static const struct attribute_group ad7879_attr_group = {
+        .attrs = ad7879_attributes,
+};
+
+#ifdef CONFIG_GPIOLIB
+static int ad7879_gpio_direction_input(struct gpio_chip *chip,
+                                        unsigned gpio)
 {
-        struct ad7879 *ts = dev_get_drvdata(dev);
+        struct ad7879 *ts = container_of(chip, struct ad7879, gc);
+        int err;
 
-        return sprintf(buf, "%u\n", ts->gpio);
+        mutex_lock(&ts->mutex);
+        ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
+        err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        mutex_unlock(&ts->mutex);
+
+        return err;
 }
 
-static ssize_t ad7879_gpio_store(struct device *dev,
-                                     struct device_attribute *attr,
-                                     const char *buf, size_t count)
+static int ad7879_gpio_direction_output(struct gpio_chip *chip,
+                                        unsigned gpio, int level)
 {
-        struct ad7879 *ts = dev_get_drvdata(dev);
-        unsigned long val;
-        int error;
+        struct ad7879 *ts = container_of(chip, struct ad7879, gc);
+        int err;
 
-        error = strict_strtoul(buf, 10, &val);
-        if (error)
-                return error;
+        mutex_lock(&ts->mutex);
+        ts->cmd_crtl2 &= ~AD7879_GPIODIR;
+        ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL;
+        if (level)
+                ts->cmd_crtl2 |= AD7879_GPIO_DATA;
+        else
+                ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
+
+        err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        mutex_unlock(&ts->mutex);
+
+        return err;
+}
+
+static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
+{
+        struct ad7879 *ts = container_of(chip, struct ad7879, gc);
+        u16 val;
 
         mutex_lock(&ts->mutex);
-        ts->gpio = !!val;
-        error = ad7879_write(ts->bus, AD7879_REG_CTRL2,
-                           ts->gpio ?
-                                ts->cmd_crtl2 & ~AD7879_GPIO_DATA :
-                                ts->cmd_crtl2 | AD7879_GPIO_DATA);
+        val = ad7879_read(ts->bus, AD7879_REG_CTRL2);
         mutex_unlock(&ts->mutex);
 
-        return error ? : count;
+        return !!(val & AD7879_GPIO_DATA);
 }
 
-static DEVICE_ATTR(gpio, 0664, ad7879_gpio_show, ad7879_gpio_store);
+static void ad7879_gpio_set_value(struct gpio_chip *chip,
+                                  unsigned gpio, int value)
+{
+        struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 
-static struct attribute *ad7879_attributes[] = {
-        &dev_attr_disable.attr,
-        &dev_attr_gpio.attr,
-        NULL
-};
+        mutex_lock(&ts->mutex);
+        if (value)
+                ts->cmd_crtl2 |= AD7879_GPIO_DATA;
+        else
+                ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 
-static const struct attribute_group ad7879_attr_group = {
-        .attrs = ad7879_attributes,
-};
+        ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        mutex_unlock(&ts->mutex);
+}
+
+static int __devinit ad7879_gpio_add(struct device *dev)
+{
+        struct ad7879 *ts = dev_get_drvdata(dev);
+        struct ad7879_platform_data *pdata = dev->platform_data;
+        int ret = 0;
+
+        if (pdata->gpio_export) {
+                ts->gc.direction_input = ad7879_gpio_direction_input;
+                ts->gc.direction_output = ad7879_gpio_direction_output;
+                ts->gc.get = ad7879_gpio_get_value;
+                ts->gc.set = ad7879_gpio_set_value;
+                ts->gc.can_sleep = 1;
+                ts->gc.base = pdata->gpio_base;
+                ts->gc.ngpio = 1;
+                ts->gc.label = "AD7879-GPIO";
+                ts->gc.owner = THIS_MODULE;
+                ts->gc.dev = dev;
+
+                ret = gpiochip_add(&ts->gc);
+                if (ret)
+                        dev_err(dev, "failed to register gpio %d\n",
+                                ts->gc.base);
+        }
+
+        return ret;
+}
+
+/*
+ * We mark ad7879_gpio_remove inline so there is a chance the code
+ * gets discarded when not needed. We can't do __devinit/__devexit
+ * markup since it is used in both probe and remove methods.
+ */
+static inline void ad7879_gpio_remove(struct device *dev)
+{
+        struct ad7879 *ts = dev_get_drvdata(dev);
+        struct ad7879_platform_data *pdata = dev->platform_data;
+        int ret;
+
+        if (pdata->gpio_export) {
+                ret = gpiochip_remove(&ts->gc);
+                if (ret)
+                        dev_err(dev, "failed to remove gpio %d\n",
+                                ts->gc.base);
+        }
+}
+#else
+static inline int ad7879_gpio_add(struct device *dev)
+{
+        return 0;
+}
+
+static inline void ad7879_gpio_remove(struct device *dev)
+{
+}
+#endif
 
 static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
 {
@@ -403,12 +470,6 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
         ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
         ts->median = pdata->median;
 
-        if (pdata->gpio_output)
-                ts->gpio_init = AD7879_GPIO_EN |
-                                (pdata->gpio_default ? 0 : AD7879_GPIO_DATA);
-        else
-                ts->gpio_init = AD7879_GPIO_EN | AD7879_GPIODIR;
-
         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&bus->dev));
 
         input_dev->name = "AD7879 Touchscreen";
@@ -446,6 +507,23 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
                 goto err_free_mem;
         }
 
+        ts->cmd_crtl3 = AD7879_YPLUS_BIT |
+                        AD7879_XPLUS_BIT |
+                        AD7879_Z2_BIT |
+                        AD7879_Z1_BIT |
+                        AD7879_TEMPMASK_BIT |
+                        AD7879_AUXVBATMASK_BIT |
+                        AD7879_GPIOALERTMASK_BIT;
+
+        ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
+                        AD7879_AVG(ts->averaging) |
+                        AD7879_MFS(ts->median) |
+                        AD7879_FCD(ts->first_conversion_delay);
+
+        ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
+                        AD7879_ACQ(ts->acquisition_time) |
+                        AD7879_TMR(ts->pen_down_acc_interval);
+
         ad7879_setup(ts);
 
         err = request_irq(bus->irq, ad7879_irq,
@@ -460,15 +538,21 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
         if (err)
                 goto err_free_irq;
 
-        err = input_register_device(input_dev);
+        err = ad7879_gpio_add(&bus->dev);
         if (err)
                 goto err_remove_attr;
 
+        err = input_register_device(input_dev);
+        if (err)
+                goto err_remove_gpio;
+
         dev_info(&bus->dev, "Rev.%d touchscreen, irq %d\n",
                  revid >> 8, bus->irq);
 
         return 0;
 
+err_remove_gpio:
+        ad7879_gpio_remove(&bus->dev);
 err_remove_attr:
         sysfs_remove_group(&bus->dev.kobj, &ad7879_attr_group);
 err_free_irq:
@@ -481,6 +565,7 @@ err_free_mem:
 
 static int __devexit ad7879_destroy(bus_device *bus, struct ad7879 *ts)
 {
+        ad7879_gpio_remove(&bus->dev);
         ad7879_disable(ts);
         sysfs_remove_group(&ts->bus->dev.kobj, &ad7879_attr_group);
         free_irq(ts->bus->irq, ts);
diff --git a/drivers/media/common/saa7146_video.c b/drivers/media/common/saa7146_video.c
index becbaadb3b77..5ed75263340a 100644
--- a/drivers/media/common/saa7146_video.c
+++ b/drivers/media/common/saa7146_video.c
@@ -1333,9 +1333,9 @@ static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
 
         DEB_CAP(("vbuf:%p\n",vb));
 
-        release_all_pagetables(dev, buf);
-
         saa7146_dma_free(dev,q,buf);
+
+        release_all_pagetables(dev, buf);
 }
 
 static struct videobuf_queue_ops video_qops = {
diff --git a/drivers/media/video/saa7134/saa7134-empress.c b/drivers/media/video/saa7134/saa7134-empress.c
index 7dfecfc6017c..ee5bff02a92c 100644
--- a/drivers/media/video/saa7134/saa7134-empress.c
+++ b/drivers/media/video/saa7134/saa7134-empress.c
@@ -93,9 +93,9 @@ static int ts_open(struct file *file)
         dprintk("open dev=%s\n", video_device_node_name(vdev));
         err = -EBUSY;
         if (!mutex_trylock(&dev->empress_tsq.vb_lock))
-                goto done;
+                return err;
         if (atomic_read(&dev->empress_users))
-                goto done_up;
+                goto done;
 
         /* Unmute audio */
         saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
@@ -105,10 +105,8 @@ static int ts_open(struct file *file)
         file->private_data = dev;
         err = 0;
 
-done_up:
-        mutex_unlock(&dev->empress_tsq.vb_lock);
 done:
-        unlock_kernel();
+        mutex_unlock(&dev->empress_tsq.vb_lock);
         return err;
 }
 
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 85bc6a685e36..44d2037e9e56 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -4330,6 +4330,8 @@ initChainBuffers(MPT_ADAPTER *ioc)
 
         if (ioc->bus_type == SPI)
                 num_chain *= MPT_SCSI_CAN_QUEUE;
+        else if (ioc->bus_type == SAS)
+                num_chain *= MPT_SAS_CAN_QUEUE;
         else
                 num_chain *= MPT_FC_CAN_QUEUE;
 
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 8f0d18409ede..e09eb4870db6 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -3,7 +3,7 @@
 #
 
 obj-$(CONFIG_MFD_SM501)         += sm501.o
-obj-$(CONFIG_MFD_ASIC3)         += asic3.o
+obj-$(CONFIG_MFD_ASIC3)         += asic3.o tmio_core.o
 obj-$(CONFIG_MFD_SH_MOBILE_SDHI)                += sh_mobile_sdhi.o
 
 obj-$(CONFIG_HTC_EGPIO)         += htc-egpio.o
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 4c364d44ad59..2de0cc823d60 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -549,4 +549,21 @@ config MTD_VMU
           To build this as a module select M here, the module will be called
           vmu-flash.
 
+config MTD_PISMO
+        tristate "MTD discovery driver for PISMO modules"
+        depends on I2C
+        depends on ARCH_VERSATILE
+        help
+          This driver allows for discovery of PISMO modules - see
+          <http://www.pismoworld.org/>.  These are small modules containing
+          up to five memory devices (eg, SRAM, flash, DOC) described by an
+          I2C EEPROM.
+
+          This driver does not create any MTD maps itself; instead it
+          creates MTD physmap and MTD SRAM platform devices.  If you
+          enable this option, you should consider enabling MTD_PHYSMAP
+          and/or MTD_PLATRAM according to the devices on your module.
+
+          When built as a module, it will be called pismo.ko
+
 endmenu
diff --git a/drivers/mtd/maps/pismo.c b/drivers/mtd/maps/pismo.c
new file mode 100644
index 000000000000..c48cad271f5d
--- /dev/null
+++ b/drivers/mtd/maps/pismo.c
@@ -0,0 +1,320 @@
+/*
+ * PISMO memory driver - http://www.pismoworld.org/
+ *
+ * For ARM Realview and Versatile platforms
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License.
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <linux/mtd/physmap.h>
+#include <linux/mtd/plat-ram.h>
+#include <linux/mtd/pismo.h>
+
+#define PISMO_NUM_CS    5
+
+struct pismo_cs_block {
+        u8      type;
+        u8      width;
+        __le16  access;
+        __le32  size;
+        u32     reserved[2];
+        char    device[32];
+} __packed;
+
+struct pismo_eeprom {
+        struct pismo_cs_block cs[PISMO_NUM_CS];
+        char    board[15];
+        u8      sum;
+} __packed;
+
+struct pismo_mem {
+        phys_addr_t base;
+        u32     size;
+        u16     access;
+        u8      width;
+        u8      type;
+};
+
+struct pismo_data {
+        struct i2c_client       *client;
+        void                    (*vpp)(void *, int);
+        void                    *vpp_data;
+        struct platform_device  *dev[PISMO_NUM_CS];
+};
+
+/* FIXME: set_vpp could do with a better calling convention */
+static struct pismo_data *vpp_pismo;
+static DEFINE_MUTEX(pismo_mutex);
+
+static int pismo_setvpp_probe_fix(struct pismo_data *pismo)
+{
+        mutex_lock(&pismo_mutex);
+        if (vpp_pismo) {
+                mutex_unlock(&pismo_mutex);
+                kfree(pismo);
+                return -EBUSY;
+        }
+        vpp_pismo = pismo;
+        mutex_unlock(&pismo_mutex);
+        return 0;
+}
+
+static void pismo_setvpp_remove_fix(struct pismo_data *pismo)
+{
+        mutex_lock(&pismo_mutex);
+        if (vpp_pismo == pismo)
+                vpp_pismo = NULL;
+        mutex_unlock(&pismo_mutex);
+}
+
+static void pismo_set_vpp(struct map_info *map, int on)
+{
+        struct pismo_data *pismo = vpp_pismo;
+
+        pismo->vpp(pismo->vpp_data, on);
+}
+/* end of hack */
+
+
+static unsigned int __devinit pismo_width_to_bytes(unsigned int width)
+{
+        width &= 15;
+        if (width > 2)
+                return 0;
+        return 1 << width;
+}
+
+static int __devinit pismo_eeprom_read(struct i2c_client *client, void *buf,
+        u8 addr, size_t size)
+{
+        int ret;
+        struct i2c_msg msg[] = {
+                {
+                        .addr = client->addr,
+                        .len = sizeof(addr),
+                        .buf = &addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = size,
+                        .buf = buf,
+                },
+        };
+
+        ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
+
+        return ret == ARRAY_SIZE(msg) ? size : -EIO;
+}
+
+static int __devinit pismo_add_device(struct pismo_data *pismo, int i,
+        struct pismo_mem *region, const char *name, void *pdata, size_t psize)
+{
+        struct platform_device *dev;
+        struct resource res = { };
+        phys_addr_t base = region.base;
+        int ret;
+
+        if (base == ~0)
+                return -ENXIO;
+
+        res.start = base;
+        res.end = base + region->size - 1;
+        res.flags = IORESOURCE_MEM;
+
+        dev = platform_device_alloc(name, i);
+        if (!dev)
+                return -ENOMEM;
+        dev->dev.parent = &pismo->client->dev;
+
+        do {
+                ret = platform_device_add_resources(dev, &res, 1);
+                if (ret)
+                        break;
+
+                ret = platform_device_add_data(dev, pdata, psize);
+                if (ret)
+                        break;
+
+                ret = platform_device_add(dev);
+                if (ret)
+                        break;
+
+                pismo->dev[i] = dev;
+                return 0;
+        } while (0);
+
+        platform_device_put(dev);
+        return ret;
+}
+
+static int __devinit pismo_add_nor(struct pismo_data *pismo, int i,
+        struct pismo_mem *region)
+{
+        struct physmap_flash_data data = {
+                .width = region->width,
+        };
+
+        if (pismo->vpp)
+                data.set_vpp = pismo_set_vpp;
+
+        return pismo_add_device(pismo, i, region, "physmap-flash",
+                &data, sizeof(data));
+}
+
+static int __devinit pismo_add_sram(struct pismo_data *pismo, int i,
+        struct pismo_mem *region)
+{
+        struct platdata_mtd_ram data = {
+                .bankwidth = region->width,
+        };
+
+        return pismo_add_device(pismo, i, region, "mtd-ram",
+                &data, sizeof(data));
+}
+
+static void __devinit pismo_add_one(struct pismo_data *pismo, int i,
+        const struct pismo_cs_block *cs, phys_addr_t base)
+{
+        struct device *dev = &pismo->client->dev;
+        struct pismo_mem region;
+
+        region.base = base;
+        region.type = cs->type;
+        region.width = pismo_width_to_bytes(cs->width);
+        region.access = le16_to_cpu(cs->access);
+        region.size = le32_to_cpu(cs->size);
+
+        if (region.width == 0) {
+                dev_err(dev, "cs%u: bad width: %02x, ignoring\n", i, cs->width);
+                return;
+        }
+
+        /*
+         * FIXME: may need to the platforms memory controller here, but at
+         * the moment we assume that it has already been correctly setup.
+         * The memory controller can also tell us the base address as well.
+         */
+
+        dev_info(dev, "cs%u: %.32s: type %02x access %u00ps size %uK\n",
+                i, cs->device, region.type, region.access, region.size / 1024);
+
+        switch (region.type) {
+        case 0:
+                break;
+        case 1:
+                /* static DOC */
+                break;
+        case 2:
+                /* static NOR */
+                pismo_add_nor(pismo, i, &region);
+                break;
+        case 3:
+                /* static RAM */
+                pismo_add_sram(pismo, i, &region);
+                break;
+        }
+}
+
+static int __devexit pismo_remove(struct i2c_client *client)
+{
+        struct pismo_data *pismo = i2c_get_clientdata(client);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(pismo->dev); i++)
+                platform_device_unregister(pismo->dev[i]);
+
+        /* FIXME: set_vpp needs saner arguments */
+        pismo_setvpp_remove_fix(pismo);
+
+        kfree(pismo);
+
+        return 0;
+}
+
+static int __devinit pismo_probe(struct i2c_client *client,
+                                 const struct i2c_device_id *id)
+{
+        struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+        struct pismo_pdata *pdata = client->dev.platform_data;
+        struct pismo_eeprom eeprom;
+        struct pismo_data *pismo;
+        int ret, i;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                dev_err(&client->dev, "functionality mismatch\n");
+                return -EIO;
+        }
+
+        pismo = kzalloc(sizeof(*pismo), GFP_KERNEL);
+        if (!pismo)
+                return -ENOMEM;
+
+        /* FIXME: set_vpp needs saner arguments */
+        ret = pismo_setvpp_probe_fix(pismo);
+        if (ret)
+                return ret;
+
+        pismo->client = client;
+        if (pdata) {
+                pismo->vpp = pdata->set_vpp;
+                pismo->vpp_data = pdata->vpp_data;
+        }
+        i2c_set_clientdata(client, pismo);
+
+        ret = pismo_eeprom_read(client, &eeprom, 0, sizeof(eeprom));
+        if (ret < 0) {
+                dev_err(&client->dev, "error reading EEPROM: %d\n", ret);
+                return ret;
+        }
+
+        dev_info(&client->dev, "%.15s board found\n", eeprom.board);
+
+        for (i = 0; i < ARRAY_SIZE(eeprom.cs); i++)
+                if (eeprom.cs[i].type != 0xff)
+                        pismo_add_one(pismo, i, &eeprom.cs[i],
+                                      pdata->cs_addrs[i]);
+
+        return 0;
+}
+
+static const struct i2c_device_id pismo_id[] = {
+        { "pismo" },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, pismo_id);
+
+static struct i2c_driver pismo_driver = {
+        .driver = {
+                .name   = "pismo",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = pismo_probe,
+        .remove         = __devexit_p(pismo_remove),
+        .id_table       = pismo_id,
+};
+
+static int __init pismo_init(void)
+{
+        BUILD_BUG_ON(sizeof(struct pismo_cs_block) != 48);
+        BUILD_BUG_ON(sizeof(struct pismo_eeprom) != 256);
+
+        return i2c_add_driver(&pismo_driver);
+}
+module_init(pismo_init);
+
+static void __exit pismo_exit(void)
+{
+        i2c_del_driver(&pismo_driver);
+}
+module_exit(pismo_exit);
+
+MODULE_AUTHOR("Russell King <linux@arm.linux.org.uk>");
+MODULE_DESCRIPTION("PISMO memory driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
index a714ec482761..92e12df0917f 100644
--- a/drivers/mtd/mtdoops.c
+++ b/drivers/mtd/mtdoops.c
@@ -322,7 +322,7 @@ static void mtdoops_do_dump(struct kmsg_dumper *dumper,
         memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy);
 
         /* Panics must be written immediately */
-        if (reason == KMSG_DUMP_PANIC) {
+        if (reason != KMSG_DUMP_OOPS) {
                 if (!cxt->mtd->panic_write)
                         printk(KERN_ERR "mtdoops: Cannot write from panic without panic_write\n");
                 else
diff --git a/drivers/mtd/tests/mtd_readtest.c b/drivers/mtd/tests/mtd_readtest.c
index 79fc4530987b..25c5dd03a837 100644
--- a/drivers/mtd/tests/mtd_readtest.c
+++ b/drivers/mtd/tests/mtd_readtest.c
@@ -147,6 +147,10 @@ static int scan_for_bad_eraseblocks(void)
         }
         memset(bbt, 0 , ebcnt);
 
+        /* NOR flash does not implement block_isbad */
+        if (mtd->block_isbad == NULL)
+                return 0;
+
         printk(PRINT_PREF "scanning for bad eraseblocks\n");
         for (i = 0; i < ebcnt; ++i) {
                 bbt[i] = is_block_bad(i) ? 1 : 0;
@@ -184,7 +188,7 @@ static int __init mtd_readtest_init(void)
         tmp = mtd->size;
         do_div(tmp, mtd->erasesize);
         ebcnt = tmp;
-        pgcnt = mtd->erasesize / mtd->writesize;
+        pgcnt = mtd->erasesize / pgsize;
 
         printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
                "page size %u, count of eraseblocks %u, pages per "
diff --git a/drivers/mtd/tests/mtd_speedtest.c b/drivers/mtd/tests/mtd_speedtest.c
index 141363a7e805..7fbb51d4eabe 100644
--- a/drivers/mtd/tests/mtd_speedtest.c
+++ b/drivers/mtd/tests/mtd_speedtest.c
@@ -301,6 +301,10 @@ static int scan_for_bad_eraseblocks(void)
         }
         memset(bbt, 0 , ebcnt);
 
+        /* NOR flash does not implement block_isbad */
+        if (mtd->block_isbad == NULL)
+                goto out;
+
         printk(PRINT_PREF "scanning for bad eraseblocks\n");
         for (i = 0; i < ebcnt; ++i) {
                 bbt[i] = is_block_bad(i) ? 1 : 0;
@@ -309,6 +313,7 @@ static int scan_for_bad_eraseblocks(void)
                 cond_resched();
         }
         printk(PRINT_PREF "scanned %d eraseblocks, %d are bad\n", i, bad);
+out:
         goodebcnt = ebcnt - bad;
         return 0;
 }
@@ -340,7 +345,7 @@ static int __init mtd_speedtest_init(void)
         tmp = mtd->size;
         do_div(tmp, mtd->erasesize);
         ebcnt = tmp;
-        pgcnt = mtd->erasesize / mtd->writesize;
+        pgcnt = mtd->erasesize / pgsize;
 
         printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
                "page size %u, count of eraseblocks %u, pages per "
diff --git a/drivers/mtd/tests/mtd_stresstest.c b/drivers/mtd/tests/mtd_stresstest.c
index 63920476b57a..a99d3cd737d8 100644
--- a/drivers/mtd/tests/mtd_stresstest.c
+++ b/drivers/mtd/tests/mtd_stresstest.c
@@ -227,6 +227,10 @@ static int scan_for_bad_eraseblocks(void)
         }
         memset(bbt, 0 , ebcnt);
 
+        /* NOR flash does not implement block_isbad */
+        if (mtd->block_isbad == NULL)
+                return 0;
+
         printk(PRINT_PREF "scanning for bad eraseblocks\n");
         for (i = 0; i < ebcnt; ++i) {
                 bbt[i] = is_block_bad(i) ? 1 : 0;
@@ -265,7 +269,7 @@ static int __init mtd_stresstest_init(void)
         tmp = mtd->size;
         do_div(tmp, mtd->erasesize);
         ebcnt = tmp;
-        pgcnt = mtd->erasesize / mtd->writesize;
+        pgcnt = mtd->erasesize / pgsize;
 
         printk(PRINT_PREF "MTD device size %llu, eraseblock size %u, "
                "page size %u, count of eraseblocks %u, pages per "
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index f237ddbb2713..111ea41c4ecd 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -853,7 +853,6 @@ static long ubi_cdev_ioctl(struct file *file, unsigned int cmd,
                         break;
                 }
 
-                req.name[req.name_len] = '\0';
                 err = verify_mkvol_req(ubi, &req);
                 if (err)
                         break;
diff --git a/drivers/mtd/ubi/kapi.c b/drivers/mtd/ubi/kapi.c
index 277786ebaa2c..1361574e2b00 100644
--- a/drivers/mtd/ubi/kapi.c
+++ b/drivers/mtd/ubi/kapi.c
@@ -291,8 +291,7 @@ EXPORT_SYMBOL_GPL(ubi_open_volume_nm);
  */
 struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode)
 {
-        int error, ubi_num, vol_id;
-        struct ubi_volume_desc *ret;
+        int error, ubi_num, vol_id, mod;
         struct inode *inode;
         struct path path;
 
@@ -306,16 +305,16 @@ struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode)
                 return ERR_PTR(error);
 
         inode = path.dentry->d_inode;
+        mod = inode->i_mode;
         ubi_num = ubi_major2num(imajor(inode));
         vol_id = iminor(inode) - 1;
+        path_put(&path);
 
+        if (!S_ISCHR(mod))
+                return ERR_PTR(-EINVAL);
         if (vol_id >= 0 && ubi_num >= 0)
-                ret = ubi_open_volume(ubi_num, vol_id, mode);
-        else
-                ret = ERR_PTR(-ENODEV);
-
-        path_put(&path);
-        return ret;
+                return ubi_open_volume(ubi_num, vol_id, mode);
+        return ERR_PTR(-ENODEV);
 }
 EXPORT_SYMBOL_GPL(ubi_open_volume_path);
 
diff --git a/drivers/mtd/ubi/upd.c b/drivers/mtd/ubi/upd.c
index c1d7b880c795..425bf5a3edd4 100644
--- a/drivers/mtd/ubi/upd.c
+++ b/drivers/mtd/ubi/upd.c
@@ -155,6 +155,7 @@ int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
                 if (err)
                         return err;
                 vol->updating = 0;
+                return 0;
         }
 
         vol->upd_buf = vmalloc(ubi->leb_size);
diff --git a/drivers/mtd/ubi/vtbl.c b/drivers/mtd/ubi/vtbl.c
index 1afc61e7455d..40044028d682 100644
--- a/drivers/mtd/ubi/vtbl.c
+++ b/drivers/mtd/ubi/vtbl.c
@@ -566,6 +566,7 @@ static int init_volumes(struct ubi_device *ubi, const struct ubi_scan_info *si,
                 vol->reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
                 vol->alignment = be32_to_cpu(vtbl[i].alignment);
                 vol->data_pad = be32_to_cpu(vtbl[i].data_pad);
+                vol->upd_marker = vtbl[i].upd_marker;
                 vol->vol_type = vtbl[i].vol_type == UBI_VID_DYNAMIC ?
                                         UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
                 vol->name_len = be16_to_cpu(vtbl[i].name_len);
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 9fd8e5ecd5d7..5bc74590c73e 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -276,8 +276,13 @@ struct be_adapter {
         int link_speed;
         u8 port_type;
         u8 transceiver;
+        u8 generation;          /* BladeEngine ASIC generation */
 };
 
+/* BladeEngine Generation numbers */
+#define BE_GEN2 2
+#define BE_GEN3 3
+
 extern const struct ethtool_ops be_ethtool_ops;
 
 #define drvr_stats(adapter)             (&adapter->stats.drvr_stats)
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index 102ade134165..fee6eee7ae5b 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -286,7 +286,7 @@ static void be_wrb_hdr_prepare(struct be_mcc_wrb *wrb, int payload_len,
                                 MCC_WRB_SGE_CNT_SHIFT;
         wrb->payload_length = payload_len;
         wrb->tag0 = opcode;
-        be_dws_cpu_to_le(wrb, 20);
+        be_dws_cpu_to_le(wrb, 8);
 }
 
 /* Don't touch the hdr after it's prepared */
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index c002b8391b4d..13b33c841083 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -164,7 +164,8 @@ struct be_cmd_req_hdr {
         u8 domain;              /* dword 0 */
         u32 timeout;            /* dword 1 */
         u32 request_length;     /* dword 2 */
-        u32 rsvd;               /* dword 3 */
+        u8 version;             /* dword 3 */
+        u8 rsvd[3];             /* dword 3 */
 };
 
 #define RESP_HDR_INFO_OPCODE_SHIFT      0       /* bits 0 - 7 */
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 3a1f7902c16d..626b76c0ebc7 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -910,7 +910,7 @@ static inline struct page *be_alloc_pages(u32 size)
 static void be_post_rx_frags(struct be_adapter *adapter)
 {
         struct be_rx_page_info *page_info_tbl = adapter->rx_obj.page_info_tbl;
-        struct be_rx_page_info *page_info = NULL;
+        struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
         struct be_queue_info *rxq = &adapter->rx_obj.q;
         struct page *pagep = NULL;
         struct be_eth_rx_d *rxd;
@@ -941,7 +941,6 @@ static void be_post_rx_frags(struct be_adapter *adapter)
                 rxd = queue_head_node(rxq);
                 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
                 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
-                queue_head_inc(rxq);
 
                 /* Any space left in the current big page for another frag? */
                 if ((page_offset + rx_frag_size + rx_frag_size) >
@@ -949,10 +948,13 @@ static void be_post_rx_frags(struct be_adapter *adapter)
                         pagep = NULL;
                         page_info->last_page_user = true;
                 }
+
+                prev_page_info = page_info;
+                queue_head_inc(rxq);
                 page_info = &page_info_tbl[rxq->head];
         }
         if (pagep)
-                page_info->last_page_user = true;
+                prev_page_info->last_page_user = true;
 
         if (posted) {
                 atomic_add(posted, &rxq->used);
@@ -1348,7 +1350,7 @@ static irqreturn_t be_intx(int irq, void *dev)
         int isr;
 
         isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
-                        be_pci_func(adapter) * CEV_ISR_SIZE);
+                (adapter->tx_eq.q.id/ 8) * CEV_ISR_SIZE);
         if (!isr)
                 return IRQ_NONE;
 
@@ -2049,6 +2051,7 @@ static void be_unmap_pci_bars(struct be_adapter *adapter)
 static int be_map_pci_bars(struct be_adapter *adapter)
 {
         u8 __iomem *addr;
+        int pcicfg_reg;
 
         addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
                         pci_resource_len(adapter->pdev, 2));
@@ -2062,8 +2065,13 @@ static int be_map_pci_bars(struct be_adapter *adapter)
                 goto pci_map_err;
         adapter->db = addr;
 
-        addr = ioremap_nocache(pci_resource_start(adapter->pdev, 1),
-                        pci_resource_len(adapter->pdev, 1));
+        if (adapter->generation == BE_GEN2)
+                pcicfg_reg = 1;
+        else
+                pcicfg_reg = 0;
+
+        addr = ioremap_nocache(pci_resource_start(adapter->pdev, pcicfg_reg),
+                        pci_resource_len(adapter->pdev, pcicfg_reg));
         if (addr == NULL)
                 goto pci_map_err;
         adapter->pcicfg = addr;
@@ -2160,6 +2168,7 @@ static int be_stats_init(struct be_adapter *adapter)
         cmd->va = pci_alloc_consistent(adapter->pdev, cmd->size, &cmd->dma);
         if (cmd->va == NULL)
                 return -1;
+        memset(cmd->va, 0, cmd->size);
         return 0;
 }
 
@@ -2238,6 +2247,20 @@ static int __devinit be_probe(struct pci_dev *pdev,
                 goto rel_reg;
         }
         adapter = netdev_priv(netdev);
+
+        switch (pdev->device) {
+        case BE_DEVICE_ID1:
+        case OC_DEVICE_ID1:
+                adapter->generation = BE_GEN2;
+                break;
+        case BE_DEVICE_ID2:
+        case OC_DEVICE_ID2:
+                adapter->generation = BE_GEN3;
+                break;
+        default:
+                adapter->generation = 0;
+        }
+
         adapter->pdev = pdev;
         pci_set_drvdata(pdev, adapter);
         adapter->netdev = netdev;
diff --git a/drivers/net/bfin_mac.c b/drivers/net/bfin_mac.c
index 8ffea3990d07..0b23bc4f56c6 100644
--- a/drivers/net/bfin_mac.c
+++ b/drivers/net/bfin_mac.c
@@ -33,6 +33,7 @@
 #include <asm/dma.h>
 #include <linux/dma-mapping.h>
 
+#include <asm/dpmc.h>
 #include <asm/blackfin.h>
 #include <asm/cacheflush.h>
 #include <asm/portmux.h>
@@ -386,8 +387,8 @@ static int mii_probe(struct net_device *dev)
         u32 sclk, mdc_div;
 
         /* Enable PHY output early */
-        if (!(bfin_read_VR_CTL() & PHYCLKOE))
-                bfin_write_VR_CTL(bfin_read_VR_CTL() | PHYCLKOE);
+        if (!(bfin_read_VR_CTL() & CLKBUFOE))
+                bfin_write_VR_CTL(bfin_read_VR_CTL() | CLKBUFOE);
 
         sclk = get_sclk();
         mdc_div = ((sclk / MDC_CLK) / 2) - 1;
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 3f0071cfe56b..efa0e41bf3ec 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3639,7 +3639,7 @@ static int bond_open(struct net_device *bond_dev)
                  */
                 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
                         /* something went wrong - fail the open operation */
-                        return -1;
+                        return -ENOMEM;
                 }
 
                 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
diff --git a/drivers/net/e1000/e1000.h b/drivers/net/e1000/e1000.h
index 2a567df3ea71..e8932db7ee77 100644
--- a/drivers/net/e1000/e1000.h
+++ b/drivers/net/e1000/e1000.h
@@ -326,6 +326,8 @@ struct e1000_adapter {
         /* for ioport free */
         int bars;
         int need_ioport;
+
+        bool discarding;
 };
 
 enum e1000_state_t {
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 7e855f9bbd97..d29bb532eccf 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -1698,18 +1698,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
         rctl &= ~E1000_RCTL_SZ_4096;
         rctl |= E1000_RCTL_BSEX;
         switch (adapter->rx_buffer_len) {
-                case E1000_RXBUFFER_256:
-                        rctl |= E1000_RCTL_SZ_256;
-                        rctl &= ~E1000_RCTL_BSEX;
-                        break;
-                case E1000_RXBUFFER_512:
-                        rctl |= E1000_RCTL_SZ_512;
-                        rctl &= ~E1000_RCTL_BSEX;
-                        break;
-                case E1000_RXBUFFER_1024:
-                        rctl |= E1000_RCTL_SZ_1024;
-                        rctl &= ~E1000_RCTL_BSEX;
-                        break;
                 case E1000_RXBUFFER_2048:
                 default:
                         rctl |= E1000_RCTL_SZ_2048;
@@ -2802,13 +2790,13 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
 dma_error:
         dev_err(&pdev->dev, "TX DMA map failed\n");
         buffer_info->dma = 0;
-        count--;
-
-        while (count >= 0) {
+        if (count)
                 count--;
-                i--;
-                if (i < 0)
+
+        while (count--) {
+                if (i==0)
                         i += tx_ring->count;
+                i--;
                 buffer_info = &tx_ring->buffer_info[i];
                 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
         }
@@ -3176,13 +3164,7 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
          *  however with the new *_jumbo_rx* routines, jumbo receives will use
          *  fragmented skbs */
 
-        if (max_frame <= E1000_RXBUFFER_256)
-                adapter->rx_buffer_len = E1000_RXBUFFER_256;
-        else if (max_frame <= E1000_RXBUFFER_512)
-                adapter->rx_buffer_len = E1000_RXBUFFER_512;
-        else if (max_frame <= E1000_RXBUFFER_1024)
-                adapter->rx_buffer_len = E1000_RXBUFFER_1024;
-        else if (max_frame <= E1000_RXBUFFER_2048)
+        if (max_frame <= E1000_RXBUFFER_2048)
                 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
         else
 #if (PAGE_SIZE >= E1000_RXBUFFER_16384)
@@ -3850,13 +3832,22 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
 
                 length = le16_to_cpu(rx_desc->length);
                 /* !EOP means multiple descriptors were used to store a single
-                 * packet, also make sure the frame isn't just CRC only */
-                if (unlikely(!(status & E1000_RXD_STAT_EOP) || (length <= 4))) {
+                 * packet, if thats the case we need to toss it.  In fact, we
+                 * to toss every packet with the EOP bit clear and the next
+                 * frame that _does_ have the EOP bit set, as it is by
+                 * definition only a frame fragment
+                 */
+                if (unlikely(!(status & E1000_RXD_STAT_EOP)))
+                        adapter->discarding = true;
+
+                if (adapter->discarding) {
                         /* All receives must fit into a single buffer */
                         E1000_DBG("%s: Receive packet consumed multiple"
                                   " buffers\n", netdev->name);
                         /* recycle */
                         buffer_info->skb = skb;
+                        if (status & E1000_RXD_STAT_EOP)
+                                adapter->discarding = false;
                         goto next_desc;
                 }
 
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index d6ee28f6ea08..d236efaf7478 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -421,6 +421,7 @@ struct e1000_info {
 /* CRC Stripping defines */
 #define FLAG2_CRC_STRIPPING               (1 << 0)
 #define FLAG2_HAS_PHY_WAKEUP              (1 << 1)
+#define FLAG2_IS_DISCARDING               (1 << 2)
 
 #define E1000_RX_DESC_PS(R, i)      \
         (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index c45965a256b6..57f149b75fbe 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -450,13 +450,23 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
 
                 length = le16_to_cpu(rx_desc->length);
 
-                /* !EOP means multiple descriptors were used to store a single
-                 * packet, also make sure the frame isn't just CRC only */
-                if (!(status & E1000_RXD_STAT_EOP) || (length <= 4)) {
+                /*
+                 * !EOP means multiple descriptors were used to store a single
+                 * packet, if that's the case we need to toss it.  In fact, we
+                 * need to toss every packet with the EOP bit clear and the
+                 * next frame that _does_ have the EOP bit set, as it is by
+                 * definition only a frame fragment
+                 */
+                if (unlikely(!(status & E1000_RXD_STAT_EOP)))
+                        adapter->flags2 |= FLAG2_IS_DISCARDING;
+
+                if (adapter->flags2 & FLAG2_IS_DISCARDING) {
                         /* All receives must fit into a single buffer */
                         e_dbg("Receive packet consumed multiple buffers\n");
                         /* recycle */
                         buffer_info->skb = skb;
+                        if (status & E1000_RXD_STAT_EOP)
+                                adapter->flags2 &= ~FLAG2_IS_DISCARDING;
                         goto next_desc;
                 }
 
@@ -745,10 +755,16 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                                  PCI_DMA_FROMDEVICE);
                 buffer_info->dma = 0;
 
-                if (!(staterr & E1000_RXD_STAT_EOP)) {
+                /* see !EOP comment in other rx routine */
+                if (!(staterr & E1000_RXD_STAT_EOP))
+                        adapter->flags2 |= FLAG2_IS_DISCARDING;
+
+                if (adapter->flags2 & FLAG2_IS_DISCARDING) {
                         e_dbg("Packet Split buffers didn't pick up the full "
                               "packet\n");
                         dev_kfree_skb_irq(skb);
+                        if (staterr & E1000_RXD_STAT_EOP)
+                                adapter->flags2 &= ~FLAG2_IS_DISCARDING;
                         goto next_desc;
                 }
 
@@ -1118,6 +1134,7 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter)
 
         rx_ring->next_to_clean = 0;
         rx_ring->next_to_use = 0;
+        adapter->flags2 &= ~FLAG2_IS_DISCARDING;
 
         writel(0, adapter->hw.hw_addr + rx_ring->head);
         writel(0, adapter->hw.hw_addr + rx_ring->tail);
@@ -2333,18 +2350,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
         rctl &= ~E1000_RCTL_SZ_4096;
         rctl |= E1000_RCTL_BSEX;
         switch (adapter->rx_buffer_len) {
-        case 256:
-                rctl |= E1000_RCTL_SZ_256;
-                rctl &= ~E1000_RCTL_BSEX;
-                break;
-        case 512:
-                rctl |= E1000_RCTL_SZ_512;
-                rctl &= ~E1000_RCTL_BSEX;
-                break;
-        case 1024:
-                rctl |= E1000_RCTL_SZ_1024;
-                rctl &= ~E1000_RCTL_BSEX;
-                break;
         case 2048:
         default:
                 rctl |= E1000_RCTL_SZ_2048;
@@ -3781,7 +3786,7 @@ static int e1000_tso(struct e1000_adapter *adapter,
                                                          0, IPPROTO_TCP, 0);
                 cmd_length = E1000_TXD_CMD_IP;
                 ipcse = skb_transport_offset(skb) - 1;
-        } else if (skb_shinfo(skb)->gso_type == SKB_GSO_TCPV6) {
+        } else if (skb_is_gso_v6(skb)) {
                 ipv6_hdr(skb)->payload_len = 0;
                 tcp_hdr(skb)->check = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
                                                        &ipv6_hdr(skb)->daddr,
@@ -3962,13 +3967,13 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
 dma_error:
         dev_err(&pdev->dev, "TX DMA map failed\n");
         buffer_info->dma = 0;
-        count--;
-
-        while (count >= 0) {
+        if (count)
                 count--;
-                i--;
-                if (i < 0)
+
+        while (count--) {
+                if (i==0)
                         i += tx_ring->count;
+                i--;
                 buffer_info = &tx_ring->buffer_info[i];
                 e1000_put_txbuf(adapter, buffer_info);;
         }
@@ -4317,13 +4322,7 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
          * fragmented skbs
          */
 
-        if (max_frame <= 256)
-                adapter->rx_buffer_len = 256;
-        else if (max_frame <= 512)
-                adapter->rx_buffer_len = 512;
-        else if (max_frame <= 1024)
-                adapter->rx_buffer_len = 1024;
-        else if (max_frame <= 2048)
+        if (max_frame <= 2048)
                 adapter->rx_buffer_len = 2048;
         else
                 adapter->rx_buffer_len = 4096;
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index 933c64ff2465..997124d2992a 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -3422,7 +3422,7 @@ static inline int igb_tso_adv(struct igb_ring *tx_ring,
                                                          iph->daddr, 0,
                                                          IPPROTO_TCP,
                                                          0);
-        } else if (skb_shinfo(skb)->gso_type == SKB_GSO_TCPV6) {
+        } else if (skb_is_gso_v6(skb)) {
                 ipv6_hdr(skb)->payload_len = 0;
                 tcp_hdr(skb)->check = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
                                                        &ipv6_hdr(skb)->daddr,
@@ -3584,6 +3584,7 @@ static inline int igb_tx_map_adv(struct igb_ring *tx_ring, struct sk_buff *skb,
         for (f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
                 struct skb_frag_struct *frag;
 
+                count++;
                 i++;
                 if (i == tx_ring->count)
                         i = 0;
@@ -3605,7 +3606,6 @@ static inline int igb_tx_map_adv(struct igb_ring *tx_ring, struct sk_buff *skb,
                 if (pci_dma_mapping_error(pdev, buffer_info->dma))
                         goto dma_error;
 
-                count++;
         }
 
         tx_ring->buffer_info[i].skb = skb;
diff --git a/drivers/net/igbvf/netdev.c b/drivers/net/igbvf/netdev.c
index 0dbd0320023a..2aa71a766c35 100644
--- a/drivers/net/igbvf/netdev.c
+++ b/drivers/net/igbvf/netdev.c
@@ -1963,7 +1963,7 @@ static int igbvf_tso(struct igbvf_adapter *adapter,
                                                          iph->daddr, 0,
                                                          IPPROTO_TCP,
                                                          0);
-        } else if (skb_shinfo(skb)->gso_type == SKB_GSO_TCPV6) {
+        } else if (skb_is_gso_v6(skb)) {
                 ipv6_hdr(skb)->payload_len = 0;
                 tcp_hdr(skb)->check = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
                                                        &ipv6_hdr(skb)->daddr,
@@ -2117,6 +2117,7 @@ static inline int igbvf_tx_map_adv(struct igbvf_adapter *adapter,
         /* set time_stamp *before* dma to help avoid a possible race */
         buffer_info->time_stamp = jiffies;
         buffer_info->next_to_watch = i;
+        buffer_info->mapped_as_page = false;
         buffer_info->dma = pci_map_single(pdev, skb->data, len,
                                           PCI_DMA_TODEVICE);
         if (pci_dma_mapping_error(pdev, buffer_info->dma))
@@ -2126,6 +2127,7 @@ static inline int igbvf_tx_map_adv(struct igbvf_adapter *adapter,
         for (f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
                 struct skb_frag_struct *frag;
 
+                count++;
                 i++;
                 if (i == tx_ring->count)
                         i = 0;
@@ -2146,7 +2148,6 @@ static inline int igbvf_tx_map_adv(struct igbvf_adapter *adapter,
                                                 PCI_DMA_TODEVICE);
                 if (pci_dma_mapping_error(pdev, buffer_info->dma))
                         goto dma_error;
-                count++;
         }
 
         tx_ring->buffer_info[i].skb = skb;
@@ -2163,14 +2164,14 @@ dma_error:
         buffer_info->length = 0;
         buffer_info->next_to_watch = 0;
         buffer_info->mapped_as_page = false;
-        count--;
+        if (count)
+                count--;
 
         /* clear timestamp and dma mappings for remaining portion of packet */
-        while (count >= 0) {
-                count--;
-                i--;
-                if (i < 0)
+        while (count--) {
+                if (i==0)
                         i += tx_ring->count;
+                i--;
                 buffer_info = &tx_ring->buffer_info[i];
                 igbvf_put_txbuf(adapter, buffer_info);
         }
diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c
index bcd0f01d5feb..593d1a4f217c 100644
--- a/drivers/net/ixgb/ixgb_main.c
+++ b/drivers/net/ixgb/ixgb_main.c
@@ -1363,13 +1363,13 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb,
 dma_error:
         dev_err(&pdev->dev, "TX DMA map failed\n");
         buffer_info->dma = 0;
-        count--;
-
-        while (count >= 0) {
+        if (count)
                 count--;
-                i--;
-                if (i < 0)
+
+        while (count--) {
+                if (i==0)
                         i += tx_ring->count;
+                i--;
                 buffer_info = &tx_ring->buffer_info[i];
                 ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
         }
diff --git a/drivers/net/ixgbe/ixgbe_dcb_nl.c b/drivers/net/ixgbe/ixgbe_dcb_nl.c
index 56f37f66b696..dd4883f642be 100644
--- a/drivers/net/ixgbe/ixgbe_dcb_nl.c
+++ b/drivers/net/ixgbe/ixgbe_dcb_nl.c
@@ -223,7 +223,7 @@ static void ixgbe_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 
         if (adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] !=
             adapter->dcb_cfg.bw_percentage[0][bwg_id]) {
-                adapter->dcb_set_bitmap |= BIT_PG_RX;
+                adapter->dcb_set_bitmap |= BIT_PG_TX;
                 adapter->dcb_set_bitmap |= BIT_RESETLINK;
         }
 }
@@ -341,6 +341,12 @@ static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
         if (!adapter->dcb_set_bitmap)
                 return DCB_NO_HW_CHG;
 
+        ret = ixgbe_copy_dcb_cfg(&adapter->temp_dcb_cfg, &adapter->dcb_cfg,
+                                 adapter->ring_feature[RING_F_DCB].indices);
+
+        if (ret)
+                return DCB_NO_HW_CHG;
+
         /*
          * Only take down the adapter if the configuration change
          * requires a reset.
@@ -359,14 +365,6 @@ static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
                 }
         }
 
-        ret = ixgbe_copy_dcb_cfg(&adapter->temp_dcb_cfg, &adapter->dcb_cfg,
-                                 adapter->ring_feature[RING_F_DCB].indices);
-        if (ret) {
-                if (adapter->dcb_set_bitmap & BIT_RESETLINK)
-                        clear_bit(__IXGBE_RESETTING, &adapter->state);
-                return DCB_NO_HW_CHG;
-        }
-
         if (adapter->dcb_cfg.pfc_mode_enable) {
                 if ((adapter->hw.mac.type != ixgbe_mac_82598EB) &&
                         (adapter->hw.fc.current_mode != ixgbe_fc_pfc))
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 9c9202f40b10..b5f64ad67975 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -4928,7 +4928,7 @@ static int ixgbe_tso(struct ixgbe_adapter *adapter,
                                                                  iph->daddr, 0,
                                                                  IPPROTO_TCP,
                                                                  0);
-                } else if (skb_shinfo(skb)->gso_type == SKB_GSO_TCPV6) {
+                } else if (skb_is_gso_v6(skb)) {
                         ipv6_hdr(skb)->payload_len = 0;
                         tcp_hdr(skb)->check =
                             ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
@@ -5167,14 +5167,14 @@ dma_error:
         tx_buffer_info->dma = 0;
         tx_buffer_info->time_stamp = 0;
         tx_buffer_info->next_to_watch = 0;
-        count--;
+        if (count)
+                count--;
 
         /* clear timestamp and dma mappings for remaining portion of packet */
-        while (count >= 0) {
-                count--;
-                i--;
-                if (i < 0)
+        while (count--) {
+                if (i==0)
                         i += tx_ring->count;
+                i--;
                 tx_buffer_info = &tx_ring->tx_buffer_info[i];
                 ixgbe_unmap_and_free_tx_resource(adapter, tx_buffer_info);
         }
diff --git a/drivers/net/ks8851_mll.c b/drivers/net/ks8851_mll.c
index c146304d8d6c..c0ceebccaa49 100644
--- a/drivers/net/ks8851_mll.c
+++ b/drivers/net/ks8851_mll.c
@@ -854,8 +854,8 @@ static void ks_update_link_status(struct net_device *netdev, struct ks_net *ks)
 
 static irqreturn_t ks_irq(int irq, void *pw)
 {
-        struct ks_net *ks = pw;
-        struct net_device *netdev = ks->netdev;
+        struct net_device *netdev = pw;
+        struct ks_net *ks = netdev_priv(netdev);
         u16 status;
 
         /*this should be the first in IRQ handler */
diff --git a/drivers/net/pcmcia/fmvj18x_cs.c b/drivers/net/pcmcia/fmvj18x_cs.c
index 813aca3fc433..7b17404d0858 100644
--- a/drivers/net/pcmcia/fmvj18x_cs.c
+++ b/drivers/net/pcmcia/fmvj18x_cs.c
@@ -717,6 +717,7 @@ static struct pcmcia_device_id fmvj18x_ids[] = {
         PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
+        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
         PCMCIA_DEVICE_NULL,
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index b0e9f9c51721..0295097d6c44 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -410,7 +410,6 @@ EXPORT_SYMBOL(phy_start_aneg);
 
 
 static void phy_change(struct work_struct *work);
-static void phy_state_machine(struct work_struct *work);
 
 /**
  * phy_start_machine - start PHY state machine tracking
@@ -430,7 +429,6 @@ void phy_start_machine(struct phy_device *phydev,
 {
         phydev->adjust_state = handler;
 
-        INIT_DELAYED_WORK(&phydev->state_queue, phy_state_machine);
         schedule_delayed_work(&phydev->state_queue, HZ);
 }
 
@@ -761,7 +759,7 @@ EXPORT_SYMBOL(phy_start);
  * phy_state_machine - Handle the state machine
  * @work: work_struct that describes the work to be done
  */
-static void phy_state_machine(struct work_struct *work)
+void phy_state_machine(struct work_struct *work)
 {
         struct delayed_work *dwork = to_delayed_work(work);
         struct phy_device *phydev =
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index 8212b2b93422..adbc0fded130 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -177,6 +177,7 @@ struct phy_device* phy_device_create(struct mii_bus *bus, int addr, int phy_id)
         dev->state = PHY_DOWN;
 
         mutex_init(&dev->lock);
+        INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
 
         return dev;
 }
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index 707b391afa02..894a7c84faef 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -4119,7 +4119,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
         err = pcie_set_readrq(pdev, 4096);
         if (err) {
                 dev_err(&pdev->dev, "Set readrq failed.\n");
-                goto err_out;
+                goto err_out1;
         }
 
         err = pci_request_regions(pdev, DRV_NAME);
@@ -4140,7 +4140,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
 
         if (err) {
                 dev_err(&pdev->dev, "No usable DMA configuration.\n");
-                goto err_out;
+                goto err_out2;
         }
 
         /* Set PCIe reset type for EEH to fundamental. */
@@ -4152,7 +4152,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
         if (!qdev->reg_base) {
                 dev_err(&pdev->dev, "Register mapping failed.\n");
                 err = -ENOMEM;
-                goto err_out;
+                goto err_out2;
         }
 
         qdev->doorbell_area_size = pci_resource_len(pdev, 3);
@@ -4162,14 +4162,14 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
         if (!qdev->doorbell_area) {
                 dev_err(&pdev->dev, "Doorbell register mapping failed.\n");
                 err = -ENOMEM;
-                goto err_out;
+                goto err_out2;
         }
 
         err = ql_get_board_info(qdev);
         if (err) {
                 dev_err(&pdev->dev, "Register access failed.\n");
                 err = -EIO;
-                goto err_out;
+                goto err_out2;
         }
         qdev->msg_enable = netif_msg_init(debug, default_msg);
         spin_lock_init(&qdev->hw_lock);
@@ -4179,7 +4179,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
         err = qdev->nic_ops->get_flash(qdev);
         if (err) {
                 dev_err(&pdev->dev, "Invalid FLASH.\n");
-                goto err_out;
+                goto err_out2;
         }
 
         memcpy(ndev->perm_addr, ndev->dev_addr, ndev->addr_len);
@@ -4212,8 +4212,9 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
                          DRV_NAME, DRV_VERSION);
         }
         return 0;
-err_out:
+err_out2:
         ql_release_all(pdev);
+err_out1:
         pci_disable_device(pdev);
         return err;
 }
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index cc4218667cba..3c4836d0898f 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -3421,7 +3421,7 @@ static int wait_for_cmd_complete(void __iomem *addr, u64 busy_bit,
                                 break;
                         }
                 } else {
-                        if (!(val64 & busy_bit)) {
+                        if (val64 & busy_bit) {
                                 ret = SUCCESS;
                                 break;
                         }
diff --git a/drivers/net/sfc/mcdi.c b/drivers/net/sfc/mcdi.c
index 0d4eba7266ec..9f035b9f0350 100644
--- a/drivers/net/sfc/mcdi.c
+++ b/drivers/net/sfc/mcdi.c
@@ -804,7 +804,7 @@ int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,
                         loff_t offset, u8 *buffer, size_t length)
 {
         u8 inbuf[MC_CMD_NVRAM_READ_IN_LEN];
-        u8 outbuf[MC_CMD_NVRAM_READ_OUT_LEN(length)];
+        u8 outbuf[MC_CMD_NVRAM_READ_OUT_LEN(EFX_MCDI_NVRAM_LEN_MAX)];
         size_t outlen;
         int rc;
 
@@ -828,7 +828,7 @@ fail:
 int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,
                            loff_t offset, const u8 *buffer, size_t length)
 {
-        u8 inbuf[MC_CMD_NVRAM_WRITE_IN_LEN(length)];
+        u8 inbuf[MC_CMD_NVRAM_WRITE_IN_LEN(EFX_MCDI_NVRAM_LEN_MAX)];
         int rc;
 
         MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_TYPE, type);
@@ -838,7 +838,8 @@ int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,
 
         BUILD_BUG_ON(MC_CMD_NVRAM_WRITE_OUT_LEN != 0);
 
-        rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_WRITE, inbuf, sizeof(inbuf),
+        rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_WRITE, inbuf,
+                          ALIGN(MC_CMD_NVRAM_WRITE_IN_LEN(length), 4),
                           NULL, 0, NULL);
         if (rc)
                 goto fail;
diff --git a/drivers/net/sfc/mcdi.h b/drivers/net/sfc/mcdi.h
index de916728c2e3..10ce98f4c0fb 100644
--- a/drivers/net/sfc/mcdi.h
+++ b/drivers/net/sfc/mcdi.h
@@ -111,6 +111,7 @@ extern int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,
 extern int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,
                                 loff_t offset, const u8 *buffer,
                                 size_t length);
+#define EFX_MCDI_NVRAM_LEN_MAX 128
 extern int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,
                                 loff_t offset, size_t length);
 extern int efx_mcdi_nvram_update_finish(struct efx_nic *efx,
diff --git a/drivers/net/sfc/mcdi_pcol.h b/drivers/net/sfc/mcdi_pcol.h
index 2a85360a46f0..73e71f420624 100644
--- a/drivers/net/sfc/mcdi_pcol.h
+++ b/drivers/net/sfc/mcdi_pcol.h
@@ -1090,8 +1090,10 @@
 #define MC_CMD_MAC_RX_LANES01_DISP_ERR 57
 #define MC_CMD_MAC_RX_LANES23_DISP_ERR 58
 #define MC_CMD_MAC_RX_MATCH_FAULT 59
+#define MC_CMD_GMAC_DMABUF_START 64
+#define MC_CMD_GMAC_DMABUF_END   95
 /* Insert new members here. */
-#define MC_CMD_MAC_GENERATION_END 60
+#define MC_CMD_MAC_GENERATION_END 96
 #define MC_CMD_MAC_NSTATS (MC_CMD_MAC_GENERATION_END+1)
 
 /* MC_CMD_MAC_STATS:
diff --git a/drivers/net/sfc/mtd.c b/drivers/net/sfc/mtd.c
index 3a464529a46b..407bbaddfea6 100644
--- a/drivers/net/sfc/mtd.c
+++ b/drivers/net/sfc/mtd.c
@@ -23,7 +23,6 @@
 #include "mcdi_pcol.h"
 
 #define EFX_SPI_VERIFY_BUF_LEN 16
-#define EFX_MCDI_CHUNK_LEN 128
 
 struct efx_mtd_partition {
         struct mtd_info mtd;
@@ -428,7 +427,7 @@ static int siena_mtd_read(struct mtd_info *mtd, loff_t start,
         int rc = 0;
 
         while (offset < end) {
-                chunk = min_t(size_t, end - offset, EFX_MCDI_CHUNK_LEN);
+                chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);
                 rc = efx_mcdi_nvram_read(efx, part->mcdi.nvram_type, offset,
                                          buffer, chunk);
                 if (rc)
@@ -491,7 +490,7 @@ static int siena_mtd_write(struct mtd_info *mtd, loff_t start,
         }
 
         while (offset < end) {
-                chunk = min_t(size_t, end - offset, EFX_MCDI_CHUNK_LEN);
+                chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);
                 rc = efx_mcdi_nvram_write(efx, part->mcdi.nvram_type, offset,
                                           buffer, chunk);
                 if (rc)
diff --git a/drivers/net/sfc/qt202x_phy.c b/drivers/net/sfc/qt202x_phy.c
index ff8f0a417fa3..e0d13a451019 100644
--- a/drivers/net/sfc/qt202x_phy.c
+++ b/drivers/net/sfc/qt202x_phy.c
@@ -318,12 +318,6 @@ static int qt202x_reset_phy(struct efx_nic *efx)
         /* Wait 250ms for the PHY to complete bootup */
         msleep(250);
 
-        /* Check that all the MMDs we expect are present and responding. We
-         * expect faults on some if the link is down, but not on the PHY XS */
-        rc = efx_mdio_check_mmds(efx, QT202X_REQUIRED_DEVS, MDIO_DEVS_PHYXS);
-        if (rc < 0)
-                goto fail;
-
         falcon_board(efx)->type->init_phy(efx);
 
         return rc;
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 37f486b65f63..d760650c5c04 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -644,6 +644,7 @@ static void sky2_phy_power_up(struct sky2_hw *hw, unsigned port)
 {
         u32 reg1;
 
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
         reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
         reg1 &= ~phy_power[port];
 
@@ -651,6 +652,7 @@ static void sky2_phy_power_up(struct sky2_hw *hw, unsigned port)
                 reg1 |= coma_mode[port];
 
         sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
         sky2_pci_read32(hw, PCI_DEV_REG1);
 
         if (hw->chip_id == CHIP_ID_YUKON_FE)
@@ -707,9 +709,11 @@ static void sky2_phy_power_down(struct sky2_hw *hw, unsigned port)
                 gm_phy_write(hw, port, PHY_MARV_CTRL, PHY_CT_PDOWN);
         }
 
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
         reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
         reg1 |= phy_power[port];                /* set PHY to PowerDown/COMA Mode */
         sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 }
 
 /* Force a renegotiation */
@@ -2149,7 +2153,9 @@ static void sky2_qlink_intr(struct sky2_hw *hw)
 
         /* reset PHY Link Detect */
         phy = sky2_pci_read16(hw, PSM_CONFIG_REG4);
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
         sky2_pci_write16(hw, PSM_CONFIG_REG4, phy | 1);
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 
         sky2_link_up(sky2);
 }
@@ -2640,6 +2646,7 @@ static void sky2_hw_intr(struct sky2_hw *hw)
         if (status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) {
                 u16 pci_err;
 
+                sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
                 pci_err = sky2_pci_read16(hw, PCI_STATUS);
                 if (net_ratelimit())
                         dev_err(&pdev->dev, "PCI hardware error (0x%x)\n",
@@ -2647,12 +2654,14 @@ static void sky2_hw_intr(struct sky2_hw *hw)
 
                 sky2_pci_write16(hw, PCI_STATUS,
                                       pci_err | PCI_STATUS_ERROR_BITS);
+                sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
         }
 
         if (status & Y2_IS_PCI_EXP) {
                 /* PCI-Express uncorrectable Error occurred */
                 u32 err;
 
+                sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
                 err = sky2_read32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS);
                 sky2_write32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS,
                              0xfffffffful);
@@ -2660,6 +2669,7 @@ static void sky2_hw_intr(struct sky2_hw *hw)
                         dev_err(&pdev->dev, "PCI Express error (0x%x)\n", err);
 
                 sky2_read32(hw, Y2_CFG_AER + PCI_ERR_UNCOR_STATUS);
+                sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
         }
 
         if (status & Y2_HWE_L1_MASK)
@@ -3038,6 +3048,7 @@ static void sky2_reset(struct sky2_hw *hw)
         }
 
         sky2_power_on(hw);
+        sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 
         for (i = 0; i < hw->ports; i++) {
                 sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_SET);
@@ -3074,6 +3085,7 @@ static void sky2_reset(struct sky2_hw *hw)
                 reg <<= PSM_CONFIG_REG4_TIMER_PHY_LINK_DETECT_BASE;
 
                 /* reset PHY Link Detect */
+                sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
                 sky2_pci_write16(hw, PSM_CONFIG_REG4,
                                  reg | PSM_CONFIG_REG4_RST_PHY_LINK_DETECT);
                 sky2_pci_write16(hw, PSM_CONFIG_REG4, reg);
@@ -3091,6 +3103,7 @@ static void sky2_reset(struct sky2_hw *hw)
                         /* restore the PCIe Link Control register */
                         sky2_pci_write16(hw, cap + PCI_EXP_LNKCTL, reg);
                 }
+                sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 
                 /* re-enable PEX PM in PEX PHY debug reg. 8 (clear bit 12) */
                 sky2_write32(hw, Y2_PEX_PHY_DATA, PEX_DB_ACCESS | (0x08UL << 16));
@@ -3228,6 +3241,27 @@ static inline u8 sky2_wol_supported(const struct sky2_hw *hw)
         return sky2_is_copper(hw) ? (WAKE_PHY | WAKE_MAGIC) : 0;
 }
 
+static void sky2_hw_set_wol(struct sky2_hw *hw)
+{
+        int wol = 0;
+        int i;
+
+        for (i = 0; i < hw->ports; i++) {
+                struct net_device *dev = hw->dev[i];
+                struct sky2_port *sky2 = netdev_priv(dev);
+
+                if (sky2->wol)
+                        wol = 1;
+        }
+
+        if (hw->chip_id == CHIP_ID_YUKON_EC_U ||
+            hw->chip_id == CHIP_ID_YUKON_EX ||
+            hw->chip_id == CHIP_ID_YUKON_FE_P)
+                sky2_write32(hw, B0_CTST, wol ? Y2_HW_WOL_ON : Y2_HW_WOL_OFF);
+
+        device_set_wakeup_enable(&hw->pdev->dev, wol);
+}
+
 static void sky2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
         const struct sky2_port *sky2 = netdev_priv(dev);
@@ -3247,13 +3281,7 @@ static int sky2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 
         sky2->wol = wol->wolopts;
 
-        if (hw->chip_id == CHIP_ID_YUKON_EC_U ||
-            hw->chip_id == CHIP_ID_YUKON_EX ||
-            hw->chip_id == CHIP_ID_YUKON_FE_P)
-                sky2_write32(hw, B0_CTST, sky2->wol
-                             ? Y2_HW_WOL_ON : Y2_HW_WOL_OFF);
-
-        device_set_wakeup_enable(&hw->pdev->dev, sky2->wol);
+        sky2_hw_set_wol(hw);
 
         if (!netif_running(dev))
                 sky2_wol_init(sky2);
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index 95db60adde41..f9521136a869 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -1063,7 +1063,7 @@ static int netdev_open(struct net_device *dev)
         if (retval) {
                 printk(KERN_ERR "starfire: Failed to load firmware \"%s\"\n",
                        FIRMWARE_RX);
-                return retval;
+                goto out_init;
         }
         if (fw_rx->size % 4) {
                 printk(KERN_ERR "starfire: bogus length %zu in \"%s\"\n",
@@ -1108,6 +1108,9 @@ out_tx:
         release_firmware(fw_tx);
 out_rx:
         release_firmware(fw_rx);
+out_init:
+        if (retval)
+                netdev_close(dev);
         return retval;
 }
 
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index 595777dcadb1..20696b5d60a5 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -249,6 +249,7 @@ static struct pci_device_id tulip_pci_tbl[] = {
         { 0x17B3, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
         { 0x10b7, 0x9300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* 3Com 3CSOHO100B-TX */
         { 0x14ea, 0xab08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* Planex FNW-3602-TX */
+        { 0x1414, 0x0001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* Microsoft MN-120 */
         { 0x1414, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
         { } /* terminate list */
 };
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 96bdc0b43889..eb8fe7e16c6c 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3279,13 +3279,12 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
                 /* Handle the transmitted buffer and release */
                 /* the BD to be used with the current frame  */
 
-                if (bd == ugeth->txBd[txQ]) /* queue empty? */
+                skb = ugeth->tx_skbuff[txQ][ugeth->skb_dirtytx[txQ]];
+                if (!skb)
                         break;
 
                 dev->stats.tx_packets++;
 
-                skb = ugeth->tx_skbuff[txQ][ugeth->skb_dirtytx[txQ]];
-
                 if (skb_queue_len(&ugeth->rx_recycle) < RX_BD_RING_LEN &&
                              skb_recycle_check(skb,
                                     ugeth->ug_info->uf_info.max_rx_buf_length +
diff --git a/drivers/net/usb/cdc_ether.c b/drivers/net/usb/cdc_ether.c
index 21e183a83b99..4f27f022fbf7 100644
--- a/drivers/net/usb/cdc_ether.c
+++ b/drivers/net/usb/cdc_ether.c
@@ -419,7 +419,7 @@ static int cdc_manage_power(struct usbnet *dev, int on)
 
 static const struct driver_info cdc_info = {
         .description =  "CDC Ethernet Device",
-        .flags =        FLAG_ETHER | FLAG_LINK_INTR,
+        .flags =        FLAG_ETHER,
         // .check_connect = cdc_check_connect,
         .bind =         cdc_bind,
         .unbind =       usbnet_cdc_unbind,
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index c708ecc3cb2e..9ead30bd00c4 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -395,8 +395,7 @@ static void refill_work(struct work_struct *work)
 
         vi = container_of(work, struct virtnet_info, refill.work);
         napi_disable(&vi->napi);
-        try_fill_recv(vi, GFP_KERNEL);
-        still_empty = (vi->num == 0);
+        still_empty = !try_fill_recv(vi, GFP_KERNEL);
         napi_enable(&vi->napi);
 
         /* In theory, this can happen: if we don't get any buffers in
diff --git a/drivers/net/wimax/i2400m/i2400m-usb.h b/drivers/net/wimax/i2400m/i2400m-usb.h
index 5cc0f279417e..2d7c96d7e865 100644
--- a/drivers/net/wimax/i2400m/i2400m-usb.h
+++ b/drivers/net/wimax/i2400m/i2400m-usb.h
@@ -151,6 +151,7 @@ enum {
 
         /* Device IDs */
         USB_DEVICE_ID_I6050 = 0x0186,
+        USB_DEVICE_ID_I6050_2 = 0x0188,
 };
 
 
@@ -234,6 +235,7 @@ struct i2400mu {
         u8 rx_size_auto_shrink;
 
         struct dentry *debugfs_dentry;
+        unsigned i6050:1;       /* 1 if this is a 6050 based SKU */
 };
 
 
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index 3b48681f8a0d..98f4f8c5fb68 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -478,7 +478,16 @@ int i2400mu_probe(struct usb_interface *iface,
         i2400m->bus_bm_wait_for_ack = i2400mu_bus_bm_wait_for_ack;
         i2400m->bus_bm_mac_addr_impaired = 0;
 
-        if (id->idProduct == USB_DEVICE_ID_I6050) {
+        switch (id->idProduct) {
+        case USB_DEVICE_ID_I6050:
+        case USB_DEVICE_ID_I6050_2:
+                i2400mu->i6050 = 1;
+                break;
+        default:
+                break;
+        }
+
+        if (i2400mu->i6050) {
                 i2400m->bus_fw_names = i2400mu_bus_fw_names_6050;
                 i2400mu->endpoint_cfg.bulk_out = 0;
                 i2400mu->endpoint_cfg.notification = 3;
@@ -719,6 +728,7 @@ int i2400mu_post_reset(struct usb_interface *iface)
 static
 struct usb_device_id i2400mu_id_table[] = {
         { USB_DEVICE(0x8086, USB_DEVICE_ID_I6050) },
+        { USB_DEVICE(0x8086, USB_DEVICE_ID_I6050_2) },
         { USB_DEVICE(0x8086, 0x0181) },
         { USB_DEVICE(0x8086, 0x1403) },
         { USB_DEVICE(0x8086, 0x1405) },
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 2ec61f08cfdb..ae371448b5a0 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -855,12 +855,11 @@ static void ath9k_hw_init_mode_gain_regs(struct ath_hw *ah)
         }
 }
 
-static void ath9k_hw_init_11a_eeprom_fix(struct ath_hw *ah)
+static void ath9k_hw_init_eeprom_fix(struct ath_hw *ah)
 {
         u32 i, j;
 
-        if ((ah->hw_version.devid == AR9280_DEVID_PCI) &&
-            test_bit(ATH9K_MODE_11A, ah->caps.wireless_modes)) {
+        if (ah->hw_version.devid == AR9280_DEVID_PCI) {
 
                 /* EEPROM Fixup */
                 for (i = 0; i < ah->iniModes.ia_rows; i++) {
@@ -980,7 +979,7 @@ int ath9k_hw_init(struct ath_hw *ah)
         if (r)
                 return r;
 
-        ath9k_hw_init_11a_eeprom_fix(ah);
+        ath9k_hw_init_eeprom_fix(ah);
 
         r = ath9k_hw_init_macaddr(ah);
         if (r) {
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 996eb90263cc..643bea35686f 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -2655,10 +2655,10 @@ static void ath9k_remove_interface(struct ieee80211_hw *hw,
             (sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT)) {
                 ath9k_ps_wakeup(sc);
                 ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
-                ath_beacon_return(sc, avp);
                 ath9k_ps_restore(sc);
         }
 
+        ath_beacon_return(sc, avp);
         sc->sc_flags &= ~SC_OP_BEACONS;
 
         for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++) {
diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c
index 33a5866538e7..de45f308b744 100644
--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
@@ -1598,6 +1598,7 @@ struct iwl_cfg iwl5300_agn_cfg = {
         .use_bsm = false,
         .ht_greenfield_support = true,
         .led_compensation = 51,
+        .use_rts_for_ht = true, /* use rts/cts protection */
         .chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
         .sm_ps_mode = WLAN_HT_CAP_SM_PS_DISABLED,
 };
@@ -1622,6 +1623,7 @@ struct iwl_cfg iwl5100_bgn_cfg = {
         .use_bsm = false,
         .ht_greenfield_support = true,
         .led_compensation = 51,
+        .use_rts_for_ht = true, /* use rts/cts protection */
         .chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
 };
 
@@ -1667,6 +1669,7 @@ struct iwl_cfg iwl5100_agn_cfg = {
         .use_bsm = false,
         .ht_greenfield_support = true,
         .led_compensation = 51,
+        .use_rts_for_ht = true, /* use rts/cts protection */
         .chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
         .sm_ps_mode = WLAN_HT_CAP_SM_PS_DISABLED,
 };
@@ -1691,6 +1694,7 @@ struct iwl_cfg iwl5350_agn_cfg = {
         .use_bsm = false,
         .ht_greenfield_support = true,
         .led_compensation = 51,
+        .use_rts_for_ht = true, /* use rts/cts protection */
         .chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
         .sm_ps_mode = WLAN_HT_CAP_SM_PS_DISABLED,
 };
@@ -1715,6 +1719,7 @@ struct iwl_cfg iwl5150_agn_cfg = {
         .use_bsm = false,
         .ht_greenfield_support = true,
         .led_compensation = 51,
+        .use_rts_for_ht = true, /* use rts/cts protection */
         .chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
         .sm_ps_mode = WLAN_HT_CAP_SM_PS_DISABLED,
 };
diff --git a/drivers/net/wireless/iwlwifi/iwl-devtrace.c b/drivers/net/wireless/iwlwifi/iwl-devtrace.c
index e7d88d1da15d..83cc4e500a96 100644
--- a/drivers/net/wireless/iwlwifi/iwl-devtrace.c
+++ b/drivers/net/wireless/iwlwifi/iwl-devtrace.c
@@ -1,3 +1,29 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2009 - 2010 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
 #include <linux/module.h>
 
 /* sparse doesn't like tracepoint macros */
diff --git a/drivers/net/wireless/iwlwifi/iwl-devtrace.h b/drivers/net/wireless/iwlwifi/iwl-devtrace.h
index 21361968ab7e..d9c7363b1bbb 100644
--- a/drivers/net/wireless/iwlwifi/iwl-devtrace.h
+++ b/drivers/net/wireless/iwlwifi/iwl-devtrace.h
@@ -1,3 +1,29 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2009 - 2010 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called LICENSE.
+ *
+ * Contact Information:
+ *  Intel Linux Wireless <ilw@linux.intel.com>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ *****************************************************************************/
+
 #if !defined(__IWLWIFI_DEVICE_TRACE) || defined(TRACE_HEADER_MULTI_READ)
 #define __IWLWIFI_DEVICE_TRACE
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index cde09a890b73..90fbdb25399e 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -297,7 +297,7 @@ u8 iwl_add_station(struct iwl_priv *priv, const u8 *addr, bool is_ap, u8 flags,
 }
 EXPORT_SYMBOL(iwl_add_station);
 
-static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, const char *addr)
+static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, const u8 *addr)
 {
         unsigned long flags;
         u8 sta_id = iwl_find_station(priv, addr);
@@ -324,7 +324,7 @@ static void iwl_remove_sta_callback(struct iwl_priv *priv,
 {
         struct iwl_rem_sta_cmd *rm_sta =
                         (struct iwl_rem_sta_cmd *)cmd->cmd.payload;
-        const char *addr = rm_sta->addr;
+        const u8 *addr = rm_sta->addr;
 
         if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
                 IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
diff --git a/drivers/net/wireless/iwmc3200wifi/commands.c b/drivers/net/wireless/iwmc3200wifi/commands.c
index 777584d76a88..1e41ad0fcad5 100644
--- a/drivers/net/wireless/iwmc3200wifi/commands.c
+++ b/drivers/net/wireless/iwmc3200wifi/commands.c
@@ -973,6 +973,10 @@ int iwm_send_pmkid_update(struct iwm_priv *iwm,
 
         memset(&update, 0, sizeof(struct iwm_umac_pmkid_update));
 
+        update.hdr.oid = UMAC_WIFI_IF_CMD_PMKID_UPDATE;
+        update.hdr.buf_size = cpu_to_le16(sizeof(struct iwm_umac_pmkid_update) -
+                                          sizeof(struct iwm_umac_wifi_if));
+
         update.command = cpu_to_le32(command);
         if (pmksa->bssid)
                 memcpy(&update.bssid, pmksa->bssid, ETH_ALEN);
diff --git a/drivers/net/wireless/iwmc3200wifi/commands.h b/drivers/net/wireless/iwmc3200wifi/commands.h
index 06af0552cd75..3dfd9f0e9003 100644
--- a/drivers/net/wireless/iwmc3200wifi/commands.h
+++ b/drivers/net/wireless/iwmc3200wifi/commands.h
@@ -463,6 +463,7 @@ struct iwm_umac_cmd_stop_resume_tx {
 #define IWM_CMD_PMKID_FLUSH 3
 
 struct iwm_umac_pmkid_update {
+        struct iwm_umac_wifi_if hdr;
         __le32 command;
         u8 bssid[ETH_ALEN];
         __le16 reserved;
diff --git a/drivers/net/wireless/p54/p54pci.c b/drivers/net/wireless/p54/p54pci.c
index a15962a19b2a..a72f7c2577de 100644
--- a/drivers/net/wireless/p54/p54pci.c
+++ b/drivers/net/wireless/p54/p54pci.c
@@ -197,6 +197,14 @@ static void p54p_check_rx_ring(struct ieee80211_hw *dev, u32 *index,
                         i %= ring_limit;
                         continue;
                 }
+
+                if (unlikely(len > priv->common.rx_mtu)) {
+                        if (net_ratelimit())
+                                dev_err(&priv->pdev->dev, "rx'd frame size "
+                                        "exceeds length threshold.\n");
+
+                        len = priv->common.rx_mtu;
+                }
                 skb_put(skb, len);
 
                 if (p54_rx(dev, skb)) {
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index ac19ecd19cfe..72d3e437e190 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -62,6 +62,7 @@ static struct usb_device_id usb_ids[] = {
         { USB_DEVICE(0x6891, 0xa727), .driver_info = DEVICE_ZD1211 },
         /* ZD1211B */
         { USB_DEVICE(0x0053, 0x5301), .driver_info = DEVICE_ZD1211B },
+        { USB_DEVICE(0x0409, 0x0248), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0411, 0x00da), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0471, 0x1236), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
diff --git a/drivers/pci/pcie/aer/aer_inject.c b/drivers/pci/pcie/aer/aer_inject.c
index 8c30a9544d61..223052b73563 100644
--- a/drivers/pci/pcie/aer/aer_inject.c
+++ b/drivers/pci/pcie/aer/aer_inject.c
@@ -321,7 +321,7 @@ static int aer_inject(struct aer_error_inj *einj)
         unsigned long flags;
         unsigned int devfn = PCI_DEVFN(einj->dev, einj->fn);
         int pos_cap_err, rp_pos_cap_err;
-        u32 sever, mask;
+        u32 sever, cor_mask, uncor_mask;
         int ret = 0;
 
         dev = pci_get_domain_bus_and_slot((int)einj->domain, einj->bus, devfn);
@@ -339,6 +339,9 @@ static int aer_inject(struct aer_error_inj *einj)
                 goto out_put;
         }
         pci_read_config_dword(dev, pos_cap_err + PCI_ERR_UNCOR_SEVER, &sever);
+        pci_read_config_dword(dev, pos_cap_err + PCI_ERR_COR_MASK, &cor_mask);
+        pci_read_config_dword(dev, pos_cap_err + PCI_ERR_UNCOR_MASK,
+                              &uncor_mask);
 
         rp_pos_cap_err = pci_find_ext_capability(rpdev, PCI_EXT_CAP_ID_ERR);
         if (!rp_pos_cap_err) {
@@ -374,17 +377,14 @@ static int aer_inject(struct aer_error_inj *einj)
         err->header_log2 = einj->header_log2;
         err->header_log3 = einj->header_log3;
 
-        pci_read_config_dword(dev, pos_cap_err + PCI_ERR_COR_MASK, &mask);
-        if (einj->cor_status && !(einj->cor_status & ~mask)) {
+        if (einj->cor_status && !(einj->cor_status & ~cor_mask)) {
                 ret = -EINVAL;
                 printk(KERN_WARNING "The correctable error(s) is masked "
                                 "by device\n");
                 spin_unlock_irqrestore(&inject_lock, flags);
                 goto out_put;
         }
-
-        pci_read_config_dword(dev, pos_cap_err + PCI_ERR_UNCOR_MASK, &mask);
-        if (einj->uncor_status && !(einj->uncor_status & ~mask)) {
+        if (einj->uncor_status && !(einj->uncor_status & ~uncor_mask)) {
                 ret = -EINVAL;
                 printk(KERN_WARNING "The uncorrectable error(s) is masked "
                                 "by device\n");
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 98ffb2de22e9..446e4a94d7d3 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -681,7 +681,7 @@ static void pci_read_irq(struct pci_dev *dev)
         dev->irq = irq;
 }
 
-static void set_pcie_port_type(struct pci_dev *pdev)
+void set_pcie_port_type(struct pci_dev *pdev)
 {
         int pos;
         u16 reg16;
@@ -695,7 +695,7 @@ static void set_pcie_port_type(struct pci_dev *pdev)
         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
 }
 
-static void set_pcie_hotplug_bridge(struct pci_dev *pdev)
+void set_pcie_hotplug_bridge(struct pci_dev *pdev)
 {
         int pos;
         u16 reg16;
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index 1bbff099a546..e7b89e704af6 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -1504,7 +1504,8 @@ int wm8350_register_led(struct wm8350 *wm8350, int lednum, int dcdc, int isink,
         led->isink_init.consumer_supplies = &led->isink_consumer;
         led->isink_init.constraints.min_uA = 0;
         led->isink_init.constraints.max_uA = pdata->max_uA;
-        led->isink_init.constraints.valid_ops_mask = REGULATOR_CHANGE_CURRENT;
+        led->isink_init.constraints.valid_ops_mask
+                = REGULATOR_CHANGE_CURRENT | REGULATOR_CHANGE_STATUS;
         led->isink_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
         ret = wm8350_register_regulator(wm8350, isink, &led->isink_init);
         if (ret != 0) {
@@ -1517,6 +1518,7 @@ int wm8350_register_led(struct wm8350 *wm8350, int lednum, int dcdc, int isink,
         led->dcdc_init.num_consumer_supplies = 1;
         led->dcdc_init.consumer_supplies = &led->dcdc_consumer;
         led->dcdc_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
+        led->dcdc_init.constraints.valid_ops_mask =  REGULATOR_CHANGE_STATUS;
         ret = wm8350_register_regulator(wm8350, dcdc, &led->dcdc_init);
         if (ret != 0) {
                 platform_device_put(pdev);
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index 3a7be11cc6b9..812c66755083 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -376,20 +376,22 @@ static int __devinit fm3130_probe(struct i2c_client *client,
         }
 
         /* Disabling calibration mode */
-        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_CAL)
+        if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_CAL) {
                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
                         fm3130->regs[FM3130_RTC_CONTROL] &
                                 ~(FM3130_RTC_CONTROL_BIT_CAL));
                 dev_warn(&client->dev, "Disabling calibration mode!\n");
+        }
 
         /* Disabling read and write modes */
         if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_WRITE ||
-            fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_READ)
+            fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_READ) {
                 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
                         fm3130->regs[FM3130_RTC_CONTROL] &
                                 ~(FM3130_RTC_CONTROL_BIT_READ |
                                         FM3130_RTC_CONTROL_BIT_WRITE));
                 dev_warn(&client->dev, "Disabling READ or WRITE mode!\n");
+        }
 
         /* oscillator off?  turn it on, so clock can tick. */
         if (fm3130->regs[FM3130_CAL_CONTROL] & FM3130_CAL_CONTROL_BIT_nOSCEN)
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index fdb2e7c14506..5905936c7c60 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1004,8 +1004,8 @@ static void dasd_handle_killed_request(struct ccw_device *cdev,
         if (device == NULL ||
             device != dasd_device_from_cdev_locked(cdev) ||
             strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
-                DBF_DEV_EVENT(DBF_DEBUG, device, "invalid device in request: "
-                              "bus_id %s", dev_name(&cdev->dev));
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
+                                "invalid device in request");
                 return;
         }
 
@@ -1078,8 +1078,8 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
         device = (struct dasd_device *) cqr->startdev;
         if (!device ||
             strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
-                DBF_DEV_EVENT(DBF_DEBUG, device, "invalid device in request: "
-                              "bus_id %s", dev_name(&cdev->dev));
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
+                                "invalid device in request");
                 return;
         }
 
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 1c500c462225..1cca21aafaba 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -3033,7 +3033,7 @@ static void dasd_eckd_dump_sense_ccw(struct dasd_device *device,
         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                        " in req: %p CS: 0x%02X DS: 0x%02X CC: 0x%02X RC: %d\n",
                        req, scsw_cstat(&irb->scsw), scsw_dstat(&irb->scsw),
-                       scsw_cc(&irb->scsw), req->intrc);
+                       scsw_cc(&irb->scsw), req ? req->intrc : 0);
         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                        " device %s: Failing CCW: %p\n",
                        dev_name(&device->cdev->dev),
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index fc7b30b4a255..7039d9cf0fb4 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -260,7 +260,7 @@ static int dasd_ioctl_information(struct dasd_block *block,
         struct ccw_dev_id dev_id;
 
         base = block->base;
-        if (!base->discipline->fill_info)
+        if (!base->discipline || !base->discipline->fill_info)
                 return -EINVAL;
 
         dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
@@ -303,10 +303,7 @@ static int dasd_ioctl_information(struct dasd_block *block,
         dasd_info->features |=
                 ((base->features & DASD_FEATURE_READONLY) != 0);
 
-        if (base->discipline)
-                memcpy(dasd_info->type, base->discipline->name, 4);
-        else
-                memcpy(dasd_info->type, "none", 4);
+        memcpy(dasd_info->type, base->discipline->name, 4);
 
         if (block->request_queue->request_fn) {
                 struct list_head *l;
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index 6315fbd8e68b..71f95f54866f 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -72,7 +72,7 @@ dasd_devices_show(struct seq_file *m, void *v)
         /* Print device number. */
         seq_printf(m, "%s", dev_name(&device->cdev->dev));
         /* Print discipline string. */
-        if (device != NULL && device->discipline != NULL)
+        if (device->discipline != NULL)
                 seq_printf(m, "(%s)", device->discipline->name);
         else
                 seq_printf(m, "(none)");
@@ -92,10 +92,7 @@ dasd_devices_show(struct seq_file *m, void *v)
         substr = (device->features & DASD_FEATURE_READONLY) ? "(ro)" : " ";
         seq_printf(m, "%4s: ", substr);
         /* Print device status information. */
-        switch ((device != NULL) ? device->state : -1) {
-        case -1:
-                seq_printf(m, "unknown");
-                break;
+        switch (device->state) {
         case DASD_STATE_NEW:
                 seq_printf(m, "new");
                 break;
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index b9d2a007e93b..3796ffdb8479 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -495,6 +495,10 @@ sclp_vt220_open(struct tty_struct *tty, struct file *filp)
                 if (tty->driver_data == NULL)
                         return -ENOMEM;
                 tty->low_latency = 0;
+                if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
+                        tty->winsize.ws_row = 24;
+                        tty->winsize.ws_col = 80;
+                }
         }
         return 0;
 }
diff --git a/drivers/s390/crypto/zcrypt_pcicc.c b/drivers/s390/crypto/zcrypt_pcicc.c
index a23726a0735c..142f72a2ca5a 100644
--- a/drivers/s390/crypto/zcrypt_pcicc.c
+++ b/drivers/s390/crypto/zcrypt_pcicc.c
@@ -373,6 +373,8 @@ static int convert_type86(struct zcrypt_device *zdev,
                         zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
                         return -EAGAIN;
                 }
+                if (service_rc == 8 && service_rs == 72)
+                        return -EINVAL;
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
         }
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index 79c120578e61..68f3e6204db8 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -470,6 +470,8 @@ static int convert_type86_ica(struct zcrypt_device *zdev,
                 }
                 if (service_rc == 12 && service_rs == 769)
                         return -EINVAL;
+                if (service_rc == 8 && service_rs == 72)
+                        return -EINVAL;
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
         }
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index f932400e980a..0eb6eefd2c1a 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -12,6 +12,7 @@
 
 #include <linux/types.h>
 #include <linux/miscdevice.h>
+#include <asm/compat.h>
 #include <asm/ccwdev.h>
 #include "zfcp_def.h"
 #include "zfcp_ext.h"
@@ -163,7 +164,7 @@ static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data,
 }
 
 static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
-                                unsigned long buffer)
+                                unsigned long arg)
 {
         struct zfcp_cfdc_data *data;
         struct zfcp_cfdc_data __user *data_user;
@@ -175,7 +176,11 @@ static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
         if (command != ZFCP_CFDC_IOC)
                 return -ENOTTY;
 
-        data_user = (void __user *) buffer;
+        if (is_compat_task())
+                data_user = compat_ptr(arg);
+        else
+                data_user = (void __user *)arg;
+
         if (!data_user)
                 return -EINVAL;
 
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 84450955ae11..7369c8911bcf 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -327,7 +327,7 @@ static void zfcp_dbf_hba_view_response(char **p,
                         break;
                 zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd);
                 zfcp_dbf_out(p, "scsi_serial", "0x%016Lx", r->u.fcp.serial);
-                p += sprintf(*p, "\n");
+                *p += sprintf(*p, "\n");
                 break;
 
         case FSF_QTCB_OPEN_PORT_WITH_DID:
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index 03dec832b465..66bdb34143cb 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -108,6 +108,7 @@ extern void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *);
 extern int zfcp_fc_gs_setup(struct zfcp_adapter *);
 extern void zfcp_fc_gs_destroy(struct zfcp_adapter *);
 extern int zfcp_fc_exec_bsg_job(struct fc_bsg_job *);
+extern int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *);
 
 /* zfcp_fsf.c */
 extern int zfcp_fsf_open_port(struct zfcp_erp_action *);
@@ -129,9 +130,9 @@ extern void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *);
 extern int zfcp_fsf_status_read(struct zfcp_qdio *);
 extern int zfcp_status_read_refill(struct zfcp_adapter *adapter);
 extern int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *, struct zfcp_fsf_ct_els *,
-                            mempool_t *);
+                            mempool_t *, unsigned int);
 extern int zfcp_fsf_send_els(struct zfcp_adapter *, u32,
-                             struct zfcp_fsf_ct_els *);
+                             struct zfcp_fsf_ct_els *, unsigned int);
 extern int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *,
                                           struct scsi_cmnd *);
 extern void zfcp_fsf_req_free(struct zfcp_fsf_req *);
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index ac5e3b7a3576..0f7b493fb105 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -258,7 +258,8 @@ static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
         gid_pn->gid_pn_req.gid_pn.fn_wwpn = port->wwpn;
 
         ret = zfcp_fsf_send_ct(&adapter->gs->ds, &gid_pn->ct,
-                               adapter->pool.gid_pn_req);
+                               adapter->pool.gid_pn_req,
+                               ZFCP_FC_CTELS_TMO);
         if (!ret) {
                 wait_for_completion(&completion);
                 zfcp_fc_ns_gid_pn_eval(gid_pn);
@@ -421,7 +422,8 @@ static int zfcp_fc_adisc(struct zfcp_port *port)
         hton24(adisc->adisc_req.adisc_port_id,
                fc_host_port_id(adapter->scsi_host));
 
-        ret = zfcp_fsf_send_els(adapter, port->d_id, &adisc->els);
+        ret = zfcp_fsf_send_els(adapter, port->d_id, &adisc->els,
+                                ZFCP_FC_CTELS_TMO);
         if (ret)
                 kmem_cache_free(zfcp_data.adisc_cache, adisc);
 
@@ -532,7 +534,8 @@ static int zfcp_fc_send_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
         ct->req = &gpn_ft->sg_req;
         ct->resp = gpn_ft->sg_resp;
 
-        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct, NULL);
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct, NULL,
+                               ZFCP_FC_CTELS_TMO);
         if (!ret)
                 wait_for_completion(&completion);
         return ret;
@@ -677,6 +680,44 @@ static void zfcp_fc_ct_els_job_handler(void *data)
         job->job_done(job);
 }
 
+static struct zfcp_fc_wka_port *zfcp_fc_job_wka_port(struct fc_bsg_job *job)
+{
+        u32 preamble_word1;
+        u8 gs_type;
+        struct zfcp_adapter *adapter;
+
+        preamble_word1 = job->request->rqst_data.r_ct.preamble_word1;
+        gs_type = (preamble_word1 & 0xff000000) >> 24;
+
+        adapter = (struct zfcp_adapter *) job->shost->hostdata[0];
+
+        switch (gs_type) {
+        case FC_FST_ALIAS:
+                return &adapter->gs->as;
+        case FC_FST_MGMT:
+                return &adapter->gs->ms;
+        case FC_FST_TIME:
+                return &adapter->gs->ts;
+                break;
+        case FC_FST_DIR:
+                return &adapter->gs->ds;
+                break;
+        default:
+                return NULL;
+        }
+}
+
+static void zfcp_fc_ct_job_handler(void *data)
+{
+        struct fc_bsg_job *job = data;
+        struct zfcp_fc_wka_port *wka_port;
+
+        wka_port = zfcp_fc_job_wka_port(job);
+        zfcp_fc_wka_port_put(wka_port);
+
+        zfcp_fc_ct_els_job_handler(data);
+}
+
 static int zfcp_fc_exec_els_job(struct fc_bsg_job *job,
                                 struct zfcp_adapter *adapter)
 {
@@ -695,43 +736,27 @@ static int zfcp_fc_exec_els_job(struct fc_bsg_job *job,
         } else
                 d_id = ntoh24(job->request->rqst_data.h_els.port_id);
 
-        return zfcp_fsf_send_els(adapter, d_id, els);
+        els->handler = zfcp_fc_ct_els_job_handler;
+        return zfcp_fsf_send_els(adapter, d_id, els, job->req->timeout / HZ);
 }
 
 static int zfcp_fc_exec_ct_job(struct fc_bsg_job *job,
                                struct zfcp_adapter *adapter)
 {
         int ret;
-        u8 gs_type;
         struct zfcp_fsf_ct_els *ct = job->dd_data;
         struct zfcp_fc_wka_port *wka_port;
-        u32 preamble_word1;
 
-        preamble_word1 = job->request->rqst_data.r_ct.preamble_word1;
-        gs_type = (preamble_word1 & 0xff000000) >> 24;
-
-        switch (gs_type) {
-        case FC_FST_ALIAS:
-                wka_port = &adapter->gs->as;
-                break;
-        case FC_FST_MGMT:
-                wka_port = &adapter->gs->ms;
-                break;
-        case FC_FST_TIME:
-                wka_port = &adapter->gs->ts;
-                break;
-        case FC_FST_DIR:
-                wka_port = &adapter->gs->ds;
-                break;
-        default:
-                return -EINVAL; /* no such service */
-        }
+        wka_port = zfcp_fc_job_wka_port(job);
+        if (!wka_port)
+                return -EINVAL;
 
         ret = zfcp_fc_wka_port_get(wka_port);
         if (ret)
                 return ret;
 
-        ret = zfcp_fsf_send_ct(wka_port, ct, NULL);
+        ct->handler = zfcp_fc_ct_job_handler;
+        ret = zfcp_fsf_send_ct(wka_port, ct, NULL, job->req->timeout / HZ);
         if (ret)
                 zfcp_fc_wka_port_put(wka_port);
 
@@ -752,7 +777,6 @@ int zfcp_fc_exec_bsg_job(struct fc_bsg_job *job)
 
         ct_els->req = job->request_payload.sg_list;
         ct_els->resp = job->reply_payload.sg_list;
-        ct_els->handler = zfcp_fc_ct_els_job_handler;
         ct_els->handler_data = job;
 
         switch (job->request->msgcode) {
@@ -767,6 +791,12 @@ int zfcp_fc_exec_bsg_job(struct fc_bsg_job *job)
         }
 }
 
+int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *job)
+{
+        /* hardware tracks timeout, reset bsg timeout to not interfere */
+        return -EAGAIN;
+}
+
 int zfcp_fc_gs_setup(struct zfcp_adapter *adapter)
 {
         struct zfcp_fc_wka_ports *wka_ports;
diff --git a/drivers/s390/scsi/zfcp_fc.h b/drivers/s390/scsi/zfcp_fc.h
index cb2a3669a384..0747b087390d 100644
--- a/drivers/s390/scsi/zfcp_fc.h
+++ b/drivers/s390/scsi/zfcp_fc.h
@@ -27,6 +27,8 @@
 #define ZFCP_FC_GPN_FT_MAX_ENT    (ZFCP_FC_GPN_FT_NUM_BUFS * \
                                         (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
 
+#define ZFCP_FC_CTELS_TMO       (2 * FC_DEF_R_A_TOV / 1000)
+
 /**
  * struct zfcp_fc_gid_pn_req - container for ct header plus gid_pn request
  * @ct_hdr: FC GS common transport header
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 482dcd97aa5d..e8fb4d9baa8b 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -1068,20 +1068,20 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
 static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
                                  struct scatterlist *sg_req,
                                  struct scatterlist *sg_resp,
-                                 int max_sbals)
+                                 int max_sbals, unsigned int timeout)
 {
         int ret;
-        unsigned int fcp_chan_timeout;
 
         ret = zfcp_fsf_setup_ct_els_sbals(req, sg_req, sg_resp, max_sbals);
         if (ret)
                 return ret;
 
         /* common settings for ct/gs and els requests */
-        fcp_chan_timeout = 2 * FC_DEF_R_A_TOV / 1000;
+        if (timeout > 255)
+                timeout = 255; /* max value accepted by hardware */
         req->qtcb->bottom.support.service_class = FSF_CLASS_3;
-        req->qtcb->bottom.support.timeout = fcp_chan_timeout;
-        zfcp_fsf_start_timer(req, (fcp_chan_timeout + 10) * HZ);
+        req->qtcb->bottom.support.timeout = timeout;
+        zfcp_fsf_start_timer(req, (timeout + 10) * HZ);
 
         return 0;
 }
@@ -1092,7 +1092,8 @@ static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
  * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
  */
 int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
-                     struct zfcp_fsf_ct_els *ct, mempool_t *pool)
+                     struct zfcp_fsf_ct_els *ct, mempool_t *pool,
+                     unsigned int timeout)
 {
         struct zfcp_qdio *qdio = wka_port->adapter->qdio;
         struct zfcp_fsf_req *req;
@@ -1111,7 +1112,7 @@ int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
         ret = zfcp_fsf_setup_ct_els(req, ct->req, ct->resp,
-                                    FSF_MAX_SBALS_PER_REQ);
+                                    FSF_MAX_SBALS_PER_REQ, timeout);
         if (ret)
                 goto failed_send;
 
@@ -1188,7 +1189,7 @@ skip_fsfstatus:
  * @els: pointer to struct zfcp_send_els with data for the command
  */
 int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
-                      struct zfcp_fsf_ct_els *els)
+                      struct zfcp_fsf_ct_els *els, unsigned int timeout)
 {
         struct zfcp_fsf_req *req;
         struct zfcp_qdio *qdio = adapter->qdio;
@@ -1206,7 +1207,7 @@ int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, 2);
+        ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, 2, timeout);
 
         if (ret)
                 goto failed_send;
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 771cc536a989..8e6fc68d6bd4 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -652,6 +652,7 @@ struct fc_function_template zfcp_transport_functions = {
         .show_host_port_state = 1,
         .show_host_active_fc4s = 1,
         .bsg_request = zfcp_fc_exec_bsg_job,
+        .bsg_timeout = zfcp_fc_timeout_bsg_job,
         /* no functions registered for following dynamic attributes but
            directly set by LLDD */
         .show_host_port_type = 1,
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 2a889853a106..7e26ebc26661 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -293,7 +293,10 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
                         status = -EINVAL;
                 }
         }
-        aac_fib_complete(fibptr);
+        /* Do not set XferState to zero unless receives a response from F/W */
+        if (status >= 0)
+                aac_fib_complete(fibptr);
+
         /* Send a CT_COMMIT_CONFIG to enable discovery of devices */
         if (status >= 0) {
                 if ((aac_commit == 1) || commit_flag) {
@@ -310,13 +313,18 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
                                     FsaNormal,
                                     1, 1,
                                     NULL, NULL);
-                        aac_fib_complete(fibptr);
+                        /* Do not set XferState to zero unless
+                         * receives a response from F/W */
+                        if (status >= 0)
+                                aac_fib_complete(fibptr);
                 } else if (aac_commit == 0) {
                         printk(KERN_WARNING
                           "aac_get_config_status: Foreign device configurations are being ignored\n");
                 }
         }
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibptr);
         return status;
 }
 
@@ -355,7 +363,9 @@ int aac_get_containers(struct aac_dev *dev)
                 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
                 aac_fib_complete(fibptr);
         }
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibptr);
 
         if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
                 maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
@@ -1245,8 +1255,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
                          NULL);
 
         if (rcode < 0) {
-                aac_fib_complete(fibptr);
-                aac_fib_free(fibptr);
+                /* FIB should be freed only after
+                 * getting the response from the F/W */
+                if (rcode != -ERESTARTSYS) {
+                        aac_fib_complete(fibptr);
+                        aac_fib_free(fibptr);
+                }
                 return rcode;
         }
         memcpy(&dev->adapter_info, info, sizeof(*info));
@@ -1270,6 +1284,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
 
                 if (rcode >= 0)
                         memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo));
+                if (rcode == -ERESTARTSYS) {
+                        fibptr = aac_fib_alloc(dev);
+                        if (!fibptr)
+                                return -ENOMEM;
+                }
+
         }
 
 
@@ -1470,9 +1490,11 @@ int aac_get_adapter_info(struct aac_dev* dev)
                           (dev->scsi_host_ptr->sg_tablesize * 8) + 112;
                 }
         }
-
-        aac_fib_complete(fibptr);
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (rcode != -ERESTARTSYS) {
+                aac_fib_complete(fibptr);
+                aac_fib_free(fibptr);
+        }
 
         return rcode;
 }
@@ -1633,6 +1655,7 @@ static int aac_read(struct scsi_cmnd * scsicmd)
          *      Alocate and initialize a Fib
          */
         if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
+                printk(KERN_WARNING "aac_read: fib allocation failed\n");
                 return -1;
         }
 
@@ -1712,9 +1735,14 @@ static int aac_write(struct scsi_cmnd * scsicmd)
          *      Allocate and initialize a Fib then setup a BlockWrite command
          */
         if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
-                scsicmd->result = DID_ERROR << 16;
-                scsicmd->scsi_done(scsicmd);
-                return 0;
+                /* FIB temporarily unavailable,not catastrophic failure */
+
+                /* scsicmd->result = DID_ERROR << 16;
+                 * scsicmd->scsi_done(scsicmd);
+                 * return 0;
+                 */
+                printk(KERN_WARNING "aac_write: fib allocation failed\n");
+                return -1;
         }
 
         status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index 83986ed86556..619c02d9c862 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -12,7 +12,7 @@
  *----------------------------------------------------------------------------*/
 
 #ifndef AAC_DRIVER_BUILD
-# define AAC_DRIVER_BUILD 2461
+# define AAC_DRIVER_BUILD 24702
 # define AAC_DRIVER_BRANCH "-ms"
 #endif
 #define MAXIMUM_NUM_CONTAINERS  32
@@ -1036,6 +1036,9 @@ struct aac_dev
         u8                      printf_enabled;
         u8                      in_reset;
         u8                      msi;
+        int                     management_fib_count;
+        spinlock_t              manage_lock;
+
 };
 
 #define aac_adapter_interrupt(dev) \
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index 0391d759dfdb..9c0c91178538 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -153,7 +153,7 @@ cleanup:
                 fibptr->hw_fib_pa = hw_fib_pa;
                 fibptr->hw_fib_va = hw_fib;
         }
-        if (retval != -EINTR)
+        if (retval != -ERESTARTSYS)
                 aac_fib_free(fibptr);
         return retval;
 }
@@ -322,7 +322,7 @@ return_fib:
                 }
                 if (f.wait) {
                         if(down_interruptible(&fibctx->wait_sem) < 0) {
-                                status = -EINTR;
+                                status = -ERESTARTSYS;
                         } else {
                                 /* Lock again and retry */
                                 spin_lock_irqsave(&dev->fib_lock, flags);
@@ -593,10 +593,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 u64 addr;
                                 void* p;
                                 if (upsg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -645,10 +645,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 u64 addr;
                                 void* p;
                                 if (usg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -695,10 +695,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 uintptr_t addr;
                                 void* p;
                                 if (usg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -734,10 +734,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 dma_addr_t addr;
                                 void* p;
                                 if (upsg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -772,8 +772,8 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                 psg->count = cpu_to_le32(sg_indx+1);
                 status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
         }
-        if (status == -EINTR) {
-                rcode = -EINTR;
+        if (status == -ERESTARTSYS) {
+                rcode = -ERESTARTSYS;
                 goto cleanup;
         }
 
@@ -810,7 +810,7 @@ cleanup:
         for(i=0; i <= sg_indx; i++){
                 kfree(sg_list[i]);
         }
-        if (rcode != -EINTR) {
+        if (rcode != -ERESTARTSYS) {
                 aac_fib_complete(srbfib);
                 aac_fib_free(srbfib);
         }
@@ -848,7 +848,7 @@ int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg)
          */
 
         status = aac_dev_ioctl(dev, cmd, arg);
-        if(status != -ENOTTY)
+        if (status != -ENOTTY)
                 return status;
 
         switch (cmd) {
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index 666d5151d628..a7261486ccd4 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -194,7 +194,9 @@ int aac_send_shutdown(struct aac_dev * dev)
 
         if (status >= 0)
                 aac_fib_complete(fibctx);
-        aac_fib_free(fibctx);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibctx);
         return status;
 }
 
@@ -304,6 +306,8 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
         /*
          *      Check the preferred comm settings, defaults from template.
          */
+        dev->management_fib_count = 0;
+        spin_lock_init(&dev->manage_lock);
         dev->max_fib_size = sizeof(struct hw_fib);
         dev->sg_tablesize = host->sg_tablesize = (dev->max_fib_size
                 - sizeof(struct aac_fibhdr)
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 956261f25181..94d2954d79ae 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -189,7 +189,14 @@ struct fib *aac_fib_alloc(struct aac_dev *dev)
 
 void aac_fib_free(struct fib *fibptr)
 {
-        unsigned long flags;
+        unsigned long flags, flagsv;
+
+        spin_lock_irqsave(&fibptr->event_lock, flagsv);
+        if (fibptr->done == 2) {
+                spin_unlock_irqrestore(&fibptr->event_lock, flagsv);
+                return;
+        }
+        spin_unlock_irqrestore(&fibptr->event_lock, flagsv);
 
         spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
         if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
@@ -390,6 +397,8 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
         unsigned long flags = 0;
         unsigned long qflags;
+        unsigned long mflags = 0;
+
 
         if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
                 return -EBUSY;
@@ -471,9 +480,31 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         if (!dev->queues)
                 return -EBUSY;
 
-        if(wait)
+        if (wait) {
+
+                spin_lock_irqsave(&dev->manage_lock, mflags);
+                if (dev->management_fib_count >= AAC_NUM_MGT_FIB) {
+                        printk(KERN_INFO "No management Fibs Available:%d\n",
+                                                dev->management_fib_count);
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+                        return -EBUSY;
+                }
+                dev->management_fib_count++;
+                spin_unlock_irqrestore(&dev->manage_lock, mflags);
                 spin_lock_irqsave(&fibptr->event_lock, flags);
-        aac_adapter_deliver(fibptr);
+        }
+
+        if (aac_adapter_deliver(fibptr) != 0) {
+                printk(KERN_ERR "aac_fib_send: returned -EBUSY\n");
+                if (wait) {
+                        spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+                }
+                return -EBUSY;
+        }
+
 
         /*
          *      If the caller wanted us to wait for response wait now.
@@ -516,14 +547,15 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                                 udelay(5);
                         }
                 } else if (down_interruptible(&fibptr->event_wait)) {
-                        fibptr->done = 2;
-                        up(&fibptr->event_wait);
+                        /* Do nothing ... satisfy
+                         * down_interruptible must_check */
                 }
+
                 spin_lock_irqsave(&fibptr->event_lock, flags);
-                if ((fibptr->done == 0) || (fibptr->done == 2)) {
+                if (fibptr->done == 0) {
                         fibptr->done = 2; /* Tell interrupt we aborted */
                         spin_unlock_irqrestore(&fibptr->event_lock, flags);
-                        return -EINTR;
+                        return -ERESTARTSYS;
                 }
                 spin_unlock_irqrestore(&fibptr->event_lock, flags);
                 BUG_ON(fibptr->done == 0);
@@ -689,6 +721,7 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
 
 int aac_fib_complete(struct fib *fibptr)
 {
+        unsigned long flags;
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
 
         /*
@@ -709,6 +742,13 @@ int aac_fib_complete(struct fib *fibptr)
          *      command is complete that we had sent to the adapter and this
          *      cdb could be reused.
          */
+        spin_lock_irqsave(&fibptr->event_lock, flags);
+        if (fibptr->done == 2) {
+                spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&fibptr->event_lock, flags);
+
         if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) &&
                 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed)))
         {
@@ -1355,7 +1395,10 @@ int aac_reset_adapter(struct aac_dev * aac, int forced)
 
                         if (status >= 0)
                                 aac_fib_complete(fibctx);
-                        aac_fib_free(fibctx);
+                        /* FIB should be freed only after getting
+                         * the response from the F/W */
+                        if (status != -ERESTARTSYS)
+                                aac_fib_free(fibctx);
                 }
         }
 
@@ -1759,6 +1802,7 @@ int aac_command_thread(void *data)
                                 struct fib *fibptr;
 
                                 if ((fibptr = aac_fib_alloc(dev))) {
+                                        int status;
                                         __le32 *info;
 
                                         aac_fib_init(fibptr);
@@ -1769,15 +1813,21 @@ int aac_command_thread(void *data)
 
                                         *info = cpu_to_le32(now.tv_sec);
 
-                                        (void)aac_fib_send(SendHostTime,
+                                        status = aac_fib_send(SendHostTime,
                                                 fibptr,
                                                 sizeof(*info),
                                                 FsaNormal,
                                                 1, 1,
                                                 NULL,
                                                 NULL);
-                                        aac_fib_complete(fibptr);
-                                        aac_fib_free(fibptr);
+                                        /* Do not set XferState to zero unless
+                                         * receives a response from F/W */
+                                        if (status >= 0)
+                                                aac_fib_complete(fibptr);
+                                        /* FIB should be freed only after
+                                         * getting the response from the F/W */
+                                        if (status != -ERESTARTSYS)
+                                                aac_fib_free(fibptr);
                                 }
                                 difference = (long)(unsigned)update_interval*HZ;
                         } else {
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index abc9ef5d1b10..9c7408fe8c7d 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -57,9 +57,9 @@ unsigned int aac_response_normal(struct aac_queue * q)
         struct hw_fib * hwfib;
         struct fib * fib;
         int consumed = 0;
-        unsigned long flags;
+        unsigned long flags, mflags;
 
-        spin_lock_irqsave(q->lock, flags);      
+        spin_lock_irqsave(q->lock, flags);
         /*
          *      Keep pulling response QEs off the response queue and waking
          *      up the waiters until there are no more QEs. We then return
@@ -125,12 +125,21 @@ unsigned int aac_response_normal(struct aac_queue * q)
                 } else {
                         unsigned long flagv;
                         spin_lock_irqsave(&fib->event_lock, flagv);
-                        if (!fib->done)
+                        if (!fib->done) {
                                 fib->done = 1;
-                        up(&fib->event_wait);
+                                up(&fib->event_wait);
+                        }
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
+
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+
                         FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
                         if (fib->done == 2) {
+                                spin_lock_irqsave(&fib->event_lock, flagv);
+                                fib->done = 0;
+                                spin_unlock_irqrestore(&fib->event_lock, flagv);
                                 aac_fib_complete(fib);
                                 aac_fib_free(fib);
                         }
@@ -232,6 +241,7 @@ unsigned int aac_command_normal(struct aac_queue *q)
 
 unsigned int aac_intr_normal(struct aac_dev * dev, u32 index)
 {
+        unsigned long mflags;
         dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, index));
         if ((index & 0x00000002L)) {
                 struct hw_fib * hw_fib;
@@ -320,11 +330,25 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 index)
                         unsigned long flagv;
                         dprintk((KERN_INFO "event_wait up\n"));
                         spin_lock_irqsave(&fib->event_lock, flagv);
-                        if (!fib->done)
+                        if (!fib->done) {
                                 fib->done = 1;
-                        up(&fib->event_wait);
+                                up(&fib->event_wait);
+                        }
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
+
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+
                         FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
+                        if (fib->done == 2) {
+                                spin_lock_irqsave(&fib->event_lock, flagv);
+                                fib->done = 0;
+                                spin_unlock_irqrestore(&fib->event_lock, flagv);
+                                aac_fib_complete(fib);
+                                aac_fib_free(fib);
+                        }
+
                 }
                 return 0;
         }
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 4d419c155ce9..78971db5b60e 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -3171,13 +3171,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                 tinfo->curr.transport_version = 2;
                                 tinfo->goal.transport_version = 2;
                                 tinfo->goal.ppr_options = 0;
-                                /*
-                                 * Remove any SCBs in the waiting for selection
-                                 * queue that may also be for this target so
-                                 * that command ordering is preserved.
-                                 */
-                                ahd_freeze_devq(ahd, scb);
-                                ahd_qinfifo_requeue_tail(ahd, scb);
+                                if (scb != NULL) {
+                                        /*
+                                         * Remove any SCBs in the waiting
+                                         * for selection queue that may
+                                         * also be for this target so that
+                                         * command ordering is preserved.
+                                         */
+                                        ahd_freeze_devq(ahd, scb);
+                                        ahd_qinfifo_requeue_tail(ahd, scb);
+                                }
                                 printerror = 0;
                         }
                 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, FALSE)
@@ -3194,13 +3197,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                       MSG_EXT_WDTR_BUS_8_BIT,
                                       AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                       /*paused*/TRUE);
-                        /*
-                         * Remove any SCBs in the waiting for selection
-                         * queue that may also be for this target so that
-                         * command ordering is preserved.
-                         */
-                        ahd_freeze_devq(ahd, scb);
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                        if (scb != NULL) {
+                                /*
+                                 * Remove any SCBs in the waiting for
+                                 * selection queue that may also be for
+                                 * this target so that command ordering
+                                 * is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                        }
                         printerror = 0;
                 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, FALSE)
                         && ppr_busfree == 0) {
@@ -3217,13 +3223,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                         /*ppr_options*/0,
                                         AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                         /*paused*/TRUE);
-                        /*
-                         * Remove any SCBs in the waiting for selection
-                         * queue that may also be for this target so that
-                         * command ordering is preserved.
-                         */
-                        ahd_freeze_devq(ahd, scb);
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                        if (scb != NULL) {
+                                /*
+                                 * Remove any SCBs in the waiting for
+                                 * selection queue that may also be for
+                                 * this target so that command ordering
+                                 * is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                        }
                         printerror = 0;
                 } else if ((ahd->msg_flags & MSG_FLAG_EXPECT_IDE_BUSFREE) != 0
                         && ahd_sent_msg(ahd, AHDMSG_1B,
@@ -3251,7 +3260,7 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
          * the message phases.  We check it last in case we
          * had to send some other message that caused a busfree.
          */
-        if (printerror != 0
+        if (scb != NULL && printerror != 0
          && (lastphase == P_MESGIN || lastphase == P_MESGOUT)
          && ((ahd->msg_flags & MSG_FLAG_EXPECT_PPR_BUSFREE) != 0)) {
 
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 2445e399fd60..2445e399fd60 100755..100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 8a2a1c5935c6..8a2a1c5935c6 100755..100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 608e675f68c8..1263d9796e89 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -1586,8 +1586,7 @@ typedef struct fc_port {
  */
 #define FCF_FABRIC_DEVICE       BIT_0
 #define FCF_LOGIN_NEEDED        BIT_1
-#define FCF_TAPE_PRESENT        BIT_2
-#define FCF_FCP2_DEVICE         BIT_3
+#define FCF_FCP2_DEVICE         BIT_2
 
 /* No loop ID flag. */
 #define FC_NO_LOOP_ID           0x1000
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index b4a0eac8f96d..3f8e8495b743 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -205,7 +205,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 
         switch (data[0]) {
         case MBS_COMMAND_COMPLETE:
-                if (fcport->flags & FCF_TAPE_PRESENT)
+                if (fcport->flags & FCF_FCP2_DEVICE)
                         opts |= BIT_1;
                 rval = qla2x00_get_port_database(vha, fcport, opts);
                 if (rval != QLA_SUCCESS)
@@ -2726,7 +2726,7 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
 
                 /*
                  * Logout all previous fabric devices marked lost, except
-                 * tape devices.
+                 * FCP2 devices.
                  */
                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
                         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
@@ -2739,7 +2739,7 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
                                 qla2x00_mark_device_lost(vha, fcport,
                                     ql2xplogiabsentdevice, 0);
                                 if (fcport->loop_id != FC_NO_LOOP_ID &&
-                                    (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
+                                    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
                                     fcport->port_type != FCT_INITIATOR &&
                                     fcport->port_type != FCT_BROADCAST) {
                                         ha->isp_ops->fabric_logout(vha,
@@ -3018,7 +3018,7 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                         fcport->d_id.b24 = new_fcport->d_id.b24;
                         fcport->flags |= FCF_LOGIN_NEEDED;
                         if (fcport->loop_id != FC_NO_LOOP_ID &&
-                            (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
+                            (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
                             fcport->port_type != FCT_INITIATOR &&
                             fcport->port_type != FCT_BROADCAST) {
                                 ha->isp_ops->fabric_logout(vha, fcport->loop_id,
@@ -3272,9 +3272,9 @@ qla2x00_fabric_dev_login(scsi_qla_host_t *vha, fc_port_t *fcport,
 
         rval = qla2x00_fabric_login(vha, fcport, next_loopid);
         if (rval == QLA_SUCCESS) {
-                /* Send an ADISC to tape devices.*/
+                /* Send an ADISC to FCP2 devices.*/
                 opts = 0;
-                if (fcport->flags & FCF_TAPE_PRESENT)
+                if (fcport->flags & FCF_FCP2_DEVICE)
                         opts |= BIT_1;
                 rval = qla2x00_get_port_database(vha, fcport, opts);
                 if (rval != QLA_SUCCESS) {
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 209f50e788a1..8529eb1f3cd4 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1188,7 +1188,6 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
         scsi_qla_host_t *vha = shost_priv(sdev->host);
         struct qla_hw_data *ha = vha->hw;
         struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
-        fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
         struct req_que *req = vha->req;
 
         if (sdev->tagged_supported)
@@ -1197,8 +1196,6 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
                 scsi_deactivate_tcq(sdev, req->max_q_depth);
 
         rport->dev_loss_tmo = ha->port_down_retry_count;
-        if (sdev->type == TYPE_TAPE)
-                fcport->flags |= FCF_TAPE_PRESENT;
 
         return 0;
 }
@@ -2805,7 +2802,7 @@ void qla2x00_relogin(struct scsi_qla_host *vha)
 
                         fcport->login_retry--;
                         if (fcport->flags & FCF_FABRIC_DEVICE) {
-                                if (fcport->flags & FCF_TAPE_PRESENT)
+                                if (fcport->flags & FCF_FCP2_DEVICE)
                                         ha->isp_ops->fabric_logout(vha,
                                                         fcport->loop_id,
                                                         fcport->d_id.b.domain,
@@ -3141,7 +3138,10 @@ qla2x00_timer(scsi_qla_host_t *vha)
                         if (!IS_QLA2100(ha) && vha->link_down_timeout)
                                 atomic_set(&vha->loop_state, LOOP_DEAD);
 
-                        /* Schedule an ISP abort to return any tape commands. */
+                        /*
+                         * Schedule an ISP abort to return any FCP2-device
+                         * commands.
+                         */
                         /* NPIV - scan physical port only */
                         if (!vha->vp_idx) {
                                 spin_lock_irqsave(&ha->hardware_lock,
@@ -3158,7 +3158,7 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                         if (sp->ctx)
                                                 continue;
                                         sfcp = sp->fcport;
-                                        if (!(sfcp->flags & FCF_TAPE_PRESENT))
+                                        if (!(sfcp->flags & FCF_FCP2_DEVICE))
                                                 continue;
 
                                         set_bit(ISP_ABORT_NEEDED,
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 010e69b29afe..371dc895972a 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -2292,11 +2292,14 @@ qla25xx_read_optrom_data(struct scsi_qla_host *vha, uint8_t *buf,
         uint32_t faddr, left, burst;
         struct qla_hw_data *ha = vha->hw;
 
+        if (IS_QLA25XX(ha) || IS_QLA81XX(ha))
+                goto try_fast;
         if (offset & 0xfff)
                 goto slow_read;
         if (length < OPTROM_BURST_SIZE)
                 goto slow_read;
 
+try_fast:
         optrom = dma_alloc_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
             &optrom_dma, GFP_KERNEL);
         if (!optrom) {
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index a65dd95507c6..ed36279a33c1 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.01-k9"
+#define QLA2XXX_VERSION      "8.03.01-k10"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index d8927681ec88..c6642423cc67 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -749,9 +749,9 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                          */
                         req->next_rq->resid_len = scsi_in(cmd)->resid;
 
+                        scsi_release_buffers(cmd);
                         blk_end_request_all(req, 0);
 
-                        scsi_release_buffers(cmd);
                         scsi_next_command(cmd);
                         return;
                 }
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index ddfcecd5099f..653f22a8deb9 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -3527,7 +3527,10 @@ fc_bsg_job_timeout(struct request *req)
         if (!done && i->f->bsg_timeout) {
                 /* call LLDD to abort the i/o as it has timed out */
                 err = i->f->bsg_timeout(job);
-                if (err)
+                if (err == -EAGAIN) {
+                        job->ref_cnt--;
+                        return BLK_EH_RESET_TIMER;
+                } else if (err)
                         printk(KERN_ERR "ERROR: FC BSG request timeout - LLD "
                                 "abort failed with status %d\n", err);
         }
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index df854401af2d..95421fa3b304 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -758,6 +758,7 @@ static struct pcmcia_device_id serial_ids[] = {
         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
         PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
+        PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x0e01),
         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x0a05),
         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x1101),
         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index 377f2712289e..ab2ab3c81834 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -394,7 +394,7 @@ static void ulite_console_write(struct console *co, const char *s,
                 spin_unlock_irqrestore(&port->lock, flags);
 }
 
-static int __init ulite_console_setup(struct console *co, char *options)
+static int __devinit ulite_console_setup(struct console *co, char *options)
 {
         struct uart_port *port;
         int baud = 9600;
diff --git a/drivers/spi/spi_sh_msiof.c b/drivers/spi/spi_sh_msiof.c
index 51e5e1dfa6e5..30973ec16a93 100644
--- a/drivers/spi/spi_sh_msiof.c
+++ b/drivers/spi/spi_sh_msiof.c
@@ -173,15 +173,12 @@ static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p,
         int edge;
 
         /*
-         * CPOL CPHA     TSCKIZ RSCKIZ TEDG REDG(!)
-         *    0    0         10     10    1    0
-         *    0    1         10     10    0    1
-         *    1    0         11     11    0    1
-         *    1    1         11     11    1    0
-         *
-         * (!) Note: REDG is inverted recommended data sheet setting
+         * CPOL CPHA     TSCKIZ RSCKIZ TEDG REDG
+         *    0    0         10     10    1    1
+         *    0    1         10     10    0    0
+         *    1    0         11     11    0    0
+         *    1    1         11     11    1    1
          */
-
         sh_msiof_write(p, FCTR, 0);
         sh_msiof_write(p, TMDR1, 0xe2000005 | (lsb_first << 24));
         sh_msiof_write(p, RMDR1, 0x22000005 | (lsb_first << 24));
@@ -193,7 +190,7 @@ static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p,
         edge = cpol ? cpha : !cpha;
 
         tmp |= edge << 27; /* TEDG */
-        tmp |= !edge << 26; /* REDG */
+        tmp |= edge << 26; /* REDG */
         tmp |= (tx_hi_z ? 2 : 0) << 22; /* TXDIZ */
         sh_msiof_write(p, CTR, tmp);
 }
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index 94eb86319ff3..fc2e963e65e9 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -99,8 +99,6 @@ source "drivers/staging/line6/Kconfig"
 
 source "drivers/gpu/drm/vmwgfx/Kconfig"
 
-source "drivers/gpu/drm/radeon/Kconfig"
-
 source "drivers/gpu/drm/nouveau/Kconfig"
 
 source "drivers/staging/octeon/Kconfig"
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index b7a661c02bcd..0ceec123ddfd 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -216,8 +216,17 @@ static void disable_controller(struct r8a66597 *r8a66597)
 {
         int port;
 
+        /* disable interrupts */
         r8a66597_write(r8a66597, 0, INTENB0);
-        r8a66597_write(r8a66597, 0, INTSTS0);
+        r8a66597_write(r8a66597, 0, INTENB1);
+        r8a66597_write(r8a66597, 0, BRDYENB);
+        r8a66597_write(r8a66597, 0, BEMPENB);
+        r8a66597_write(r8a66597, 0, NRDYENB);
+
+        /* clear status */
+        r8a66597_write(r8a66597, 0, BRDYSTS);
+        r8a66597_write(r8a66597, 0, NRDYSTS);
+        r8a66597_write(r8a66597, 0, BEMPSTS);
 
         for (port = 0; port < r8a66597->max_root_hub; port++)
                 r8a66597_disable_port(r8a66597, port);
@@ -2466,6 +2475,12 @@ static int __devinit r8a66597_probe(struct platform_device *pdev)
         r8a66597->rh_timer.data = (unsigned long)r8a66597;
         r8a66597->reg = (unsigned long)reg;
 
+        /* make sure no interrupts are pending */
+        ret = r8a66597_clock_enable(r8a66597);
+        if (ret < 0)
+                goto clean_up3;
+        disable_controller(r8a66597);
+
         for (i = 0; i < R8A66597_MAX_NUM_PIPE; i++) {
                 INIT_LIST_HEAD(&r8a66597->pipe_queue[i]);
                 init_timer(&r8a66597->td_timer[i]);
diff --git a/drivers/video/imxfb.c b/drivers/video/imxfb.c
index 66358fa825f3..b4b6deceed15 100644
--- a/drivers/video/imxfb.c
+++ b/drivers/video/imxfb.c
@@ -593,7 +593,8 @@ static int imxfb_activate_var(struct fb_var_screeninfo *var, struct fb_info *inf
  */
 static int imxfb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct imxfb_info *fbi = platform_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
+        struct imxfb_info *fbi = info->par;
 
         pr_debug("%s\n", __func__);
 
@@ -603,7 +604,8 @@ static int imxfb_suspend(struct platform_device *dev, pm_message_t state)
 
 static int imxfb_resume(struct platform_device *dev)
 {
-        struct imxfb_info *fbi = platform_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
+        struct imxfb_info *fbi = info->par;
 
         pr_debug("%s\n", __func__);
 
diff --git a/drivers/video/mx3fb.c b/drivers/video/mx3fb.c
index 054ef29be479..772ba3f45e6f 100644
--- a/drivers/video/mx3fb.c
+++ b/drivers/video/mx3fb.c
@@ -324,8 +324,11 @@ static void sdc_enable_channel(struct mx3fb_info *mx3_fbi)
         unsigned long flags;
         dma_cookie_t cookie;
 
-        dev_dbg(mx3fb->dev, "mx3fbi %p, desc %p, sg %p\n", mx3_fbi,
-                to_tx_desc(mx3_fbi->txd), to_tx_desc(mx3_fbi->txd)->sg);
+        if (mx3_fbi->txd)
+                dev_dbg(mx3fb->dev, "mx3fbi %p, desc %p, sg %p\n", mx3_fbi,
+                        to_tx_desc(mx3_fbi->txd), to_tx_desc(mx3_fbi->txd)->sg);
+        else
+                dev_dbg(mx3fb->dev, "mx3fbi %p, txd = NULL\n", mx3_fbi);
 
         /* This enables the channel */
         if (mx3_fbi->cookie < 0) {
@@ -646,6 +649,7 @@ static int sdc_set_global_alpha(struct mx3fb_data *mx3fb, bool enable, uint8_t a
 
 static void sdc_set_brightness(struct mx3fb_data *mx3fb, uint8_t value)
 {
+        dev_dbg(mx3fb->dev, "%s: value = %d\n", __func__, value);
         /* This might be board-specific */
         mx3fb_write_reg(mx3fb, 0x03000000UL | value << 16, SDC_PWM_CTRL);
         return;
@@ -1486,12 +1490,12 @@ static int mx3fb_probe(struct platform_device *pdev)
                 goto ersdc0;
         }
 
+        mx3fb->backlight_level = 255;
+
         ret = init_fb_chan(mx3fb, to_idmac_chan(chan));
         if (ret < 0)
                 goto eisdc0;
 
-        mx3fb->backlight_level = 255;
-
         return 0;
 
 eisdc0:
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 088f32f29a6e..050ee147592f 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -396,8 +396,8 @@ config SBC_FITPC2_WATCHDOG
         tristate "Compulab SBC-FITPC2 watchdog"
         depends on X86
         ---help---
-          This is the driver for the built-in watchdog timer on the fit-PC2
-          Single-board computer made by Compulab.
+          This is the driver for the built-in watchdog timer on the fit-PC2,
+          fit-PC2i, CM-iAM single-board computers made by Compulab.
 
           It`s possible to enable watchdog timer either from BIOS (F2) or from booted Linux.
           When "Watchdog Timer Value" enabled one can set 31-255 s operational range.
diff --git a/drivers/watchdog/ixp2000_wdt.c b/drivers/watchdog/ixp2000_wdt.c
index 4f4b35a20d84..3c79dc587958 100644
--- a/drivers/watchdog/ixp2000_wdt.c
+++ b/drivers/watchdog/ixp2000_wdt.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/types.h>
+#include <linux/timer.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
diff --git a/drivers/watchdog/sbc_fitpc2_wdt.c b/drivers/watchdog/sbc_fitpc2_wdt.c
index 91430a89107c..e6763d2a567b 100644
--- a/drivers/watchdog/sbc_fitpc2_wdt.c
+++ b/drivers/watchdog/sbc_fitpc2_wdt.c
@@ -46,9 +46,9 @@ static DEFINE_SPINLOCK(wdt_lock);
 static void wdt_send_data(unsigned char command, unsigned char data)
 {
         outb(command, COMMAND_PORT);
-        mdelay(100);
+        msleep(100);
         outb(data, DATA_PORT);
-        mdelay(200);
+        msleep(200);
 }
 
 static void wdt_enable(void)
@@ -202,11 +202,10 @@ static int __init fitpc2_wdt_init(void)
 {
         int err;
 
-        if (strcmp("SBC-FITPC2", dmi_get_system_info(DMI_BOARD_NAME))) {
-                pr_info("board name is: %s. Should be SBC-FITPC2\n",
-                        dmi_get_system_info(DMI_BOARD_NAME));
+        if (!strstr(dmi_get_system_info(DMI_BOARD_NAME), "SBC-FITPC2"))
                 return -ENODEV;
-        }
+
+        pr_info("%s found\n", dmi_get_system_info(DMI_BOARD_NAME));
 
         if (!request_region(COMMAND_PORT, 1, WATCHDOG_NAME)) {
                 pr_err("I/O address 0x%04x already in use\n", COMMAND_PORT);