379 files changed, 10683 insertions, 3528 deletions

diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 8a5bf3b356fa..55b5b90c2a44 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -395,7 +395,7 @@ struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
                 fn  = adr & 0xffff;
 
                 pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
-                if (hnd == handle)
+                if (!pdev || hnd == handle)
                         break;
 
                 pbus = pdev->subordinate;
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 768d973d0ded..f60b2b6a0931 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -208,6 +208,16 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
         void __iomem *tmp;
         int i, ret;
 
+        device_initialize(&dev->dev);
+
+        /*
+         * Copy from device_add
+         */
+        if (dev->dev.init_name) {
+                dev_set_name(&dev->dev, "%s", dev->dev.init_name);
+                dev->dev.init_name = NULL;
+        }
+
         dev->dev.release = amba_device_release;
         dev->dev.bus = &amba_bustype;
         dev->dev.dma_mask = &dev->dma_mask;
@@ -250,7 +260,7 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
                 goto err_release;
         }
 
-        ret = device_register(&dev->dev);
+        ret = device_add(&dev->dev);
         if (ret)
                 goto err_release;
 
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index ddeb819c8f87..fc466531260e 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -357,7 +357,7 @@ static void fw_dev_release(struct device *dev)
         kfree(fw_priv->pages);
         kfree(fw_priv->fw_id);
         kfree(fw_priv);
-        put_device(dev);
+        kfree(dev);
 
         module_put(THIS_MODULE);
 }
@@ -408,13 +408,11 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
         if (retval) {
                 dev_err(device, "%s: device_register failed\n", __func__);
                 put_device(f_dev);
-                goto error_kfree_fw_id;
+                return retval;
         }
         *dev_p = f_dev;
         return 0;
 
-error_kfree_fw_id:
-        kfree(fw_priv->fw_id);
 error_kfree:
         kfree(f_dev);
         kfree(fw_priv);
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index fae725458981..58a3e572f2c9 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -762,6 +762,7 @@ static int dpm_prepare(pm_message_t state)
                         dev->power.status = DPM_ON;
                         if (error == -EAGAIN) {
                                 put_device(dev);
+                                error = 0;
                                 continue;
                         }
                         printk(KERN_ERR "PM: Failed to prepare device %s "
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index bb72ada9f074..1d886e079c58 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -298,6 +298,22 @@ config BLK_DEV_NBD
 
           If unsure, say N.
 
+config BLK_DEV_OSD
+        tristate "OSD object-as-blkdev support"
+        depends on SCSI_OSD_ULD
+        ---help---
+          Saying Y or M here will allow the exporting of a single SCSI
+          OSD (object-based storage) object as a Linux block device.
+
+          For example, if you create a 2G object on an OSD device,
+          you can then use this module to present that 2G object as
+          a Linux block device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called osdblk.
+
+          If unsure, say N.
+
 config BLK_DEV_SX8
         tristate "Promise SATA SX8 support"
         depends on PCI
diff --git a/drivers/block/Makefile b/drivers/block/Makefile
index 7755a5e2a85e..cdaa3f8fddf0 100644
--- a/drivers/block/Makefile
+++ b/drivers/block/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_XILINX_SYSACE)	+= xsysace.o
 obj-$(CONFIG_CDROM_PKTCDVD)     += pktcdvd.o
 obj-$(CONFIG_MG_DISK)           += mg_disk.o
 obj-$(CONFIG_SUNVDC)            += sunvdc.o
+obj-$(CONFIG_BLK_DEV_OSD)       += osdblk.o
 
 obj-$(CONFIG_BLK_DEV_UMEM)      += umem.o
 obj-$(CONFIG_BLK_DEV_NBD)       += nbd.o
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 9c6e5b0fe894..2f07b7c99a95 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1645,7 +1645,7 @@ static int __init fd_probe_drives(void)
 {
         int drive,drives,nomem;
 
-        printk(KERN_INFO "FD: probing units\n" KERN_INFO "found ");
+        printk(KERN_INFO "FD: probing units\nfound ");
         drives=0;
         nomem=0;
         for(drive=0;drive<FD_MAX_UNITS;drive++) {
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index c7a527c08a09..65a0655e7fc8 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -226,8 +226,18 @@ static inline void addQ(struct hlist_head *list, CommandList_struct *c)
 
 static inline void removeQ(CommandList_struct *c)
 {
-        if (WARN_ON(hlist_unhashed(&c->list)))
+        /*
+         * After kexec/dump some commands might still
+         * be in flight, which the firmware will try
+         * to complete. Resetting the firmware doesn't work
+         * with old fw revisions, so we have to mark
+         * them off as 'stale' to prevent the driver from
+         * falling over.
+         */
+        if (WARN_ON(hlist_unhashed(&c->list))) {
+                c->cmd_type = CMD_MSG_STALE;
                 return;
+        }
 
         hlist_del_init(&c->list);
 }
@@ -4246,7 +4256,8 @@ static void fail_all_cmds(unsigned long ctlr)
         while (!hlist_empty(&h->cmpQ)) {
                 c = hlist_entry(h->cmpQ.first, CommandList_struct, list);
                 removeQ(c);
-                c->err_info->CommandStatus = CMD_HARDWARE_ERR;
+                if (c->cmd_type != CMD_MSG_STALE)
+                        c->err_info->CommandStatus = CMD_HARDWARE_ERR;
                 if (c->cmd_type == CMD_RWREQ) {
                         complete_command(h, c, 0);
                 } else if (c->cmd_type == CMD_IOCTL_PEND)
diff --git a/drivers/block/cciss_cmd.h b/drivers/block/cciss_cmd.h
index cd665b00c7c5..dbaed1ea0da3 100644
--- a/drivers/block/cciss_cmd.h
+++ b/drivers/block/cciss_cmd.h
@@ -274,6 +274,7 @@ typedef struct _ErrorInfo_struct {
 #define CMD_SCSI        0x03
 #define CMD_MSG_DONE    0x04
 #define CMD_MSG_TIMEOUT 0x05
+#define CMD_MSG_STALE   0xff
 
 /* This structure needs to be divisible by 8 for new
  * indexing method.
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 862b40c90181..91b753013780 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3327,7 +3327,10 @@ static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
                 mutex_lock(&open_lock);
-                LOCK_FDC(drive, 1);
+                if (lock_fdc(drive, 1)) {
+                        mutex_unlock(&open_lock);
+                        return -EINTR;
+                }
                 floppy_type[type] = *g;
                 floppy_type[type].name = "user format";
                 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
diff --git a/drivers/block/osdblk.c b/drivers/block/osdblk.c
new file mode 100644
index 000000000000..13c1aee6aa3f
--- /dev/null
+++ b/drivers/block/osdblk.c
@@ -0,0 +1,701 @@
+
+/*
+   osdblk.c -- Export a single SCSI OSD object as a Linux block device
+
+
+   Copyright 2009 Red Hat, 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.
+
+   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; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+   Instructions for use
+   --------------------
+
+   1) Map a Linux block device to an existing OSD object.
+
+      In this example, we will use partition id 1234, object id 5678,
+      OSD device /dev/osd1.
+
+      $ echo "1234 5678 /dev/osd1" > /sys/class/osdblk/add
+
+
+   2) List all active blkdev<->object mappings.
+
+      In this example, we have performed step #1 twice, creating two blkdevs,
+      mapped to two separate OSD objects.
+
+      $ cat /sys/class/osdblk/list
+      0 174 1234 5678 /dev/osd1
+      1 179 1994 897123 /dev/osd0
+
+      The columns, in order, are:
+      - blkdev unique id
+      - blkdev assigned major
+      - OSD object partition id
+      - OSD object id
+      - OSD device
+
+
+   3) Remove an active blkdev<->object mapping.
+
+      In this example, we remove the mapping with blkdev unique id 1.
+
+      $ echo 1 > /sys/class/osdblk/remove
+
+
+   NOTE:  The actual creation and deletion of OSD objects is outside the scope
+   of this driver.
+
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <scsi/osd_initiator.h>
+#include <scsi/osd_attributes.h>
+#include <scsi/osd_sec.h>
+#include <scsi/scsi_device.h>
+
+#define DRV_NAME "osdblk"
+#define PFX DRV_NAME ": "
+
+/* #define _OSDBLK_DEBUG */
+#ifdef _OSDBLK_DEBUG
+#define OSDBLK_DEBUG(fmt, a...) \
+        printk(KERN_NOTICE "osdblk @%s:%d: " fmt, __func__, __LINE__, ##a)
+#else
+#define OSDBLK_DEBUG(fmt, a...) \
+        do { if (0) printk(fmt, ##a); } while (0)
+#endif
+
+MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
+MODULE_DESCRIPTION("block device inside an OSD object osdblk.ko");
+MODULE_LICENSE("GPL");
+
+struct osdblk_device;
+
+enum {
+        OSDBLK_MINORS_PER_MAJOR = 256,          /* max minors per blkdev */
+        OSDBLK_MAX_REQ          = 32,           /* max parallel requests */
+        OSDBLK_OP_TIMEOUT       = 4 * 60,       /* sync OSD req timeout */
+};
+
+struct osdblk_request {
+        struct request          *rq;            /* blk layer request */
+        struct bio              *bio;           /* cloned bio */
+        struct osdblk_device    *osdev;         /* associated blkdev */
+};
+
+struct osdblk_device {
+        int                     id;             /* blkdev unique id */
+
+        int                     major;          /* blkdev assigned major */
+        struct gendisk          *disk;          /* blkdev's gendisk and rq */
+        struct request_queue    *q;
+
+        struct osd_dev          *osd;           /* associated OSD */
+
+        char                    name[32];       /* blkdev name, e.g. osdblk34 */
+
+        spinlock_t              lock;           /* queue lock */
+
+        struct osd_obj_id       obj;            /* OSD partition, obj id */
+        uint8_t                 obj_cred[OSD_CAP_LEN]; /* OSD cred */
+
+        struct osdblk_request   req[OSDBLK_MAX_REQ]; /* request table */
+
+        struct list_head        node;
+
+        char                    osd_path[0];    /* OSD device path */
+};
+
+static struct class *class_osdblk;              /* /sys/class/osdblk */
+static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */
+static LIST_HEAD(osdblkdev_list);
+
+static struct block_device_operations osdblk_bd_ops = {
+        .owner          = THIS_MODULE,
+};
+
+static const struct osd_attr g_attr_logical_length = ATTR_DEF(
+        OSD_APAGE_OBJECT_INFORMATION, OSD_ATTR_OI_LOGICAL_LENGTH, 8);
+
+static void osdblk_make_credential(u8 cred_a[OSD_CAP_LEN],
+                                   const struct osd_obj_id *obj)
+{
+        osd_sec_init_nosec_doall_caps(cred_a, obj, false, true);
+}
+
+/* copied from exofs; move to libosd? */
+/*
+ * Perform a synchronous OSD operation.  copied from exofs; move to libosd?
+ */
+static int osd_sync_op(struct osd_request *or, int timeout, uint8_t *credential)
+{
+        int ret;
+
+        or->timeout = timeout;
+        ret = osd_finalize_request(or, 0, credential, NULL);
+        if (ret)
+                return ret;
+
+        ret = osd_execute_request(or);
+
+        /* osd_req_decode_sense(or, ret); */
+        return ret;
+}
+
+/*
+ * Perform an asynchronous OSD operation.  copied from exofs; move to libosd?
+ */
+static int osd_async_op(struct osd_request *or, osd_req_done_fn *async_done,
+                   void *caller_context, u8 *cred)
+{
+        int ret;
+
+        ret = osd_finalize_request(or, 0, cred, NULL);
+        if (ret)
+                return ret;
+
+        ret = osd_execute_request_async(or, async_done, caller_context);
+
+        return ret;
+}
+
+/* copied from exofs; move to libosd? */
+static int extract_attr_from_req(struct osd_request *or, struct osd_attr *attr)
+{
+        struct osd_attr cur_attr = {.attr_page = 0}; /* start with zeros */
+        void *iter = NULL;
+        int nelem;
+
+        do {
+                nelem = 1;
+                osd_req_decode_get_attr_list(or, &cur_attr, &nelem, &iter);
+                if ((cur_attr.attr_page == attr->attr_page) &&
+                    (cur_attr.attr_id == attr->attr_id)) {
+                        attr->len = cur_attr.len;
+                        attr->val_ptr = cur_attr.val_ptr;
+                        return 0;
+                }
+        } while (iter);
+
+        return -EIO;
+}
+
+static int osdblk_get_obj_size(struct osdblk_device *osdev, u64 *size_out)
+{
+        struct osd_request *or;
+        struct osd_attr attr;
+        int ret;
+
+        /* start request */
+        or = osd_start_request(osdev->osd, GFP_KERNEL);
+        if (!or)
+                return -ENOMEM;
+
+        /* create a get-attributes(length) request */
+        osd_req_get_attributes(or, &osdev->obj);
+
+        osd_req_add_get_attr_list(or, &g_attr_logical_length, 1);
+
+        /* execute op synchronously */
+        ret = osd_sync_op(or, OSDBLK_OP_TIMEOUT, osdev->obj_cred);
+        if (ret)
+                goto out;
+
+        /* extract length from returned attribute info */
+        attr = g_attr_logical_length;
+        ret = extract_attr_from_req(or, &attr);
+        if (ret)
+                goto out;
+
+        *size_out = get_unaligned_be64(attr.val_ptr);
+
+out:
+        osd_end_request(or);
+        return ret;
+
+}
+
+static void osdblk_osd_complete(struct osd_request *or, void *private)
+{
+        struct osdblk_request *orq = private;
+        struct osd_sense_info osi;
+        int ret = osd_req_decode_sense(or, &osi);
+
+        if (ret) {
+                ret = -EIO;
+                OSDBLK_DEBUG("osdblk_osd_complete with err=%d\n", ret);
+        }
+
+        /* complete OSD request */
+        osd_end_request(or);
+
+        /* complete request passed to osdblk by block layer */
+        __blk_end_request_all(orq->rq, ret);
+}
+
+static void bio_chain_put(struct bio *chain)
+{
+        struct bio *tmp;
+
+        while (chain) {
+                tmp = chain;
+                chain = chain->bi_next;
+
+                bio_put(tmp);
+        }
+}
+
+static struct bio *bio_chain_clone(struct bio *old_chain, gfp_t gfpmask)
+{
+        struct bio *tmp, *new_chain = NULL, *tail = NULL;
+
+        while (old_chain) {
+                tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs);
+                if (!tmp)
+                        goto err_out;
+
+                __bio_clone(tmp, old_chain);
+                tmp->bi_bdev = NULL;
+                gfpmask &= ~__GFP_WAIT;
+                tmp->bi_next = NULL;
+
+                if (!new_chain)
+                        new_chain = tail = tmp;
+                else {
+                        tail->bi_next = tmp;
+                        tail = tmp;
+                }
+
+                old_chain = old_chain->bi_next;
+        }
+
+        return new_chain;
+
+err_out:
+        OSDBLK_DEBUG("bio_chain_clone with err\n");
+        bio_chain_put(new_chain);
+        return NULL;
+}
+
+static void osdblk_rq_fn(struct request_queue *q)
+{
+        struct osdblk_device *osdev = q->queuedata;
+
+        while (1) {
+                struct request *rq;
+                struct osdblk_request *orq;
+                struct osd_request *or;
+                struct bio *bio;
+                bool do_write, do_flush;
+
+                /* peek at request from block layer */
+                rq = blk_fetch_request(q);
+                if (!rq)
+                        break;
+
+                /* filter out block requests we don't understand */
+                if (!blk_fs_request(rq) && !blk_barrier_rq(rq)) {
+                        blk_end_request_all(rq, 0);
+                        continue;
+                }
+
+                /* deduce our operation (read, write, flush) */
+                /* I wish the block layer simplified cmd_type/cmd_flags/cmd[]
+                 * into a clearly defined set of RPC commands:
+                 * read, write, flush, scsi command, power mgmt req,
+                 * driver-specific, etc.
+                 */
+
+                do_flush = (rq->special == (void *) 0xdeadbeefUL);
+                do_write = (rq_data_dir(rq) == WRITE);
+
+                if (!do_flush) { /* osd_flush does not use a bio */
+                        /* a bio clone to be passed down to OSD request */
+                        bio = bio_chain_clone(rq->bio, GFP_ATOMIC);
+                        if (!bio)
+                                break;
+                } else
+                        bio = NULL;
+
+                /* alloc internal OSD request, for OSD command execution */
+                or = osd_start_request(osdev->osd, GFP_ATOMIC);
+                if (!or) {
+                        bio_chain_put(bio);
+                        OSDBLK_DEBUG("osd_start_request with err\n");
+                        break;
+                }
+
+                orq = &osdev->req[rq->tag];
+                orq->rq = rq;
+                orq->bio = bio;
+                orq->osdev = osdev;
+
+                /* init OSD command: flush, write or read */
+                if (do_flush)
+                        osd_req_flush_object(or, &osdev->obj,
+                                             OSD_CDB_FLUSH_ALL, 0, 0);
+                else if (do_write)
+                        osd_req_write(or, &osdev->obj, blk_rq_pos(rq) * 512ULL,
+                                      bio, blk_rq_bytes(rq));
+                else
+                        osd_req_read(or, &osdev->obj, blk_rq_pos(rq) * 512ULL,
+                                     bio, blk_rq_bytes(rq));
+
+                OSDBLK_DEBUG("%s 0x%x bytes at 0x%llx\n",
+                        do_flush ? "flush" : do_write ?
+                                "write" : "read", blk_rq_bytes(rq),
+                        blk_rq_pos(rq) * 512ULL);
+
+                /* begin OSD command execution */
+                if (osd_async_op(or, osdblk_osd_complete, orq,
+                                 osdev->obj_cred)) {
+                        osd_end_request(or);
+                        blk_requeue_request(q, rq);
+                        bio_chain_put(bio);
+                        OSDBLK_DEBUG("osd_execute_request_async with err\n");
+                        break;
+                }
+
+                /* remove the special 'flush' marker, now that the command
+                 * is executing
+                 */
+                rq->special = NULL;
+        }
+}
+
+static void osdblk_prepare_flush(struct request_queue *q, struct request *rq)
+{
+        /* add driver-specific marker, to indicate that this request
+         * is a flush command
+         */
+        rq->special = (void *) 0xdeadbeefUL;
+}
+
+static void osdblk_free_disk(struct osdblk_device *osdev)
+{
+        struct gendisk *disk = osdev->disk;
+
+        if (!disk)
+                return;
+
+        if (disk->flags & GENHD_FL_UP)
+                del_gendisk(disk);
+        if (disk->queue)
+                blk_cleanup_queue(disk->queue);
+        put_disk(disk);
+}
+
+static int osdblk_init_disk(struct osdblk_device *osdev)
+{
+        struct gendisk *disk;
+        struct request_queue *q;
+        int rc;
+        u64 obj_size = 0;
+
+        /* contact OSD, request size info about the object being mapped */
+        rc = osdblk_get_obj_size(osdev, &obj_size);
+        if (rc)
+                return rc;
+
+        /* create gendisk info */
+        disk = alloc_disk(OSDBLK_MINORS_PER_MAJOR);
+        if (!disk)
+                return -ENOMEM;
+
+        sprintf(disk->disk_name, DRV_NAME "%d", osdev->id);
+        disk->major = osdev->major;
+        disk->first_minor = 0;
+        disk->fops = &osdblk_bd_ops;
+        disk->private_data = osdev;
+
+        /* init rq */
+        q = blk_init_queue(osdblk_rq_fn, &osdev->lock);
+        if (!q) {
+                put_disk(disk);
+                return -ENOMEM;
+        }
+
+        /* switch queue to TCQ mode; allocate tag map */
+        rc = blk_queue_init_tags(q, OSDBLK_MAX_REQ, NULL);
+        if (rc) {
+                blk_cleanup_queue(q);
+                put_disk(disk);
+                return rc;
+        }
+
+        /* Set our limits to the lower device limits, because osdblk cannot
+         * sleep when allocating a lower-request and therefore cannot be
+         * bouncing.
+         */
+        blk_queue_stack_limits(q, osd_request_queue(osdev->osd));
+
+        blk_queue_prep_rq(q, blk_queue_start_tag);
+        blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH, osdblk_prepare_flush);
+
+        disk->queue = q;
+
+        q->queuedata = osdev;
+
+        osdev->disk = disk;
+        osdev->q = q;
+
+        /* finally, announce the disk to the world */
+        set_capacity(disk, obj_size / 512ULL);
+        add_disk(disk);
+
+        printk(KERN_INFO "%s: Added of size 0x%llx\n",
+                disk->disk_name, (unsigned long long)obj_size);
+
+        return 0;
+}
+
+/********************************************************************
+ * /sys/class/osdblk/
+ *                   add        map OSD object to blkdev
+ *                   remove     unmap OSD object
+ *                   list       show mappings
+ *******************************************************************/
+
+static void class_osdblk_release(struct class *cls)
+{
+        kfree(cls);
+}
+
+static ssize_t class_osdblk_list(struct class *c, char *data)
+{
+        int n = 0;
+        struct list_head *tmp;
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        list_for_each(tmp, &osdblkdev_list) {
+                struct osdblk_device *osdev;
+
+                osdev = list_entry(tmp, struct osdblk_device, node);
+
+                n += sprintf(data+n, "%d %d %llu %llu %s\n",
+                        osdev->id,
+                        osdev->major,
+                        osdev->obj.partition,
+                        osdev->obj.id,
+                        osdev->osd_path);
+        }
+
+        mutex_unlock(&ctl_mutex);
+        return n;
+}
+
+static ssize_t class_osdblk_add(struct class *c, const char *buf, size_t count)
+{
+        struct osdblk_device *osdev;
+        ssize_t rc;
+        int irc, new_id = 0;
+        struct list_head *tmp;
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        /* new osdblk_device object */
+        osdev = kzalloc(sizeof(*osdev) + strlen(buf) + 1, GFP_KERNEL);
+        if (!osdev) {
+                rc = -ENOMEM;
+                goto err_out_mod;
+        }
+
+        /* static osdblk_device initialization */
+        spin_lock_init(&osdev->lock);
+        INIT_LIST_HEAD(&osdev->node);
+
+        /* generate unique id: find highest unique id, add one */
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        list_for_each(tmp, &osdblkdev_list) {
+                struct osdblk_device *osdev;
+
+                osdev = list_entry(tmp, struct osdblk_device, node);
+                if (osdev->id > new_id)
+                        new_id = osdev->id + 1;
+        }
+
+        osdev->id = new_id;
+
+        /* add to global list */
+        list_add_tail(&osdev->node, &osdblkdev_list);
+
+        mutex_unlock(&ctl_mutex);
+
+        /* parse add command */
+        if (sscanf(buf, "%llu %llu %s", &osdev->obj.partition, &osdev->obj.id,
+                   osdev->osd_path) != 3) {
+                rc = -EINVAL;
+                goto err_out_slot;
+        }
+
+        /* initialize rest of new object */
+        sprintf(osdev->name, DRV_NAME "%d", osdev->id);
+
+        /* contact requested OSD */
+        osdev->osd = osduld_path_lookup(osdev->osd_path);
+        if (IS_ERR(osdev->osd)) {
+                rc = PTR_ERR(osdev->osd);
+                goto err_out_slot;
+        }
+
+        /* build OSD credential */
+        osdblk_make_credential(osdev->obj_cred, &osdev->obj);
+
+        /* register our block device */
+        irc = register_blkdev(0, osdev->name);
+        if (irc < 0) {
+                rc = irc;
+                goto err_out_osd;
+        }
+
+        osdev->major = irc;
+
+        /* set up and announce blkdev mapping */
+        rc = osdblk_init_disk(osdev);
+        if (rc)
+                goto err_out_blkdev;
+
+        return count;
+
+err_out_blkdev:
+        unregister_blkdev(osdev->major, osdev->name);
+err_out_osd:
+        osduld_put_device(osdev->osd);
+err_out_slot:
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+        list_del_init(&osdev->node);
+        mutex_unlock(&ctl_mutex);
+
+        kfree(osdev);
+err_out_mod:
+        OSDBLK_DEBUG("Error adding device %s\n", buf);
+        module_put(THIS_MODULE);
+        return rc;
+}
+
+static ssize_t class_osdblk_remove(struct class *c, const char *buf,
+                                        size_t count)
+{
+        struct osdblk_device *osdev = NULL;
+        int target_id, rc;
+        unsigned long ul;
+        struct list_head *tmp;
+
+        rc = strict_strtoul(buf, 10, &ul);
+        if (rc)
+                return rc;
+
+        /* convert to int; abort if we lost anything in the conversion */
+        target_id = (int) ul;
+        if (target_id != ul)
+                return -EINVAL;
+
+        /* remove object from list immediately */
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        list_for_each(tmp, &osdblkdev_list) {
+                osdev = list_entry(tmp, struct osdblk_device, node);
+                if (osdev->id == target_id) {
+                        list_del_init(&osdev->node);
+                        break;
+                }
+                osdev = NULL;
+        }
+
+        mutex_unlock(&ctl_mutex);
+
+        if (!osdev)
+                return -ENOENT;
+
+        /* clean up and free blkdev and associated OSD connection */
+        osdblk_free_disk(osdev);
+        unregister_blkdev(osdev->major, osdev->name);
+        osduld_put_device(osdev->osd);
+        kfree(osdev);
+
+        /* release module ref */
+        module_put(THIS_MODULE);
+
+        return count;
+}
+
+static struct class_attribute class_osdblk_attrs[] = {
+        __ATTR(add,     0200, NULL, class_osdblk_add),
+        __ATTR(remove,  0200, NULL, class_osdblk_remove),
+        __ATTR(list,    0444, class_osdblk_list, NULL),
+        __ATTR_NULL
+};
+
+static int osdblk_sysfs_init(void)
+{
+        int ret = 0;
+
+        /*
+         * create control files in sysfs
+         * /sys/class/osdblk/...
+         */
+        class_osdblk = kzalloc(sizeof(*class_osdblk), GFP_KERNEL);
+        if (!class_osdblk)
+                return -ENOMEM;
+
+        class_osdblk->name = DRV_NAME;
+        class_osdblk->owner = THIS_MODULE;
+        class_osdblk->class_release = class_osdblk_release;
+        class_osdblk->class_attrs = class_osdblk_attrs;
+
+        ret = class_register(class_osdblk);
+        if (ret) {
+                kfree(class_osdblk);
+                class_osdblk = NULL;
+                printk(PFX "failed to create class osdblk\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static void osdblk_sysfs_cleanup(void)
+{
+        if (class_osdblk)
+                class_destroy(class_osdblk);
+        class_osdblk = NULL;
+}
+
+static int __init osdblk_init(void)
+{
+        int rc;
+
+        rc = osdblk_sysfs_init();
+        if (rc)
+                return rc;
+
+        return 0;
+}
+
+static void __exit osdblk_exit(void)
+{
+        osdblk_sysfs_cleanup();
+}
+
+module_init(osdblk_init);
+module_exit(osdblk_exit);
+
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 83650e00632d..99a506f619b7 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -1372,8 +1372,10 @@ try_next_bio:
         wakeup = (pd->write_congestion_on > 0
                         && pd->bio_queue_size <= pd->write_congestion_off);
         spin_unlock(&pd->lock);
-        if (wakeup)
-                clear_bdi_congested(&pd->disk->queue->backing_dev_info, WRITE);
+        if (wakeup) {
+                clear_bdi_congested(&pd->disk->queue->backing_dev_info,
+                                        BLK_RW_ASYNC);
+        }
 
         pkt->sleep_time = max(PACKET_WAIT_TIME, 1);
         pkt_set_state(pkt, PACKET_WAITING_STATE);
@@ -2592,10 +2594,10 @@ static int pkt_make_request(struct request_queue *q, struct bio *bio)
         spin_lock(&pd->lock);
         if (pd->write_congestion_on > 0
             && pd->bio_queue_size >= pd->write_congestion_on) {
-                set_bdi_congested(&q->backing_dev_info, WRITE);
+                set_bdi_congested(&q->backing_dev_info, BLK_RW_ASYNC);
                 do {
                         spin_unlock(&pd->lock);
-                        congestion_wait(WRITE, HZ);
+                        congestion_wait(BLK_RW_ASYNC, HZ);
                         spin_lock(&pd->lock);
                 } while(pd->bio_queue_size > pd->write_congestion_off);
         }
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index f08491a3a813..b20abe102a2b 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -390,9 +390,10 @@ static inline void ace_dump_mem(void *base, int len)
 
 static void ace_dump_regs(struct ace_device *ace)
 {
-        dev_info(ace->dev, "    ctrl:  %.8x  seccnt/cmd: %.4x      ver:%.4x\n"
-                 KERN_INFO "    status:%.8x  mpu_lba:%.8x  busmode:%4x\n"
-                 KERN_INFO "    error: %.8x  cfg_lba:%.8x  fatstat:%.4x\n",
+        dev_info(ace->dev,
+                 "    ctrl:  %.8x  seccnt/cmd: %.4x      ver:%.4x\n"
+                 "    status:%.8x  mpu_lba:%.8x  busmode:%4x\n"
+                 "    error: %.8x  cfg_lba:%.8x  fatstat:%.4x\n",
                  ace_in32(ace, ACE_CTRL),
                  ace_in(ace, ACE_SECCNTCMD),
                  ace_in(ace, ACE_VERSION),
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 0bd01f49cfd8..6a06913b01d3 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -1029,10 +1029,6 @@ config CS5535_GPIO
 
           If compiled as a module, it will be called cs5535_gpio.
 
-config GPIO_VR41XX
-        tristate "NEC VR4100 series General-purpose I/O Unit support"
-        depends on CPU_VR41XX
-
 config RAW_DRIVER
         tristate "RAW driver (/dev/raw/rawN)"
         depends on BLOCK
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 189efcff08ce..66f779ad4f4c 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -95,7 +95,6 @@ obj-$(CONFIG_SCx200_GPIO)	+= scx200_gpio.o
 obj-$(CONFIG_PC8736x_GPIO)      += pc8736x_gpio.o
 obj-$(CONFIG_NSC_GPIO)          += nsc_gpio.o
 obj-$(CONFIG_CS5535_GPIO)       += cs5535_gpio.o
-obj-$(CONFIG_GPIO_VR41XX)       += vr41xx_giu.o
 obj-$(CONFIG_GPIO_TB0219)       += tb0219.o
 obj-$(CONFIG_TELCLOCK)          += tlclk.o
 
diff --git a/drivers/char/bsr.c b/drivers/char/bsr.c
index 140ea10ecb88..c02db01f736e 100644
--- a/drivers/char/bsr.c
+++ b/drivers/char/bsr.c
@@ -27,6 +27,7 @@
 #include <linux/cdev.h>
 #include <linux/list.h>
 #include <linux/mm.h>
+#include <asm/pgtable.h>
 #include <asm/io.h>
 
 /*
@@ -75,12 +76,13 @@ static struct class *bsr_class;
 static int bsr_major;
 
 enum {
-        BSR_8   = 0,
-        BSR_16  = 1,
-        BSR_64  = 2,
-        BSR_128 = 3,
-        BSR_UNKNOWN = 4,
-        BSR_MAX = 5,
+        BSR_8    = 0,
+        BSR_16   = 1,
+        BSR_64   = 2,
+        BSR_128  = 3,
+        BSR_4096 = 4,
+        BSR_UNKNOWN = 5,
+        BSR_MAX  = 6,
 };
 
 static unsigned bsr_types[BSR_MAX];
@@ -117,15 +119,22 @@ static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
 {
         unsigned long size   = vma->vm_end - vma->vm_start;
         struct bsr_dev *dev = filp->private_data;
+        int ret;
 
-        if (size > dev->bsr_len || (size & (PAGE_SIZE-1)))
-                return -EINVAL;
-
-        vma->vm_flags |= (VM_IO | VM_DONTEXPAND);
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
-        if (io_remap_pfn_range(vma, vma->vm_start, dev->bsr_addr >> PAGE_SHIFT,
-                               size, vma->vm_page_prot))
+        /* check for the case of a small BSR device and map one 4k page for it*/
+        if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
+                ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
+                                   vma->vm_page_prot);
+        else if (size <= dev->bsr_len)
+                ret = io_remap_pfn_range(vma, vma->vm_start,
+                                         dev->bsr_addr >> PAGE_SHIFT,
+                                         size, vma->vm_page_prot);
+        else
+                return -EINVAL;
+
+        if (ret)
                 return -EAGAIN;
 
         return 0;
@@ -205,6 +214,11 @@ static int bsr_add_node(struct device_node *bn)
                 cur->bsr_stride = bsr_stride[i];
                 cur->bsr_dev    = MKDEV(bsr_major, i + total_bsr_devs);
 
+                /* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
+                /* we can only map 4k of it, so only advertise the 4k in sysfs */
+                if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
+                        cur->bsr_len = 4096;
+
                 switch(cur->bsr_bytes) {
                 case 8:
                         cur->bsr_type = BSR_8;
@@ -218,9 +232,11 @@ static int bsr_add_node(struct device_node *bn)
                 case 128:
                         cur->bsr_type = BSR_128;
                         break;
+                case 4096:
+                        cur->bsr_type = BSR_4096;
+                        break;
                 default:
                         cur->bsr_type = BSR_UNKNOWN;
-                        printk(KERN_INFO "unknown BSR size %d\n",cur->bsr_bytes);
                 }
 
                 cur->bsr_num = bsr_types[cur->bsr_type];
diff --git a/drivers/char/hw_random/intel-rng.c b/drivers/char/hw_random/intel-rng.c
index 5dcbe603eca2..91b53eb1c053 100644
--- a/drivers/char/hw_random/intel-rng.c
+++ b/drivers/char/hw_random/intel-rng.c
@@ -305,10 +305,11 @@ static int __init intel_init_hw_struct(struct intel_rng_hw *intel_rng_hw,
              (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK))
             == BIOS_CNTL_LOCK_ENABLE_MASK) {
                 static __initdata /*const*/ char warning[] =
-                        KERN_WARNING PFX "Firmware space is locked read-only. If you can't or\n"
-                        KERN_WARNING PFX "don't want to disable this in firmware setup, and if\n"
-                        KERN_WARNING PFX "you are certain that your system has a functional\n"
-                        KERN_WARNING PFX "RNG, try using the 'no_fwh_detect' option.\n";
+                        KERN_WARNING
+PFX "Firmware space is locked read-only. If you can't or\n"
+PFX "don't want to disable this in firmware setup, and if\n"
+PFX "you are certain that your system has a functional\n"
+PFX "RNG, try using the 'no_fwh_detect' option.\n";
 
                 if (no_fwh_detect)
                         return -ENODEV;
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 4159292e35cf..621d1184673c 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -1478,10 +1478,10 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                 status = inw(base + 0x4);
                 if (status != 0) {
                         dev_warn(&pdev->dev, "Card%d rejected load header:\n"
-                                KERN_WARNING "Address:0x%x\n"
-                                KERN_WARNING "Count:0x%x\n"
-                                KERN_WARNING "Status:0x%x\n",
-                                index + 1, frame->addr, frame->count, status);
+                                 "Address:0x%x\n"
+                                 "Count:0x%x\n"
+                                 "Status:0x%x\n",
+                                 index + 1, frame->addr, frame->count, status);
                         goto errrelfw;
                 }
                 outsw(base, frame->data, word_count);
@@ -1526,10 +1526,10 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                 status = inw(base + 0x4);
                 if (status != 0) {
                         dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
-                                KERN_WARNING "Address:0x%x\n"
-                                KERN_WARNING "Count:0x%x\n"
-                                KERN_WARNING "Status: 0x%x\n",
-                                index + 1, frame->addr, frame->count, status);
+                                 "Address:0x%x\n"
+                                 "Count:0x%x\n"
+                                 "Status: 0x%x\n",
+                                 index + 1, frame->addr, frame->count, status);
                         goto errrelfw;
                 }
 
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index daebe1ba43d4..9d1b4f548f67 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -75,114 +75,88 @@ static void pty_close(struct tty_struct *tty, struct file *filp)
  */
 static void pty_unthrottle(struct tty_struct *tty)
 {
-        struct tty_struct *o_tty = tty->link;
-
-        if (!o_tty)
-                return;
-
-        tty_wakeup(o_tty);
+        tty_wakeup(tty->link);
         set_bit(TTY_THROTTLED, &tty->flags);
 }
 
-/*
- * WSH 05/24/97: modified to
- *   (1) use space in tty->flip instead of a shared temp buffer
- *       The flip buffers aren't being used for a pty, so there's lots
- *       of space available.  The buffer is protected by a per-pty
- *       semaphore that should almost never come under contention.
- *   (2) avoid redundant copying for cases where count >> receive_room
- * N.B. Calls from user space may now return an error code instead of
- * a count.
+/**
+ *      pty_space       -       report space left for writing
+ *      @to: tty we are writing into
  *
- * FIXME: Our pty_write method is called with our ldisc lock held but
- * not our partners. We can't just wait on the other one blindly without
- * risking deadlocks. At some point when everything has settled down we need
- * to look into making pty_write at least able to sleep over an ldisc change.
+ *      The tty buffers allow 64K but we sneak a peak and clip at 8K this
+ *      allows a lot of overspill room for echo and other fun messes to
+ *      be handled properly
+ */
+
+static int pty_space(struct tty_struct *to)
+{
+        int n = 8192 - to->buf.memory_used;
+        if (n < 0)
+                return 0;
+        return n;
+}
+
+/**
+ *      pty_write               -       write to a pty
+ *      @tty: the tty we write from
+ *      @buf: kernel buffer of data
+ *      @count: bytes to write
  *
- * The return on no ldisc is a bit counter intuitive but the logic works
- * like this. During an ldisc change the other end will flush its buffers. We
- * thus return the full length which is identical to the case where we had
- * proper locking and happened to queue the bytes just before the flush during
- * the ldisc change.
+ *      Our "hardware" write method. Data is coming from the ldisc which
+ *      may be in a non sleeping state. We simply throw this at the other
+ *      end of the link as if we were an IRQ handler receiving stuff for
+ *      the other side of the pty/tty pair.
  */
+
 static int pty_write(struct tty_struct *tty, const unsigned char *buf,
                                                                 int count)
 {
         struct tty_struct *to = tty->link;
-        struct tty_ldisc *ld;
-        int c = count;
+        int c;
 
-        if (!to || tty->stopped)
+        if (tty->stopped)
                 return 0;
-        ld = tty_ldisc_ref(to);
-
-        if (ld) {
-                c = to->receive_room;
-                if (c > count)
-                        c = count;
-                ld->ops->receive_buf(to, buf, NULL, c);
-                tty_ldisc_deref(ld);
+
+        /* This isn't locked but our 8K is quite sloppy so no
+           big deal */
+
+        c = pty_space(to);
+        if (c > count)
+                c = count;
+        if (c > 0) {
+                /* Stuff the data into the input queue of the other end */
+                c = tty_insert_flip_string(to, buf, c);
+                /* And shovel */
+                tty_flip_buffer_push(to);
+                tty_wakeup(tty);
         }
         return c;
 }
 
+/**
+ *      pty_write_room  -       write space
+ *      @tty: tty we are writing from
+ *
+ *      Report how many bytes the ldisc can send into the queue for
+ *      the other device.
+ */
+
 static int pty_write_room(struct tty_struct *tty)
 {
-        struct tty_struct *to = tty->link;
-
-        if (!to || tty->stopped)
-                return 0;
-
-        return to->receive_room;
+        return pty_space(tty->link);
 }
 
-/*
- *      WSH 05/24/97:  Modified for asymmetric MASTER/SLAVE behavior
- *      The chars_in_buffer() value is used by the ldisc select() function
- *      to hold off writing when chars_in_buffer > WAKEUP_CHARS (== 256).
- *      The pty driver chars_in_buffer() Master/Slave must behave differently:
- *
- *      The Master side needs to allow typed-ahead commands to accumulate
- *      while being canonicalized, so we report "our buffer" as empty until
- *      some threshold is reached, and then report the count. (Any count >
- *      WAKEUP_CHARS is regarded by select() as "full".)  To avoid deadlock
- *      the count returned must be 0 if no canonical data is available to be
- *      read. (The N_TTY ldisc.chars_in_buffer now knows this.)
+/**
+ *      pty_chars_in_buffer     -       characters currently in our tx queue
+ *      @tty: our tty
  *
- *      The Slave side passes all characters in raw mode to the Master side's
- *      buffer where they can be read immediately, so in this case we can
- *      return the true count in the buffer.
+ *      Report how much we have in the transmit queue. As everything is
+ *      instantly at the other end this is easy to implement.
  */
+
 static int pty_chars_in_buffer(struct tty_struct *tty)
 {
-        struct tty_struct *to = tty->link;
-        struct tty_ldisc *ld;
-        int count = 0;
-
-        /* We should get the line discipline lock for "tty->link" */
-        if (!to)
-                return 0;
-        /* We cannot take a sleeping reference here without deadlocking with
-           an ldisc change - but it doesn't really matter */
-        ld = tty_ldisc_ref(to);
-        if (ld == NULL)
-                return 0;
-
-        /* The ldisc must report 0 if no characters available to be read */
-        if (ld->ops->chars_in_buffer)
-                count = ld->ops->chars_in_buffer(to);
-
-        tty_ldisc_deref(ld);
-
-        if (tty->driver->subtype == PTY_TYPE_SLAVE)
-                return count;
-
-        /* Master side driver ... if the other side's read buffer is less than
-         * half full, return 0 to allow writers to proceed; otherwise return
-         * the count.  This leaves a comfortable margin to avoid overflow,
-         * and still allows half a buffer's worth of typed-ahead commands.
-         */
-        return (count < N_TTY_BUF_SIZE/2) ? 0 : count;
+        return 0;
 }
 
 /* Set the lock flag on a pty */
@@ -202,20 +176,10 @@ static void pty_flush_buffer(struct tty_struct *tty)
 {
         struct tty_struct *to = tty->link;
         unsigned long flags;
-        struct tty_ldisc *ld;
 
         if (!to)
                 return;
-        ld = tty_ldisc_ref(to);
-
-        /* The other end is changing discipline */
-        if (!ld)
-                return;
-
-        if (ld->ops->flush_buffer)
-                to->ldisc->ops->flush_buffer(to);
-        tty_ldisc_deref(ld);
-
+        /* tty_buffer_flush(to); FIXME */
         if (to->packet) {
                 spin_lock_irqsave(&tty->ctrl_lock, flags);
                 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
diff --git a/drivers/char/tb0219.c b/drivers/char/tb0219.c
index 6062b62800fd..b3ec9b10e292 100644
--- a/drivers/char/tb0219.c
+++ b/drivers/char/tb0219.c
@@ -1,7 +1,7 @@
 /*
  *  Driver for TANBAC TB0219 base board.
  *
- *  Copyright (C) 2005  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2005  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
@@ -28,7 +28,7 @@
 #include <asm/vr41xx/giu.h>
 #include <asm/vr41xx/tb0219.h>
 
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
 MODULE_DESCRIPTION("TANBAC TB0219 base board driver");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
index a19e935847b0..913aa8d3f1c5 100644
--- a/drivers/char/tty_ldisc.c
+++ b/drivers/char/tty_ldisc.c
@@ -867,15 +867,22 @@ void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
         tty_ldisc_wait_idle(tty);
 
         /*
-         * Shutdown the current line discipline, and reset it to N_TTY.
-         *
-         * FIXME: this MUST get fixed for the new reflocking
+         * Now kill off the ldisc
          */
+        tty_ldisc_close(tty, tty->ldisc);
+        tty_ldisc_put(tty->ldisc);
+        /* Force an oops if we mess this up */
+        tty->ldisc = NULL;
+
+        /* Ensure the next open requests the N_TTY ldisc */
+        tty_set_termios_ldisc(tty, N_TTY);
 
-        tty_ldisc_reinit(tty);
         /* This will need doing differently if we need to lock */
         if (o_tty)
                 tty_ldisc_release(o_tty, NULL);
+
+        /* And the memory resources remaining (buffers, termios) will be
+           disposed of when the kref hits zero */
 }
 
 /**
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index 54c837288d19..e69de29bb2d1 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -1,680 +0,0 @@
-/*
- *  Driver for NEC VR4100 series General-purpose I/O Unit.
- *
- *  Copyright (C) 2002 MontaVista Software Inc.
- *      Author: Yoichi Yuasa <yyuasa@mvista.com or source@mvista.com>
- *  Copyright (C) 2003-2007  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
- *
- *  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/errno.h>
-#include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/smp_lock.h>
-#include <linux/spinlock.h>
-#include <linux/types.h>
-
-#include <asm/io.h>
-#include <asm/vr41xx/giu.h>
-#include <asm/vr41xx/irq.h>
-#include <asm/vr41xx/vr41xx.h>
-
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
-MODULE_DESCRIPTION("NEC VR4100 series General-purpose I/O Unit driver");
-MODULE_LICENSE("GPL");
-
-static int major;       /* default is dynamic major device number */
-module_param(major, int, 0);
-MODULE_PARM_DESC(major, "Major device number");
-
-#define GIUIOSELL       0x00
-#define GIUIOSELH       0x02
-#define GIUPIODL        0x04
-#define GIUPIODH        0x06
-#define GIUINTSTATL     0x08
-#define GIUINTSTATH     0x0a
-#define GIUINTENL       0x0c
-#define GIUINTENH       0x0e
-#define GIUINTTYPL      0x10
-#define GIUINTTYPH      0x12
-#define GIUINTALSELL    0x14
-#define GIUINTALSELH    0x16
-#define GIUINTHTSELL    0x18
-#define GIUINTHTSELH    0x1a
-#define GIUPODATL       0x1c
-#define GIUPODATEN      0x1c
-#define GIUPODATH       0x1e
- #define PIOEN0         0x0100
- #define PIOEN1         0x0200
-#define GIUPODAT        0x1e
-#define GIUFEDGEINHL    0x20
-#define GIUFEDGEINHH    0x22
-#define GIUREDGEINHL    0x24
-#define GIUREDGEINHH    0x26
-
-#define GIUUSEUPDN      0x1e0
-#define GIUTERMUPDN     0x1e2
-
-#define GPIO_HAS_PULLUPDOWN_IO          0x0001
-#define GPIO_HAS_OUTPUT_ENABLE          0x0002
-#define GPIO_HAS_INTERRUPT_EDGE_SELECT  0x0100
-
-static spinlock_t giu_lock;
-static unsigned long giu_flags;
-static unsigned int giu_nr_pins;
-
-static void __iomem *giu_base;
-
-#define giu_read(offset)                readw(giu_base + (offset))
-#define giu_write(offset, value)        writew((value), giu_base + (offset))
-
-#define GPIO_PIN_OF_IRQ(irq)    ((irq) - GIU_IRQ_BASE)
-#define GIUINT_HIGH_OFFSET      16
-#define GIUINT_HIGH_MAX         32
-
-static inline uint16_t giu_set(uint16_t offset, uint16_t set)
-{
-        uint16_t data;
-
-        data = giu_read(offset);
-        data |= set;
-        giu_write(offset, data);
-
-        return data;
-}
-
-static inline uint16_t giu_clear(uint16_t offset, uint16_t clear)
-{
-        uint16_t data;
-
-        data = giu_read(offset);
-        data &= ~clear;
-        giu_write(offset, data);
-
-        return data;
-}
-
-static void ack_giuint_low(unsigned int irq)
-{
-        giu_write(GIUINTSTATL, 1 << GPIO_PIN_OF_IRQ(irq));
-}
-
-static void mask_giuint_low(unsigned int irq)
-{
-        giu_clear(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
-}
-
-static void mask_ack_giuint_low(unsigned int irq)
-{
-        unsigned int pin;
-
-        pin = GPIO_PIN_OF_IRQ(irq);
-        giu_clear(GIUINTENL, 1 << pin);
-        giu_write(GIUINTSTATL, 1 << pin);
-}
-
-static void unmask_giuint_low(unsigned int irq)
-{
-        giu_set(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
-}
-
-static struct irq_chip giuint_low_irq_chip = {
-        .name           = "GIUINTL",
-        .ack            = ack_giuint_low,
-        .mask           = mask_giuint_low,
-        .mask_ack       = mask_ack_giuint_low,
-        .unmask         = unmask_giuint_low,
-};
-
-static void ack_giuint_high(unsigned int irq)
-{
-        giu_write(GIUINTSTATH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
-}
-
-static void mask_giuint_high(unsigned int irq)
-{
-        giu_clear(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
-}
-
-static void mask_ack_giuint_high(unsigned int irq)
-{
-        unsigned int pin;
-
-        pin = GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET;
-        giu_clear(GIUINTENH, 1 << pin);
-        giu_write(GIUINTSTATH, 1 << pin);
-}
-
-static void unmask_giuint_high(unsigned int irq)
-{
-        giu_set(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
-}
-
-static struct irq_chip giuint_high_irq_chip = {
-        .name           = "GIUINTH",
-        .ack            = ack_giuint_high,
-        .mask           = mask_giuint_high,
-        .mask_ack       = mask_ack_giuint_high,
-        .unmask         = unmask_giuint_high,
-};
-
-static int giu_get_irq(unsigned int irq)
-{
-        uint16_t pendl, pendh, maskl, maskh;
-        int i;
-
-        pendl = giu_read(GIUINTSTATL);
-        pendh = giu_read(GIUINTSTATH);
-        maskl = giu_read(GIUINTENL);
-        maskh = giu_read(GIUINTENH);
-
-        maskl &= pendl;
-        maskh &= pendh;
-
-        if (maskl) {
-                for (i = 0; i < 16; i++) {
-                        if (maskl & (1 << i))
-                                return GIU_IRQ(i);
-                }
-        } else if (maskh) {
-                for (i = 0; i < 16; i++) {
-                        if (maskh & (1 << i))
-                                return GIU_IRQ(i + GIUINT_HIGH_OFFSET);
-                }
-        }
-
-        printk(KERN_ERR "spurious GIU interrupt: %04x(%04x),%04x(%04x)\n",
-               maskl, pendl, maskh, pendh);
-
-        atomic_inc(&irq_err_count);
-
-        return -EINVAL;
-}
-
-void vr41xx_set_irq_trigger(unsigned int pin, irq_trigger_t trigger, irq_signal_t signal)
-{
-        uint16_t mask;
-
-        if (pin < GIUINT_HIGH_OFFSET) {
-                mask = 1 << pin;
-                if (trigger != IRQ_TRIGGER_LEVEL) {
-                        giu_set(GIUINTTYPL, mask);
-                        if (signal == IRQ_SIGNAL_HOLD)
-                                giu_set(GIUINTHTSELL, mask);
-                        else
-                                giu_clear(GIUINTHTSELL, mask);
-                        if (giu_flags & GPIO_HAS_INTERRUPT_EDGE_SELECT) {
-                                switch (trigger) {
-                                case IRQ_TRIGGER_EDGE_FALLING:
-                                        giu_set(GIUFEDGEINHL, mask);
-                                        giu_clear(GIUREDGEINHL, mask);
-                                        break;
-                                case IRQ_TRIGGER_EDGE_RISING:
-                                        giu_clear(GIUFEDGEINHL, mask);
-                                        giu_set(GIUREDGEINHL, mask);
-                                        break;
-                                default:
-                                        giu_set(GIUFEDGEINHL, mask);
-                                        giu_set(GIUREDGEINHL, mask);
-                                        break;
-                                }
-                        }
-                        set_irq_chip_and_handler(GIU_IRQ(pin),
-                                                 &giuint_low_irq_chip,
-                                                 handle_edge_irq);
-                } else {
-                        giu_clear(GIUINTTYPL, mask);
-                        giu_clear(GIUINTHTSELL, mask);
-                        set_irq_chip_and_handler(GIU_IRQ(pin),
-                                                 &giuint_low_irq_chip,
-                                                 handle_level_irq);
-                }
-                giu_write(GIUINTSTATL, mask);
-        } else if (pin < GIUINT_HIGH_MAX) {
-                mask = 1 << (pin - GIUINT_HIGH_OFFSET);
-                if (trigger != IRQ_TRIGGER_LEVEL) {
-                        giu_set(GIUINTTYPH, mask);
-                        if (signal == IRQ_SIGNAL_HOLD)
-                                giu_set(GIUINTHTSELH, mask);
-                        else
-                                giu_clear(GIUINTHTSELH, mask);
-                        if (giu_flags & GPIO_HAS_INTERRUPT_EDGE_SELECT) {
-                                switch (trigger) {
-                                case IRQ_TRIGGER_EDGE_FALLING:
-                                        giu_set(GIUFEDGEINHH, mask);
-                                        giu_clear(GIUREDGEINHH, mask);
-                                        break;
-                                case IRQ_TRIGGER_EDGE_RISING:
-                                        giu_clear(GIUFEDGEINHH, mask);
-                                        giu_set(GIUREDGEINHH, mask);
-                                        break;
-                                default:
-                                        giu_set(GIUFEDGEINHH, mask);
-                                        giu_set(GIUREDGEINHH, mask);
-                                        break;
-                                }
-                        }
-                        set_irq_chip_and_handler(GIU_IRQ(pin),
-                                                 &giuint_high_irq_chip,
-                                                 handle_edge_irq);
-                } else {
-                        giu_clear(GIUINTTYPH, mask);
-                        giu_clear(GIUINTHTSELH, mask);
-                        set_irq_chip_and_handler(GIU_IRQ(pin),
-                                                 &giuint_high_irq_chip,
-                                                 handle_level_irq);
-                }
-                giu_write(GIUINTSTATH, mask);
-        }
-}
-EXPORT_SYMBOL_GPL(vr41xx_set_irq_trigger);
-
-void vr41xx_set_irq_level(unsigned int pin, irq_level_t level)
-{
-        uint16_t mask;
-
-        if (pin < GIUINT_HIGH_OFFSET) {
-                mask = 1 << pin;
-                if (level == IRQ_LEVEL_HIGH)
-                        giu_set(GIUINTALSELL, mask);
-                else
-                        giu_clear(GIUINTALSELL, mask);
-                giu_write(GIUINTSTATL, mask);
-        } else if (pin < GIUINT_HIGH_MAX) {
-                mask = 1 << (pin - GIUINT_HIGH_OFFSET);
-                if (level == IRQ_LEVEL_HIGH)
-                        giu_set(GIUINTALSELH, mask);
-                else
-                        giu_clear(GIUINTALSELH, mask);
-                giu_write(GIUINTSTATH, mask);
-        }
-}
-EXPORT_SYMBOL_GPL(vr41xx_set_irq_level);
-
-gpio_data_t vr41xx_gpio_get_pin(unsigned int pin)
-{
-        uint16_t reg, mask;
-
-        if (pin >= giu_nr_pins)
-                return GPIO_DATA_INVAL;
-
-        if (pin < 16) {
-                reg = giu_read(GIUPIODL);
-                mask = (uint16_t)1 << pin;
-        } else if (pin < 32) {
-                reg = giu_read(GIUPIODH);
-                mask = (uint16_t)1 << (pin - 16);
-        } else if (pin < 48) {
-                reg = giu_read(GIUPODATL);
-                mask = (uint16_t)1 << (pin - 32);
-        } else {
-                reg = giu_read(GIUPODATH);
-                mask = (uint16_t)1 << (pin - 48);
-        }
-
-        if (reg & mask)
-                return GPIO_DATA_HIGH;
-
-        return GPIO_DATA_LOW;
-}
-EXPORT_SYMBOL_GPL(vr41xx_gpio_get_pin);
-
-int vr41xx_gpio_set_pin(unsigned int pin, gpio_data_t data)
-{
-        uint16_t offset, mask, reg;
-        unsigned long flags;
-
-        if (pin >= giu_nr_pins)
-                return -EINVAL;
-
-        if (pin < 16) {
-                offset = GIUPIODL;
-                mask = (uint16_t)1 << pin;
-        } else if (pin < 32) {
-                offset = GIUPIODH;
-                mask = (uint16_t)1 << (pin - 16);
-        } else if (pin < 48) {
-                offset = GIUPODATL;
-                mask = (uint16_t)1 << (pin - 32);
-        } else {
-                offset = GIUPODATH;
-                mask = (uint16_t)1 << (pin - 48);
-        }
-
-        spin_lock_irqsave(&giu_lock, flags);
-
-        reg = giu_read(offset);
-        if (data == GPIO_DATA_HIGH)
-                reg |= mask;
-        else
-                reg &= ~mask;
-        giu_write(offset, reg);
-
-        spin_unlock_irqrestore(&giu_lock, flags);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(vr41xx_gpio_set_pin);
-
-int vr41xx_gpio_set_direction(unsigned int pin, gpio_direction_t dir)
-{
-        uint16_t offset, mask, reg;
-        unsigned long flags;
-
-        if (pin >= giu_nr_pins)
-                return -EINVAL;
-
-        if (pin < 16) {
-                offset = GIUIOSELL;
-                mask = (uint16_t)1 << pin;
-        } else if (pin < 32) {
-                offset = GIUIOSELH;
-                mask = (uint16_t)1 << (pin - 16);
-        } else {
-                if (giu_flags & GPIO_HAS_OUTPUT_ENABLE) {
-                        offset = GIUPODATEN;
-                        mask = (uint16_t)1 << (pin - 32);
-                } else {
-                        switch (pin) {
-                        case 48:
-                                offset = GIUPODATH;
-                                mask = PIOEN0;
-                                break;
-                        case 49:
-                                offset = GIUPODATH;
-                                mask = PIOEN1;
-                                break;
-                        default:
-                                return -EINVAL;
-                        }
-                }
-        }
-
-        spin_lock_irqsave(&giu_lock, flags);
-
-        reg = giu_read(offset);
-        if (dir == GPIO_OUTPUT)
-                reg |= mask;
-        else
-                reg &= ~mask;
-        giu_write(offset, reg);
-
-        spin_unlock_irqrestore(&giu_lock, flags);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(vr41xx_gpio_set_direction);
-
-int vr41xx_gpio_pullupdown(unsigned int pin, gpio_pull_t pull)
-{
-        uint16_t reg, mask;
-        unsigned long flags;
-
-        if ((giu_flags & GPIO_HAS_PULLUPDOWN_IO) != GPIO_HAS_PULLUPDOWN_IO)
-                return -EPERM;
-
-        if (pin >= 15)
-                return -EINVAL;
-
-        mask = (uint16_t)1 << pin;
-
-        spin_lock_irqsave(&giu_lock, flags);
-
-        if (pull == GPIO_PULL_UP || pull == GPIO_PULL_DOWN) {
-                reg = giu_read(GIUTERMUPDN);
-                if (pull == GPIO_PULL_UP)
-                        reg |= mask;
-                else
-                        reg &= ~mask;
-                giu_write(GIUTERMUPDN, reg);
-
-                reg = giu_read(GIUUSEUPDN);
-                reg |= mask;
-                giu_write(GIUUSEUPDN, reg);
-        } else {
-                reg = giu_read(GIUUSEUPDN);
-                reg &= ~mask;
-                giu_write(GIUUSEUPDN, reg);
-        }
-
-        spin_unlock_irqrestore(&giu_lock, flags);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(vr41xx_gpio_pullupdown);
-
-static ssize_t gpio_read(struct file *file, char __user *buf, size_t len,
-                         loff_t *ppos)
-{
-        unsigned int pin;
-        char value = '0';
-
-        pin = iminor(file->f_path.dentry->d_inode);
-        if (pin >= giu_nr_pins)
-                return -EBADF;
-
-        if (vr41xx_gpio_get_pin(pin) == GPIO_DATA_HIGH)
-                value = '1';
-
-        if (len <= 0)
-                return -EFAULT;
-
-        if (put_user(value, buf))
-                return -EFAULT;
-
-        return 1;
-}
-
-static ssize_t gpio_write(struct file *file, const char __user *data,
-                          size_t len, loff_t *ppos)
-{
-        unsigned int pin;
-        size_t i;
-        char c;
-        int retval = 0;
-
-        pin = iminor(file->f_path.dentry->d_inode);
-        if (pin >= giu_nr_pins)
-                return -EBADF;
-
-        for (i = 0; i < len; i++) {
-                if (get_user(c, data + i))
-                        return -EFAULT;
-
-                switch (c) {
-                case '0':
-                        retval = vr41xx_gpio_set_pin(pin, GPIO_DATA_LOW);
-                        break;
-                case '1':
-                        retval = vr41xx_gpio_set_pin(pin, GPIO_DATA_HIGH);
-                        break;
-                case 'D':
-                        printk(KERN_INFO "GPIO%d: pull down\n", pin);
-                        retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_DOWN);
-                        break;
-                case 'd':
-                        printk(KERN_INFO "GPIO%d: pull up/down disable\n", pin);
-                        retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_DISABLE);
-                        break;
-                case 'I':
-                        printk(KERN_INFO "GPIO%d: input\n", pin);
-                        retval = vr41xx_gpio_set_direction(pin, GPIO_INPUT);
-                        break;
-                case 'O':
-                        printk(KERN_INFO "GPIO%d: output\n", pin);
-                        retval = vr41xx_gpio_set_direction(pin, GPIO_OUTPUT);
-                        break;
-                case 'o':
-                        printk(KERN_INFO "GPIO%d: output disable\n", pin);
-                        retval = vr41xx_gpio_set_direction(pin, GPIO_OUTPUT_DISABLE);
-                        break;
-                case 'P':
-                        printk(KERN_INFO "GPIO%d: pull up\n", pin);
-                        retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_UP);
-                        break;
-                case 'p':
-                        printk(KERN_INFO "GPIO%d: pull up/down disable\n", pin);
-                        retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_DISABLE);
-                        break;
-                default:
-                        break;
-                }
-
-                if (retval < 0)
-                        break;
-        }
-
-        return i;
-}
-
-static int gpio_open(struct inode *inode, struct file *file)
-{
-        unsigned int pin;
-
-        cycle_kernel_lock();
-        pin = iminor(inode);
-        if (pin >= giu_nr_pins)
-                return -EBADF;
-
-        return nonseekable_open(inode, file);
-}
-
-static int gpio_release(struct inode *inode, struct file *file)
-{
-        unsigned int pin;
-
-        pin = iminor(inode);
-        if (pin >= giu_nr_pins)
-                return -EBADF;
-
-        return 0;
-}
-
-static const struct file_operations gpio_fops = {
-        .owner          = THIS_MODULE,
-        .read           = gpio_read,
-        .write          = gpio_write,
-        .open           = gpio_open,
-        .release        = gpio_release,
-};
-
-static int __devinit giu_probe(struct platform_device *dev)
-{
-        struct resource *res;
-        unsigned int trigger, i, pin;
-        struct irq_chip *chip;
-        int irq, retval;
-
-        switch (dev->id) {
-        case GPIO_50PINS_PULLUPDOWN:
-                giu_flags = GPIO_HAS_PULLUPDOWN_IO;
-                giu_nr_pins = 50;
-                break;
-        case GPIO_36PINS:
-                giu_nr_pins = 36;
-                break;
-        case GPIO_48PINS_EDGE_SELECT:
-                giu_flags = GPIO_HAS_INTERRUPT_EDGE_SELECT;
-                giu_nr_pins = 48;
-                break;
-        default:
-                printk(KERN_ERR "GIU: unknown ID %d\n", dev->id);
-                return -ENODEV;
-        }
-
-        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -EBUSY;
-
-        giu_base = ioremap(res->start, res->end - res->start + 1);
-        if (!giu_base)
-                return -ENOMEM;
-
-        retval = register_chrdev(major, "GIU", &gpio_fops);
-        if (retval < 0) {
-                iounmap(giu_base);
-                giu_base = NULL;
-                return retval;
-        }
-
-        if (major == 0) {
-                major = retval;
-                printk(KERN_INFO "GIU: major number %d\n", major);
-        }
-
-        spin_lock_init(&giu_lock);
-
-        giu_write(GIUINTENL, 0);
-        giu_write(GIUINTENH, 0);
-
-        trigger = giu_read(GIUINTTYPH) << 16;
-        trigger |= giu_read(GIUINTTYPL);
-        for (i = GIU_IRQ_BASE; i <= GIU_IRQ_LAST; i++) {
-                pin = GPIO_PIN_OF_IRQ(i);
-                if (pin < GIUINT_HIGH_OFFSET)
-                        chip = &giuint_low_irq_chip;
-                else
-                        chip = &giuint_high_irq_chip;
-
-                if (trigger & (1 << pin))
-                        set_irq_chip_and_handler(i, chip, handle_edge_irq);
-                else
-                        set_irq_chip_and_handler(i, chip, handle_level_irq);
-
-        }
-
-        irq = platform_get_irq(dev, 0);
-        if (irq < 0 || irq >= nr_irqs)
-                return -EBUSY;
-
-        return cascade_irq(irq, giu_get_irq);
-}
-
-static int __devexit giu_remove(struct platform_device *dev)
-{
-        if (giu_base) {
-                iounmap(giu_base);
-                giu_base = NULL;
-        }
-
-        return 0;
-}
-
-static struct platform_driver giu_device_driver = {
-        .probe          = giu_probe,
-        .remove         = __devexit_p(giu_remove),
-        .driver         = {
-                .name   = "GIU",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init vr41xx_giu_init(void)
-{
-        return platform_driver_register(&giu_device_driver);
-}
-
-static void __exit vr41xx_giu_exit(void)
-{
-        platform_driver_unregister(&giu_device_driver);
-}
-
-module_init(vr41xx_giu_init);
-module_exit(vr41xx_giu_exit);
diff --git a/drivers/clocksource/sh_tmu.c b/drivers/clocksource/sh_tmu.c
index 9ffb05f4095d..93c2322feab7 100644
--- a/drivers/clocksource/sh_tmu.c
+++ b/drivers/clocksource/sh_tmu.c
@@ -161,7 +161,7 @@ static void sh_tmu_set_next(struct sh_tmu_priv *p, unsigned long delta,
         if (periodic)
                 sh_tmu_write(p, TCOR, delta);
         else
-                sh_tmu_write(p, TCOR, 0);
+                sh_tmu_write(p, TCOR, 0xffffffff);
 
         sh_tmu_write(p, TCNT, delta);
 
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 6e2ec0b18948..b90eda8b3440 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -761,6 +761,10 @@ static struct kobj_type ktype_cpufreq = {
  * cpufreq_add_dev - add a CPU device
  *
  * Adds the cpufreq interface for a CPU device.
+ *
+ * The Oracle says: try running cpufreq registration/unregistration concurrently
+ * with with cpu hotplugging and all hell will break loose. Tried to clean this
+ * mess up, but more thorough testing is needed. - Mathieu
  */
 static int cpufreq_add_dev(struct sys_device *sys_dev)
 {
@@ -772,9 +776,6 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         struct sys_device *cpu_sys_dev;
         unsigned long flags;
         unsigned int j;
-#ifdef CONFIG_SMP
-        struct cpufreq_policy *managed_policy;
-#endif
 
         if (cpu_is_offline(cpu))
                 return 0;
@@ -804,15 +805,12 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                 goto nomem_out;
         }
         if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL)) {
-                kfree(policy);
                 ret = -ENOMEM;
-                goto nomem_out;
+                goto err_free_policy;
         }
         if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL)) {
-                free_cpumask_var(policy->cpus);
-                kfree(policy);
                 ret = -ENOMEM;
-                goto nomem_out;
+                goto err_free_cpumask;
         }
 
         policy->cpu = cpu;
@@ -820,7 +818,8 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 
         /* Initially set CPU itself as the policy_cpu */
         per_cpu(policy_cpu, cpu) = cpu;
-        lock_policy_rwsem_write(cpu);
+        ret = (lock_policy_rwsem_write(cpu) < 0);
+        WARN_ON(ret);
 
         init_completion(&policy->kobj_unregister);
         INIT_WORK(&policy->update, handle_update);
@@ -833,7 +832,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         ret = cpufreq_driver->init(policy);
         if (ret) {
                 dprintk("initialization failed\n");
-                goto err_out;
+                goto err_unlock_policy;
         }
         policy->user_policy.min = policy->min;
         policy->user_policy.max = policy->max;
@@ -852,21 +851,29 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 #endif
 
         for_each_cpu(j, policy->cpus) {
+                struct cpufreq_policy *managed_policy;
+
                 if (cpu == j)
                         continue;
 
                 /* Check for existing affected CPUs.
                  * They may not be aware of it due to CPU Hotplug.
                  */
-                managed_policy = cpufreq_cpu_get(j);            /* FIXME: Where is this released?  What about error paths? */
+                managed_policy = cpufreq_cpu_get(j);
                 if (unlikely(managed_policy)) {
 
                         /* Set proper policy_cpu */
                         unlock_policy_rwsem_write(cpu);
                         per_cpu(policy_cpu, cpu) = managed_policy->cpu;
 
-                        if (lock_policy_rwsem_write(cpu) < 0)
-                                goto err_out_driver_exit;
+                        if (lock_policy_rwsem_write(cpu) < 0) {
+                                /* Should not go through policy unlock path */
+                                if (cpufreq_driver->exit)
+                                        cpufreq_driver->exit(policy);
+                                ret = -EBUSY;
+                                cpufreq_cpu_put(managed_policy);
+                                goto err_free_cpumask;
+                        }
 
                         spin_lock_irqsave(&cpufreq_driver_lock, flags);
                         cpumask_copy(managed_policy->cpus, policy->cpus);
@@ -877,12 +884,14 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                         ret = sysfs_create_link(&sys_dev->kobj,
                                                 &managed_policy->kobj,
                                                 "cpufreq");
-                        if (ret)
-                                goto err_out_driver_exit;
-
-                        cpufreq_debug_enable_ratelimit();
-                        ret = 0;
-                        goto err_out_driver_exit; /* call driver->exit() */
+                        if (!ret)
+                                cpufreq_cpu_put(managed_policy);
+                        /*
+                         * Success. We only needed to be added to the mask.
+                         * Call driver->exit() because only the cpu parent of
+                         * the kobj needed to call init().
+                         */
+                        goto out_driver_exit; /* call driver->exit() */
                 }
         }
 #endif
@@ -892,25 +901,25 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj,
                                    "cpufreq");
         if (ret)
-                goto err_out_driver_exit;
+                goto out_driver_exit;
 
         /* set up files for this cpu device */
         drv_attr = cpufreq_driver->attr;
         while ((drv_attr) && (*drv_attr)) {
                 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
                 if (ret)
-                        goto err_out_driver_exit;
+                        goto err_out_kobj_put;
                 drv_attr++;
         }
         if (cpufreq_driver->get) {
                 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
                 if (ret)
-                        goto err_out_driver_exit;
+                        goto err_out_kobj_put;
         }
         if (cpufreq_driver->target) {
                 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
                 if (ret)
-                        goto err_out_driver_exit;
+                        goto err_out_kobj_put;
         }
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
@@ -922,18 +931,22 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 
         /* symlink affected CPUs */
         for_each_cpu(j, policy->cpus) {
+                struct cpufreq_policy *managed_policy;
+
                 if (j == cpu)
                         continue;
                 if (!cpu_online(j))
                         continue;
 
                 dprintk("CPU %u already managed, adding link\n", j);
-                cpufreq_cpu_get(cpu);
+                managed_policy = cpufreq_cpu_get(cpu);
                 cpu_sys_dev = get_cpu_sysdev(j);
                 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
                                         "cpufreq");
-                if (ret)
+                if (ret) {
+                        cpufreq_cpu_put(managed_policy);
                         goto err_out_unregister;
+                }
         }
 
         policy->governor = NULL; /* to assure that the starting sequence is
@@ -965,17 +978,20 @@ err_out_unregister:
                 per_cpu(cpufreq_cpu_data, j) = NULL;
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
+err_out_kobj_put:
         kobject_put(&policy->kobj);
         wait_for_completion(&policy->kobj_unregister);
 
-err_out_driver_exit:
+out_driver_exit:
         if (cpufreq_driver->exit)
                 cpufreq_driver->exit(policy);
 
-err_out:
+err_unlock_policy:
         unlock_policy_rwsem_write(cpu);
+err_free_cpumask:
+        free_cpumask_var(policy->cpus);
+err_free_policy:
         kfree(policy);
-
 nomem_out:
         module_put(cpufreq_driver->owner);
 module_out:
@@ -1070,8 +1086,6 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 #endif
 
-        unlock_policy_rwsem_write(cpu);
-
         if (cpufreq_driver->target)
                 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
 
@@ -1088,6 +1102,8 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         if (cpufreq_driver->exit)
                 cpufreq_driver->exit(data);
 
+        unlock_policy_rwsem_write(cpu);
+
         free_cpumask_var(data->related_cpus);
         free_cpumask_var(data->cpus);
         kfree(data);
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 7fc58af748b4..57490502b21c 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -63,22 +63,20 @@ struct cpu_dbs_info_s {
         unsigned int down_skip;
         unsigned int requested_freq;
         int cpu;
-        unsigned int enable:1;
+        /*
+         * percpu mutex that serializes governor limit change with
+         * do_dbs_timer invocation. We do not want do_dbs_timer to run
+         * when user is changing the governor or limits.
+         */
+        struct mutex timer_mutex;
 };
 static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
 
 static unsigned int dbs_enable; /* number of CPUs using this policy */
 
 /*
- * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug
- * lock and dbs_mutex. cpu_hotplug lock should always be held before
- * dbs_mutex. If any function that can potentially take cpu_hotplug lock
- * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then
- * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
- * is recursive for the same process. -Venki
- * DEADLOCK ALERT! (2) : do_dbs_timer() must not take the dbs_mutex, because it
- * would deadlock with cancel_delayed_work_sync(), which is needed for proper
- * raceless workqueue teardown.
+ * dbs_mutex protects data in dbs_tuners_ins from concurrent changes on
+ * different CPUs. It protects dbs_enable in governor start/stop.
  */
 static DEFINE_MUTEX(dbs_mutex);
 
@@ -143,9 +141,6 @@ dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
 
         struct cpufreq_policy *policy;
 
-        if (!this_dbs_info->enable)
-                return 0;
-
         policy = this_dbs_info->cur_policy;
 
         /*
@@ -488,18 +483,12 @@ static void do_dbs_timer(struct work_struct *work)
 
         delay -= jiffies % delay;
 
-        if (lock_policy_rwsem_write(cpu) < 0)
-                return;
-
-        if (!dbs_info->enable) {
-                unlock_policy_rwsem_write(cpu);
-                return;
-        }
+        mutex_lock(&dbs_info->timer_mutex);
 
         dbs_check_cpu(dbs_info);
 
         queue_delayed_work_on(cpu, kconservative_wq, &dbs_info->work, delay);
-        unlock_policy_rwsem_write(cpu);
+        mutex_unlock(&dbs_info->timer_mutex);
 }
 
 static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
@@ -508,7 +497,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
         int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
         delay -= jiffies % delay;
 
-        dbs_info->enable = 1;
         INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
         queue_delayed_work_on(dbs_info->cpu, kconservative_wq, &dbs_info->work,
                                 delay);
@@ -516,7 +504,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
 
 static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
 {
-        dbs_info->enable = 0;
         cancel_delayed_work_sync(&dbs_info->work);
 }
 
@@ -535,9 +522,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 if ((!cpu_online(cpu)) || (!policy->cur))
                         return -EINVAL;
 
-                if (this_dbs_info->enable) /* Already enabled */
-                        break;
-
                 mutex_lock(&dbs_mutex);
 
                 rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
@@ -561,6 +545,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 this_dbs_info->down_skip = 0;
                 this_dbs_info->requested_freq = policy->cur;
 
+                mutex_init(&this_dbs_info->timer_mutex);
                 dbs_enable++;
                 /*
                  * Start the timerschedule work, when this governor
@@ -590,17 +575,19 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                         &dbs_cpufreq_notifier_block,
                                         CPUFREQ_TRANSITION_NOTIFIER);
                 }
-                dbs_timer_init(this_dbs_info);
-
                 mutex_unlock(&dbs_mutex);
 
+                dbs_timer_init(this_dbs_info);
+
                 break;
 
         case CPUFREQ_GOV_STOP:
-                mutex_lock(&dbs_mutex);
                 dbs_timer_exit(this_dbs_info);
+
+                mutex_lock(&dbs_mutex);
                 sysfs_remove_group(&policy->kobj, &dbs_attr_group);
                 dbs_enable--;
+                mutex_destroy(&this_dbs_info->timer_mutex);
 
                 /*
                  * Stop the timerschedule work, when this governor
@@ -616,7 +603,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 break;
 
         case CPUFREQ_GOV_LIMITS:
-                mutex_lock(&dbs_mutex);
+                mutex_lock(&this_dbs_info->timer_mutex);
                 if (policy->max < this_dbs_info->cur_policy->cur)
                         __cpufreq_driver_target(
                                         this_dbs_info->cur_policy,
@@ -625,7 +612,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         __cpufreq_driver_target(
                                         this_dbs_info->cur_policy,
                                         policy->min, CPUFREQ_RELATION_L);
-                mutex_unlock(&dbs_mutex);
+                mutex_unlock(&this_dbs_info->timer_mutex);
 
                 break;
         }
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 1911d1729353..d6ba14276bb1 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -70,23 +70,21 @@ struct cpu_dbs_info_s {
         unsigned int freq_lo_jiffies;
         unsigned int freq_hi_jiffies;
         int cpu;
-        unsigned int enable:1,
-                sample_type:1;
+        unsigned int sample_type:1;
+        /*
+         * percpu mutex that serializes governor limit change with
+         * do_dbs_timer invocation. We do not want do_dbs_timer to run
+         * when user is changing the governor or limits.
+         */
+        struct mutex timer_mutex;
 };
 static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
 
 static unsigned int dbs_enable; /* number of CPUs using this policy */
 
 /*
- * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug
- * lock and dbs_mutex. cpu_hotplug lock should always be held before
- * dbs_mutex. If any function that can potentially take cpu_hotplug lock
- * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then
- * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
- * is recursive for the same process. -Venki
- * DEADLOCK ALERT! (2) : do_dbs_timer() must not take the dbs_mutex, because it
- * would deadlock with cancel_delayed_work_sync(), which is needed for proper
- * raceless workqueue teardown.
+ * dbs_mutex protects data in dbs_tuners_ins from concurrent changes on
+ * different CPUs. It protects dbs_enable in governor start/stop.
  */
 static DEFINE_MUTEX(dbs_mutex);
 
@@ -192,13 +190,18 @@ static unsigned int powersave_bias_target(struct cpufreq_policy *policy,
         return freq_hi;
 }
 
+static void ondemand_powersave_bias_init_cpu(int cpu)
+{
+        struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu);
+        dbs_info->freq_table = cpufreq_frequency_get_table(cpu);
+        dbs_info->freq_lo = 0;
+}
+
 static void ondemand_powersave_bias_init(void)
 {
         int i;
         for_each_online_cpu(i) {
-                struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, i);
-                dbs_info->freq_table = cpufreq_frequency_get_table(i);
-                dbs_info->freq_lo = 0;
+                ondemand_powersave_bias_init_cpu(i);
         }
 }
 
@@ -240,12 +243,10 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
         unsigned int input;
         int ret;
         ret = sscanf(buf, "%u", &input);
+        if (ret != 1)
+                return -EINVAL;
 
         mutex_lock(&dbs_mutex);
-        if (ret != 1) {
-                mutex_unlock(&dbs_mutex);
-                return -EINVAL;
-        }
         dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate);
         mutex_unlock(&dbs_mutex);
 
@@ -259,13 +260,12 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
         int ret;
         ret = sscanf(buf, "%u", &input);
 
-        mutex_lock(&dbs_mutex);
         if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
                         input < MIN_FREQUENCY_UP_THRESHOLD) {
-                mutex_unlock(&dbs_mutex);
                 return -EINVAL;
         }
 
+        mutex_lock(&dbs_mutex);
         dbs_tuners_ins.up_threshold = input;
         mutex_unlock(&dbs_mutex);
 
@@ -363,9 +363,6 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
         struct cpufreq_policy *policy;
         unsigned int j;
 
-        if (!this_dbs_info->enable)
-                return;
-
         this_dbs_info->freq_lo = 0;
         policy = this_dbs_info->cur_policy;
 
@@ -493,14 +490,7 @@ static void do_dbs_timer(struct work_struct *work)
         int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
 
         delay -= jiffies % delay;
-
-        if (lock_policy_rwsem_write(cpu) < 0)
-                return;
-
-        if (!dbs_info->enable) {
-                unlock_policy_rwsem_write(cpu);
-                return;
-        }
+        mutex_lock(&dbs_info->timer_mutex);
 
         /* Common NORMAL_SAMPLE setup */
         dbs_info->sample_type = DBS_NORMAL_SAMPLE;
@@ -517,7 +507,7 @@ static void do_dbs_timer(struct work_struct *work)
                         dbs_info->freq_lo, CPUFREQ_RELATION_H);
         }
         queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay);
-        unlock_policy_rwsem_write(cpu);
+        mutex_unlock(&dbs_info->timer_mutex);
 }
 
 static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
@@ -526,8 +516,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
         int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
         delay -= jiffies % delay;
 
-        dbs_info->enable = 1;
-        ondemand_powersave_bias_init();
         dbs_info->sample_type = DBS_NORMAL_SAMPLE;
         INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
         queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work,
@@ -536,7 +524,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
 
 static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
 {
-        dbs_info->enable = 0;
         cancel_delayed_work_sync(&dbs_info->work);
 }
 
@@ -555,19 +542,15 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 if ((!cpu_online(cpu)) || (!policy->cur))
                         return -EINVAL;
 
-                if (this_dbs_info->enable) /* Already enabled */
-                        break;
-
                 mutex_lock(&dbs_mutex);
-                dbs_enable++;
 
                 rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
                 if (rc) {
-                        dbs_enable--;
                         mutex_unlock(&dbs_mutex);
                         return rc;
                 }
 
+                dbs_enable++;
                 for_each_cpu(j, policy->cpus) {
                         struct cpu_dbs_info_s *j_dbs_info;
                         j_dbs_info = &per_cpu(cpu_dbs_info, j);
@@ -581,6 +564,8 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         }
                 }
                 this_dbs_info->cpu = cpu;
+                ondemand_powersave_bias_init_cpu(cpu);
+                mutex_init(&this_dbs_info->timer_mutex);
                 /*
                  * Start the timerschedule work, when this governor
                  * is used for first time
@@ -598,29 +583,31 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                 max(min_sampling_rate,
                                     latency * LATENCY_MULTIPLIER);
                 }
-                dbs_timer_init(this_dbs_info);
-
                 mutex_unlock(&dbs_mutex);
+
+                dbs_timer_init(this_dbs_info);
                 break;
 
         case CPUFREQ_GOV_STOP:
-                mutex_lock(&dbs_mutex);
                 dbs_timer_exit(this_dbs_info);
+
+                mutex_lock(&dbs_mutex);
                 sysfs_remove_group(&policy->kobj, &dbs_attr_group);
+                mutex_destroy(&this_dbs_info->timer_mutex);
                 dbs_enable--;
                 mutex_unlock(&dbs_mutex);
 
                 break;
 
         case CPUFREQ_GOV_LIMITS:
-                mutex_lock(&dbs_mutex);
+                mutex_lock(&this_dbs_info->timer_mutex);
                 if (policy->max < this_dbs_info->cur_policy->cur)
                         __cpufreq_driver_target(this_dbs_info->cur_policy,
                                 policy->max, CPUFREQ_RELATION_H);
                 else if (policy->min > this_dbs_info->cur_policy->cur)
                         __cpufreq_driver_target(this_dbs_info->cur_policy,
                                 policy->min, CPUFREQ_RELATION_L);
-                mutex_unlock(&dbs_mutex);
+                mutex_unlock(&this_dbs_info->timer_mutex);
                 break;
         }
         return 0;
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
index c36bf40568cf..858fe6037223 100644
--- a/drivers/edac/amd64_edac.c
+++ b/drivers/edac/amd64_edac.c
@@ -754,13 +754,13 @@ static void amd64_cpu_display_info(struct amd64_pvt *pvt)
 static enum edac_type amd64_determine_edac_cap(struct amd64_pvt *pvt)
 {
         int bit;
-        enum dev_type edac_cap = EDAC_NONE;
+        enum dev_type edac_cap = EDAC_FLAG_NONE;
 
         bit = (boot_cpu_data.x86 > 0xf || pvt->ext_model >= OPTERON_CPU_REV_F)
                 ? 19
                 : 17;
 
-        if (pvt->dclr0 >> BIT(bit))
+        if (pvt->dclr0 & BIT(bit))
                 edac_cap = EDAC_FLAG_SECDED;
 
         return edac_cap;
@@ -1269,7 +1269,7 @@ static int f10_early_channel_count(struct amd64_pvt *pvt)
         if (channels == 0)
                 channels = 1;
 
-        debugf0("DIMM count= %d\n", channels);
+        debugf0("MCT channel count: %d\n", channels);
 
         return channels;
 
@@ -2966,7 +2966,12 @@ static int amd64_check_ecc_enabled(struct amd64_pvt *pvt)
                                 "    Use of the override can cause "
                                 "unknown side effects.\n");
                         ret = -ENODEV;
-                }
+                } else
+                        /*
+                         * enable further driver loading if ECC enable is
+                         * overridden.
+                         */
+                        ret = 0;
         } else {
                 amd64_printk(KERN_INFO,
                         "ECC is enabled by BIOS, Proceeding "
@@ -3006,7 +3011,6 @@ static void amd64_setup_mci_misc_attributes(struct mem_ctl_info *mci)
 
         mci->mtype_cap          = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
         mci->edac_ctl_cap       = EDAC_FLAG_NONE;
-        mci->edac_cap           = EDAC_FLAG_NONE;
 
         if (pvt->nbcap & K8_NBCAP_SECDED)
                 mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
@@ -3052,7 +3056,7 @@ static int amd64_probe_one_instance(struct pci_dev *dram_f2_ctl,
         if (!pvt)
                 goto err_exit;
 
-        pvt->mc_node_id = get_mc_node_id_from_pdev(dram_f2_ctl);
+        pvt->mc_node_id = get_node_id(dram_f2_ctl);
 
         pvt->dram_f2_ctl        = dram_f2_ctl;
         pvt->ext_model          = boot_cpu_data.x86_model >> 4;
@@ -3179,8 +3183,7 @@ static int __devinit amd64_init_one_instance(struct pci_dev *pdev,
 {
         int ret = 0;
 
-        debugf0("(MC node=%d,mc_type='%s')\n",
-                get_mc_node_id_from_pdev(pdev),
+        debugf0("(MC node=%d,mc_type='%s')\n", get_node_id(pdev),
                 get_amd_family_name(mc_type->driver_data));
 
         ret = pci_enable_device(pdev);
@@ -3319,15 +3322,17 @@ static int __init amd64_edac_init(void)
 
                 err = amd64_init_2nd_stage(pvt_lookup[nb]);
                 if (err)
-                        goto err_exit;
+                        goto err_2nd_stage;
         }
 
         amd64_setup_pci_device();
 
         return 0;
 
+err_2nd_stage:
+        debugf0("2nd stage failed\n");
+
 err_exit:
-        debugf0("'finish_setup' stage failed\n");
         pci_unregister_driver(&amd64_pci_driver);
 
         return err;
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h
index a159957e167b..ba73015af8e4 100644
--- a/drivers/edac/amd64_edac.h
+++ b/drivers/edac/amd64_edac.h
@@ -444,7 +444,7 @@ enum {
 #define K8_MSR_MC4ADDR                  0x0412
 
 /* AMD sets the first MC device at device ID 0x18. */
-static inline int get_mc_node_id_from_pdev(struct pci_dev *pdev)
+static inline int get_node_id(struct pci_dev *pdev)
 {
         return PCI_SLOT(pdev->devfn) - 0x18;
 }
diff --git a/drivers/edac/edac_core.h b/drivers/edac/edac_core.h
index 3493c6bdb820..871c13b4c148 100644
--- a/drivers/edac/edac_core.h
+++ b/drivers/edac/edac_core.h
@@ -150,6 +150,8 @@ enum mem_type {
         MEM_FB_DDR2,            /* fully buffered DDR2 */
         MEM_RDDR2,              /* Registered DDR2 RAM */
         MEM_XDR,                /* Rambus XDR */
+        MEM_DDR3,               /* DDR3 RAM */
+        MEM_RDDR3,              /* Registered DDR3 RAM */
 };
 
 #define MEM_FLAG_EMPTY          BIT(MEM_EMPTY)
@@ -167,6 +169,8 @@ enum mem_type {
 #define MEM_FLAG_FB_DDR2        BIT(MEM_FB_DDR2)
 #define MEM_FLAG_RDDR2          BIT(MEM_RDDR2)
 #define MEM_FLAG_XDR            BIT(MEM_XDR)
+#define MEM_FLAG_DDR3            BIT(MEM_DDR3)
+#define MEM_FLAG_RDDR3           BIT(MEM_RDDR3)
 
 /* chipset Error Detection and Correction capabilities and mode */
 enum edac_type {
diff --git a/drivers/edac/edac_mc_sysfs.c b/drivers/edac/edac_mc_sysfs.c
index ad218fe4942d..e1d4ce083481 100644
--- a/drivers/edac/edac_mc_sysfs.c
+++ b/drivers/edac/edac_mc_sysfs.c
@@ -94,7 +94,9 @@ static const char *mem_types[] = {
         [MEM_DDR2] = "Unbuffered-DDR2",
         [MEM_FB_DDR2] = "FullyBuffered-DDR2",
         [MEM_RDDR2] = "Registered-DDR2",
-        [MEM_XDR] = "XDR"
+        [MEM_XDR] = "XDR",
+        [MEM_DDR3] = "Unbuffered-DDR3",
+        [MEM_RDDR3] = "Registered-DDR3"
 };
 
 static const char *dev_types[] = {
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index 7c8c2d72916f..3f2ccfc6407c 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -757,6 +757,9 @@ static void __devinit mpc85xx_init_csrows(struct mem_ctl_info *mci)
                 case DSC_SDTYPE_DDR2:
                         mtype = MEM_RDDR2;
                         break;
+                case DSC_SDTYPE_DDR3:
+                        mtype = MEM_RDDR3;
+                        break;
                 default:
                         mtype = MEM_UNKNOWN;
                         break;
@@ -769,6 +772,9 @@ static void __devinit mpc85xx_init_csrows(struct mem_ctl_info *mci)
                 case DSC_SDTYPE_DDR2:
                         mtype = MEM_DDR2;
                         break;
+                case DSC_SDTYPE_DDR3:
+                        mtype = MEM_DDR3;
+                        break;
                 default:
                         mtype = MEM_UNKNOWN;
                         break;
diff --git a/drivers/edac/mpc85xx_edac.h b/drivers/edac/mpc85xx_edac.h
index 135b3539a030..52432ee7c4b9 100644
--- a/drivers/edac/mpc85xx_edac.h
+++ b/drivers/edac/mpc85xx_edac.h
@@ -53,6 +53,7 @@
 
 #define DSC_SDTYPE_DDR          0x02000000
 #define DSC_SDTYPE_DDR2         0x03000000
+#define DSC_SDTYPE_DDR3         0x07000000
 #define DSC_X32_EN      0x00000020
 
 /* Err_Int_En */
diff --git a/drivers/firewire/core-card.c b/drivers/firewire/core-card.c
index 543fccac81bb..f74edae5cb4c 100644
--- a/drivers/firewire/core-card.c
+++ b/drivers/firewire/core-card.c
@@ -196,8 +196,8 @@ static void allocate_broadcast_channel(struct fw_card *card, int generation)
 {
         int channel, bandwidth = 0;
 
-        fw_iso_resource_manage(card, generation, 1ULL << 31,
-                               &channel, &bandwidth, true);
+        fw_iso_resource_manage(card, generation, 1ULL << 31, &channel,
+                               &bandwidth, true, card->bm_transaction_data);
         if (channel == 31) {
                 card->broadcast_channel_allocated = true;
                 device_for_each_child(card->device, (void *)(long)generation,
@@ -230,7 +230,6 @@ static void fw_card_bm_work(struct work_struct *work)
         bool do_reset = false;
         bool root_device_is_running;
         bool root_device_is_cmc;
-        __be32 lock_data[2];
 
         spin_lock_irqsave(&card->lock, flags);
 
@@ -273,22 +272,23 @@ static void fw_card_bm_work(struct work_struct *work)
                         goto pick_me;
                 }
 
-                lock_data[0] = cpu_to_be32(0x3f);
-                lock_data[1] = cpu_to_be32(local_id);
+                card->bm_transaction_data[0] = cpu_to_be32(0x3f);
+                card->bm_transaction_data[1] = cpu_to_be32(local_id);
 
                 spin_unlock_irqrestore(&card->lock, flags);
 
                 rcode = fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP,
                                 irm_id, generation, SCODE_100,
                                 CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID,
-                                lock_data, sizeof(lock_data));
+                                card->bm_transaction_data,
+                                sizeof(card->bm_transaction_data));
 
                 if (rcode == RCODE_GENERATION)
                         /* Another bus reset, BM work has been rescheduled. */
                         goto out;
 
                 if (rcode == RCODE_COMPLETE &&
-                    lock_data[0] != cpu_to_be32(0x3f)) {
+                    card->bm_transaction_data[0] != cpu_to_be32(0x3f)) {
 
                         /* Somebody else is BM.  Only act as IRM. */
                         if (local_id == irm_id)
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c
index d1d30c615b0f..ced186d7e9a9 100644
--- a/drivers/firewire/core-cdev.c
+++ b/drivers/firewire/core-cdev.c
@@ -125,6 +125,7 @@ struct iso_resource {
         int generation;
         u64 channels;
         s32 bandwidth;
+        __be32 transaction_data[2];
         struct iso_resource_event *e_alloc, *e_dealloc;
 };
 
@@ -1049,7 +1050,8 @@ static void iso_resource_work(struct work_struct *work)
                         r->channels, &channel, &bandwidth,
                         todo == ISO_RES_ALLOC ||
                         todo == ISO_RES_REALLOC ||
-                        todo == ISO_RES_ALLOC_ONCE);
+                        todo == ISO_RES_ALLOC_ONCE,
+                        r->transaction_data);
         /*
          * Is this generation outdated already?  As long as this resource sticks
          * in the idr, it will be scheduled again for a newer generation or at
diff --git a/drivers/firewire/core-iso.c b/drivers/firewire/core-iso.c
index 166f19c6d38d..110e731f5574 100644
--- a/drivers/firewire/core-iso.c
+++ b/drivers/firewire/core-iso.c
@@ -177,9 +177,8 @@ EXPORT_SYMBOL(fw_iso_context_stop);
  */
 
 static int manage_bandwidth(struct fw_card *card, int irm_id, int generation,
-                            int bandwidth, bool allocate)
+                            int bandwidth, bool allocate, __be32 data[2])
 {
-        __be32 data[2];
         int try, new, old = allocate ? BANDWIDTH_AVAILABLE_INITIAL : 0;
 
         /*
@@ -215,9 +214,9 @@ static int manage_bandwidth(struct fw_card *card, int irm_id, int generation,
 }
 
 static int manage_channel(struct fw_card *card, int irm_id, int generation,
-                          u32 channels_mask, u64 offset, bool allocate)
+                u32 channels_mask, u64 offset, bool allocate, __be32 data[2])
 {
-        __be32 data[2], c, all, old;
+        __be32 c, all, old;
         int i, retry = 5;
 
         old = all = allocate ? cpu_to_be32(~0) : 0;
@@ -260,7 +259,7 @@ static int manage_channel(struct fw_card *card, int irm_id, int generation,
 }
 
 static void deallocate_channel(struct fw_card *card, int irm_id,
-                               int generation, int channel)
+                               int generation, int channel, __be32 buffer[2])
 {
         u32 mask;
         u64 offset;
@@ -269,7 +268,7 @@ static void deallocate_channel(struct fw_card *card, int irm_id,
         offset = channel < 32 ? CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI :
                                 CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO;
 
-        manage_channel(card, irm_id, generation, mask, offset, false);
+        manage_channel(card, irm_id, generation, mask, offset, false, buffer);
 }
 
 /**
@@ -298,7 +297,7 @@ static void deallocate_channel(struct fw_card *card, int irm_id,
  */
 void fw_iso_resource_manage(struct fw_card *card, int generation,
                             u64 channels_mask, int *channel, int *bandwidth,
-                            bool allocate)
+                            bool allocate, __be32 buffer[2])
 {
         u32 channels_hi = channels_mask;        /* channels 31...0 */
         u32 channels_lo = channels_mask >> 32;  /* channels 63...32 */
@@ -310,10 +309,12 @@ void fw_iso_resource_manage(struct fw_card *card, int generation,
 
         if (channels_hi)
                 c = manage_channel(card, irm_id, generation, channels_hi,
-                    CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI, allocate);
+                                CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_HI,
+                                allocate, buffer);
         if (channels_lo && c < 0) {
                 c = manage_channel(card, irm_id, generation, channels_lo,
-                    CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO, allocate);
+                                CSR_REGISTER_BASE + CSR_CHANNELS_AVAILABLE_LO,
+                                allocate, buffer);
                 if (c >= 0)
                         c += 32;
         }
@@ -325,12 +326,13 @@ void fw_iso_resource_manage(struct fw_card *card, int generation,
         if (*bandwidth == 0)
                 return;
 
-        ret = manage_bandwidth(card, irm_id, generation, *bandwidth, allocate);
+        ret = manage_bandwidth(card, irm_id, generation, *bandwidth,
+                               allocate, buffer);
         if (ret < 0)
                 *bandwidth = 0;
 
         if (allocate && ret < 0 && c >= 0) {
-                deallocate_channel(card, irm_id, generation, c);
+                deallocate_channel(card, irm_id, generation, c, buffer);
                 *channel = ret;
         }
 }
diff --git a/drivers/firewire/core.h b/drivers/firewire/core.h
index c3cfc647e5e3..6052816be353 100644
--- a/drivers/firewire/core.h
+++ b/drivers/firewire/core.h
@@ -120,7 +120,8 @@ void fw_node_event(struct fw_card *card, struct fw_node *node, int event);
 
 int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma);
 void fw_iso_resource_manage(struct fw_card *card, int generation,
-                u64 channels_mask, int *channel, int *bandwidth, bool allocate);
+                            u64 channels_mask, int *channel, int *bandwidth,
+                            bool allocate, __be32 buffer[2]);
 
 
 /* -topology */
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index 24c45635376a..8d51568ee143 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -201,6 +201,12 @@ static struct fw_device *target_device(struct sbp2_target *tgt)
 #define SBP2_CYCLE_LIMIT                (0xc8 << 12)    /* 200 125us cycles */
 
 /*
+ * There is no transport protocol limit to the CDB length,  but we implement
+ * a fixed length only.  16 bytes is enough for disks larger than 2 TB.
+ */
+#define SBP2_MAX_CDB_SIZE               16
+
+/*
  * The default maximum s/g segment size of a FireWire controller is
  * usually 0x10000, but SBP-2 only allows 0xffff. Since buffers have to
  * be quadlet-aligned, we set the length limit to 0xffff & ~3.
@@ -312,7 +318,7 @@ struct sbp2_command_orb {
                 struct sbp2_pointer next;
                 struct sbp2_pointer data_descriptor;
                 __be32 misc;
-                u8 command_block[12];
+                u8 command_block[SBP2_MAX_CDB_SIZE];
         } request;
         struct scsi_cmnd *cmd;
         scsi_done_fn_t done;
@@ -1146,6 +1152,8 @@ static int sbp2_probe(struct device *dev)
         if (fw_device_enable_phys_dma(device) < 0)
                 goto fail_shost_put;
 
+        shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
+
         if (scsi_add_host(shost, &unit->device) < 0)
                 goto fail_shost_put;
 
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 3582c39f9725..96dda81c9228 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -79,6 +79,12 @@ config GPIO_XILINX
         help
           Say yes here to support the Xilinx FPGA GPIO device
 
+config GPIO_VR41XX
+        tristate "NEC VR4100 series General-purpose I/O Uint support"
+        depends on CPU_VR41XX
+        help
+          Say yes here to support the NEC VR4100 series General-purpose I/O Uint
+
 comment "I2C GPIO expanders:"
 
 config GPIO_MAX732X
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index ef90203e8f3c..9244c6fcd8be 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -13,3 +13,4 @@ obj-$(CONFIG_GPIO_PL061)	+= pl061.o
 obj-$(CONFIG_GPIO_TWL4030)      += twl4030-gpio.o
 obj-$(CONFIG_GPIO_XILINX)       += xilinx_gpio.o
 obj-$(CONFIG_GPIO_BT8XX)        += bt8xxgpio.o
+obj-$(CONFIG_GPIO_VR41XX)       += vr41xx_giu.o
diff --git a/drivers/gpio/pl061.c b/drivers/gpio/pl061.c
index aa8e7cb020d9..4ee4c8367a3f 100644
--- a/drivers/gpio/pl061.c
+++ b/drivers/gpio/pl061.c
@@ -109,6 +109,16 @@ static void pl061_set_value(struct gpio_chip *gc, unsigned offset, int value)
         writeb(!!value << offset, chip->base + (1 << (offset + 2)));
 }
 
+static int pl061_to_irq(struct gpio_chip *gc, unsigned offset)
+{
+        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+
+        if (chip->irq_base == (unsigned) -1)
+                return -EINVAL;
+
+        return chip->irq_base + offset;
+}
+
 /*
  * PL061 GPIO IRQ
  */
@@ -200,7 +210,7 @@ static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
         desc->chip->ack(irq);
         list_for_each(ptr, chip_list) {
                 unsigned long pending;
-                int gpio;
+                int offset;
 
                 chip = list_entry(ptr, struct pl061_gpio, list);
                 pending = readb(chip->base + GPIOMIS);
@@ -209,8 +219,8 @@ static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
                 if (pending == 0)
                         continue;
 
-                for_each_bit(gpio, &pending, PL061_GPIO_NR)
-                        generic_handle_irq(gpio_to_irq(gpio));
+                for_each_bit(offset, &pending, PL061_GPIO_NR)
+                        generic_handle_irq(pl061_to_irq(&chip->gc, offset));
         }
         desc->chip->unmask(irq);
 }
@@ -221,7 +231,7 @@ static int __init pl061_probe(struct amba_device *dev, struct amba_id *id)
         struct pl061_gpio *chip;
         struct list_head *chip_list;
         int ret, irq, i;
-        static unsigned long init_irq[BITS_TO_LONGS(NR_IRQS)];
+        static DECLARE_BITMAP(init_irq, NR_IRQS);
 
         pdata = dev->dev.platform_data;
         if (pdata == NULL)
@@ -251,6 +261,7 @@ static int __init pl061_probe(struct amba_device *dev, struct amba_id *id)
         chip->gc.direction_output = pl061_direction_output;
         chip->gc.get = pl061_get_value;
         chip->gc.set = pl061_set_value;
+        chip->gc.to_irq = pl061_to_irq;
         chip->gc.base = pdata->gpio_base;
         chip->gc.ngpio = PL061_GPIO_NR;
         chip->gc.label = dev_name(&dev->dev);
@@ -280,6 +291,7 @@ static int __init pl061_probe(struct amba_device *dev, struct amba_id *id)
         if (!test_and_set_bit(irq, init_irq)) { /* list initialized? */
                 chip_list = kmalloc(sizeof(*chip_list), GFP_KERNEL);
                 if (chip_list == NULL) {
+                        clear_bit(irq, init_irq);
                         ret = -ENOMEM;
                         goto iounmap;
                 }
diff --git a/drivers/gpio/vr41xx_giu.c b/drivers/gpio/vr41xx_giu.c
new file mode 100644
index 000000000000..b70e06133e78
--- /dev/null
+++ b/drivers/gpio/vr41xx_giu.c
@@ -0,0 +1,586 @@
+/*
+ *  Driver for NEC VR4100 series General-purpose I/O Unit.
+ *
+ *  Copyright (C) 2002 MontaVista Software Inc.
+ *      Author: Yoichi Yuasa <source@mvista.com>
+ *  Copyright (C) 2003-2009  Yoichi Yuasa <yuasa@linux-mips.org>
+ *
+ *  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/errno.h>
+#include <linux/fs.h>
+#include <linux/gpio.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/smp_lock.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include <asm/vr41xx/giu.h>
+#include <asm/vr41xx/irq.h>
+#include <asm/vr41xx/vr41xx.h>
+
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
+MODULE_DESCRIPTION("NEC VR4100 series General-purpose I/O Unit driver");
+MODULE_LICENSE("GPL");
+
+#define GIUIOSELL       0x00
+#define GIUIOSELH       0x02
+#define GIUPIODL        0x04
+#define GIUPIODH        0x06
+#define GIUINTSTATL     0x08
+#define GIUINTSTATH     0x0a
+#define GIUINTENL       0x0c
+#define GIUINTENH       0x0e
+#define GIUINTTYPL      0x10
+#define GIUINTTYPH      0x12
+#define GIUINTALSELL    0x14
+#define GIUINTALSELH    0x16
+#define GIUINTHTSELL    0x18
+#define GIUINTHTSELH    0x1a
+#define GIUPODATL       0x1c
+#define GIUPODATEN      0x1c
+#define GIUPODATH       0x1e
+ #define PIOEN0         0x0100
+ #define PIOEN1         0x0200
+#define GIUPODAT        0x1e
+#define GIUFEDGEINHL    0x20
+#define GIUFEDGEINHH    0x22
+#define GIUREDGEINHL    0x24
+#define GIUREDGEINHH    0x26
+
+#define GIUUSEUPDN      0x1e0
+#define GIUTERMUPDN     0x1e2
+
+#define GPIO_HAS_PULLUPDOWN_IO          0x0001
+#define GPIO_HAS_OUTPUT_ENABLE          0x0002
+#define GPIO_HAS_INTERRUPT_EDGE_SELECT  0x0100
+
+enum {
+        GPIO_INPUT,
+        GPIO_OUTPUT,
+};
+
+static DEFINE_SPINLOCK(giu_lock);
+static unsigned long giu_flags;
+
+static void __iomem *giu_base;
+
+#define giu_read(offset)                readw(giu_base + (offset))
+#define giu_write(offset, value)        writew((value), giu_base + (offset))
+
+#define GPIO_PIN_OF_IRQ(irq)    ((irq) - GIU_IRQ_BASE)
+#define GIUINT_HIGH_OFFSET      16
+#define GIUINT_HIGH_MAX         32
+
+static inline u16 giu_set(u16 offset, u16 set)
+{
+        u16 data;
+
+        data = giu_read(offset);
+        data |= set;
+        giu_write(offset, data);
+
+        return data;
+}
+
+static inline u16 giu_clear(u16 offset, u16 clear)
+{
+        u16 data;
+
+        data = giu_read(offset);
+        data &= ~clear;
+        giu_write(offset, data);
+
+        return data;
+}
+
+static void ack_giuint_low(unsigned int irq)
+{
+        giu_write(GIUINTSTATL, 1 << GPIO_PIN_OF_IRQ(irq));
+}
+
+static void mask_giuint_low(unsigned int irq)
+{
+        giu_clear(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
+}
+
+static void mask_ack_giuint_low(unsigned int irq)
+{
+        unsigned int pin;
+
+        pin = GPIO_PIN_OF_IRQ(irq);
+        giu_clear(GIUINTENL, 1 << pin);
+        giu_write(GIUINTSTATL, 1 << pin);
+}
+
+static void unmask_giuint_low(unsigned int irq)
+{
+        giu_set(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
+}
+
+static struct irq_chip giuint_low_irq_chip = {
+        .name           = "GIUINTL",
+        .ack            = ack_giuint_low,
+        .mask           = mask_giuint_low,
+        .mask_ack       = mask_ack_giuint_low,
+        .unmask         = unmask_giuint_low,
+};
+
+static void ack_giuint_high(unsigned int irq)
+{
+        giu_write(GIUINTSTATH,
+                  1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
+}
+
+static void mask_giuint_high(unsigned int irq)
+{
+        giu_clear(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
+}
+
+static void mask_ack_giuint_high(unsigned int irq)
+{
+        unsigned int pin;
+
+        pin = GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET;
+        giu_clear(GIUINTENH, 1 << pin);
+        giu_write(GIUINTSTATH, 1 << pin);
+}
+
+static void unmask_giuint_high(unsigned int irq)
+{
+        giu_set(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
+}
+
+static struct irq_chip giuint_high_irq_chip = {
+        .name           = "GIUINTH",
+        .ack            = ack_giuint_high,
+        .mask           = mask_giuint_high,
+        .mask_ack       = mask_ack_giuint_high,
+        .unmask         = unmask_giuint_high,
+};
+
+static int giu_get_irq(unsigned int irq)
+{
+        u16 pendl, pendh, maskl, maskh;
+        int i;
+
+        pendl = giu_read(GIUINTSTATL);
+        pendh = giu_read(GIUINTSTATH);
+        maskl = giu_read(GIUINTENL);
+        maskh = giu_read(GIUINTENH);
+
+        maskl &= pendl;
+        maskh &= pendh;
+
+        if (maskl) {
+                for (i = 0; i < 16; i++) {
+                        if (maskl & (1 << i))
+                                return GIU_IRQ(i);
+                }
+        } else if (maskh) {
+                for (i = 0; i < 16; i++) {
+                        if (maskh & (1 << i))
+                                return GIU_IRQ(i + GIUINT_HIGH_OFFSET);
+                }
+        }
+
+        printk(KERN_ERR "spurious GIU interrupt: %04x(%04x),%04x(%04x)\n",
+               maskl, pendl, maskh, pendh);
+
+        atomic_inc(&irq_err_count);
+
+        return -EINVAL;
+}
+
+void vr41xx_set_irq_trigger(unsigned int pin, irq_trigger_t trigger,
+                            irq_signal_t signal)
+{
+        u16 mask;
+
+        if (pin < GIUINT_HIGH_OFFSET) {
+                mask = 1 << pin;
+                if (trigger != IRQ_TRIGGER_LEVEL) {
+                        giu_set(GIUINTTYPL, mask);
+                        if (signal == IRQ_SIGNAL_HOLD)
+                                giu_set(GIUINTHTSELL, mask);
+                        else
+                                giu_clear(GIUINTHTSELL, mask);
+                        if (giu_flags & GPIO_HAS_INTERRUPT_EDGE_SELECT) {
+                                switch (trigger) {
+                                case IRQ_TRIGGER_EDGE_FALLING:
+                                        giu_set(GIUFEDGEINHL, mask);
+                                        giu_clear(GIUREDGEINHL, mask);
+                                        break;
+                                case IRQ_TRIGGER_EDGE_RISING:
+                                        giu_clear(GIUFEDGEINHL, mask);
+                                        giu_set(GIUREDGEINHL, mask);
+                                        break;
+                                default:
+                                        giu_set(GIUFEDGEINHL, mask);
+                                        giu_set(GIUREDGEINHL, mask);
+                                        break;
+                                }
+                        }
+                        set_irq_chip_and_handler(GIU_IRQ(pin),
+                                                 &giuint_low_irq_chip,
+                                                 handle_edge_irq);
+                } else {
+                        giu_clear(GIUINTTYPL, mask);
+                        giu_clear(GIUINTHTSELL, mask);
+                        set_irq_chip_and_handler(GIU_IRQ(pin),
+                                                 &giuint_low_irq_chip,
+                                                 handle_level_irq);
+                }
+                giu_write(GIUINTSTATL, mask);
+        } else if (pin < GIUINT_HIGH_MAX) {
+                mask = 1 << (pin - GIUINT_HIGH_OFFSET);
+                if (trigger != IRQ_TRIGGER_LEVEL) {
+                        giu_set(GIUINTTYPH, mask);
+                        if (signal == IRQ_SIGNAL_HOLD)
+                                giu_set(GIUINTHTSELH, mask);
+                        else
+                                giu_clear(GIUINTHTSELH, mask);
+                        if (giu_flags & GPIO_HAS_INTERRUPT_EDGE_SELECT) {
+                                switch (trigger) {
+                                case IRQ_TRIGGER_EDGE_FALLING:
+                                        giu_set(GIUFEDGEINHH, mask);
+                                        giu_clear(GIUREDGEINHH, mask);
+                                        break;
+                                case IRQ_TRIGGER_EDGE_RISING:
+                                        giu_clear(GIUFEDGEINHH, mask);
+                                        giu_set(GIUREDGEINHH, mask);
+                                        break;
+                                default:
+                                        giu_set(GIUFEDGEINHH, mask);
+                                        giu_set(GIUREDGEINHH, mask);
+                                        break;
+                                }
+                        }
+                        set_irq_chip_and_handler(GIU_IRQ(pin),
+                                                 &giuint_high_irq_chip,
+                                                 handle_edge_irq);
+                } else {
+                        giu_clear(GIUINTTYPH, mask);
+                        giu_clear(GIUINTHTSELH, mask);
+                        set_irq_chip_and_handler(GIU_IRQ(pin),
+                                                 &giuint_high_irq_chip,
+                                                 handle_level_irq);
+                }
+                giu_write(GIUINTSTATH, mask);
+        }
+}
+EXPORT_SYMBOL_GPL(vr41xx_set_irq_trigger);
+
+void vr41xx_set_irq_level(unsigned int pin, irq_level_t level)
+{
+        u16 mask;
+
+        if (pin < GIUINT_HIGH_OFFSET) {
+                mask = 1 << pin;
+                if (level == IRQ_LEVEL_HIGH)
+                        giu_set(GIUINTALSELL, mask);
+                else
+                        giu_clear(GIUINTALSELL, mask);
+                giu_write(GIUINTSTATL, mask);
+        } else if (pin < GIUINT_HIGH_MAX) {
+                mask = 1 << (pin - GIUINT_HIGH_OFFSET);
+                if (level == IRQ_LEVEL_HIGH)
+                        giu_set(GIUINTALSELH, mask);
+                else
+                        giu_clear(GIUINTALSELH, mask);
+                giu_write(GIUINTSTATH, mask);
+        }
+}
+EXPORT_SYMBOL_GPL(vr41xx_set_irq_level);
+
+static int giu_set_direction(struct gpio_chip *chip, unsigned pin, int dir)
+{
+        u16 offset, mask, reg;
+        unsigned long flags;
+
+        if (pin >= chip->ngpio)
+                return -EINVAL;
+
+        if (pin < 16) {
+                offset = GIUIOSELL;
+                mask = 1 << pin;
+        } else if (pin < 32) {
+                offset = GIUIOSELH;
+                mask = 1 << (pin - 16);
+        } else {
+                if (giu_flags & GPIO_HAS_OUTPUT_ENABLE) {
+                        offset = GIUPODATEN;
+                        mask = 1 << (pin - 32);
+                } else {
+                        switch (pin) {
+                        case 48:
+                                offset = GIUPODATH;
+                                mask = PIOEN0;
+                                break;
+                        case 49:
+                                offset = GIUPODATH;
+                                mask = PIOEN1;
+                                break;
+                        default:
+                                return -EINVAL;
+                        }
+                }
+        }
+
+        spin_lock_irqsave(&giu_lock, flags);
+
+        reg = giu_read(offset);
+        if (dir == GPIO_OUTPUT)
+                reg |= mask;
+        else
+                reg &= ~mask;
+        giu_write(offset, reg);
+
+        spin_unlock_irqrestore(&giu_lock, flags);
+
+        return 0;
+}
+
+int vr41xx_gpio_pullupdown(unsigned int pin, gpio_pull_t pull)
+{
+        u16 reg, mask;
+        unsigned long flags;
+
+        if ((giu_flags & GPIO_HAS_PULLUPDOWN_IO) != GPIO_HAS_PULLUPDOWN_IO)
+                return -EPERM;
+
+        if (pin >= 15)
+                return -EINVAL;
+
+        mask = 1 << pin;
+
+        spin_lock_irqsave(&giu_lock, flags);
+
+        if (pull == GPIO_PULL_UP || pull == GPIO_PULL_DOWN) {
+                reg = giu_read(GIUTERMUPDN);
+                if (pull == GPIO_PULL_UP)
+                        reg |= mask;
+                else
+                        reg &= ~mask;
+                giu_write(GIUTERMUPDN, reg);
+
+                reg = giu_read(GIUUSEUPDN);
+                reg |= mask;
+                giu_write(GIUUSEUPDN, reg);
+        } else {
+                reg = giu_read(GIUUSEUPDN);
+                reg &= ~mask;
+                giu_write(GIUUSEUPDN, reg);
+        }
+
+        spin_unlock_irqrestore(&giu_lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(vr41xx_gpio_pullupdown);
+
+static int vr41xx_gpio_get(struct gpio_chip *chip, unsigned pin)
+{
+        u16 reg, mask;
+
+        if (pin >= chip->ngpio)
+                return -EINVAL;
+
+        if (pin < 16) {
+                reg = giu_read(GIUPIODL);
+                mask = 1 << pin;
+        } else if (pin < 32) {
+                reg = giu_read(GIUPIODH);
+                mask = 1 << (pin - 16);
+        } else if (pin < 48) {
+                reg = giu_read(GIUPODATL);
+                mask = 1 << (pin - 32);
+        } else {
+                reg = giu_read(GIUPODATH);
+                mask = 1 << (pin - 48);
+        }
+
+        if (reg & mask)
+                return 1;
+
+        return 0;
+}
+
+static void vr41xx_gpio_set(struct gpio_chip *chip, unsigned pin,
+                            int value)
+{
+        u16 offset, mask, reg;
+        unsigned long flags;
+
+        if (pin >= chip->ngpio)
+                return;
+
+        if (pin < 16) {
+                offset = GIUPIODL;
+                mask = 1 << pin;
+        } else if (pin < 32) {
+                offset = GIUPIODH;
+                mask = 1 << (pin - 16);
+        } else if (pin < 48) {
+                offset = GIUPODATL;
+                mask = 1 << (pin - 32);
+        } else {
+                offset = GIUPODATH;
+                mask = 1 << (pin - 48);
+        }
+
+        spin_lock_irqsave(&giu_lock, flags);
+
+        reg = giu_read(offset);
+        if (value)
+                reg |= mask;
+        else
+                reg &= ~mask;
+        giu_write(offset, reg);
+
+        spin_unlock_irqrestore(&giu_lock, flags);
+}
+
+
+static int vr41xx_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        return giu_set_direction(chip, offset, GPIO_INPUT);
+}
+
+static int vr41xx_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                int value)
+{
+        vr41xx_gpio_set(chip, offset, value);
+
+        return giu_set_direction(chip, offset, GPIO_OUTPUT);
+}
+
+static int vr41xx_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        if (offset >= chip->ngpio)
+                return -EINVAL;
+
+        return GIU_IRQ_BASE + offset;
+}
+
+static struct gpio_chip vr41xx_gpio_chip = {
+        .label                  = "vr41xx",
+        .owner                  = THIS_MODULE,
+        .direction_input        = vr41xx_gpio_direction_input,
+        .get                    = vr41xx_gpio_get,
+        .direction_output       = vr41xx_gpio_direction_output,
+        .set                    = vr41xx_gpio_set,
+        .to_irq                 = vr41xx_gpio_to_irq,
+};
+
+static int __devinit giu_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        unsigned int trigger, i, pin;
+        struct irq_chip *chip;
+        int irq, retval;
+
+        switch (pdev->id) {
+        case GPIO_50PINS_PULLUPDOWN:
+                giu_flags = GPIO_HAS_PULLUPDOWN_IO;
+                vr41xx_gpio_chip.ngpio = 50;
+                break;
+        case GPIO_36PINS:
+                vr41xx_gpio_chip.ngpio = 36;
+                break;
+        case GPIO_48PINS_EDGE_SELECT:
+                giu_flags = GPIO_HAS_INTERRUPT_EDGE_SELECT;
+                vr41xx_gpio_chip.ngpio = 48;
+                break;
+        default:
+                dev_err(&pdev->dev, "GIU: unknown ID %d\n", pdev->id);
+                return -ENODEV;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EBUSY;
+
+        giu_base = ioremap(res->start, res->end - res->start + 1);
+        if (!giu_base)
+                return -ENOMEM;
+
+        vr41xx_gpio_chip.dev = &pdev->dev;
+
+        retval = gpiochip_add(&vr41xx_gpio_chip);
+
+        giu_write(GIUINTENL, 0);
+        giu_write(GIUINTENH, 0);
+
+        trigger = giu_read(GIUINTTYPH) << 16;
+        trigger |= giu_read(GIUINTTYPL);
+        for (i = GIU_IRQ_BASE; i <= GIU_IRQ_LAST; i++) {
+                pin = GPIO_PIN_OF_IRQ(i);
+                if (pin < GIUINT_HIGH_OFFSET)
+                        chip = &giuint_low_irq_chip;
+                else
+                        chip = &giuint_high_irq_chip;
+
+                if (trigger & (1 << pin))
+                        set_irq_chip_and_handler(i, chip, handle_edge_irq);
+                else
+                        set_irq_chip_and_handler(i, chip, handle_level_irq);
+
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0 || irq >= nr_irqs)
+                return -EBUSY;
+
+        return cascade_irq(irq, giu_get_irq);
+}
+
+static int __devexit giu_remove(struct platform_device *pdev)
+{
+        if (giu_base) {
+                iounmap(giu_base);
+                giu_base = NULL;
+        }
+
+        return 0;
+}
+
+static struct platform_driver giu_device_driver = {
+        .probe          = giu_probe,
+        .remove         = __devexit_p(giu_remove),
+        .driver         = {
+                .name   = "GIU",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init vr41xx_giu_init(void)
+{
+        return platform_driver_register(&giu_device_driver);
+}
+
+static void __exit vr41xx_giu_exit(void)
+{
+        platform_driver_unregister(&giu_device_driver);
+}
+
+module_init(vr41xx_giu_init);
+module_exit(vr41xx_giu_exit);
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index c961fe415aef..39b393d38bb3 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -81,6 +81,7 @@ config DRM_I830
 
 config DRM_I915
         tristate "i915 driver"
+        depends on AGP_INTEL
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 4e89ab08b7b8..fe23f29f7cba 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -16,6 +16,7 @@ drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
 drm-$(CONFIG_COMPAT) += drm_ioc32.o
 
 obj-$(CONFIG_DRM)       += drm.o
+obj-$(CONFIG_DRM_TTM)   += ttm/
 obj-$(CONFIG_DRM_TDFX)  += tdfx/
 obj-$(CONFIG_DRM_R128)  += r128/
 obj-$(CONFIG_DRM_RADEON)+= radeon/
@@ -26,4 +27,3 @@ obj-$(CONFIG_DRM_I915)  += i915/
 obj-$(CONFIG_DRM_SIS)   += sis/
 obj-$(CONFIG_DRM_SAVAGE)+= savage/
 obj-$(CONFIG_DRM_VIA)   +=via/
-obj-$(CONFIG_DRM_TTM)   += ttm/
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index a6f73f1e99d9..3da9cfa31848 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -1090,6 +1090,8 @@ int drm_helper_resume_force_mode(struct drm_device *dev)
                 if (ret == false)
                         DRM_ERROR("failed to set mode on crtc %p\n", crtc);
         }
+        /* disable the unused connectors while restoring the modesetting */
+        drm_helper_disable_unused_functions(dev);
         return 0;
 }
 EXPORT_SYMBOL(drm_helper_resume_force_mode);
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 7d0835226f6e..80cc6d06d61b 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -294,10 +294,10 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
         unsigned vactive = (pt->vactive_vblank_hi & 0xf0) << 4 | pt->vactive_lo;
         unsigned hblank = (pt->hactive_hblank_hi & 0xf) << 8 | pt->hblank_lo;
         unsigned vblank = (pt->vactive_vblank_hi & 0xf) << 8 | pt->vblank_lo;
-        unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 8 | pt->hsync_offset_lo;
-        unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) << 6 | pt->hsync_pulse_width_lo;
-        unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) | (pt->vsync_offset_pulse_width_lo & 0xf);
-        unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) >> 2 | pt->vsync_offset_pulse_width_lo >> 4;
+        unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) << 2 | pt->hsync_offset_lo;
+        unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) << 4 | pt->hsync_pulse_width_lo;
+        unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) >> 2 | pt->vsync_offset_pulse_width_lo >> 4;
+        unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 4 | (pt->vsync_offset_pulse_width_lo & 0xf);
 
         /* ignore tiny modes */
         if (hactive < 64 || vactive < 64)
@@ -347,8 +347,8 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
         mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
                 DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
 
-        mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
-        mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
+        mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
+        mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
 
         if (quirks & EDID_QUIRK_DETAILED_IN_CM) {
                 mode->width_mm *= 10;
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 51c5a050aa73..30d6b99fb302 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -13,6 +13,8 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \
           intel_crt.o \
           intel_lvds.o \
           intel_bios.o \
+          intel_dp.o \
+          intel_dp_i2c.o \
           intel_hdmi.o \
           intel_sdvo.o \
           intel_modes.o \
diff --git a/drivers/gpu/drm/i915/dvo.h b/drivers/gpu/drm/i915/dvo.h
index e747ac42fe3a..288fc50627e2 100644
--- a/drivers/gpu/drm/i915/dvo.h
+++ b/drivers/gpu/drm/i915/dvo.h
@@ -37,7 +37,7 @@ struct intel_dvo_device {
         /* GPIO register used for i2c bus to control this device */
         u32 gpio;
         int slave_addr;
-        struct intel_i2c_chan *i2c_bus;
+        struct i2c_adapter *i2c_bus;
 
         const struct intel_dvo_dev_ops *dev_ops;
         void *dev_priv;
@@ -52,7 +52,7 @@ struct intel_dvo_dev_ops {
          * Returns NULL if the device does not exist.
          */
         bool (*init)(struct intel_dvo_device *dvo,
-                     struct intel_i2c_chan *i2cbus);
+                     struct i2c_adapter *i2cbus);
 
         /*
          * Called to allow the output a chance to create properties after the
diff --git a/drivers/gpu/drm/i915/dvo_ch7017.c b/drivers/gpu/drm/i915/dvo_ch7017.c
index 03d4b4973b02..621815b531db 100644
--- a/drivers/gpu/drm/i915/dvo_ch7017.c
+++ b/drivers/gpu/drm/i915/dvo_ch7017.c
@@ -176,19 +176,20 @@ static void ch7017_dpms(struct intel_dvo_device *dvo, int mode);
 
 static bool ch7017_read(struct intel_dvo_device *dvo, int addr, uint8_t *val)
 {
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -208,10 +209,11 @@ static bool ch7017_read(struct intel_dvo_device *dvo, int addr, uint8_t *val)
 
 static bool ch7017_write(struct intel_dvo_device *dvo, int addr, uint8_t val)
 {
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -228,8 +230,9 @@ static bool ch7017_write(struct intel_dvo_device *dvo, int addr, uint8_t val)
 
 /** Probes for a CH7017 on the given bus and slave address. */
 static bool ch7017_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         struct ch7017_priv *priv;
         uint8_t val;
 
@@ -237,8 +240,7 @@ static bool ch7017_init(struct intel_dvo_device *dvo,
         if (priv == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = priv;
 
         if (!ch7017_read(dvo, CH7017_DEVICE_ID, &val))
@@ -248,7 +250,7 @@ static bool ch7017_init(struct intel_dvo_device *dvo,
             val != CH7018_DEVICE_ID_VALUE &&
             val != CH7019_DEVICE_ID_VALUE) {
                 DRM_DEBUG("ch701x not detected, got %d: from %s Slave %d.\n",
-                          val, i2cbus->adapter.name,i2cbus->slave_addr);
+                          val, i2cbus->adapter.name,dvo->slave_addr);
                 goto fail;
         }
 
diff --git a/drivers/gpu/drm/i915/dvo_ch7xxx.c b/drivers/gpu/drm/i915/dvo_ch7xxx.c
index d2fd95dbd034..a9b896289680 100644
--- a/drivers/gpu/drm/i915/dvo_ch7xxx.c
+++ b/drivers/gpu/drm/i915/dvo_ch7xxx.c
@@ -123,19 +123,20 @@ static char *ch7xxx_get_id(uint8_t vid)
 static bool ch7xxx_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 {
         struct ch7xxx_priv *ch7xxx= dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -152,7 +153,7 @@ static bool ch7xxx_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 
         if (!ch7xxx->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -161,10 +162,11 @@ static bool ch7xxx_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 static bool ch7xxx_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 {
         struct ch7xxx_priv *ch7xxx = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -178,14 +180,14 @@ static bool ch7xxx_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
         if (!ch7xxx->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
 }
 
 static bool ch7xxx_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
         /* this will detect the CH7xxx chip on the specified i2c bus */
         struct ch7xxx_priv *ch7xxx;
@@ -196,8 +198,7 @@ static bool ch7xxx_init(struct intel_dvo_device *dvo,
         if (ch7xxx == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = ch7xxx;
         ch7xxx->quiet = true;
 
@@ -207,7 +208,7 @@ static bool ch7xxx_init(struct intel_dvo_device *dvo,
         name = ch7xxx_get_id(vendor);
         if (!name) {
                 DRM_DEBUG("ch7xxx not detected; got 0x%02x from %s slave %d.\n",
-                          vendor, i2cbus->adapter.name, i2cbus->slave_addr);
+                          vendor, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
@@ -217,7 +218,7 @@ static bool ch7xxx_init(struct intel_dvo_device *dvo,
 
         if (device != CH7xxx_DID) {
                 DRM_DEBUG("ch7xxx not detected; got 0x%02x from %s slave %d.\n",
-                          vendor, i2cbus->adapter.name, i2cbus->slave_addr);
+                          vendor, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
diff --git a/drivers/gpu/drm/i915/dvo_ivch.c b/drivers/gpu/drm/i915/dvo_ivch.c
index 0c8d375e8e37..aa176f9921fe 100644
--- a/drivers/gpu/drm/i915/dvo_ivch.c
+++ b/drivers/gpu/drm/i915/dvo_ivch.c
@@ -169,13 +169,14 @@ static void ivch_dump_regs(struct intel_dvo_device *dvo);
 static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
 {
         struct ivch_priv *priv = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[1];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 0,
                 },
@@ -186,7 +187,7 @@ static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD | I2C_M_NOSTART,
                         .len = 2,
                         .buf = in_buf,
@@ -202,7 +203,7 @@ static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
 
         if (!priv->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -211,10 +212,11 @@ static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
 static bool ivch_write(struct intel_dvo_device *dvo, int addr, uint16_t data)
 {
         struct ivch_priv *priv = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[3];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 3,
                 .buf = out_buf,
@@ -229,7 +231,7 @@ static bool ivch_write(struct intel_dvo_device *dvo, int addr, uint16_t data)
 
         if (!priv->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
@@ -237,7 +239,7 @@ static bool ivch_write(struct intel_dvo_device *dvo, int addr, uint16_t data)
 
 /** Probes the given bus and slave address for an ivch */
 static bool ivch_init(struct intel_dvo_device *dvo,
-                      struct intel_i2c_chan *i2cbus)
+                      struct i2c_adapter *adapter)
 {
         struct ivch_priv *priv;
         uint16_t temp;
@@ -246,8 +248,7 @@ static bool ivch_init(struct intel_dvo_device *dvo,
         if (priv == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = priv;
         priv->quiet = true;
 
diff --git a/drivers/gpu/drm/i915/dvo_sil164.c b/drivers/gpu/drm/i915/dvo_sil164.c
index 033a4bb070b2..e1c1f7341e5c 100644
--- a/drivers/gpu/drm/i915/dvo_sil164.c
+++ b/drivers/gpu/drm/i915/dvo_sil164.c
@@ -76,19 +76,20 @@ struct sil164_priv {
 static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 {
         struct sil164_priv *sil = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -105,7 +106,7 @@ static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 
         if (!sil->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -113,10 +114,11 @@ static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 {
         struct sil164_priv *sil= dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -130,7 +132,7 @@ static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
         if (!sil->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
@@ -138,7 +140,7 @@ static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
 /* Silicon Image 164 driver for chip on i2c bus */
 static bool sil164_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
         /* this will detect the SIL164 chip on the specified i2c bus */
         struct sil164_priv *sil;
@@ -148,8 +150,7 @@ static bool sil164_init(struct intel_dvo_device *dvo,
         if (sil == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = sil;
         sil->quiet = true;
 
@@ -158,7 +159,7 @@ static bool sil164_init(struct intel_dvo_device *dvo,
 
         if (ch != (SIL164_VID & 0xff)) {
                 DRM_DEBUG("sil164 not detected got %d: from %s Slave %d.\n",
-                          ch, i2cbus->adapter.name, i2cbus->slave_addr);
+                          ch, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
@@ -167,7 +168,7 @@ static bool sil164_init(struct intel_dvo_device *dvo,
 
         if (ch != (SIL164_DID & 0xff)) {
                 DRM_DEBUG("sil164 not detected got %d: from %s Slave %d.\n",
-                          ch, i2cbus->adapter.name, i2cbus->slave_addr);
+                          ch, adapter->name, dvo->slave_addr);
                 goto out;
         }
         sil->quiet = false;
diff --git a/drivers/gpu/drm/i915/dvo_tfp410.c b/drivers/gpu/drm/i915/dvo_tfp410.c
index 207fda806ebf..9ecc907384ec 100644
--- a/drivers/gpu/drm/i915/dvo_tfp410.c
+++ b/drivers/gpu/drm/i915/dvo_tfp410.c
@@ -101,19 +101,20 @@ struct tfp410_priv {
 static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 {
         struct tfp410_priv *tfp = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -130,7 +131,7 @@ static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 
         if (!tfp->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -138,10 +139,11 @@ static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 static bool tfp410_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 {
         struct tfp410_priv *tfp = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -155,7 +157,7 @@ static bool tfp410_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
         if (!tfp->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
@@ -174,7 +176,7 @@ static int tfp410_getid(struct intel_dvo_device *dvo, int addr)
 
 /* Ti TFP410 driver for chip on i2c bus */
 static bool tfp410_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
         /* this will detect the tfp410 chip on the specified i2c bus */
         struct tfp410_priv *tfp;
@@ -184,20 +186,19 @@ static bool tfp410_init(struct intel_dvo_device *dvo,
         if (tfp == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = tfp;
         tfp->quiet = true;
 
         if ((id = tfp410_getid(dvo, TFP410_VID_LO)) != TFP410_VID) {
                 DRM_DEBUG("tfp410 not detected got VID %X: from %s Slave %d.\n",
-                          id, i2cbus->adapter.name, i2cbus->slave_addr);
+                          id, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
         if ((id = tfp410_getid(dvo, TFP410_DID_LO)) != TFP410_DID) {
                 DRM_DEBUG("tfp410 not detected got DID %X: from %s Slave %d.\n",
-                          id, i2cbus->adapter.name, i2cbus->slave_addr);
+                          id, adapter->name, dvo->slave_addr);
                 goto out;
         }
         tfp->quiet = false;
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index f112c769d533..8c4783180bf6 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -846,7 +846,7 @@ static int i915_set_status_page(struct drm_device *dev, void *data,
                 return 0;
         }
 
-        printk(KERN_DEBUG "set status page addr 0x%08x\n", (u32)hws->addr);
+        DRM_DEBUG("set status page addr 0x%08x\n", (u32)hws->addr);
 
         dev_priv->status_gfx_addr = hws->addr & (0x1ffff<<12);
 
@@ -885,8 +885,8 @@ static int i915_set_status_page(struct drm_device *dev, void *data,
  * some RAM for the framebuffer at early boot.  This code figures out
  * how much was set aside so we can use it for our own purposes.
  */
-static int i915_probe_agp(struct drm_device *dev, unsigned long *aperture_size,
-                          unsigned long *preallocated_size)
+static int i915_probe_agp(struct drm_device *dev, uint32_t *aperture_size,
+                          uint32_t *preallocated_size)
 {
         struct pci_dev *bridge_dev;
         u16 tmp = 0;
@@ -984,10 +984,11 @@ static int i915_probe_agp(struct drm_device *dev, unsigned long *aperture_size,
         return 0;
 }
 
-static int i915_load_modeset_init(struct drm_device *dev)
+static int i915_load_modeset_init(struct drm_device *dev,
+                                  unsigned long prealloc_size,
+                                  unsigned long agp_size)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        unsigned long agp_size, prealloc_size;
         int fb_bar = IS_I9XX(dev) ? 2 : 0;
         int ret = 0;
 
@@ -1002,10 +1003,6 @@ static int i915_load_modeset_init(struct drm_device *dev)
         if (IS_I965G(dev) || IS_G33(dev))
                 dev_priv->cursor_needs_physical = false;
 
-        ret = i915_probe_agp(dev, &agp_size, &prealloc_size);
-        if (ret)
-                goto out;
-
         /* Basic memrange allocator for stolen space (aka vram) */
         drm_mm_init(&dev_priv->vram, 0, prealloc_size);
 
@@ -1082,6 +1079,44 @@ void i915_master_destroy(struct drm_device *dev, struct drm_master *master)
         master->driver_priv = NULL;
 }
 
+static void i915_get_mem_freq(struct drm_device *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        u32 tmp;
+
+        if (!IS_IGD(dev))
+                return;
+
+        tmp = I915_READ(CLKCFG);
+
+        switch (tmp & CLKCFG_FSB_MASK) {
+        case CLKCFG_FSB_533:
+                dev_priv->fsb_freq = 533; /* 133*4 */
+                break;
+        case CLKCFG_FSB_800:
+                dev_priv->fsb_freq = 800; /* 200*4 */
+                break;
+        case CLKCFG_FSB_667:
+                dev_priv->fsb_freq =  667; /* 167*4 */
+                break;
+        case CLKCFG_FSB_400:
+                dev_priv->fsb_freq = 400; /* 100*4 */
+                break;
+        }
+
+        switch (tmp & CLKCFG_MEM_MASK) {
+        case CLKCFG_MEM_533:
+                dev_priv->mem_freq = 533;
+                break;
+        case CLKCFG_MEM_667:
+                dev_priv->mem_freq = 667;
+                break;
+        case CLKCFG_MEM_800:
+                dev_priv->mem_freq = 800;
+                break;
+        }
+}
+
 /**
  * i915_driver_load - setup chip and create an initial config
  * @dev: DRM device
@@ -1098,6 +1133,7 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         struct drm_i915_private *dev_priv = dev->dev_private;
         resource_size_t base, size;
         int ret = 0, mmio_bar = IS_I9XX(dev) ? 0 : 1;
+        uint32_t agp_size, prealloc_size;
 
         /* i915 has 4 more counters */
         dev->counters += 4;
@@ -1146,9 +1182,22 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                          "performance may suffer.\n");
         }
 
+        ret = i915_probe_agp(dev, &agp_size, &prealloc_size);
+        if (ret)
+                goto out_iomapfree;
+
         /* enable GEM by default */
         dev_priv->has_gem = 1;
 
+        if (prealloc_size > agp_size * 3 / 4) {
+                DRM_ERROR("Detected broken video BIOS with %d/%dkB of video "
+                          "memory stolen.\n",
+                          prealloc_size / 1024, agp_size / 1024);
+                DRM_ERROR("Disabling GEM. (try reducing stolen memory or "
+                          "updating the BIOS to fix).\n");
+                dev_priv->has_gem = 0;
+        }
+
         dev->driver->get_vblank_counter = i915_get_vblank_counter;
         dev->max_vblank_count = 0xffffff; /* only 24 bits of frame count */
         if (IS_G4X(dev) || IS_IGDNG(dev)) {
@@ -1165,6 +1214,8 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                         goto out_iomapfree;
         }
 
+        i915_get_mem_freq(dev);
+
         /* On the 945G/GM, the chipset reports the MSI capability on the
          * integrated graphics even though the support isn't actually there
          * according to the published specs.  It doesn't appear to function
@@ -1180,6 +1231,7 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 pci_enable_msi(dev->pdev);
 
         spin_lock_init(&dev_priv->user_irq_lock);
+        spin_lock_init(&dev_priv->error_lock);
         dev_priv->user_irq_refcount = 0;
 
         ret = drm_vblank_init(dev, I915_NUM_PIPE);
@@ -1190,7 +1242,7 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         }
 
         if (drm_core_check_feature(dev, DRIVER_MODESET)) {
-                ret = i915_load_modeset_init(dev);
+                ret = i915_load_modeset_init(dev, prealloc_size, agp_size);
                 if (ret < 0) {
                         DRM_ERROR("failed to init modeset\n");
                         goto out_rmmap;
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 98560e1e899a..fc4b68aa2d05 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -35,6 +35,7 @@
 
 #include "drm_pciids.h"
 #include <linux/console.h>
+#include "drm_crtc_helper.h"
 
 static unsigned int i915_modeset = -1;
 module_param_named(modeset, i915_modeset, int, 0400);
@@ -57,8 +58,8 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
         struct drm_i915_private *dev_priv = dev->dev_private;
 
         if (!dev || !dev_priv) {
-                printk(KERN_ERR "dev: %p, dev_priv: %p\n", dev, dev_priv);
-                printk(KERN_ERR "DRM not initialized, aborting suspend.\n");
+                DRM_ERROR("dev: %p, dev_priv: %p\n", dev, dev_priv);
+                DRM_ERROR("DRM not initialized, aborting suspend.\n");
                 return -ENODEV;
         }
 
@@ -67,8 +68,6 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
 
         pci_save_state(dev->pdev);
 
-        i915_save_state(dev);
-
         /* If KMS is active, we do the leavevt stuff here */
         if (drm_core_check_feature(dev, DRIVER_MODESET)) {
                 if (i915_gem_idle(dev))
@@ -77,6 +76,8 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
                 drm_irq_uninstall(dev);
         }
 
+        i915_save_state(dev);
+
         intel_opregion_free(dev, 1);
 
         if (state.event == PM_EVENT_SUSPEND) {
@@ -115,6 +116,10 @@ static int i915_resume(struct drm_device *dev)
 
                 drm_irq_install(dev);
         }
+        if (drm_core_check_feature(dev, DRIVER_MODESET)) {
+                /* Resume the modeset for every activated CRTC */
+                drm_helper_resume_force_mode(dev);
+        }
 
         return ret;
 }
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 7a84f04e8439..d08752875885 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -133,6 +133,22 @@ struct sdvo_device_mapping {
         u8 initialized;
 };
 
+struct drm_i915_error_state {
+        u32 eir;
+        u32 pgtbl_er;
+        u32 pipeastat;
+        u32 pipebstat;
+        u32 ipeir;
+        u32 ipehr;
+        u32 instdone;
+        u32 acthd;
+        u32 instpm;
+        u32 instps;
+        u32 instdone1;
+        u32 seqno;
+        struct timeval time;
+};
+
 typedef struct drm_i915_private {
         struct drm_device *dev;
 
@@ -209,6 +225,11 @@ typedef struct drm_i915_private {
         int fence_reg_start; /* 4 if userland hasn't ioctl'd us yet */
         int num_fence_regs; /* 8 on pre-965, 16 otherwise */
 
+        unsigned int fsb_freq, mem_freq;
+
+        spinlock_t error_lock;
+        struct drm_i915_error_state *first_error;
+
         /* Register state */
         u8 saveLBB;
         u32 saveDSPACNTR;
@@ -306,6 +327,17 @@ typedef struct drm_i915_private {
         u32 saveCURBPOS;
         u32 saveCURBBASE;
         u32 saveCURSIZE;
+        u32 saveDP_B;
+        u32 saveDP_C;
+        u32 saveDP_D;
+        u32 savePIPEA_GMCH_DATA_M;
+        u32 savePIPEB_GMCH_DATA_M;
+        u32 savePIPEA_GMCH_DATA_N;
+        u32 savePIPEB_GMCH_DATA_N;
+        u32 savePIPEA_DP_LINK_M;
+        u32 savePIPEB_DP_LINK_M;
+        u32 savePIPEA_DP_LINK_N;
+        u32 savePIPEB_DP_LINK_N;
 
         struct {
                 struct drm_mm gtt_space;
@@ -457,9 +489,6 @@ struct drm_i915_gem_object {
          */
         int fence_reg;
 
-        /** Boolean whether this object has a valid gtt offset. */
-        int gtt_bound;
-
         /** How many users have pinned this object in GTT space */
         int pin_count;
 
@@ -644,6 +673,7 @@ void i915_gem_free_object(struct drm_gem_object *obj);
 int i915_gem_object_pin(struct drm_gem_object *obj, uint32_t alignment);
 void i915_gem_object_unpin(struct drm_gem_object *obj);
 int i915_gem_object_unbind(struct drm_gem_object *obj);
+void i915_gem_release_mmap(struct drm_gem_object *obj);
 void i915_gem_lastclose(struct drm_device *dev);
 uint32_t i915_get_gem_seqno(struct drm_device *dev);
 int i915_gem_object_get_fence_reg(struct drm_gem_object *obj);
@@ -857,7 +887,10 @@ extern int i915_wait_ring(struct drm_device * dev, int n, const char *caller);
 #define HAS_128_BYTE_Y_TILING(dev) (IS_I9XX(dev) && !(IS_I915G(dev) || \
                                                       IS_I915GM(dev)))
 #define SUPPORTS_INTEGRATED_HDMI(dev)   (IS_G4X(dev) || IS_IGDNG(dev))
+#define SUPPORTS_INTEGRATED_DP(dev)     (IS_G4X(dev) || IS_IGDNG(dev))
 #define I915_HAS_HOTPLUG(dev) (IS_I945G(dev) || IS_I945GM(dev) || IS_I965G(dev))
+/* dsparb controlled by hw only */
+#define DSPARB_HWCONTROL(dev) (IS_G4X(dev) || IS_IGDNG(dev))
 
 #define PRIMARY_RINGBUFFER_SIZE         (128*1024)
 
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index fd2b8bdffe3f..5bf420378b6d 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -1006,7 +1006,7 @@ i915_gem_set_domain_ioctl(struct drm_device *dev, void *data,
 
         mutex_lock(&dev->struct_mutex);
 #if WATCH_BUF
-        DRM_INFO("set_domain_ioctl %p(%d), %08x %08x\n",
+        DRM_INFO("set_domain_ioctl %p(%zd), %08x %08x\n",
                  obj, obj->size, read_domains, write_domain);
 #endif
         if (read_domains & I915_GEM_DOMAIN_GTT) {
@@ -1050,7 +1050,7 @@ i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data,
         }
 
 #if WATCH_BUF
-        DRM_INFO("%s: sw_finish %d (%p %d)\n",
+        DRM_INFO("%s: sw_finish %d (%p %zd)\n",
                  __func__, args->handle, obj, obj->size);
 #endif
         obj_priv = obj->driver_private;
@@ -1252,6 +1252,31 @@ out_free_list:
         return ret;
 }
 
+/**
+ * i915_gem_release_mmap - remove physical page mappings
+ * @obj: obj in question
+ *
+ * Preserve the reservation of the mmaping with the DRM core code, but
+ * relinquish ownership of the pages back to the system.
+ *
+ * It is vital that we remove the page mapping if we have mapped a tiled
+ * object through the GTT and then lose the fence register due to
+ * resource pressure. Similarly if the object has been moved out of the
+ * aperture, than pages mapped into userspace must be revoked. Removing the
+ * mapping will then trigger a page fault on the next user access, allowing
+ * fixup by i915_gem_fault().
+ */
+void
+i915_gem_release_mmap(struct drm_gem_object *obj)
+{
+        struct drm_device *dev = obj->dev;
+        struct drm_i915_gem_object *obj_priv = obj->driver_private;
+
+        if (dev->dev_mapping)
+                unmap_mapping_range(dev->dev_mapping,
+                                    obj_priv->mmap_offset, obj->size, 1);
+}
+
 static void
 i915_gem_free_mmap_offset(struct drm_gem_object *obj)
 {
@@ -1861,7 +1886,6 @@ i915_gem_object_unbind(struct drm_gem_object *obj)
 {
         struct drm_device *dev = obj->dev;
         struct drm_i915_gem_object *obj_priv = obj->driver_private;
-        loff_t offset;
         int ret = 0;
 
 #if WATCH_BUF
@@ -1898,9 +1922,7 @@ i915_gem_object_unbind(struct drm_gem_object *obj)
         BUG_ON(obj_priv->active);
 
         /* blow away mappings if mapped through GTT */
-        offset = ((loff_t) obj->map_list.hash.key) << PAGE_SHIFT;
-        if (dev->dev_mapping)
-                unmap_mapping_range(dev->dev_mapping, offset, obj->size, 1);
+        i915_gem_release_mmap(obj);
 
         if (obj_priv->fence_reg != I915_FENCE_REG_NONE)
                 i915_gem_clear_fence_reg(obj);
@@ -2222,7 +2244,6 @@ try_again:
         /* None available, try to steal one or wait for a user to finish */
         if (i == dev_priv->num_fence_regs) {
                 uint32_t seqno = dev_priv->mm.next_gem_seqno;
-                loff_t offset;
 
                 if (avail == 0)
                         return -ENOSPC;
@@ -2274,10 +2295,7 @@ try_again:
                  * Zap this virtual mapping so we can set up a fence again
                  * for this object next time we need it.
                  */
-                offset = ((loff_t) reg->obj->map_list.hash.key) << PAGE_SHIFT;
-                if (dev->dev_mapping)
-                        unmap_mapping_range(dev->dev_mapping, offset,
-                                            reg->obj->size, 1);
+                i915_gem_release_mmap(reg->obj);
                 old_obj_priv->fence_reg = I915_FENCE_REG_NONE;
         }
 
@@ -2423,7 +2441,7 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
         }
 
 #if WATCH_BUF
-        DRM_INFO("Binding object of size %d at 0x%08x\n",
+        DRM_INFO("Binding object of size %zd at 0x%08x\n",
                  obj->size, obj_priv->gtt_offset);
 #endif
         ret = i915_gem_object_get_pages(obj);
@@ -4227,6 +4245,7 @@ i915_gem_lastclose(struct drm_device *dev)
 void
 i915_gem_load(struct drm_device *dev)
 {
+        int i;
         drm_i915_private_t *dev_priv = dev->dev_private;
 
         spin_lock_init(&dev_priv->mm.active_list_lock);
@@ -4246,6 +4265,18 @@ i915_gem_load(struct drm_device *dev)
         else
                 dev_priv->num_fence_regs = 8;
 
+        /* Initialize fence registers to zero */
+        if (IS_I965G(dev)) {
+                for (i = 0; i < 16; i++)
+                        I915_WRITE64(FENCE_REG_965_0 + (i * 8), 0);
+        } else {
+                for (i = 0; i < 8; i++)
+                        I915_WRITE(FENCE_REG_830_0 + (i * 4), 0);
+                if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev))
+                        for (i = 0; i < 8; i++)
+                                I915_WRITE(FENCE_REG_945_8 + (i * 4), 0);
+        }
+
         i915_gem_detect_bit_6_swizzle(dev);
 }
 
diff --git a/drivers/gpu/drm/i915/i915_gem_debug.c b/drivers/gpu/drm/i915/i915_gem_debug.c
index 8d0b943e2c5a..e602614bd3f8 100644
--- a/drivers/gpu/drm/i915/i915_gem_debug.c
+++ b/drivers/gpu/drm/i915/i915_gem_debug.c
@@ -87,7 +87,7 @@ i915_gem_dump_object(struct drm_gem_object *obj, int len,
                         chunk_len = page_len - chunk;
                         if (chunk_len > 128)
                                 chunk_len = 128;
-                        i915_gem_dump_page(obj_priv->page_list[page],
+                        i915_gem_dump_page(obj_priv->pages[page],
                                            chunk, chunk + chunk_len,
                                            obj_priv->gtt_offset +
                                            page * PAGE_SIZE,
@@ -143,7 +143,7 @@ i915_gem_object_check_coherency(struct drm_gem_object *obj, int handle)
         uint32_t *backing_map = NULL;
         int bad_count = 0;
 
-        DRM_INFO("%s: checking coherency of object %p@0x%08x (%d, %dkb):\n",
+        DRM_INFO("%s: checking coherency of object %p@0x%08x (%d, %zdkb):\n",
                  __func__, obj, obj_priv->gtt_offset, handle,
                  obj->size / 1024);
 
@@ -157,7 +157,7 @@ i915_gem_object_check_coherency(struct drm_gem_object *obj, int handle)
         for (page = 0; page < obj->size / PAGE_SIZE; page++) {
                 int i;
 
-                backing_map = kmap_atomic(obj_priv->page_list[page], KM_USER0);
+                backing_map = kmap_atomic(obj_priv->pages[page], KM_USER0);
 
                 if (backing_map == NULL) {
                         DRM_ERROR("failed to map backing page\n");
diff --git a/drivers/gpu/drm/i915/i915_gem_debugfs.c b/drivers/gpu/drm/i915/i915_gem_debugfs.c
index 28146e405e87..9a44bfcb8139 100644
--- a/drivers/gpu/drm/i915/i915_gem_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_gem_debugfs.c
@@ -75,11 +75,10 @@ static int i915_gem_object_list_info(struct seq_file *m, void *data)
         case ACTIVE_LIST:
                 seq_printf(m, "Active:\n");
                 lock = &dev_priv->mm.active_list_lock;
-                spin_lock(lock);
                 head = &dev_priv->mm.active_list;
                 break;
         case INACTIVE_LIST:
-                seq_printf(m, "Inctive:\n");
+                seq_printf(m, "Inactive:\n");
                 head = &dev_priv->mm.inactive_list;
                 break;
         case FLUSHING_LIST:
@@ -91,6 +90,8 @@ static int i915_gem_object_list_info(struct seq_file *m, void *data)
                 return 0;
         }
 
+        if (lock)
+                spin_lock(lock);
         list_for_each_entry(obj_priv, head, list)
         {
                 struct drm_gem_object *obj = obj_priv->obj;
@@ -104,7 +105,10 @@ static int i915_gem_object_list_info(struct seq_file *m, void *data)
                 if (obj->name)
                         seq_printf(m, " (name: %d)", obj->name);
                 if (obj_priv->fence_reg != I915_FENCE_REG_NONE)
-                        seq_printf(m, " (fence: %d)\n", obj_priv->fence_reg);
+                        seq_printf(m, " (fence: %d)", obj_priv->fence_reg);
+                if (obj_priv->gtt_space != NULL)
+                        seq_printf(m, " (gtt_offset: %08x)", obj_priv->gtt_offset);
+
                 seq_printf(m, "\n");
         }
 
@@ -323,6 +327,39 @@ static int i915_ringbuffer_info(struct seq_file *m, void *data)
         return 0;
 }
 
+static int i915_error_state(struct seq_file *m, void *unused)
+{
+        struct drm_info_node *node = (struct drm_info_node *) m->private;
+        struct drm_device *dev = node->minor->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_i915_error_state *error;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev_priv->error_lock, flags);
+        if (!dev_priv->first_error) {
+                seq_printf(m, "no error state collected\n");
+                goto out;
+        }
+
+        error = dev_priv->first_error;
+
+        seq_printf(m, "EIR: 0x%08x\n", error->eir);
+        seq_printf(m, "  PGTBL_ER: 0x%08x\n", error->pgtbl_er);
+        seq_printf(m, "  INSTPM: 0x%08x\n", error->instpm);
+        seq_printf(m, "  IPEIR: 0x%08x\n", error->ipeir);
+        seq_printf(m, "  IPEHR: 0x%08x\n", error->ipehr);
+        seq_printf(m, "  INSTDONE: 0x%08x\n", error->instdone);
+        seq_printf(m, "  ACTHD: 0x%08x\n", error->acthd);
+        if (IS_I965G(dev)) {
+                seq_printf(m, "  INSTPS: 0x%08x\n", error->instps);
+                seq_printf(m, "  INSTDONE1: 0x%08x\n", error->instdone1);
+        }
+
+out:
+        spin_unlock_irqrestore(&dev_priv->error_lock, flags);
+
+        return 0;
+}
 
 static struct drm_info_list i915_gem_debugfs_list[] = {
         {"i915_gem_active", i915_gem_object_list_info, 0, (void *) ACTIVE_LIST},
@@ -336,6 +373,7 @@ static struct drm_info_list i915_gem_debugfs_list[] = {
         {"i915_ringbuffer_data", i915_ringbuffer_data, 0},
         {"i915_ringbuffer_info", i915_ringbuffer_info, 0},
         {"i915_batchbuffers", i915_batchbuffer_info, 0},
+        {"i915_error_state", i915_error_state, 0},
 };
 #define I915_GEM_DEBUGFS_ENTRIES ARRAY_SIZE(i915_gem_debugfs_list)
 
diff --git a/drivers/gpu/drm/i915/i915_gem_tiling.c b/drivers/gpu/drm/i915/i915_gem_tiling.c
index 5c1ceec49f5b..a2d527b22ec4 100644
--- a/drivers/gpu/drm/i915/i915_gem_tiling.c
+++ b/drivers/gpu/drm/i915/i915_gem_tiling.c
@@ -114,11 +114,13 @@ intel_alloc_mchbar_resource(struct drm_device *dev)
         mchbar_addr = ((u64)temp_hi << 32) | temp_lo;
 
         /* If ACPI doesn't have it, assume we need to allocate it ourselves */
+#ifdef CONFIG_PNP
         if (mchbar_addr &&
             pnp_range_reserved(mchbar_addr, mchbar_addr + MCHBAR_SIZE)) {
                 ret = 0;
                 goto out_put;
         }
+#endif
 
         /* Get some space for it */
         ret = pci_bus_alloc_resource(bridge_dev->bus, &dev_priv->mch_res,
@@ -519,6 +521,12 @@ i915_gem_set_tiling(struct drm_device *dev, void *data,
                         goto err;
                 }
 
+                /* If we've changed tiling, GTT-mappings of the object
+                 * need to re-fault to ensure that the correct fence register
+                 * setup is in place.
+                 */
+                i915_gem_release_mmap(obj);
+
                 obj_priv->tiling_mode = args->tiling_mode;
                 obj_priv->stride = args->stride;
         }
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index b86b7b7130c6..7ba23a69a0c0 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -26,6 +26,7 @@
  *
  */
 
+#include <linux/sysrq.h>
 #include "drmP.h"
 #include "drm.h"
 #include "i915_drm.h"
@@ -41,9 +42,10 @@
  * we leave them always unmasked in IMR and then control enabling them through
  * PIPESTAT alone.
  */
-#define I915_INTERRUPT_ENABLE_FIX (I915_ASLE_INTERRUPT | \
-                                   I915_DISPLAY_PIPE_A_EVENT_INTERRUPT |  \
-                                   I915_DISPLAY_PIPE_B_EVENT_INTERRUPT)
+#define I915_INTERRUPT_ENABLE_FIX (I915_ASLE_INTERRUPT |                 \
+                                   I915_DISPLAY_PIPE_A_EVENT_INTERRUPT | \
+                                   I915_DISPLAY_PIPE_B_EVENT_INTERRUPT | \
+                                   I915_RENDER_COMMAND_PARSER_ERROR_INTERRUPT)
 
 /** Interrupts that we mask and unmask at runtime. */
 #define I915_INTERRUPT_ENABLE_VAR (I915_USER_INTERRUPT)
@@ -232,7 +234,17 @@ static void i915_hotplug_work_func(struct work_struct *work)
         drm_i915_private_t *dev_priv = container_of(work, drm_i915_private_t,
                                                     hotplug_work);
         struct drm_device *dev = dev_priv->dev;
-
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_connector *connector;
+
+        if (mode_config->num_connector) {
+                list_for_each_entry(connector, &mode_config->connector_list, head) {
+                        struct intel_output *intel_output = to_intel_output(connector);
+        
+                        if (intel_output->hot_plug)
+                                (*intel_output->hot_plug) (intel_output);
+                }
+        }
         /* Just fire off a uevent and let userspace tell us what to do */
         drm_sysfs_hotplug_event(dev);
 }
@@ -278,6 +290,47 @@ irqreturn_t igdng_irq_handler(struct drm_device *dev)
         return ret;
 }
 
+static void i915_capture_error_state(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_i915_error_state *error;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev_priv->error_lock, flags);
+        if (dev_priv->first_error)
+                goto out;
+
+        error = kmalloc(sizeof(*error), GFP_ATOMIC);
+        if (!error) {
+                DRM_DEBUG("out ot memory, not capturing error state\n");
+                goto out;
+        }
+
+        error->eir = I915_READ(EIR);
+        error->pgtbl_er = I915_READ(PGTBL_ER);
+        error->pipeastat = I915_READ(PIPEASTAT);
+        error->pipebstat = I915_READ(PIPEBSTAT);
+        error->instpm = I915_READ(INSTPM);
+        if (!IS_I965G(dev)) {
+                error->ipeir = I915_READ(IPEIR);
+                error->ipehr = I915_READ(IPEHR);
+                error->instdone = I915_READ(INSTDONE);
+                error->acthd = I915_READ(ACTHD);
+        } else {
+                error->ipeir = I915_READ(IPEIR_I965);
+                error->ipehr = I915_READ(IPEHR_I965);
+                error->instdone = I915_READ(INSTDONE_I965);
+                error->instps = I915_READ(INSTPS);
+                error->instdone1 = I915_READ(INSTDONE1);
+                error->acthd = I915_READ(ACTHD_I965);
+        }
+
+        dev_priv->first_error = error;
+
+out:
+        spin_unlock_irqrestore(&dev_priv->error_lock, flags);
+}
+
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
         struct drm_device *dev = (struct drm_device *) arg;
@@ -323,11 +376,15 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
                  * Clear the PIPE(A|B)STAT regs before the IIR
                  */
                 if (pipea_stats & 0x8000ffff) {
+                        if (pipea_stats &  PIPE_FIFO_UNDERRUN_STATUS)
+                                DRM_DEBUG("pipe a underrun\n");
                         I915_WRITE(PIPEASTAT, pipea_stats);
                         irq_received = 1;
                 }
 
                 if (pipeb_stats & 0x8000ffff) {
+                        if (pipeb_stats &  PIPE_FIFO_UNDERRUN_STATUS)
+                                DRM_DEBUG("pipe b underrun\n");
                         I915_WRITE(PIPEBSTAT, pipeb_stats);
                         irq_received = 1;
                 }
@@ -352,6 +409,80 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
                         I915_READ(PORT_HOTPLUG_STAT);
                 }
 
+                if (iir & I915_RENDER_COMMAND_PARSER_ERROR_INTERRUPT) {
+                        u32 eir = I915_READ(EIR);
+
+                        i915_capture_error_state(dev);
+
+                        printk(KERN_ERR "render error detected, EIR: 0x%08x\n",
+                               eir);
+                        if (eir & I915_ERROR_PAGE_TABLE) {
+                                u32 pgtbl_err = I915_READ(PGTBL_ER);
+                                printk(KERN_ERR "page table error\n");
+                                printk(KERN_ERR "  PGTBL_ER: 0x%08x\n",
+                                       pgtbl_err);
+                                I915_WRITE(PGTBL_ER, pgtbl_err);
+                                (void)I915_READ(PGTBL_ER);
+                        }
+                        if (eir & I915_ERROR_MEMORY_REFRESH) {
+                                printk(KERN_ERR "memory refresh error\n");
+                                printk(KERN_ERR "PIPEASTAT: 0x%08x\n",
+                                       pipea_stats);
+                                printk(KERN_ERR "PIPEBSTAT: 0x%08x\n",
+                                       pipeb_stats);
+                                /* pipestat has already been acked */
+                        }
+                        if (eir & I915_ERROR_INSTRUCTION) {
+                                printk(KERN_ERR "instruction error\n");
+                                printk(KERN_ERR "  INSTPM: 0x%08x\n",
+                                       I915_READ(INSTPM));
+                                if (!IS_I965G(dev)) {
+                                        u32 ipeir = I915_READ(IPEIR);
+
+                                        printk(KERN_ERR "  IPEIR: 0x%08x\n",
+                                               I915_READ(IPEIR));
+                                        printk(KERN_ERR "  IPEHR: 0x%08x\n",
+                                                   I915_READ(IPEHR));
+                                        printk(KERN_ERR "  INSTDONE: 0x%08x\n",
+                                                   I915_READ(INSTDONE));
+                                        printk(KERN_ERR "  ACTHD: 0x%08x\n",
+                                                   I915_READ(ACTHD));
+                                        I915_WRITE(IPEIR, ipeir);
+                                        (void)I915_READ(IPEIR);
+                                } else {
+                                        u32 ipeir = I915_READ(IPEIR_I965);
+
+                                        printk(KERN_ERR "  IPEIR: 0x%08x\n",
+                                               I915_READ(IPEIR_I965));
+                                        printk(KERN_ERR "  IPEHR: 0x%08x\n",
+                                               I915_READ(IPEHR_I965));
+                                        printk(KERN_ERR "  INSTDONE: 0x%08x\n",
+                                               I915_READ(INSTDONE_I965));
+                                        printk(KERN_ERR "  INSTPS: 0x%08x\n",
+                                               I915_READ(INSTPS));
+                                        printk(KERN_ERR "  INSTDONE1: 0x%08x\n",
+                                               I915_READ(INSTDONE1));
+                                        printk(KERN_ERR "  ACTHD: 0x%08x\n",
+                                               I915_READ(ACTHD_I965));
+                                        I915_WRITE(IPEIR_I965, ipeir);
+                                        (void)I915_READ(IPEIR_I965);
+                                }
+                        }
+
+                        I915_WRITE(EIR, eir);
+                        (void)I915_READ(EIR);
+                        eir = I915_READ(EIR);
+                        if (eir) {
+                                /*
+                                 * some errors might have become stuck,
+                                 * mask them.
+                                 */
+                                DRM_ERROR("EIR stuck: 0x%08x, masking\n", eir);
+                                I915_WRITE(EMR, I915_READ(EMR) | eir);
+                                I915_WRITE(IIR, I915_RENDER_COMMAND_PARSER_ERROR_INTERRUPT);
+                        }
+                }
+
                 I915_WRITE(IIR, iir);
                 new_iir = I915_READ(IIR); /* Flush posted writes */
 
@@ -722,6 +853,7 @@ int i915_driver_irq_postinstall(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         u32 enable_mask = I915_INTERRUPT_ENABLE_FIX | I915_INTERRUPT_ENABLE_VAR;
+        u32 error_mask;
 
         DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
 
@@ -758,6 +890,21 @@ int i915_driver_irq_postinstall(struct drm_device *dev)
                 i915_enable_irq(dev_priv, I915_DISPLAY_PORT_INTERRUPT);
         }
 
+        /*
+         * Enable some error detection, note the instruction error mask
+         * bit is reserved, so we leave it masked.
+         */
+        if (IS_G4X(dev)) {
+                error_mask = ~(GM45_ERROR_PAGE_TABLE |
+                               GM45_ERROR_MEM_PRIV |
+                               GM45_ERROR_CP_PRIV |
+                               I915_ERROR_MEMORY_REFRESH);
+        } else {
+                error_mask = ~(I915_ERROR_PAGE_TABLE |
+                               I915_ERROR_MEMORY_REFRESH);
+        }
+        I915_WRITE(EMR, error_mask);
+
         /* Disable pipe interrupt enables, clear pending pipe status */
         I915_WRITE(PIPEASTAT, I915_READ(PIPEASTAT) & 0x8000ffff);
         I915_WRITE(PIPEBSTAT, I915_READ(PIPEBSTAT) & 0x8000ffff);
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index f6237a0b1133..6c0858484094 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -206,6 +206,7 @@
 /*
  * Instruction and interrupt control regs
  */
+#define PGTBL_ER        0x02024
 #define PRB0_TAIL       0x02030
 #define PRB0_HEAD       0x02034
 #define PRB0_START      0x02038
@@ -226,11 +227,18 @@
 #define PRB1_HEAD       0x02044 /* 915+ only */
 #define PRB1_START      0x02048 /* 915+ only */
 #define PRB1_CTL        0x0204c /* 915+ only */
+#define IPEIR_I965      0x02064
+#define IPEHR_I965      0x02068
+#define INSTDONE_I965   0x0206c
+#define INSTPS          0x02070 /* 965+ only */
+#define INSTDONE1       0x0207c /* 965+ only */
 #define ACTHD_I965      0x02074
 #define HWS_PGA         0x02080
 #define HWS_ADDRESS_MASK        0xfffff000
 #define HWS_START_ADDRESS_SHIFT 4
 #define IPEIR           0x02088
+#define IPEHR           0x0208c
+#define INSTDONE        0x02090
 #define NOPID           0x02094
 #define HWSTAM          0x02098
 #define SCPD0           0x0209c /* 915+ only */
@@ -258,10 +266,22 @@
 #define EIR             0x020b0
 #define EMR             0x020b4
 #define ESR             0x020b8
+#define   GM45_ERROR_PAGE_TABLE                         (1<<5)
+#define   GM45_ERROR_MEM_PRIV                           (1<<4)
+#define   I915_ERROR_PAGE_TABLE                         (1<<4)
+#define   GM45_ERROR_CP_PRIV                            (1<<3)
+#define   I915_ERROR_MEMORY_REFRESH                     (1<<1)
+#define   I915_ERROR_INSTRUCTION                        (1<<0)
 #define INSTPM          0x020c0
 #define ACTHD           0x020c8
 #define FW_BLC          0x020d8
+#define FW_BLC2         0x020dc
 #define FW_BLC_SELF     0x020e0 /* 915+ only */
+#define   FW_BLC_SELF_EN (1<<15)
+#define MM_BURST_LENGTH     0x00700000
+#define MM_FIFO_WATERMARK   0x0001F000
+#define LM_BURST_LENGTH     0x00000700
+#define LM_FIFO_WATERMARK   0x0000001F
 #define MI_ARB_STATE    0x020e4 /* 915+ only */
 #define CACHE_MODE_0    0x02120 /* 915+ only */
 #define   CM0_MASK_SHIFT          16
@@ -569,6 +589,23 @@
 #define C0DRB3                  0x10206
 #define C1DRB3                  0x10606
 
+/* Clocking configuration register */
+#define CLKCFG                  0x10c00
+#define CLKCFG_FSB_400                                  (5 << 0)        /* hrawclk 100 */
+#define CLKCFG_FSB_533                                  (1 << 0)        /* hrawclk 133 */
+#define CLKCFG_FSB_667                                  (3 << 0)        /* hrawclk 166 */
+#define CLKCFG_FSB_800                                  (2 << 0)        /* hrawclk 200 */
+#define CLKCFG_FSB_1067                                 (6 << 0)        /* hrawclk 266 */
+#define CLKCFG_FSB_1333                                 (7 << 0)        /* hrawclk 333 */
+/* Note, below two are guess */
+#define CLKCFG_FSB_1600                                 (4 << 0)        /* hrawclk 400 */
+#define CLKCFG_FSB_1600_ALT                             (0 << 0)        /* hrawclk 400 */
+#define CLKCFG_FSB_MASK                                 (7 << 0)
+#define CLKCFG_MEM_533                                  (1 << 4)
+#define CLKCFG_MEM_667                                  (2 << 4)
+#define CLKCFG_MEM_800                                  (3 << 4)
+#define CLKCFG_MEM_MASK                                 (7 << 4)
+
 /** GM965 GM45 render standby register */
 #define MCHBAR_RENDER_STANDBY   0x111B8
 
@@ -834,9 +871,25 @@
 #define   HORIZ_INTERP_MASK     (3 << 6)
 #define   HORIZ_AUTO_SCALE      (1 << 5)
 #define   PANEL_8TO6_DITHER_ENABLE (1 << 3)
+#define   PFIT_FILTER_FUZZY     (0 << 24)
+#define   PFIT_SCALING_AUTO     (0 << 26)
+#define   PFIT_SCALING_PROGRAMMED (1 << 26)
+#define   PFIT_SCALING_PILLAR   (2 << 26)
+#define   PFIT_SCALING_LETTER   (3 << 26)
 #define PFIT_PGM_RATIOS 0x61234
 #define   PFIT_VERT_SCALE_MASK                  0xfff00000
 #define   PFIT_HORIZ_SCALE_MASK                 0x0000fff0
+/* Pre-965 */
+#define         PFIT_VERT_SCALE_SHIFT           20
+#define         PFIT_VERT_SCALE_MASK            0xfff00000
+#define         PFIT_HORIZ_SCALE_SHIFT          4
+#define         PFIT_HORIZ_SCALE_MASK           0x0000fff0
+/* 965+ */
+#define         PFIT_VERT_SCALE_SHIFT_965       16
+#define         PFIT_VERT_SCALE_MASK_965        0x1fff0000
+#define         PFIT_HORIZ_SCALE_SHIFT_965      0
+#define         PFIT_HORIZ_SCALE_MASK_965       0x00001fff
+
 #define PFIT_AUTO_RATIOS 0x61238
 
 /* Backlight control */
@@ -1552,6 +1605,34 @@
 #define   DSPARB_CSTART_SHIFT   7
 #define   DSPARB_BSTART_MASK    (0x7f)
 #define   DSPARB_BSTART_SHIFT   0
+#define   DSPARB_BEND_SHIFT     9 /* on 855 */
+#define   DSPARB_AEND_SHIFT     0
+
+#define DSPFW1                  0x70034
+#define DSPFW2                  0x70038
+#define DSPFW3                  0x7003c
+#define   IGD_SELF_REFRESH_EN   (1<<30)
+
+/* FIFO watermark sizes etc */
+#define I915_FIFO_LINE_SIZE     64
+#define I830_FIFO_LINE_SIZE     32
+#define I945_FIFO_SIZE          127 /* 945 & 965 */
+#define I915_FIFO_SIZE          95
+#define I855GM_FIFO_SIZE        255
+#define I830_FIFO_SIZE          95
+#define I915_MAX_WM             0x3f
+
+#define IGD_DISPLAY_FIFO        512 /* in 64byte unit */
+#define IGD_FIFO_LINE_SIZE      64
+#define IGD_MAX_WM              0x1ff
+#define IGD_DFT_WM              0x3f
+#define IGD_DFT_HPLLOFF_WM      0
+#define IGD_GUARD_WM            10
+#define IGD_CURSOR_FIFO         64
+#define IGD_CURSOR_MAX_WM       0x3f
+#define IGD_CURSOR_DFT_WM       0
+#define IGD_CURSOR_GUARD_WM     5
+
 /*
  * The two pipe frame counter registers are not synchronized, so
  * reading a stable value is somewhat tricky. The following code
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index a98e2831ed31..9e1d16e5c3ea 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -222,23 +222,12 @@ static void i915_restore_vga(struct drm_device *dev)
         I915_WRITE8(VGA_DACMASK, dev_priv->saveDACMASK);
 }
 
-int i915_save_state(struct drm_device *dev)
+static void i915_save_modeset_reg(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        int i;
-
-        pci_read_config_byte(dev->pdev, LBB, &dev_priv->saveLBB);
-
-        /* Render Standby */
-        if (IS_I965G(dev) && IS_MOBILE(dev))
-                dev_priv->saveRENDERSTANDBY = I915_READ(MCHBAR_RENDER_STANDBY);
-
-        /* Hardware status page */
-        dev_priv->saveHWS = I915_READ(HWS_PGA);
-
-        /* Display arbitration control */
-        dev_priv->saveDSPARB = I915_READ(DSPARB);
 
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                return;
         /* Pipe & plane A info */
         dev_priv->savePIPEACONF = I915_READ(PIPEACONF);
         dev_priv->savePIPEASRC = I915_READ(PIPEASRC);
@@ -294,7 +283,122 @@ int i915_save_state(struct drm_device *dev)
         }
         i915_save_palette(dev, PIPE_B);
         dev_priv->savePIPEBSTAT = I915_READ(PIPEBSTAT);
+        return;
+}
+static void i915_restore_modeset_reg(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                return;
+
+        /* Pipe & plane A info */
+        /* Prime the clock */
+        if (dev_priv->saveDPLL_A & DPLL_VCO_ENABLE) {
+                I915_WRITE(DPLL_A, dev_priv->saveDPLL_A &
+                           ~DPLL_VCO_ENABLE);
+                DRM_UDELAY(150);
+        }
+        I915_WRITE(FPA0, dev_priv->saveFPA0);
+        I915_WRITE(FPA1, dev_priv->saveFPA1);
+        /* Actually enable it */
+        I915_WRITE(DPLL_A, dev_priv->saveDPLL_A);
+        DRM_UDELAY(150);
+        if (IS_I965G(dev))
+                I915_WRITE(DPLL_A_MD, dev_priv->saveDPLL_A_MD);
+        DRM_UDELAY(150);
+
+        /* Restore mode */
+        I915_WRITE(HTOTAL_A, dev_priv->saveHTOTAL_A);
+        I915_WRITE(HBLANK_A, dev_priv->saveHBLANK_A);
+        I915_WRITE(HSYNC_A, dev_priv->saveHSYNC_A);
+        I915_WRITE(VTOTAL_A, dev_priv->saveVTOTAL_A);
+        I915_WRITE(VBLANK_A, dev_priv->saveVBLANK_A);
+        I915_WRITE(VSYNC_A, dev_priv->saveVSYNC_A);
+        I915_WRITE(BCLRPAT_A, dev_priv->saveBCLRPAT_A);
+
+        /* Restore plane info */
+        I915_WRITE(DSPASIZE, dev_priv->saveDSPASIZE);
+        I915_WRITE(DSPAPOS, dev_priv->saveDSPAPOS);
+        I915_WRITE(PIPEASRC, dev_priv->savePIPEASRC);
+        I915_WRITE(DSPAADDR, dev_priv->saveDSPAADDR);
+        I915_WRITE(DSPASTRIDE, dev_priv->saveDSPASTRIDE);
+        if (IS_I965G(dev)) {
+                I915_WRITE(DSPASURF, dev_priv->saveDSPASURF);
+                I915_WRITE(DSPATILEOFF, dev_priv->saveDSPATILEOFF);
+        }
+
+        I915_WRITE(PIPEACONF, dev_priv->savePIPEACONF);
+
+        i915_restore_palette(dev, PIPE_A);
+        /* Enable the plane */
+        I915_WRITE(DSPACNTR, dev_priv->saveDSPACNTR);
+        I915_WRITE(DSPAADDR, I915_READ(DSPAADDR));
+
+        /* Pipe & plane B info */
+        if (dev_priv->saveDPLL_B & DPLL_VCO_ENABLE) {
+                I915_WRITE(DPLL_B, dev_priv->saveDPLL_B &
+                           ~DPLL_VCO_ENABLE);
+                DRM_UDELAY(150);
+        }
+        I915_WRITE(FPB0, dev_priv->saveFPB0);
+        I915_WRITE(FPB1, dev_priv->saveFPB1);
+        /* Actually enable it */
+        I915_WRITE(DPLL_B, dev_priv->saveDPLL_B);
+        DRM_UDELAY(150);
+        if (IS_I965G(dev))
+                I915_WRITE(DPLL_B_MD, dev_priv->saveDPLL_B_MD);
+        DRM_UDELAY(150);
+
+        /* Restore mode */
+        I915_WRITE(HTOTAL_B, dev_priv->saveHTOTAL_B);
+        I915_WRITE(HBLANK_B, dev_priv->saveHBLANK_B);
+        I915_WRITE(HSYNC_B, dev_priv->saveHSYNC_B);
+        I915_WRITE(VTOTAL_B, dev_priv->saveVTOTAL_B);
+        I915_WRITE(VBLANK_B, dev_priv->saveVBLANK_B);
+        I915_WRITE(VSYNC_B, dev_priv->saveVSYNC_B);
+        I915_WRITE(BCLRPAT_B, dev_priv->saveBCLRPAT_B);
+
+        /* Restore plane info */
+        I915_WRITE(DSPBSIZE, dev_priv->saveDSPBSIZE);
+        I915_WRITE(DSPBPOS, dev_priv->saveDSPBPOS);
+        I915_WRITE(PIPEBSRC, dev_priv->savePIPEBSRC);
+        I915_WRITE(DSPBADDR, dev_priv->saveDSPBADDR);
+        I915_WRITE(DSPBSTRIDE, dev_priv->saveDSPBSTRIDE);
+        if (IS_I965G(dev)) {
+                I915_WRITE(DSPBSURF, dev_priv->saveDSPBSURF);
+                I915_WRITE(DSPBTILEOFF, dev_priv->saveDSPBTILEOFF);
+        }
+
+        I915_WRITE(PIPEBCONF, dev_priv->savePIPEBCONF);
+
+        i915_restore_palette(dev, PIPE_B);
+        /* Enable the plane */
+        I915_WRITE(DSPBCNTR, dev_priv->saveDSPBCNTR);
+        I915_WRITE(DSPBADDR, I915_READ(DSPBADDR));
 
+        return;
+}
+int i915_save_state(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        int i;
+
+        pci_read_config_byte(dev->pdev, LBB, &dev_priv->saveLBB);
+
+        /* Render Standby */
+        if (IS_I965G(dev) && IS_MOBILE(dev))
+                dev_priv->saveRENDERSTANDBY = I915_READ(MCHBAR_RENDER_STANDBY);
+
+        /* Hardware status page */
+        dev_priv->saveHWS = I915_READ(HWS_PGA);
+
+        /* Display arbitration control */
+        dev_priv->saveDSPARB = I915_READ(DSPARB);
+
+        /* This is only meaningful in non-KMS mode */
+        /* Don't save them in KMS mode */
+        i915_save_modeset_reg(dev);
         /* Cursor state */
         dev_priv->saveCURACNTR = I915_READ(CURACNTR);
         dev_priv->saveCURAPOS = I915_READ(CURAPOS);
@@ -322,6 +426,20 @@ int i915_save_state(struct drm_device *dev)
         dev_priv->savePP_OFF_DELAYS = I915_READ(PP_OFF_DELAYS);
         dev_priv->savePP_DIVISOR = I915_READ(PP_DIVISOR);
 
+        /* Display Port state */
+        if (SUPPORTS_INTEGRATED_DP(dev)) {
+                dev_priv->saveDP_B = I915_READ(DP_B);
+                dev_priv->saveDP_C = I915_READ(DP_C);
+                dev_priv->saveDP_D = I915_READ(DP_D);
+                dev_priv->savePIPEA_GMCH_DATA_M = I915_READ(PIPEA_GMCH_DATA_M);
+                dev_priv->savePIPEB_GMCH_DATA_M = I915_READ(PIPEB_GMCH_DATA_M);
+                dev_priv->savePIPEA_GMCH_DATA_N = I915_READ(PIPEA_GMCH_DATA_N);
+                dev_priv->savePIPEB_GMCH_DATA_N = I915_READ(PIPEB_GMCH_DATA_N);
+                dev_priv->savePIPEA_DP_LINK_M = I915_READ(PIPEA_DP_LINK_M);
+                dev_priv->savePIPEB_DP_LINK_M = I915_READ(PIPEB_DP_LINK_M);
+                dev_priv->savePIPEA_DP_LINK_N = I915_READ(PIPEA_DP_LINK_N);
+                dev_priv->savePIPEB_DP_LINK_N = I915_READ(PIPEB_DP_LINK_N);
+        }
         /* FIXME: save TV & SDVO state */
 
         /* FBC state */
@@ -404,92 +522,21 @@ int i915_restore_state(struct drm_device *dev)
                         for (i = 0; i < 8; i++)
                                 I915_WRITE(FENCE_REG_945_8 + (i * 4), dev_priv->saveFENCE[i+8]);
         }
-
-        /* Pipe & plane A info */
-        /* Prime the clock */
-        if (dev_priv->saveDPLL_A & DPLL_VCO_ENABLE) {
-                I915_WRITE(DPLL_A, dev_priv->saveDPLL_A &
-                           ~DPLL_VCO_ENABLE);
-                DRM_UDELAY(150);
+        
+        /* Display port ratios (must be done before clock is set) */
+        if (SUPPORTS_INTEGRATED_DP(dev)) {
+                I915_WRITE(PIPEA_GMCH_DATA_M, dev_priv->savePIPEA_GMCH_DATA_M);
+                I915_WRITE(PIPEB_GMCH_DATA_M, dev_priv->savePIPEB_GMCH_DATA_M);
+                I915_WRITE(PIPEA_GMCH_DATA_N, dev_priv->savePIPEA_GMCH_DATA_N);
+                I915_WRITE(PIPEB_GMCH_DATA_N, dev_priv->savePIPEB_GMCH_DATA_N);
+                I915_WRITE(PIPEA_DP_LINK_M, dev_priv->savePIPEA_DP_LINK_M);
+                I915_WRITE(PIPEB_DP_LINK_M, dev_priv->savePIPEB_DP_LINK_M);
+                I915_WRITE(PIPEA_DP_LINK_N, dev_priv->savePIPEA_DP_LINK_N);
+                I915_WRITE(PIPEB_DP_LINK_N, dev_priv->savePIPEB_DP_LINK_N);
         }
-        I915_WRITE(FPA0, dev_priv->saveFPA0);
-        I915_WRITE(FPA1, dev_priv->saveFPA1);
-        /* Actually enable it */
-        I915_WRITE(DPLL_A, dev_priv->saveDPLL_A);
-        DRM_UDELAY(150);
-        if (IS_I965G(dev))
-                I915_WRITE(DPLL_A_MD, dev_priv->saveDPLL_A_MD);
-        DRM_UDELAY(150);
-
-        /* Restore mode */
-        I915_WRITE(HTOTAL_A, dev_priv->saveHTOTAL_A);
-        I915_WRITE(HBLANK_A, dev_priv->saveHBLANK_A);
-        I915_WRITE(HSYNC_A, dev_priv->saveHSYNC_A);
-        I915_WRITE(VTOTAL_A, dev_priv->saveVTOTAL_A);
-        I915_WRITE(VBLANK_A, dev_priv->saveVBLANK_A);
-        I915_WRITE(VSYNC_A, dev_priv->saveVSYNC_A);
-        I915_WRITE(BCLRPAT_A, dev_priv->saveBCLRPAT_A);
-
-        /* Restore plane info */
-        I915_WRITE(DSPASIZE, dev_priv->saveDSPASIZE);
-        I915_WRITE(DSPAPOS, dev_priv->saveDSPAPOS);
-        I915_WRITE(PIPEASRC, dev_priv->savePIPEASRC);
-        I915_WRITE(DSPAADDR, dev_priv->saveDSPAADDR);
-        I915_WRITE(DSPASTRIDE, dev_priv->saveDSPASTRIDE);
-        if (IS_I965G(dev)) {
-                I915_WRITE(DSPASURF, dev_priv->saveDSPASURF);
-                I915_WRITE(DSPATILEOFF, dev_priv->saveDSPATILEOFF);
-        }
-
-        I915_WRITE(PIPEACONF, dev_priv->savePIPEACONF);
-
-        i915_restore_palette(dev, PIPE_A);
-        /* Enable the plane */
-        I915_WRITE(DSPACNTR, dev_priv->saveDSPACNTR);
-        I915_WRITE(DSPAADDR, I915_READ(DSPAADDR));
-
-        /* Pipe & plane B info */
-        if (dev_priv->saveDPLL_B & DPLL_VCO_ENABLE) {
-                I915_WRITE(DPLL_B, dev_priv->saveDPLL_B &
-                           ~DPLL_VCO_ENABLE);
-                DRM_UDELAY(150);
-        }
-        I915_WRITE(FPB0, dev_priv->saveFPB0);
-        I915_WRITE(FPB1, dev_priv->saveFPB1);
-        /* Actually enable it */
-        I915_WRITE(DPLL_B, dev_priv->saveDPLL_B);
-        DRM_UDELAY(150);
-        if (IS_I965G(dev))
-                I915_WRITE(DPLL_B_MD, dev_priv->saveDPLL_B_MD);
-        DRM_UDELAY(150);
-
-        /* Restore mode */
-        I915_WRITE(HTOTAL_B, dev_priv->saveHTOTAL_B);
-        I915_WRITE(HBLANK_B, dev_priv->saveHBLANK_B);
-        I915_WRITE(HSYNC_B, dev_priv->saveHSYNC_B);
-        I915_WRITE(VTOTAL_B, dev_priv->saveVTOTAL_B);
-        I915_WRITE(VBLANK_B, dev_priv->saveVBLANK_B);
-        I915_WRITE(VSYNC_B, dev_priv->saveVSYNC_B);
-        I915_WRITE(BCLRPAT_B, dev_priv->saveBCLRPAT_B);
-
-        /* Restore plane info */
-        I915_WRITE(DSPBSIZE, dev_priv->saveDSPBSIZE);
-        I915_WRITE(DSPBPOS, dev_priv->saveDSPBPOS);
-        I915_WRITE(PIPEBSRC, dev_priv->savePIPEBSRC);
-        I915_WRITE(DSPBADDR, dev_priv->saveDSPBADDR);
-        I915_WRITE(DSPBSTRIDE, dev_priv->saveDSPBSTRIDE);
-        if (IS_I965G(dev)) {
-                I915_WRITE(DSPBSURF, dev_priv->saveDSPBSURF);
-                I915_WRITE(DSPBTILEOFF, dev_priv->saveDSPBTILEOFF);
-        }
-
-        I915_WRITE(PIPEBCONF, dev_priv->savePIPEBCONF);
-
-        i915_restore_palette(dev, PIPE_B);
-        /* Enable the plane */
-        I915_WRITE(DSPBCNTR, dev_priv->saveDSPBCNTR);
-        I915_WRITE(DSPBADDR, I915_READ(DSPBADDR));
-
+        /* This is only meaningful in non-KMS mode */
+        /* Don't restore them in KMS mode */
+        i915_restore_modeset_reg(dev);
         /* Cursor state */
         I915_WRITE(CURAPOS, dev_priv->saveCURAPOS);
         I915_WRITE(CURACNTR, dev_priv->saveCURACNTR);
@@ -518,6 +565,12 @@ int i915_restore_state(struct drm_device *dev)
         I915_WRITE(PP_DIVISOR, dev_priv->savePP_DIVISOR);
         I915_WRITE(PP_CONTROL, dev_priv->savePP_CONTROL);
 
+        /* Display Port state */
+        if (SUPPORTS_INTEGRATED_DP(dev)) {
+                I915_WRITE(DP_B, dev_priv->saveDP_B);
+                I915_WRITE(DP_C, dev_priv->saveDP_C);
+                I915_WRITE(DP_D, dev_priv->saveDP_D);
+        }
         /* FIXME: restore TV & SDVO state */
 
         /* FBC info */
diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c
index cdd126d068a7..7cc447191028 100644
--- a/drivers/gpu/drm/i915/intel_bios.c
+++ b/drivers/gpu/drm/i915/intel_bios.c
@@ -97,11 +97,14 @@ static void
 parse_lfp_panel_data(struct drm_i915_private *dev_priv,
                             struct bdb_header *bdb)
 {
+        struct drm_device *dev = dev_priv->dev;
         struct bdb_lvds_options *lvds_options;
         struct bdb_lvds_lfp_data *lvds_lfp_data;
+        struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs;
         struct bdb_lvds_lfp_data_entry *entry;
         struct lvds_dvo_timing *dvo_timing;
         struct drm_display_mode *panel_fixed_mode;
+        int lfp_data_size;
 
         /* Defaults if we can't find VBT info */
         dev_priv->lvds_dither = 0;
@@ -119,10 +122,25 @@ parse_lfp_panel_data(struct drm_i915_private *dev_priv,
         if (!lvds_lfp_data)
                 return;
 
+        lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS);
+        if (!lvds_lfp_data_ptrs)
+                return;
+
         dev_priv->lvds_vbt = 1;
 
-        entry = &lvds_lfp_data->data[lvds_options->panel_type];
-        dvo_timing = &entry->dvo_timing;
+        lfp_data_size = lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset -
+                lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset;
+        entry = (struct bdb_lvds_lfp_data_entry *)
+                ((uint8_t *)lvds_lfp_data->data + (lfp_data_size *
+                                                   lvds_options->panel_type));
+
+        /* On IGDNG mobile, LVDS data block removes panel fitting registers.
+           So dec 2 dword from dvo_timing offset */
+        if (IS_IGDNG(dev))
+                dvo_timing = (struct lvds_dvo_timing *)
+                                        ((u8 *)&entry->dvo_timing - 8);
+        else
+                dvo_timing = &entry->dvo_timing;
 
         panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);
 
@@ -185,10 +203,12 @@ parse_general_features(struct drm_i915_private *dev_priv,
                 dev_priv->lvds_use_ssc = general->enable_ssc;
 
                 if (dev_priv->lvds_use_ssc) {
-                  if (IS_I855(dev_priv->dev))
-                    dev_priv->lvds_ssc_freq = general->ssc_freq ? 66 : 48;
-                  else
-                    dev_priv->lvds_ssc_freq = general->ssc_freq ? 100 : 96;
+                        if (IS_I85X(dev_priv->dev))
+                                dev_priv->lvds_ssc_freq =
+                                        general->ssc_freq ? 66 : 48;
+                        else
+                                dev_priv->lvds_ssc_freq =
+                                        general->ssc_freq ? 100 : 96;
                 }
         }
 }
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 6de97fc66029..d6a1a6e5539a 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -46,7 +46,7 @@ static void intel_crt_dpms(struct drm_encoder *encoder, int mode)
 
         temp = I915_READ(reg);
         temp &= ~(ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE);
-        temp |= ADPA_DAC_ENABLE;
+        temp &= ~ADPA_DAC_ENABLE;
 
         switch(mode) {
         case DRM_MODE_DPMS_ON:
@@ -428,8 +428,34 @@ static void intel_crt_destroy(struct drm_connector *connector)
 
 static int intel_crt_get_modes(struct drm_connector *connector)
 {
+        int ret;
         struct intel_output *intel_output = to_intel_output(connector);
-        return intel_ddc_get_modes(intel_output);
+        struct i2c_adapter *ddcbus;
+        struct drm_device *dev = connector->dev;
+
+
+        ret = intel_ddc_get_modes(intel_output);
+        if (ret || !IS_G4X(dev))
+                goto end;
+
+        ddcbus = intel_output->ddc_bus;
+        /* Try to probe digital port for output in DVI-I -> VGA mode. */
+        intel_output->ddc_bus =
+                intel_i2c_create(connector->dev, GPIOD, "CRTDDC_D");
+
+        if (!intel_output->ddc_bus) {
+                intel_output->ddc_bus = ddcbus;
+                dev_printk(KERN_ERR, &connector->dev->pdev->dev,
+                           "DDC bus registration failed for CRTDDC_D.\n");
+                goto end;
+        }
+        /* Try to get modes by GPIOD port */
+        ret = intel_ddc_get_modes(intel_output);
+        intel_i2c_destroy(ddcbus);
+
+end:
+        return ret;
+
 }
 
 static int intel_crt_set_property(struct drm_connector *connector,
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 3e1c78162119..508838ee31e0 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -25,14 +25,17 @@
  */
 
 #include <linux/i2c.h>
+#include <linux/kernel.h>
 #include "drmP.h"
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
+#include "intel_dp.h"
 
 #include "drm_crtc_helper.h"
 
 bool intel_pipe_has_type (struct drm_crtc *crtc, int type);
+static void intel_update_watermarks(struct drm_device *dev);
 
 typedef struct {
     /* given values */
@@ -127,19 +130,6 @@ struct intel_limit {
 #define I9XX_P2_LVDS_FAST                     7
 #define I9XX_P2_LVDS_SLOW_LIMIT          112000
 
-#define INTEL_LIMIT_I8XX_DVO_DAC    0
-#define INTEL_LIMIT_I8XX_LVDS       1
-#define INTEL_LIMIT_I9XX_SDVO_DAC   2
-#define INTEL_LIMIT_I9XX_LVDS       3
-#define INTEL_LIMIT_G4X_SDVO        4
-#define INTEL_LIMIT_G4X_HDMI_DAC   5
-#define INTEL_LIMIT_G4X_SINGLE_CHANNEL_LVDS   6
-#define INTEL_LIMIT_G4X_DUAL_CHANNEL_LVDS   7
-#define INTEL_LIMIT_IGD_SDVO_DAC    8
-#define INTEL_LIMIT_IGD_LVDS        9
-#define INTEL_LIMIT_IGDNG_SDVO_DAC  10
-#define INTEL_LIMIT_IGDNG_LVDS      11
-
 /*The parameter is for SDVO on G4x platform*/
 #define G4X_DOT_SDVO_MIN           25000
 #define G4X_DOT_SDVO_MAX           270000
@@ -218,6 +208,25 @@ struct intel_limit {
 #define G4X_P2_DUAL_CHANNEL_LVDS_FAST           7
 #define G4X_P2_DUAL_CHANNEL_LVDS_LIMIT          0
 
+/*The parameter is for DISPLAY PORT on G4x platform*/
+#define G4X_DOT_DISPLAY_PORT_MIN           161670
+#define G4X_DOT_DISPLAY_PORT_MAX           227000
+#define G4X_N_DISPLAY_PORT_MIN             1
+#define G4X_N_DISPLAY_PORT_MAX             2
+#define G4X_M_DISPLAY_PORT_MIN             97
+#define G4X_M_DISPLAY_PORT_MAX             108
+#define G4X_M1_DISPLAY_PORT_MIN            0x10
+#define G4X_M1_DISPLAY_PORT_MAX            0x12
+#define G4X_M2_DISPLAY_PORT_MIN            0x05
+#define G4X_M2_DISPLAY_PORT_MAX            0x06
+#define G4X_P_DISPLAY_PORT_MIN             10
+#define G4X_P_DISPLAY_PORT_MAX             20
+#define G4X_P1_DISPLAY_PORT_MIN            1
+#define G4X_P1_DISPLAY_PORT_MAX            2
+#define G4X_P2_DISPLAY_PORT_SLOW           10
+#define G4X_P2_DISPLAY_PORT_FAST           10
+#define G4X_P2_DISPLAY_PORT_LIMIT          0
+
 /* IGDNG */
 /* as we calculate clock using (register_value + 2) for
    N/M1/M2, so here the range value for them is (actual_value-2).
@@ -256,8 +265,11 @@ static bool
 intel_igdng_find_best_PLL(const intel_limit_t *limit, struct drm_crtc *crtc,
                         int target, int refclk, intel_clock_t *best_clock);
 
-static const intel_limit_t intel_limits[] = {
-    { /* INTEL_LIMIT_I8XX_DVO_DAC */
+static bool
+intel_find_pll_g4x_dp(const intel_limit_t *, struct drm_crtc *crtc,
+                      int target, int refclk, intel_clock_t *best_clock);
+
+static const intel_limit_t intel_limits_i8xx_dvo = {
         .dot = { .min = I8XX_DOT_MIN,           .max = I8XX_DOT_MAX },
         .vco = { .min = I8XX_VCO_MIN,           .max = I8XX_VCO_MAX },
         .n   = { .min = I8XX_N_MIN,             .max = I8XX_N_MAX },
@@ -269,8 +281,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I8XX_P2_SLOW_LIMIT,
                  .p2_slow = I8XX_P2_SLOW,       .p2_fast = I8XX_P2_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_I8XX_LVDS */
+};
+
+static const intel_limit_t intel_limits_i8xx_lvds = {
         .dot = { .min = I8XX_DOT_MIN,           .max = I8XX_DOT_MAX },
         .vco = { .min = I8XX_VCO_MIN,           .max = I8XX_VCO_MAX },
         .n   = { .min = I8XX_N_MIN,             .max = I8XX_N_MAX },
@@ -282,8 +295,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I8XX_P2_SLOW_LIMIT,
                  .p2_slow = I8XX_P2_LVDS_SLOW,  .p2_fast = I8XX_P2_LVDS_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_I9XX_SDVO_DAC */
+};
+        
+static const intel_limit_t intel_limits_i9xx_sdvo = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX },
         .vco = { .min = I9XX_VCO_MIN,           .max = I9XX_VCO_MAX },
         .n   = { .min = I9XX_N_MIN,             .max = I9XX_N_MAX },
@@ -295,8 +309,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_SDVO_DAC_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_SDVO_DAC_SLOW,      .p2_fast = I9XX_P2_SDVO_DAC_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_I9XX_LVDS */
+};
+
+static const intel_limit_t intel_limits_i9xx_lvds = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX },
         .vco = { .min = I9XX_VCO_MIN,           .max = I9XX_VCO_MAX },
         .n   = { .min = I9XX_N_MIN,             .max = I9XX_N_MAX },
@@ -311,9 +326,10 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_LVDS_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_LVDS_SLOW,  .p2_fast = I9XX_P2_LVDS_FAST },
         .find_pll = intel_find_best_PLL,
-    },
+};
+
     /* below parameter and function is for G4X Chipset Family*/
-    { /* INTEL_LIMIT_G4X_SDVO */
+static const intel_limit_t intel_limits_g4x_sdvo = {
         .dot = { .min = G4X_DOT_SDVO_MIN,       .max = G4X_DOT_SDVO_MAX },
         .vco = { .min = G4X_VCO_MIN,            .max = G4X_VCO_MAX},
         .n   = { .min = G4X_N_SDVO_MIN,         .max = G4X_N_SDVO_MAX },
@@ -327,8 +343,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_SDVO_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_G4X_HDMI_DAC */
+};
+
+static const intel_limit_t intel_limits_g4x_hdmi = {
         .dot = { .min = G4X_DOT_HDMI_DAC_MIN,   .max = G4X_DOT_HDMI_DAC_MAX },
         .vco = { .min = G4X_VCO_MIN,            .max = G4X_VCO_MAX},
         .n   = { .min = G4X_N_HDMI_DAC_MIN,     .max = G4X_N_HDMI_DAC_MAX },
@@ -342,8 +359,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_HDMI_DAC_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_G4X_SINGLE_CHANNEL_LVDS */
+};
+
+static const intel_limit_t intel_limits_g4x_single_channel_lvds = {
         .dot = { .min = G4X_DOT_SINGLE_CHANNEL_LVDS_MIN,
                  .max = G4X_DOT_SINGLE_CHANNEL_LVDS_MAX },
         .vco = { .min = G4X_VCO_MIN,
@@ -365,8 +383,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_SINGLE_CHANNEL_LVDS_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_G4X_DUAL_CHANNEL_LVDS */
+};
+
+static const intel_limit_t intel_limits_g4x_dual_channel_lvds = {
         .dot = { .min = G4X_DOT_DUAL_CHANNEL_LVDS_MIN,
                  .max = G4X_DOT_DUAL_CHANNEL_LVDS_MAX },
         .vco = { .min = G4X_VCO_MIN,
@@ -388,8 +407,32 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_DUAL_CHANNEL_LVDS_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGD_SDVO */
+};
+
+static const intel_limit_t intel_limits_g4x_display_port = {
+        .dot = { .min = G4X_DOT_DISPLAY_PORT_MIN,
+                 .max = G4X_DOT_DISPLAY_PORT_MAX },
+        .vco = { .min = G4X_VCO_MIN,
+                 .max = G4X_VCO_MAX},
+        .n   = { .min = G4X_N_DISPLAY_PORT_MIN,
+                 .max = G4X_N_DISPLAY_PORT_MAX },
+        .m   = { .min = G4X_M_DISPLAY_PORT_MIN,
+                 .max = G4X_M_DISPLAY_PORT_MAX },
+        .m1  = { .min = G4X_M1_DISPLAY_PORT_MIN,
+                 .max = G4X_M1_DISPLAY_PORT_MAX },
+        .m2  = { .min = G4X_M2_DISPLAY_PORT_MIN,
+                 .max = G4X_M2_DISPLAY_PORT_MAX },
+        .p   = { .min = G4X_P_DISPLAY_PORT_MIN,
+                 .max = G4X_P_DISPLAY_PORT_MAX },
+        .p1  = { .min = G4X_P1_DISPLAY_PORT_MIN,
+                 .max = G4X_P1_DISPLAY_PORT_MAX},
+        .p2  = { .dot_limit = G4X_P2_DISPLAY_PORT_LIMIT,
+                 .p2_slow = G4X_P2_DISPLAY_PORT_SLOW,
+                 .p2_fast = G4X_P2_DISPLAY_PORT_FAST },
+        .find_pll = intel_find_pll_g4x_dp,
+};
+
+static const intel_limit_t intel_limits_igd_sdvo = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX},
         .vco = { .min = IGD_VCO_MIN,            .max = IGD_VCO_MAX },
         .n   = { .min = IGD_N_MIN,              .max = IGD_N_MAX },
@@ -401,8 +444,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_SDVO_DAC_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_SDVO_DAC_SLOW,      .p2_fast = I9XX_P2_SDVO_DAC_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGD_LVDS */
+};
+
+static const intel_limit_t intel_limits_igd_lvds = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX },
         .vco = { .min = IGD_VCO_MIN,            .max = IGD_VCO_MAX },
         .n   = { .min = IGD_N_MIN,              .max = IGD_N_MAX },
@@ -415,8 +459,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_LVDS_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_LVDS_SLOW,  .p2_fast = I9XX_P2_LVDS_SLOW },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGDNG_SDVO_DAC */
+};
+
+static const intel_limit_t intel_limits_igdng_sdvo = {
         .dot = { .min = IGDNG_DOT_MIN,          .max = IGDNG_DOT_MAX },
         .vco = { .min = IGDNG_VCO_MIN,          .max = IGDNG_VCO_MAX },
         .n   = { .min = IGDNG_N_MIN,            .max = IGDNG_N_MAX },
@@ -429,8 +474,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_slow = IGDNG_P2_SDVO_DAC_SLOW,
                  .p2_fast = IGDNG_P2_SDVO_DAC_FAST },
         .find_pll = intel_igdng_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGDNG_LVDS */
+};
+
+static const intel_limit_t intel_limits_igdng_lvds = {
         .dot = { .min = IGDNG_DOT_MIN,          .max = IGDNG_DOT_MAX },
         .vco = { .min = IGDNG_VCO_MIN,          .max = IGDNG_VCO_MAX },
         .n   = { .min = IGDNG_N_MIN,            .max = IGDNG_N_MAX },
@@ -443,16 +489,15 @@ static const intel_limit_t intel_limits[] = {
                  .p2_slow = IGDNG_P2_LVDS_SLOW,
                  .p2_fast = IGDNG_P2_LVDS_FAST },
         .find_pll = intel_igdng_find_best_PLL,
-    },
 };
 
 static const intel_limit_t *intel_igdng_limit(struct drm_crtc *crtc)
 {
         const intel_limit_t *limit;
         if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                limit = &intel_limits[INTEL_LIMIT_IGDNG_LVDS];
+                limit = &intel_limits_igdng_lvds;
         else
-                limit = &intel_limits[INTEL_LIMIT_IGDNG_SDVO_DAC];
+                limit = &intel_limits_igdng_sdvo;
 
         return limit;
 }
@@ -467,19 +512,19 @@ static const intel_limit_t *intel_g4x_limit(struct drm_crtc *crtc)
                 if ((I915_READ(LVDS) & LVDS_CLKB_POWER_MASK) ==
                     LVDS_CLKB_POWER_UP)
                         /* LVDS with dual channel */
-                        limit = &intel_limits
-                                        [INTEL_LIMIT_G4X_DUAL_CHANNEL_LVDS];
+                        limit = &intel_limits_g4x_dual_channel_lvds;
                 else
                         /* LVDS with dual channel */
-                        limit = &intel_limits
-                                        [INTEL_LIMIT_G4X_SINGLE_CHANNEL_LVDS];
+                        limit = &intel_limits_g4x_single_channel_lvds;
         } else if (intel_pipe_has_type(crtc, INTEL_OUTPUT_HDMI) ||
                    intel_pipe_has_type(crtc, INTEL_OUTPUT_ANALOG)) {
-                limit = &intel_limits[INTEL_LIMIT_G4X_HDMI_DAC];
+                limit = &intel_limits_g4x_hdmi;
         } else if (intel_pipe_has_type(crtc, INTEL_OUTPUT_SDVO)) {
-                limit = &intel_limits[INTEL_LIMIT_G4X_SDVO];
+                limit = &intel_limits_g4x_sdvo;
+        } else if (intel_pipe_has_type (crtc, INTEL_OUTPUT_DISPLAYPORT)) {
+                limit = &intel_limits_g4x_display_port;
         } else /* The option is for other outputs */
-                limit = &intel_limits[INTEL_LIMIT_I9XX_SDVO_DAC];
+                limit = &intel_limits_i9xx_sdvo;
 
         return limit;
 }
@@ -495,19 +540,19 @@ static const intel_limit_t *intel_limit(struct drm_crtc *crtc)
                 limit = intel_g4x_limit(crtc);
         } else if (IS_I9XX(dev) && !IS_IGD(dev)) {
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                        limit = &intel_limits[INTEL_LIMIT_I9XX_LVDS];
+                        limit = &intel_limits_i9xx_lvds;
                 else
-                        limit = &intel_limits[INTEL_LIMIT_I9XX_SDVO_DAC];
+                        limit = &intel_limits_i9xx_sdvo;
         } else if (IS_IGD(dev)) {
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                        limit = &intel_limits[INTEL_LIMIT_IGD_LVDS];
+                        limit = &intel_limits_igd_lvds;
                 else
-                        limit = &intel_limits[INTEL_LIMIT_IGD_SDVO_DAC];
+                        limit = &intel_limits_igd_sdvo;
         } else {
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                        limit = &intel_limits[INTEL_LIMIT_I8XX_LVDS];
+                        limit = &intel_limits_i8xx_lvds;
                 else
-                        limit = &intel_limits[INTEL_LIMIT_I8XX_DVO_DAC];
+                        limit = &intel_limits_i8xx_dvo;
         }
         return limit;
 }
@@ -764,6 +809,32 @@ out:
         return found;
 }
 
+/* DisplayPort has only two frequencies, 162MHz and 270MHz */
+static bool
+intel_find_pll_g4x_dp(const intel_limit_t *limit, struct drm_crtc *crtc,
+                      int target, int refclk, intel_clock_t *best_clock)
+{
+    intel_clock_t clock;
+    if (target < 200000) {
+        clock.p1 = 2;
+        clock.p2 = 10;
+        clock.n = 2;
+        clock.m1 = 23;
+        clock.m2 = 8;
+    } else {
+        clock.p1 = 1;
+        clock.p2 = 10;
+        clock.n = 1;
+        clock.m1 = 14;
+        clock.m2 = 2;
+    }
+    clock.m = 5 * (clock.m1 + 2) + (clock.m2 + 2);
+    clock.p = (clock.p1 * clock.p2);
+    clock.dot = 96000 * clock.m / (clock.n + 2) / clock.p;
+    memcpy(best_clock, &clock, sizeof(intel_clock_t));
+    return true;
+}
+
 void
 intel_wait_for_vblank(struct drm_device *dev)
 {
@@ -933,7 +1004,7 @@ static void igdng_crtc_dpms(struct drm_crtc *crtc, int mode)
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
         int pipe = intel_crtc->pipe;
-        int plane = intel_crtc->pipe;
+        int plane = intel_crtc->plane;
         int pch_dpll_reg = (pipe == 0) ? PCH_DPLL_A : PCH_DPLL_B;
         int pipeconf_reg = (pipe == 0) ? PIPEACONF : PIPEBCONF;
         int dspcntr_reg = (plane == 0) ? DSPACNTR : DSPBCNTR;
@@ -1263,8 +1334,10 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode)
 
                 /* Give the overlay scaler a chance to enable if it's on this pipe */
                 //intel_crtc_dpms_video(crtc, true); TODO
+                intel_update_watermarks(dev);
         break;
         case DRM_MODE_DPMS_OFF:
+                intel_update_watermarks(dev);
                 /* Give the overlay scaler a chance to disable if it's on this pipe */
                 //intel_crtc_dpms_video(crtc, FALSE); TODO
 
@@ -1443,7 +1516,6 @@ static int intel_get_core_clock_speed(struct drm_device *dev)
         return 0; /* Silence gcc warning */
 }
 
-
 /**
  * Return the pipe currently connected to the panel fitter,
  * or -1 if the panel fitter is not present or not in use
@@ -1502,7 +1574,7 @@ igdng_compute_m_n(int bytes_per_pixel, int nlanes,
 
         temp = (u64) DATA_N * pixel_clock;
         temp = div_u64(temp, link_clock);
-        m_n->gmch_m = (temp * bytes_per_pixel) / nlanes;
+        m_n->gmch_m = div_u64(temp * bytes_per_pixel, nlanes);
         m_n->gmch_n = DATA_N;
         fdi_reduce_ratio(&m_n->gmch_m, &m_n->gmch_n);
 
@@ -1513,6 +1585,420 @@ igdng_compute_m_n(int bytes_per_pixel, int nlanes,
 }
 
 
+struct intel_watermark_params {
+        unsigned long fifo_size;
+        unsigned long max_wm;
+        unsigned long default_wm;
+        unsigned long guard_size;
+        unsigned long cacheline_size;
+};
+
+/* IGD has different values for various configs */
+static struct intel_watermark_params igd_display_wm = {
+        IGD_DISPLAY_FIFO,
+        IGD_MAX_WM,
+        IGD_DFT_WM,
+        IGD_GUARD_WM,
+        IGD_FIFO_LINE_SIZE
+};
+static struct intel_watermark_params igd_display_hplloff_wm = {
+        IGD_DISPLAY_FIFO,
+        IGD_MAX_WM,
+        IGD_DFT_HPLLOFF_WM,
+        IGD_GUARD_WM,
+        IGD_FIFO_LINE_SIZE
+};
+static struct intel_watermark_params igd_cursor_wm = {
+        IGD_CURSOR_FIFO,
+        IGD_CURSOR_MAX_WM,
+        IGD_CURSOR_DFT_WM,
+        IGD_CURSOR_GUARD_WM,
+        IGD_FIFO_LINE_SIZE,
+};
+static struct intel_watermark_params igd_cursor_hplloff_wm = {
+        IGD_CURSOR_FIFO,
+        IGD_CURSOR_MAX_WM,
+        IGD_CURSOR_DFT_WM,
+        IGD_CURSOR_GUARD_WM,
+        IGD_FIFO_LINE_SIZE
+};
+static struct intel_watermark_params i945_wm_info = {
+        I915_FIFO_LINE_SIZE,
+        I915_MAX_WM,
+        1,
+        0,
+        IGD_FIFO_LINE_SIZE
+};
+static struct intel_watermark_params i915_wm_info = {
+        I945_FIFO_SIZE,
+        I915_MAX_WM,
+        1,
+        0,
+        I915_FIFO_LINE_SIZE
+};
+static struct intel_watermark_params i855_wm_info = {
+        I855GM_FIFO_SIZE,
+        I915_MAX_WM,
+        1,
+        0,
+        I830_FIFO_LINE_SIZE
+};
+static struct intel_watermark_params i830_wm_info = {
+        I830_FIFO_SIZE,
+        I915_MAX_WM,
+        1,
+        0,
+        I830_FIFO_LINE_SIZE
+};
+
+static unsigned long intel_calculate_wm(unsigned long clock_in_khz,
+                                        struct intel_watermark_params *wm,
+                                        int pixel_size,
+                                        unsigned long latency_ns)
+{
+        unsigned long bytes_required, wm_size;
+
+        bytes_required = (clock_in_khz * pixel_size * latency_ns) / 1000000;
+        bytes_required /= wm->cacheline_size;
+        wm_size = wm->fifo_size - bytes_required - wm->guard_size;
+
+        if (wm_size > wm->max_wm)
+                wm_size = wm->max_wm;
+        if (wm_size == 0)
+                wm_size = wm->default_wm;
+        return wm_size;
+}
+
+struct cxsr_latency {
+        int is_desktop;
+        unsigned long fsb_freq;
+        unsigned long mem_freq;
+        unsigned long display_sr;
+        unsigned long display_hpll_disable;
+        unsigned long cursor_sr;
+        unsigned long cursor_hpll_disable;
+};
+
+static struct cxsr_latency cxsr_latency_table[] = {
+        {1, 800, 400, 3382, 33382, 3983, 33983},    /* DDR2-400 SC */
+        {1, 800, 667, 3354, 33354, 3807, 33807},    /* DDR2-667 SC */
+        {1, 800, 800, 3347, 33347, 3763, 33763},    /* DDR2-800 SC */
+
+        {1, 667, 400, 3400, 33400, 4021, 34021},    /* DDR2-400 SC */
+        {1, 667, 667, 3372, 33372, 3845, 33845},    /* DDR2-667 SC */
+        {1, 667, 800, 3386, 33386, 3822, 33822},    /* DDR2-800 SC */
+
+        {1, 400, 400, 3472, 33472, 4173, 34173},    /* DDR2-400 SC */
+        {1, 400, 667, 3443, 33443, 3996, 33996},    /* DDR2-667 SC */
+        {1, 400, 800, 3430, 33430, 3946, 33946},    /* DDR2-800 SC */
+
+        {0, 800, 400, 3438, 33438, 4065, 34065},    /* DDR2-400 SC */
+        {0, 800, 667, 3410, 33410, 3889, 33889},    /* DDR2-667 SC */
+        {0, 800, 800, 3403, 33403, 3845, 33845},    /* DDR2-800 SC */
+
+        {0, 667, 400, 3456, 33456, 4103, 34106},    /* DDR2-400 SC */
+        {0, 667, 667, 3428, 33428, 3927, 33927},    /* DDR2-667 SC */
+        {0, 667, 800, 3443, 33443, 3905, 33905},    /* DDR2-800 SC */
+
+        {0, 400, 400, 3528, 33528, 4255, 34255},    /* DDR2-400 SC */
+        {0, 400, 667, 3500, 33500, 4079, 34079},    /* DDR2-667 SC */
+        {0, 400, 800, 3487, 33487, 4029, 34029},    /* DDR2-800 SC */
+};
+
+static struct cxsr_latency *intel_get_cxsr_latency(int is_desktop, int fsb,
+                                                   int mem)
+{
+        int i;
+        struct cxsr_latency *latency;
+
+        if (fsb == 0 || mem == 0)
+                return NULL;
+
+        for (i = 0; i < ARRAY_SIZE(cxsr_latency_table); i++) {
+                latency = &cxsr_latency_table[i];
+                if (is_desktop == latency->is_desktop &&
+                        fsb == latency->fsb_freq && mem == latency->mem_freq)
+                        break;
+        }
+        if (i >= ARRAY_SIZE(cxsr_latency_table)) {
+                DRM_DEBUG("Unknown FSB/MEM found, disable CxSR\n");
+                return NULL;
+        }
+        return latency;
+}
+
+static void igd_disable_cxsr(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 reg;
+
+        /* deactivate cxsr */
+        reg = I915_READ(DSPFW3);
+        reg &= ~(IGD_SELF_REFRESH_EN);
+        I915_WRITE(DSPFW3, reg);
+        DRM_INFO("Big FIFO is disabled\n");
+}
+
+static void igd_enable_cxsr(struct drm_device *dev, unsigned long clock,
+                            int pixel_size)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 reg;
+        unsigned long wm;
+        struct cxsr_latency *latency;
+
+        latency = intel_get_cxsr_latency(IS_IGDG(dev), dev_priv->fsb_freq,
+                dev_priv->mem_freq);
+        if (!latency) {
+                DRM_DEBUG("Unknown FSB/MEM found, disable CxSR\n");
+                igd_disable_cxsr(dev);
+                return;
+        }
+
+        /* Display SR */
+        wm = intel_calculate_wm(clock, &igd_display_wm, pixel_size,
+                                latency->display_sr);
+        reg = I915_READ(DSPFW1);
+        reg &= 0x7fffff;
+        reg |= wm << 23;
+        I915_WRITE(DSPFW1, reg);
+        DRM_DEBUG("DSPFW1 register is %x\n", reg);
+
+        /* cursor SR */
+        wm = intel_calculate_wm(clock, &igd_cursor_wm, pixel_size,
+                                latency->cursor_sr);
+        reg = I915_READ(DSPFW3);
+        reg &= ~(0x3f << 24);
+        reg |= (wm & 0x3f) << 24;
+        I915_WRITE(DSPFW3, reg);
+
+        /* Display HPLL off SR */
+        wm = intel_calculate_wm(clock, &igd_display_hplloff_wm,
+                latency->display_hpll_disable, I915_FIFO_LINE_SIZE);
+        reg = I915_READ(DSPFW3);
+        reg &= 0xfffffe00;
+        reg |= wm & 0x1ff;
+        I915_WRITE(DSPFW3, reg);
+
+        /* cursor HPLL off SR */
+        wm = intel_calculate_wm(clock, &igd_cursor_hplloff_wm, pixel_size,
+                                latency->cursor_hpll_disable);
+        reg = I915_READ(DSPFW3);
+        reg &= ~(0x3f << 16);
+        reg |= (wm & 0x3f) << 16;
+        I915_WRITE(DSPFW3, reg);
+        DRM_DEBUG("DSPFW3 register is %x\n", reg);
+
+        /* activate cxsr */
+        reg = I915_READ(DSPFW3);
+        reg |= IGD_SELF_REFRESH_EN;
+        I915_WRITE(DSPFW3, reg);
+
+        DRM_INFO("Big FIFO is enabled\n");
+
+        return;
+}
+
+const static int latency_ns = 5000; /* default for non-igd platforms */
+
+
+static void i965_update_wm(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        DRM_DEBUG("Setting FIFO watermarks - A: 8, B: 8, C: 8, SR 8\n");
+
+        /* 965 has limitations... */
+        I915_WRITE(DSPFW1, (8 << 16) | (8 << 8) | (8 << 0));
+        I915_WRITE(DSPFW2, (8 << 8) | (8 << 0));
+}
+
+static void i9xx_update_wm(struct drm_device *dev, int planea_clock,
+                           int planeb_clock, int sr_hdisplay, int pixel_size)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t fwater_lo = I915_READ(FW_BLC) & MM_FIFO_WATERMARK;
+        uint32_t fwater_hi = I915_READ(FW_BLC2) & LM_FIFO_WATERMARK;
+        int bsize, asize, cwm, bwm = 1, awm = 1, srwm = 1;
+        uint32_t dsparb = I915_READ(DSPARB);
+        int planea_entries, planeb_entries;
+        struct intel_watermark_params *wm_params;
+        unsigned long line_time_us;
+        int sr_clock, sr_entries = 0;
+
+        if (IS_I965GM(dev) || IS_I945GM(dev))
+                wm_params = &i945_wm_info;
+        else if (IS_I9XX(dev))
+                wm_params = &i915_wm_info;
+        else
+                wm_params = &i855_wm_info;
+
+        planea_entries = intel_calculate_wm(planea_clock, wm_params,
+                                            pixel_size, latency_ns);
+        planeb_entries = intel_calculate_wm(planeb_clock, wm_params,
+                                            pixel_size, latency_ns);
+
+        DRM_DEBUG("FIFO entries - A: %d, B: %d\n", planea_entries,
+                  planeb_entries);
+
+        if (IS_I9XX(dev)) {
+                asize = dsparb & 0x7f;
+                bsize = (dsparb >> DSPARB_CSTART_SHIFT) & 0x7f;
+        } else {
+                asize = dsparb & 0x1ff;
+                bsize = (dsparb >> DSPARB_BEND_SHIFT) & 0x1ff;
+        }
+        DRM_DEBUG("FIFO size - A: %d, B: %d\n", asize, bsize);
+
+        /* Two extra entries for padding */
+        awm = asize - (planea_entries + 2);
+        bwm = bsize - (planeb_entries + 2);
+
+        /* Sanity check against potentially bad FIFO allocations */
+        if (awm <= 0) {
+                /* pipe is on but has too few FIFO entries */
+                if (planea_entries != 0)
+                        DRM_DEBUG("plane A needs more FIFO entries\n");
+                awm = 1;
+        }
+        if (bwm <= 0) {
+                if (planeb_entries != 0)
+                        DRM_DEBUG("plane B needs more FIFO entries\n");
+                bwm = 1;
+        }
+
+        /*
+         * Overlay gets an aggressive default since video jitter is bad.
+         */
+        cwm = 2;
+
+        /* Calc sr entries for one pipe configs */
+        if (!planea_clock || !planeb_clock) {
+                sr_clock = planea_clock ? planea_clock : planeb_clock;
+                line_time_us = (sr_hdisplay * 1000) / sr_clock;
+                sr_entries = (((latency_ns / line_time_us) + 1) * pixel_size *
+                              sr_hdisplay) / 1000;
+                sr_entries = roundup(sr_entries / wm_params->cacheline_size, 1);
+                if (sr_entries < wm_params->fifo_size)
+                        srwm = wm_params->fifo_size - sr_entries;
+        }
+
+        DRM_DEBUG("Setting FIFO watermarks - A: %d, B: %d, C: %d, SR %d\n",
+                  awm, bwm, cwm, srwm);
+
+        fwater_lo = fwater_lo | ((bwm & 0x3f) << 16) | (awm & 0x3f);
+        fwater_hi = fwater_hi | (cwm & 0x1f);
+
+        I915_WRITE(FW_BLC, fwater_lo);
+        I915_WRITE(FW_BLC2, fwater_hi);
+        if (IS_I9XX(dev))
+                I915_WRITE(FW_BLC_SELF, FW_BLC_SELF_EN | (srwm & 0x3f));
+}
+
+static void i830_update_wm(struct drm_device *dev, int planea_clock,
+                           int pixel_size)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t dsparb = I915_READ(DSPARB);
+        uint32_t fwater_lo = I915_READ(FW_BLC) & MM_FIFO_WATERMARK;
+        unsigned int asize, awm;
+        int planea_entries;
+
+        planea_entries = intel_calculate_wm(planea_clock, &i830_wm_info,
+                                            pixel_size, latency_ns);
+
+        asize = dsparb & 0x7f;
+
+        awm = asize - planea_entries;
+
+        fwater_lo = fwater_lo | awm;
+
+        I915_WRITE(FW_BLC, fwater_lo);
+}
+
+/**
+ * intel_update_watermarks - update FIFO watermark values based on current modes
+ *
+ * Calculate watermark values for the various WM regs based on current mode
+ * and plane configuration.
+ *
+ * There are several cases to deal with here:
+ *   - normal (i.e. non-self-refresh)
+ *   - self-refresh (SR) mode
+ *   - lines are large relative to FIFO size (buffer can hold up to 2)
+ *   - lines are small relative to FIFO size (buffer can hold more than 2
+ *     lines), so need to account for TLB latency
+ *
+ *   The normal calculation is:
+ *     watermark = dotclock * bytes per pixel * latency
+ *   where latency is platform & configuration dependent (we assume pessimal
+ *   values here).
+ *
+ *   The SR calculation is:
+ *     watermark = (trunc(latency/line time)+1) * surface width *
+ *       bytes per pixel
+ *   where
+ *     line time = htotal / dotclock
+ *   and latency is assumed to be high, as above.
+ *
+ * The final value programmed to the register should always be rounded up,
+ * and include an extra 2 entries to account for clock crossings.
+ *
+ * We don't use the sprite, so we can ignore that.  And on Crestline we have
+ * to set the non-SR watermarks to 8.
+  */
+static void intel_update_watermarks(struct drm_device *dev)
+{
+        struct drm_crtc *crtc;
+        struct intel_crtc *intel_crtc;
+        int sr_hdisplay = 0;
+        unsigned long planea_clock = 0, planeb_clock = 0, sr_clock = 0;
+        int enabled = 0, pixel_size = 0;
+
+        if (DSPARB_HWCONTROL(dev))
+                return;
+
+        /* Get the clock config from both planes */
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                intel_crtc = to_intel_crtc(crtc);
+                if (crtc->enabled) {
+                        enabled++;
+                        if (intel_crtc->plane == 0) {
+                                DRM_DEBUG("plane A (pipe %d) clock: %d\n",
+                                          intel_crtc->pipe, crtc->mode.clock);
+                                planea_clock = crtc->mode.clock;
+                        } else {
+                                DRM_DEBUG("plane B (pipe %d) clock: %d\n",
+                                          intel_crtc->pipe, crtc->mode.clock);
+                                planeb_clock = crtc->mode.clock;
+                        }
+                        sr_hdisplay = crtc->mode.hdisplay;
+                        sr_clock = crtc->mode.clock;
+                        if (crtc->fb)
+                                pixel_size = crtc->fb->bits_per_pixel / 8;
+                        else
+                                pixel_size = 4; /* by default */
+                }
+        }
+
+        if (enabled <= 0)
+                return;
+
+        /* Single pipe configs can enable self refresh */
+        if (enabled == 1 && IS_IGD(dev))
+                igd_enable_cxsr(dev, sr_clock, pixel_size);
+        else if (IS_IGD(dev))
+                igd_disable_cxsr(dev);
+
+        if (IS_I965G(dev))
+                i965_update_wm(dev);
+        else if (IS_I9XX(dev) || IS_MOBILE(dev))
+                i9xx_update_wm(dev, planea_clock, planeb_clock, sr_hdisplay,
+                               pixel_size);
+        else
+                i830_update_wm(dev, planea_clock, pixel_size);
+}
+
 static int intel_crtc_mode_set(struct drm_crtc *crtc,
                                struct drm_display_mode *mode,
                                struct drm_display_mode *adjusted_mode,
@@ -1541,7 +2027,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         intel_clock_t clock;
         u32 dpll = 0, fp = 0, dspcntr, pipeconf;
         bool ok, is_sdvo = false, is_dvo = false;
-        bool is_crt = false, is_lvds = false, is_tv = false;
+        bool is_crt = false, is_lvds = false, is_tv = false, is_dp = false;
         struct drm_mode_config *mode_config = &dev->mode_config;
         struct drm_connector *connector;
         const intel_limit_t *limit;
@@ -1585,6 +2071,9 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 case INTEL_OUTPUT_ANALOG:
                         is_crt = true;
                         break;
+                case INTEL_OUTPUT_DISPLAYPORT:
+                        is_dp = true;
+                        break;
                 }
 
                 num_outputs++;
@@ -1600,6 +2089,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         } else {
                 refclk = 48000;
         }
+        
 
         /*
          * Returns a set of divisors for the desired target clock with the given
@@ -1662,6 +2152,8 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                         else if (IS_IGDNG(dev))
                                 dpll |= (sdvo_pixel_multiply - 1) << PLL_REF_SDVO_HDMI_MULTIPLIER_SHIFT;
                 }
+                if (is_dp)
+                        dpll |= DPLL_DVO_HIGH_SPEED;
 
                 /* compute bitmask from p1 value */
                 if (IS_IGD(dev))
@@ -1809,6 +2301,8 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 I915_WRITE(lvds_reg, lvds);
                 I915_READ(lvds_reg);
         }
+        if (is_dp)
+                intel_dp_set_m_n(crtc, mode, adjusted_mode);
 
         I915_WRITE(fp_reg, fp);
         I915_WRITE(dpll_reg, dpll);
@@ -1871,6 +2365,9 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
 
         /* Flush the plane changes */
         ret = intel_pipe_set_base(crtc, x, y, old_fb);
+
+        intel_update_watermarks(dev);
+
         drm_vblank_post_modeset(dev, pipe);
 
         return ret;
@@ -2359,6 +2856,7 @@ static void intel_crtc_init(struct drm_device *dev, int pipe)
 
         drm_mode_crtc_set_gamma_size(&intel_crtc->base, 256);
         intel_crtc->pipe = pipe;
+        intel_crtc->plane = pipe;
         for (i = 0; i < 256; i++) {
                 intel_crtc->lut_r[i] = i;
                 intel_crtc->lut_g[i] = i;
@@ -2475,6 +2973,8 @@ static void intel_setup_outputs(struct drm_device *dev)
                         found = intel_sdvo_init(dev, SDVOB);
                         if (!found && SUPPORTS_INTEGRATED_HDMI(dev))
                                 intel_hdmi_init(dev, SDVOB);
+                        if (!found && SUPPORTS_INTEGRATED_DP(dev))
+                                intel_dp_init(dev, DP_B);
                 }
 
                 /* Before G4X SDVOC doesn't have its own detect register */
@@ -2487,7 +2987,11 @@ static void intel_setup_outputs(struct drm_device *dev)
                         found = intel_sdvo_init(dev, SDVOC);
                         if (!found && SUPPORTS_INTEGRATED_HDMI(dev))
                                 intel_hdmi_init(dev, SDVOC);
+                        if (!found && SUPPORTS_INTEGRATED_DP(dev))
+                                intel_dp_init(dev, DP_C);
                 }
+                if (SUPPORTS_INTEGRATED_DP(dev) && (I915_READ(DP_D) & DP_DETECTED))
+                        intel_dp_init(dev, DP_D);
         } else
                 intel_dvo_init(dev);
 
@@ -2530,6 +3034,11 @@ static void intel_setup_outputs(struct drm_device *dev)
                                      (1 << 1));
                         clone_mask = (1 << INTEL_OUTPUT_TVOUT);
                         break;
+                case INTEL_OUTPUT_DISPLAYPORT:
+                        crtc_mask = ((1 << 0) |
+                                     (1 << 1));
+                        clone_mask = (1 << INTEL_OUTPUT_DISPLAYPORT);
+                        break;
                 }
                 encoder->possible_crtcs = crtc_mask;
                 encoder->possible_clones = intel_connector_clones(dev, clone_mask);
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
new file mode 100644
index 000000000000..6770ae88370d
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -0,0 +1,1156 @@
+/*
+ * Copyright © 2008 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Packard <keithp@keithp.com>
+ *
+ */
+
+#include <linux/i2c.h>
+#include "drmP.h"
+#include "drm.h"
+#include "drm_crtc.h"
+#include "drm_crtc_helper.h"
+#include "intel_drv.h"
+#include "i915_drm.h"
+#include "i915_drv.h"
+#include "intel_dp.h"
+
+#define DP_LINK_STATUS_SIZE     6
+#define DP_LINK_CHECK_TIMEOUT   (10 * 1000)
+
+#define DP_LINK_CONFIGURATION_SIZE      9
+
+struct intel_dp_priv {
+        uint32_t output_reg;
+        uint32_t DP;
+        uint8_t  link_configuration[DP_LINK_CONFIGURATION_SIZE];
+        uint32_t save_DP;
+        uint8_t  save_link_configuration[DP_LINK_CONFIGURATION_SIZE];
+        bool has_audio;
+        int dpms_mode;
+        uint8_t link_bw;
+        uint8_t lane_count;
+        uint8_t dpcd[4];
+        struct intel_output *intel_output;
+        struct i2c_adapter adapter;
+        struct i2c_algo_dp_aux_data algo;
+};
+
+static void
+intel_dp_link_train(struct intel_output *intel_output, uint32_t DP,
+                    uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE]);
+
+static void
+intel_dp_link_down(struct intel_output *intel_output, uint32_t DP);
+
+static int
+intel_dp_max_lane_count(struct intel_output *intel_output)
+{
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+        int max_lane_count = 4;
+
+        if (dp_priv->dpcd[0] >= 0x11) {
+                max_lane_count = dp_priv->dpcd[2] & 0x1f;
+                switch (max_lane_count) {
+                case 1: case 2: case 4:
+                        break;
+                default:
+                        max_lane_count = 4;
+                }
+        }
+        return max_lane_count;
+}
+
+static int
+intel_dp_max_link_bw(struct intel_output *intel_output)
+{
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+        int max_link_bw = dp_priv->dpcd[1];
+
+        switch (max_link_bw) {
+        case DP_LINK_BW_1_62:
+        case DP_LINK_BW_2_7:
+                break;
+        default:
+                max_link_bw = DP_LINK_BW_1_62;
+                break;
+        }
+        return max_link_bw;
+}
+
+static int
+intel_dp_link_clock(uint8_t link_bw)
+{
+        if (link_bw == DP_LINK_BW_2_7)
+                return 270000;
+        else
+                return 162000;
+}
+
+/* I think this is a fiction */
+static int
+intel_dp_link_required(int pixel_clock)
+{
+        return pixel_clock * 3;
+}
+
+static int
+intel_dp_mode_valid(struct drm_connector *connector,
+                    struct drm_display_mode *mode)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_output));
+        int max_lanes = intel_dp_max_lane_count(intel_output);
+
+        if (intel_dp_link_required(mode->clock) > max_link_clock * max_lanes)
+                return MODE_CLOCK_HIGH;
+
+        if (mode->clock < 10000)
+                return MODE_CLOCK_LOW;
+
+        return MODE_OK;
+}
+
+static uint32_t
+pack_aux(uint8_t *src, int src_bytes)
+{
+        int     i;
+        uint32_t v = 0;
+
+        if (src_bytes > 4)
+                src_bytes = 4;
+        for (i = 0; i < src_bytes; i++)
+                v |= ((uint32_t) src[i]) << ((3-i) * 8);
+        return v;
+}
+
+static void
+unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes)
+{
+        int i;
+        if (dst_bytes > 4)
+                dst_bytes = 4;
+        for (i = 0; i < dst_bytes; i++)
+                dst[i] = src >> ((3-i) * 8);
+}
+
+/* hrawclock is 1/4 the FSB frequency */
+static int
+intel_hrawclk(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t clkcfg;
+
+        clkcfg = I915_READ(CLKCFG);
+        switch (clkcfg & CLKCFG_FSB_MASK) {
+        case CLKCFG_FSB_400:
+                return 100;
+        case CLKCFG_FSB_533:
+                return 133;
+        case CLKCFG_FSB_667:
+                return 166;
+        case CLKCFG_FSB_800:
+                return 200;
+        case CLKCFG_FSB_1067:
+                return 266;
+        case CLKCFG_FSB_1333:
+                return 333;
+        /* these two are just a guess; one of them might be right */
+        case CLKCFG_FSB_1600:
+        case CLKCFG_FSB_1600_ALT:
+                return 400;
+        default:
+                return 133;
+        }
+}
+
+static int
+intel_dp_aux_ch(struct intel_output *intel_output,
+                uint8_t *send, int send_bytes,
+                uint8_t *recv, int recv_size)
+{
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint32_t output_reg = dp_priv->output_reg;
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t ch_ctl = output_reg + 0x10;
+        uint32_t ch_data = ch_ctl + 4;
+        int i;
+        int recv_bytes;
+        uint32_t ctl;
+        uint32_t status;
+        uint32_t aux_clock_divider;
+        int try;
+
+        /* The clock divider is based off the hrawclk,
+         * and would like to run at 2MHz. So, take the
+         * hrawclk value and divide by 2 and use that
+         */
+        aux_clock_divider = intel_hrawclk(dev) / 2;
+        /* Must try at least 3 times according to DP spec */
+        for (try = 0; try < 5; try++) {
+                /* Load the send data into the aux channel data registers */
+                for (i = 0; i < send_bytes; i += 4) {
+                        uint32_t    d = pack_aux(send + i, send_bytes - i);;
+        
+                        I915_WRITE(ch_data + i, d);
+                }
+        
+                ctl = (DP_AUX_CH_CTL_SEND_BUSY |
+                       DP_AUX_CH_CTL_TIME_OUT_400us |
+                       (send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
+                       (5 << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
+                       (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT) |
+                       DP_AUX_CH_CTL_DONE |
+                       DP_AUX_CH_CTL_TIME_OUT_ERROR |
+                       DP_AUX_CH_CTL_RECEIVE_ERROR);
+        
+                /* Send the command and wait for it to complete */
+                I915_WRITE(ch_ctl, ctl);
+                (void) I915_READ(ch_ctl);
+                for (;;) {
+                        udelay(100);
+                        status = I915_READ(ch_ctl);
+                        if ((status & DP_AUX_CH_CTL_SEND_BUSY) == 0)
+                                break;
+                }
+        
+                /* Clear done status and any errors */
+                I915_WRITE(ch_ctl, (ctl |
+                                DP_AUX_CH_CTL_DONE |
+                                DP_AUX_CH_CTL_TIME_OUT_ERROR |
+                                DP_AUX_CH_CTL_RECEIVE_ERROR));
+                (void) I915_READ(ch_ctl);
+                if ((status & DP_AUX_CH_CTL_TIME_OUT_ERROR) == 0)
+                        break;
+        }
+
+        if ((status & DP_AUX_CH_CTL_DONE) == 0) {
+                DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status);
+                return -EBUSY;
+        }
+
+        /* Check for timeout or receive error.
+         * Timeouts occur when the sink is not connected
+         */
+        if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) {
+                DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status);
+                return -EIO;
+        }
+
+        /* Timeouts occur when the device isn't connected, so they're
+         * "normal" -- don't fill the kernel log with these */
+        if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) {
+                DRM_DEBUG("dp_aux_ch timeout status 0x%08x\n", status);
+                return -ETIMEDOUT;
+        }
+
+        /* Unload any bytes sent back from the other side */
+        recv_bytes = ((status & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >>
+                      DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT);
+
+        if (recv_bytes > recv_size)
+                recv_bytes = recv_size;
+        
+        for (i = 0; i < recv_bytes; i += 4) {
+                uint32_t    d = I915_READ(ch_data + i);
+
+                unpack_aux(d, recv + i, recv_bytes - i);
+        }
+
+        return recv_bytes;
+}
+
+/* Write data to the aux channel in native mode */
+static int
+intel_dp_aux_native_write(struct intel_output *intel_output,
+                          uint16_t address, uint8_t *send, int send_bytes)
+{
+        int ret;
+        uint8_t msg[20];
+        int msg_bytes;
+        uint8_t ack;
+
+        if (send_bytes > 16)
+                return -1;
+        msg[0] = AUX_NATIVE_WRITE << 4;
+        msg[1] = address >> 8;
+        msg[2] = address;
+        msg[3] = send_bytes - 1;
+        memcpy(&msg[4], send, send_bytes);
+        msg_bytes = send_bytes + 4;
+        for (;;) {
+                ret = intel_dp_aux_ch(intel_output, msg, msg_bytes, &ack, 1);
+                if (ret < 0)
+                        return ret;
+                if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK)
+                        break;
+                else if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_DEFER)
+                        udelay(100);
+                else
+                        return -EIO;
+        }
+        return send_bytes;
+}
+
+/* Write a single byte to the aux channel in native mode */
+static int
+intel_dp_aux_native_write_1(struct intel_output *intel_output,
+                            uint16_t address, uint8_t byte)
+{
+        return intel_dp_aux_native_write(intel_output, address, &byte, 1);
+}
+
+/* read bytes from a native aux channel */
+static int
+intel_dp_aux_native_read(struct intel_output *intel_output,
+                         uint16_t address, uint8_t *recv, int recv_bytes)
+{
+        uint8_t msg[4];
+        int msg_bytes;
+        uint8_t reply[20];
+        int reply_bytes;
+        uint8_t ack;
+        int ret;
+
+        msg[0] = AUX_NATIVE_READ << 4;
+        msg[1] = address >> 8;
+        msg[2] = address & 0xff;
+        msg[3] = recv_bytes - 1;
+
+        msg_bytes = 4;
+        reply_bytes = recv_bytes + 1;
+
+        for (;;) {
+                ret = intel_dp_aux_ch(intel_output, msg, msg_bytes,
+                                      reply, reply_bytes);
+                if (ret == 0)
+                        return -EPROTO;
+                if (ret < 0)
+                        return ret;
+                ack = reply[0];
+                if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK) {
+                        memcpy(recv, reply + 1, ret - 1);
+                        return ret - 1;
+                }
+                else if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_DEFER)
+                        udelay(100);
+                else
+                        return -EIO;
+        }
+}
+
+static int
+intel_dp_i2c_aux_ch(struct i2c_adapter *adapter,
+                    uint8_t *send, int send_bytes,
+                    uint8_t *recv, int recv_bytes)
+{
+        struct intel_dp_priv *dp_priv = container_of(adapter,
+                                                     struct intel_dp_priv,
+                                                     adapter);
+        struct intel_output *intel_output = dp_priv->intel_output;
+
+        return intel_dp_aux_ch(intel_output,
+                               send, send_bytes, recv, recv_bytes);
+}
+
+static int
+intel_dp_i2c_init(struct intel_output *intel_output, const char *name)
+{
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+
+        DRM_ERROR("i2c_init %s\n", name);
+        dp_priv->algo.running = false;
+        dp_priv->algo.address = 0;
+        dp_priv->algo.aux_ch = intel_dp_i2c_aux_ch;
+
+        memset(&dp_priv->adapter, '\0', sizeof (dp_priv->adapter));
+        dp_priv->adapter.owner = THIS_MODULE;
+        dp_priv->adapter.class = I2C_CLASS_DDC;
+        strncpy (dp_priv->adapter.name, name, sizeof dp_priv->adapter.name - 1);
+        dp_priv->adapter.name[sizeof dp_priv->adapter.name - 1] = '\0';
+        dp_priv->adapter.algo_data = &dp_priv->algo;
+        dp_priv->adapter.dev.parent = &intel_output->base.kdev;
+        
+        return i2c_dp_aux_add_bus(&dp_priv->adapter);
+}
+
+static bool
+intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode,
+                    struct drm_display_mode *adjusted_mode)
+{
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+        int lane_count, clock;
+        int max_lane_count = intel_dp_max_lane_count(intel_output);
+        int max_clock = intel_dp_max_link_bw(intel_output) == DP_LINK_BW_2_7 ? 1 : 0;
+        static int bws[2] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7 };
+
+        for (lane_count = 1; lane_count <= max_lane_count; lane_count <<= 1) {
+                for (clock = 0; clock <= max_clock; clock++) {
+                        int link_avail = intel_dp_link_clock(bws[clock]) * lane_count;
+
+                        if (intel_dp_link_required(mode->clock) <= link_avail) {
+                                dp_priv->link_bw = bws[clock];
+                                dp_priv->lane_count = lane_count;
+                                adjusted_mode->clock = intel_dp_link_clock(dp_priv->link_bw);
+                                DRM_DEBUG("Display port link bw %02x lane count %d clock %d\n",
+                                       dp_priv->link_bw, dp_priv->lane_count,
+                                       adjusted_mode->clock);
+                                return true;
+                        }
+                }
+        }
+        return false;
+}
+
+struct intel_dp_m_n {
+        uint32_t        tu;
+        uint32_t        gmch_m;
+        uint32_t        gmch_n;
+        uint32_t        link_m;
+        uint32_t        link_n;
+};
+
+static void
+intel_reduce_ratio(uint32_t *num, uint32_t *den)
+{
+        while (*num > 0xffffff || *den > 0xffffff) {
+                *num >>= 1;
+                *den >>= 1;
+        }
+}
+
+static void
+intel_dp_compute_m_n(int bytes_per_pixel,
+                     int nlanes,
+                     int pixel_clock,
+                     int link_clock,
+                     struct intel_dp_m_n *m_n)
+{
+        m_n->tu = 64;
+        m_n->gmch_m = pixel_clock * bytes_per_pixel;
+        m_n->gmch_n = link_clock * nlanes;
+        intel_reduce_ratio(&m_n->gmch_m, &m_n->gmch_n);
+        m_n->link_m = pixel_clock;
+        m_n->link_n = link_clock;
+        intel_reduce_ratio(&m_n->link_m, &m_n->link_n);
+}
+
+void
+intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode,
+                 struct drm_display_mode *adjusted_mode)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_connector *connector;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        int lane_count = 4;
+        struct intel_dp_m_n m_n;
+
+        /*
+         * Find the lane count in the intel_output private
+         */
+        list_for_each_entry(connector, &mode_config->connector_list, head) {
+                struct intel_output *intel_output = to_intel_output(connector);
+                struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+                if (!connector->encoder || connector->encoder->crtc != crtc)
+                        continue;
+
+                if (intel_output->type == INTEL_OUTPUT_DISPLAYPORT) {
+                        lane_count = dp_priv->lane_count;
+                        break;
+                }
+        }
+
+        /*
+         * Compute the GMCH and Link ratios. The '3' here is
+         * the number of bytes_per_pixel post-LUT, which we always
+         * set up for 8-bits of R/G/B, or 3 bytes total.
+         */
+        intel_dp_compute_m_n(3, lane_count,
+                             mode->clock, adjusted_mode->clock, &m_n);
+
+        if (intel_crtc->pipe == 0) {
+                I915_WRITE(PIPEA_GMCH_DATA_M,
+                       ((m_n.tu - 1) << PIPE_GMCH_DATA_M_TU_SIZE_SHIFT) |
+                       m_n.gmch_m);
+                I915_WRITE(PIPEA_GMCH_DATA_N,
+                       m_n.gmch_n);
+                I915_WRITE(PIPEA_DP_LINK_M, m_n.link_m);
+                I915_WRITE(PIPEA_DP_LINK_N, m_n.link_n);
+        } else {
+                I915_WRITE(PIPEB_GMCH_DATA_M,
+                       ((m_n.tu - 1) << PIPE_GMCH_DATA_M_TU_SIZE_SHIFT) |
+                       m_n.gmch_m);
+                I915_WRITE(PIPEB_GMCH_DATA_N,
+                       m_n.gmch_n);
+                I915_WRITE(PIPEB_DP_LINK_M, m_n.link_m);
+                I915_WRITE(PIPEB_DP_LINK_N, m_n.link_n);
+        }
+}
+
+static void
+intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
+                  struct drm_display_mode *adjusted_mode)
+{
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        struct drm_crtc *crtc = intel_output->enc.crtc;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+
+        dp_priv->DP = (DP_LINK_TRAIN_OFF |
+                        DP_VOLTAGE_0_4 |
+                        DP_PRE_EMPHASIS_0 |
+                        DP_SYNC_VS_HIGH |
+                        DP_SYNC_HS_HIGH);
+
+        switch (dp_priv->lane_count) {
+        case 1:
+                dp_priv->DP |= DP_PORT_WIDTH_1;
+                break;
+        case 2:
+                dp_priv->DP |= DP_PORT_WIDTH_2;
+                break;
+        case 4:
+                dp_priv->DP |= DP_PORT_WIDTH_4;
+                break;
+        }
+        if (dp_priv->has_audio)
+                dp_priv->DP |= DP_AUDIO_OUTPUT_ENABLE;
+
+        memset(dp_priv->link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
+        dp_priv->link_configuration[0] = dp_priv->link_bw;
+        dp_priv->link_configuration[1] = dp_priv->lane_count;
+
+        /*
+         * Check for DPCD version > 1.1,
+         * enable enahanced frame stuff in that case
+         */
+        if (dp_priv->dpcd[0] >= 0x11) {
+                dp_priv->link_configuration[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
+                dp_priv->DP |= DP_ENHANCED_FRAMING;
+        }
+
+        if (intel_crtc->pipe == 1)
+                dp_priv->DP |= DP_PIPEB_SELECT;
+}
+
+
+static void
+intel_dp_dpms(struct drm_encoder *encoder, int mode)
+{
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t dp_reg = I915_READ(dp_priv->output_reg);
+
+        if (mode != DRM_MODE_DPMS_ON) {
+                if (dp_reg & DP_PORT_EN)
+                        intel_dp_link_down(intel_output, dp_priv->DP);
+        } else {
+                if (!(dp_reg & DP_PORT_EN))
+                        intel_dp_link_train(intel_output, dp_priv->DP, dp_priv->link_configuration);
+        }
+        dp_priv->dpms_mode = mode;
+}
+
+/*
+ * Fetch AUX CH registers 0x202 - 0x207 which contain
+ * link status information
+ */
+static bool
+intel_dp_get_link_status(struct intel_output *intel_output,
+                         uint8_t link_status[DP_LINK_STATUS_SIZE])
+{
+        int ret;
+
+        ret = intel_dp_aux_native_read(intel_output,
+                                       DP_LANE0_1_STATUS,
+                                       link_status, DP_LINK_STATUS_SIZE);
+        if (ret != DP_LINK_STATUS_SIZE)
+                return false;
+        return true;
+}
+
+static uint8_t
+intel_dp_link_status(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                     int r)
+{
+        return link_status[r - DP_LANE0_1_STATUS];
+}
+
+static void
+intel_dp_save(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        dp_priv->save_DP = I915_READ(dp_priv->output_reg);
+        intel_dp_aux_native_read(intel_output, DP_LINK_BW_SET,
+                                 dp_priv->save_link_configuration,
+                                 sizeof (dp_priv->save_link_configuration));
+}
+
+static uint8_t
+intel_get_adjust_request_voltage(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                                 int lane)
+{
+        int         i = DP_ADJUST_REQUEST_LANE0_1 + (lane >> 1);
+        int         s = ((lane & 1) ?
+                         DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT :
+                         DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT);
+        uint8_t l = intel_dp_link_status(link_status, i);
+
+        return ((l >> s) & 3) << DP_TRAIN_VOLTAGE_SWING_SHIFT;
+}
+
+static uint8_t
+intel_get_adjust_request_pre_emphasis(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                                      int lane)
+{
+        int         i = DP_ADJUST_REQUEST_LANE0_1 + (lane >> 1);
+        int         s = ((lane & 1) ?
+                         DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT :
+                         DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT);
+        uint8_t l = intel_dp_link_status(link_status, i);
+
+        return ((l >> s) & 3) << DP_TRAIN_PRE_EMPHASIS_SHIFT;
+}
+
+
+#if 0
+static char     *voltage_names[] = {
+        "0.4V", "0.6V", "0.8V", "1.2V"
+};
+static char     *pre_emph_names[] = {
+        "0dB", "3.5dB", "6dB", "9.5dB"
+};
+static char     *link_train_names[] = {
+        "pattern 1", "pattern 2", "idle", "off"
+};
+#endif
+
+/*
+ * These are source-specific values; current Intel hardware supports
+ * a maximum voltage of 800mV and a maximum pre-emphasis of 6dB
+ */
+#define I830_DP_VOLTAGE_MAX         DP_TRAIN_VOLTAGE_SWING_800
+
+static uint8_t
+intel_dp_pre_emphasis_max(uint8_t voltage_swing)
+{
+        switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
+        case DP_TRAIN_VOLTAGE_SWING_400:
+                return DP_TRAIN_PRE_EMPHASIS_6;
+        case DP_TRAIN_VOLTAGE_SWING_600:
+                return DP_TRAIN_PRE_EMPHASIS_6;
+        case DP_TRAIN_VOLTAGE_SWING_800:
+                return DP_TRAIN_PRE_EMPHASIS_3_5;
+        case DP_TRAIN_VOLTAGE_SWING_1200:
+        default:
+                return DP_TRAIN_PRE_EMPHASIS_0;
+        }
+}
+
+static void
+intel_get_adjust_train(struct intel_output *intel_output,
+                       uint8_t link_status[DP_LINK_STATUS_SIZE],
+                       int lane_count,
+                       uint8_t train_set[4])
+{
+        uint8_t v = 0;
+        uint8_t p = 0;
+        int lane;
+
+        for (lane = 0; lane < lane_count; lane++) {
+                uint8_t this_v = intel_get_adjust_request_voltage(link_status, lane);
+                uint8_t this_p = intel_get_adjust_request_pre_emphasis(link_status, lane);
+
+                if (this_v > v)
+                        v = this_v;
+                if (this_p > p)
+                        p = this_p;
+        }
+
+        if (v >= I830_DP_VOLTAGE_MAX)
+                v = I830_DP_VOLTAGE_MAX | DP_TRAIN_MAX_SWING_REACHED;
+
+        if (p >= intel_dp_pre_emphasis_max(v))
+                p = intel_dp_pre_emphasis_max(v) | DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
+
+        for (lane = 0; lane < 4; lane++)
+                train_set[lane] = v | p;
+}
+
+static uint32_t
+intel_dp_signal_levels(uint8_t train_set, int lane_count)
+{
+        uint32_t        signal_levels = 0;
+
+        switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
+        case DP_TRAIN_VOLTAGE_SWING_400:
+        default:
+                signal_levels |= DP_VOLTAGE_0_4;
+                break;
+        case DP_TRAIN_VOLTAGE_SWING_600:
+                signal_levels |= DP_VOLTAGE_0_6;
+                break;
+        case DP_TRAIN_VOLTAGE_SWING_800:
+                signal_levels |= DP_VOLTAGE_0_8;
+                break;
+        case DP_TRAIN_VOLTAGE_SWING_1200:
+                signal_levels |= DP_VOLTAGE_1_2;
+                break;
+        }
+        switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
+        case DP_TRAIN_PRE_EMPHASIS_0:
+        default:
+                signal_levels |= DP_PRE_EMPHASIS_0;
+                break;
+        case DP_TRAIN_PRE_EMPHASIS_3_5:
+                signal_levels |= DP_PRE_EMPHASIS_3_5;
+                break;
+        case DP_TRAIN_PRE_EMPHASIS_6:
+                signal_levels |= DP_PRE_EMPHASIS_6;
+                break;
+        case DP_TRAIN_PRE_EMPHASIS_9_5:
+                signal_levels |= DP_PRE_EMPHASIS_9_5;
+                break;
+        }
+        return signal_levels;
+}
+
+static uint8_t
+intel_get_lane_status(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                      int lane)
+{
+        int i = DP_LANE0_1_STATUS + (lane >> 1);
+        int s = (lane & 1) * 4;
+        uint8_t l = intel_dp_link_status(link_status, i);
+
+        return (l >> s) & 0xf;
+}
+
+/* Check for clock recovery is done on all channels */
+static bool
+intel_clock_recovery_ok(uint8_t link_status[DP_LINK_STATUS_SIZE], int lane_count)
+{
+        int lane;
+        uint8_t lane_status;
+
+        for (lane = 0; lane < lane_count; lane++) {
+                lane_status = intel_get_lane_status(link_status, lane);
+                if ((lane_status & DP_LANE_CR_DONE) == 0)
+                        return false;
+        }
+        return true;
+}
+
+/* Check to see if channel eq is done on all channels */
+#define CHANNEL_EQ_BITS (DP_LANE_CR_DONE|\
+                         DP_LANE_CHANNEL_EQ_DONE|\
+                         DP_LANE_SYMBOL_LOCKED)
+static bool
+intel_channel_eq_ok(uint8_t link_status[DP_LINK_STATUS_SIZE], int lane_count)
+{
+        uint8_t lane_align;
+        uint8_t lane_status;
+        int lane;
+
+        lane_align = intel_dp_link_status(link_status,
+                                          DP_LANE_ALIGN_STATUS_UPDATED);
+        if ((lane_align & DP_INTERLANE_ALIGN_DONE) == 0)
+                return false;
+        for (lane = 0; lane < lane_count; lane++) {
+                lane_status = intel_get_lane_status(link_status, lane);
+                if ((lane_status & CHANNEL_EQ_BITS) != CHANNEL_EQ_BITS)
+                        return false;
+        }
+        return true;
+}
+
+static bool
+intel_dp_set_link_train(struct intel_output *intel_output,
+                        uint32_t dp_reg_value,
+                        uint8_t dp_train_pat,
+                        uint8_t train_set[4],
+                        bool first)
+{
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        int ret;
+
+        I915_WRITE(dp_priv->output_reg, dp_reg_value);
+        POSTING_READ(dp_priv->output_reg);
+        if (first)
+                intel_wait_for_vblank(dev);
+
+        intel_dp_aux_native_write_1(intel_output,
+                                    DP_TRAINING_PATTERN_SET,
+                                    dp_train_pat);
+
+        ret = intel_dp_aux_native_write(intel_output,
+                                        DP_TRAINING_LANE0_SET, train_set, 4);
+        if (ret != 4)
+                return false;
+
+        return true;
+}
+
+static void
+intel_dp_link_train(struct intel_output *intel_output, uint32_t DP,
+                    uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE])
+{
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint8_t train_set[4];
+        uint8_t link_status[DP_LINK_STATUS_SIZE];
+        int i;
+        uint8_t voltage;
+        bool clock_recovery = false;
+        bool channel_eq = false;
+        bool first = true;
+        int tries;
+
+        /* Write the link configuration data */
+        intel_dp_aux_native_write(intel_output, 0x100,
+                                  link_configuration, DP_LINK_CONFIGURATION_SIZE);
+
+        DP |= DP_PORT_EN;
+        DP &= ~DP_LINK_TRAIN_MASK;
+        memset(train_set, 0, 4);
+        voltage = 0xff;
+        tries = 0;
+        clock_recovery = false;
+        for (;;) {
+                /* Use train_set[0] to set the voltage and pre emphasis values */
+                uint32_t    signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count);
+                DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels;
+
+                if (!intel_dp_set_link_train(intel_output, DP | DP_LINK_TRAIN_PAT_1,
+                                             DP_TRAINING_PATTERN_1, train_set, first))
+                        break;
+                first = false;
+                /* Set training pattern 1 */
+
+                udelay(100);
+                if (!intel_dp_get_link_status(intel_output, link_status))
+                        break;
+
+                if (intel_clock_recovery_ok(link_status, dp_priv->lane_count)) {
+                        clock_recovery = true;
+                        break;
+                }
+
+                /* Check to see if we've tried the max voltage */
+                for (i = 0; i < dp_priv->lane_count; i++)
+                        if ((train_set[i] & DP_TRAIN_MAX_SWING_REACHED) == 0)
+                                break;
+                if (i == dp_priv->lane_count)
+                        break;
+
+                /* Check to see if we've tried the same voltage 5 times */
+                if ((train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK) == voltage) {
+                        ++tries;
+                        if (tries == 5)
+                                break;
+                } else
+                        tries = 0;
+                voltage = train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
+
+                /* Compute new train_set as requested by target */
+                intel_get_adjust_train(intel_output, link_status, dp_priv->lane_count, train_set);
+        }
+
+        /* channel equalization */
+        tries = 0;
+        channel_eq = false;
+        for (;;) {
+                /* Use train_set[0] to set the voltage and pre emphasis values */
+                uint32_t    signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count);
+                DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels;
+
+                /* channel eq pattern */
+                if (!intel_dp_set_link_train(intel_output, DP | DP_LINK_TRAIN_PAT_2,
+                                             DP_TRAINING_PATTERN_2, train_set,
+                                             false))
+                        break;
+
+                udelay(400);
+                if (!intel_dp_get_link_status(intel_output, link_status))
+                        break;
+
+                if (intel_channel_eq_ok(link_status, dp_priv->lane_count)) {
+                        channel_eq = true;
+                        break;
+                }
+
+                /* Try 5 times */
+                if (tries > 5)
+                        break;
+
+                /* Compute new train_set as requested by target */
+                intel_get_adjust_train(intel_output, link_status, dp_priv->lane_count, train_set);
+                ++tries;
+        }
+
+        I915_WRITE(dp_priv->output_reg, DP | DP_LINK_TRAIN_OFF);
+        POSTING_READ(dp_priv->output_reg);
+        intel_dp_aux_native_write_1(intel_output,
+                                    DP_TRAINING_PATTERN_SET, DP_TRAINING_PATTERN_DISABLE);
+}
+
+static void
+intel_dp_link_down(struct intel_output *intel_output, uint32_t DP)
+{
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        I915_WRITE(dp_priv->output_reg, DP & ~DP_PORT_EN);
+        POSTING_READ(dp_priv->output_reg);
+}
+
+static void
+intel_dp_restore(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        if (dp_priv->save_DP & DP_PORT_EN)
+                intel_dp_link_train(intel_output, dp_priv->save_DP, dp_priv->save_link_configuration);
+        else
+                intel_dp_link_down(intel_output,  dp_priv->save_DP);
+}
+
+/*
+ * According to DP spec
+ * 5.1.2:
+ *  1. Read DPCD
+ *  2. Configure link according to Receiver Capabilities
+ *  3. Use Link Training from 2.5.3.3 and 3.5.1.3
+ *  4. Check link status on receipt of hot-plug interrupt
+ */
+
+static void
+intel_dp_check_link_status(struct intel_output *intel_output)
+{
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint8_t link_status[DP_LINK_STATUS_SIZE];
+
+        if (!intel_output->enc.crtc)
+                return;
+
+        if (!intel_dp_get_link_status(intel_output, link_status)) {
+                intel_dp_link_down(intel_output, dp_priv->DP);
+                return;
+        }
+
+        if (!intel_channel_eq_ok(link_status, dp_priv->lane_count))
+                intel_dp_link_train(intel_output, dp_priv->DP, dp_priv->link_configuration);
+}
+
+/**
+ * Uses CRT_HOTPLUG_EN and CRT_HOTPLUG_STAT to detect DP connection.
+ *
+ * \return true if DP port is connected.
+ * \return false if DP port is disconnected.
+ */
+static enum drm_connector_status
+intel_dp_detect(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint32_t temp, bit;
+        enum drm_connector_status status;
+
+        dp_priv->has_audio = false;
+
+        temp = I915_READ(PORT_HOTPLUG_EN);
+
+        I915_WRITE(PORT_HOTPLUG_EN,
+               temp |
+               DPB_HOTPLUG_INT_EN |
+               DPC_HOTPLUG_INT_EN |
+               DPD_HOTPLUG_INT_EN);
+
+        POSTING_READ(PORT_HOTPLUG_EN);
+
+        switch (dp_priv->output_reg) {
+        case DP_B:
+                bit = DPB_HOTPLUG_INT_STATUS;
+                break;
+        case DP_C:
+                bit = DPC_HOTPLUG_INT_STATUS;
+                break;
+        case DP_D:
+                bit = DPD_HOTPLUG_INT_STATUS;
+                break;
+        default:
+                return connector_status_unknown;
+        }
+
+        temp = I915_READ(PORT_HOTPLUG_STAT);
+
+        if ((temp & bit) == 0)
+                return connector_status_disconnected;
+
+        status = connector_status_disconnected;
+        if (intel_dp_aux_native_read(intel_output,
+                                     0x000, dp_priv->dpcd,
+                                     sizeof (dp_priv->dpcd)) == sizeof (dp_priv->dpcd))
+        {
+                if (dp_priv->dpcd[0] != 0)
+                        status = connector_status_connected;
+        }
+        return status;
+}
+
+static int intel_dp_get_modes(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+
+        /* We should parse the EDID data and find out if it has an audio sink
+         */
+
+        return intel_ddc_get_modes(intel_output);
+}
+
+static void
+intel_dp_destroy (struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+
+        if (intel_output->i2c_bus)
+                intel_i2c_destroy(intel_output->i2c_bus);
+        drm_sysfs_connector_remove(connector);
+        drm_connector_cleanup(connector);
+        kfree(intel_output);
+}
+
+static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = {
+        .dpms = intel_dp_dpms,
+        .mode_fixup = intel_dp_mode_fixup,
+        .prepare = intel_encoder_prepare,
+        .mode_set = intel_dp_mode_set,
+        .commit = intel_encoder_commit,
+};
+
+static const struct drm_connector_funcs intel_dp_connector_funcs = {
+        .dpms = drm_helper_connector_dpms,
+        .save = intel_dp_save,
+        .restore = intel_dp_restore,
+        .detect = intel_dp_detect,
+        .fill_modes = drm_helper_probe_single_connector_modes,
+        .destroy = intel_dp_destroy,
+};
+
+static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs = {
+        .get_modes = intel_dp_get_modes,
+        .mode_valid = intel_dp_mode_valid,
+        .best_encoder = intel_best_encoder,
+};
+
+static void intel_dp_enc_destroy(struct drm_encoder *encoder)
+{
+        drm_encoder_cleanup(encoder);
+}
+
+static const struct drm_encoder_funcs intel_dp_enc_funcs = {
+        .destroy = intel_dp_enc_destroy,
+};
+
+void
+intel_dp_hot_plug(struct intel_output *intel_output)
+{
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        if (dp_priv->dpms_mode == DRM_MODE_DPMS_ON)
+                intel_dp_check_link_status(intel_output);
+}
+
+void
+intel_dp_init(struct drm_device *dev, int output_reg)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_connector *connector;
+        struct intel_output *intel_output;
+        struct intel_dp_priv *dp_priv;
+
+        intel_output = kcalloc(sizeof(struct intel_output) + 
+                               sizeof(struct intel_dp_priv), 1, GFP_KERNEL);
+        if (!intel_output)
+                return;
+
+        dp_priv = (struct intel_dp_priv *)(intel_output + 1);
+
+        connector = &intel_output->base;
+        drm_connector_init(dev, connector, &intel_dp_connector_funcs,
+                           DRM_MODE_CONNECTOR_DisplayPort);
+        drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs);
+
+        intel_output->type = INTEL_OUTPUT_DISPLAYPORT;
+
+        connector->interlace_allowed = true;
+        connector->doublescan_allowed = 0;
+
+        dp_priv->intel_output = intel_output;
+        dp_priv->output_reg = output_reg;
+        dp_priv->has_audio = false;
+        dp_priv->dpms_mode = DRM_MODE_DPMS_ON;
+        intel_output->dev_priv = dp_priv;
+
+        drm_encoder_init(dev, &intel_output->enc, &intel_dp_enc_funcs,
+                         DRM_MODE_ENCODER_TMDS);
+        drm_encoder_helper_add(&intel_output->enc, &intel_dp_helper_funcs);
+
+        drm_mode_connector_attach_encoder(&intel_output->base,
+                                          &intel_output->enc);
+        drm_sysfs_connector_add(connector);
+
+        /* Set up the DDC bus. */
+        intel_dp_i2c_init(intel_output,
+                          (output_reg == DP_B) ? "DPDDC-B" :
+                          (output_reg == DP_C) ? "DPDDC-C" : "DPDDC-D");
+        intel_output->ddc_bus = &dp_priv->adapter;
+        intel_output->hot_plug = intel_dp_hot_plug;
+
+        /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
+         * 0xd.  Failure to do so will result in spurious interrupts being
+         * generated on the port when a cable is not attached.
+         */
+        if (IS_G4X(dev) && !IS_GM45(dev)) {
+                u32 temp = I915_READ(PEG_BAND_GAP_DATA);
+                I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd);
+        }
+}
diff --git a/drivers/gpu/drm/i915/intel_dp.h b/drivers/gpu/drm/i915/intel_dp.h
new file mode 100644
index 000000000000..2b38054d3b6d
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_dp.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright © 2008 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _INTEL_DP_H_
+#define _INTEL_DP_H_
+
+/* From the VESA DisplayPort spec */
+
+#define AUX_NATIVE_WRITE        0x8
+#define AUX_NATIVE_READ         0x9
+#define AUX_I2C_WRITE           0x0
+#define AUX_I2C_READ            0x1
+#define AUX_I2C_STATUS          0x2
+#define AUX_I2C_MOT             0x4
+
+#define AUX_NATIVE_REPLY_ACK    (0x0 << 4)
+#define AUX_NATIVE_REPLY_NACK   (0x1 << 4)
+#define AUX_NATIVE_REPLY_DEFER  (0x2 << 4)
+#define AUX_NATIVE_REPLY_MASK   (0x3 << 4)
+
+#define AUX_I2C_REPLY_ACK       (0x0 << 6)
+#define AUX_I2C_REPLY_NACK      (0x1 << 6)
+#define AUX_I2C_REPLY_DEFER     (0x2 << 6)
+#define AUX_I2C_REPLY_MASK      (0x3 << 6)
+
+/* AUX CH addresses */
+#define DP_LINK_BW_SET          0x100
+# define DP_LINK_BW_1_62                    0x06
+# define DP_LINK_BW_2_7                     0x0a
+
+#define DP_LANE_COUNT_SET       0x101
+# define DP_LANE_COUNT_MASK                 0x0f
+# define DP_LANE_COUNT_ENHANCED_FRAME_EN    (1 << 7)
+
+#define DP_TRAINING_PATTERN_SET 0x102
+
+# define DP_TRAINING_PATTERN_DISABLE        0
+# define DP_TRAINING_PATTERN_1              1
+# define DP_TRAINING_PATTERN_2              2
+# define DP_TRAINING_PATTERN_MASK           0x3
+
+# define DP_LINK_QUAL_PATTERN_DISABLE       (0 << 2)
+# define DP_LINK_QUAL_PATTERN_D10_2         (1 << 2)
+# define DP_LINK_QUAL_PATTERN_ERROR_RATE    (2 << 2)
+# define DP_LINK_QUAL_PATTERN_PRBS7         (3 << 2)
+# define DP_LINK_QUAL_PATTERN_MASK          (3 << 2)
+
+# define DP_RECOVERED_CLOCK_OUT_EN          (1 << 4)
+# define DP_LINK_SCRAMBLING_DISABLE         (1 << 5)
+
+# define DP_SYMBOL_ERROR_COUNT_BOTH         (0 << 6)
+# define DP_SYMBOL_ERROR_COUNT_DISPARITY    (1 << 6)
+# define DP_SYMBOL_ERROR_COUNT_SYMBOL       (2 << 6)
+# define DP_SYMBOL_ERROR_COUNT_MASK         (3 << 6)
+
+#define DP_TRAINING_LANE0_SET               0x103
+#define DP_TRAINING_LANE1_SET               0x104
+#define DP_TRAINING_LANE2_SET               0x105
+#define DP_TRAINING_LANE3_SET               0x106
+
+# define DP_TRAIN_VOLTAGE_SWING_MASK        0x3
+# define DP_TRAIN_VOLTAGE_SWING_SHIFT       0
+# define DP_TRAIN_MAX_SWING_REACHED         (1 << 2)
+# define DP_TRAIN_VOLTAGE_SWING_400         (0 << 0)
+# define DP_TRAIN_VOLTAGE_SWING_600         (1 << 0)
+# define DP_TRAIN_VOLTAGE_SWING_800         (2 << 0)
+# define DP_TRAIN_VOLTAGE_SWING_1200        (3 << 0)
+
+# define DP_TRAIN_PRE_EMPHASIS_MASK         (3 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_0            (0 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_3_5          (1 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_6            (2 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_9_5          (3 << 3)
+
+# define DP_TRAIN_PRE_EMPHASIS_SHIFT        3
+# define DP_TRAIN_MAX_PRE_EMPHASIS_REACHED  (1 << 5)
+
+#define DP_DOWNSPREAD_CTRL                  0x107
+# define DP_SPREAD_AMP_0_5                  (1 << 4)
+
+#define DP_MAIN_LINK_CHANNEL_CODING_SET     0x108
+# define DP_SET_ANSI_8B10B                  (1 << 0)
+
+#define DP_LANE0_1_STATUS                   0x202
+#define DP_LANE2_3_STATUS                   0x203
+
+# define DP_LANE_CR_DONE                    (1 << 0)
+# define DP_LANE_CHANNEL_EQ_DONE            (1 << 1)
+# define DP_LANE_SYMBOL_LOCKED              (1 << 2)
+
+#define DP_LANE_ALIGN_STATUS_UPDATED        0x204
+
+#define DP_INTERLANE_ALIGN_DONE             (1 << 0)
+#define DP_DOWNSTREAM_PORT_STATUS_CHANGED   (1 << 6)
+#define DP_LINK_STATUS_UPDATED              (1 << 7)
+
+#define DP_SINK_STATUS                      0x205
+
+#define DP_RECEIVE_PORT_0_STATUS            (1 << 0)
+#define DP_RECEIVE_PORT_1_STATUS            (1 << 1)
+
+#define DP_ADJUST_REQUEST_LANE0_1           0x206
+#define DP_ADJUST_REQUEST_LANE2_3           0x207
+
+#define DP_ADJUST_VOLTAGE_SWING_LANE0_MASK  0x03
+#define DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT 0
+#define DP_ADJUST_PRE_EMPHASIS_LANE0_MASK   0x0c
+#define DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT  2
+#define DP_ADJUST_VOLTAGE_SWING_LANE1_MASK  0x30
+#define DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT 4
+#define DP_ADJUST_PRE_EMPHASIS_LANE1_MASK   0xc0
+#define DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT  6
+
+struct i2c_algo_dp_aux_data {
+        bool running;
+        u16 address;
+        int (*aux_ch) (struct i2c_adapter *adapter,
+                       uint8_t *send, int send_bytes,
+                       uint8_t *recv, int recv_bytes);
+};
+
+int
+i2c_dp_aux_add_bus(struct i2c_adapter *adapter);
+
+#endif /* _INTEL_DP_H_ */
diff --git a/drivers/gpu/drm/i915/intel_dp_i2c.c b/drivers/gpu/drm/i915/intel_dp_i2c.c
new file mode 100644
index 000000000000..a63b6f57d2d4
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_dp_i2c.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright © 2009 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/i2c.h>
+#include "intel_dp.h"
+#include "drmP.h"
+
+/* Run a single AUX_CH I2C transaction, writing/reading data as necessary */
+
+#define MODE_I2C_START  1
+#define MODE_I2C_WRITE  2
+#define MODE_I2C_READ   4
+#define MODE_I2C_STOP   8
+
+static int
+i2c_algo_dp_aux_transaction(struct i2c_adapter *adapter, int mode,
+                            uint8_t write_byte, uint8_t *read_byte)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        uint16_t address = algo_data->address;
+        uint8_t msg[5];
+        uint8_t reply[2];
+        int msg_bytes;
+        int reply_bytes;
+        int ret;
+
+        /* Set up the command byte */
+        if (mode & MODE_I2C_READ)
+                msg[0] = AUX_I2C_READ << 4;
+        else
+                msg[0] = AUX_I2C_WRITE << 4;
+
+        if (!(mode & MODE_I2C_STOP))
+                msg[0] |= AUX_I2C_MOT << 4;
+
+        msg[1] = address >> 8;
+        msg[2] = address;
+
+        switch (mode) {
+        case MODE_I2C_WRITE:
+                msg[3] = 0;
+                msg[4] = write_byte;
+                msg_bytes = 5;
+                reply_bytes = 1;
+                break;
+        case MODE_I2C_READ:
+                msg[3] = 0;
+                msg_bytes = 4;
+                reply_bytes = 2;
+                break;
+        default:
+                msg_bytes = 3;
+                reply_bytes = 1;
+                break;
+        }
+
+        for (;;) {
+                ret = (*algo_data->aux_ch)(adapter,
+                                           msg, msg_bytes,
+                                           reply, reply_bytes);
+                if (ret < 0) {
+                        DRM_DEBUG("aux_ch failed %d\n", ret);
+                        return ret;
+                }
+                switch (reply[0] & AUX_I2C_REPLY_MASK) {
+                case AUX_I2C_REPLY_ACK:
+                        if (mode == MODE_I2C_READ) {
+                                *read_byte = reply[1];
+                        }
+                        return reply_bytes - 1;
+                case AUX_I2C_REPLY_NACK:
+                        DRM_DEBUG("aux_ch nack\n");
+                        return -EREMOTEIO;
+                case AUX_I2C_REPLY_DEFER:
+                        DRM_DEBUG("aux_ch defer\n");
+                        udelay(100);
+                        break;
+                default:
+                        DRM_ERROR("aux_ch invalid reply 0x%02x\n", reply[0]);
+                        return -EREMOTEIO;
+                }
+        }
+}
+
+/*
+ * I2C over AUX CH
+ */
+
+/*
+ * Send the address. If the I2C link is running, this 'restarts'
+ * the connection with the new address, this is used for doing
+ * a write followed by a read (as needed for DDC)
+ */
+static int
+i2c_algo_dp_aux_address(struct i2c_adapter *adapter, u16 address, bool reading)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int mode = MODE_I2C_START;
+        int ret;
+
+        if (reading)
+                mode |= MODE_I2C_READ;
+        else
+                mode |= MODE_I2C_WRITE;
+        algo_data->address = address;
+        algo_data->running = true;
+        ret = i2c_algo_dp_aux_transaction(adapter, mode, 0, NULL);
+        return ret;
+}
+
+/*
+ * Stop the I2C transaction. This closes out the link, sending
+ * a bare address packet with the MOT bit turned off
+ */
+static void
+i2c_algo_dp_aux_stop(struct i2c_adapter *adapter, bool reading)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int mode = MODE_I2C_STOP;
+
+        if (reading)
+                mode |= MODE_I2C_READ;
+        else
+                mode |= MODE_I2C_WRITE;
+        if (algo_data->running) {
+                (void) i2c_algo_dp_aux_transaction(adapter, mode, 0, NULL);
+                algo_data->running = false;
+        }
+}
+
+/*
+ * Write a single byte to the current I2C address, the
+ * the I2C link must be running or this returns -EIO
+ */
+static int
+i2c_algo_dp_aux_put_byte(struct i2c_adapter *adapter, u8 byte)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int ret;
+
+        if (!algo_data->running)
+                return -EIO;
+
+        ret = i2c_algo_dp_aux_transaction(adapter, MODE_I2C_WRITE, byte, NULL);
+        return ret;
+}
+
+/*
+ * Read a single byte from the current I2C address, the
+ * I2C link must be running or this returns -EIO
+ */
+static int
+i2c_algo_dp_aux_get_byte(struct i2c_adapter *adapter, u8 *byte_ret)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int ret;
+
+        if (!algo_data->running)
+                return -EIO;
+
+        ret = i2c_algo_dp_aux_transaction(adapter, MODE_I2C_READ, 0, byte_ret);
+        return ret;
+}
+
+static int
+i2c_algo_dp_aux_xfer(struct i2c_adapter *adapter,
+                     struct i2c_msg *msgs,
+                     int num)
+{
+        int ret = 0;
+        bool reading = false;
+        int m;
+        int b;
+
+        for (m = 0; m < num; m++) {
+                u16 len = msgs[m].len;
+                u8 *buf = msgs[m].buf;
+                reading = (msgs[m].flags & I2C_M_RD) != 0;
+                ret = i2c_algo_dp_aux_address(adapter, msgs[m].addr, reading);
+                if (ret < 0)
+                        break;
+                if (reading) {
+                        for (b = 0; b < len; b++) {
+                                ret = i2c_algo_dp_aux_get_byte(adapter, &buf[b]);
+                                if (ret < 0)
+                                        break;
+                        }
+                } else {
+                        for (b = 0; b < len; b++) {
+                                ret = i2c_algo_dp_aux_put_byte(adapter, buf[b]);
+                                if (ret < 0)
+                                        break;
+                        }
+                }
+                if (ret < 0)
+                        break;
+        }
+        if (ret >= 0)
+                ret = num;
+        i2c_algo_dp_aux_stop(adapter, reading);
+        DRM_DEBUG("dp_aux_xfer return %d\n", ret);
+        return ret;
+}
+
+static u32
+i2c_algo_dp_aux_functionality(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
+               I2C_FUNC_SMBUS_READ_BLOCK_DATA |
+               I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
+               I2C_FUNC_10BIT_ADDR;
+}
+
+static const struct i2c_algorithm i2c_dp_aux_algo = {
+        .master_xfer    = i2c_algo_dp_aux_xfer,
+        .functionality  = i2c_algo_dp_aux_functionality,
+};
+
+static void
+i2c_dp_aux_reset_bus(struct i2c_adapter *adapter)
+{
+        (void) i2c_algo_dp_aux_address(adapter, 0, false);
+        (void) i2c_algo_dp_aux_stop(adapter, false);
+                                           
+}
+
+static int
+i2c_dp_aux_prepare_bus(struct i2c_adapter *adapter)
+{
+        adapter->algo = &i2c_dp_aux_algo;
+        adapter->retries = 3;
+        i2c_dp_aux_reset_bus(adapter);
+        return 0;
+}
+
+int
+i2c_dp_aux_add_bus(struct i2c_adapter *adapter)
+{
+        int error;
+        
+        error = i2c_dp_aux_prepare_bus(adapter);
+        if (error)
+                return error;
+        error = i2c_add_adapter(adapter);
+        return error;
+}
+EXPORT_SYMBOL(i2c_dp_aux_add_bus);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index cd4b9c5f715e..004541c935a8 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -54,6 +54,7 @@
 #define INTEL_OUTPUT_LVDS 4
 #define INTEL_OUTPUT_TVOUT 5
 #define INTEL_OUTPUT_HDMI 6
+#define INTEL_OUTPUT_DISPLAYPORT 7
 
 #define INTEL_DVO_CHIP_NONE 0
 #define INTEL_DVO_CHIP_LVDS 1
@@ -65,7 +66,6 @@ struct intel_i2c_chan {
         u32 reg; /* GPIO reg */
         struct i2c_adapter adapter;
         struct i2c_algo_bit_data algo;
-        u8 slave_addr;
 };
 
 struct intel_framebuffer {
@@ -79,11 +79,12 @@ struct intel_output {
 
         struct drm_encoder enc;
         int type;
-        struct intel_i2c_chan *i2c_bus; /* for control functions */
-        struct intel_i2c_chan *ddc_bus; /* for DDC only stuff */
+        struct i2c_adapter *i2c_bus;
+        struct i2c_adapter *ddc_bus;
         bool load_detect_temp;
         bool needs_tv_clock;
         void *dev_priv;
+        void (*hot_plug)(struct intel_output *);
 };
 
 struct intel_crtc {
@@ -104,9 +105,9 @@ struct intel_crtc {
 #define enc_to_intel_output(x) container_of(x, struct intel_output, enc)
 #define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base)
 
-struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
-                                        const char *name);
-void intel_i2c_destroy(struct intel_i2c_chan *chan);
+struct i2c_adapter *intel_i2c_create(struct drm_device *dev, const u32 reg,
+                                     const char *name);
+void intel_i2c_destroy(struct i2c_adapter *adapter);
 int intel_ddc_get_modes(struct intel_output *intel_output);
 extern bool intel_ddc_probe(struct intel_output *intel_output);
 void intel_i2c_quirk_set(struct drm_device *dev, bool enable);
@@ -116,6 +117,10 @@ extern bool intel_sdvo_init(struct drm_device *dev, int output_device);
 extern void intel_dvo_init(struct drm_device *dev);
 extern void intel_tv_init(struct drm_device *dev);
 extern void intel_lvds_init(struct drm_device *dev);
+extern void intel_dp_init(struct drm_device *dev, int dp_reg);
+void
+intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode,
+                 struct drm_display_mode *adjusted_mode);
 
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
 extern void intel_encoder_prepare (struct drm_encoder *encoder);
diff --git a/drivers/gpu/drm/i915/intel_dvo.c b/drivers/gpu/drm/i915/intel_dvo.c
index 1ee3007d6ec0..13bff20930e8 100644
--- a/drivers/gpu/drm/i915/intel_dvo.c
+++ b/drivers/gpu/drm/i915/intel_dvo.c
@@ -384,10 +384,9 @@ void intel_dvo_init(struct drm_device *dev)
 {
         struct intel_output *intel_output;
         struct intel_dvo_device *dvo;
-        struct intel_i2c_chan *i2cbus = NULL;
+        struct i2c_adapter *i2cbus = NULL;
         int ret = 0;
         int i;
-        int gpio_inited = 0;
         int encoder_type = DRM_MODE_ENCODER_NONE;
         intel_output = kzalloc (sizeof(struct intel_output), GFP_KERNEL);
         if (!intel_output)
@@ -420,14 +419,11 @@ void intel_dvo_init(struct drm_device *dev)
                  * It appears that everything is on GPIOE except for panels
                  * on i830 laptops, which are on GPIOB (DVOA).
                  */
-                if (gpio_inited != gpio) {
-                        if (i2cbus != NULL)
-                                intel_i2c_destroy(i2cbus);
-                        if (!(i2cbus = intel_i2c_create(dev, gpio,
-                                gpio == GPIOB ? "DVOI2C_B" : "DVOI2C_E"))) {
-                                continue;
-                        }
-                        gpio_inited = gpio;
+                if (i2cbus != NULL)
+                        intel_i2c_destroy(i2cbus);
+                if (!(i2cbus = intel_i2c_create(dev, gpio,
+                        gpio == GPIOB ? "DVOI2C_B" : "DVOI2C_E"))) {
+                        continue;
                 }
 
                 if (dvo->dev_ops!= NULL)
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c
index 1af7d68e3807..1d30802e773e 100644
--- a/drivers/gpu/drm/i915/intel_fb.c
+++ b/drivers/gpu/drm/i915/intel_fb.c
@@ -453,7 +453,7 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width,
         size = ALIGN(size, PAGE_SIZE);
         fbo = drm_gem_object_alloc(dev, size);
         if (!fbo) {
-                printk(KERN_ERR "failed to allocate framebuffer\n");
+                DRM_ERROR("failed to allocate framebuffer\n");
                 ret = -ENOMEM;
                 goto out;
         }
@@ -610,8 +610,8 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width,
         par->dev = dev;
 
         /* To allow resizeing without swapping buffers */
-        printk("allocated %dx%d fb: 0x%08x, bo %p\n", intel_fb->base.width,
-               intel_fb->base.height, obj_priv->gtt_offset, fbo);
+        DRM_DEBUG("allocated %dx%d fb: 0x%08x, bo %p\n", intel_fb->base.width,
+                  intel_fb->base.height, obj_priv->gtt_offset, fbo);
 
         mutex_unlock(&dev->struct_mutex);
         return 0;
@@ -698,13 +698,13 @@ static int intelfb_multi_fb_probe_crtc(struct drm_device *dev, struct drm_crtc *
         } else
                 intelfb_set_par(info);
 
-        printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
+        DRM_INFO("fb%d: %s frame buffer device\n", info->node,
                info->fix.id);
 
         /* Switch back to kernel console on panic */
         kernelfb_mode = *modeset;
         atomic_notifier_chain_register(&panic_notifier_list, &paniced);
-        printk(KERN_INFO "registered panic notifier\n");
+        DRM_DEBUG("registered panic notifier\n");
 
         return 0;
 }
@@ -852,13 +852,13 @@ static int intelfb_single_fb_probe(struct drm_device *dev)
         } else
                 intelfb_set_par(info);
 
-        printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
+        DRM_INFO("fb%d: %s frame buffer device\n", info->node,
                info->fix.id);
 
         /* Switch back to kernel console on panic */
         kernelfb_mode = *modeset;
         atomic_notifier_chain_register(&panic_notifier_list, &paniced);
-        printk(KERN_INFO "registered panic notifier\n");
+        DRM_DEBUG("registered panic notifier\n");
 
         return 0;
 }
@@ -872,8 +872,8 @@ void intelfb_restore(void)
 {
         int ret;
         if ((ret = drm_crtc_helper_set_config(&kernelfb_mode)) != 0) {
-                printk(KERN_ERR "Failed to restore crtc configuration: %d\n",
-                       ret);
+                DRM_ERROR("Failed to restore crtc configuration: %d\n",
+                          ret);
         }
 }
 
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 4ea2a651b92c..9e30daae37dc 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -31,6 +31,7 @@
 #include "drmP.h"
 #include "drm.h"
 #include "drm_crtc.h"
+#include "drm_edid.h"
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
@@ -56,8 +57,7 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         sdvox = SDVO_ENCODING_HDMI |
                 SDVO_BORDER_ENABLE |
                 SDVO_VSYNC_ACTIVE_HIGH |
-                SDVO_HSYNC_ACTIVE_HIGH |
-                SDVO_NULL_PACKETS_DURING_VSYNC;
+                SDVO_HSYNC_ACTIVE_HIGH;
 
         if (hdmi_priv->has_hdmi_sink)
                 sdvox |= SDVO_AUDIO_ENABLE;
@@ -129,20 +129,26 @@ static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,
         return true;
 }
 
-static void
-intel_hdmi_sink_detect(struct drm_connector *connector)
+static enum drm_connector_status
+intel_hdmi_edid_detect(struct drm_connector *connector)
 {
         struct intel_output *intel_output = to_intel_output(connector);
         struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv;
         struct edid *edid = NULL;
+        enum drm_connector_status status = connector_status_disconnected;
 
         edid = drm_get_edid(&intel_output->base,
-                            &intel_output->ddc_bus->adapter);
-        if (edid != NULL) {
-                hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
-                kfree(edid);
+                            intel_output->ddc_bus);
+        hdmi_priv->has_hdmi_sink = false;
+        if (edid) {
+                if (edid->input & DRM_EDID_INPUT_DIGITAL) {
+                        status = connector_status_connected;
+                        hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
+                }
                 intel_output->base.display_info.raw_edid = NULL;
+                kfree(edid);
         }
+        return status;
 }
 
 static enum drm_connector_status
@@ -154,11 +160,7 @@ igdng_hdmi_detect(struct drm_connector *connector)
         /* FIXME hotplug detect */
 
         hdmi_priv->has_hdmi_sink = false;
-        intel_hdmi_sink_detect(connector);
-        if (hdmi_priv->has_hdmi_sink)
-                return connector_status_connected;
-        else
-                return connector_status_disconnected;
+        return intel_hdmi_edid_detect(connector);
 }
 
 static enum drm_connector_status
@@ -201,10 +203,9 @@ intel_hdmi_detect(struct drm_connector *connector)
                 return connector_status_unknown;
         }
 
-        if ((I915_READ(PORT_HOTPLUG_STAT) & bit) != 0) {
-                intel_hdmi_sink_detect(connector);
-                return connector_status_connected;
-        } else
+        if ((I915_READ(PORT_HOTPLUG_STAT) & bit) != 0)
+                return intel_hdmi_edid_detect(connector);
+        else
                 return connector_status_disconnected;
 }
 
diff --git a/drivers/gpu/drm/i915/intel_i2c.c b/drivers/gpu/drm/i915/intel_i2c.c
index f7061f68d050..62b8bead7652 100644
--- a/drivers/gpu/drm/i915/intel_i2c.c
+++ b/drivers/gpu/drm/i915/intel_i2c.c
@@ -124,6 +124,7 @@ static void set_data(void *data, int state_high)
  * @output: driver specific output device
  * @reg: GPIO reg to use
  * @name: name for this bus
+ * @slave_addr: slave address (if fixed)
  *
  * Creates and registers a new i2c bus with the Linux i2c layer, for use
  * in output probing and control (e.g. DDC or SDVO control functions).
@@ -139,8 +140,8 @@ static void set_data(void *data, int state_high)
  *   %GPIOH
  * see PRM for details on how these different busses are used.
  */
-struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
-                                        const char *name)
+struct i2c_adapter *intel_i2c_create(struct drm_device *dev, const u32 reg,
+                                     const char *name)
 {
         struct intel_i2c_chan *chan;
 
@@ -174,7 +175,7 @@ struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
         intel_i2c_quirk_set(dev, false);
         udelay(20);
 
-        return chan;
+        return &chan->adapter;
 
 out_free:
         kfree(chan);
@@ -187,11 +188,16 @@ out_free:
  *
  * Unregister the adapter from the i2c layer, then free the structure.
  */
-void intel_i2c_destroy(struct intel_i2c_chan *chan)
+void intel_i2c_destroy(struct i2c_adapter *adapter)
 {
-        if (!chan)
+        struct intel_i2c_chan *chan;
+
+        if (!adapter)
                 return;
 
+        chan = container_of(adapter,
+                            struct intel_i2c_chan,
+                            adapter);
         i2c_del_adapter(&chan->adapter);
         kfree(chan);
 }
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index f073ed8432e8..9ab38efffecf 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -36,9 +36,25 @@
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
+#include <linux/acpi.h>
 
 #define I915_LVDS "i915_lvds"
 
+/*
+ * the following four scaling options are defined.
+ * #define DRM_MODE_SCALE_NON_GPU       0
+ * #define DRM_MODE_SCALE_FULLSCREEN    1
+ * #define DRM_MODE_SCALE_NO_SCALE      2
+ * #define DRM_MODE_SCALE_ASPECT        3
+ */
+
+/* Private structure for the integrated LVDS support */
+struct intel_lvds_priv {
+        int fitting_mode;
+        u32 pfit_control;
+        u32 pfit_pgm_ratios;
+};
+
 /**
  * Sets the backlight level.
  *
@@ -213,26 +229,45 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
                                   struct drm_display_mode *mode,
                                   struct drm_display_mode *adjusted_mode)
 {
+        /*
+         * float point operation is not supported . So the PANEL_RATIO_FACTOR
+         * is defined, which can avoid the float point computation when
+         * calculating the panel ratio.
+         */
+#define PANEL_RATIO_FACTOR 8192
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
         struct drm_encoder *tmp_encoder;
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_lvds_priv *lvds_priv = intel_output->dev_priv;
+        u32 pfit_control = 0, pfit_pgm_ratios = 0;
+        int left_border = 0, right_border = 0, top_border = 0;
+        int bottom_border = 0;
+        bool border = 0;
+        int panel_ratio, desired_ratio, vert_scale, horiz_scale;
+        int horiz_ratio, vert_ratio;
+        u32 hsync_width, vsync_width;
+        u32 hblank_width, vblank_width;
+        u32 hsync_pos, vsync_pos;
 
         /* Should never happen!! */
         if (!IS_I965G(dev) && intel_crtc->pipe == 0) {
-                printk(KERN_ERR "Can't support LVDS on pipe A\n");
+                DRM_ERROR("Can't support LVDS on pipe A\n");
                 return false;
         }
 
         /* Should never happen!! */
         list_for_each_entry(tmp_encoder, &dev->mode_config.encoder_list, head) {
                 if (tmp_encoder != encoder && tmp_encoder->crtc == encoder->crtc) {
-                        printk(KERN_ERR "Can't enable LVDS and another "
+                        DRM_ERROR("Can't enable LVDS and another "
                                "encoder on the same pipe\n");
                         return false;
                 }
         }
-
+        /* If we don't have a panel mode, there is nothing we can do */
+        if (dev_priv->panel_fixed_mode == NULL)
+                return true;
         /*
          * If we have timings from the BIOS for the panel, put them in
          * to the adjusted mode.  The CRTC will be set up for this mode,
@@ -256,6 +291,243 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
                 drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
         }
 
+        /* Make sure pre-965s set dither correctly */
+        if (!IS_I965G(dev)) {
+                if (dev_priv->panel_wants_dither || dev_priv->lvds_dither)
+                        pfit_control |= PANEL_8TO6_DITHER_ENABLE;
+        }
+
+        /* Native modes don't need fitting */
+        if (adjusted_mode->hdisplay == mode->hdisplay &&
+                        adjusted_mode->vdisplay == mode->vdisplay) {
+                pfit_pgm_ratios = 0;
+                border = 0;
+                goto out;
+        }
+
+        /* 965+ wants fuzzy fitting */
+        if (IS_I965G(dev))
+                pfit_control |= (intel_crtc->pipe << PFIT_PIPE_SHIFT) |
+                                        PFIT_FILTER_FUZZY;
+
+        hsync_width = adjusted_mode->crtc_hsync_end -
+                                        adjusted_mode->crtc_hsync_start;
+        vsync_width = adjusted_mode->crtc_vsync_end -
+                                        adjusted_mode->crtc_vsync_start;
+        hblank_width = adjusted_mode->crtc_hblank_end -
+                                        adjusted_mode->crtc_hblank_start;
+        vblank_width = adjusted_mode->crtc_vblank_end -
+                                        adjusted_mode->crtc_vblank_start;
+        /*
+         * Deal with panel fitting options. Figure out how to stretch the
+         * image based on its aspect ratio & the current panel fitting mode.
+         */
+        panel_ratio = adjusted_mode->hdisplay * PANEL_RATIO_FACTOR /
+                                adjusted_mode->vdisplay;
+        desired_ratio = mode->hdisplay * PANEL_RATIO_FACTOR /
+                                mode->vdisplay;
+        /*
+         * Enable automatic panel scaling for non-native modes so that they fill
+         * the screen.  Should be enabled before the pipe is enabled, according
+         * to register description and PRM.
+         * Change the value here to see the borders for debugging
+         */
+        I915_WRITE(BCLRPAT_A, 0);
+        I915_WRITE(BCLRPAT_B, 0);
+
+        switch (lvds_priv->fitting_mode) {
+        case DRM_MODE_SCALE_NO_SCALE:
+                /*
+                 * For centered modes, we have to calculate border widths &
+                 * heights and modify the values programmed into the CRTC.
+                 */
+                left_border = (adjusted_mode->hdisplay - mode->hdisplay) / 2;
+                right_border = left_border;
+                if (mode->hdisplay & 1)
+                        right_border++;
+                top_border = (adjusted_mode->vdisplay - mode->vdisplay) / 2;
+                bottom_border = top_border;
+                if (mode->vdisplay & 1)
+                        bottom_border++;
+                /* Set active & border values */
+                adjusted_mode->crtc_hdisplay = mode->hdisplay;
+                /* Keep the boder be even */
+                if (right_border & 1)
+                        right_border++;
+                /* use the border directly instead of border minuse one */
+                adjusted_mode->crtc_hblank_start = mode->hdisplay +
+                                                right_border;
+                /* keep the blank width constant */
+                adjusted_mode->crtc_hblank_end =
+                        adjusted_mode->crtc_hblank_start + hblank_width;
+                /* get the hsync pos relative to hblank start */
+                hsync_pos = (hblank_width - hsync_width) / 2;
+                /* keep the hsync pos be even */
+                if (hsync_pos & 1)
+                        hsync_pos++;
+                adjusted_mode->crtc_hsync_start =
+                                adjusted_mode->crtc_hblank_start + hsync_pos;
+                /* keep the hsync width constant */
+                adjusted_mode->crtc_hsync_end =
+                                adjusted_mode->crtc_hsync_start + hsync_width;
+                adjusted_mode->crtc_vdisplay = mode->vdisplay;
+                /* use the border instead of border minus one */
+                adjusted_mode->crtc_vblank_start = mode->vdisplay +
+                                                bottom_border;
+                /* keep the vblank width constant */
+                adjusted_mode->crtc_vblank_end =
+                                adjusted_mode->crtc_vblank_start + vblank_width;
+                /* get the vsync start postion relative to vblank start */
+                vsync_pos = (vblank_width - vsync_width) / 2;
+                adjusted_mode->crtc_vsync_start =
+                                adjusted_mode->crtc_vblank_start + vsync_pos;
+                /* keep the vsync width constant */
+                adjusted_mode->crtc_vsync_end =
+                                adjusted_mode->crtc_vblank_start + vsync_width;
+                border = 1;
+                break;
+        case DRM_MODE_SCALE_ASPECT:
+                /* Scale but preserve the spect ratio */
+                pfit_control |= PFIT_ENABLE;
+                if (IS_I965G(dev)) {
+                        /* 965+ is easy, it does everything in hw */
+                        if (panel_ratio > desired_ratio)
+                                pfit_control |= PFIT_SCALING_PILLAR;
+                        else if (panel_ratio < desired_ratio)
+                                pfit_control |= PFIT_SCALING_LETTER;
+                        else
+                                pfit_control |= PFIT_SCALING_AUTO;
+                } else {
+                        /*
+                         * For earlier chips we have to calculate the scaling
+                         * ratio by hand and program it into the
+                         * PFIT_PGM_RATIO register
+                         */
+                        u32 horiz_bits, vert_bits, bits = 12;
+                        horiz_ratio = mode->hdisplay * PANEL_RATIO_FACTOR/
+                                                adjusted_mode->hdisplay;
+                        vert_ratio = mode->vdisplay * PANEL_RATIO_FACTOR/
+                                                adjusted_mode->vdisplay;
+                        horiz_scale = adjusted_mode->hdisplay *
+                                        PANEL_RATIO_FACTOR / mode->hdisplay;
+                        vert_scale = adjusted_mode->vdisplay *
+                                        PANEL_RATIO_FACTOR / mode->vdisplay;
+
+                        /* retain aspect ratio */
+                        if (panel_ratio > desired_ratio) { /* Pillar */
+                                u32 scaled_width;
+                                scaled_width = mode->hdisplay * vert_scale /
+                                                PANEL_RATIO_FACTOR;
+                                horiz_ratio = vert_ratio;
+                                pfit_control |= (VERT_AUTO_SCALE |
+                                                 VERT_INTERP_BILINEAR |
+                                                 HORIZ_INTERP_BILINEAR);
+                                /* Pillar will have left/right borders */
+                                left_border = (adjusted_mode->hdisplay -
+                                                scaled_width) / 2;
+                                right_border = left_border;
+                                if (mode->hdisplay & 1) /* odd resolutions */
+                                        right_border++;
+                                /* keep the border be even */
+                                if (right_border & 1)
+                                        right_border++;
+                                adjusted_mode->crtc_hdisplay = scaled_width;
+                                /* use border instead of border minus one */
+                                adjusted_mode->crtc_hblank_start =
+                                        scaled_width + right_border;
+                                /* keep the hblank width constant */
+                                adjusted_mode->crtc_hblank_end =
+                                        adjusted_mode->crtc_hblank_start +
+                                                        hblank_width;
+                                /*
+                                 * get the hsync start pos relative to
+                                 * hblank start
+                                 */
+                                hsync_pos = (hblank_width - hsync_width) / 2;
+                                /* keep the hsync_pos be even */
+                                if (hsync_pos & 1)
+                                        hsync_pos++;
+                                adjusted_mode->crtc_hsync_start =
+                                        adjusted_mode->crtc_hblank_start +
+                                                        hsync_pos;
+                                /* keept hsync width constant */
+                                adjusted_mode->crtc_hsync_end =
+                                        adjusted_mode->crtc_hsync_start +
+                                                        hsync_width;
+                                border = 1;
+                        } else if (panel_ratio < desired_ratio) { /* letter */
+                                u32 scaled_height = mode->vdisplay *
+                                        horiz_scale / PANEL_RATIO_FACTOR;
+                                vert_ratio = horiz_ratio;
+                                pfit_control |= (HORIZ_AUTO_SCALE |
+                                                 VERT_INTERP_BILINEAR |
+                                                 HORIZ_INTERP_BILINEAR);
+                                /* Letterbox will have top/bottom border */
+                                top_border = (adjusted_mode->vdisplay -
+                                        scaled_height) / 2;
+                                bottom_border = top_border;
+                                if (mode->vdisplay & 1)
+                                        bottom_border++;
+                                adjusted_mode->crtc_vdisplay = scaled_height;
+                                /* use border instead of border minus one */
+                                adjusted_mode->crtc_vblank_start =
+                                        scaled_height + bottom_border;
+                                /* keep the vblank width constant */
+                                adjusted_mode->crtc_vblank_end =
+                                        adjusted_mode->crtc_vblank_start +
+                                                        vblank_width;
+                                /*
+                                 * get the vsync start pos relative to
+                                 * vblank start
+                                 */
+                                vsync_pos = (vblank_width - vsync_width) / 2;
+                                adjusted_mode->crtc_vsync_start =
+                                        adjusted_mode->crtc_vblank_start +
+                                                        vsync_pos;
+                                /* keep the vsync width constant */
+                                adjusted_mode->crtc_vsync_end =
+                                        adjusted_mode->crtc_vsync_start +
+                                                        vsync_width;
+                                border = 1;
+                        } else {
+                        /* Aspects match, Let hw scale both directions */
+                                pfit_control |= (VERT_AUTO_SCALE |
+                                                 HORIZ_AUTO_SCALE |
+                                                 VERT_INTERP_BILINEAR |
+                                                 HORIZ_INTERP_BILINEAR);
+                        }
+                        horiz_bits = (1 << bits) * horiz_ratio /
+                                        PANEL_RATIO_FACTOR;
+                        vert_bits = (1 << bits) * vert_ratio /
+                                        PANEL_RATIO_FACTOR;
+                        pfit_pgm_ratios =
+                                ((vert_bits << PFIT_VERT_SCALE_SHIFT) &
+                                                PFIT_VERT_SCALE_MASK) |
+                                ((horiz_bits << PFIT_HORIZ_SCALE_SHIFT) &
+                                                PFIT_HORIZ_SCALE_MASK);
+                }
+                break;
+
+        case DRM_MODE_SCALE_FULLSCREEN:
+                /*
+                 * Full scaling, even if it changes the aspect ratio.
+                 * Fortunately this is all done for us in hw.
+                 */
+                pfit_control |= PFIT_ENABLE;
+                if (IS_I965G(dev))
+                        pfit_control |= PFIT_SCALING_AUTO;
+                else
+                        pfit_control |= (VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
+                                         VERT_INTERP_BILINEAR |
+                                         HORIZ_INTERP_BILINEAR);
+                break;
+        default:
+                break;
+        }
+
+out:
+        lvds_priv->pfit_control = pfit_control;
+        lvds_priv->pfit_pgm_ratios = pfit_pgm_ratios;
         /*
          * XXX: It would be nice to support lower refresh rates on the
          * panels to reduce power consumption, and perhaps match the
@@ -301,8 +573,8 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
 {
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
-        u32 pfit_control;
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_lvds_priv *lvds_priv = intel_output->dev_priv;
 
         /*
          * The LVDS pin pair will already have been turned on in the
@@ -319,22 +591,8 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
          * screen.  Should be enabled before the pipe is enabled, according to
          * register description and PRM.
          */
-        if (mode->hdisplay != adjusted_mode->hdisplay ||
-            mode->vdisplay != adjusted_mode->vdisplay)
-                pfit_control = (PFIT_ENABLE | VERT_AUTO_SCALE |
-                                HORIZ_AUTO_SCALE | VERT_INTERP_BILINEAR |
-                                HORIZ_INTERP_BILINEAR);
-        else
-                pfit_control = 0;
-
-        if (!IS_I965G(dev)) {
-                if (dev_priv->panel_wants_dither || dev_priv->lvds_dither)
-                        pfit_control |= PANEL_8TO6_DITHER_ENABLE;
-        }
-        else
-                pfit_control |= intel_crtc->pipe << PFIT_PIPE_SHIFT;
-
-        I915_WRITE(PFIT_CONTROL, pfit_control);
+        I915_WRITE(PFIT_PGM_RATIOS, lvds_priv->pfit_pgm_ratios);
+        I915_WRITE(PFIT_CONTROL, lvds_priv->pfit_control);
 }
 
 /**
@@ -406,6 +664,34 @@ static int intel_lvds_set_property(struct drm_connector *connector,
                                    struct drm_property *property,
                                    uint64_t value)
 {
+        struct drm_device *dev = connector->dev;
+        struct intel_output *intel_output =
+                        to_intel_output(connector);
+
+        if (property == dev->mode_config.scaling_mode_property &&
+                                connector->encoder) {
+                struct drm_crtc *crtc = connector->encoder->crtc;
+                struct intel_lvds_priv *lvds_priv = intel_output->dev_priv;
+                if (value == DRM_MODE_SCALE_NON_GPU) {
+                        DRM_DEBUG_KMS(I915_LVDS,
+                                        "non_GPU property is unsupported\n");
+                        return 0;
+                }
+                if (lvds_priv->fitting_mode == value) {
+                        /* the LVDS scaling property is not changed */
+                        return 0;
+                }
+                lvds_priv->fitting_mode = value;
+                if (crtc && crtc->enabled) {
+                        /*
+                         * If the CRTC is enabled, the display will be changed
+                         * according to the new panel fitting mode.
+                         */
+                        drm_crtc_helper_set_mode(crtc, &crtc->mode,
+                                crtc->x, crtc->y, crtc->fb);
+                }
+        }
+
         return 0;
 }
 
@@ -456,7 +742,7 @@ static const struct dmi_system_id intel_no_lvds[] = {
                 .callback = intel_no_lvds_dmi_callback,
                 .ident = "Apple Mac Mini (Core series)",
                 .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
                 },
         },
@@ -464,7 +750,7 @@ static const struct dmi_system_id intel_no_lvds[] = {
                 .callback = intel_no_lvds_dmi_callback,
                 .ident = "Apple Mac Mini (Core 2 series)",
                 .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Macmini2,1"),
                 },
         },
@@ -503,6 +789,65 @@ static const struct dmi_system_id intel_no_lvds[] = {
         { }     /* terminating entry */
 };
 
+#ifdef CONFIG_ACPI
+/*
+ * check_lid_device -- check whether @handle is an ACPI LID device.
+ * @handle: ACPI device handle
+ * @level : depth in the ACPI namespace tree
+ * @context: the number of LID device when we find the device
+ * @rv: a return value to fill if desired (Not use)
+ */
+static acpi_status
+check_lid_device(acpi_handle handle, u32 level, void *context,
+                        void **return_value)
+{
+        struct acpi_device *acpi_dev;
+        int *lid_present = context;
+
+        acpi_dev = NULL;
+        /* Get the acpi device for device handle */
+        if (acpi_bus_get_device(handle, &acpi_dev) || !acpi_dev) {
+                /* If there is no ACPI device for handle, return */
+                return AE_OK;
+        }
+
+        if (!strncmp(acpi_device_hid(acpi_dev), "PNP0C0D", 7))
+                *lid_present = 1;
+
+        return AE_OK;
+}
+
+/**
+ * check whether there exists the ACPI LID device by enumerating the ACPI
+ * device tree.
+ */
+static int intel_lid_present(void)
+{
+        int lid_present = 0;
+
+        if (acpi_disabled) {
+                /* If ACPI is disabled, there is no ACPI device tree to
+                 * check, so assume the LID device would have been present.
+                 */
+                return 1;
+        }
+
+        acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                                ACPI_UINT32_MAX,
+                                check_lid_device, &lid_present, NULL);
+
+        return lid_present;
+}
+#else
+static int intel_lid_present(void)
+{
+        /* In the absence of ACPI built in, assume that the LID device would
+         * have been present.
+         */
+        return 1;
+}
+#endif
+
 /**
  * intel_lvds_init - setup LVDS connectors on this device
  * @dev: drm device
@@ -518,6 +863,7 @@ void intel_lvds_init(struct drm_device *dev)
         struct drm_encoder *encoder;
         struct drm_display_mode *scan; /* *modes, *bios_mode; */
         struct drm_crtc *crtc;
+        struct intel_lvds_priv *lvds_priv;
         u32 lvds;
         int pipe, gpio = GPIOC;
 
@@ -525,13 +871,24 @@ void intel_lvds_init(struct drm_device *dev)
         if (dmi_check_system(intel_no_lvds))
                 return;
 
+        /* Assume that any device without an ACPI LID device also doesn't
+         * have an integrated LVDS.  We would be better off parsing the BIOS
+         * to get a reliable indicator, but that code isn't written yet.
+         *
+         * In the case of all-in-one desktops using LVDS that we've seen,
+         * they're using SDVO LVDS.
+         */
+        if (!intel_lid_present())
+                return;
+
         if (IS_IGDNG(dev)) {
                 if ((I915_READ(PCH_LVDS) & LVDS_DETECTED) == 0)
                         return;
                 gpio = PCH_GPIOC;
         }
 
-        intel_output = kzalloc(sizeof(struct intel_output), GFP_KERNEL);
+        intel_output = kzalloc(sizeof(struct intel_output) +
+                                sizeof(struct intel_lvds_priv), GFP_KERNEL);
         if (!intel_output) {
                 return;
         }
@@ -553,7 +910,18 @@ void intel_lvds_init(struct drm_device *dev)
         connector->interlace_allowed = false;
         connector->doublescan_allowed = false;
 
+        lvds_priv = (struct intel_lvds_priv *)(intel_output + 1);
+        intel_output->dev_priv = lvds_priv;
+        /* create the scaling mode property */
+        drm_mode_create_scaling_mode_property(dev);
+        /*
+         * the initial panel fitting mode will be FULL_SCREEN.
+         */
 
+        drm_connector_attach_property(&intel_output->base,
+                                      dev->mode_config.scaling_mode_property,
+                                      DRM_MODE_SCALE_FULLSCREEN);
+        lvds_priv->fitting_mode = DRM_MODE_SCALE_FULLSCREEN;
         /*
          * LVDS discovery:
          * 1) check for EDID on DDC
@@ -649,5 +1017,5 @@ failed:
         if (intel_output->ddc_bus)
                 intel_i2c_destroy(intel_output->ddc_bus);
         drm_connector_cleanup(connector);
-        kfree(connector);
+        kfree(intel_output);
 }
diff --git a/drivers/gpu/drm/i915/intel_modes.c b/drivers/gpu/drm/i915/intel_modes.c
index e0910fefce87..67e2f4632a24 100644
--- a/drivers/gpu/drm/i915/intel_modes.c
+++ b/drivers/gpu/drm/i915/intel_modes.c
@@ -53,10 +53,9 @@ bool intel_ddc_probe(struct intel_output *intel_output)
                 }
         };
 
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, true);
-        ret = i2c_transfer(&intel_output->ddc_bus->adapter, msgs, 2);
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, false);
-
+        intel_i2c_quirk_set(intel_output->base.dev, true);
+        ret = i2c_transfer(intel_output->ddc_bus, msgs, 2);
+        intel_i2c_quirk_set(intel_output->base.dev, false);
         if (ret == 2)
                 return true;
 
@@ -74,10 +73,9 @@ int intel_ddc_get_modes(struct intel_output *intel_output)
         struct edid *edid;
         int ret = 0;
 
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, true);
-        edid = drm_get_edid(&intel_output->base,
-                            &intel_output->ddc_bus->adapter);
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, false);
+        intel_i2c_quirk_set(intel_output->base.dev, true);
+        edid = drm_get_edid(&intel_output->base, intel_output->ddc_bus);
+        intel_i2c_quirk_set(intel_output->base.dev, false);
         if (edid) {
                 drm_mode_connector_update_edid_property(&intel_output->base,
                                                         edid);
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 9a00adb3a508..4f0c30948bc4 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -38,8 +38,7 @@
 #undef SDVO_DEBUG
 #define I915_SDVO       "i915_sdvo"
 struct intel_sdvo_priv {
-        struct intel_i2c_chan *i2c_bus;
-        int slaveaddr;
+        u8 slave_addr;
 
         /* Register for the SDVO device: SDVOB or SDVOC */
         int output_device;
@@ -69,12 +68,23 @@ struct intel_sdvo_priv {
          * This is set if we treat the device as HDMI, instead of DVI.
          */
         bool is_hdmi;
+
         /**
          * This is set if we detect output of sdvo device as LVDS.
          */
         bool is_lvds;
 
         /**
+         * This is sdvo flags for input timing.
+         */
+        uint8_t sdvo_flags;
+
+        /**
+         * This is sdvo fixed pannel mode pointer
+         */
+        struct drm_display_mode *sdvo_lvds_fixed_mode;
+
+        /**
          * Returned SDTV resolutions allowed for the current format, if the
          * device reported it.
          */
@@ -146,13 +156,13 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = sdvo_priv->i2c_bus->slave_addr,
+                        .addr = sdvo_priv->slave_addr >> 1,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = sdvo_priv->i2c_bus->slave_addr,
+                        .addr = sdvo_priv->slave_addr >> 1,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = buf,
@@ -162,7 +172,7 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
         out_buf[0] = addr;
         out_buf[1] = 0;
 
-        if ((ret = i2c_transfer(&sdvo_priv->i2c_bus->adapter, msgs, 2)) == 2)
+        if ((ret = i2c_transfer(intel_output->i2c_bus, msgs, 2)) == 2)
         {
                 *ch = buf[0];
                 return true;
@@ -175,10 +185,11 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
 static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr,
                                   u8 ch)
 {
+        struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
         u8 out_buf[2];
         struct i2c_msg msgs[] = {
                 {
-                        .addr = intel_output->i2c_bus->slave_addr,
+                        .addr = sdvo_priv->slave_addr >> 1,
                         .flags = 0,
                         .len = 2,
                         .buf = out_buf,
@@ -188,7 +199,7 @@ static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr,
         out_buf[0] = addr;
         out_buf[1] = ch;
 
-        if (i2c_transfer(&intel_output->i2c_bus->adapter, msgs, 1) == 1)
+        if (i2c_transfer(intel_output->i2c_bus, msgs, 1) == 1)
         {
                 return true;
         }
@@ -592,6 +603,7 @@ intel_sdvo_create_preferred_input_timing(struct intel_output *output,
                                          uint16_t height)
 {
         struct intel_sdvo_preferred_input_timing_args args;
+        struct intel_sdvo_priv *sdvo_priv = output->dev_priv;
         uint8_t status;
 
         memset(&args, 0, sizeof(args));
@@ -599,7 +611,12 @@ intel_sdvo_create_preferred_input_timing(struct intel_output *output,
         args.width = width;
         args.height = height;
         args.interlace = 0;
-        args.scaled = 0;
+
+        if (sdvo_priv->is_lvds &&
+           (sdvo_priv->sdvo_lvds_fixed_mode->hdisplay != width ||
+            sdvo_priv->sdvo_lvds_fixed_mode->vdisplay != height))
+                args.scaled = 1;
+
         intel_sdvo_write_cmd(output, SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING,
                              &args, sizeof(args));
         status = intel_sdvo_read_response(output, NULL, 0);
@@ -944,12 +961,7 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
         struct intel_output *output = enc_to_intel_output(encoder);
         struct intel_sdvo_priv *dev_priv = output->dev_priv;
 
-        if (!dev_priv->is_tv) {
-                /* Make the CRTC code factor in the SDVO pixel multiplier.  The
-                 * SDVO device will be told of the multiplier during mode_set.
-                 */
-                adjusted_mode->clock *= intel_sdvo_get_pixel_multiplier(mode);
-        } else {
+        if (dev_priv->is_tv) {
                 struct intel_sdvo_dtd output_dtd;
                 bool success;
 
@@ -980,6 +992,7 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
                         intel_sdvo_get_preferred_input_timing(output,
                                                              &input_dtd);
                         intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
+                        dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags;
 
                         drm_mode_set_crtcinfo(adjusted_mode, 0);
 
@@ -990,6 +1003,52 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
                 } else {
                         return false;
                 }
+        } else if (dev_priv->is_lvds) {
+                struct intel_sdvo_dtd output_dtd;
+                bool success;
+
+                drm_mode_set_crtcinfo(dev_priv->sdvo_lvds_fixed_mode, 0);
+                /* Set output timings */
+                intel_sdvo_get_dtd_from_mode(&output_dtd,
+                                dev_priv->sdvo_lvds_fixed_mode);
+
+                intel_sdvo_set_target_output(output,
+                                             dev_priv->controlled_output);
+                intel_sdvo_set_output_timing(output, &output_dtd);
+
+                /* Set the input timing to the screen. Assume always input 0. */
+                intel_sdvo_set_target_input(output, true, false);
+
+
+                success = intel_sdvo_create_preferred_input_timing(
+                                output,
+                                mode->clock / 10,
+                                mode->hdisplay,
+                                mode->vdisplay);
+
+                if (success) {
+                        struct intel_sdvo_dtd input_dtd;
+
+                        intel_sdvo_get_preferred_input_timing(output,
+                                                             &input_dtd);
+                        intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
+                        dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags;
+
+                        drm_mode_set_crtcinfo(adjusted_mode, 0);
+
+                        mode->clock = adjusted_mode->clock;
+
+                        adjusted_mode->clock *=
+                                intel_sdvo_get_pixel_multiplier(mode);
+                } else {
+                        return false;
+                }
+
+        } else {
+                /* Make the CRTC code factor in the SDVO pixel multiplier.  The
+                 * SDVO device will be told of the multiplier during mode_set.
+                 */
+                adjusted_mode->clock *= intel_sdvo_get_pixel_multiplier(mode);
         }
         return true;
 }
@@ -1033,15 +1092,16 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
 
         /* We have tried to get input timing in mode_fixup, and filled into
            adjusted_mode */
-        if (sdvo_priv->is_tv)
+        if (sdvo_priv->is_tv || sdvo_priv->is_lvds) {
                 intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
-        else
+                input_dtd.part2.sdvo_flags = sdvo_priv->sdvo_flags;
+        } else
                 intel_sdvo_get_dtd_from_mode(&input_dtd, mode);
 
         /* If it's a TV, we already set the output timing in mode_fixup.
          * Otherwise, the output timing is equal to the input timing.
          */
-        if (!sdvo_priv->is_tv) {
+        if (!sdvo_priv->is_tv && !sdvo_priv->is_lvds) {
                 /* Set the output timing to the screen */
                 intel_sdvo_set_target_output(output,
                                              sdvo_priv->controlled_output);
@@ -1116,6 +1176,8 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
                 sdvox |= (sdvo_pixel_multiply - 1) << SDVO_PORT_MULTIPLY_SHIFT;
         }
 
+        if (sdvo_priv->sdvo_flags & SDVO_NEED_TO_STALL)
+                sdvox |= SDVO_STALL_SELECT;
         intel_sdvo_write_sdvox(output, sdvox);
 }
 
@@ -1276,6 +1338,17 @@ static int intel_sdvo_mode_valid(struct drm_connector *connector,
         if (sdvo_priv->pixel_clock_max < mode->clock)
                 return MODE_CLOCK_HIGH;
 
+        if (sdvo_priv->is_lvds == true) {
+                if (sdvo_priv->sdvo_lvds_fixed_mode == NULL)
+                        return MODE_PANEL;
+
+                if (mode->hdisplay > sdvo_priv->sdvo_lvds_fixed_mode->hdisplay)
+                        return MODE_PANEL;
+
+                if (mode->vdisplay > sdvo_priv->sdvo_lvds_fixed_mode->vdisplay)
+                        return MODE_PANEL;
+        }
+
         return MODE_OK;
 }
 
@@ -1369,9 +1442,8 @@ intel_sdvo_hdmi_sink_detect(struct drm_connector *connector)
         struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
         struct edid *edid = NULL;
 
-        intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus);
         edid = drm_get_edid(&intel_output->base,
-                            &intel_output->ddc_bus->adapter);
+                            intel_output->ddc_bus);
         if (edid != NULL) {
                 sdvo_priv->is_hdmi = drm_detect_hdmi_monitor(edid);
                 kfree(edid);
@@ -1549,23 +1621,21 @@ static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
 static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
 {
         struct intel_output *intel_output = to_intel_output(connector);
-        struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
         struct drm_i915_private *dev_priv = connector->dev->dev_private;
+        struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
+        struct drm_display_mode *newmode;
 
         /*
          * Attempt to get the mode list from DDC.
          * Assume that the preferred modes are
          * arranged in priority order.
          */
-        /* set the bus switch and get the modes */
-        intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus);
         intel_ddc_get_modes(intel_output);
         if (list_empty(&connector->probed_modes) == false)
-                return;
+                goto end;
 
         /* Fetch modes from VBT */
         if (dev_priv->sdvo_lvds_vbt_mode != NULL) {
-                struct drm_display_mode *newmode;
                 newmode = drm_mode_duplicate(connector->dev,
                                              dev_priv->sdvo_lvds_vbt_mode);
                 if (newmode != NULL) {
@@ -1575,6 +1645,16 @@ static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
                         drm_mode_probed_add(connector, newmode);
                 }
         }
+
+end:
+        list_for_each_entry(newmode, &connector->probed_modes, head) {
+                if (newmode->type & DRM_MODE_TYPE_PREFERRED) {
+                        sdvo_priv->sdvo_lvds_fixed_mode =
+                                drm_mode_duplicate(connector->dev, newmode);
+                        break;
+                }
+        }
+
 }
 
 static int intel_sdvo_get_modes(struct drm_connector *connector)
@@ -1597,14 +1677,20 @@ static int intel_sdvo_get_modes(struct drm_connector *connector)
 static void intel_sdvo_destroy(struct drm_connector *connector)
 {
         struct intel_output *intel_output = to_intel_output(connector);
+        struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
 
         if (intel_output->i2c_bus)
                 intel_i2c_destroy(intel_output->i2c_bus);
         if (intel_output->ddc_bus)
                 intel_i2c_destroy(intel_output->ddc_bus);
 
+        if (sdvo_priv->sdvo_lvds_fixed_mode != NULL)
+                drm_mode_destroy(connector->dev,
+                                 sdvo_priv->sdvo_lvds_fixed_mode);
+
         drm_sysfs_connector_remove(connector);
         drm_connector_cleanup(connector);
+
         kfree(intel_output);
 }
 
@@ -1709,7 +1795,7 @@ intel_sdvo_chan_to_intel_output(struct intel_i2c_chan *chan)
 
         list_for_each_entry(connector,
                         &dev->mode_config.connector_list, head) {
-                if (to_intel_output(connector)->ddc_bus == chan) {
+                if (to_intel_output(connector)->ddc_bus == &chan->adapter) {
                         intel_output = to_intel_output(connector);
                         break;
                 }
@@ -1723,7 +1809,7 @@ static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap,
         struct intel_output *intel_output;
         struct intel_sdvo_priv *sdvo_priv;
         struct i2c_algo_bit_data *algo_data;
-        struct i2c_algorithm *algo;
+        const struct i2c_algorithm *algo;
 
         algo_data = (struct i2c_algo_bit_data *)i2c_adap->algo_data;
         intel_output =
@@ -1733,7 +1819,7 @@ static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap,
                 return -EINVAL;
 
         sdvo_priv = intel_output->dev_priv;
-        algo = (struct i2c_algorithm *)intel_output->i2c_bus->adapter.algo;
+        algo = intel_output->i2c_bus->algo;
 
         intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus);
         return algo->master_xfer(i2c_adap, msgs, num);
@@ -1785,13 +1871,11 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
         struct drm_connector *connector;
         struct intel_output *intel_output;
         struct intel_sdvo_priv *sdvo_priv;
-        struct intel_i2c_chan *i2cbus = NULL;
-        struct intel_i2c_chan *ddcbus = NULL;
+
         int connector_type;
         u8 ch[0x40];
         int i;
-        int encoder_type, output_id;
-        u8 slave_addr;
+        int encoder_type;
 
         intel_output = kcalloc(sizeof(struct intel_output)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL);
         if (!intel_output) {
@@ -1799,29 +1883,24 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
         }
 
         sdvo_priv = (struct intel_sdvo_priv *)(intel_output + 1);
+        sdvo_priv->output_device = output_device;
+
+        intel_output->dev_priv = sdvo_priv;
         intel_output->type = INTEL_OUTPUT_SDVO;
 
         /* setup the DDC bus. */
         if (output_device == SDVOB)
-                i2cbus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB");
+                intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB");
         else
-                i2cbus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC");
+                intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC");
 
-        if (!i2cbus)
+        if (!intel_output->i2c_bus)
                 goto err_inteloutput;
 
-        slave_addr = intel_sdvo_get_slave_addr(dev, output_device);
-        sdvo_priv->i2c_bus = i2cbus;
+        sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, output_device);
 
-        if (output_device == SDVOB) {
-                output_id = 1;
-        } else {
-                output_id = 2;
-        }
-        sdvo_priv->i2c_bus->slave_addr = slave_addr >> 1;
-        sdvo_priv->output_device = output_device;
-        intel_output->i2c_bus = i2cbus;
-        intel_output->dev_priv = sdvo_priv;
+        /* Save the bit-banging i2c functionality for use by the DDC wrapper */
+        intel_sdvo_i2c_bit_algo.functionality = intel_output->i2c_bus->algo->functionality;
 
         /* Read the regs to test if we can talk to the device */
         for (i = 0; i < 0x40; i++) {
@@ -1835,17 +1914,15 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
 
         /* setup the DDC bus. */
         if (output_device == SDVOB)
-                ddcbus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS");
+                intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS");
         else
-                ddcbus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS");
+                intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS");
 
-        if (ddcbus == NULL)
+        if (intel_output->ddc_bus == NULL)
                 goto err_i2c;
 
-        intel_sdvo_i2c_bit_algo.functionality =
-                intel_output->i2c_bus->adapter.algo->functionality;
-        ddcbus->adapter.algo = &intel_sdvo_i2c_bit_algo;
-        intel_output->ddc_bus = ddcbus;
+        /* Wrap with our custom algo which switches to DDC mode */
+        intel_output->ddc_bus->algo = &intel_sdvo_i2c_bit_algo;
 
         /* In defaut case sdvo lvds is false */
         sdvo_priv->is_lvds = false;
@@ -1965,9 +2042,10 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
         return true;
 
 err_i2c:
-        if (ddcbus != NULL)
+        if (intel_output->ddc_bus != NULL)
                 intel_i2c_destroy(intel_output->ddc_bus);
-        intel_i2c_destroy(intel_output->i2c_bus);
+        if (intel_output->i2c_bus != NULL)
+                intel_i2c_destroy(intel_output->i2c_bus);
 err_inteloutput:
         kfree(intel_output);
 
diff --git a/drivers/gpu/drm/i915/intel_sdvo_regs.h b/drivers/gpu/drm/i915/intel_sdvo_regs.h
index 193938b7d7f9..ba5cdf8ae40b 100644
--- a/drivers/gpu/drm/i915/intel_sdvo_regs.h
+++ b/drivers/gpu/drm/i915/intel_sdvo_regs.h
@@ -715,6 +715,7 @@ struct intel_sdvo_enhancements_arg {
   #define SDVO_HBUF_TX_ONCE     (2 << 6)
   #define SDVO_HBUF_TX_VSYNC    (3 << 6)
 #define SDVO_CMD_GET_AUDIO_TX_INFO      0x9c
+#define SDVO_NEED_TO_STALL  (1 << 7)
 
 struct intel_sdvo_encode{
     u8 dvi_rev;
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index ea68992e4416..a43c98e3f077 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -1383,34 +1383,31 @@ intel_tv_detect_type (struct drm_crtc *crtc, struct intel_output *intel_output)
         /*
          * Detect TV by polling)
          */
-        if (intel_output->load_detect_temp) {
-                /* TV not currently running, prod it with destructive detect */
-                save_tv_dac = tv_dac;
-                tv_ctl = I915_READ(TV_CTL);
-                save_tv_ctl = tv_ctl;
-                tv_ctl &= ~TV_ENC_ENABLE;
-                tv_ctl &= ~TV_TEST_MODE_MASK;
-                tv_ctl |= TV_TEST_MODE_MONITOR_DETECT;
-                tv_dac &= ~TVDAC_SENSE_MASK;
-                tv_dac &= ~DAC_A_MASK;
-                tv_dac &= ~DAC_B_MASK;
-                tv_dac &= ~DAC_C_MASK;
-                tv_dac |= (TVDAC_STATE_CHG_EN |
-                           TVDAC_A_SENSE_CTL |
-                           TVDAC_B_SENSE_CTL |
-                           TVDAC_C_SENSE_CTL |
-                           DAC_CTL_OVERRIDE |
-                           DAC_A_0_7_V |
-                           DAC_B_0_7_V |
-                           DAC_C_0_7_V);
-                I915_WRITE(TV_CTL, tv_ctl);
-                I915_WRITE(TV_DAC, tv_dac);
-                intel_wait_for_vblank(dev);
-                tv_dac = I915_READ(TV_DAC);
-                I915_WRITE(TV_DAC, save_tv_dac);
-                I915_WRITE(TV_CTL, save_tv_ctl);
-                intel_wait_for_vblank(dev);
-        }
+        save_tv_dac = tv_dac;
+        tv_ctl = I915_READ(TV_CTL);
+        save_tv_ctl = tv_ctl;
+        tv_ctl &= ~TV_ENC_ENABLE;
+        tv_ctl &= ~TV_TEST_MODE_MASK;
+        tv_ctl |= TV_TEST_MODE_MONITOR_DETECT;
+        tv_dac &= ~TVDAC_SENSE_MASK;
+        tv_dac &= ~DAC_A_MASK;
+        tv_dac &= ~DAC_B_MASK;
+        tv_dac &= ~DAC_C_MASK;
+        tv_dac |= (TVDAC_STATE_CHG_EN |
+                   TVDAC_A_SENSE_CTL |
+                   TVDAC_B_SENSE_CTL |
+                   TVDAC_C_SENSE_CTL |
+                   DAC_CTL_OVERRIDE |
+                   DAC_A_0_7_V |
+                   DAC_B_0_7_V |
+                   DAC_C_0_7_V);
+        I915_WRITE(TV_CTL, tv_ctl);
+        I915_WRITE(TV_DAC, tv_dac);
+        intel_wait_for_vblank(dev);
+        tv_dac = I915_READ(TV_DAC);
+        I915_WRITE(TV_DAC, save_tv_dac);
+        I915_WRITE(TV_CTL, save_tv_ctl);
+        intel_wait_for_vblank(dev);
         /*
          *  A B C
          *  0 1 1 Composite
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index f30aa7274a54..f97563db4e59 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -35,6 +35,23 @@
 #include "atom.h"
 
 /*
+ * Clear GPU surface registers.
+ */
+static void radeon_surface_init(struct radeon_device *rdev)
+{
+        /* FIXME: check this out */
+        if (rdev->family < CHIP_R600) {
+                int i;
+
+                for (i = 0; i < 8; i++) {
+                        WREG32(RADEON_SURFACE0_INFO +
+                               i * (RADEON_SURFACE1_INFO - RADEON_SURFACE0_INFO),
+                               0);
+                }
+        }
+}
+
+/*
  * GPU scratch registers helpers function.
  */
 static void radeon_scratch_init(struct radeon_device *rdev)
@@ -496,6 +513,8 @@ int radeon_device_init(struct radeon_device *rdev,
         radeon_errata(rdev);
         /* Initialize scratch registers */
         radeon_scratch_init(rdev);
+        /* Initialize surface registers */
+        radeon_surface_init(rdev);
 
         /* TODO: disable VGA need to use VGA request */
         /* BIOS*/
@@ -604,9 +623,6 @@ int radeon_device_init(struct radeon_device *rdev,
         if (r) {
                 return r;
         }
-        if (rdev->fbdev_rfb && rdev->fbdev_rfb->obj) {
-                rdev->fbdev_robj = rdev->fbdev_rfb->obj->driver_private;
-        }
         if (!ret) {
                 DRM_INFO("radeon: kernel modesetting successfully initialized.\n");
         }
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index 09c9fb9f6210..84ba69f48784 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -345,7 +345,7 @@ static void __exit radeon_exit(void)
         drm_exit(driver);
 }
 
-late_initcall(radeon_init);
+module_init(radeon_init);
 module_exit(radeon_exit);
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c
index fa86d398945e..9e8f191eb64a 100644
--- a/drivers/gpu/drm/radeon/radeon_fb.c
+++ b/drivers/gpu/drm/radeon/radeon_fb.c
@@ -478,14 +478,16 @@ int radeonfb_create(struct radeon_device *rdev,
 {
         struct fb_info *info;
         struct radeon_fb_device *rfbdev;
-        struct drm_framebuffer *fb;
+        struct drm_framebuffer *fb = NULL;
         struct radeon_framebuffer *rfb;
         struct drm_mode_fb_cmd mode_cmd;
         struct drm_gem_object *gobj = NULL;
         struct radeon_object *robj = NULL;
         struct device *device = &rdev->pdev->dev;
         int size, aligned_size, ret;
+        u64 fb_gpuaddr;
         void *fbptr = NULL;
+        unsigned long tmp;
 
         mode_cmd.width = surface_width;
         mode_cmd.height = surface_height;
@@ -498,11 +500,12 @@ int radeonfb_create(struct radeon_device *rdev,
         aligned_size = ALIGN(size, PAGE_SIZE);
 
         ret = radeon_gem_object_create(rdev, aligned_size, 0,
-                                       RADEON_GEM_DOMAIN_VRAM,
-                                       false, ttm_bo_type_kernel,
-                                       false, &gobj);
+                        RADEON_GEM_DOMAIN_VRAM,
+                        false, ttm_bo_type_kernel,
+                        false, &gobj);
         if (ret) {
-                printk(KERN_ERR "failed to allocate framebuffer\n");
+                printk(KERN_ERR "failed to allocate framebuffer (%d %d)\n",
+                       surface_width, surface_height);
                 ret = -ENOMEM;
                 goto out;
         }
@@ -515,12 +518,19 @@ int radeonfb_create(struct radeon_device *rdev,
                 ret = -ENOMEM;
                 goto out_unref;
         }
+        ret = radeon_object_pin(robj, RADEON_GEM_DOMAIN_VRAM, &fb_gpuaddr);
+        if (ret) {
+                printk(KERN_ERR "failed to pin framebuffer\n");
+                ret = -ENOMEM;
+                goto out_unref;
+        }
 
         list_add(&fb->filp_head, &rdev->ddev->mode_config.fb_kernel_list);
 
         rfb = to_radeon_framebuffer(fb);
         *rfb_p = rfb;
         rdev->fbdev_rfb = rfb;
+        rdev->fbdev_robj = robj;
 
         info = framebuffer_alloc(sizeof(struct radeon_fb_device), device);
         if (info == NULL) {
@@ -541,13 +551,13 @@ int radeonfb_create(struct radeon_device *rdev,
         info->fix.xpanstep = 1; /* doing it in hw */
         info->fix.ypanstep = 1; /* doing it in hw */
         info->fix.ywrapstep = 0;
-        info->fix.accel = FB_ACCEL_I830;
+        info->fix.accel = FB_ACCEL_NONE;
         info->fix.type_aux = 0;
         info->flags = FBINFO_DEFAULT;
         info->fbops = &radeonfb_ops;
         info->fix.line_length = fb->pitch;
-        info->screen_base = fbptr;
-        info->fix.smem_start = (unsigned long)fbptr;
+        tmp = fb_gpuaddr - rdev->mc.vram_location;
+        info->fix.smem_start = rdev->mc.aper_base + tmp;
         info->fix.smem_len = size;
         info->screen_base = fbptr;
         info->screen_size = size;
@@ -562,8 +572,8 @@ int radeonfb_create(struct radeon_device *rdev,
         info->var.width = -1;
         info->var.xres = fb_width;
         info->var.yres = fb_height;
-        info->fix.mmio_start = pci_resource_start(rdev->pdev, 2);
-        info->fix.mmio_len = pci_resource_len(rdev->pdev, 2);
+        info->fix.mmio_start = 0;
+        info->fix.mmio_len = 0;
         info->pixmap.size = 64*1024;
         info->pixmap.buf_align = 8;
         info->pixmap.access_align = 32;
@@ -644,7 +654,7 @@ out_unref:
         if (robj) {
                 radeon_object_kunmap(robj);
         }
-        if (ret) {
+        if (fb && ret) {
                 list_del(&fb->filp_head);
                 drm_gem_object_unreference(gobj);
                 drm_framebuffer_cleanup(fb);
@@ -813,6 +823,7 @@ int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb)
                 robj = rfb->obj->driver_private;
                 unregister_framebuffer(info);
                 radeon_object_kunmap(robj);
+                radeon_object_unpin(robj);
                 framebuffer_release(info);
         }
 
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index 983e8df5e000..bac0d06c52ac 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -223,7 +223,6 @@ int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
 {
         uint32_t flags;
         uint32_t tmp;
-        void *fbptr;
         int r;
 
         flags = radeon_object_flags_from_domain(domain);
@@ -242,10 +241,6 @@ int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
                 DRM_ERROR("radeon: failed to reserve object for pinning it.\n");
                 return r;
         }
-        if (robj->rdev->fbdev_robj == robj) {
-                mutex_lock(&robj->rdev->fbdev_info->lock);
-                radeon_object_kunmap(robj);
-        }
         tmp = robj->tobj.mem.placement;
         ttm_flag_masked(&tmp, flags, TTM_PL_MASK_MEM);
         robj->tobj.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT | TTM_PL_MASK_CACHING;
@@ -261,23 +256,12 @@ int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
                 DRM_ERROR("radeon: failed to pin object.\n");
         }
         radeon_object_unreserve(robj);
-        if (robj->rdev->fbdev_robj == robj) {
-                if (!r) {
-                        r = radeon_object_kmap(robj, &fbptr);
-                }
-                if (!r) {
-                        robj->rdev->fbdev_info->screen_base = fbptr;
-                        robj->rdev->fbdev_info->fix.smem_start = (unsigned long)fbptr;
-                }
-                mutex_unlock(&robj->rdev->fbdev_info->lock);
-        }
         return r;
 }
 
 void radeon_object_unpin(struct radeon_object *robj)
 {
         uint32_t flags;
-        void *fbptr;
         int r;
 
         spin_lock(&robj->tobj.lock);
@@ -297,10 +281,6 @@ void radeon_object_unpin(struct radeon_object *robj)
                 DRM_ERROR("radeon: failed to reserve object for unpinning it.\n");
                 return;
         }
-        if (robj->rdev->fbdev_robj == robj) {
-                mutex_lock(&robj->rdev->fbdev_info->lock);
-                radeon_object_kunmap(robj);
-        }
         flags = robj->tobj.mem.placement;
         robj->tobj.proposed_placement = flags & ~TTM_PL_FLAG_NO_EVICT;
         r = ttm_buffer_object_validate(&robj->tobj,
@@ -310,16 +290,6 @@ void radeon_object_unpin(struct radeon_object *robj)
                 DRM_ERROR("radeon: failed to unpin buffer.\n");
         }
         radeon_object_unreserve(robj);
-        if (robj->rdev->fbdev_robj == robj) {
-                if (!r) {
-                        r = radeon_object_kmap(robj, &fbptr);
-                }
-                if (!r) {
-                        robj->rdev->fbdev_info->screen_base = fbptr;
-                        robj->rdev->fbdev_info->fix.smem_start = (unsigned long)fbptr;
-                }
-                mutex_unlock(&robj->rdev->fbdev_info->lock);
-        }
 }
 
 int radeon_object_wait(struct radeon_object *robj)
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 517c84559633..bdec583901eb 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -34,7 +34,6 @@
 #include <linux/highmem.h>
 #include <linux/wait.h>
 #include <linux/vmalloc.h>
-#include <linux/version.h>
 #include <linux/module.h>
 
 void ttm_bo_free_old_node(struct ttm_buffer_object *bo)
diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c
index 27b146c54fbc..40b75032ea47 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_vm.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c
@@ -32,7 +32,6 @@
 #include <ttm/ttm_bo_driver.h>
 #include <ttm/ttm_placement.h>
 #include <linux/mm.h>
-#include <linux/version.h>
 #include <linux/rbtree.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index 0331fa74cd3f..75dc8bd24592 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -28,7 +28,6 @@
  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
  */
 
-#include <linux/version.h>
 #include <linux/vmalloc.h>
 #include <linux/sched.h>
 #include <linux/highmem.h>
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index aa87b6a3bbef..8206442fbabd 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -328,6 +328,7 @@ config I2C_DAVINCI
 
 config I2C_DESIGNWARE
         tristate "Synopsys DesignWare"
+        depends on HAVE_CLK
         help
           If you say yes to this option, support will be included for the
           Synopsys DesignWare I2C adapter. Only master mode is supported.
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index e4476743f203..b1bc6e277d2a 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -85,10 +85,11 @@ static void dump_iic_regs(const char* header, struct ibm_iic_private* dev)
 {
         volatile struct iic_regs __iomem *iic = dev->vaddr;
         printk(KERN_DEBUG "ibm-iic%d: %s\n", dev->idx, header);
-        printk(KERN_DEBUG "  cntl     = 0x%02x, mdcntl = 0x%02x\n"
-               KERN_DEBUG "  sts      = 0x%02x, extsts = 0x%02x\n"
-               KERN_DEBUG "  clkdiv   = 0x%02x, xfrcnt = 0x%02x\n"
-               KERN_DEBUG "  xtcntlss = 0x%02x, directcntl = 0x%02x\n",
+        printk(KERN_DEBUG
+               "  cntl     = 0x%02x, mdcntl = 0x%02x\n"
+               "  sts      = 0x%02x, extsts = 0x%02x\n"
+               "  clkdiv   = 0x%02x, xfrcnt = 0x%02x\n"
+               "  xtcntlss = 0x%02x, directcntl = 0x%02x\n",
                 in_8(&iic->cntl), in_8(&iic->mdcntl), in_8(&iic->sts),
                 in_8(&iic->extsts), in_8(&iic->clkdiv), in_8(&iic->xfrcnt),
                 in_8(&iic->xtcntlss), in_8(&iic->directcntl));
diff --git a/drivers/ide/cs5520.c b/drivers/ide/cs5520.c
index bd066bb9d611..09f98ed0731f 100644
--- a/drivers/ide/cs5520.c
+++ b/drivers/ide/cs5520.c
@@ -135,6 +135,7 @@ static int __devinit cs5520_init_one(struct pci_dev *dev, const struct pci_devic
 
         ide_pci_setup_ports(dev, d, &hw[0], &hws[0]);
         hw[0].irq = 14;
+        hw[1].irq = 15;
 
         return ide_host_add(d, hws, 2, NULL);
 }
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index 77f79d26b264..c509c9916464 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -92,6 +92,11 @@ int ide_acpi_init(void)
         return 0;
 }
 
+bool ide_port_acpi(ide_hwif_t *hwif)
+{
+        return ide_noacpi == 0 && hwif->acpidata;
+}
+
 /**
  * ide_get_dev_handle - finds acpi_handle and PCI device.function
  * @dev: device to locate
@@ -352,9 +357,6 @@ int ide_acpi_exec_tfs(ide_drive_t *drive)
         unsigned long   gtf_address;
         unsigned long   obj_loc;
 
-        if (ide_noacpi)
-                return 0;
-
         DEBPRINT("call get_GTF, drive=%s port=%d\n", drive->name, drive->dn);
 
         ret = do_drive_get_GTF(drive, &gtf_length, &gtf_address, &obj_loc);
@@ -389,16 +391,6 @@ void ide_acpi_get_timing(ide_hwif_t *hwif)
         struct acpi_buffer      output;
         union acpi_object       *out_obj;
 
-        if (ide_noacpi)
-                return;
-
-        DEBPRINT("ENTER:\n");
-
-        if (!hwif->acpidata) {
-                DEBPRINT("no ACPI data for %s\n", hwif->name);
-                return;
-        }
-
         /* Setting up output buffer for _GTM */
         output.length = ACPI_ALLOCATE_BUFFER;
         output.pointer = NULL;  /* ACPI-CA sets this; save/free it later */
@@ -479,16 +471,6 @@ void ide_acpi_push_timing(ide_hwif_t *hwif)
         struct ide_acpi_drive_link      *master = &hwif->acpidata->master;
         struct ide_acpi_drive_link      *slave = &hwif->acpidata->slave;
 
-        if (ide_noacpi)
-                return;
-
-        DEBPRINT("ENTER:\n");
-
-        if (!hwif->acpidata) {
-                DEBPRINT("no ACPI data for %s\n", hwif->name);
-                return;
-        }
-
         /* Give the GTM buffer + drive Identify data to the channel via the
          * _STM method: */
         /* setup input parameters buffer for _STM */
@@ -527,16 +509,11 @@ void ide_acpi_set_state(ide_hwif_t *hwif, int on)
         ide_drive_t *drive;
         int i;
 
-        if (ide_noacpi || ide_noacpi_psx)
+        if (ide_noacpi_psx)
                 return;
 
         DEBPRINT("ENTER:\n");
 
-        if (!hwif->acpidata) {
-                DEBPRINT("no ACPI data for %s\n", hwif->name);
-                return;
-        }
-
         /* channel first and then drives for power on and verse versa for power off */
         if (on)
                 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D0);
@@ -616,7 +593,7 @@ void ide_acpi_port_init_devices(ide_hwif_t *hwif)
                                  drive->name, err);
         }
 
-        if (!ide_acpionboot) {
+        if (ide_noacpi || ide_acpionboot == 0) {
                 DEBPRINT("ACPI methods disabled on boot\n");
                 return;
         }
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 4a19686fcfe9..6a9a769bffc1 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -592,9 +592,19 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                         }
                 } else if (!blk_pc_request(rq)) {
                         ide_cd_request_sense_fixup(drive, cmd);
-                        /* complain if we still have data left to transfer */
+
                         uptodate = cmd->nleft ? 0 : 1;
-                        if (uptodate == 0)
+
+                        /*
+                         * suck out the remaining bytes from the drive in an
+                         * attempt to complete the data xfer. (see BZ#13399)
+                         */
+                        if (!(stat & ATA_ERR) && !uptodate && thislen) {
+                                ide_pio_bytes(drive, cmd, write, thislen);
+                                uptodate = cmd->nleft ? 0 : 1;
+                        }
+
+                        if (!uptodate)
                                 rq->cmd_flags |= REQ_FAILED;
                 }
                 goto out_end;
@@ -876,9 +886,12 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
                 return stat;
 
         /*
-         * Sanity check the given block size
+         * Sanity check the given block size, in so far as making
+         * sure the sectors_per_frame we give to the caller won't
+         * end up being bogus.
          */
         blocklen = be32_to_cpu(capbuf.blocklen);
+        blocklen = (blocklen >> SECTOR_BITS) << SECTOR_BITS;
         switch (blocklen) {
         case 512:
         case 1024:
@@ -886,10 +899,9 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
         case 4096:
                 break;
         default:
-                printk(KERN_ERR PFX "%s: weird block size %u\n",
+                printk_once(KERN_ERR PFX "%s: weird block size %u; "
+                                "setting default block size to 2048\n",
                                 drive->name, blocklen);
-                printk(KERN_ERR PFX "%s: default to 2kb block size\n",
-                                drive->name);
                 blocklen = 2048;
                 break;
         }
diff --git a/drivers/ide/ide-devsets.c b/drivers/ide/ide-devsets.c
index 5bf958e5b1d5..1099bf7cf968 100644
--- a/drivers/ide/ide-devsets.c
+++ b/drivers/ide/ide-devsets.c
@@ -183,6 +183,6 @@ ide_startstop_t ide_do_devset(ide_drive_t *drive, struct request *rq)
         err = setfunc(drive, *(int *)&rq->cmd[1]);
         if (err)
                 rq->errors = err;
-        ide_complete_rq(drive, err, ide_rq_bytes(rq));
+        ide_complete_rq(drive, err, blk_rq_bytes(rq));
         return ide_stopped;
 }
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 219e6fb78dc6..ee58c88dee5a 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -361,9 +361,6 @@ static int ide_tune_dma(ide_drive_t *drive)
         if (__ide_dma_bad_drive(drive))
                 return 0;
 
-        if (ide_id_dma_bug(drive))
-                return 0;
-
         if (hwif->host_flags & IDE_HFLAG_TRUST_BIOS_FOR_DMA)
                 return config_drive_for_dma(drive);
 
@@ -394,24 +391,6 @@ static int ide_dma_check(ide_drive_t *drive)
         return -1;
 }
 
-int ide_id_dma_bug(ide_drive_t *drive)
-{
-        u16 *id = drive->id;
-
-        if (id[ATA_ID_FIELD_VALID] & 4) {
-                if ((id[ATA_ID_UDMA_MODES] >> 8) &&
-                    (id[ATA_ID_MWDMA_MODES] >> 8))
-                        goto err_out;
-        } else if ((id[ATA_ID_MWDMA_MODES] >> 8) &&
-                   (id[ATA_ID_SWDMA_MODES] >> 8))
-                goto err_out;
-
-        return 0;
-err_out:
-        printk(KERN_ERR "%s: bad DMA info in identify block\n", drive->name);
-        return 1;
-}
-
 int ide_set_dma(ide_drive_t *drive)
 {
         int rc;
diff --git a/drivers/ide/ide-eh.c b/drivers/ide/ide-eh.c
index 2b9141979613..e9abf2c3c335 100644
--- a/drivers/ide/ide-eh.c
+++ b/drivers/ide/ide-eh.c
@@ -149,7 +149,7 @@ static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
         if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET) {
                 if (err <= 0 && rq->errors == 0)
                         rq->errors = -EIO;
-                ide_complete_rq(drive, err ? err : 0, ide_rq_bytes(rq));
+                ide_complete_rq(drive, err ? err : 0, blk_rq_bytes(rq));
         }
 }
 
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 8b3f204f7d73..fefbdfc8db06 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -293,7 +293,7 @@ out_end:
         drive->failed_pc = NULL;
         if (blk_fs_request(rq) == 0 && rq->errors == 0)
                 rq->errors = -EIO;
-        ide_complete_rq(drive, -EIO, ide_rq_bytes(rq));
+        ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
         return ide_stopped;
 }
 
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 1059f809b809..db96138fefcd 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -112,16 +112,6 @@ void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err)
         }
 }
 
-/* obsolete, blk_rq_bytes() should be used instead */
-unsigned int ide_rq_bytes(struct request *rq)
-{
-        if (blk_pc_request(rq))
-                return blk_rq_bytes(rq);
-        else
-                return blk_rq_cur_sectors(rq) << 9;
-}
-EXPORT_SYMBOL_GPL(ide_rq_bytes);
-
 int ide_complete_rq(ide_drive_t *drive, int error, unsigned int nr_bytes)
 {
         ide_hwif_t *hwif = drive->hwif;
@@ -152,14 +142,14 @@ void ide_kill_rq(ide_drive_t *drive, struct request *rq)
 
         if ((media == ide_floppy || media == ide_tape) && drv_req) {
                 rq->errors = 0;
-                ide_complete_rq(drive, 0, blk_rq_bytes(rq));
         } else {
                 if (media == ide_tape)
                         rq->errors = IDE_DRV_ERROR_GENERAL;
                 else if (blk_fs_request(rq) == 0 && rq->errors == 0)
                         rq->errors = -EIO;
-                ide_complete_rq(drive, -EIO, ide_rq_bytes(rq));
         }
+
+        ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
 }
 
 static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index 82f252c3ee6e..e246d3d3fbcc 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -64,7 +64,8 @@ static int ide_get_identity_ioctl(ide_drive_t *drive, unsigned int cmd,
                 goto out;
         }
 
-        id = kmalloc(size, GFP_KERNEL);
+        /* ata_id_to_hd_driveid() relies on 'id' to be fully allocated. */
+        id = kmalloc(ATA_ID_WORDS * 2, GFP_KERNEL);
         if (id == NULL) {
                 rc = -ENOMEM;
                 goto out;
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index fa047150a1c6..2892b242bbe1 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -210,6 +210,7 @@ EXPORT_SYMBOL_GPL(ide_in_drive_list);
  */
 static const struct drive_list_entry ivb_list[] = {
         { "QUANTUM FIREBALLlct10 05"    , "A03.0900"    },
+        { "QUANTUM FIREBALLlct20 30"    , "APL.0900"    },
         { "TSSTcorp CDDVDW SH-S202J"    , "SB00"        },
         { "TSSTcorp CDDVDW SH-S202J"    , "SB01"        },
         { "TSSTcorp CDDVDW SH-S202N"    , "SB00"        },
@@ -329,9 +330,6 @@ int ide_driveid_update(ide_drive_t *drive)
 
         kfree(id);
 
-        if ((drive->dev_flags & IDE_DFLAG_USING_DMA) && ide_id_dma_bug(drive))
-                ide_dma_off(drive);
-
         return 1;
 out_err:
         if (rc == 2)
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index c14ca144cffe..ad7be2669dcb 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -10,9 +10,11 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         struct request_pm_state rqpm;
         int ret;
 
-        /* call ACPI _GTM only once */
-        if ((drive->dn & 1) == 0 || pair == NULL)
-                ide_acpi_get_timing(hwif);
+        if (ide_port_acpi(hwif)) {
+                /* call ACPI _GTM only once */
+                if ((drive->dn & 1) == 0 || pair == NULL)
+                        ide_acpi_get_timing(hwif);
+        }
 
         memset(&rqpm, 0, sizeof(rqpm));
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
@@ -26,9 +28,11 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         ret = blk_execute_rq(drive->queue, NULL, rq, 0);
         blk_put_request(rq);
 
-        /* call ACPI _PS3 only after both devices are suspended */
-        if (ret == 0 && ((drive->dn & 1) || pair == NULL))
-                ide_acpi_set_state(hwif, 0);
+        if (ret == 0 && ide_port_acpi(hwif)) {
+                /* call ACPI _PS3 only after both devices are suspended */
+                if ((drive->dn & 1) || pair == NULL)
+                        ide_acpi_set_state(hwif, 0);
+        }
 
         return ret;
 }
@@ -42,13 +46,15 @@ int generic_ide_resume(struct device *dev)
         struct request_pm_state rqpm;
         int err;
 
-        /* call ACPI _PS0 / _STM only once */
-        if ((drive->dn & 1) == 0 || pair == NULL) {
-                ide_acpi_set_state(hwif, 1);
-                ide_acpi_push_timing(hwif);
-        }
+        if (ide_port_acpi(hwif)) {
+                /* call ACPI _PS0 / _STM only once */
+                if ((drive->dn & 1) == 0 || pair == NULL) {
+                        ide_acpi_set_state(hwif, 1);
+                        ide_acpi_push_timing(hwif);
+                }
 
-        ide_acpi_exec_tfs(drive);
+                ide_acpi_exec_tfs(drive);
+        }
 
         memset(&rqpm, 0, sizeof(rqpm));
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 51af4eea0d36..1bb106f6221a 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -818,6 +818,24 @@ static int ide_port_setup_devices(ide_hwif_t *hwif)
         return j;
 }
 
+static void ide_host_enable_irqs(struct ide_host *host)
+{
+        ide_hwif_t *hwif;
+        int i;
+
+        ide_host_for_each_port(i, hwif, host) {
+                if (hwif == NULL)
+                        continue;
+
+                /* clear any pending IRQs */
+                hwif->tp_ops->read_status(hwif);
+
+                /* unmask IRQs */
+                if (hwif->io_ports.ctl_addr)
+                        hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
+        }
+}
+
 /*
  * This routine sets up the IRQ for an IDE interface.
  */
@@ -831,9 +849,6 @@ static int init_irq (ide_hwif_t *hwif)
         if (irq_handler == NULL)
                 irq_handler = ide_intr;
 
-        if (io_ports->ctl_addr)
-                hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
-
         if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
                 goto out_up;
 
@@ -1404,6 +1419,8 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                         ide_port_tune_devices(hwif);
         }
 
+        ide_host_enable_irqs(host);
+
         ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index 83b734aec923..52b25f8b111d 100644
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -880,6 +880,7 @@ static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *ud)
         }
 
         shost->hostdata[0] = (unsigned long)lu;
+        shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
 
         if (!scsi_add_host(shost, &ud->device)) {
                 lu->shost = shost;
diff --git a/drivers/ieee1394/sbp2.h b/drivers/ieee1394/sbp2.h
index c5036f1cc5b0..64a3a66a8a39 100644
--- a/drivers/ieee1394/sbp2.h
+++ b/drivers/ieee1394/sbp2.h
@@ -25,6 +25,12 @@
 #define SBP2_DEVICE_NAME                "sbp2"
 
 /*
+ * There is no transport protocol limit to the CDB length,  but we implement
+ * a fixed length only.  16 bytes is enough for disks larger than 2 TB.
+ */
+#define SBP2_MAX_CDB_SIZE               16
+
+/*
  * SBP-2 specific definitions
  */
 
@@ -51,7 +57,7 @@ struct sbp2_command_orb {
         u32 data_descriptor_hi;
         u32 data_descriptor_lo;
         u32 misc;
-        u8 cdb[12];
+        u8 cdb[SBP2_MAX_CDB_SIZE];
 } __attribute__((packed));
 
 #define SBP2_LOGIN_REQUEST              0x0
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 9d8f796c6745..a6b989a9dc07 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -12,6 +12,42 @@ menuconfig INPUT_KEYBOARD
 
 if INPUT_KEYBOARD
 
+config KEYBOARD_AAED2000
+        tristate "AAED-2000 keyboard"
+        depends on MACH_AAED2000
+        select INPUT_POLLDEV
+        default y
+        help
+          Say Y here to enable the keyboard on the Agilent AAED-2000
+          development board.
+
+          To compile this driver as a module, choose M here: the
+          module will be called aaed2000_kbd.
+
+config KEYBOARD_AMIGA
+        tristate "Amiga keyboard"
+        depends on AMIGA
+        help
+          Say Y here if you are running Linux on any AMIGA and have a keyboard
+          attached.
+
+          To compile this driver as a module, choose M here: the
+          module will be called amikbd.
+
+config ATARI_KBD_CORE
+        bool
+
+config KEYBOARD_ATARI
+        tristate "Atari keyboard"
+        depends on ATARI
+        select ATARI_KBD_CORE
+        help
+          Say Y here if you are running Linux on any Atari and have a keyboard
+          attached.
+
+          To compile this driver as a module, choose M here: the
+          module will be called atakbd.
+
 config KEYBOARD_ATKBD
         tristate "AT keyboard" if EMBEDDED || !X86
         default y
@@ -68,69 +104,14 @@ config KEYBOARD_ATKBD_RDI_KEYCODES
           right-hand column will be interpreted as the key shown in the
           left-hand column.
 
-config KEYBOARD_SUNKBD
-        tristate "Sun Type 4 and Type 5 keyboard"
-        select SERIO
-        help
-          Say Y here if you want to use a Sun Type 4 or Type 5 keyboard,
-          connected either to the Sun keyboard connector or to an serial
-          (RS-232) port via a simple adapter.
-
-          To compile this driver as a module, choose M here: the
-          module will be called sunkbd.
-
-config KEYBOARD_LKKBD
-        tristate "DECstation/VAXstation LK201/LK401 keyboard"
-        select SERIO
-        help
-          Say Y here if you want to use a LK201 or LK401 style serial
-          keyboard. This keyboard is also useable on PCs if you attach
-          it with the inputattach program. The connector pinout is
-          described within lkkbd.c.
-
-          To compile this driver as a module, choose M here: the
-          module will be called lkkbd.
-
-config KEYBOARD_LOCOMO
-        tristate "LoCoMo Keyboard Support"
-        depends on SHARP_LOCOMO && INPUT_KEYBOARD
-        help
-          Say Y here if you are running Linux on a Sharp Zaurus Collie or Poodle based PDA
-
-          To compile this driver as a module, choose M here: the
-          module will be called locomokbd.
-
-config KEYBOARD_XTKBD
-        tristate "XT keyboard"
-        select SERIO
-        help
-          Say Y here if you want to use the old IBM PC/XT keyboard (or
-          compatible) on your system. This is only possible with a
-          parallel port keyboard adapter, you cannot connect it to the
-          keyboard port on a PC that runs Linux.
-
-          To compile this driver as a module, choose M here: the
-          module will be called xtkbd.
-
-config KEYBOARD_NEWTON
-        tristate "Newton keyboard"
-        select SERIO
-        help
-          Say Y here if you have a Newton keyboard on a serial port.
-
-          To compile this driver as a module, choose M here: the
-          module will be called newtonkbd.
-
-config KEYBOARD_STOWAWAY
-        tristate "Stowaway keyboard"
-        select SERIO
+config KEYBOARD_BFIN
+        tristate "Blackfin BF54x keypad support"
+        depends on (BF54x && !BF544)
         help
-          Say Y here if you have a Stowaway keyboard on a serial port.
-          Stowaway compatible keyboards like Dicota Input-PDA keyboard
-          are also supported by this driver.
+          Say Y here if you want to use the BF54x keypad.
 
           To compile this driver as a module, choose M here: the
-          module will be called stowaway.
+          module will be called bf54x-keys.
 
 config KEYBOARD_CORGI
         tristate "Corgi keyboard"
@@ -143,61 +124,50 @@ config KEYBOARD_CORGI
           To compile this driver as a module, choose M here: the
           module will be called corgikbd.
 
-config KEYBOARD_SPITZ
-        tristate "Spitz keyboard"
-        depends on PXA_SHARPSL
-        default y
+config KEYBOARD_LKKBD
+        tristate "DECstation/VAXstation LK201/LK401 keyboard"
+        select SERIO
         help
-          Say Y here to enable the keyboard on the Sharp Zaurus SL-C1000,
-          SL-C3000 and Sl-C3100 series of PDAs.
+          Say Y here if you want to use a LK201 or LK401 style serial
+          keyboard. This keyboard is also useable on PCs if you attach
+          it with the inputattach program. The connector pinout is
+          described within lkkbd.c.
 
           To compile this driver as a module, choose M here: the
-          module will be called spitzkbd.
+          module will be called lkkbd.
 
-config KEYBOARD_TOSA
-        tristate "Tosa keyboard"
-        depends on MACH_TOSA
-        default y
+config KEYBOARD_EP93XX
+        tristate "EP93xx Matrix Keypad support"
+        depends on ARCH_EP93XX
         help
-          Say Y here to enable the keyboard on the Sharp Zaurus SL-6000x (Tosa)
+          Say Y here to enable the matrix keypad on the Cirrus EP93XX.
 
           To compile this driver as a module, choose M here: the
-          module will be called tosakbd.
+          module will be called ep93xx_keypad.
 
-config KEYBOARD_TOSA_USE_EXT_KEYCODES
-        bool "Tosa keyboard: use extended keycodes"
-        depends on KEYBOARD_TOSA
-        default n
+config KEYBOARD_GPIO
+        tristate "GPIO Buttons"
+        depends on GENERIC_GPIO
         help
-          Say Y here to enable the tosa keyboard driver to generate extended
-          (>= 127) keycodes. Be aware, that they can't be correctly interpreted
-          by either console keyboard driver or by Kdrive keybd driver.
-
-          Say Y only if you know, what you are doing!
+          This driver implements support for buttons connected
+          to GPIO pins of various CPUs (and some other chips).
 
-config KEYBOARD_AMIGA
-        tristate "Amiga keyboard"
-        depends on AMIGA
-        help
-          Say Y here if you are running Linux on any AMIGA and have a keyboard
-          attached.
+          Say Y here if your device has buttons connected
+          directly to such GPIO pins.  Your board-specific
+          setup logic must also provide a platform device,
+          with configuration data saying which GPIOs are used.
 
           To compile this driver as a module, choose M here: the
-          module will be called amikbd.
+          module will be called gpio_keys.
 
-config ATARI_KBD_CORE
-        bool
-
-config KEYBOARD_ATARI
-        tristate "Atari keyboard"
-        depends on ATARI
-        select ATARI_KBD_CORE
+config KEYBOARD_MATRIX
+        tristate "GPIO driven matrix keypad support"
+        depends on GENERIC_GPIO
         help
-          Say Y here if you are running Linux on any Atari and have a keyboard
-          attached.
+          Enable support for GPIO driven matrix keypad.
 
           To compile this driver as a module, choose M here: the
-          module will be called atakbd.
+          module will be called matrix_keypad.
 
 config KEYBOARD_HIL_OLD
         tristate "HP HIL keyboard support (simple driver)"
@@ -261,20 +231,39 @@ config KEYBOARD_LM8323
           To compile this driver as a module, choose M here: the
           module will be called lm8323.
 
-config KEYBOARD_OMAP
-        tristate "TI OMAP keypad support"
-        depends on (ARCH_OMAP1 || ARCH_OMAP2)
+config KEYBOARD_LOCOMO
+        tristate "LoCoMo Keyboard Support"
+        depends on SHARP_LOCOMO
         help
-          Say Y here if you want to use the OMAP keypad.
+          Say Y here if you are running Linux on a Sharp Zaurus Collie or Poodle based PDA
 
           To compile this driver as a module, choose M here: the
-          module will be called omap-keypad.
+          module will be called locomokbd.
+
+config KEYBOARD_MAPLE
+        tristate "Maple bus keyboard"
+        depends on SH_DREAMCAST && MAPLE
+        help
+          Say Y here if you have a Dreamcast console running Linux and have
+          a keyboard attached to its Maple bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called maple_keyb.
+
+config KEYBOARD_NEWTON
+        tristate "Newton keyboard"
+        select SERIO
+        help
+          Say Y here if you have a Newton keyboard on a serial port.
+
+          To compile this driver as a module, choose M here: the
+          module will be called newtonkbd.
 
 config KEYBOARD_PXA27x
         tristate "PXA27x/PXA3xx keypad support"
         depends on PXA27x || PXA3xx
         help
-          Enable support for PXA27x/PXA3xx keypad controller
+          Enable support for PXA27x/PXA3xx keypad controller.
 
           To compile this driver as a module, choose M here: the
           module will be called pxa27x_keypad.
@@ -288,51 +277,38 @@ config KEYBOARD_PXA930_ROTARY
           To compile this driver as a module, choose M here: the
           module will be called pxa930_rotary.
 
-config KEYBOARD_AAED2000
-        tristate "AAED-2000 keyboard"
-        depends on MACH_AAED2000
-        select INPUT_POLLDEV
+config KEYBOARD_SPITZ
+        tristate "Spitz keyboard"
+        depends on PXA_SHARPSL
         default y
         help
-          Say Y here to enable the keyboard on the Agilent AAED-2000
-          development board.
-
-          To compile this driver as a module, choose M here: the
-          module will be called aaed2000_kbd.
-
-config KEYBOARD_GPIO
-        tristate "GPIO Buttons"
-        depends on GENERIC_GPIO
-        help
-          This driver implements support for buttons connected
-          to GPIO pins of various CPUs (and some other chips).
-
-          Say Y here if your device has buttons connected
-          directly to such GPIO pins.  Your board-specific
-          setup logic must also provide a platform device,
-          with configuration data saying which GPIOs are used.
+          Say Y here to enable the keyboard on the Sharp Zaurus SL-C1000,
+          SL-C3000 and Sl-C3100 series of PDAs.
 
           To compile this driver as a module, choose M here: the
-          module will be called gpio-keys.
+          module will be called spitzkbd.
 
-config KEYBOARD_MAPLE
-        tristate "Maple bus keyboard"
-        depends on SH_DREAMCAST && MAPLE
+config KEYBOARD_STOWAWAY
+        tristate "Stowaway keyboard"
+        select SERIO
         help
-          Say Y here if you have a Dreamcast console running Linux and have
-          a keyboard attached to its Maple bus.
+          Say Y here if you have a Stowaway keyboard on a serial port.
+          Stowaway compatible keyboards like Dicota Input-PDA keyboard
+          are also supported by this driver.
 
           To compile this driver as a module, choose M here: the
-          module will be called maple_keyb.
+          module will be called stowaway.
 
-config KEYBOARD_BFIN
-        tristate "Blackfin BF54x keypad support"
-        depends on (BF54x && !BF544)
+config KEYBOARD_SUNKBD
+        tristate "Sun Type 4 and Type 5 keyboard"
+        select SERIO
         help
-          Say Y here if you want to use the BF54x keypad.
+          Say Y here if you want to use a Sun Type 4 or Type 5 keyboard,
+          connected either to the Sun keyboard connector or to an serial
+          (RS-232) port via a simple adapter.
 
           To compile this driver as a module, choose M here: the
-          module will be called bf54x-keys.
+          module will be called sunkbd.
 
 config KEYBOARD_SH_KEYSC
         tristate "SuperH KEYSC keypad support"
@@ -344,13 +320,45 @@ config KEYBOARD_SH_KEYSC
           To compile this driver as a module, choose M here: the
           module will be called sh_keysc.
 
-config KEYBOARD_EP93XX
-        tristate "EP93xx Matrix Keypad support"
-        depends on ARCH_EP93XX
+config KEYBOARD_OMAP
+        tristate "TI OMAP keypad support"
+        depends on (ARCH_OMAP1 || ARCH_OMAP2)
         help
-          Say Y here to enable the matrix keypad on the Cirrus EP93XX.
+          Say Y here if you want to use the OMAP keypad.
 
           To compile this driver as a module, choose M here: the
-          module will be called ep93xx_keypad.
+          module will be called omap-keypad.
+
+config KEYBOARD_TOSA
+        tristate "Tosa keyboard"
+        depends on MACH_TOSA
+        default y
+        help
+          Say Y here to enable the keyboard on the Sharp Zaurus SL-6000x (Tosa)
+
+          To compile this driver as a module, choose M here: the
+          module will be called tosakbd.
+
+config KEYBOARD_TOSA_USE_EXT_KEYCODES
+        bool "Tosa keyboard: use extended keycodes"
+        depends on KEYBOARD_TOSA
+        help
+          Say Y here to enable the tosa keyboard driver to generate extended
+          (>= 127) keycodes. Be aware, that they can't be correctly interpreted
+          by either console keyboard driver or by Kdrive keybd driver.
+
+          Say Y only if you know, what you are doing!
+
+config KEYBOARD_XTKBD
+        tristate "XT keyboard"
+        select SERIO
+        help
+          Say Y here if you want to use the old IBM PC/XT keyboard (or
+          compatible) on your system. This is only possible with a
+          parallel port keyboard adapter, you cannot connect it to the
+          keyboard port on a PC that runs Linux.
+
+          To compile this driver as a module, choose M here: the
+          module will be called xtkbd.
 
 endif
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 156b647a259b..b5b5eae9724f 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -4,29 +4,30 @@
 
 # Each configuration option enables a list of files.
 
-obj-$(CONFIG_KEYBOARD_ATKBD)            += atkbd.o
-obj-$(CONFIG_KEYBOARD_SUNKBD)           += sunkbd.o
-obj-$(CONFIG_KEYBOARD_LKKBD)            += lkkbd.o
-obj-$(CONFIG_KEYBOARD_XTKBD)            += xtkbd.o
+obj-$(CONFIG_KEYBOARD_AAED2000)         += aaed2000_kbd.o
 obj-$(CONFIG_KEYBOARD_AMIGA)            += amikbd.o
 obj-$(CONFIG_KEYBOARD_ATARI)            += atakbd.o
-obj-$(CONFIG_KEYBOARD_LOCOMO)           += locomokbd.o
-obj-$(CONFIG_KEYBOARD_NEWTON)           += newtonkbd.o
-obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
+obj-$(CONFIG_KEYBOARD_ATKBD)            += atkbd.o
+obj-$(CONFIG_KEYBOARD_BFIN)             += bf54x-keys.o
 obj-$(CONFIG_KEYBOARD_CORGI)            += corgikbd.o
-obj-$(CONFIG_KEYBOARD_SPITZ)            += spitzkbd.o
-obj-$(CONFIG_KEYBOARD_TOSA)             += tosakbd.o
+obj-$(CONFIG_KEYBOARD_EP93XX)           += ep93xx_keypad.o
+obj-$(CONFIG_KEYBOARD_GPIO)             += gpio_keys.o
 obj-$(CONFIG_KEYBOARD_HIL)              += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)          += hilkbd.o
+obj-$(CONFIG_KEYBOARD_HP6XX)            += jornada680_kbd.o
+obj-$(CONFIG_KEYBOARD_HP7XX)            += jornada720_kbd.o
+obj-$(CONFIG_KEYBOARD_LKKBD)            += lkkbd.o
 obj-$(CONFIG_KEYBOARD_LM8323)           += lm8323.o
+obj-$(CONFIG_KEYBOARD_LOCOMO)           += locomokbd.o
+obj-$(CONFIG_KEYBOARD_MAPLE)            += maple_keyb.o
+obj-$(CONFIG_KEYBOARD_MATRIX)           += matrix_keypad.o
+obj-$(CONFIG_KEYBOARD_NEWTON)           += newtonkbd.o
 obj-$(CONFIG_KEYBOARD_OMAP)             += omap-keypad.o
 obj-$(CONFIG_KEYBOARD_PXA27x)           += pxa27x_keypad.o
 obj-$(CONFIG_KEYBOARD_PXA930_ROTARY)    += pxa930_rotary.o
-obj-$(CONFIG_KEYBOARD_AAED2000)         += aaed2000_kbd.o
-obj-$(CONFIG_KEYBOARD_GPIO)             += gpio_keys.o
-obj-$(CONFIG_KEYBOARD_HP6XX)            += jornada680_kbd.o
-obj-$(CONFIG_KEYBOARD_HP7XX)            += jornada720_kbd.o
-obj-$(CONFIG_KEYBOARD_MAPLE)            += maple_keyb.o
-obj-$(CONFIG_KEYBOARD_BFIN)             += bf54x-keys.o
 obj-$(CONFIG_KEYBOARD_SH_KEYSC)         += sh_keysc.o
-obj-$(CONFIG_KEYBOARD_EP93XX)           += ep93xx_keypad.o
+obj-$(CONFIG_KEYBOARD_SPITZ)            += spitzkbd.o
+obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
+obj-$(CONFIG_KEYBOARD_SUNKBD)           += sunkbd.o
+obj-$(CONFIG_KEYBOARD_TOSA)             += tosakbd.o
+obj-$(CONFIG_KEYBOARD_XTKBD)            += xtkbd.o
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index 2157cd7de00c..efed0c9e242e 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -29,7 +29,8 @@
 struct gpio_button_data {
         struct gpio_keys_button *button;
         struct input_dev *input;
-        struct delayed_work work;
+        struct timer_list timer;
+        struct work_struct work;
 };
 
 struct gpio_keys_drvdata {
@@ -40,7 +41,7 @@ struct gpio_keys_drvdata {
 static void gpio_keys_report_event(struct work_struct *work)
 {
         struct gpio_button_data *bdata =
-                container_of(work, struct gpio_button_data, work.work);
+                container_of(work, struct gpio_button_data, work);
         struct gpio_keys_button *button = bdata->button;
         struct input_dev *input = bdata->input;
         unsigned int type = button->type ?: EV_KEY;
@@ -50,17 +51,25 @@ static void gpio_keys_report_event(struct work_struct *work)
         input_sync(input);
 }
 
+static void gpio_keys_timer(unsigned long _data)
+{
+        struct gpio_button_data *data = (struct gpio_button_data *)_data;
+
+        schedule_work(&data->work);
+}
+
 static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
 {
         struct gpio_button_data *bdata = dev_id;
         struct gpio_keys_button *button = bdata->button;
-        unsigned long delay;
 
         BUG_ON(irq != gpio_to_irq(button->gpio));
 
-        delay = button->debounce_interval ?
-                        msecs_to_jiffies(button->debounce_interval) : 0;
-        schedule_delayed_work(&bdata->work, delay);
+        if (button->debounce_interval)
+                mod_timer(&bdata->timer,
+                        jiffies + msecs_to_jiffies(button->debounce_interval));
+        else
+                schedule_work(&bdata->work);
 
         return IRQ_HANDLED;
 }
@@ -107,7 +116,9 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
 
                 bdata->input = input;
                 bdata->button = button;
-                INIT_DELAYED_WORK(&bdata->work, gpio_keys_report_event);
+                setup_timer(&bdata->timer,
+                            gpio_keys_timer, (unsigned long)bdata);
+                INIT_WORK(&bdata->work, gpio_keys_report_event);
 
                 error = gpio_request(button->gpio, button->desc ?: "gpio_keys");
                 if (error < 0) {
@@ -166,7 +177,9 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
  fail2:
         while (--i >= 0) {
                 free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
-                cancel_delayed_work_sync(&ddata->data[i].work);
+                if (pdata->buttons[i].debounce_interval)
+                        del_timer_sync(&ddata->data[i].timer);
+                cancel_work_sync(&ddata->data[i].work);
                 gpio_free(pdata->buttons[i].gpio);
         }
 
@@ -190,7 +203,9 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)
         for (i = 0; i < pdata->nbuttons; i++) {
                 int irq = gpio_to_irq(pdata->buttons[i].gpio);
                 free_irq(irq, &ddata->data[i]);
-                cancel_delayed_work_sync(&ddata->data[i].work);
+                if (pdata->buttons[i].debounce_interval)
+                        del_timer_sync(&ddata->data[i].timer);
+                cancel_work_sync(&ddata->data[i].work);
                 gpio_free(pdata->buttons[i].gpio);
         }
 
diff --git a/drivers/input/keyboard/matrix_keypad.c b/drivers/input/keyboard/matrix_keypad.c
new file mode 100644
index 000000000000..e9b2e7cb05be
--- /dev/null
+++ b/drivers/input/keyboard/matrix_keypad.c
@@ -0,0 +1,453 @@
+/*
+ *  GPIO driven matrix keyboard driver
+ *
+ *  Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
+ *
+ *  Based on corgikbd.c
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/input/matrix_keypad.h>
+
+struct matrix_keypad {
+        const struct matrix_keypad_platform_data *pdata;
+        struct input_dev *input_dev;
+        unsigned short *keycodes;
+
+        uint32_t last_key_state[MATRIX_MAX_COLS];
+        struct delayed_work work;
+        bool scan_pending;
+        bool stopped;
+        spinlock_t lock;
+};
+
+/*
+ * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
+ * minmal side effect when scanning other columns, here it is configured to
+ * be input, and it should work on most platforms.
+ */
+static void __activate_col(const struct matrix_keypad_platform_data *pdata,
+                           int col, bool on)
+{
+        bool level_on = !pdata->active_low;
+
+        if (on) {
+                gpio_direction_output(pdata->col_gpios[col], level_on);
+        } else {
+                gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
+                gpio_direction_input(pdata->col_gpios[col]);
+        }
+}
+
+static void activate_col(const struct matrix_keypad_platform_data *pdata,
+                         int col, bool on)
+{
+        __activate_col(pdata, col, on);
+
+        if (on && pdata->col_scan_delay_us)
+                udelay(pdata->col_scan_delay_us);
+}
+
+static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
+                              bool on)
+{
+        int col;
+
+        for (col = 0; col < pdata->num_col_gpios; col++)
+                __activate_col(pdata, col, on);
+}
+
+static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
+                         int row)
+{
+        return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
+                        !pdata->active_low : pdata->active_low;
+}
+
+static void enable_row_irqs(struct matrix_keypad *keypad)
+{
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        int i;
+
+        for (i = 0; i < pdata->num_row_gpios; i++)
+                enable_irq(gpio_to_irq(pdata->row_gpios[i]));
+}
+
+static void disable_row_irqs(struct matrix_keypad *keypad)
+{
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        int i;
+
+        for (i = 0; i < pdata->num_row_gpios; i++)
+                disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
+}
+
+/*
+ * This gets the keys from keyboard and reports it to input subsystem
+ */
+static void matrix_keypad_scan(struct work_struct *work)
+{
+        struct matrix_keypad *keypad =
+                container_of(work, struct matrix_keypad, work.work);
+        struct input_dev *input_dev = keypad->input_dev;
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        uint32_t new_state[MATRIX_MAX_COLS];
+        int row, col, code;
+
+        /* de-activate all columns for scanning */
+        activate_all_cols(pdata, false);
+
+        memset(new_state, 0, sizeof(new_state));
+
+        /* assert each column and read the row status out */
+        for (col = 0; col < pdata->num_col_gpios; col++) {
+
+                activate_col(pdata, col, true);
+
+                for (row = 0; row < pdata->num_row_gpios; row++)
+                        new_state[col] |=
+                                row_asserted(pdata, row) ? (1 << row) : 0;
+
+                activate_col(pdata, col, false);
+        }
+
+        for (col = 0; col < pdata->num_col_gpios; col++) {
+                uint32_t bits_changed;
+
+                bits_changed = keypad->last_key_state[col] ^ new_state[col];
+                if (bits_changed == 0)
+                        continue;
+
+                for (row = 0; row < pdata->num_row_gpios; row++) {
+                        if ((bits_changed & (1 << row)) == 0)
+                                continue;
+
+                        code = (row << 4) + col;
+                        input_event(input_dev, EV_MSC, MSC_SCAN, code);
+                        input_report_key(input_dev,
+                                         keypad->keycodes[code],
+                                         new_state[col] & (1 << row));
+                }
+        }
+        input_sync(input_dev);
+
+        memcpy(keypad->last_key_state, new_state, sizeof(new_state));
+
+        activate_all_cols(pdata, true);
+
+        /* Enable IRQs again */
+        spin_lock_irq(&keypad->lock);
+        keypad->scan_pending = false;
+        enable_row_irqs(keypad);
+        spin_unlock_irq(&keypad->lock);
+}
+
+static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
+{
+        struct matrix_keypad *keypad = id;
+        unsigned long flags;
+
+        spin_lock_irqsave(&keypad->lock, flags);
+
+        /*
+         * See if another IRQ beaten us to it and scheduled the
+         * scan already. In that case we should not try to
+         * disable IRQs again.
+         */
+        if (unlikely(keypad->scan_pending || keypad->stopped))
+                goto out;
+
+        disable_row_irqs(keypad);
+        keypad->scan_pending = true;
+        schedule_delayed_work(&keypad->work,
+                msecs_to_jiffies(keypad->pdata->debounce_ms));
+
+out:
+        spin_unlock_irqrestore(&keypad->lock, flags);
+        return IRQ_HANDLED;
+}
+
+static int matrix_keypad_start(struct input_dev *dev)
+{
+        struct matrix_keypad *keypad = input_get_drvdata(dev);
+
+        keypad->stopped = false;
+        mb();
+
+        /*
+         * Schedule an immediate key scan to capture current key state;
+         * columns will be activated and IRQs be enabled after the scan.
+         */
+        schedule_delayed_work(&keypad->work, 0);
+
+        return 0;
+}
+
+static void matrix_keypad_stop(struct input_dev *dev)
+{
+        struct matrix_keypad *keypad = input_get_drvdata(dev);
+
+        keypad->stopped = true;
+        mb();
+        flush_work(&keypad->work.work);
+        /*
+         * matrix_keypad_scan() will leave IRQs enabled;
+         * we should disable them now.
+         */
+        disable_row_irqs(keypad);
+}
+
+#ifdef CONFIG_PM
+static int matrix_keypad_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        int i;
+
+        matrix_keypad_stop(keypad->input_dev);
+
+        if (device_may_wakeup(&pdev->dev))
+                for (i = 0; i < pdata->num_row_gpios; i++)
+                        enable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));
+
+        return 0;
+}
+
+static int matrix_keypad_resume(struct platform_device *pdev)
+{
+        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        int i;
+
+        if (device_may_wakeup(&pdev->dev))
+                for (i = 0; i < pdata->num_row_gpios; i++)
+                        disable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));
+
+        matrix_keypad_start(keypad->input_dev);
+
+        return 0;
+}
+#else
+#define matrix_keypad_suspend   NULL
+#define matrix_keypad_resume    NULL
+#endif
+
+static int __devinit init_matrix_gpio(struct platform_device *pdev,
+                                        struct matrix_keypad *keypad)
+{
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        int i, err = -EINVAL;
+
+        /* initialized strobe lines as outputs, activated */
+        for (i = 0; i < pdata->num_col_gpios; i++) {
+                err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col");
+                if (err) {
+                        dev_err(&pdev->dev,
+                                "failed to request GPIO%d for COL%d\n",
+                                pdata->col_gpios[i], i);
+                        goto err_free_cols;
+                }
+
+                gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);
+        }
+
+        for (i = 0; i < pdata->num_row_gpios; i++) {
+                err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");
+                if (err) {
+                        dev_err(&pdev->dev,
+                                "failed to request GPIO%d for ROW%d\n",
+                                pdata->row_gpios[i], i);
+                        goto err_free_rows;
+                }
+
+                gpio_direction_input(pdata->row_gpios[i]);
+        }
+
+        for (i = 0; i < pdata->num_row_gpios; i++) {
+                err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
+                                matrix_keypad_interrupt,
+                                IRQF_DISABLED |
+                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                "matrix-keypad", keypad);
+                if (err) {
+                        dev_err(&pdev->dev,
+                                "Unable to acquire interrupt for GPIO line %i\n",
+                                pdata->row_gpios[i]);
+                        goto err_free_irqs;
+                }
+        }
+
+        /* initialized as disabled - enabled by input->open */
+        disable_row_irqs(keypad);
+        return 0;
+
+err_free_irqs:
+        while (--i >= 0)
+                free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
+        i = pdata->num_row_gpios;
+err_free_rows:
+        while (--i >= 0)
+                gpio_free(pdata->row_gpios[i]);
+        i = pdata->num_col_gpios;
+err_free_cols:
+        while (--i >= 0)
+                gpio_free(pdata->col_gpios[i]);
+
+        return err;
+}
+
+static int __devinit matrix_keypad_probe(struct platform_device *pdev)
+{
+        const struct matrix_keypad_platform_data *pdata;
+        const struct matrix_keymap_data *keymap_data;
+        struct matrix_keypad *keypad;
+        struct input_dev *input_dev;
+        unsigned short *keycodes;
+        int i;
+        int err;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data defined\n");
+                return -EINVAL;
+        }
+
+        keymap_data = pdata->keymap_data;
+        if (!keymap_data) {
+                dev_err(&pdev->dev, "no keymap data defined\n");
+                return -EINVAL;
+        }
+
+        if (!keymap_data->max_keymap_size) {
+                dev_err(&pdev->dev, "invalid keymap data supplied\n");
+                return -EINVAL;
+        }
+
+        keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
+        keycodes = kzalloc(keymap_data->max_keymap_size *
+                                sizeof(keypad->keycodes),
+                           GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!keypad || !keycodes || !input_dev) {
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        keypad->input_dev = input_dev;
+        keypad->pdata = pdata;
+        keypad->keycodes = keycodes;
+        keypad->stopped = true;
+        INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
+        spin_lock_init(&keypad->lock);
+
+        input_dev->name         = pdev->name;
+        input_dev->id.bustype   = BUS_HOST;
+        input_dev->dev.parent   = &pdev->dev;
+        input_dev->evbit[0]     = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
+        input_dev->open         = matrix_keypad_start;
+        input_dev->close        = matrix_keypad_stop;
+
+        input_dev->keycode      = keycodes;
+        input_dev->keycodesize  = sizeof(*keycodes);
+        input_dev->keycodemax   = keymap_data->max_keymap_size;
+
+        for (i = 0; i < keymap_data->keymap_size; i++) {
+                unsigned int key = keymap_data->keymap[i];
+                unsigned int row = KEY_ROW(key);
+                unsigned int col = KEY_COL(key);
+                unsigned short code = KEY_VAL(key);
+
+                keycodes[(row << 4) + col] = code;
+                __set_bit(code, input_dev->keybit);
+        }
+        __clear_bit(KEY_RESERVED, input_dev->keybit);
+
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+        input_set_drvdata(input_dev, keypad);
+
+        err = init_matrix_gpio(pdev, keypad);
+        if (err)
+                goto err_free_mem;
+
+        err = input_register_device(keypad->input_dev);
+        if (err)
+                goto err_free_mem;
+
+        device_init_wakeup(&pdev->dev, pdata->wakeup);
+        platform_set_drvdata(pdev, keypad);
+
+        return 0;
+
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(keycodes);
+        kfree(keypad);
+        return err;
+}
+
+static int __devexit matrix_keypad_remove(struct platform_device *pdev)
+{
+        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
+        const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        int i;
+
+        device_init_wakeup(&pdev->dev, 0);
+
+        for (i = 0; i < pdata->num_row_gpios; i++) {
+                free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
+                gpio_free(pdata->row_gpios[i]);
+        }
+
+        for (i = 0; i < pdata->num_col_gpios; i++)
+                gpio_free(pdata->col_gpios[i]);
+
+        input_unregister_device(keypad->input_dev);
+        platform_set_drvdata(pdev, NULL);
+        kfree(keypad->keycodes);
+        kfree(keypad);
+
+        return 0;
+}
+
+static struct platform_driver matrix_keypad_driver = {
+        .probe          = matrix_keypad_probe,
+        .remove         = __devexit_p(matrix_keypad_remove),
+        .suspend        = matrix_keypad_suspend,
+        .resume         = matrix_keypad_resume,
+        .driver         = {
+                .name   = "matrix-keypad",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init matrix_keypad_init(void)
+{
+        return platform_driver_register(&matrix_keypad_driver);
+}
+
+static void __exit matrix_keypad_exit(void)
+{
+        platform_driver_unregister(&matrix_keypad_driver);
+}
+
+module_init(matrix_keypad_init);
+module_exit(matrix_keypad_exit);
+
+MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
+MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:matrix-keypad");
diff --git a/drivers/input/misc/cobalt_btns.c b/drivers/input/misc/cobalt_btns.c
index 2adf9cb265da..d114d3a9e1e9 100644
--- a/drivers/input/misc/cobalt_btns.c
+++ b/drivers/input/misc/cobalt_btns.c
@@ -1,7 +1,7 @@
 /*
  *  Cobalt button interface driver.
  *
- *  Copyright (C) 2007-2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2007-2008  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
@@ -148,7 +148,7 @@ static int __devexit cobalt_buttons_remove(struct platform_device *pdev)
         return 0;
 }
 
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
 MODULE_DESCRIPTION("Cobalt button interface driver");
 MODULE_LICENSE("GPL");
 /* work with hotplug and coldplug */
diff --git a/drivers/input/mouse/gpio_mouse.c b/drivers/input/mouse/gpio_mouse.c
index 5e5eb88d8d1e..7b6ce178f1b6 100644
--- a/drivers/input/mouse/gpio_mouse.c
+++ b/drivers/input/mouse/gpio_mouse.c
@@ -46,7 +46,7 @@ static void gpio_mouse_scan(struct input_polled_dev *dev)
         input_sync(input);
 }
 
-static int __init gpio_mouse_probe(struct platform_device *pdev)
+static int __devinit gpio_mouse_probe(struct platform_device *pdev)
 {
         struct gpio_mouse_platform_data *pdata = pdev->dev.platform_data;
         struct input_polled_dev *input_poll;
@@ -170,10 +170,8 @@ static int __devexit gpio_mouse_remove(struct platform_device *pdev)
         return 0;
 }
 
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:gpio_mouse");
-
 static struct platform_driver gpio_mouse_device_driver = {
+        .probe          = gpio_mouse_probe,
         .remove         = __devexit_p(gpio_mouse_remove),
         .driver         = {
                 .name   = "gpio_mouse",
@@ -183,8 +181,7 @@ static struct platform_driver gpio_mouse_device_driver = {
 
 static int __init gpio_mouse_init(void)
 {
-        return platform_driver_probe(&gpio_mouse_device_driver,
-                        gpio_mouse_probe);
+        return platform_driver_register(&gpio_mouse_device_driver);
 }
 module_init(gpio_mouse_init);
 
@@ -197,3 +194,5 @@ module_exit(gpio_mouse_exit);
 MODULE_AUTHOR("Hans-Christian Egtvedt <hcegtvedt@atmel.com>");
 MODULE_DESCRIPTION("GPIO mouse driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:gpio_mouse"); /* work with hotplug and coldplug */
+
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index fb8a3cd3ffd0..924e8ed7f2cf 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -392,6 +392,34 @@ static struct dmi_system_id __initdata i8042_dmi_reset_table[] = {
                         DMI_MATCH(DMI_BOARD_VENDOR, "LG Electronics Inc."),
                 },
         },
+        {
+                .ident = "Acer Aspire One 150",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "AOA150"),
+                },
+        },
+        {
+                .ident = "Advent 4211",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "DIXONSXP"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Advent 4211"),
+                },
+        },
+        {
+                .ident = "Medion Akoya Mini E1210",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "E1210"),
+                },
+        },
+        {
+                .ident = "Mivvy M310",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "VIOOO"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N10"),
+                },
+        },
         { }
 };
 
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index f919bf57293c..582245c497eb 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -934,10 +934,11 @@ static bool i8042_suspended;
 
 static int i8042_suspend(struct platform_device *dev, pm_message_t state)
 {
-        if (!i8042_suspended && state.event == PM_EVENT_SUSPEND) {
+        if (!i8042_suspended && state.event == PM_EVENT_SUSPEND)
                 i8042_controller_reset();
-                i8042_suspended = true;
-        }
+
+        i8042_suspended = state.event == PM_EVENT_SUSPEND ||
+                          state.event == PM_EVENT_FREEZE;
 
         return 0;
 }
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index fb17573f8f2d..d66f4944f2a0 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -935,10 +935,11 @@ static int serio_suspend(struct device *dev, pm_message_t state)
 {
         struct serio *serio = to_serio_port(dev);
 
-        if (!serio->suspended && state.event == PM_EVENT_SUSPEND) {
+        if (!serio->suspended && state.event == PM_EVENT_SUSPEND)
                 serio_cleanup(serio);
-                serio->suspended = true;
-        }
+
+        serio->suspended = state.event == PM_EVENT_SUSPEND ||
+                           state.event == PM_EVENT_FREEZE;
 
         return 0;
 }
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 38bf86384aeb..c896d6a21b7e 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -384,6 +384,8 @@ static int wacom_intuos_inout(struct wacom_wac *wacom, void *wcombo)
                         wacom_report_key(wcombo, BTN_STYLUS2, 0);
                         wacom_report_key(wcombo, BTN_TOUCH, 0);
                         wacom_report_abs(wcombo, ABS_WHEEL, 0);
+                        if (wacom->features->type >= INTUOS3S)
+                                wacom_report_abs(wcombo, ABS_Z, 0);
                 }
                 wacom_report_key(wcombo, wacom->tool[idx], 0);
                 wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */
@@ -836,6 +838,7 @@ static struct wacom_features wacom_features[] = {
         { "Wacom DTU710",        8,  34080, 27660,  511,  0, PL },
         { "Wacom DTF521",        8,   6282,  4762,  511,  0, PL },
         { "Wacom DTF720",        8,   6858,  5506,  511,  0, PL },
+        { "Wacom DTF720a",       8,   6858,  5506,  511,  0, PL },
         { "Wacom Cintiq Partner",8,  20480, 15360,  511,  0, PTU },
         { "Wacom Intuos2 4x5",   10, 12700, 10600, 1023, 31, INTUOS },
         { "Wacom Intuos2 6x8",   10, 20320, 16240, 1023, 31, INTUOS },
@@ -897,8 +900,9 @@ static struct usb_device_id wacom_ids[] = {
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x37) },
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x38) },
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x39) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC0) },
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC4) },
+        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC0) },
+        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC2) },
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x03) },
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x41) },
         { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x42) },
diff --git a/drivers/input/touchscreen/w90p910_ts.c b/drivers/input/touchscreen/w90p910_ts.c
index 6071f5882572..937dfe4e9b12 100644
--- a/drivers/input/touchscreen/w90p910_ts.c
+++ b/drivers/input/touchscreen/w90p910_ts.c
@@ -326,7 +326,7 @@ static struct platform_driver w90x900ts_driver = {
         .probe          = w90x900ts_probe,
         .remove         = __devexit_p(w90x900ts_remove),
         .driver         = {
-                .name   = "w90x900-ts",
+                .name   = "nuc900-ts",
                 .owner  = THIS_MODULE,
         },
 };
@@ -347,4 +347,4 @@ module_exit(w90x900ts_exit);
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("w90p910 touch screen driver!");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:w90p910-ts");
+MODULE_ALIAS("platform:nuc900-ts");
diff --git a/drivers/isdn/gigaset/ev-layer.c b/drivers/isdn/gigaset/ev-layer.c
index ec5169604a6a..2d91049571a4 100644
--- a/drivers/isdn/gigaset/ev-layer.c
+++ b/drivers/isdn/gigaset/ev-layer.c
@@ -294,32 +294,33 @@ struct reply_t gigaset_tab_cid[] =
         {RSP_OK,      604,604, -1,                605, 5, {ACT_CMD+AT_MSN}},
         {RSP_OK,      605,605, -1,                606, 5, {ACT_CMD+AT_ISO}},
         {RSP_NULL,    605,605, -1,                606, 5, {ACT_CMD+AT_ISO}},
-        {RSP_OK,      606,606, -1,                607, 5, {0},             "+VLS=17\r"}, /* set "Endgeraetemodus" */
+        {RSP_OK,      606,606, -1,                607, 5, {0}, "+VLS=17\r"},
         {RSP_OK,      607,607, -1,                608,-1},
-        //{RSP_ZSAU,    608,608,ZSAU_PROCEEDING,    608, 0, {ACT_ERROR}},//DELETE
         {RSP_ZSAU,    608,608,ZSAU_PROCEEDING,    609, 5, {ACT_CMD+AT_DIAL}},
         {RSP_OK,      609,609, -1,                650, 0, {ACT_DIALING}},
 
-        {RSP_ZVLS,    608,608, 17,                 -1,-1, {ACT_DEBUG}},
-        {RSP_ZCTP,    609,609, -1,                 -1,-1, {ACT_DEBUG}},
-        {RSP_ZCPN,    609,609, -1,                 -1,-1, {ACT_DEBUG}},
         {RSP_ERROR,   601,609, -1,                  0, 0, {ACT_ABORTDIAL}},
         {EV_TIMEOUT,  601,609, -1,                  0, 0, {ACT_ABORTDIAL}},
 
-        /* dialing */
-        {RSP_ZCTP,    650,650, -1,                 -1,-1, {ACT_DEBUG}},
-        {RSP_ZCPN,    650,650, -1,                 -1,-1, {ACT_DEBUG}},
-        {RSP_ZSAU,    650,650,ZSAU_CALL_DELIVERED, -1,-1, {ACT_DEBUG}}, /* some devices don't send this */
-
-        /* connection established  */
-        {RSP_ZSAU,    650,650,ZSAU_ACTIVE,        800,-1, {ACT_CONNECT}}, //FIXME -> DLE1
-        {RSP_ZSAU,    750,750,ZSAU_ACTIVE,        800,-1, {ACT_CONNECT}}, //FIXME -> DLE1
-
-        {EV_BC_OPEN,  800,800, -1,                800,-1, {ACT_NOTIFY_BC_UP}}, //FIXME new constate + timeout
+        /* optional dialing responses */
+        {EV_BC_OPEN,  650,650, -1,                651,-1},
+        {RSP_ZVLS,    608,651, 17,                 -1,-1, {ACT_DEBUG}},
+        {RSP_ZCTP,    609,651, -1,                 -1,-1, {ACT_DEBUG}},
+        {RSP_ZCPN,    609,651, -1,                 -1,-1, {ACT_DEBUG}},
+        {RSP_ZSAU,    650,651,ZSAU_CALL_DELIVERED, -1,-1, {ACT_DEBUG}},
+
+        /* connect */
+        {RSP_ZSAU,    650,650,ZSAU_ACTIVE,        800,-1, {ACT_CONNECT}},
+        {RSP_ZSAU,    651,651,ZSAU_ACTIVE,        800,-1, {ACT_CONNECT,
+                                                           ACT_NOTIFY_BC_UP}},
+        {RSP_ZSAU,    750,750,ZSAU_ACTIVE,        800,-1, {ACT_CONNECT}},
+        {RSP_ZSAU,    751,751,ZSAU_ACTIVE,        800,-1, {ACT_CONNECT,
+                                                           ACT_NOTIFY_BC_UP}},
+        {EV_BC_OPEN,  800,800, -1,                800,-1, {ACT_NOTIFY_BC_UP}},
 
         /* remote hangup */
-        {RSP_ZSAU,    650,650,ZSAU_DISCONNECT_IND,  0, 0, {ACT_REMOTEREJECT}},
-        {RSP_ZSAU,    750,750,ZSAU_DISCONNECT_IND,  0, 0, {ACT_REMOTEHUP}},
+        {RSP_ZSAU,    650,651,ZSAU_DISCONNECT_IND,  0, 0, {ACT_REMOTEREJECT}},
+        {RSP_ZSAU,    750,751,ZSAU_DISCONNECT_IND,  0, 0, {ACT_REMOTEHUP}},
         {RSP_ZSAU,    800,800,ZSAU_DISCONNECT_IND,  0, 0, {ACT_REMOTEHUP}},
 
         /* hangup */
@@ -358,7 +359,8 @@ struct reply_t gigaset_tab_cid[] =
         {RSP_ZSAU,    700,729,ZSAU_ACTIVE,          0, 0, {ACT_ABORTACCEPT}},
         {RSP_ZSAU,    700,729,ZSAU_DISCONNECT_IND,  0, 0, {ACT_ABORTACCEPT}},
 
-        {EV_TIMEOUT,  750,750, -1,                  0, 0, {ACT_CONNTIMEOUT}},
+        {EV_BC_OPEN,  750,750, -1,                751,-1},
+        {EV_TIMEOUT,  750,751, -1,                  0, 0, {ACT_CONNTIMEOUT}},
 
         /* B channel closed (general case) */
         {EV_BC_CLOSED, -1, -1, -1,                 -1,-1, {ACT_NOTIFY_BC_DOWN}}, //FIXME
@@ -876,12 +878,6 @@ static void bchannel_down(struct bc_state *bcs)
 
 static void bchannel_up(struct bc_state *bcs)
 {
-        if (!(bcs->chstate & CHS_D_UP)) {
-                dev_notice(bcs->cs->dev, "%s: D channel not up\n", __func__);
-                bcs->chstate |= CHS_D_UP;
-                gigaset_i4l_channel_cmd(bcs, ISDN_STAT_DCONN);
-        }
-
         if (bcs->chstate & CHS_B_UP) {
                 dev_notice(bcs->cs->dev, "%s: B channel already up\n",
                            __func__);
diff --git a/drivers/isdn/gigaset/isocdata.c b/drivers/isdn/gigaset/isocdata.c
index db3a1e4cd489..bed38fcc432b 100644
--- a/drivers/isdn/gigaset/isocdata.c
+++ b/drivers/isdn/gigaset/isocdata.c
@@ -174,12 +174,6 @@ int gigaset_isowbuf_getbytes(struct isowbuf_t *iwb, int size)
                 pr_err("invalid size %d\n", size);
                 return -EINVAL;
         }
-        src = iwb->read;
-        if (unlikely(limit >= BAS_OUTBUFSIZE + BAS_OUTBUFPAD ||
-                     (read < src && limit >= src))) {
-                pr_err("isoc write buffer frame reservation violated\n");
-                return -EFAULT;
-        }
 #endif
 
         if (read < write) {
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 9b60b6b684d9..7c8e7122aaa9 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -75,6 +75,7 @@ config LEDS_ALIX2
         depends on LEDS_CLASS && X86 && EXPERIMENTAL
         help
           This option enables support for the PCEngines ALIX.2 and ALIX.3 LEDs.
+          You have to set leds-alix2.force=1 for boards with Award BIOS.
 
 config LEDS_H1940
         tristate "LED Support for iPAQ H1940 device"
@@ -145,15 +146,16 @@ config LEDS_GPIO_OF
           of_platform devices.  For instance, LEDs which are listed in a "dts"
           file.
 
-config LEDS_LP5521
-        tristate "LED Support for the LP5521 LEDs"
+config LEDS_LP3944
+        tristate "LED Support for N.S. LP3944 (Fun Light) I2C chip"
         depends on LEDS_CLASS && I2C
         help
-          If you say 'Y' here you get support for the National Semiconductor
-          LP5521 LED driver used in n8x0 boards.
+    This option enables support for LEDs connected to the National
+    Semiconductor LP3944 Lighting Management Unit (LMU) also known as
+    Fun Light Chip.
 
-          This driver can be built as a module by choosing 'M'. The module
-          will be called leds-lp5521.
+          To compile this driver as a module, choose M here: the
+          module will be called leds-lp3944.
 
 config LEDS_CLEVO_MAIL
         tristate "Mail LED on Clevo notebook"
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 2d41c4dcf92f..e8cdcf77a4c3 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_LEDS_COBALT_RAQ)		+= leds-cobalt-raq.o
 obj-$(CONFIG_LEDS_SUNFIRE)              += leds-sunfire.o
 obj-$(CONFIG_LEDS_PCA9532)              += leds-pca9532.o
 obj-$(CONFIG_LEDS_GPIO)                 += leds-gpio.o
+obj-$(CONFIG_LEDS_LP3944)               += leds-lp3944.o
 obj-$(CONFIG_LEDS_CLEVO_MAIL)           += leds-clevo-mail.o
 obj-$(CONFIG_LEDS_HP6XX)                += leds-hp6xx.o
 obj-$(CONFIG_LEDS_FSG)                  += leds-fsg.o
diff --git a/drivers/leds/leds-alix2.c b/drivers/leds/leds-alix2.c
index ddbd7730dfc8..731d4eef3425 100644
--- a/drivers/leds/leds-alix2.c
+++ b/drivers/leds/leds-alix2.c
@@ -14,7 +14,7 @@
 
 static int force = 0;
 module_param(force, bool, 0444);
-MODULE_PARM_DESC(force, "Assume system has ALIX.2 style LEDs");
+MODULE_PARM_DESC(force, "Assume system has ALIX.2/ALIX.3 style LEDs");
 
 struct alix_led {
         struct led_classdev cdev;
@@ -155,6 +155,11 @@ static int __init alix_led_init(void)
                 goto out;
         }
 
+        /* enable output on GPIO for LED 1,2,3 */
+        outl(1 << 6, 0x6104);
+        outl(1 << 9, 0x6184);
+        outl(1 << 11, 0x6184);
+
         pdev = platform_device_register_simple(KBUILD_MODNAME, -1, NULL, 0);
         if (!IS_ERR(pdev)) {
                 ret = platform_driver_probe(&alix_led_driver, alix_led_probe);
diff --git a/drivers/leds/leds-bd2802.c b/drivers/leds/leds-bd2802.c
index 4149ecb3a9b2..779d7f262c04 100644
--- a/drivers/leds/leds-bd2802.c
+++ b/drivers/leds/leds-bd2802.c
@@ -97,6 +97,10 @@ struct bd2802_led {
         enum led_ids                    led_id;
         enum led_colors                 color;
         enum led_bits                   state;
+
+        /* General attributes of RGB LEDs */
+        int                             wave_pattern;
+        int                             rgb_current;
 };
 
 
@@ -254,7 +258,7 @@ static void bd2802_set_on(struct bd2802_led *led, enum led_ids id,
                 bd2802_reset_cancel(led);
 
         reg = bd2802_get_reg_addr(id, color, BD2802_REG_CURRENT1SETUP);
-        bd2802_write_byte(led->client, reg, BD2802_CURRENT_032);
+        bd2802_write_byte(led->client, reg, led->rgb_current);
         reg = bd2802_get_reg_addr(id, color, BD2802_REG_CURRENT2SETUP);
         bd2802_write_byte(led->client, reg, BD2802_CURRENT_000);
         reg = bd2802_get_reg_addr(id, color, BD2802_REG_WAVEPATTERN);
@@ -275,9 +279,9 @@ static void bd2802_set_blink(struct bd2802_led *led, enum led_ids id,
         reg = bd2802_get_reg_addr(id, color, BD2802_REG_CURRENT1SETUP);
         bd2802_write_byte(led->client, reg, BD2802_CURRENT_000);
         reg = bd2802_get_reg_addr(id, color, BD2802_REG_CURRENT2SETUP);
-        bd2802_write_byte(led->client, reg, BD2802_CURRENT_032);
+        bd2802_write_byte(led->client, reg, led->rgb_current);
         reg = bd2802_get_reg_addr(id, color, BD2802_REG_WAVEPATTERN);
-        bd2802_write_byte(led->client, reg, BD2802_PATTERN_HALF);
+        bd2802_write_byte(led->client, reg, led->wave_pattern);
 
         bd2802_enable(led, id);
         bd2802_update_state(led, id, color, BD2802_BLINK);
@@ -406,7 +410,7 @@ static void bd2802_enable_adv_conf(struct bd2802_led *led)
                 ret = device_create_file(&led->client->dev,
                                                 bd2802_addr_attributes[i]);
                 if (ret) {
-                        dev_err(&led->client->dev, "failed to sysfs file %s\n",
+                        dev_err(&led->client->dev, "failed: sysfs file %s\n",
                                         bd2802_addr_attributes[i]->attr.name);
                         goto failed_remove_files;
                 }
@@ -483,6 +487,52 @@ static struct device_attribute bd2802_adv_conf_attr = {
         .store = bd2802_store_adv_conf,
 };
 
+#define BD2802_CONTROL_ATTR(attr_name, name_str)                        \
+static ssize_t bd2802_show_##attr_name(struct device *dev,              \
+        struct device_attribute *attr, char *buf)                       \
+{                                                                       \
+        struct bd2802_led *led = i2c_get_clientdata(to_i2c_client(dev));\
+        ssize_t ret;                                                    \
+        down_read(&led->rwsem);                                         \
+        ret = sprintf(buf, "0x%02x\n", led->attr_name);                 \
+        up_read(&led->rwsem);                                           \
+        return ret;                                                     \
+}                                                                       \
+static ssize_t bd2802_store_##attr_name(struct device *dev,             \
+        struct device_attribute *attr, const char *buf, size_t count)   \
+{                                                                       \
+        struct bd2802_led *led = i2c_get_clientdata(to_i2c_client(dev));\
+        unsigned long val;                                              \
+        int ret;                                                        \
+        if (!count)                                                     \
+                return -EINVAL;                                         \
+        ret = strict_strtoul(buf, 16, &val);                            \
+        if (ret)                                                        \
+                return ret;                                             \
+        down_write(&led->rwsem);                                        \
+        led->attr_name = val;                                           \
+        up_write(&led->rwsem);                                          \
+        return count;                                                   \
+}                                                                       \
+static struct device_attribute bd2802_##attr_name##_attr = {            \
+        .attr = {                                                       \
+                .name = name_str,                                       \
+                .mode = 0644,                                           \
+                .owner = THIS_MODULE                                    \
+        },                                                              \
+        .show = bd2802_show_##attr_name,                                \
+        .store = bd2802_store_##attr_name,                              \
+};
+
+BD2802_CONTROL_ATTR(wave_pattern, "wave_pattern");
+BD2802_CONTROL_ATTR(rgb_current, "rgb_current");
+
+static struct device_attribute *bd2802_attributes[] = {
+        &bd2802_adv_conf_attr,
+        &bd2802_wave_pattern_attr,
+        &bd2802_rgb_current_attr,
+};
+
 static void bd2802_led_work(struct work_struct *work)
 {
         struct bd2802_led *led = container_of(work, struct bd2802_led, work);
@@ -538,7 +588,6 @@ static int bd2802_register_led_classdev(struct bd2802_led *led)
         led->cdev_led1r.brightness = LED_OFF;
         led->cdev_led1r.brightness_set = bd2802_set_led1r_brightness;
         led->cdev_led1r.blink_set = bd2802_set_led1r_blink;
-        led->cdev_led1r.flags |= LED_CORE_SUSPENDRESUME;
 
         ret = led_classdev_register(&led->client->dev, &led->cdev_led1r);
         if (ret < 0) {
@@ -551,7 +600,6 @@ static int bd2802_register_led_classdev(struct bd2802_led *led)
         led->cdev_led1g.brightness = LED_OFF;
         led->cdev_led1g.brightness_set = bd2802_set_led1g_brightness;
         led->cdev_led1g.blink_set = bd2802_set_led1g_blink;
-        led->cdev_led1g.flags |= LED_CORE_SUSPENDRESUME;
 
         ret = led_classdev_register(&led->client->dev, &led->cdev_led1g);
         if (ret < 0) {
@@ -564,7 +612,6 @@ static int bd2802_register_led_classdev(struct bd2802_led *led)
         led->cdev_led1b.brightness = LED_OFF;
         led->cdev_led1b.brightness_set = bd2802_set_led1b_brightness;
         led->cdev_led1b.blink_set = bd2802_set_led1b_blink;
-        led->cdev_led1b.flags |= LED_CORE_SUSPENDRESUME;
 
         ret = led_classdev_register(&led->client->dev, &led->cdev_led1b);
         if (ret < 0) {
@@ -577,7 +624,6 @@ static int bd2802_register_led_classdev(struct bd2802_led *led)
         led->cdev_led2r.brightness = LED_OFF;
         led->cdev_led2r.brightness_set = bd2802_set_led2r_brightness;
         led->cdev_led2r.blink_set = bd2802_set_led2r_blink;
-        led->cdev_led2r.flags |= LED_CORE_SUSPENDRESUME;
 
         ret = led_classdev_register(&led->client->dev, &led->cdev_led2r);
         if (ret < 0) {
@@ -590,7 +636,6 @@ static int bd2802_register_led_classdev(struct bd2802_led *led)
         led->cdev_led2g.brightness = LED_OFF;
         led->cdev_led2g.brightness_set = bd2802_set_led2g_brightness;
         led->cdev_led2g.blink_set = bd2802_set_led2g_blink;
-        led->cdev_led2g.flags |= LED_CORE_SUSPENDRESUME;
 
         ret = led_classdev_register(&led->client->dev, &led->cdev_led2g);
         if (ret < 0) {
@@ -640,7 +685,7 @@ static int __devinit bd2802_probe(struct i2c_client *client,
 {
         struct bd2802_led *led;
         struct bd2802_led_platform_data *pdata;
-        int ret;
+        int ret, i;
 
         led = kzalloc(sizeof(struct bd2802_led), GFP_KERNEL);
         if (!led) {
@@ -670,13 +715,20 @@ static int __devinit bd2802_probe(struct i2c_client *client,
         /* To save the power, reset BD2802 after detecting */
         gpio_set_value(led->pdata->reset_gpio, 0);
 
+        /* Default attributes */
+        led->wave_pattern = BD2802_PATTERN_HALF;
+        led->rgb_current = BD2802_CURRENT_032;
+
         init_rwsem(&led->rwsem);
 
-        ret = device_create_file(&client->dev, &bd2802_adv_conf_attr);
-        if (ret) {
-                dev_err(&client->dev, "failed to create sysfs file %s\n",
-                                        bd2802_adv_conf_attr.attr.name);
-                goto failed_free;
+        for (i = 0; i < ARRAY_SIZE(bd2802_attributes); i++) {
+                ret = device_create_file(&led->client->dev,
+                                                bd2802_attributes[i]);
+                if (ret) {
+                        dev_err(&led->client->dev, "failed: sysfs file %s\n",
+                                        bd2802_attributes[i]->attr.name);
+                        goto failed_unregister_dev_file;
+                }
         }
 
         ret = bd2802_register_led_classdev(led);
@@ -686,7 +738,8 @@ static int __devinit bd2802_probe(struct i2c_client *client,
         return 0;
 
 failed_unregister_dev_file:
-        device_remove_file(&client->dev, &bd2802_adv_conf_attr);
+        for (i--; i >= 0; i--)
+                device_remove_file(&led->client->dev, bd2802_attributes[i]);
 failed_free:
         i2c_set_clientdata(client, NULL);
         kfree(led);
@@ -697,12 +750,14 @@ failed_free:
 static int __exit bd2802_remove(struct i2c_client *client)
 {
         struct bd2802_led *led = i2c_get_clientdata(client);
+        int i;
 
-        bd2802_unregister_led_classdev(led);
         gpio_set_value(led->pdata->reset_gpio, 0);
+        bd2802_unregister_led_classdev(led);
         if (led->adf_on)
                 bd2802_disable_adv_conf(led);
-        device_remove_file(&client->dev, &bd2802_adv_conf_attr);
+        for (i = 0; i < ARRAY_SIZE(bd2802_attributes); i++)
+                device_remove_file(&led->client->dev, bd2802_attributes[i]);
         i2c_set_clientdata(client, NULL);
         kfree(led);
 
@@ -723,8 +778,7 @@ static int bd2802_resume(struct i2c_client *client)
         struct bd2802_led *led = i2c_get_clientdata(client);
 
         if (!bd2802_is_all_off(led) || led->adf_on) {
-                gpio_set_value(led->pdata->reset_gpio, 1);
-                udelay(100);
+                bd2802_reset_cancel(led);
                 bd2802_restore_state(led);
         }
 
@@ -762,4 +816,4 @@ module_exit(bd2802_exit);
 
 MODULE_AUTHOR("Kim Kyuwon <q1.kim@samsung.com>");
 MODULE_DESCRIPTION("BD2802 LED driver");
-MODULE_LICENSE("GPL");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-cobalt-raq.c b/drivers/leds/leds-cobalt-raq.c
index ff0e8c3fbf9b..5f1ce810815f 100644
--- a/drivers/leds/leds-cobalt-raq.c
+++ b/drivers/leds/leds-cobalt-raq.c
@@ -1,7 +1,7 @@
 /*
  *  LEDs driver for the Cobalt Raq series.
  *
- *  Copyright (C) 2007  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2007  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index d2109054de85..6b06638eb5b4 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -76,7 +76,7 @@ static int __devinit create_gpio_led(const struct gpio_led *template,
         struct gpio_led_data *led_dat, struct device *parent,
         int (*blink_set)(unsigned, unsigned long *, unsigned long *))
 {
-        int ret;
+        int ret, state;
 
         /* skip leds that aren't available */
         if (!gpio_is_valid(template->gpio)) {
@@ -99,11 +99,15 @@ static int __devinit create_gpio_led(const struct gpio_led *template,
                 led_dat->cdev.blink_set = gpio_blink_set;
         }
         led_dat->cdev.brightness_set = gpio_led_set;
-        led_dat->cdev.brightness = LED_OFF;
+        if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP)
+                state = !!gpio_get_value(led_dat->gpio) ^ led_dat->active_low;
+        else
+                state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
+        led_dat->cdev.brightness = state ? LED_FULL : LED_OFF;
         if (!template->retain_state_suspended)
                 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
 
-        ret = gpio_direction_output(led_dat->gpio, led_dat->active_low);
+        ret = gpio_direction_output(led_dat->gpio, led_dat->active_low ^ state);
         if (ret < 0)
                 goto err;
 
@@ -129,7 +133,7 @@ static void delete_gpio_led(struct gpio_led_data *led)
 }
 
 #ifdef CONFIG_LEDS_GPIO_PLATFORM
-static int gpio_led_probe(struct platform_device *pdev)
+static int __devinit gpio_led_probe(struct platform_device *pdev)
 {
         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
         struct gpio_led_data *leds_data;
@@ -223,12 +227,22 @@ static int __devinit of_gpio_leds_probe(struct of_device *ofdev,
         memset(&led, 0, sizeof(led));
         for_each_child_of_node(np, child) {
                 enum of_gpio_flags flags;
+                const char *state;
 
                 led.gpio = of_get_gpio_flags(child, 0, &flags);
                 led.active_low = flags & OF_GPIO_ACTIVE_LOW;
                 led.name = of_get_property(child, "label", NULL) ? : child->name;
                 led.default_trigger =
                         of_get_property(child, "linux,default-trigger", NULL);
+                state = of_get_property(child, "default-state", NULL);
+                if (state) {
+                        if (!strcmp(state, "keep"))
+                                led.default_state = LEDS_GPIO_DEFSTATE_KEEP;
+                        else if(!strcmp(state, "on"))
+                                led.default_state = LEDS_GPIO_DEFSTATE_ON;
+                        else
+                                led.default_state = LEDS_GPIO_DEFSTATE_OFF;
+                }
 
                 ret = create_gpio_led(&led, &pdata->led_data[pdata->num_leds++],
                                       &ofdev->dev, NULL);
diff --git a/drivers/leds/leds-lp3944.c b/drivers/leds/leds-lp3944.c
new file mode 100644
index 000000000000..5946208ba26e
--- /dev/null
+++ b/drivers/leds/leds-lp3944.c
@@ -0,0 +1,466 @@
+/*
+ * leds-lp3944.c - driver for National Semiconductor LP3944 Funlight Chip
+ *
+ * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+/*
+ * I2C driver for National Semiconductor LP3944 Funlight Chip
+ * http://www.national.com/pf/LP/LP3944.html
+ *
+ * This helper chip can drive up to 8 leds, with two programmable DIM modes;
+ * it could even be used as a gpio expander but this driver assumes it is used
+ * as a led controller.
+ *
+ * The DIM modes are used to set _blink_ patterns for leds, the pattern is
+ * specified supplying two parameters:
+ *   - period: from 0s to 1.6s
+ *   - duty cycle: percentage of the period the led is on, from 0 to 100
+ *
+ * LP3944 can be found on Motorola A910 smartphone, where it drives the rgb
+ * leds, the camera flash light and the displays backlights.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/leds.h>
+#include <linux/mutex.h>
+#include <linux/workqueue.h>
+#include <linux/leds-lp3944.h>
+
+/* Read Only Registers */
+#define LP3944_REG_INPUT1     0x00 /* LEDs 0-7 InputRegister (Read Only) */
+#define LP3944_REG_REGISTER1  0x01 /* None (Read Only) */
+
+#define LP3944_REG_PSC0       0x02 /* Frequency Prescaler 0 (R/W) */
+#define LP3944_REG_PWM0       0x03 /* PWM Register 0 (R/W) */
+#define LP3944_REG_PSC1       0x04 /* Frequency Prescaler 1 (R/W) */
+#define LP3944_REG_PWM1       0x05 /* PWM Register 1 (R/W) */
+#define LP3944_REG_LS0        0x06 /* LEDs 0-3 Selector (R/W) */
+#define LP3944_REG_LS1        0x07 /* LEDs 4-7 Selector (R/W) */
+
+/* These registers are not used to control leds in LP3944, they can store
+ * arbitrary values which the chip will ignore.
+ */
+#define LP3944_REG_REGISTER8  0x08
+#define LP3944_REG_REGISTER9  0x09
+
+#define LP3944_DIM0 0
+#define LP3944_DIM1 1
+
+/* period in ms */
+#define LP3944_PERIOD_MIN 0
+#define LP3944_PERIOD_MAX 1600
+
+/* duty cycle is a percentage */
+#define LP3944_DUTY_CYCLE_MIN 0
+#define LP3944_DUTY_CYCLE_MAX 100
+
+#define ldev_to_led(c)       container_of(c, struct lp3944_led_data, ldev)
+
+/* Saved data */
+struct lp3944_led_data {
+        u8 id;
+        enum lp3944_type type;
+        enum lp3944_status status;
+        struct led_classdev ldev;
+        struct i2c_client *client;
+        struct work_struct work;
+};
+
+struct lp3944_data {
+        struct mutex lock;
+        struct i2c_client *client;
+        struct lp3944_led_data leds[LP3944_LEDS_MAX];
+};
+
+static int lp3944_reg_read(struct i2c_client *client, u8 reg, u8 *value)
+{
+        int tmp;
+
+        tmp = i2c_smbus_read_byte_data(client, reg);
+        if (tmp < 0)
+                return -EINVAL;
+
+        *value = tmp;
+
+        return 0;
+}
+
+static int lp3944_reg_write(struct i2c_client *client, u8 reg, u8 value)
+{
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/**
+ * Set the period for DIM status
+ *
+ * @client: the i2c client
+ * @dim: either LP3944_DIM0 or LP3944_DIM1
+ * @period: period of a blink, that is a on/off cycle, expressed in ms.
+ */
+static int lp3944_dim_set_period(struct i2c_client *client, u8 dim, u16 period)
+{
+        u8 psc_reg;
+        u8 psc_value;
+        int err;
+
+        if (dim == LP3944_DIM0)
+                psc_reg = LP3944_REG_PSC0;
+        else if (dim == LP3944_DIM1)
+                psc_reg = LP3944_REG_PSC1;
+        else
+                return -EINVAL;
+
+        /* Convert period to Prescaler value */
+        if (period > LP3944_PERIOD_MAX)
+                return -EINVAL;
+
+        psc_value = (period * 255) / LP3944_PERIOD_MAX;
+
+        err = lp3944_reg_write(client, psc_reg, psc_value);
+
+        return err;
+}
+
+/**
+ * Set the duty cycle for DIM status
+ *
+ * @client: the i2c client
+ * @dim: either LP3944_DIM0 or LP3944_DIM1
+ * @duty_cycle: percentage of a period during which a led is ON
+ */
+static int lp3944_dim_set_dutycycle(struct i2c_client *client, u8 dim,
+                                    u8 duty_cycle)
+{
+        u8 pwm_reg;
+        u8 pwm_value;
+        int err;
+
+        if (dim == LP3944_DIM0)
+                pwm_reg = LP3944_REG_PWM0;
+        else if (dim == LP3944_DIM1)
+                pwm_reg = LP3944_REG_PWM1;
+        else
+                return -EINVAL;
+
+        /* Convert duty cycle to PWM value */
+        if (duty_cycle > LP3944_DUTY_CYCLE_MAX)
+                return -EINVAL;
+
+        pwm_value = (duty_cycle * 255) / LP3944_DUTY_CYCLE_MAX;
+
+        err = lp3944_reg_write(client, pwm_reg, pwm_value);
+
+        return err;
+}
+
+/**
+ * Set the led status
+ *
+ * @led: a lp3944_led_data structure
+ * @status: one of LP3944_LED_STATUS_OFF
+ *                 LP3944_LED_STATUS_ON
+ *                 LP3944_LED_STATUS_DIM0
+ *                 LP3944_LED_STATUS_DIM1
+ */
+static int lp3944_led_set(struct lp3944_led_data *led, u8 status)
+{
+        struct lp3944_data *data = i2c_get_clientdata(led->client);
+        u8 id = led->id;
+        u8 reg;
+        u8 val = 0;
+        int err;
+
+        dev_dbg(&led->client->dev, "%s: %s, status before normalization:%d\n",
+                __func__, led->ldev.name, status);
+
+        switch (id) {
+        case LP3944_LED0:
+        case LP3944_LED1:
+        case LP3944_LED2:
+        case LP3944_LED3:
+                reg = LP3944_REG_LS0;
+                break;
+        case LP3944_LED4:
+        case LP3944_LED5:
+        case LP3944_LED6:
+        case LP3944_LED7:
+                id -= LP3944_LED4;
+                reg = LP3944_REG_LS1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (status > LP3944_LED_STATUS_DIM1)
+                return -EINVAL;
+
+        /* invert only 0 and 1, leave unchanged the other values,
+         * remember we are abusing status to set blink patterns
+         */
+        if (led->type == LP3944_LED_TYPE_LED_INVERTED && status < 2)
+                status = 1 - status;
+
+        mutex_lock(&data->lock);
+        lp3944_reg_read(led->client, reg, &val);
+
+        val &= ~(LP3944_LED_STATUS_MASK << (id << 1));
+        val |= (status << (id << 1));
+
+        dev_dbg(&led->client->dev, "%s: %s, reg:%d id:%d status:%d val:%#x\n",
+                __func__, led->ldev.name, reg, id, status, val);
+
+        /* set led status */
+        err = lp3944_reg_write(led->client, reg, val);
+        mutex_unlock(&data->lock);
+
+        return err;
+}
+
+static int lp3944_led_set_blink(struct led_classdev *led_cdev,
+                                unsigned long *delay_on,
+                                unsigned long *delay_off)
+{
+        struct lp3944_led_data *led = ldev_to_led(led_cdev);
+        u16 period;
+        u8 duty_cycle;
+        int err;
+
+        /* units are in ms */
+        if (*delay_on + *delay_off > LP3944_PERIOD_MAX)
+                return -EINVAL;
+
+        if (*delay_on == 0 && *delay_off == 0) {
+                /* Special case: the leds subsystem requires a default user
+                 * friendly blink pattern for the LED.  Let's blink the led
+                 * slowly (1Hz).
+                 */
+                *delay_on = 500;
+                *delay_off = 500;
+        }
+
+        period = (*delay_on) + (*delay_off);
+
+        /* duty_cycle is the percentage of period during which the led is ON */
+        duty_cycle = 100 * (*delay_on) / period;
+
+        /* invert duty cycle for inverted leds, this has the same effect of
+         * swapping delay_on and delay_off
+         */
+        if (led->type == LP3944_LED_TYPE_LED_INVERTED)
+                duty_cycle = 100 - duty_cycle;
+
+        /* NOTE: using always the first DIM mode, this means that all leds
+         * will have the same blinking pattern.
+         *
+         * We could find a way later to have two leds blinking in hardware
+         * with different patterns at the same time, falling back to software
+         * control for the other ones.
+         */
+        err = lp3944_dim_set_period(led->client, LP3944_DIM0, period);
+        if (err)
+                return err;
+
+        err = lp3944_dim_set_dutycycle(led->client, LP3944_DIM0, duty_cycle);
+        if (err)
+                return err;
+
+        dev_dbg(&led->client->dev, "%s: OK hardware accelerated blink!\n",
+                __func__);
+
+        led->status = LP3944_LED_STATUS_DIM0;
+        schedule_work(&led->work);
+
+        return 0;
+}
+
+static void lp3944_led_set_brightness(struct led_classdev *led_cdev,
+                                      enum led_brightness brightness)
+{
+        struct lp3944_led_data *led = ldev_to_led(led_cdev);
+
+        dev_dbg(&led->client->dev, "%s: %s, %d\n",
+                __func__, led_cdev->name, brightness);
+
+        led->status = brightness;
+        schedule_work(&led->work);
+}
+
+static void lp3944_led_work(struct work_struct *work)
+{
+        struct lp3944_led_data *led;
+
+        led = container_of(work, struct lp3944_led_data, work);
+        lp3944_led_set(led, led->status);
+}
+
+static int lp3944_configure(struct i2c_client *client,
+                            struct lp3944_data *data,
+                            struct lp3944_platform_data *pdata)
+{
+        int i, err = 0;
+
+        for (i = 0; i < pdata->leds_size; i++) {
+                struct lp3944_led *pled = &pdata->leds[i];
+                struct lp3944_led_data *led = &data->leds[i];
+                led->client = client;
+                led->id = i;
+
+                switch (pled->type) {
+
+                case LP3944_LED_TYPE_LED:
+                case LP3944_LED_TYPE_LED_INVERTED:
+                        led->type = pled->type;
+                        led->status = pled->status;
+                        led->ldev.name = pled->name;
+                        led->ldev.max_brightness = 1;
+                        led->ldev.brightness_set = lp3944_led_set_brightness;
+                        led->ldev.blink_set = lp3944_led_set_blink;
+                        led->ldev.flags = LED_CORE_SUSPENDRESUME;
+
+                        INIT_WORK(&led->work, lp3944_led_work);
+                        err = led_classdev_register(&client->dev, &led->ldev);
+                        if (err < 0) {
+                                dev_err(&client->dev,
+                                        "couldn't register LED %s\n",
+                                        led->ldev.name);
+                                goto exit;
+                        }
+
+                        /* to expose the default value to userspace */
+                        led->ldev.brightness = led->status;
+
+                        /* Set the default led status */
+                        err = lp3944_led_set(led, led->status);
+                        if (err < 0) {
+                                dev_err(&client->dev,
+                                        "%s couldn't set STATUS %d\n",
+                                        led->ldev.name, led->status);
+                                goto exit;
+                        }
+                        break;
+
+                case LP3944_LED_TYPE_NONE:
+                default:
+                        break;
+
+                }
+        }
+        return 0;
+
+exit:
+        if (i > 0)
+                for (i = i - 1; i >= 0; i--)
+                        switch (pdata->leds[i].type) {
+
+                        case LP3944_LED_TYPE_LED:
+                        case LP3944_LED_TYPE_LED_INVERTED:
+                                led_classdev_unregister(&data->leds[i].ldev);
+                                cancel_work_sync(&data->leds[i].work);
+                                break;
+
+                        case LP3944_LED_TYPE_NONE:
+                        default:
+                                break;
+                        }
+
+        return err;
+}
+
+static int __devinit lp3944_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct lp3944_platform_data *lp3944_pdata = client->dev.platform_data;
+        struct lp3944_data *data;
+
+        if (lp3944_pdata == NULL) {
+                dev_err(&client->dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        /* Let's see whether this adapter can support what we need. */
+        if (!i2c_check_functionality(client->adapter,
+                                I2C_FUNC_SMBUS_BYTE_DATA)) {
+                dev_err(&client->dev, "insufficient functionality!\n");
+                return -ENODEV;
+        }
+
+        data = kzalloc(sizeof(struct lp3944_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        data->client = client;
+        i2c_set_clientdata(client, data);
+
+        mutex_init(&data->lock);
+
+        dev_info(&client->dev, "lp3944 enabled\n");
+
+        lp3944_configure(client, data, lp3944_pdata);
+        return 0;
+}
+
+static int __devexit lp3944_remove(struct i2c_client *client)
+{
+        struct lp3944_platform_data *pdata = client->dev.platform_data;
+        struct lp3944_data *data = i2c_get_clientdata(client);
+        int i;
+
+        for (i = 0; i < pdata->leds_size; i++)
+                switch (data->leds[i].type) {
+                case LP3944_LED_TYPE_LED:
+                case LP3944_LED_TYPE_LED_INVERTED:
+                        led_classdev_unregister(&data->leds[i].ldev);
+                        cancel_work_sync(&data->leds[i].work);
+                        break;
+
+                case LP3944_LED_TYPE_NONE:
+                default:
+                        break;
+                }
+
+        kfree(data);
+        i2c_set_clientdata(client, NULL);
+
+        return 0;
+}
+
+/* lp3944 i2c driver struct */
+static const struct i2c_device_id lp3944_id[] = {
+        {"lp3944", 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(i2c, lp3944_id);
+
+static struct i2c_driver lp3944_driver = {
+        .driver   = {
+                   .name = "lp3944",
+        },
+        .probe    = lp3944_probe,
+        .remove   = __devexit_p(lp3944_remove),
+        .id_table = lp3944_id,
+};
+
+static int __init lp3944_module_init(void)
+{
+        return i2c_add_driver(&lp3944_driver);
+}
+
+static void __exit lp3944_module_exit(void)
+{
+        i2c_del_driver(&lp3944_driver);
+}
+
+module_init(lp3944_module_init);
+module_exit(lp3944_module_exit);
+
+MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
+MODULE_DESCRIPTION("LP3944 Fun Light Chip");
+MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c
index 3937244fdcab..dba8921240f2 100644
--- a/drivers/leds/leds-pca9532.c
+++ b/drivers/leds/leds-pca9532.c
@@ -35,7 +35,7 @@ struct pca9532_data {
         struct pca9532_led leds[16];
         struct mutex update_lock;
         struct input_dev    *idev;
-       struct work_struct work;
+        struct work_struct work;
         u8 pwm[2];
         u8 psc[2];
 };
@@ -87,14 +87,14 @@ static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,
         if (b > 0xFF)
                 return -EINVAL;
         data->pwm[pwm] = b;
-       data->psc[pwm] = blink;
-       return 0;
+        data->psc[pwm] = blink;
+        return 0;
 }
 
 static int pca9532_setpwm(struct i2c_client *client, int pwm)
 {
-       struct pca9532_data *data = i2c_get_clientdata(client);
-       mutex_lock(&data->update_lock);
+        struct pca9532_data *data = i2c_get_clientdata(client);
+        mutex_lock(&data->update_lock);
         i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(pwm),
                 data->pwm[pwm]);
         i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(pwm),
@@ -132,11 +132,11 @@ static void pca9532_set_brightness(struct led_classdev *led_cdev,
                 led->state = PCA9532_ON;
         else {
                 led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
-               err = pca9532_calcpwm(led->client, 0, 0, value);
+                err = pca9532_calcpwm(led->client, 0, 0, value);
                 if (err)
                         return; /* XXX: led api doesn't allow error code? */
         }
-       schedule_work(&led->work);
+        schedule_work(&led->work);
 }
 
 static int pca9532_set_blink(struct led_classdev *led_cdev,
@@ -145,7 +145,7 @@ static int pca9532_set_blink(struct led_classdev *led_cdev,
         struct pca9532_led *led = ldev_to_led(led_cdev);
         struct i2c_client *client = led->client;
         int psc;
-       int err = 0;
+        int err = 0;
 
         if (*delay_on == 0 && *delay_off == 0) {
         /* led subsystem ask us for a blink rate */
@@ -157,11 +157,11 @@ static int pca9532_set_blink(struct led_classdev *led_cdev,
 
         /* Thecus specific: only use PSC/PWM 0 */
         psc = (*delay_on * 152-1)/1000;
-       err = pca9532_calcpwm(client, 0, psc, led_cdev->brightness);
-       if (err)
-               return err;
-       schedule_work(&led->work);
-       return 0;
+        err = pca9532_calcpwm(client, 0, psc, led_cdev->brightness);
+        if (err)
+                return err;
+        schedule_work(&led->work);
+        return 0;
 }
 
 static int pca9532_event(struct input_dev *dev, unsigned int type,
@@ -178,15 +178,15 @@ static int pca9532_event(struct input_dev *dev, unsigned int type,
         else
                 data->pwm[1] = 0;
 
-       schedule_work(&data->work);
+        schedule_work(&data->work);
 
-       return 0;
+        return 0;
 }
 
 static void pca9532_input_work(struct work_struct *work)
 {
-       struct pca9532_data *data;
-       data = container_of(work, struct pca9532_data, work);
+        struct pca9532_data *data;
+        data = container_of(work, struct pca9532_data, work);
         mutex_lock(&data->update_lock);
         i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(1),
                 data->pwm[1]);
@@ -195,11 +195,11 @@ static void pca9532_input_work(struct work_struct *work)
 
 static void pca9532_led_work(struct work_struct *work)
 {
-       struct pca9532_led *led;
-       led = container_of(work, struct pca9532_led, work);
-       if (led->state == PCA9532_PWM0)
-               pca9532_setpwm(led->client, 0);
-       pca9532_setled(led);
+        struct pca9532_led *led;
+        led = container_of(work, struct pca9532_led, work);
+        if (led->state == PCA9532_PWM0)
+                pca9532_setpwm(led->client, 0);
+        pca9532_setled(led);
 }
 
 static int pca9532_configure(struct i2c_client *client,
@@ -232,7 +232,7 @@ static int pca9532_configure(struct i2c_client *client,
                         led->ldev.brightness = LED_OFF;
                         led->ldev.brightness_set = pca9532_set_brightness;
                         led->ldev.blink_set = pca9532_set_blink;
-                       INIT_WORK(&led->work, pca9532_led_work);
+                        INIT_WORK(&led->work, pca9532_led_work);
                         err = led_classdev_register(&client->dev, &led->ldev);
                         if (err < 0) {
                                 dev_err(&client->dev,
@@ -262,11 +262,11 @@ static int pca9532_configure(struct i2c_client *client,
                                                 BIT_MASK(SND_TONE);
                         data->idev->event = pca9532_event;
                         input_set_drvdata(data->idev, data);
-                       INIT_WORK(&data->work, pca9532_input_work);
+                        INIT_WORK(&data->work, pca9532_input_work);
                         err = input_register_device(data->idev);
                         if (err) {
                                 input_free_device(data->idev);
-                               cancel_work_sync(&data->work);
+                                cancel_work_sync(&data->work);
                                 data->idev = NULL;
                                 goto exit;
                         }
@@ -283,13 +283,13 @@ exit:
                                 break;
                         case PCA9532_TYPE_LED:
                                 led_classdev_unregister(&data->leds[i].ldev);
-                               cancel_work_sync(&data->leds[i].work);
+                                cancel_work_sync(&data->leds[i].work);
                                 break;
                         case PCA9532_TYPE_N2100_BEEP:
                                 if (data->idev != NULL) {
                                         input_unregister_device(data->idev);
                                         input_free_device(data->idev);
-                                       cancel_work_sync(&data->work);
+                                        cancel_work_sync(&data->work);
                                         data->idev = NULL;
                                 }
                                 break;
@@ -340,13 +340,13 @@ static int pca9532_remove(struct i2c_client *client)
                         break;
                 case PCA9532_TYPE_LED:
                         led_classdev_unregister(&data->leds[i].ldev);
-                       cancel_work_sync(&data->leds[i].work);
+                        cancel_work_sync(&data->leds[i].work);
                         break;
                 case PCA9532_TYPE_N2100_BEEP:
                         if (data->idev != NULL) {
                                 input_unregister_device(data->idev);
                                 input_free_device(data->idev);
-                               cancel_work_sync(&data->work);
+                                cancel_work_sync(&data->work);
                                 data->idev = NULL;
                         }
                         break;
diff --git a/drivers/lguest/lg.h b/drivers/lguest/lg.h
index d4e8979735cb..9c3138265f8e 100644
--- a/drivers/lguest/lg.h
+++ b/drivers/lguest/lg.h
@@ -82,7 +82,7 @@ struct lg_cpu {
 
 struct lg_eventfd {
         unsigned long addr;
-        struct file *event;
+        struct eventfd_ctx *event;
 };
 
 struct lg_eventfd_map {
diff --git a/drivers/lguest/lguest_user.c b/drivers/lguest/lguest_user.c
index 32e297121058..9f9a2953b383 100644
--- a/drivers/lguest/lguest_user.c
+++ b/drivers/lguest/lguest_user.c
@@ -50,7 +50,7 @@ static int add_eventfd(struct lguest *lg, unsigned long addr, int fd)
 
         /* Now append new entry. */
         new->map[new->num].addr = addr;
-        new->map[new->num].event = eventfd_fget(fd);
+        new->map[new->num].event = eventfd_ctx_fdget(fd);
         if (IS_ERR(new->map[new->num].event)) {
                 kfree(new);
                 return PTR_ERR(new->map[new->num].event);
@@ -357,7 +357,7 @@ static int close(struct inode *inode, struct file *file)
 
         /* Release any eventfds they registered. */
         for (i = 0; i < lg->eventfds->num; i++)
-                fput(lg->eventfds->map[i].event);
+                eventfd_ctx_put(lg->eventfds->map[i].event);
         kfree(lg->eventfds);
 
         /* If lg->dead doesn't contain an error code it will be NULL or a
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 6e149f4a1fff..a0f68386c12f 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -378,6 +378,17 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
         dev->ofdev.dev.bus = &macio_bus_type;
         dev->ofdev.dev.release = macio_release_dev;
 
+#ifdef CONFIG_PCI
+        /* Set the DMA ops to the ones from the PCI device, this could be
+         * fishy if we didn't know that on PowerMac it's always direct ops
+         * or iommu ops that will work fine
+         */
+        dev->ofdev.dev.archdata.dma_ops =
+                chip->lbus.pdev->dev.archdata.dma_ops;
+        dev->ofdev.dev.archdata.dma_data =
+                chip->lbus.pdev->dev.archdata.dma_data;
+#endif /* CONFIG_PCI */
+
 #ifdef DEBUG
         printk("preparing mdev @%p, ofdev @%p, dev @%p, kobj @%p\n",
                dev, &dev->ofdev, &dev->ofdev.dev, &dev->ofdev.dev.kobj);
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 9933eb861c71..529e2ba505c3 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -776,7 +776,7 @@ static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
                  * But don't wait if split was due to the io size restriction
                  */
                 if (unlikely(out_of_pages))
-                        congestion_wait(WRITE, HZ/100);
+                        congestion_wait(BLK_RW_ASYNC, HZ/100);
 
                 /*
                  * With async crypto it is unsafe to share the crypto context
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index c3ae51584b12..3710ff88fc10 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -195,7 +195,7 @@ int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
                               struct dm_exception_store **store)
 {
         int r = 0;
-        struct dm_exception_store_type *type;
+        struct dm_exception_store_type *type = NULL;
         struct dm_exception_store *tmp_store;
         char persistent;
 
@@ -211,12 +211,15 @@ int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
         }
 
         persistent = toupper(*argv[1]);
-        if (persistent != 'P' && persistent != 'N') {
+        if (persistent == 'P')
+                type = get_type("P");
+        else if (persistent == 'N')
+                type = get_type("N");
+        else {
                 ti->error = "Persistent flag is not P or N";
                 return -EINVAL;
         }
 
-        type = get_type(&persistent);
         if (!type) {
                 ti->error = "Exception store type not recognised";
                 r = -EINVAL;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 4899ebe767c8..2cba557d9e61 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -495,7 +495,7 @@ int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
                 return 0;
         }
 
-        if (blk_stack_limits(limits, &q->limits, start) < 0)
+        if (blk_stack_limits(limits, &q->limits, start << 9) < 0)
                 DMWARN("%s: target device %s is misaligned",
                        dm_device_name(ti->table->md), bdevname(bdev, b));
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 3c6d4ee8921d..9acd54a5cffb 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1017,7 +1017,7 @@ static struct bio *split_bvec(struct bio *bio, sector_t sector,
         clone->bi_flags |= 1 << BIO_CLONED;
 
         if (bio_integrity(bio)) {
-                bio_integrity_clone(clone, bio, GFP_NOIO);
+                bio_integrity_clone(clone, bio, GFP_NOIO, bs);
                 bio_integrity_trim(clone,
                                    bio_sector_offset(bio, idx, offset), len);
         }
@@ -1045,7 +1045,7 @@ static struct bio *clone_bio(struct bio *bio, sector_t sector,
         clone->bi_flags &= ~(1 << BIO_SEG_VALID);
 
         if (bio_integrity(bio)) {
-                bio_integrity_clone(clone, bio, GFP_NOIO);
+                bio_integrity_clone(clone, bio, GFP_NOIO, bs);
 
                 if (idx != bio->bi_idx || clone->bi_size < bio->bi_size)
                         bio_integrity_trim(clone,
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 15c8b7b25a9b..5810fa906af0 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -166,8 +166,8 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                         rdev->sectors = sectors * mddev->chunk_sectors;
                 }
 
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 09be637d52cb..d4351ff0849f 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1756,9 +1756,10 @@ static void print_sb_1(struct mdp_superblock_1 *sb)
         __u8 *uuid;
 
         uuid = sb->set_uuid;
-        printk(KERN_INFO "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x"
-                        ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n"
-               KERN_INFO "md:    Name: \"%s\" CT:%llu\n",
+        printk(KERN_INFO
+               "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x"
+               ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n"
+               "md:    Name: \"%s\" CT:%llu\n",
                 le32_to_cpu(sb->major_version),
                 le32_to_cpu(sb->feature_map),
                 uuid[0], uuid[1], uuid[2], uuid[3],
@@ -1770,12 +1771,13 @@ static void print_sb_1(struct mdp_superblock_1 *sb)
                        & MD_SUPERBLOCK_1_TIME_SEC_MASK);
 
         uuid = sb->device_uuid;
-        printk(KERN_INFO "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
+        printk(KERN_INFO
+               "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
                         " RO:%llu\n"
-               KERN_INFO "md:     Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x"
-                        ":%02x%02x%02x%02x%02x%02x\n"
-               KERN_INFO "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
-               KERN_INFO "md:         (MaxDev:%u) \n",
+               "md:     Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x"
+                        ":%02x%02x%02x%02x%02x%02x\n"
+               "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
+               "md:         (MaxDev:%u) \n",
                 le32_to_cpu(sb->level),
                 (unsigned long long)le64_to_cpu(sb->size),
                 le32_to_cpu(sb->raid_disks),
@@ -3573,7 +3575,8 @@ suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
         char *e;
         unsigned long long new = simple_strtoull(buf, &e, 10);
 
-        if (mddev->pers->quiesce == NULL)
+        if (mddev->pers == NULL || 
+            mddev->pers->quiesce == NULL)
                 return -EINVAL;
         if (buf == e || (*e && *e != '\n'))
                 return -EINVAL;
@@ -3601,7 +3604,8 @@ suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
         char *e;
         unsigned long long new = simple_strtoull(buf, &e, 10);
 
-        if (mddev->pers->quiesce == NULL)
+        if (mddev->pers == NULL ||
+            mddev->pers->quiesce == NULL)
                 return -EINVAL;
         if (buf == e || (*e && *e != '\n'))
                 return -EINVAL;
@@ -3844,11 +3848,9 @@ static int md_alloc(dev_t dev, char *name)
         flush_scheduled_work();
 
         mutex_lock(&disks_mutex);
-        if (mddev->gendisk) {
-                mutex_unlock(&disks_mutex);
-                mddev_put(mddev);
-                return -EEXIST;
-        }
+        error = -EEXIST;
+        if (mddev->gendisk)
+                goto abort;
 
         if (name) {
                 /* Need to ensure that 'name' is not a duplicate.
@@ -3860,17 +3862,15 @@ static int md_alloc(dev_t dev, char *name)
                         if (mddev2->gendisk &&
                             strcmp(mddev2->gendisk->disk_name, name) == 0) {
                                 spin_unlock(&all_mddevs_lock);
-                                return -EEXIST;
+                                goto abort;
                         }
                 spin_unlock(&all_mddevs_lock);
         }
 
+        error = -ENOMEM;
         mddev->queue = blk_alloc_queue(GFP_KERNEL);
-        if (!mddev->queue) {
-                mutex_unlock(&disks_mutex);
-                mddev_put(mddev);
-                return -ENOMEM;
-        }
+        if (!mddev->queue)
+                goto abort;
         mddev->queue->queuedata = mddev;
 
         /* Can be unlocked because the queue is new: no concurrency */
@@ -3880,11 +3880,9 @@ static int md_alloc(dev_t dev, char *name)
 
         disk = alloc_disk(1 << shift);
         if (!disk) {
-                mutex_unlock(&disks_mutex);
                 blk_cleanup_queue(mddev->queue);
                 mddev->queue = NULL;
-                mddev_put(mddev);
-                return -ENOMEM;
+                goto abort;
         }
         disk->major = MAJOR(mddev->unit);
         disk->first_minor = unit << shift;
@@ -3906,16 +3904,22 @@ static int md_alloc(dev_t dev, char *name)
         mddev->gendisk = disk;
         error = kobject_init_and_add(&mddev->kobj, &md_ktype,
                                      &disk_to_dev(disk)->kobj, "%s", "md");
-        mutex_unlock(&disks_mutex);
-        if (error)
+        if (error) {
+                /* This isn't possible, but as kobject_init_and_add is marked
+                 * __must_check, we must do something with the result
+                 */
                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
                        disk->disk_name);
-        else {
+                error = 0;
+        }
+ abort:
+        mutex_unlock(&disks_mutex);
+        if (!error) {
                 kobject_uevent(&mddev->kobj, KOBJ_ADD);
                 mddev->sysfs_state = sysfs_get_dirent(mddev->kobj.sd, "array_state");
         }
         mddev_put(mddev);
-        return 0;
+        return error;
 }
 
 static struct kobject *md_probe(dev_t dev, int *part, void *data)
@@ -6334,10 +6338,16 @@ void md_do_sync(mddev_t *mddev)
                         sysfs_notify(&mddev->kobj, NULL, "sync_completed");
                 }
 
-                if (j >= mddev->resync_max)
-                        wait_event(mddev->recovery_wait,
-                                   mddev->resync_max > j
-                                   || kthread_should_stop());
+                while (j >= mddev->resync_max && !kthread_should_stop()) {
+                        /* As this condition is controlled by user-space,
+                         * we can block indefinitely, so use '_interruptible'
+                         * to avoid triggering warnings.
+                         */
+                        flush_signals(current); /* just in case */
+                        wait_event_interruptible(mddev->recovery_wait,
+                                                 mddev->resync_max > j
+                                                 || kthread_should_stop());
+                }
 
                 if (kthread_should_stop())
                         goto interrupted;
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index cbe368fa6598..237fe3fd235c 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -294,7 +294,8 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         for (path = first; path <= last; path++)
                 if ((p=conf->multipaths+path)->rdev == NULL) {
                         q = rdev->bdev->bd_disk->queue;
-                        blk_queue_stack_limits(mddev->queue, q);
+                        disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                          rdev->data_offset << 9);
 
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
@@ -463,9 +464,9 @@ static int multipath_run (mddev_t *mddev)
 
                 disk = conf->multipaths + disk_idx;
                 disk->rdev = rdev;
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
 
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, not that we ever expect a device with
                  * a merge_bvec_fn to be involved in multipath */
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index ab4a489d8695..335f490dcad6 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -170,8 +170,8 @@ static int create_strip_zones(mddev_t *mddev)
                 }
                 dev[j] = rdev1;
 
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev1->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev1->bdev,
+                                  rdev1->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
@@ -250,6 +250,11 @@ static int create_strip_zones(mddev_t *mddev)
                        mddev->chunk_sectors << 9);
                 goto abort;
         }
+
+        blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
+        blk_queue_io_opt(mddev->queue,
+                         (mddev->chunk_sectors << 9) * mddev->raid_disks);
+
         printk(KERN_INFO "raid0: done.\n");
         mddev->private = conf;
         return 0;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 89939a7aef57..0569efba0c02 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1123,8 +1123,8 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         for (mirror = first; mirror <= last; mirror++)
                 if ( !(p=conf->mirrors+mirror)->rdev) {
 
-                        blk_queue_stack_limits(mddev->queue,
-                                               rdev->bdev->bd_disk->queue);
+                        disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                          rdev->data_offset << 9);
                         /* as we don't honour merge_bvec_fn, we must never risk
                          * violating it, so limit ->max_sector to one PAGE, as
                          * a one page request is never in violation.
@@ -1988,9 +1988,8 @@ static int run(mddev_t *mddev)
                 disk = conf->mirrors + disk_idx;
 
                 disk->rdev = rdev;
-
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index ae12ceafe10c..7298a5e5a183 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1151,8 +1151,8 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         for ( ; mirror <= last ; mirror++)
                 if ( !(p=conf->mirrors+mirror)->rdev) {
 
-                        blk_queue_stack_limits(mddev->queue,
-                                               rdev->bdev->bd_disk->queue);
+                        disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                          rdev->data_offset << 9);
                         /* as we don't honour merge_bvec_fn, we must never risk
                          * violating it, so limit ->max_sector to one PAGE, as
                          * a one page request is never in violation.
@@ -2044,7 +2044,7 @@ raid10_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 static int run(mddev_t *mddev)
 {
         conf_t *conf;
-        int i, disk_idx;
+        int i, disk_idx, chunk_size;
         mirror_info_t *disk;
         mdk_rdev_t *rdev;
         int nc, fc, fo;
@@ -2130,6 +2130,14 @@ static int run(mddev_t *mddev)
         spin_lock_init(&conf->device_lock);
         mddev->queue->queue_lock = &conf->device_lock;
 
+        chunk_size = mddev->chunk_sectors << 9;
+        blk_queue_io_min(mddev->queue, chunk_size);
+        if (conf->raid_disks % conf->near_copies)
+                blk_queue_io_opt(mddev->queue, chunk_size * conf->raid_disks);
+        else
+                blk_queue_io_opt(mddev->queue, chunk_size *
+                                 (conf->raid_disks / conf->near_copies));
+
         list_for_each_entry(rdev, &mddev->disks, same_set) {
                 disk_idx = rdev->raid_disk;
                 if (disk_idx >= mddev->raid_disks
@@ -2138,9 +2146,8 @@ static int run(mddev_t *mddev)
                 disk = conf->mirrors + disk_idx;
 
                 disk->rdev = rdev;
-
-                blk_queue_stack_limits(mddev->queue,
-                                       rdev->bdev->bd_disk->queue);
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
                 /* as we don't honour merge_bvec_fn, we must never risk
                  * violating it, so limit ->max_sector to one PAGE, as
                  * a one page request is never in violation.
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index f9f991e6e138..37835538b58e 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3699,13 +3699,21 @@ static int make_request(struct request_queue *q, struct bio * bi)
                                         goto retry;
                                 }
                         }
-                        /* FIXME what if we get a false positive because these
-                         * are being updated.
-                         */
-                        if (logical_sector >= mddev->suspend_lo &&
+
+                        if (bio_data_dir(bi) == WRITE &&
+                            logical_sector >= mddev->suspend_lo &&
                             logical_sector < mddev->suspend_hi) {
                                 release_stripe(sh);
-                                schedule();
+                                /* As the suspend_* range is controlled by
+                                 * userspace, we want an interruptible
+                                 * wait.
+                                 */
+                                flush_signals(current);
+                                prepare_to_wait(&conf->wait_for_overlap,
+                                                &w, TASK_INTERRUPTIBLE);
+                                if (logical_sector >= mddev->suspend_lo &&
+                                    logical_sector < mddev->suspend_hi)
+                                        schedule();
                                 goto retry;
                         }
 
@@ -4452,7 +4460,7 @@ static raid5_conf_t *setup_conf(mddev_t *mddev)
 static int run(mddev_t *mddev)
 {
         raid5_conf_t *conf;
-        int working_disks = 0;
+        int working_disks = 0, chunk_size;
         mdk_rdev_t *rdev;
 
         if (mddev->recovery_cp != MaxSector)
@@ -4607,6 +4615,14 @@ static int run(mddev_t *mddev)
         md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
 
         blk_queue_merge_bvec(mddev->queue, raid5_mergeable_bvec);
+        chunk_size = mddev->chunk_sectors << 9;
+        blk_queue_io_min(mddev->queue, chunk_size);
+        blk_queue_io_opt(mddev->queue, chunk_size *
+                         (conf->raid_disks - conf->max_degraded));
+
+        list_for_each_entry(rdev, &mddev->disks, same_set)
+                disk_stack_limits(mddev->gendisk, rdev->bdev,
+                                  rdev->data_offset << 9);
 
         return 0;
 abort:
diff --git a/drivers/media/common/tuners/tuner-xc2028.c b/drivers/media/common/tuners/tuner-xc2028.c
index b6da9c3873fe..aa20ce8cc668 100644
--- a/drivers/media/common/tuners/tuner-xc2028.c
+++ b/drivers/media/common/tuners/tuner-xc2028.c
@@ -1096,8 +1096,19 @@ static int xc2028_set_params(struct dvb_frontend *fe,
         }
 
         /* All S-code tables need a 200kHz shift */
-        if (priv->ctrl.demod)
+        if (priv->ctrl.demod) {
                 demod = priv->ctrl.demod + 200;
+                /*
+                 * The DTV7 S-code table needs a 700 kHz shift.
+                 * Thanks to Terry Wu <terrywu2009@gmail.com> for reporting this
+                 *
+                 * DTV7 is only used in Australia.  Germany or Italy may also
+                 * use this firmware after initialization, but a tune to a UHF
+                 * channel should then cause DTV78 to be used.
+                 */
+                if (type & DTV7)
+                        demod += 500;
+        }
 
         return generic_set_freq(fe, p->frequency,
                                 T_DIGITAL_TV, type, 0, demod);
diff --git a/drivers/media/dvb/ttpci/Kconfig b/drivers/media/dvb/ttpci/Kconfig
index 68eb4493f991..d8d4214fd65f 100644
--- a/drivers/media/dvb/ttpci/Kconfig
+++ b/drivers/media/dvb/ttpci/Kconfig
@@ -1,5 +1,6 @@
 config TTPCI_EEPROM
         tristate
+        depends on I2C
         default n
 
 config DVB_AV7110
diff --git a/drivers/media/radio/radio-si470x.c b/drivers/media/radio/radio-si470x.c
index 640421ceb24a..46d216329611 100644
--- a/drivers/media/radio/radio-si470x.c
+++ b/drivers/media/radio/radio-si470x.c
@@ -1200,7 +1200,7 @@ static int si470x_fops_release(struct file *file)
                         video_unregister_device(radio->videodev);
                         kfree(radio->buffer);
                         kfree(radio);
-                        goto done;
+                        goto unlock;
                 }
 
                 /* stop rds reception */
@@ -1213,9 +1213,8 @@ static int si470x_fops_release(struct file *file)
                 retval = si470x_stop(radio);
                 usb_autopm_put_interface(radio->intf);
         }
-
+unlock:
         mutex_unlock(&radio->disconnect_lock);
-
 done:
         return retval;
 }
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 061e147f6f26..84b6fc15519d 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -312,6 +312,14 @@ config VIDEO_OV7670
           OV7670 VGA camera.  It currently only works with the M88ALP01
           controller.
 
+config VIDEO_MT9V011
+        tristate "Micron mt9v011 sensor support"
+        depends on I2C && VIDEO_V4L2
+        ---help---
+          This is a Video4Linux2 sensor-level driver for the Micron
+          mt0v011 1.3 Mpixel camera.  It currently only works with the
+          em28xx driver.
+
 config VIDEO_TCM825X
         tristate "TCM825x camera sensor support"
         depends on I2C && VIDEO_V4L2
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 7fb3add1b387..9f2e3214a482 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -69,6 +69,7 @@ obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
 obj-$(CONFIG_VIDEO_OV7670)      += ov7670.o
 obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
 obj-$(CONFIG_VIDEO_TVEEPROM) += tveeprom.o
+obj-$(CONFIG_VIDEO_MT9V011) += mt9v011.o
 
 obj-$(CONFIG_SOC_CAMERA_MT9M001)        += mt9m001.o
 obj-$(CONFIG_SOC_CAMERA_MT9M111)        += mt9m111.o
diff --git a/drivers/media/video/cx18/cx18-cards.c b/drivers/media/video/cx18/cx18-cards.c
index c92a25036f0e..36f2d76006fd 100644
--- a/drivers/media/video/cx18/cx18-cards.c
+++ b/drivers/media/video/cx18/cx18-cards.c
@@ -198,11 +198,14 @@ static const struct cx18_card_pci_info cx18_pci_mpc718[] = {
 
 static const struct cx18_card cx18_card_mpc718 = {
         .type = CX18_CARD_YUAN_MPC718,
-        .name = "Yuan MPC718",
-        .comment = "Analog video capture works; some audio line in may not.\n",
+        .name = "Yuan MPC718 MiniPCI DVB-T/Analog",
+        .comment = "Experimenters needed for device to work well.\n"
+                  "\tTo help, mail the ivtv-devel list (www.ivtvdriver.org).\n",
         .v4l2_capabilities = CX18_CAP_ENCODER,
         .hw_audio_ctrl = CX18_HW_418_AV,
-        .hw_all = CX18_HW_418_AV | CX18_HW_TUNER | CX18_HW_GPIO_RESET_CTRL,
+        .hw_muxer = CX18_HW_GPIO_MUX,
+        .hw_all = CX18_HW_418_AV | CX18_HW_TUNER |
+                  CX18_HW_GPIO_MUX | CX18_HW_DVB | CX18_HW_GPIO_RESET_CTRL,
         .video_inputs = {
                 { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE2 },
                 { CX18_CARD_INPUT_SVIDEO1,    1,
@@ -211,27 +214,34 @@ static const struct cx18_card cx18_card_mpc718 = {
                 { CX18_CARD_INPUT_SVIDEO2,    2,
                                 CX18_AV_SVIDEO_LUMA7 | CX18_AV_SVIDEO_CHROMA8 },
                 { CX18_CARD_INPUT_COMPOSITE2, 2, CX18_AV_COMPOSITE6 },
-                { CX18_CARD_INPUT_COMPOSITE3, 2, CX18_AV_COMPOSITE3 },
         },
         .audio_inputs = {
                 { CX18_CARD_INPUT_AUD_TUNER, CX18_AV_AUDIO5,        0 },
-                { CX18_CARD_INPUT_LINE_IN1,  CX18_AV_AUDIO_SERIAL1, 0 },
-                { CX18_CARD_INPUT_LINE_IN2,  CX18_AV_AUDIO_SERIAL1, 0 },
+                { CX18_CARD_INPUT_LINE_IN1,  CX18_AV_AUDIO_SERIAL1, 1 },
+                { CX18_CARD_INPUT_LINE_IN2,  CX18_AV_AUDIO_SERIAL2, 1 },
         },
-        .radio_input = { CX18_CARD_INPUT_AUD_TUNER, CX18_AV_AUDIO_SERIAL1, 0 },
         .tuners = {
                 /* XC3028 tuner */
                 { .std = V4L2_STD_ALL, .tuner = TUNER_XC2028 },
         },
+        /* FIXME - the FM radio is just a guess and driver doesn't use SIF */
+        .radio_input = { CX18_CARD_INPUT_AUD_TUNER, CX18_AV_AUDIO5, 2 },
         .ddr = {
-                /* Probably Samsung K4D263238G-VC33 memory */
-                .chip_config = 0x003,
-                .refresh = 0x30c,
-                .timing1 = 0x23230b73,
-                .timing2 = 0x08,
+                /* Hynix HY5DU283222B DDR RAM */
+                .chip_config = 0x303,
+                .refresh = 0x3bd,
+                .timing1 = 0x36320966,
+                .timing2 = 0x1f,
                 .tune_lane = 0,
                 .initial_emrs = 2,
         },
+        .gpio_init.initial_value = 0x1,
+        .gpio_init.direction = 0x3,
+        /* FIXME - these GPIO's are just guesses */
+        .gpio_audio_input = { .mask   = 0x3,
+                              .tuner  = 0x1,
+                              .linein = 0x3,
+                              .radio  = 0x1 },
         .xceive_pin = 0,
         .pci_list = cx18_pci_mpc718,
         .i2c = &cx18_i2c_std,
diff --git a/drivers/media/video/cx18/cx18-dvb.c b/drivers/media/video/cx18/cx18-dvb.c
index 6ea3fe623ef4..51a0c33b25b7 100644
--- a/drivers/media/video/cx18/cx18-dvb.c
+++ b/drivers/media/video/cx18/cx18-dvb.c
@@ -30,6 +30,10 @@
 #include "s5h1409.h"
 #include "mxl5005s.h"
 #include "zl10353.h"
+
+#include <linux/firmware.h>
+#include "mt352.h"
+#include "mt352_priv.h"
 #include "tuner-xc2028.h"
 
 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
@@ -38,6 +42,11 @@ DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 #define CX18_CLOCK_ENABLE2               0xc71024
 #define CX18_DMUX_CLK_MASK               0x0080
 
+/*
+ * CX18_CARD_HVR_1600_ESMT
+ * CX18_CARD_HVR_1600_SAMSUNG
+ */
+
 static struct mxl5005s_config hauppauge_hvr1600_tuner = {
         .i2c_address     = 0xC6 >> 1,
         .if_freq         = IF_FREQ_5380000HZ,
@@ -65,6 +74,9 @@ static struct s5h1409_config hauppauge_hvr1600_config = {
         .mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
 };
 
+/*
+ * CX18_CARD_LEADTEK_DVR3100H
+ */
 /* Information/confirmation of proper config values provided by Terry Wu */
 static struct zl10353_config leadtek_dvr3100h_demod = {
         .demod_address         = 0x1e >> 1, /* Datasheet suggested straps */
@@ -74,6 +86,121 @@ static struct zl10353_config leadtek_dvr3100h_demod = {
         .disable_i2c_gate_ctrl = 1,         /* Disable the I2C gate */
 };
 
+/*
+ * CX18_CARD_YUAN_MPC718
+ */
+/*
+ * Due to
+ *
+ * 1. an absence of information on how to prgram the MT352
+ * 2. the Linux mt352 module pushing MT352 initialzation off onto us here
+ *
+ * We have to use an init sequence that *you* must extract from the Windows
+ * driver (yuanrap.sys) and which we load as a firmware.
+ *
+ * If someone can provide me with a Zarlink MT352 (Intel CE6352?) Design Manual
+ * with chip programming details, then I can remove this annoyance.
+ */
+static int yuan_mpc718_mt352_reqfw(struct cx18_stream *stream,
+                                   const struct firmware **fw)
+{
+        struct cx18 *cx = stream->cx;
+        const char *fn = "dvb-cx18-mpc718-mt352.fw";
+        int ret;
+
+        ret = request_firmware(fw, fn, &cx->pci_dev->dev);
+        if (ret)
+                CX18_ERR("Unable to open firmware file %s\n", fn);
+        else {
+                size_t sz = (*fw)->size;
+                if (sz < 2 || sz > 64 || (sz % 2) != 0) {
+                        CX18_ERR("Firmware %s has a bad size: %lu bytes\n",
+                                 fn, (unsigned long) sz);
+                        ret = -EILSEQ;
+                        release_firmware(*fw);
+                        *fw = NULL;
+                }
+        }
+
+        if (ret) {
+                CX18_ERR("The MPC718 board variant with the MT352 DVB-T"
+                          "demodualtor will not work without it\n");
+                CX18_ERR("Run 'linux/Documentation/dvb/get_dvb_firmware "
+                          "mpc718' if you need the firmware\n");
+        }
+        return ret;
+}
+
+static int yuan_mpc718_mt352_init(struct dvb_frontend *fe)
+{
+        struct cx18_dvb *dvb = container_of(fe->dvb,
+                                            struct cx18_dvb, dvb_adapter);
+        struct cx18_stream *stream = container_of(dvb, struct cx18_stream, dvb);
+        const struct firmware *fw = NULL;
+        int ret;
+        int i;
+        u8 buf[3];
+
+        ret = yuan_mpc718_mt352_reqfw(stream, &fw);
+        if (ret)
+                return ret;
+
+        /* Loop through all the register-value pairs in the firmware file */
+        for (i = 0; i < fw->size; i += 2) {
+                buf[0] = fw->data[i];
+                /* Intercept a few registers we want to set ourselves */
+                switch (buf[0]) {
+                case TRL_NOMINAL_RATE_0:
+                        /* Set our custom OFDM bandwidth in the case below */
+                        break;
+                case TRL_NOMINAL_RATE_1:
+                        /* 6 MHz: 64/7 * 6/8 / 20.48 * 2^16 = 0x55b6.db6 */
+                        /* 7 MHz: 64/7 * 7/8 / 20.48 * 2^16 = 0x6400 */
+                        /* 8 MHz: 64/7 * 8/8 / 20.48 * 2^16 = 0x7249.249 */
+                        buf[1] = 0x72;
+                        buf[2] = 0x49;
+                        mt352_write(fe, buf, 3);
+                        break;
+                case INPUT_FREQ_0:
+                        /* Set our custom IF in the case below */
+                        break;
+                case INPUT_FREQ_1:
+                        /* 4.56 MHz IF: (20.48 - 4.56)/20.48 * 2^14 = 0x31c0 */
+                        buf[1] = 0x31;
+                        buf[2] = 0xc0;
+                        mt352_write(fe, buf, 3);
+                        break;
+                default:
+                        /* Pass through the register-value pair from the fw */
+                        buf[1] = fw->data[i+1];
+                        mt352_write(fe, buf, 2);
+                        break;
+                }
+        }
+
+        buf[0] = (u8) TUNER_GO;
+        buf[1] = 0x01; /* Go */
+        mt352_write(fe, buf, 2);
+        release_firmware(fw);
+        return 0;
+}
+
+static struct mt352_config yuan_mpc718_mt352_demod = {
+        .demod_address = 0x1e >> 1,
+        .adc_clock     = 20480,     /* 20.480 MHz */
+        .if2           =  4560,     /*  4.560 MHz */
+        .no_tuner      = 1,         /* XC3028 is not behind the gate */
+        .demod_init    = yuan_mpc718_mt352_init,
+};
+
+static struct zl10353_config yuan_mpc718_zl10353_demod = {
+        .demod_address         = 0x1e >> 1, /* Datasheet suggested straps */
+        .if2                   = 45600,     /* 4.560 MHz IF from the XC3028 */
+        .parallel_ts           = 1,         /* Not a serial TS */
+        .no_tuner              = 1,         /* XC3028 is not behind the gate */
+        .disable_i2c_gate_ctrl = 1,         /* Disable the I2C gate */
+};
+
 static int dvb_register(struct cx18_stream *stream);
 
 /* Kernel DVB framework calls this when the feed needs to start.
@@ -113,6 +240,7 @@ static int cx18_dvb_start_feed(struct dvb_demux_feed *feed)
                 break;
 
         case CX18_CARD_LEADTEK_DVR3100H:
+        case CX18_CARD_YUAN_MPC718:
         default:
                 /* Assumption - Parallel transport - Signalling
                  * undefined or default.
@@ -326,6 +454,38 @@ static int dvb_register(struct cx18_stream *stream)
                                 fe->ops.tuner_ops.set_config(fe, &ctrl);
                 }
                 break;
+        case CX18_CARD_YUAN_MPC718:
+                /*
+                 * TODO
+                 * Apparently, these cards also could instead have a
+                 * DiBcom demod supported by one of the db7000 drivers
+                 */
+                dvb->fe = dvb_attach(mt352_attach,
+                                     &yuan_mpc718_mt352_demod,
+                                     &cx->i2c_adap[1]);
+                if (dvb->fe == NULL)
+                        dvb->fe = dvb_attach(zl10353_attach,
+                                             &yuan_mpc718_zl10353_demod,
+                                             &cx->i2c_adap[1]);
+                if (dvb->fe != NULL) {
+                        struct dvb_frontend *fe;
+                        struct xc2028_config cfg = {
+                                .i2c_adap = &cx->i2c_adap[1],
+                                .i2c_addr = 0xc2 >> 1,
+                                .ctrl = NULL,
+                        };
+                        static struct xc2028_ctrl ctrl = {
+                                .fname   = XC2028_DEFAULT_FIRMWARE,
+                                .max_len = 64,
+                                .demod   = XC3028_FE_ZARLINK456,
+                                .type    = XC2028_AUTO,
+                        };
+
+                        fe = dvb_attach(xc2028_attach, dvb->fe, &cfg);
+                        if (fe != NULL && fe->ops.tuner_ops.set_config != NULL)
+                                fe->ops.tuner_ops.set_config(fe, &ctrl);
+                }
+                break;
         default:
                 /* No Digital Tv Support */
                 break;
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index 48a975134ac5..86ac529e62be 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -463,6 +463,30 @@ static struct xc5000_config mygica_x8506_xc5000_config = {
         .if_khz = 5380,
 };
 
+static int cx23885_dvb_set_frontend(struct dvb_frontend *fe,
+                                    struct dvb_frontend_parameters *param)
+{
+        struct cx23885_tsport *port = fe->dvb->priv;
+        struct cx23885_dev *dev = port->dev;
+
+        switch (dev->board) {
+        case CX23885_BOARD_HAUPPAUGE_HVR1275:
+                switch (param->u.vsb.modulation) {
+                case VSB_8:
+                        cx23885_gpio_clear(dev, GPIO_5);
+                        break;
+                case QAM_64:
+                case QAM_256:
+                default:
+                        cx23885_gpio_set(dev, GPIO_5);
+                        break;
+                }
+                break;
+        }
+        return (port->set_frontend_save) ?
+                port->set_frontend_save(fe, param) : -ENODEV;
+}
+
 static int dvb_register(struct cx23885_tsport *port)
 {
         struct cx23885_dev *dev = port->dev;
@@ -502,6 +526,12 @@ static int dvb_register(struct cx23885_tsport *port)
                                    0x60, &dev->i2c_bus[1].i2c_adap,
                                    &hauppauge_hvr127x_config);
                 }
+
+                /* FIXME: temporary hack */
+                /* define bridge override to set_frontend */
+                port->set_frontend_save = fe0->dvb.frontend->ops.set_frontend;
+                fe0->dvb.frontend->ops.set_frontend = cx23885_dvb_set_frontend;
+
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
                 i2c_bus = &dev->i2c_bus[0];
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index 1a2ac518a3f1..214a55e943b7 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -288,6 +288,10 @@ struct cx23885_tsport {
         /* Allow a single tsport to have multiple frontends */
         u32                        num_frontends;
         void                       *port_priv;
+
+        /* FIXME: temporary hack */
+        int (*set_frontend_save) (struct dvb_frontend *,
+                                  struct dvb_frontend_parameters *);
 };
 
 struct cx23885_dev {
diff --git a/drivers/media/video/em28xx/Kconfig b/drivers/media/video/em28xx/Kconfig
index 16a5af30e9d1..6524b493e033 100644
--- a/drivers/media/video/em28xx/Kconfig
+++ b/drivers/media/video/em28xx/Kconfig
@@ -8,6 +8,8 @@ config VIDEO_EM28XX
         select VIDEO_SAA711X if VIDEO_HELPER_CHIPS_AUTO
         select VIDEO_TVP5150 if VIDEO_HELPER_CHIPS_AUTO
         select VIDEO_MSP3400 if VIDEO_HELPER_CHIPS_AUTO
+        select VIDEO_MT9V011 if VIDEO_HELPER_CHIPS_AUTO
+
         ---help---
           This is a video4linux driver for Empia 28xx based TV cards.
 
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index c43fdb9bc888..ebd24a25fb85 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -58,6 +58,8 @@ static unsigned int card[]     = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
 module_param_array(card,  int, NULL, 0444);
 MODULE_PARM_DESC(card,     "card type");
 
+#define MT9V011_VERSION                 0x8243
+
 /* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
 static unsigned long em28xx_devused;
 
@@ -191,6 +193,13 @@ static struct em28xx_reg_seq terratec_av350_unmute_gpio[] = {
         {EM28XX_R08_GPIO,       0xff,   0xff,           10},
         {       -1,             -1,     -1,             -1},
 };
+
+static struct em28xx_reg_seq silvercrest_reg_seq[] = {
+        {EM28XX_R08_GPIO,       0xff,   0xff,           10},
+        {EM28XX_R08_GPIO,       0x01,   0xf7,           10},
+        {       -1,             -1,     -1,             -1},
+};
+
 /*
  *  Board definitions
  */
@@ -438,6 +447,18 @@ struct em28xx_board em28xx_boards[] = {
                         .amux     = EM28XX_AMUX_VIDEO,
                 } },
         },
+        [EM2820_BOARD_SILVERCREST_WEBCAM] = {
+                .name         = "Silvercrest Webcam 1.3mpix",
+                .tuner_type   = TUNER_ABSENT,
+                .is_27xx      = 1,
+                .decoder      = EM28XX_MT9V011,
+                .input        = { {
+                        .type     = EM28XX_VMUX_COMPOSITE1,
+                        .vmux     = 0,
+                        .amux     = EM28XX_AMUX_VIDEO,
+                        .gpio     = silvercrest_reg_seq,
+                } },
+        },
         [EM2821_BOARD_SUPERCOMP_USB_2] = {
                 .name         = "Supercomp USB 2.0 TV",
                 .valid        = EM28XX_BOARD_NOT_VALIDATED,
@@ -826,7 +847,7 @@ struct em28xx_board em28xx_boards[] = {
                 .tuner_gpio     = default_tuner_gpio,
                 .decoder        = EM28XX_TVP5150,
                 .has_dvb        = 1,
-                .dvb_gpio       = default_analog,
+                .dvb_gpio       = default_digital,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = TVP5150_COMPOSITE0,
@@ -1639,6 +1660,11 @@ static unsigned short tvp5150_addrs[] = {
         I2C_CLIENT_END
 };
 
+static unsigned short mt9v011_addrs[] = {
+        0xba >> 1,
+        I2C_CLIENT_END
+};
+
 static unsigned short msp3400_addrs[] = {
         0x80 >> 1,
         0x88 >> 1,
@@ -1678,6 +1704,46 @@ static inline void em28xx_set_model(struct em28xx *dev)
                                        EM28XX_I2C_FREQ_100_KHZ;
 }
 
+/* HINT method: webcam I2C chips
+ *
+ * This method work for webcams with Micron sensors
+ */
+static int em28xx_hint_sensor(struct em28xx *dev)
+{
+        int rc;
+        char *sensor_name;
+        unsigned char cmd;
+        __be16 version_be;
+        u16 version;
+
+        if (dev->model != EM2820_BOARD_UNKNOWN)
+                return 0;
+
+        dev->i2c_client.addr = 0xba >> 1;
+        cmd = 0;
+        i2c_master_send(&dev->i2c_client, &cmd, 1);
+        rc = i2c_master_recv(&dev->i2c_client, (char *)&version_be, 2);
+        if (rc != 2)
+                return -EINVAL;
+
+        version = be16_to_cpu(version_be);
+
+        switch (version) {
+        case MT9V011_VERSION:
+                dev->model = EM2820_BOARD_SILVERCREST_WEBCAM;
+                sensor_name = "mt9v011";
+                break;
+        default:
+                printk("Unknown Sensor 0x%04x\n", be16_to_cpu(version));
+                return -EINVAL;
+        }
+
+        em28xx_errdev("Sensor is %s, assuming that webcam is %s\n",
+                      sensor_name, em28xx_boards[dev->model].name);
+
+        return 0;
+}
+
 /* Since em28xx_pre_card_setup() requires a proper dev->model,
  * this won't work for boards with generic PCI IDs
  */
@@ -1706,7 +1772,10 @@ void em28xx_pre_card_setup(struct em28xx *dev)
                         em28xx_info("chip ID is em2750\n");
                         break;
                 case CHIP_ID_EM2820:
-                        em28xx_info("chip ID is em2820\n");
+                        if (dev->board.is_27xx)
+                                em28xx_info("chip is em2710\n");
+                        else
+                                em28xx_info("chip ID is em2820\n");
                         break;
                 case CHIP_ID_EM2840:
                         em28xx_info("chip ID is em2840\n");
@@ -2158,6 +2227,10 @@ void em28xx_card_setup(struct em28xx *dev)
                    before probing the i2c bus. */
                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
                 break;
+        case EM2820_BOARD_SILVERCREST_WEBCAM:
+                /* FIXME: need to document the registers bellow */
+                em28xx_write_reg(dev, 0x0d, 0x42);
+                em28xx_write_reg(dev, 0x13, 0x08);
         }
 
         if (dev->board.has_snapshot_button)
@@ -2189,6 +2262,10 @@ void em28xx_card_setup(struct em28xx *dev)
                 v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap,
                         "tvp5150", "tvp5150", tvp5150_addrs);
 
+        if (dev->board.decoder == EM28XX_MT9V011)
+                v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap,
+                        "mt9v011", "mt9v011", mt9v011_addrs);
+
         if (dev->board.adecoder == EM28XX_TVAUDIO)
                 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
                         "tvaudio", "tvaudio", dev->board.tvaudio_addr);
@@ -2333,6 +2410,8 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
                 return errCode;
         }
 
+        em28xx_hint_sensor(dev);
+
         /* Do board specific init and eeprom reading */
         em28xx_card_setup(dev);
 
@@ -2573,6 +2652,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
         retval = em28xx_init_dev(&dev, udev, interface, nr);
         if (retval) {
                 em28xx_devused &= ~(1<<dev->devno);
+                mutex_unlock(&dev->lock);
                 kfree(dev);
                 goto err;
         }
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index c8d7ce8fbd36..079ab4d563a6 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -648,17 +648,28 @@ int em28xx_capture_start(struct em28xx *dev, int start)
 int em28xx_set_outfmt(struct em28xx *dev)
 {
         int ret;
+        int vinmode, vinctl, outfmt;
+
+        outfmt  = dev->format->reg;
+
+        if (dev->board.is_27xx) {
+                vinmode = 0x0d;
+                vinctl  = 0x00;
+        } else {
+                vinmode = 0x10;
+                vinctl  = 0x11;
+        }
 
         ret = em28xx_write_reg_bits(dev, EM28XX_R27_OUTFMT,
-                                    dev->format->reg | 0x20, 0x3f);
+                                outfmt | 0x20, 0xff);
         if (ret < 0)
-                return ret;
+                        return ret;
 
-        ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, 0x10);
+        ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, vinmode);
         if (ret < 0)
                 return ret;
 
-        return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, 0x11);
+        return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctl);
 }
 
 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
@@ -695,13 +706,19 @@ static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 {
         u8 mode;
         /* the em2800 scaler only supports scaling down to 50% */
-        if (dev->board.is_em2800)
+
+        if (dev->board.is_27xx) {
+                /* FIXME: Don't use the scaler yet */
+                mode = 0;
+        } else if (dev->board.is_em2800) {
                 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
-        else {
+        } else {
                 u8 buf[2];
+
                 buf[0] = h;
                 buf[1] = h >> 8;
                 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
+
                 buf[0] = v;
                 buf[1] = v >> 8;
                 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
@@ -720,8 +737,11 @@ int em28xx_resolution_set(struct em28xx *dev)
         height = norm_maxh(dev) >> 1;
 
         em28xx_set_outfmt(dev);
+
+
         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
         em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
+
         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 }
 
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
index e7b47c8da8f3..3da97c32b8fa 100644
--- a/drivers/media/video/em28xx/em28xx-dvb.c
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -243,6 +243,14 @@ static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
         .mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
 };
 
+static struct zl10353_config em28xx_terratec_xs_zl10353_xc3028 = {
+        .demod_address = (0x1e >> 1),
+        .no_tuner = 1,
+        .disable_i2c_gate_ctrl = 1,
+        .parallel_ts = 1,
+        .if2 = 45600,
+};
+
 #ifdef EM28XX_DRX397XD_SUPPORT
 /* [TODO] djh - not sure yet what the device config needs to contain */
 static struct drx397xD_config em28xx_drx397xD_with_xc3028 = {
@@ -433,7 +441,6 @@ static int dvb_init(struct em28xx *dev)
                 }
                 break;
         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
-        case EM2880_BOARD_TERRATEC_HYBRID_XS:
         case EM2880_BOARD_KWORLD_DVB_310U:
         case EM2880_BOARD_EMPIRE_DUAL_TV:
                 dvb->frontend = dvb_attach(zl10353_attach,
@@ -444,6 +451,25 @@ static int dvb_init(struct em28xx *dev)
                         goto out_free;
                 }
                 break;
+        case EM2880_BOARD_TERRATEC_HYBRID_XS:
+                dvb->frontend = dvb_attach(zl10353_attach,
+                                           &em28xx_terratec_xs_zl10353_xc3028,
+                                           &dev->i2c_adap);
+                if (dvb->frontend == NULL) {
+                        /* This board could have either a zl10353 or a mt352.
+                           If the chip id isn't for zl10353, try mt352 */
+
+                        /* FIXME: make support for mt352 work */
+                        printk(KERN_ERR "version of this board with mt352 not "
+                               "currently supported\n");
+                        result = -EINVAL;
+                        goto out_free;
+                }
+                if (attach_xc3028(0x61, dev) < 0) {
+                        result = -EINVAL;
+                        goto out_free;
+                }
+                break;
         case EM2883_BOARD_KWORLD_HYBRID_330U:
         case EM2882_BOARD_EVGA_INDTUBE:
                 dvb->frontend = dvb_attach(s5h1409_attach,
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 2c86fcf089f5..27e33a287dfc 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -483,7 +483,7 @@ static char *i2c_devs[128] = {
         [0xa0 >> 1] = "eeprom",
         [0xb0 >> 1] = "tda9874",
         [0xb8 >> 1] = "tvp5150a",
-        [0xba >> 1] = "tvp5150a",
+        [0xba >> 1] = "webcam sensor or tvp5150a",
         [0xc0 >> 1] = "tuner (analog)",
         [0xc2 >> 1] = "tuner (analog)",
         [0xc4 >> 1] = "tuner (analog)",
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 8fe1beecfffa..14316c912179 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -90,10 +90,35 @@ MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
 /* supported video standards */
 static struct em28xx_fmt format[] = {
         {
-                .name     = "16bpp YUY2, 4:2:2, packed",
+                .name     = "16 bpp YUY2, 4:2:2, packed",
                 .fourcc   = V4L2_PIX_FMT_YUYV,
                 .depth    = 16,
                 .reg      = EM28XX_OUTFMT_YUV422_Y0UY1V,
+        }, {
+                .name     = "16 bpp RGB 565, LE",
+                .fourcc   = V4L2_PIX_FMT_RGB565,
+                .depth    = 16,
+                .reg      = EM28XX_OUTFMT_RGB_16_656,
+        }, {
+                .name     = "8 bpp Bayer BGBG..GRGR",
+                .fourcc   = V4L2_PIX_FMT_SBGGR8,
+                .depth    = 8,
+                .reg      = EM28XX_OUTFMT_RGB_8_BGBG,
+        }, {
+                .name     = "8 bpp Bayer GRGR..BGBG",
+                .fourcc   = V4L2_PIX_FMT_SGRBG8,
+                .depth    = 8,
+                .reg      = EM28XX_OUTFMT_RGB_8_GRGR,
+        }, {
+                .name     = "8 bpp Bayer GBGB..RGRG",
+                .fourcc   = V4L2_PIX_FMT_SGBRG8,
+                .depth    = 8,
+                .reg      = EM28XX_OUTFMT_RGB_8_GBGB,
+        }, {
+                .name     = "12 bpp YUV411",
+                .fourcc   = V4L2_PIX_FMT_YUV411P,
+                .depth    = 12,
+                .reg      = EM28XX_OUTFMT_YUV411,
         },
 };
 
@@ -701,7 +726,11 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                 return -EINVAL;
         }
 
-        if (dev->board.is_em2800) {
+        if (dev->board.is_27xx) {
+                /* FIXME: This is the only supported fmt */
+                width  = 640;
+                height = 480;
+        } else if (dev->board.is_em2800) {
                 /* the em2800 can only scale down to 50% */
                 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
                 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
@@ -733,13 +762,40 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         return 0;
 }
 
+static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
+                                   unsigned width, unsigned height)
+{
+        struct em28xx_fmt     *fmt;
+
+        /* FIXME: This is the only supported fmt */
+        if (dev->board.is_27xx) {
+                width  = 640;
+                height = 480;
+        }
+
+        fmt = format_by_fourcc(fourcc);
+        if (!fmt)
+                return -EINVAL;
+
+        dev->format = fmt;
+        dev->width  = width;
+        dev->height = height;
+
+        /* set new image size */
+        get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
+
+        em28xx_set_alternate(dev);
+        em28xx_resolution_set(dev);
+
+        return 0;
+}
+
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                         struct v4l2_format *f)
 {
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
         int                   rc;
-        struct em28xx_fmt     *fmt;
 
         rc = check_dev(dev);
         if (rc < 0)
@@ -749,12 +805,6 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 
         vidioc_try_fmt_vid_cap(file, priv, f);
 
-        fmt = format_by_fourcc(f->fmt.pix.pixelformat);
-        if (!fmt) {
-                rc = -EINVAL;
-                goto out;
-        }
-
         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
                 em28xx_errdev("%s queue busy\n", __func__);
                 rc = -EBUSY;
@@ -767,16 +817,8 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                 goto out;
         }
 
-        /* set new image size */
-        dev->width = f->fmt.pix.width;
-        dev->height = f->fmt.pix.height;
-        dev->format = fmt;
-        get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
-
-        em28xx_set_alternate(dev);
-        em28xx_resolution_set(dev);
-
-        rc = 0;
+        rc = em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
+                                f->fmt.pix.width, f->fmt.pix.height);
 
 out:
         mutex_unlock(&dev->lock);
@@ -1616,11 +1658,6 @@ static int em28xx_v4l2_open(struct file *filp)
         filp->private_data = fh;
 
         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
-                dev->width = norm_maxw(dev);
-                dev->height = norm_maxh(dev);
-                dev->hscale = 0;
-                dev->vscale = 0;
-
                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
                 em28xx_set_alternate(dev);
                 em28xx_resolution_set(dev);
@@ -1962,15 +1999,14 @@ int em28xx_register_analog_devices(struct em28xx *dev)
 
         /* set default norm */
         dev->norm = em28xx_video_template.current_norm;
-        dev->width = norm_maxw(dev);
-        dev->height = norm_maxh(dev);
         dev->interlaced = EM28XX_INTERLACED_DEFAULT;
-        dev->hscale = 0;
-        dev->vscale = 0;
         dev->ctl_input = 0;
 
         /* Analog specific initialization */
         dev->format = &format[0];
+        em28xx_set_video_format(dev, format[0].fourcc,
+                                norm_maxw(dev), norm_maxh(dev));
+
         video_mux(dev, dev->ctl_input);
 
         /* Audio defaults */
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index 813ce45c2f99..d90fef463764 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -107,6 +107,7 @@
 #define EM2860_BOARD_TERRATEC_AV350               68
 #define EM2882_BOARD_KWORLD_ATSC_315U             69
 #define EM2882_BOARD_EVGA_INDTUBE                 70
+#define EM2820_BOARD_SILVERCREST_WEBCAM           71
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
@@ -360,6 +361,7 @@ enum em28xx_decoder {
         EM28XX_NODECODER,
         EM28XX_TVP5150,
         EM28XX_SAA711X,
+        EM28XX_MT9V011,
 };
 
 enum em28xx_adecoder {
@@ -388,6 +390,7 @@ struct em28xx_board {
         unsigned int max_range_640_480:1;
         unsigned int has_dvb:1;
         unsigned int has_snapshot_button:1;
+        unsigned int is_27xx:1;
         unsigned int valid:1;
 
         unsigned char xclk, i2c_speed;
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.h b/drivers/media/video/gspca/stv06xx/stv06xx.h
index 9df7137fe67e..992ce530f138 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.h
@@ -36,10 +36,6 @@
 
 #define STV_ISOC_ENDPOINT_ADDR          0x81
 
-#ifndef V4L2_PIX_FMT_SGRBG8
-#define V4L2_PIX_FMT_SGRBG8 v4l2_fourcc('G', 'R', 'B', 'G')
-#endif
-
 #define STV_REG23                       0x0423
 
 /* Control registers of the STV0600 ASIC */
diff --git a/drivers/media/video/mt9v011.c b/drivers/media/video/mt9v011.c
new file mode 100644
index 000000000000..1fe8fc9183a7
--- /dev/null
+++ b/drivers/media/video/mt9v011.c
@@ -0,0 +1,431 @@
+/*
+ * mt9v011 -Micron 1/4-Inch VGA Digital Image Sensor
+ *
+ * Copyright (c) 2009 Mauro Carvalho Chehab (mchehab@redhat.com)
+ * This code is placed under the terms of the GNU General Public License v2
+ */
+
+#include <linux/i2c.h>
+#include <linux/videodev2.h>
+#include <linux/delay.h>
+#include <media/v4l2-device.h>
+#include "mt9v011.h"
+#include <media/v4l2-i2c-drv.h>
+#include <media/v4l2-chip-ident.h>
+
+MODULE_DESCRIPTION("Micron mt9v011 sensor driver");
+MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
+MODULE_LICENSE("GPL");
+
+
+static int debug;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug level (0-2)");
+
+/* supported controls */
+static struct v4l2_queryctrl mt9v011_qctrl[] = {
+        {
+                .id = V4L2_CID_GAIN,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Gain",
+                .minimum = 0,
+                .maximum = (1 << 10) - 1,
+                .step = 1,
+                .default_value = 0x0020,
+                .flags = 0,
+        }, {
+                .id = V4L2_CID_RED_BALANCE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Red Balance",
+                .minimum = -1 << 9,
+                .maximum = (1 << 9) - 1,
+                .step = 1,
+                .default_value = 0,
+                .flags = 0,
+        }, {
+                .id = V4L2_CID_BLUE_BALANCE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Blue Balance",
+                .minimum = -1 << 9,
+                .maximum = (1 << 9) - 1,
+                .step = 1,
+                .default_value = 0,
+                .flags = 0,
+        },
+};
+
+struct mt9v011 {
+        struct v4l2_subdev sd;
+        unsigned width, height;
+
+        u16 global_gain, red_bal, blue_bal;
+};
+
+static inline struct mt9v011 *to_mt9v011(struct v4l2_subdev *sd)
+{
+        return container_of(sd, struct mt9v011, sd);
+}
+
+static int mt9v011_read(struct v4l2_subdev *sd, unsigned char addr)
+{
+        struct i2c_client *c = v4l2_get_subdevdata(sd);
+        __be16 buffer;
+        int rc, val;
+
+        rc = i2c_master_send(c, &addr, 1);
+        if (rc != 1)
+                v4l2_dbg(0, debug, sd,
+                         "i2c i/o error: rc == %d (should be 1)\n", rc);
+
+        msleep(10);
+
+        rc = i2c_master_recv(c, (char *)&buffer, 2);
+        if (rc != 2)
+                v4l2_dbg(0, debug, sd,
+                         "i2c i/o error: rc == %d (should be 2)\n", rc);
+
+        val = be16_to_cpu(buffer);
+
+        v4l2_dbg(2, debug, sd, "mt9v011: read 0x%02x = 0x%04x\n", addr, val);
+
+        return val;
+}
+
+static void mt9v011_write(struct v4l2_subdev *sd, unsigned char addr,
+                                 u16 value)
+{
+        struct i2c_client *c = v4l2_get_subdevdata(sd);
+        unsigned char buffer[3];
+        int rc;
+
+        buffer[0] = addr;
+        buffer[1] = value >> 8;
+        buffer[2] = value & 0xff;
+
+        v4l2_dbg(2, debug, sd,
+                 "mt9v011: writing 0x%02x 0x%04x\n", buffer[0], value);
+        rc = i2c_master_send(c, buffer, 3);
+        if (rc != 3)
+                v4l2_dbg(0, debug, sd,
+                         "i2c i/o error: rc == %d (should be 3)\n", rc);
+}
+
+
+struct i2c_reg_value {
+        unsigned char reg;
+        u16           value;
+};
+
+/*
+ * Values used at the original driver
+ * Some values are marked as Reserved at the datasheet
+ */
+static const struct i2c_reg_value mt9v011_init_default[] = {
+                { R0D_MT9V011_RESET, 0x0001 },
+                { R0D_MT9V011_RESET, 0x0000 },
+
+                { R0C_MT9V011_SHUTTER_DELAY, 0x0000 },
+                { R09_MT9V011_SHUTTER_WIDTH, 0x1fc },
+
+                { R0A_MT9V011_CLK_SPEED, 0x0000 },
+                { R1E_MT9V011_DIGITAL_ZOOM,  0x0000 },
+                { R20_MT9V011_READ_MODE, 0x1000 },
+
+                { R07_MT9V011_OUT_CTRL, 0x000a },       /* chip enable */
+};
+
+static void set_balance(struct v4l2_subdev *sd)
+{
+        struct mt9v011 *core = to_mt9v011(sd);
+        u16 green1_gain, green2_gain, blue_gain, red_gain;
+
+        green1_gain = core->global_gain;
+        green2_gain = core->global_gain;
+
+        blue_gain = core->global_gain +
+                    core->global_gain * core->blue_bal / (1 << 9);
+
+        red_gain = core->global_gain +
+                   core->global_gain * core->blue_bal / (1 << 9);
+
+        mt9v011_write(sd, R2B_MT9V011_GREEN_1_GAIN, green1_gain);
+        mt9v011_write(sd, R2E_MT9V011_GREEN_2_GAIN,  green1_gain);
+        mt9v011_write(sd, R2C_MT9V011_BLUE_GAIN, blue_gain);
+        mt9v011_write(sd, R2D_MT9V011_RED_GAIN, red_gain);
+}
+
+static void set_res(struct v4l2_subdev *sd)
+{
+        struct mt9v011 *core = to_mt9v011(sd);
+        unsigned vstart, hstart;
+
+        /*
+         * The mt9v011 doesn't have scaling. So, in order to select the desired
+         * resolution, we're cropping at the middle of the sensor.
+         * hblank and vblank should be adjusted, in order to warrant that
+         * we'll preserve the line timings for 30 fps, no matter what resolution
+         * is selected.
+         * NOTE: datasheet says that width (and height) should be filled with
+         * width-1. However, this doesn't work, since one pixel per line will
+         * be missing.
+         */
+
+        hstart = 14 + (640 - core->width) / 2;
+        mt9v011_write(sd, R02_MT9V011_COLSTART, hstart);
+        mt9v011_write(sd, R04_MT9V011_WIDTH, core->width);
+        mt9v011_write(sd, R05_MT9V011_HBLANK, 771 - core->width);
+
+        vstart = 8 + (640 - core->height) / 2;
+        mt9v011_write(sd, R01_MT9V011_ROWSTART, vstart);
+        mt9v011_write(sd, R03_MT9V011_HEIGHT, core->height);
+        mt9v011_write(sd, R06_MT9V011_VBLANK, 508 - core->height);
+};
+
+static int mt9v011_reset(struct v4l2_subdev *sd, u32 val)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(mt9v011_init_default); i++)
+                mt9v011_write(sd, mt9v011_init_default[i].reg,
+                               mt9v011_init_default[i].value);
+
+        set_balance(sd);
+        set_res(sd);
+
+        return 0;
+};
+
+static int mt9v011_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+        struct mt9v011 *core = to_mt9v011(sd);
+
+        v4l2_dbg(1, debug, sd, "g_ctrl called\n");
+
+        switch (ctrl->id) {
+        case V4L2_CID_GAIN:
+                ctrl->value = core->global_gain;
+                return 0;
+        case V4L2_CID_RED_BALANCE:
+                ctrl->value = core->red_bal;
+                return 0;
+        case V4L2_CID_BLUE_BALANCE:
+                ctrl->value = core->blue_bal;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int mt9v011_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+        struct mt9v011 *core = to_mt9v011(sd);
+        u8 i, n;
+        n = ARRAY_SIZE(mt9v011_qctrl);
+
+        for (i = 0; i < n; i++) {
+                if (ctrl->id != mt9v011_qctrl[i].id)
+                        continue;
+                if (ctrl->value < mt9v011_qctrl[i].minimum ||
+                    ctrl->value > mt9v011_qctrl[i].maximum)
+                        return -ERANGE;
+                v4l2_dbg(1, debug, sd, "s_ctrl: id=%d, value=%d\n",
+                                        ctrl->id, ctrl->value);
+                break;
+        }
+
+        switch (ctrl->id) {
+        case V4L2_CID_GAIN:
+                core->global_gain = ctrl->value;
+                break;
+        case V4L2_CID_RED_BALANCE:
+                core->red_bal = ctrl->value;
+                break;
+        case V4L2_CID_BLUE_BALANCE:
+                core->blue_bal = ctrl->value;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        set_balance(sd);
+
+        return 0;
+}
+
+static int mt9v011_enum_fmt(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmt)
+{
+        if (fmt->index > 0)
+                return -EINVAL;
+
+        fmt->flags = 0;
+        strcpy(fmt->description, "8 bpp Bayer GRGR..BGBG");
+        fmt->pixelformat = V4L2_PIX_FMT_SGRBG8;
+
+        return 0;
+}
+
+static int mt9v011_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
+{
+        struct v4l2_pix_format *pix = &fmt->fmt.pix;
+
+        if (pix->pixelformat != V4L2_PIX_FMT_SGRBG8)
+                return -EINVAL;
+
+        v4l_bound_align_image(&pix->width, 48, 639, 1,
+                              &pix->height, 32, 480, 1, 0);
+
+        return 0;
+}
+
+static int mt9v011_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
+{
+        struct v4l2_pix_format *pix = &fmt->fmt.pix;
+        struct mt9v011 *core = to_mt9v011(sd);
+        int rc;
+
+        rc = mt9v011_try_fmt(sd, fmt);
+        if (rc < 0)
+                return -EINVAL;
+
+        core->width = pix->width;
+        core->height = pix->height;
+
+        set_res(sd);
+
+        return 0;
+}
+
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int mt9v011_g_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
+                return -EINVAL;
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        reg->val = mt9v011_read(sd, reg->reg & 0xff);
+        reg->size = 2;
+
+        return 0;
+}
+
+static int mt9v011_s_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        if (!v4l2_chip_match_i2c_client(client, &reg->match))
+                return -EINVAL;
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        mt9v011_write(sd, reg->reg & 0xff, reg->val & 0xffff);
+
+        return 0;
+}
+#endif
+
+static int mt9v011_g_chip_ident(struct v4l2_subdev *sd,
+                                struct v4l2_dbg_chip_ident *chip)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_MT9V011,
+                                          MT9V011_VERSION);
+}
+
+static const struct v4l2_subdev_core_ops mt9v011_core_ops = {
+        .g_ctrl = mt9v011_g_ctrl,
+        .s_ctrl = mt9v011_s_ctrl,
+        .reset = mt9v011_reset,
+        .g_chip_ident = mt9v011_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register = mt9v011_g_register,
+        .s_register = mt9v011_s_register,
+#endif
+};
+
+static const struct v4l2_subdev_video_ops mt9v011_video_ops = {
+        .enum_fmt = mt9v011_enum_fmt,
+        .try_fmt = mt9v011_try_fmt,
+        .s_fmt = mt9v011_s_fmt,
+};
+
+static const struct v4l2_subdev_ops mt9v011_ops = {
+        .core  = &mt9v011_core_ops,
+        .video = &mt9v011_video_ops,
+};
+
+
+/****************************************************************************
+                        I2C Client & Driver
+ ****************************************************************************/
+
+static int mt9v011_probe(struct i2c_client *c,
+                         const struct i2c_device_id *id)
+{
+        u16 version;
+        struct mt9v011 *core;
+        struct v4l2_subdev *sd;
+
+        /* Check if the adapter supports the needed features */
+        if (!i2c_check_functionality(c->adapter,
+             I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
+                return -EIO;
+
+        core = kzalloc(sizeof(struct mt9v011), GFP_KERNEL);
+        if (!core)
+                return -ENOMEM;
+
+        sd = &core->sd;
+        v4l2_i2c_subdev_init(sd, c, &mt9v011_ops);
+
+        /* Check if the sensor is really a MT9V011 */
+        version = mt9v011_read(sd, R00_MT9V011_CHIP_VERSION);
+        if (version != MT9V011_VERSION) {
+                v4l2_info(sd, "*** unknown micron chip detected (0x%04x.\n",
+                          version);
+                kfree(core);
+                return -EINVAL;
+        }
+
+        core->global_gain = 0x0024;
+        core->width  = 640;
+        core->height = 480;
+
+        v4l_info(c, "chip found @ 0x%02x (%s)\n",
+                 c->addr << 1, c->adapter->name);
+
+        return 0;
+}
+
+static int mt9v011_remove(struct i2c_client *c)
+{
+        struct v4l2_subdev *sd = i2c_get_clientdata(c);
+
+        v4l2_dbg(1, debug, sd,
+                "mt9v011.c: removing mt9v011 adapter on address 0x%x\n",
+                c->addr << 1);
+
+        v4l2_device_unregister_subdev(sd);
+        kfree(to_mt9v011(sd));
+        return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+static const struct i2c_device_id mt9v011_id[] = {
+        { "mt9v011", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, mt9v011_id);
+
+static struct v4l2_i2c_driver_data v4l2_i2c_data = {
+        .name = "mt9v011",
+        .probe = mt9v011_probe,
+        .remove = mt9v011_remove,
+        .id_table = mt9v011_id,
+};
diff --git a/drivers/media/video/mt9v011.h b/drivers/media/video/mt9v011.h
new file mode 100644
index 000000000000..9e443ee30558
--- /dev/null
+++ b/drivers/media/video/mt9v011.h
@@ -0,0 +1,35 @@
+/*
+ * mt9v011 -Micron 1/4-Inch VGA Digital Image Sensor
+ *
+ * Copyright (c) 2009 Mauro Carvalho Chehab (mchehab@redhat.com)
+ * This code is placed under the terms of the GNU General Public License v2
+ */
+
+#ifndef MT9V011_H_
+#define MT9V011_H_
+
+#define R00_MT9V011_CHIP_VERSION        0x00
+#define R01_MT9V011_ROWSTART            0x01
+#define R02_MT9V011_COLSTART            0x02
+#define R03_MT9V011_HEIGHT              0x03
+#define R04_MT9V011_WIDTH               0x04
+#define R05_MT9V011_HBLANK              0x05
+#define R06_MT9V011_VBLANK              0x06
+#define R07_MT9V011_OUT_CTRL            0x07
+#define R09_MT9V011_SHUTTER_WIDTH       0x09
+#define R0A_MT9V011_CLK_SPEED           0x0a
+#define R0B_MT9V011_RESTART             0x0b
+#define R0C_MT9V011_SHUTTER_DELAY       0x0c
+#define R0D_MT9V011_RESET               0x0d
+#define R1E_MT9V011_DIGITAL_ZOOM        0x1e
+#define R20_MT9V011_READ_MODE           0x20
+#define R2B_MT9V011_GREEN_1_GAIN        0x2b
+#define R2C_MT9V011_BLUE_GAIN           0x2c
+#define R2D_MT9V011_RED_GAIN            0x2d
+#define R2E_MT9V011_GREEN_2_GAIN        0x2e
+#define R35_MT9V011_GLOBAL_GAIN         0x35
+#define RF1_MT9V011_CHIP_ENABLE         0xf1
+
+#define MT9V011_VERSION                 0x8243
+
+#endif
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 16f595d4337a..9f5ae8167855 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -237,11 +237,11 @@ static int soc_camera_init_user_formats(struct soc_camera_device *icd)
                 return -ENOMEM;
 
         icd->num_user_formats = fmts;
-        fmts = 0;
 
         dev_dbg(&icd->dev, "Found %d supported formats.\n", fmts);
 
         /* Second pass - actually fill data formats */
+        fmts = 0;
         for (i = 0; i < icd->num_formats; i++)
                 if (!ici->ops->get_formats) {
                         icd->user_formats[i].host_fmt = icd->formats + i;
@@ -877,8 +877,11 @@ static int soc_camera_probe(struct device *dev)
                         (unsigned short)~0;
 
                 ret = soc_camera_init_user_formats(icd);
-                if (ret < 0)
+                if (ret < 0) {
+                        if (icd->ops->remove)
+                                icd->ops->remove(icd);
                         goto eiufmt;
+                }
 
                 icd->height     = DEFAULT_HEIGHT;
                 icd->width      = DEFAULT_WIDTH;
@@ -902,8 +905,10 @@ static int soc_camera_remove(struct device *dev)
 {
         struct soc_camera_device *icd = to_soc_camera_dev(dev);
 
+        mutex_lock(&icd->video_lock);
         if (icd->ops->remove)
                 icd->ops->remove(icd);
+        mutex_unlock(&icd->video_lock);
 
         soc_camera_free_user_formats(icd);
 
@@ -1145,6 +1150,7 @@ evidallocd:
 }
 EXPORT_SYMBOL(soc_camera_video_start);
 
+/* Called from client .remove() methods with .video_lock held */
 void soc_camera_video_stop(struct soc_camera_device *icd)
 {
         struct video_device *vdev = icd->vdev;
@@ -1154,10 +1160,8 @@ void soc_camera_video_stop(struct soc_camera_device *icd)
         if (!icd->dev.parent || !vdev)
                 return;
 
-        mutex_lock(&icd->video_lock);
         video_unregister_device(vdev);
         icd->vdev = NULL;
-        mutex_unlock(&icd->video_lock);
 }
 EXPORT_SYMBOL(soc_camera_video_stop);
 
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index cd7266858462..7705fc6baf00 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -343,6 +343,53 @@ static struct bar_std bars[] = {
 #define TO_U(r, g, b) \
         (((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
 
+/* precalculate color bar values to speed up rendering */
+static void precalculate_bars(struct vivi_fh *fh)
+{
+        struct vivi_dev *dev = fh->dev;
+        unsigned char r, g, b;
+        int k, is_yuv;
+
+        fh->input = dev->input;
+
+        for (k = 0; k < 8; k++) {
+                r = bars[fh->input].bar[k][0];
+                g = bars[fh->input].bar[k][1];
+                b = bars[fh->input].bar[k][2];
+                is_yuv = 0;
+
+                switch (fh->fmt->fourcc) {
+                case V4L2_PIX_FMT_YUYV:
+                case V4L2_PIX_FMT_UYVY:
+                        is_yuv = 1;
+                        break;
+                case V4L2_PIX_FMT_RGB565:
+                case V4L2_PIX_FMT_RGB565X:
+                        r >>= 3;
+                        g >>= 2;
+                        b >>= 3;
+                        break;
+                case V4L2_PIX_FMT_RGB555:
+                case V4L2_PIX_FMT_RGB555X:
+                        r >>= 3;
+                        g >>= 3;
+                        b >>= 3;
+                        break;
+                }
+
+                if (is_yuv) {
+                        fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
+                        fh->bars[k][1] = TO_U(r, g, b); /* Cb */
+                        fh->bars[k][2] = TO_V(r, g, b); /* Cr */
+                } else {
+                        fh->bars[k][0] = r;
+                        fh->bars[k][1] = g;
+                        fh->bars[k][2] = b;
+                }
+        }
+
+}
+
 #define TSTAMP_MIN_Y    24
 #define TSTAMP_MAX_Y    (TSTAMP_MIN_Y + 15)
 #define TSTAMP_INPUT_X  10
@@ -755,6 +802,8 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
         buf->vb.height = fh->height;
         buf->vb.field  = field;
 
+        precalculate_bars(fh);
+
         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
                 rc = videobuf_iolock(vq, &buf->vb, NULL);
                 if (rc < 0)
@@ -893,53 +942,6 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         return 0;
 }
 
-/* precalculate color bar values to speed up rendering */
-static void precalculate_bars(struct vivi_fh *fh)
-{
-        struct vivi_dev *dev = fh->dev;
-        unsigned char r, g, b;
-        int k, is_yuv;
-
-        fh->input = dev->input;
-
-        for (k = 0; k < 8; k++) {
-                r = bars[fh->input].bar[k][0];
-                g = bars[fh->input].bar[k][1];
-                b = bars[fh->input].bar[k][2];
-                is_yuv = 0;
-
-                switch (fh->fmt->fourcc) {
-                case V4L2_PIX_FMT_YUYV:
-                case V4L2_PIX_FMT_UYVY:
-                        is_yuv = 1;
-                        break;
-                case V4L2_PIX_FMT_RGB565:
-                case V4L2_PIX_FMT_RGB565X:
-                        r >>= 3;
-                        g >>= 2;
-                        b >>= 3;
-                        break;
-                case V4L2_PIX_FMT_RGB555:
-                case V4L2_PIX_FMT_RGB555X:
-                        r >>= 3;
-                        g >>= 3;
-                        b >>= 3;
-                        break;
-                }
-
-                if (is_yuv) {
-                        fh->bars[k][0] = TO_Y(r, g, b); /* Luma */
-                        fh->bars[k][1] = TO_U(r, g, b); /* Cb */
-                        fh->bars[k][2] = TO_V(r, g, b); /* Cr */
-                } else {
-                        fh->bars[k][0] = r;
-                        fh->bars[k][1] = g;
-                        fh->bars[k][2] = b;
-                }
-        }
-
-}
-
 /*FIXME: This seems to be generic enough to be at videodev2 */
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                                         struct v4l2_format *f)
@@ -965,8 +967,6 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
         fh->vb_vidq.field = f->fmt.pix.field;
         fh->type          = f->type;
 
-        precalculate_bars(fh);
-
         ret = 0;
 out:
         mutex_unlock(&q->vb_lock);
@@ -1357,6 +1357,7 @@ static int __init vivi_create_instance(int inst)
                 goto unreg_dev;
 
         *vfd = vivi_template;
+        vfd->debug = debug;
 
         ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
         if (ret < 0)
diff --git a/drivers/mfd/dm355evm_msp.c b/drivers/mfd/dm355evm_msp.c
index 7ac12cb0be4a..5b6e58a3ba46 100644
--- a/drivers/mfd/dm355evm_msp.c
+++ b/drivers/mfd/dm355evm_msp.c
@@ -32,8 +32,7 @@
  * This driver was tested with firmware revision A4.
  */
 
-#if defined(CONFIG_KEYBOARD_DM355EVM) \
-                || defined(CONFIG_KEYBOARD_DM355EVM_MODULE)
+#if defined(CONFIG_INPUT_DM355EVM) || defined(CONFIG_INPUT_DM355EVM_MODULE)
 #define msp_has_keyboard()      true
 #else
 #define msp_has_keyboard()      false
diff --git a/drivers/mfd/ezx-pcap.c b/drivers/mfd/ezx-pcap.c
index 671a7efe86a8..c1de4afa89a6 100644
--- a/drivers/mfd/ezx-pcap.c
+++ b/drivers/mfd/ezx-pcap.c
@@ -238,8 +238,10 @@ static irqreturn_t pcap_adc_irq(int irq, void *_pcap)
         mutex_lock(&pcap->adc_mutex);
         req = pcap->adc_queue[pcap->adc_head];
 
-        if (WARN(!req, KERN_WARNING "adc irq without pending request\n"))
+        if (WARN(!req, KERN_WARNING "adc irq without pending request\n")) {
+                mutex_unlock(&pcap->adc_mutex);
                 return IRQ_HANDLED;
+        }
 
         /* read requested channels results */
         ezx_pcap_read(pcap, PCAP_REG_ADC, &tmp);
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index 4c7b7962f6b8..0cc5eeff5ee8 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -367,7 +367,8 @@ int sm501_unit_power(struct device *dev, unsigned int unit, unsigned int to)
                 break;
 
         default:
-                return -1;
+                gate = -1;
+                goto already;
         }
 
         writel(mode, sm->regs + SM501_POWER_MODE_CONTROL);
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 68ab39d7cb35..df1f86b5c83e 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -233,6 +233,19 @@ config ISL29003
           This driver can also be built as a module.  If so, the module
           will be called isl29003.
 
+config EP93XX_PWM
+        tristate "EP93xx PWM support"
+        depends on ARCH_EP93XX
+        help
+          This option enables device driver support for the PWM channels
+          on the Cirrus EP93xx processors.  The EP9307 chip only has one
+          PWM channel all the others have two, the second channel is an
+          alternate function of the EGPIO14 pin.  A sysfs interface is
+          provided to control the PWM channels.
+
+          To compile this driver as a module, choose M here: the module will
+          be called ep93xx_pwm.
+
 source "drivers/misc/c2port/Kconfig"
 source "drivers/misc/eeprom/Kconfig"
 source "drivers/misc/cb710/Kconfig"
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 36f733cd60e6..f982d2ecfde7 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -19,6 +19,7 @@ obj-$(CONFIG_SGI_XP)		+= sgi-xp/
 obj-$(CONFIG_SGI_GRU)           += sgi-gru/
 obj-$(CONFIG_HP_ILO)            += hpilo.o
 obj-$(CONFIG_ISL29003)          += isl29003.o
+obj-$(CONFIG_EP93XX_PWM)        += ep93xx_pwm.o
 obj-$(CONFIG_C2PORT)            += c2port/
 obj-y                           += eeprom/
 obj-y                           += cb710/
diff --git a/drivers/misc/ep93xx_pwm.c b/drivers/misc/ep93xx_pwm.c
new file mode 100644
index 000000000000..ba4694169d79
--- /dev/null
+++ b/drivers/misc/ep93xx_pwm.c
@@ -0,0 +1,384 @@
+/*
+ *  Simple PWM driver for EP93XX
+ *
+ *      (c) Copyright 2009  Matthieu Crapet <mcrapet@gmail.com>
+ *      (c) Copyright 2009  H Hartley Sweeten <hsweeten@visionengravers.com>
+ *
+ *      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.
+ *
+ *  EP9307 has only one channel:
+ *    - PWMOUT
+ *
+ *  EP9301/02/12/15 have two channels:
+ *    - PWMOUT
+ *    - PWMOUT1 (alternate function for EGPIO14)
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <mach/platform.h>
+
+#define EP93XX_PWMx_TERM_COUNT  0x00
+#define EP93XX_PWMx_DUTY_CYCLE  0x04
+#define EP93XX_PWMx_ENABLE      0x08
+#define EP93XX_PWMx_INVERT      0x0C
+
+#define EP93XX_PWM_MAX_COUNT    0xFFFF
+
+struct ep93xx_pwm {
+        void __iomem    *mmio_base;
+        struct clk      *clk;
+        u32             duty_percent;
+};
+
+static inline void ep93xx_pwm_writel(struct ep93xx_pwm *pwm,
+                unsigned int val, unsigned int off)
+{
+        __raw_writel(val, pwm->mmio_base + off);
+}
+
+static inline unsigned int ep93xx_pwm_readl(struct ep93xx_pwm *pwm,
+                unsigned int off)
+{
+        return __raw_readl(pwm->mmio_base + off);
+}
+
+static inline void ep93xx_pwm_write_tc(struct ep93xx_pwm *pwm, u16 value)
+{
+        ep93xx_pwm_writel(pwm, value, EP93XX_PWMx_TERM_COUNT);
+}
+
+static inline u16 ep93xx_pwm_read_tc(struct ep93xx_pwm *pwm)
+{
+        return ep93xx_pwm_readl(pwm, EP93XX_PWMx_TERM_COUNT);
+}
+
+static inline void ep93xx_pwm_write_dc(struct ep93xx_pwm *pwm, u16 value)
+{
+        ep93xx_pwm_writel(pwm, value, EP93XX_PWMx_DUTY_CYCLE);
+}
+
+static inline void ep93xx_pwm_enable(struct ep93xx_pwm *pwm)
+{
+        ep93xx_pwm_writel(pwm, 0x1, EP93XX_PWMx_ENABLE);
+}
+
+static inline void ep93xx_pwm_disable(struct ep93xx_pwm *pwm)
+{
+        ep93xx_pwm_writel(pwm, 0x0, EP93XX_PWMx_ENABLE);
+}
+
+static inline int ep93xx_pwm_is_enabled(struct ep93xx_pwm *pwm)
+{
+        return ep93xx_pwm_readl(pwm, EP93XX_PWMx_ENABLE) & 0x1;
+}
+
+static inline void ep93xx_pwm_invert(struct ep93xx_pwm *pwm)
+{
+        ep93xx_pwm_writel(pwm, 0x1, EP93XX_PWMx_INVERT);
+}
+
+static inline void ep93xx_pwm_normal(struct ep93xx_pwm *pwm)
+{
+        ep93xx_pwm_writel(pwm, 0x0, EP93XX_PWMx_INVERT);
+}
+
+static inline int ep93xx_pwm_is_inverted(struct ep93xx_pwm *pwm)
+{
+        return ep93xx_pwm_readl(pwm, EP93XX_PWMx_INVERT) & 0x1;
+}
+
+/*
+ * /sys/devices/platform/ep93xx-pwm.N
+ *   /min_freq      read-only   minimum pwm output frequency
+ *   /max_req       read-only   maximum pwm output frequency
+ *   /freq          read-write  pwm output frequency (0 = disable output)
+ *   /duty_percent  read-write  pwm duty cycle percent (1..99)
+ *   /invert        read-write  invert pwm output
+ */
+
+static ssize_t ep93xx_pwm_get_min_freq(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+        unsigned long rate = clk_get_rate(pwm->clk);
+
+        return sprintf(buf, "%ld\n", rate / (EP93XX_PWM_MAX_COUNT + 1));
+}
+
+static ssize_t ep93xx_pwm_get_max_freq(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+        unsigned long rate = clk_get_rate(pwm->clk);
+
+        return sprintf(buf, "%ld\n", rate / 2);
+}
+
+static ssize_t ep93xx_pwm_get_freq(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+
+        if (ep93xx_pwm_is_enabled(pwm)) {
+                unsigned long rate = clk_get_rate(pwm->clk);
+                u16 term = ep93xx_pwm_read_tc(pwm);
+
+                return sprintf(buf, "%ld\n", rate / (term + 1));
+        } else {
+                return sprintf(buf, "disabled\n");
+        }
+}
+
+static ssize_t ep93xx_pwm_set_freq(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+        long val;
+        int err;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return -EINVAL;
+
+        if (val == 0) {
+                ep93xx_pwm_disable(pwm);
+        } else if (val <= (clk_get_rate(pwm->clk) / 2)) {
+                u32 term, duty;
+
+                val = (clk_get_rate(pwm->clk) / val) - 1;
+                if (val > EP93XX_PWM_MAX_COUNT)
+                        val = EP93XX_PWM_MAX_COUNT;
+                if (val < 1)
+                        val = 1;
+
+                term = ep93xx_pwm_read_tc(pwm);
+                duty = ((val + 1) * pwm->duty_percent / 100) - 1;
+
+                /* If pwm is running, order is important */
+                if (val > term) {
+                        ep93xx_pwm_write_tc(pwm, val);
+                        ep93xx_pwm_write_dc(pwm, duty);
+                } else {
+                        ep93xx_pwm_write_dc(pwm, duty);
+                        ep93xx_pwm_write_tc(pwm, val);
+                }
+
+                if (!ep93xx_pwm_is_enabled(pwm))
+                        ep93xx_pwm_enable(pwm);
+        } else {
+                return -EINVAL;
+        }
+
+        return count;
+}
+
+static ssize_t ep93xx_pwm_get_duty_percent(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+
+        return sprintf(buf, "%d\n", pwm->duty_percent);
+}
+
+static ssize_t ep93xx_pwm_set_duty_percent(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+        long val;
+        int err;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return -EINVAL;
+
+        if (val > 0 && val < 100) {
+                u32 term = ep93xx_pwm_read_tc(pwm);
+                ep93xx_pwm_write_dc(pwm, ((term + 1) * val / 100) - 1);
+                pwm->duty_percent = val;
+                return count;
+        }
+
+        return -EINVAL;
+}
+
+static ssize_t ep93xx_pwm_get_invert(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+
+        return sprintf(buf, "%d\n", ep93xx_pwm_is_inverted(pwm));
+}
+
+static ssize_t ep93xx_pwm_set_invert(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+        long val;
+        int err;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return -EINVAL;
+
+        if (val == 0)
+                ep93xx_pwm_normal(pwm);
+        else if (val == 1)
+                ep93xx_pwm_invert(pwm);
+        else
+                return -EINVAL;
+
+        return count;
+}
+
+static DEVICE_ATTR(min_freq, S_IRUGO, ep93xx_pwm_get_min_freq, NULL);
+static DEVICE_ATTR(max_freq, S_IRUGO, ep93xx_pwm_get_max_freq, NULL);
+static DEVICE_ATTR(freq, S_IWUGO | S_IRUGO,
+                   ep93xx_pwm_get_freq, ep93xx_pwm_set_freq);
+static DEVICE_ATTR(duty_percent, S_IWUGO | S_IRUGO,
+                   ep93xx_pwm_get_duty_percent, ep93xx_pwm_set_duty_percent);
+static DEVICE_ATTR(invert, S_IWUGO | S_IRUGO,
+                   ep93xx_pwm_get_invert, ep93xx_pwm_set_invert);
+
+static struct attribute *ep93xx_pwm_attrs[] = {
+        &dev_attr_min_freq.attr,
+        &dev_attr_max_freq.attr,
+        &dev_attr_freq.attr,
+        &dev_attr_duty_percent.attr,
+        &dev_attr_invert.attr,
+        NULL
+};
+
+static const struct attribute_group ep93xx_pwm_sysfs_files = {
+        .attrs  = ep93xx_pwm_attrs,
+};
+
+static int __init ep93xx_pwm_probe(struct platform_device *pdev)
+{
+        struct ep93xx_pwm *pwm;
+        struct resource *res;
+        int err;
+
+        err = ep93xx_pwm_acquire_gpio(pdev);
+        if (err)
+                return err;
+
+        pwm = kzalloc(sizeof(struct ep93xx_pwm), GFP_KERNEL);
+        if (!pwm) {
+                err = -ENOMEM;
+                goto fail_no_mem;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                err = -ENXIO;
+                goto fail_no_mem_resource;
+        }
+
+        res = request_mem_region(res->start, resource_size(res), pdev->name);
+        if (res == NULL) {
+                err = -EBUSY;
+                goto fail_no_mem_resource;
+        }
+
+        pwm->mmio_base = ioremap(res->start, resource_size(res));
+        if (pwm->mmio_base == NULL) {
+                err = -ENXIO;
+                goto fail_no_ioremap;
+        }
+
+        err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
+        if (err)
+                goto fail_no_sysfs;
+
+        pwm->clk = clk_get(&pdev->dev, "pwm_clk");
+        if (IS_ERR(pwm->clk)) {
+                err = PTR_ERR(pwm->clk);
+                goto fail_no_clk;
+        }
+
+        pwm->duty_percent = 50;
+
+        platform_set_drvdata(pdev, pwm);
+
+        /* disable pwm at startup. Avoids zero value. */
+        ep93xx_pwm_disable(pwm);
+        ep93xx_pwm_write_tc(pwm, EP93XX_PWM_MAX_COUNT);
+        ep93xx_pwm_write_dc(pwm, EP93XX_PWM_MAX_COUNT / 2);
+
+        clk_enable(pwm->clk);
+
+        return 0;
+
+fail_no_clk:
+        sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
+fail_no_sysfs:
+        iounmap(pwm->mmio_base);
+fail_no_ioremap:
+        release_mem_region(res->start, resource_size(res));
+fail_no_mem_resource:
+        kfree(pwm);
+fail_no_mem:
+        ep93xx_pwm_release_gpio(pdev);
+        return err;
+}
+
+static int __exit ep93xx_pwm_remove(struct platform_device *pdev)
+{
+        struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        ep93xx_pwm_disable(pwm);
+        clk_disable(pwm->clk);
+        clk_put(pwm->clk);
+        platform_set_drvdata(pdev, NULL);
+        sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
+        iounmap(pwm->mmio_base);
+        release_mem_region(res->start, resource_size(res));
+        kfree(pwm);
+        ep93xx_pwm_release_gpio(pdev);
+
+        return 0;
+}
+
+static struct platform_driver ep93xx_pwm_driver = {
+        .driver         = {
+                .name   = "ep93xx-pwm",
+                .owner  = THIS_MODULE,
+        },
+        .remove         = __exit_p(ep93xx_pwm_remove),
+};
+
+static int __init ep93xx_pwm_init(void)
+{
+        return platform_driver_probe(&ep93xx_pwm_driver, ep93xx_pwm_probe);
+}
+
+static void __exit ep93xx_pwm_exit(void)
+{
+        platform_driver_unregister(&ep93xx_pwm_driver);
+}
+
+module_init(ep93xx_pwm_init);
+module_exit(ep93xx_pwm_exit);
+
+MODULE_AUTHOR("Matthieu Crapet <mcrapet@gmail.com>, "
+              "H Hartley Sweeten <hsweeten@visionengravers.com>");
+MODULE_DESCRIPTION("EP93xx PWM driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ep93xx-pwm");
diff --git a/drivers/misc/sgi-xp/xpnet.c b/drivers/misc/sgi-xp/xpnet.c
index 8d1c60a3f0df..5d778ec8cdb2 100644
--- a/drivers/misc/sgi-xp/xpnet.c
+++ b/drivers/misc/sgi-xp/xpnet.c
@@ -235,7 +235,7 @@ xpnet_receive(short partid, int channel, struct xpnet_message *msg)
         skb->ip_summed = CHECKSUM_UNNECESSARY;
 
         dev_dbg(xpnet, "passing skb to network layer\n"
-                KERN_DEBUG "\tskb->head=0x%p skb->data=0x%p skb->tail=0x%p "
+                "\tskb->head=0x%p skb->data=0x%p skb->tail=0x%p "
                 "skb->end=0x%p skb->len=%d\n",
                 (void *)skb->head, (void *)skb->data, skb_tail_pointer(skb),
                 skb_end_pointer(skb), skb->len);
@@ -399,7 +399,7 @@ xpnet_send(struct sk_buff *skb, struct xpnet_pending_msg *queued_msg,
         msg->buf_pa = xp_pa((void *)start_addr);
 
         dev_dbg(xpnet, "sending XPC message to %d:%d\n"
-                KERN_DEBUG "msg->buf_pa=0x%lx, msg->size=%u, "
+                "msg->buf_pa=0x%lx, msg->size=%u, "
                 "msg->leadin_ignore=%u, msg->tailout_ignore=%u\n",
                 dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size,
                 msg->leadin_ignore, msg->tailout_ignore);
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 240608cc7ae9..a461017ce5ce 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -1313,6 +1313,12 @@ static int mmc_spi_probe(struct spi_device *spi)
         struct mmc_spi_host     *host;
         int                     status;
 
+        /* We rely on full duplex transfers, mostly to reduce
+         * per-transfer overheads (by making fewer transfers).
+         */
+        if (spi->master->flags & SPI_MASTER_HALF_DUPLEX)
+                return -EINVAL;
+
         /* MMC and SD specs only seem to care that sampling is on the
          * rising edge ... meaning SPI modes 0 or 3.  So either SPI mode
          * should be legit.  We'll use mode 0 since the steady state is 0,
diff --git a/drivers/mtd/cmdlinepart.c b/drivers/mtd/cmdlinepart.c
index 5011fa73f918..1479da6d3aa6 100644
--- a/drivers/mtd/cmdlinepart.c
+++ b/drivers/mtd/cmdlinepart.c
@@ -194,7 +194,7 @@ static struct mtd_partition * newpart(char *s,
         parts[this_part].name = extra_mem;
         extra_mem += name_len + 1;
 
-        dbg(("partition %d: name <%s>, offset %x, size %x, mask flags %x\n",
+        dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n",
              this_part,
              parts[this_part].name,
              parts[this_part].offset,
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index 59c46126a5ce..ae5fe91867e1 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -54,7 +54,7 @@
 #define SR_SRWD                 0x80    /* SR write protect */
 
 /* Define max times to check status register before we give up. */
-#define MAX_READY_WAIT_JIFFIES  (10 * HZ)       /* eg. M25P128 specs 6s max sector erase */
+#define MAX_READY_WAIT_JIFFIES  (40 * HZ)       /* M25P16 specs 40s max chip erase */
 #define CMD_SIZE                4
 
 #ifdef CONFIG_M25PXX_USE_FAST_READ
diff --git a/drivers/mtd/inftlcore.c b/drivers/mtd/inftlcore.c
index 73f05227dc8c..d8cf29c01cc4 100644
--- a/drivers/mtd/inftlcore.c
+++ b/drivers/mtd/inftlcore.c
@@ -226,7 +226,7 @@ static u16 INFTL_findfreeblock(struct INFTLrecord *inftl, int desperate)
         if (!desperate && inftl->numfreeEUNs < 2) {
                 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: there are too few free "
                         "EUNs (%d)\n", inftl->numfreeEUNs);
-                return 0xffff;
+                return BLOCK_NIL;
         }
 
         /* Scan for a free block */
@@ -281,7 +281,8 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
         silly = MAX_LOOPS;
         while (thisEUN < inftl->nb_blocks) {
                 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) {
-                        if ((BlockMap[block] != 0xffff) || BlockDeleted[block])
+                        if ((BlockMap[block] != BLOCK_NIL) ||
+                            BlockDeleted[block])
                                 continue;
 
                         if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
@@ -525,7 +526,7 @@ static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block)
                         if (!silly--) {
                                 printk(KERN_WARNING "INFTL: infinite loop in "
                                         "Virtual Unit Chain 0x%x\n", thisVUC);
-                                return 0xffff;
+                                return BLOCK_NIL;
                         }
 
                         /* Skip to next block in chain */
@@ -549,7 +550,7 @@ hitused:
                          * waiting to be picked up. We're going to have to fold
                          * a chain to make room.
                          */
-                        thisEUN = INFTL_makefreeblock(inftl, 0xffff);
+                        thisEUN = INFTL_makefreeblock(inftl, BLOCK_NIL);
 
                         /*
                          * Hopefully we free something, lets try again.
@@ -631,7 +632,7 @@ hitused:
 
         printk(KERN_WARNING "INFTL: error folding to make room for Virtual "
                 "Unit Chain 0x%x\n", thisVUC);
-        return 0xffff;
+        return BLOCK_NIL;
 }
 
 /*
diff --git a/drivers/mtd/maps/integrator-flash.c b/drivers/mtd/maps/integrator-flash.c
index b08a798ee254..2aac41bde8b3 100644
--- a/drivers/mtd/maps/integrator-flash.c
+++ b/drivers/mtd/maps/integrator-flash.c
@@ -42,10 +42,8 @@
 #include <mach/hardware.h>
 #include <asm/system.h>
 
-#define SUBDEV_NAME_SIZE        (BUS_ID_SIZE + 2)
-
 struct armflash_subdev_info {
-        char                    name[SUBDEV_NAME_SIZE];
+        char                    *name;
         struct mtd_info         *mtd;
         struct map_info         map;
         struct flash_platform_data *plat;
@@ -134,6 +132,8 @@ static void armflash_subdev_remove(struct armflash_subdev_info *subdev)
                 map_destroy(subdev->mtd);
         if (subdev->map.virt)
                 iounmap(subdev->map.virt);
+        kfree(subdev->name);
+        subdev->name = NULL;
         release_mem_region(subdev->map.phys, subdev->map.size);
 }
 
@@ -177,16 +177,22 @@ static int armflash_probe(struct platform_device *dev)
 
                 if (nr == 1)
                         /* No MTD concatenation, just use the default name */
-                        snprintf(subdev->name, SUBDEV_NAME_SIZE, "%s",
-                                 dev_name(&dev->dev));
+                        subdev->name = kstrdup(dev_name(&dev->dev), GFP_KERNEL);
                 else
-                        snprintf(subdev->name, SUBDEV_NAME_SIZE, "%s-%d",
-                                 dev_name(&dev->dev), i);
+                        subdev->name = kasprintf(GFP_KERNEL, "%s-%d",
+                                                 dev_name(&dev->dev), i);
+                if (!subdev->name) {
+                        err = -ENOMEM;
+                        break;
+                }
                 subdev->plat = plat;
 
                 err = armflash_subdev_probe(subdev, res);
-                if (err)
+                if (err) {
+                        kfree(subdev->name);
+                        subdev->name = NULL;
                         break;
+                }
         }
         info->nr_subdev = i;
 
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index 2802992b39da..20c828ba9405 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -534,7 +534,7 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                                                          &num_partitions);
 
         if ((!partitions) || (num_partitions == 0)) {
-                printk(KERN_ERR "atmel_nand: No parititions defined, or unsupported device.\n");
+                printk(KERN_ERR "atmel_nand: No partitions defined, or unsupported device.\n");
                 res = ENXIO;
                 goto err_no_partitions;
         }
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index 0cd76f89f4b0..ebd07e95b814 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -11,6 +11,8 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/sched.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
@@ -541,7 +543,7 @@ static int omap_wait(struct mtd_info *mtd, struct nand_chip *chip)
         struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
                                                         mtd);
         unsigned long timeo = jiffies;
-        int status, state = this->state;
+        int status = NAND_STATUS_FAIL, state = this->state;
 
         if (state == FL_ERASING)
                 timeo += (HZ * 400) / 1000;
@@ -556,8 +558,9 @@ static int omap_wait(struct mtd_info *mtd, struct nand_chip *chip)
 
         while (time_before(jiffies, timeo)) {
                 status = __raw_readb(this->IO_ADDR_R);
-                if (!(status & 0x40))
+                if (status & NAND_STATUS_READY)
                         break;
+                cond_resched();
         }
         return status;
 }
diff --git a/drivers/mtd/nand/ts7250.c b/drivers/mtd/nand/ts7250.c
index 2c410a011317..0f5562aeedc1 100644
--- a/drivers/mtd/nand/ts7250.c
+++ b/drivers/mtd/nand/ts7250.c
@@ -24,8 +24,11 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
-#include <asm/io.h>
+#include <linux/io.h>
+
 #include <mach/hardware.h>
+#include <mach/ts72xx.h>
+
 #include <asm/sizes.h>
 #include <asm/mach-types.h>
 
diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index e3f8495a94c2..fb86cacd5bdb 100644
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -208,7 +208,7 @@ static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
         /* Normally, we force a fold to happen before we run out of free blocks completely */
         if (!desperate && nftl->numfreeEUNs < 2) {
                 DEBUG(MTD_DEBUG_LEVEL1, "NFTL_findfreeblock: there are too few free EUNs\n");
-                return 0xffff;
+                return BLOCK_NIL;
         }
 
         /* Scan for a free block */
@@ -230,11 +230,11 @@ static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
                         printk("Argh! No free blocks found! LastFreeEUN = %d, "
                                "FirstEUN = %d\n", nftl->LastFreeEUN,
                                le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
-                        return 0xffff;
+                        return BLOCK_NIL;
                 }
         } while (pot != nftl->LastFreeEUN);
 
-        return 0xffff;
+        return BLOCK_NIL;
 }
 
 static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
@@ -431,7 +431,7 @@ static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned p
 
         /* add the header so that it is now a valid chain */
         oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
-        oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff;
+        oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
 
         nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
                        8, &retlen, (char *)&oob.u);
@@ -515,7 +515,7 @@ static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
         if (ChainLength < 2) {
                 printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
                        "Failing request\n");
-                return 0xffff;
+                return BLOCK_NIL;
         }
 
         return NFTL_foldchain (nftl, LongestChain, pendingblock);
@@ -578,7 +578,7 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
                                 printk(KERN_WARNING
                                        "Infinite loop in Virtual Unit Chain 0x%x\n",
                                        thisVUC);
-                                return 0xffff;
+                                return BLOCK_NIL;
                         }
 
                         /* Skip to next block in chain */
@@ -601,7 +601,7 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
                         //u16 startEUN = nftl->EUNtable[thisVUC];
 
                         //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
-                        writeEUN = NFTL_makefreeblock(nftl, 0xffff);
+                        writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
 
                         if (writeEUN == BLOCK_NIL) {
                                 /* OK, we accept that the above comment is
@@ -673,7 +673,7 @@ static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
 
         printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
                thisVUC);
-        return 0xffff;
+        return BLOCK_NIL;
 }
 
 static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 286ed594e5a0..e1f7d0a78b9d 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -657,6 +657,11 @@ static int io_init(struct ubi_device *ubi)
         if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
                 ubi->bad_allowed = 1;
 
+        if (ubi->mtd->type == MTD_NORFLASH) {
+                ubi_assert(ubi->mtd->writesize == 1);
+                ubi->nor_flash = 1;
+        }
+
         ubi->min_io_size = ubi->mtd->writesize;
         ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
 
@@ -996,6 +1001,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
         ubi_msg("number of PEBs reserved for bad PEB handling: %d",
                 ubi->beb_rsvd_pebs);
         ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
+        ubi_msg("image sequence number: %d", ubi->image_seq);
 
         /*
          * The below lock makes sure we do not race with 'ubi_thread()' which
diff --git a/drivers/mtd/ubi/debug.c b/drivers/mtd/ubi/debug.c
index c0ed60e8ade9..54b0186915fb 100644
--- a/drivers/mtd/ubi/debug.c
+++ b/drivers/mtd/ubi/debug.c
@@ -44,6 +44,8 @@ void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)
                be32_to_cpu(ec_hdr->vid_hdr_offset));
         printk(KERN_DEBUG "\tdata_offset    %d\n",
                be32_to_cpu(ec_hdr->data_offset));
+        printk(KERN_DEBUG "\timage_seq      %d\n",
+               be32_to_cpu(ec_hdr->image_seq));
         printk(KERN_DEBUG "\thdr_crc        %#08x\n",
                be32_to_cpu(ec_hdr->hdr_crc));
         printk(KERN_DEBUG "erase counter header hexdump:\n");
diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index 13777e5beac9..a4da7a09b949 100644
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -93,6 +93,12 @@ void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);
 #define UBI_IO_DEBUG 0
 #endif
 
+#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
+int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len);
+#else
+#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
+#endif
+
 #ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
 #define DBG_DISABLE_BGT 1
 #else
@@ -167,6 +173,7 @@ static inline int ubi_dbg_is_erase_failure(void)
 #define ubi_dbg_is_bitflip()       0
 #define ubi_dbg_is_write_failure() 0
 #define ubi_dbg_is_erase_failure() 0
+#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
 
 #endif /* !CONFIG_MTD_UBI_DEBUG */
 #endif /* !__UBI_DEBUG_H__ */
diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index effaff28bab1..4cb69925d8d9 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -98,17 +98,12 @@ static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
                                   const struct ubi_vid_hdr *vid_hdr);
-static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
-                                 int len);
-static int paranoid_check_empty(struct ubi_device *ubi, int pnum);
 #else
 #define paranoid_check_not_bad(ubi, pnum) 0
 #define paranoid_check_peb_ec_hdr(ubi, pnum)  0
 #define paranoid_check_ec_hdr(ubi, pnum, ec_hdr)  0
 #define paranoid_check_peb_vid_hdr(ubi, pnum) 0
 #define paranoid_check_vid_hdr(ubi, pnum, vid_hdr) 0
-#define paranoid_check_all_ff(ubi, pnum, offset, len) 0
-#define paranoid_check_empty(ubi, pnum) 0
 #endif
 
 /**
@@ -244,7 +239,7 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
                 return err > 0 ? -EINVAL : err;
 
         /* The area we are writing to has to contain all 0xFF bytes */
-        err = paranoid_check_all_ff(ubi, pnum, offset, len);
+        err = ubi_dbg_check_all_ff(ubi, pnum, offset, len);
         if (err)
                 return err > 0 ? -EINVAL : err;
 
@@ -271,8 +266,8 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
         addr = (loff_t)pnum * ubi->peb_size + offset;
         err = ubi->mtd->write(ubi->mtd, addr, len, &written, buf);
         if (err) {
-                ubi_err("error %d while writing %d bytes to PEB %d:%d, written"
-                        " %zd bytes", err, len, pnum, offset, written);
+                ubi_err("error %d while writing %d bytes to PEB %d:%d, written "
+                        "%zd bytes", err, len, pnum, offset, written);
                 ubi_dbg_dump_stack();
         } else
                 ubi_assert(written == len);
@@ -350,7 +345,7 @@ retry:
                 return -EIO;
         }
 
-        err = paranoid_check_all_ff(ubi, pnum, 0, ubi->peb_size);
+        err = ubi_dbg_check_all_ff(ubi, pnum, 0, ubi->peb_size);
         if (err)
                 return err > 0 ? -EINVAL : err;
 
@@ -459,6 +454,54 @@ out:
 }
 
 /**
+ * nor_erase_prepare - prepare a NOR flash PEB for erasure.
+ * @ubi: UBI device description object
+ * @pnum: physical eraseblock number to prepare
+ *
+ * NOR flash, or at least some of them, have peculiar embedded PEB erasure
+ * algorithm: the PEB is first filled with zeroes, then it is erased. And
+ * filling with zeroes starts from the end of the PEB. This was observed with
+ * Spansion S29GL512N NOR flash.
+ *
+ * This means that in case of a power cut we may end up with intact data at the
+ * beginning of the PEB, and all zeroes at the end of PEB. In other words, the
+ * EC and VID headers are OK, but a large chunk of data at the end of PEB is
+ * zeroed. This makes UBI mistakenly treat this PEB as used and associate it
+ * with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
+ *
+ * This function is called before erasing NOR PEBs and it zeroes out EC and VID
+ * magic numbers in order to invalidate them and prevent the failures. Returns
+ * zero in case of success and a negative error code in case of failure.
+ */
+static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
+{
+        int err;
+        size_t written;
+        loff_t addr;
+        uint32_t data = 0;
+
+        addr = (loff_t)pnum * ubi->peb_size;
+        err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);
+        if (err) {
+                ubi_err("error %d while writing 4 bytes to PEB %d:%d, written "
+                        "%zd bytes", err, pnum, 0, written);
+                ubi_dbg_dump_stack();
+                return err;
+        }
+
+        addr += ubi->vid_hdr_aloffset;
+        err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);
+        if (err) {
+                ubi_err("error %d while writing 4 bytes to PEB %d:%d, written "
+                        "%zd bytes", err, pnum, ubi->vid_hdr_aloffset, written);
+                ubi_dbg_dump_stack();
+                return err;
+        }
+
+        return 0;
+}
+
+/**
  * ubi_io_sync_erase - synchronously erase a physical eraseblock.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number to erase
@@ -489,6 +532,12 @@ int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
                 return -EROFS;
         }
 
+        if (ubi->nor_flash) {
+                err = nor_erase_prepare(ubi, pnum);
+                if (err)
+                        return err;
+        }
+
         if (torture) {
                 ret = torture_peb(ubi, pnum);
                 if (ret < 0)
@@ -672,11 +721,6 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                 if (read_err != -EBADMSG &&
                     check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
                         /* The physical eraseblock is supposedly empty */
-                        err = paranoid_check_all_ff(ubi, pnum, 0,
-                                                    ubi->peb_size);
-                        if (err)
-                                return err > 0 ? UBI_IO_BAD_EC_HDR : err;
-
                         if (verbose)
                                 ubi_warn("no EC header found at PEB %d, "
                                          "only 0xFF bytes", pnum);
@@ -752,6 +796,7 @@ int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
         ec_hdr->version = UBI_VERSION;
         ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
         ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
+        ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
         ec_hdr->hdr_crc = cpu_to_be32(crc);
 
@@ -947,15 +992,6 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                 if (read_err != -EBADMSG &&
                     check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
                         /* The physical eraseblock is supposedly free */
-
-                        /*
-                         * The below is just a paranoid check, it has to be
-                         * compiled out if paranoid checks are disabled.
-                         */
-                        err = paranoid_check_empty(ubi, pnum);
-                        if (err)
-                                return err > 0 ? UBI_IO_BAD_VID_HDR : err;
-
                         if (verbose)
                                 ubi_warn("no VID header found at PEB %d, "
                                          "only 0xFF bytes", pnum);
@@ -1229,7 +1265,7 @@ exit:
 }
 
 /**
- * paranoid_check_all_ff - check that a region of flash is empty.
+ * ubi_dbg_check_all_ff - check that a region of flash is empty.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to check
  * @offset: the starting offset within the physical eraseblock to check
@@ -1239,8 +1275,7 @@ exit:
  * @offset of the physical eraseblock @pnum, %1 if not, and a negative error
  * code if an error occurred.
  */
-static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
-                                 int len)
+int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
 {
         size_t read;
         int err;
@@ -1276,74 +1311,4 @@ error:
         return err;
 }
 
-/**
- * paranoid_check_empty - whether a PEB is empty.
- * @ubi: UBI device description object
- * @pnum: the physical eraseblock number to check
- *
- * This function makes sure PEB @pnum is empty, which means it contains only
- * %0xFF data bytes. Returns zero if the PEB is empty, %1 if not, and a
- * negative error code in case of failure.
- *
- * Empty PEBs have the EC header, and do not have the VID header. The caller of
- * this function should have already made sure the PEB does not have the VID
- * header. However, this function re-checks that, because it is possible that
- * the header and data has already been written to the PEB.
- *
- * Let's consider a possible scenario. Suppose there are 2 tasks - A and B.
- * Task A is in 'wear_leveling_worker()'. It is reading VID header of PEB X to
- * find which LEB it corresponds to. PEB X is currently unmapped, and has no
- * VID header. Task B is trying to write to PEB X.
- *
- * Task A: in 'ubi_io_read_vid_hdr()': reads the VID header from PEB X. The
- *         read data contain all 0xFF bytes;
- * Task B: writes VID header and some data to PEB X;
- * Task A: assumes PEB X is empty, calls 'paranoid_check_empty()'. And if we
- *         do not re-read the VID header, and do not cancel the checking if it
- *         is there, we fail.
- */
-static int paranoid_check_empty(struct ubi_device *ubi, int pnum)
-{
-        int err, offs = ubi->vid_hdr_aloffset, len = ubi->vid_hdr_alsize;
-        size_t read;
-        uint32_t magic;
-        const struct ubi_vid_hdr *vid_hdr;
-
-        mutex_lock(&ubi->dbg_buf_mutex);
-        err = ubi->mtd->read(ubi->mtd, offs, len, &read, ubi->dbg_peb_buf);
-        if (err && err != -EUCLEAN) {
-                ubi_err("error %d while reading %d bytes from PEB %d:%d, "
-                        "read %zd bytes", err, len, pnum, offs, read);
-                goto error;
-        }
-
-        vid_hdr = ubi->dbg_peb_buf;
-        magic = be32_to_cpu(vid_hdr->magic);
-        if (magic == UBI_VID_HDR_MAGIC)
-                /* The PEB contains VID header, so it is not empty */
-                goto out;
-
-        err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);
-        if (err == 0) {
-                ubi_err("flash region at PEB %d:%d, length %d does not "
-                        "contain all 0xFF bytes", pnum, offs, len);
-                goto fail;
-        }
-
-out:
-        mutex_unlock(&ubi->dbg_buf_mutex);
-        return 0;
-
-fail:
-        ubi_err("paranoid check failed for PEB %d", pnum);
-        ubi_msg("hex dump of the %d-%d region", offs, offs + len);
-        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
-                       ubi->dbg_peb_buf, len, 1);
-        err = 1;
-error:
-        ubi_dbg_dump_stack();
-        mutex_unlock(&ubi->dbg_buf_mutex);
-        return err;
-}
-
 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */
diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index c3d653ba5ca0..f60895ee0aeb 100644
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -757,6 +757,8 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
         si->is_empty = 0;
 
         if (!ec_corr) {
+                int image_seq;
+
                 /* Make sure UBI version is OK */
                 if (ech->version != UBI_VERSION) {
                         ubi_err("this UBI version is %d, image version is %d",
@@ -778,6 +780,18 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                         ubi_dbg_dump_ec_hdr(ech);
                         return -EINVAL;
                 }
+
+                image_seq = be32_to_cpu(ech->ec);
+                if (!si->image_seq_set) {
+                        ubi->image_seq = image_seq;
+                        si->image_seq_set = 1;
+                } else if (ubi->image_seq != image_seq) {
+                        ubi_err("bad image sequence number %d in PEB %d, "
+                                "expected %d", image_seq, pnum, ubi->image_seq);
+                        ubi_dbg_dump_ec_hdr(ech);
+                        return -EINVAL;
+                }
+
         }
 
         /* OK, we've done with the EC header, let's look at the VID header */
diff --git a/drivers/mtd/ubi/scan.h b/drivers/mtd/ubi/scan.h
index 61df208e2f20..1017cf12def5 100644
--- a/drivers/mtd/ubi/scan.h
+++ b/drivers/mtd/ubi/scan.h
@@ -102,6 +102,7 @@ struct ubi_scan_volume {
  * @mean_ec: mean erase counter value
  * @ec_sum: a temporary variable used when calculating @mean_ec
  * @ec_count: a temporary variable used when calculating @mean_ec
+ * @image_seq_set: indicates @ubi->image_seq is known
  *
  * This data structure contains the result of scanning and may be used by other
  * UBI sub-systems to build final UBI data structures, further error-recovery
@@ -124,6 +125,7 @@ struct ubi_scan_info {
         int mean_ec;
         uint64_t ec_sum;
         int ec_count;
+        int image_seq_set;
 };
 
 struct ubi_device;
diff --git a/drivers/mtd/ubi/ubi-media.h b/drivers/mtd/ubi/ubi-media.h
index 8419fdccc79c..503ea9b27309 100644
--- a/drivers/mtd/ubi/ubi-media.h
+++ b/drivers/mtd/ubi/ubi-media.h
@@ -129,6 +129,7 @@ enum {
  * @ec: the erase counter
  * @vid_hdr_offset: where the VID header starts
  * @data_offset: where the user data start
+ * @image_seq: image sequence number
  * @padding2: reserved for future, zeroes
  * @hdr_crc: erase counter header CRC checksum
  *
@@ -144,6 +145,14 @@ enum {
  * volume identifier header and user data, relative to the beginning of the
  * physical eraseblock. These values have to be the same for all physical
  * eraseblocks.
+ *
+ * The @image_seq field is used to validate a UBI image that has been prepared
+ * for a UBI device. The @image_seq value can be any value, but it must be the
+ * same on all eraseblocks. UBI will ensure that all new erase counter headers
+ * also contain this value, and will check the value when scanning at start-up.
+ * One way to make use of @image_seq is to increase its value by one every time
+ * an image is flashed over an existing image, then, if the flashing does not
+ * complete, UBI will detect the error when scanning.
  */
 struct ubi_ec_hdr {
         __be32  magic;
@@ -152,7 +161,8 @@ struct ubi_ec_hdr {
         __be64  ec; /* Warning: the current limit is 31-bit anyway! */
         __be32  vid_hdr_offset;
         __be32  data_offset;
-        __u8    padding2[36];
+        __be32  image_seq;
+        __u8    padding2[32];
         __be32  hdr_crc;
 } __attribute__ ((packed));
 
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index 28acd133c997..6a5fe9633783 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -301,6 +301,7 @@ struct ubi_wl_entry;
  *                @vol->readers, @vol->writers, @vol->exclusive,
  *                @vol->ref_count, @vol->mapping and @vol->eba_tbl.
  * @ref_count: count of references on the UBI device
+ * @image_seq: image sequence number recorded on EC headers
  *
  * @rsvd_pebs: count of reserved physical eraseblocks
  * @avail_pebs: count of available physical eraseblocks
@@ -372,6 +373,7 @@ struct ubi_wl_entry;
  * @vid_hdr_shift: contains @vid_hdr_offset - @vid_hdr_aloffset
  * @bad_allowed: whether the MTD device admits of bad physical eraseblocks or
  *               not
+ * @nor_flash: non-zero if working on top of NOR flash
  * @mtd: MTD device descriptor
  *
  * @peb_buf1: a buffer of PEB size used for different purposes
@@ -390,6 +392,7 @@ struct ubi_device {
         struct ubi_volume *volumes[UBI_MAX_VOLUMES+UBI_INT_VOL_COUNT];
         spinlock_t volumes_lock;
         int ref_count;
+        int image_seq;
 
         int rsvd_pebs;
         int avail_pebs;
@@ -452,7 +455,8 @@ struct ubi_device {
         int vid_hdr_offset;
         int vid_hdr_aloffset;
         int vid_hdr_shift;
-        int bad_allowed;
+        unsigned int bad_allowed:1;
+        unsigned int nor_flash:1;
         struct mtd_info *mtd;
 
         void *peb_buf1;
diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 2b2472300610..600c7229d5cf 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -459,6 +459,14 @@ retry:
         dbg_wl("PEB %d EC %d", e->pnum, e->ec);
         prot_queue_add(ubi, e);
         spin_unlock(&ubi->wl_lock);
+
+        err = ubi_dbg_check_all_ff(ubi, e->pnum, ubi->vid_hdr_aloffset,
+                                   ubi->peb_size - ubi->vid_hdr_aloffset);
+        if (err) {
+                ubi_err("new PEB %d does not contain all 0xFF bytes", e->pnum);
+                return err > 0 ? -EINVAL : err;
+        }
+
         return e->pnum;
 }
 
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index c155bd3ec9f1..f053ba5c37ba 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -209,7 +209,7 @@ config MII
 
 config MACB
         tristate "Atmel MACB support"
-        depends on AVR32 || ARCH_AT91SAM9260 || ARCH_AT91SAM9263 || ARCH_AT91SAM9G20 || ARCH_AT91CAP9
+        depends on AVR32 || ARCH_AT91SAM9260 || ARCH_AT91SAM9263 || ARCH_AT91SAM9G20 || ARCH_AT91SAM9G45 || ARCH_AT91CAP9
         select PHYLIB
         help
           The Atmel MACB ethernet interface is found on many AT32 and AT91
diff --git a/drivers/net/a2065.c b/drivers/net/a2065.c
index 85a18175730b..08787f5a22a3 100644
--- a/drivers/net/a2065.c
+++ b/drivers/net/a2065.c
@@ -569,16 +569,8 @@ static int lance_start_xmit (struct sk_buff *skb, struct net_device *dev)
 
 #ifdef DEBUG_DRIVER
         /* dump the packet */
-        {
-                int i;
-
-                for (i = 0; i < 64; i++) {
-                        if ((i % 16) == 0)
-                                printk("\n" KERN_DEBUG);
-                        printk ("%2.2x ", skb->data [i]);
-                }
-                printk("\n");
-        }
+        print_hex_dump(KERN_DEBUG, "skb->data: ", DUMP_PREFIX_NONE,
+                       16, 1, skb->data, 64, true);
 #endif
         entry = lp->tx_new & lp->tx_ring_mod_mask;
         ib->btx_ring [entry].length = (-skblen) | 0xf000;
diff --git a/drivers/net/arcnet/arcnet.c b/drivers/net/arcnet/arcnet.c
index d6d4ab3b430c..7d227cdab9f8 100644
--- a/drivers/net/arcnet/arcnet.c
+++ b/drivers/net/arcnet/arcnet.c
@@ -158,15 +158,12 @@ module_exit(arcnet_exit);
 void arcnet_dump_skb(struct net_device *dev,
                      struct sk_buff *skb, char *desc)
 {
-        int i;
+        char hdr[32];
 
-        printk(KERN_DEBUG "%6s: skb dump (%s) follows:", dev->name, desc);
-        for (i = 0; i < skb->len; i++) {
-                if (i % 16 == 0)
-                        printk("\n" KERN_DEBUG "[%04X] ", i);
-                printk("%02X ", ((u_char *) skb->data)[i]);
-        }
-        printk("\n");
+        /* dump the packet */
+        snprintf(hdr, sizeof(hdr), "%6s:%s skb->data:", dev->name, desc);
+        print_hex_dump(KERN_DEBUG, hdr, DUMP_PREFIX_OFFSET,
+                       16, 1, skb->data, skb->len, true);
 }
 
 EXPORT_SYMBOL(arcnet_dump_skb);
@@ -184,6 +181,7 @@ static void arcnet_dump_packet(struct net_device *dev, int bufnum,
         int i, length;
         unsigned long flags = 0;
         static uint8_t buf[512];
+        char hdr[32];
 
         /* hw.copy_from_card expects IRQ context so take the IRQ lock
            to keep it single threaded */
@@ -197,14 +195,10 @@ static void arcnet_dump_packet(struct net_device *dev, int bufnum,
         /* if the offset[0] byte is nonzero, this is a 256-byte packet */
         length = (buf[2] ? 256 : 512);
 
-        printk(KERN_DEBUG "%6s: packet dump (%s) follows:", dev->name, desc);
-        for (i = 0; i < length; i++) {
-                if (i % 16 == 0)
-                        printk("\n" KERN_DEBUG "[%04X] ", i);
-                printk("%02X ", buf[i]);
-        }
-        printk("\n");
-
+        /* dump the packet */
+        snprintf(hdr, sizeof(hdr), "%6s:%s packet dump:", dev->name, desc);
+        print_hex_dump(KERN_DEBUG, hdr, DUMP_PREFIX_OFFSET,
+                       16, 1, buf, length, true);
 }
 
 #else
diff --git a/drivers/net/atl1c/atl1c_ethtool.c b/drivers/net/atl1c/atl1c_ethtool.c
index e4afbd628c23..607007d75b6f 100644
--- a/drivers/net/atl1c/atl1c_ethtool.c
+++ b/drivers/net/atl1c/atl1c_ethtool.c
@@ -281,6 +281,8 @@ static int atl1c_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & WAKE_PHY)
                 adapter->wol |= AT_WUFC_LNKC;
 
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
+
         return 0;
 }
 
diff --git a/drivers/net/atl1e/atl1e_ethtool.c b/drivers/net/atl1e/atl1e_ethtool.c
index 619c6583e1aa..4003955d7a96 100644
--- a/drivers/net/atl1e/atl1e_ethtool.c
+++ b/drivers/net/atl1e/atl1e_ethtool.c
@@ -365,6 +365,8 @@ static int atl1e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         if (wol->wolopts & WAKE_PHY)
                 adapter->wol |= AT_WUFC_LNKC;
 
+        device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
+
         return 0;
 }
 
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index f703758f0a6e..5b4bf3d2cdc2 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -73,7 +73,7 @@ static inline char *nic_name(struct pci_dev *pdev)
 #define RX_FRAGS_REFILL_WM      (RX_Q_LEN - MAX_RX_POST)
 
 #define BE_MAX_LRO_DESCRIPTORS  16
-#define BE_MAX_FRAGS_PER_FRAME  16
+#define BE_MAX_FRAGS_PER_FRAME  (min((u32) 16, (u32) MAX_SKB_FRAGS))
 
 struct be_dma_mem {
         void *va;
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index 9592f22e4c8c..cccc5419ad72 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -162,8 +162,8 @@ be_set_coalesce(struct net_device *netdev, struct ethtool_coalesce *coalesce)
                 return -EINVAL;
 
         adapter->max_rx_coal = coalesce->rx_max_coalesced_frames;
-        if (adapter->max_rx_coal > MAX_SKB_FRAGS)
-                adapter->max_rx_coal = MAX_SKB_FRAGS - 1;
+        if (adapter->max_rx_coal > BE_MAX_FRAGS_PER_FRAME)
+                adapter->max_rx_coal = BE_MAX_FRAGS_PER_FRAME;
 
         /* if AIC is being turned on now, start with an EQD of 0 */
         if (rx_eq->enable_aic == 0 &&
diff --git a/drivers/net/benet/be_hw.h b/drivers/net/benet/be_hw.h
index b02e805c1db3..29c33c709c6d 100644
--- a/drivers/net/benet/be_hw.h
+++ b/drivers/net/benet/be_hw.h
@@ -55,6 +55,10 @@
 #define MEMBAR_CTRL_INT_CTRL_PFUNC_MASK         0x7     /* bits 26 - 28 */
 #define MEMBAR_CTRL_INT_CTRL_PFUNC_SHIFT        26
 
+/********* ISR0 Register offset **********/
+#define CEV_ISR0_OFFSET                         0xC18
+#define CEV_ISR_SIZE                            4
+
 /********* Event Q door bell *************/
 #define DB_EQ_OFFSET                    DB_CQ_OFFSET
 #define DB_EQ_RING_ID_MASK              0x1FF   /* bits 0 - 8 */
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 66c10c87f517..c43f6a119295 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -666,7 +666,7 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
 {
         struct be_queue_info *rxq = &adapter->rx_obj.q;
         struct be_rx_page_info *page_info;
-        u16 rxq_idx, i, num_rcvd;
+        u16 rxq_idx, i, num_rcvd, j;
         u32 pktsize, hdr_len, curr_frag_len;
         u8 *start;
 
@@ -709,22 +709,33 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
 
         /* More frags present for this completion */
         pktsize -= curr_frag_len; /* account for above copied frag */
-        for (i = 1; i < num_rcvd; i++) {
+        for (i = 1, j = 0; i < num_rcvd; i++) {
                 index_inc(&rxq_idx, rxq->len);
                 page_info = get_rx_page_info(adapter, rxq_idx);
 
                 curr_frag_len = min(pktsize, rx_frag_size);
 
-                skb_shinfo(skb)->frags[i].page = page_info->page;
-                skb_shinfo(skb)->frags[i].page_offset = page_info->page_offset;
-                skb_shinfo(skb)->frags[i].size = curr_frag_len;
+                /* Coalesce all frags from the same physical page in one slot */
+                if (page_info->page_offset == 0) {
+                        /* Fresh page */
+                        j++;
+                        skb_shinfo(skb)->frags[j].page = page_info->page;
+                        skb_shinfo(skb)->frags[j].page_offset =
+                                                        page_info->page_offset;
+                        skb_shinfo(skb)->frags[j].size = 0;
+                        skb_shinfo(skb)->nr_frags++;
+                } else {
+                        put_page(page_info->page);
+                }
+
+                skb_shinfo(skb)->frags[j].size += curr_frag_len;
                 skb->len += curr_frag_len;
                 skb->data_len += curr_frag_len;
-                skb_shinfo(skb)->nr_frags++;
                 pktsize -= curr_frag_len;
 
                 memset(page_info, 0, sizeof(*page_info));
         }
+        BUG_ON(j > MAX_SKB_FRAGS);
 
 done:
         be_rx_stats_update(adapter, pktsize, num_rcvd);
@@ -786,7 +797,7 @@ static void be_rx_compl_process_lro(struct be_adapter *adapter,
         struct skb_frag_struct rx_frags[BE_MAX_FRAGS_PER_FRAME];
         struct be_queue_info *rxq = &adapter->rx_obj.q;
         u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len;
-        u16 i, rxq_idx = 0, vid;
+        u16 i, rxq_idx = 0, vid, j;
 
         num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
         pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
@@ -794,20 +805,28 @@ static void be_rx_compl_process_lro(struct be_adapter *adapter,
         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
 
         remaining = pkt_size;
-        for (i = 0; i < num_rcvd; i++) {
+        for (i = 0, j = -1; i < num_rcvd; i++) {
                 page_info = get_rx_page_info(adapter, rxq_idx);
 
                 curr_frag_len = min(remaining, rx_frag_size);
 
-                rx_frags[i].page = page_info->page;
-                rx_frags[i].page_offset = page_info->page_offset;
-                rx_frags[i].size = curr_frag_len;
-                remaining -= curr_frag_len;
+                /* Coalesce all frags from the same physical page in one slot */
+                if (i == 0 || page_info->page_offset == 0) {
+                        /* First frag or Fresh page */
+                        j++;
+                        rx_frags[j].page = page_info->page;
+                        rx_frags[j].page_offset = page_info->page_offset;
+                        rx_frags[j].size = 0;
+                } else {
+                        put_page(page_info->page);
+                }
+                rx_frags[j].size += curr_frag_len;
 
+                remaining -= curr_frag_len;
                 index_inc(&rxq_idx, rxq->len);
-
                 memset(page_info, 0, sizeof(*page_info));
         }
+        BUG_ON(j > MAX_SKB_FRAGS);
 
         if (likely(!vlanf)) {
                 lro_receive_frags(&adapter->rx_obj.lro_mgr, rx_frags, pkt_size,
@@ -1255,15 +1274,17 @@ static irqreturn_t be_intx(int irq, void *dev)
 {
         struct be_adapter *adapter = dev;
         struct be_ctrl_info *ctrl = &adapter->ctrl;
-        int rx, tx;
+        int isr;
 
-        tx = event_handle(ctrl, &adapter->tx_eq);
-        rx = event_handle(ctrl, &adapter->rx_eq);
+        isr = ioread32(ctrl->csr + CEV_ISR0_OFFSET +
+                      ctrl->pci_func * CEV_ISR_SIZE);
+        if (!isr)
+                return IRQ_NONE;
 
-        if (rx || tx)
-                return IRQ_HANDLED;
-        else
-                return IRQ_NONE;
+        event_handle(ctrl, &adapter->tx_eq);
+        event_handle(ctrl, &adapter->rx_eq);
+
+        return IRQ_HANDLED;
 }
 
 static irqreturn_t be_msix_rx(int irq, void *dev)
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 9578a3dfac01..206144f2470f 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -428,10 +428,11 @@ bmac_init_phy(struct net_device *dev)
         printk(KERN_DEBUG "phy registers:");
         for (addr = 0; addr < 32; ++addr) {
                 if ((addr & 7) == 0)
-                        printk("\n" KERN_DEBUG);
-                printk(" %.4x", bmac_mif_read(dev, addr));
+                        printk(KERN_DEBUG);
+                printk(KERN_CONT " %.4x", bmac_mif_read(dev, addr));
         }
-        printk("\n");
+        printk(KERN_CONT "\n");
+
         if (bp->is_bmac_plus) {
                 unsigned int capable, ctrl;
 
diff --git a/drivers/net/bnx2x.h b/drivers/net/bnx2x.h
index 8678457849f9..85a737c5c23f 100644
--- a/drivers/net/bnx2x.h
+++ b/drivers/net/bnx2x.h
@@ -902,6 +902,8 @@ struct bnx2x {
         u16                     rx_quick_cons_trip;
         u16                     rx_ticks_int;
         u16                     rx_ticks;
+/* Maximal coalescing timeout in us */
+#define BNX2X_MAX_COALESCE_TOUT         (0xf0*12)
 
         u32                     lin_cnt;
 
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index fbf1352e9c1c..c36a5f33739f 100644
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -484,8 +484,9 @@ static void bnx2x_fw_dump(struct bnx2x *bp)
 
         mark = REG_RD(bp, MCP_REG_MCPR_SCRATCH + 0xf104);
         mark = ((mark + 0x3) & ~0x3);
-        printk(KERN_ERR PFX "begin fw dump (mark 0x%x)\n" KERN_ERR, mark);
+        printk(KERN_ERR PFX "begin fw dump (mark 0x%x)\n", mark);
 
+        printk(KERN_ERR PFX);
         for (offset = mark - 0x08000000; offset <= 0xF900; offset += 0x8*4) {
                 for (word = 0; word < 8; word++)
                         data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
@@ -500,7 +501,7 @@ static void bnx2x_fw_dump(struct bnx2x *bp)
                 data[8] = 0x0;
                 printk(KERN_CONT "%s", (char *)data);
         }
-        printk("\n" KERN_ERR PFX "end of fw dump\n");
+        printk(KERN_ERR PFX "end of fw dump\n");
 }
 
 static void bnx2x_panic_dump(struct bnx2x *bp)
@@ -4434,7 +4435,7 @@ static void bnx2x_update_coalesce(struct bnx2x *bp)
                 REG_WR16(bp, BAR_USTRORM_INTMEM +
                          USTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
                                                      U_SB_ETH_RX_CQ_INDEX),
-                         bp->rx_ticks ? 0 : 1);
+                         (bp->rx_ticks/12) ? 0 : 1);
 
                 /* HC_INDEX_C_ETH_TX_CQ_CONS */
                 REG_WR8(bp, BAR_CSTRORM_INTMEM +
@@ -4444,7 +4445,7 @@ static void bnx2x_update_coalesce(struct bnx2x *bp)
                 REG_WR16(bp, BAR_CSTRORM_INTMEM +
                          CSTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
                                                      C_SB_ETH_TX_CQ_INDEX),
-                         bp->tx_ticks ? 0 : 1);
+                         (bp->tx_ticks/12) ? 0 : 1);
         }
 }
 
@@ -7354,7 +7355,7 @@ static void bnx2x_reset_task(struct work_struct *work)
 #ifdef BNX2X_STOP_ON_ERROR
         BNX2X_ERR("reset task called but STOP_ON_ERROR defined"
                   " so reset not done to allow debug dump,\n"
-         KERN_ERR " you will need to reboot when done\n");
+                  " you will need to reboot when done\n");
         return;
 #endif
 
@@ -8637,6 +8638,14 @@ static int bnx2x_nway_reset(struct net_device *dev)
         return 0;
 }
 
+static u32
+bnx2x_get_link(struct net_device *dev)
+{
+        struct bnx2x *bp = netdev_priv(dev);
+
+        return bp->link_vars.link_up;
+}
+
 static int bnx2x_get_eeprom_len(struct net_device *dev)
 {
         struct bnx2x *bp = netdev_priv(dev);
@@ -9061,12 +9070,12 @@ static int bnx2x_set_coalesce(struct net_device *dev,
         struct bnx2x *bp = netdev_priv(dev);
 
         bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
-        if (bp->rx_ticks > 3000)
-                bp->rx_ticks = 3000;
+        if (bp->rx_ticks > BNX2X_MAX_COALESCE_TOUT)
+                bp->rx_ticks = BNX2X_MAX_COALESCE_TOUT;
 
         bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
-        if (bp->tx_ticks > 0x3000)
-                bp->tx_ticks = 0x3000;
+        if (bp->tx_ticks > BNX2X_MAX_COALESCE_TOUT)
+                bp->tx_ticks = BNX2X_MAX_COALESCE_TOUT;
 
         if (netif_running(dev))
                 bnx2x_update_coalesce(bp);
@@ -10034,7 +10043,7 @@ static struct ethtool_ops bnx2x_ethtool_ops = {
         .get_msglevel           = bnx2x_get_msglevel,
         .set_msglevel           = bnx2x_set_msglevel,
         .nway_reset             = bnx2x_nway_reset,
-        .get_link               = ethtool_op_get_link,
+        .get_link               = bnx2x_get_link,
         .get_eeprom_len         = bnx2x_get_eeprom_len,
         .get_eeprom             = bnx2x_get_eeprom,
         .set_eeprom             = bnx2x_set_eeprom,
diff --git a/drivers/net/cpmac.c b/drivers/net/cpmac.c
index 58afafbd3b9c..fd5e32cbcb87 100644
--- a/drivers/net/cpmac.c
+++ b/drivers/net/cpmac.c
@@ -1097,7 +1097,7 @@ static const struct net_device_ops cpmac_netdev_ops = {
         .ndo_start_xmit         = cpmac_start_xmit,
         .ndo_tx_timeout         = cpmac_tx_timeout,
         .ndo_set_multicast_list = cpmac_set_multicast_list,
-        .ndo_so_ioctl           = cpmac_ioctl,
+        .ndo_do_ioctl           = cpmac_ioctl,
         .ndo_set_config         = cpmac_config,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 538dda4422dc..fb5df5c6203e 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -642,8 +642,7 @@ static int setup_sge_qsets(struct adapter *adap)
                 struct port_info *pi = netdev_priv(dev);
 
                 pi->qs = &adap->sge.qs[pi->first_qset];
-                for (j = pi->first_qset; j < pi->first_qset + pi->nqsets;
-                     ++j, ++qset_idx) {
+                for (j = 0; j < pi->nqsets; ++j, ++qset_idx) {
                         set_qset_lro(dev, qset_idx, pi->rx_offload & T3_LRO);
                         err = t3_sge_alloc_qset(adap, qset_idx, 1,
                                 (adap->flags & USING_MSIX) ? qset_idx + 1 :
diff --git a/drivers/net/davinci_emac.c b/drivers/net/davinci_emac.c
index 2df8fb0af701..12fd446f9895 100644
--- a/drivers/net/davinci_emac.c
+++ b/drivers/net/davinci_emac.c
@@ -1820,11 +1820,19 @@ static int emac_dev_setmac_addr(struct net_device *ndev, void *addr)
         struct device *emac_dev = &priv->ndev->dev;
         struct sockaddr *sa = addr;
 
+        if (!is_valid_ether_addr(sa->sa_data))
+                return -EINVAL;
+
         /* Store mac addr in priv and rx channel and set it in EMAC hw */
         memcpy(priv->mac_addr, sa->sa_data, ndev->addr_len);
-        memcpy(rxch->mac_addr, sa->sa_data, ndev->addr_len);
         memcpy(ndev->dev_addr, sa->sa_data, ndev->addr_len);
-        emac_setmac(priv, EMAC_DEF_RX_CH, rxch->mac_addr);
+
+        /* If the interface is down - rxch is NULL. */
+        /* MAC address is configured only after the interface is enabled. */
+        if (netif_running(ndev)) {
+                memcpy(rxch->mac_addr, sa->sa_data, ndev->addr_len);
+                emac_setmac(priv, EMAC_DEF_RX_CH, rxch->mac_addr);
+        }
 
         if (netif_msg_drv(priv))
                 dev_notice(emac_dev, "DaVinci EMAC: emac_dev_setmac_addr %pM\n",
diff --git a/drivers/net/dl2k.c b/drivers/net/dl2k.c
index 895d72143ee0..4b6a219fecea 100644
--- a/drivers/net/dl2k.c
+++ b/drivers/net/dl2k.c
@@ -268,8 +268,9 @@ rio_probe1 (struct pci_dev *pdev, const struct pci_device_id *ent)
                 printk(KERN_INFO "tx_coalesce:\t%d packets\n",
                                 tx_coalesce);
         if (np->coalesce)
-                printk(KERN_INFO "rx_coalesce:\t%d packets\n"
-                       KERN_INFO "rx_timeout: \t%d ns\n",
+                printk(KERN_INFO
+                       "rx_coalesce:\t%d packets\n"
+                       "rx_timeout: \t%d ns\n",
                                 np->rx_coalesce, np->rx_timeout*640);
         if (np->vlan)
                 printk(KERN_INFO "vlan(id):\t%d\n", np->vlan);
@@ -1522,9 +1523,9 @@ mii_get_media (struct net_device *dev)
                         printk (KERN_INFO "Operating at 10 Mbps, ");
                 }
                 if (bmcr & MII_BMCR_DUPLEX_MODE) {
-                        printk ("Full duplex\n");
+                        printk (KERN_CONT "Full duplex\n");
                 } else {
-                        printk ("Half duplex\n");
+                        printk (KERN_CONT "Half duplex\n");
                 }
         }
         if (np->tx_flow)
@@ -1614,9 +1615,9 @@ mii_set_media (struct net_device *dev)
                 }
                 if (np->full_duplex) {
                         bmcr |= MII_BMCR_DUPLEX_MODE;
-                        printk ("Full duplex\n");
+                        printk (KERN_CONT "Full duplex\n");
                 } else {
-                        printk ("Half duplex\n");
+                        printk (KERN_CONT "Half duplex\n");
                 }
 #if 0
                 /* Set 1000BaseT Master/Slave setting */
@@ -1669,9 +1670,9 @@ mii_get_media_pcs (struct net_device *dev)
                 __u16 bmcr = mii_read (dev, phy_addr, PCS_BMCR);
                 printk (KERN_INFO "Operating at 1000 Mbps, ");
                 if (bmcr & MII_BMCR_DUPLEX_MODE) {
-                        printk ("Full duplex\n");
+                        printk (KERN_CONT "Full duplex\n");
                 } else {
-                        printk ("Half duplex\n");
+                        printk (KERN_CONT "Half duplex\n");
                 }
         }
         if (np->tx_flow)
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 5e3356f8eb5a..5b8cbdb4b520 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -2185,12 +2185,16 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
         /* Free all the Rx ring sk_buffs */
         for (i = 0; i < rx_ring->count; i++) {
                 buffer_info = &rx_ring->buffer_info[i];
-                if (buffer_info->skb) {
+                if (buffer_info->dma) {
                         pci_unmap_single(pdev,
                                          buffer_info->dma,
                                          buffer_info->length,
                                          PCI_DMA_FROMDEVICE);
+                }
+
+                buffer_info->dma = 0;
 
+                if (buffer_info->skb) {
                         dev_kfree_skb(buffer_info->skb);
                         buffer_info->skb = NULL;
                 }
@@ -4033,6 +4037,7 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
                                  buffer_info->dma,
                                  buffer_info->length,
                                  PCI_DMA_FROMDEVICE);
+                buffer_info->dma = 0;
 
                 length = le16_to_cpu(rx_desc->length);
                 /* !EOP means multiple descriptors were used to store a single
@@ -4222,6 +4227,7 @@ map_skb:
                         pci_unmap_single(pdev, buffer_info->dma,
                                          adapter->rx_buffer_len,
                                          PCI_DMA_FROMDEVICE);
+                        buffer_info->dma = 0;
 
                         break; /* while !buffer_info->skb */
                 }
@@ -4817,6 +4823,9 @@ static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
 
         netif_device_detach(netdev);
 
+        if (state == pci_channel_io_perm_failure)
+                return PCI_ERS_RESULT_DISCONNECT;
+
         if (netif_running(netdev))
                 e1000_down(adapter);
         pci_disable_device(pdev);
diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index 8890c97e1120..c0f185beb8bc 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -238,6 +238,7 @@
 #define E1000_STATUS_SPEED_100  0x00000040      /* Speed 100Mb/s */
 #define E1000_STATUS_SPEED_1000 0x00000080      /* Speed 1000Mb/s */
 #define E1000_STATUS_LAN_INIT_DONE 0x00000200   /* Lan Init Completion by NVM */
+#define E1000_STATUS_PHYRA      0x00000400      /* PHY Reset Asserted */
 #define E1000_STATUS_GIO_MASTER_ENABLE 0x00080000 /* Status of Master requests. */
 
 /* Constants used to interpret the masked PCI-X bus speed. */
@@ -575,6 +576,8 @@
 #define PHY_1000T_STATUS 0x0A /* 1000Base-T Status Reg */
 #define PHY_EXT_STATUS   0x0F /* Extended Status Reg */
 
+#define PHY_CONTROL_LB   0x4000 /* PHY Loopback bit */
+
 /* NVM Control */
 #define E1000_EECD_SK        0x00000001 /* NVM Clock */
 #define E1000_EECD_CS        0x00000002 /* NVM Chip Select */
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index 163c1c0cfee7..fd44d9f90769 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -215,6 +215,7 @@ enum e1e_registers {
         E1000_SWSM      = 0x05B50, /* SW Semaphore */
         E1000_FWSM      = 0x05B54, /* FW Semaphore */
         E1000_SWSM2     = 0x05B58, /* Driver-only SW semaphore */
+        E1000_CRC_OFFSET = 0x05F50, /* CRC Offset register */
         E1000_HICR      = 0x08F00, /* Host Interface Control */
 };
 
@@ -302,6 +303,9 @@ enum e1e_registers {
 #define E1000_KMRNCTRLSTA_REN           0x00200000
 #define E1000_KMRNCTRLSTA_DIAG_OFFSET   0x3    /* Kumeran Diagnostic */
 #define E1000_KMRNCTRLSTA_DIAG_NELPBK   0x1000 /* Nearend Loopback mode */
+#define E1000_KMRNCTRLSTA_K1_CONFIG     0x7
+#define E1000_KMRNCTRLSTA_K1_ENABLE     0x140E
+#define E1000_KMRNCTRLSTA_K1_DISABLE    0x1400
 
 #define IFE_PHY_EXTENDED_STATUS_CONTROL 0x10
 #define IFE_PHY_SPECIAL_CONTROL         0x11 /* 100BaseTx PHY Special Control */
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 9e23f50fb9cd..d56c7473144a 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -338,6 +338,7 @@ static s32 e1000_init_nvm_params_ich8lan(struct e1000_hw *hw)
 {
         struct e1000_nvm_info *nvm = &hw->nvm;
         struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan;
+        union ich8_hws_flash_status hsfsts;
         u32 gfpreg;
         u32 sector_base_addr;
         u32 sector_end_addr;
@@ -374,6 +375,20 @@ static s32 e1000_init_nvm_params_ich8lan(struct e1000_hw *hw)
         /* Adjust to word count */
         nvm->flash_bank_size /= sizeof(u16);
 
+        /*
+         * Make sure the flash bank size does not overwrite the 4k
+         * sector ranges. We may have 64k allotted to us but we only care
+         * about the first 2 4k sectors. Therefore, if we have anything less
+         * than 64k set in the HSFSTS register, we will reduce the bank size
+         * down to 4k and let the rest remain unused. If berasesz == 3, then
+         * we are working in 64k mode. Otherwise we are not.
+         */
+        if (nvm->flash_bank_size > E1000_ICH8_SHADOW_RAM_WORDS) {
+                hsfsts.regval = er16flash(ICH_FLASH_HSFSTS);
+                if (hsfsts.hsf_status.berasesz != 3)
+                        nvm->flash_bank_size = E1000_ICH8_SHADOW_RAM_WORDS;
+        }
+
         nvm->word_size = E1000_ICH8_SHADOW_RAM_WORDS;
 
         /* Clear shadow ram */
@@ -446,6 +461,95 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_adapter *adapter)
         return 0;
 }
 
+/**
+ *  e1000_check_for_copper_link_ich8lan - Check for link (Copper)
+ *  @hw: pointer to the HW structure
+ *
+ *  Checks to see of the link status of the hardware has changed.  If a
+ *  change in link status has been detected, then we read the PHY registers
+ *  to get the current speed/duplex if link exists.
+ **/
+static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
+{
+        struct e1000_mac_info *mac = &hw->mac;
+        s32 ret_val;
+        bool link;
+
+        /*
+         * We only want to go out to the PHY registers to see if Auto-Neg
+         * has completed and/or if our link status has changed.  The
+         * get_link_status flag is set upon receiving a Link Status
+         * Change or Rx Sequence Error interrupt.
+         */
+        if (!mac->get_link_status) {
+                ret_val = 0;
+                goto out;
+        }
+
+        if (hw->mac.type == e1000_pchlan) {
+                ret_val = e1000e_write_kmrn_reg(hw,
+                                                   E1000_KMRNCTRLSTA_K1_CONFIG,
+                                                   E1000_KMRNCTRLSTA_K1_ENABLE);
+                if (ret_val)
+                        goto out;
+        }
+
+        /*
+         * First we want to see if the MII Status Register reports
+         * link.  If so, then we want to get the current speed/duplex
+         * of the PHY.
+         */
+        ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
+        if (ret_val)
+                goto out;
+
+        if (!link)
+                goto out; /* No link detected */
+
+        mac->get_link_status = false;
+
+        if (hw->phy.type == e1000_phy_82578) {
+                ret_val = e1000_link_stall_workaround_hv(hw);
+                if (ret_val)
+                        goto out;
+        }
+
+        /*
+         * Check if there was DownShift, must be checked
+         * immediately after link-up
+         */
+        e1000e_check_downshift(hw);
+
+        /*
+         * If we are forcing speed/duplex, then we simply return since
+         * we have already determined whether we have link or not.
+         */
+        if (!mac->autoneg) {
+                ret_val = -E1000_ERR_CONFIG;
+                goto out;
+        }
+
+        /*
+         * Auto-Neg is enabled.  Auto Speed Detection takes care
+         * of MAC speed/duplex configuration.  So we only need to
+         * configure Collision Distance in the MAC.
+         */
+        e1000e_config_collision_dist(hw);
+
+        /*
+         * Configure Flow Control now that Auto-Neg has completed.
+         * First, we need to restore the desired flow control
+         * settings because we may have had to re-autoneg with a
+         * different link partner.
+         */
+        ret_val = e1000e_config_fc_after_link_up(hw);
+        if (ret_val)
+                hw_dbg(hw, "Error configuring flow control\n");
+
+out:
+        return ret_val;
+}
+
 static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
@@ -694,6 +798,38 @@ static s32 e1000_hv_phy_workarounds_ich8lan(struct e1000_hw *hw)
 }
 
 /**
+ *  e1000_lan_init_done_ich8lan - Check for PHY config completion
+ *  @hw: pointer to the HW structure
+ *
+ *  Check the appropriate indication the MAC has finished configuring the
+ *  PHY after a software reset.
+ **/
+static void e1000_lan_init_done_ich8lan(struct e1000_hw *hw)
+{
+        u32 data, loop = E1000_ICH8_LAN_INIT_TIMEOUT;
+
+        /* Wait for basic configuration completes before proceeding */
+        do {
+                data = er32(STATUS);
+                data &= E1000_STATUS_LAN_INIT_DONE;
+                udelay(100);
+        } while ((!data) && --loop);
+
+        /*
+         * If basic configuration is incomplete before the above loop
+         * count reaches 0, loading the configuration from NVM will
+         * leave the PHY in a bad state possibly resulting in no link.
+         */
+        if (loop == 0)
+                hw_dbg(hw, "LAN_INIT_DONE not set, increase timeout\n");
+
+        /* Clear the Init Done bit for the next init event */
+        data = er32(STATUS);
+        data &= ~E1000_STATUS_LAN_INIT_DONE;
+        ew32(STATUS, data);
+}
+
+/**
  *  e1000_phy_hw_reset_ich8lan - Performs a PHY reset
  *  @hw: pointer to the HW structure
  *
@@ -707,13 +843,15 @@ static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw)
         u32 i;
         u32 data, cnf_size, cnf_base_addr, sw_cfg_mask;
         s32 ret_val;
-        u16 loop = E1000_ICH8_LAN_INIT_TIMEOUT;
         u16 word_addr, reg_data, reg_addr, phy_page = 0;
 
         ret_val = e1000e_phy_hw_reset_generic(hw);
         if (ret_val)
                 return ret_val;
 
+        /* Allow time for h/w to get to a quiescent state after reset */
+        mdelay(10);
+
         if (hw->mac.type == e1000_pchlan) {
                 ret_val = e1000_hv_phy_workarounds_ich8lan(hw);
                 if (ret_val)
@@ -741,26 +879,8 @@ static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw)
                 if (!(data & sw_cfg_mask))
                         return 0;
 
-                /* Wait for basic configuration completes before proceeding*/
-                do {
-                        data = er32(STATUS);
-                        data &= E1000_STATUS_LAN_INIT_DONE;
-                        udelay(100);
-                } while ((!data) && --loop);
-
-                /*
-                 * If basic configuration is incomplete before the above loop
-                 * count reaches 0, loading the configuration from NVM will
-                 * leave the PHY in a bad state possibly resulting in no link.
-                 */
-                if (loop == 0) {
-                        hw_dbg(hw, "LAN_INIT_DONE not set, increase timeout\n");
-                }
-
-                /* Clear the Init Done bit for the next init event */
-                data = er32(STATUS);
-                data &= ~E1000_STATUS_LAN_INIT_DONE;
-                ew32(STATUS, data);
+                /* Wait for basic configuration completes before proceeding */
+                e1000_lan_init_done_ich8lan(hw);
 
                 /*
                  * Make sure HW does not configure LCD from PHY
@@ -961,12 +1081,14 @@ static s32 e1000_set_d0_lplu_state_ich8lan(struct e1000_hw *hw, bool active)
                 phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU;
                 ew32(PHY_CTRL, phy_ctrl);
 
+                if (phy->type != e1000_phy_igp_3)
+                        return 0;
+
                 /*
                  * Call gig speed drop workaround on LPLU before accessing
                  * any PHY registers
                  */
-                if ((hw->mac.type == e1000_ich8lan) &&
-                    (hw->phy.type == e1000_phy_igp_3))
+                if (hw->mac.type == e1000_ich8lan)
                         e1000e_gig_downshift_workaround_ich8lan(hw);
 
                 /* When LPLU is enabled, we should disable SmartSpeed */
@@ -979,6 +1101,9 @@ static s32 e1000_set_d0_lplu_state_ich8lan(struct e1000_hw *hw, bool active)
                 phy_ctrl &= ~E1000_PHY_CTRL_D0A_LPLU;
                 ew32(PHY_CTRL, phy_ctrl);
 
+                if (phy->type != e1000_phy_igp_3)
+                        return 0;
+
                 /*
                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
                  * during Dx states where the power conservation is most
@@ -1038,6 +1163,10 @@ static s32 e1000_set_d3_lplu_state_ich8lan(struct e1000_hw *hw, bool active)
         if (!active) {
                 phy_ctrl &= ~E1000_PHY_CTRL_NOND0A_LPLU;
                 ew32(PHY_CTRL, phy_ctrl);
+
+                if (phy->type != e1000_phy_igp_3)
+                        return 0;
+
                 /*
                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
                  * during Dx states where the power conservation is most
@@ -1073,12 +1202,14 @@ static s32 e1000_set_d3_lplu_state_ich8lan(struct e1000_hw *hw, bool active)
                 phy_ctrl |= E1000_PHY_CTRL_NOND0A_LPLU;
                 ew32(PHY_CTRL, phy_ctrl);
 
+                if (phy->type != e1000_phy_igp_3)
+                        return 0;
+
                 /*
                  * Call gig speed drop workaround on LPLU before accessing
                  * any PHY registers
                  */
-                if ((hw->mac.type == e1000_ich8lan) &&
-                    (hw->phy.type == e1000_phy_igp_3))
+                if (hw->mac.type == e1000_ich8lan)
                         e1000e_gig_downshift_workaround_ich8lan(hw);
 
                 /* When LPLU is enabled, we should disable SmartSpeed */
@@ -1905,7 +2036,7 @@ static s32 e1000_erase_flash_bank_ich8lan(struct e1000_hw *hw, u32 bank)
                 break;
         case 1:
                 sector_size = ICH_FLASH_SEG_SIZE_4K;
-                iteration = flash_bank_size / ICH_FLASH_SEG_SIZE_4K;
+                iteration = 1;
                 break;
         case 2:
                 if (hw->mac.type == e1000_ich9lan) {
@@ -1917,7 +2048,7 @@ static s32 e1000_erase_flash_bank_ich8lan(struct e1000_hw *hw, u32 bank)
                 break;
         case 3:
                 sector_size = ICH_FLASH_SEG_SIZE_64K;
-                iteration = flash_bank_size / ICH_FLASH_SEG_SIZE_64K;
+                iteration = 1;
                 break;
         default:
                 return -E1000_ERR_NVM;
@@ -2143,6 +2274,12 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
         ctrl = er32(CTRL);
 
         if (!e1000_check_reset_block(hw)) {
+                /* Clear PHY Reset Asserted bit */
+                if (hw->mac.type >= e1000_pchlan) {
+                        u32 status = er32(STATUS);
+                        ew32(STATUS, status & ~E1000_STATUS_PHYRA);
+                }
+
                 /*
                  * PHY HW reset requires MAC CORE reset at the same
                  * time to make sure the interface between MAC and the
@@ -2156,23 +2293,34 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
         ew32(CTRL, (ctrl | E1000_CTRL_RST));
         msleep(20);
 
-        if (!ret_val) {
-                /* release the swflag because it is not reset by
-                 * hardware reset
-                 */
+        if (!ret_val)
                 e1000_release_swflag_ich8lan(hw);
-        }
 
-        ret_val = e1000e_get_auto_rd_done(hw);
-        if (ret_val) {
-                /*
-                 * When auto config read does not complete, do not
-                 * return with an error. This can happen in situations
-                 * where there is no eeprom and prevents getting link.
-                 */
-                hw_dbg(hw, "Auto Read Done did not complete\n");
+        if (ctrl & E1000_CTRL_PHY_RST)
+                ret_val = hw->phy.ops.get_cfg_done(hw);
+
+        if (hw->mac.type >= e1000_ich10lan) {
+                e1000_lan_init_done_ich8lan(hw);
+        } else {
+                ret_val = e1000e_get_auto_rd_done(hw);
+                if (ret_val) {
+                        /*
+                         * When auto config read does not complete, do not
+                         * return with an error. This can happen in situations
+                         * where there is no eeprom and prevents getting link.
+                         */
+                        hw_dbg(hw, "Auto Read Done did not complete\n");
+                }
         }
 
+        /*
+         * For PCH, this write will make sure that any noise
+         * will be detected as a CRC error and be dropped rather than show up
+         * as a bad packet to the DMA engine.
+         */
+        if (hw->mac.type == e1000_pchlan)
+                ew32(CRC_OFFSET, 0x65656565);
+
         ew32(IMC, 0xffffffff);
         icr = er32(ICR);
 
@@ -2222,6 +2370,18 @@ static s32 e1000_init_hw_ich8lan(struct e1000_hw *hw)
         for (i = 0; i < mac->mta_reg_count; i++)
                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
 
+        /*
+         * The 82578 Rx buffer will stall if wakeup is enabled in host and
+         * the ME.  Reading the BM_WUC register will clear the host wakeup bit.
+         * Reset the phy after disabling host wakeup to reset the Rx buffer.
+         */
+        if (hw->phy.type == e1000_phy_82578) {
+                hw->phy.ops.read_phy_reg(hw, BM_WUC, &i);
+                ret_val = e1000_phy_hw_reset_ich8lan(hw);
+                if (ret_val)
+                        return ret_val;
+        }
+
         /* Setup link and flow control */
         ret_val = e1000_setup_link_ich8lan(hw);
 
@@ -2254,16 +2414,6 @@ static s32 e1000_init_hw_ich8lan(struct e1000_hw *hw)
         ew32(CTRL_EXT, ctrl_ext);
 
         /*
-         * The 82578 Rx buffer will stall if wakeup is enabled in host and
-         * the ME.  Reading the BM_WUC register will clear the host wakeup bit.
-         * Reset the phy after disabling host wakeup to reset the Rx buffer.
-         */
-        if (hw->phy.type == e1000_phy_82578) {
-                e1e_rphy(hw, BM_WUC, &i);
-                e1000e_phy_hw_reset_generic(hw);
-        }
-
-        /*
          * Clear all of the statistics registers (clear on read).  It is
          * important that we do this after we have tried to establish link
          * because the symbol error count will increment wildly if there
@@ -2485,6 +2635,14 @@ static s32 e1000_get_link_up_info_ich8lan(struct e1000_hw *hw, u16 *speed,
         if (ret_val)
                 return ret_val;
 
+        if ((hw->mac.type == e1000_pchlan) && (*speed == SPEED_1000)) {
+                ret_val = e1000e_write_kmrn_reg(hw,
+                                                  E1000_KMRNCTRLSTA_K1_CONFIG,
+                                                  E1000_KMRNCTRLSTA_K1_DISABLE);
+                if (ret_val)
+                        return ret_val;
+        }
+
         if ((hw->mac.type == e1000_ich8lan) &&
             (hw->phy.type == e1000_phy_igp_3) &&
             (*speed == SPEED_1000)) {
@@ -2850,6 +3008,16 @@ static s32 e1000_get_cfg_done_ich8lan(struct e1000_hw *hw)
 {
         u32 bank = 0;
 
+        if (hw->mac.type >= e1000_pchlan) {
+                u32 status = er32(STATUS);
+
+                if (status & E1000_STATUS_PHYRA)
+                        ew32(STATUS, status & ~E1000_STATUS_PHYRA);
+                else
+                        hw_dbg(hw,
+                               "PHY Reset Asserted not set - needs delay\n");
+        }
+
         e1000e_get_cfg_done(hw);
 
         /* If EEPROM is not marked present, init the IGP 3 PHY manually */
@@ -2921,7 +3089,7 @@ static void e1000_clear_hw_cntrs_ich8lan(struct e1000_hw *hw)
 static struct e1000_mac_operations ich8_mac_ops = {
         .id_led_init            = e1000e_id_led_init,
         .check_mng_mode         = e1000_check_mng_mode_ich8lan,
-        .check_for_link         = e1000e_check_for_copper_link,
+        .check_for_link         = e1000_check_for_copper_link_ich8lan,
         /* cleanup_led dependent on mac type */
         .clear_hw_cntrs         = e1000_clear_hw_cntrs_ich8lan,
         .get_bus_info           = e1000_get_bus_info_ich8lan,
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index be6d9e990374..99ba2b8a2a05 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -378,12 +378,6 @@ s32 e1000e_check_for_copper_link(struct e1000_hw *hw)
 
         mac->get_link_status = 0;
 
-        if (hw->phy.type == e1000_phy_82578) {
-                ret_val = e1000_link_stall_workaround_hv(hw);
-                if (ret_val)
-                        return ret_val;
-        }
-
         /*
          * Check if there was DownShift, must be checked
          * immediately after link-up
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 679885a122b4..63415bb6f48f 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -4785,6 +4785,9 @@ static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
 
         netif_device_detach(netdev);
 
+        if (state == pci_channel_io_perm_failure)
+                return PCI_ERS_RESULT_DISCONNECT;
+
         if (netif_running(netdev))
                 e1000e_down(adapter);
         pci_disable_device(pdev);
diff --git a/drivers/net/e1000e/phy.c b/drivers/net/e1000e/phy.c
index e23459cf3d0e..994401fd0664 100644
--- a/drivers/net/e1000e/phy.c
+++ b/drivers/net/e1000e/phy.c
@@ -1531,7 +1531,12 @@ s32 e1000e_phy_has_link_generic(struct e1000_hw *hw, u32 iterations,
                  */
                 ret_val = e1e_rphy(hw, PHY_STATUS, &phy_status);
                 if (ret_val)
-                        break;
+                        /*
+                         * If the first read fails, another entity may have
+                         * ownership of the resources, wait and try again to
+                         * see if they have relinquished the resources yet.
+                         */
+                        udelay(usec_interval);
                 ret_val = e1e_rphy(hw, PHY_STATUS, &phy_status);
                 if (ret_val)
                         break;
@@ -2737,6 +2742,11 @@ s32 e1000_link_stall_workaround_hv(struct e1000_hw *hw)
         if (hw->phy.type != e1000_phy_82578)
                 goto out;
 
+        /* Do not apply workaround if in PHY loopback bit 14 set */
+        hw->phy.ops.read_phy_reg(hw, PHY_CONTROL, &data);
+        if (data & PHY_CONTROL_LB)
+                goto out;
+
         /* check if link is up and at 1Gbps */
         ret_val = hw->phy.ops.read_phy_reg(hw, BM_CS_STATUS, &data);
         if (ret_val)
diff --git a/drivers/net/epic100.c b/drivers/net/epic100.c
index b60e27dfcfa7..88d7ebf31220 100644
--- a/drivers/net/epic100.c
+++ b/drivers/net/epic100.c
@@ -338,8 +338,7 @@ static int __devinit epic_init_one (struct pci_dev *pdev,
 #ifndef MODULE
         static int printed_version;
         if (!printed_version++)
-                printk (KERN_INFO "%s" KERN_INFO "%s",
-                        version, version2);
+                printk(KERN_INFO "%s%s", version, version2);
 #endif
 
         card_idx++;
@@ -1600,7 +1599,7 @@ static int __init epic_init (void)
 {
 /* when a module, this is printed whether or not devices are found in probe */
 #ifdef MODULE
-        printk (KERN_INFO "%s" KERN_INFO "%s",
+        printk (KERN_INFO "%s%s",
                 version, version2);
 #endif
 
diff --git a/drivers/net/fealnx.c b/drivers/net/fealnx.c
index 891be28a7d4f..48385c42ab57 100644
--- a/drivers/net/fealnx.c
+++ b/drivers/net/fealnx.c
@@ -1209,17 +1209,20 @@ static void fealnx_tx_timeout(struct net_device *dev)
         unsigned long flags;
         int i;
 
-        printk(KERN_WARNING "%s: Transmit timed out, status %8.8x,"
-               " resetting...\n", dev->name, ioread32(ioaddr + ISR));
+        printk(KERN_WARNING
+               "%s: Transmit timed out, status %8.8x, resetting...\n",
+               dev->name, ioread32(ioaddr + ISR));
 
         {
                 printk(KERN_DEBUG "  Rx ring %p: ", np->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++)
-                        printk(" %8.8x", (unsigned int) np->rx_ring[i].status);
-                printk("\n" KERN_DEBUG "  Tx ring %p: ", np->tx_ring);
+                        printk(KERN_CONT " %8.8x",
+                               (unsigned int) np->rx_ring[i].status);
+                printk(KERN_CONT "\n");
+                printk(KERN_DEBUG "  Tx ring %p: ", np->tx_ring);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" %4.4x", np->tx_ring[i].status);
-                printk("\n");
+                        printk(KERN_CONT " %4.4x", np->tx_ring[i].status);
+                printk(KERN_CONT "\n");
         }
 
         spin_lock_irqsave(&np->lock, flags);
diff --git a/drivers/net/fec.h b/drivers/net/fec.h
index 30b7dd671336..cc47f3f057c7 100644
--- a/drivers/net/fec.h
+++ b/drivers/net/fec.h
@@ -46,12 +46,12 @@
 
 #else
 
-#define FEC_ECNTRL;             0x000 /* Ethernet control reg */
-#define FEC_IEVENT;             0x004 /* Interrupt even reg */
-#define FEC_IMASK;              0x008 /* Interrupt mask reg */
-#define FEC_IVEC;               0x00c /* Interrupt vec status reg */
-#define FEC_R_DES_ACTIVE;       0x010 /* Receive descriptor reg */
-#define FEC_X_DES_ACTIVE;       0x01c /* Transmit descriptor reg */
+#define FEC_ECNTRL              0x000 /* Ethernet control reg */
+#define FEC_IEVENT              0x004 /* Interrupt even reg */
+#define FEC_IMASK               0x008 /* Interrupt mask reg */
+#define FEC_IVEC                0x00c /* Interrupt vec status reg */
+#define FEC_R_DES_ACTIVE        0x010 /* Receive descriptor reg */
+#define FEC_X_DES_ACTIVE        0x014 /* Transmit descriptor reg */
 #define FEC_MII_DATA            0x040 /* MII manage frame reg */
 #define FEC_MII_SPEED           0x044 /* MII speed control reg */
 #define FEC_R_BOUND             0x08c /* FIFO receive bound reg */
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 1094d292630f..3b4e0766c7b2 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -3514,11 +3514,13 @@ static irqreturn_t nv_nic_irq(int foo, void *data)
         nv_msi_workaround(np);
 
 #ifdef CONFIG_FORCEDETH_NAPI
-        napi_schedule(&np->napi);
-
-        /* Disable furthur irq's
-           (msix not enabled with napi) */
-        writel(0, base + NvRegIrqMask);
+        if (napi_schedule_prep(&np->napi)) {
+                /*
+                 * Disable further irq's (msix not enabled with napi)
+                 */
+                writel(0, base + NvRegIrqMask);
+                __napi_schedule(&np->napi);
+        }
 
 #else
         do
@@ -3615,12 +3617,13 @@ static irqreturn_t nv_nic_irq_optimized(int foo, void *data)
         nv_msi_workaround(np);
 
 #ifdef CONFIG_FORCEDETH_NAPI
-        napi_schedule(&np->napi);
-
-        /* Disable furthur irq's
-           (msix not enabled with napi) */
-        writel(0, base + NvRegIrqMask);
-
+        if (napi_schedule_prep(&np->napi)) {
+                /*
+                 * Disable further irq's (msix not enabled with napi)
+                 */
+                writel(0, base + NvRegIrqMask);
+                __napi_schedule(&np->napi);
+        }
 #else
         do
         {
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index 3af581303ca2..d167090248e2 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -188,7 +188,7 @@ static int fsl_pq_mdio_find_free(struct mii_bus *new_bus)
 }
 
 
-#ifdef CONFIG_GIANFAR
+#if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
 static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs)
 {
         struct gfar __iomem *enet_regs;
@@ -206,7 +206,7 @@ static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs)
 #endif
 
 
-#ifdef CONFIG_UCC_GETH
+#if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE)
 static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id)
 {
         struct device_node *np = NULL;
@@ -291,7 +291,7 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
         if (of_device_is_compatible(np, "fsl,gianfar-mdio") ||
                         of_device_is_compatible(np, "fsl,gianfar-tbi") ||
                         of_device_is_compatible(np, "gianfar")) {
-#ifdef CONFIG_GIANFAR
+#if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
                 tbipa = get_gfar_tbipa(regs);
 #else
                 err = -ENODEV;
@@ -299,7 +299,7 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
 #endif
         } else if (of_device_is_compatible(np, "fsl,ucc-mdio") ||
                         of_device_is_compatible(np, "ucc_geth_phy")) {
-#ifdef CONFIG_UCC_GETH
+#if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE)
                 u32 id;
                 static u32 mii_mng_master;
 
diff --git a/drivers/net/hamachi.c b/drivers/net/hamachi.c
index 9d5b62cb30f7..d62378cbc149 100644
--- a/drivers/net/hamachi.c
+++ b/drivers/net/hamachi.c
@@ -173,8 +173,8 @@ static int tx_params[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
 
 static const char version[] __devinitconst =
 KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE "  Written by Donald Becker\n"
-KERN_INFO "   Some modifications by Eric kasten <kasten@nscl.msu.edu>\n"
-KERN_INFO "   Further modifications by Keith Underwood <keithu@parl.clemson.edu>\n";
+"   Some modifications by Eric kasten <kasten@nscl.msu.edu>\n"
+"   Further modifications by Keith Underwood <keithu@parl.clemson.edu>\n";
 
 
 /* IP_MF appears to be only defined in <netinet/ip.h>, however,
@@ -1080,11 +1080,14 @@ static void hamachi_tx_timeout(struct net_device *dev)
         {
                 printk(KERN_DEBUG "  Rx ring %p: ", hmp->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++)
-                        printk(" %8.8x", le32_to_cpu(hmp->rx_ring[i].status_n_length));
-                printk("\n"KERN_DEBUG"  Tx ring %p: ", hmp->tx_ring);
+                        printk(KERN_CONT " %8.8x",
+                               le32_to_cpu(hmp->rx_ring[i].status_n_length));
+                printk(KERN_CONT "\n");
+                printk(KERN_DEBUG"  Tx ring %p: ", hmp->tx_ring);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" %4.4x", le32_to_cpu(hmp->tx_ring[i].status_n_length));
-                printk("\n");
+                        printk(KERN_CONT " %4.4x",
+                               le32_to_cpu(hmp->tx_ring[i].status_n_length));
+                printk(KERN_CONT "\n");
         }
 
         /* Reinit the hardware and make sure the Rx and Tx processes
@@ -1753,13 +1756,13 @@ static int hamachi_close(struct net_device *dev)
 
 #ifdef __i386__
         if (hamachi_debug > 2) {
-                printk("\n"KERN_DEBUG"  Tx ring at %8.8x:\n",
+                printk(KERN_DEBUG "  Tx ring at %8.8x:\n",
                            (int)hmp->tx_ring_dma);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" %c #%d desc. %8.8x %8.8x.\n",
+                        printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x.\n",
                                    readl(ioaddr + TxCurPtr) == (long)&hmp->tx_ring[i] ? '>' : ' ',
                                    i, hmp->tx_ring[i].status_n_length, hmp->tx_ring[i].addr);
-                printk("\n"KERN_DEBUG "  Rx ring %8.8x:\n",
+                printk(KERN_DEBUG "  Rx ring %8.8x:\n",
                            (int)hmp->rx_ring_dma);
                 for (i = 0; i < RX_RING_SIZE; i++) {
                         printk(KERN_DEBUG " %c #%d desc. %4.4x %8.8x\n",
@@ -1770,7 +1773,7 @@ static int hamachi_close(struct net_device *dev)
                                         u16 *addr = (u16 *)
                                                 hmp->rx_skbuff[i]->data;
                                         int j;
-
+                                        printk(KERN_DEBUG "Addr: ");
                                         for (j = 0; j < 0x50; j++)
                                                 printk(" %4.4x", addr[j]);
                                         printk("\n");
diff --git a/drivers/net/hamradio/baycom_epp.c b/drivers/net/hamradio/baycom_epp.c
index 5e4b7afd0683..352703255bba 100644
--- a/drivers/net/hamradio/baycom_epp.c
+++ b/drivers/net/hamradio/baycom_epp.c
@@ -68,7 +68,7 @@ static const char paranoia_str[] = KERN_ERR
 
 static const char bc_drvname[] = "baycom_epp";
 static const char bc_drvinfo[] = KERN_INFO "baycom_epp: (C) 1998-2000 Thomas Sailer, HB9JNX/AE4WA\n"
-KERN_INFO "baycom_epp: version 0.7 compiled " __TIME__ " " __DATE__ "\n";
+"baycom_epp: version 0.7 compiled " __TIME__ " " __DATE__ "\n";
 
 /* --------------------------------------------------------------------- */
 
diff --git a/drivers/net/hamradio/baycom_par.c b/drivers/net/hamradio/baycom_par.c
index 2e6fc4dc74b1..5f5af9a606f8 100644
--- a/drivers/net/hamradio/baycom_par.c
+++ b/drivers/net/hamradio/baycom_par.c
@@ -102,7 +102,7 @@
 
 static const char bc_drvname[] = "baycom_par";
 static const char bc_drvinfo[] = KERN_INFO "baycom_par: (C) 1996-2000 Thomas Sailer, HB9JNX/AE4WA\n"
-KERN_INFO "baycom_par: version 0.9 compiled " __TIME__ " " __DATE__ "\n";
+"baycom_par: version 0.9 compiled " __TIME__ " " __DATE__ "\n";
 
 /* --------------------------------------------------------------------- */
 
diff --git a/drivers/net/hamradio/baycom_ser_fdx.c b/drivers/net/hamradio/baycom_ser_fdx.c
index b6a816e60c0f..aa4488e871b2 100644
--- a/drivers/net/hamradio/baycom_ser_fdx.c
+++ b/drivers/net/hamradio/baycom_ser_fdx.c
@@ -91,7 +91,7 @@
 
 static const char bc_drvname[] = "baycom_ser_fdx";
 static const char bc_drvinfo[] = KERN_INFO "baycom_ser_fdx: (C) 1996-2000 Thomas Sailer, HB9JNX/AE4WA\n"
-KERN_INFO "baycom_ser_fdx: version 0.10 compiled " __TIME__ " " __DATE__ "\n";
+"baycom_ser_fdx: version 0.10 compiled " __TIME__ " " __DATE__ "\n";
 
 /* --------------------------------------------------------------------- */
 
diff --git a/drivers/net/hamradio/baycom_ser_hdx.c b/drivers/net/hamradio/baycom_ser_hdx.c
index 3bcc57acbe6d..88c593596020 100644
--- a/drivers/net/hamradio/baycom_ser_hdx.c
+++ b/drivers/net/hamradio/baycom_ser_hdx.c
@@ -79,7 +79,7 @@
 
 static const char bc_drvname[] = "baycom_ser_hdx";
 static const char bc_drvinfo[] = KERN_INFO "baycom_ser_hdx: (C) 1996-2000 Thomas Sailer, HB9JNX/AE4WA\n"
-KERN_INFO "baycom_ser_hdx: version 0.10 compiled " __TIME__ " " __DATE__ "\n";
+"baycom_ser_hdx: version 0.10 compiled " __TIME__ " " __DATE__ "\n";
 
 /* --------------------------------------------------------------------- */
 
diff --git a/drivers/net/igb/e1000_82575.c b/drivers/net/igb/e1000_82575.c
index efd9be214885..ac28dd5a4fd1 100644
--- a/drivers/net/igb/e1000_82575.c
+++ b/drivers/net/igb/e1000_82575.c
@@ -190,6 +190,10 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
                 phy->ops.write_reg          = igb_write_phy_reg_igp;
         }
 
+        /* set lan id */
+        hw->bus.func = (rd32(E1000_STATUS) & E1000_STATUS_FUNC_MASK) >>
+                       E1000_STATUS_FUNC_SHIFT;
+
         /* Set phy->phy_addr and phy->id. */
         ret_val = igb_get_phy_id_82575(hw);
         if (ret_val)
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index ea17319624aa..be480292aba1 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -4549,11 +4549,12 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
                 cleaned = true;
                 cleaned_count++;
 
+                /* this is the fast path for the non-packet split case */
                 if (!adapter->rx_ps_hdr_size) {
                         pci_unmap_single(pdev, buffer_info->dma,
-                                         adapter->rx_buffer_len +
-                                           NET_IP_ALIGN,
+                                         adapter->rx_buffer_len,
                                          PCI_DMA_FROMDEVICE);
+                        buffer_info->dma = 0;
                         skb_put(skb, length);
                         goto send_up;
                 }
@@ -4570,8 +4571,9 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
 
                 if (!skb_shinfo(skb)->nr_frags) {
                         pci_unmap_single(pdev, buffer_info->dma,
-                                         adapter->rx_ps_hdr_size + NET_IP_ALIGN,
+                                         adapter->rx_ps_hdr_size,
                                          PCI_DMA_FROMDEVICE);
+                        buffer_info->dma = 0;
                         skb_put(skb, hlen);
                 }
 
@@ -4713,7 +4715,6 @@ static void igb_alloc_rx_buffers_adv(struct igb_ring *rx_ring,
                 bufsz = adapter->rx_ps_hdr_size;
         else
                 bufsz = adapter->rx_buffer_len;
-        bufsz += NET_IP_ALIGN;
 
         while (cleaned_count--) {
                 rx_desc = E1000_RX_DESC_ADV(*rx_ring, i);
@@ -4737,7 +4738,7 @@ static void igb_alloc_rx_buffers_adv(struct igb_ring *rx_ring,
                 }
 
                 if (!buffer_info->skb) {
-                        skb = netdev_alloc_skb(netdev, bufsz);
+                        skb = netdev_alloc_skb(netdev, bufsz + NET_IP_ALIGN);
                         if (!skb) {
                                 adapter->alloc_rx_buff_failed++;
                                 goto no_buffers;
@@ -5338,6 +5339,9 @@ static pci_ers_result_t igb_io_error_detected(struct pci_dev *pdev,
 
         netif_device_detach(netdev);
 
+        if (state == pci_channel_io_perm_failure)
+                return PCI_ERS_RESULT_DISCONNECT;
+
         if (netif_running(netdev))
                 igb_down(adapter);
         pci_disable_device(pdev);
diff --git a/drivers/net/irda/bfin_sir.c b/drivers/net/irda/bfin_sir.c
index f3eed6a8fba5..911c082cee5a 100644
--- a/drivers/net/irda/bfin_sir.c
+++ b/drivers/net/irda/bfin_sir.c
@@ -677,6 +677,14 @@ static int bfin_sir_init_iobuf(iobuff_t *io, int size)
         return 0;
 }
 
+static const struct net_device_ops bfin_sir_ndo = {
+        .ndo_open               = bfin_sir_open,
+        .ndo_stop               = bfin_sir_stop,
+        .ndo_start_xmit         = bfin_sir_hard_xmit,
+        .ndo_do_ioctl           = bfin_sir_ioctl,
+        .ndo_get_stats          = bfin_sir_stats,
+};
+
 static int __devinit bfin_sir_probe(struct platform_device *pdev)
 {
         struct net_device *dev;
@@ -718,12 +726,8 @@ static int __devinit bfin_sir_probe(struct platform_device *pdev)
         if (err)
                 goto err_mem_3;
 
-        dev->hard_start_xmit = bfin_sir_hard_xmit;
-        dev->open            = bfin_sir_open;
-        dev->stop            = bfin_sir_stop;
-        dev->do_ioctl        = bfin_sir_ioctl;
-        dev->get_stats       = bfin_sir_stats;
-        dev->irq             = sir_port->irq;
+        dev->netdev_ops = &bfin_sir_ndo;
+        dev->irq = sir_port->irq;
 
         irda_init_max_qos_capabilies(&self->qos);
 
diff --git a/drivers/net/ixgbe/ixgbe_dcb_nl.c b/drivers/net/ixgbe/ixgbe_dcb_nl.c
index d56890f5c9d5..7c5978ad929a 100644
--- a/drivers/net/ixgbe/ixgbe_dcb_nl.c
+++ b/drivers/net/ixgbe/ixgbe_dcb_nl.c
@@ -138,6 +138,10 @@ static u8 ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
                         adapter->hw.fc.requested_mode = ixgbe_fc_none;
                 }
                 adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
+                if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
+                        adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
+                        adapter->flags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
+                }
                 adapter->flags |= IXGBE_FLAG_DCB_ENABLED;
                 ixgbe_init_interrupt_scheme(adapter);
                 if (netif_running(netdev))
@@ -154,6 +158,8 @@ static u8 ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
                         adapter->dcb_cfg.pfc_mode_enable = false;
                         adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
                         adapter->flags |= IXGBE_FLAG_RSS_ENABLED;
+                        if (adapter->hw.mac.type == ixgbe_mac_82599EB)
+                                adapter->flags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
                         ixgbe_init_interrupt_scheme(adapter);
                         if (netif_running(netdev))
                                 netdev->netdev_ops->ndo_open(netdev);
diff --git a/drivers/net/ixgbe/ixgbe_ethtool.c b/drivers/net/ixgbe/ixgbe_ethtool.c
index 86f4f3e36f27..2a978008fd6e 100644
--- a/drivers/net/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ixgbe/ixgbe_ethtool.c
@@ -139,7 +139,7 @@ static int ixgbe_get_settings(struct net_device *netdev,
         ecmd->autoneg = AUTONEG_ENABLE;
         ecmd->transceiver = XCVR_EXTERNAL;
         if ((hw->phy.media_type == ixgbe_media_type_copper) ||
-            (hw->mac.type == ixgbe_mac_82599EB)) {
+            (hw->phy.multispeed_fiber)) {
                 ecmd->supported |= (SUPPORTED_1000baseT_Full |
                                     SUPPORTED_Autoneg);
 
@@ -217,7 +217,7 @@ static int ixgbe_set_settings(struct net_device *netdev,
         s32 err = 0;
 
         if ((hw->phy.media_type == ixgbe_media_type_copper) ||
-            (hw->mac.type == ixgbe_mac_82599EB)) {
+            (hw->phy.multispeed_fiber)) {
                 /* 10000/copper and 1000/copper must autoneg
                  * this function does not support any duplex forcing, but can
                  * limit the advertising of the adapter to only 10000 or 1000 */
@@ -245,6 +245,7 @@ static int ixgbe_set_settings(struct net_device *netdev,
         } else {
                 /* in this case we currently only support 10Gb/FULL */
                 if ((ecmd->autoneg == AUTONEG_ENABLE) ||
+                    (ecmd->advertising != ADVERTISED_10000baseT_Full) ||
                     (ecmd->speed + ecmd->duplex != SPEED_10000 + DUPLEX_FULL))
                         return -EINVAL;
         }
@@ -1829,7 +1830,6 @@ static int ixgbe_wol_exclusion(struct ixgbe_adapter *adapter,
                 break;
         default:
                 wol->supported = 0;
-                retval = 0;
         }
 
         return retval;
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index e756e220db32..e3442f47f932 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -563,7 +563,6 @@ static void ixgbe_alloc_rx_buffers(struct ixgbe_adapter *adapter,
         union ixgbe_adv_rx_desc *rx_desc;
         struct ixgbe_rx_buffer *bi;
         unsigned int i;
-        unsigned int bufsz = rx_ring->rx_buf_len + NET_IP_ALIGN;
 
         i = rx_ring->next_to_use;
         bi = &rx_ring->rx_buffer_info[i];
@@ -593,7 +592,9 @@ static void ixgbe_alloc_rx_buffers(struct ixgbe_adapter *adapter,
 
                 if (!bi->skb) {
                         struct sk_buff *skb;
-                        skb = netdev_alloc_skb(adapter->netdev, bufsz);
+                        skb = netdev_alloc_skb(adapter->netdev,
+                                               (rx_ring->rx_buf_len +
+                                                NET_IP_ALIGN));
 
                         if (!skb) {
                                 adapter->alloc_rx_buff_failed++;
@@ -608,7 +609,8 @@ static void ixgbe_alloc_rx_buffers(struct ixgbe_adapter *adapter,
                         skb_reserve(skb, NET_IP_ALIGN);
 
                         bi->skb = skb;
-                        bi->dma = pci_map_single(pdev, skb->data, bufsz,
+                        bi->dma = pci_map_single(pdev, skb->data,
+                                                 rx_ring->rx_buf_len,
                                                  PCI_DMA_FROMDEVICE);
                 }
                 /* Refresh the desc even if buffer_addrs didn't change because
@@ -732,6 +734,7 @@ static bool ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                         pci_unmap_single(pdev, rx_buffer_info->dma,
                                          rx_ring->rx_buf_len,
                                          PCI_DMA_FROMDEVICE);
+                        rx_buffer_info->dma = 0;
                         skb_put(skb, len);
                 }
 
@@ -2694,16 +2697,23 @@ static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
 
         /*
          * For hot-pluggable SFP+ devices, a new SFP+ module may have
-         * arrived before interrupts were enabled.  We need to kick off
-         * the SFP+ module setup first, then try to bring up link.
+         * arrived before interrupts were enabled but after probe.  Such
+         * devices wouldn't have their type identified yet. We need to
+         * kick off the SFP+ module setup first, then try to bring up link.
          * If we're not hot-pluggable SFP+, we just need to configure link
          * and bring it up.
          */
-        err = hw->phy.ops.identify(hw);
-        if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
-                DPRINTK(PROBE, ERR, "PHY not supported on this NIC %d\n", err);
-                ixgbe_down(adapter);
-                return err;
+        if (hw->phy.type == ixgbe_phy_unknown) {
+                err = hw->phy.ops.identify(hw);
+                if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
+                        /*
+                         * Take the device down and schedule the sfp tasklet
+                         * which will unregister_netdev and log it.
+                         */
+                        ixgbe_down(adapter);
+                        schedule_work(&adapter->sfp_config_module_task);
+                        return err;
+                }
         }
 
         if (ixgbe_is_sfp(hw)) {
@@ -2812,9 +2822,11 @@ static void ixgbe_clean_rx_ring(struct ixgbe_adapter *adapter,
                 }
                 if (!rx_buffer_info->page)
                         continue;
-                pci_unmap_page(pdev, rx_buffer_info->page_dma, PAGE_SIZE / 2,
-                               PCI_DMA_FROMDEVICE);
-                rx_buffer_info->page_dma = 0;
+                if (rx_buffer_info->page_dma) {
+                        pci_unmap_page(pdev, rx_buffer_info->page_dma,
+                                       PAGE_SIZE / 2, PCI_DMA_FROMDEVICE);
+                        rx_buffer_info->page_dma = 0;
+                }
                 put_page(rx_buffer_info->page);
                 rx_buffer_info->page = NULL;
                 rx_buffer_info->page_offset = 0;
@@ -3118,7 +3130,11 @@ static inline bool ixgbe_set_fcoe_queues(struct ixgbe_adapter *adapter)
 #endif
                 if (adapter->flags & IXGBE_FLAG_RSS_ENABLED) {
                         DPRINTK(PROBE, INFO, "FCOE enabled with RSS \n");
-                        ixgbe_set_rss_queues(adapter);
+                        if ((adapter->flags & IXGBE_FLAG_FDIR_HASH_CAPABLE) ||
+                            (adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE))
+                                ixgbe_set_fdir_queues(adapter);
+                        else
+                                ixgbe_set_rss_queues(adapter);
                 }
                 /* adding FCoE rx rings to the end */
                 f->mask = adapter->num_rx_queues;
@@ -3376,7 +3392,12 @@ static inline bool ixgbe_cache_ring_fcoe(struct ixgbe_adapter *adapter)
                 }
 #endif /* CONFIG_IXGBE_DCB */
                 if (adapter->flags & IXGBE_FLAG_RSS_ENABLED) {
-                        ixgbe_cache_ring_rss(adapter);
+                        if ((adapter->flags & IXGBE_FLAG_FDIR_HASH_CAPABLE) ||
+                            (adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE))
+                                ixgbe_cache_ring_fdir(adapter);
+                        else
+                                ixgbe_cache_ring_rss(adapter);
+
                         fcoe_i = f->mask;
                 }
                 for (i = 0; i < f->indices; i++, fcoe_i++)
@@ -3716,14 +3737,15 @@ static void ixgbe_sfp_task(struct work_struct *work)
         if ((hw->phy.type == ixgbe_phy_nl) &&
             (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) {
                 s32 ret = hw->phy.ops.identify_sfp(hw);
-                if (ret)
+                if (ret == IXGBE_ERR_SFP_NOT_PRESENT)
                         goto reschedule;
                 ret = hw->phy.ops.reset(hw);
                 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) {
-                        DPRINTK(PROBE, ERR, "failed to initialize because an "
-                                "unsupported SFP+ module type was detected.\n"
-                                "Reload the driver after installing a "
-                                "supported module.\n");
+                        dev_err(&adapter->pdev->dev, "failed to initialize "
+                                "because an unsupported SFP+ module type "
+                                "was detected.\n"
+                                "Reload the driver after installing a "
+                                "supported module.\n");
                         unregister_netdev(adapter->netdev);
                 } else {
                         DPRINTK(PROBE, INFO, "detected SFP+: %d\n",
@@ -4502,7 +4524,8 @@ static void ixgbe_multispeed_fiber_task(struct work_struct *work)
         u32 autoneg;
 
         adapter->flags |= IXGBE_FLAG_IN_SFP_LINK_TASK;
-        if (hw->mac.ops.get_link_capabilities)
+        autoneg = hw->phy.autoneg_advertised;
+        if ((!autoneg) && (hw->mac.ops.get_link_capabilities))
                 hw->mac.ops.get_link_capabilities(hw, &autoneg,
                                                   &hw->mac.autoneg);
         if (hw->mac.ops.setup_link_speed)
@@ -4524,10 +4547,17 @@ static void ixgbe_sfp_config_module_task(struct work_struct *work)
         u32 err;
 
         adapter->flags |= IXGBE_FLAG_IN_SFP_MOD_TASK;
+
+        /* Time for electrical oscillations to settle down */
+        msleep(100);
         err = hw->phy.ops.identify_sfp(hw);
+
         if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
-                DPRINTK(PROBE, ERR, "PHY not supported on this NIC %d\n", err);
-                ixgbe_down(adapter);
+                dev_err(&adapter->pdev->dev, "failed to initialize because "
+                        "an unsupported SFP+ module type was detected.\n"
+                        "Reload the driver after installing a supported "
+                        "module.\n");
+                unregister_netdev(adapter->netdev);
                 return;
         }
         hw->mac.ops.setup_sfp(hw);
@@ -5513,8 +5543,10 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
                           round_jiffies(jiffies + (2 * HZ)));
                 err = 0;
         } else if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
-                dev_err(&adapter->pdev->dev, "failed to load because an "
-                        "unsupported SFP+ module type was detected.\n");
+                dev_err(&adapter->pdev->dev, "failed to initialize because "
+                        "an unsupported SFP+ module type was detected.\n"
+                        "Reload the driver after installing a supported "
+                        "module.\n");
                 goto err_sw_init;
         } else if (err) {
                 dev_err(&adapter->pdev->dev, "HW Init failed: %d\n", err);
@@ -5555,12 +5587,6 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
                                 netdev->features |= NETIF_F_FCOE_CRC;
                                 netdev->features |= NETIF_F_FSO;
                                 netdev->fcoe_ddp_xid = IXGBE_FCOE_DDP_MAX - 1;
-                                DPRINTK(DRV, INFO, "FCoE enabled, "
-                                        "disabling Flow Director\n");
-                                adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
-                                adapter->flags &=
-                                        ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
-                                adapter->atr_sample_rate = 0;
                         } else {
                                 adapter->flags &= ~IXGBE_FLAG_FCOE_ENABLED;
                         }
diff --git a/drivers/net/ixgbe/ixgbe_phy.c b/drivers/net/ixgbe/ixgbe_phy.c
index 453e966762f0..9ecad17522c3 100644
--- a/drivers/net/ixgbe/ixgbe_phy.c
+++ b/drivers/net/ixgbe/ixgbe_phy.c
@@ -60,6 +60,7 @@ s32 ixgbe_identify_phy_generic(struct ixgbe_hw *hw)
 
         if (hw->phy.type == ixgbe_phy_unknown) {
                 for (phy_addr = 0; phy_addr < IXGBE_MAX_PHY_ADDR; phy_addr++) {
+                        hw->phy.mdio.prtad = phy_addr;
                         if (mdio45_probe(&hw->phy.mdio, phy_addr) == 0) {
                                 ixgbe_get_phy_id(hw);
                                 hw->phy.type =
@@ -68,6 +69,8 @@ s32 ixgbe_identify_phy_generic(struct ixgbe_hw *hw)
                                 break;
                         }
                 }
+                /* clear value if nothing found */
+                hw->phy.mdio.prtad = 0;
         } else {
                 status = 0;
         }
diff --git a/drivers/net/mdio.c b/drivers/net/mdio.c
index dc45e9856c35..6851bdb2ce29 100644
--- a/drivers/net/mdio.c
+++ b/drivers/net/mdio.c
@@ -14,6 +14,10 @@
 #include <linux/mdio.h>
 #include <linux/module.h>
 
+MODULE_DESCRIPTION("Generic support for MDIO-compatible transceivers");
+MODULE_AUTHOR("Copyright 2006-2009 Solarflare Communications Inc.");
+MODULE_LICENSE("GPL");
+
 /**
  * mdio45_probe - probe for an MDIO (clause 45) device
  * @mdio: MDIO interface
diff --git a/drivers/net/natsemi.c b/drivers/net/natsemi.c
index c9bfe4eea189..78c088331f57 100644
--- a/drivers/net/natsemi.c
+++ b/drivers/net/natsemi.c
@@ -130,8 +130,8 @@ static int full_duplex[MAX_UNITS];
 static const char version[] __devinitconst =
   KERN_INFO DRV_NAME " dp8381x driver, version "
       DRV_VERSION ", " DRV_RELDATE "\n"
-  KERN_INFO "  originally by Donald Becker <becker@scyld.com>\n"
-  KERN_INFO "  2.4.x kernel port by Jeff Garzik, Tjeerd Mulder\n";
+  "  originally by Donald Becker <becker@scyld.com>\n"
+  "  2.4.x kernel port by Jeff Garzik, Tjeerd Mulder\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("National Semiconductor DP8381x series PCI Ethernet driver");
diff --git a/drivers/net/ne.c b/drivers/net/ne.c
index 5c3e242428f1..992dbfffdb05 100644
--- a/drivers/net/ne.c
+++ b/drivers/net/ne.c
@@ -321,7 +321,7 @@ static int __init ne_probe1(struct net_device *dev, unsigned long ioaddr)
         }
 
         if (ei_debug  &&  version_printed++ == 0)
-                printk(KERN_INFO "%s" KERN_INFO "%s", version1, version2);
+                printk(KERN_INFO "%s%s", version1, version2);
 
         printk(KERN_INFO "NE*000 ethercard probe at %#3lx:", ioaddr);
 
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index 970cedeb5f37..e1cdba752e09 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -60,7 +60,18 @@
 #define _NETXEN_NIC_LINUX_SUBVERSION 30
 #define NETXEN_NIC_LINUX_VERSIONID  "4.0.30"
 
-#define NETXEN_VERSION_CODE(a, b, c)    (((a) << 16) + ((b) << 8) + (c))
+#define NETXEN_VERSION_CODE(a, b, c)    (((a) << 24) + ((b) << 16) + (c))
+#define _major(v)       (((v) >> 24) & 0xff)
+#define _minor(v)       (((v) >> 16) & 0xff)
+#define _build(v)       ((v) & 0xffff)
+
+/* version in image has weird encoding:
+ *  7:0  - major
+ * 15:8  - minor
+ * 31:16 - build (little endian)
+ */
+#define NETXEN_DECODE_VERSION(v) \
+        NETXEN_VERSION_CODE(((v) & 0xff), (((v) >> 8) & 0xff), ((v) >> 16))
 
 #define NETXEN_NUM_FLASH_SECTORS (64)
 #define NETXEN_FLASH_SECTOR_SIZE (64 * 1024)
@@ -614,6 +625,7 @@ struct netxen_new_user_info {
 #define NX_P2_MN_ROMIMAGE       0
 #define NX_P3_CT_ROMIMAGE       1
 #define NX_P3_MN_ROMIMAGE       2
+#define NX_FLASH_ROMIMAGE       3
 
 #define NETXEN_USER_START_OLD NETXEN_PXE_START  /* for backward compatibility */
 
@@ -1243,7 +1255,7 @@ struct netxen_adapter {
         u32 resv3;
 
         u8 has_link_events;
-        u8 resv1;
+        u8 fw_type;
         u16 tx_context_id;
         u16 mtu;
         u16 is_up;
@@ -1387,6 +1399,7 @@ void netxen_free_adapter_offload(struct netxen_adapter *adapter);
 int netxen_initialize_adapter_offload(struct netxen_adapter *adapter);
 int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val);
 int netxen_load_firmware(struct netxen_adapter *adapter);
+int netxen_need_fw_reset(struct netxen_adapter *adapter);
 void netxen_request_firmware(struct netxen_adapter *adapter);
 void netxen_release_firmware(struct netxen_adapter *adapter);
 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose);
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index 3cc047844af3..824103675648 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -853,6 +853,7 @@ enum {
 #define NX_PEG_TUNE_CAPABILITY          (NETXEN_CAM_RAM(0x02c))
 
 #define NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL                (0x14)
+#define NETXEN_PEG_ALIVE_COUNTER        (NETXEN_CAM_RAM(0xb0))
 
 #define ISR_MSI_INT_TRIGGER(FUNC) (NETXEN_PCIX_PS_REG(PCIX_MSI_F(FUNC)))
 #define ISR_LEGACY_INT_TRIGGERED(VAL)   (((VAL) & 0x300) == 0x200)
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index 055bb61d6e77..b899bd51fcd8 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -684,11 +684,84 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 }
 
 int
+netxen_need_fw_reset(struct netxen_adapter *adapter)
+{
+        u32 count, old_count;
+        u32 val, version, major, minor, build;
+        int i, timeout;
+        u8 fw_type;
+
+        /* NX2031 firmware doesn't support heartbit */
+        if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
+                return 1;
+
+        /* last attempt had failed */
+        if (NXRD32(adapter, CRB_CMDPEG_STATE) == PHAN_INITIALIZE_FAILED)
+                return 1;
+
+        old_count = count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
+
+        for (i = 0; i < 10; i++) {
+
+                timeout = msleep_interruptible(200);
+                if (timeout) {
+                        NXWR32(adapter, CRB_CMDPEG_STATE,
+                                        PHAN_INITIALIZE_FAILED);
+                        return -EINTR;
+                }
+
+                count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
+                if (count != old_count)
+                        break;
+        }
+
+        /* firmware is dead */
+        if (count == old_count)
+                return 1;
+
+        /* check if we have got newer or different file firmware */
+        if (adapter->fw) {
+
+                const struct firmware *fw = adapter->fw;
+
+                val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);
+                version = NETXEN_DECODE_VERSION(val);
+
+                major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
+                minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
+                build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
+
+                if (version > NETXEN_VERSION_CODE(major, minor, build))
+                        return 1;
+
+                if (version == NETXEN_VERSION_CODE(major, minor, build)) {
+
+                        val = NXRD32(adapter, NETXEN_MIU_MN_CONTROL);
+                        fw_type = (val & 0x4) ?
+                                NX_P3_CT_ROMIMAGE : NX_P3_MN_ROMIMAGE;
+
+                        if (adapter->fw_type != fw_type)
+                                return 1;
+                }
+        }
+
+        return 0;
+}
+
+static char *fw_name[] = {
+        "nxromimg.bin", "nx3fwct.bin", "nx3fwmn.bin", "flash",
+};
+
+int
 netxen_load_firmware(struct netxen_adapter *adapter)
 {
         u64 *ptr64;
         u32 i, flashaddr, size;
         const struct firmware *fw = adapter->fw;
+        struct pci_dev *pdev = adapter->pdev;
+
+        dev_info(&pdev->dev, "loading firmware from %s\n",
+                        fw_name[adapter->fw_type]);
 
         if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
                 NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 1);
@@ -756,7 +829,7 @@ static int
 netxen_validate_firmware(struct netxen_adapter *adapter, const char *fwname)
 {
         __le32 val;
-        u32 major, minor, build, ver, min_ver, bios;
+        u32 ver, min_ver, bios;
         struct pci_dev *pdev = adapter->pdev;
         const struct firmware *fw = adapter->fw;
 
@@ -768,21 +841,18 @@ netxen_validate_firmware(struct netxen_adapter *adapter, const char *fwname)
                 return -EINVAL;
 
         val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);
-        major = (__force u32)val & 0xff;
-        minor = ((__force u32)val >> 8) & 0xff;
-        build = (__force u32)val >> 16;
 
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
                 min_ver = NETXEN_VERSION_CODE(4, 0, 216);
         else
                 min_ver = NETXEN_VERSION_CODE(3, 4, 216);
 
-        ver = NETXEN_VERSION_CODE(major, minor, build);
+        ver = NETXEN_DECODE_VERSION(val);
 
-        if ((major > _NETXEN_NIC_LINUX_MAJOR) || (ver < min_ver)) {
+        if ((_major(ver) > _NETXEN_NIC_LINUX_MAJOR) || (ver < min_ver)) {
                 dev_err(&pdev->dev,
                                 "%s: firmware version %d.%d.%d unsupported\n",
-                                fwname, major, minor, build);
+                                fwname, _major(ver), _minor(ver), _build(ver));
                 return -EINVAL;
         }
 
@@ -798,22 +868,21 @@ netxen_validate_firmware(struct netxen_adapter *adapter, const char *fwname)
         if (netxen_rom_fast_read(adapter,
                         NX_FW_VERSION_OFFSET, (int *)&val))
                 return -EIO;
-        major = (__force u32)val & 0xff;
-        minor = ((__force u32)val >> 8) & 0xff;
-        build = (__force u32)val >> 16;
-        if (NETXEN_VERSION_CODE(major, minor, build) > ver)
+        val = NETXEN_DECODE_VERSION(val);
+        if (val > ver) {
+                dev_info(&pdev->dev, "%s: firmware is older than flash\n",
+                                fwname);
                 return -EINVAL;
+        }
 
         NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
         return 0;
 }
 
-static char *fw_name[] = { "nxromimg.bin", "nx3fwct.bin", "nx3fwmn.bin" };
-
 void netxen_request_firmware(struct netxen_adapter *adapter)
 {
         u32 capability, flashed_ver;
-        int fw_type;
+        u8 fw_type;
         struct pci_dev *pdev = adapter->pdev;
         int rc = 0;
 
@@ -830,6 +899,8 @@ request_mn:
 
         netxen_rom_fast_read(adapter,
                         NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
+        flashed_ver = NETXEN_DECODE_VERSION(flashed_ver);
+
         if (flashed_ver >= NETXEN_VERSION_CODE(4, 0, 220)) {
                 capability = NXRD32(adapter, NX_PEG_TUNE_CAPABILITY);
                 if (capability & NX_PEG_TUNE_MN_PRESENT) {
@@ -838,6 +909,10 @@ request_mn:
                 }
         }
 
+        fw_type = NX_FLASH_ROMIMAGE;
+        adapter->fw = NULL;
+        goto done;
+
 request_fw:
         rc = request_firmware(&adapter->fw, fw_name[fw_type], &pdev->dev);
         if (rc != 0) {
@@ -846,6 +921,7 @@ request_fw:
                         goto request_mn;
                 }
 
+                fw_type = NX_FLASH_ROMIMAGE;
                 adapter->fw = NULL;
                 goto done;
         }
@@ -859,16 +935,13 @@ request_fw:
                         goto request_mn;
                 }
 
+                fw_type = NX_FLASH_ROMIMAGE;
                 adapter->fw = NULL;
                 goto done;
         }
 
 done:
-        if (adapter->fw)
-                dev_info(&pdev->dev, "loading firmware from file %s\n",
-                                fw_name[fw_type]);
-        else
-                dev_info(&pdev->dev, "loading firmware from flash\n");
+        adapter->fw_type = fw_type;
 }
 
 
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 2919a2d12bf4..27539ddf94c4 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -718,6 +718,10 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
         if (request_fw)
                 netxen_request_firmware(adapter);
 
+        err = netxen_need_fw_reset(adapter);
+        if (err <= 0)
+                return err;
+
         if (first_boot != 0x55555555) {
                 NXWR32(adapter, CRB_CMDPEG_STATE, 0);
                 netxen_pinit_from_rom(adapter, 0);
diff --git a/drivers/net/pci-skeleton.c b/drivers/net/pci-skeleton.c
index 8c1f6988f398..89f7b2ad5231 100644
--- a/drivers/net/pci-skeleton.c
+++ b/drivers/net/pci-skeleton.c
@@ -105,7 +105,7 @@ IVc. Errata
 
 static char version[] __devinitdata =
 KERN_INFO NETDRV_DRIVER_LOAD_MSG "\n"
-KERN_INFO "  Support available from http://foo.com/bar/baz.html\n";
+"  Support available from http://foo.com/bar/baz.html\n";
 
 /* define to 1 to enable PIO instead of MMIO */
 #undef USE_IO_OPS
diff --git a/drivers/net/pcmcia/ibmtr_cs.c b/drivers/net/pcmcia/ibmtr_cs.c
index f51944b28cfa..06618af1a468 100644
--- a/drivers/net/pcmcia/ibmtr_cs.c
+++ b/drivers/net/pcmcia/ibmtr_cs.c
@@ -298,14 +298,11 @@ static int __devinit ibmtr_config(struct pcmcia_device *link)
 
     strcpy(info->node.dev_name, dev->name);
 
-    printk(KERN_INFO "%s: port %#3lx, irq %d,",
-           dev->name, dev->base_addr, dev->irq);
-    printk (" mmio %#5lx,", (u_long)ti->mmio);
-    printk (" sram %#5lx,", (u_long)ti->sram_base << 12);
-    printk ("\n" KERN_INFO "  hwaddr=");
-    for (i = 0; i < TR_ALEN; i++)
-        printk("%02X", dev->dev_addr[i]);
-    printk("\n");
+    printk(KERN_INFO
+           "%s: port %#3lx, irq %d,  mmio %#5lx, sram %#5lx, hwaddr=%pM\n",
+           dev->name, dev->base_addr, dev->irq,
+           (u_long)ti->mmio, (u_long)(ti->sram_base << 12),
+           dev->dev_addr);
     return 0;
 
 cs_failed:
diff --git a/drivers/net/pcmcia/nmclan_cs.c b/drivers/net/pcmcia/nmclan_cs.c
index 02ef63ed1f99..36de91baf238 100644
--- a/drivers/net/pcmcia/nmclan_cs.c
+++ b/drivers/net/pcmcia/nmclan_cs.c
@@ -1425,15 +1425,12 @@ static void BuildLAF(int *ladrf, int *adr)
   ladrf[byte] |= (1 << (hashcode & 7));
 
 #ifdef PCMCIA_DEBUG
-  if (pc_debug > 2) {
-    printk(KERN_DEBUG "    adr =");
-    for (i = 0; i < 6; i++)
-      printk(" %02X", adr[i]);
-    printk("\n" KERN_DEBUG "    hashcode = %d(decimal), ladrf[0:63]"
-           " =", hashcode);
-    for (i = 0; i < 8; i++)
-      printk(" %02X", ladrf[i]);
-    printk("\n");
+  if (pc_debug > 2)
+    printk(KERN_DEBUG "    adr =%pM\n", adr);
+  printk(KERN_DEBUG "    hashcode = %d(decimal), ladrf[0:63] =", hashcode);
+  for (i = 0; i < 8; i++)
+    printk(KERN_CONT " %02X", ladrf[i]);
+  printk(KERN_CONT "\n");
   }
 #endif
 } /* BuildLAF */
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index 652a36888361..9ef1c1bfa83d 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1727,6 +1727,7 @@ static struct pcmcia_device_id pcnet_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("PRETEC", "Ethernet CompactLAN 10BaseT 3.3V", 0xebf91155, 0x7f5a4f50),
         PCMCIA_DEVICE_PROD_ID12("Psion Dacom", "Gold Card Ethernet", 0xf5f025c2, 0x3a30e110),
         PCMCIA_DEVICE_PROD_ID12("=RELIA==", "Ethernet", 0xcdd0644a, 0x00b2e941),
+        PCMCIA_DEVICE_PROD_ID12("RIOS Systems Co.", "PC CARD3 ETHERNET", 0x7dd33481, 0x10b41826),
         PCMCIA_DEVICE_PROD_ID12("RP", "1625B Ethernet NE2000 Compatible", 0xe3e66e22, 0xb96150df),
         PCMCIA_DEVICE_PROD_ID12("RPTI", "EP400 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4a7e2ae0),
         PCMCIA_DEVICE_PROD_ID12("RPTI", "EP401 Ethernet NE2000 Compatible", 0xdc6f88fd, 0x4bcbd7fd),
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 1c35e1d637a0..28368157dac4 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -485,7 +485,7 @@ static void pcnet32_realloc_tx_ring(struct net_device *dev,
                                            &new_ring_dma_addr);
         if (new_tx_ring == NULL) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR
+                        printk(KERN_ERR
                                "%s: Consistent memory allocation failed.\n",
                                dev->name);
                 return;
@@ -496,7 +496,7 @@ static void pcnet32_realloc_tx_ring(struct net_device *dev,
                                 GFP_ATOMIC);
         if (!new_dma_addr_list) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR
+                        printk(KERN_ERR
                                "%s: Memory allocation failed.\n", dev->name);
                 goto free_new_tx_ring;
         }
@@ -505,7 +505,7 @@ static void pcnet32_realloc_tx_ring(struct net_device *dev,
                                 GFP_ATOMIC);
         if (!new_skb_list) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR
+                        printk(KERN_ERR
                                "%s: Memory allocation failed.\n", dev->name);
                 goto free_new_lists;
         }
@@ -563,7 +563,7 @@ static void pcnet32_realloc_rx_ring(struct net_device *dev,
                                            &new_ring_dma_addr);
         if (new_rx_ring == NULL) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR
+                        printk(KERN_ERR
                                "%s: Consistent memory allocation failed.\n",
                                dev->name);
                 return;
@@ -574,7 +574,7 @@ static void pcnet32_realloc_rx_ring(struct net_device *dev,
                                 GFP_ATOMIC);
         if (!new_dma_addr_list) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR
+                        printk(KERN_ERR
                                "%s: Memory allocation failed.\n", dev->name);
                 goto free_new_rx_ring;
         }
@@ -583,7 +583,7 @@ static void pcnet32_realloc_rx_ring(struct net_device *dev,
                                 GFP_ATOMIC);
         if (!new_skb_list) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR
+                        printk(KERN_ERR
                                "%s: Memory allocation failed.\n", dev->name);
                 goto free_new_lists;
         }
@@ -1766,38 +1766,38 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
                 /* Version 0x2623 and 0x2624 */
                 if (((chip_version + 1) & 0xfffe) == 0x2624) {
                         i = a->read_csr(ioaddr, 80) & 0x0C00;   /* Check tx_start_pt */
-                        printk("\n" KERN_INFO "    tx_start_pt(0x%04x):", i);
+                        printk(KERN_INFO "    tx_start_pt(0x%04x):", i);
                         switch (i >> 10) {
                         case 0:
-                                printk("  20 bytes,");
+                                printk(KERN_CONT "  20 bytes,");
                                 break;
                         case 1:
-                                printk("  64 bytes,");
+                                printk(KERN_CONT "  64 bytes,");
                                 break;
                         case 2:
-                                printk(" 128 bytes,");
+                                printk(KERN_CONT " 128 bytes,");
                                 break;
                         case 3:
-                                printk("~220 bytes,");
+                                printk(KERN_CONT "~220 bytes,");
                                 break;
                         }
                         i = a->read_bcr(ioaddr, 18);    /* Check Burst/Bus control */
-                        printk(" BCR18(%x):", i & 0xffff);
+                        printk(KERN_CONT " BCR18(%x):", i & 0xffff);
                         if (i & (1 << 5))
-                                printk("BurstWrEn ");
+                                printk(KERN_CONT "BurstWrEn ");
                         if (i & (1 << 6))
-                                printk("BurstRdEn ");
+                                printk(KERN_CONT "BurstRdEn ");
                         if (i & (1 << 7))
-                                printk("DWordIO ");
+                                printk(KERN_CONT "DWordIO ");
                         if (i & (1 << 11))
-                                printk("NoUFlow ");
+                                printk(KERN_CONT "NoUFlow ");
                         i = a->read_bcr(ioaddr, 25);
-                        printk("\n" KERN_INFO "    SRAMSIZE=0x%04x,", i << 8);
+                        printk(KERN_INFO "    SRAMSIZE=0x%04x,", i << 8);
                         i = a->read_bcr(ioaddr, 26);
-                        printk(" SRAM_BND=0x%04x,", i << 8);
+                        printk(KERN_CONT " SRAM_BND=0x%04x,", i << 8);
                         i = a->read_bcr(ioaddr, 27);
                         if (i & (1 << 14))
-                                printk("LowLatRx");
+                                printk(KERN_CONT "LowLatRx");
                 }
         }
 
@@ -1996,7 +1996,7 @@ static int pcnet32_alloc_ring(struct net_device *dev, const char *name)
                                            &lp->tx_ring_dma_addr);
         if (lp->tx_ring == NULL) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR PFX
+                        printk(KERN_ERR PFX
                                "%s: Consistent memory allocation failed.\n",
                                name);
                 return -ENOMEM;
@@ -2008,7 +2008,7 @@ static int pcnet32_alloc_ring(struct net_device *dev, const char *name)
                                            &lp->rx_ring_dma_addr);
         if (lp->rx_ring == NULL) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR PFX
+                        printk(KERN_ERR PFX
                                "%s: Consistent memory allocation failed.\n",
                                name);
                 return -ENOMEM;
@@ -2018,7 +2018,7 @@ static int pcnet32_alloc_ring(struct net_device *dev, const char *name)
                                   GFP_ATOMIC);
         if (!lp->tx_dma_addr) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR PFX
+                        printk(KERN_ERR PFX
                                "%s: Memory allocation failed.\n", name);
                 return -ENOMEM;
         }
@@ -2027,7 +2027,7 @@ static int pcnet32_alloc_ring(struct net_device *dev, const char *name)
                                   GFP_ATOMIC);
         if (!lp->rx_dma_addr) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR PFX
+                        printk(KERN_ERR PFX
                                "%s: Memory allocation failed.\n", name);
                 return -ENOMEM;
         }
@@ -2036,7 +2036,7 @@ static int pcnet32_alloc_ring(struct net_device *dev, const char *name)
                                 GFP_ATOMIC);
         if (!lp->tx_skbuff) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR PFX
+                        printk(KERN_ERR PFX
                                "%s: Memory allocation failed.\n", name);
                 return -ENOMEM;
         }
@@ -2045,7 +2045,7 @@ static int pcnet32_alloc_ring(struct net_device *dev, const char *name)
                                 GFP_ATOMIC);
         if (!lp->rx_skbuff) {
                 if (netif_msg_drv(lp))
-                        printk("\n" KERN_ERR PFX
+                        printk(KERN_ERR PFX
                                "%s: Memory allocation failed.\n", name);
                 return -ENOMEM;
         }
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index 61755cbd978e..eda94fcd4065 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -928,13 +928,32 @@ static void phy_state_machine(struct work_struct *work)
                                  * Otherwise, it's 0, and we're
                                  * still waiting for AN */
                                 if (err > 0) {
-                                        phydev->state = PHY_RUNNING;
+                                        err = phy_read_status(phydev);
+                                        if (err)
+                                                break;
+
+                                        if (phydev->link) {
+                                                phydev->state = PHY_RUNNING;
+                                                netif_carrier_on(phydev->attached_dev);
+                                        } else
+                                                phydev->state = PHY_NOLINK;
+                                        phydev->adjust_link(phydev->attached_dev);
                                 } else {
                                         phydev->state = PHY_AN;
                                         phydev->link_timeout = PHY_AN_TIMEOUT;
                                 }
-                        } else
-                                phydev->state = PHY_RUNNING;
+                        } else {
+                                err = phy_read_status(phydev);
+                                if (err)
+                                        break;
+
+                                if (phydev->link) {
+                                        phydev->state = PHY_RUNNING;
+                                        netif_carrier_on(phydev->attached_dev);
+                                } else
+                                        phydev->state = PHY_NOLINK;
+                                phydev->adjust_link(phydev->attached_dev);
+                        }
                         break;
         }
 
diff --git a/drivers/net/qlge/qlge.h b/drivers/net/qlge/qlge.h
index 156e02e8905d..6ed5317ab1c0 100644
--- a/drivers/net/qlge/qlge.h
+++ b/drivers/net/qlge/qlge.h
@@ -1607,6 +1607,8 @@ int ql_mb_get_fw_state(struct ql_adapter *qdev);
 int ql_cam_route_initialize(struct ql_adapter *qdev);
 int ql_read_mpi_reg(struct ql_adapter *qdev, u32 reg, u32 *data);
 int ql_mb_about_fw(struct ql_adapter *qdev);
+void ql_link_on(struct ql_adapter *qdev);
+void ql_link_off(struct ql_adapter *qdev);
 
 #if 1
 #define QL_ALL_DUMP
diff --git a/drivers/net/qlge/qlge_ethtool.c b/drivers/net/qlge/qlge_ethtool.c
index 37c99fe79770..eb6a9ee640ed 100644
--- a/drivers/net/qlge/qlge_ethtool.c
+++ b/drivers/net/qlge/qlge_ethtool.c
@@ -59,7 +59,7 @@ static int ql_update_ring_coalescing(struct ql_adapter *qdev)
                         cqicb->pkt_delay =
                             cpu_to_le16(qdev->tx_max_coalesced_frames);
                         cqicb->flags = FLAGS_LI;
-                        status = ql_write_cfg(qdev, cqicb, sizeof(cqicb),
+                        status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
                                                 CFG_LCQ, rx_ring->cq_id);
                         if (status) {
                                 QPRINTK(qdev, IFUP, ERR,
@@ -82,7 +82,7 @@ static int ql_update_ring_coalescing(struct ql_adapter *qdev)
                         cqicb->pkt_delay =
                             cpu_to_le16(qdev->rx_max_coalesced_frames);
                         cqicb->flags = FLAGS_LI;
-                        status = ql_write_cfg(qdev, cqicb, sizeof(cqicb),
+                        status = ql_write_cfg(qdev, cqicb, sizeof(*cqicb),
                                                 CFG_LCQ, rx_ring->cq_id);
                         if (status) {
                                 QPRINTK(qdev, IFUP, ERR,
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index 90d1f76c0e8b..5768af17f168 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -214,6 +214,10 @@ int ql_write_cfg(struct ql_adapter *qdev, void *ptr, int size, u32 bit,
                 return -ENOMEM;
         }
 
+        status = ql_sem_spinlock(qdev, SEM_ICB_MASK);
+        if (status)
+                return status;
+
         status = ql_wait_cfg(qdev, bit);
         if (status) {
                 QPRINTK(qdev, IFUP, ERR,
@@ -221,12 +225,8 @@ int ql_write_cfg(struct ql_adapter *qdev, void *ptr, int size, u32 bit,
                 goto exit;
         }
 
-        status = ql_sem_spinlock(qdev, SEM_ICB_MASK);
-        if (status)
-                goto exit;
         ql_write32(qdev, ICB_L, (u32) map);
         ql_write32(qdev, ICB_H, (u32) (map >> 32));
-        ql_sem_unlock(qdev, SEM_ICB_MASK);      /* does flush too */
 
         mask = CFG_Q_MASK | (bit << 16);
         value = bit | (q_id << CFG_Q_SHIFT);
@@ -237,6 +237,7 @@ int ql_write_cfg(struct ql_adapter *qdev, void *ptr, int size, u32 bit,
          */
         status = ql_wait_cfg(qdev, bit);
 exit:
+        ql_sem_unlock(qdev, SEM_ICB_MASK);      /* does flush too */
         pci_unmap_single(qdev->pdev, map, size, direction);
         return status;
 }
@@ -412,6 +413,57 @@ exit:
         return status;
 }
 
+/* Set or clear MAC address in hardware. We sometimes
+ * have to clear it to prevent wrong frame routing
+ * especially in a bonding environment.
+ */
+static int ql_set_mac_addr(struct ql_adapter *qdev, int set)
+{
+        int status;
+        char zero_mac_addr[ETH_ALEN];
+        char *addr;
+
+        if (set) {
+                addr = &qdev->ndev->dev_addr[0];
+                QPRINTK(qdev, IFUP, DEBUG,
+                        "Set Mac addr %02x:%02x:%02x:%02x:%02x:%02x\n",
+                        addr[0], addr[1], addr[2], addr[3],
+                        addr[4], addr[5]);
+        } else {
+                memset(zero_mac_addr, 0, ETH_ALEN);
+                addr = &zero_mac_addr[0];
+                QPRINTK(qdev, IFUP, DEBUG,
+                                "Clearing MAC address on %s\n",
+                                qdev->ndev->name);
+        }
+        status = ql_sem_spinlock(qdev, SEM_MAC_ADDR_MASK);
+        if (status)
+                return status;
+        status = ql_set_mac_addr_reg(qdev, (u8 *) addr,
+                        MAC_ADDR_TYPE_CAM_MAC, qdev->func * MAX_CQ);
+        ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK);
+        if (status)
+                QPRINTK(qdev, IFUP, ERR, "Failed to init mac "
+                        "address.\n");
+        return status;
+}
+
+void ql_link_on(struct ql_adapter *qdev)
+{
+        QPRINTK(qdev, LINK, ERR, "%s: Link is up.\n",
+                                 qdev->ndev->name);
+        netif_carrier_on(qdev->ndev);
+        ql_set_mac_addr(qdev, 1);
+}
+
+void ql_link_off(struct ql_adapter *qdev)
+{
+        QPRINTK(qdev, LINK, ERR, "%s: Link is down.\n",
+                                 qdev->ndev->name);
+        netif_carrier_off(qdev->ndev);
+        ql_set_mac_addr(qdev, 0);
+}
+
 /* Get a specific frame routing value from the CAM.
  * Used for debug and reg dump.
  */
@@ -1628,7 +1680,7 @@ static void ql_process_mac_tx_intr(struct ql_adapter *qdev,
         tx_ring = &qdev->tx_ring[mac_rsp->txq_idx];
         tx_ring_desc = &tx_ring->q[mac_rsp->tid];
         ql_unmap_send(qdev, tx_ring_desc, tx_ring_desc->map_cnt);
-        qdev->stats.tx_bytes += tx_ring_desc->map_cnt;
+        qdev->stats.tx_bytes += (tx_ring_desc->skb)->len;
         qdev->stats.tx_packets++;
         dev_kfree_skb(tx_ring_desc->skb);
         tx_ring_desc->skb = NULL;
@@ -1660,13 +1712,13 @@ static void ql_process_mac_tx_intr(struct ql_adapter *qdev,
 /* Fire up a handler to reset the MPI processor. */
 void ql_queue_fw_error(struct ql_adapter *qdev)
 {
-        netif_carrier_off(qdev->ndev);
+        ql_link_off(qdev);
         queue_delayed_work(qdev->workqueue, &qdev->mpi_reset_work, 0);
 }
 
 void ql_queue_asic_error(struct ql_adapter *qdev)
 {
-        netif_carrier_off(qdev->ndev);
+        ql_link_off(qdev);
         ql_disable_interrupts(qdev);
         /* Clear adapter up bit to signal the recovery
          * process that it shouldn't kill the reset worker
@@ -2104,7 +2156,7 @@ static int qlge_send(struct sk_buff *skb, struct net_device *ndev)
         }
         tx_ring_desc = &tx_ring->q[tx_ring->prod_idx];
         mac_iocb_ptr = tx_ring_desc->queue_entry;
-        memset((void *)mac_iocb_ptr, 0, sizeof(mac_iocb_ptr));
+        memset((void *)mac_iocb_ptr, 0, sizeof(*mac_iocb_ptr));
 
         mac_iocb_ptr->opcode = OPCODE_OB_MAC_IOCB;
         mac_iocb_ptr->tid = tx_ring_desc->index;
@@ -2743,7 +2795,7 @@ static int ql_start_tx_ring(struct ql_adapter *qdev, struct tx_ring *tx_ring)
 
         ql_init_tx_ring(qdev, tx_ring);
 
-        err = ql_write_cfg(qdev, wqicb, sizeof(wqicb), CFG_LRQ,
+        err = ql_write_cfg(qdev, wqicb, sizeof(*wqicb), CFG_LRQ,
                            (u16) tx_ring->wq_id);
         if (err) {
                 QPRINTK(qdev, IFUP, ERR, "Failed to load tx_ring.\n");
@@ -3008,7 +3060,7 @@ static int ql_start_rss(struct ql_adapter *qdev)
         int i;
         u8 *hash_id = (u8 *) ricb->hash_cq_id;
 
-        memset((void *)ricb, 0, sizeof(ricb));
+        memset((void *)ricb, 0, sizeof(*ricb));
 
         ricb->base_cq = qdev->rss_ring_first_cq_id | RSS_L4K;
         ricb->flags =
@@ -3030,7 +3082,7 @@ static int ql_start_rss(struct ql_adapter *qdev)
 
         QPRINTK(qdev, IFUP, DEBUG, "Initializing RSS.\n");
 
-        status = ql_write_cfg(qdev, ricb, sizeof(ricb), CFG_LR, 0);
+        status = ql_write_cfg(qdev, ricb, sizeof(*ricb), CFG_LR, 0);
         if (status) {
                 QPRINTK(qdev, IFUP, ERR, "Failed to load RICB.\n");
                 return status;
@@ -3039,25 +3091,40 @@ static int ql_start_rss(struct ql_adapter *qdev)
         return status;
 }
 
-/* Initialize the frame-to-queue routing. */
-static int ql_route_initialize(struct ql_adapter *qdev)
+static int ql_clear_routing_entries(struct ql_adapter *qdev)
 {
-        int status = 0;
-        int i;
+        int i, status = 0;
 
         status = ql_sem_spinlock(qdev, SEM_RT_IDX_MASK);
         if (status)
                 return status;
-
         /* Clear all the entries in the routing table. */
         for (i = 0; i < 16; i++) {
                 status = ql_set_routing_reg(qdev, i, 0, 0);
                 if (status) {
                         QPRINTK(qdev, IFUP, ERR,
-                                "Failed to init routing register for CAM packets.\n");
-                        goto exit;
+                                "Failed to init routing register for CAM "
+                                "packets.\n");
+                        break;
                 }
         }
+        ql_sem_unlock(qdev, SEM_RT_IDX_MASK);
+        return status;
+}
+
+/* Initialize the frame-to-queue routing. */
+static int ql_route_initialize(struct ql_adapter *qdev)
+{
+        int status = 0;
+
+        status = ql_sem_spinlock(qdev, SEM_RT_IDX_MASK);
+        if (status)
+                return status;
+
+        /* Clear all the entries in the routing table. */
+        status = ql_clear_routing_entries(qdev);
+        if (status)
+                goto exit;
 
         status = ql_set_routing_reg(qdev, RT_IDX_ALL_ERR_SLOT, RT_IDX_ERR, 1);
         if (status) {
@@ -3096,14 +3163,15 @@ exit:
 
 int ql_cam_route_initialize(struct ql_adapter *qdev)
 {
-        int status;
+        int status, set;
 
-        status = ql_sem_spinlock(qdev, SEM_MAC_ADDR_MASK);
-        if (status)
-                return status;
-        status = ql_set_mac_addr_reg(qdev, (u8 *) qdev->ndev->perm_addr,
-                             MAC_ADDR_TYPE_CAM_MAC, qdev->func * MAX_CQ);
-        ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK);
+        /* If check if the link is up and use to
+         * determine if we are setting or clearing
+         * the MAC address in the CAM.
+         */
+        set = ql_read32(qdev, STS);
+        set &= qdev->port_link_up;
+        status = ql_set_mac_addr(qdev, set);
         if (status) {
                 QPRINTK(qdev, IFUP, ERR, "Failed to init mac address.\n");
                 return status;
@@ -3210,9 +3278,17 @@ static int ql_adapter_reset(struct ql_adapter *qdev)
 {
         u32 value;
         int status = 0;
-        unsigned long end_jiffies = jiffies +
-                max((unsigned long)1, usecs_to_jiffies(30));
+        unsigned long end_jiffies;
 
+        /* Clear all the entries in the routing table. */
+        status = ql_clear_routing_entries(qdev);
+        if (status) {
+                QPRINTK(qdev, IFUP, ERR, "Failed to clear routing bits.\n");
+                return status;
+        }
+
+        end_jiffies = jiffies +
+                max((unsigned long)1, usecs_to_jiffies(30));
         ql_write32(qdev, RST_FO, (RST_FO_FR << 16) | RST_FO_FR);
 
         do {
@@ -3252,7 +3328,7 @@ static int ql_adapter_down(struct ql_adapter *qdev)
         int i, status = 0;
         struct rx_ring *rx_ring;
 
-        netif_carrier_off(qdev->ndev);
+        ql_link_off(qdev);
 
         /* Don't kill the reset worker thread if we
          * are in the process of recovery.
@@ -3319,8 +3395,12 @@ static int ql_adapter_up(struct ql_adapter *qdev)
         }
         set_bit(QL_ADAPTER_UP, &qdev->flags);
         ql_alloc_rx_buffers(qdev);
-        if ((ql_read32(qdev, STS) & qdev->port_init))
-                netif_carrier_on(qdev->ndev);
+        /* If the port is initialized and the
+         * link is up the turn on the carrier.
+         */
+        if ((ql_read32(qdev, STS) & qdev->port_init) &&
+                        (ql_read32(qdev, STS) & qdev->port_link_up))
+                ql_link_on(qdev);
         ql_enable_interrupts(qdev);
         ql_enable_all_completion_interrupts(qdev);
         netif_tx_start_all_queues(qdev->ndev);
@@ -3346,11 +3426,6 @@ static int ql_get_adapter_resources(struct ql_adapter *qdev)
                 return -ENOMEM;
         }
         status = ql_request_irq(qdev);
-        if (status)
-                goto err_irq;
-        return status;
-err_irq:
-        ql_free_mem_resources(qdev);
         return status;
 }
 
@@ -3414,7 +3489,7 @@ static int ql_configure_rings(struct ql_adapter *qdev)
 
         for (i = 0; i < qdev->tx_ring_count; i++) {
                 tx_ring = &qdev->tx_ring[i];
-                memset((void *)tx_ring, 0, sizeof(tx_ring));
+                memset((void *)tx_ring, 0, sizeof(*tx_ring));
                 tx_ring->qdev = qdev;
                 tx_ring->wq_id = i;
                 tx_ring->wq_len = qdev->tx_ring_size;
@@ -3430,7 +3505,7 @@ static int ql_configure_rings(struct ql_adapter *qdev)
 
         for (i = 0; i < qdev->rx_ring_count; i++) {
                 rx_ring = &qdev->rx_ring[i];
-                memset((void *)rx_ring, 0, sizeof(rx_ring));
+                memset((void *)rx_ring, 0, sizeof(*rx_ring));
                 rx_ring->qdev = qdev;
                 rx_ring->cq_id = i;
                 rx_ring->cpu = i % cpu_cnt;     /* CPU to run handler on. */
@@ -3789,7 +3864,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev,
         int pos, err = 0;
         u16 val16;
 
-        memset((void *)qdev, 0, sizeof(qdev));
+        memset((void *)qdev, 0, sizeof(*qdev));
         err = pci_enable_device(pdev);
         if (err) {
                 dev_err(&pdev->dev, "PCI device enable failed.\n");
@@ -3976,7 +4051,7 @@ static int __devinit qlge_probe(struct pci_dev *pdev,
                 pci_disable_device(pdev);
                 return err;
         }
-        netif_carrier_off(ndev);
+        ql_link_off(qdev);
         ql_display_dev_info(ndev);
         cards_found++;
         return 0;
diff --git a/drivers/net/qlge/qlge_mpi.c b/drivers/net/qlge/qlge_mpi.c
index 71afbf8b9c50..6685bd97da91 100644
--- a/drivers/net/qlge/qlge_mpi.c
+++ b/drivers/net/qlge/qlge_mpi.c
@@ -238,7 +238,7 @@ static void ql_link_up(struct ql_adapter *qdev, struct mbox_params *mbcp)
                                 &qdev->mpi_port_cfg_work, 0);
         }
 
-        netif_carrier_on(qdev->ndev);
+        ql_link_on(qdev);
 }
 
 static void ql_link_down(struct ql_adapter *qdev, struct mbox_params *mbcp)
@@ -251,7 +251,7 @@ static void ql_link_down(struct ql_adapter *qdev, struct mbox_params *mbcp)
         if (status)
                 QPRINTK(qdev, DRV, ERR, "Link down AEN broken!\n");
 
-        netif_carrier_off(qdev->ndev);
+        ql_link_off(qdev);
 }
 
 static int ql_sfp_in(struct ql_adapter *qdev, struct mbox_params *mbcp)
@@ -849,7 +849,7 @@ void ql_mpi_idc_work(struct work_struct *work)
         case MB_CMD_PORT_RESET:
         case MB_CMD_SET_PORT_CFG:
         case MB_CMD_STOP_FW:
-                netif_carrier_off(qdev->ndev);
+                ql_link_off(qdev);
                 /* Signal the resulting link up AEN
                  * that the frame routing and mac addr
                  * needs to be set.
diff --git a/drivers/net/r6040.c b/drivers/net/r6040.c
index ed63d23a6452..961b5397a531 100644
--- a/drivers/net/r6040.c
+++ b/drivers/net/r6040.c
@@ -49,8 +49,8 @@
 #include <asm/processor.h>
 
 #define DRV_NAME        "r6040"
-#define DRV_VERSION     "0.23"
-#define DRV_RELDATE     "05May2009"
+#define DRV_VERSION     "0.24"
+#define DRV_RELDATE     "08Jul2009"
 
 /* PHY CHIP Address */
 #define PHY1_ADDR       1       /* For MAC1 */
@@ -704,8 +704,11 @@ static irqreturn_t r6040_interrupt(int irq, void *dev_id)
         /* Read MISR status and clear */
         status = ioread16(ioaddr + MISR);
 
-        if (status == 0x0000 || status == 0xffff)
+        if (status == 0x0000 || status == 0xffff) {
+                /* Restore RDC MAC interrupt */
+                iowrite16(misr, ioaddr + MIER);
                 return IRQ_NONE;
+        }
 
         /* RX interrupt request */
         if (status & RX_INTS) {
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index 341882f959f3..a2d82ddb3b4d 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -865,8 +865,7 @@ static irqreturn_t sh_eth_interrupt(int irq, void *netdev)
         struct sh_eth_private *mdp = netdev_priv(ndev);
         struct sh_eth_cpu_data *cd = mdp->cd;
         irqreturn_t ret = IRQ_NONE;
-        u32 ioaddr, boguscnt = RX_RING_SIZE;
-        u32 intr_status = 0;
+        u32 ioaddr, intr_status = 0;
 
         ioaddr = ndev->base_addr;
         spin_lock(&mdp->lock);
@@ -901,12 +900,6 @@ static irqreturn_t sh_eth_interrupt(int irq, void *netdev)
         if (intr_status & cd->eesr_err_check)
                 sh_eth_error(ndev, intr_status);
 
-        if (--boguscnt < 0) {
-                printk(KERN_WARNING
-                       "%s: Too much work at interrupt, status=0x%4.4x.\n",
-                       ndev->name, intr_status);
-        }
-
 other_irq:
         spin_unlock(&mdp->lock);
 
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 7681d28c53d7..daf961ab68bc 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -2495,7 +2495,7 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
                         if (likely(status >> 16 == (status & 0xffff))) {
                                 skb = sky2->rx_ring[sky2->rx_next].skb;
                                 skb->ip_summed = CHECKSUM_COMPLETE;
-                                skb->csum = status & 0xffff;
+                                skb->csum = le16_to_cpu(status);
                         } else {
                                 printk(KERN_NOTICE PFX "%s: hardware receive "
                                        "checksum problem (status = %#x)\n",
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index b60639bd181b..66067f9d91c0 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -1938,7 +1938,7 @@ static int __devexit smsc911x_drv_remove(struct platform_device *pdev)
         if (!res)
                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
-        release_mem_region(res->start, res->end - res->start);
+        release_mem_region(res->start, resource_size(res));
 
         iounmap(pdata->ioaddr);
 
@@ -1976,7 +1976,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
                 retval = -ENODEV;
                 goto out_0;
         }
-        res_size = res->end - res->start + 1;
+        res_size = resource_size(res);
 
         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!irq_res) {
@@ -2104,7 +2104,7 @@ out_unmap_io_3:
 out_free_netdev_2:
         free_netdev(dev);
 out_release_io_1:
-        release_mem_region(res->start, res->end - res->start);
+        release_mem_region(res->start, resource_size(res));
 out_0:
         return retval;
 }
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index 838cce8b8fff..669253c7bd41 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -180,7 +180,7 @@ static int full_duplex[MAX_UNITS] = {0, };
 /* These identify the driver base version and may not be removed. */
 static const char version[] __devinitconst =
 KERN_INFO "starfire.c:v1.03 7/26/2000  Written by Donald Becker <becker@scyld.com>\n"
-KERN_INFO " (unofficial 2.2/2.4 kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";
+" (unofficial 2.2/2.4 kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("Adaptec Starfire Ethernet driver");
diff --git a/drivers/net/sundance.c b/drivers/net/sundance.c
index 545f81b34ad7..d1521c3875b2 100644
--- a/drivers/net/sundance.c
+++ b/drivers/net/sundance.c
@@ -1698,13 +1698,13 @@ static int netdev_close(struct net_device *dev)
 
 #ifdef __i386__
         if (netif_msg_hw(np)) {
-                printk("\n"KERN_DEBUG"  Tx ring at %8.8x:\n",
+                printk(KERN_DEBUG "  Tx ring at %8.8x:\n",
                            (int)(np->tx_ring_dma));
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" #%d desc. %4.4x %8.8x %8.8x.\n",
+                        printk(KERN_DEBUG " #%d desc. %4.4x %8.8x %8.8x.\n",
                                    i, np->tx_ring[i].status, np->tx_ring[i].frag[0].addr,
                                    np->tx_ring[i].frag[0].length);
-                printk("\n"KERN_DEBUG "  Rx ring %8.8x:\n",
+                printk(KERN_DEBUG "  Rx ring %8.8x:\n",
                            (int)(np->rx_ring_dma));
                 for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) {
                         printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
diff --git a/drivers/net/tsi108_eth.c b/drivers/net/tsi108_eth.c
index 0f78f99f9b20..7030bd5e9848 100644
--- a/drivers/net/tsi108_eth.c
+++ b/drivers/net/tsi108_eth.c
@@ -1132,7 +1132,9 @@ static int tsi108_get_mac(struct net_device *dev)
         }
 
         if (!is_valid_ether_addr(dev->dev_addr)) {
-                printk("KERN_ERR: word1: %08x, word2: %08x\n", word1, word2);
+                printk(KERN_ERR
+                       "%s: Invalid MAC address. word1: %08x, word2: %08x\n",
+                       dev->name, word1, word2);
                 return -EINVAL;
         }
 
@@ -1201,8 +1203,8 @@ static void tsi108_set_rx_mode(struct net_device *dev)
                                 __set_bit(hash, &data->mc_hash[0]);
                         } else {
                                 printk(KERN_ERR
-                                       "%s: got multicast address of length %d "
-                                       "instead of 6.\n", dev->name,
+                "%s: got multicast address of length %d instead of 6.\n",
+                                       dev->name,
                                        mc->dmi_addrlen);
                         }
 
diff --git a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
index 81f054dbb88d..ef49744a5085 100644
--- a/drivers/net/tulip/de2104x.c
+++ b/drivers/net/tulip/de2104x.c
@@ -944,9 +944,10 @@ static void de_set_media (struct de_private *de)
                 macmode &= ~FullDuplex;
 
         if (netif_msg_link(de)) {
-                printk(KERN_INFO "%s: set link %s\n"
-                       KERN_INFO "%s:    mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
-                       KERN_INFO "%s:    set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
+                printk(KERN_INFO
+                       "%s: set link %s\n"
+                       "%s:    mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
+                       "%s:    set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
                        de->dev->name, media_name[media],
                        de->dev->name, dr32(MacMode), dr32(SIAStatus),
                        dr32(CSR13), dr32(CSR14), dr32(CSR15),
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index 2abb5d3becc6..99a63649f4fc 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -570,16 +570,18 @@ static void tulip_tx_timeout(struct net_device *dev)
                                    (unsigned int)tp->rx_ring[i].buffer2,
                                    buf[0], buf[1], buf[2]);
                         for (j = 0; buf[j] != 0xee && j < 1600; j++)
-                                if (j < 100) printk(" %2.2x", buf[j]);
-                        printk(" j=%d.\n", j);
+                                if (j < 100)
+                                        printk(KERN_CONT " %2.2x", buf[j]);
+                        printk(KERN_CONT " j=%d.\n", j);
                 }
                 printk(KERN_DEBUG "  Rx ring %8.8x: ", (int)tp->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++)
-                        printk(" %8.8x", (unsigned int)tp->rx_ring[i].status);
-                printk("\n" KERN_DEBUG "  Tx ring %8.8x: ", (int)tp->tx_ring);
+                        printk(KERN_CONT " %8.8x",
+                               (unsigned int)tp->rx_ring[i].status);
+                printk(KERN_DEBUG "  Tx ring %8.8x: ", (int)tp->tx_ring);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" %8.8x", (unsigned int)tp->tx_ring[i].status);
-                printk("\n");
+                        printk(KERN_CONT " %8.8x", (unsigned int)tp->tx_ring[i].status);
+                printk(KERN_CONT "\n");
         }
 #endif
 
diff --git a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c
index 842b1a2c40d4..0f15773dae52 100644
--- a/drivers/net/tulip/winbond-840.c
+++ b/drivers/net/tulip/winbond-840.c
@@ -142,7 +142,7 @@ static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
 static const char version[] __initconst =
         KERN_INFO DRV_NAME ".c:v" DRV_VERSION " (2.4 port) "
         DRV_RELDATE "  Donald Becker <becker@scyld.com>\n"
-        KERN_INFO "  http://www.scyld.com/network/drivers.html\n";
+        "  http://www.scyld.com/network/drivers.html\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("Winbond W89c840 Ethernet driver");
@@ -939,7 +939,7 @@ static void tx_timeout(struct net_device *dev)
                 printk(KERN_DEBUG "  Rx ring %p: ", np->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++)
                         printk(" %8.8x", (unsigned int)np->rx_ring[i].status);
-                printk("\n"KERN_DEBUG"  Tx ring %p: ", np->tx_ring);
+                printk(KERN_DEBUG"  Tx ring %p: ", np->tx_ring);
                 for (i = 0; i < TX_RING_SIZE; i++)
                         printk(" %8.8x", np->tx_ring[i].status);
                 printk("\n");
@@ -1520,7 +1520,7 @@ static int netdev_close(struct net_device *dev)
                         printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x.\n",
                                    i, np->tx_ring[i].length,
                                    np->tx_ring[i].status, np->tx_ring[i].buffer1);
-                printk("\n"KERN_DEBUG "  Rx ring %8.8x:\n",
+                printk(KERN_DEBUG "  Rx ring %8.8x:\n",
                            (int)np->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++) {
                         printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 11a0ba47b677..027f7aba26af 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -486,12 +486,14 @@ static unsigned int tun_chr_poll(struct file *file, poll_table * wait)
 {
         struct tun_file *tfile = file->private_data;
         struct tun_struct *tun = __tun_get(tfile);
-        struct sock *sk = tun->sk;
+        struct sock *sk;
         unsigned int mask = 0;
 
         if (!tun)
                 return POLLERR;
 
+        sk = tun->sk;
+
         DBG(KERN_INFO "%s: tun_chr_poll\n", tun->dev->name);
 
         poll_wait(file, &tun->socket.wait, wait);
@@ -1324,20 +1326,22 @@ static int tun_chr_close(struct inode *inode, struct file *file)
         struct tun_file *tfile = file->private_data;
         struct tun_struct *tun;
 
-
-        rtnl_lock();
         tun = __tun_get(tfile);
         if (tun) {
-                DBG(KERN_INFO "%s: tun_chr_close\n", tun->dev->name);
+                struct net_device *dev = tun->dev;
+
+                DBG(KERN_INFO "%s: tun_chr_close\n", dev->name);
 
                 __tun_detach(tun);
 
                 /* If desireable, unregister the netdevice. */
-                if (!(tun->flags & TUN_PERSIST))
-                        unregister_netdevice(tun->dev);
-
+                if (!(tun->flags & TUN_PERSIST)) {
+                        rtnl_lock();
+                        if (dev->reg_state == NETREG_REGISTERED)
+                                unregister_netdevice(dev);
+                        rtnl_unlock();
+                }
         }
-        rtnl_unlock();
 
         tun = tfile->tun;
         if (tun)
diff --git a/drivers/net/usb/cdc_eem.c b/drivers/net/usb/cdc_eem.c
index 80e01778dd3b..cd35d50e46d4 100644
--- a/drivers/net/usb/cdc_eem.c
+++ b/drivers/net/usb/cdc_eem.c
@@ -319,7 +319,7 @@ static int eem_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                                 return crc == crc2;
 
                         if (unlikely(crc != crc2)) {
-                                dev->stats.rx_errors++;
+                                dev->net->stats.rx_errors++;
                                 dev_kfree_skb_any(skb2);
                         } else
                                 usbnet_skb_return(dev, skb2);
diff --git a/drivers/net/usb/dm9601.c b/drivers/net/usb/dm9601.c
index 7ae82446b93a..1d3730d6690f 100644
--- a/drivers/net/usb/dm9601.c
+++ b/drivers/net/usb/dm9601.c
@@ -513,11 +513,11 @@ static int dm9601_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
         len = (skb->data[1] | (skb->data[2] << 8)) - 4;
 
         if (unlikely(status & 0xbf)) {
-                if (status & 0x01) dev->stats.rx_fifo_errors++;
-                if (status & 0x02) dev->stats.rx_crc_errors++;
-                if (status & 0x04) dev->stats.rx_frame_errors++;
-                if (status & 0x20) dev->stats.rx_missed_errors++;
-                if (status & 0x90) dev->stats.rx_length_errors++;
+                if (status & 0x01) dev->net->stats.rx_fifo_errors++;
+                if (status & 0x02) dev->net->stats.rx_crc_errors++;
+                if (status & 0x04) dev->net->stats.rx_frame_errors++;
+                if (status & 0x20) dev->net->stats.rx_missed_errors++;
+                if (status & 0x90) dev->net->stats.rx_length_errors++;
                 return 0;
         }
 
diff --git a/drivers/net/usb/net1080.c b/drivers/net/usb/net1080.c
index 034e8a73ca6b..aeb1ab03a9ee 100644
--- a/drivers/net/usb/net1080.c
+++ b/drivers/net/usb/net1080.c
@@ -433,7 +433,7 @@ static int net1080_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                 dbg("rx framesize %d range %d..%d mtu %d", skb->len,
                         net->hard_header_len, dev->hard_mtu, net->mtu);
 #endif
-                dev->stats.rx_frame_errors++;
+                dev->net->stats.rx_frame_errors++;
                 nc_ensure_sync(dev);
                 return 0;
         }
@@ -442,12 +442,12 @@ static int net1080_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
         hdr_len = le16_to_cpup(&header->hdr_len);
         packet_len = le16_to_cpup(&header->packet_len);
         if (FRAMED_SIZE(packet_len) > NC_MAX_PACKET) {
-                dev->stats.rx_frame_errors++;
+                dev->net->stats.rx_frame_errors++;
                 dbg("packet too big, %d", packet_len);
                 nc_ensure_sync(dev);
                 return 0;
         } else if (hdr_len < MIN_HEADER) {
-                dev->stats.rx_frame_errors++;
+                dev->net->stats.rx_frame_errors++;
                 dbg("header too short, %d", hdr_len);
                 nc_ensure_sync(dev);
                 return 0;
@@ -465,21 +465,21 @@ static int net1080_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 
         if ((packet_len & 0x01) == 0) {
                 if (skb->data [packet_len] != PAD_BYTE) {
-                        dev->stats.rx_frame_errors++;
+                        dev->net->stats.rx_frame_errors++;
                         dbg("bad pad");
                         return 0;
                 }
                 skb_trim(skb, skb->len - 1);
         }
         if (skb->len != packet_len) {
-                dev->stats.rx_frame_errors++;
+                dev->net->stats.rx_frame_errors++;
                 dbg("bad packet len %d (expected %d)",
                         skb->len, packet_len);
                 nc_ensure_sync(dev);
                 return 0;
         }
         if (header->packet_id != get_unaligned(&trailer->packet_id)) {
-                dev->stats.rx_fifo_errors++;
+                dev->net->stats.rx_fifo_errors++;
                 dbg("(2+ dropped) rx packet_id mismatch 0x%x 0x%x",
                         le16_to_cpu(header->packet_id),
                         le16_to_cpu(trailer->packet_id));
diff --git a/drivers/net/usb/rndis_host.c b/drivers/net/usb/rndis_host.c
index 1bf243ef950e..2232232b7989 100644
--- a/drivers/net/usb/rndis_host.c
+++ b/drivers/net/usb/rndis_host.c
@@ -487,7 +487,7 @@ int rndis_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                 if (unlikely(hdr->msg_type != RNDIS_MSG_PACKET
                                 || skb->len < msg_len
                                 || (data_offset + data_len + 8) > msg_len)) {
-                        dev->stats.rx_frame_errors++;
+                        dev->net->stats.rx_frame_errors++;
                         devdbg(dev, "bad rndis message %d/%d/%d/%d, len %d",
                                 le32_to_cpu(hdr->msg_type),
                                 msg_len, data_offset, data_len, skb->len);
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 89a91f8c22de..fe045896406b 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -1108,18 +1108,18 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                 if (unlikely(header & RX_STS_ES_)) {
                         if (netif_msg_rx_err(dev))
                                 devdbg(dev, "Error header=0x%08x", header);
-                        dev->stats.rx_errors++;
-                        dev->stats.rx_dropped++;
+                        dev->net->stats.rx_errors++;
+                        dev->net->stats.rx_dropped++;
 
                         if (header & RX_STS_CRC_) {
-                                dev->stats.rx_crc_errors++;
+                                dev->net->stats.rx_crc_errors++;
                         } else {
                                 if (header & (RX_STS_TL_ | RX_STS_RF_))
-                                        dev->stats.rx_frame_errors++;
+                                        dev->net->stats.rx_frame_errors++;
 
                                 if ((header & RX_STS_LE_) &&
                                         (!(header & RX_STS_FT_)))
-                                        dev->stats.rx_length_errors++;
+                                        dev->net->stats.rx_length_errors++;
                         }
                 } else {
                         /* ETH_FRAME_LEN + 4(CRC) + 2(COE) + 4(Vlan) */
diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c
index 22c0585a0319..edfd9e10ceba 100644
--- a/drivers/net/usb/usbnet.c
+++ b/drivers/net/usb/usbnet.c
@@ -234,8 +234,8 @@ void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
         int     status;
 
         skb->protocol = eth_type_trans (skb, dev->net);
-        dev->stats.rx_packets++;
-        dev->stats.rx_bytes += skb->len;
+        dev->net->stats.rx_packets++;
+        dev->net->stats.rx_bytes += skb->len;
 
         if (netif_msg_rx_status (dev))
                 devdbg (dev, "< rx, len %zu, type 0x%x",
@@ -397,7 +397,7 @@ static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
                 if (netif_msg_rx_err (dev))
                         devdbg (dev, "drop");
 error:
-                dev->stats.rx_errors++;
+                dev->net->stats.rx_errors++;
                 skb_queue_tail (&dev->done, skb);
         }
 }
@@ -420,8 +420,8 @@ static void rx_complete (struct urb *urb)
         case 0:
                 if (skb->len < dev->net->hard_header_len) {
                         entry->state = rx_cleanup;
-                        dev->stats.rx_errors++;
-                        dev->stats.rx_length_errors++;
+                        dev->net->stats.rx_errors++;
+                        dev->net->stats.rx_length_errors++;
                         if (netif_msg_rx_err (dev))
                                 devdbg (dev, "rx length %d", skb->len);
                 }
@@ -433,7 +433,7 @@ static void rx_complete (struct urb *urb)
          * storm, recovering as needed.
          */
         case -EPIPE:
-                dev->stats.rx_errors++;
+                dev->net->stats.rx_errors++;
                 usbnet_defer_kevent (dev, EVENT_RX_HALT);
                 // FALLTHROUGH
 
@@ -451,7 +451,7 @@ static void rx_complete (struct urb *urb)
         case -EPROTO:
         case -ETIME:
         case -EILSEQ:
-                dev->stats.rx_errors++;
+                dev->net->stats.rx_errors++;
                 if (!timer_pending (&dev->delay)) {
                         mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
                         if (netif_msg_link (dev))
@@ -465,12 +465,12 @@ block:
 
         /* data overrun ... flush fifo? */
         case -EOVERFLOW:
-                dev->stats.rx_over_errors++;
+                dev->net->stats.rx_over_errors++;
                 // FALLTHROUGH
 
         default:
                 entry->state = rx_cleanup;
-                dev->stats.rx_errors++;
+                dev->net->stats.rx_errors++;
                 if (netif_msg_rx_err (dev))
                         devdbg (dev, "rx status %d", urb_status);
                 break;
@@ -583,8 +583,8 @@ int usbnet_stop (struct net_device *net)
 
         if (netif_msg_ifdown (dev))
                 devinfo (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld",
-                        dev->stats.rx_packets, dev->stats.tx_packets,
-                        dev->stats.rx_errors, dev->stats.tx_errors
+                        net->stats.rx_packets, net->stats.tx_packets,
+                        net->stats.rx_errors, net->stats.tx_errors
                         );
 
         // ensure there are no more active urbs
@@ -891,10 +891,10 @@ static void tx_complete (struct urb *urb)
         struct usbnet           *dev = entry->dev;
 
         if (urb->status == 0) {
-                dev->stats.tx_packets++;
-                dev->stats.tx_bytes += entry->length;
+                dev->net->stats.tx_packets++;
+                dev->net->stats.tx_bytes += entry->length;
         } else {
-                dev->stats.tx_errors++;
+                dev->net->stats.tx_errors++;
 
                 switch (urb->status) {
                 case -EPIPE:
@@ -1020,7 +1020,7 @@ int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
                         devdbg (dev, "drop, code %d", retval);
 drop:
                 retval = NET_XMIT_SUCCESS;
-                dev->stats.tx_dropped++;
+                dev->net->stats.tx_dropped++;
                 if (skb)
                         dev_kfree_skb_any (skb);
                 usb_free_urb (urb);
diff --git a/drivers/net/veth.c b/drivers/net/veth.c
index 87197dd9c788..1097c72e44d5 100644
--- a/drivers/net/veth.c
+++ b/drivers/net/veth.c
@@ -208,11 +208,14 @@ rx_drop:
 
 static struct net_device_stats *veth_get_stats(struct net_device *dev)
 {
-        struct veth_priv *priv = netdev_priv(dev);
-        struct net_device_stats *dev_stats = &dev->stats;
-        unsigned int cpu;
+        struct veth_priv *priv;
+        struct net_device_stats *dev_stats;
+        int cpu;
         struct veth_net_stats *stats;
 
+        priv = netdev_priv(dev);
+        dev_stats = &dev->stats;
+
         dev_stats->rx_packets = 0;
         dev_stats->tx_packets = 0;
         dev_stats->rx_bytes = 0;
@@ -220,17 +223,16 @@ static struct net_device_stats *veth_get_stats(struct net_device *dev)
         dev_stats->tx_dropped = 0;
         dev_stats->rx_dropped = 0;
 
-        if (priv->stats)
-                for_each_online_cpu(cpu) {
-                        stats = per_cpu_ptr(priv->stats, cpu);
+        for_each_online_cpu(cpu) {
+                stats = per_cpu_ptr(priv->stats, cpu);
 
-                        dev_stats->rx_packets += stats->rx_packets;
-                        dev_stats->tx_packets += stats->tx_packets;
-                        dev_stats->rx_bytes += stats->rx_bytes;
-                        dev_stats->tx_bytes += stats->tx_bytes;
-                        dev_stats->tx_dropped += stats->tx_dropped;
-                        dev_stats->rx_dropped += stats->rx_dropped;
-                }
+                dev_stats->rx_packets += stats->rx_packets;
+                dev_stats->tx_packets += stats->tx_packets;
+                dev_stats->rx_bytes += stats->rx_bytes;
+                dev_stats->tx_bytes += stats->tx_bytes;
+                dev_stats->tx_dropped += stats->tx_dropped;
+                dev_stats->rx_dropped += stats->rx_dropped;
+        }
 
         return dev_stats;
 }
@@ -257,8 +259,6 @@ static int veth_close(struct net_device *dev)
         netif_carrier_off(dev);
         netif_carrier_off(priv->peer);
 
-        free_percpu(priv->stats);
-        priv->stats = NULL;
         return 0;
 }
 
@@ -289,6 +289,15 @@ static int veth_dev_init(struct net_device *dev)
         return 0;
 }
 
+static void veth_dev_free(struct net_device *dev)
+{
+        struct veth_priv *priv;
+
+        priv = netdev_priv(dev);
+        free_percpu(priv->stats);
+        free_netdev(dev);
+}
+
 static const struct net_device_ops veth_netdev_ops = {
         .ndo_init            = veth_dev_init,
         .ndo_open            = veth_open,
@@ -306,7 +315,7 @@ static void veth_setup(struct net_device *dev)
         dev->netdev_ops = &veth_netdev_ops;
         dev->ethtool_ops = &veth_ethtool_ops;
         dev->features |= NETIF_F_LLTX;
-        dev->destructor = free_netdev;
+        dev->destructor = veth_dev_free;
 }
 
 /*
diff --git a/drivers/net/wan/hd64570.c b/drivers/net/wan/hd64570.c
index 223238de475c..1ea1ef6c3b96 100644
--- a/drivers/net/wan/hd64570.c
+++ b/drivers/net/wan/hd64570.c
@@ -584,8 +584,9 @@ static void sca_dump_rings(struct net_device *dev)
                sca_in(DSR_RX(phy_node(port)), card) & DSR_DE ? "" : "in");
         for (cnt = 0; cnt < port_to_card(port)->rx_ring_buffers; cnt++)
                 printk(" %02X", readb(&(desc_address(port, cnt, 0)->stat)));
+        printk(KERN_CONT "\n");
 
-        printk("\n" KERN_DEBUG "TX ring: CDA=%u EDA=%u DSR=%02X in=%u "
+        printk(KERN_DEBUG "TX ring: CDA=%u EDA=%u DSR=%02X in=%u "
                "last=%u %sactive",
                sca_inw(get_dmac_tx(port) + CDAL, card),
                sca_inw(get_dmac_tx(port) + EDAL, card),
diff --git a/drivers/net/wan/hd64572.c b/drivers/net/wan/hd64572.c
index 497b003d7239..f099c34a3ae2 100644
--- a/drivers/net/wan/hd64572.c
+++ b/drivers/net/wan/hd64572.c
@@ -529,8 +529,9 @@ static void sca_dump_rings(struct net_device *dev)
                sca_in(DSR_RX(port->chan), card) & DSR_DE ? "" : "in");
         for (cnt = 0; cnt < port->card->rx_ring_buffers; cnt++)
                 printk(" %02X", readb(&(desc_address(port, cnt, 0)->stat)));
+        printk(KERN_CONT "\n");
 
-        printk("\n" KERN_DEBUG "TX ring: CDA=%u EDA=%u DSR=%02X in=%u "
+        printk(KERN_DEBUG "TX ring: CDA=%u EDA=%u DSR=%02X in=%u "
                "last=%u %sactive",
                sca_inl(get_dmac_tx(port) + CDAL, card),
                sca_inl(get_dmac_tx(port) + EDAL, card),
diff --git a/drivers/net/wan/sbni.c b/drivers/net/wan/sbni.c
index 3fb9dbc88a1a..d14e95a08d66 100644
--- a/drivers/net/wan/sbni.c
+++ b/drivers/net/wan/sbni.c
@@ -326,11 +326,9 @@ sbni_pci_probe( struct net_device  *dev )
                 }
 
                 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
-                        printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
-                                "this PCI card to IRQ %d, which is unlikely "
-                                "to work!.\n"
-                                KERN_WARNING " You should use the PCI BIOS "
-                                "setup to assign a valid IRQ line.\n",
+                        printk( KERN_WARNING
+        "  WARNING: The PCI BIOS assigned this PCI card to IRQ %d, which is unlikely to work!.\n"
+        " You should use the PCI BIOS setup to assign a valid IRQ line.\n",
                                 pci_irq_line );
 
                 /* avoiding re-enable dual adapters */
diff --git a/drivers/net/wireless/ath/Kconfig b/drivers/net/wireless/ath/Kconfig
index d26e7b485315..eb0337c49546 100644
--- a/drivers/net/wireless/ath/Kconfig
+++ b/drivers/net/wireless/ath/Kconfig
@@ -1,5 +1,6 @@
 config ATH_COMMON
         tristate "Atheros Wireless Cards"
+        depends on WLAN_80211
         depends on ATH5K || ATH9K || AR9170_USB
 
 source "drivers/net/wireless/ath/ath5k/Kconfig"
diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index b61a071788a5..4ccf48e396df 100644
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -355,7 +355,14 @@ static void ath_tx_complete_aggr(struct ath_softc *sc, struct ath_txq *txq,
                 }
 
                 if (bf_next == NULL) {
-                        INIT_LIST_HEAD(&bf_head);
+                        /*
+                         * Make sure the last desc is reclaimed if it
+                         * not a holding desc.
+                         */
+                        if (!bf_last->bf_stale)
+                                list_move_tail(&bf->list, &bf_head);
+                        else
+                                INIT_LIST_HEAD(&bf_head);
                 } else {
                         ASSERT(!list_empty(bf_q));
                         list_move_tail(&bf->list, &bf_head);
diff --git a/drivers/net/wireless/b43/b43.h b/drivers/net/wireless/b43/b43.h
index f580c2812d91..40448067e4cc 100644
--- a/drivers/net/wireless/b43/b43.h
+++ b/drivers/net/wireless/b43/b43.h
@@ -648,6 +648,7 @@ struct b43_wl {
         u8 nr_devs;
 
         bool radiotap_enabled;
+        bool radio_enabled;
 
         /* The beacon we are currently using (AP or IBSS mode).
          * This beacon stuff is protected by the irq_lock. */
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 6456afebdba1..e71c8d9cd706 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -3497,8 +3497,8 @@ static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
         if (phy->ops->set_rx_antenna)
                 phy->ops->set_rx_antenna(dev, antenna);
 
-        if (!!conf->radio_enabled != phy->radio_on) {
-                if (conf->radio_enabled) {
+        if (wl->radio_enabled != phy->radio_on) {
+                if (wl->radio_enabled) {
                         b43_software_rfkill(dev, false);
                         b43info(dev->wl, "Radio turned on by software\n");
                         if (!dev->radio_hw_enable) {
@@ -4339,6 +4339,7 @@ static int b43_op_start(struct ieee80211_hw *hw)
         wl->beacon0_uploaded = 0;
         wl->beacon1_uploaded = 0;
         wl->beacon_templates_virgin = 1;
+        wl->radio_enabled = 1;
 
         mutex_lock(&wl->mutex);
 
@@ -4378,6 +4379,7 @@ static void b43_op_stop(struct ieee80211_hw *hw)
         if (b43_status(dev) >= B43_STAT_STARTED)
                 b43_wireless_core_stop(dev);
         b43_wireless_core_exit(dev);
+        wl->radio_enabled = 0;
         mutex_unlock(&wl->mutex);
 
         cancel_work_sync(&(wl->txpower_adjust_work));
@@ -4560,6 +4562,7 @@ static int b43_wireless_core_attach(struct b43_wldev *dev)
                 B43_WARN_ON(1);
 
         dev->phy.gmode = have_2ghz_phy;
+        dev->phy.radio_on = 1;
         tmp = dev->phy.gmode ? B43_TMSLOW_GMODE : 0;
         b43_wireless_core_reset(dev, tmp);
 
diff --git a/drivers/net/wireless/b43/pcmcia.c b/drivers/net/wireless/b43/pcmcia.c
index 3cfc30307a27..6c3a74964ab8 100644
--- a/drivers/net/wireless/b43/pcmcia.c
+++ b/drivers/net/wireless/b43/pcmcia.c
@@ -35,6 +35,7 @@
 
 static /*const */ struct pcmcia_device_id b43_pcmcia_tbl[] = {
         PCMCIA_DEVICE_MANF_CARD(0x2D0, 0x448),
+        PCMCIA_DEVICE_MANF_CARD(0x2D0, 0x476),
         PCMCIA_DEVICE_NULL,
 };
 
diff --git a/drivers/net/wireless/b43legacy/b43legacy.h b/drivers/net/wireless/b43legacy/b43legacy.h
index 77fda148ac46..038baa8869e2 100644
--- a/drivers/net/wireless/b43legacy/b43legacy.h
+++ b/drivers/net/wireless/b43legacy/b43legacy.h
@@ -607,6 +607,7 @@ struct b43legacy_wl {
         u8 nr_devs;
 
         bool radiotap_enabled;
+        bool radio_enabled;
 
         /* The beacon we are currently using (AP or IBSS mode).
          * This beacon stuff is protected by the irq_lock. */
diff --git a/drivers/net/wireless/b43legacy/main.c b/drivers/net/wireless/b43legacy/main.c
index e5136fb65ddd..c4973c1942bf 100644
--- a/drivers/net/wireless/b43legacy/main.c
+++ b/drivers/net/wireless/b43legacy/main.c
@@ -2689,8 +2689,8 @@ static int b43legacy_op_dev_config(struct ieee80211_hw *hw,
         /* Antennas for RX and management frame TX. */
         b43legacy_mgmtframe_txantenna(dev, antenna_tx);
 
-        if (!!conf->radio_enabled != phy->radio_on) {
-                if (conf->radio_enabled) {
+        if (wl->radio_enabled != phy->radio_on) {
+                if (wl->radio_enabled) {
                         b43legacy_radio_turn_on(dev);
                         b43legacyinfo(dev->wl, "Radio turned on by software\n");
                         if (!dev->radio_hw_enable)
@@ -3441,6 +3441,7 @@ static int b43legacy_op_start(struct ieee80211_hw *hw)
         wl->beacon0_uploaded = 0;
         wl->beacon1_uploaded = 0;
         wl->beacon_templates_virgin = 1;
+        wl->radio_enabled = 1;
 
         mutex_lock(&wl->mutex);
 
@@ -3479,6 +3480,7 @@ static void b43legacy_op_stop(struct ieee80211_hw *hw)
         if (b43legacy_status(dev) >= B43legacy_STAT_STARTED)
                 b43legacy_wireless_core_stop(dev);
         b43legacy_wireless_core_exit(dev);
+        wl->radio_enabled = 0;
         mutex_unlock(&wl->mutex);
 }
 
@@ -3620,6 +3622,7 @@ static int b43legacy_wireless_core_attach(struct b43legacy_wldev *dev)
                 have_bphy = 1;
 
         dev->phy.gmode = (have_gphy || have_bphy);
+        dev->phy.radio_on = 1;
         tmp = dev->phy.gmode ? B43legacy_TMSLOW_GMODE : 0;
         b43legacy_wireless_core_reset(dev, tmp);
 
diff --git a/drivers/net/wireless/iwmc3200wifi/Kconfig b/drivers/net/wireless/iwmc3200wifi/Kconfig
index 1eccb6df46dd..030401d367d3 100644
--- a/drivers/net/wireless/iwmc3200wifi/Kconfig
+++ b/drivers/net/wireless/iwmc3200wifi/Kconfig
@@ -4,6 +4,15 @@ config IWM
         depends on CFG80211
         select WIRELESS_EXT
         select FW_LOADER
+        help
+          The Intel Wireless Multicomm 3200 hardware is a combo
+          card with GPS, Bluetooth, WiMax and 802.11 radios. It
+          runs over SDIO and is typically found on Moorestown
+          based platform. This driver takes care of the 802.11
+          part, which is a fullmac one.
+
+          If you choose to build it as a module, it'll be called
+          iwmc3200wifi.ko.
 
 config IWM_DEBUG
         bool "Enable full debugging output in iwmc3200wifi"
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
index e789c6e9938c..a111bda392e2 100644
--- a/drivers/net/wireless/mac80211_hwsim.c
+++ b/drivers/net/wireless/mac80211_hwsim.c
@@ -418,6 +418,7 @@ static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
                         continue;
 
                 if (!data2->started || !hwsim_ps_rx_ok(data2, skb) ||
+                    !data->channel || !data2->channel ||
                     data->channel->center_freq != data2->channel->center_freq ||
                     !(data->group & data2->group))
                         continue;
diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index b618bd14583f..22ca122bd798 100644
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -823,30 +823,30 @@ void p54_free_skb(struct ieee80211_hw *dev, struct sk_buff *skb)
         struct p54_tx_info *range;
         unsigned long flags;
 
-        if (unlikely(!skb || !dev || skb_queue_empty(&priv->tx_queue)))
+        if (unlikely(!skb || !dev || !skb_queue_len(&priv->tx_queue)))
                 return;
 
-        /* There used to be a check here to see if the SKB was on the
-         * TX queue or not.  This can never happen because all SKBs we
-         * see here successfully went through p54_assign_address()
-         * which means the SKB is on the ->tx_queue.
+        /*
+         * don't try to free an already unlinked skb
          */
+        if (unlikely((!skb->next) || (!skb->prev)))
+                return;
 
         spin_lock_irqsave(&priv->tx_queue.lock, flags);
         info = IEEE80211_SKB_CB(skb);
         range = (void *)info->rate_driver_data;
-        if (!skb_queue_is_first(&priv->tx_queue, skb)) {
+        if (skb->prev != (struct sk_buff *)&priv->tx_queue) {
                 struct ieee80211_tx_info *ni;
                 struct p54_tx_info *mr;
 
-                ni = IEEE80211_SKB_CB(skb_queue_prev(&priv->tx_queue, skb));
+                ni = IEEE80211_SKB_CB(skb->prev);
                 mr = (struct p54_tx_info *)ni->rate_driver_data;
         }
-        if (!skb_queue_is_last(&priv->tx_queue, skb)) {
+        if (skb->next != (struct sk_buff *)&priv->tx_queue) {
                 struct ieee80211_tx_info *ni;
                 struct p54_tx_info *mr;
 
-                ni = IEEE80211_SKB_CB(skb_queue_next(&priv->tx_queue, skb));
+                ni = IEEE80211_SKB_CB(skb->next);
                 mr = (struct p54_tx_info *)ni->rate_driver_data;
         }
         __skb_unlink(skb, &priv->tx_queue);
@@ -864,13 +864,15 @@ static struct sk_buff *p54_find_tx_entry(struct ieee80211_hw *dev,
         unsigned long flags;
 
         spin_lock_irqsave(&priv->tx_queue.lock, flags);
-        skb_queue_walk(&priv->tx_queue, entry) {
+        entry = priv->tx_queue.next;
+        while (entry != (struct sk_buff *)&priv->tx_queue) {
                 struct p54_hdr *hdr = (struct p54_hdr *) entry->data;
 
                 if (hdr->req_id == req_id) {
                         spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
                         return entry;
                 }
+                entry = entry->next;
         }
         spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
         return NULL;
@@ -888,33 +890,36 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
         int count, idx;
 
         spin_lock_irqsave(&priv->tx_queue.lock, flags);
-        skb_queue_walk(&priv->tx_queue, entry) {
+        entry = (struct sk_buff *) priv->tx_queue.next;
+        while (entry != (struct sk_buff *)&priv->tx_queue) {
                 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(entry);
                 struct p54_hdr *entry_hdr;
                 struct p54_tx_data *entry_data;
                 unsigned int pad = 0, frame_len;
 
                 range = (void *)info->rate_driver_data;
-                if (range->start_addr != addr)
+                if (range->start_addr != addr) {
+                        entry = entry->next;
                         continue;
+                }
 
-                if (!skb_queue_is_last(&priv->tx_queue, entry)) {
+                if (entry->next != (struct sk_buff *)&priv->tx_queue) {
                         struct ieee80211_tx_info *ni;
                         struct p54_tx_info *mr;
 
-                        ni = IEEE80211_SKB_CB(skb_queue_next(&priv->tx_queue,
-                                                             entry));
+                        ni = IEEE80211_SKB_CB(entry->next);
                         mr = (struct p54_tx_info *)ni->rate_driver_data;
                 }
 
                 __skb_unlink(entry, &priv->tx_queue);
-                spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
 
                 frame_len = entry->len;
                 entry_hdr = (struct p54_hdr *) entry->data;
                 entry_data = (struct p54_tx_data *) entry_hdr->data;
-                priv->tx_stats[entry_data->hw_queue].len--;
+                if (priv->tx_stats[entry_data->hw_queue].len)
+                        priv->tx_stats[entry_data->hw_queue].len--;
                 priv->stats.dot11ACKFailureCount += payload->tries - 1;
+                spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
 
                 /*
                  * Frames in P54_QUEUE_FWSCAN and P54_QUEUE_BEACON are
@@ -1164,21 +1169,23 @@ static int p54_assign_address(struct ieee80211_hw *dev, struct sk_buff *skb,
                 }
         }
 
-        skb_queue_walk(&priv->tx_queue, entry) {
+        entry = priv->tx_queue.next;
+        while (left--) {
                 u32 hole_size;
                 info = IEEE80211_SKB_CB(entry);
                 range = (void *)info->rate_driver_data;
                 hole_size = range->start_addr - last_addr;
                 if (!target_skb && hole_size >= len) {
-                        target_skb = skb_queue_prev(&priv->tx_queue, entry);
+                        target_skb = entry->prev;
                         hole_size -= len;
                         target_addr = last_addr;
                 }
                 largest_hole = max(largest_hole, hole_size);
                 last_addr = range->end_addr;
+                entry = entry->next;
         }
         if (!target_skb && priv->rx_end - last_addr >= len) {
-                target_skb = skb_peek_tail(&priv->tx_queue);
+                target_skb = priv->tx_queue.prev;
                 largest_hole = max(largest_hole, priv->rx_end - last_addr - len);
                 if (!skb_queue_empty(&priv->tx_queue)) {
                         info = IEEE80211_SKB_CB(target_skb);
@@ -2084,6 +2091,7 @@ out:
 static void p54_stop(struct ieee80211_hw *dev)
 {
         struct p54_common *priv = dev->priv;
+        struct sk_buff *skb;
 
         mutex_lock(&priv->conf_mutex);
         priv->mode = NL80211_IFTYPE_UNSPECIFIED;
@@ -2098,7 +2106,8 @@ static void p54_stop(struct ieee80211_hw *dev)
                 p54_tx_cancel(dev, priv->cached_beacon);
 
         priv->stop(dev);
-        skb_queue_purge(&priv->tx_queue);
+        while ((skb = skb_dequeue(&priv->tx_queue)))
+                kfree_skb(skb);
         priv->cached_beacon = NULL;
         priv->tsf_high32 = priv->tsf_low32 = 0;
         mutex_unlock(&priv->conf_mutex);
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index b10b0383dfa5..698b11b1cadb 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -2427,11 +2427,10 @@ static void untranslate(ray_dev_t *local, struct sk_buff *skb, int len)
 
 #ifdef PCMCIA_DEBUG
         if (pc_debug > 3) {
-                int i;
-                printk(KERN_DEBUG "skb->data before untranslate");
-                for (i = 0; i < 64; i++)
-                        printk("%02x ", skb->data[i]);
-                printk("\n" KERN_DEBUG
+                print_hex_dump(KERN_DEBUG, "skb->data before untranslate: ",
+                               DUMP_PREFIX_NONE, 16, 1,
+                               skb->data, 64, true);
+                printk(KERN_DEBUG
                        "type = %08x, xsap = %02x%02x%02x, org = %02x02x02x\n",
                        ntohs(type), psnap->dsap, psnap->ssap, psnap->ctrl,
                        psnap->org[0], psnap->org[1], psnap->org[2]);
diff --git a/drivers/net/wireless/wavelan_cs.c b/drivers/net/wireless/wavelan_cs.c
index 6af706408ac0..c6d300666ad8 100644
--- a/drivers/net/wireless/wavelan_cs.c
+++ b/drivers/net/wireless/wavelan_cs.c
@@ -3556,17 +3556,8 @@ wv_82593_config(struct net_device *	dev)
   cfblk.rcvstop = TRUE;         /* Enable Receive Stop Register */
 
 #ifdef DEBUG_I82593_SHOW
-  {
-    u_char *c = (u_char *) &cfblk;
-    int i;
-    printk(KERN_DEBUG "wavelan_cs: config block:");
-    for(i = 0; i < sizeof(struct i82593_conf_block); i++,c++)
-      {
-        if((i % 16) == 0) printk("\n" KERN_DEBUG);
-        printk("%02x ", *c);
-      }
-    printk("\n");
-  }
+  print_hex_dump(KERN_DEBUG, "wavelan_cs: config block: ", DUMP_PREFIX_NONE,
+                 16, 1, &cfblk, sizeof(struct i82593_conf_block), false);
 #endif
 
   /* Copy the config block to the i82593 */
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index 14a19baff214..0e6e44689cc6 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -38,7 +38,6 @@ static struct usb_device_id usb_ids[] = {
         /* ZD1211 */
         { USB_DEVICE(0x0ace, 0x1211), .driver_info = DEVICE_ZD1211 },
         { USB_DEVICE(0x0ace, 0xa211), .driver_info = DEVICE_ZD1211 },
-        { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211 },
         { USB_DEVICE(0x126f, 0xa006), .driver_info = DEVICE_ZD1211 },
         { USB_DEVICE(0x6891, 0xa727), .driver_info = DEVICE_ZD1211 },
         { USB_DEVICE(0x0df6, 0x9071), .driver_info = DEVICE_ZD1211 },
@@ -61,6 +60,7 @@ static struct usb_device_id usb_ids[] = {
         { USB_DEVICE(0x157e, 0x300a), .driver_info = DEVICE_ZD1211 },
         { USB_DEVICE(0x0105, 0x145f), .driver_info = DEVICE_ZD1211 },
         /* ZD1211B */
+        { USB_DEVICE(0x054c, 0x0257), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0ace, 0x1215), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0ace, 0xb215), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x157e, 0x300d), .driver_info = DEVICE_ZD1211B },
@@ -87,6 +87,7 @@ static struct usb_device_id usb_ids[] = {
         { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x07fa, 0x1196), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0df6, 0x0036), .driver_info = DEVICE_ZD1211B },
+        { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211B },
         /* "Driverless" devices that need ejecting */
         { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
         { USB_DEVICE(0x0ace, 0x20ff), .driver_info = DEVICE_INSTALLER },
diff --git a/drivers/net/yellowfin.c b/drivers/net/yellowfin.c
index 3c7a5053f1da..a07580138e81 100644
--- a/drivers/net/yellowfin.c
+++ b/drivers/net/yellowfin.c
@@ -109,7 +109,7 @@ static int gx_fix;
 /* These identify the driver base version and may not be removed. */
 static const char version[] __devinitconst =
   KERN_INFO DRV_NAME ".c:v1.05  1/09/2001  Written by Donald Becker <becker@scyld.com>\n"
-  KERN_INFO "  (unofficial 2.4.x port, " DRV_VERSION ", " DRV_RELDATE ")\n";
+  "  (unofficial 2.4.x port, " DRV_VERSION ", " DRV_RELDATE ")\n";
 
 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("Packet Engines Yellowfin G-NIC Gigabit Ethernet driver");
@@ -700,12 +700,15 @@ static void yellowfin_tx_timeout(struct net_device *dev)
                 int i;
                 printk(KERN_WARNING "  Rx ring %p: ", yp->rx_ring);
                 for (i = 0; i < RX_RING_SIZE; i++)
-                        printk(" %8.8x", yp->rx_ring[i].result_status);
-                printk("\n"KERN_WARNING"  Tx ring %p: ", yp->tx_ring);
+                        printk(KERN_CONT " %8.8x",
+                               yp->rx_ring[i].result_status);
+                printk(KERN_CONT "\n");
+                printk(KERN_WARNING"  Tx ring %p: ", yp->tx_ring);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk(" %4.4x /%8.8x", yp->tx_status[i].tx_errs,
-                                   yp->tx_ring[i].result_status);
-                printk("\n");
+                        printk(KERN_CONT " %4.4x /%8.8x",
+                               yp->tx_status[i].tx_errs,
+                               yp->tx_ring[i].result_status);
+                printk(KERN_CONT "\n");
         }
 
         /* If the hardware is found to hang regularly, we will update the code
@@ -1216,20 +1219,20 @@ static int yellowfin_close(struct net_device *dev)
 
 #if defined(__i386__)
         if (yellowfin_debug > 2) {
-                printk("\n"KERN_DEBUG"  Tx ring at %8.8llx:\n",
+                printk(KERN_DEBUG"  Tx ring at %8.8llx:\n",
                                 (unsigned long long)yp->tx_ring_dma);
                 for (i = 0; i < TX_RING_SIZE*2; i++)
-                        printk(" %c #%d desc. %8.8x %8.8x %8.8x %8.8x.\n",
+                        printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x %8.8x %8.8x.\n",
                                    ioread32(ioaddr + TxPtr) == (long)&yp->tx_ring[i] ? '>' : ' ',
                                    i, yp->tx_ring[i].dbdma_cmd, yp->tx_ring[i].addr,
                                    yp->tx_ring[i].branch_addr, yp->tx_ring[i].result_status);
                 printk(KERN_DEBUG "  Tx status %p:\n", yp->tx_status);
                 for (i = 0; i < TX_RING_SIZE; i++)
-                        printk("   #%d status %4.4x %4.4x %4.4x %4.4x.\n",
+                        printk(KERN_DEBUG "   #%d status %4.4x %4.4x %4.4x %4.4x.\n",
                                    i, yp->tx_status[i].tx_cnt, yp->tx_status[i].tx_errs,
                                    yp->tx_status[i].total_tx_cnt, yp->tx_status[i].paused);
 
-                printk("\n"KERN_DEBUG "  Rx ring %8.8llx:\n",
+                printk(KERN_DEBUG "  Rx ring %8.8llx:\n",
                                 (unsigned long long)yp->rx_ring_dma);
                 for (i = 0; i < RX_RING_SIZE; i++) {
                         printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x %8.8x\n",
diff --git a/drivers/oprofile/oprofile_stats.c b/drivers/oprofile/oprofile_stats.c
index e1f6ce03705e..3c2270a8300c 100644
--- a/drivers/oprofile/oprofile_stats.c
+++ b/drivers/oprofile/oprofile_stats.c
@@ -33,6 +33,7 @@ void oprofile_reset_stats(void)
         atomic_set(&oprofile_stats.sample_lost_no_mm, 0);
         atomic_set(&oprofile_stats.sample_lost_no_mapping, 0);
         atomic_set(&oprofile_stats.event_lost_overflow, 0);
+        atomic_set(&oprofile_stats.bt_lost_no_mapping, 0);
 }
 
 
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 5d610cbcfe80..0f0e0b919ef4 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -1134,7 +1134,7 @@ static const struct file_operations ccio_proc_bitmap_fops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
-#endif
+#endif /* CONFIG_PROC_FS */
 
 /**
  * ccio_find_ioc - Find the ioc in the ioc_list
@@ -1568,14 +1568,15 @@ static int __init ccio_probe(struct parisc_device *dev)
         /* if this fails, no I/O cards will work, so may as well bug */
         BUG_ON(dev->dev.platform_data == NULL);
         HBA_DATA(dev->dev.platform_data)->iommu = ioc;
-        
+
+#ifdef CONFIG_PROC_FS
         if (ioc_count == 0) {
                 proc_create(MODULE_NAME, 0, proc_runway_root,
                             &ccio_proc_info_fops);
                 proc_create(MODULE_NAME"-bitmap", 0, proc_runway_root,
                             &ccio_proc_bitmap_fops);
         }
-
+#endif
         ioc_count++;
 
         parisc_has_iommu();
diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
index 52ae0b1d470c..c590974e9815 100644
--- a/drivers/parisc/dino.c
+++ b/drivers/parisc/dino.c
@@ -353,7 +353,7 @@ static unsigned int dino_startup_irq(unsigned int irq)
         return 0;
 }
 
-static struct hw_interrupt_type dino_interrupt_type = {
+static struct irq_chip dino_interrupt_type = {
         .typename       = "GSC-PCI",
         .startup        = dino_startup_irq,
         .shutdown       = dino_disable_irq,
@@ -1019,22 +1019,22 @@ static int __init dino_probe(struct parisc_device *dev)
         ** It's not used to avoid chicken/egg problems
         ** with configuration accessor functions.
         */
-        bus = pci_scan_bus_parented(&dev->dev, dino_current_bus,
-                                    &dino_cfg_ops, NULL);
+        dino_dev->hba.hba_bus = bus = pci_scan_bus_parented(&dev->dev,
+                         dino_current_bus, &dino_cfg_ops, NULL);
+
         if(bus) {
-                pci_bus_add_devices(bus);
                 /* This code *depends* on scanning being single threaded
                  * if it isn't, this global bus number count will fail
                  */
                 dino_current_bus = bus->subordinate + 1;
                 pci_bus_assign_resources(bus);
+                pci_bus_add_devices(bus);
         } else {
-                printk(KERN_ERR "ERROR: failed to scan PCI bus on %s (probably duplicate bus number %d)\n",
+                printk(KERN_ERR "ERROR: failed to scan PCI bus on %s (duplicate bus number %d?)\n",
                        dev_name(&dev->dev), dino_current_bus);
                 /* increment the bus number in case of duplicates */
                 dino_current_bus++;
         }
-        dino_dev->hba.hba_bus = bus;
         return 0;
 }
 
diff --git a/drivers/parisc/eisa.c b/drivers/parisc/eisa.c
index 5b89f404e668..51220749cb65 100644
--- a/drivers/parisc/eisa.c
+++ b/drivers/parisc/eisa.c
@@ -188,7 +188,7 @@ static unsigned int eisa_startup_irq(unsigned int irq)
         return 0;
 }
 
-static struct hw_interrupt_type eisa_interrupt_type = {
+static struct irq_chip eisa_interrupt_type = {
         .typename =     "EISA",
         .startup =      eisa_startup_irq,
         .shutdown =     eisa_disable_irq,
diff --git a/drivers/parisc/eisa_enumerator.c b/drivers/parisc/eisa_enumerator.c
index c709ecc2b7f7..0be1d50645ab 100644
--- a/drivers/parisc/eisa_enumerator.c
+++ b/drivers/parisc/eisa_enumerator.c
@@ -101,7 +101,7 @@ static int configure_memory(const unsigned char *buf,
                         printk("memory %lx-%lx ", (unsigned long)res->start, (unsigned long)res->end);
                         result = request_resource(mem_parent, res);
                         if (result < 0) {
-                                printk("\n" KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");
+                                printk(KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");
                                 return result;
                         }
                 }
@@ -191,7 +191,7 @@ static int configure_port(const unsigned char *buf, struct resource *io_parent,
                         printk("ioports %lx-%lx ", (unsigned long)res->start, (unsigned long)res->end);
                         result = request_resource(io_parent, res);
                         if (result < 0) {
-                                printk("\n" KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");
+                                printk(KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");
                                 return result;
                         }
                 }
@@ -224,7 +224,7 @@ static int configure_port_init(const unsigned char *buf)
                  case HPEE_PORT_INIT_WIDTH_BYTE:
                         s=1;
                         if (c & HPEE_PORT_INIT_MASK) {
-                                printk("\n" KERN_WARNING "port_init: unverified mask attribute\n");
+                                printk(KERN_WARNING "port_init: unverified mask attribute\n");
                                 outb((inb(get_16(buf+len+1) & 
                                           get_8(buf+len+3)) | 
                                       get_8(buf+len+4)), get_16(buf+len+1));
@@ -249,7 +249,7 @@ static int configure_port_init(const unsigned char *buf)
                  case HPEE_PORT_INIT_WIDTH_DWORD:
                         s=4;
                         if (c & HPEE_PORT_INIT_MASK) {
-                                printk("\n" KERN_WARNING "port_init: unverified mask attribute\n");
+                                printk(KERN_WARNING "port_init: unverified mask attribute\n");
                                 outl((inl(get_16(buf+len+1) &
                                           get_32(buf+len+3)) |
                                       get_32(buf+len+7)), get_16(buf+len+1));
@@ -259,7 +259,7 @@ static int configure_port_init(const unsigned char *buf)
 
                         break;
                  default:
-                        printk("\n" KERN_ERR "Invalid port init word %02x\n", c);
+                        printk(KERN_ERR "Invalid port init word %02x\n", c);
                         return 0;
                 }
                 
@@ -297,7 +297,7 @@ static int configure_type_string(const unsigned char *buf)
         /* just skip past the type field */
         len = get_8(buf);
         if (len > 80) {
-                printk("\n" KERN_ERR "eisa_enumerator: type info field too long (%d, max is 80)\n", len);
+                printk(KERN_ERR "eisa_enumerator: type info field too long (%d, max is 80)\n", len);
         }
         
         return 1+len;
@@ -398,7 +398,7 @@ static int parse_slot_config(int slot,
                 }
                 
                 if (p0 + function_len < pos) {
-                        printk("\n" KERN_ERR "eisa_enumerator: function %d length mis-match "
+                        printk(KERN_ERR "eisa_enumerator: function %d length mis-match "
                                "got %d, expected %d\n",
                                num_func, pos-p0, function_len);
                         res=-1;
diff --git a/drivers/parisc/gsc.c b/drivers/parisc/gsc.c
index d33632917696..647adc9f85ad 100644
--- a/drivers/parisc/gsc.c
+++ b/drivers/parisc/gsc.c
@@ -148,7 +148,7 @@ static unsigned int gsc_asic_startup_irq(unsigned int irq)
         return 0;
 }
 
-static struct hw_interrupt_type gsc_asic_interrupt_type = {
+static struct irq_chip gsc_asic_interrupt_type = {
         .typename =     "GSC-ASIC",
         .startup =      gsc_asic_startup_irq,
         .shutdown =     gsc_asic_disable_irq,
@@ -158,7 +158,7 @@ static struct hw_interrupt_type gsc_asic_interrupt_type = {
         .end =          no_end_irq,
 };
 
-int gsc_assign_irq(struct hw_interrupt_type *type, void *data)
+int gsc_assign_irq(struct irq_chip *type, void *data)
 {
         static int irq = GSC_IRQ_BASE;
         struct irq_desc *desc;
diff --git a/drivers/parisc/gsc.h b/drivers/parisc/gsc.h
index 762a1babad60..b9d7bfb68e24 100644
--- a/drivers/parisc/gsc.h
+++ b/drivers/parisc/gsc.h
@@ -38,7 +38,7 @@ struct gsc_asic {
 int gsc_common_setup(struct parisc_device *parent, struct gsc_asic *gsc_asic);
 int gsc_alloc_irq(struct gsc_irq *dev);                 /* dev needs an irq */
 int gsc_claim_irq(struct gsc_irq *dev, int irq);        /* dev needs this irq */
-int gsc_assign_irq(struct hw_interrupt_type *type, void *data);
+int gsc_assign_irq(struct irq_chip *type, void *data);
 int gsc_find_local_irq(unsigned int irq, int *global_irq, int limit);
 void gsc_fixup_irqs(struct parisc_device *parent, void *ctrl,
                 void (*choose)(struct parisc_device *child, void *ctrl));
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 4a9cc92d4d18..88e333553212 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -729,7 +729,7 @@ static int iosapic_set_affinity_irq(unsigned int irq,
 }
 #endif
 
-static struct hw_interrupt_type iosapic_interrupt_type = {
+static struct irq_chip iosapic_interrupt_type = {
         .typename =     "IO-SAPIC-level",
         .startup =      iosapic_startup_irq,
         .shutdown =     iosapic_disable_irq,
diff --git a/drivers/parisc/lba_pci.c b/drivers/parisc/lba_pci.c
index 59fbbf128365..ede614616f8e 100644
--- a/drivers/parisc/lba_pci.c
+++ b/drivers/parisc/lba_pci.c
@@ -980,28 +980,38 @@ static void
 lba_pat_resources(struct parisc_device *pa_dev, struct lba_device *lba_dev)
 {
         unsigned long bytecnt;
-        pdc_pat_cell_mod_maddr_block_t pa_pdc_cell;     /* PA_VIEW */
-        pdc_pat_cell_mod_maddr_block_t io_pdc_cell;     /* IO_VIEW */
         long io_count;
         long status;    /* PDC return status */
         long pa_count;
+        pdc_pat_cell_mod_maddr_block_t *pa_pdc_cell;    /* PA_VIEW */
+        pdc_pat_cell_mod_maddr_block_t *io_pdc_cell;    /* IO_VIEW */
         int i;
 
+        pa_pdc_cell = kzalloc(sizeof(pdc_pat_cell_mod_maddr_block_t), GFP_KERNEL);
+        if (!pa_pdc_cell)
+                return;
+
+        io_pdc_cell = kzalloc(sizeof(pdc_pat_cell_mod_maddr_block_t), GFP_KERNEL);
+        if (!pa_pdc_cell) {
+                kfree(pa_pdc_cell);
+                return;
+        }
+
         /* return cell module (IO view) */
         status = pdc_pat_cell_module(&bytecnt, pa_dev->pcell_loc, pa_dev->mod_index,
-                                PA_VIEW, & pa_pdc_cell);
-        pa_count = pa_pdc_cell.mod[1];
+                                PA_VIEW, pa_pdc_cell);
+        pa_count = pa_pdc_cell->mod[1];
 
         status |= pdc_pat_cell_module(&bytecnt, pa_dev->pcell_loc, pa_dev->mod_index,
-                                IO_VIEW, &io_pdc_cell);
-        io_count = io_pdc_cell.mod[1];
+                                IO_VIEW, io_pdc_cell);
+        io_count = io_pdc_cell->mod[1];
 
         /* We've already done this once for device discovery...*/
         if (status != PDC_OK) {
                 panic("pdc_pat_cell_module() call failed for LBA!\n");
         }
 
-        if (PAT_GET_ENTITY(pa_pdc_cell.mod_info) != PAT_ENTITY_LBA) {
+        if (PAT_GET_ENTITY(pa_pdc_cell->mod_info) != PAT_ENTITY_LBA) {
                 panic("pdc_pat_cell_module() entity returned != PAT_ENTITY_LBA!\n");
         }
 
@@ -1016,8 +1026,8 @@ lba_pat_resources(struct parisc_device *pa_dev, struct lba_device *lba_dev)
                 } *p, *io;
                 struct resource *r;
 
-                p = (void *) &(pa_pdc_cell.mod[2+i*3]);
-                io = (void *) &(io_pdc_cell.mod[2+i*3]);
+                p = (void *) &(pa_pdc_cell->mod[2+i*3]);
+                io = (void *) &(io_pdc_cell->mod[2+i*3]);
 
                 /* Convert the PAT range data to PCI "struct resource" */
                 switch(p->type & 0xff) {
@@ -1096,6 +1106,9 @@ lba_pat_resources(struct parisc_device *pa_dev, struct lba_device *lba_dev)
                         break;
                 }
         }
+
+        kfree(pa_pdc_cell);
+        kfree(io_pdc_cell);
 }
 #else
 /* keep compiler from complaining about missing declarations */
@@ -1509,10 +1522,6 @@ lba_driver_probe(struct parisc_device *dev)
         lba_bus = lba_dev->hba.hba_bus =
                 pci_scan_bus_parented(&dev->dev, lba_dev->hba.bus_num.start,
                                 cfg_ops, NULL);
-        if (lba_bus) {
-                lba_next_bus = lba_bus->subordinate + 1;
-                pci_bus_add_devices(lba_bus);
-        }
 
         /* This is in lieu of calling pci_assign_unassigned_resources() */
         if (is_pdc_pat()) {
@@ -1533,7 +1542,6 @@ lba_driver_probe(struct parisc_device *dev)
         }
         pci_enable_bridges(lba_bus);
 
-
         /*
         ** Once PCI register ops has walked the bus, access to config
         ** space is restricted. Avoids master aborts on config cycles.
@@ -1543,6 +1551,11 @@ lba_driver_probe(struct parisc_device *dev)
                 lba_dev->flags |= LBA_FLAG_SKIP_PROBE;
         }
 
+        if (lba_bus) {
+                lba_next_bus = lba_bus->subordinate + 1;
+                pci_bus_add_devices(lba_bus);
+        }
+
         /* Whew! Finally done! Tell services we got this one covered. */
         return 0;
 }
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index d46dd57450ac..123d8fe3427d 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -2057,6 +2057,7 @@ void sba_directed_lmmio(struct parisc_device *pci_hba, struct resource *r)
                 r->start = (base & ~1UL) | PCI_F_EXTEND;
                 size = ~ READ_REG32(reg + LMMIO_DIRECT0_MASK);
                 r->end = r->start + size;
+                r->flags = IORESOURCE_MEM;
         }
 }
 
@@ -2093,4 +2094,5 @@ void sba_distributed_lmmio(struct parisc_device *pci_hba, struct resource *r )
         size = (~READ_REG32(sba->sba_hpa + LMMIO_DIST_MASK)) / ROPES_PER_IOC;
         r->start += rope * (size + 1);  /* adjust base for this rope */
         r->end = r->start + size;
+        r->flags = IORESOURCE_MEM;
 }
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index 33e5ade774ca..675f04e6597a 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -325,7 +325,7 @@ static unsigned int superio_startup_irq(unsigned int irq)
         return 0;
 }
 
-static struct hw_interrupt_type superio_interrupt_type = {
+static struct irq_chip superio_interrupt_type = {
         .typename =     SUPERIO,
         .startup =      superio_startup_irq,
         .shutdown =     superio_disable_irq,
@@ -434,8 +434,8 @@ static void __init superio_parport_init(void)
                         0 /*base_hi*/,
                         PAR_IRQ, 
                         PARPORT_DMA_NONE /* dma */,
-                        NULL /*struct pci_dev* */),
-                        0 /* shared irq flags */ )
+                        NULL /*struct pci_dev* */,
+                        0 /* shared irq flags */))
 
                 printk(KERN_WARNING PFX "Probing parallel port failed.\n");
 #endif  /* CONFIG_PARPORT_PC */
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 1032d5fdbd42..2597145a066e 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -2907,6 +2907,7 @@ enum parport_pc_pci_cards {
         netmos_9755,
         netmos_9805,
         netmos_9815,
+        netmos_9901,
         quatech_sppxp100,
 };
 
@@ -2987,7 +2988,7 @@ static struct parport_pc_pci {
         /* netmos_9755 */               { 2, { { 0, 1 }, { 2, 3 },} },
         /* netmos_9805 */               { 1, { { 0, -1 }, } },
         /* netmos_9815 */               { 2, { { 0, -1 }, { 2, -1 }, } },
-
+        /* netmos_9901 */               { 1, { { 0, -1 }, } },
         /* quatech_sppxp100 */          { 1, { { 0, 1 }, } },
 };
 
@@ -3089,6 +3090,8 @@ static const struct pci_device_id parport_pc_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, netmos_9805 },
         { PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9815,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, netmos_9815 },
+        { PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901,
+          0xA000, 0x2000, 0, 0, netmos_9901 },
         /* Quatech SPPXP-100 Parallel port PCI ExpressCard */
         { PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SPPXP_100,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, quatech_sppxp100 },
diff --git a/drivers/pci/hotplug/pci_hotplug_core.c b/drivers/pci/hotplug/pci_hotplug_core.c
index 844580489d4d..5c5043f239cf 100644
--- a/drivers/pci/hotplug/pci_hotplug_core.c
+++ b/drivers/pci/hotplug/pci_hotplug_core.c
@@ -555,6 +555,8 @@ static struct hotplug_slot *get_slot_from_name (const char *name)
  * @slot: pointer to the &struct hotplug_slot to register
  * @devnr: device number
  * @name: name registered with kobject core
+ * @owner: caller module owner
+ * @mod_name: caller module name
  *
  * Registers a hotplug slot with the pci hotplug subsystem, which will allow
  * userspace interaction to the slot.
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index e53eacd75c8d..ebc9b8dca881 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -39,7 +39,6 @@
 #include <linux/sysdev.h>
 #include <asm/cacheflush.h>
 #include <asm/iommu.h>
-#include <asm/e820.h>
 #include "pci.h"
 
 #define ROOT_SIZE               VTD_PAGE_SIZE
@@ -57,14 +56,32 @@
 #define MAX_AGAW_WIDTH 64
 
 #define DOMAIN_MAX_ADDR(gaw) ((((u64)1) << gaw) - 1)
+#define DOMAIN_MAX_PFN(gaw)  ((((u64)1) << (gaw-VTD_PAGE_SHIFT)) - 1)
 
 #define IOVA_PFN(addr)          ((addr) >> PAGE_SHIFT)
 #define DMA_32BIT_PFN           IOVA_PFN(DMA_BIT_MASK(32))
 #define DMA_64BIT_PFN           IOVA_PFN(DMA_BIT_MASK(64))
 
-#ifndef PHYSICAL_PAGE_MASK
-#define PHYSICAL_PAGE_MASK PAGE_MASK
-#endif
+
+/* VT-d pages must always be _smaller_ than MM pages. Otherwise things
+   are never going to work. */
+static inline unsigned long dma_to_mm_pfn(unsigned long dma_pfn)
+{
+        return dma_pfn >> (PAGE_SHIFT - VTD_PAGE_SHIFT);
+}
+
+static inline unsigned long mm_to_dma_pfn(unsigned long mm_pfn)
+{
+        return mm_pfn << (PAGE_SHIFT - VTD_PAGE_SHIFT);
+}
+static inline unsigned long page_to_dma_pfn(struct page *pg)
+{
+        return mm_to_dma_pfn(page_to_pfn(pg));
+}
+static inline unsigned long virt_to_dma_pfn(void *p)
+{
+        return page_to_dma_pfn(virt_to_page(p));
+}
 
 /* global iommu list, set NULL for ignored DMAR units */
 static struct intel_iommu **g_iommus;
@@ -205,12 +222,17 @@ static inline void dma_set_pte_prot(struct dma_pte *pte, unsigned long prot)
 
 static inline u64 dma_pte_addr(struct dma_pte *pte)
 {
-        return (pte->val & VTD_PAGE_MASK);
+#ifdef CONFIG_64BIT
+        return pte->val & VTD_PAGE_MASK;
+#else
+        /* Must have a full atomic 64-bit read */
+        return  __cmpxchg64(pte, 0ULL, 0ULL) & VTD_PAGE_MASK;
+#endif
 }
 
-static inline void dma_set_pte_addr(struct dma_pte *pte, u64 addr)
+static inline void dma_set_pte_pfn(struct dma_pte *pte, unsigned long pfn)
 {
-        pte->val |= (addr & VTD_PAGE_MASK);
+        pte->val |= (uint64_t)pfn << VTD_PAGE_SHIFT;
 }
 
 static inline bool dma_pte_present(struct dma_pte *pte)
@@ -218,6 +240,11 @@ static inline bool dma_pte_present(struct dma_pte *pte)
         return (pte->val & 3) != 0;
 }
 
+static inline int first_pte_in_page(struct dma_pte *pte)
+{
+        return !((unsigned long)pte & ~VTD_PAGE_MASK);
+}
+
 /*
  * This domain is a statically identity mapping domain.
  *      1. This domain creats a static 1:1 mapping to all usable memory.
@@ -245,7 +272,6 @@ struct dmar_domain {
         struct iova_domain iovad;       /* iova's that belong to this domain */
 
         struct dma_pte  *pgd;           /* virtual address */
-        spinlock_t      mapping_lock;   /* page table lock */
         int             gaw;            /* max guest address width */
 
         /* adjusted guest address width, 0 is level 2 30-bit */
@@ -649,80 +675,78 @@ static inline int width_to_agaw(int width)
 
 static inline unsigned int level_to_offset_bits(int level)
 {
-        return (12 + (level - 1) * LEVEL_STRIDE);
+        return (level - 1) * LEVEL_STRIDE;
 }
 
-static inline int address_level_offset(u64 addr, int level)
+static inline int pfn_level_offset(unsigned long pfn, int level)
 {
-        return ((addr >> level_to_offset_bits(level)) & LEVEL_MASK);
+        return (pfn >> level_to_offset_bits(level)) & LEVEL_MASK;
 }
 
-static inline u64 level_mask(int level)
+static inline unsigned long level_mask(int level)
 {
-        return ((u64)-1 << level_to_offset_bits(level));
+        return -1UL << level_to_offset_bits(level);
 }
 
-static inline u64 level_size(int level)
+static inline unsigned long level_size(int level)
 {
-        return ((u64)1 << level_to_offset_bits(level));
+        return 1UL << level_to_offset_bits(level);
 }
 
-static inline u64 align_to_level(u64 addr, int level)
+static inline unsigned long align_to_level(unsigned long pfn, int level)
 {
-        return ((addr + level_size(level) - 1) & level_mask(level));
+        return (pfn + level_size(level) - 1) & level_mask(level);
 }
 
-static struct dma_pte * addr_to_dma_pte(struct dmar_domain *domain, u64 addr)
+static struct dma_pte *pfn_to_dma_pte(struct dmar_domain *domain,
+                                      unsigned long pfn)
 {
-        int addr_width = agaw_to_width(domain->agaw);
+        int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
         struct dma_pte *parent, *pte = NULL;
         int level = agaw_to_level(domain->agaw);
         int offset;
-        unsigned long flags;
 
         BUG_ON(!domain->pgd);
-
-        addr &= (((u64)1) << addr_width) - 1;
+        BUG_ON(addr_width < BITS_PER_LONG && pfn >> addr_width);
         parent = domain->pgd;
 
-        spin_lock_irqsave(&domain->mapping_lock, flags);
         while (level > 0) {
                 void *tmp_page;
 
-                offset = address_level_offset(addr, level);
+                offset = pfn_level_offset(pfn, level);
                 pte = &parent[offset];
                 if (level == 1)
                         break;
 
                 if (!dma_pte_present(pte)) {
+                        uint64_t pteval;
+
                         tmp_page = alloc_pgtable_page();
 
-                        if (!tmp_page) {
-                                spin_unlock_irqrestore(&domain->mapping_lock,
-                                        flags);
+                        if (!tmp_page)
                                 return NULL;
+
+                        domain_flush_cache(domain, tmp_page, VTD_PAGE_SIZE);
+                        pteval = (virt_to_dma_pfn(tmp_page) << VTD_PAGE_SHIFT) | DMA_PTE_READ | DMA_PTE_WRITE;
+                        if (cmpxchg64(&pte->val, 0ULL, pteval)) {
+                                /* Someone else set it while we were thinking; use theirs. */
+                                free_pgtable_page(tmp_page);
+                        } else {
+                                dma_pte_addr(pte);
+                                domain_flush_cache(domain, pte, sizeof(*pte));
                         }
-                        domain_flush_cache(domain, tmp_page, PAGE_SIZE);
-                        dma_set_pte_addr(pte, virt_to_phys(tmp_page));
-                        /*
-                         * high level table always sets r/w, last level page
-                         * table control read/write
-                         */
-                        dma_set_pte_readable(pte);
-                        dma_set_pte_writable(pte);
-                        domain_flush_cache(domain, pte, sizeof(*pte));
                 }
                 parent = phys_to_virt(dma_pte_addr(pte));
                 level--;
         }
 
-        spin_unlock_irqrestore(&domain->mapping_lock, flags);
         return pte;
 }
 
 /* return address's pte at specific level */
-static struct dma_pte *dma_addr_level_pte(struct dmar_domain *domain, u64 addr,
-                int level)
+static struct dma_pte *dma_pfn_level_pte(struct dmar_domain *domain,
+                                         unsigned long pfn,
+                                         int level)
 {
         struct dma_pte *parent, *pte = NULL;
         int total = agaw_to_level(domain->agaw);
@@ -730,7 +754,7 @@ static struct dma_pte *dma_addr_level_pte(struct dmar_domain *domain, u64 addr,
 
         parent = domain->pgd;
         while (level <= total) {
-                offset = address_level_offset(addr, total);
+                offset = pfn_level_offset(pfn, total);
                 pte = &parent[offset];
                 if (level == total)
                         return pte;
@@ -743,74 +767,82 @@ static struct dma_pte *dma_addr_level_pte(struct dmar_domain *domain, u64 addr,
         return NULL;
 }
 
-/* clear one page's page table */
-static void dma_pte_clear_one(struct dmar_domain *domain, u64 addr)
-{
-        struct dma_pte *pte = NULL;
-
-        /* get last level pte */
-        pte = dma_addr_level_pte(domain, addr, 1);
-
-        if (pte) {
-                dma_clear_pte(pte);
-                domain_flush_cache(domain, pte, sizeof(*pte));
-        }
-}
-
 /* clear last level pte, a tlb flush should be followed */
-static void dma_pte_clear_range(struct dmar_domain *domain, u64 start, u64 end)
+static void dma_pte_clear_range(struct dmar_domain *domain,
+                                unsigned long start_pfn,
+                                unsigned long last_pfn)
 {
-        int addr_width = agaw_to_width(domain->agaw);
-        int npages;
+        int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
+        struct dma_pte *first_pte, *pte;
 
-        start &= (((u64)1) << addr_width) - 1;
-        end &= (((u64)1) << addr_width) - 1;
-        /* in case it's partial page */
-        start &= PAGE_MASK;
-        end = PAGE_ALIGN(end);
-        npages = (end - start) / VTD_PAGE_SIZE;
+        BUG_ON(addr_width < BITS_PER_LONG && start_pfn >> addr_width);
+        BUG_ON(addr_width < BITS_PER_LONG && last_pfn >> addr_width);
 
-        /* we don't need lock here, nobody else touches the iova range */
-        while (npages--) {
-                dma_pte_clear_one(domain, start);
-                start += VTD_PAGE_SIZE;
+        /* we don't need lock here; nobody else touches the iova range */
+        while (start_pfn <= last_pfn) {
+                first_pte = pte = dma_pfn_level_pte(domain, start_pfn, 1);
+                if (!pte) {
+                        start_pfn = align_to_level(start_pfn + 1, 2);
+                        continue;
+                }
+                do { 
+                        dma_clear_pte(pte);
+                        start_pfn++;
+                        pte++;
+                } while (start_pfn <= last_pfn && !first_pte_in_page(pte));
+
+                domain_flush_cache(domain, first_pte,
+                                   (void *)pte - (void *)first_pte);
         }
 }
 
 /* free page table pages. last level pte should already be cleared */
 static void dma_pte_free_pagetable(struct dmar_domain *domain,
-        u64 start, u64 end)
+                                   unsigned long start_pfn,
+                                   unsigned long last_pfn)
 {
-        int addr_width = agaw_to_width(domain->agaw);
-        struct dma_pte *pte;
+        int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
+        struct dma_pte *first_pte, *pte;
         int total = agaw_to_level(domain->agaw);
         int level;
-        u64 tmp;
+        unsigned long tmp;
 
-        start &= (((u64)1) << addr_width) - 1;
-        end &= (((u64)1) << addr_width) - 1;
+        BUG_ON(addr_width < BITS_PER_LONG && start_pfn >> addr_width);
+        BUG_ON(addr_width < BITS_PER_LONG && last_pfn >> addr_width);
 
-        /* we don't need lock here, nobody else touches the iova range */
+        /* We don't need lock here; nobody else touches the iova range */
         level = 2;
         while (level <= total) {
-                tmp = align_to_level(start, level);
-                if (tmp >= end || (tmp + level_size(level) > end))
+                tmp = align_to_level(start_pfn, level);
+
+                /* If we can't even clear one PTE at this level, we're done */
+                if (tmp + level_size(level) - 1 > last_pfn)
                         return;
 
-                while (tmp < end) {
-                        pte = dma_addr_level_pte(domain, tmp, level);
-                        if (pte) {
-                                free_pgtable_page(
-                                        phys_to_virt(dma_pte_addr(pte)));
-                                dma_clear_pte(pte);
-                                domain_flush_cache(domain, pte, sizeof(*pte));
+                while (tmp + level_size(level) - 1 <= last_pfn) {
+                        first_pte = pte = dma_pfn_level_pte(domain, tmp, level);
+                        if (!pte) {
+                                tmp = align_to_level(tmp + 1, level + 1);
+                                continue;
                         }
-                        tmp += level_size(level);
+                        do {
+                                if (dma_pte_present(pte)) {
+                                        free_pgtable_page(phys_to_virt(dma_pte_addr(pte)));
+                                        dma_clear_pte(pte);
+                                }
+                                pte++;
+                                tmp += level_size(level);
+                        } while (!first_pte_in_page(pte) &&
+                                 tmp + level_size(level) - 1 <= last_pfn);
+
+                        domain_flush_cache(domain, first_pte,
+                                           (void *)pte - (void *)first_pte);
+                        
                 }
                 level++;
         }
         /* free pgd */
-        if (start == 0 && end >= ((((u64)1) << addr_width) - 1)) {
+        if (start_pfn == 0 && last_pfn == DOMAIN_MAX_PFN(domain->gaw)) {
                 free_pgtable_page(domain->pgd);
                 domain->pgd = NULL;
         }
@@ -1036,11 +1068,11 @@ static void iommu_flush_dev_iotlb(struct dmar_domain *domain,
 }
 
 static void iommu_flush_iotlb_psi(struct intel_iommu *iommu, u16 did,
-                                  u64 addr, unsigned int pages)
+                                  unsigned long pfn, unsigned int pages)
 {
         unsigned int mask = ilog2(__roundup_pow_of_two(pages));
+        uint64_t addr = (uint64_t)pfn << VTD_PAGE_SHIFT;
 
-        BUG_ON(addr & (~VTD_PAGE_MASK));
         BUG_ON(pages == 0);
 
         /*
@@ -1055,7 +1087,12 @@ static void iommu_flush_iotlb_psi(struct intel_iommu *iommu, u16 did,
         else
                 iommu->flush.flush_iotlb(iommu, did, addr, mask,
                                                 DMA_TLB_PSI_FLUSH);
-        if (did)
+
+        /*
+         * In caching mode, domain ID 0 is reserved for non-present to present
+         * mapping flush. Device IOTLB doesn't need to be flushed in this case.
+         */
+        if (!cap_caching_mode(iommu->cap) || did)
                 iommu_flush_dev_iotlb(iommu->domains[did], addr, mask);
 }
 
@@ -1280,7 +1317,6 @@ static void dmar_init_reserved_ranges(void)
         struct pci_dev *pdev = NULL;
         struct iova *iova;
         int i;
-        u64 addr, size;
 
         init_iova_domain(&reserved_iova_list, DMA_32BIT_PFN);
 
@@ -1303,12 +1339,9 @@ static void dmar_init_reserved_ranges(void)
                         r = &pdev->resource[i];
                         if (!r->flags || !(r->flags & IORESOURCE_MEM))
                                 continue;
-                        addr = r->start;
-                        addr &= PHYSICAL_PAGE_MASK;
-                        size = r->end - addr;
-                        size = PAGE_ALIGN(size);
-                        iova = reserve_iova(&reserved_iova_list, IOVA_PFN(addr),
-                                IOVA_PFN(size + addr) - 1);
+                        iova = reserve_iova(&reserved_iova_list,
+                                            IOVA_PFN(r->start),
+                                            IOVA_PFN(r->end));
                         if (!iova)
                                 printk(KERN_ERR "Reserve iova failed\n");
                 }
@@ -1342,7 +1375,6 @@ static int domain_init(struct dmar_domain *domain, int guest_width)
         unsigned long sagaw;
 
         init_iova_domain(&domain->iovad, DMA_32BIT_PFN);
-        spin_lock_init(&domain->mapping_lock);
         spin_lock_init(&domain->iommu_lock);
 
         domain_reserve_special_ranges(domain);
@@ -1389,7 +1421,6 @@ static void domain_exit(struct dmar_domain *domain)
 {
         struct dmar_drhd_unit *drhd;
         struct intel_iommu *iommu;
-        u64 end;
 
         /* Domain 0 is reserved, so dont process it */
         if (!domain)
@@ -1398,14 +1429,12 @@ static void domain_exit(struct dmar_domain *domain)
         domain_remove_dev_info(domain);
         /* destroy iovas */
         put_iova_domain(&domain->iovad);
-        end = DOMAIN_MAX_ADDR(domain->gaw);
-        end = end & (~PAGE_MASK);
 
         /* clear ptes */
-        dma_pte_clear_range(domain, 0, end);
+        dma_pte_clear_range(domain, 0, DOMAIN_MAX_PFN(domain->gaw));
 
         /* free page tables */
-        dma_pte_free_pagetable(domain, 0, end);
+        dma_pte_free_pagetable(domain, 0, DOMAIN_MAX_PFN(domain->gaw));
 
         for_each_active_iommu(iommu, drhd)
                 if (test_bit(iommu->seq_id, &domain->iommu_bmp))
@@ -1619,42 +1648,86 @@ static int domain_context_mapped(struct pci_dev *pdev)
                                              tmp->devfn);
 }
 
-static int
-domain_page_mapping(struct dmar_domain *domain, dma_addr_t iova,
-                        u64 hpa, size_t size, int prot)
+static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
+                            struct scatterlist *sg, unsigned long phys_pfn,
+                            unsigned long nr_pages, int prot)
 {
-        u64 start_pfn, end_pfn;
-        struct dma_pte *pte;
-        int index;
-        int addr_width = agaw_to_width(domain->agaw);
+        struct dma_pte *first_pte = NULL, *pte = NULL;
+        phys_addr_t uninitialized_var(pteval);
+        int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
+        unsigned long sg_res;
 
-        hpa &= (((u64)1) << addr_width) - 1;
+        BUG_ON(addr_width < BITS_PER_LONG && (iov_pfn + nr_pages - 1) >> addr_width);
 
         if ((prot & (DMA_PTE_READ|DMA_PTE_WRITE)) == 0)
                 return -EINVAL;
-        iova &= PAGE_MASK;
-        start_pfn = ((u64)hpa) >> VTD_PAGE_SHIFT;
-        end_pfn = (VTD_PAGE_ALIGN(((u64)hpa) + size)) >> VTD_PAGE_SHIFT;
-        index = 0;
-        while (start_pfn < end_pfn) {
-                pte = addr_to_dma_pte(domain, iova + VTD_PAGE_SIZE * index);
-                if (!pte)
-                        return -ENOMEM;
+
+        prot &= DMA_PTE_READ | DMA_PTE_WRITE | DMA_PTE_SNP;
+
+        if (sg)
+                sg_res = 0;
+        else {
+                sg_res = nr_pages + 1;
+                pteval = ((phys_addr_t)phys_pfn << VTD_PAGE_SHIFT) | prot;
+        }
+
+        while (nr_pages--) {
+                uint64_t tmp;
+
+                if (!sg_res) {
+                        sg_res = (sg->offset + sg->length + VTD_PAGE_SIZE - 1) >> VTD_PAGE_SHIFT;
+                        sg->dma_address = ((dma_addr_t)iov_pfn << VTD_PAGE_SHIFT) + sg->offset;
+                        sg->dma_length = sg->length;
+                        pteval = page_to_phys(sg_page(sg)) | prot;
+                }
+                if (!pte) {
+                        first_pte = pte = pfn_to_dma_pte(domain, iov_pfn);
+                        if (!pte)
+                                return -ENOMEM;
+                }
                 /* We don't need lock here, nobody else
                  * touches the iova range
                  */
-                BUG_ON(dma_pte_addr(pte));
-                dma_set_pte_addr(pte, start_pfn << VTD_PAGE_SHIFT);
-                dma_set_pte_prot(pte, prot);
-                if (prot & DMA_PTE_SNP)
-                        dma_set_pte_snp(pte);
-                domain_flush_cache(domain, pte, sizeof(*pte));
-                start_pfn++;
-                index++;
+                tmp = cmpxchg64_local(&pte->val, 0ULL, pteval);
+                if (tmp) {
+                        static int dumps = 5;
+                        printk(KERN_CRIT "ERROR: DMA PTE for vPFN 0x%lx already set (to %llx not %llx)\n",
+                               iov_pfn, tmp, (unsigned long long)pteval);
+                        if (dumps) {
+                                dumps--;
+                                debug_dma_dump_mappings(NULL);
+                        }
+                        WARN_ON(1);
+                }
+                pte++;
+                if (!nr_pages || first_pte_in_page(pte)) {
+                        domain_flush_cache(domain, first_pte,
+                                           (void *)pte - (void *)first_pte);
+                        pte = NULL;
+                }
+                iov_pfn++;
+                pteval += VTD_PAGE_SIZE;
+                sg_res--;
+                if (!sg_res)
+                        sg = sg_next(sg);
         }
         return 0;
 }
 
+static inline int domain_sg_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
+                                    struct scatterlist *sg, unsigned long nr_pages,
+                                    int prot)
+{
+        return __domain_mapping(domain, iov_pfn, sg, 0, nr_pages, prot);
+}
+
+static inline int domain_pfn_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
+                                     unsigned long phys_pfn, unsigned long nr_pages,
+                                     int prot)
+{
+        return __domain_mapping(domain, iov_pfn, NULL, phys_pfn, nr_pages, prot);
+}
+
 static void iommu_detach_dev(struct intel_iommu *iommu, u8 bus, u8 devfn)
 {
         if (!iommu)
@@ -1845,58 +1918,61 @@ error:
 
 static int iommu_identity_mapping;
 
+static int iommu_domain_identity_map(struct dmar_domain *domain,
+                                     unsigned long long start,
+                                     unsigned long long end)
+{
+        unsigned long first_vpfn = start >> VTD_PAGE_SHIFT;
+        unsigned long last_vpfn = end >> VTD_PAGE_SHIFT;
+
+        if (!reserve_iova(&domain->iovad, dma_to_mm_pfn(first_vpfn),
+                          dma_to_mm_pfn(last_vpfn))) {
+                printk(KERN_ERR "IOMMU: reserve iova failed\n");
+                return -ENOMEM;
+        }
+
+        pr_debug("Mapping reserved region %llx-%llx for domain %d\n",
+                 start, end, domain->id);
+        /*
+         * RMRR range might have overlap with physical memory range,
+         * clear it first
+         */
+        dma_pte_clear_range(domain, first_vpfn, last_vpfn);
+
+        return domain_pfn_mapping(domain, first_vpfn, first_vpfn,
+                                  last_vpfn - first_vpfn + 1,
+                                  DMA_PTE_READ|DMA_PTE_WRITE);
+}
+
 static int iommu_prepare_identity_map(struct pci_dev *pdev,
                                       unsigned long long start,
                                       unsigned long long end)
 {
         struct dmar_domain *domain;
-        unsigned long size;
-        unsigned long long base;
         int ret;
 
         printk(KERN_INFO
-                "IOMMU: Setting identity map for device %s [0x%Lx - 0x%Lx]\n",
-                pci_name(pdev), start, end);
-        if (iommu_identity_mapping)
-                domain = si_domain;
-        else
-                /* page table init */
-                domain = get_domain_for_dev(pdev, DEFAULT_DOMAIN_ADDRESS_WIDTH);
+               "IOMMU: Setting identity map for device %s [0x%Lx - 0x%Lx]\n",
+               pci_name(pdev), start, end);
+
+        domain = get_domain_for_dev(pdev, DEFAULT_DOMAIN_ADDRESS_WIDTH);
         if (!domain)
                 return -ENOMEM;
 
-        /* The address might not be aligned */
-        base = start & PAGE_MASK;
-        size = end - base;
-        size = PAGE_ALIGN(size);
-        if (!reserve_iova(&domain->iovad, IOVA_PFN(base),
-                        IOVA_PFN(base + size) - 1)) {
-                printk(KERN_ERR "IOMMU: reserve iova failed\n");
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        pr_debug("Mapping reserved region %lx@%llx for %s\n",
-                size, base, pci_name(pdev));
-        /*
-         * RMRR range might have overlap with physical memory range,
-         * clear it first
-         */
-        dma_pte_clear_range(domain, base, base + size);
-
-        ret = domain_page_mapping(domain, base, base, size,
-                DMA_PTE_READ|DMA_PTE_WRITE);
+        ret = iommu_domain_identity_map(domain, start, end);
         if (ret)
                 goto error;
 
         /* context entry init */
         ret = domain_context_mapping(domain, pdev, CONTEXT_TT_MULTI_LEVEL);
-        if (!ret)
-                return 0;
-error:
+        if (ret)
+                goto error;
+
+        return 0;
+
+ error:
         domain_exit(domain);
         return ret;
-
 }
 
 static inline int iommu_prepare_rmrr_dev(struct dmar_rmrr_unit *rmrr,
@@ -1908,64 +1984,6 @@ static inline int iommu_prepare_rmrr_dev(struct dmar_rmrr_unit *rmrr,
                 rmrr->end_address + 1);
 }
 
-#ifdef CONFIG_DMAR_GFX_WA
-struct iommu_prepare_data {
-        struct pci_dev *pdev;
-        int ret;
-};
-
-static int __init iommu_prepare_work_fn(unsigned long start_pfn,
-                                         unsigned long end_pfn, void *datax)
-{
-        struct iommu_prepare_data *data;
-
-        data = (struct iommu_prepare_data *)datax;
-
-        data->ret = iommu_prepare_identity_map(data->pdev,
-                                start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);
-        return data->ret;
-
-}
-
-static int __init iommu_prepare_with_active_regions(struct pci_dev *pdev)
-{
-        int nid;
-        struct iommu_prepare_data data;
-
-        data.pdev = pdev;
-        data.ret = 0;
-
-        for_each_online_node(nid) {
-                work_with_active_regions(nid, iommu_prepare_work_fn, &data);
-                if (data.ret)
-                        return data.ret;
-        }
-        return data.ret;
-}
-
-static void __init iommu_prepare_gfx_mapping(void)
-{
-        struct pci_dev *pdev = NULL;
-        int ret;
-
-        for_each_pci_dev(pdev) {
-                if (pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO ||
-                                !IS_GFX_DEVICE(pdev))
-                        continue;
-                printk(KERN_INFO "IOMMU: gfx device %s 1-1 mapping\n",
-                        pci_name(pdev));
-                ret = iommu_prepare_with_active_regions(pdev);
-                if (ret)
-                        printk(KERN_ERR "IOMMU: mapping reserved region failed\n");
-        }
-}
-#else /* !CONFIG_DMAR_GFX_WA */
-static inline void iommu_prepare_gfx_mapping(void)
-{
-        return;
-}
-#endif
-
 #ifdef CONFIG_DMAR_FLOPPY_WA
 static inline void iommu_prepare_isa(void)
 {
@@ -1976,12 +1994,12 @@ static inline void iommu_prepare_isa(void)
         if (!pdev)
                 return;
 
-        printk(KERN_INFO "IOMMU: Prepare 0-16M unity mapping for LPC\n");
+        printk(KERN_INFO "IOMMU: Prepare 0-16MiB unity mapping for LPC\n");
         ret = iommu_prepare_identity_map(pdev, 0, 16*1024*1024);
 
         if (ret)
-                printk(KERN_ERR "IOMMU: Failed to create 0-64M identity map, "
-                        "floppy might not work\n");
+                printk(KERN_ERR "IOMMU: Failed to create 0-16MiB identity map; "
+                       "floppy might not work\n");
 
 }
 #else
@@ -2009,16 +2027,30 @@ static int __init init_context_pass_through(void)
 }
 
 static int md_domain_init(struct dmar_domain *domain, int guest_width);
+
+static int __init si_domain_work_fn(unsigned long start_pfn,
+                                    unsigned long end_pfn, void *datax)
+{
+        int *ret = datax;
+
+        *ret = iommu_domain_identity_map(si_domain,
+                                         (uint64_t)start_pfn << PAGE_SHIFT,
+                                         (uint64_t)end_pfn << PAGE_SHIFT);
+        return *ret;
+
+}
+
 static int si_domain_init(void)
 {
         struct dmar_drhd_unit *drhd;
         struct intel_iommu *iommu;
-        int ret = 0;
+        int nid, ret = 0;
 
         si_domain = alloc_domain();
         if (!si_domain)
                 return -EFAULT;
 
+        pr_debug("Identity mapping domain is domain %d\n", si_domain->id);
 
         for_each_active_iommu(iommu, drhd) {
                 ret = iommu_attach_domain(si_domain, iommu);
@@ -2035,6 +2067,12 @@ static int si_domain_init(void)
 
         si_domain->flags = DOMAIN_FLAG_STATIC_IDENTITY;
 
+        for_each_online_node(nid) {
+                work_with_active_regions(nid, si_domain_work_fn, &ret);
+                if (ret)
+                        return ret;
+        }
+
         return 0;
 }
 
@@ -2079,9 +2117,49 @@ static int domain_add_dev_info(struct dmar_domain *domain,
         return 0;
 }
 
+static int iommu_should_identity_map(struct pci_dev *pdev, int startup)
+{
+        if (iommu_identity_mapping == 2)
+                return IS_GFX_DEVICE(pdev);
+
+        /*
+         * We want to start off with all devices in the 1:1 domain, and
+         * take them out later if we find they can't access all of memory.
+         *
+         * However, we can't do this for PCI devices behind bridges,
+         * because all PCI devices behind the same bridge will end up
+         * with the same source-id on their transactions.
+         *
+         * Practically speaking, we can't change things around for these
+         * devices at run-time, because we can't be sure there'll be no
+         * DMA transactions in flight for any of their siblings.
+         * 
+         * So PCI devices (unless they're on the root bus) as well as
+         * their parent PCI-PCI or PCIe-PCI bridges must be left _out_ of
+         * the 1:1 domain, just in _case_ one of their siblings turns out
+         * not to be able to map all of memory.
+         */
+        if (!pdev->is_pcie) {
+                if (!pci_is_root_bus(pdev->bus))
+                        return 0;
+                if (pdev->class >> 8 == PCI_CLASS_BRIDGE_PCI)
+                        return 0;
+        } else if (pdev->pcie_type == PCI_EXP_TYPE_PCI_BRIDGE)
+                return 0;
+
+        /* 
+         * At boot time, we don't yet know if devices will be 64-bit capable.
+         * Assume that they will -- if they turn out not to be, then we can 
+         * take them out of the 1:1 domain later.
+         */
+        if (!startup)
+                return pdev->dma_mask > DMA_BIT_MASK(32);
+
+        return 1;
+}
+
 static int iommu_prepare_static_identity_mapping(void)
 {
-        int i;
         struct pci_dev *pdev = NULL;
         int ret;
 
@@ -2089,23 +2167,19 @@ static int iommu_prepare_static_identity_mapping(void)
         if (ret)
                 return -EFAULT;
 
-        printk(KERN_INFO "IOMMU: Setting identity map:\n");
         for_each_pci_dev(pdev) {
-                for (i = 0; i < e820.nr_map; i++) {
-                        struct e820entry *ei = &e820.map[i];
-
-                        if (ei->type == E820_RAM) {
-                                ret = iommu_prepare_identity_map(pdev,
-                                        ei->addr, ei->addr + ei->size);
-                                if (ret)  {
-                                        printk(KERN_INFO "1:1 mapping to one domain failed.\n");
-                                        return -EFAULT;
-                                }
-                        }
+                if (iommu_should_identity_map(pdev, 1)) {
+                        printk(KERN_INFO "IOMMU: identity mapping for device %s\n",
+                               pci_name(pdev));
+
+                        ret = domain_context_mapping(si_domain, pdev,
+                                                     CONTEXT_TT_MULTI_LEVEL);
+                        if (ret)
+                                return ret;
+                        ret = domain_add_dev_info(si_domain, pdev);
+                        if (ret)
+                                return ret;
                 }
-                ret = domain_add_dev_info(si_domain, pdev);
-                if (ret)
-                        return ret;
         }
 
         return 0;
@@ -2260,6 +2334,10 @@ int __init init_dmars(void)
          * identity mapping if iommu_identity_mapping is set.
          */
         if (!iommu_pass_through) {
+#ifdef CONFIG_DMAR_BROKEN_GFX_WA
+                if (!iommu_identity_mapping)
+                        iommu_identity_mapping = 2;
+#endif
                 if (iommu_identity_mapping)
                         iommu_prepare_static_identity_mapping();
                 /*
@@ -2293,8 +2371,6 @@ int __init init_dmars(void)
                         }
                 }
 
-                iommu_prepare_gfx_mapping();
-
                 iommu_prepare_isa();
         }
 
@@ -2339,50 +2415,40 @@ error:
         return ret;
 }
 
-static inline u64 aligned_size(u64 host_addr, size_t size)
+/* Returns a number of VTD pages, but aligned to MM page size */
+static inline unsigned long aligned_nrpages(unsigned long host_addr,
+                                            size_t size)
 {
-        u64 addr;
-        addr = (host_addr & (~PAGE_MASK)) + size;
-        return PAGE_ALIGN(addr);
-}
-
-struct iova *
-iommu_alloc_iova(struct dmar_domain *domain, size_t size, u64 end)
-{
-        struct iova *piova;
-
-        /* Make sure it's in range */
-        end = min_t(u64, DOMAIN_MAX_ADDR(domain->gaw), end);
-        if (!size || (IOVA_START_ADDR + size > end))
-                return NULL;
-
-        piova = alloc_iova(&domain->iovad,
-                        size >> PAGE_SHIFT, IOVA_PFN(end), 1);
-        return piova;
+        host_addr &= ~PAGE_MASK;
+        return PAGE_ALIGN(host_addr + size) >> VTD_PAGE_SHIFT;
 }
 
-static struct iova *
-__intel_alloc_iova(struct device *dev, struct dmar_domain *domain,
-                   size_t size, u64 dma_mask)
+/* This takes a number of _MM_ pages, not VTD pages */
+static struct iova *intel_alloc_iova(struct device *dev,
+                                     struct dmar_domain *domain,
+                                     unsigned long nrpages, uint64_t dma_mask)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         struct iova *iova = NULL;
 
-        if (dma_mask <= DMA_BIT_MASK(32) || dmar_forcedac)
-                iova = iommu_alloc_iova(domain, size, dma_mask);
-        else {
+        /* Restrict dma_mask to the width that the iommu can handle */
+        dma_mask = min_t(uint64_t, DOMAIN_MAX_ADDR(domain->gaw), dma_mask);
+
+        if (!dmar_forcedac && dma_mask > DMA_BIT_MASK(32)) {
                 /*
                  * First try to allocate an io virtual address in
                  * DMA_BIT_MASK(32) and if that fails then try allocating
                  * from higher range
                  */
-                iova = iommu_alloc_iova(domain, size, DMA_BIT_MASK(32));
-                if (!iova)
-                        iova = iommu_alloc_iova(domain, size, dma_mask);
-        }
-
-        if (!iova) {
-                printk(KERN_ERR"Allocating iova for %s failed", pci_name(pdev));
+                iova = alloc_iova(&domain->iovad, nrpages,
+                                  IOVA_PFN(DMA_BIT_MASK(32)), 1);
+                if (iova)
+                        return iova;
+        }
+        iova = alloc_iova(&domain->iovad, nrpages, IOVA_PFN(dma_mask), 1);
+        if (unlikely(!iova)) {
+                printk(KERN_ERR "Allocating %ld-page iova for %s failed",
+                       nrpages, pci_name(pdev));
                 return NULL;
         }
 
@@ -2424,16 +2490,24 @@ static int iommu_dummy(struct pci_dev *pdev)
 }
 
 /* Check if the pdev needs to go through non-identity map and unmap process.*/
-static int iommu_no_mapping(struct pci_dev *pdev)
+static int iommu_no_mapping(struct device *dev)
 {
+        struct pci_dev *pdev;
         int found;
 
+        if (unlikely(dev->bus != &pci_bus_type))
+                return 1;
+
+        pdev = to_pci_dev(dev);
+        if (iommu_dummy(pdev))
+                return 1;
+
         if (!iommu_identity_mapping)
-                return iommu_dummy(pdev);
+                return 0;
 
         found = identity_mapping(pdev);
         if (found) {
-                if (pdev->dma_mask > DMA_BIT_MASK(32))
+                if (iommu_should_identity_map(pdev, 0))
                         return 1;
                 else {
                         /*
@@ -2450,9 +2524,12 @@ static int iommu_no_mapping(struct pci_dev *pdev)
                  * In case of a detached 64 bit DMA device from vm, the device
                  * is put into si_domain for identity mapping.
                  */
-                if (pdev->dma_mask > DMA_BIT_MASK(32)) {
+                if (iommu_should_identity_map(pdev, 0)) {
                         int ret;
                         ret = domain_add_dev_info(si_domain, pdev);
+                        if (ret)
+                                return 0;
+                        ret = domain_context_mapping(si_domain, pdev, CONTEXT_TT_MULTI_LEVEL);
                         if (!ret) {
                                 printk(KERN_INFO "64bit %s uses identity mapping\n",
                                        pci_name(pdev));
@@ -2461,7 +2538,7 @@ static int iommu_no_mapping(struct pci_dev *pdev)
                 }
         }
 
-        return iommu_dummy(pdev);
+        return 0;
 }
 
 static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
@@ -2477,7 +2554,7 @@ static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
 
         BUG_ON(dir == DMA_NONE);
 
-        if (iommu_no_mapping(pdev))
+        if (iommu_no_mapping(hwdev))
                 return paddr;
 
         domain = get_valid_domain_for_dev(pdev);
@@ -2485,14 +2562,13 @@ static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
                 return 0;
 
         iommu = domain_get_iommu(domain);
-        size = aligned_size((u64)paddr, size);
+        size = aligned_nrpages(paddr, size);
 
-        iova = __intel_alloc_iova(hwdev, domain, size, pdev->dma_mask);
+        iova = intel_alloc_iova(hwdev, domain, dma_to_mm_pfn(size),
+                                pdev->dma_mask);
         if (!iova)
                 goto error;
 
-        start_paddr = (phys_addr_t)iova->pfn_lo << PAGE_SHIFT;
-
         /*
          * Check if DMAR supports zero-length reads on write only
          * mappings..
@@ -2508,20 +2584,20 @@ static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
          * might have two guest_addr mapping to the same host paddr, but this
          * is not a big problem
          */
-        ret = domain_page_mapping(domain, start_paddr,
-                                  ((u64)paddr) & PHYSICAL_PAGE_MASK,
-                                  size, prot);
+        ret = domain_pfn_mapping(domain, mm_to_dma_pfn(iova->pfn_lo),
+                                 paddr >> VTD_PAGE_SHIFT, size, prot);
         if (ret)
                 goto error;
 
         /* it's a non-present to present mapping. Only flush if caching mode */
         if (cap_caching_mode(iommu->cap))
-                iommu_flush_iotlb_psi(iommu, 0, start_paddr,
-                                      size >> VTD_PAGE_SHIFT);
+                iommu_flush_iotlb_psi(iommu, 0, mm_to_dma_pfn(iova->pfn_lo), size);
         else
                 iommu_flush_write_buffer(iommu);
 
-        return start_paddr + ((u64)paddr & (~PAGE_MASK));
+        start_paddr = (phys_addr_t)iova->pfn_lo << PAGE_SHIFT;
+        start_paddr += paddr & ~PAGE_MASK;
+        return start_paddr;
 
 error:
         if (iova)
@@ -2614,11 +2690,11 @@ static void intel_unmap_page(struct device *dev, dma_addr_t dev_addr,
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         struct dmar_domain *domain;
-        unsigned long start_addr;
+        unsigned long start_pfn, last_pfn;
         struct iova *iova;
         struct intel_iommu *iommu;
 
-        if (iommu_no_mapping(pdev))
+        if (iommu_no_mapping(dev))
                 return;
 
         domain = find_domain(pdev);
@@ -2627,22 +2703,25 @@ static void intel_unmap_page(struct device *dev, dma_addr_t dev_addr,
         iommu = domain_get_iommu(domain);
 
         iova = find_iova(&domain->iovad, IOVA_PFN(dev_addr));
-        if (!iova)
+        if (WARN_ONCE(!iova, "Driver unmaps unmatched page at PFN %llx\n",
+                      (unsigned long long)dev_addr))
                 return;
 
-        start_addr = iova->pfn_lo << PAGE_SHIFT;
-        size = aligned_size((u64)dev_addr, size);
+        start_pfn = mm_to_dma_pfn(iova->pfn_lo);
+        last_pfn = mm_to_dma_pfn(iova->pfn_hi + 1) - 1;
 
-        pr_debug("Device %s unmapping: %zx@%llx\n",
-                pci_name(pdev), size, (unsigned long long)start_addr);
+        pr_debug("Device %s unmapping: pfn %lx-%lx\n",
+                 pci_name(pdev), start_pfn, last_pfn);
 
         /*  clear the whole page */
-        dma_pte_clear_range(domain, start_addr, start_addr + size);
+        dma_pte_clear_range(domain, start_pfn, last_pfn);
+
         /* free page tables */
-        dma_pte_free_pagetable(domain, start_addr, start_addr + size);
+        dma_pte_free_pagetable(domain, start_pfn, last_pfn);
+
         if (intel_iommu_strict) {
-                iommu_flush_iotlb_psi(iommu, domain->id, start_addr,
-                                      size >> VTD_PAGE_SHIFT);
+                iommu_flush_iotlb_psi(iommu, domain->id, start_pfn,
+                                      last_pfn - start_pfn + 1);
                 /* free iova */
                 __free_iova(&domain->iovad, iova);
         } else {
@@ -2700,17 +2779,13 @@ static void intel_unmap_sg(struct device *hwdev, struct scatterlist *sglist,
                            int nelems, enum dma_data_direction dir,
                            struct dma_attrs *attrs)
 {
-        int i;
         struct pci_dev *pdev = to_pci_dev(hwdev);
         struct dmar_domain *domain;
-        unsigned long start_addr;
+        unsigned long start_pfn, last_pfn;
         struct iova *iova;
-        size_t size = 0;
-        phys_addr_t addr;
-        struct scatterlist *sg;
         struct intel_iommu *iommu;
 
-        if (iommu_no_mapping(pdev))
+        if (iommu_no_mapping(hwdev))
                 return;
 
         domain = find_domain(pdev);
@@ -2719,22 +2794,21 @@ static void intel_unmap_sg(struct device *hwdev, struct scatterlist *sglist,
         iommu = domain_get_iommu(domain);
 
         iova = find_iova(&domain->iovad, IOVA_PFN(sglist[0].dma_address));
-        if (!iova)
+        if (WARN_ONCE(!iova, "Driver unmaps unmatched sglist at PFN %llx\n",
+                      (unsigned long long)sglist[0].dma_address))
                 return;
-        for_each_sg(sglist, sg, nelems, i) {
-                addr = page_to_phys(sg_page(sg)) + sg->offset;
-                size += aligned_size((u64)addr, sg->length);
-        }
 
-        start_addr = iova->pfn_lo << PAGE_SHIFT;
+        start_pfn = mm_to_dma_pfn(iova->pfn_lo);
+        last_pfn = mm_to_dma_pfn(iova->pfn_hi + 1) - 1;
 
         /*  clear the whole page */
-        dma_pte_clear_range(domain, start_addr, start_addr + size);
+        dma_pte_clear_range(domain, start_pfn, last_pfn);
+
         /* free page tables */
-        dma_pte_free_pagetable(domain, start_addr, start_addr + size);
+        dma_pte_free_pagetable(domain, start_pfn, last_pfn);
 
-        iommu_flush_iotlb_psi(iommu, domain->id, start_addr,
-                              size >> VTD_PAGE_SHIFT);
+        iommu_flush_iotlb_psi(iommu, domain->id, start_pfn,
+                              (last_pfn - start_pfn + 1));
 
         /* free iova */
         __free_iova(&domain->iovad, iova);
@@ -2757,21 +2831,20 @@ static int intel_nontranslate_map_sg(struct device *hddev,
 static int intel_map_sg(struct device *hwdev, struct scatterlist *sglist, int nelems,
                         enum dma_data_direction dir, struct dma_attrs *attrs)
 {
-        phys_addr_t addr;
         int i;
         struct pci_dev *pdev = to_pci_dev(hwdev);
         struct dmar_domain *domain;
         size_t size = 0;
         int prot = 0;
-        size_t offset = 0;
+        size_t offset_pfn = 0;
         struct iova *iova = NULL;
         int ret;
         struct scatterlist *sg;
-        unsigned long start_addr;
+        unsigned long start_vpfn;
         struct intel_iommu *iommu;
 
         BUG_ON(dir == DMA_NONE);
-        if (iommu_no_mapping(pdev))
+        if (iommu_no_mapping(hwdev))
                 return intel_nontranslate_map_sg(hwdev, sglist, nelems, dir);
 
         domain = get_valid_domain_for_dev(pdev);
@@ -2780,12 +2853,11 @@ static int intel_map_sg(struct device *hwdev, struct scatterlist *sglist, int ne
 
         iommu = domain_get_iommu(domain);
 
-        for_each_sg(sglist, sg, nelems, i) {
-                addr = page_to_phys(sg_page(sg)) + sg->offset;
-                size += aligned_size((u64)addr, sg->length);
-        }
+        for_each_sg(sglist, sg, nelems, i)
+                size += aligned_nrpages(sg->offset, sg->length);
 
-        iova = __intel_alloc_iova(hwdev, domain, size, pdev->dma_mask);
+        iova = intel_alloc_iova(hwdev, domain, dma_to_mm_pfn(size),
+                                pdev->dma_mask);
         if (!iova) {
                 sglist->dma_length = 0;
                 return 0;
@@ -2801,35 +2873,24 @@ static int intel_map_sg(struct device *hwdev, struct scatterlist *sglist, int ne
         if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
                 prot |= DMA_PTE_WRITE;
 
-        start_addr = iova->pfn_lo << PAGE_SHIFT;
-        offset = 0;
-        for_each_sg(sglist, sg, nelems, i) {
-                addr = page_to_phys(sg_page(sg)) + sg->offset;
-                size = aligned_size((u64)addr, sg->length);
-                ret = domain_page_mapping(domain, start_addr + offset,
-                                          ((u64)addr) & PHYSICAL_PAGE_MASK,
-                                          size, prot);
-                if (ret) {
-                        /*  clear the page */
-                        dma_pte_clear_range(domain, start_addr,
-                                  start_addr + offset);
-                        /* free page tables */
-                        dma_pte_free_pagetable(domain, start_addr,
-                                  start_addr + offset);
-                        /* free iova */
-                        __free_iova(&domain->iovad, iova);
-                        return 0;
-                }
-                sg->dma_address = start_addr + offset +
-                                ((u64)addr & (~PAGE_MASK));
-                sg->dma_length = sg->length;
-                offset += size;
+        start_vpfn = mm_to_dma_pfn(iova->pfn_lo);
+
+        ret = domain_sg_mapping(domain, start_vpfn, sglist, mm_to_dma_pfn(size), prot);
+        if (unlikely(ret)) {
+                /*  clear the page */
+                dma_pte_clear_range(domain, start_vpfn,
+                                    start_vpfn + size - 1);
+                /* free page tables */
+                dma_pte_free_pagetable(domain, start_vpfn,
+                                       start_vpfn + size - 1);
+                /* free iova */
+                __free_iova(&domain->iovad, iova);
+                return 0;
         }
 
         /* it's a non-present to present mapping. Only flush if caching mode */
         if (cap_caching_mode(iommu->cap))
-                iommu_flush_iotlb_psi(iommu, 0, start_addr,
-                                      offset >> VTD_PAGE_SHIFT);
+                iommu_flush_iotlb_psi(iommu, 0, start_vpfn, offset_pfn);
         else
                 iommu_flush_write_buffer(iommu);
 
@@ -3334,7 +3395,6 @@ static int md_domain_init(struct dmar_domain *domain, int guest_width)
         int adjust_width;
 
         init_iova_domain(&domain->iovad, DMA_32BIT_PFN);
-        spin_lock_init(&domain->mapping_lock);
         spin_lock_init(&domain->iommu_lock);
 
         domain_reserve_special_ranges(domain);
@@ -3388,8 +3448,6 @@ static void iommu_free_vm_domain(struct dmar_domain *domain)
 
 static void vm_domain_exit(struct dmar_domain *domain)
 {
-        u64 end;
-
         /* Domain 0 is reserved, so dont process it */
         if (!domain)
                 return;
@@ -3397,14 +3455,12 @@ static void vm_domain_exit(struct dmar_domain *domain)
         vm_domain_remove_all_dev_info(domain);
         /* destroy iovas */
         put_iova_domain(&domain->iovad);
-        end = DOMAIN_MAX_ADDR(domain->gaw);
-        end = end & (~VTD_PAGE_MASK);
 
         /* clear ptes */
-        dma_pte_clear_range(domain, 0, end);
+        dma_pte_clear_range(domain, 0, DOMAIN_MAX_PFN(domain->gaw));
 
         /* free page tables */
-        dma_pte_free_pagetable(domain, 0, end);
+        dma_pte_free_pagetable(domain, 0, DOMAIN_MAX_PFN(domain->gaw));
 
         iommu_free_vm_domain(domain);
         free_domain_mem(domain);
@@ -3513,7 +3569,7 @@ static int intel_iommu_map_range(struct iommu_domain *domain,
         if ((iommu_prot & IOMMU_CACHE) && dmar_domain->iommu_snooping)
                 prot |= DMA_PTE_SNP;
 
-        max_addr = (iova & VTD_PAGE_MASK) + VTD_PAGE_ALIGN(size);
+        max_addr = iova + size;
         if (dmar_domain->max_addr < max_addr) {
                 int min_agaw;
                 u64 end;
@@ -3531,8 +3587,11 @@ static int intel_iommu_map_range(struct iommu_domain *domain,
                 }
                 dmar_domain->max_addr = max_addr;
         }
-
-        ret = domain_page_mapping(dmar_domain, iova, hpa, size, prot);
+        /* Round up size to next multiple of PAGE_SIZE, if it and
+           the low bits of hpa would take us onto the next page */
+        size = aligned_nrpages(hpa, size);
+        ret = domain_pfn_mapping(dmar_domain, iova >> VTD_PAGE_SHIFT,
+                                 hpa >> VTD_PAGE_SHIFT, size, prot);
         return ret;
 }
 
@@ -3540,15 +3599,15 @@ static void intel_iommu_unmap_range(struct iommu_domain *domain,
                                     unsigned long iova, size_t size)
 {
         struct dmar_domain *dmar_domain = domain->priv;
-        dma_addr_t base;
 
-        /* The address might not be aligned */
-        base = iova & VTD_PAGE_MASK;
-        size = VTD_PAGE_ALIGN(size);
-        dma_pte_clear_range(dmar_domain, base, base + size);
+        if (!size)
+                return;
+
+        dma_pte_clear_range(dmar_domain, iova >> VTD_PAGE_SHIFT,
+                            (iova + size - 1) >> VTD_PAGE_SHIFT);
 
-        if (dmar_domain->max_addr == base + size)
-                dmar_domain->max_addr = base;
+        if (dmar_domain->max_addr == iova + size)
+                dmar_domain->max_addr = iova;
 }
 
 static phys_addr_t intel_iommu_iova_to_phys(struct iommu_domain *domain,
@@ -3558,7 +3617,7 @@ static phys_addr_t intel_iommu_iova_to_phys(struct iommu_domain *domain,
         struct dma_pte *pte;
         u64 phys = 0;
 
-        pte = addr_to_dma_pte(dmar_domain, iova);
+        pte = pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT);
         if (pte)
                 phys = dma_pte_addr(pte);
 
diff --git a/drivers/pci/iova.c b/drivers/pci/iova.c
index 2287116e9822..46dd440e2315 100644
--- a/drivers/pci/iova.c
+++ b/drivers/pci/iova.c
@@ -1,9 +1,19 @@
 /*
- * Copyright (c) 2006, Intel Corporation.
+ * Copyright © 2006-2009, Intel Corporation.
  *
- * This file is released under the GPLv2.
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
  *
- * Copyright (C) 2006-2008 Intel Corporation
  * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
  */
 
@@ -123,7 +133,15 @@ move_left:
         /* Insert the new_iova into domain rbtree by holding writer lock */
         /* Add new node and rebalance tree. */
         {
-                struct rb_node **entry = &((prev)), *parent = NULL;
+                struct rb_node **entry, *parent = NULL;
+
+                /* If we have 'prev', it's a valid place to start the
+                   insertion. Otherwise, start from the root. */
+                if (prev)
+                        entry = &prev;
+                else
+                        entry = &iovad->rbroot.rb_node;
+
                 /* Figure out where to put new node */
                 while (*entry) {
                         struct iova *this = container_of(*entry,
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index d9f06fbfa0bf..d986afb7032b 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -127,17 +127,23 @@ static inline __attribute_const__ u32 msi_enabled_mask(u16 control)
  * reliably as devices without an INTx disable bit will then generate a
  * level IRQ which will never be cleared.
  */
-static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
+static u32 __msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
 {
         u32 mask_bits = desc->masked;
 
         if (!desc->msi_attrib.maskbit)
-                return;
+                return 0;
 
         mask_bits &= ~mask;
         mask_bits |= flag;
         pci_write_config_dword(desc->dev, desc->mask_pos, mask_bits);
-        desc->masked = mask_bits;
+
+        return mask_bits;
+}
+
+static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
+{
+        desc->masked = __msi_mask_irq(desc, mask, flag);
 }
 
 /*
@@ -147,15 +153,21 @@ static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
  * file.  This saves a few milliseconds when initialising devices with lots
  * of MSI-X interrupts.
  */
-static void msix_mask_irq(struct msi_desc *desc, u32 flag)
+static u32 __msix_mask_irq(struct msi_desc *desc, u32 flag)
 {
         u32 mask_bits = desc->masked;
         unsigned offset = desc->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
-                                        PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET;
+                                                PCI_MSIX_ENTRY_VECTOR_CTRL;
         mask_bits &= ~1;
         mask_bits |= flag;
         writel(mask_bits, desc->mask_base + offset);
-        desc->masked = mask_bits;
+
+        return mask_bits;
+}
+
+static void msix_mask_irq(struct msi_desc *desc, u32 flag)
+{
+        desc->masked = __msix_mask_irq(desc, flag);
 }
 
 static void msi_set_mask_bit(unsigned irq, u32 flag)
@@ -188,9 +200,9 @@ void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
                 void __iomem *base = entry->mask_base +
                         entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
 
-                msg->address_lo = readl(base + PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                msg->address_hi = readl(base + PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                msg->data = readl(base + PCI_MSIX_ENTRY_DATA_OFFSET);
+                msg->address_lo = readl(base + PCI_MSIX_ENTRY_LOWER_ADDR);
+                msg->address_hi = readl(base + PCI_MSIX_ENTRY_UPPER_ADDR);
+                msg->data = readl(base + PCI_MSIX_ENTRY_DATA);
         } else {
                 struct pci_dev *dev = entry->dev;
                 int pos = entry->msi_attrib.pos;
@@ -225,11 +237,9 @@ void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
                 base = entry->mask_base +
                         entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
 
-                writel(msg->address_lo,
-                        base + PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                writel(msg->address_hi,
-                        base + PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                writel(msg->data, base + PCI_MSIX_ENTRY_DATA_OFFSET);
+                writel(msg->address_lo, base + PCI_MSIX_ENTRY_LOWER_ADDR);
+                writel(msg->address_hi, base + PCI_MSIX_ENTRY_UPPER_ADDR);
+                writel(msg->data, base + PCI_MSIX_ENTRY_DATA);
         } else {
                 struct pci_dev *dev = entry->dev;
                 int pos = entry->msi_attrib.pos;
@@ -385,6 +395,7 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
         /* Configure MSI capability structure */
         ret = arch_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSI);
         if (ret) {
+                msi_mask_irq(entry, mask, ~mask);
                 msi_free_irqs(dev);
                 return ret;
         }
@@ -439,8 +450,14 @@ static int msix_capability_init(struct pci_dev *dev,
 
         for (i = 0; i < nvec; i++) {
                 entry = alloc_msi_entry(dev);
-                if (!entry)
-                        break;
+                if (!entry) {
+                        if (!i)
+                                iounmap(base);
+                        else
+                                msi_free_irqs(dev);
+                        /* No enough memory. Don't try again */
+                        return -ENOMEM;
+                }
 
                 j = entries[i].entry;
                 entry->msi_attrib.is_msix = 1;
@@ -487,7 +504,7 @@ static int msix_capability_init(struct pci_dev *dev,
                 set_irq_msi(entry->irq, entry);
                 j = entries[i].entry;
                 entry->masked = readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                                        PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
+                                                PCI_MSIX_ENTRY_VECTOR_CTRL);
                 msix_mask_irq(entry, 1);
                 i++;
         }
@@ -611,9 +628,11 @@ void pci_msi_shutdown(struct pci_dev *dev)
         pci_intx_for_msi(dev, 1);
         dev->msi_enabled = 0;
 
+        /* Return the device with MSI unmasked as initial states */
         pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &ctrl);
         mask = msi_capable_mask(ctrl);
-        msi_mask_irq(desc, mask, ~mask);
+        /* Keep cached state to be restored */
+        __msi_mask_irq(desc, mask, ~mask);
 
         /* Restore dev->irq to its default pin-assertion irq */
         dev->irq = desc->msi_attrib.default_irq;
@@ -653,7 +672,6 @@ static int msi_free_irqs(struct pci_dev* dev)
 
         list_for_each_entry_safe(entry, tmp, &dev->msi_list, list) {
                 if (entry->msi_attrib.is_msix) {
-                        msix_mask_irq(entry, 1);
                         if (list_is_last(&entry->list, &dev->msi_list))
                                 iounmap(entry->mask_base);
                 }
@@ -741,9 +759,17 @@ static void msix_free_all_irqs(struct pci_dev *dev)
 
 void pci_msix_shutdown(struct pci_dev* dev)
 {
+        struct msi_desc *entry;
+
         if (!pci_msi_enable || !dev || !dev->msix_enabled)
                 return;
 
+        /* Return the device with MSI-X masked as initial states */
+        list_for_each_entry(entry, &dev->msi_list, list) {
+                /* Keep cached states to be restored */
+                __msix_mask_irq(entry, 1);
+        }
+
         msix_set_enable(dev, 0);
         pci_intx_for_msi(dev, 1);
         dev->msix_enabled = 0;
diff --git a/drivers/pci/msi.h b/drivers/pci/msi.h
index a0662842550b..de27c1cb5a2b 100644
--- a/drivers/pci/msi.h
+++ b/drivers/pci/msi.h
@@ -6,11 +6,11 @@
 #ifndef MSI_H
 #define MSI_H
 
-#define PCI_MSIX_ENTRY_SIZE                     16
-#define  PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET       0
-#define  PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET       4
-#define  PCI_MSIX_ENTRY_DATA_OFFSET             8
-#define  PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET      12
+#define PCI_MSIX_ENTRY_SIZE             16
+#define  PCI_MSIX_ENTRY_LOWER_ADDR      0
+#define  PCI_MSIX_ENTRY_UPPER_ADDR      4
+#define  PCI_MSIX_ENTRY_DATA            8
+#define  PCI_MSIX_ENTRY_VECTOR_CTRL     12
 
 #define msi_control_reg(base)           (base + PCI_MSI_FLAGS)
 #define msi_lower_address_reg(base)     (base + PCI_MSI_ADDRESS_LO)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 6c93af5ced18..dbd0f947f497 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1517,11 +1517,20 @@ void pci_enable_ari(struct pci_dev *dev)
  *
  * Perform INTx swizzling for a device behind one level of bridge.  This is
  * required by section 9.1 of the PCI-to-PCI bridge specification for devices
- * behind bridges on add-in cards.
+ * behind bridges on add-in cards.  For devices with ARI enabled, the slot
+ * number is always 0 (see the Implementation Note in section 2.2.8.1 of
+ * the PCI Express Base Specification, Revision 2.1)
  */
 u8 pci_swizzle_interrupt_pin(struct pci_dev *dev, u8 pin)
 {
-        return (((pin - 1) + PCI_SLOT(dev->devfn)) % 4) + 1;
+        int slot;
+
+        if (pci_ari_enabled(dev->bus))
+                slot = 0;
+        else
+                slot = PCI_SLOT(dev->devfn);
+
+        return (((pin - 1) + slot) % 4) + 1;
 }
 
 int
@@ -2171,7 +2180,7 @@ static int pci_parent_bus_reset(struct pci_dev *dev, int probe)
         u16 ctrl;
         struct pci_dev *pdev;
 
-        if (dev->subordinate)
+        if (pci_is_root_bus(dev->bus) || dev->subordinate || !dev->bus->self)
                 return -ENOTTY;
 
         list_for_each_entry(pdev, &dev->bus->devices, bus_list)
diff --git a/drivers/pci/pcie/aer/ecrc.c b/drivers/pci/pcie/aer/ecrc.c
index ece97df4df6d..a928d8ab6bda 100644
--- a/drivers/pci/pcie/aer/ecrc.c
+++ b/drivers/pci/pcie/aer/ecrc.c
@@ -106,7 +106,7 @@ void pcie_set_ecrc_checking(struct pci_dev *dev)
                 disable_ecrc_checking(dev);
                 break;
         case ECRC_POLICY_ON:
-                enable_ecrc_checking(dev);;
+                enable_ecrc_checking(dev);
                 break;
         default:
                 return;
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 56552d74abea..06b965623962 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -1058,6 +1058,11 @@ static void __devinit quirk_no_ata_d3(struct pci_dev *pdev)
 }
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_SERVERWORKS, PCI_ANY_ID, quirk_no_ata_d3);
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_ATI, PCI_ANY_ID, quirk_no_ata_d3);
+/* ALi loses some register settings that we cannot then restore */
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_AL, PCI_ANY_ID, quirk_no_ata_d3);
+/* VIA comes back fine but we need to keep it alive or ACPI GTM failures
+   occur when mode detecting */
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_VIA, PCI_ANY_ID, quirk_no_ata_d3);
 
 /* This was originally an Alpha specific thing, but it really fits here.
  * The i82375 PCI/EISA bridge appears as non-classified. Fix that.
diff --git a/drivers/pci/slot.c b/drivers/pci/slot.c
index eddb0748b0ea..8c02b6c53bdb 100644
--- a/drivers/pci/slot.c
+++ b/drivers/pci/slot.c
@@ -311,7 +311,7 @@ EXPORT_SYMBOL_GPL(pci_destroy_slot);
 #include <linux/pci_hotplug.h>
 /**
  * pci_hp_create_link - create symbolic link to the hotplug driver module.
- * @slot: struct pci_slot
+ * @pci_slot: struct pci_slot
  *
  * Helper function for pci_hotplug_core.c to create symbolic link to
  * the hotplug driver module.
@@ -334,7 +334,7 @@ EXPORT_SYMBOL_GPL(pci_hp_create_module_link);
 
 /**
  * pci_hp_remove_link - remove symbolic link to the hotplug driver module.
- * @slot: struct pci_slot
+ * @pci_slot: struct pci_slot
  *
  * Helper function for pci_hotplug_core.c to remove symbolic link to
  * the hotplug driver module.
diff --git a/drivers/pcmcia/tcic.c b/drivers/pcmcia/tcic.c
index 9ad97ea836e8..8eb04230fec7 100644
--- a/drivers/pcmcia/tcic.c
+++ b/drivers/pcmcia/tcic.c
@@ -472,7 +472,8 @@ static int __init init_tcic(void)
     init_timer(&poll_timer);
 
     /* Build interrupt mask */
-    printk(", %d sockets\n" KERN_INFO "  irq list (", sockets);
+    printk(KERN_CONT ", %d sockets\n", sockets);
+    printk(KERN_INFO "  irq list (");
     if (irq_list_count == 0)
         mask = irq_mask;
     else
diff --git a/drivers/pcmcia/vrc4171_card.c b/drivers/pcmcia/vrc4171_card.c
index 659421d0ca46..d4ad50d737b0 100644
--- a/drivers/pcmcia/vrc4171_card.c
+++ b/drivers/pcmcia/vrc4171_card.c
@@ -1,7 +1,7 @@
 /*
  * vrc4171_card.c, NEC VRC4171 Card Controller driver for Socket Services.
  *
- * Copyright (C) 2003-2005  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ * Copyright (C) 2003-2005  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
@@ -32,7 +32,7 @@
 #include "i82365.h"
 
 MODULE_DESCRIPTION("NEC VRC4171 Card Controllers driver for Socket Services");
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
 MODULE_LICENSE("GPL");
 
 #define CARD_MAX_SLOTS          2
diff --git a/drivers/pcmcia/vrc4173_cardu.c b/drivers/pcmcia/vrc4173_cardu.c
index 812f038e9bda..9b3c15827e5c 100644
--- a/drivers/pcmcia/vrc4173_cardu.c
+++ b/drivers/pcmcia/vrc4173_cardu.c
@@ -6,7 +6,7 @@
  *      NEC VRC4173 CARDU driver for Socket Services
  *      (This device doesn't support CardBus. it is supporting only 16bit PC Card.)
  *
- * Copyright 2002,2003 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ * Copyright 2002,2003 Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
@@ -41,7 +41,7 @@
 #include "vrc4173_cardu.h"
 
 MODULE_DESCRIPTION("NEC VRC4173 CARDU driver for Socket Services");
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
 MODULE_LICENSE("GPL");
 
 static int vrc4173_cardu_slots;
diff --git a/drivers/pcmcia/vrc4173_cardu.h b/drivers/pcmcia/vrc4173_cardu.h
index 7d77c74120c1..a7d96018ed8d 100644
--- a/drivers/pcmcia/vrc4173_cardu.h
+++ b/drivers/pcmcia/vrc4173_cardu.h
@@ -5,7 +5,7 @@
  * BRIEF MODULE DESCRIPTION
  *      Include file for NEC VRC4173 CARDU.
  *
- * Copyright 2002 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ * Copyright 2002 Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 7232fe7104aa..46dad12f952f 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -355,6 +355,7 @@ config EEEPC_LAPTOP
         depends on INPUT
         depends on EXPERIMENTAL
         depends on RFKILL || RFKILL = n
+        depends on HOTPLUG_PCI
         select BACKLIGHT_CLASS_DEVICE
         select HWMON
         ---help---
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 4207b26ff990..ec560f16d720 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -16,6 +16,8 @@
  *  GNU General Public License for more details.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -31,6 +33,7 @@
 #include <linux/input.h>
 #include <linux/rfkill.h>
 #include <linux/pci.h>
+#include <linux/pci_hotplug.h>
 
 #define EEEPC_LAPTOP_VERSION    "0.1"
 
@@ -40,11 +43,6 @@
 #define EEEPC_HOTK_DEVICE_NAME  "Hotkey"
 #define EEEPC_HOTK_HID          "ASUS010"
 
-#define EEEPC_LOG       EEEPC_HOTK_FILE ": "
-#define EEEPC_ERR       KERN_ERR        EEEPC_LOG
-#define EEEPC_WARNING   KERN_WARNING    EEEPC_LOG
-#define EEEPC_NOTICE    KERN_NOTICE     EEEPC_LOG
-#define EEEPC_INFO      KERN_INFO       EEEPC_LOG
 
 /*
  * Definitions for Asus EeePC
@@ -141,8 +139,10 @@ struct eeepc_hotk {
         u16 event_count[128];           /* count for each event */
         struct input_dev *inputdev;
         u16 *keycode_map;
-        struct rfkill *eeepc_wlan_rfkill;
-        struct rfkill *eeepc_bluetooth_rfkill;
+        struct rfkill *wlan_rfkill;
+        struct rfkill *bluetooth_rfkill;
+        struct rfkill *wwan3g_rfkill;
+        struct hotplug_slot *hotplug_slot;
 };
 
 /* The actual device the driver binds to */
@@ -213,6 +213,15 @@ static struct acpi_driver eeepc_hotk_driver = {
         },
 };
 
+/* PCI hotplug ops */
+static int eeepc_get_adapter_status(struct hotplug_slot *slot, u8 *value);
+
+static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
+        .owner = THIS_MODULE,
+        .get_adapter_status = eeepc_get_adapter_status,
+        .get_power_status = eeepc_get_adapter_status,
+};
+
 /* The backlight device /sys/class/backlight */
 static struct backlight_device *eeepc_backlight_device;
 
@@ -274,20 +283,20 @@ static int set_acpi(int cm, int value)
                 if (method == NULL)
                         return -ENODEV;
                 if (write_acpi_int(ehotk->handle, method, value, NULL))
-                        printk(EEEPC_WARNING "Error writing %s\n", method);
+                        pr_warning("Error writing %s\n", method);
         }
         return 0;
 }
 
 static int get_acpi(int cm)
 {
-        int value = -1;
+        int value = -ENODEV;
         if ((ehotk->cm_supported & (0x1 << cm))) {
                 const char *method = cm_getv[cm];
                 if (method == NULL)
                         return -ENODEV;
                 if (read_acpi_int(ehotk->handle, method, &value))
-                        printk(EEEPC_WARNING "Error reading %s\n", method);
+                        pr_warning("Error reading %s\n", method);
         }
         return value;
 }
@@ -359,13 +368,19 @@ static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
 
         rv = parse_arg(buf, count, &value);
         if (rv > 0)
-                set_acpi(cm, value);
+                value = set_acpi(cm, value);
+        if (value < 0)
+                return value;
         return rv;
 }
 
 static ssize_t show_sys_acpi(int cm, char *buf)
 {
-        return sprintf(buf, "%d\n", get_acpi(cm));
+        int value = get_acpi(cm);
+
+        if (value < 0)
+                return value;
+        return sprintf(buf, "%d\n", value);
 }
 
 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm)                            \
@@ -539,6 +554,28 @@ static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
         return -EINVAL;
 }
 
+static void cmsg_quirk(int cm, const char *name)
+{
+        int dummy;
+
+        /* Some BIOSes do not report cm although it is avaliable.
+           Check if cm_getv[cm] works and, if yes, assume cm should be set. */
+        if (!(ehotk->cm_supported & (1 << cm))
+            && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) {
+                pr_info("%s (%x) not reported by BIOS,"
+                        " enabling anyway\n", name, 1 << cm);
+                ehotk->cm_supported |= 1 << cm;
+        }
+}
+
+static void cmsg_quirks(void)
+{
+        cmsg_quirk(CM_ASL_LID, "LID");
+        cmsg_quirk(CM_ASL_TYPE, "TYPE");
+        cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER");
+        cmsg_quirk(CM_ASL_TPD, "TPD");
+}
+
 static int eeepc_hotk_check(void)
 {
         const struct key_entry *key;
@@ -551,26 +588,24 @@ static int eeepc_hotk_check(void)
         if (ehotk->device->status.present) {
                 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
                                     &buffer)) {
-                        printk(EEEPC_ERR "Hotkey initialization failed\n");
+                        pr_err("Hotkey initialization failed\n");
                         return -ENODEV;
                 } else {
-                        printk(EEEPC_NOTICE "Hotkey init flags 0x%x\n",
-                               ehotk->init_flag);
+                        pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag);
                 }
                 /* get control methods supported */
                 if (read_acpi_int(ehotk->handle, "CMSG"
                                    , &ehotk->cm_supported)) {
-                        printk(EEEPC_ERR
-                               "Get control methods supported failed\n");
+                        pr_err("Get control methods supported failed\n");
                         return -ENODEV;
                 } else {
-                        printk(EEEPC_INFO
-                               "Get control methods supported: 0x%x\n",
-                               ehotk->cm_supported);
+                        cmsg_quirks();
+                        pr_info("Get control methods supported: 0x%x\n",
+                                ehotk->cm_supported);
                 }
                 ehotk->inputdev = input_allocate_device();
                 if (!ehotk->inputdev) {
-                        printk(EEEPC_INFO "Unable to allocate input device\n");
+                        pr_info("Unable to allocate input device\n");
                         return 0;
                 }
                 ehotk->inputdev->name = "Asus EeePC extra buttons";
@@ -589,12 +624,12 @@ static int eeepc_hotk_check(void)
                 }
                 result = input_register_device(ehotk->inputdev);
                 if (result) {
-                        printk(EEEPC_INFO "Unable to register input device\n");
+                        pr_info("Unable to register input device\n");
                         input_free_device(ehotk->inputdev);
                         return 0;
                 }
         } else {
-                printk(EEEPC_ERR "Hotkey device not present, aborting\n");
+                pr_err("Hotkey device not present, aborting\n");
                 return -EINVAL;
         }
         return 0;
@@ -612,6 +647,19 @@ static int notify_brn(void)
         return -1;
 }
 
+static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
+                                    u8 *value)
+{
+        int val = get_acpi(CM_ASL_WLAN);
+
+        if (val == 1 || val == 0)
+                *value = val;
+        else
+                return -EINVAL;
+
+        return 0;
+}
+
 static void eeepc_rfkill_hotplug(void)
 {
         struct pci_dev *dev;
@@ -619,7 +667,7 @@ static void eeepc_rfkill_hotplug(void)
         bool blocked;
 
         if (!bus) {
-                printk(EEEPC_WARNING "Unable to find PCI bus 1?\n");
+                pr_warning("Unable to find PCI bus 1?\n");
                 return;
         }
 
@@ -635,7 +683,7 @@ static void eeepc_rfkill_hotplug(void)
                 if (dev) {
                         pci_bus_assign_resources(bus);
                         if (pci_bus_add_device(dev))
-                                printk(EEEPC_ERR "Unable to hotplug wifi\n");
+                                pr_err("Unable to hotplug wifi\n");
                 }
         } else {
                 dev = pci_get_slot(bus, 0);
@@ -645,7 +693,7 @@ static void eeepc_rfkill_hotplug(void)
                 }
         }
 
-        rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill, blocked);
+        rfkill_set_sw_state(ehotk->wlan_rfkill, blocked);
 }
 
 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
@@ -718,8 +766,7 @@ static int eeepc_register_rfkill_notifier(char *node)
                                                      eeepc_rfkill_notify,
                                                      NULL);
                 if (ACPI_FAILURE(status))
-                        printk(EEEPC_WARNING
-                               "Failed to register notify on %s\n", node);
+                        pr_warning("Failed to register notify on %s\n", node);
         } else
                 return -ENODEV;
 
@@ -738,19 +785,66 @@ static void eeepc_unregister_rfkill_notifier(char *node)
                                                      ACPI_SYSTEM_NOTIFY,
                                                      eeepc_rfkill_notify);
                 if (ACPI_FAILURE(status))
-                        printk(EEEPC_ERR
-                               "Error removing rfkill notify handler %s\n",
+                        pr_err("Error removing rfkill notify handler %s\n",
                                 node);
         }
 }
 
+static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+{
+        kfree(hotplug_slot->info);
+        kfree(hotplug_slot);
+}
+
+static int eeepc_setup_pci_hotplug(void)
+{
+        int ret = -ENOMEM;
+        struct pci_bus *bus = pci_find_bus(0, 1);
+
+        if (!bus) {
+                pr_err("Unable to find wifi PCI bus\n");
+                return -ENODEV;
+        }
+
+        ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+        if (!ehotk->hotplug_slot)
+                goto error_slot;
+
+        ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+                                            GFP_KERNEL);
+        if (!ehotk->hotplug_slot->info)
+                goto error_info;
+
+        ehotk->hotplug_slot->private = ehotk;
+        ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
+        ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
+        eeepc_get_adapter_status(ehotk->hotplug_slot,
+                                 &ehotk->hotplug_slot->info->adapter_status);
+
+        ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi");
+        if (ret) {
+                pr_err("Unable to register hotplug slot - %d\n", ret);
+                goto error_register;
+        }
+
+        return 0;
+
+error_register:
+        kfree(ehotk->hotplug_slot->info);
+error_info:
+        kfree(ehotk->hotplug_slot);
+        ehotk->hotplug_slot = NULL;
+error_slot:
+        return ret;
+}
+
 static int eeepc_hotk_add(struct acpi_device *device)
 {
         int result;
 
         if (!device)
                  return -EINVAL;
-        printk(EEEPC_NOTICE EEEPC_HOTK_NAME "\n");
+        pr_notice(EEEPC_HOTK_NAME "\n");
         ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
         if (!ehotk)
                 return -ENOMEM;
@@ -764,53 +858,8 @@ static int eeepc_hotk_add(struct acpi_device *device)
         if (result)
                 goto ehotk_fail;
 
-        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
-        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
-
-        if (get_acpi(CM_ASL_WLAN) != -1) {
-                ehotk->eeepc_wlan_rfkill = rfkill_alloc("eeepc-wlan",
-                                                        &device->dev,
-                                                        RFKILL_TYPE_WLAN,
-                                                        &eeepc_rfkill_ops,
-                                                        (void *)CM_ASL_WLAN);
-
-                if (!ehotk->eeepc_wlan_rfkill)
-                        goto wlan_fail;
-
-                rfkill_init_sw_state(ehotk->eeepc_wlan_rfkill,
-                                     get_acpi(CM_ASL_WLAN) != 1);
-                result = rfkill_register(ehotk->eeepc_wlan_rfkill);
-                if (result)
-                        goto wlan_fail;
-        }
-
-        if (get_acpi(CM_ASL_BLUETOOTH) != -1) {
-                ehotk->eeepc_bluetooth_rfkill =
-                        rfkill_alloc("eeepc-bluetooth",
-                                     &device->dev,
-                                     RFKILL_TYPE_BLUETOOTH,
-                                     &eeepc_rfkill_ops,
-                                     (void *)CM_ASL_BLUETOOTH);
-
-                if (!ehotk->eeepc_bluetooth_rfkill)
-                        goto bluetooth_fail;
-
-                rfkill_init_sw_state(ehotk->eeepc_bluetooth_rfkill,
-                                     get_acpi(CM_ASL_BLUETOOTH) != 1);
-                result = rfkill_register(ehotk->eeepc_bluetooth_rfkill);
-                if (result)
-                        goto bluetooth_fail;
-        }
-
         return 0;
 
- bluetooth_fail:
-        rfkill_destroy(ehotk->eeepc_bluetooth_rfkill);
-        rfkill_unregister(ehotk->eeepc_wlan_rfkill);
- wlan_fail:
-        rfkill_destroy(ehotk->eeepc_wlan_rfkill);
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
  ehotk_fail:
         kfree(ehotk);
         ehotk = NULL;
@@ -823,16 +872,13 @@ static int eeepc_hotk_remove(struct acpi_device *device, int type)
         if (!device || !acpi_driver_data(device))
                  return -EINVAL;
 
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
-
         kfree(ehotk);
         return 0;
 }
 
 static int eeepc_hotk_resume(struct acpi_device *device)
 {
-        if (ehotk->eeepc_wlan_rfkill) {
+        if (ehotk->wlan_rfkill) {
                 bool wlan;
 
                 /* Workaround - it seems that _PTS disables the wireless
@@ -844,14 +890,13 @@ static int eeepc_hotk_resume(struct acpi_device *device)
                 wlan = get_acpi(CM_ASL_WLAN);
                 set_acpi(CM_ASL_WLAN, wlan);
 
-                rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill,
-                                    wlan != 1);
+                rfkill_set_sw_state(ehotk->wlan_rfkill, wlan != 1);
 
                 eeepc_rfkill_hotplug();
         }
 
-        if (ehotk->eeepc_bluetooth_rfkill)
-                rfkill_set_sw_state(ehotk->eeepc_bluetooth_rfkill,
+        if (ehotk->bluetooth_rfkill)
+                rfkill_set_sw_state(ehotk->bluetooth_rfkill,
                                     get_acpi(CM_ASL_BLUETOOTH) != 1);
 
         return 0;
@@ -973,10 +1018,16 @@ static void eeepc_backlight_exit(void)
 
 static void eeepc_rfkill_exit(void)
 {
-        if (ehotk->eeepc_wlan_rfkill)
-                rfkill_unregister(ehotk->eeepc_wlan_rfkill);
-        if (ehotk->eeepc_bluetooth_rfkill)
-                rfkill_unregister(ehotk->eeepc_bluetooth_rfkill);
+        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
+        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
+        if (ehotk->wlan_rfkill)
+                rfkill_unregister(ehotk->wlan_rfkill);
+        if (ehotk->bluetooth_rfkill)
+                rfkill_unregister(ehotk->bluetooth_rfkill);
+        if (ehotk->wwan3g_rfkill)
+                rfkill_unregister(ehotk->wwan3g_rfkill);
+        if (ehotk->hotplug_slot)
+                pci_hp_deregister(ehotk->hotplug_slot);
 }
 
 static void eeepc_input_exit(void)
@@ -1011,6 +1062,75 @@ static void __exit eeepc_laptop_exit(void)
         platform_driver_unregister(&platform_driver);
 }
 
+static int eeepc_new_rfkill(struct rfkill **rfkill,
+                            const char *name, struct device *dev,
+                            enum rfkill_type type, int cm)
+{
+        int result;
+
+        result = get_acpi(cm);
+        if (result < 0)
+                return result;
+
+        *rfkill = rfkill_alloc(name, dev, type,
+                               &eeepc_rfkill_ops, (void *)(unsigned long)cm);
+
+        if (!*rfkill)
+                return -EINVAL;
+
+        rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1);
+        result = rfkill_register(*rfkill);
+        if (result) {
+                rfkill_destroy(*rfkill);
+                *rfkill = NULL;
+                return result;
+        }
+        return 0;
+}
+
+
+static int eeepc_rfkill_init(struct device *dev)
+{
+        int result = 0;
+
+        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
+        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
+
+        result = eeepc_new_rfkill(&ehotk->wlan_rfkill,
+                                  "eeepc-wlan", dev,
+                                  RFKILL_TYPE_WLAN, CM_ASL_WLAN);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill,
+                                  "eeepc-bluetooth", dev,
+                                  RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill,
+                                  "eeepc-wwan3g", dev,
+                                  RFKILL_TYPE_WWAN, CM_ASL_3G);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = eeepc_setup_pci_hotplug();
+        /*
+         * If we get -EBUSY then something else is handling the PCI hotplug -
+         * don't fail in this case
+         */
+        if (result == -EBUSY)
+                result = 0;
+
+exit:
+        if (result && result != -ENODEV)
+                eeepc_rfkill_exit();
+        return result;
+}
+
 static int eeepc_backlight_init(struct device *dev)
 {
         struct backlight_device *bd;
@@ -1018,8 +1138,7 @@ static int eeepc_backlight_init(struct device *dev)
         bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
                                        NULL, &eeepcbl_ops);
         if (IS_ERR(bd)) {
-                printk(EEEPC_ERR
-                       "Could not register eeepc backlight device\n");
+                pr_err("Could not register eeepc backlight device\n");
                 eeepc_backlight_device = NULL;
                 return PTR_ERR(bd);
         }
@@ -1038,8 +1157,7 @@ static int eeepc_hwmon_init(struct device *dev)
 
         hwmon = hwmon_device_register(dev);
         if (IS_ERR(hwmon)) {
-                printk(EEEPC_ERR
-                       "Could not register eeepc hwmon device\n");
+                pr_err("Could not register eeepc hwmon device\n");
                 eeepc_hwmon_device = NULL;
                 return PTR_ERR(hwmon);
         }
@@ -1065,19 +1183,6 @@ static int __init eeepc_laptop_init(void)
                 acpi_bus_unregister_driver(&eeepc_hotk_driver);
                 return -ENODEV;
         }
-        dev = acpi_get_physical_device(ehotk->device->handle);
-
-        if (!acpi_video_backlight_support()) {
-                result = eeepc_backlight_init(dev);
-                if (result)
-                        goto fail_backlight;
-        } else
-                printk(EEEPC_INFO "Backlight controlled by ACPI video "
-                       "driver\n");
-
-        result = eeepc_hwmon_init(dev);
-        if (result)
-                goto fail_hwmon;
 
         eeepc_enable_camera();
 
@@ -1097,7 +1202,33 @@ static int __init eeepc_laptop_init(void)
                                     &platform_attribute_group);
         if (result)
                 goto fail_sysfs;
+
+        dev = &platform_device->dev;
+
+        if (!acpi_video_backlight_support()) {
+                result = eeepc_backlight_init(dev);
+                if (result)
+                        goto fail_backlight;
+        } else
+                pr_info("Backlight controlled by ACPI video "
+                        "driver\n");
+
+        result = eeepc_hwmon_init(dev);
+        if (result)
+                goto fail_hwmon;
+
+        result = eeepc_rfkill_init(dev);
+        if (result)
+                goto fail_rfkill;
+
         return 0;
+fail_rfkill:
+        eeepc_hwmon_exit();
+fail_hwmon:
+        eeepc_backlight_exit();
+fail_backlight:
+        sysfs_remove_group(&platform_device->dev.kobj,
+                           &platform_attribute_group);
 fail_sysfs:
         platform_device_del(platform_device);
 fail_platform_device2:
@@ -1105,12 +1236,7 @@ fail_platform_device2:
 fail_platform_device1:
         platform_driver_unregister(&platform_driver);
 fail_platform_driver:
-        eeepc_hwmon_exit();
-fail_hwmon:
-        eeepc_backlight_exit();
-fail_backlight:
         eeepc_input_exit();
-        eeepc_rfkill_exit();
         return result;
 }
 
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 4ac2311c00af..ca508564a181 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -171,7 +171,7 @@ static int hp_wmi_tablet_state(void)
 static int hp_wmi_set_block(void *data, bool blocked)
 {
         unsigned long b = (unsigned long) data;
-        int query = BIT(b + 8) | ((!!blocked) << b);
+        int query = BIT(b + 8) | ((!blocked) << b);
 
         return hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1, query);
 }
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index aafd3e6ebb0d..a118eb0f1e67 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -1,8 +1,8 @@
 /*
  * Blackfin On-Chip Real Time Clock Driver
- *  Supports BF52[257]/BF53[123]/BF53[467]/BF54[24789]
+ *  Supports BF51x/BF52x/BF53[123]/BF53[467]/BF54x
  *
- * Copyright 2004-2008 Analog Devices Inc.
+ * Copyright 2004-2009 Analog Devices Inc.
  *
  * Enter bugs at http://blackfin.uclinux.org/
  *
@@ -363,7 +363,7 @@ static int __devinit bfin_rtc_probe(struct platform_device *pdev)
         struct bfin_rtc *rtc;
         struct device *dev = &pdev->dev;
         int ret = 0;
-        unsigned long timeout;
+        unsigned long timeout = jiffies + HZ;
 
         dev_dbg_stamp(dev);
 
@@ -374,32 +374,32 @@ static int __devinit bfin_rtc_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, rtc);
         device_init_wakeup(dev, 1);
 
+        /* Register our RTC with the RTC framework */
+        rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops,
+                                                THIS_MODULE);
+        if (unlikely(IS_ERR(rtc->rtc_dev))) {
+                ret = PTR_ERR(rtc->rtc_dev);
+                goto err;
+        }
+
         /* Grab the IRQ and init the hardware */
         ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, IRQF_SHARED, pdev->name, dev);
         if (unlikely(ret))
-                goto err;
+                goto err_reg;
         /* sometimes the bootloader touched things, but the write complete was not
          * enabled, so let's just do a quick timeout here since the IRQ will not fire ...
          */
-        timeout = jiffies + HZ;
         while (bfin_read_RTC_ISTAT() & RTC_ISTAT_WRITE_PENDING)
                 if (time_after(jiffies, timeout))
                         break;
         bfin_rtc_reset(dev, RTC_ISTAT_WRITE_COMPLETE);
         bfin_write_RTC_SWCNT(0);
 
-        /* Register our RTC with the RTC framework */
-        rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops, THIS_MODULE);
-        if (unlikely(IS_ERR(rtc->rtc_dev))) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto err_irq;
-        }
-
         return 0;
 
- err_irq:
-        free_irq(IRQ_RTC, dev);
- err:
+err_reg:
+        rtc_device_unregister(rtc->rtc_dev);
+err:
         kfree(rtc);
         return ret;
 }
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 32b27739ec2a..713f7bf5afb3 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -283,7 +283,7 @@ static void ds1374_work(struct work_struct *work)
 
         stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
         if (stat < 0)
-                return;
+                goto unlock;
 
         if (stat & DS1374_REG_SR_AF) {
                 stat &= ~DS1374_REG_SR_AF;
@@ -302,7 +302,7 @@ static void ds1374_work(struct work_struct *work)
 out:
         if (!ds1374->exiting)
                 enable_irq(client->irq);
-
+unlock:
         mutex_unlock(&ds1374->mutex);
 }
 
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index f11297aff854..2c839d0d21bd 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -1,7 +1,7 @@
 /*
  *  Driver for NEC VR4100 series Real Time Clock unit.
  *
- *  Copyright (C) 2003-2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2003-2008  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
@@ -33,7 +33,7 @@
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
-MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
 MODULE_DESCRIPTION("NEC VR4100 series RTC driver");
 MODULE_LICENSE("GPL v2");
 
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index f8b1f04f26b8..c11770f5b368 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1696,8 +1696,7 @@ static void dasd_eckd_handle_unsolicited_interrupt(struct dasd_device *device,
                 DBF_DEV_EVENT(DBF_ERR, device, "%s",
                             "unsolicited interrupt received "
                             "(sense available)");
-                device->discipline->dump_sense_dbf(device, NULL, irb,
-                                                   "unsolicited");
+                device->discipline->dump_sense_dbf(device, irb, "unsolicited");
         }
 
         dasd_schedule_device_bh(device);
@@ -2941,42 +2940,20 @@ dasd_eckd_dump_ccw_range(struct ccw1 *from, struct ccw1 *to, char *page)
 }
 
 static void
-dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct dasd_ccw_req *req,
-                         struct irb *irb, char *reason)
+dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb,
+                         char *reason)
 {
         u64 *sense;
-        int sl;
-        struct tsb *tsb;
 
-        sense = NULL;
-        tsb = NULL;
-        if (req && scsw_is_tm(&req->irb.scsw)) {
-                if (irb->scsw.tm.tcw)
-                        tsb = tcw_get_tsb(
-                                (struct tcw *)(unsigned long)irb->scsw.tm.tcw);
-                if (tsb && (irb->scsw.tm.fcxs == 0x01)) {
-                        switch (tsb->flags & 0x07) {
-                        case 1: /* tsa_iostat */
-                                sense = (u64 *)tsb->tsa.iostat.sense;
-                        break;
-                        case 2: /* ts_ddpc */
-                                sense = (u64 *)tsb->tsa.ddpc.sense;
-                        break;
-                        case 3: /* tsa_intrg */
-                        break;
-                        }
-                }
-        } else {
-                if (irb->esw.esw0.erw.cons)
-                        sense = (u64 *)irb->ecw;
-        }
+        sense = (u64 *) dasd_get_sense(irb);
         if (sense) {
-                for (sl = 0; sl < 4; sl++) {
-                        DBF_DEV_EVENT(DBF_EMERG, device,
-                                      "%s: %016llx %016llx %016llx %016llx",
-                                      reason, sense[0], sense[1], sense[2],
-                                      sense[3]);
-                }
+                DBF_DEV_EVENT(DBF_EMERG, device,
+                              "%s: %s %02x%02x%02x %016llx %016llx %016llx "
+                              "%016llx", reason,
+                              scsw_is_tm(&irb->scsw) ? "t" : "c",
+                              scsw_cc(&irb->scsw), scsw_cstat(&irb->scsw),
+                              scsw_dstat(&irb->scsw), sense[0], sense[1],
+                              sense[2], sense[3]);
         } else {
                 DBF_DEV_EVENT(DBF_EMERG, device, "%s",
                               "SORRY - NO VALID SENSE AVAILABLE\n");
diff --git a/drivers/s390/block/dasd_erp.c b/drivers/s390/block/dasd_erp.c
index d970ce2814be..cb8f9cef7429 100644
--- a/drivers/s390/block/dasd_erp.c
+++ b/drivers/s390/block/dasd_erp.c
@@ -172,7 +172,7 @@ dasd_log_sense_dbf(struct dasd_ccw_req *cqr, struct irb *irb)
         device = cqr->startdev;
         /* dump sense data to s390 debugfeature*/
         if (device->discipline && device->discipline->dump_sense_dbf)
-                device->discipline->dump_sense_dbf(device, cqr, irb, "log");
+                device->discipline->dump_sense_dbf(device, irb, "log");
 }
 EXPORT_SYMBOL(dasd_log_sense_dbf);
 
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index e21ee735f926..31849ad5e59f 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -241,7 +241,7 @@ static void dasd_fba_handle_unsolicited_interrupt(struct dasd_device *device,
         /* check for unsolicited interrupts */
         DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                     "unsolicited interrupt received");
-        device->discipline->dump_sense_dbf(device, NULL, irb, "unsolicited");
+        device->discipline->dump_sense_dbf(device, irb, "unsolicited");
         dasd_schedule_device_bh(device);
         return;
 };
@@ -444,17 +444,20 @@ dasd_fba_fill_info(struct dasd_device * device,
 }
 
 static void
-dasd_fba_dump_sense_dbf(struct dasd_device *device, struct dasd_ccw_req *req,
-                         struct irb *irb, char *reason)
+dasd_fba_dump_sense_dbf(struct dasd_device *device, struct irb *irb,
+                        char *reason)
 {
-        int sl;
-        if (irb->esw.esw0.erw.cons) {
-                for (sl = 0; sl < 4; sl++) {
-                        DBF_DEV_EVENT(DBF_EMERG, device,
-                                      "%s: %08x %08x %08x %08x",
-                                      reason, irb->ecw[8 * 0], irb->ecw[8 * 1],
-                                      irb->ecw[8 * 2], irb->ecw[8 * 3]);
-                }
+        u64 *sense;
+
+        sense = (u64 *) dasd_get_sense(irb);
+        if (sense) {
+                DBF_DEV_EVENT(DBF_EMERG, device,
+                              "%s: %s %02x%02x%02x %016llx %016llx %016llx "
+                              "%016llx", reason,
+                              scsw_is_tm(&irb->scsw) ? "t" : "c",
+                              scsw_cc(&irb->scsw), scsw_cstat(&irb->scsw),
+                              scsw_dstat(&irb->scsw), sense[0], sense[1],
+                              sense[2], sense[3]);
         } else {
                 DBF_DEV_EVENT(DBF_EMERG, device, "%s",
                               "SORRY - NO VALID SENSE AVAILABLE\n");
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index fd63b2f2bda9..b699ca356ac5 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -284,8 +284,7 @@ struct dasd_discipline {
         dasd_erp_fn_t(*erp_postaction) (struct dasd_ccw_req *);
         void (*dump_sense) (struct dasd_device *, struct dasd_ccw_req *,
                             struct irb *);
-        void (*dump_sense_dbf) (struct dasd_device *, struct dasd_ccw_req *,
-                            struct irb *, char *);
+        void (*dump_sense_dbf) (struct dasd_device *, struct irb *, char *);
 
         void (*handle_unsolicited_interrupt) (struct dasd_device *,
                                               struct irb *);
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 016f9e9d2591..d34617682a62 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -964,7 +964,8 @@ static int dcssblk_freeze(struct device *dev)
                         break;
         }
         if (rc)
-                pr_err("Suspend failed because device %s is writeable.\n",
+                pr_err("Suspending the system failed because DCSS device %s "
+                       "is writable\n",
                        dev_info->segment_name);
         return rc;
 }
@@ -987,8 +988,8 @@ static int dcssblk_restore(struct device *dev)
                                 goto out_panic;
                         }
                         if (start != entry->start || end != entry->end) {
-                                pr_err("Mismatch of start / end address after "
-                                       "resuming device %s\n",
+                                pr_err("The address range of DCSS %s changed "
+                                       "while the system was suspended\n",
                                        entry->segment_name);
                                 goto out_panic;
                         }
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 2e9e1ecd6d82..db442cd6621e 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -443,7 +443,7 @@ fail:
  */
 static void xpram_resume_error(const char *message)
 {
-        pr_err("Resume error: %s\n", message);
+        pr_err("Resuming the system failed: %s\n", message);
         panic("xpram resume error\n");
 }
 
diff --git a/drivers/s390/char/monreader.c b/drivers/s390/char/monreader.c
index 7892550d7932..3234e90bd7f9 100644
--- a/drivers/s390/char/monreader.c
+++ b/drivers/s390/char/monreader.c
@@ -320,7 +320,7 @@ static int mon_open(struct inode *inode, struct file *filp)
                 goto out_path;
         }
         filp->private_data = monpriv;
-        dev_set_drvdata(&monreader_device, monpriv);
+        dev_set_drvdata(monreader_device, monpriv);
         unlock_kernel();
         return nonseekable_open(inode, filp);
 
@@ -463,7 +463,7 @@ static struct miscdevice mon_dev = {
  *****************************************************************************/
 static int monreader_freeze(struct device *dev)
 {
-        struct mon_private *monpriv = dev_get_drvdata(&dev);
+        struct mon_private *monpriv = dev_get_drvdata(dev);
         int rc;
 
         if (!monpriv)
diff --git a/drivers/s390/char/sclp_rw.h b/drivers/s390/char/sclp_rw.h
index 85f491ea929c..7a7bfc947d97 100644
--- a/drivers/s390/char/sclp_rw.h
+++ b/drivers/s390/char/sclp_rw.h
@@ -92,5 +92,10 @@ void sclp_set_columns(struct sclp_buffer *, unsigned short);
 void sclp_set_htab(struct sclp_buffer *, unsigned short);
 int sclp_chars_in_buffer(struct sclp_buffer *);
 
+#ifdef CONFIG_SCLP_CONSOLE
 void sclp_console_pm_event(enum sclp_pm_event sclp_pm_event);
+#else
+static inline void sclp_console_pm_event(enum sclp_pm_event sclp_pm_event) { }
+#endif
+
 #endif  /* __SCLP_RW_H__ */
diff --git a/drivers/s390/char/vmwatchdog.c b/drivers/s390/char/vmwatchdog.c
index cb7854c10c04..f2bc287b69e4 100644
--- a/drivers/s390/char/vmwatchdog.c
+++ b/drivers/s390/char/vmwatchdog.c
@@ -250,14 +250,14 @@ static int vmwdt_resume(void)
 static int vmwdt_suspend(void)
 {
         if (test_and_set_bit(VMWDT_OPEN, &vmwdt_is_open)) {
-                pr_err("The watchdog is in use. "
-                        "This prevents hibernation or suspend.\n");
+                pr_err("The system cannot be suspended while the watchdog"
+                        " is in use\n");
                 return NOTIFY_BAD;
         }
         if (test_bit(VMWDT_RUNNING, &vmwdt_is_open)) {
                 clear_bit(VMWDT_OPEN, &vmwdt_is_open);
-                pr_err("The watchdog is running. "
-                        "This prevents hibernation or suspend.\n");
+                pr_err("The system cannot be suspended while the watchdog"
+                        " is running\n");
                 return NOTIFY_BAD;
         }
         return NOTIFY_DONE;
diff --git a/drivers/scsi/atari_NCR5380.c b/drivers/scsi/atari_NCR5380.c
index 0471f8800483..4240b05aef6d 100644
--- a/drivers/scsi/atari_NCR5380.c
+++ b/drivers/scsi/atari_NCR5380.c
@@ -2826,8 +2826,7 @@ int NCR5380_abort(Scsi_Cmnd *cmd)
          */
 
         local_irq_restore(flags);
-        printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully\n"
-               KERN_INFO "        before abortion\n", HOSTNO);
+        printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO);
 
         /* Maybe it is sufficient just to release the ST-DMA lock... (if
          * possible at all) At least, we should check if the lock could be
diff --git a/drivers/scsi/cxgb3i/Kbuild b/drivers/scsi/cxgb3i/Kbuild
index 25a2032bfa26..70d060b7ff4f 100644
--- a/drivers/scsi/cxgb3i/Kbuild
+++ b/drivers/scsi/cxgb3i/Kbuild
@@ -1,4 +1,4 @@
-EXTRA_CFLAGS += -I$(TOPDIR)/drivers/net/cxgb3
+EXTRA_CFLAGS += -I$(srctree)/drivers/net/cxgb3
 
 cxgb3i-y := cxgb3i_init.o cxgb3i_iscsi.o cxgb3i_pdu.o cxgb3i_offload.o cxgb3i_ddp.o
 obj-$(CONFIG_SCSI_CXGB3_ISCSI) += cxgb3i.o
diff --git a/drivers/scsi/cxgb3i/cxgb3i_iscsi.c b/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
index 74369a3f963b..c399f485aa7d 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
@@ -13,6 +13,7 @@
 
 #include <linux/inet.h>
 #include <linux/crypto.h>
+#include <linux/if_vlan.h>
 #include <net/dst.h>
 #include <net/tcp.h>
 #include <scsi/scsi_cmnd.h>
@@ -184,6 +185,9 @@ static struct cxgb3i_hba *cxgb3i_hba_find_by_netdev(struct net_device *ndev)
         struct cxgb3i_adapter *snic;
         int i;
 
+        if (ndev->priv_flags & IFF_802_1Q_VLAN)
+                ndev = vlan_dev_real_dev(ndev);
+
         read_lock(&cxgb3i_snic_rwlock);
         list_for_each_entry(snic, &cxgb3i_snic_list, list_head) {
                 for (i = 0; i < snic->hba_cnt; i++) {
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index a84072865fc2..2c266c01dc5a 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -473,16 +473,16 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
          * limitation for the device.  Try 40-bit first, and
          * fail to 32-bit.
          */
-        err = pci_set_dma_mask(pdev, DMA_40BIT_MASK);
+        err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
         if (err) {
-                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+                err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                 if (err) {
                         shost_printk(KERN_ERR, fnic->lport->host,
                                      "No usable DMA configuration "
                                      "aborting\n");
                         goto err_out_release_regions;
                 }
-                err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
                 if (err) {
                         shost_printk(KERN_ERR, fnic->lport->host,
                                      "Unable to obtain 32-bit DMA "
@@ -490,7 +490,7 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                         goto err_out_release_regions;
                 }
         } else {
-                err = pci_set_consistent_dma_mask(pdev, DMA_40BIT_MASK);
+                err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(40));
                 if (err) {
                         shost_printk(KERN_ERR, fnic->lport->host,
                                      "Unable to obtain 40-bit DMA "
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index eabf36502856..bfc996971b81 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -245,7 +245,7 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
                                           struct vnic_wq_copy *wq,
                                           struct fnic_io_req *io_req,
                                           struct scsi_cmnd *sc,
-                                          u32 sg_count)
+                                          int sg_count)
 {
         struct scatterlist *sg;
         struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
@@ -260,9 +260,6 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
         char msg[2];
 
         if (sg_count) {
-                BUG_ON(sg_count < 0);
-                BUG_ON(sg_count > FNIC_MAX_SG_DESC_CNT);
-
                 /* For each SGE, create a device desc entry */
                 desc = io_req->sgl_list;
                 for_each_sg(scsi_sglist(sc), sg, sg_count, i) {
@@ -344,7 +341,7 @@ int fnic_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
         struct fnic *fnic;
         struct vnic_wq_copy *wq;
         int ret;
-        u32 sg_count;
+        int sg_count;
         unsigned long flags;
         unsigned long ptr;
 
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 869a11bdccbd..9928704e235f 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1095,9 +1095,14 @@ static void adapter_info_rsp(struct srp_event_struct *evt_struct)
                                 MAX_INDIRECT_BUFS);
                         hostdata->host->sg_tablesize = MAX_INDIRECT_BUFS;
                 }
+
+                if (hostdata->madapter_info.os_type == 3) {
+                        enable_fast_fail(hostdata);
+                        return;
+                }
         }
 
-        enable_fast_fail(hostdata);
+        send_srp_login(hostdata);
 }
 
 /**
diff --git a/drivers/scsi/mac53c94.c b/drivers/scsi/mac53c94.c
index b12ad7c7c673..18735b39b3d3 100644
--- a/drivers/scsi/mac53c94.c
+++ b/drivers/scsi/mac53c94.c
@@ -75,8 +75,9 @@ static int mac53c94_queue(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *
                 int i;
                 printk(KERN_DEBUG "mac53c94_queue %p: command is", cmd);
                 for (i = 0; i < cmd->cmd_len; ++i)
-                        printk(" %.2x", cmd->cmnd[i]);
-                printk("\n" KERN_DEBUG "use_sg=%d request_bufflen=%d request_buffer=%p\n",
+                        printk(KERN_CONT " %.2x", cmd->cmnd[i]);
+                printk(KERN_CONT "\n");
+                printk(KERN_DEBUG "use_sg=%d request_bufflen=%d request_buffer=%p\n",
                        scsi_sg_count(cmd), scsi_bufflen(cmd), scsi_sglist(cmd));
         }
 #endif
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 2eee9e6e4fe8..292c02f810d0 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -3670,13 +3670,14 @@ static void
 fc_bsg_goose_queue(struct fc_rport *rport)
 {
         int flagset;
+        unsigned long flags;
 
         if (!rport->rqst_q)
                 return;
 
         get_device(&rport->dev);
 
-        spin_lock(rport->rqst_q->queue_lock);
+        spin_lock_irqsave(rport->rqst_q->queue_lock, flags);
         flagset = test_bit(QUEUE_FLAG_REENTER, &rport->rqst_q->queue_flags) &&
                   !test_bit(QUEUE_FLAG_REENTER, &rport->rqst_q->queue_flags);
         if (flagset)
@@ -3684,7 +3685,7 @@ fc_bsg_goose_queue(struct fc_rport *rport)
         __blk_run_queue(rport->rqst_q);
         if (flagset)
                 queue_flag_clear(QUEUE_FLAG_REENTER, rport->rqst_q);
-        spin_unlock(rport->rqst_q->queue_lock);
+        spin_unlock_irqrestore(rport->rqst_q->queue_lock, flags);
 
         put_device(&rport->dev);
 }
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 8201387b4daa..9230402c45af 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -210,13 +210,11 @@ static void sg_put_dev(Sg_device *sdp);
 static int sg_allow_access(struct file *filp, unsigned char *cmd)
 {
         struct sg_fd *sfp = (struct sg_fd *)filp->private_data;
-        struct request_queue *q = sfp->parentdp->device->request_queue;
 
         if (sfp->parentdp->device->type == TYPE_SCANNER)
                 return 0;
 
-        return blk_verify_command(&q->cmd_filter,
-                                  cmd, filp->f_mode & FMODE_WRITE);
+        return blk_verify_command(cmd, filp->f_mode & FMODE_WRITE);
 }
 
 static int
@@ -621,7 +619,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
                 if (strcmp(current->comm, cmd) && printk_ratelimit()) {
                         printk(KERN_WARNING
                                "sg_write: data in/out %d/%d bytes for SCSI command 0x%x--"
-                               "guessing data in;\n" KERN_WARNING "   "
+                               "guessing data in;\n   "
                                "program %s not setting count and/or reply_len properly\n",
                                old_hdr.reply_len - (int)SZ_SG_HEADER,
                                input_size, (unsigned int) cmnd[0],
@@ -1658,6 +1656,10 @@ static int sg_start_req(Sg_request *srp, unsigned char *cmd)
                 md->nr_entries = req_schp->k_use_sg;
                 md->offset = 0;
                 md->null_mapped = hp->dxferp ? 0 : 1;
+                if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
+                        md->from_user = 1;
+                else
+                        md->from_user = 0;
         }
 
         if (iov_count) {
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index bcaba86060ab..75da6e58ce55 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -2860,8 +2860,7 @@ static int NCR5380_abort(struct scsi_cmnd *cmd)
  */
 
     local_irq_restore(flags);
-    printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully\n"
-           KERN_INFO "        before abortion\n", HOSTNO); 
+    printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO); 
 
     return SCSI_ABORT_NOT_RUNNING;
 }
diff --git a/drivers/scsi/zalon.c b/drivers/scsi/zalon.c
index 97f3158fa7b5..27e84e4b1fa9 100644
--- a/drivers/scsi/zalon.c
+++ b/drivers/scsi/zalon.c
@@ -134,7 +134,7 @@ zalon_probe(struct parisc_device *dev)
 
         host = ncr_attach(&zalon7xx_template, unit, &device);
         if (!host)
-                goto fail;
+                return -ENODEV;
 
         if (request_irq(dev->irq, ncr53c8xx_intr, IRQF_SHARED, "zalon", host)) {
           dev_printk(KERN_ERR, &dev->dev, "irq problem with %d, detaching\n ",
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index a07015d646dd..e7108e75653d 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -60,11 +60,12 @@ struct serial_private {
 
 static void moan_device(const char *str, struct pci_dev *dev)
 {
-        printk(KERN_WARNING "%s: %s\n"
-               KERN_WARNING "Please send the output of lspci -vv, this\n"
-               KERN_WARNING "message (0x%04x,0x%04x,0x%04x,0x%04x), the\n"
-               KERN_WARNING "manufacturer and name of serial board or\n"
-               KERN_WARNING "modem board to rmk+serial@arm.linux.org.uk.\n",
+        printk(KERN_WARNING
+               "%s: %s\n"
+               "Please send the output of lspci -vv, this\n"
+               "message (0x%04x,0x%04x,0x%04x,0x%04x), the\n"
+               "manufacturer and name of serial board or\n"
+               "modem board to rmk+serial@arm.linux.org.uk.\n",
                pci_name(dev), str, dev->vendor, dev->device,
                dev->subsystem_vendor, dev->subsystem_device);
 }
@@ -759,6 +760,8 @@ static int pci_netmos_init(struct pci_dev *dev)
         /* subdevice 0x00PS means <P> parallel, <S> serial */
         unsigned int num_serial = dev->subsystem_device & 0xf;
 
+        if (dev->device == PCI_DEVICE_ID_NETMOS_9901)
+                return 0;
         if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM &&
                         dev->subsystem_device == 0x0299)
                 return 0;
@@ -3557,6 +3560,10 @@ static struct pci_device_id serial_pci_tbl[] = {
                 PCI_VENDOR_ID_IBM, 0x0299,
                 0, 0, pbn_b0_bt_2_115200 },
 
+        {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901,
+                0xA000, 0x1000,
+                0, 0, pbn_b0_1_115200 },
+
         /*
          * These entries match devices with class COMMUNICATION_SERIAL,
          * COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 66f52674ca0c..8e2feb563347 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -707,24 +707,25 @@ static irqreturn_t sci_br_interrupt(int irq, void *ptr)
 
 static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr)
 {
-        unsigned short ssr_status, scr_status;
+        unsigned short ssr_status, scr_status, err_enabled;
         struct uart_port *port = ptr;
         irqreturn_t ret = IRQ_NONE;
 
         ssr_status = sci_in(port, SCxSR);
         scr_status = sci_in(port, SCSCR);
+        err_enabled = scr_status & (SCI_CTRL_FLAGS_REIE | SCI_CTRL_FLAGS_RIE);
 
         /* Tx Interrupt */
-        if ((ssr_status & 0x0020) && (scr_status & SCI_CTRL_FLAGS_TIE))
+        if ((ssr_status & SCxSR_TDxE(port)) && (scr_status & SCI_CTRL_FLAGS_TIE))
                 ret = sci_tx_interrupt(irq, ptr);
         /* Rx Interrupt */
-        if ((ssr_status & 0x0002) && (scr_status & SCI_CTRL_FLAGS_RIE))
+        if ((ssr_status & SCxSR_RDxF(port)) && (scr_status & SCI_CTRL_FLAGS_RIE))
                 ret = sci_rx_interrupt(irq, ptr);
         /* Error Interrupt */
-        if ((ssr_status & 0x0080) && (scr_status & SCI_CTRL_FLAGS_REIE))
+        if ((ssr_status & SCxSR_ERRORS(port)) && err_enabled)
                 ret = sci_er_interrupt(irq, ptr);
         /* Break Interrupt */
-        if ((ssr_status & 0x0010) && (scr_status & SCI_CTRL_FLAGS_REIE))
+        if ((ssr_status & SCxSR_BRK(port)) && err_enabled)
                 ret = sci_br_interrupt(irq, ptr);
 
         return ret;
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index 0573f3b5175e..dac550e57c29 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -1,7 +1,7 @@
 /*
  *  Driver for NEC VR4100 series Serial Interface Unit.
  *
- *  Copyright (C) 2004-2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2004-2008  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  Based on drivers/serial/8250.c, by Russell King.
  *
diff --git a/drivers/spi/amba-pl022.c b/drivers/spi/amba-pl022.c
index da76797ce8b9..c0f950a7cbec 100644
--- a/drivers/spi/amba-pl022.c
+++ b/drivers/spi/amba-pl022.c
@@ -38,14 +38,12 @@
 #include <linux/interrupt.h>
 #include <linux/spi/spi.h>
 #include <linux/workqueue.h>
-#include <linux/errno.h>
 #include <linux/delay.h>
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/amba/bus.h>
 #include <linux/amba/pl022.h>
 #include <linux/io.h>
-#include <linux/delay.h>
 
 /*
  * This macro is used to define some register default values.
diff --git a/drivers/spi/omap_uwire.c b/drivers/spi/omap_uwire.c
index aa90ddb37066..8980a5640bd9 100644
--- a/drivers/spi/omap_uwire.c
+++ b/drivers/spi/omap_uwire.c
@@ -514,6 +514,8 @@ static int __init uwire_probe(struct platform_device *pdev)
         /* the spi->mode bits understood by this driver: */
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 
+        master->flags = SPI_MASTER_HALF_DUPLEX;
+
         master->bus_num = 2;    /* "official" */
         master->num_chipselect = 4;
         master->setup = uwire_setup;
diff --git a/drivers/spi/spi_bitbang.c b/drivers/spi/spi_bitbang.c
index 2a5abc08e857..f1db395dd889 100644
--- a/drivers/spi/spi_bitbang.c
+++ b/drivers/spi/spi_bitbang.c
@@ -258,6 +258,11 @@ static void bitbang_work(struct work_struct *work)
         struct spi_bitbang      *bitbang =
                 container_of(work, struct spi_bitbang, work);
         unsigned long           flags;
+        int                     do_setup = -1;
+        int                     (*setup_transfer)(struct spi_device *,
+                                        struct spi_transfer *);
+
+        setup_transfer = bitbang->setup_transfer;
 
         spin_lock_irqsave(&bitbang->lock, flags);
         bitbang->busy = 1;
@@ -269,8 +274,6 @@ static void bitbang_work(struct work_struct *work)
                 unsigned                tmp;
                 unsigned                cs_change;
                 int                     status;
-                int                     (*setup_transfer)(struct spi_device *,
-                                                struct spi_transfer *);
 
                 m = container_of(bitbang->queue.next, struct spi_message,
                                 queue);
@@ -287,19 +290,19 @@ static void bitbang_work(struct work_struct *work)
                 tmp = 0;
                 cs_change = 1;
                 status = 0;
-                setup_transfer = NULL;
 
                 list_for_each_entry (t, &m->transfers, transfer_list) {
 
-                        /* override or restore speed and wordsize */
-                        if (t->speed_hz || t->bits_per_word) {
-                                setup_transfer = bitbang->setup_transfer;
+                        /* override speed or wordsize? */
+                        if (t->speed_hz || t->bits_per_word)
+                                do_setup = 1;
+
+                        /* init (-1) or override (1) transfer params */
+                        if (do_setup != 0) {
                                 if (!setup_transfer) {
                                         status = -ENOPROTOOPT;
                                         break;
                                 }
-                        }
-                        if (setup_transfer) {
                                 status = setup_transfer(spi, t);
                                 if (status < 0)
                                         break;
@@ -363,9 +366,10 @@ static void bitbang_work(struct work_struct *work)
                 m->status = status;
                 m->complete(m->context);
 
-                /* restore speed and wordsize */
-                if (setup_transfer)
+                /* restore speed and wordsize if it was overridden */
+                if (do_setup == 1)
                         setup_transfer(spi, NULL);
+                do_setup = 0;
 
                 /* normally deactivate chipselect ... unless no error and
                  * cs_change has hinted that the next message will probably
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index 5d869c4d3eb2..606e7a40a8da 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -58,15 +58,20 @@ static unsigned long	minors[N_SPI_MINORS / BITS_PER_LONG];
 
 
 /* Bit masks for spi_device.mode management.  Note that incorrect
- * settings for CS_HIGH and 3WIRE can cause *lots* of trouble for other
- * devices on a shared bus:  CS_HIGH, because this device will be
- * active when it shouldn't be;  3WIRE, because when active it won't
- * behave as it should.
+ * settings for some settings can cause *lots* of trouble for other
+ * devices on a shared bus:
  *
- * REVISIT should changing those two modes be privileged?
+ *  - CS_HIGH ... this device will be active when it shouldn't be
+ *  - 3WIRE ... when active, it won't behave as it should
+ *  - NO_CS ... there will be no explicit message boundaries; this
+ *      is completely incompatible with the shared bus model
+ *  - READY ... transfers may proceed when they shouldn't.
+ *
+ * REVISIT should changing those flags be privileged?
  */
 #define SPI_MODE_MASK           (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
-                                | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP)
+                                | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
+                                | SPI_NO_CS | SPI_READY)
 
 struct spidev_data {
         dev_t                   devt;
diff --git a/drivers/ssb/driver_mipscore.c b/drivers/ssb/driver_mipscore.c
index 3fd3e3b412b6..3c6feed46f6e 100644
--- a/drivers/ssb/driver_mipscore.c
+++ b/drivers/ssb/driver_mipscore.c
@@ -49,29 +49,54 @@ static const u32 ipsflag_irq_shift[] = {
 
 static inline u32 ssb_irqflag(struct ssb_device *dev)
 {
-        return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG;
+        u32 tpsflag = ssb_read32(dev, SSB_TPSFLAG);
+        if (tpsflag)
+                return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG;
+        else
+                /* not irq supported */
+                return 0x3f;
+}
+
+static struct ssb_device *find_device(struct ssb_device *rdev, int irqflag)
+{
+        struct ssb_bus *bus = rdev->bus;
+        int i;
+        for (i = 0; i < bus->nr_devices; i++) {
+                struct ssb_device *dev;
+                dev = &(bus->devices[i]);
+                if (ssb_irqflag(dev) == irqflag)
+                        return dev;
+        }
+        return NULL;
 }
 
 /* Get the MIPS IRQ assignment for a specified device.
  * If unassigned, 0 is returned.
+ * If disabled, 5 is returned.
+ * If not supported, 6 is returned.
  */
 unsigned int ssb_mips_irq(struct ssb_device *dev)
 {
         struct ssb_bus *bus = dev->bus;
+        struct ssb_device *mdev = bus->mipscore.dev;
         u32 irqflag;
         u32 ipsflag;
         u32 tmp;
         unsigned int irq;
 
         irqflag = ssb_irqflag(dev);
+        if (irqflag == 0x3f)
+                return 6;
         ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG);
         for (irq = 1; irq <= 4; irq++) {
                 tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]);
                 if (tmp == irqflag)
                         break;
         }
-        if (irq == 5)
-                irq = 0;
+        if (irq == 5) {
+                if ((1 << irqflag) & ssb_read32(mdev, SSB_INTVEC))
+                        irq = 0;
+        }
 
         return irq;
 }
@@ -97,25 +122,56 @@ static void set_irq(struct ssb_device *dev, unsigned int irq)
         struct ssb_device *mdev = bus->mipscore.dev;
         u32 irqflag = ssb_irqflag(dev);
 
+        BUG_ON(oldirq == 6);
+
         dev->irq = irq + 2;
 
-        ssb_dprintk(KERN_INFO PFX
-                    "set_irq: core 0x%04x, irq %d => %d\n",
-                    dev->id.coreid, oldirq, irq);
         /* clear the old irq */
         if (oldirq == 0)
                 ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)));
-        else
+        else if (oldirq != 5)
                 clear_irq(bus, oldirq);
 
         /* assign the new one */
         if (irq == 0) {
                 ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC)));
         } else {
+                u32 ipsflag = ssb_read32(mdev, SSB_IPSFLAG);
+                if ((ipsflag & ipsflag_irq_mask[irq]) != ipsflag_irq_mask[irq]) {
+                        u32 oldipsflag = (ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq];
+                        struct ssb_device *olddev = find_device(dev, oldipsflag);
+                        if (olddev)
+                                set_irq(olddev, 0);
+                }
                 irqflag <<= ipsflag_irq_shift[irq];
-                irqflag |= (ssb_read32(mdev, SSB_IPSFLAG) & ~ipsflag_irq_mask[irq]);
+                irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]);
                 ssb_write32(mdev, SSB_IPSFLAG, irqflag);
         }
+        ssb_dprintk(KERN_INFO PFX
+                    "set_irq: core 0x%04x, irq %d => %d\n",
+                    dev->id.coreid, oldirq+2, irq+2);
+}
+
+static void print_irq(struct ssb_device *dev, unsigned int irq)
+{
+        int i;
+        static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"};
+        ssb_dprintk(KERN_INFO PFX
+                "core 0x%04x, irq :", dev->id.coreid);
+        for (i = 0; i <= 6; i++) {
+                ssb_dprintk(" %s%s", irq_name[i], i==irq?"*":" ");
+        }
+        ssb_dprintk("\n");
+}
+
+static void dump_irq(struct ssb_bus *bus)
+{
+        int i;
+        for (i = 0; i < bus->nr_devices; i++) {
+                struct ssb_device *dev;
+                dev = &(bus->devices[i]);
+                print_irq(dev, ssb_mips_irq(dev));
+        }
 }
 
 static void ssb_mips_serial_init(struct ssb_mipscore *mcore)
@@ -197,16 +253,23 @@ void ssb_mipscore_init(struct ssb_mipscore *mcore)
 
         /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */
         for (irq = 2, i = 0; i < bus->nr_devices; i++) {
+                int mips_irq;
                 dev = &(bus->devices[i]);
-                dev->irq = ssb_mips_irq(dev) + 2;
+                mips_irq = ssb_mips_irq(dev);
+                if (mips_irq > 4)
+                        dev->irq = 0;
+                else
+                        dev->irq = mips_irq + 2;
+                if (dev->irq > 5)
+                        continue;
                 switch (dev->id.coreid) {
                 case SSB_DEV_USB11_HOST:
                         /* shouldn't need a separate irq line for non-4710, most of them have a proper
                          * external usb controller on the pci */
                         if ((bus->chip_id == 0x4710) && (irq <= 4)) {
                                 set_irq(dev, irq++);
-                                break;
                         }
+                        break;
                         /* fallthrough */
                 case SSB_DEV_PCI:
                 case SSB_DEV_ETHERNET:
@@ -220,6 +283,8 @@ void ssb_mipscore_init(struct ssb_mipscore *mcore)
                         }
                 }
         }
+        ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n");
+        dump_irq(bus);
 
         ssb_mips_serial_init(mcore);
         ssb_mips_flash_detect(mcore);
diff --git a/drivers/ssb/pcmcia.c b/drivers/ssb/pcmcia.c
index fbfadbac67e8..100e7a5c5ea1 100644
--- a/drivers/ssb/pcmcia.c
+++ b/drivers/ssb/pcmcia.c
@@ -583,7 +583,7 @@ static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
                         ssb_printk(".");
                 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
                 if (err) {
-                        ssb_printk("\n" KERN_NOTICE PFX
+                        ssb_printk(KERN_NOTICE PFX
                                    "Failed to write to SPROM.\n");
                         failed = 1;
                         break;
@@ -591,7 +591,7 @@ static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
         }
         err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
         if (err) {
-                ssb_printk("\n" KERN_NOTICE PFX
+                ssb_printk(KERN_NOTICE PFX
                            "Could not disable SPROM write access.\n");
                 failed = 1;
         }
@@ -678,7 +678,8 @@ int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
                         sprom->board_rev = tuple.TupleData[1];
                         break;
                 case SSB_PCMCIA_CIS_PA:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 9,
+                        GOTO_ERROR_ON((tuple.TupleDataLen != 9) &&
+                                      (tuple.TupleDataLen != 10),
                                       "pa tpl size");
                         sprom->pa0b0 = tuple.TupleData[1] |
                                  ((u16)tuple.TupleData[2] << 8);
@@ -718,7 +719,8 @@ int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
                         sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1];
                         break;
                 case SSB_PCMCIA_CIS_BFLAGS:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 3,
+                        GOTO_ERROR_ON((tuple.TupleDataLen != 3) &&
+                                      (tuple.TupleDataLen != 5),
                                       "bfl tpl size");
                         sprom->boardflags_lo = tuple.TupleData[1] |
                                          ((u16)tuple.TupleData[2] << 8);
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 38bfdb0f6660..3f1045993474 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -550,7 +550,7 @@ static void acm_waker(struct work_struct *waker)
 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm;
-        int rv = -EINVAL;
+        int rv = -ENODEV;
         int i;
         dbg("Entering acm_tty_open.");
 
@@ -677,7 +677,7 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 
         /* Perform the closing process and see if we need to do the hardware
            shutdown */
-        if (tty_port_close_start(&acm->port, tty, filp) == 0)
+        if (!acm || tty_port_close_start(&acm->port, tty, filp) == 0)
                 return;
         acm_port_down(acm, 0);
         tty_port_close_end(&acm->port, tty);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index ce3f453f02ef..95ccfa0b9fc5 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -648,7 +648,7 @@ void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
         struct urb      *urb;
         int             length;
         unsigned long   flags;
-        char            buffer[4];      /* Any root hubs with > 31 ports? */
+        char            buffer[6];      /* Any root hubs with > 31 ports? */
 
         if (unlikely(!hcd->rh_registered))
                 return;
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 1576a0520adf..0c03471f0d41 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -337,10 +337,10 @@ config USB_R8A66597_HCD
 
 config SUPERH_ON_CHIP_R8A66597
         boolean "Enable SuperH on-chip R8A66597 USB"
-        depends on USB_R8A66597_HCD && (CPU_SUBTYPE_SH7366 || CPU_SUBTYPE_SH7723)
+        depends on USB_R8A66597_HCD && (CPU_SUBTYPE_SH7366 || CPU_SUBTYPE_SH7723 || CPU_SUBTYPE_SH7724)
         help
            This driver enables support for the on-chip R8A66597 in the
-           SH7366 and SH7723 processors.
+           SH7366, SH7723 and SH7724 processors.
 
 config USB_WHCI_HCD
         tristate "Wireless USB Host Controller Interface (WHCI) driver (EXPERIMENTAL)"
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index f8d9045d668a..0f7a30b7d2d1 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -1261,7 +1261,7 @@ static int mon_alloc_buff(struct mon_pgmap *map, int npages)
                         return -ENOMEM;
                 }
                 map[n].ptr = (unsigned char *) vaddr;
-                map[n].pg = virt_to_page(vaddr);
+                map[n].pg = virt_to_page((void *) vaddr);
         }
         return 0;
 }
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 3dc3768ca71c..5f08702f672f 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -2121,7 +2121,7 @@ static void ftdi_process_read(struct work_struct *work)
                                 /* Note that the error flag is duplicated for
                                    every character received since we don't know
                                    which character it applied to */
-                                if (!usb_serial_handle_sysrq_char(port,
+                                if (!usb_serial_handle_sysrq_char(tty, port,
                                                 data[packet_offset + i]))
                                         tty_insert_flip_char(tty,
                                                 data[packet_offset + i],
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 932d6241b787..ce57f6a32bdf 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -424,10 +424,17 @@ static void flush_and_resubmit_read_urb(struct usb_serial_port *port)
         if (!tty)
                 goto done;
 
-        /* Push data to tty */
-        for (i = 0; i < urb->actual_length; i++, ch++) {
-                if (!usb_serial_handle_sysrq_char(port, *ch))
-                        tty_insert_flip_char(tty, *ch, TTY_NORMAL);
+        /* The per character mucking around with sysrq path it too slow for
+           stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases
+           where the USB serial is not a console anyway */
+        if (!port->console || !port->sysrq)
+                tty_insert_flip_string(tty, ch, urb->actual_length);
+        else {
+                /* Push data to tty */
+                for (i = 0; i < urb->actual_length; i++, ch++) {
+                        if (!usb_serial_handle_sysrq_char(tty, port, *ch))
+                                tty_insert_flip_char(tty, *ch, TTY_NORMAL);
+                }
         }
         tty_flip_buffer_push(tty);
         tty_kref_put(tty);
@@ -527,11 +534,12 @@ void usb_serial_generic_unthrottle(struct tty_struct *tty)
         }
 }
 
-int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch)
+int usb_serial_handle_sysrq_char(struct tty_struct *tty,
+                        struct usb_serial_port *port, unsigned int ch)
 {
         if (port->sysrq && port->console) {
                 if (ch && time_before(jiffies, port->sysrq)) {
-                        handle_sysrq(ch, tty_port_tty_get(&port->port));
+                        handle_sysrq(ch, tty);
                         port->sysrq = 0;
                         return 1;
                 }
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index ec6c132a25b5..efaf59c4f5d0 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -971,18 +971,46 @@ exit:
                         __func__, retval);
 }
 
+static void pl2303_push_data(struct tty_struct *tty,
+                struct usb_serial_port *port, struct urb *urb,
+                u8 line_status)
+{
+        unsigned char *data = urb->transfer_buffer;
+        /* get tty_flag from status */
+        char tty_flag = TTY_NORMAL;
+        /* break takes precedence over parity, */
+        /* which takes precedence over framing errors */
+        if (line_status & UART_BREAK_ERROR)
+                tty_flag = TTY_BREAK;
+        else if (line_status & UART_PARITY_ERROR)
+                tty_flag = TTY_PARITY;
+        else if (line_status & UART_FRAME_ERROR)
+                tty_flag = TTY_FRAME;
+        dbg("%s - tty_flag = %d", __func__, tty_flag);
+
+        tty_buffer_request_room(tty, urb->actual_length + 1);
+        /* overrun is special, not associated with a char */
+        if (line_status & UART_OVERRUN_ERROR)
+                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+        if (port->console && port->sysrq) {
+                int i;
+                for (i = 0; i < urb->actual_length; ++i)
+                        if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
+                                tty_insert_flip_char(tty, data[i], tty_flag);
+        } else
+                tty_insert_flip_string(tty, data, urb->actual_length);
+        tty_flip_buffer_push(tty);
+}
+
 static void pl2303_read_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port =  urb->context;
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         struct tty_struct *tty;
-        unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
-        int i;
         int result;
         int status = urb->status;
         u8 line_status;
-        char tty_flag;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -1010,10 +1038,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
         }
 
         usb_serial_debug_data(debug, &port->dev, __func__,
-                              urb->actual_length, data);
-
-        /* get tty_flag from status */
-        tty_flag = TTY_NORMAL;
+                              urb->actual_length, urb->transfer_buffer);
 
         spin_lock_irqsave(&priv->lock, flags);
         line_status = priv->line_status;
@@ -1021,26 +1046,9 @@ static void pl2303_read_bulk_callback(struct urb *urb)
         spin_unlock_irqrestore(&priv->lock, flags);
         wake_up_interruptible(&priv->delta_msr_wait);
 
-        /* break takes precedence over parity, */
-        /* which takes precedence over framing errors */
-        if (line_status & UART_BREAK_ERROR)
-                tty_flag = TTY_BREAK;
-        else if (line_status & UART_PARITY_ERROR)
-                tty_flag = TTY_PARITY;
-        else if (line_status & UART_FRAME_ERROR)
-                tty_flag = TTY_FRAME;
-        dbg("%s - tty_flag = %d", __func__, tty_flag);
-
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length + 1);
-                /* overrun is special, not associated with a char */
-                if (line_status & UART_OVERRUN_ERROR)
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                for (i = 0; i < urb->actual_length; ++i)
-                        if (!usb_serial_handle_sysrq_char(port, data[i]))
-                                tty_insert_flip_char(tty, data[i], tty_flag);
-                tty_flip_buffer_push(tty);
+                pl2303_push_data(tty, port, urb, line_status);
         }
         tty_kref_put(tty);
         /* Schedule the next read _if_ we are still open */
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index d595aa5586a7..a84216464ca0 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -333,6 +333,9 @@ static void serial_close(struct tty_struct *tty, struct file *filp)
 {
         struct usb_serial_port *port = tty->driver_data;
 
+        if (!port)
+                return;
+
         dbg("%s - port %d", __func__, port->number);
 
 
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index d6d65ef85f54..41296a6807e2 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -616,6 +616,8 @@ config FB_STI
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
+        select STI_CONSOLE
+        select VT
         default y
         ---help---
           STI refers to the HP "Standard Text Interface" which is a set of
@@ -933,7 +935,7 @@ config FB_S1D13XXX
 
 config FB_ATMEL
         tristate "AT91/AT32 LCD Controller support"
-        depends on FB && (ARCH_AT91SAM9261 || ARCH_AT91SAM9263 || ARCH_AT91SAM9RL || ARCH_AT91CAP9 || AVR32)
+        depends on FB && (ARCH_AT91SAM9261 || ARCH_AT91SAM9G10 || ARCH_AT91SAM9263 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45 || ARCH_AT91CAP9 || AVR32)
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -949,7 +951,7 @@ config FB_INTSRAM
 
 config FB_ATMEL_STN
         bool "Use a STN display with AT91/AT32 LCD Controller"
-        depends on FB_ATMEL && MACH_AT91SAM9261EK
+        depends on FB_ATMEL && (MACH_AT91SAM9261EK || MACH_AT91SAM9G10EK)
         default n
         help
           Say Y if you want to connect a STN LCD display to the AT91/AT32 LCD
diff --git a/drivers/video/amba-clcd.c b/drivers/video/amba-clcd.c
index fb8163d181ab..a21efcd10b78 100644
--- a/drivers/video/amba-clcd.c
+++ b/drivers/video/amba-clcd.c
@@ -226,9 +226,10 @@ static int clcdfb_set_par(struct fb_info *info)
         clcdfb_enable(fb, regs.cntl);
 
 #ifdef DEBUG
-        printk(KERN_INFO "CLCD: Registers set to\n"
-               KERN_INFO "  %08x %08x %08x %08x\n"
-               KERN_INFO "  %08x %08x %08x %08x\n",
+        printk(KERN_INFO
+               "CLCD: Registers set to\n"
+               "  %08x %08x %08x %08x\n"
+               "  %08x %08x %08x %08x\n",
                 readl(fb->regs + CLCD_TIM0), readl(fb->regs + CLCD_TIM1),
                 readl(fb->regs + CLCD_TIM2), readl(fb->regs + CLCD_TIM3),
                 readl(fb->regs + CLCD_UBAS), readl(fb->regs + CLCD_LBAS),
diff --git a/drivers/video/atafb.c b/drivers/video/atafb.c
index 018850c116c6..8cd279be74e5 100644
--- a/drivers/video/atafb.c
+++ b/drivers/video/atafb.c
@@ -2405,6 +2405,9 @@ static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
         return 0;
 }
 
+/* fbhw->encode_fix() must be called with fb_info->mm_lock held
+ * if it is called after the register_framebuffer() - not a case here
+ */
 static int atafb_get_fix(struct fb_fix_screeninfo *fix, struct fb_info *info)
 {
         struct atafb_par par;
@@ -2414,7 +2417,8 @@ static int atafb_get_fix(struct fb_fix_screeninfo *fix, struct fb_info *info)
         if (err)
                 return err;
         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
-        return fbhw->encode_fix(fix, &par);
+        err = fbhw->encode_fix(fix, &par);
+        return err;
 }
 
 static int atafb_get_var(struct fb_var_screeninfo *var, struct fb_info *info)
@@ -2743,7 +2747,9 @@ static int atafb_set_par(struct fb_info *info)
 
         /* Decode wanted screen parameters */
         fbhw->decode_var(&info->var, par);
+        mutex_lock(&info->mm_lock);
         fbhw->encode_fix(&info->fix, par);
+        mutex_unlock(&info->mm_lock);
 
         /* Set new videomode */
         ata_set_par(par);
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 5afd64482f55..2830ffd72976 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -182,7 +182,8 @@ static unsigned long compute_hozval(unsigned long xres, unsigned long lcdcon2)
 {
         unsigned long value;
 
-        if (!(cpu_is_at91sam9261() || cpu_is_at32ap7000()))
+        if (!(cpu_is_at91sam9261() || cpu_is_at91sam9g10()
+                || cpu_is_at32ap7000()))
                 return xres;
 
         value = xres;
@@ -261,6 +262,9 @@ static inline void atmel_lcdfb_free_video_memory(struct atmel_lcdfb_info *sinfo)
 /**
  *      atmel_lcdfb_alloc_video_memory - Allocate framebuffer memory
  *      @sinfo: the frame buffer to allocate memory for
+ *      
+ *      This function is called only from the atmel_lcdfb_probe()
+ *      so no locking by fb_info->mm_lock around smem_len setting is needed.
  */
 static int atmel_lcdfb_alloc_video_memory(struct atmel_lcdfb_info *sinfo)
 {
@@ -821,7 +825,8 @@ static int __init atmel_lcdfb_probe(struct platform_device *pdev)
         info->fix = atmel_lcdfb_fix;
 
         /* Enable LCDC Clocks */
-        if (cpu_is_at91sam9261() || cpu_is_at32ap7000()) {
+        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()
+         || cpu_is_at32ap7000()) {
                 sinfo->bus_clk = clk_get(dev, "hck1");
                 if (IS_ERR(sinfo->bus_clk)) {
                         ret = PTR_ERR(sinfo->bus_clk);
diff --git a/drivers/video/aty/atyfb.h b/drivers/video/aty/atyfb.h
index 7691e73823d3..1f39a62f899b 100644
--- a/drivers/video/aty/atyfb.h
+++ b/drivers/video/aty/atyfb.h
@@ -187,6 +187,8 @@ struct atyfb_par {
         int mtrr_reg;
 #endif
         u32 mem_cntl;
+        struct crtc saved_crtc;
+        union aty_pll saved_pll;
 };
 
     /*
@@ -217,6 +219,7 @@ struct atyfb_par {
 #define M64F_XL_DLL             0x00080000
 #define M64F_MFB_FORCE_4        0x00100000
 #define M64F_HW_TRIPLE          0x00200000
+#define M64F_XL_MEM             0x00400000
     /*
      *  Register access
      */
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 1207c208a30b..63d3739d43a8 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -66,6 +66,8 @@
 #include <linux/spinlock.h>
 #include <linux/wait.h>
 #include <linux/backlight.h>
+#include <linux/reboot.h>
+#include <linux/dmi.h>
 
 #include <asm/io.h>
 #include <linux/uaccess.h>
@@ -249,8 +251,6 @@ static int aty_init(struct fb_info *info);
 static int store_video_par(char *videopar, unsigned char m64_num);
 #endif
 
-static struct crtc saved_crtc;
-static union aty_pll saved_pll;
 static void aty_get_crtc(const struct atyfb_par *par, struct crtc *crtc);
 
 static void aty_set_crtc(const struct atyfb_par *par, const struct crtc *crtc);
@@ -261,6 +261,8 @@ static void set_off_pitch(struct atyfb_par *par, const struct fb_info *info);
 static int read_aty_sense(const struct atyfb_par *par);
 #endif
 
+static DEFINE_MUTEX(reboot_lock);
+static struct fb_info *reboot_info;
 
     /*
      *  Interface used by the world
@@ -361,8 +363,8 @@ static unsigned long phys_guiregbase[FB_MAX] __devinitdata = { 0, };
 #define ATI_CHIP_264GTPRO  (ATI_MODERN_SET | M64F_SDRAM_MAGIC_PLL | M64F_HW_TRIPLE | M64F_FIFO_32 | M64F_RESET_3D)
 #define ATI_CHIP_264LTPRO  (ATI_MODERN_SET | M64F_HW_TRIPLE | M64F_FIFO_32 | M64F_RESET_3D)
 
-#define ATI_CHIP_264XL     (ATI_MODERN_SET | M64F_HW_TRIPLE | M64F_FIFO_32 | M64F_RESET_3D | M64F_XL_DLL | M64F_MFB_FORCE_4)
-#define ATI_CHIP_MOBILITY  (ATI_MODERN_SET | M64F_HW_TRIPLE | M64F_FIFO_32 | M64F_RESET_3D | M64F_XL_DLL | M64F_MFB_FORCE_4 | M64F_MOBIL_BUS)
+#define ATI_CHIP_264XL     (ATI_MODERN_SET | M64F_HW_TRIPLE | M64F_FIFO_32 | M64F_RESET_3D | M64F_XL_DLL | M64F_MFB_FORCE_4 | M64F_XL_MEM)
+#define ATI_CHIP_MOBILITY  (ATI_MODERN_SET | M64F_HW_TRIPLE | M64F_FIFO_32 | M64F_RESET_3D | M64F_XL_DLL | M64F_MFB_FORCE_4 | M64F_XL_MEM | M64F_MOBIL_BUS)
 
 static struct {
         u16 pci_id;
@@ -539,6 +541,7 @@ static char ram_edo[] __devinitdata = "EDO";
 static char ram_sdram[] __devinitdata = "SDRAM (1:1)";
 static char ram_sgram[] __devinitdata = "SGRAM (1:1)";
 static char ram_sdram32[] __devinitdata = "SDRAM (2:1) (32-bit)";
+static char ram_wram[] __devinitdata = "WRAM";
 static char ram_off[] __devinitdata = "OFF";
 #endif /* CONFIG_FB_ATY_CT */
 
@@ -553,6 +556,10 @@ static char *aty_gx_ram[8] __devinitdata = {
 #ifdef CONFIG_FB_ATY_CT
 static char *aty_ct_ram[8] __devinitdata = {
         ram_off, ram_dram, ram_edo, ram_edo,
+        ram_sdram, ram_sgram, ram_wram, ram_resv
+};
+static char *aty_xl_ram[8] __devinitdata = {
+        ram_off, ram_dram, ram_edo, ram_edo,
         ram_sdram, ram_sgram, ram_sdram32, ram_resv
 };
 #endif /* CONFIG_FB_ATY_CT */
@@ -760,6 +767,17 @@ static void aty_set_crtc(const struct atyfb_par *par, const struct crtc *crtc)
 #endif /* CONFIG_FB_ATY_GENERIC_LCD */
 }
 
+static u32 calc_line_length(struct atyfb_par *par, u32 vxres, u32 bpp)
+{
+        u32 line_length = vxres * bpp / 8;
+
+        if (par->ram_type == SGRAM ||
+            (!M64_HAS(XL_MEM) && par->ram_type == WRAM))
+                line_length = (line_length + 63) & ~63;
+
+        return line_length;
+}
+
 static int aty_var_to_crtc(const struct fb_info *info,
         const struct fb_var_screeninfo *var, struct crtc *crtc)
 {
@@ -769,13 +787,14 @@ static int aty_var_to_crtc(const struct fb_info *info,
         u32 h_total, h_disp, h_sync_strt, h_sync_end, h_sync_dly, h_sync_wid, h_sync_pol;
         u32 v_total, v_disp, v_sync_strt, v_sync_end, v_sync_wid, v_sync_pol, c_sync;
         u32 pix_width, dp_pix_width, dp_chain_mask;
+        u32 line_length;
 
         /* input */
-        xres = var->xres;
+        xres = (var->xres + 7) & ~7;
         yres = var->yres;
-        vxres = var->xres_virtual;
+        vxres = (var->xres_virtual + 7) & ~7;
         vyres = var->yres_virtual;
-        xoffset = var->xoffset;
+        xoffset = (var->xoffset + 7) & ~7;
         yoffset = var->yoffset;
         bpp = var->bits_per_pixel;
         if (bpp == 16)
@@ -827,7 +846,9 @@ static int aty_var_to_crtc(const struct fb_info *info,
         } else
                 FAIL("invalid bpp");
 
-        if (vxres * vyres * bpp / 8 > info->fix.smem_len)
+        line_length = calc_line_length(par, vxres, bpp);
+
+        if (vyres * line_length > info->fix.smem_len)
                 FAIL("not enough video RAM");
 
         h_sync_pol = sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
@@ -969,7 +990,9 @@ static int aty_var_to_crtc(const struct fb_info *info,
         crtc->xoffset = xoffset;
         crtc->yoffset = yoffset;
         crtc->bpp = bpp;
-        crtc->off_pitch = ((yoffset*vxres+xoffset)*bpp/64) | (vxres<<19);
+        crtc->off_pitch =
+                ((yoffset * line_length + xoffset * bpp / 8) / 8) |
+                ((line_length / bpp) << 22);
         crtc->vline_crnt_vline = 0;
 
         crtc->h_tot_disp = h_total | (h_disp<<16);
@@ -1394,7 +1417,9 @@ static int atyfb_set_par(struct fb_info *info)
         }
         aty_st_8(DAC_MASK, 0xff, par);
 
-        info->fix.line_length = var->xres_virtual * var->bits_per_pixel/8;
+        info->fix.line_length = calc_line_length(par, var->xres_virtual,
+                                                 var->bits_per_pixel);
+
         info->fix.visual = var->bits_per_pixel <= 8 ?
                 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
 
@@ -1505,10 +1530,12 @@ static void set_off_pitch(struct atyfb_par *par, const struct fb_info *info)
 {
         u32 xoffset = info->var.xoffset;
         u32 yoffset = info->var.yoffset;
-        u32 vxres = par->crtc.vxres;
+        u32 line_length = info->fix.line_length;
         u32 bpp = info->var.bits_per_pixel;
 
-        par->crtc.off_pitch = ((yoffset * vxres + xoffset) * bpp / 64) | (vxres << 19);
+        par->crtc.off_pitch =
+                ((yoffset * line_length + xoffset * bpp / 8) / 8) |
+                ((line_length / bpp) << 22);
 }
 
 
@@ -2201,7 +2228,7 @@ static void __devinit aty_calc_mem_refresh(struct atyfb_par *par, int xclk)
         const int *refresh_tbl;
         int i, size;
 
-        if (IS_XL(par->pci_id) || IS_MOBILITY(par->pci_id)) {
+        if (M64_HAS(XL_MEM)) {
                 refresh_tbl = ragexl_tbl;
                 size = ARRAY_SIZE(ragexl_tbl);
         } else {
@@ -2335,7 +2362,10 @@ static int __devinit aty_init(struct fb_info *info)
                 par->pll_ops = &aty_pll_ct;
                 par->bus_type = PCI;
                 par->ram_type = (aty_ld_le32(CNFG_STAT0, par) & 0x07);
-                ramname = aty_ct_ram[par->ram_type];
+                if (M64_HAS(XL_MEM))
+                        ramname = aty_xl_ram[par->ram_type];
+                else
+                        ramname = aty_ct_ram[par->ram_type];
                 /* for many chips, the mclk is 67 MHz for SDRAM, 63 MHz otherwise */
                 if (par->pll_limits.mclk == 67 && par->ram_type < SDRAM)
                         par->pll_limits.mclk = 63;
@@ -2390,9 +2420,9 @@ static int __devinit aty_init(struct fb_info *info)
 #endif /* CONFIG_FB_ATY_CT */
 
         /* save previous video mode */
-        aty_get_crtc(par, &saved_crtc);
+        aty_get_crtc(par, &par->saved_crtc);
         if(par->pll_ops->get_pll)
-                par->pll_ops->get_pll(info, &saved_pll);
+                par->pll_ops->get_pll(info, &par->saved_pll);
 
         par->mem_cntl = aty_ld_le32(MEM_CNTL, par);
         gtb_memsize = M64_HAS(GTB_DSP);
@@ -2667,8 +2697,8 @@ static int __devinit aty_init(struct fb_info *info)
 
 aty_init_exit:
         /* restore video mode */
-        aty_set_crtc(par, &saved_crtc);
-        par->pll_ops->set_pll(info, &saved_pll);
+        aty_set_crtc(par, &par->saved_crtc);
+        par->pll_ops->set_pll(info, &par->saved_pll);
 
 #ifdef CONFIG_MTRR
         if (par->mtrr_reg >= 0) {
@@ -3502,6 +3532,11 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         par->mmap_map[1].prot_flag = _PAGE_E;
 #endif /* __sparc__ */
 
+        mutex_lock(&reboot_lock);
+        if (!reboot_info)
+                reboot_info = info;
+        mutex_unlock(&reboot_lock);
+
         return 0;
 
 err_release_io:
@@ -3614,8 +3649,8 @@ static void __devexit atyfb_remove(struct fb_info *info)
         struct atyfb_par *par = (struct atyfb_par *) info->par;
 
         /* restore video mode */
-        aty_set_crtc(par, &saved_crtc);
-        par->pll_ops->set_pll(info, &saved_pll);
+        aty_set_crtc(par, &par->saved_crtc);
+        par->pll_ops->set_pll(info, &par->saved_pll);
 
         unregister_framebuffer(info);
 
@@ -3661,6 +3696,11 @@ static void __devexit atyfb_pci_remove(struct pci_dev *pdev)
 {
         struct fb_info *info = pci_get_drvdata(pdev);
 
+        mutex_lock(&reboot_lock);
+        if (reboot_info == info)
+                reboot_info = NULL;
+        mutex_unlock(&reboot_lock);
+
         atyfb_remove(info);
 }
 
@@ -3808,6 +3848,56 @@ static int __init atyfb_setup(char *options)
 }
 #endif  /*  MODULE  */
 
+static int atyfb_reboot_notify(struct notifier_block *nb,
+                               unsigned long code, void *unused)
+{
+        struct atyfb_par *par;
+
+        if (code != SYS_RESTART)
+                return NOTIFY_DONE;
+
+        mutex_lock(&reboot_lock);
+
+        if (!reboot_info)
+                goto out;
+
+        if (!lock_fb_info(reboot_info))
+                goto out;
+
+        par = reboot_info->par;
+
+        /*
+         * HP OmniBook 500's BIOS doesn't like the state of the
+         * hardware after atyfb has been used. Restore the hardware
+         * to the original state to allow successful reboots.
+         */
+        aty_set_crtc(par, &par->saved_crtc);
+        par->pll_ops->set_pll(reboot_info, &par->saved_pll);
+
+        unlock_fb_info(reboot_info);
+ out:
+        mutex_unlock(&reboot_lock);
+
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block atyfb_reboot_notifier = {
+        .notifier_call = atyfb_reboot_notify,
+};
+
+static const struct dmi_system_id atyfb_reboot_ids[] = {
+        {
+                .ident = "HP OmniBook 500",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "HP OmniBook PC"),
+                        DMI_MATCH(DMI_PRODUCT_VERSION, "HP OmniBook 500 FA"),
+                },
+        },
+
+        { }
+};
+
 static int __init atyfb_init(void)
 {
     int err1 = 1, err2 = 1;
@@ -3826,11 +3916,20 @@ static int __init atyfb_init(void)
     err2 = atyfb_atari_probe();
 #endif
 
-    return (err1 && err2) ? -ENODEV : 0;
+    if (err1 && err2)
+        return -ENODEV;
+
+    if (dmi_check_system(atyfb_reboot_ids))
+        register_reboot_notifier(&atyfb_reboot_notifier);
+
+    return 0;
 }
 
 static void __exit atyfb_exit(void)
 {
+        if (dmi_check_system(atyfb_reboot_ids))
+                unregister_reboot_notifier(&atyfb_reboot_notifier);
+
 #ifdef CONFIG_PCI
         pci_unregister_driver(&atyfb_driver);
 #endif
diff --git a/drivers/video/aty/mach64_accel.c b/drivers/video/aty/mach64_accel.c
index 0cc9724e61a2..51fcc0a2c94a 100644
--- a/drivers/video/aty/mach64_accel.c
+++ b/drivers/video/aty/mach64_accel.c
@@ -63,14 +63,17 @@ static void reset_GTC_3D_engine(const struct atyfb_par *par)
 void aty_init_engine(struct atyfb_par *par, struct fb_info *info)
 {
         u32 pitch_value;
+        u32 vxres;
 
         /* determine modal information from global mode structure */
-        pitch_value = info->var.xres_virtual;
+        pitch_value = info->fix.line_length / (info->var.bits_per_pixel / 8);
+        vxres = info->var.xres_virtual;
 
         if (info->var.bits_per_pixel == 24) {
                 /* In 24 bpp, the engine is in 8 bpp - this requires that all */
                 /* horizontal coordinates and widths must be adjusted */
                 pitch_value *= 3;
+                vxres *= 3;
         }
 
         /* On GTC (RagePro), we need to reset the 3D engine before */
@@ -133,7 +136,7 @@ void aty_init_engine(struct atyfb_par *par, struct fb_info *info)
         aty_st_le32(SC_LEFT, 0, par);
         aty_st_le32(SC_TOP, 0, par);
         aty_st_le32(SC_BOTTOM, par->crtc.vyres - 1, par);
-        aty_st_le32(SC_RIGHT, pitch_value - 1, par);
+        aty_st_le32(SC_RIGHT, vxres - 1, par);
 
         /* set background color to minimum value (usually BLACK) */
         aty_st_le32(DP_BKGD_CLR, 0, par);
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index f9d19be05540..90861cd93165 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -110,7 +110,7 @@ config BACKLIGHT_CLASS_DEVICE
 config BACKLIGHT_ATMEL_LCDC
         bool "Atmel LCDC Contrast-as-Backlight control"
         depends on BACKLIGHT_CLASS_DEVICE && FB_ATMEL
-        default y if MACH_SAM9261EK || MACH_SAM9263EK
+        default y if MACH_SAM9261EK || MACH_SAM9G10EK || MACH_SAM9263EK
         help
           This provides a backlight control internal to the Atmel LCDC
           driver.  If the LCD "contrast control" on your board is wired
diff --git a/drivers/video/backlight/tdo24m.c b/drivers/video/backlight/tdo24m.c
index 1dae7f8f3c6b..51422fc4f606 100644
--- a/drivers/video/backlight/tdo24m.c
+++ b/drivers/video/backlight/tdo24m.c
@@ -356,7 +356,7 @@ static int __devinit tdo24m_probe(struct spi_device *spi)
         lcd->power = FB_BLANK_POWERDOWN;
         lcd->mode = MODE_VGA;   /* default to VGA */
 
-        lcd->buf = kmalloc(TDO24M_SPI_BUFF_SIZE, sizeof(GFP_KERNEL));
+        lcd->buf = kmalloc(TDO24M_SPI_BUFF_SIZE, GFP_KERNEL);
         if (lcd->buf == NULL) {
                 kfree(lcd);
                 return -ENOMEM;
diff --git a/drivers/video/cobalt_lcdfb.c b/drivers/video/cobalt_lcdfb.c
index 7bad24ed04ef..108b89e09a80 100644
--- a/drivers/video/cobalt_lcdfb.c
+++ b/drivers/video/cobalt_lcdfb.c
@@ -1,7 +1,7 @@
 /*
  *  Cobalt server LCD frame buffer driver.
  *
- *  Copyright (C) 2008  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *  Copyright (C) 2008  Yoichi Yuasa <yuasa@linux-mips.org>
  *
  *  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
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index f8a09bf8d0cd..53ea05645ff8 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1310,8 +1310,6 @@ static long fb_compat_ioctl(struct file *file, unsigned int cmd,
 
 static int
 fb_mmap(struct file *file, struct vm_area_struct * vma)
-__acquires(&info->lock)
-__releases(&info->lock)
 {
         int fbidx = iminor(file->f_path.dentry->d_inode);
         struct fb_info *info = registered_fb[fbidx];
@@ -1325,16 +1323,14 @@ __releases(&info->lock)
         off = vma->vm_pgoff << PAGE_SHIFT;
         if (!fb)
                 return -ENODEV;
+        mutex_lock(&info->mm_lock);
         if (fb->fb_mmap) {
                 int res;
-                mutex_lock(&info->lock);
                 res = fb->fb_mmap(info, vma);
-                mutex_unlock(&info->lock);
+                mutex_unlock(&info->mm_lock);
                 return res;
         }
 
-        mutex_lock(&info->lock);
-
         /* frame buffer memory */
         start = info->fix.smem_start;
         len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len);
@@ -1342,13 +1338,13 @@ __releases(&info->lock)
                 /* memory mapped io */
                 off -= len;
                 if (info->var.accel_flags) {
-                        mutex_unlock(&info->lock);
+                        mutex_unlock(&info->mm_lock);
                         return -EINVAL;
                 }
                 start = info->fix.mmio_start;
                 len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
         }
-        mutex_unlock(&info->lock);
+        mutex_unlock(&info->mm_lock);
         start &= PAGE_MASK;
         if ((vma->vm_end - vma->vm_start + off) > len)
                 return -EINVAL;
@@ -1518,6 +1514,7 @@ register_framebuffer(struct fb_info *fb_info)
                         break;
         fb_info->node = i;
         mutex_init(&fb_info->lock);
+        mutex_init(&fb_info->mm_lock);
 
         fb_info->dev = device_create(fb_class, fb_info->device,
                                      MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index f153c581cbd7..72d68b3dc478 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -750,24 +750,26 @@ static void update_lcdc(struct fb_info *info)
 static int map_video_memory(struct fb_info *info)
 {
         phys_addr_t phys;
+        u32 smem_len = info->fix.line_length * info->var.yres_virtual;
 
         pr_debug("info->var.xres_virtual = %d\n", info->var.xres_virtual);
         pr_debug("info->var.yres_virtual = %d\n", info->var.yres_virtual);
         pr_debug("info->fix.line_length  = %d\n", info->fix.line_length);
+        pr_debug("MAP_VIDEO_MEMORY: smem_len = %u\n", smem_len);
 
-        info->fix.smem_len = info->fix.line_length * info->var.yres_virtual;
-        pr_debug("MAP_VIDEO_MEMORY: smem_len = %d\n", info->fix.smem_len);
-        info->screen_base = fsl_diu_alloc(info->fix.smem_len, &phys);
+        info->screen_base = fsl_diu_alloc(smem_len, &phys);
         if (info->screen_base == NULL) {
                 printk(KERN_ERR "Unable to allocate fb memory\n");
                 return -ENOMEM;
         }
+        mutex_lock(&info->mm_lock);
         info->fix.smem_start = (unsigned long) phys;
+        info->fix.smem_len = smem_len;
+        mutex_unlock(&info->mm_lock);
         info->screen_size = info->fix.smem_len;
 
         pr_debug("Allocated fb @ paddr=0x%08lx, size=%d.\n",
-                                info->fix.smem_start,
-                info->fix.smem_len);
+                 info->fix.smem_start, info->fix.smem_len);
         pr_debug("screen base %p\n", info->screen_base);
 
         return 0;
@@ -776,9 +778,11 @@ static int map_video_memory(struct fb_info *info)
 static void unmap_video_memory(struct fb_info *info)
 {
         fsl_diu_free(info->screen_base, info->fix.smem_len);
+        mutex_lock(&info->mm_lock);
         info->screen_base = NULL;
         info->fix.smem_start = 0;
         info->fix.smem_len = 0;
+        mutex_unlock(&info->mm_lock);
 }
 
 /*
@@ -1219,12 +1223,6 @@ static int __devinit install_fb(struct fb_info *info)
                 return -EINVAL;
         }
 
-        if (fsl_diu_set_par(info)) {
-                printk(KERN_ERR "fb_set_par failed");
-                fb_dealloc_cmap(&info->cmap);
-                return -EINVAL;
-        }
-
         if (register_framebuffer(info) < 0) {
                 printk(KERN_ERR "register_framebuffer failed");
                 unmap_video_memory(info);
diff --git a/drivers/video/hitfb.c b/drivers/video/hitfb.c
index 020db7fc9153..e7116a6d82d3 100644
--- a/drivers/video/hitfb.c
+++ b/drivers/video/hitfb.c
@@ -44,9 +44,6 @@ static struct fb_fix_screeninfo hitfb_fix __initdata = {
         .accel          = FB_ACCEL_NONE,
 };
 
-static u32 pseudo_palette[16];
-static struct fb_info fb_info;
-
 static inline void hitfb_accel_wait(void)
 {
         while (fb_readw(HD64461_GRCFGR) & HD64461_GRCFGR_ACCSTATUS) ;
@@ -331,6 +328,8 @@ static struct fb_ops hitfb_ops = {
 static int __init hitfb_probe(struct platform_device *dev)
 {
         unsigned short lcdclor, ldr3, ldvndr;
+        struct fb_info *info;
+        int ret;
 
         if (fb_get_options("hitfb", NULL))
                 return -ENODEV;
@@ -384,32 +383,53 @@ static int __init hitfb_probe(struct platform_device *dev)
                 break;
         }
 
-        fb_info.fbops = &hitfb_ops;
-        fb_info.var = hitfb_var;
-        fb_info.fix = hitfb_fix;
-        fb_info.pseudo_palette = pseudo_palette;
-        fb_info.flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN |
+        info = framebuffer_alloc(sizeof(u32) * 16, &dev->dev);
+        if (unlikely(!info))
+                return -ENOMEM;
+
+        info->fbops = &hitfb_ops;
+        info->var = hitfb_var;
+        info->fix = hitfb_fix;
+        info->pseudo_palette = info->par;
+        info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN |
                 FBINFO_HWACCEL_FILLRECT | FBINFO_HWACCEL_COPYAREA;
 
-        fb_info.screen_base = (void *)hitfb_fix.smem_start;
+        info->screen_base = (void *)hitfb_fix.smem_start;
 
-        fb_alloc_cmap(&fb_info.cmap, 256, 0);
+        ret = fb_alloc_cmap(&info->cmap, 256, 0);
+        if (unlikely(ret < 0))
+                goto err_fb;
 
-        if (register_framebuffer(&fb_info) < 0)
-                return -EINVAL;
+        ret = register_framebuffer(info);
+        if (unlikely(ret < 0))
+                goto err;
+
+        platform_set_drvdata(dev, info);
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n",
-               fb_info.node, fb_info.fix.id);
+               info->node, info->fix.id);
+
         return 0;
+
+err:
+        fb_dealloc_cmap(&info->cmap);
+err_fb:
+        framebuffer_release(info);
+        return ret;
 }
 
 static int __exit hitfb_remove(struct platform_device *dev)
 {
-        return unregister_framebuffer(&fb_info);
+        struct fb_info *info = platform_get_drvdata(dev);
+
+        unregister_framebuffer(info);
+        fb_dealloc_cmap(&info->cmap);
+        framebuffer_release(info);
+
+        return 0;
 }
 
-#ifdef CONFIG_PM
-static int hitfb_suspend(struct platform_device *dev, pm_message_t state)
+static int hitfb_suspend(struct device *dev)
 {
         u16 v;
 
@@ -421,7 +441,7 @@ static int hitfb_suspend(struct platform_device *dev, pm_message_t state)
         return 0;
 }
 
-static int hitfb_resume(struct platform_device *dev)
+static int hitfb_resume(struct device *dev)
 {
         u16 v;
 
@@ -435,17 +455,19 @@ static int hitfb_resume(struct platform_device *dev)
 
         return 0;
 }
-#endif
+
+static struct dev_pm_ops hitfb_dev_pm_ops = {
+        .suspend        = hitfb_suspend,
+        .resume         = hitfb_resume,
+};
 
 static struct platform_driver hitfb_driver = {
         .probe          = hitfb_probe,
         .remove         = __exit_p(hitfb_remove),
-#ifdef CONFIG_PM
-        .suspend        = hitfb_suspend,
-        .resume         = hitfb_resume,
-#endif
         .driver         = {
                 .name   = "hitfb",
+                .owner  = THIS_MODULE,
+                .pm     = &hitfb_dev_pm_ops,
         },
 };
 
diff --git a/drivers/video/i810/i810_main.c b/drivers/video/i810/i810_main.c
index 2e940199fc89..5743ea25e818 100644
--- a/drivers/video/i810/i810_main.c
+++ b/drivers/video/i810/i810_main.c
@@ -1090,8 +1090,10 @@ static int encode_fix(struct fb_fix_screeninfo *fix, struct fb_info *info)
         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
 
         strcpy(fix->id, "I810");
+        mutex_lock(&info->mm_lock);
         fix->smem_start = par->fb.physical;
         fix->smem_len = par->fb.size;
+        mutex_unlock(&info->mm_lock);
         fix->type = FB_TYPE_PACKED_PIXELS;
         fix->type_aux = 0;
         fix->xpanstep = 8;
@@ -2058,8 +2060,7 @@ static int __devinit i810fb_init_pci (struct pci_dev *dev,
 
         fb_var_to_videomode(&mode, &info->var);
         fb_add_videomode(&mode, &info->modelist);
-        encode_fix(&info->fix, info); 
-                    
+
         i810fb_init_ringbuffer(info);
         err = register_framebuffer(info);
 
diff --git a/drivers/video/matrox/matroxfb_DAC1064.c b/drivers/video/matrox/matroxfb_DAC1064.c
index 0ce3b0a89798..a74e5da17aa0 100644
--- a/drivers/video/matrox/matroxfb_DAC1064.c
+++ b/drivers/video/matrox/matroxfb_DAC1064.c
@@ -454,9 +454,9 @@ static void DAC1064_restore_2(WPMINFO2) {
         dprintk(KERN_DEBUG "DAC1064regs ");
         for (i = 0; i < sizeof(MGA1064_DAC_regs); i++) {
                 dprintk("R%02X=%02X ", MGA1064_DAC_regs[i], ACCESS_FBINFO(hw).DACreg[i]);
-                if ((i & 0x7) == 0x7) dprintk("\n" KERN_DEBUG "continuing... ");
+                if ((i & 0x7) == 0x7) dprintk(KERN_DEBUG "continuing... ");
         }
-        dprintk("\n" KERN_DEBUG "DAC1064clk ");
+        dprintk(KERN_DEBUG "DAC1064clk ");
         for (i = 0; i < 6; i++)
                 dprintk("C%02X=%02X ", i, ACCESS_FBINFO(hw).DACclk[i]);
         dprintk("\n");
diff --git a/drivers/video/matrox/matroxfb_Ti3026.c b/drivers/video/matrox/matroxfb_Ti3026.c
index 13524821e242..4e825112a601 100644
--- a/drivers/video/matrox/matroxfb_Ti3026.c
+++ b/drivers/video/matrox/matroxfb_Ti3026.c
@@ -651,9 +651,9 @@ static void Ti3026_restore(WPMINFO2) {
         dprintk(KERN_DEBUG "3026DACregs ");
         for (i = 0; i < 21; i++) {
                 dprintk("R%02X=%02X ", DACseq[i], hw->DACreg[i]);
-                if ((i & 0x7) == 0x7) dprintk("\n" KERN_DEBUG "continuing... ");
+                if ((i & 0x7) == 0x7) dprintk(KERN_DEBUG "continuing... ");
         }
-        dprintk("\n" KERN_DEBUG "DACclk ");
+        dprintk(KERN_DEBUG "DACclk ");
         for (i = 0; i < 6; i++)
                 dprintk("C%02X=%02X ", i, hw->DACclk[i]);
         dprintk("\n");
diff --git a/drivers/video/matrox/matroxfb_base.c b/drivers/video/matrox/matroxfb_base.c
index 8e7a275df50c..0c1049b308bf 100644
--- a/drivers/video/matrox/matroxfb_base.c
+++ b/drivers/video/matrox/matroxfb_base.c
@@ -724,8 +724,10 @@ static void matroxfb_update_fix(WPMINFO2)
         struct fb_fix_screeninfo *fix = &ACCESS_FBINFO(fbcon).fix;
         DBG(__func__)
 
+        mutex_lock(&ACCESS_FBINFO(fbcon).mm_lock);
         fix->smem_start = ACCESS_FBINFO(video.base) + ACCESS_FBINFO(curr.ydstorg.bytes);
         fix->smem_len = ACCESS_FBINFO(video.len_usable) - ACCESS_FBINFO(curr.ydstorg.bytes);
+        mutex_unlock(&ACCESS_FBINFO(fbcon).mm_lock);
 }
 
 static int matroxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
@@ -1874,7 +1876,6 @@ static int initMatrox2(WPMINFO struct board* b){
         }
         matroxfb_init_fix(PMINFO2);
         ACCESS_FBINFO(fbcon.screen_base) = vaddr_va(ACCESS_FBINFO(video.vbase));
-        matroxfb_update_fix(PMINFO2);
         /* Normalize values (namely yres_virtual) */
         matroxfb_check_var(&vesafb_defined, &ACCESS_FBINFO(fbcon));
         /* And put it into "current" var. Do NOT program hardware yet, or we'll not take over
@@ -2081,6 +2082,7 @@ static int matroxfb_probe(struct pci_dev* pdev, const struct pci_device_id* dumm
         spin_lock_init(&ACCESS_FBINFO(lock.accel));
         init_rwsem(&ACCESS_FBINFO(crtc2.lock));
         init_rwsem(&ACCESS_FBINFO(altout.lock));
+        mutex_init(&ACCESS_FBINFO(fbcon).mm_lock);
         ACCESS_FBINFO(irq_flags) = 0;
         init_waitqueue_head(&ACCESS_FBINFO(crtc1.vsync.wait));
         init_waitqueue_head(&ACCESS_FBINFO(crtc2.vsync.wait));
diff --git a/drivers/video/matrox/matroxfb_crtc2.c b/drivers/video/matrox/matroxfb_crtc2.c
index 7ac4c5f6145d..ebcb5c6b4962 100644
--- a/drivers/video/matrox/matroxfb_crtc2.c
+++ b/drivers/video/matrox/matroxfb_crtc2.c
@@ -289,7 +289,12 @@ static int matroxfb_dh_release(struct fb_info* info, int user) {
 #undef m2info
 }
 
-static void matroxfb_dh_init_fix(struct matroxfb_dh_fb_info *m2info) {
+/*
+ * This function is called before the register_framebuffer so
+ * no locking is needed.
+ */
+static void matroxfb_dh_init_fix(struct matroxfb_dh_fb_info *m2info)
+{
         struct fb_fix_screeninfo *fix = &m2info->fbcon.fix;
 
         strcpy(fix->id, "MATROX DH");
diff --git a/drivers/video/mx3fb.c b/drivers/video/mx3fb.c
index b7af5256e887..f8778cde2183 100644
--- a/drivers/video/mx3fb.c
+++ b/drivers/video/mx3fb.c
@@ -669,7 +669,7 @@ static uint32_t bpp_to_pixfmt(int bpp)
 }
 
 static int mx3fb_blank(int blank, struct fb_info *fbi);
-static int mx3fb_map_video_memory(struct fb_info *fbi);
+static int mx3fb_map_video_memory(struct fb_info *fbi, unsigned int mem_len);
 static int mx3fb_unmap_video_memory(struct fb_info *fbi);
 
 /**
@@ -742,8 +742,7 @@ static int mx3fb_set_par(struct fb_info *fbi)
                 if (fbi->fix.smem_start)
                         mx3fb_unmap_video_memory(fbi);
 
-                fbi->fix.smem_len = mem_len;
-                if (mx3fb_map_video_memory(fbi) < 0) {
+                if (mx3fb_map_video_memory(fbi, mem_len) < 0) {
                         mutex_unlock(&mx3_fbi->mutex);
                         return -ENOMEM;
                 }
@@ -1198,6 +1197,7 @@ static int mx3fb_resume(struct platform_device *pdev)
 /**
  * mx3fb_map_video_memory() - allocates the DRAM memory for the frame buffer.
  * @fbi:        framebuffer information pointer
+ * @mem_len:    length of mapped memory
  * @return:     Error code indicating success or failure
  *
  * This buffer is remapped into a non-cached, non-buffered, memory region to
@@ -1205,23 +1205,26 @@ static int mx3fb_resume(struct platform_device *pdev)
  * area is remapped, all virtual memory access to the video memory should occur
  * at the new region.
  */
-static int mx3fb_map_video_memory(struct fb_info *fbi)
+static int mx3fb_map_video_memory(struct fb_info *fbi, unsigned int mem_len)
 {
         int retval = 0;
         dma_addr_t addr;
 
         fbi->screen_base = dma_alloc_writecombine(fbi->device,
-                                                  fbi->fix.smem_len,
+                                                  mem_len,
                                                   &addr, GFP_DMA);
 
         if (!fbi->screen_base) {
                 dev_err(fbi->device, "Cannot allocate %u bytes framebuffer memory\n",
-                        fbi->fix.smem_len);
+                        mem_len);
                 retval = -EBUSY;
                 goto err0;
         }
 
+        mutex_lock(&fbi->mm_lock);
         fbi->fix.smem_start = addr;
+        fbi->fix.smem_len = mem_len;
+        mutex_unlock(&fbi->mm_lock);
 
         dev_dbg(fbi->device, "allocated fb @ p=0x%08x, v=0x%p, size=%d.\n",
                 (uint32_t) fbi->fix.smem_start, fbi->screen_base, fbi->fix.smem_len);
@@ -1251,8 +1254,10 @@ static int mx3fb_unmap_video_memory(struct fb_info *fbi)
                               fbi->screen_base, fbi->fix.smem_start);
 
         fbi->screen_base = 0;
+        mutex_lock(&fbi->mm_lock);
         fbi->fix.smem_start = 0;
         fbi->fix.smem_len = 0;
+        mutex_unlock(&fbi->mm_lock);
         return 0;
 }
 
@@ -1360,11 +1365,6 @@ static int init_fb_chan(struct mx3fb_data *mx3fb, struct idmac_channel *ichan)
         init_completion(&mx3fbi->flip_cmpl);
         disable_irq(ichan->eof_irq);
         dev_dbg(mx3fb->dev, "disabling irq %d\n", ichan->eof_irq);
-        ret = mx3fb_set_par(fbi);
-        if (ret < 0)
-                goto esetpar;
-
-        mx3fb_blank(FB_BLANK_UNBLANK, fbi);
 
         dev_info(dev, "registered, using mode %s\n", fb_mode);
 
diff --git a/drivers/video/omap/omapfb_main.c b/drivers/video/omap/omapfb_main.c
index 060d72fe57cb..4ea99bfc37b4 100644
--- a/drivers/video/omap/omapfb_main.c
+++ b/drivers/video/omap/omapfb_main.c
@@ -393,8 +393,10 @@ static void set_fb_fix(struct fb_info *fbi)
 
         rg = &plane->fbdev->mem_desc.region[plane->idx];
         fbi->screen_base        = rg->vaddr;
+        mutex_lock(&fbi->mm_lock);
         fix->smem_start         = rg->paddr;
         fix->smem_len           = rg->size;
+        mutex_unlock(&fbi->mm_lock);
 
         fix->type = FB_TYPE_PACKED_PIXELS;
         bpp = var->bits_per_pixel;
@@ -886,8 +888,10 @@ static int omapfb_setup_mem(struct fb_info *fbi, struct omapfb_mem_info *mi)
                                  * plane memory is dealloce'd, the other
                                  * screen parameters in var / fix are invalid.
                                  */
+                                mutex_lock(&fbi->mm_lock);
                                 fbi->fix.smem_start = 0;
                                 fbi->fix.smem_len = 0;
+                                mutex_unlock(&fbi->mm_lock);
                         }
                 }
         }
diff --git a/drivers/video/platinumfb.c b/drivers/video/platinumfb.c
index 03b3670130a0..bacfabd9ce16 100644
--- a/drivers/video/platinumfb.c
+++ b/drivers/video/platinumfb.c
@@ -141,7 +141,9 @@ static int platinumfb_set_par (struct fb_info *info)
                 offset = 0x10;
 
         info->screen_base = pinfo->frame_buffer + init->fb_offset + offset;
+        mutex_lock(&info->mm_lock);
         info->fix.smem_start = (pinfo->frame_buffer_phys) + init->fb_offset + offset;
+        mutex_unlock(&info->mm_lock);
         info->fix.visual = (pinfo->cmode == CMODE_8) ?
                 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
         info->fix.line_length = vmode_attrs[pinfo->vmode-1].hres * (1<<pinfo->cmode)
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 0889d50c3288..6506117c134b 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -815,8 +815,10 @@ static int overlayfb_map_video_memory(struct pxafb_layer *ofb)
         ofb->video_mem_phys = virt_to_phys(ofb->video_mem);
         ofb->video_mem_size = size;
 
+        mutex_lock(&ofb->fb.mm_lock);
         ofb->fb.fix.smem_start  = ofb->video_mem_phys;
         ofb->fb.fix.smem_len    = ofb->fb.fix.line_length * var->yres_virtual;
+        mutex_unlock(&ofb->fb.mm_lock);
         ofb->fb.screen_base     = ofb->video_mem;
         return 0;
 }
diff --git a/drivers/video/s3c-fb.c b/drivers/video/s3c-fb.c
index 43680e545427..bb63c07e13de 100644
--- a/drivers/video/s3c-fb.c
+++ b/drivers/video/s3c-fb.c
@@ -211,23 +211,21 @@ static int s3c_fb_check_var(struct fb_var_screeninfo *var,
 
 /**
  * s3c_fb_calc_pixclk() - calculate the divider to create the pixel clock.
+ * @id: window id.
  * @sfb: The hardware state.
  * @pixclock: The pixel clock wanted, in picoseconds.
  *
  * Given the specified pixel clock, work out the necessary divider to get
  * close to the output frequency.
  */
-static int s3c_fb_calc_pixclk(struct s3c_fb *sfb, unsigned int pixclk)
+static int s3c_fb_calc_pixclk(unsigned char id, struct s3c_fb *sfb, unsigned int pixclk)
 {
+        struct s3c_fb_pd_win *win = sfb->pdata->win[id];
         unsigned long clk = clk_get_rate(sfb->bus_clk);
-        unsigned long long tmp;
         unsigned int result;
 
-        tmp = (unsigned long long)clk;
-        tmp *= pixclk;
-
-        do_div(tmp, 1000000000UL);
-        result = (unsigned int)tmp / 1000;
+        pixclk *= win->win_mode.refresh;
+        result = clk / pixclk;
 
         dev_dbg(sfb->dev, "pixclk=%u, clk=%lu, div=%d (%lu)\n",
                 pixclk, clk, result, clk / result);
@@ -267,6 +265,7 @@ static int s3c_fb_set_par(struct fb_info *info)
         struct s3c_fb *sfb = win->parent;
         void __iomem *regs = sfb->regs;
         int win_no = win->index;
+        u32 osdc_data = 0;
         u32 data;
         u32 pagewidth;
         int clkdiv;
@@ -302,7 +301,7 @@ static int s3c_fb_set_par(struct fb_info *info)
         /* use window 0 as the basis for the lcd output timings */
 
         if (win_no == 0) {
-                clkdiv = s3c_fb_calc_pixclk(sfb, var->pixclock);
+                clkdiv = s3c_fb_calc_pixclk(win_no, sfb, var->pixclock);
 
                 data = sfb->pdata->vidcon0;
                 data &= ~(VIDCON0_CLKVAL_F_MASK | VIDCON0_CLKDIR);
@@ -359,8 +358,6 @@ static int s3c_fb_set_par(struct fb_info *info)
 
         data = var->xres * var->yres;
 
-        u32 osdc_data = 0;
-
         osdc_data = VIDISD14C_ALPHA1_R(0xf) |
                 VIDISD14C_ALPHA1_G(0xf) |
                 VIDISD14C_ALPHA1_B(0xf);
diff --git a/drivers/video/sh7760fb.c b/drivers/video/sh7760fb.c
index 653bdfee3057..9f6d6e61f0cc 100644
--- a/drivers/video/sh7760fb.c
+++ b/drivers/video/sh7760fb.c
@@ -120,18 +120,6 @@ static int sh7760_setcolreg (u_int regno,
         return 0;
 }
 
-static void encode_fix(struct fb_fix_screeninfo *fix, struct fb_info *info,
-                       unsigned long stride)
-{
-        memset(fix, 0, sizeof(struct fb_fix_screeninfo));
-        strcpy(fix->id, "sh7760-lcdc");
-
-        fix->smem_start = (unsigned long)info->screen_base;
-        fix->smem_len = info->screen_size;
-
-        fix->line_length = stride;
-}
-
 static int sh7760fb_get_color_info(struct device *dev,
                                    u16 lddfr, int *bpp, int *gray)
 {
@@ -334,7 +322,8 @@ static int sh7760fb_set_par(struct fb_info *info)
 
         iowrite32(ldsarl, par->base + LDSARL);  /* mem for lower half of DSTN */
 
-        encode_fix(&info->fix, info, stride);
+        info->fix.line_length = stride;
+
         sh7760fb_check_var(&info->var, info);
 
         sh7760fb_blank(FB_BLANK_UNBLANK, info); /* panel on! */
@@ -435,6 +424,8 @@ static int sh7760fb_alloc_mem(struct fb_info *info)
 
         info->screen_base = fbmem;
         info->screen_size = vram;
+        info->fix.smem_start = (unsigned long)info->screen_base;
+        info->fix.smem_len = info->screen_size;
 
         return 0;
 }
@@ -520,6 +511,8 @@ static int __devinit sh7760fb_probe(struct platform_device *pdev)
         info->var.transp.length = 0;
         info->var.transp.msb_right = 0;
 
+        strcpy(info->fix.id, "sh7760-lcdc");
+
         /* set the DON2 bit now, before cmap allocation, as it will randomize
          * palette memory.
          */
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index f10d2fbeda06..8f24564f77b0 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -17,6 +17,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
+#include <linux/vmalloc.h>
 #include <video/sh_mobile_lcdc.h>
 #include <asm/atomic.h>
 
@@ -30,9 +31,10 @@ struct sh_mobile_lcdc_chan {
         unsigned long enabled; /* ME and SE in LDCNT2R */
         struct sh_mobile_lcdc_chan_cfg cfg;
         u32 pseudo_palette[PALETTE_NR];
-        struct fb_info info;
+        struct fb_info *info;
         dma_addr_t dma_handle;
         struct fb_deferred_io defio;
+        struct scatterlist *sglist;
         unsigned long frame_end;
         wait_queue_head_t frame_end_wait;
 };
@@ -206,16 +208,38 @@ static void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv *priv) {}
 static void sh_mobile_lcdc_clk_off(struct sh_mobile_lcdc_priv *priv) {}
 #endif
 
+static int sh_mobile_lcdc_sginit(struct fb_info *info,
+                                  struct list_head *pagelist)
+{
+        struct sh_mobile_lcdc_chan *ch = info->par;
+        unsigned int nr_pages_max = info->fix.smem_len >> PAGE_SHIFT;
+        struct page *page;
+        int nr_pages = 0;
+
+        sg_init_table(ch->sglist, nr_pages_max);
+
+        list_for_each_entry(page, pagelist, lru)
+                sg_set_page(&ch->sglist[nr_pages++], page, PAGE_SIZE, 0);
+
+        return nr_pages;
+}
+
 static void sh_mobile_lcdc_deferred_io(struct fb_info *info,
                                        struct list_head *pagelist)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
+        unsigned int nr_pages;
 
         /* enable clocks before accessing hardware */
         sh_mobile_lcdc_clk_on(ch->lcdc);
 
+        nr_pages = sh_mobile_lcdc_sginit(info, pagelist);
+        dma_map_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
+
         /* trigger panel update */
         lcdc_write_chan(ch, LDSM2R, 1);
+
+        dma_unmap_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
 }
 
 static void sh_mobile_lcdc_deferred_io_touch(struct fb_info *info)
@@ -418,22 +442,22 @@ static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
                 /* set bpp format in PKF[4:0] */
                 tmp = lcdc_read_chan(ch, LDDFR);
                 tmp &= ~(0x0001001f);
-                tmp |= (priv->ch[k].info.var.bits_per_pixel == 16) ? 3 : 0;
+                tmp |= (ch->info->var.bits_per_pixel == 16) ? 3 : 0;
                 lcdc_write_chan(ch, LDDFR, tmp);
 
                 /* point out our frame buffer */
-                lcdc_write_chan(ch, LDSA1R, ch->info.fix.smem_start);
+                lcdc_write_chan(ch, LDSA1R, ch->info->fix.smem_start);
 
                 /* set line size */
-                lcdc_write_chan(ch, LDMLSR, ch->info.fix.line_length);
+                lcdc_write_chan(ch, LDMLSR, ch->info->fix.line_length);
 
                 /* setup deferred io if SYS bus */
                 tmp = ch->cfg.sys_bus_cfg.deferred_io_msec;
                 if (ch->ldmt1r_value & (1 << 12) && tmp) {
                         ch->defio.deferred_io = sh_mobile_lcdc_deferred_io;
                         ch->defio.delay = msecs_to_jiffies(tmp);
-                        ch->info.fbdefio = &ch->defio;
-                        fb_deferred_io_init(&ch->info);
+                        ch->info->fbdefio = &ch->defio;
+                        fb_deferred_io_init(ch->info);
 
                         /* one-shot mode */
                         lcdc_write_chan(ch, LDSM1R, 1);
@@ -479,12 +503,12 @@ static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
                  * flush frame, and wait for frame end interrupt
                  * clean up deferred io and enable clock
                  */
-                if (ch->info.fbdefio) {
+                if (ch->info->fbdefio) {
                         ch->frame_end = 0;
-                        schedule_delayed_work(&ch->info.deferred_work, 0);
+                        schedule_delayed_work(&ch->info->deferred_work, 0);
                         wait_event(ch->frame_end_wait, ch->frame_end);
-                        fb_deferred_io_cleanup(&ch->info);
-                        ch->info.fbdefio = NULL;
+                        fb_deferred_io_cleanup(ch->info);
+                        ch->info->fbdefio = NULL;
                         sh_mobile_lcdc_clk_on(priv);
                 }
 
@@ -793,9 +817,16 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
         priv->base = ioremap_nocache(res->start, (res->end - res->start) + 1);
 
         for (i = 0; i < j; i++) {
-                info = &priv->ch[i].info;
                 cfg = &priv->ch[i].cfg;
 
+                priv->ch[i].info = framebuffer_alloc(0, &pdev->dev);
+                if (!priv->ch[i].info) {
+                        dev_err(&pdev->dev, "unable to allocate fb_info\n");
+                        error = -ENOMEM;
+                        break;
+                }
+
+                info = priv->ch[i].info;
                 info->fbops = &sh_mobile_lcdc_ops;
                 info->var.xres = info->var.xres_virtual = cfg->lcd_cfg.xres;
                 info->var.yres = info->var.yres_virtual = cfg->lcd_cfg.yres;
@@ -846,21 +877,31 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
         }
 
         for (i = 0; i < j; i++) {
-                error = register_framebuffer(&priv->ch[i].info);
+                struct sh_mobile_lcdc_chan *ch = priv->ch + i;
+
+                info = ch->info;
+
+                if (info->fbdefio) {
+                        priv->ch->sglist = vmalloc(sizeof(struct scatterlist) *
+                                        info->fix.smem_len >> PAGE_SHIFT);
+                        if (!priv->ch->sglist) {
+                                dev_err(&pdev->dev, "cannot allocate sglist\n");
+                                goto err1;
+                        }
+                }
+
+                error = register_framebuffer(info);
                 if (error < 0)
                         goto err1;
-        }
 
-        for (i = 0; i < j; i++) {
-                info = &priv->ch[i].info;
                 dev_info(info->dev,
                          "registered %s/%s as %dx%d %dbpp.\n",
                          pdev->name,
-                         (priv->ch[i].cfg.chan == LCDC_CHAN_MAINLCD) ?
+                         (ch->cfg.chan == LCDC_CHAN_MAINLCD) ?
                          "mainlcd" : "sublcd",
-                         (int) priv->ch[i].cfg.lcd_cfg.xres,
-                         (int) priv->ch[i].cfg.lcd_cfg.yres,
-                         priv->ch[i].cfg.bpp);
+                         (int) ch->cfg.lcd_cfg.xres,
+                         (int) ch->cfg.lcd_cfg.yres,
+                         ch->cfg.bpp);
 
                 /* deferred io mode: disable clock to save power */
                 if (info->fbdefio)
@@ -881,20 +922,24 @@ static int sh_mobile_lcdc_remove(struct platform_device *pdev)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(priv->ch); i++)
-                if (priv->ch[i].info.dev)
-                        unregister_framebuffer(&priv->ch[i].info);
+                if (priv->ch[i].info->dev)
+                        unregister_framebuffer(priv->ch[i].info);
 
         sh_mobile_lcdc_stop(priv);
 
         for (i = 0; i < ARRAY_SIZE(priv->ch); i++) {
-                info = &priv->ch[i].info;
+                info = priv->ch[i].info;
 
-                if (!info->device)
+                if (!info || !info->device)
                         continue;
 
+                if (priv->ch[i].sglist)
+                        vfree(priv->ch[i].sglist);
+
                 dma_free_coherent(&pdev->dev, info->fix.smem_len,
                                   info->screen_base, priv->ch[i].dma_handle);
                 fb_dealloc_cmap(&info->cmap);
+                framebuffer_release(info);
         }
 
 #ifdef CONFIG_HAVE_CLK
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index 7072d19080d5..4a067f0d0ceb 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -1847,8 +1847,10 @@ sisfb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
 
         strcpy(fix->id, ivideo->myid);
 
+        mutex_lock(&info->mm_lock);
         fix->smem_start  = ivideo->video_base + ivideo->video_offset;
         fix->smem_len    = ivideo->sisfb_mem;
+        mutex_unlock(&info->mm_lock);
         fix->type        = FB_TYPE_PACKED_PIXELS;
         fix->type_aux    = 0;
         fix->visual      = (ivideo->video_bpp == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
@@ -6365,7 +6367,6 @@ error_3:	vfree(ivideo->bios_abase);
                 sis_fb_info->fix = ivideo->sisfb_fix;
                 sis_fb_info->screen_base = ivideo->video_vbase + ivideo->video_offset;
                 sis_fb_info->fbops = &sisfb_ops;
-                sisfb_get_fix(&sis_fb_info->fix, -1, sis_fb_info);
                 sis_fb_info->pseudo_palette = ivideo->pseudo_palette;
 
                 fb_alloc_cmap(&sis_fb_info->cmap, 256 , 0);
diff --git a/drivers/video/sm501fb.c b/drivers/video/sm501fb.c
index eb5d73a06702..924d79462780 100644
--- a/drivers/video/sm501fb.c
+++ b/drivers/video/sm501fb.c
@@ -145,7 +145,7 @@ static inline void sm501fb_sync_regs(struct sm501fb_info *info)
 #define SM501_MEMF_ACCEL                (8)
 
 static int sm501_alloc_mem(struct sm501fb_info *inf, struct sm501_mem *mem,
-                           unsigned int why, size_t size)
+                           unsigned int why, size_t size, u32 smem_len)
 {
         struct sm501fb_par *par;
         struct fb_info *fbi;
@@ -172,7 +172,7 @@ static int sm501_alloc_mem(struct sm501fb_info *inf, struct sm501_mem *mem,
                 if (ptr > 0)
                         ptr &= ~(PAGE_SIZE - 1);
 
-                if (fbi && ptr < fbi->fix.smem_len)
+                if (fbi && ptr < smem_len)
                         return -ENOMEM;
 
                 break;
@@ -197,7 +197,7 @@ static int sm501_alloc_mem(struct sm501fb_info *inf, struct sm501_mem *mem,
 
         case SM501_MEMF_ACCEL:
                 fbi = inf->fb[HEAD_CRT];
-                ptr = fbi ? fbi->fix.smem_len : 0;
+                ptr = fbi ? smem_len : 0;
 
                 fbi = inf->fb[HEAD_PANEL];
                 if (fbi) {
@@ -413,6 +413,7 @@ static int sm501fb_set_par_common(struct fb_info *info,
         unsigned int mem_type;
         unsigned int clock_type;
         unsigned int head_addr;
+        unsigned int smem_len;
 
         dev_dbg(fbi->dev, "%s: %dx%d, bpp = %d, virtual %dx%d\n",
                 __func__, var->xres, var->yres, var->bits_per_pixel,
@@ -453,18 +454,20 @@ static int sm501fb_set_par_common(struct fb_info *info,
 
         /* allocate fb memory within 501 */
         info->fix.line_length = (var->xres_virtual * var->bits_per_pixel)/8;
-        info->fix.smem_len    = info->fix.line_length * var->yres_virtual;
+        smem_len = info->fix.line_length * var->yres_virtual;
 
         dev_dbg(fbi->dev, "%s: line length = %u\n", __func__,
                 info->fix.line_length);
 
-        if (sm501_alloc_mem(fbi, &par->screen, mem_type,
-                            info->fix.smem_len)) {
+        if (sm501_alloc_mem(fbi, &par->screen, mem_type, smem_len, smem_len)) {
                 dev_err(fbi->dev, "no memory available\n");
                 return -ENOMEM;
         }
 
+        mutex_lock(&info->mm_lock);
         info->fix.smem_start = fbi->fbmem_res->start + par->screen.sm_addr;
+        info->fix.smem_len   = smem_len;
+        mutex_unlock(&info->mm_lock);
 
         info->screen_base = fbi->fbmem + par->screen.sm_addr;
         info->screen_size = info->fix.smem_len;
@@ -637,7 +640,8 @@ static int sm501fb_set_par_crt(struct fb_info *info)
         if ((control & SM501_DC_CRT_CONTROL_SEL) == 0) {
                 /* the head is displaying panel data... */
 
-                sm501_alloc_mem(fbi, &par->screen, SM501_MEMF_CRT, 0);
+                sm501_alloc_mem(fbi, &par->screen, SM501_MEMF_CRT, 0,
+                                info->fix.smem_len);
                 goto out_update;
         }
 
@@ -1289,7 +1293,8 @@ static int sm501_init_cursor(struct fb_info *fbi, unsigned int reg_base)
 
         par->cursor_regs = info->regs + reg_base;
 
-        ret = sm501_alloc_mem(info, &par->cursor, SM501_MEMF_CURSOR, 1024);
+        ret = sm501_alloc_mem(info, &par->cursor, SM501_MEMF_CURSOR, 1024,
+                              fbi->fix.smem_len);
         if (ret < 0)
                 return ret;
 
@@ -1535,9 +1540,6 @@ static int sm501fb_init_fb(struct fb_info *fb,
         if (ret)
                 dev_err(info->dev, "check_var() failed on initial setup?\n");
 
-        /* ensure we've activated our new configuration */
-        (fb->fbops->fb_set_par)(fb);
-
         return 0;
 }
 
@@ -1619,6 +1621,8 @@ static int __devinit sm501fb_start_one(struct sm501fb_info *info,
         if (!fbi)
                 return 0;
 
+        mutex_init(&info->fb[head]->mm_lock);
+
         ret = sm501fb_init_fb(info->fb[head], head, drvname);
         if (ret) {
                 dev_err(info->dev, "cannot initialise fb %s\n", drvname);
diff --git a/drivers/video/stifb.c b/drivers/video/stifb.c
index eec9dcb7f599..6120f0c526fe 100644
--- a/drivers/video/stifb.c
+++ b/drivers/video/stifb.c
@@ -1115,10 +1115,9 @@ static int __init stifb_init_fb(struct sti_struct *sti, int bpp_pref)
                   if the device name contains the string "DX" and tell the
                   user how to reconfigure the card. */
                 if (strstr(sti->outptr.dev_name, "DX")) {
-                   printk(KERN_WARNING "WARNING: stifb framebuffer driver does not "
-                        "support '%s' in double-buffer mode.\n"
-                        KERN_WARNING "WARNING: Please disable the double-buffer mode "
-                        "in IPL menu (the PARISC-BIOS).\n",
+                   printk(KERN_WARNING
+"WARNING: stifb framebuffer driver does not support '%s' in double-buffer mode.\n"
+"WARNING: Please disable the double-buffer mode in IPL menu (the PARISC-BIOS).\n",
                         sti->outptr.dev_name);
                    goto out_err0;
                 }
diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c
index d0674f1e3f10..2376f688ec8b 100644
--- a/drivers/video/w100fb.c
+++ b/drivers/video/w100fb.c
@@ -523,6 +523,7 @@ static int w100fb_set_par(struct fb_info *info)
                 info->fix.ywrapstep = 0;
                 info->fix.line_length = par->xres * BITS_PER_PIXEL / 8;
 
+                mutex_lock(&info->mm_lock);
                 if ((par->xres*par->yres*BITS_PER_PIXEL/8) > (MEM_INT_SIZE+1)) {
                         par->extmem_active = 1;
                         info->fix.smem_len = par->mach->mem->size+1;
@@ -530,6 +531,7 @@ static int w100fb_set_par(struct fb_info *info)
                         par->extmem_active = 0;
                         info->fix.smem_len = MEM_INT_SIZE+1;
                 }
+                mutex_unlock(&info->mm_lock);
 
                 w100fb_activate_var(par);
         }
@@ -746,8 +748,6 @@ int __init w100fb_probe(struct platform_device *pdev)
                 goto out;
         }
 
-        w100fb_set_par(info);
-
         if (register_framebuffer(info) < 0) {
                 err = -EINVAL;
                 goto out;
diff --git a/drivers/vlynq/Kconfig b/drivers/vlynq/Kconfig
index f6542211db48..a9efb1625321 100644
--- a/drivers/vlynq/Kconfig
+++ b/drivers/vlynq/Kconfig
@@ -13,7 +13,7 @@ config VLYNQ
 
 config VLYNQ_DEBUG
         bool "VLYNQ bus debug"
-        depends on VLYNQ && KERNEL_DEBUG
+        depends on VLYNQ && DEBUG_KERNEL
         help
           Turn on VLYNQ bus debugging.
 
diff --git a/drivers/vlynq/vlynq.c b/drivers/vlynq/vlynq.c
index 7335433b067b..f05d2a368367 100644
--- a/drivers/vlynq/vlynq.c
+++ b/drivers/vlynq/vlynq.c
@@ -76,7 +76,7 @@ struct vlynq_regs {
         u32 int_device[8];
 };
 
-#ifdef VLYNQ_DEBUG
+#ifdef CONFIG_VLYNQ_DEBUG
 static void vlynq_dump_regs(struct vlynq_device *dev)
 {
         int i;
diff --git a/drivers/watchdog/bcm47xx_wdt.c b/drivers/watchdog/bcm47xx_wdt.c
index 5c7011cda6a6..751c003864ad 100644
--- a/drivers/watchdog/bcm47xx_wdt.c
+++ b/drivers/watchdog/bcm47xx_wdt.c
@@ -161,7 +161,7 @@ static long bcm47xx_wdt_ioctl(struct file *file,
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        int new_value, retval = -EINVAL;;
+        int new_value, retval = -EINVAL;
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
diff --git a/drivers/watchdog/sa1100_wdt.c b/drivers/watchdog/sa1100_wdt.c
index ee1caae4d33b..016245419fad 100644
--- a/drivers/watchdog/sa1100_wdt.c
+++ b/drivers/watchdog/sa1100_wdt.c
@@ -38,7 +38,7 @@
 
 static unsigned long oscr_freq;
 static unsigned long sa1100wdt_users;
-static int pre_margin;
+static unsigned int pre_margin;
 static int boot_status;
 
 /*
@@ -84,6 +84,7 @@ static const struct watchdog_info ident = {
         .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT
                                 | WDIOF_KEEPALIVEPING,
         .identity       = "SA1100/PXA255 Watchdog",
+        .firmware_version       = 1,
 };
 
 static long sa1100dog_ioctl(struct file *file, unsigned int cmd,
@@ -118,7 +119,7 @@ static long sa1100dog_ioctl(struct file *file, unsigned int cmd,
                 if (ret)
                         break;
 
-                if (time <= 0 || time > 255) {
+                if (time <= 0 || (oscr_freq * (long long)time >= 0xffffffff)) {
                         ret = -EINVAL;
                         break;
                 }
diff --git a/drivers/watchdog/w83627hf_wdt.c b/drivers/watchdog/w83627hf_wdt.c
index 916890abffdd..f201accc4e3d 100644
--- a/drivers/watchdog/w83627hf_wdt.c
+++ b/drivers/watchdog/w83627hf_wdt.c
@@ -89,6 +89,11 @@ static void w83627hf_select_wd_register(void)
                 c = ((inb_p(WDT_EFDR) & 0xf7) | 0x04); /* select WDT0 */
                 outb_p(0x2b, WDT_EFER);
                 outb_p(c, WDT_EFDR);    /* set GPIO3 to WDT0 */
+        } else if (c == 0x88) { /* W83627EHF */
+                outb_p(0x2d, WDT_EFER); /* select GPIO5 */
+                c = inb_p(WDT_EFDR) & ~0x01; /* PIN77 -> WDT0# */
+                outb_p(0x2d, WDT_EFER);
+                outb_p(c, WDT_EFDR); /* set GPIO5 to WDT0 */
         }
 
         outb_p(0x07, WDT_EFER); /* point to logical device number reg */
diff --git a/drivers/watchdog/w83697ug_wdt.c b/drivers/watchdog/w83697ug_wdt.c
index 883b5f79673a..a6c12dec91a1 100644
--- a/drivers/watchdog/w83697ug_wdt.c
+++ b/drivers/watchdog/w83697ug_wdt.c
@@ -149,8 +149,10 @@ static void wdt_ctrl(int timeout)
 {
         spin_lock(&io_lock);
 
-        if (w83697ug_select_wd_register() < 0)
+        if (w83697ug_select_wd_register() < 0) {
+                spin_unlock(&io_lock);
                 return;
+        }
 
         outb_p(0xF4, WDT_EFER);    /* Select CRF4 */
         outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF4 */
diff --git a/drivers/watchdog/wdrtas.c b/drivers/watchdog/wdrtas.c
index a4fe7a38d9b0..3bde56bce63a 100644
--- a/drivers/watchdog/wdrtas.c
+++ b/drivers/watchdog/wdrtas.c
@@ -218,16 +218,14 @@ static void wdrtas_timer_keepalive(void)
  */
 static int wdrtas_get_temperature(void)
 {
-        long result;
+        int result;
         int temperature = 0;
 
-        result = rtas_call(wdrtas_token_get_sensor_state, 2, 2,
-                           (void *)__pa(&temperature),
-                           WDRTAS_THERMAL_SENSOR, 0);
+        result = rtas_get_sensor(WDRTAS_THERMAL_SENSOR, 0, &temperature);
 
         if (result < 0)
                 printk(KERN_WARNING "wdrtas: reading the thermal sensor "
-                       "faild: %li\n", result);
+                       "failed: %i\n", result);
         else
                 temperature = ((temperature * 9) / 5) + 32; /* fahrenheit */
 
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 891d2e90753a..abad71b1632b 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -927,9 +927,9 @@ static struct irq_chip xen_dynamic_chip __read_mostly = {
 void __init xen_init_IRQ(void)
 {
         int i;
-        size_t size = nr_cpu_ids * sizeof(struct cpu_evtchn_s);
 
-        cpu_evtchn_mask_p = alloc_bootmem(size);
+        cpu_evtchn_mask_p = kcalloc(nr_cpu_ids, sizeof(struct cpu_evtchn_s),
+                                    GFP_KERNEL);
         BUG_ON(cpu_evtchn_mask_p == NULL);
 
         init_evtchn_cpu_bindings();