284 files changed, 5828 insertions, 1939 deletions

diff --git a/Documentation/00-INDEX b/Documentation/00-INDEX
index 9e642c5bf52..8dfc6708a25 100644
--- a/Documentation/00-INDEX
+++ b/Documentation/00-INDEX
@@ -232,6 +232,8 @@ memory.txt
         - info on typical Linux memory problems.
 mips/
         - directory with info about Linux on MIPS architecture.
+mmc/
+        - directory with info about the MMC subsystem
 mono.txt
         - how to execute Mono-based .NET binaries with the help of BINFMT_MISC.
 mutex-design.txt
diff --git a/Documentation/mmc/00-INDEX b/Documentation/mmc/00-INDEX
new file mode 100644
index 00000000000..fca586f5b85
--- /dev/null
+++ b/Documentation/mmc/00-INDEX
@@ -0,0 +1,4 @@
+00-INDEX
+        - this file
+mmc-dev-attrs.txt
+        - info on SD and MMC device attributes
diff --git a/Documentation/mmc/mmc-dev-attrs.txt b/Documentation/mmc/mmc-dev-attrs.txt
new file mode 100644
index 00000000000..ff2bd685bce
--- /dev/null
+++ b/Documentation/mmc/mmc-dev-attrs.txt
@@ -0,0 +1,56 @@
+SD and MMC Device Attributes
+============================
+
+All attributes are read-only.
+
+        cid                     Card Identifaction Register
+        csd                     Card Specific Data Register
+        scr                     SD Card Configuration Register (SD only)
+        date                    Manufacturing Date (from CID Register)
+        fwrev                   Firmware/Product Revision (from CID Register) (SD and MMCv1 only)
+        hwrev                   Hardware/Product Revision (from CID Register) (SD and MMCv1 only)
+        manfid                  Manufacturer ID (from CID Register)
+        name                    Product Name (from CID Register)
+        oemid                   OEM/Application ID (from CID Register)
+        serial                  Product Serial Number (from CID Register)
+        erase_size              Erase group size
+        preferred_erase_size    Preferred erase size
+
+Note on Erase Size and Preferred Erase Size:
+
+        "erase_size" is the  minimum size, in bytes, of an erase
+        operation.  For MMC, "erase_size" is the erase group size
+        reported by the card.  Note that "erase_size" does not apply
+        to trim or secure trim operations where the minimum size is
+        always one 512 byte sector.  For SD, "erase_size" is 512
+        if the card is block-addressed, 0 otherwise.
+
+        SD/MMC cards can erase an arbitrarily large area up to and
+        including the whole card.  When erasing a large area it may
+        be desirable to do it in smaller chunks for three reasons:
+                1. A single erase command will make all other I/O on
+                the card wait.  This is not a problem if the whole card
+                is being erased, but erasing one partition will make
+                I/O for another partition on the same card wait for the
+                duration of the erase - which could be a several
+                minutes.
+                2. To be able to inform the user of erase progress.
+                3. The erase timeout becomes too large to be very
+                useful.  Because the erase timeout contains a margin
+                which is multiplied by the size of the erase area,
+                the value can end up being several minutes for large
+                areas.
+
+        "erase_size" is not the most efficient unit to erase
+        (especially for SD where it is just one sector),
+        hence "preferred_erase_size" provides a good chunk
+        size for erasing large areas.
+
+        For MMC, "preferred_erase_size" is the high-capacity
+        erase size if a card specifies one, otherwise it is
+        based on the capacity of the card.
+
+        For SD, "preferred_erase_size" is the allocation unit
+        size specified by the card.
+
+        "preferred_erase_size" is in bytes.
diff --git a/arch/parisc/mm/ioremap.c b/arch/parisc/mm/ioremap.c
index 92d496ad07c..838d0259cd2 100644
--- a/arch/parisc/mm/ioremap.c
+++ b/arch/parisc/mm/ioremap.c
@@ -71,7 +71,7 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l
          */
         offset = phys_addr & ~PAGE_MASK;
         phys_addr &= PAGE_MASK;
-        size = PAGE_ALIGN(last_addr) - phys_addr;
+        size = PAGE_ALIGN(last_addr + 1) - phys_addr;
 
         /*
          * Ok, go for it..
diff --git a/arch/powerpc/platforms/83xx/mpc837x_mds.c b/arch/powerpc/platforms/83xx/mpc837x_mds.c
index 51df7e75469..f9751c8905b 100644
--- a/arch/powerpc/platforms/83xx/mpc837x_mds.c
+++ b/arch/powerpc/platforms/83xx/mpc837x_mds.c
@@ -102,7 +102,7 @@ static struct of_device_id mpc837x_ids[] = {
 
 static int __init mpc837x_declare_of_platform_devices(void)
 {
-        /* Publish of_device */
+        /* Publish platform_device */
         of_platform_bus_probe(NULL, mpc837x_ids, NULL);
 
         return 0;
diff --git a/arch/powerpc/platforms/83xx/mpc837x_rdb.c b/arch/powerpc/platforms/83xx/mpc837x_rdb.c
index e00801c4254..910caa6b581 100644
--- a/arch/powerpc/platforms/83xx/mpc837x_rdb.c
+++ b/arch/powerpc/platforms/83xx/mpc837x_rdb.c
@@ -78,7 +78,7 @@ static struct of_device_id mpc837x_ids[] = {
 
 static int __init mpc837x_declare_of_platform_devices(void)
 {
-        /* Publish of_device */
+        /* Publish platform_device */
         of_platform_bus_probe(NULL, mpc837x_ids, NULL);
 
         return 0;
diff --git a/arch/powerpc/sysdev/fsl_rio.c b/arch/powerpc/sysdev/fsl_rio.c
index 8bd86530ee2..6425abe5b7d 100644
--- a/arch/powerpc/sysdev/fsl_rio.c
+++ b/arch/powerpc/sysdev/fsl_rio.c
@@ -1332,7 +1332,7 @@ static inline void fsl_rio_info(struct device *dev, u32 ccsr)
 
 /**
  * fsl_rio_setup - Setup Freescale PowerPC RapidIO interface
- * @dev: of_device pointer
+ * @dev: platform_device pointer
  *
  * Initializes MPC85xx RapidIO hardware interface, configures
  * master port with system-specific info, and registers the
diff --git a/arch/score/mm/tlb-score.c b/arch/score/mm/tlb-score.c
index 4fa5aa5afec..6fdb100244c 100644
--- a/arch/score/mm/tlb-score.c
+++ b/arch/score/mm/tlb-score.c
@@ -158,7 +158,7 @@ void local_flush_tlb_kernel_range(unsigned long start, unsigned long end)
 
 void local_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
 {
-        if (!vma || vma->vm_mm->context != 0) {
+        if (vma && vma->vm_mm->context != 0) {
                 unsigned long flags;
                 int oldpid, newpid, idx;
                 unsigned long vma_ASID = vma->vm_mm->context;
diff --git a/arch/x86/include/asm/xen/page.h b/arch/x86/include/asm/xen/page.h
index 018a0a40079..bf5f7d32bd0 100644
--- a/arch/x86/include/asm/xen/page.h
+++ b/arch/x86/include/asm/xen/page.h
@@ -112,13 +112,9 @@ static inline xpaddr_t machine_to_phys(xmaddr_t machine)
  */
 static inline unsigned long mfn_to_local_pfn(unsigned long mfn)
 {
-        extern unsigned long max_mapnr;
         unsigned long pfn = mfn_to_pfn(mfn);
-        if ((pfn < max_mapnr)
-            && !xen_feature(XENFEAT_auto_translated_physmap)
-            && (get_phys_to_machine(pfn) != mfn))
-                return max_mapnr; /* force !pfn_valid() */
-        /* XXX fixme; not true with sparsemem */
+        if (get_phys_to_machine(pfn) != mfn)
+                return -1; /* force !pfn_valid() */
         return pfn;
 }
 
diff --git a/arch/x86/include/asm/xen/swiotlb-xen.h b/arch/x86/include/asm/xen/swiotlb-xen.h
new file mode 100644
index 00000000000..1be1ab7d6a4
--- /dev/null
+++ b/arch/x86/include/asm/xen/swiotlb-xen.h
@@ -0,0 +1,14 @@
+#ifndef _ASM_X86_SWIOTLB_XEN_H
+#define _ASM_X86_SWIOTLB_XEN_H
+
+#ifdef CONFIG_SWIOTLB_XEN
+extern int xen_swiotlb;
+extern int __init pci_xen_swiotlb_detect(void);
+extern void __init pci_xen_swiotlb_init(void);
+#else
+#define xen_swiotlb (0)
+static inline int __init pci_xen_swiotlb_detect(void) { return 0; }
+static inline void __init pci_xen_swiotlb_init(void) { }
+#endif
+
+#endif /* _ASM_X86_SWIOTLB_XEN_H */
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index 4b7e3d8b01d..9f07cfcbd3a 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -13,6 +13,7 @@
 #include <asm/calgary.h>
 #include <asm/amd_iommu.h>
 #include <asm/x86_init.h>
+#include <asm/xen/swiotlb-xen.h>
 
 static int forbid_dac __read_mostly;
 
@@ -132,7 +133,7 @@ void __init pci_iommu_alloc(void)
         /* free the range so iommu could get some range less than 4G */
         dma32_free_bootmem();
 
-        if (pci_swiotlb_detect())
+        if (pci_xen_swiotlb_detect() || pci_swiotlb_detect())
                 goto out;
 
         gart_iommu_hole_init();
@@ -144,6 +145,8 @@ void __init pci_iommu_alloc(void)
         /* needs to be called after gart_iommu_hole_init */
         amd_iommu_detect();
 out:
+        pci_xen_swiotlb_init();
+
         pci_swiotlb_init();
 }
 
@@ -296,7 +299,7 @@ static int __init pci_iommu_init(void)
 #endif
         x86_init.iommu.iommu_init();
 
-        if (swiotlb) {
+        if (swiotlb || xen_swiotlb) {
                 printk(KERN_INFO "PCI-DMA: "
                        "Using software bounce buffering for IO (SWIOTLB)\n");
                 swiotlb_print_info();
diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
index 93095468598..77938515891 100644
--- a/arch/x86/xen/Makefile
+++ b/arch/x86/xen/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_SMP)		+= smp.o
 obj-$(CONFIG_PARAVIRT_SPINLOCKS)+= spinlock.o
 obj-$(CONFIG_XEN_DEBUG_FS)      += debugfs.o
 
+obj-$(CONFIG_SWIOTLB_XEN)       += pci-swiotlb-xen.o
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index d4ff5e83621..7d46c844141 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -1172,6 +1172,10 @@ asmlinkage void __init xen_start_kernel(void)
 
         pgd = (pgd_t *)xen_start_info->pt_base;
 
+        if (!xen_initial_domain())
+                __supported_pte_mask &= ~(_PAGE_PWT | _PAGE_PCD);
+
+        __supported_pte_mask |= _PAGE_IOMAP;
         /* Don't do the full vcpu_info placement stuff until we have a
            possible map and a non-dummy shared_info. */
         per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index 413b19b3d0f..42086ac406a 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -42,6 +42,7 @@
 #include <linux/highmem.h>
 #include <linux/debugfs.h>
 #include <linux/bug.h>
+#include <linux/vmalloc.h>
 #include <linux/module.h>
 #include <linux/gfp.h>
 
@@ -51,15 +52,19 @@
 #include <asm/mmu_context.h>
 #include <asm/setup.h>
 #include <asm/paravirt.h>
+#include <asm/e820.h>
 #include <asm/linkage.h>
+#include <asm/page.h>
 
 #include <asm/xen/hypercall.h>
 #include <asm/xen/hypervisor.h>
 
+#include <xen/xen.h>
 #include <xen/page.h>
 #include <xen/interface/xen.h>
 #include <xen/interface/hvm/hvm_op.h>
 #include <xen/interface/version.h>
+#include <xen/interface/memory.h>
 #include <xen/hvc-console.h>
 
 #include "multicalls.h"
@@ -68,6 +73,13 @@
 
 #define MMU_UPDATE_HISTO        30
 
+/*
+ * Protects atomic reservation decrease/increase against concurrent increases.
+ * Also protects non-atomic updates of current_pages and driver_pages, and
+ * balloon lists.
+ */
+DEFINE_SPINLOCK(xen_reservation_lock);
+
 #ifdef CONFIG_XEN_DEBUG_FS
 
 static struct {
@@ -378,6 +390,28 @@ static bool xen_page_pinned(void *ptr)
         return PagePinned(page);
 }
 
+static bool xen_iomap_pte(pte_t pte)
+{
+        return pte_flags(pte) & _PAGE_IOMAP;
+}
+
+static void xen_set_iomap_pte(pte_t *ptep, pte_t pteval)
+{
+        struct multicall_space mcs;
+        struct mmu_update *u;
+
+        mcs = xen_mc_entry(sizeof(*u));
+        u = mcs.args;
+
+        /* ptep might be kmapped when using 32-bit HIGHPTE */
+        u->ptr = arbitrary_virt_to_machine(ptep).maddr;
+        u->val = pte_val_ma(pteval);
+
+        MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_IO);
+
+        xen_mc_issue(PARAVIRT_LAZY_MMU);
+}
+
 static void xen_extend_mmu_update(const struct mmu_update *update)
 {
         struct multicall_space mcs;
@@ -454,6 +488,11 @@ void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
                     pte_t *ptep, pte_t pteval)
 {
+        if (xen_iomap_pte(pteval)) {
+                xen_set_iomap_pte(ptep, pteval);
+                goto out;
+        }
+
         ADD_STATS(set_pte_at, 1);
 //      ADD_STATS(set_pte_at_pinned, xen_page_pinned(ptep));
         ADD_STATS(set_pte_at_current, mm == current->mm);
@@ -524,8 +563,25 @@ static pteval_t pte_pfn_to_mfn(pteval_t val)
         return val;
 }
 
+static pteval_t iomap_pte(pteval_t val)
+{
+        if (val & _PAGE_PRESENT) {
+                unsigned long pfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
+                pteval_t flags = val & PTE_FLAGS_MASK;
+
+                /* We assume the pte frame number is a MFN, so
+                   just use it as-is. */
+                val = ((pteval_t)pfn << PAGE_SHIFT) | flags;
+        }
+
+        return val;
+}
+
 pteval_t xen_pte_val(pte_t pte)
 {
+        if (xen_initial_domain() && (pte.pte & _PAGE_IOMAP))
+                return pte.pte;
+
         return pte_mfn_to_pfn(pte.pte);
 }
 PV_CALLEE_SAVE_REGS_THUNK(xen_pte_val);
@@ -538,7 +594,22 @@ PV_CALLEE_SAVE_REGS_THUNK(xen_pgd_val);
 
 pte_t xen_make_pte(pteval_t pte)
 {
-        pte = pte_pfn_to_mfn(pte);
+        phys_addr_t addr = (pte & PTE_PFN_MASK);
+
+        /*
+         * Unprivileged domains are allowed to do IOMAPpings for
+         * PCI passthrough, but not map ISA space.  The ISA
+         * mappings are just dummy local mappings to keep other
+         * parts of the kernel happy.
+         */
+        if (unlikely(pte & _PAGE_IOMAP) &&
+            (xen_initial_domain() || addr >= ISA_END_ADDRESS)) {
+                pte = iomap_pte(pte);
+        } else {
+                pte &= ~_PAGE_IOMAP;
+                pte = pte_pfn_to_mfn(pte);
+        }
+
         return native_make_pte(pte);
 }
 PV_CALLEE_SAVE_REGS_THUNK(xen_make_pte);
@@ -594,6 +665,11 @@ void xen_set_pud(pud_t *ptr, pud_t val)
 
 void xen_set_pte(pte_t *ptep, pte_t pte)
 {
+        if (xen_iomap_pte(pte)) {
+                xen_set_iomap_pte(ptep, pte);
+                return;
+        }
+
         ADD_STATS(pte_update, 1);
 //      ADD_STATS(pte_update_pinned, xen_page_pinned(ptep));
         ADD_STATS(pte_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);
@@ -610,6 +686,11 @@ void xen_set_pte(pte_t *ptep, pte_t pte)
 #ifdef CONFIG_X86_PAE
 void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
 {
+        if (xen_iomap_pte(pte)) {
+                xen_set_iomap_pte(ptep, pte);
+                return;
+        }
+
         set_64bit((u64 *)ptep, native_pte_val(pte));
 }
 
@@ -936,8 +1017,6 @@ static int xen_pin_page(struct mm_struct *mm, struct page *page,
    read-only, and can be pinned. */
 static void __xen_pgd_pin(struct mm_struct *mm, pgd_t *pgd)
 {
-        vm_unmap_aliases();
-
         xen_mc_batch();
 
         if (__xen_pgd_walk(mm, pgd, xen_pin_page, USER_LIMIT)) {
@@ -1501,7 +1580,6 @@ static void xen_alloc_ptpage(struct mm_struct *mm, unsigned long pfn, unsigned l
         if (PagePinned(virt_to_page(mm->pgd))) {
                 SetPagePinned(page);
 
-                vm_unmap_aliases();
                 if (!PageHighMem(page)) {
                         make_lowmem_page_readonly(__va(PFN_PHYS((unsigned long)pfn)));
                         if (level == PT_PTE && USE_SPLIT_PTLOCKS)
@@ -1812,9 +1890,16 @@ static void xen_set_fixmap(unsigned idx, phys_addr_t phys, pgprot_t prot)
                 pte = pfn_pte(phys, prot);
                 break;
 
-        default:
+        case FIX_PARAVIRT_BOOTMAP:
+                /* This is an MFN, but it isn't an IO mapping from the
+                   IO domain */
                 pte = mfn_pte(phys, prot);
                 break;
+
+        default:
+                /* By default, set_fixmap is used for hardware mappings */
+                pte = mfn_pte(phys, __pgprot(pgprot_val(prot) | _PAGE_IOMAP));
+                break;
         }
 
         __native_set_fixmap(idx, pte);
@@ -1940,7 +2025,205 @@ void __init xen_init_mmu_ops(void)
         x86_init.paging.pagetable_setup_start = xen_pagetable_setup_start;
         x86_init.paging.pagetable_setup_done = xen_pagetable_setup_done;
         pv_mmu_ops = xen_mmu_ops;
+
+        vmap_lazy_unmap = false;
+}
+
+/* Protected by xen_reservation_lock. */
+#define MAX_CONTIG_ORDER 9 /* 2MB */
+static unsigned long discontig_frames[1<<MAX_CONTIG_ORDER];
+
+#define VOID_PTE (mfn_pte(0, __pgprot(0)))
+static void xen_zap_pfn_range(unsigned long vaddr, unsigned int order,
+                                unsigned long *in_frames,
+                                unsigned long *out_frames)
+{
+        int i;
+        struct multicall_space mcs;
+
+        xen_mc_batch();
+        for (i = 0; i < (1UL<<order); i++, vaddr += PAGE_SIZE) {
+                mcs = __xen_mc_entry(0);
+
+                if (in_frames)
+                        in_frames[i] = virt_to_mfn(vaddr);
+
+                MULTI_update_va_mapping(mcs.mc, vaddr, VOID_PTE, 0);
+                set_phys_to_machine(virt_to_pfn(vaddr), INVALID_P2M_ENTRY);
+
+                if (out_frames)
+                        out_frames[i] = virt_to_pfn(vaddr);
+        }
+        xen_mc_issue(0);
+}
+
+/*
+ * Update the pfn-to-mfn mappings for a virtual address range, either to
+ * point to an array of mfns, or contiguously from a single starting
+ * mfn.
+ */
+static void xen_remap_exchanged_ptes(unsigned long vaddr, int order,
+                                     unsigned long *mfns,
+                                     unsigned long first_mfn)
+{
+        unsigned i, limit;
+        unsigned long mfn;
+
+        xen_mc_batch();
+
+        limit = 1u << order;
+        for (i = 0; i < limit; i++, vaddr += PAGE_SIZE) {
+                struct multicall_space mcs;
+                unsigned flags;
+
+                mcs = __xen_mc_entry(0);
+                if (mfns)
+                        mfn = mfns[i];
+                else
+                        mfn = first_mfn + i;
+
+                if (i < (limit - 1))
+                        flags = 0;
+                else {
+                        if (order == 0)
+                                flags = UVMF_INVLPG | UVMF_ALL;
+                        else
+                                flags = UVMF_TLB_FLUSH | UVMF_ALL;
+                }
+
+                MULTI_update_va_mapping(mcs.mc, vaddr,
+                                mfn_pte(mfn, PAGE_KERNEL), flags);
+
+                set_phys_to_machine(virt_to_pfn(vaddr), mfn);
+        }
+
+        xen_mc_issue(0);
+}
+
+/*
+ * Perform the hypercall to exchange a region of our pfns to point to
+ * memory with the required contiguous alignment.  Takes the pfns as
+ * input, and populates mfns as output.
+ *
+ * Returns a success code indicating whether the hypervisor was able to
+ * satisfy the request or not.
+ */
+static int xen_exchange_memory(unsigned long extents_in, unsigned int order_in,
+                               unsigned long *pfns_in,
+                               unsigned long extents_out,
+                               unsigned int order_out,
+                               unsigned long *mfns_out,
+                               unsigned int address_bits)
+{
+        long rc;
+        int success;
+
+        struct xen_memory_exchange exchange = {
+                .in = {
+                        .nr_extents   = extents_in,
+                        .extent_order = order_in,
+                        .extent_start = pfns_in,
+                        .domid        = DOMID_SELF
+                },
+                .out = {
+                        .nr_extents   = extents_out,
+                        .extent_order = order_out,
+                        .extent_start = mfns_out,
+                        .address_bits = address_bits,
+                        .domid        = DOMID_SELF
+                }
+        };
+
+        BUG_ON(extents_in << order_in != extents_out << order_out);
+
+        rc = HYPERVISOR_memory_op(XENMEM_exchange, &exchange);
+        success = (exchange.nr_exchanged == extents_in);
+
+        BUG_ON(!success && ((exchange.nr_exchanged != 0) || (rc == 0)));
+        BUG_ON(success && (rc != 0));
+
+        return success;
+}
+
+int xen_create_contiguous_region(unsigned long vstart, unsigned int order,
+                                 unsigned int address_bits)
+{
+        unsigned long *in_frames = discontig_frames, out_frame;
+        unsigned long  flags;
+        int            success;
+
+        /*
+         * Currently an auto-translated guest will not perform I/O, nor will
+         * it require PAE page directories below 4GB. Therefore any calls to
+         * this function are redundant and can be ignored.
+         */
+
+        if (xen_feature(XENFEAT_auto_translated_physmap))
+                return 0;
+
+        if (unlikely(order > MAX_CONTIG_ORDER))
+                return -ENOMEM;
+
+        memset((void *) vstart, 0, PAGE_SIZE << order);
+
+        spin_lock_irqsave(&xen_reservation_lock, flags);
+
+        /* 1. Zap current PTEs, remembering MFNs. */
+        xen_zap_pfn_range(vstart, order, in_frames, NULL);
+
+        /* 2. Get a new contiguous memory extent. */
+        out_frame = virt_to_pfn(vstart);
+        success = xen_exchange_memory(1UL << order, 0, in_frames,
+                                      1, order, &out_frame,
+                                      address_bits);
+
+        /* 3. Map the new extent in place of old pages. */
+        if (success)
+                xen_remap_exchanged_ptes(vstart, order, NULL, out_frame);
+        else
+                xen_remap_exchanged_ptes(vstart, order, in_frames, 0);
+
+        spin_unlock_irqrestore(&xen_reservation_lock, flags);
+
+        return success ? 0 : -ENOMEM;
+}
+EXPORT_SYMBOL_GPL(xen_create_contiguous_region);
+
+void xen_destroy_contiguous_region(unsigned long vstart, unsigned int order)
+{
+        unsigned long *out_frames = discontig_frames, in_frame;
+        unsigned long  flags;
+        int success;
+
+        if (xen_feature(XENFEAT_auto_translated_physmap))
+                return;
+
+        if (unlikely(order > MAX_CONTIG_ORDER))
+                return;
+
+        memset((void *) vstart, 0, PAGE_SIZE << order);
+
+        spin_lock_irqsave(&xen_reservation_lock, flags);
+
+        /* 1. Find start MFN of contiguous extent. */
+        in_frame = virt_to_mfn(vstart);
+
+        /* 2. Zap current PTEs. */
+        xen_zap_pfn_range(vstart, order, NULL, out_frames);
+
+        /* 3. Do the exchange for non-contiguous MFNs. */
+        success = xen_exchange_memory(1, order, &in_frame, 1UL << order,
+                                        0, out_frames, 0);
+
+        /* 4. Map new pages in place of old pages. */
+        if (success)
+                xen_remap_exchanged_ptes(vstart, order, out_frames, 0);
+        else
+                xen_remap_exchanged_ptes(vstart, order, NULL, in_frame);
+
+        spin_unlock_irqrestore(&xen_reservation_lock, flags);
 }
+EXPORT_SYMBOL_GPL(xen_destroy_contiguous_region);
 
 #ifdef CONFIG_XEN_PVHVM
 static void xen_hvm_exit_mmap(struct mm_struct *mm)
diff --git a/arch/x86/xen/pci-swiotlb-xen.c b/arch/x86/xen/pci-swiotlb-xen.c
new file mode 100644
index 00000000000..a013ec9d0c5
--- /dev/null
+++ b/arch/x86/xen/pci-swiotlb-xen.c
@@ -0,0 +1,58 @@
+/* Glue code to lib/swiotlb-xen.c */
+
+#include <linux/dma-mapping.h>
+#include <xen/swiotlb-xen.h>
+
+#include <asm/xen/hypervisor.h>
+#include <xen/xen.h>
+
+int xen_swiotlb __read_mostly;
+
+static struct dma_map_ops xen_swiotlb_dma_ops = {
+        .mapping_error = xen_swiotlb_dma_mapping_error,
+        .alloc_coherent = xen_swiotlb_alloc_coherent,
+        .free_coherent = xen_swiotlb_free_coherent,
+        .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu,
+        .sync_single_for_device = xen_swiotlb_sync_single_for_device,
+        .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu,
+        .sync_sg_for_device = xen_swiotlb_sync_sg_for_device,
+        .map_sg = xen_swiotlb_map_sg_attrs,
+        .unmap_sg = xen_swiotlb_unmap_sg_attrs,
+        .map_page = xen_swiotlb_map_page,
+        .unmap_page = xen_swiotlb_unmap_page,
+        .dma_supported = xen_swiotlb_dma_supported,
+};
+
+/*
+ * pci_xen_swiotlb_detect - set xen_swiotlb to 1 if necessary
+ *
+ * This returns non-zero if we are forced to use xen_swiotlb (by the boot
+ * option).
+ */
+int __init pci_xen_swiotlb_detect(void)
+{
+
+        /* If running as PV guest, either iommu=soft, or swiotlb=force will
+         * activate this IOMMU. If running as PV privileged, activate it
+         * irregardlesss.
+         */
+        if ((xen_initial_domain() || swiotlb || swiotlb_force) &&
+            (xen_pv_domain()))
+                xen_swiotlb = 1;
+
+        /* If we are running under Xen, we MUST disable the native SWIOTLB.
+         * Don't worry about swiotlb_force flag activating the native, as
+         * the 'swiotlb' flag is the only one turning it on. */
+        if (xen_pv_domain())
+                swiotlb = 0;
+
+        return xen_swiotlb;
+}
+
+void __init pci_xen_swiotlb_init(void)
+{
+        if (xen_swiotlb) {
+                xen_swiotlb_init(1);
+                dma_ops = &xen_swiotlb_dma_ops;
+        }
+}
diff --git a/block/blk-core.c b/block/blk-core.c
index 7da630e25ae..ee1a1e7e63c 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1514,7 +1514,10 @@ static inline void __generic_make_request(struct bio *bio)
                 if (bio_check_eod(bio, nr_sectors))
                         goto end_io;
 
-                if ((bio->bi_rw & REQ_DISCARD) && !blk_queue_discard(q)) {
+                if ((bio->bi_rw & REQ_DISCARD) &&
+                    (!blk_queue_discard(q) ||
+                     ((bio->bi_rw & REQ_SECURE) &&
+                      !blk_queue_secdiscard(q)))) {
                         err = -EOPNOTSUPP;
                         goto end_io;
                 }
diff --git a/block/blk-lib.c b/block/blk-lib.c
index c1fc55a83ba..c392029a104 100644
--- a/block/blk-lib.c
+++ b/block/blk-lib.c
@@ -62,6 +62,12 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                 max_discard_sectors &= ~(disc_sects - 1);
         }
 
+        if (flags & BLKDEV_IFL_SECURE) {
+                if (!blk_queue_secdiscard(q))
+                        return -EOPNOTSUPP;
+                type |= DISCARD_SECURE;
+        }
+
         while (nr_sects && !ret) {
                 bio = bio_alloc(gfp_mask, 1);
                 if (!bio) {
diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index d5308563773..119f07b74dc 100644
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -703,6 +703,7 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
         case BLKFLSBUF:
         case BLKROSET:
         case BLKDISCARD:
+        case BLKSECDISCARD:
         /*
          * the ones below are implemented in blkdev_locked_ioctl,
          * but we call blkdev_ioctl, which gets the lock for us
diff --git a/block/elevator.c b/block/elevator.c
index 816a7c8d639..ec585c9554d 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -83,6 +83,12 @@ int elv_rq_merge_ok(struct request *rq, struct bio *bio)
                 return 0;
 
         /*
+         * Don't merge discard requests and secure discard requests
+         */
+        if ((bio->bi_rw & REQ_SECURE) != (rq->bio->bi_rw & REQ_SECURE))
+                return 0;
+
+        /*
          * different data direction or already started, don't merge
          */
         if (bio_data_dir(bio) != rq_data_dir(rq))
diff --git a/block/ioctl.c b/block/ioctl.c
index 09fd7f1ef23..d8052f0dabd 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -114,8 +114,10 @@ static int blkdev_reread_part(struct block_device *bdev)
 }
 
 static int blk_ioctl_discard(struct block_device *bdev, uint64_t start,
-                             uint64_t len)
+                             uint64_t len, int secure)
 {
+        unsigned long flags = BLKDEV_IFL_WAIT;
+
         if (start & 511)
                 return -EINVAL;
         if (len & 511)
@@ -125,8 +127,9 @@ static int blk_ioctl_discard(struct block_device *bdev, uint64_t start,
 
         if (start + len > (bdev->bd_inode->i_size >> 9))
                 return -EINVAL;
-        return blkdev_issue_discard(bdev, start, len, GFP_KERNEL,
-                                    BLKDEV_IFL_WAIT);
+        if (secure)
+                flags |= BLKDEV_IFL_SECURE;
+        return blkdev_issue_discard(bdev, start, len, GFP_KERNEL, flags);
 }
 
 static int put_ushort(unsigned long arg, unsigned short val)
@@ -213,7 +216,8 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                 set_device_ro(bdev, n);
                 return 0;
 
-        case BLKDISCARD: {
+        case BLKDISCARD:
+        case BLKSECDISCARD: {
                 uint64_t range[2];
 
                 if (!(mode & FMODE_WRITE))
@@ -222,7 +226,8 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                 if (copy_from_user(range, (void __user *)arg, sizeof(range)))
                         return -EFAULT;
 
-                return blk_ioctl_discard(bdev, range[0], range[1]);
+                return blk_ioctl_discard(bdev, range[0], range[1],
+                                         cmd == BLKSECDISCARD);
         }
 
         case HDIO_GETGEO: {
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index 864dd46c346..18645f4e83c 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -33,6 +33,7 @@
 #include <linux/uaccess.h>
 #include <linux/cper.h>
 #include <linux/nmi.h>
+#include <linux/hardirq.h>
 #include <acpi/apei.h>
 
 #include "apei-internal.h"
diff --git a/drivers/ata/pata_mpc52xx.c b/drivers/ata/pata_mpc52xx.c
index f087ab55b1d..8cc536e49a0 100644
--- a/drivers/ata/pata_mpc52xx.c
+++ b/drivers/ata/pata_mpc52xx.c
@@ -680,7 +680,7 @@ mpc52xx_ata_remove_one(struct device *dev)
 /* ======================================================================== */
 
 static int __devinit
-mpc52xx_ata_probe(struct of_device *op, const struct of_device_id *match)
+mpc52xx_ata_probe(struct platform_device *op, const struct of_device_id *match)
 {
         unsigned int ipb_freq;
         struct resource res_mem;
@@ -821,7 +821,7 @@ mpc52xx_ata_probe(struct of_device *op, const struct of_device_id *match)
 }
 
 static int
-mpc52xx_ata_remove(struct of_device *op)
+mpc52xx_ata_remove(struct platform_device *op)
 {
         struct mpc52xx_ata_priv *priv;
         int task_irq;
@@ -848,7 +848,7 @@ mpc52xx_ata_remove(struct of_device *op)
 #ifdef CONFIG_PM
 
 static int
-mpc52xx_ata_suspend(struct of_device *op, pm_message_t state)
+mpc52xx_ata_suspend(struct platform_device *op, pm_message_t state)
 {
         struct ata_host *host = dev_get_drvdata(&op->dev);
 
@@ -856,7 +856,7 @@ mpc52xx_ata_suspend(struct of_device *op, pm_message_t state)
 }
 
 static int
-mpc52xx_ata_resume(struct of_device *op)
+mpc52xx_ata_resume(struct platform_device *op)
 {
         struct ata_host *host = dev_get_drvdata(&op->dev);
         struct mpc52xx_ata_priv *priv = host->private_data;
diff --git a/drivers/ata/pata_of_platform.c b/drivers/ata/pata_of_platform.c
index 5a1b82c08be..480e043ce6b 100644
--- a/drivers/ata/pata_of_platform.c
+++ b/drivers/ata/pata_of_platform.c
@@ -14,7 +14,7 @@
 #include <linux/of_platform.h>
 #include <linux/ata_platform.h>
 
-static int __devinit pata_of_platform_probe(struct of_device *ofdev,
+static int __devinit pata_of_platform_probe(struct platform_device *ofdev,
                                             const struct of_device_id *match)
 {
         int ret;
@@ -78,7 +78,7 @@ static int __devinit pata_of_platform_probe(struct of_device *ofdev,
                                      reg_shift, pio_mask);
 }
 
-static int __devexit pata_of_platform_remove(struct of_device *ofdev)
+static int __devexit pata_of_platform_remove(struct platform_device *ofdev)
 {
         return __pata_platform_remove(&ofdev->dev);
 }
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 18c986dbb7f..7325f77480d 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -1296,7 +1296,7 @@ static const struct ata_port_info sata_fsl_port_info[] = {
          },
 };
 
-static int sata_fsl_probe(struct of_device *ofdev,
+static int sata_fsl_probe(struct platform_device *ofdev,
                         const struct of_device_id *match)
 {
         int retval = -ENXIO;
@@ -1370,7 +1370,7 @@ error_exit_with_cleanup:
         return retval;
 }
 
-static int sata_fsl_remove(struct of_device *ofdev)
+static int sata_fsl_remove(struct platform_device *ofdev)
 {
         struct ata_host *host = dev_get_drvdata(&ofdev->dev);
         struct sata_fsl_host_priv *host_priv = host->private_data;
@@ -1387,13 +1387,13 @@ static int sata_fsl_remove(struct of_device *ofdev)
 }
 
 #ifdef CONFIG_PM
-static int sata_fsl_suspend(struct of_device *op, pm_message_t state)
+static int sata_fsl_suspend(struct platform_device *op, pm_message_t state)
 {
         struct ata_host *host = dev_get_drvdata(&op->dev);
         return ata_host_suspend(host, state);
 }
 
-static int sata_fsl_resume(struct of_device *op)
+static int sata_fsl_resume(struct platform_device *op)
 {
         struct ata_host *host = dev_get_drvdata(&op->dev);
         struct sata_fsl_host_priv *host_priv = host->private_data;
diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
index b7385e07771..c8fc69c85a0 100644
--- a/drivers/atm/fore200e.c
+++ b/drivers/atm/fore200e.c
@@ -674,7 +674,7 @@ static void fore200e_sba_write(u32 val, volatile u32 __iomem *addr)
 
 static u32 fore200e_sba_dma_map(struct fore200e *fore200e, void* virt_addr, int size, int direction)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
         u32 dma_addr;
 
         dma_addr = dma_map_single(&op->dev, virt_addr, size, direction);
@@ -687,7 +687,7 @@ static u32 fore200e_sba_dma_map(struct fore200e *fore200e, void* virt_addr, int
 
 static void fore200e_sba_dma_unmap(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
 
         DPRINTK(3, "SBUS DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d,\n",
                 dma_addr, size, direction);
@@ -697,7 +697,7 @@ static void fore200e_sba_dma_unmap(struct fore200e *fore200e, u32 dma_addr, int
 
 static void fore200e_sba_dma_sync_for_cpu(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
 
         DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
     
@@ -706,7 +706,7 @@ static void fore200e_sba_dma_sync_for_cpu(struct fore200e *fore200e, u32 dma_add
 
 static void fore200e_sba_dma_sync_for_device(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
 
         DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
 
@@ -719,7 +719,7 @@ static void fore200e_sba_dma_sync_for_device(struct fore200e *fore200e, u32 dma_
 static int fore200e_sba_dma_chunk_alloc(struct fore200e *fore200e, struct chunk *chunk,
                                         int size, int nbr, int alignment)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
 
         chunk->alloc_size = chunk->align_size = size * nbr;
 
@@ -738,7 +738,7 @@ static int fore200e_sba_dma_chunk_alloc(struct fore200e *fore200e, struct chunk
 /* free a DVMA consistent chunk of memory */
 static void fore200e_sba_dma_chunk_free(struct fore200e *fore200e, struct chunk *chunk)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
 
         dma_free_coherent(&op->dev, chunk->alloc_size,
                           chunk->alloc_addr, chunk->dma_addr);
@@ -770,7 +770,7 @@ static void fore200e_sba_reset(struct fore200e *fore200e)
 
 static int __init fore200e_sba_map(struct fore200e *fore200e)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
         unsigned int bursts;
 
         /* gain access to the SBA specific registers  */
@@ -800,7 +800,7 @@ static int __init fore200e_sba_map(struct fore200e *fore200e)
 
 static void fore200e_sba_unmap(struct fore200e *fore200e)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
 
         of_iounmap(&op->resource[0], fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
         of_iounmap(&op->resource[1], fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
@@ -816,7 +816,7 @@ static int __init fore200e_sba_configure(struct fore200e *fore200e)
 
 static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_data *prom)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
         const u8 *prop;
         int len;
 
@@ -840,7 +840,7 @@ static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_
 
 static int fore200e_sba_proc_read(struct fore200e *fore200e, char *page)
 {
-        struct of_device *op = fore200e->bus_dev;
+        struct platform_device *op = fore200e->bus_dev;
         const struct linux_prom_registers *regs;
 
         regs = of_get_property(op->dev.of_node, "reg", NULL);
@@ -2513,7 +2513,7 @@ fore200e_load_and_start_fw(struct fore200e* fore200e)
         device = &((struct pci_dev *) fore200e->bus_dev)->dev;
 #ifdef CONFIG_SBUS
     else if (strcmp(fore200e->bus->model_name, "SBA-200E") == 0)
-        device = &((struct of_device *) fore200e->bus_dev)->dev;
+        device = &((struct platform_device *) fore200e->bus_dev)->dev;
 #endif
     else
         return err;
@@ -2643,7 +2643,7 @@ fore200e_init(struct fore200e* fore200e)
 }
 
 #ifdef CONFIG_SBUS
-static int __devinit fore200e_sba_probe(struct of_device *op,
+static int __devinit fore200e_sba_probe(struct platform_device *op,
                                         const struct of_device_id *match)
 {
         const struct fore200e_bus *bus = match->data;
@@ -2675,7 +2675,7 @@ static int __devinit fore200e_sba_probe(struct of_device *op,
         return 0;
 }
 
-static int __devexit fore200e_sba_remove(struct of_device *op)
+static int __devexit fore200e_sba_remove(struct platform_device *op)
 {
         struct fore200e *fore200e = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index b71888b909a..2982b3ee946 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -1194,7 +1194,7 @@ static struct platform_driver ace_platform_driver = {
 
 #if defined(CONFIG_OF)
 static int __devinit
-ace_of_probe(struct of_device *op, const struct of_device_id *match)
+ace_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource res;
         resource_size_t physaddr;
@@ -1226,7 +1226,7 @@ ace_of_probe(struct of_device *op, const struct of_device_id *match)
         return ace_alloc(&op->dev, id ? *id : 0, physaddr, irq, bus_width);
 }
 
-static int __devexit ace_of_remove(struct of_device *op)
+static int __devexit ace_of_remove(struct platform_device *op)
 {
         ace_free(&op->dev);
         return 0;
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 7cfcc629a7f..3d44ec724c1 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -1002,7 +1002,7 @@ config SCx200_GPIO
 
 config PC8736x_GPIO
         tristate "NatSemi PC8736x GPIO Support"
-        depends on X86
+        depends on X86_32
         default SCx200_GPIO     # mostly N
         select NSC_GPIO         # needed for support routines
         help
diff --git a/drivers/char/hw_random/n2-drv.c b/drivers/char/hw_random/n2-drv.c
index 7a4f080f835..1acdb250951 100644
--- a/drivers/char/hw_random/n2-drv.c
+++ b/drivers/char/hw_random/n2-drv.c
@@ -619,7 +619,7 @@ static void __devinit n2rng_driver_version(void)
                 pr_info("%s", version);
 }
 
-static int __devinit n2rng_probe(struct of_device *op,
+static int __devinit n2rng_probe(struct platform_device *op,
                                  const struct of_device_id *match)
 {
         int victoria_falls = (match->data != NULL);
@@ -714,7 +714,7 @@ out:
         return err;
 }
 
-static int __devexit n2rng_remove(struct of_device *op)
+static int __devexit n2rng_remove(struct platform_device *op)
 {
         struct n2rng *np = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/char/hw_random/n2rng.h b/drivers/char/hw_random/n2rng.h
index a2b81e7bfc1..4bea07f3097 100644
--- a/drivers/char/hw_random/n2rng.h
+++ b/drivers/char/hw_random/n2rng.h
@@ -65,7 +65,7 @@ struct n2rng_unit {
 };
 
 struct n2rng {
-        struct of_device        *op;
+        struct platform_device  *op;
 
         unsigned long           flags;
 #define N2RNG_FLAG_VF           0x00000001 /* Victoria Falls RNG, else N2 */
diff --git a/drivers/char/hw_random/pasemi-rng.c b/drivers/char/hw_random/pasemi-rng.c
index 261ba8f22b8..a31c830ca8c 100644
--- a/drivers/char/hw_random/pasemi-rng.c
+++ b/drivers/char/hw_random/pasemi-rng.c
@@ -94,7 +94,7 @@ static struct hwrng pasemi_rng = {
         .data_read      = pasemi_rng_data_read,
 };
 
-static int __devinit rng_probe(struct of_device *ofdev,
+static int __devinit rng_probe(struct platform_device *ofdev,
                                const struct of_device_id *match)
 {
         void __iomem *rng_regs;
@@ -123,7 +123,7 @@ static int __devinit rng_probe(struct of_device *ofdev,
         return err;
 }
 
-static int __devexit rng_remove(struct of_device *dev)
+static int __devexit rng_remove(struct platform_device *dev)
 {
         void __iomem *rng_regs = (void __iomem *)pasemi_rng.priv;
 
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 48330e0fd48..3822b4f49c8 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -2528,7 +2528,7 @@ static struct pci_driver ipmi_pci_driver = {
 
 
 #ifdef CONFIG_PPC_OF
-static int __devinit ipmi_of_probe(struct of_device *dev,
+static int __devinit ipmi_of_probe(struct platform_device *dev,
                          const struct of_device_id *match)
 {
         struct smi_info *info;
@@ -2607,7 +2607,7 @@ static int __devinit ipmi_of_probe(struct of_device *dev,
         return 0;
 }
 
-static int __devexit ipmi_of_remove(struct of_device *dev)
+static int __devexit ipmi_of_remove(struct platform_device *dev)
 {
         cleanup_one_si(dev_get_drvdata(&dev->dev));
         return 0;
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index 95acb8c880f..dfa8b3062fd 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -961,7 +961,7 @@ static int __init rtc_init(void)
 #endif
 #ifdef CONFIG_SPARC32
         struct device_node *ebus_dp;
-        struct of_device *op;
+        struct platform_device *op;
 #else
         void *r;
 #ifdef RTC_IRQ
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.c b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
index ed8a9cec2a0..0ed763cd2e7 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.c
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
@@ -761,7 +761,7 @@ static struct platform_driver hwicap_platform_driver = {
 
 #if defined(CONFIG_OF)
 static int __devinit
-hwicap_of_probe(struct of_device *op, const struct of_device_id *match)
+hwicap_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource res;
         const unsigned int *id;
@@ -798,7 +798,7 @@ hwicap_of_probe(struct of_device *op, const struct of_device_id *match)
                         regs);
 }
 
-static int __devexit hwicap_of_remove(struct of_device *op)
+static int __devexit hwicap_of_remove(struct platform_device *op)
 {
         return hwicap_remove(&op->dev);
 }
diff --git a/drivers/crypto/amcc/crypto4xx_core.c b/drivers/crypto/amcc/crypto4xx_core.c
index 983530ba04a..2b1baee525b 100644
--- a/drivers/crypto/amcc/crypto4xx_core.c
+++ b/drivers/crypto/amcc/crypto4xx_core.c
@@ -1150,7 +1150,7 @@ struct crypto4xx_alg_common crypto4xx_alg[] = {
 /**
  * Module Initialization Routine
  */
-static int __init crypto4xx_probe(struct of_device *ofdev,
+static int __init crypto4xx_probe(struct platform_device *ofdev,
                                   const struct of_device_id *match)
 {
         int rc;
@@ -1258,7 +1258,7 @@ err_alloc_dev:
         return rc;
 }
 
-static int __exit crypto4xx_remove(struct of_device *ofdev)
+static int __exit crypto4xx_remove(struct platform_device *ofdev)
 {
         struct device *dev = &ofdev->dev;
         struct crypto4xx_core_device *core_dev = dev_get_drvdata(dev);
diff --git a/drivers/crypto/amcc/crypto4xx_core.h b/drivers/crypto/amcc/crypto4xx_core.h
index da9cbe3b9fc..bac0bdeb4b5 100644
--- a/drivers/crypto/amcc/crypto4xx_core.h
+++ b/drivers/crypto/amcc/crypto4xx_core.h
@@ -104,7 +104,7 @@ struct crypto4xx_device {
 
 struct crypto4xx_core_device {
         struct device *device;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         struct crypto4xx_device *dev;
         u32 int_status;
         u32 irq;
diff --git a/drivers/crypto/n2_core.c b/drivers/crypto/n2_core.c
index 26af2dd5d83..88ee01510ec 100644
--- a/drivers/crypto/n2_core.c
+++ b/drivers/crypto/n2_core.c
@@ -1552,7 +1552,7 @@ static void __exit n2_unregister_algs(void)
 
 /* To map CWQ queues to interrupt sources, the hypervisor API provides
  * a devino.  This isn't very useful to us because all of the
- * interrupts listed in the of_device node have been translated to
+ * interrupts listed in the device_node have been translated to
  * Linux virtual IRQ cookie numbers.
  *
  * So we have to back-translate, going through the 'intr' and 'ino'
@@ -1560,7 +1560,7 @@ static void __exit n2_unregister_algs(void)
  * 'interrupts' property entries, in order to to figure out which
  * devino goes to which already-translated IRQ.
  */
-static int find_devino_index(struct of_device *dev, struct spu_mdesc_info *ip,
+static int find_devino_index(struct platform_device *dev, struct spu_mdesc_info *ip,
                              unsigned long dev_ino)
 {
         const unsigned int *dev_intrs;
@@ -1580,7 +1580,7 @@ static int find_devino_index(struct of_device *dev, struct spu_mdesc_info *ip,
         if (!dev_intrs)
                 return -ENODEV;
 
-        for (i = 0; i < dev->num_irqs; i++) {
+        for (i = 0; i < dev->archdata.num_irqs; i++) {
                 if (dev_intrs[i] == intr)
                         return i;
         }
@@ -1588,7 +1588,7 @@ static int find_devino_index(struct of_device *dev, struct spu_mdesc_info *ip,
         return -ENODEV;
 }
 
-static int spu_map_ino(struct of_device *dev, struct spu_mdesc_info *ip,
+static int spu_map_ino(struct platform_device *dev, struct spu_mdesc_info *ip,
                        const char *irq_name, struct spu_queue *p,
                        irq_handler_t handler)
 {
@@ -1603,7 +1603,7 @@ static int spu_map_ino(struct of_device *dev, struct spu_mdesc_info *ip,
         if (index < 0)
                 return index;
 
-        p->irq = dev->irqs[index];
+        p->irq = dev->archdata.irqs[index];
 
         sprintf(p->irq_name, "%s-%d", irq_name, index);
 
@@ -1736,7 +1736,7 @@ static void spu_list_destroy(struct list_head *list)
  * gathering cpu membership information.
  */
 static int spu_mdesc_walk_arcs(struct mdesc_handle *mdesc,
-                               struct of_device *dev,
+                               struct platform_device *dev,
                                u64 node, struct spu_queue *p,
                                struct spu_queue **table)
 {
@@ -1763,7 +1763,7 @@ static int spu_mdesc_walk_arcs(struct mdesc_handle *mdesc,
 
 /* Process an 'exec-unit' MDESC node of type 'cwq'.  */
 static int handle_exec_unit(struct spu_mdesc_info *ip, struct list_head *list,
-                            struct of_device *dev, struct mdesc_handle *mdesc,
+                            struct platform_device *dev, struct mdesc_handle *mdesc,
                             u64 node, const char *iname, unsigned long q_type,
                             irq_handler_t handler, struct spu_queue **table)
 {
@@ -1794,7 +1794,7 @@ static int handle_exec_unit(struct spu_mdesc_info *ip, struct list_head *list,
         return spu_map_ino(dev, ip, iname, p, handler);
 }
 
-static int spu_mdesc_scan(struct mdesc_handle *mdesc, struct of_device *dev,
+static int spu_mdesc_scan(struct mdesc_handle *mdesc, struct platform_device *dev,
                           struct spu_mdesc_info *ip, struct list_head *list,
                           const char *exec_name, unsigned long q_type,
                           irq_handler_t handler, struct spu_queue **table)
@@ -1855,7 +1855,7 @@ static int __devinit get_irq_props(struct mdesc_handle *mdesc, u64 node,
 }
 
 static int __devinit grab_mdesc_irq_props(struct mdesc_handle *mdesc,
-                                          struct of_device *dev,
+                                          struct platform_device *dev,
                                           struct spu_mdesc_info *ip,
                                           const char *node_name)
 {
@@ -2004,7 +2004,7 @@ static void __devinit n2_spu_driver_version(void)
                 pr_info("%s", version);
 }
 
-static int __devinit n2_crypto_probe(struct of_device *dev,
+static int __devinit n2_crypto_probe(struct platform_device *dev,
                                      const struct of_device_id *match)
 {
         struct mdesc_handle *mdesc;
@@ -2081,7 +2081,7 @@ out_free_n2cp:
         return err;
 }
 
-static int __devexit n2_crypto_remove(struct of_device *dev)
+static int __devexit n2_crypto_remove(struct platform_device *dev)
 {
         struct n2_crypto *np = dev_get_drvdata(&dev->dev);
 
@@ -2116,7 +2116,7 @@ static void free_ncp(struct n2_mau *mp)
         kfree(mp);
 }
 
-static int __devinit n2_mau_probe(struct of_device *dev,
+static int __devinit n2_mau_probe(struct platform_device *dev,
                                      const struct of_device_id *match)
 {
         struct mdesc_handle *mdesc;
@@ -2184,7 +2184,7 @@ out_free_ncp:
         return err;
 }
 
-static int __devexit n2_mau_remove(struct of_device *dev)
+static int __devexit n2_mau_remove(struct platform_device *dev)
 {
         struct n2_mau *mp = dev_get_drvdata(&dev->dev);
 
diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index 97f4af1d8a6..4bcd825b573 100644
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -118,7 +118,7 @@ struct talitos_channel {
 
 struct talitos_private {
         struct device *dev;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         void __iomem *reg;
         int irq;
 
@@ -2308,7 +2308,7 @@ static int hw_supports(struct device *dev, __be32 desc_hdr_template)
         return ret;
 }
 
-static int talitos_remove(struct of_device *ofdev)
+static int talitos_remove(struct platform_device *ofdev)
 {
         struct device *dev = &ofdev->dev;
         struct talitos_private *priv = dev_get_drvdata(dev);
@@ -2401,7 +2401,7 @@ static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev,
         return t_alg;
 }
 
-static int talitos_probe(struct of_device *ofdev,
+static int talitos_probe(struct platform_device *ofdev,
                          const struct of_device_id *match)
 {
         struct device *dev = &ofdev->dev;
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index f0fd6db6063..cea08bed9cf 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -1297,7 +1297,7 @@ static void fsl_dma_chan_remove(struct fsldma_chan *chan)
         kfree(chan);
 }
 
-static int __devinit fsldma_of_probe(struct of_device *op,
+static int __devinit fsldma_of_probe(struct platform_device *op,
                         const struct of_device_id *match)
 {
         struct fsldma_device *fdev;
@@ -1382,7 +1382,7 @@ out_return:
         return err;
 }
 
-static int fsldma_of_remove(struct of_device *op)
+static int fsldma_of_remove(struct platform_device *op)
 {
         struct fsldma_device *fdev;
         unsigned int i;
diff --git a/drivers/dma/mpc512x_dma.c b/drivers/dma/mpc512x_dma.c
index 14a8c0f1698..4e9cbf30059 100644
--- a/drivers/dma/mpc512x_dma.c
+++ b/drivers/dma/mpc512x_dma.c
@@ -627,7 +627,7 @@ mpc_dma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,
         return &mdesc->desc;
 }
 
-static int __devinit mpc_dma_probe(struct of_device *op,
+static int __devinit mpc_dma_probe(struct platform_device *op,
                                         const struct of_device_id *match)
 {
         struct device_node *dn = op->dev.of_node;
@@ -753,7 +753,7 @@ static int __devinit mpc_dma_probe(struct of_device *op,
         return retval;
 }
 
-static int __devexit mpc_dma_remove(struct of_device *op)
+static int __devexit mpc_dma_remove(struct platform_device *op)
 {
         struct device *dev = &op->dev;
         struct mpc_dma *mdma = dev_get_drvdata(dev);
diff --git a/drivers/dma/ppc4xx/adma.c b/drivers/dma/ppc4xx/adma.c
index 7c3747902a3..0d58a4a4487 100644
--- a/drivers/dma/ppc4xx/adma.c
+++ b/drivers/dma/ppc4xx/adma.c
@@ -4257,11 +4257,11 @@ static int ppc440spe_adma_setup_irqs(struct ppc440spe_adma_device *adev,
                                      struct ppc440spe_adma_chan *chan,
                                      int *initcode)
 {
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         struct device_node *np;
         int ret;
 
-        ofdev = container_of(adev->dev, struct of_device, dev);
+        ofdev = container_of(adev->dev, struct platform_device, dev);
         np = ofdev->dev.of_node;
         if (adev->id != PPC440SPE_XOR_ID) {
                 adev->err_irq = irq_of_parse_and_map(np, 1);
@@ -4393,7 +4393,7 @@ static void ppc440spe_adma_release_irqs(struct ppc440spe_adma_device *adev,
 /**
  * ppc440spe_adma_probe - probe the asynch device
  */
-static int __devinit ppc440spe_adma_probe(struct of_device *ofdev,
+static int __devinit ppc440spe_adma_probe(struct platform_device *ofdev,
                                           const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -4625,7 +4625,7 @@ out:
 /**
  * ppc440spe_adma_remove - remove the asynch device
  */
-static int __devexit ppc440spe_adma_remove(struct of_device *ofdev)
+static int __devexit ppc440spe_adma_remove(struct platform_device *ofdev)
 {
         struct ppc440spe_adma_device *adev = dev_get_drvdata(&ofdev->dev);
         struct device_node *np = ofdev->dev.of_node;
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index af75e27f522..b123bb308a4 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -200,7 +200,7 @@ static irqreturn_t mpc85xx_pci_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int __devinit mpc85xx_pci_err_probe(struct of_device *op,
+static int __devinit mpc85xx_pci_err_probe(struct platform_device *op,
                                            const struct of_device_id *match)
 {
         struct edac_pci_ctl_info *pci;
@@ -305,7 +305,7 @@ err:
         return res;
 }
 
-static int mpc85xx_pci_err_remove(struct of_device *op)
+static int mpc85xx_pci_err_remove(struct platform_device *op)
 {
         struct edac_pci_ctl_info *pci = dev_get_drvdata(&op->dev);
         struct mpc85xx_pci_pdata *pdata = pci->pvt_info;
@@ -503,7 +503,7 @@ static irqreturn_t mpc85xx_l2_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int __devinit mpc85xx_l2_err_probe(struct of_device *op,
+static int __devinit mpc85xx_l2_err_probe(struct platform_device *op,
                                           const struct of_device_id *match)
 {
         struct edac_device_ctl_info *edac_dev;
@@ -613,7 +613,7 @@ err:
         return res;
 }
 
-static int mpc85xx_l2_err_remove(struct of_device *op)
+static int mpc85xx_l2_err_remove(struct platform_device *op)
 {
         struct edac_device_ctl_info *edac_dev = dev_get_drvdata(&op->dev);
         struct mpc85xx_l2_pdata *pdata = edac_dev->pvt_info;
@@ -956,7 +956,7 @@ static void __devinit mpc85xx_init_csrows(struct mem_ctl_info *mci)
         }
 }
 
-static int __devinit mpc85xx_mc_err_probe(struct of_device *op,
+static int __devinit mpc85xx_mc_err_probe(struct platform_device *op,
                                           const struct of_device_id *match)
 {
         struct mem_ctl_info *mci;
@@ -1088,7 +1088,7 @@ err:
         return res;
 }
 
-static int mpc85xx_mc_err_remove(struct of_device *op)
+static int mpc85xx_mc_err_remove(struct platform_device *op)
 {
         struct mem_ctl_info *mci = dev_get_drvdata(&op->dev);
         struct mpc85xx_mc_pdata *pdata = mci->pvt_info;
diff --git a/drivers/edac/ppc4xx_edac.c b/drivers/edac/ppc4xx_edac.c
index e78839e89a0..070cea41b66 100644
--- a/drivers/edac/ppc4xx_edac.c
+++ b/drivers/edac/ppc4xx_edac.c
@@ -184,9 +184,9 @@ struct ppc4xx_ecc_status {
 
 /* Function Prototypes */
 
-static int ppc4xx_edac_probe(struct of_device *device,
+static int ppc4xx_edac_probe(struct platform_device *device,
                              const struct of_device_id *device_id);
-static int ppc4xx_edac_remove(struct of_device *device);
+static int ppc4xx_edac_remove(struct platform_device *device);
 
 /* Global Variables */
 
@@ -1014,7 +1014,7 @@ ppc4xx_edac_init_csrows(struct mem_ctl_info *mci, u32 mcopt1)
  */
 static int __devinit
 ppc4xx_edac_mc_init(struct mem_ctl_info *mci,
-                    struct of_device *op,
+                    struct platform_device *op,
                     const struct of_device_id *match,
                     const dcr_host_t *dcr_host,
                     u32 mcopt1)
@@ -1108,7 +1108,7 @@ ppc4xx_edac_mc_init(struct mem_ctl_info *mci,
  * mapped and assigned.
  */
 static int __devinit
-ppc4xx_edac_register_irq(struct of_device *op, struct mem_ctl_info *mci)
+ppc4xx_edac_register_irq(struct platform_device *op, struct mem_ctl_info *mci)
 {
         int status = 0;
         int ded_irq, sec_irq;
@@ -1238,7 +1238,7 @@ ppc4xx_edac_map_dcrs(const struct device_node *np, dcr_host_t *dcr_host)
  * driver; otherwise, < 0 on error.
  */
 static int __devinit
-ppc4xx_edac_probe(struct of_device *op, const struct of_device_id *match)
+ppc4xx_edac_probe(struct platform_device *op, const struct of_device_id *match)
 {
         int status = 0;
         u32 mcopt1, memcheck;
@@ -1359,7 +1359,7 @@ ppc4xx_edac_probe(struct of_device *op, const struct of_device_id *match)
  * Unconditionally returns 0.
  */
 static int
-ppc4xx_edac_remove(struct of_device *op)
+ppc4xx_edac_remove(struct platform_device *op)
 {
         struct mem_ctl_info *mci = dev_get_drvdata(&op->dev);
         struct ppc4xx_edac_pdata *pdata = mci->pvt_info;
diff --git a/drivers/gpu/drm/ati_pcigart.c b/drivers/gpu/drm/ati_pcigart.c
index 17be051b7aa..1c364924220 100644
--- a/drivers/gpu/drm/ati_pcigart.c
+++ b/drivers/gpu/drm/ati_pcigart.c
@@ -152,7 +152,7 @@ int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *ga
                 /* we need to support large memory configurations */
                 entry->busaddr[i] = pci_map_page(dev->pdev, entry->pagelist[i],
                                                  0, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-                if (entry->busaddr[i] == 0) {
+                if (pci_dma_mapping_error(dev->pdev, entry->busaddr[i])) {
                         DRM_ERROR("unable to map PCIGART pages!\n");
                         drm_ati_pcigart_cleanup(dev, gart_info);
                         address = NULL;
diff --git a/drivers/gpu/drm/drm_bufs.c b/drivers/gpu/drm/drm_bufs.c
index a5c9ce93bbc..3e257a50bf5 100644
--- a/drivers/gpu/drm/drm_bufs.c
+++ b/drivers/gpu/drm/drm_bufs.c
@@ -328,14 +328,13 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                 return -EINVAL;
         }
 
-        list = kmalloc(sizeof(*list), GFP_KERNEL);
+        list = kzalloc(sizeof(*list), GFP_KERNEL);
         if (!list) {
                 if (map->type == _DRM_REGISTERS)
                         iounmap(map->handle);
                 kfree(map);
                 return -EINVAL;
         }
-        memset(list, 0, sizeof(*list));
         list->map = map;
 
         mutex_lock(&dev->struct_mutex);
@@ -678,13 +677,12 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
                 return -EINVAL;
         }
 
-        entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
+        entry->buflist = kzalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
         if (!entry->buflist) {
                 mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
-        memset(entry->buflist, 0, count * sizeof(*entry->buflist));
 
         entry->buf_size = size;
         entry->page_order = page_order;
@@ -708,7 +706,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
                 buf->file_priv = NULL;
 
                 buf->dev_priv_size = dev->driver->dev_priv_size;
-                buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
+                buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
                 if (!buf->dev_private) {
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
@@ -717,7 +715,6 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
-                memset(buf->dev_private, 0, buf->dev_priv_size);
 
                 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
 
@@ -832,22 +829,20 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                 return -EINVAL;
         }
 
-        entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
+        entry->buflist = kzalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
         if (!entry->buflist) {
                 mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
-        memset(entry->buflist, 0, count * sizeof(*entry->buflist));
 
-        entry->seglist = kmalloc(count * sizeof(*entry->seglist), GFP_KERNEL);
+        entry->seglist = kzalloc(count * sizeof(*entry->seglist), GFP_KERNEL);
         if (!entry->seglist) {
                 kfree(entry->buflist);
                 mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
-        memset(entry->seglist, 0, count * sizeof(*entry->seglist));
 
         /* Keep the original pagelist until we know all the allocations
          * have succeeded
@@ -911,8 +906,8 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                         buf->file_priv = NULL;
 
                         buf->dev_priv_size = dev->driver->dev_priv_size;
-                        buf->dev_private = kmalloc(buf->dev_priv_size,
-                                                  GFP_KERNEL);
+                        buf->dev_private = kzalloc(buf->dev_priv_size,
+                                                GFP_KERNEL);
                         if (!buf->dev_private) {
                                 /* Set count correctly so we free the proper amount. */
                                 entry->buf_count = count;
@@ -923,7 +918,6 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                                 atomic_dec(&dev->buf_alloc);
                                 return -ENOMEM;
                         }
-                        memset(buf->dev_private, 0, buf->dev_priv_size);
 
                         DRM_DEBUG("buffer %d @ %p\n",
                                   entry->buf_count, buf->address);
@@ -1048,14 +1042,13 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
                 return -EINVAL;
         }
 
-        entry->buflist = kmalloc(count * sizeof(*entry->buflist),
+        entry->buflist = kzalloc(count * sizeof(*entry->buflist),
                                 GFP_KERNEL);
         if (!entry->buflist) {
                 mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
-        memset(entry->buflist, 0, count * sizeof(*entry->buflist));
 
         entry->buf_size = size;
         entry->page_order = page_order;
@@ -1080,7 +1073,7 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
                 buf->file_priv = NULL;
 
                 buf->dev_priv_size = dev->driver->dev_priv_size;
-                buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
+                buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
                 if (!buf->dev_private) {
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
@@ -1090,8 +1083,6 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
                         return -ENOMEM;
                 }
 
-                memset(buf->dev_private, 0, buf->dev_priv_size);
-
                 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
 
                 offset += alignment;
@@ -1209,14 +1200,13 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
                 return -EINVAL;
         }
 
-        entry->buflist = kmalloc(count * sizeof(*entry->buflist),
+        entry->buflist = kzalloc(count * sizeof(*entry->buflist),
                                 GFP_KERNEL);
         if (!entry->buflist) {
                 mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
-        memset(entry->buflist, 0, count * sizeof(*entry->buflist));
 
         entry->buf_size = size;
         entry->page_order = page_order;
@@ -1240,7 +1230,7 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
                 buf->file_priv = NULL;
 
                 buf->dev_priv_size = dev->driver->dev_priv_size;
-                buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
+                buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
                 if (!buf->dev_private) {
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
@@ -1249,7 +1239,6 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
-                memset(buf->dev_private, 0, buf->dev_priv_size);
 
                 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
 
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 4c68f76993d..37e0b4fa482 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -1682,9 +1682,9 @@ int drm_mode_addfb(struct drm_device *dev,
         /* TODO setup destructor callback */
 
         fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
-        if (!fb) {
+        if (IS_ERR(fb)) {
                 DRM_ERROR("could not create framebuffer\n");
-                ret = -EINVAL;
+                ret = PTR_ERR(fb);
                 goto out;
         }
 
@@ -2541,7 +2541,7 @@ int drm_mode_gamma_set_ioctl(struct drm_device *dev,
                 goto out;
         }
 
-        crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);
+        crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
 
 out:
         mutex_unlock(&dev->mode_config.mutex);
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index b9e4dbfa053..7e31d434834 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -817,12 +817,12 @@ int drm_helper_resume_force_mode(struct drm_device *dev)
                                 if (encoder_funcs->dpms)
                                         (*encoder_funcs->dpms) (encoder,
                                                                 drm_helper_choose_encoder_dpms(encoder));
-
-                                crtc_funcs = crtc->helper_private;
-                                if (crtc_funcs->dpms)
-                                        (*crtc_funcs->dpms) (crtc,
-                                                             drm_helper_choose_crtc_dpms(crtc));
                         }
+
+                        crtc_funcs = crtc->helper_private;
+                        if (crtc_funcs->dpms)
+                                (*crtc_funcs->dpms) (crtc,
+                                                     drm_helper_choose_crtc_dpms(crtc));
                 }
         }
         /* disable the unused connectors while restoring the modesetting */
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index dce5c4a97f8..96e96310822 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -33,6 +33,11 @@
 #include <linux/i2c-algo-bit.h>
 #include "drmP.h"
 #include "drm_edid.h"
+#include "drm_edid_modes.h"
+
+#define version_greater(edid, maj, min) \
+        (((edid)->version > (maj)) || \
+         ((edid)->version == (maj) && (edid)->revision > (min)))
 
 #define EDID_EST_TIMINGS 16
 #define EDID_STD_TIMINGS 8
@@ -62,6 +67,13 @@
 /* use +hsync +vsync for detailed mode */
 #define EDID_QUIRK_DETAILED_SYNC_PP             (1 << 6)
 
+struct detailed_mode_closure {
+        struct drm_connector *connector;
+        struct edid *edid;
+        bool preferred;
+        u32 quirks;
+        int modes;
+};
 
 #define LEVEL_DMT       0
 #define LEVEL_GTF       1
@@ -375,7 +387,6 @@ static u32 edid_get_quirks(struct edid *edid)
 #define MODE_SIZE(m) ((m)->hdisplay * (m)->vdisplay)
 #define MODE_REFRESH_DIFF(m,r) (abs((m)->vrefresh - target_refresh))
 
-
 /**
  * edid_fixup_preferred - set preferred modes based on quirk list
  * @connector: has mode list to fix up
@@ -422,245 +433,6 @@ static void edid_fixup_preferred(struct drm_connector *connector,
         preferred_mode->type |= DRM_MODE_TYPE_PREFERRED;
 }
 
-/*
- * Add the Autogenerated from the DMT spec.
- * This table is copied from xfree86/modes/xf86EdidModes.c.
- * But the mode with Reduced blank feature is deleted.
- */
-static struct drm_display_mode drm_dmt_modes[] = {
-        /* 640x350@85Hz */
-        { DRM_MODE("640x350", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
-                   736, 832, 0, 350, 382, 385, 445, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 640x400@85Hz */
-        { DRM_MODE("640x400", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
-                   736, 832, 0, 400, 401, 404, 445, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 720x400@85Hz */
-        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 756,
-                   828, 936, 0, 400, 401, 404, 446, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 640x480@60Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
-                   752, 800, 0, 480, 489, 492, 525, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 640x480@72Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
-                   704, 832, 0, 480, 489, 492, 520, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 640x480@75Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
-                   720, 840, 0, 480, 481, 484, 500, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 640x480@85Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 36000, 640, 696,
-                   752, 832, 0, 480, 481, 484, 509, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 800x600@56Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
-                   896, 1024, 0, 600, 601, 603, 625, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 800x600@60Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
-                   968, 1056, 0, 600, 601, 605, 628, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 800x600@72Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
-                   976, 1040, 0, 600, 637, 643, 666, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 800x600@75Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
-                   896, 1056, 0, 600, 601, 604, 625, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 800x600@85Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 56250, 800, 832,
-                   896, 1048, 0, 600, 601, 604, 631, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 848x480@60Hz */
-        { DRM_MODE("848x480", DRM_MODE_TYPE_DRIVER, 33750, 848, 864,
-                   976, 1088, 0, 480, 486, 494, 517, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1024x768@43Hz, interlace */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 44900, 1024, 1032,
-                   1208, 1264, 0, 768, 768, 772, 817, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
-                        DRM_MODE_FLAG_INTERLACE) },
-        /* 1024x768@60Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
-                   1184, 1344, 0, 768, 771, 777, 806, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 1024x768@70Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
-                   1184, 1328, 0, 768, 771, 777, 806, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 1024x768@75Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78750, 1024, 1040,
-                   1136, 1312, 0, 768, 769, 772, 800, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1024x768@85Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 94500, 1024, 1072,
-                   1168, 1376, 0, 768, 769, 772, 808, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1152x864@75Hz */
-        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
-                   1344, 1600, 0, 864, 865, 868, 900, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x768@60Hz */
-        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
-                   1472, 1664, 0, 768, 771, 778, 798, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x768@75Hz */
-        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 102250, 1280, 1360,
-                   1488, 1696, 0, 768, 771, 778, 805, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 1280x768@85Hz */
-        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 117500, 1280, 1360,
-                   1496, 1712, 0, 768, 771, 778, 809, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x800@60Hz */
-        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
-                   1480, 1680, 0, 800, 803, 809, 831, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 1280x800@75Hz */
-        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 106500, 1280, 1360,
-                   1488, 1696, 0, 800, 803, 809, 838, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x800@85Hz */
-        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 122500, 1280, 1360,
-                   1496, 1712, 0, 800, 803, 809, 843, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x960@60Hz */
-        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
-                   1488, 1800, 0, 960, 961, 964, 1000, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x960@85Hz */
-        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1344,
-                   1504, 1728, 0, 960, 961, 964, 1011, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x1024@60Hz */
-        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
-                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x1024@75Hz */
-        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
-                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x1024@85Hz */
-        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 157500, 1280, 1344,
-                   1504, 1728, 0, 1024, 1025, 1028, 1072, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1360x768@60Hz */
-        { DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
-                   1536, 1792, 0, 768, 771, 777, 795, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x1050@60Hz */
-        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
-                   1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x1050@75Hz */
-        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 156000, 1400, 1504,
-                   1648, 1896, 0, 1050, 1053, 1057, 1099, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x1050@85Hz */
-        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 179500, 1400, 1504,
-                   1656, 1912, 0, 1050, 1053, 1057, 1105, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x900@60Hz */
-        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
-                   1672, 1904, 0, 900, 903, 909, 934, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x900@75Hz */
-        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 136750, 1440, 1536,
-                   1688, 1936, 0, 900, 903, 909, 942, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x900@85Hz */
-        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 157000, 1440, 1544,
-                   1696, 1952, 0, 900, 903, 909, 948, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1600x1200@60Hz */
-        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
-                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1600x1200@65Hz */
-        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 175500, 1600, 1664,
-                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1600x1200@70Hz */
-        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 189000, 1600, 1664,
-                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1600x1200@75Hz */
-        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 202500, 1600, 1664,
-                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1600x1200@85Hz */
-        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 229500, 1600, 1664,
-                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1680x1050@60Hz */
-        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
-                   1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1680x1050@75Hz */
-        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 187000, 1680, 1800,
-                   1976, 2272, 0, 1050, 1053, 1059, 1099, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1680x1050@85Hz */
-        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 214750, 1680, 1808,
-                   1984, 2288, 0, 1050, 1053, 1059, 1105, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1792x1344@60Hz */
-        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
-                   2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1729x1344@75Hz */
-        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 261000, 1792, 1888,
-                   2104, 2456, 0, 1344, 1345, 1348, 1417, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1853x1392@60Hz */
-        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
-                   2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1856x1392@75Hz */
-        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 288000, 1856, 1984,
-                   2208, 2560, 0, 1392, 1395, 1399, 1500, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1200@60Hz */
-        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
-                   2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1200@75Hz */
-        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 245250, 1920, 2056,
-                   2264, 2608, 0, 1200, 1203, 1209, 1255, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1200@85Hz */
-        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 281250, 1920, 2064,
-                   2272, 2624, 0, 1200, 1203, 1209, 1262, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1440@60Hz */
-        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
-                   2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1440@75Hz */
-        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2064,
-                   2288, 2640, 0, 1440, 1441, 1444, 1500, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 2560x1600@60Hz */
-        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
-                   3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 2560x1600@75HZ */
-        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 443250, 2560, 2768,
-                   3048, 3536, 0, 1600, 1603, 1609, 1672, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 2560x1600@85HZ */
-        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 505250, 2560, 2768,
-                   3048, 3536, 0, 1600, 1603, 1609, 1682, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-};
-static const int drm_num_dmt_modes =
-        sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
-
 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
                                            int hsize, int vsize, int fresh)
 {
@@ -685,6 +457,46 @@ EXPORT_SYMBOL(drm_mode_find_dmt);
 typedef void detailed_cb(struct detailed_timing *timing, void *closure);
 
 static void
+cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
+{
+        int i, n = 0;
+        u8 rev = ext[0x01], d = ext[0x02];
+        u8 *det_base = ext + d;
+
+        switch (rev) {
+        case 0:
+                /* can't happen */
+                return;
+        case 1:
+                /* have to infer how many blocks we have, check pixel clock */
+                for (i = 0; i < 6; i++)
+                        if (det_base[18*i] || det_base[18*i+1])
+                                n++;
+                break;
+        default:
+                /* explicit count */
+                n = min(ext[0x03] & 0x0f, 6);
+                break;
+        }
+
+        for (i = 0; i < n; i++)
+                cb((struct detailed_timing *)(det_base + 18 * i), closure);
+}
+
+static void
+vtb_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
+{
+        unsigned int i, n = min((int)ext[0x02], 6);
+        u8 *det_base = ext + 5;
+
+        if (ext[0x01] != 1)
+                return; /* unknown version */
+
+        for (i = 0; i < n; i++)
+                cb((struct detailed_timing *)(det_base + 18 * i), closure);
+}
+
+static void
 drm_for_each_detailed_block(u8 *raw_edid, detailed_cb *cb, void *closure)
 {
         int i;
@@ -696,7 +508,19 @@ drm_for_each_detailed_block(u8 *raw_edid, detailed_cb *cb, void *closure)
         for (i = 0; i < EDID_DETAILED_TIMINGS; i++)
                 cb(&(edid->detailed_timings[i]), closure);
 
-        /* XXX extension block walk */
+        for (i = 1; i <= raw_edid[0x7e]; i++) {
+                u8 *ext = raw_edid + (i * EDID_LENGTH);
+                switch (*ext) {
+                case CEA_EXT:
+                        cea_for_each_detailed_block(ext, cb, closure);
+                        break;
+                case VTB_EXT:
+                        vtb_for_each_detailed_block(ext, cb, closure);
+                        break;
+                default:
+                        break;
+                }
+        }
 }
 
 static void
@@ -1047,117 +871,6 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
         return mode;
 }
 
-/*
- * Detailed mode info for the EDID "established modes" data to use.
- */
-static struct drm_display_mode edid_est_modes[] = {
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
-                   968, 1056, 0, 600, 601, 605, 628, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@60Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
-                   896, 1024, 0, 600, 601, 603,  625, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@56Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
-                   720, 840, 0, 480, 481, 484, 500, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@75Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
-                   704,  832, 0, 480, 489, 491, 520, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@72Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 30240, 640, 704,
-                   768,  864, 0, 480, 483, 486, 525, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@67Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25200, 640, 656,
-                   752, 800, 0, 480, 490, 492, 525, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@60Hz */
-        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 738,
-                   846, 900, 0, 400, 421, 423,  449, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 720x400@88Hz */
-        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 28320, 720, 738,
-                   846,  900, 0, 400, 412, 414, 449, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 720x400@70Hz */
-        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
-                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1280x1024@75Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78800, 1024, 1040,
-                   1136, 1312, 0,  768, 769, 772, 800, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1024x768@75Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
-                   1184, 1328, 0,  768, 771, 777, 806, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@70Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
-                   1184, 1344, 0,  768, 771, 777, 806, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@60Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER,44900, 1024, 1032,
-                   1208, 1264, 0, 768, 768, 776, 817, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_INTERLACE) }, /* 1024x768@43Hz */
-        { DRM_MODE("832x624", DRM_MODE_TYPE_DRIVER, 57284, 832, 864,
-                   928, 1152, 0, 624, 625, 628, 667, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 832x624@75Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
-                   896, 1056, 0, 600, 601, 604,  625, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@75Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
-                   976, 1040, 0, 600, 637, 643, 666, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@72Hz */
-        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
-                   1344, 1600, 0,  864, 865, 868, 900, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1152x864@75Hz */
-};
-
-/**
- * add_established_modes - get est. modes from EDID and add them
- * @edid: EDID block to scan
- *
- * Each EDID block contains a bitmap of the supported "established modes" list
- * (defined above).  Tease them out and add them to the global modes list.
- */
-static int add_established_modes(struct drm_connector *connector, struct edid *edid)
-{
-        struct drm_device *dev = connector->dev;
-        unsigned long est_bits = edid->established_timings.t1 |
-                (edid->established_timings.t2 << 8) |
-                ((edid->established_timings.mfg_rsvd & 0x80) << 9);
-        int i, modes = 0;
-
-        for (i = 0; i <= EDID_EST_TIMINGS; i++)
-                if (est_bits & (1<<i)) {
-                        struct drm_display_mode *newmode;
-                        newmode = drm_mode_duplicate(dev, &edid_est_modes[i]);
-                        if (newmode) {
-                                drm_mode_probed_add(connector, newmode);
-                                modes++;
-                        }
-                }
-
-        return modes;
-}
-
-/**
- * add_standard_modes - get std. modes from EDID and add them
- * @edid: EDID block to scan
- *
- * Standard modes can be calculated using the CVT standard.  Grab them from
- * @edid, calculate them, and add them to the list.
- */
-static int add_standard_modes(struct drm_connector *connector, struct edid *edid)
-{
-        int i, modes = 0;
-
-        for (i = 0; i < EDID_STD_TIMINGS; i++) {
-                struct drm_display_mode *newmode;
-
-                newmode = drm_mode_std(connector, edid,
-                                       &edid->standard_timings[i],
-                                       edid->revision);
-                if (newmode) {
-                        drm_mode_probed_add(connector, newmode);
-                        modes++;
-                }
-        }
-
-        return modes;
-}
-
 static bool
 mode_is_rb(struct drm_display_mode *mode)
 {
@@ -1267,113 +980,33 @@ drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
         return modes;
 }
 
-static int drm_cvt_modes(struct drm_connector *connector,
-                         struct detailed_timing *timing)
+static void
+do_inferred_modes(struct detailed_timing *timing, void *c)
 {
-        int i, j, modes = 0;
-        struct drm_display_mode *newmode;
-        struct drm_device *dev = connector->dev;
-        struct cvt_timing *cvt;
-        const int rates[] = { 60, 85, 75, 60, 50 };
-        const u8 empty[3] = { 0, 0, 0 };
-
-        for (i = 0; i < 4; i++) {
-                int uninitialized_var(width), height;
-                cvt = &(timing->data.other_data.data.cvt[i]);
+        struct detailed_mode_closure *closure = c;
+        struct detailed_non_pixel *data = &timing->data.other_data;
+        int gtf = (closure->edid->features & DRM_EDID_FEATURE_DEFAULT_GTF);
 
-                if (!memcmp(cvt->code, empty, 3))
-                        continue;
+        if (gtf && data->type == EDID_DETAIL_MONITOR_RANGE)
+                closure->modes += drm_gtf_modes_for_range(closure->connector,
+                                                          closure->edid,
+                                                          timing);
+}
 
-                height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 4) + 1) * 2;
-                switch (cvt->code[1] & 0x0c) {
-                case 0x00:
-                        width = height * 4 / 3;
-                        break;
-                case 0x04:
-                        width = height * 16 / 9;
-                        break;
-                case 0x08:
-                        width = height * 16 / 10;
-                        break;
-                case 0x0c:
-                        width = height * 15 / 9;
-                        break;
-                }
+static int
+add_inferred_modes(struct drm_connector *connector, struct edid *edid)
+{
+        struct detailed_mode_closure closure = {
+                connector, edid, 0, 0, 0
+        };
 
-                for (j = 1; j < 5; j++) {
-                        if (cvt->code[2] & (1 << j)) {
-                                newmode = drm_cvt_mode(dev, width, height,
-                                                       rates[j], j == 0,
-                                                       false, false);
-                                if (newmode) {
-                                        drm_mode_probed_add(connector, newmode);
-                                        modes++;
-                                }
-                        }
-                }
-        }
+        if (version_greater(edid, 1, 0))
+                drm_for_each_detailed_block((u8 *)edid, do_inferred_modes,
+                                            &closure);
 
-        return modes;
+        return closure.modes;
 }
 
-static const struct {
-        short w;
-        short h;
-        short r;
-        short rb;
-} est3_modes[] = {
-        /* byte 6 */
-        { 640, 350, 85, 0 },
-        { 640, 400, 85, 0 },
-        { 720, 400, 85, 0 },
-        { 640, 480, 85, 0 },
-        { 848, 480, 60, 0 },
-        { 800, 600, 85, 0 },
-        { 1024, 768, 85, 0 },
-        { 1152, 864, 75, 0 },
-        /* byte 7 */
-        { 1280, 768, 60, 1 },
-        { 1280, 768, 60, 0 },
-        { 1280, 768, 75, 0 },
-        { 1280, 768, 85, 0 },
-        { 1280, 960, 60, 0 },
-        { 1280, 960, 85, 0 },
-        { 1280, 1024, 60, 0 },
-        { 1280, 1024, 85, 0 },
-        /* byte 8 */
-        { 1360, 768, 60, 0 },
-        { 1440, 900, 60, 1 },
-        { 1440, 900, 60, 0 },
-        { 1440, 900, 75, 0 },
-        { 1440, 900, 85, 0 },
-        { 1400, 1050, 60, 1 },
-        { 1400, 1050, 60, 0 },
-        { 1400, 1050, 75, 0 },
-        /* byte 9 */
-        { 1400, 1050, 85, 0 },
-        { 1680, 1050, 60, 1 },
-        { 1680, 1050, 60, 0 },
-        { 1680, 1050, 75, 0 },
-        { 1680, 1050, 85, 0 },
-        { 1600, 1200, 60, 0 },
-        { 1600, 1200, 65, 0 },
-        { 1600, 1200, 70, 0 },
-        /* byte 10 */
-        { 1600, 1200, 75, 0 },
-        { 1600, 1200, 85, 0 },
-        { 1792, 1344, 60, 0 },
-        { 1792, 1344, 85, 0 },
-        { 1856, 1392, 60, 0 },
-        { 1856, 1392, 75, 0 },
-        { 1920, 1200, 60, 1 },
-        { 1920, 1200, 60, 0 },
-        /* byte 11 */
-        { 1920, 1200, 75, 0 },
-        { 1920, 1200, 85, 0 },
-        { 1920, 1440, 60, 0 },
-        { 1920, 1440, 75, 0 },
-};
-
 static int
 drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing)
 {
@@ -1403,37 +1036,63 @@ drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing)
         return modes;
 }
 
-static int add_detailed_modes(struct drm_connector *connector,
-                              struct detailed_timing *timing,
-                              struct edid *edid, u32 quirks, int preferred)
+static void
+do_established_modes(struct detailed_timing *timing, void *c)
 {
-        int i, modes = 0;
+        struct detailed_mode_closure *closure = c;
         struct detailed_non_pixel *data = &timing->data.other_data;
-        int gtf = (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF);
-        struct drm_display_mode *newmode;
-        struct drm_device *dev = connector->dev;
 
-        if (timing->pixel_clock) {
-                newmode = drm_mode_detailed(dev, edid, timing, quirks);
-                if (!newmode)
-                        return 0;
+        if (data->type == EDID_DETAIL_EST_TIMINGS)
+                closure->modes += drm_est3_modes(closure->connector, timing);
+}
 
-                if (preferred)
-                        newmode->type |= DRM_MODE_TYPE_PREFERRED;
+/**
+ * add_established_modes - get est. modes from EDID and add them
+ * @edid: EDID block to scan
+ *
+ * Each EDID block contains a bitmap of the supported "established modes" list
+ * (defined above).  Tease them out and add them to the global modes list.
+ */
+static int
+add_established_modes(struct drm_connector *connector, struct edid *edid)
+{
+        struct drm_device *dev = connector->dev;
+        unsigned long est_bits = edid->established_timings.t1 |
+                (edid->established_timings.t2 << 8) |
+                ((edid->established_timings.mfg_rsvd & 0x80) << 9);
+        int i, modes = 0;
+        struct detailed_mode_closure closure = {
+                connector, edid, 0, 0, 0
+        };
 
-                drm_mode_probed_add(connector, newmode);
-                return 1;
+        for (i = 0; i <= EDID_EST_TIMINGS; i++) {
+                if (est_bits & (1<<i)) {
+                        struct drm_display_mode *newmode;
+                        newmode = drm_mode_duplicate(dev, &edid_est_modes[i]);
+                        if (newmode) {
+                                drm_mode_probed_add(connector, newmode);
+                                modes++;
+                        }
+                }
         }
 
-        /* other timing types */
-        switch (data->type) {
-        case EDID_DETAIL_MONITOR_RANGE:
-                if (gtf)
-                        modes += drm_gtf_modes_for_range(connector, edid,
-                                                         timing);
-                break;
-        case EDID_DETAIL_STD_MODES:
-                /* Six modes per detailed section */
+        if (version_greater(edid, 1, 0))
+                    drm_for_each_detailed_block((u8 *)edid,
+                                                do_established_modes, &closure);
+
+        return modes + closure.modes;
+}
+
+static void
+do_standard_modes(struct detailed_timing *timing, void *c)
+{
+        struct detailed_mode_closure *closure = c;
+        struct detailed_non_pixel *data = &timing->data.other_data;
+        struct drm_connector *connector = closure->connector;
+        struct edid *edid = closure->edid;
+
+        if (data->type == EDID_DETAIL_STD_MODES) {
+                int i;
                 for (i = 0; i < 6; i++) {
                         struct std_timing *std;
                         struct drm_display_mode *newmode;
@@ -1443,108 +1102,169 @@ static int add_detailed_modes(struct drm_connector *connector,
                                                edid->revision);
                         if (newmode) {
                                 drm_mode_probed_add(connector, newmode);
-                                modes++;
+                                closure->modes++;
                         }
                 }
-                break;
-        case EDID_DETAIL_CVT_3BYTE:
-                modes += drm_cvt_modes(connector, timing);
-                break;
-        case EDID_DETAIL_EST_TIMINGS:
-                modes += drm_est3_modes(connector, timing);
-                break;
-        default:
-                break;
         }
-
-        return modes;
 }
 
 /**
- * add_detailed_info - get detailed mode info from EDID data
- * @connector: attached connector
+ * add_standard_modes - get std. modes from EDID and add them
  * @edid: EDID block to scan
- * @quirks: quirks to apply
  *
- * Some of the detailed timing sections may contain mode information.  Grab
- * it and add it to the list.
+ * Standard modes can be calculated using the appropriate standard (DMT,
+ * GTF or CVT. Grab them from @edid and add them to the list.
  */
-static int add_detailed_info(struct drm_connector *connector,
-                             struct edid *edid, u32 quirks)
+static int
+add_standard_modes(struct drm_connector *connector, struct edid *edid)
 {
         int i, modes = 0;
+        struct detailed_mode_closure closure = {
+                connector, edid, 0, 0, 0
+        };
+
+        for (i = 0; i < EDID_STD_TIMINGS; i++) {
+                struct drm_display_mode *newmode;
+
+                newmode = drm_mode_std(connector, edid,
+                                       &edid->standard_timings[i],
+                                       edid->revision);
+                if (newmode) {
+                        drm_mode_probed_add(connector, newmode);
+                        modes++;
+                }
+        }
+
+        if (version_greater(edid, 1, 0))
+                drm_for_each_detailed_block((u8 *)edid, do_standard_modes,
+                                            &closure);
+
+        /* XXX should also look for standard codes in VTB blocks */
+
+        return modes + closure.modes;
+}
 
-        for (i = 0; i < EDID_DETAILED_TIMINGS; i++) {
-                struct detailed_timing *timing = &edid->detailed_timings[i];
-                int preferred = (i == 0);
+static int drm_cvt_modes(struct drm_connector *connector,
+                         struct detailed_timing *timing)
+{
+        int i, j, modes = 0;
+        struct drm_display_mode *newmode;
+        struct drm_device *dev = connector->dev;
+        struct cvt_timing *cvt;
+        const int rates[] = { 60, 85, 75, 60, 50 };
+        const u8 empty[3] = { 0, 0, 0 };
 
-                if (preferred && edid->version == 1 && edid->revision < 4)
-                        preferred = (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING);
+        for (i = 0; i < 4; i++) {
+                int uninitialized_var(width), height;
+                cvt = &(timing->data.other_data.data.cvt[i]);
 
-                /* In 1.0, only timings are allowed */
-                if (!timing->pixel_clock && edid->version == 1 &&
-                        edid->revision == 0)
+                if (!memcmp(cvt->code, empty, 3))
                         continue;
 
-                modes += add_detailed_modes(connector, timing, edid, quirks,
-                                            preferred);
+                height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 4) + 1) * 2;
+                switch (cvt->code[1] & 0x0c) {
+                case 0x00:
+                        width = height * 4 / 3;
+                        break;
+                case 0x04:
+                        width = height * 16 / 9;
+                        break;
+                case 0x08:
+                        width = height * 16 / 10;
+                        break;
+                case 0x0c:
+                        width = height * 15 / 9;
+                        break;
+                }
+
+                for (j = 1; j < 5; j++) {
+                        if (cvt->code[2] & (1 << j)) {
+                                newmode = drm_cvt_mode(dev, width, height,
+                                                       rates[j], j == 0,
+                                                       false, false);
+                                if (newmode) {
+                                        drm_mode_probed_add(connector, newmode);
+                                        modes++;
+                                }
+                        }
+                }
         }
 
         return modes;
 }
 
-/**
- * add_detailed_mode_eedid - get detailed mode info from addtional timing
- *                      EDID block
- * @connector: attached connector
- * @edid: EDID block to scan(It is only to get addtional timing EDID block)
- * @quirks: quirks to apply
- *
- * Some of the detailed timing sections may contain mode information.  Grab
- * it and add it to the list.
- */
-static int add_detailed_info_eedid(struct drm_connector *connector,
-                             struct edid *edid, u32 quirks)
+static void
+do_cvt_mode(struct detailed_timing *timing, void *c)
 {
-        int i, modes = 0;
-        char *edid_ext = NULL;
-        struct detailed_timing *timing;
-        int start_offset, end_offset;
+        struct detailed_mode_closure *closure = c;
+        struct detailed_non_pixel *data = &timing->data.other_data;
 
-        if (edid->version == 1 && edid->revision < 3)
-                return 0;
-        if (!edid->extensions)
-                return 0;
+        if (data->type == EDID_DETAIL_CVT_3BYTE)
+                closure->modes += drm_cvt_modes(closure->connector, timing);
+}
 
-        /* Find CEA extension */
-        for (i = 0; i < edid->extensions; i++) {
-                edid_ext = (char *)edid + EDID_LENGTH * (i + 1);
-                if (edid_ext[0] == 0x02)
-                        break;
-        }
+static int
+add_cvt_modes(struct drm_connector *connector, struct edid *edid)
+{       
+        struct detailed_mode_closure closure = {
+                connector, edid, 0, 0, 0
+        };
 
-        if (i == edid->extensions)
-                return 0;
+        if (version_greater(edid, 1, 2))
+                drm_for_each_detailed_block((u8 *)edid, do_cvt_mode, &closure);
 
-        /* Get the start offset of detailed timing block */
-        start_offset = edid_ext[2];
-        if (start_offset == 0) {
-                /* If the start_offset is zero, it means that neither detailed
-                 * info nor data block exist. In such case it is also
-                 * unnecessary to parse the detailed timing info.
-                 */
-                return 0;
-        }
+        /* XXX should also look for CVT codes in VTB blocks */
 
-        end_offset = EDID_LENGTH;
-        end_offset -= sizeof(struct detailed_timing);
-        for (i = start_offset; i < end_offset;
-                        i += sizeof(struct detailed_timing)) {
-                timing = (struct detailed_timing *)(edid_ext + i);
-                modes += add_detailed_modes(connector, timing, edid, quirks, 0);
+        return closure.modes;
+}
+
+static void
+do_detailed_mode(struct detailed_timing *timing, void *c)
+{
+        struct detailed_mode_closure *closure = c;
+        struct drm_display_mode *newmode;
+
+        if (timing->pixel_clock) {
+                newmode = drm_mode_detailed(closure->connector->dev,
+                                            closure->edid, timing,
+                                            closure->quirks);
+                if (!newmode)
+                        return;
+
+                if (closure->preferred)
+                        newmode->type |= DRM_MODE_TYPE_PREFERRED;
+
+                drm_mode_probed_add(closure->connector, newmode);
+                closure->modes++;
+                closure->preferred = 0;
         }
+}
 
-        return modes;
+/*
+ * add_detailed_modes - Add modes from detailed timings
+ * @connector: attached connector
+ * @edid: EDID block to scan
+ * @quirks: quirks to apply
+ */
+static int
+add_detailed_modes(struct drm_connector *connector, struct edid *edid,
+                   u32 quirks)
+{
+        struct detailed_mode_closure closure = {
+                connector,
+                edid,
+                1,
+                quirks,
+                0
+        };
+
+        if (closure.preferred && !version_greater(edid, 1, 3))
+                closure.preferred =
+                    (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING);
+
+        drm_for_each_detailed_block((u8 *)edid, do_detailed_mode, &closure);
+
+        return closure.modes;
 }
 
 #define HDMI_IDENTIFIER 0x000C03
@@ -1640,35 +1360,21 @@ int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
          * - established timing codes
          * - modes inferred from GTF or CVT range information
          *
-         * We don't quite implement this yet, but we're close.
+         * We get this pretty much right.
          *
          * XXX order for additional mode types in extension blocks?
          */
-        num_modes += add_detailed_info(connector, edid, quirks);
-        num_modes += add_detailed_info_eedid(connector, edid, quirks);
+        num_modes += add_detailed_modes(connector, edid, quirks);
+        num_modes += add_cvt_modes(connector, edid);
         num_modes += add_standard_modes(connector, edid);
         num_modes += add_established_modes(connector, edid);
+        num_modes += add_inferred_modes(connector, edid);
 
         if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75))
                 edid_fixup_preferred(connector, quirks);
 
-        connector->display_info.serration_vsync = (edid->input & DRM_EDID_INPUT_SERRATION_VSYNC) ? 1 : 0;
-        connector->display_info.sync_on_green = (edid->input & DRM_EDID_INPUT_SYNC_ON_GREEN) ? 1 : 0;
-        connector->display_info.composite_sync = (edid->input & DRM_EDID_INPUT_COMPOSITE_SYNC) ? 1 : 0;
-        connector->display_info.separate_syncs = (edid->input & DRM_EDID_INPUT_SEPARATE_SYNCS) ? 1 : 0;
-        connector->display_info.blank_to_black = (edid->input & DRM_EDID_INPUT_BLANK_TO_BLACK) ? 1 : 0;
-        connector->display_info.video_level = (edid->input & DRM_EDID_INPUT_VIDEO_LEVEL) >> 5;
-        connector->display_info.digital = (edid->input & DRM_EDID_INPUT_DIGITAL) ? 1 : 0;
         connector->display_info.width_mm = edid->width_cm * 10;
         connector->display_info.height_mm = edid->height_cm * 10;
-        connector->display_info.gamma = edid->gamma;
-        connector->display_info.gtf_supported = (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF) ? 1 : 0;
-        connector->display_info.standard_color = (edid->features & DRM_EDID_FEATURE_STANDARD_COLOR) ? 1 : 0;
-        connector->display_info.display_type = (edid->features & DRM_EDID_FEATURE_DISPLAY_TYPE) >> 3;
-        connector->display_info.active_off_supported = (edid->features & DRM_EDID_FEATURE_PM_ACTIVE_OFF) ? 1 : 0;
-        connector->display_info.suspend_supported = (edid->features & DRM_EDID_FEATURE_PM_SUSPEND) ? 1 : 0;
-        connector->display_info.standby_supported = (edid->features & DRM_EDID_FEATURE_PM_STANDBY) ? 1 : 0;
-        connector->display_info.gamma = edid->gamma;
 
         return num_modes;
 }
diff --git a/drivers/gpu/drm/drm_edid_modes.h b/drivers/gpu/drm/drm_edid_modes.h
new file mode 100644
index 00000000000..6eb7592e152
--- /dev/null
+++ b/drivers/gpu/drm/drm_edid_modes.h
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2007-2008 Intel Corporation
+ *   Jesse Barnes <jesse.barnes@intel.com>
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE 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.
+ */
+
+#include <linux/kernel.h>
+#include "drmP.h"
+#include "drm_edid.h"
+
+/*
+ * Autogenerated from the DMT spec.
+ * This table is copied from xfree86/modes/xf86EdidModes.c.
+ * But the mode with Reduced blank feature is deleted.
+ */
+static struct drm_display_mode drm_dmt_modes[] = {
+        /* 640x350@85Hz */
+        { DRM_MODE("640x350", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
+                   736, 832, 0, 350, 382, 385, 445, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 640x400@85Hz */
+        { DRM_MODE("640x400", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
+                   736, 832, 0, 400, 401, 404, 445, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 720x400@85Hz */
+        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 756,
+                   828, 936, 0, 400, 401, 404, 446, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 640x480@60Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
+                   752, 800, 0, 480, 489, 492, 525, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 640x480@72Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
+                   704, 832, 0, 480, 489, 492, 520, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 640x480@75Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
+                   720, 840, 0, 480, 481, 484, 500, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 640x480@85Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 36000, 640, 696,
+                   752, 832, 0, 480, 481, 484, 509, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 800x600@56Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
+                   896, 1024, 0, 600, 601, 603, 625, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 800x600@60Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
+                   968, 1056, 0, 600, 601, 605, 628, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 800x600@72Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
+                   976, 1040, 0, 600, 637, 643, 666, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 800x600@75Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
+                   896, 1056, 0, 600, 601, 604, 625, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 800x600@85Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 56250, 800, 832,
+                   896, 1048, 0, 600, 601, 604, 631, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 848x480@60Hz */
+        { DRM_MODE("848x480", DRM_MODE_TYPE_DRIVER, 33750, 848, 864,
+                   976, 1088, 0, 480, 486, 494, 517, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1024x768@43Hz, interlace */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 44900, 1024, 1032,
+                   1208, 1264, 0, 768, 768, 772, 817, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
+                        DRM_MODE_FLAG_INTERLACE) },
+        /* 1024x768@60Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
+                   1184, 1344, 0, 768, 771, 777, 806, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 1024x768@70Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
+                   1184, 1328, 0, 768, 771, 777, 806, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 1024x768@75Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78750, 1024, 1040,
+                   1136, 1312, 0, 768, 769, 772, 800, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1024x768@85Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 94500, 1024, 1072,
+                   1168, 1376, 0, 768, 769, 772, 808, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1152x864@75Hz */
+        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
+                   1344, 1600, 0, 864, 865, 868, 900, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x768@60Hz */
+        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
+                   1472, 1664, 0, 768, 771, 778, 798, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x768@75Hz */
+        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 102250, 1280, 1360,
+                   1488, 1696, 0, 768, 771, 778, 805, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 1280x768@85Hz */
+        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 117500, 1280, 1360,
+                   1496, 1712, 0, 768, 771, 778, 809, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x800@60Hz */
+        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
+                   1480, 1680, 0, 800, 803, 809, 831, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
+        /* 1280x800@75Hz */
+        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 106500, 1280, 1360,
+                   1488, 1696, 0, 800, 803, 809, 838, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x800@85Hz */
+        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 122500, 1280, 1360,
+                   1496, 1712, 0, 800, 803, 809, 843, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x960@60Hz */
+        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
+                   1488, 1800, 0, 960, 961, 964, 1000, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x960@85Hz */
+        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1344,
+                   1504, 1728, 0, 960, 961, 964, 1011, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x1024@60Hz */
+        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
+                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x1024@75Hz */
+        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
+                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1280x1024@85Hz */
+        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 157500, 1280, 1344,
+                   1504, 1728, 0, 1024, 1025, 1028, 1072, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1360x768@60Hz */
+        { DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
+                   1536, 1792, 0, 768, 771, 777, 795, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1440x1050@60Hz */
+        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
+                   1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1440x1050@75Hz */
+        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 156000, 1400, 1504,
+                   1648, 1896, 0, 1050, 1053, 1057, 1099, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1440x1050@85Hz */
+        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 179500, 1400, 1504,
+                   1656, 1912, 0, 1050, 1053, 1057, 1105, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1440x900@60Hz */
+        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
+                   1672, 1904, 0, 900, 903, 909, 934, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1440x900@75Hz */
+        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 136750, 1440, 1536,
+                   1688, 1936, 0, 900, 903, 909, 942, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1440x900@85Hz */
+        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 157000, 1440, 1544,
+                   1696, 1952, 0, 900, 903, 909, 948, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1600x1200@60Hz */
+        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
+                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1600x1200@65Hz */
+        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 175500, 1600, 1664,
+                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1600x1200@70Hz */
+        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 189000, 1600, 1664,
+                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1600x1200@75Hz */
+        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 202500, 1600, 1664,
+                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1600x1200@85Hz */
+        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 229500, 1600, 1664,
+                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1680x1050@60Hz */
+        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
+                   1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1680x1050@75Hz */
+        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 187000, 1680, 1800,
+                   1976, 2272, 0, 1050, 1053, 1059, 1099, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1680x1050@85Hz */
+        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 214750, 1680, 1808,
+                   1984, 2288, 0, 1050, 1053, 1059, 1105, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1792x1344@60Hz */
+        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
+                   2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1729x1344@75Hz */
+        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 261000, 1792, 1888,
+                   2104, 2456, 0, 1344, 1345, 1348, 1417, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1853x1392@60Hz */
+        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
+                   2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1856x1392@75Hz */
+        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 288000, 1856, 1984,
+                   2208, 2560, 0, 1392, 1395, 1399, 1500, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1920x1200@60Hz */
+        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
+                   2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1920x1200@75Hz */
+        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 245250, 1920, 2056,
+                   2264, 2608, 0, 1200, 1203, 1209, 1255, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1920x1200@85Hz */
+        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 281250, 1920, 2064,
+                   2272, 2624, 0, 1200, 1203, 1209, 1262, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1920x1440@60Hz */
+        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
+                   2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 1920x1440@75Hz */
+        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2064,
+                   2288, 2640, 0, 1440, 1441, 1444, 1500, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 2560x1600@60Hz */
+        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
+                   3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 2560x1600@75HZ */
+        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 443250, 2560, 2768,
+                   3048, 3536, 0, 1600, 1603, 1609, 1672, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+        /* 2560x1600@85HZ */
+        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 505250, 2560, 2768,
+                   3048, 3536, 0, 1600, 1603, 1609, 1682, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
+};
+static const int drm_num_dmt_modes =
+        sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
+
+static struct drm_display_mode edid_est_modes[] = {
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
+                   968, 1056, 0, 600, 601, 605, 628, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@60Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
+                   896, 1024, 0, 600, 601, 603,  625, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@56Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
+                   720, 840, 0, 480, 481, 484, 500, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@75Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
+                   704,  832, 0, 480, 489, 491, 520, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@72Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 30240, 640, 704,
+                   768,  864, 0, 480, 483, 486, 525, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@67Hz */
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25200, 640, 656,
+                   752, 800, 0, 480, 490, 492, 525, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@60Hz */
+        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 738,
+                   846, 900, 0, 400, 421, 423,  449, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 720x400@88Hz */
+        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 28320, 720, 738,
+                   846,  900, 0, 400, 412, 414, 449, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 720x400@70Hz */
+        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
+                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1280x1024@75Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78800, 1024, 1040,
+                   1136, 1312, 0,  768, 769, 772, 800, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1024x768@75Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
+                   1184, 1328, 0,  768, 771, 777, 806, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@70Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
+                   1184, 1344, 0,  768, 771, 777, 806, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@60Hz */
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER,44900, 1024, 1032,
+                   1208, 1264, 0, 768, 768, 776, 817, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_INTERLACE) }, /* 1024x768@43Hz */
+        { DRM_MODE("832x624", DRM_MODE_TYPE_DRIVER, 57284, 832, 864,
+                   928, 1152, 0, 624, 625, 628, 667, 0,
+                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 832x624@75Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
+                   896, 1056, 0, 600, 601, 604,  625, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@75Hz */
+        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
+                   976, 1040, 0, 600, 637, 643, 666, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@72Hz */
+        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
+                   1344, 1600, 0,  864, 865, 868, 900, 0,
+                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1152x864@75Hz */
+};
+
+static const struct {
+        short w;
+        short h;
+        short r;
+        short rb;
+} est3_modes[] = {
+        /* byte 6 */
+        { 640, 350, 85, 0 },
+        { 640, 400, 85, 0 },
+        { 720, 400, 85, 0 },
+        { 640, 480, 85, 0 },
+        { 848, 480, 60, 0 },
+        { 800, 600, 85, 0 },
+        { 1024, 768, 85, 0 },
+        { 1152, 864, 75, 0 },
+        /* byte 7 */
+        { 1280, 768, 60, 1 },
+        { 1280, 768, 60, 0 },
+        { 1280, 768, 75, 0 },
+        { 1280, 768, 85, 0 },
+        { 1280, 960, 60, 0 },
+        { 1280, 960, 85, 0 },
+        { 1280, 1024, 60, 0 },
+        { 1280, 1024, 85, 0 },
+        /* byte 8 */
+        { 1360, 768, 60, 0 },
+        { 1440, 900, 60, 1 },
+        { 1440, 900, 60, 0 },
+        { 1440, 900, 75, 0 },
+        { 1440, 900, 85, 0 },
+        { 1400, 1050, 60, 1 },
+        { 1400, 1050, 60, 0 },
+        { 1400, 1050, 75, 0 },
+        /* byte 9 */
+        { 1400, 1050, 85, 0 },
+        { 1680, 1050, 60, 1 },
+        { 1680, 1050, 60, 0 },
+        { 1680, 1050, 75, 0 },
+        { 1680, 1050, 85, 0 },
+        { 1600, 1200, 60, 0 },
+        { 1600, 1200, 65, 0 },
+        { 1600, 1200, 70, 0 },
+        /* byte 10 */
+        { 1600, 1200, 75, 0 },
+        { 1600, 1200, 85, 0 },
+        { 1792, 1344, 60, 0 },
+        { 1792, 1344, 85, 0 },
+        { 1856, 1392, 60, 0 },
+        { 1856, 1392, 75, 0 },
+        { 1920, 1200, 60, 1 },
+        { 1920, 1200, 60, 0 },
+        /* byte 11 */
+        { 1920, 1200, 75, 0 },
+        { 1920, 1200, 85, 0 },
+        { 1920, 1440, 60, 0 },
+        { 1920, 1440, 75, 0 },
+};
+static const int num_est3_modes = sizeof(est3_modes) / sizeof(est3_modes[0]);
diff --git a/drivers/gpu/drm/drm_fops.c b/drivers/gpu/drm/drm_fops.c
index 2ca8df8b610..3a652a65546 100644
--- a/drivers/gpu/drm/drm_fops.c
+++ b/drivers/gpu/drm/drm_fops.c
@@ -135,15 +135,9 @@ int drm_open(struct inode *inode, struct file *filp)
         retcode = drm_open_helper(inode, filp, dev);
         if (!retcode) {
                 atomic_inc(&dev->counts[_DRM_STAT_OPENS]);
-                spin_lock(&dev->count_lock);
-                if (!dev->open_count++) {
-                        spin_unlock(&dev->count_lock);
+                if (!dev->open_count++)
                         retcode = drm_setup(dev);
-                        goto out;
-                }
-                spin_unlock(&dev->count_lock);
         }
-out:
         if (!retcode) {
                 mutex_lock(&dev->struct_mutex);
                 if (minor->type == DRM_MINOR_LEGACY) {
@@ -570,18 +564,14 @@ int drm_release(struct inode *inode, struct file *filp)
          */
 
         atomic_inc(&dev->counts[_DRM_STAT_CLOSES]);
-        spin_lock(&dev->count_lock);
         if (!--dev->open_count) {
                 if (atomic_read(&dev->ioctl_count)) {
                         DRM_ERROR("Device busy: %d\n",
                                   atomic_read(&dev->ioctl_count));
                         retcode = -EBUSY;
-                        goto out;
-                }
-                retcode = drm_lastclose(dev);
+                } else
+                        retcode = drm_lastclose(dev);
         }
-out:
-        spin_unlock(&dev->count_lock);
         mutex_unlock(&drm_global_mutex);
 
         return retcode;
diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
index 4f1b8671448..bf92d07510d 100644
--- a/drivers/gpu/drm/drm_gem.c
+++ b/drivers/gpu/drm/drm_gem.c
@@ -322,7 +322,7 @@ drm_gem_flink_ioctl(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EBADF;
+                return -ENOENT;
 
 again:
         if (idr_pre_get(&dev->object_name_idr, GFP_KERNEL) == 0) {
diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c
index 7b03b197fc0..47db4df37a6 100644
--- a/drivers/gpu/drm/drm_ioctl.c
+++ b/drivers/gpu/drm/drm_ioctl.c
@@ -392,6 +392,7 @@ int drm_setversion(struct drm_device *dev, void *data, struct drm_file *file_pri
                 if (sv->drm_di_minor >= 1) {
                         /*
                          * Version 1.1 includes tying of DRM to specific device
+                         * Version 1.4 has proper PCI domain support
                          */
                         retcode = drm_set_busid(dev, file_priv);
                         if (retcode)
diff --git a/drivers/gpu/drm/i2c/ch7006_drv.c b/drivers/gpu/drm/i2c/ch7006_drv.c
index 833b35f44a7..08792a740f1 100644
--- a/drivers/gpu/drm/i2c/ch7006_drv.c
+++ b/drivers/gpu/drm/i2c/ch7006_drv.c
@@ -470,6 +470,7 @@ static int ch7006_encoder_init(struct i2c_client *client,
         priv->hmargin = 50;
         priv->vmargin = 50;
         priv->last_dpms = -1;
+        priv->chip_version = ch7006_read(client, CH7006_VERSION_ID);
 
         if (ch7006_tv_norm) {
                 for (i = 0; i < NUM_TV_NORMS; i++) {
diff --git a/drivers/gpu/drm/i2c/ch7006_mode.c b/drivers/gpu/drm/i2c/ch7006_mode.c
index e447dfb6389..c860f24a5af 100644
--- a/drivers/gpu/drm/i2c/ch7006_mode.c
+++ b/drivers/gpu/drm/i2c/ch7006_mode.c
@@ -316,7 +316,10 @@ void ch7006_setup_power_state(struct drm_encoder *encoder)
                 }
 
         } else {
-                *power |= bitfs(CH7006_POWER_LEVEL, FULL_POWER_OFF);
+                if (priv->chip_version >= 0x20)
+                        *power |= bitfs(CH7006_POWER_LEVEL, FULL_POWER_OFF);
+                else
+                        *power |= bitfs(CH7006_POWER_LEVEL, POWER_OFF);
         }
 }
 
diff --git a/drivers/gpu/drm/i2c/ch7006_priv.h b/drivers/gpu/drm/i2c/ch7006_priv.h
index 1c6d2e3bd96..17667b7d57e 100644
--- a/drivers/gpu/drm/i2c/ch7006_priv.h
+++ b/drivers/gpu/drm/i2c/ch7006_priv.h
@@ -95,6 +95,7 @@ struct ch7006_priv {
         int flicker;
         int scale;
 
+        int chip_version;
         int last_dpms;
 };
 
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 2a4ed7ca8b4..0758c7802e6 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -456,7 +456,7 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EBADF;
+                return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
         /* Bounds check source.
@@ -919,7 +919,7 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EBADF;
+                return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
         /* Bounds check destination.
@@ -1002,7 +1002,7 @@ i915_gem_set_domain_ioctl(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EBADF;
+                return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
         mutex_lock(&dev->struct_mutex);
@@ -1060,7 +1060,7 @@ i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data,
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL) {
                 mutex_unlock(&dev->struct_mutex);
-                return -EBADF;
+                return -ENOENT;
         }
 
 #if WATCH_BUF
@@ -1099,7 +1099,7 @@ i915_gem_mmap_ioctl(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EBADF;
+                return -ENOENT;
 
         offset = args->offset;
 
@@ -1373,7 +1373,7 @@ i915_gem_mmap_gtt_ioctl(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EBADF;
+                return -ENOENT;
 
         mutex_lock(&dev->struct_mutex);
 
@@ -3364,7 +3364,7 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
                                                    reloc->target_handle);
                 if (target_obj == NULL) {
                         i915_gem_object_unpin(obj);
-                        return -EBADF;
+                        return -ENOENT;
                 }
                 target_obj_priv = to_intel_bo(target_obj);
 
@@ -3781,7 +3781,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
                                    exec_list[i].handle, i);
                         /* prevent error path from reading uninitialized data */
                         args->buffer_count = i + 1;
-                        ret = -EBADF;
+                        ret = -ENOENT;
                         goto err;
                 }
 
@@ -3791,7 +3791,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
                                    object_list[i]);
                         /* prevent error path from reading uninitialized data */
                         args->buffer_count = i + 1;
-                        ret = -EBADF;
+                        ret = -EINVAL;
                         goto err;
                 }
                 obj_priv->in_execbuffer = true;
@@ -4265,7 +4265,7 @@ i915_gem_pin_ioctl(struct drm_device *dev, void *data,
                 DRM_ERROR("Bad handle in i915_gem_pin_ioctl(): %d\n",
                           args->handle);
                 mutex_unlock(&dev->struct_mutex);
-                return -EBADF;
+                return -ENOENT;
         }
         obj_priv = to_intel_bo(obj);
 
@@ -4321,7 +4321,7 @@ i915_gem_unpin_ioctl(struct drm_device *dev, void *data,
                 DRM_ERROR("Bad handle in i915_gem_unpin_ioctl(): %d\n",
                           args->handle);
                 mutex_unlock(&dev->struct_mutex);
-                return -EBADF;
+                return -ENOENT;
         }
 
         obj_priv = to_intel_bo(obj);
@@ -4355,7 +4355,7 @@ i915_gem_busy_ioctl(struct drm_device *dev, void *data,
         if (obj == NULL) {
                 DRM_ERROR("Bad handle in i915_gem_busy_ioctl(): %d\n",
                           args->handle);
-                return -EBADF;
+                return -ENOENT;
         }
 
         mutex_lock(&dev->struct_mutex);
@@ -4408,7 +4408,7 @@ i915_gem_madvise_ioctl(struct drm_device *dev, void *data,
         if (obj == NULL) {
                 DRM_ERROR("Bad handle in i915_gem_madvise_ioctl(): %d\n",
                           args->handle);
-                return -EBADF;
+                return -ENOENT;
         }
 
         mutex_lock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/i915/i915_gem_tiling.c b/drivers/gpu/drm/i915/i915_gem_tiling.c
index 155719e4d16..710eca70b32 100644
--- a/drivers/gpu/drm/i915/i915_gem_tiling.c
+++ b/drivers/gpu/drm/i915/i915_gem_tiling.c
@@ -275,7 +275,7 @@ i915_gem_set_tiling(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EINVAL;
+                return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
         if (!i915_tiling_ok(dev, args->stride, obj->size, args->tiling_mode)) {
@@ -362,7 +362,7 @@ i915_gem_get_tiling(struct drm_device *dev, void *data,
 
         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
         if (obj == NULL)
-                return -EINVAL;
+                return -ENOENT;
         obj_priv = to_intel_bo(obj);
 
         mutex_lock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 1e5e0d379fa..5ec10e02341 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -4429,15 +4429,12 @@ void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
 }
 
 static void intel_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green,
-                                 u16 *blue, uint32_t size)
+                                 u16 *blue, uint32_t start, uint32_t size)
 {
+        int end = (start + size > 256) ? 256 : start + size, i;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
-        int i;
-
-        if (size != 256)
-                return;
 
-        for (i = 0; i < 256; i++) {
+        for (i = start; i < end; i++) {
                 intel_crtc->lut_r[i] = red[i] >> 8;
                 intel_crtc->lut_g[i] = green[i] >> 8;
                 intel_crtc->lut_b[i] = blue[i] >> 8;
@@ -5412,18 +5409,18 @@ intel_user_framebuffer_create(struct drm_device *dev,
 
         obj = drm_gem_object_lookup(dev, filp, mode_cmd->handle);
         if (!obj)
-                return NULL;
+                return ERR_PTR(-ENOENT);
 
         intel_fb = kzalloc(sizeof(*intel_fb), GFP_KERNEL);
         if (!intel_fb)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         ret = intel_framebuffer_init(dev, intel_fb,
                                      mode_cmd, obj);
         if (ret) {
                 drm_gem_object_unreference_unlocked(obj);
                 kfree(intel_fb);
-                return NULL;
+                return ERR_PTR(ret);
         }
 
         return &intel_fb->base;
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c
index a79525f434a..7bdc96256bf 100644
--- a/drivers/gpu/drm/i915/intel_fb.c
+++ b/drivers/gpu/drm/i915/intel_fb.c
@@ -121,7 +121,9 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
 
         info->par = ifbdev;
 
-        intel_framebuffer_init(dev, &ifbdev->ifb, &mode_cmd, fbo);
+        ret = intel_framebuffer_init(dev, &ifbdev->ifb, &mode_cmd, fbo);
+        if (ret)
+                goto out_unpin;
 
         fb = &ifbdev->ifb.base;
 
diff --git a/drivers/gpu/drm/nouveau/Makefile b/drivers/gpu/drm/nouveau/Makefile
index 2405d5ef0ca..e9b06e4ef2a 100644
--- a/drivers/gpu/drm/nouveau/Makefile
+++ b/drivers/gpu/drm/nouveau/Makefile
@@ -12,12 +12,12 @@ nouveau-y := nouveau_drv.o nouveau_state.o nouveau_channel.o nouveau_mem.o \
              nouveau_dp.o \
              nv04_timer.o \
              nv04_mc.o nv40_mc.o nv50_mc.o \
-             nv04_fb.o nv10_fb.o nv30_fb.o nv40_fb.o nv50_fb.o \
-             nv04_fifo.o nv10_fifo.o nv40_fifo.o nv50_fifo.o \
+             nv04_fb.o nv10_fb.o nv30_fb.o nv40_fb.o nv50_fb.o nvc0_fb.o \
+             nv04_fifo.o nv10_fifo.o nv40_fifo.o nv50_fifo.o nvc0_fifo.o \
              nv04_graph.o nv10_graph.o nv20_graph.o \
-             nv40_graph.o nv50_graph.o \
+             nv40_graph.o nv50_graph.o nvc0_graph.o \
              nv40_grctx.o nv50_grctx.o \
-             nv04_instmem.o nv50_instmem.o \
+             nv04_instmem.o nv50_instmem.o nvc0_instmem.o \
              nv50_crtc.o nv50_dac.o nv50_sor.o \
              nv50_cursor.o nv50_display.o nv50_fbcon.o \
              nv04_dac.o nv04_dfp.o nv04_tv.o nv17_tv.o nv17_tv_modes.o \
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.c b/drivers/gpu/drm/nouveau/nouveau_bios.c
index 7369b5e7364..0b69a9628c9 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.c
@@ -1928,6 +1928,31 @@ init_condition_time(struct nvbios *bios, uint16_t offset,
 }
 
 static int
+init_ltime(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
+{
+        /*
+         * INIT_LTIME   opcode: 0x57 ('V')
+         *
+         * offset      (8  bit): opcode
+         * offset + 1  (16 bit): time
+         *
+         * Sleep for "time" miliseconds.
+         */
+
+        unsigned time = ROM16(bios->data[offset + 1]);
+
+        if (!iexec->execute)
+                return 3;
+
+        BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X miliseconds\n",
+                offset, time);
+
+        msleep(time);
+
+        return 3;
+}
+
+static int
 init_zm_reg_sequence(struct nvbios *bios, uint16_t offset,
                      struct init_exec *iexec)
 {
@@ -1995,6 +2020,64 @@ init_sub_direct(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
 }
 
 static int
+init_i2c_if(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
+{
+        /*
+         * INIT_I2C_IF   opcode: 0x5E ('^')
+         *
+         * offset      (8 bit): opcode
+         * offset + 1  (8 bit): DCB I2C table entry index
+         * offset + 2  (8 bit): I2C slave address
+         * offset + 3  (8 bit): I2C register
+         * offset + 4  (8 bit): mask
+         * offset + 5  (8 bit): data
+         *
+         * Read the register given by "I2C register" on the device addressed
+         * by "I2C slave address" on the I2C bus given by "DCB I2C table
+         * entry index". Compare the result AND "mask" to "data".
+         * If they're not equal, skip subsequent opcodes until condition is
+         * inverted (INIT_NOT), or we hit INIT_RESUME
+         */
+
+        uint8_t i2c_index = bios->data[offset + 1];
+        uint8_t i2c_address = bios->data[offset + 2] >> 1;
+        uint8_t reg = bios->data[offset + 3];
+        uint8_t mask = bios->data[offset + 4];
+        uint8_t data = bios->data[offset + 5];
+        struct nouveau_i2c_chan *chan;
+        union i2c_smbus_data val;
+        int ret;
+
+        /* no execute check by design */
+
+        BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X\n",
+                offset, i2c_index, i2c_address);
+
+        chan = init_i2c_device_find(bios->dev, i2c_index);
+        if (!chan)
+                return -ENODEV;
+
+        ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
+                             I2C_SMBUS_READ, reg,
+                             I2C_SMBUS_BYTE_DATA, &val);
+        if (ret < 0) {
+                BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: [no device], "
+                              "Mask: 0x%02X, Data: 0x%02X\n",
+                        offset, reg, mask, data);
+                iexec->execute = 0;
+                return 6;
+        }
+
+        BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: 0x%02X, "
+                      "Mask: 0x%02X, Data: 0x%02X\n",
+                offset, reg, val.byte, mask, data);
+
+        iexec->execute = ((val.byte & mask) == data);
+
+        return 6;
+}
+
+static int
 init_copy_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
 {
         /*
@@ -2083,9 +2166,10 @@ peek_fb(struct drm_device *dev, struct io_mapping *fb,
         uint32_t val = 0;
 
         if (off < pci_resource_len(dev->pdev, 1)) {
-                uint32_t __iomem *p = io_mapping_map_atomic_wc(fb, off, KM_USER0);
+                uint32_t __iomem *p =
+                        io_mapping_map_atomic_wc(fb, off & PAGE_MASK, KM_USER0);
 
-                val = ioread32(p);
+                val = ioread32(p + (off & ~PAGE_MASK));
 
                 io_mapping_unmap_atomic(p, KM_USER0);
         }
@@ -2098,9 +2182,10 @@ poke_fb(struct drm_device *dev, struct io_mapping *fb,
         uint32_t off, uint32_t val)
 {
         if (off < pci_resource_len(dev->pdev, 1)) {
-                uint32_t __iomem *p = io_mapping_map_atomic_wc(fb, off, KM_USER0);
+                uint32_t __iomem *p =
+                        io_mapping_map_atomic_wc(fb, off & PAGE_MASK, KM_USER0);
 
-                iowrite32(val, p);
+                iowrite32(val, p + (off & ~PAGE_MASK));
                 wmb();
 
                 io_mapping_unmap_atomic(p, KM_USER0);
@@ -2165,7 +2250,7 @@ nv04_init_compute_mem(struct nvbios *bios)
                           NV04_PFB_BOOT_0_RAM_AMOUNT,
                           NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
 
-        } else if (peek_fb(dev, fb, 0) == patt) {
+        } else if (peek_fb(dev, fb, 0) != patt) {
                 if (read_back_fb(dev, fb, 0x800000, patt))
                         bios_md32(bios, NV04_PFB_BOOT_0,
                                   NV04_PFB_BOOT_0_RAM_AMOUNT,
@@ -2593,7 +2678,7 @@ init_configure_preinit(struct nvbios *bios, uint16_t offset,
         /* no iexec->execute check by design */
 
         uint32_t straps = bios_rd32(bios, NV_PEXTDEV_BOOT_0);
-        uint8_t cr3c = ((straps << 2) & 0xf0) | (straps & (1 << 6));
+        uint8_t cr3c = ((straps << 2) & 0xf0) | (straps & 0x40) >> 6;
 
         if (bios->major_version > 2)
                 return 0;
@@ -3140,7 +3225,7 @@ init_gpio(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
         const uint32_t nv50_gpio_ctl[2] = { 0xe100, 0xe28c };
         int i;
 
-        if (dev_priv->card_type != NV_50) {
+        if (dev_priv->card_type < NV_50) {
                 NV_ERROR(bios->dev, "INIT_GPIO on unsupported chipset\n");
                 return 1;
         }
@@ -3490,6 +3575,69 @@ init_zm_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
         return len;
 }
 
+static int
+init_i2c_long_if(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
+{
+        /*
+         * INIT_I2C_LONG_IF   opcode: 0x9A ('')
+         *
+         * offset      (8 bit): opcode
+         * offset + 1  (8 bit): DCB I2C table entry index
+         * offset + 2  (8 bit): I2C slave address
+         * offset + 3  (16 bit): I2C register
+         * offset + 5  (8 bit): mask
+         * offset + 6  (8 bit): data
+         *
+         * Read the register given by "I2C register" on the device addressed
+         * by "I2C slave address" on the I2C bus given by "DCB I2C table
+         * entry index". Compare the result AND "mask" to "data".
+         * If they're not equal, skip subsequent opcodes until condition is
+         * inverted (INIT_NOT), or we hit INIT_RESUME
+         */
+
+        uint8_t i2c_index = bios->data[offset + 1];
+        uint8_t i2c_address = bios->data[offset + 2] >> 1;
+        uint8_t reglo = bios->data[offset + 3];
+        uint8_t reghi = bios->data[offset + 4];
+        uint8_t mask = bios->data[offset + 5];
+        uint8_t data = bios->data[offset + 6];
+        struct nouveau_i2c_chan *chan;
+        uint8_t buf0[2] = { reghi, reglo };
+        uint8_t buf1[1];
+        struct i2c_msg msg[2] = {
+                { i2c_address, 0, 1, buf0 },
+                { i2c_address, I2C_M_RD, 1, buf1 },
+        };
+        int ret;
+
+        /* no execute check by design */
+
+        BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X\n",
+                offset, i2c_index, i2c_address);
+
+        chan = init_i2c_device_find(bios->dev, i2c_index);
+        if (!chan)
+                return -ENODEV;
+
+
+        ret = i2c_transfer(&chan->adapter, msg, 2);
+        if (ret < 0) {
+                BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X:0x%02X, Value: [no device], "
+                              "Mask: 0x%02X, Data: 0x%02X\n",
+                        offset, reghi, reglo, mask, data);
+                iexec->execute = 0;
+                return 7;
+        }
+
+        BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X:0x%02X, Value: 0x%02X, "
+                      "Mask: 0x%02X, Data: 0x%02X\n",
+                offset, reghi, reglo, buf1[0], mask, data);
+
+        iexec->execute = ((buf1[0] & mask) == data);
+
+        return 7;
+}
+
 static struct init_tbl_entry itbl_entry[] = {
         /* command name                       , id  , length  , offset  , mult    , command handler                 */
         /* INIT_PROG (0x31, 15, 10, 4) removed due to no example of use */
@@ -3516,9 +3664,11 @@ static struct init_tbl_entry itbl_entry[] = {
         { "INIT_ZM_CR"                        , 0x53, init_zm_cr                      },
         { "INIT_ZM_CR_GROUP"                  , 0x54, init_zm_cr_group                },
         { "INIT_CONDITION_TIME"               , 0x56, init_condition_time             },
+        { "INIT_LTIME"                        , 0x57, init_ltime                      },
         { "INIT_ZM_REG_SEQUENCE"              , 0x58, init_zm_reg_sequence            },
         /* INIT_INDIRECT_REG (0x5A, 7, 0, 0) removed due to no example of use */
         { "INIT_SUB_DIRECT"                   , 0x5B, init_sub_direct                 },
+        { "INIT_I2C_IF"                       , 0x5E, init_i2c_if                     },
         { "INIT_COPY_NV_REG"                  , 0x5F, init_copy_nv_reg                },
         { "INIT_ZM_INDEX_IO"                  , 0x62, init_zm_index_io                },
         { "INIT_COMPUTE_MEM"                  , 0x63, init_compute_mem                },
@@ -3552,6 +3702,7 @@ static struct init_tbl_entry itbl_entry[] = {
         { "INIT_97"                           , 0x97, init_97                         },
         { "INIT_AUXCH"                        , 0x98, init_auxch                      },
         { "INIT_ZM_AUXCH"                     , 0x99, init_zm_auxch                   },
+        { "INIT_I2C_LONG_IF"                  , 0x9A, init_i2c_long_if                },
         { NULL                                , 0   , NULL                            }
 };
 
@@ -4410,7 +4561,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                                           bios->display.script_table_ptr,
                                           table[2], table[3], table[0] >= 0x21);
         if (!otable) {
-                NV_ERROR(dev, "Couldn't find matching output script table\n");
+                NV_DEBUG_KMS(dev, "failed to match any output table\n");
                 return 1;
         }
 
@@ -4467,7 +4618,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, struct dcb_entry *dcbent,
                 if (script)
                         script = clkcmptable(bios, script, pxclk);
                 if (!script) {
-                        NV_ERROR(dev, "clock script 0 not found\n");
+                        NV_DEBUG_KMS(dev, "clock script 0 not found\n");
                         return 1;
                 }
 
@@ -4826,7 +4977,7 @@ int get_pll_limits(struct drm_device *dev, uint32_t limit_match, struct pll_lims
                 pll_lim->min_p = record[12];
                 pll_lim->max_p = record[13];
                 /* where did this go to?? */
-                if (limit_match == 0x00614100 || limit_match == 0x00614900)
+                if ((entry[0] & 0xf0) == 0x80)
                         pll_lim->refclk = 27000;
                 else
                         pll_lim->refclk = 100000;
@@ -5852,7 +6003,7 @@ static void fabricate_vga_output(struct dcb_table *dcb, int i2c, int heads)
         entry->i2c_index = i2c;
         entry->heads = heads;
         entry->location = DCB_LOC_ON_CHIP;
-        /* "or" mostly unused in early gen crt modesetting, 0 is fine */
+        entry->or = 1;
 }
 
 static void fabricate_dvi_i_output(struct dcb_table *dcb, bool twoHeads)
@@ -5980,7 +6131,13 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
                 }
                 break;
         case OUTPUT_TMDS:
-                entry->tmdsconf.sor.link = (conf & 0x00000030) >> 4;
+                if (dcb->version >= 0x40)
+                        entry->tmdsconf.sor.link = (conf & 0x00000030) >> 4;
+                else if (dcb->version >= 0x30)
+                        entry->tmdsconf.slave_addr = (conf & 0x00000700) >> 8;
+                else if (dcb->version >= 0x22)
+                        entry->tmdsconf.slave_addr = (conf & 0x00000070) >> 4;
+
                 break;
         case 0xe:
                 /* weird g80 mobile type that "nv" treats as a terminator */
@@ -6270,6 +6427,19 @@ parse_dcb_table(struct drm_device *dev, struct nvbios *bios, bool twoHeads)
                 dcb->i2c_table = &bios->data[i2ctabptr];
                 if (dcb->version >= 0x30)
                         dcb->i2c_default_indices = dcb->i2c_table[4];
+
+                /*
+                 * Parse the "management" I2C bus, used for hardware
+                 * monitoring and some external TMDS transmitters.
+                 */
+                if (dcb->version >= 0x22) {
+                        int idx = (dcb->version >= 0x40 ?
+                                   dcb->i2c_default_indices & 0xf :
+                                   2);
+
+                        read_dcb_i2c_entry(dev, dcb->version, dcb->i2c_table,
+                                           idx, &dcb->i2c[idx]);
+                }
         }
 
         if (entries > DCB_MAX_NUM_ENTRIES)
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.h b/drivers/gpu/drm/nouveau/nouveau_bios.h
index 024458a8d06..fd14dfd3d78 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.h
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.h
@@ -131,6 +131,7 @@ struct dcb_entry {
                 } dpconf;
                 struct {
                         struct sor_conf sor;
+                        int slave_addr;
                 } tmdsconf;
         };
         bool i2c_upper_default;
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.c b/drivers/gpu/drm/nouveau/nouveau_bo.c
index 3ca8343c15d..84f85183d04 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bo.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bo.c
@@ -51,9 +51,6 @@ nouveau_bo_del_ttm(struct ttm_buffer_object *bo)
         if (nvbo->tile)
                 nv10_mem_expire_tiling(dev, nvbo->tile, NULL);
 
-        spin_lock(&dev_priv->ttm.bo_list_lock);
-        list_del(&nvbo->head);
-        spin_unlock(&dev_priv->ttm.bo_list_lock);
         kfree(nvbo);
 }
 
@@ -166,9 +163,6 @@ nouveau_bo_new(struct drm_device *dev, struct nouveau_channel *chan,
         }
         nvbo->channel = NULL;
 
-        spin_lock(&dev_priv->ttm.bo_list_lock);
-        list_add_tail(&nvbo->head, &dev_priv->ttm.bo_list);
-        spin_unlock(&dev_priv->ttm.bo_list_lock);
         *pnvbo = nvbo;
         return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index 734e92635e8..b1b22baf142 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
@@ -37,12 +37,6 @@
 #include "nouveau_connector.h"
 #include "nouveau_hw.h"
 
-static inline struct drm_encoder_slave_funcs *
-get_slave_funcs(struct nouveau_encoder *enc)
-{
-        return to_encoder_slave(to_drm_encoder(enc))->slave_funcs;
-}
-
 static struct nouveau_encoder *
 find_encoder_by_type(struct drm_connector *connector, int type)
 {
@@ -360,6 +354,7 @@ nouveau_connector_set_property(struct drm_connector *connector,
 {
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
+        struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
         struct drm_device *dev = connector->dev;
         int ret;
 
@@ -432,8 +427,8 @@ nouveau_connector_set_property(struct drm_connector *connector,
         }
 
         if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV)
-                return get_slave_funcs(nv_encoder)->
-                        set_property(to_drm_encoder(nv_encoder), connector, property, value);
+                return get_slave_funcs(encoder)->set_property(
+                        encoder, connector, property, value);
 
         return -EINVAL;
 }
@@ -545,6 +540,7 @@ nouveau_connector_get_modes(struct drm_connector *connector)
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
+        struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
         int ret = 0;
 
         /* destroy the native mode, the attached monitor could have changed.
@@ -580,8 +576,7 @@ nouveau_connector_get_modes(struct drm_connector *connector)
         }
 
         if (nv_encoder->dcb->type == OUTPUT_TV)
-                ret = get_slave_funcs(nv_encoder)->
-                        get_modes(to_drm_encoder(nv_encoder), connector);
+                ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
 
         if (nv_connector->dcb->type == DCB_CONNECTOR_LVDS ||
             nv_connector->dcb->type == DCB_CONNECTOR_eDP)
@@ -597,6 +592,7 @@ nouveau_connector_mode_valid(struct drm_connector *connector,
         struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
+        struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
         unsigned min_clock = 25000, max_clock = min_clock;
         unsigned clock = mode->clock;
 
@@ -623,8 +619,7 @@ nouveau_connector_mode_valid(struct drm_connector *connector,
                         max_clock = 350000;
                 break;
         case OUTPUT_TV:
-                return get_slave_funcs(nv_encoder)->
-                        mode_valid(to_drm_encoder(nv_encoder), mode);
+                return get_slave_funcs(encoder)->mode_valid(encoder, mode);
         case OUTPUT_DP:
                 if (nv_encoder->dp.link_bw == DP_LINK_BW_2_7)
                         max_clock = nv_encoder->dp.link_nr * 270000;
diff --git a/drivers/gpu/drm/nouveau/nouveau_display.c b/drivers/gpu/drm/nouveau/nouveau_display.c
index 74e6b4ed12c..2e11fd65b4d 100644
--- a/drivers/gpu/drm/nouveau/nouveau_display.c
+++ b/drivers/gpu/drm/nouveau/nouveau_display.c
@@ -84,16 +84,16 @@ nouveau_user_framebuffer_create(struct drm_device *dev,
 
         gem = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle);
         if (!gem)
-                return NULL;
+                return ERR_PTR(-ENOENT);
 
         nouveau_fb = kzalloc(sizeof(struct nouveau_framebuffer), GFP_KERNEL);
         if (!nouveau_fb)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         ret = nouveau_framebuffer_init(dev, nouveau_fb, mode_cmd, nouveau_gem_object(gem));
         if (ret) {
                 drm_gem_object_unreference(gem);
-                return NULL;
+                return ERR_PTR(ret);
         }
 
         return &nouveau_fb->base;
diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index 33742b11188..8a1b188b4cd 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dp.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dp.c
@@ -572,47 +572,64 @@ out:
         return ret ? ret : (stat & NV50_AUXCH_STAT_REPLY);
 }
 
-int
-nouveau_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
-                      uint8_t write_byte, uint8_t *read_byte)
+static int
+nouveau_dp_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 {
-        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
-        struct nouveau_i2c_chan *auxch = (struct nouveau_i2c_chan *)adapter;
+        struct nouveau_i2c_chan *auxch = (struct nouveau_i2c_chan *)adap;
         struct drm_device *dev = auxch->dev;
-        int ret = 0, cmd, addr = algo_data->address;
-        uint8_t *buf;
-
-        if (mode == MODE_I2C_READ) {
-                cmd = AUX_I2C_READ;
-                buf = read_byte;
-        } else {
-                cmd = (mode & MODE_I2C_READ) ? AUX_I2C_READ : AUX_I2C_WRITE;
-                buf = &write_byte;
-        }
+        struct i2c_msg *msg = msgs;
+        int ret, mcnt = num;
 
-        if (!(mode & MODE_I2C_STOP))
-                cmd |= AUX_I2C_MOT;
+        while (mcnt--) {
+                u8 remaining = msg->len;
+                u8 *ptr = msg->buf;
 
-        if (mode & MODE_I2C_START)
-                return 1;
+                while (remaining) {
+                        u8 cnt = (remaining > 16) ? 16 : remaining;
+                        u8 cmd;
 
-        for (;;) {
-                ret = nouveau_dp_auxch(auxch, cmd, addr, buf, 1);
-                if (ret < 0)
-                        return ret;
-
-                switch (ret & NV50_AUXCH_STAT_REPLY_I2C) {
-                case NV50_AUXCH_STAT_REPLY_I2C_ACK:
-                        return 1;
-                case NV50_AUXCH_STAT_REPLY_I2C_NACK:
-                        return -EREMOTEIO;
-                case NV50_AUXCH_STAT_REPLY_I2C_DEFER:
-                        udelay(100);
-                        break;
-                default:
-                        NV_ERROR(dev, "invalid auxch status: 0x%08x\n", ret);
-                        return -EREMOTEIO;
+                        if (msg->flags & I2C_M_RD)
+                                cmd = AUX_I2C_READ;
+                        else
+                                cmd = AUX_I2C_WRITE;
+
+                        if (mcnt || remaining > 16)
+                                cmd |= AUX_I2C_MOT;
+
+                        ret = nouveau_dp_auxch(auxch, cmd, msg->addr, ptr, cnt);
+                        if (ret < 0)
+                                return ret;
+
+                        switch (ret & NV50_AUXCH_STAT_REPLY_I2C) {
+                        case NV50_AUXCH_STAT_REPLY_I2C_ACK:
+                                break;
+                        case NV50_AUXCH_STAT_REPLY_I2C_NACK:
+                                return -EREMOTEIO;
+                        case NV50_AUXCH_STAT_REPLY_I2C_DEFER:
+                                udelay(100);
+                                continue;
+                        default:
+                                NV_ERROR(dev, "bad auxch reply: 0x%08x\n", ret);
+                                return -EREMOTEIO;
+                        }
+
+                        ptr += cnt;
+                        remaining -= cnt;
                 }
+
+                msg++;
         }
+
+        return num;
+}
+
+static u32
+nouveau_dp_i2c_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 
+const struct i2c_algorithm nouveau_dp_i2c_algo = {
+        .master_xfer = nouveau_dp_i2c_xfer,
+        .functionality = nouveau_dp_i2c_func
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h
index e15db15dca7..e424bf74d70 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drv.h
+++ b/drivers/gpu/drm/nouveau/nouveau_drv.h
@@ -410,7 +410,7 @@ enum nv04_fp_display_regs {
 
 struct nv04_crtc_reg {
         unsigned char MiscOutReg;     /* */
-        uint8_t CRTC[0x9f];
+        uint8_t CRTC[0xa0];
         uint8_t CR58[0x10];
         uint8_t Sequencer[5];
         uint8_t Graphics[9];
@@ -509,6 +509,7 @@ enum nouveau_card_type {
         NV_30      = 0x30,
         NV_40      = 0x40,
         NV_50      = 0x50,
+        NV_C0      = 0xc0,
 };
 
 struct drm_nouveau_private {
@@ -536,8 +537,6 @@ struct drm_nouveau_private {
                 struct drm_global_reference mem_global_ref;
                 struct ttm_bo_global_ref bo_global_ref;
                 struct ttm_bo_device bdev;
-                spinlock_t bo_list_lock;
-                struct list_head bo_list;
                 atomic_t validate_sequence;
         } ttm;
 
@@ -931,6 +930,10 @@ extern void nv40_fb_set_region_tiling(struct drm_device *, int, uint32_t,
 extern int  nv50_fb_init(struct drm_device *);
 extern void nv50_fb_takedown(struct drm_device *);
 
+/* nvc0_fb.c */
+extern int  nvc0_fb_init(struct drm_device *);
+extern void nvc0_fb_takedown(struct drm_device *);
+
 /* nv04_fifo.c */
 extern int  nv04_fifo_init(struct drm_device *);
 extern void nv04_fifo_disable(struct drm_device *);
@@ -968,6 +971,20 @@ extern void nv50_fifo_destroy_context(struct nouveau_channel *);
 extern int  nv50_fifo_load_context(struct nouveau_channel *);
 extern int  nv50_fifo_unload_context(struct drm_device *);
 
+/* nvc0_fifo.c */
+extern int  nvc0_fifo_init(struct drm_device *);
+extern void nvc0_fifo_takedown(struct drm_device *);
+extern void nvc0_fifo_disable(struct drm_device *);
+extern void nvc0_fifo_enable(struct drm_device *);
+extern bool nvc0_fifo_reassign(struct drm_device *, bool);
+extern bool nvc0_fifo_cache_flush(struct drm_device *);
+extern bool nvc0_fifo_cache_pull(struct drm_device *, bool);
+extern int  nvc0_fifo_channel_id(struct drm_device *);
+extern int  nvc0_fifo_create_context(struct nouveau_channel *);
+extern void nvc0_fifo_destroy_context(struct nouveau_channel *);
+extern int  nvc0_fifo_load_context(struct nouveau_channel *);
+extern int  nvc0_fifo_unload_context(struct drm_device *);
+
 /* nv04_graph.c */
 extern struct nouveau_pgraph_object_class nv04_graph_grclass[];
 extern int  nv04_graph_init(struct drm_device *);
@@ -1032,6 +1049,16 @@ extern int  nv50_graph_unload_context(struct drm_device *);
 extern void nv50_graph_context_switch(struct drm_device *);
 extern int  nv50_grctx_init(struct nouveau_grctx *);
 
+/* nvc0_graph.c */
+extern int  nvc0_graph_init(struct drm_device *);
+extern void nvc0_graph_takedown(struct drm_device *);
+extern void nvc0_graph_fifo_access(struct drm_device *, bool);
+extern struct nouveau_channel *nvc0_graph_channel(struct drm_device *);
+extern int  nvc0_graph_create_context(struct nouveau_channel *);
+extern void nvc0_graph_destroy_context(struct nouveau_channel *);
+extern int  nvc0_graph_load_context(struct nouveau_channel *);
+extern int  nvc0_graph_unload_context(struct drm_device *);
+
 /* nv04_instmem.c */
 extern int  nv04_instmem_init(struct drm_device *);
 extern void nv04_instmem_takedown(struct drm_device *);
@@ -1058,6 +1085,18 @@ extern void nv50_instmem_flush(struct drm_device *);
 extern void nv84_instmem_flush(struct drm_device *);
 extern void nv50_vm_flush(struct drm_device *, int engine);
 
+/* nvc0_instmem.c */
+extern int  nvc0_instmem_init(struct drm_device *);
+extern void nvc0_instmem_takedown(struct drm_device *);
+extern int  nvc0_instmem_suspend(struct drm_device *);
+extern void nvc0_instmem_resume(struct drm_device *);
+extern int  nvc0_instmem_populate(struct drm_device *, struct nouveau_gpuobj *,
+                                  uint32_t *size);
+extern void nvc0_instmem_clear(struct drm_device *, struct nouveau_gpuobj *);
+extern int  nvc0_instmem_bind(struct drm_device *, struct nouveau_gpuobj *);
+extern int  nvc0_instmem_unbind(struct drm_device *, struct nouveau_gpuobj *);
+extern void nvc0_instmem_flush(struct drm_device *);
+
 /* nv04_mc.c */
 extern int  nv04_mc_init(struct drm_device *);
 extern void nv04_mc_takedown(struct drm_device *);
diff --git a/drivers/gpu/drm/nouveau/nouveau_encoder.h b/drivers/gpu/drm/nouveau/nouveau_encoder.h
index a1a0d48ae70..7c82d68bc15 100644
--- a/drivers/gpu/drm/nouveau/nouveau_encoder.h
+++ b/drivers/gpu/drm/nouveau/nouveau_encoder.h
@@ -71,6 +71,12 @@ static inline struct drm_encoder *to_drm_encoder(struct nouveau_encoder *enc)
         return &enc->base.base;
 }
 
+static inline struct drm_encoder_slave_funcs *
+get_slave_funcs(struct drm_encoder *enc)
+{
+        return to_encoder_slave(enc)->slave_funcs;
+}
+
 struct nouveau_connector *
 nouveau_encoder_connector_get(struct nouveau_encoder *encoder);
 int nv50_sor_create(struct drm_connector *, struct dcb_entry *);
diff --git a/drivers/gpu/drm/nouveau/nouveau_fbcon.c b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
index 099f637264a..dbd30b2e43f 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
@@ -281,6 +281,8 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
 
         if (dev_priv->channel && !nouveau_nofbaccel) {
                 switch (dev_priv->card_type) {
+                case NV_C0:
+                        break;
                 case NV_50:
                         nv50_fbcon_accel_init(info);
                         info->fbops = &nv50_fbcon_ops;
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c
index 547f2c24c1e..0f417ac1b69 100644
--- a/drivers/gpu/drm/nouveau/nouveau_gem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_gem.c
@@ -284,7 +284,7 @@ retry:
                 if (!gem) {
                         NV_ERROR(dev, "Unknown handle 0x%08x\n", b->handle);
                         validate_fini(op, NULL);
-                        return -EINVAL;
+                        return -ENOENT;
                 }
                 nvbo = gem->driver_private;
 
@@ -759,7 +759,7 @@ nouveau_gem_ioctl_cpu_prep(struct drm_device *dev, void *data,
 
         gem = drm_gem_object_lookup(dev, file_priv, req->handle);
         if (!gem)
-                return ret;
+                return -ENOENT;
         nvbo = nouveau_gem_object(gem);
 
         if (nvbo->cpu_filp) {
@@ -797,7 +797,7 @@ nouveau_gem_ioctl_cpu_fini(struct drm_device *dev, void *data,
 
         gem = drm_gem_object_lookup(dev, file_priv, req->handle);
         if (!gem)
-                return ret;
+                return -ENOENT;
         nvbo = nouveau_gem_object(gem);
 
         if (nvbo->cpu_filp != file_priv)
@@ -822,7 +822,7 @@ nouveau_gem_ioctl_info(struct drm_device *dev, void *data,
 
         gem = drm_gem_object_lookup(dev, file_priv, req->handle);
         if (!gem)
-                return -EINVAL;
+                return -ENOENT;
 
         ret = nouveau_gem_info(gem, req);
         drm_gem_object_unreference_unlocked(gem);
diff --git a/drivers/gpu/drm/nouveau/nouveau_hw.c b/drivers/gpu/drm/nouveau/nouveau_hw.c
index 7855b35effc..7b613682e40 100644
--- a/drivers/gpu/drm/nouveau/nouveau_hw.c
+++ b/drivers/gpu/drm/nouveau/nouveau_hw.c
@@ -865,8 +865,12 @@ nv_save_state_ext(struct drm_device *dev, int head,
         rd_cio_state(dev, head, regp, NV_CIO_CRE_FF_INDEX);
         rd_cio_state(dev, head, regp, NV_CIO_CRE_FFLWM__INDEX);
         rd_cio_state(dev, head, regp, NV_CIO_CRE_21);
-        if (dev_priv->card_type >= NV_30)
+
+        if (dev_priv->card_type >= NV_30) {
                 rd_cio_state(dev, head, regp, NV_CIO_CRE_47);
+                rd_cio_state(dev, head, regp, 0x9f);
+        }
+
         rd_cio_state(dev, head, regp, NV_CIO_CRE_49);
         rd_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX);
         rd_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX);
@@ -971,8 +975,11 @@ nv_load_state_ext(struct drm_device *dev, int head,
         wr_cio_state(dev, head, regp, NV_CIO_CRE_ENH_INDEX);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_FF_INDEX);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_FFLWM__INDEX);
-        if (dev_priv->card_type >= NV_30)
+
+        if (dev_priv->card_type >= NV_30) {
                 wr_cio_state(dev, head, regp, NV_CIO_CRE_47);
+                wr_cio_state(dev, head, regp, 0x9f);
+        }
 
         wr_cio_state(dev, head, regp, NV_CIO_CRE_49);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX);
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.c b/drivers/gpu/drm/nouveau/nouveau_i2c.c
index cb0cb34440c..0bd407ca3d4 100644
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.c
+++ b/drivers/gpu/drm/nouveau/nouveau_i2c.c
@@ -163,7 +163,7 @@ nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index)
         if (entry->chan)
                 return -EEXIST;
 
-        if (dev_priv->card_type == NV_50 && entry->read >= NV50_I2C_PORTS) {
+        if (dev_priv->card_type == NV_C0 && entry->read >= NV50_I2C_PORTS) {
                 NV_ERROR(dev, "unknown i2c port %d\n", entry->read);
                 return -EINVAL;
         }
@@ -174,26 +174,26 @@ nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index)
 
         switch (entry->port_type) {
         case 0:
-                i2c->algo.bit.setsda = nv04_i2c_setsda;
-                i2c->algo.bit.setscl = nv04_i2c_setscl;
-                i2c->algo.bit.getsda = nv04_i2c_getsda;
-                i2c->algo.bit.getscl = nv04_i2c_getscl;
+                i2c->bit.setsda = nv04_i2c_setsda;
+                i2c->bit.setscl = nv04_i2c_setscl;
+                i2c->bit.getsda = nv04_i2c_getsda;
+                i2c->bit.getscl = nv04_i2c_getscl;
                 i2c->rd = entry->read;
                 i2c->wr = entry->write;
                 break;
         case 4:
-                i2c->algo.bit.setsda = nv4e_i2c_setsda;
-                i2c->algo.bit.setscl = nv4e_i2c_setscl;
-                i2c->algo.bit.getsda = nv4e_i2c_getsda;
-                i2c->algo.bit.getscl = nv4e_i2c_getscl;
+                i2c->bit.setsda = nv4e_i2c_setsda;
+                i2c->bit.setscl = nv4e_i2c_setscl;
+                i2c->bit.getsda = nv4e_i2c_getsda;
+                i2c->bit.getscl = nv4e_i2c_getscl;
                 i2c->rd = 0x600800 + entry->read;
                 i2c->wr = 0x600800 + entry->write;
                 break;
         case 5:
-                i2c->algo.bit.setsda = nv50_i2c_setsda;
-                i2c->algo.bit.setscl = nv50_i2c_setscl;
-                i2c->algo.bit.getsda = nv50_i2c_getsda;
-                i2c->algo.bit.getscl = nv50_i2c_getscl;
+                i2c->bit.setsda = nv50_i2c_setsda;
+                i2c->bit.setscl = nv50_i2c_setscl;
+                i2c->bit.getsda = nv50_i2c_getsda;
+                i2c->bit.getscl = nv50_i2c_getscl;
                 i2c->rd = nv50_i2c_port[entry->read];
                 i2c->wr = i2c->rd;
                 break;
@@ -216,17 +216,14 @@ nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index)
         i2c_set_adapdata(&i2c->adapter, i2c);
 
         if (entry->port_type < 6) {
-                i2c->adapter.algo_data = &i2c->algo.bit;
-                i2c->algo.bit.udelay = 40;
-                i2c->algo.bit.timeout = usecs_to_jiffies(5000);
-                i2c->algo.bit.data = i2c;
+                i2c->adapter.algo_data = &i2c->bit;
+                i2c->bit.udelay = 40;
+                i2c->bit.timeout = usecs_to_jiffies(5000);
+                i2c->bit.data = i2c;
                 ret = i2c_bit_add_bus(&i2c->adapter);
         } else {
-                i2c->adapter.algo_data = &i2c->algo.dp;
-                i2c->algo.dp.running = false;
-                i2c->algo.dp.address = 0;
-                i2c->algo.dp.aux_ch = nouveau_dp_i2c_aux_ch;
-                ret = i2c_dp_aux_add_bus(&i2c->adapter);
+                i2c->adapter.algo = &nouveau_dp_i2c_algo;
+                ret = i2c_add_adapter(&i2c->adapter);
         }
 
         if (ret) {
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.h b/drivers/gpu/drm/nouveau/nouveau_i2c.h
index 6dd2f8713cd..f71cb32f757 100644
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.h
+++ b/drivers/gpu/drm/nouveau/nouveau_i2c.h
@@ -33,10 +33,7 @@ struct dcb_i2c_entry;
 struct nouveau_i2c_chan {
         struct i2c_adapter adapter;
         struct drm_device *dev;
-        union {
-                struct i2c_algo_bit_data bit;
-                struct i2c_algo_dp_aux_data dp;
-        } algo;
+        struct i2c_algo_bit_data bit;
         unsigned rd;
         unsigned wr;
         unsigned data;
@@ -49,7 +46,6 @@ bool nouveau_probe_i2c_addr(struct nouveau_i2c_chan *i2c, int addr);
 int nouveau_i2c_identify(struct drm_device *dev, const char *what,
                          struct i2c_board_info *info, int index);
 
-int nouveau_dp_i2c_aux_ch(struct i2c_adapter *, int mode, uint8_t write_byte,
-                          uint8_t *read_byte);
+extern const struct i2c_algorithm nouveau_dp_i2c_algo;
 
 #endif /* __NOUVEAU_I2C_H__ */
diff --git a/drivers/gpu/drm/nouveau/nouveau_irq.c b/drivers/gpu/drm/nouveau/nouveau_irq.c
index 53360f15606..794b0ee30cf 100644
--- a/drivers/gpu/drm/nouveau/nouveau_irq.c
+++ b/drivers/gpu/drm/nouveau/nouveau_irq.c
@@ -49,7 +49,7 @@ nouveau_irq_preinstall(struct drm_device *dev)
         /* Master disable */
         nv_wr32(dev, NV03_PMC_INTR_EN_0, 0);
 
-        if (dev_priv->card_type == NV_50) {
+        if (dev_priv->card_type >= NV_50) {
                 INIT_WORK(&dev_priv->irq_work, nv50_display_irq_handler_bh);
                 INIT_WORK(&dev_priv->hpd_work, nv50_display_irq_hotplug_bh);
                 INIT_LIST_HEAD(&dev_priv->vbl_waiting);
@@ -586,11 +586,11 @@ nouveau_pgraph_irq_handler(struct drm_device *dev)
                 }
 
                 if (status & NV_PGRAPH_INTR_CONTEXT_SWITCH) {
-                        nouveau_pgraph_intr_context_switch(dev);
-
                         status &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
                         nv_wr32(dev, NV03_PGRAPH_INTR,
                                  NV_PGRAPH_INTR_CONTEXT_SWITCH);
+
+                        nouveau_pgraph_intr_context_switch(dev);
                 }
 
                 if (status) {
diff --git a/drivers/gpu/drm/nouveau/nouveau_mem.c b/drivers/gpu/drm/nouveau/nouveau_mem.c
index a9f36ab256b..9689d414768 100644
--- a/drivers/gpu/drm/nouveau/nouveau_mem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_mem.c
@@ -320,7 +320,8 @@ nouveau_mem_detect(struct drm_device *dev)
         if (dev_priv->card_type < NV_50) {
                 dev_priv->vram_size  = nv_rd32(dev, NV04_PFB_FIFO_DATA);
                 dev_priv->vram_size &= NV10_PFB_FIFO_DATA_RAM_AMOUNT_MB_MASK;
-        } else {
+        } else
+        if (dev_priv->card_type < NV_C0) {
                 dev_priv->vram_size = nv_rd32(dev, NV04_PFB_FIFO_DATA);
                 dev_priv->vram_size |= (dev_priv->vram_size & 0xff) << 32;
                 dev_priv->vram_size &= 0xffffffff00ll;
@@ -328,6 +329,9 @@ nouveau_mem_detect(struct drm_device *dev)
                         dev_priv->vram_sys_base = nv_rd32(dev, 0x100e10);
                         dev_priv->vram_sys_base <<= 12;
                 }
+        } else {
+                dev_priv->vram_size  = nv_rd32(dev, 0x10f20c) << 20;
+                dev_priv->vram_size *= nv_rd32(dev, 0x121c74);
         }
 
         NV_INFO(dev, "Detected %dMiB VRAM\n", (int)(dev_priv->vram_size >> 20));
@@ -351,7 +355,7 @@ nouveau_mem_reset_agp(struct drm_device *dev)
         /* First of all, disable fast writes, otherwise if it's
          * already enabled in the AGP bridge and we disable the card's
          * AGP controller we might be locking ourselves out of it. */
-        if (dev->agp->acquired) {
+        if (nv_rd32(dev, NV04_PBUS_PCI_NV_19) & PCI_AGP_COMMAND_FW) {
                 struct drm_agp_info info;
                 struct drm_agp_mode mode;
 
@@ -359,7 +363,7 @@ nouveau_mem_reset_agp(struct drm_device *dev)
                 if (ret)
                         return ret;
 
-                mode.mode = info.mode & ~0x10;
+                mode.mode = info.mode & ~PCI_AGP_COMMAND_FW;
                 ret = drm_agp_enable(dev, mode);
                 if (ret)
                         return ret;
@@ -405,6 +409,8 @@ nouveau_mem_init_agp(struct drm_device *dev)
                 }
         }
 
+        nouveau_mem_reset_agp(dev);
+
         ret = drm_agp_info(dev, &info);
         if (ret) {
                 NV_ERROR(dev, "Unable to get AGP info: %d\n", ret);
@@ -459,8 +465,6 @@ nouveau_mem_init(struct drm_device *dev)
                 return ret;
         }
 
-        INIT_LIST_HEAD(&dev_priv->ttm.bo_list);
-        spin_lock_init(&dev_priv->ttm.bo_list_lock);
         spin_lock_init(&dev_priv->tile.lock);
 
         dev_priv->fb_available_size = dev_priv->vram_size;
@@ -494,7 +498,6 @@ nouveau_mem_init(struct drm_device *dev)
         /* GART */
 #if !defined(__powerpc__) && !defined(__ia64__)
         if (drm_device_is_agp(dev) && dev->agp && !nouveau_noagp) {
-                nouveau_mem_reset_agp(dev);
                 ret = nouveau_mem_init_agp(dev);
                 if (ret)
                         NV_ERROR(dev, "Error initialising AGP: %d\n", ret);
diff --git a/drivers/gpu/drm/nouveau/nouveau_reg.h b/drivers/gpu/drm/nouveau/nouveau_reg.h
index 9c1056cb8a9..21a6e453b97 100644
--- a/drivers/gpu/drm/nouveau/nouveau_reg.h
+++ b/drivers/gpu/drm/nouveau/nouveau_reg.h
@@ -220,28 +220,21 @@
 #    define NV_PGRAPH_INTR_ERROR                              (1<<20)
 #define NV10_PGRAPH_CTX_CONTROL                            0x00400144
 #define NV10_PGRAPH_CTX_USER                               0x00400148
-#define NV10_PGRAPH_CTX_SWITCH1                            0x0040014C
-#define NV10_PGRAPH_CTX_SWITCH2                            0x00400150
-#define NV10_PGRAPH_CTX_SWITCH3                            0x00400154
-#define NV10_PGRAPH_CTX_SWITCH4                            0x00400158
-#define NV10_PGRAPH_CTX_SWITCH5                            0x0040015C
+#define NV10_PGRAPH_CTX_SWITCH(i)                         (0x0040014C + 0x4*(i))
 #define NV04_PGRAPH_CTX_SWITCH1                            0x00400160
-#define NV10_PGRAPH_CTX_CACHE1                             0x00400160
+#define NV10_PGRAPH_CTX_CACHE(i, j)                       (0x00400160   \
+                                                           + 0x4*(i) + 0x20*(j))
 #define NV04_PGRAPH_CTX_SWITCH2                            0x00400164
 #define NV04_PGRAPH_CTX_SWITCH3                            0x00400168
 #define NV04_PGRAPH_CTX_SWITCH4                            0x0040016C
 #define NV04_PGRAPH_CTX_CONTROL                            0x00400170
 #define NV04_PGRAPH_CTX_USER                               0x00400174
 #define NV04_PGRAPH_CTX_CACHE1                             0x00400180
-#define NV10_PGRAPH_CTX_CACHE2                             0x00400180
 #define NV03_PGRAPH_CTX_CONTROL                            0x00400190
 #define NV03_PGRAPH_CTX_USER                               0x00400194
 #define NV04_PGRAPH_CTX_CACHE2                             0x004001A0
-#define NV10_PGRAPH_CTX_CACHE3                             0x004001A0
 #define NV04_PGRAPH_CTX_CACHE3                             0x004001C0
-#define NV10_PGRAPH_CTX_CACHE4                             0x004001C0
 #define NV04_PGRAPH_CTX_CACHE4                             0x004001E0
-#define NV10_PGRAPH_CTX_CACHE5                             0x004001E0
 #define NV40_PGRAPH_CTXCTL_0304                            0x00400304
 #define NV40_PGRAPH_CTXCTL_0304_XFER_CTX                   0x00000001
 #define NV40_PGRAPH_CTXCTL_UCODE_STAT                      0x00400308
@@ -356,9 +349,12 @@
 #define NV04_PGRAPH_FFINTFC_ST2                            0x00400754
 #define NV10_PGRAPH_RDI_DATA                               0x00400754
 #define NV04_PGRAPH_DMA_PITCH                              0x00400760
-#define NV10_PGRAPH_FFINTFC_ST2                            0x00400764
+#define NV10_PGRAPH_FFINTFC_FIFO_PTR                       0x00400760
 #define NV04_PGRAPH_DVD_COLORFMT                           0x00400764
+#define NV10_PGRAPH_FFINTFC_ST2                            0x00400764
 #define NV04_PGRAPH_SCALED_FORMAT                          0x00400768
+#define NV10_PGRAPH_FFINTFC_ST2_DL                         0x00400768
+#define NV10_PGRAPH_FFINTFC_ST2_DH                         0x0040076c
 #define NV10_PGRAPH_DMA_PITCH                              0x00400770
 #define NV10_PGRAPH_DVD_COLORFMT                           0x00400774
 #define NV10_PGRAPH_SCALED_FORMAT                          0x00400778
diff --git a/drivers/gpu/drm/nouveau/nouveau_state.c b/drivers/gpu/drm/nouveau/nouveau_state.c
index ee3729e7823..989322be372 100644
--- a/drivers/gpu/drm/nouveau/nouveau_state.c
+++ b/drivers/gpu/drm/nouveau/nouveau_state.c
@@ -359,6 +359,54 @@ static int nouveau_init_engine_ptrs(struct drm_device *dev)
                 engine->gpio.set                = nv50_gpio_set;
                 engine->gpio.irq_enable         = nv50_gpio_irq_enable;
                 break;
+        case 0xC0:
+                engine->instmem.init            = nvc0_instmem_init;
+                engine->instmem.takedown        = nvc0_instmem_takedown;
+                engine->instmem.suspend         = nvc0_instmem_suspend;
+                engine->instmem.resume          = nvc0_instmem_resume;
+                engine->instmem.populate        = nvc0_instmem_populate;
+                engine->instmem.clear           = nvc0_instmem_clear;
+                engine->instmem.bind            = nvc0_instmem_bind;
+                engine->instmem.unbind          = nvc0_instmem_unbind;
+                engine->instmem.flush           = nvc0_instmem_flush;
+                engine->mc.init                 = nv50_mc_init;
+                engine->mc.takedown             = nv50_mc_takedown;
+                engine->timer.init              = nv04_timer_init;
+                engine->timer.read              = nv04_timer_read;
+                engine->timer.takedown          = nv04_timer_takedown;
+                engine->fb.init                 = nvc0_fb_init;
+                engine->fb.takedown             = nvc0_fb_takedown;
+                engine->graph.grclass           = NULL;  //nvc0_graph_grclass;
+                engine->graph.init              = nvc0_graph_init;
+                engine->graph.takedown          = nvc0_graph_takedown;
+                engine->graph.fifo_access       = nvc0_graph_fifo_access;
+                engine->graph.channel           = nvc0_graph_channel;
+                engine->graph.create_context    = nvc0_graph_create_context;
+                engine->graph.destroy_context   = nvc0_graph_destroy_context;
+                engine->graph.load_context      = nvc0_graph_load_context;
+                engine->graph.unload_context    = nvc0_graph_unload_context;
+                engine->fifo.channels           = 128;
+                engine->fifo.init               = nvc0_fifo_init;
+                engine->fifo.takedown           = nvc0_fifo_takedown;
+                engine->fifo.disable            = nvc0_fifo_disable;
+                engine->fifo.enable             = nvc0_fifo_enable;
+                engine->fifo.reassign           = nvc0_fifo_reassign;
+                engine->fifo.channel_id         = nvc0_fifo_channel_id;
+                engine->fifo.create_context     = nvc0_fifo_create_context;
+                engine->fifo.destroy_context    = nvc0_fifo_destroy_context;
+                engine->fifo.load_context       = nvc0_fifo_load_context;
+                engine->fifo.unload_context     = nvc0_fifo_unload_context;
+                engine->display.early_init      = nv50_display_early_init;
+                engine->display.late_takedown   = nv50_display_late_takedown;
+                engine->display.create          = nv50_display_create;
+                engine->display.init            = nv50_display_init;
+                engine->display.destroy         = nv50_display_destroy;
+                engine->gpio.init               = nv50_gpio_init;
+                engine->gpio.takedown           = nouveau_stub_takedown;
+                engine->gpio.get                = nv50_gpio_get;
+                engine->gpio.set                = nv50_gpio_set;
+                engine->gpio.irq_enable         = nv50_gpio_irq_enable;
+                break;
         default:
                 NV_ERROR(dev, "NV%02x unsupported\n", dev_priv->chipset);
                 return 1;
@@ -739,8 +787,10 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
         int ret;
 
         dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
-        if (!dev_priv)
-                return -ENOMEM;
+        if (!dev_priv) {
+                ret = -ENOMEM;
+                goto err_out;
+        }
         dev->dev_private = dev_priv;
         dev_priv->dev = dev;
 
@@ -750,8 +800,10 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
                  dev->pci_vendor, dev->pci_device, dev->pdev->class);
 
         dev_priv->wq = create_workqueue("nouveau");
-        if (!dev_priv->wq)
-                return -EINVAL;
+        if (!dev_priv->wq) {
+                ret = -EINVAL;
+                goto err_priv;
+        }
 
         /* resource 0 is mmio regs */
         /* resource 1 is linear FB */
@@ -764,7 +816,8 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
         if (!dev_priv->mmio) {
                 NV_ERROR(dev, "Unable to initialize the mmio mapping. "
                          "Please report your setup to " DRIVER_EMAIL "\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err_wq;
         }
         NV_DEBUG(dev, "regs mapped ok at 0x%llx\n",
                                         (unsigned long long)mmio_start_offs);
@@ -810,9 +863,13 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
         case 0xa0:
                 dev_priv->card_type = NV_50;
                 break;
+        case 0xc0:
+                dev_priv->card_type = NV_C0;
+                break;
         default:
                 NV_INFO(dev, "Unsupported chipset 0x%08x\n", reg0);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err_mmio;
         }
 
         NV_INFO(dev, "Detected an NV%2x generation card (0x%08x)\n",
@@ -820,7 +877,7 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
 
         ret = nouveau_remove_conflicting_drivers(dev);
         if (ret)
-                return ret;
+                goto err_mmio;
 
         /* Map PRAMIN BAR, or on older cards, the aperture withing BAR0 */
         if (dev_priv->card_type >= NV_40) {
@@ -834,7 +891,8 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
                                 dev_priv->ramin_size);
                 if (!dev_priv->ramin) {
                         NV_ERROR(dev, "Failed to PRAMIN BAR");
-                        return -ENOMEM;
+                        ret = -ENOMEM;
+                        goto err_mmio;
                 }
         } else {
                 dev_priv->ramin_size = 1 * 1024 * 1024;
@@ -842,7 +900,8 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
                                           dev_priv->ramin_size);
                 if (!dev_priv->ramin) {
                         NV_ERROR(dev, "Failed to map BAR0 PRAMIN.\n");
-                        return -ENOMEM;
+                        ret = -ENOMEM;
+                        goto err_mmio;
                 }
         }
 
@@ -857,9 +916,21 @@ int nouveau_load(struct drm_device *dev, unsigned long flags)
         /* For kernel modesetting, init card now and bring up fbcon */
         ret = nouveau_card_init(dev);
         if (ret)
-                return ret;
+                goto err_ramin;
 
         return 0;
+
+err_ramin:
+        iounmap(dev_priv->ramin);
+err_mmio:
+        iounmap(dev_priv->mmio);
+err_wq:
+        destroy_workqueue(dev_priv->wq);
+err_priv:
+        kfree(dev_priv);
+        dev->dev_private = NULL;
+err_out:
+        return ret;
 }
 
 void nouveau_lastclose(struct drm_device *dev)
diff --git a/drivers/gpu/drm/nouveau/nv04_crtc.c b/drivers/gpu/drm/nouveau/nv04_crtc.c
index 1c20c08ce67..497df8765f2 100644
--- a/drivers/gpu/drm/nouveau/nv04_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv04_crtc.c
@@ -542,6 +542,9 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
          * 1 << 30 on 0x60.830), for no apparent reason */
         regp->CRTC[NV_CIO_CRE_59] = off_chip_digital;
 
+        if (dev_priv->card_type >= NV_30)
+                regp->CRTC[0x9f] = off_chip_digital ? 0x11 : 0x1;
+
         regp->crtc_830 = mode->crtc_vdisplay - 3;
         regp->crtc_834 = mode->crtc_vdisplay - 1;
 
@@ -739,15 +742,13 @@ nv_crtc_gamma_load(struct drm_crtc *crtc)
 }
 
 static void
-nv_crtc_gamma_set(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, uint32_t size)
+nv_crtc_gamma_set(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, uint32_t start,
+                  uint32_t size)
 {
+        int end = (start + size > 256) ? 256 : start + size, i;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        int i;
 
-        if (size != 256)
-                return;
-
-        for (i = 0; i < 256; i++) {
+        for (i = start; i < end; i++) {
                 nv_crtc->lut.r[i] = r[i];
                 nv_crtc->lut.g[i] = g[i];
                 nv_crtc->lut.b[i] = b[i];
@@ -914,7 +915,7 @@ nv04_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
 
         gem = drm_gem_object_lookup(dev, file_priv, buffer_handle);
         if (!gem)
-                return -EINVAL;
+                return -ENOENT;
         cursor = nouveau_gem_object(gem);
 
         ret = nouveau_bo_map(cursor);
diff --git a/drivers/gpu/drm/nouveau/nv04_dfp.c b/drivers/gpu/drm/nouveau/nv04_dfp.c
index 3311f3a8c81..a5dcf768580 100644
--- a/drivers/gpu/drm/nouveau/nv04_dfp.c
+++ b/drivers/gpu/drm/nouveau/nv04_dfp.c
@@ -34,6 +34,8 @@
 #include "nouveau_hw.h"
 #include "nvreg.h"
 
+#include "i2c/sil164.h"
+
 #define FP_TG_CONTROL_ON  (NV_PRAMDAC_FP_TG_CONTROL_DISPEN_POS |        \
                            NV_PRAMDAC_FP_TG_CONTROL_HSYNC_POS |         \
                            NV_PRAMDAC_FP_TG_CONTROL_VSYNC_POS)
@@ -144,6 +146,36 @@ void nv04_dfp_update_fp_control(struct drm_encoder *encoder, int mode)
         }
 }
 
+static struct drm_encoder *get_tmds_slave(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct drm_encoder *slave;
+
+        if (dcb->type != OUTPUT_TMDS || dcb->location == DCB_LOC_ON_CHIP)
+                return NULL;
+
+        /* Some BIOSes (e.g. the one in a Quadro FX1000) report several
+         * TMDS transmitters at the same I2C address, in the same I2C
+         * bus. This can still work because in that case one of them is
+         * always hard-wired to a reasonable configuration using straps,
+         * and the other one needs to be programmed.
+         *
+         * I don't think there's a way to know which is which, even the
+         * blob programs the one exposed via I2C for *both* heads, so
+         * let's do the same.
+         */
+        list_for_each_entry(slave, &dev->mode_config.encoder_list, head) {
+                struct dcb_entry *slave_dcb = nouveau_encoder(slave)->dcb;
+
+                if (slave_dcb->type == OUTPUT_TMDS && get_slave_funcs(slave) &&
+                    slave_dcb->tmdsconf.slave_addr == dcb->tmdsconf.slave_addr)
+                        return slave;
+        }
+
+        return NULL;
+}
+
 static bool nv04_dfp_mode_fixup(struct drm_encoder *encoder,
                                 struct drm_display_mode *mode,
                                 struct drm_display_mode *adjusted_mode)
@@ -429,6 +461,11 @@ static void nv04_dfp_commit(struct drm_encoder *encoder)
         else
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);
 
+        /* Init external transmitters */
+        if (get_tmds_slave(encoder))
+                get_slave_funcs(get_tmds_slave(encoder))->mode_set(
+                        encoder, &nv_encoder->mode, &nv_encoder->mode);
+
         helper->dpms(encoder, DRM_MODE_DPMS_ON);
 
         NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
@@ -550,10 +587,42 @@ static void nv04_dfp_destroy(struct drm_encoder *encoder)
 
         NV_DEBUG_KMS(encoder->dev, "\n");
 
+        if (get_slave_funcs(encoder))
+                get_slave_funcs(encoder)->destroy(encoder);
+
         drm_encoder_cleanup(encoder);
         kfree(nv_encoder);
 }
 
+static void nv04_tmds_slave_init(struct drm_encoder *encoder)
+{
+        struct drm_device *dev = encoder->dev;
+        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct nouveau_i2c_chan *i2c = nouveau_i2c_find(dev, 2);
+        struct i2c_board_info info[] = {
+                {
+                        .type = "sil164",
+                        .addr = (dcb->tmdsconf.slave_addr == 0x7 ? 0x3a : 0x38),
+                        .platform_data = &(struct sil164_encoder_params) {
+                                SIL164_INPUT_EDGE_RISING
+                        }
+                },
+                { }
+        };
+        int type;
+
+        if (!nv_gf4_disp_arch(dev) || !i2c ||
+            get_tmds_slave(encoder))
+                return;
+
+        type = nouveau_i2c_identify(dev, "TMDS transmitter", info, 2);
+        if (type < 0)
+                return;
+
+        drm_i2c_encoder_init(dev, to_encoder_slave(encoder),
+                             &i2c->adapter, &info[type]);
+}
+
 static const struct drm_encoder_helper_funcs nv04_lvds_helper_funcs = {
         .dpms = nv04_lvds_dpms,
         .save = nv04_dfp_save,
@@ -616,6 +685,10 @@ nv04_dfp_create(struct drm_connector *connector, struct dcb_entry *entry)
         encoder->possible_crtcs = entry->heads;
         encoder->possible_clones = 0;
 
+        if (entry->type == OUTPUT_TMDS &&
+            entry->location != DCB_LOC_ON_CHIP)
+                nv04_tmds_slave_init(encoder);
+
         drm_mode_connector_attach_encoder(connector, encoder);
         return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/nv04_tv.c b/drivers/gpu/drm/nouveau/nv04_tv.c
index 94e299cef0b..0b5d012d7c2 100644
--- a/drivers/gpu/drm/nouveau/nv04_tv.c
+++ b/drivers/gpu/drm/nouveau/nv04_tv.c
@@ -89,7 +89,7 @@ static void nv04_tv_dpms(struct drm_encoder *encoder, int mode)
 
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT, state->pllsel);
 
-        to_encoder_slave(encoder)->slave_funcs->dpms(encoder, mode);
+        get_slave_funcs(encoder)->dpms(encoder, mode);
 }
 
 static void nv04_tv_bind(struct drm_device *dev, int head, bool bind)
@@ -152,7 +152,7 @@ static void nv04_tv_mode_set(struct drm_encoder *encoder,
         regp->tv_vskew = 1;
         regp->tv_vsync_delay = 1;
 
-        to_encoder_slave(encoder)->slave_funcs->mode_set(encoder, mode, adjusted_mode);
+        get_slave_funcs(encoder)->mode_set(encoder, mode, adjusted_mode);
 }
 
 static void nv04_tv_commit(struct drm_encoder *encoder)
@@ -171,8 +171,7 @@ static void nv04_tv_commit(struct drm_encoder *encoder)
 
 static void nv04_tv_destroy(struct drm_encoder *encoder)
 {
-        to_encoder_slave(encoder)->slave_funcs->destroy(encoder);
-
+        get_slave_funcs(encoder)->destroy(encoder);
         drm_encoder_cleanup(encoder);
 
         kfree(encoder->helper_private);
@@ -229,7 +228,7 @@ nv04_tv_create(struct drm_connector *connector, struct dcb_entry *entry)
                 goto fail_cleanup;
 
         /* Fill the function pointers */
-        sfuncs = to_encoder_slave(encoder)->slave_funcs;
+        sfuncs = get_slave_funcs(encoder);
 
         *hfuncs = (struct drm_encoder_helper_funcs) {
                 .dpms = nv04_tv_dpms,
@@ -243,7 +242,6 @@ nv04_tv_create(struct drm_connector *connector, struct dcb_entry *entry)
         };
 
         /* Attach it to the specified connector. */
-        sfuncs->set_config(encoder, nv04_tv_encoder_info[type].platform_data);
         sfuncs->create_resources(encoder, connector);
         drm_mode_connector_attach_encoder(connector, encoder);
 
diff --git a/drivers/gpu/drm/nouveau/nv10_graph.c b/drivers/gpu/drm/nouveau/nv10_graph.c
index fcf2cdd1949..b2f6a57c0cc 100644
--- a/drivers/gpu/drm/nouveau/nv10_graph.c
+++ b/drivers/gpu/drm/nouveau/nv10_graph.c
@@ -43,51 +43,51 @@ struct pipe_state {
 };
 
 static int nv10_graph_ctx_regs[] = {
-        NV10_PGRAPH_CTX_SWITCH1,
-        NV10_PGRAPH_CTX_SWITCH2,
-        NV10_PGRAPH_CTX_SWITCH3,
-        NV10_PGRAPH_CTX_SWITCH4,
-        NV10_PGRAPH_CTX_SWITCH5,
-        NV10_PGRAPH_CTX_CACHE1, /* 8 values from 0x400160 to 0x40017c */
-        NV10_PGRAPH_CTX_CACHE2, /* 8 values from 0x400180 to 0x40019c */
-        NV10_PGRAPH_CTX_CACHE3, /* 8 values from 0x4001a0 to 0x4001bc */
-        NV10_PGRAPH_CTX_CACHE4, /* 8 values from 0x4001c0 to 0x4001dc */
-        NV10_PGRAPH_CTX_CACHE5, /* 8 values from 0x4001e0 to 0x4001fc */
-        0x00400164,
-        0x00400184,
-        0x004001a4,
-        0x004001c4,
-        0x004001e4,
-        0x00400168,
-        0x00400188,
-        0x004001a8,
-        0x004001c8,
-        0x004001e8,
-        0x0040016c,
-        0x0040018c,
-        0x004001ac,
-        0x004001cc,
-        0x004001ec,
-        0x00400170,
-        0x00400190,
-        0x004001b0,
-        0x004001d0,
-        0x004001f0,
-        0x00400174,
-        0x00400194,
-        0x004001b4,
-        0x004001d4,
-        0x004001f4,
-        0x00400178,
-        0x00400198,
-        0x004001b8,
-        0x004001d8,
-        0x004001f8,
-        0x0040017c,
-        0x0040019c,
-        0x004001bc,
-        0x004001dc,
-        0x004001fc,
+        NV10_PGRAPH_CTX_SWITCH(0),
+        NV10_PGRAPH_CTX_SWITCH(1),
+        NV10_PGRAPH_CTX_SWITCH(2),
+        NV10_PGRAPH_CTX_SWITCH(3),
+        NV10_PGRAPH_CTX_SWITCH(4),
+        NV10_PGRAPH_CTX_CACHE(0, 0),
+        NV10_PGRAPH_CTX_CACHE(0, 1),
+        NV10_PGRAPH_CTX_CACHE(0, 2),
+        NV10_PGRAPH_CTX_CACHE(0, 3),
+        NV10_PGRAPH_CTX_CACHE(0, 4),
+        NV10_PGRAPH_CTX_CACHE(1, 0),
+        NV10_PGRAPH_CTX_CACHE(1, 1),
+        NV10_PGRAPH_CTX_CACHE(1, 2),
+        NV10_PGRAPH_CTX_CACHE(1, 3),
+        NV10_PGRAPH_CTX_CACHE(1, 4),
+        NV10_PGRAPH_CTX_CACHE(2, 0),
+        NV10_PGRAPH_CTX_CACHE(2, 1),
+        NV10_PGRAPH_CTX_CACHE(2, 2),
+        NV10_PGRAPH_CTX_CACHE(2, 3),
+        NV10_PGRAPH_CTX_CACHE(2, 4),
+        NV10_PGRAPH_CTX_CACHE(3, 0),
+        NV10_PGRAPH_CTX_CACHE(3, 1),
+        NV10_PGRAPH_CTX_CACHE(3, 2),
+        NV10_PGRAPH_CTX_CACHE(3, 3),
+        NV10_PGRAPH_CTX_CACHE(3, 4),
+        NV10_PGRAPH_CTX_CACHE(4, 0),
+        NV10_PGRAPH_CTX_CACHE(4, 1),
+        NV10_PGRAPH_CTX_CACHE(4, 2),
+        NV10_PGRAPH_CTX_CACHE(4, 3),
+        NV10_PGRAPH_CTX_CACHE(4, 4),
+        NV10_PGRAPH_CTX_CACHE(5, 0),
+        NV10_PGRAPH_CTX_CACHE(5, 1),
+        NV10_PGRAPH_CTX_CACHE(5, 2),
+        NV10_PGRAPH_CTX_CACHE(5, 3),
+        NV10_PGRAPH_CTX_CACHE(5, 4),
+        NV10_PGRAPH_CTX_CACHE(6, 0),
+        NV10_PGRAPH_CTX_CACHE(6, 1),
+        NV10_PGRAPH_CTX_CACHE(6, 2),
+        NV10_PGRAPH_CTX_CACHE(6, 3),
+        NV10_PGRAPH_CTX_CACHE(6, 4),
+        NV10_PGRAPH_CTX_CACHE(7, 0),
+        NV10_PGRAPH_CTX_CACHE(7, 1),
+        NV10_PGRAPH_CTX_CACHE(7, 2),
+        NV10_PGRAPH_CTX_CACHE(7, 3),
+        NV10_PGRAPH_CTX_CACHE(7, 4),
         NV10_PGRAPH_CTX_USER,
         NV04_PGRAPH_DMA_START_0,
         NV04_PGRAPH_DMA_START_1,
@@ -653,6 +653,78 @@ static int nv17_graph_ctx_regs_find_offset(struct drm_device *dev, int reg)
         return -1;
 }
 
+static void nv10_graph_load_dma_vtxbuf(struct nouveau_channel *chan,
+                                       uint32_t inst)
+{
+        struct drm_device *dev = chan->dev;
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_pgraph_engine *pgraph = &dev_priv->engine.graph;
+        uint32_t st2, st2_dl, st2_dh, fifo_ptr, fifo[0x60/4];
+        uint32_t ctx_user, ctx_switch[5];
+        int i, subchan = -1;
+
+        /* NV10TCL_DMA_VTXBUF (method 0x18c) modifies hidden state
+         * that cannot be restored via MMIO. Do it through the FIFO
+         * instead.
+         */
+
+        /* Look for a celsius object */
+        for (i = 0; i < 8; i++) {
+                int class = nv_rd32(dev, NV10_PGRAPH_CTX_CACHE(i, 0)) & 0xfff;
+
+                if (class == 0x56 || class == 0x96 || class == 0x99) {
+                        subchan = i;
+                        break;
+                }
+        }
+
+        if (subchan < 0 || !inst)
+                return;
+
+        /* Save the current ctx object */
+        ctx_user = nv_rd32(dev, NV10_PGRAPH_CTX_USER);
+        for (i = 0; i < 5; i++)
+                ctx_switch[i] = nv_rd32(dev, NV10_PGRAPH_CTX_SWITCH(i));
+
+        /* Save the FIFO state */
+        st2 = nv_rd32(dev, NV10_PGRAPH_FFINTFC_ST2);
+        st2_dl = nv_rd32(dev, NV10_PGRAPH_FFINTFC_ST2_DL);
+        st2_dh = nv_rd32(dev, NV10_PGRAPH_FFINTFC_ST2_DH);
+        fifo_ptr = nv_rd32(dev, NV10_PGRAPH_FFINTFC_FIFO_PTR);
+
+        for (i = 0; i < ARRAY_SIZE(fifo); i++)
+                fifo[i] = nv_rd32(dev, 0x4007a0 + 4 * i);
+
+        /* Switch to the celsius subchannel */
+        for (i = 0; i < 5; i++)
+                nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(i),
+                        nv_rd32(dev, NV10_PGRAPH_CTX_CACHE(subchan, i)));
+        nv_mask(dev, NV10_PGRAPH_CTX_USER, 0xe000, subchan << 13);
+
+        /* Inject NV10TCL_DMA_VTXBUF */
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_FIFO_PTR, 0);
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2,
+                0x2c000000 | chan->id << 20 | subchan << 16 | 0x18c);
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2_DL, inst);
+        nv_mask(dev, NV10_PGRAPH_CTX_CONTROL, 0, 0x10000);
+        pgraph->fifo_access(dev, true);
+        pgraph->fifo_access(dev, false);
+
+        /* Restore the FIFO state */
+        for (i = 0; i < ARRAY_SIZE(fifo); i++)
+                nv_wr32(dev, 0x4007a0 + 4 * i, fifo[i]);
+
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_FIFO_PTR, fifo_ptr);
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2, st2);
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2_DL, st2_dl);
+        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2_DH, st2_dh);
+
+        /* Restore the current ctx object */
+        for (i = 0; i < 5; i++)
+                nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(i), ctx_switch[i]);
+        nv_wr32(dev, NV10_PGRAPH_CTX_USER, ctx_user);
+}
+
 int nv10_graph_load_context(struct nouveau_channel *chan)
 {
         struct drm_device *dev = chan->dev;
@@ -670,6 +742,8 @@ int nv10_graph_load_context(struct nouveau_channel *chan)
         }
 
         nv10_graph_load_pipe(chan);
+        nv10_graph_load_dma_vtxbuf(chan, (nv_rd32(dev, NV10_PGRAPH_GLOBALSTATE1)
+                                          & 0xffff));
 
         nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10010100);
         tmp = nv_rd32(dev, NV10_PGRAPH_CTX_USER);
@@ -856,11 +930,12 @@ int nv10_graph_init(struct drm_device *dev)
         for (i = 0; i < NV10_PFB_TILE__SIZE; i++)
                 nv10_graph_set_region_tiling(dev, i, 0, 0, 0);
 
-        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH1, 0x00000000);
-        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH2, 0x00000000);
-        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH3, 0x00000000);
-        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH4, 0x00000000);
-        nv_wr32(dev, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
+        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(0), 0x00000000);
+        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(1), 0x00000000);
+        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(2), 0x00000000);
+        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(3), 0x00000000);
+        nv_wr32(dev, NV10_PGRAPH_CTX_SWITCH(4), 0x00000000);
+        nv_wr32(dev, NV10_PGRAPH_STATE, 0xFFFFFFFF);
 
         tmp  = nv_rd32(dev, NV10_PGRAPH_CTX_USER) & 0x00ffffff;
         tmp |= (dev_priv->engine.fifo.channels - 1) << 24;
diff --git a/drivers/gpu/drm/nouveau/nv30_fb.c b/drivers/gpu/drm/nouveau/nv30_fb.c
index 9d35c8b3b83..4a3f2f09512 100644
--- a/drivers/gpu/drm/nouveau/nv30_fb.c
+++ b/drivers/gpu/drm/nouveau/nv30_fb.c
@@ -30,15 +30,25 @@
 #include "nouveau_drm.h"
 
 static int
-calc_ref(int b, int l, int i)
+calc_bias(struct drm_device *dev, int k, int i, int j)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        int b = (dev_priv->chipset > 0x30 ?
+                 nv_rd32(dev, 0x122c + 0x10 * k + 0x4 * j) >> (4 * (i ^ 1)) :
+                 0) & 0xf;
+
+        return 2 * (b & 0x8 ? b - 0x10 : b);
+}
+
+static int
+calc_ref(struct drm_device *dev, int l, int k, int i)
 {
         int j, x = 0;
 
         for (j = 0; j < 4; j++) {
-                int n = (b >> (8 * j) & 0xf);
-                int m = (l >> (8 * i) & 0xff) + 2 * (n & 0x8 ? n - 0x10 : n);
+                int m = (l >> (8 * i) & 0xff) + calc_bias(dev, k, i, j);
 
-                x |= (0x80 | (m & 0x1f)) << (8 * j);
+                x |= (0x80 | clamp(m, 0, 0x1f)) << (8 * j);
         }
 
         return x;
@@ -63,18 +73,16 @@ nv30_fb_init(struct drm_device *dev)
             dev_priv->chipset == 0x35) {
                 /* Related to ROP count */
                 int n = (dev_priv->chipset == 0x31 ? 2 : 4);
-                int b = (dev_priv->chipset > 0x30 ?
-                         nv_rd32(dev, 0x122c) & 0xf : 0);
                 int l = nv_rd32(dev, 0x1003d0);
 
                 for (i = 0; i < n; i++) {
                         for (j = 0; j < 3; j++)
                                 nv_wr32(dev, 0x10037c + 0xc * i + 0x4 * j,
-                                        calc_ref(b, l, j));
+                                        calc_ref(dev, l, 0, j));
 
                         for (j = 0; j < 2; j++)
                                 nv_wr32(dev, 0x1003ac + 0x8 * i + 0x4 * j,
-                                        calc_ref(b, l, j));
+                                        calc_ref(dev, l, 1, j));
                 }
         }
 
diff --git a/drivers/gpu/drm/nouveau/nv50_crtc.c b/drivers/gpu/drm/nouveau/nv50_crtc.c
index 5d11ea10166..bfd4ca2fe7e 100644
--- a/drivers/gpu/drm/nouveau/nv50_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv50_crtc.c
@@ -264,11 +264,16 @@ nv50_crtc_set_scale(struct nouveau_crtc *nv_crtc, int scaling_mode, bool update)
 int
 nv50_crtc_set_clock(struct drm_device *dev, int head, int pclk)
 {
-        uint32_t reg = NV50_PDISPLAY_CRTC_CLK_CTRL1(head);
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct pll_lims pll;
-        uint32_t reg1, reg2;
+        uint32_t reg, reg1, reg2;
         int ret, N1, M1, N2, M2, P;
 
+        if (dev_priv->chipset < NV_C0)
+                reg = NV50_PDISPLAY_CRTC_CLK_CTRL1(head);
+        else
+                reg = 0x614140 + (head * 0x800);
+
         ret = get_pll_limits(dev, reg, &pll);
         if (ret)
                 return ret;
@@ -286,7 +291,8 @@ nv50_crtc_set_clock(struct drm_device *dev, int head, int pclk)
                 nv_wr32(dev, reg, 0x10000611);
                 nv_wr32(dev, reg + 4, reg1 | (M1 << 16) | N1);
                 nv_wr32(dev, reg + 8, reg2 | (P << 28) | (M2 << 16) | N2);
-        } else {
+        } else
+        if (dev_priv->chipset < NV_C0) {
                 ret = nv50_calc_pll2(dev, &pll, pclk, &N1, &N2, &M1, &P);
                 if (ret <= 0)
                         return 0;
@@ -298,6 +304,17 @@ nv50_crtc_set_clock(struct drm_device *dev, int head, int pclk)
                 nv_wr32(dev, reg, 0x50000610);
                 nv_wr32(dev, reg + 4, reg1 | (P << 16) | (M1 << 8) | N1);
                 nv_wr32(dev, reg + 8, N2);
+        } else {
+                ret = nv50_calc_pll2(dev, &pll, pclk, &N1, &N2, &M1, &P);
+                if (ret <= 0)
+                        return 0;
+
+                NV_DEBUG(dev, "pclk %d out %d N %d fN 0x%04x M %d P %d\n",
+                         pclk, ret, N1, N2, M1, P);
+
+                nv_mask(dev, reg + 0x0c, 0x00000000, 0x00000100);
+                nv_wr32(dev, reg + 0x04, (P << 16) | (N1 << 8) | M1);
+                nv_wr32(dev, reg + 0x10, N2 << 16);
         }
 
         return 0;
@@ -348,7 +365,7 @@ nv50_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
 
         gem = drm_gem_object_lookup(dev, file_priv, buffer_handle);
         if (!gem)
-                return -EINVAL;
+                return -ENOENT;
         cursor = nouveau_gem_object(gem);
 
         ret = nouveau_bo_map(cursor);
@@ -381,15 +398,12 @@ nv50_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
 
 static void
 nv50_crtc_gamma_set(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
-                    uint32_t size)
+                    uint32_t start, uint32_t size)
 {
+        int end = (start + size > 256) ? 256 : start + size, i;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        int i;
-
-        if (size != 256)
-                return;
 
-        for (i = 0; i < 256; i++) {
+        for (i = start; i < end; i++) {
                 nv_crtc->lut.r[i] = r[i];
                 nv_crtc->lut.g[i] = g[i];
                 nv_crtc->lut.b[i] = b[i];
diff --git a/drivers/gpu/drm/nouveau/nv50_display.c b/drivers/gpu/drm/nouveau/nv50_display.c
index f13ad0de9c8..612fa6d6a0c 100644
--- a/drivers/gpu/drm/nouveau/nv50_display.c
+++ b/drivers/gpu/drm/nouveau/nv50_display.c
@@ -76,7 +76,10 @@ nv50_evo_dmaobj_new(struct nouveau_channel *evo, uint32_t class, uint32_t name,
         nv_wo32(dev, obj, 2, offset);
         nv_wo32(dev, obj, 3, 0x00000000);
         nv_wo32(dev, obj, 4, 0x00000000);
-        nv_wo32(dev, obj, 5, 0x00010000);
+        if (dev_priv->card_type < NV_C0)
+                nv_wo32(dev, obj, 5, 0x00010000);
+        else
+                nv_wo32(dev, obj, 5, 0x00020000);
         dev_priv->engine.instmem.flush(dev);
 
         return 0;
diff --git a/drivers/gpu/drm/nouveau/nvc0_fb.c b/drivers/gpu/drm/nouveau/nvc0_fb.c
new file mode 100644
index 00000000000..26a996025dd
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nvc0_fb.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Ben Skeggs
+ */
+
+#include "drmP.h"
+
+#include "nouveau_drv.h"
+
+int
+nvc0_fb_init(struct drm_device *dev)
+{
+        return 0;
+}
+
+void
+nvc0_fb_takedown(struct drm_device *dev)
+{
+}
diff --git a/drivers/gpu/drm/nouveau/nvc0_fifo.c b/drivers/gpu/drm/nouveau/nvc0_fifo.c
new file mode 100644
index 00000000000..d6437587197
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nvc0_fifo.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2010 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Ben Skeggs
+ */
+
+#include "drmP.h"
+
+#include "nouveau_drv.h"
+
+void
+nvc0_fifo_disable(struct drm_device *dev)
+{
+}
+
+void
+nvc0_fifo_enable(struct drm_device *dev)
+{
+}
+
+bool
+nvc0_fifo_reassign(struct drm_device *dev, bool enable)
+{
+        return false;
+}
+
+bool
+nvc0_fifo_cache_flush(struct drm_device *dev)
+{
+        return true;
+}
+
+bool
+nvc0_fifo_cache_pull(struct drm_device *dev, bool enable)
+{
+        return false;
+}
+
+int
+nvc0_fifo_channel_id(struct drm_device *dev)
+{
+        return 127;
+}
+
+int
+nvc0_fifo_create_context(struct nouveau_channel *chan)
+{
+        return 0;
+}
+
+void
+nvc0_fifo_destroy_context(struct nouveau_channel *chan)
+{
+}
+
+int
+nvc0_fifo_load_context(struct nouveau_channel *chan)
+{
+        return 0;
+}
+
+int
+nvc0_fifo_unload_context(struct drm_device *dev)
+{
+        return 0;
+}
+
+void
+nvc0_fifo_takedown(struct drm_device *dev)
+{
+}
+
+int
+nvc0_fifo_init(struct drm_device *dev)
+{
+        return 0;
+}
+
diff --git a/drivers/gpu/drm/nouveau/nvc0_graph.c b/drivers/gpu/drm/nouveau/nvc0_graph.c
new file mode 100644
index 00000000000..717a5177a8d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nvc0_graph.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Ben Skeggs
+ */
+
+#include "drmP.h"
+
+#include "nouveau_drv.h"
+
+void
+nvc0_graph_fifo_access(struct drm_device *dev, bool enabled)
+{
+}
+
+struct nouveau_channel *
+nvc0_graph_channel(struct drm_device *dev)
+{
+        return NULL;
+}
+
+int
+nvc0_graph_create_context(struct nouveau_channel *chan)
+{
+        return 0;
+}
+
+void
+nvc0_graph_destroy_context(struct nouveau_channel *chan)
+{
+}
+
+int
+nvc0_graph_load_context(struct nouveau_channel *chan)
+{
+        return 0;
+}
+
+int
+nvc0_graph_unload_context(struct drm_device *dev)
+{
+        return 0;
+}
+
+void
+nvc0_graph_takedown(struct drm_device *dev)
+{
+}
+
+int
+nvc0_graph_init(struct drm_device *dev)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        dev_priv->engine.graph.accel_blocked = true;
+        return 0;
+}
+
diff --git a/drivers/gpu/drm/nouveau/nvc0_instmem.c b/drivers/gpu/drm/nouveau/nvc0_instmem.c
new file mode 100644
index 00000000000..3ab3cdc4217
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nvc0_instmem.c
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2010 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Ben Skeggs
+ */
+
+#include "drmP.h"
+
+#include "nouveau_drv.h"
+
+int
+nvc0_instmem_populate(struct drm_device *dev, struct nouveau_gpuobj *gpuobj,
+                      uint32_t *size)
+{
+        int ret;
+
+        *size = ALIGN(*size, 4096);
+        if (*size == 0)
+                return -EINVAL;
+
+        ret = nouveau_bo_new(dev, NULL, *size, 0, TTM_PL_FLAG_VRAM, 0, 0x0000,
+                             true, false, &gpuobj->im_backing);
+        if (ret) {
+                NV_ERROR(dev, "error getting PRAMIN backing pages: %d\n", ret);
+                return ret;
+        }
+
+        ret = nouveau_bo_pin(gpuobj->im_backing, TTM_PL_FLAG_VRAM);
+        if (ret) {
+                NV_ERROR(dev, "error pinning PRAMIN backing VRAM: %d\n", ret);
+                nouveau_bo_ref(NULL, &gpuobj->im_backing);
+                return ret;
+        }
+
+        gpuobj->im_backing_start = gpuobj->im_backing->bo.mem.mm_node->start;
+        gpuobj->im_backing_start <<= PAGE_SHIFT;
+        return 0;
+}
+
+void
+nvc0_instmem_clear(struct drm_device *dev, struct nouveau_gpuobj *gpuobj)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+
+        if (gpuobj && gpuobj->im_backing) {
+                if (gpuobj->im_bound)
+                        dev_priv->engine.instmem.unbind(dev, gpuobj);
+                nouveau_bo_unpin(gpuobj->im_backing);
+                nouveau_bo_ref(NULL, &gpuobj->im_backing);
+                gpuobj->im_backing = NULL;
+        }
+}
+
+int
+nvc0_instmem_bind(struct drm_device *dev, struct nouveau_gpuobj *gpuobj)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        uint32_t pte, pte_end;
+        uint64_t vram;
+
+        if (!gpuobj->im_backing || !gpuobj->im_pramin || gpuobj->im_bound)
+                return -EINVAL;
+
+        NV_DEBUG(dev, "st=0x%lx sz=0x%lx\n",
+                 gpuobj->im_pramin->start, gpuobj->im_pramin->size);
+
+        pte     = gpuobj->im_pramin->start >> 12;
+        pte_end = (gpuobj->im_pramin->size >> 12) + pte;
+        vram    = gpuobj->im_backing_start;
+
+        NV_DEBUG(dev, "pramin=0x%lx, pte=%d, pte_end=%d\n",
+                 gpuobj->im_pramin->start, pte, pte_end);
+        NV_DEBUG(dev, "first vram page: 0x%08x\n", gpuobj->im_backing_start);
+
+        while (pte < pte_end) {
+                nv_wr32(dev, 0x702000 + (pte * 8), (vram >> 8) | 1);
+                nv_wr32(dev, 0x702004 + (pte * 8), 0);
+                vram += 4096;
+                pte++;
+        }
+        dev_priv->engine.instmem.flush(dev);
+
+        if (1) {
+                u32 chan = nv_rd32(dev, 0x1700) << 16;
+                nv_wr32(dev, 0x100cb8, (chan + 0x1000) >> 8);
+                nv_wr32(dev, 0x100cbc, 0x80000005);
+        }
+
+        gpuobj->im_bound = 1;
+        return 0;
+}
+
+int
+nvc0_instmem_unbind(struct drm_device *dev, struct nouveau_gpuobj *gpuobj)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        uint32_t pte, pte_end;
+
+        if (gpuobj->im_bound == 0)
+                return -EINVAL;
+
+        pte     = gpuobj->im_pramin->start >> 12;
+        pte_end = (gpuobj->im_pramin->size >> 12) + pte;
+        while (pte < pte_end) {
+                nv_wr32(dev, 0x702000 + (pte * 8), 0);
+                nv_wr32(dev, 0x702004 + (pte * 8), 0);
+                pte++;
+        }
+        dev_priv->engine.instmem.flush(dev);
+
+        gpuobj->im_bound = 0;
+        return 0;
+}
+
+void
+nvc0_instmem_flush(struct drm_device *dev)
+{
+        nv_wr32(dev, 0x070000, 1);
+        if (!nv_wait(0x070000, 0x00000002, 0x00000000))
+                NV_ERROR(dev, "PRAMIN flush timeout\n");
+}
+
+int
+nvc0_instmem_suspend(struct drm_device *dev)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        int i;
+
+        dev_priv->susres.ramin_copy = vmalloc(65536);
+        if (!dev_priv->susres.ramin_copy)
+                return -ENOMEM;
+
+        for (i = 0x700000; i < 0x710000; i += 4)
+                dev_priv->susres.ramin_copy[i/4] = nv_rd32(dev, i);
+        return 0;
+}
+
+void
+nvc0_instmem_resume(struct drm_device *dev)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        u64 chan;
+        int i;
+
+        chan = dev_priv->vram_size - dev_priv->ramin_rsvd_vram;
+        nv_wr32(dev, 0x001700, chan >> 16);
+
+        for (i = 0x700000; i < 0x710000; i += 4)
+                nv_wr32(dev, i, dev_priv->susres.ramin_copy[i/4]);
+        vfree(dev_priv->susres.ramin_copy);
+        dev_priv->susres.ramin_copy = NULL;
+
+        nv_wr32(dev, 0x001714, 0xc0000000 | (chan >> 12));
+}
+
+int
+nvc0_instmem_init(struct drm_device *dev)
+{
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        u64 chan, pgt3, imem, lim3 = dev_priv->ramin_size - 1;
+        int ret, i;
+
+        dev_priv->ramin_rsvd_vram = 1 * 1024 * 1024;
+        chan = dev_priv->vram_size - dev_priv->ramin_rsvd_vram;
+        imem = 4096 + 4096 + 32768;
+
+        nv_wr32(dev, 0x001700, chan >> 16);
+
+        /* channel setup */
+        nv_wr32(dev, 0x700200, lower_32_bits(chan + 0x1000));
+        nv_wr32(dev, 0x700204, upper_32_bits(chan + 0x1000));
+        nv_wr32(dev, 0x700208, lower_32_bits(lim3));
+        nv_wr32(dev, 0x70020c, upper_32_bits(lim3));
+
+        /* point pgd -> pgt */
+        nv_wr32(dev, 0x701000, 0);
+        nv_wr32(dev, 0x701004, ((chan + 0x2000) >> 8) | 1);
+
+        /* point pgt -> physical vram for channel */
+        pgt3 = 0x2000;
+        for (i = 0; i < dev_priv->ramin_rsvd_vram; i += 4096, pgt3 += 8) {
+                nv_wr32(dev, 0x700000 + pgt3, ((chan + i) >> 8) | 1);
+                nv_wr32(dev, 0x700004 + pgt3, 0);
+        }
+
+        /* clear rest of pgt */
+        for (; i < dev_priv->ramin_size; i += 4096, pgt3 += 8) {
+                nv_wr32(dev, 0x700000 + pgt3, 0);
+                nv_wr32(dev, 0x700004 + pgt3, 0);
+        }
+
+        /* point bar3 at the channel */
+        nv_wr32(dev, 0x001714, 0xc0000000 | (chan >> 12));
+
+        /* Global PRAMIN heap */
+        ret = drm_mm_init(&dev_priv->ramin_heap, imem,
+                          dev_priv->ramin_size - imem);
+        if (ret) {
+                NV_ERROR(dev, "Failed to init RAMIN heap\n");
+                return -ENOMEM;
+        }
+
+        /*XXX: incorrect, but needed to make hash func "work" */
+        dev_priv->ramht_offset = 0x10000;
+        dev_priv->ramht_bits   = 9;
+        dev_priv->ramht_size   = (1 << dev_priv->ramht_bits);
+        return 0;
+}
+
+void
+nvc0_instmem_takedown(struct drm_device *dev)
+{
+}
+
diff --git a/drivers/gpu/drm/radeon/r600_cp.c b/drivers/gpu/drm/radeon/r600_cp.c
index 68e6f434930..4f4cd8b286d 100644
--- a/drivers/gpu/drm/radeon/r600_cp.c
+++ b/drivers/gpu/drm/radeon/r600_cp.c
@@ -200,7 +200,7 @@ int r600_page_table_init(struct drm_device *dev)
                                                  entry->pagelist[i], 0,
                                                  PAGE_SIZE,
                                                  PCI_DMA_BIDIRECTIONAL);
-                if (entry->busaddr[i] == 0) {
+                if (pci_dma_mapping_error(dev->pdev, entry->busaddr[i])) {
                         DRM_ERROR("unable to map PCIGART pages!\n");
                         r600_page_table_cleanup(dev, gart_info);
                         goto done;
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index c3ea212e0c3..d8864949e38 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -133,6 +133,7 @@ static inline int r600_bpe_from_format(u32 *bpe, u32 format)
         case V_038004_FMT_GB_GR:
         case V_038004_FMT_BG_RG:
         case V_038004_COLOR_INVALID:
+        default:
                 *bpe = 16;
                 return -EINVAL;
         }
@@ -174,7 +175,7 @@ static inline int r600_cs_track_validate_cb(struct radeon_cs_parser *p, int i)
                 dev_warn(p->dev, "FMASK or CMASK buffer are not supported by this kernel\n");
                 return -EINVAL;
         }
-        size = radeon_bo_size(track->cb_color_bo[i]);
+        size = radeon_bo_size(track->cb_color_bo[i]) - track->cb_color_bo_offset[i];
         if (r600_bpe_from_format(&bpe, G_0280A0_FORMAT(track->cb_color_info[i]))) {
                 dev_warn(p->dev, "%s:%d cb invalid format %d for %d (0x%08X)\n",
                          __func__, __LINE__, G_0280A0_FORMAT(track->cb_color_info[i]),
@@ -327,7 +328,6 @@ static int r600_cs_track_check(struct radeon_cs_parser *p)
                                 dev_warn(p->dev, "z/stencil buffer size not set\n");
                                 return -EINVAL;
                         }
-                        printk_once(KERN_WARNING "You have old & broken userspace please consider updating mesa\n");
                         tmp = radeon_bo_size(track->db_bo) - track->db_offset;
                         tmp = (tmp / bpe) >> 6;
                         if (!tmp) {
@@ -882,8 +882,6 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
                                 return -EINVAL;
                         }
                         ib[idx] = track->cb_color_base_last[tmp];
-                        printk_once(KERN_WARNING "You have old & broken userspace "
-                                        "please consider updating mesa & xf86-video-ati\n");
                         track->cb_color_frag_bo[tmp] = track->cb_color_bo[tmp];
                 } else {
                         r = r600_cs_packet_next_reloc(p, &reloc);
@@ -910,8 +908,6 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
                                 return -EINVAL;
                         }
                         ib[idx] = track->cb_color_base_last[tmp];
-                        printk_once(KERN_WARNING "You have old & broken userspace "
-                                        "please consider updating mesa & xf86-video-ati\n");
                         track->cb_color_tile_bo[tmp] = track->cb_color_bo[tmp];
                 } else {
                         r = r600_cs_packet_next_reloc(p, &reloc);
@@ -938,7 +934,7 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
                         return -EINVAL;
                 }
                 tmp = (reg - CB_COLOR0_BASE) / 4;
-                track->cb_color_bo_offset[tmp] = radeon_get_ib_value(p, idx);
+                track->cb_color_bo_offset[tmp] = radeon_get_ib_value(p, idx) << 8;
                 ib[idx] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                 track->cb_color_base_last[tmp] = ib[idx];
                 track->cb_color_bo[tmp] = reloc->robj;
@@ -950,7 +946,7 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
                                         "0x%04X\n", reg);
                         return -EINVAL;
                 }
-                track->db_offset = radeon_get_ib_value(p, idx);
+                track->db_offset = radeon_get_ib_value(p, idx) << 8;
                 ib[idx] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                 track->db_bo = reloc->robj;
                 break;
@@ -1055,10 +1051,10 @@ static void r600_texture_size(unsigned nfaces, unsigned blevel, unsigned nlevels
         }
         *l0_size = ALIGN((w0 * bpe), pitch_align) * h0 * d0;
         *mipmap_size = offset;
-        if (!blevel)
-                *mipmap_size -= *l0_size;
         if (!nlevels)
                 *mipmap_size = *l0_size;
+        if (!blevel)
+                *mipmap_size -= *l0_size;
 }
 
 /**
@@ -1165,14 +1161,14 @@ static inline int r600_check_texture_resource(struct radeon_cs_parser *p,  u32 i
                           (pitch_align * bpe),
                           &l0_size, &mipmap_size);
         /* using get ib will give us the offset into the texture bo */
-        word0 = radeon_get_ib_value(p, idx + 2);
+        word0 = radeon_get_ib_value(p, idx + 2) << 8;
         if ((l0_size + word0) > radeon_bo_size(texture)) {
                 dev_warn(p->dev, "texture bo too small (%d %d %d %d -> %d have %ld)\n",
                         w0, h0, bpe, word0, l0_size, radeon_bo_size(texture));
                 return -EINVAL;
         }
         /* using get ib will give us the offset into the mipmap bo */
-        word0 = radeon_get_ib_value(p, idx + 3);
+        word0 = radeon_get_ib_value(p, idx + 3) << 8;
         if ((mipmap_size + word0) > radeon_bo_size(mipmap)) {
                 dev_warn(p->dev, "mipmap bo too small (%d %d %d %d %d %d -> %d have %ld)\n",
                         w0, h0, bpe, blevel, nlevels, word0, mipmap_size, radeon_bo_size(texture));
@@ -1366,7 +1362,7 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                 }
                 for (i = 0; i < (pkt->count / 7); i++) {
                         struct radeon_bo *texture, *mipmap;
-                        u32 size, offset;
+                        u32 size, offset, base_offset, mip_offset;
 
                         switch (G__SQ_VTX_CONSTANT_TYPE(radeon_get_ib_value(p, idx+(i*7)+6+1))) {
                         case SQ_TEX_VTX_VALID_TEXTURE:
@@ -1376,7 +1372,7 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                                         DRM_ERROR("bad SET_RESOURCE\n");
                                         return -EINVAL;
                                 }
-                                ib[idx+1+(i*7)+2] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                base_offset = (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                                 if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO)
                                         ib[idx+1+(i*7)+0] |= S_038000_TILE_MODE(V_038000_ARRAY_2D_TILED_THIN1);
                                 else if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO)
@@ -1388,12 +1384,14 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                                         DRM_ERROR("bad SET_RESOURCE\n");
                                         return -EINVAL;
                                 }
-                                ib[idx+1+(i*7)+3] += (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
+                                mip_offset = (u32)((reloc->lobj.gpu_offset >> 8) & 0xffffffff);
                                 mipmap = reloc->robj;
                                 r = r600_check_texture_resource(p,  idx+(i*7)+1,
                                                                 texture, mipmap, reloc->lobj.tiling_flags);
                                 if (r)
                                         return r;
+                                ib[idx+1+(i*7)+2] += base_offset;
+                                ib[idx+1+(i*7)+3] += mip_offset;
                                 break;
                         case SQ_TEX_VTX_VALID_BUFFER:
                                 /* vtx base */
@@ -1403,10 +1401,11 @@ static int r600_packet3_check(struct radeon_cs_parser *p,
                                         return -EINVAL;
                                 }
                                 offset = radeon_get_ib_value(p, idx+1+(i*7)+0);
-                                size = radeon_get_ib_value(p, idx+1+(i*7)+1);
+                                size = radeon_get_ib_value(p, idx+1+(i*7)+1) + 1;
                                 if (p->rdev && (size + offset) > radeon_bo_size(reloc->robj)) {
                                         /* force size to size of the buffer */
-                                        dev_warn(p->dev, "vbo resource seems too big for the bo\n");
+                                        dev_warn(p->dev, "vbo resource seems too big (%d) for the bo (%ld)\n",
+                                                 size + offset, radeon_bo_size(reloc->robj));
                                         ib[idx+1+(i*7)+1] = radeon_bo_size(reloc->robj);
                                 }
                                 ib[idx+1+(i*7)+0] += (u32)((reloc->lobj.gpu_offset) & 0xffffffff);
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 3cd1c470b77..3dfcfa3ca42 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -1100,6 +1100,8 @@ struct radeon_device {
         struct notifier_block acpi_nb;
         /* only one userspace can use Hyperz features at a time */
         struct drm_file *hyperz_filp;
+        /* i2c buses */
+        struct radeon_i2c_chan *i2c_bus[RADEON_MAX_I2C_BUS];
 };
 
 int radeon_device_init(struct radeon_device *rdev,
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 3bc2bcdf530..6d30868744e 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -48,7 +48,8 @@ radeon_add_atom_connector(struct drm_device *dev,
                           struct radeon_i2c_bus_rec *i2c_bus,
                           bool linkb, uint32_t igp_lane_info,
                           uint16_t connector_object_id,
-                          struct radeon_hpd *hpd);
+                          struct radeon_hpd *hpd,
+                          struct radeon_router *router);
 
 /* from radeon_legacy_encoder.c */
 extern void
@@ -114,7 +115,8 @@ static inline struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_dev
 
                                 i2c.i2c_id = gpio->sucI2cId.ucAccess;
 
-                                i2c.valid = true;
+                                if (i2c.mask_clk_reg)
+                                        i2c.valid = true;
                                 break;
                         }
                 }
@@ -123,6 +125,66 @@ static inline struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_dev
         return i2c;
 }
 
+void radeon_atombios_i2c_init(struct radeon_device *rdev)
+{
+        struct atom_context *ctx = rdev->mode_info.atom_context;
+        ATOM_GPIO_I2C_ASSIGMENT *gpio;
+        struct radeon_i2c_bus_rec i2c;
+        int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
+        struct _ATOM_GPIO_I2C_INFO *i2c_info;
+        uint16_t data_offset, size;
+        int i, num_indices;
+        char stmp[32];
+
+        memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
+
+        if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
+                i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
+
+                num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
+                        sizeof(ATOM_GPIO_I2C_ASSIGMENT);
+
+                for (i = 0; i < num_indices; i++) {
+                        gpio = &i2c_info->asGPIO_Info[i];
+                        i2c.valid = false;
+                        i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
+                        i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
+                        i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
+                        i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
+                        i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
+                        i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
+                        i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
+                        i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
+                        i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
+                        i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
+                        i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
+                        i2c.en_data_mask = (1 << gpio->ucDataEnShift);
+                        i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
+                        i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
+                        i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
+                        i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
+
+                        if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
+                                i2c.hw_capable = true;
+                        else
+                                i2c.hw_capable = false;
+
+                        if (gpio->sucI2cId.ucAccess == 0xa0)
+                                i2c.mm_i2c = true;
+                        else
+                                i2c.mm_i2c = false;
+
+                        i2c.i2c_id = gpio->sucI2cId.ucAccess;
+
+                        if (i2c.mask_clk_reg) {
+                                i2c.valid = true;
+                                sprintf(stmp, "0x%x", i2c.i2c_id);
+                                rdev->i2c_bus[i] = radeon_i2c_create(rdev->ddev, &i2c, stmp);
+                        }
+                }
+        }
+}
+
 static inline struct radeon_gpio_rec radeon_lookup_gpio(struct radeon_device *rdev,
                                                         u8 id)
 {
@@ -206,6 +268,7 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                                      uint16_t *line_mux,
                                      struct radeon_hpd *hpd)
 {
+        struct radeon_device *rdev = dev->dev_private;
 
         /* Asus M2A-VM HDMI board lists the DVI port as HDMI */
         if ((dev->pdev->device == 0x791e) &&
@@ -308,13 +371,22 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                 }
         }
 
-        /* Acer laptop reports DVI-D as DVI-I */
+        /* Acer laptop reports DVI-D as DVI-I and hpd pins reversed */
         if ((dev->pdev->device == 0x95c4) &&
             (dev->pdev->subsystem_vendor == 0x1025) &&
             (dev->pdev->subsystem_device == 0x013c)) {
+                struct radeon_gpio_rec gpio;
+
                 if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
-                    (supported_device == ATOM_DEVICE_DFP1_SUPPORT))
+                    (supported_device == ATOM_DEVICE_DFP1_SUPPORT)) {
+                        gpio = radeon_lookup_gpio(rdev, 6);
+                        *hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
                         *connector_type = DRM_MODE_CONNECTOR_DVID;
+                } else if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
+                           (supported_device == ATOM_DEVICE_DFP1_SUPPORT)) {
+                        gpio = radeon_lookup_gpio(rdev, 7);
+                        *hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
+                }
         }
 
         /* XFX Pine Group device rv730 reports no VGA DDC lines
@@ -399,13 +471,15 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
         u16 size, data_offset;
         u8 frev, crev;
         ATOM_CONNECTOR_OBJECT_TABLE *con_obj;
+        ATOM_OBJECT_TABLE *router_obj;
         ATOM_DISPLAY_OBJECT_PATH_TABLE *path_obj;
         ATOM_OBJECT_HEADER *obj_header;
-        int i, j, path_size, device_support;
+        int i, j, k, path_size, device_support;
         int connector_type;
         u16 igp_lane_info, conn_id, connector_object_id;
         bool linkb;
         struct radeon_i2c_bus_rec ddc_bus;
+        struct radeon_router router;
         struct radeon_gpio_rec gpio;
         struct radeon_hpd hpd;
 
@@ -415,6 +489,8 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
         if (crev < 2)
                 return false;
 
+        router.valid = false;
+
         obj_header = (ATOM_OBJECT_HEADER *) (ctx->bios + data_offset);
         path_obj = (ATOM_DISPLAY_OBJECT_PATH_TABLE *)
             (ctx->bios + data_offset +
@@ -422,6 +498,9 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
         con_obj = (ATOM_CONNECTOR_OBJECT_TABLE *)
             (ctx->bios + data_offset +
              le16_to_cpu(obj_header->usConnectorObjectTableOffset));
+        router_obj = (ATOM_OBJECT_TABLE *)
+                (ctx->bios + data_offset +
+                 le16_to_cpu(obj_header->usRouterObjectTableOffset));
         device_support = le16_to_cpu(obj_header->usDeviceSupport);
 
         path_size = 0;
@@ -508,33 +587,86 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
                                 continue;
 
-                        for (j = 0; j < ((le16_to_cpu(path->usSize) - 8) / 2);
-                             j++) {
-                                uint8_t enc_obj_id, enc_obj_num, enc_obj_type;
+                        for (j = 0; j < ((le16_to_cpu(path->usSize) - 8) / 2); j++) {
+                                uint8_t grph_obj_id, grph_obj_num, grph_obj_type;
 
-                                enc_obj_id =
+                                grph_obj_id =
                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
                                      OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
-                                enc_obj_num =
+                                grph_obj_num =
                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
                                      ENUM_ID_MASK) >> ENUM_ID_SHIFT;
-                                enc_obj_type =
+                                grph_obj_type =
                                     (le16_to_cpu(path->usGraphicObjIds[j]) &
                                      OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
 
-                                /* FIXME: add support for router objects */
-                                if (enc_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
-                                        if (enc_obj_num == 2)
+                                if (grph_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
+                                        if (grph_obj_num == 2)
                                                 linkb = true;
                                         else
                                                 linkb = false;
 
                                         radeon_add_atom_encoder(dev,
-                                                                enc_obj_id,
+                                                                grph_obj_id,
                                                                 le16_to_cpu
                                                                 (path->
                                                                  usDeviceTag));
 
+                                } else if (grph_obj_type == GRAPH_OBJECT_TYPE_ROUTER) {
+                                        router.valid = false;
+                                        for (k = 0; k < router_obj->ucNumberOfObjects; k++) {
+                                                u16 router_obj_id = le16_to_cpu(router_obj->asObjects[j].usObjectID);
+                                                if (le16_to_cpu(path->usGraphicObjIds[j]) == router_obj_id) {
+                                                        ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
+                                                                (ctx->bios + data_offset +
+                                                                 le16_to_cpu(router_obj->asObjects[k].usRecordOffset));
+                                                        ATOM_I2C_RECORD *i2c_record;
+                                                        ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
+                                                        ATOM_ROUTER_DDC_PATH_SELECT_RECORD *ddc_path;
+                                                        ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *router_src_dst_table =
+                                                                (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *)
+                                                                (ctx->bios + data_offset +
+                                                                 le16_to_cpu(router_obj->asObjects[k].usSrcDstTableOffset));
+                                                        int enum_id;
+
+                                                        router.router_id = router_obj_id;
+                                                        for (enum_id = 0; enum_id < router_src_dst_table->ucNumberOfDst;
+                                                             enum_id++) {
+                                                                if (le16_to_cpu(path->usConnObjectId) ==
+                                                                    le16_to_cpu(router_src_dst_table->usDstObjectID[enum_id]))
+                                                                        break;
+                                                        }
+
+                                                        while (record->ucRecordType > 0 &&
+                                                               record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
+                                                                switch (record->ucRecordType) {
+                                                                case ATOM_I2C_RECORD_TYPE:
+                                                                        i2c_record =
+                                                                                (ATOM_I2C_RECORD *)
+                                                                                record;
+                                                                        i2c_config =
+                                                                                (ATOM_I2C_ID_CONFIG_ACCESS *)
+                                                                                &i2c_record->sucI2cId;
+                                                                        router.i2c_info =
+                                                                                radeon_lookup_i2c_gpio(rdev,
+                                                                                                       i2c_config->
+                                                                                                       ucAccess);
+                                                                        router.i2c_addr = i2c_record->ucI2CAddr >> 1;
+                                                                        break;
+                                                                case ATOM_ROUTER_DDC_PATH_SELECT_RECORD_TYPE:
+                                                                        ddc_path = (ATOM_ROUTER_DDC_PATH_SELECT_RECORD *)
+                                                                                record;
+                                                                        router.valid = true;
+                                                                        router.mux_type = ddc_path->ucMuxType;
+                                                                        router.mux_control_pin = ddc_path->ucMuxControlPin;
+                                                                        router.mux_state = ddc_path->ucMuxState[enum_id];
+                                                                        break;
+                                                                }
+                                                                record = (ATOM_COMMON_RECORD_HEADER *)
+                                                                        ((char *)record + record->ucRecordSize);
+                                                        }
+                                                }
+                                        }
                                 }
                         }
 
@@ -614,7 +746,8 @@ bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
                                                   connector_type, &ddc_bus,
                                                   linkb, igp_lane_info,
                                                   connector_object_id,
-                                                  &hpd);
+                                                  &hpd,
+                                                  &router);
 
                 }
         }
@@ -691,6 +824,9 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
         int i, j, max_device;
         struct bios_connector *bios_connectors;
         size_t bc_size = sizeof(*bios_connectors) * ATOM_MAX_SUPPORTED_DEVICE;
+        struct radeon_router router;
+
+        router.valid = false;
 
         bios_connectors = kzalloc(bc_size, GFP_KERNEL);
         if (!bios_connectors)
@@ -862,7 +998,8 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
                                                   &bios_connectors[i].ddc_bus,
                                                   false, 0,
                                                   connector_object_id,
-                                                  &bios_connectors[i].hpd);
+                                                  &bios_connectors[i].hpd,
+                                                  &router);
                 }
         }
 
@@ -1521,7 +1658,7 @@ void radeon_atombios_get_power_modes(struct radeon_device *rdev)
                                          thermal_controller_names[power_info->info.ucOverdriveThermalController],
                                          power_info->info.ucOverdriveControllerAddress >> 1);
                                 i2c_bus = radeon_lookup_i2c_gpio(rdev, power_info->info.ucOverdriveI2cLine);
-                                rdev->pm.i2c_bus = radeon_i2c_create(rdev->ddev, &i2c_bus, "Thermal");
+                                rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
                                 if (rdev->pm.i2c_bus) {
                                         struct i2c_board_info info = { };
                                         const char *name = thermal_controller_names[power_info->info.
@@ -1814,7 +1951,7 @@ void radeon_atombios_get_power_modes(struct radeon_device *rdev)
                                                  (controller->ucFanParameters &
                                                   ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
                                         i2c_bus = radeon_lookup_i2c_gpio(rdev, controller->ucI2cLine);
-                                        rdev->pm.i2c_bus = radeon_i2c_create(rdev->ddev, &i2c_bus, "Thermal");
+                                        rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
                                         if (rdev->pm.i2c_bus) {
                                                 struct i2c_board_info info = { };
                                                 const char *name = pp_lib_thermal_controller_names[controller->ucType];
@@ -1927,6 +2064,11 @@ void radeon_atombios_get_power_modes(struct radeon_device *rdev)
                                                 rdev->pm.power_state[state_index].type =
                                                         POWER_STATE_TYPE_PERFORMANCE;
                                                 break;
+                                        case ATOM_PPLIB_CLASSIFICATION_UI_NONE:
+                                                if (misc2 & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
+                                                        rdev->pm.power_state[state_index].type =
+                                                                POWER_STATE_TYPE_PERFORMANCE;
+                                                break;
                                         }
                                         rdev->pm.power_state[state_index].flags = 0;
                                         if (misc & ATOM_PPLIB_SINGLE_DISPLAY_ONLY)
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c
index f64936cc4dd..14448a740ba 100644
--- a/drivers/gpu/drm/radeon/radeon_clocks.c
+++ b/drivers/gpu/drm/radeon/radeon_clocks.c
@@ -91,6 +91,85 @@ uint32_t radeon_legacy_get_memory_clock(struct radeon_device *rdev)
         return mclk;
 }
 
+#ifdef CONFIG_OF
+/*
+ * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device
+ * tree. Hopefully, ATI OF driver is kind enough to fill these
+ */
+static bool __devinit radeon_read_clocks_OF(struct drm_device *dev)
+{
+        struct radeon_device *rdev = dev->dev_private;
+        struct device_node *dp = rdev->pdev->dev.of_node;
+        const u32 *val;
+        struct radeon_pll *p1pll = &rdev->clock.p1pll;
+        struct radeon_pll *p2pll = &rdev->clock.p2pll;
+        struct radeon_pll *spll = &rdev->clock.spll;
+        struct radeon_pll *mpll = &rdev->clock.mpll;
+
+        if (dp == NULL)
+                return false;
+        val = of_get_property(dp, "ATY,RefCLK", NULL);
+        if (!val || !*val) {
+                printk(KERN_WARNING "radeonfb: No ATY,RefCLK property !\n");
+                return false;
+        }
+        p1pll->reference_freq = p2pll->reference_freq = (*val) / 10;
+        p1pll->reference_div = RREG32_PLL(RADEON_PPLL_REF_DIV) & 0x3ff;
+        if (p1pll->reference_div < 2)
+                p1pll->reference_div = 12;
+        p2pll->reference_div = p1pll->reference_div;    
+
+        /* These aren't in the device-tree */
+        if (rdev->family >= CHIP_R420) {
+                p1pll->pll_in_min = 100;
+                p1pll->pll_in_max = 1350;
+                p1pll->pll_out_min = 20000;
+                p1pll->pll_out_max = 50000;
+                p2pll->pll_in_min = 100;
+                p2pll->pll_in_max = 1350;
+                p2pll->pll_out_min = 20000;
+                p2pll->pll_out_max = 50000;
+        } else {
+                p1pll->pll_in_min = 40;
+                p1pll->pll_in_max = 500;
+                p1pll->pll_out_min = 12500;
+                p1pll->pll_out_max = 35000;
+                p2pll->pll_in_min = 40;
+                p2pll->pll_in_max = 500;
+                p2pll->pll_out_min = 12500;
+                p2pll->pll_out_max = 35000;
+        }
+
+        spll->reference_freq = mpll->reference_freq = p1pll->reference_freq;
+        spll->reference_div = mpll->reference_div =
+                RREG32_PLL(RADEON_M_SPLL_REF_FB_DIV) &
+                            RADEON_M_SPLL_REF_DIV_MASK;
+
+        val = of_get_property(dp, "ATY,SCLK", NULL);
+        if (val && *val)
+                rdev->clock.default_sclk = (*val) / 10;
+        else
+                rdev->clock.default_sclk =
+                        radeon_legacy_get_engine_clock(rdev);
+                        
+        val = of_get_property(dp, "ATY,MCLK", NULL);
+        if (val && *val)
+                rdev->clock.default_mclk = (*val) / 10;
+        else
+                rdev->clock.default_mclk =
+                        radeon_legacy_get_memory_clock(rdev);
+
+        DRM_INFO("Using device-tree clock info\n");
+        
+        return true;
+}
+#else
+static bool __devinit radeon_read_clocks_OF(struct drm_device *dev)
+{
+        return false;
+}
+#endif /* CONFIG_OF */
+
 void radeon_get_clock_info(struct drm_device *dev)
 {
         struct radeon_device *rdev = dev->dev_private;
@@ -105,6 +184,8 @@ void radeon_get_clock_info(struct drm_device *dev)
                 ret = radeon_atom_get_clock_info(dev);
         else
                 ret = radeon_combios_get_clock_info(dev);
+        if (!ret)
+                ret = radeon_read_clocks_OF(dev);
 
         if (ret) {
                 if (p1pll->reference_div < 2) {
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index 5e1474cde4b..885dcfac183 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -480,9 +480,66 @@ radeon_combios_get_hardcoded_edid(struct radeon_device *rdev)
 }
 
 static struct radeon_i2c_bus_rec combios_setup_i2c_bus(struct radeon_device *rdev,
-                                                       int ddc_line)
+                                                       enum radeon_combios_ddc ddc,
+                                                       u32 clk_mask,
+                                                       u32 data_mask)
 {
         struct radeon_i2c_bus_rec i2c;
+        int ddc_line = 0;
+
+        /* ddc id            = mask reg
+         * DDC_NONE_DETECTED = none
+         * DDC_DVI           = RADEON_GPIO_DVI_DDC
+         * DDC_VGA           = RADEON_GPIO_VGA_DDC
+         * DDC_LCD           = RADEON_GPIOPAD_MASK
+         * DDC_GPIO          = RADEON_MDGPIO_MASK
+         * r1xx/r2xx
+         * DDC_MONID         = RADEON_GPIO_MONID
+         * DDC_CRT2          = RADEON_GPIO_CRT2_DDC
+         * r3xx
+         * DDC_MONID         = RADEON_GPIO_MONID
+         * DDC_CRT2          = RADEON_GPIO_DVI_DDC
+         * rs3xx/rs4xx
+         * DDC_MONID         = RADEON_GPIOPAD_MASK
+         * DDC_CRT2          = RADEON_GPIO_MONID
+         */
+        switch (ddc) {
+        case DDC_NONE_DETECTED:
+        default:
+                ddc_line = 0;
+                break;
+        case DDC_DVI:
+                ddc_line = RADEON_GPIO_DVI_DDC;
+                break;
+        case DDC_VGA:
+                ddc_line = RADEON_GPIO_VGA_DDC;
+                break;
+        case DDC_LCD:
+                ddc_line = RADEON_GPIOPAD_MASK;
+                break;
+        case DDC_GPIO:
+                ddc_line = RADEON_MDGPIO_MASK;
+                break;
+        case DDC_MONID:
+                if (rdev->family == CHIP_RS300 ||
+                    rdev->family == CHIP_RS400 ||
+                    rdev->family == CHIP_RS480)
+                        ddc_line = RADEON_GPIOPAD_MASK;
+                else
+                        ddc_line = RADEON_GPIO_MONID;
+                break;
+        case DDC_CRT2:
+                if (rdev->family == CHIP_RS300 ||
+                    rdev->family == CHIP_RS400 ||
+                    rdev->family == CHIP_RS480)
+                        ddc_line = RADEON_GPIO_MONID;
+                else if (rdev->family >= CHIP_R300) {
+                        ddc_line = RADEON_GPIO_DVI_DDC;
+                        ddc = DDC_DVI;
+                } else
+                        ddc_line = RADEON_GPIO_CRT2_DDC;
+                break;
+        }
 
         if (ddc_line == RADEON_GPIOPAD_MASK) {
                 i2c.mask_clk_reg = RADEON_GPIOPAD_MASK;
@@ -503,15 +560,6 @@ static struct radeon_i2c_bus_rec combios_setup_i2c_bus(struct radeon_device *rde
                 i2c.y_clk_reg = RADEON_MDGPIO_Y;
                 i2c.y_data_reg = RADEON_MDGPIO_Y;
         } else {
-                i2c.mask_clk_mask = RADEON_GPIO_EN_1;
-                i2c.mask_data_mask = RADEON_GPIO_EN_0;
-                i2c.a_clk_mask = RADEON_GPIO_A_1;
-                i2c.a_data_mask = RADEON_GPIO_A_0;
-                i2c.en_clk_mask = RADEON_GPIO_EN_1;
-                i2c.en_data_mask = RADEON_GPIO_EN_0;
-                i2c.y_clk_mask = RADEON_GPIO_Y_1;
-                i2c.y_data_mask = RADEON_GPIO_Y_0;
-
                 i2c.mask_clk_reg = ddc_line;
                 i2c.mask_data_reg = ddc_line;
                 i2c.a_clk_reg = ddc_line;
@@ -522,6 +570,26 @@ static struct radeon_i2c_bus_rec combios_setup_i2c_bus(struct radeon_device *rde
                 i2c.y_data_reg = ddc_line;
         }
 
+        if (clk_mask && data_mask) {
+                i2c.mask_clk_mask = clk_mask;
+                i2c.mask_data_mask = data_mask;
+                i2c.a_clk_mask = clk_mask;
+                i2c.a_data_mask = data_mask;
+                i2c.en_clk_mask = clk_mask;
+                i2c.en_data_mask = data_mask;
+                i2c.y_clk_mask = clk_mask;
+                i2c.y_data_mask = data_mask;
+        } else {
+                i2c.mask_clk_mask = RADEON_GPIO_EN_1;
+                i2c.mask_data_mask = RADEON_GPIO_EN_0;
+                i2c.a_clk_mask = RADEON_GPIO_A_1;
+                i2c.a_data_mask = RADEON_GPIO_A_0;
+                i2c.en_clk_mask = RADEON_GPIO_EN_1;
+                i2c.en_data_mask = RADEON_GPIO_EN_0;
+                i2c.y_clk_mask = RADEON_GPIO_Y_1;
+                i2c.y_data_mask = RADEON_GPIO_Y_0;
+        }
+
         switch (rdev->family) {
         case CHIP_R100:
         case CHIP_RV100:
@@ -599,7 +667,8 @@ static struct radeon_i2c_bus_rec combios_setup_i2c_bus(struct radeon_device *rde
                 break;
         }
         i2c.mm_i2c = false;
-        i2c.i2c_id = 0;
+
+        i2c.i2c_id = ddc;
         i2c.hpd = RADEON_HPD_NONE;
 
         if (ddc_line)
@@ -610,6 +679,62 @@ static struct radeon_i2c_bus_rec combios_setup_i2c_bus(struct radeon_device *rde
         return i2c;
 }
 
+void radeon_combios_i2c_init(struct radeon_device *rdev)
+{
+        struct drm_device *dev = rdev->ddev;
+        struct radeon_i2c_bus_rec i2c;
+
+
+        i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
+        rdev->i2c_bus[0] = radeon_i2c_create(dev, &i2c, "DVI_DDC");
+
+        i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
+        rdev->i2c_bus[1] = radeon_i2c_create(dev, &i2c, "VGA_DDC");
+
+        i2c.valid = true;
+        i2c.hw_capable = true;
+        i2c.mm_i2c = true;
+        i2c.i2c_id = 0xa0;
+        rdev->i2c_bus[2] = radeon_i2c_create(dev, &i2c, "MM_I2C");
+
+        if (rdev->family == CHIP_RS300 ||
+            rdev->family == CHIP_RS400 ||
+            rdev->family == CHIP_RS480) {
+                u16 offset;
+                u8 id, blocks, clk, data;
+                int i;
+
+                i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
+                rdev->i2c_bus[3] = radeon_i2c_create(dev, &i2c, "MONID");
+
+                offset = combios_get_table_offset(dev, COMBIOS_I2C_INFO_TABLE);
+                if (offset) {
+                        blocks = RBIOS8(offset + 2);
+                        for (i = 0; i < blocks; i++) {
+                                id = RBIOS8(offset + 3 + (i * 5) + 0);
+                                if (id == 136) {
+                                        clk = RBIOS8(offset + 3 + (i * 5) + 3);
+                                        data = RBIOS8(offset + 3 + (i * 5) + 4);
+                                        i2c = combios_setup_i2c_bus(rdev, DDC_MONID,
+                                                                    clk, data);
+                                        rdev->i2c_bus[4] = radeon_i2c_create(dev, &i2c, "GPIOPAD_MASK");
+                                        break;
+                                }
+                        }
+                }
+
+        } else if (rdev->family >= CHIP_R300) {
+                i2c = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
+                rdev->i2c_bus[3] = radeon_i2c_create(dev, &i2c, "MONID");
+        } else {
+                i2c = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
+                rdev->i2c_bus[3] = radeon_i2c_create(dev, &i2c, "MONID");
+
+                i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
+                rdev->i2c_bus[4] = radeon_i2c_create(dev, &i2c, "CRT2_DDC");
+        }
+}
+
 bool radeon_combios_get_clock_info(struct drm_device *dev)
 {
         struct radeon_device *rdev = dev->dev_private;
@@ -1247,8 +1372,8 @@ bool radeon_legacy_get_ext_tmds_info_from_table(struct radeon_encoder *encoder,
         struct radeon_i2c_bus_rec i2c_bus;
 
         /* default for macs */
-        i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
-        tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
+        i2c_bus = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
+        tmds->i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
 
         /* XXX some macs have duallink chips */
         switch (rdev->mode_info.connector_table) {
@@ -1269,47 +1394,16 @@ bool radeon_legacy_get_ext_tmds_info_from_combios(struct radeon_encoder *encoder
         struct drm_device *dev = encoder->base.dev;
         struct radeon_device *rdev = dev->dev_private;
         uint16_t offset;
-        uint8_t ver, id, blocks, clk, data;
-        int i;
+        uint8_t ver;
         enum radeon_combios_ddc gpio;
         struct radeon_i2c_bus_rec i2c_bus;
 
         tmds->i2c_bus = NULL;
         if (rdev->flags & RADEON_IS_IGP) {
-                offset = combios_get_table_offset(dev, COMBIOS_I2C_INFO_TABLE);
-                if (offset) {
-                        ver = RBIOS8(offset);
-                        DRM_INFO("GPIO Table revision: %d\n", ver);
-                        blocks = RBIOS8(offset + 2);
-                        for (i = 0; i < blocks; i++) {
-                                id = RBIOS8(offset + 3 + (i * 5) + 0);
-                                if (id == 136) {
-                                        clk = RBIOS8(offset + 3 + (i * 5) + 3);
-                                        data = RBIOS8(offset + 3 + (i * 5) + 4);
-                                        i2c_bus.valid = true;
-                                        i2c_bus.mask_clk_mask = (1 << clk);
-                                        i2c_bus.mask_data_mask = (1 << data);
-                                        i2c_bus.a_clk_mask = (1 << clk);
-                                        i2c_bus.a_data_mask = (1 << data);
-                                        i2c_bus.en_clk_mask = (1 << clk);
-                                        i2c_bus.en_data_mask = (1 << data);
-                                        i2c_bus.y_clk_mask = (1 << clk);
-                                        i2c_bus.y_data_mask = (1 << data);
-                                        i2c_bus.mask_clk_reg = RADEON_GPIOPAD_MASK;
-                                        i2c_bus.mask_data_reg = RADEON_GPIOPAD_MASK;
-                                        i2c_bus.a_clk_reg = RADEON_GPIOPAD_A;
-                                        i2c_bus.a_data_reg = RADEON_GPIOPAD_A;
-                                        i2c_bus.en_clk_reg = RADEON_GPIOPAD_EN;
-                                        i2c_bus.en_data_reg = RADEON_GPIOPAD_EN;
-                                        i2c_bus.y_clk_reg = RADEON_GPIOPAD_Y;
-                                        i2c_bus.y_data_reg = RADEON_GPIOPAD_Y;
-                                        tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
-                                        tmds->dvo_chip = DVO_SIL164;
-                                        tmds->slave_addr = 0x70 >> 1; /* 7 bit addressing */
-                                        break;
-                                }
-                        }
-                }
+                i2c_bus = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
+                tmds->i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
+                tmds->dvo_chip = DVO_SIL164;
+                tmds->slave_addr = 0x70 >> 1; /* 7 bit addressing */
         } else {
                 offset = combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
                 if (offset) {
@@ -1318,37 +1412,15 @@ bool radeon_legacy_get_ext_tmds_info_from_combios(struct radeon_encoder *encoder
                         tmds->slave_addr = RBIOS8(offset + 4 + 2);
                         tmds->slave_addr >>= 1; /* 7 bit addressing */
                         gpio = RBIOS8(offset + 4 + 3);
-                        switch (gpio) {
-                        case DDC_MONID:
-                                i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
-                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
-                                break;
-                        case DDC_DVI:
-                                i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
-                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
-                                break;
-                        case DDC_VGA:
-                                i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
-                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
-                                break;
-                        case DDC_CRT2:
-                                /* R3xx+ chips don't have GPIO_CRT2_DDC gpio pad */
-                                if (rdev->family >= CHIP_R300)
-                                        i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
-                                else
-                                        i2c_bus = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
-                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
-                                break;
-                        case DDC_LCD: /* MM i2c */
+                        if (gpio == DDC_LCD) {
+                                /* MM i2c */
                                 i2c_bus.valid = true;
                                 i2c_bus.hw_capable = true;
                                 i2c_bus.mm_i2c = true;
-                                tmds->i2c_bus = radeon_i2c_create(dev, &i2c_bus, "DVO");
-                                break;
-                        default:
-                                DRM_ERROR("Unsupported gpio %d\n", gpio);
-                                break;
-                        }
+                                i2c_bus.i2c_id = 0xa0;
+                        } else
+                                i2c_bus = combios_setup_i2c_bus(rdev, gpio, 0, 0);
+                        tmds->i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
                 }
         }
 
@@ -1430,7 +1502,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 /* these are the most common settings */
                 if (rdev->flags & RADEON_SINGLE_CRTC) {
                         /* VGA - primary dac */
-                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
@@ -1445,7 +1517,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     &hpd);
                 } else if (rdev->flags & RADEON_IS_MOBILITY) {
                         /* LVDS */
-                        ddc_i2c = combios_setup_i2c_bus(rdev, 0);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, DDC_NONE_DETECTED, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
@@ -1460,7 +1532,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     &hpd);
 
                         /* VGA - primary dac */
-                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
@@ -1475,7 +1547,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     &hpd);
                 } else {
                         /* DVI-I - tv dac, int tmds */
-                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                         hpd.hpd = RADEON_HPD_1;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
@@ -1496,7 +1568,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                                     &hpd);
 
                         /* VGA - primary dac */
-                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                         hpd.hpd = RADEON_HPD_NONE;
                         radeon_add_legacy_encoder(dev,
                                                   radeon_get_encoder_id(dev,
@@ -1532,7 +1604,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (ibook)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1544,7 +1616,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_LVDS,
                                             &hpd);
                 /* VGA - TV DAC */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1573,7 +1645,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (powerbook external tmds)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1585,7 +1657,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_LVDS,
                                             &hpd);
                 /* DVI-I - primary dac, ext tmds */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_2; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1622,7 +1694,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (powerbook internal tmds)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1634,7 +1706,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_LVDS,
                                             &hpd);
                 /* DVI-I - primary dac, int tmds */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1670,7 +1742,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (powerbook vga)\n",
                          rdev->mode_info.connector_table);
                 /* LVDS */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1682,7 +1754,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_LVDS,
                                             &hpd);
                 /* VGA - primary dac */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1711,7 +1783,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (mini external tmds)\n",
                          rdev->mode_info.connector_table);
                 /* DVI-I - tv dac, ext tmds */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_2; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1748,7 +1820,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (mini internal tmds)\n",
                          rdev->mode_info.connector_table);
                 /* DVI-I - tv dac, int tmds */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1784,7 +1856,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (imac g5 isight)\n",
                          rdev->mode_info.connector_table);
                 /* DVI-D - int tmds */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
                 hpd.hpd = RADEON_HPD_1; /* ??? */
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1796,7 +1868,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D,
                                             &hpd);
                 /* VGA - tv dac */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1825,7 +1897,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (emac)\n",
                          rdev->mode_info.connector_table);
                 /* VGA - primary dac */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1837,7 +1909,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             CONNECTOR_OBJECT_ID_VGA,
                                             &hpd);
                 /* VGA - tv dac */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1866,7 +1938,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                 DRM_INFO("Connector Table: %d (rn50-power)\n",
                          rdev->mode_info.connector_table);
                 /* VGA - primary dac */
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1877,7 +1949,7 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
                                             DRM_MODE_CONNECTOR_VGA, &ddc_i2c,
                                             CONNECTOR_OBJECT_ID_VGA,
                                             &hpd);
-                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
+                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_CRT2, 0, 0);
                 hpd.hpd = RADEON_HPD_NONE;
                 radeon_add_legacy_encoder(dev,
                                           radeon_get_encoder_id(dev,
@@ -1907,31 +1979,6 @@ static bool radeon_apply_legacy_quirks(struct drm_device *dev,
                                        struct radeon_i2c_bus_rec *ddc_i2c,
                                        struct radeon_hpd *hpd)
 {
-        struct radeon_device *rdev = dev->dev_private;
-
-        /* XPRESS DDC quirks */
-        if ((rdev->family == CHIP_RS400 ||
-             rdev->family == CHIP_RS480) &&
-            ddc_i2c->mask_clk_reg == RADEON_GPIO_CRT2_DDC)
-                *ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
-        else if ((rdev->family == CHIP_RS400 ||
-                  rdev->family == CHIP_RS480) &&
-                 ddc_i2c->mask_clk_reg == RADEON_GPIO_MONID) {
-                *ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIOPAD_MASK);
-                ddc_i2c->mask_clk_mask = (0x20 << 8);
-                ddc_i2c->mask_data_mask = 0x80;
-                ddc_i2c->a_clk_mask = (0x20 << 8);
-                ddc_i2c->a_data_mask = 0x80;
-                ddc_i2c->en_clk_mask = (0x20 << 8);
-                ddc_i2c->en_data_mask = 0x80;
-                ddc_i2c->y_clk_mask = (0x20 << 8);
-                ddc_i2c->y_data_mask = 0x80;
-        }
-
-        /* R3xx+ chips don't have GPIO_CRT2_DDC gpio pad */
-        if ((rdev->family >= CHIP_R300) &&
-            ddc_i2c->mask_clk_reg == RADEON_GPIO_CRT2_DDC)
-                *ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
 
         /* Certain IBM chipset RN50s have a BIOS reporting two VGAs,
            one with VGA DDC and one with CRT2 DDC. - kill the CRT2 DDC one */
@@ -2035,27 +2082,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         connector = (tmp >> 12) & 0xf;
 
                         ddc_type = (tmp >> 8) & 0xf;
-                        switch (ddc_type) {
-                        case DDC_MONID:
-                                ddc_i2c =
-                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_MONID);
-                                break;
-                        case DDC_DVI:
-                                ddc_i2c =
-                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
-                                break;
-                        case DDC_VGA:
-                                ddc_i2c =
-                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
-                                break;
-                        case DDC_CRT2:
-                                ddc_i2c =
-                                        combios_setup_i2c_bus(rdev, RADEON_GPIO_CRT2_DDC);
-                                break;
-                        default:
-                                ddc_i2c.valid = false;
-                                break;
-                        }
+                        ddc_i2c = combios_setup_i2c_bus(rdev, ddc_type, 0, 0);
 
                         switch (connector) {
                         case CONNECTOR_PROPRIETARY_LEGACY:
@@ -2225,7 +2252,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                                         0),
                                                   ATOM_DEVICE_DFP1_SUPPORT);
 
-                        ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_DVI_DDC);
+                        ddc_i2c = combios_setup_i2c_bus(rdev, DDC_DVI, 0, 0);
                         hpd.hpd = RADEON_HPD_1;
                         radeon_add_legacy_connector(dev,
                                                     0,
@@ -2245,7 +2272,7 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                                                                                 ATOM_DEVICE_CRT1_SUPPORT,
                                                                                 1),
                                                           ATOM_DEVICE_CRT1_SUPPORT);
-                                ddc_i2c = combios_setup_i2c_bus(rdev, RADEON_GPIO_VGA_DDC);
+                                ddc_i2c = combios_setup_i2c_bus(rdev, DDC_VGA, 0, 0);
                                 hpd.hpd = RADEON_HPD_NONE;
                                 radeon_add_legacy_connector(dev,
                                                             0,
@@ -2278,70 +2305,25 @@ bool radeon_get_legacy_connector_info_from_bios(struct drm_device *dev)
                         if (lcd_ddc_info) {
                                 ddc_type = RBIOS8(lcd_ddc_info + 2);
                                 switch (ddc_type) {
-                                case DDC_MONID:
-                                        ddc_i2c =
-                                            combios_setup_i2c_bus
-                                                (rdev, RADEON_GPIO_MONID);
-                                        break;
-                                case DDC_DVI:
-                                        ddc_i2c =
-                                            combios_setup_i2c_bus
-                                                (rdev, RADEON_GPIO_DVI_DDC);
-                                        break;
-                                case DDC_VGA:
-                                        ddc_i2c =
-                                            combios_setup_i2c_bus
-                                                (rdev, RADEON_GPIO_VGA_DDC);
-                                        break;
-                                case DDC_CRT2:
-                                        ddc_i2c =
-                                            combios_setup_i2c_bus
-                                                (rdev, RADEON_GPIO_CRT2_DDC);
-                                        break;
                                 case DDC_LCD:
                                         ddc_i2c =
-                                            combios_setup_i2c_bus
-                                                (rdev, RADEON_GPIOPAD_MASK);
-                                        ddc_i2c.mask_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.mask_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.a_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.a_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.en_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.en_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.y_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.y_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
+                                                combios_setup_i2c_bus(rdev,
+                                                                      DDC_LCD,
+                                                                      RBIOS32(lcd_ddc_info + 3),
+                                                                      RBIOS32(lcd_ddc_info + 7));
+                                        radeon_i2c_add(rdev, &ddc_i2c, "LCD");
                                         break;
                                 case DDC_GPIO:
                                         ddc_i2c =
-                                            combios_setup_i2c_bus
-                                                (rdev, RADEON_MDGPIO_MASK);
-                                        ddc_i2c.mask_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.mask_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.a_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.a_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.en_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.en_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
-                                        ddc_i2c.y_clk_mask =
-                                            RBIOS32(lcd_ddc_info + 3);
-                                        ddc_i2c.y_data_mask =
-                                            RBIOS32(lcd_ddc_info + 7);
+                                                combios_setup_i2c_bus(rdev,
+                                                                      DDC_GPIO,
+                                                                      RBIOS32(lcd_ddc_info + 3),
+                                                                      RBIOS32(lcd_ddc_info + 7));
+                                        radeon_i2c_add(rdev, &ddc_i2c, "LCD");
                                         break;
                                 default:
-                                        ddc_i2c.valid = false;
+                                        ddc_i2c =
+                                                combios_setup_i2c_bus(rdev, ddc_type, 0, 0);
                                         break;
                                 }
                                 DRM_DEBUG_KMS("LCD DDC Info Table found!\n");
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 2395c8600cf..47c4b276d30 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -518,8 +518,6 @@ static void radeon_connector_destroy(struct drm_connector *connector)
 {
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
 
-        if (radeon_connector->ddc_bus)
-                radeon_i2c_destroy(radeon_connector->ddc_bus);
         if (radeon_connector->edid)
                 kfree(radeon_connector->edid);
         kfree(radeon_connector->con_priv);
@@ -955,8 +953,6 @@ static void radeon_dp_connector_destroy(struct drm_connector *connector)
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
 
-        if (radeon_connector->ddc_bus)
-                radeon_i2c_destroy(radeon_connector->ddc_bus);
         if (radeon_connector->edid)
                 kfree(radeon_connector->edid);
         if (radeon_dig_connector->dp_i2c_bus)
@@ -1044,7 +1040,8 @@ radeon_add_atom_connector(struct drm_device *dev,
                           bool linkb,
                           uint32_t igp_lane_info,
                           uint16_t connector_object_id,
-                          struct radeon_hpd *hpd)
+                          struct radeon_hpd *hpd,
+                          struct radeon_router *router)
 {
         struct radeon_device *rdev = dev->dev_private;
         struct drm_connector *connector;
@@ -1069,6 +1066,11 @@ radeon_add_atom_connector(struct drm_device *dev,
                                 radeon_connector->shared_ddc = true;
                                 shared_ddc = true;
                         }
+                        if (radeon_connector->router_bus && router->valid &&
+                            (radeon_connector->router.router_id == router->router_id)) {
+                                radeon_connector->shared_ddc = false;
+                                shared_ddc = false;
+                        }
                 }
         }
 
@@ -1083,12 +1085,18 @@ radeon_add_atom_connector(struct drm_device *dev,
         radeon_connector->shared_ddc = shared_ddc;
         radeon_connector->connector_object_id = connector_object_id;
         radeon_connector->hpd = *hpd;
+        radeon_connector->router = *router;
+        if (router->valid) {
+                radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
+                if (!radeon_connector->router_bus)
+                        goto failed;
+        }
         switch (connector_type) {
         case DRM_MODE_CONNECTOR_VGA:
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1104,7 +1112,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1126,7 +1134,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1156,7 +1164,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1187,10 +1195,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
                         if (!radeon_dig_connector->dp_i2c_bus)
                                 goto failed;
-                        if (connector_type == DRM_MODE_CONNECTOR_eDP)
-                                radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "eDP");
-                        else
-                                radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1230,7 +1235,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1252,8 +1257,6 @@ radeon_add_atom_connector(struct drm_device *dev,
         return;
 
 failed:
-        if (radeon_connector->ddc_bus)
-                radeon_i2c_destroy(radeon_connector->ddc_bus);
         drm_connector_cleanup(connector);
         kfree(connector);
 }
@@ -1300,7 +1303,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1316,7 +1319,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1332,7 +1335,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1372,7 +1375,7 @@ radeon_add_legacy_connector(struct drm_device *dev,
                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
                 if (i2c_bus->valid) {
-                        radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
+                        radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
                         if (!radeon_connector->ddc_bus)
                                 goto failed;
                 }
@@ -1393,8 +1396,6 @@ radeon_add_legacy_connector(struct drm_device *dev,
         return;
 
 failed:
-        if (radeon_connector->ddc_bus)
-                radeon_i2c_destroy(radeon_connector->ddc_bus);
         drm_connector_cleanup(connector);
         kfree(connector);
 }
diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c
index ae0fb7356e6..fcc79b5d22d 100644
--- a/drivers/gpu/drm/radeon/radeon_cs.c
+++ b/drivers/gpu/drm/radeon/radeon_cs.c
@@ -72,7 +72,7 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p)
                         if (p->relocs[i].gobj == NULL) {
                                 DRM_ERROR("gem object lookup failed 0x%x\n",
                                           r->handle);
-                                return -EINVAL;
+                                return -ENOENT;
                         }
                         p->relocs_ptr[i] = &p->relocs[i];
                         p->relocs[i].robj = p->relocs[i].gobj->driver_private;
diff --git a/drivers/gpu/drm/radeon/radeon_cursor.c b/drivers/gpu/drm/radeon/radeon_cursor.c
index 4eb67c0e099..5731fc9b1ae 100644
--- a/drivers/gpu/drm/radeon/radeon_cursor.c
+++ b/drivers/gpu/drm/radeon/radeon_cursor.c
@@ -170,7 +170,7 @@ int radeon_crtc_cursor_set(struct drm_crtc *crtc,
         obj = drm_gem_object_lookup(crtc->dev, file_priv, handle);
         if (!obj) {
                 DRM_ERROR("Cannot find cursor object %x for crtc %d\n", handle, radeon_crtc->crtc_id);
-                return -EINVAL;
+                return -ENOENT;
         }
 
         ret = radeon_gem_object_pin(obj, RADEON_GEM_DOMAIN_VRAM, &gpu_addr);
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index a64811a9451..4f7a170d156 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -347,7 +347,8 @@ int radeon_dummy_page_init(struct radeon_device *rdev)
                 return -ENOMEM;
         rdev->dummy_page.addr = pci_map_page(rdev->pdev, rdev->dummy_page.page,
                                         0, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-        if (!rdev->dummy_page.addr) {
+        if (pci_dma_mapping_error(rdev->pdev, rdev->dummy_page.addr)) {
+                dev_err(&rdev->pdev->dev, "Failed to DMA MAP the dummy page\n");
                 __free_page(rdev->dummy_page.page);
                 rdev->dummy_page.page = NULL;
                 return -ENOMEM;
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 74dac9635d7..5764f4d3b4f 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -161,17 +161,13 @@ void radeon_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
 }
 
 static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green,
-                                  u16 *blue, uint32_t size)
+                                  u16 *blue, uint32_t start, uint32_t size)
 {
         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
-        int i;
-
-        if (size != 256) {
-                return;
-        }
+        int end = (start + size > 256) ? 256 : start + size, i;
 
         /* userspace palettes are always correct as is */
-        for (i = 0; i < 256; i++) {
+        for (i = start; i < end; i++) {
                 radeon_crtc->lut_r[i] = red[i] >> 6;
                 radeon_crtc->lut_g[i] = green[i] >> 6;
                 radeon_crtc->lut_b[i] = blue[i] >> 6;
@@ -319,6 +315,10 @@ static void radeon_print_display_setup(struct drm_device *dev)
                                  radeon_connector->ddc_bus->rec.en_data_reg,
                                  radeon_connector->ddc_bus->rec.y_clk_reg,
                                  radeon_connector->ddc_bus->rec.y_data_reg);
+                        if (radeon_connector->router_bus)
+                                DRM_INFO("  DDC Router 0x%x/0x%x\n",
+                                         radeon_connector->router.mux_control_pin,
+                                         radeon_connector->router.mux_state);
                 } else {
                         if (connector->connector_type == DRM_MODE_CONNECTOR_VGA ||
                             connector->connector_type == DRM_MODE_CONNECTOR_DVII ||
@@ -395,6 +395,10 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
         struct radeon_device *rdev = dev->dev_private;
         int ret = 0;
 
+        /* on hw with routers, select right port */
+        if (radeon_connector->router.valid)
+                radeon_router_select_port(radeon_connector);
+
         if ((radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
             (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP)) {
                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
@@ -425,6 +429,10 @@ static int radeon_ddc_dump(struct drm_connector *connector)
         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
         int ret = 0;
 
+        /* on hw with routers, select right port */
+        if (radeon_connector->router.valid)
+                radeon_router_select_port(radeon_connector);
+
         if (!radeon_connector->ddc_bus)
                 return -1;
         edid = drm_get_edid(connector, &radeon_connector->ddc_bus->adapter);
@@ -876,13 +884,12 @@ radeon_user_framebuffer_create(struct drm_device *dev,
         if (obj ==  NULL) {
                 dev_err(&dev->pdev->dev, "No GEM object associated to handle 0x%08X, "
                         "can't create framebuffer\n", mode_cmd->handle);
-                return NULL;
+                return ERR_PTR(-ENOENT);
         }
 
         radeon_fb = kzalloc(sizeof(*radeon_fb), GFP_KERNEL);
-        if (radeon_fb == NULL) {
-                return NULL;
-        }
+        if (radeon_fb == NULL)
+                return ERR_PTR(-ENOMEM);
 
         radeon_framebuffer_init(dev, radeon_fb, mode_cmd, obj);
 
@@ -1040,6 +1047,9 @@ int radeon_modeset_init(struct radeon_device *rdev)
                 return ret;
         }
 
+        /* init i2c buses */
+        radeon_i2c_init(rdev);
+
         /* check combios for a valid hardcoded EDID - Sun servers */
         if (!rdev->is_atom_bios) {
                 /* check for hardcoded EDID in BIOS */
@@ -1080,6 +1090,8 @@ void radeon_modeset_fini(struct radeon_device *rdev)
                 drm_mode_config_cleanup(rdev->ddev);
                 rdev->mode_info.mode_config_initialized = false;
         }
+        /* free i2c buses */
+        radeon_i2c_fini(rdev);
 }
 
 bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
diff --git a/drivers/gpu/drm/radeon/radeon_gem.c b/drivers/gpu/drm/radeon/radeon_gem.c
index a72a3ee5d69..c578f265b24 100644
--- a/drivers/gpu/drm/radeon/radeon_gem.c
+++ b/drivers/gpu/drm/radeon/radeon_gem.c
@@ -226,7 +226,7 @@ int radeon_gem_set_domain_ioctl(struct drm_device *dev, void *data,
         /* just do a BO wait for now */
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL) {
-                return -EINVAL;
+                return -ENOENT;
         }
         robj = gobj->driver_private;
 
@@ -245,7 +245,7 @@ int radeon_gem_mmap_ioctl(struct drm_device *dev, void *data,
 
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL) {
-                return -EINVAL;
+                return -ENOENT;
         }
         robj = gobj->driver_private;
         args->addr_ptr = radeon_bo_mmap_offset(robj);
@@ -264,7 +264,7 @@ int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
 
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL) {
-                return -EINVAL;
+                return -ENOENT;
         }
         robj = gobj->driver_private;
         r = radeon_bo_wait(robj, &cur_placement, true);
@@ -294,7 +294,7 @@ int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
 
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL) {
-                return -EINVAL;
+                return -ENOENT;
         }
         robj = gobj->driver_private;
         r = radeon_bo_wait(robj, NULL, false);
@@ -316,7 +316,7 @@ int radeon_gem_set_tiling_ioctl(struct drm_device *dev, void *data,
         DRM_DEBUG("%d \n", args->handle);
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL)
-                return -EINVAL;
+                return -ENOENT;
         robj = gobj->driver_private;
         r = radeon_bo_set_tiling_flags(robj, args->tiling_flags, args->pitch);
         drm_gem_object_unreference_unlocked(gobj);
@@ -334,7 +334,7 @@ int radeon_gem_get_tiling_ioctl(struct drm_device *dev, void *data,
         DRM_DEBUG("\n");
         gobj = drm_gem_object_lookup(dev, filp, args->handle);
         if (gobj == NULL)
-                return -EINVAL;
+                return -ENOENT;
         rbo = gobj->driver_private;
         r = radeon_bo_reserve(rbo, false);
         if (unlikely(r != 0))
diff --git a/drivers/gpu/drm/radeon/radeon_i2c.c b/drivers/gpu/drm/radeon/radeon_i2c.c
index 5def6f5dff3..bfd2ce5f537 100644
--- a/drivers/gpu/drm/radeon/radeon_i2c.c
+++ b/drivers/gpu/drm/radeon/radeon_i2c.c
@@ -52,6 +52,10 @@ bool radeon_ddc_probe(struct radeon_connector *radeon_connector)
                 }
         };
 
+        /* on hw with routers, select right port */
+        if (radeon_connector->router.valid)
+                radeon_router_select_port(radeon_connector);
+
         ret = i2c_transfer(&radeon_connector->ddc_bus->adapter, msgs, 2);
         if (ret == 2)
                 return true;
@@ -960,6 +964,59 @@ void radeon_i2c_destroy(struct radeon_i2c_chan *i2c)
         kfree(i2c);
 }
 
+/* Add the default buses */
+void radeon_i2c_init(struct radeon_device *rdev)
+{
+        if (rdev->is_atom_bios)
+                radeon_atombios_i2c_init(rdev);
+        else
+                radeon_combios_i2c_init(rdev);
+}
+
+/* remove all the buses */
+void radeon_i2c_fini(struct radeon_device *rdev)
+{
+        int i;
+
+        for (i = 0; i < RADEON_MAX_I2C_BUS; i++) {
+                if (rdev->i2c_bus[i]) {
+                        radeon_i2c_destroy(rdev->i2c_bus[i]);
+                        rdev->i2c_bus[i] = NULL;
+                }
+        }
+}
+
+/* Add additional buses */
+void radeon_i2c_add(struct radeon_device *rdev,
+                    struct radeon_i2c_bus_rec *rec,
+                    const char *name)
+{
+        struct drm_device *dev = rdev->ddev;
+        int i;
+
+        for (i = 0; i < RADEON_MAX_I2C_BUS; i++) {
+                if (!rdev->i2c_bus[i]) {
+                        rdev->i2c_bus[i] = radeon_i2c_create(dev, rec, name);
+                        return;
+                }
+        }
+}
+
+/* looks up bus based on id */
+struct radeon_i2c_chan *radeon_i2c_lookup(struct radeon_device *rdev,
+                                          struct radeon_i2c_bus_rec *i2c_bus)
+{
+        int i;
+
+        for (i = 0; i < RADEON_MAX_I2C_BUS; i++) {
+                if (rdev->i2c_bus[i] &&
+                    (rdev->i2c_bus[i]->rec.i2c_id == i2c_bus->i2c_id)) {
+                        return rdev->i2c_bus[i];
+                }
+        }
+        return NULL;
+}
+
 struct drm_encoder *radeon_best_encoder(struct drm_connector *connector)
 {
         return NULL;
@@ -1020,3 +1077,28 @@ void radeon_i2c_put_byte(struct radeon_i2c_chan *i2c_bus,
                           addr, val);
 }
 
+/* router switching */
+void radeon_router_select_port(struct radeon_connector *radeon_connector)
+{
+        u8 val;
+
+        if (!radeon_connector->router.valid)
+                return;
+
+        radeon_i2c_get_byte(radeon_connector->router_bus,
+                            radeon_connector->router.i2c_addr,
+                            0x3, &val);
+        val &= radeon_connector->router.mux_control_pin;
+        radeon_i2c_put_byte(radeon_connector->router_bus,
+                            radeon_connector->router.i2c_addr,
+                            0x3, val);
+        radeon_i2c_get_byte(radeon_connector->router_bus,
+                            radeon_connector->router.i2c_addr,
+                            0x1, &val);
+        val &= radeon_connector->router.mux_control_pin;
+        val |= radeon_connector->router.mux_state;
+        radeon_i2c_put_byte(radeon_connector->router_bus,
+                            radeon_connector->router.i2c_addr,
+                            0x1, val);
+}
+
diff --git a/drivers/gpu/drm/radeon/radeon_kms.c b/drivers/gpu/drm/radeon/radeon_kms.c
index ddcd3b13f15..b1c8ace5f08 100644
--- a/drivers/gpu/drm/radeon/radeon_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_kms.c
@@ -112,7 +112,9 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 
         info = data;
         value_ptr = (uint32_t *)((unsigned long)info->value);
-        value = *value_ptr;
+        if (DRM_COPY_FROM_USER(&value, value_ptr, sizeof(value)))
+                return -EFAULT;
+
         switch (info->request) {
         case RADEON_INFO_DEVICE_ID:
                 value = dev->pci_device;
@@ -160,13 +162,27 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
                         return -EINVAL;
                 }
         case RADEON_INFO_WANT_HYPERZ:
+                /* The "value" here is both an input and output parameter.
+                 * If the input value is 1, filp requests hyper-z access.
+                 * If the input value is 0, filp revokes its hyper-z access.
+                 *
+                 * When returning, the value is 1 if filp owns hyper-z access,
+                 * 0 otherwise. */
+                if (value >= 2) {
+                        DRM_DEBUG_KMS("WANT_HYPERZ: invalid value %d\n", value);
+                        return -EINVAL;
+                }
                 mutex_lock(&dev->struct_mutex);
-                if (rdev->hyperz_filp)
-                        value = 0;
-                else {
-                        rdev->hyperz_filp = filp;
-                        value = 1;
+                if (value == 1) {
+                        /* wants hyper-z */
+                        if (!rdev->hyperz_filp)
+                                rdev->hyperz_filp = filp;
+                } else if (value == 0) {
+                        /* revokes hyper-z */
+                        if (rdev->hyperz_filp == filp)
+                                rdev->hyperz_filp = NULL;
                 }
+                value = rdev->hyperz_filp == filp ?  1 : 0;
                 mutex_unlock(&dev->struct_mutex);
                 break;
         default:
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h
index 71aea4037e9..5bbc086b926 100644
--- a/drivers/gpu/drm/radeon/radeon_mode.h
+++ b/drivers/gpu/drm/radeon/radeon_mode.h
@@ -82,6 +82,8 @@ enum radeon_hpd_id {
         RADEON_HPD_NONE = 0xff,
 };
 
+#define RADEON_MAX_I2C_BUS 16
+
 /* radeon gpio-based i2c
  * 1. "mask" reg and bits
  *    grabs the gpio pins for software use
@@ -398,6 +400,16 @@ struct radeon_hpd {
         struct radeon_gpio_rec gpio;
 };
 
+struct radeon_router {
+        bool valid;
+        u32 router_id;
+        struct radeon_i2c_bus_rec i2c_info;
+        u8 i2c_addr;
+        u8 mux_type;
+        u8 mux_control_pin;
+        u8 mux_state;
+};
+
 struct radeon_connector {
         struct drm_connector base;
         uint32_t connector_id;
@@ -413,6 +425,8 @@ struct radeon_connector {
         bool dac_load_detect;
         uint16_t connector_object_id;
         struct radeon_hpd hpd;
+        struct radeon_router router;
+        struct radeon_i2c_chan *router_bus;
 };
 
 struct radeon_framebuffer {
@@ -445,6 +459,15 @@ extern void atombios_dig_transmitter_setup(struct drm_encoder *encoder,
 extern int radeon_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
                                 uint8_t write_byte, uint8_t *read_byte);
 
+extern void radeon_i2c_init(struct radeon_device *rdev);
+extern void radeon_i2c_fini(struct radeon_device *rdev);
+extern void radeon_combios_i2c_init(struct radeon_device *rdev);
+extern void radeon_atombios_i2c_init(struct radeon_device *rdev);
+extern void radeon_i2c_add(struct radeon_device *rdev,
+                           struct radeon_i2c_bus_rec *rec,
+                           const char *name);
+extern struct radeon_i2c_chan *radeon_i2c_lookup(struct radeon_device *rdev,
+                                                 struct radeon_i2c_bus_rec *i2c_bus);
 extern struct radeon_i2c_chan *radeon_i2c_create_dp(struct drm_device *dev,
                                                     struct radeon_i2c_bus_rec *rec,
                                                     const char *name);
@@ -460,6 +483,7 @@ extern void radeon_i2c_put_byte(struct radeon_i2c_chan *i2c,
                                 u8 slave_addr,
                                 u8 addr,
                                 u8 val);
+extern void radeon_router_select_port(struct radeon_connector *radeon_connector);
 extern bool radeon_ddc_probe(struct radeon_connector *radeon_connector);
 extern int radeon_ddc_get_modes(struct radeon_connector *radeon_connector);
 
diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c
index 95f8b3a3c43..58038f5cab3 100644
--- a/drivers/gpu/drm/radeon/radeon_pm.c
+++ b/drivers/gpu/drm/radeon/radeon_pm.c
@@ -472,9 +472,9 @@ static const struct attribute_group hwmon_attrgroup = {
         .attrs = hwmon_attributes,
 };
 
-static void radeon_hwmon_init(struct radeon_device *rdev)
+static int radeon_hwmon_init(struct radeon_device *rdev)
 {
-        int err;
+        int err = 0;
 
         rdev->pm.int_hwmon_dev = NULL;
 
@@ -483,15 +483,26 @@ static void radeon_hwmon_init(struct radeon_device *rdev)
         case THERMAL_TYPE_RV770:
         case THERMAL_TYPE_EVERGREEN:
                 rdev->pm.int_hwmon_dev = hwmon_device_register(rdev->dev);
+                if (IS_ERR(rdev->pm.int_hwmon_dev)) {
+                        err = PTR_ERR(rdev->pm.int_hwmon_dev);
+                        dev_err(rdev->dev,
+                                "Unable to register hwmon device: %d\n", err);
+                        break;
+                }
                 dev_set_drvdata(rdev->pm.int_hwmon_dev, rdev->ddev);
                 err = sysfs_create_group(&rdev->pm.int_hwmon_dev->kobj,
                                          &hwmon_attrgroup);
-                if (err)
-                        DRM_ERROR("Unable to create hwmon sysfs file: %d\n", err);
+                if (err) {
+                        dev_err(rdev->dev,
+                                "Unable to create hwmon sysfs file: %d\n", err);
+                        hwmon_device_unregister(rdev->dev);
+                }
                 break;
         default:
                 break;
         }
+
+        return err;
 }
 
 static void radeon_hwmon_fini(struct radeon_device *rdev)
@@ -540,6 +551,7 @@ void radeon_pm_resume(struct radeon_device *rdev)
 int radeon_pm_init(struct radeon_device *rdev)
 {
         int ret;
+
         /* default to profile method */
         rdev->pm.pm_method = PM_METHOD_PROFILE;
         rdev->pm.profile = PM_PROFILE_DEFAULT;
@@ -561,7 +573,9 @@ int radeon_pm_init(struct radeon_device *rdev)
         }
 
         /* set up the internal thermal sensor if applicable */
-        radeon_hwmon_init(rdev);
+        ret = radeon_hwmon_init(rdev);
+        if (ret)
+                return ret;
         if (rdev->pm.num_power_states > 1) {
                 /* where's the best place to put these? */
                 ret = device_create_file(rdev->dev, &dev_attr_power_profile);
diff --git a/drivers/gpu/drm/radeon/reg_srcs/rv515 b/drivers/gpu/drm/radeon/reg_srcs/rv515
index 8293855f5f0..b3f9f1d9200 100644
--- a/drivers/gpu/drm/radeon/reg_srcs/rv515
+++ b/drivers/gpu/drm/radeon/reg_srcs/rv515
@@ -316,6 +316,7 @@ rv515 0x6d40
 0x4BD0 FG_FOG_COLOR_B
 0x4BD4 FG_ALPHA_FUNC
 0x4BD8 FG_DEPTH_SRC
+0x4BE0 FG_ALPHA_VALUE
 0x4C00 US_ALU_CONST_R_0
 0x4C04 US_ALU_CONST_G_0
 0x4C08 US_ALU_CONST_B_0
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
index 437ac786277..64d7f47df86 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c
@@ -737,7 +737,7 @@ static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
 
         if (ret) {
                 DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
-                return NULL;
+                return ERR_PTR(ret);
         }
         return &vfb->base;
 
@@ -747,7 +747,7 @@ try_dmabuf:
         ret = vmw_user_dmabuf_lookup(tfile, mode_cmd->handle, &bo);
         if (ret) {
                 DRM_ERROR("failed to find buffer: %i\n", ret);
-                return NULL;
+                return ERR_PTR(-ENOENT);
         }
 
         ret = vmw_kms_new_framebuffer_dmabuf(dev_priv, bo, &vfb,
@@ -758,7 +758,7 @@ try_dmabuf:
 
         if (ret) {
                 DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
-                return NULL;
+                return ERR_PTR(ret);
         }
 
         return &vfb->base;
@@ -768,7 +768,7 @@ err_not_scanout:
         /* vmw_user_surface_lookup takes one ref */
         vmw_surface_unreference(&surface);
 
-        return NULL;
+        return ERR_PTR(-EINVAL);
 }
 
 static struct drm_mode_config_funcs vmw_kms_funcs = {
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
index cfaf690a5b2..2ff5cf78235 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
@@ -79,7 +79,7 @@ static void vmw_ldu_crtc_restore(struct drm_crtc *crtc)
 
 static void vmw_ldu_crtc_gamma_set(struct drm_crtc *crtc,
                                    u16 *r, u16 *g, u16 *b,
-                                   uint32_t size)
+                                   uint32_t start, uint32_t size)
 {
 }
 
diff --git a/drivers/hwmon/ams/ams.h b/drivers/hwmon/ams/ams.h
index b28d7e27a03..90f094d4545 100644
--- a/drivers/hwmon/ams/ams.h
+++ b/drivers/hwmon/ams/ams.h
@@ -23,7 +23,7 @@ struct ams {
 
         /* General properties */
         struct device_node *of_node;
-        struct of_device *of_dev;
+        struct platform_device *of_dev;
         char has_device;
         char vflag;
         u32 orient1;
diff --git a/drivers/hwmon/ultra45_env.c b/drivers/hwmon/ultra45_env.c
index 89643261ccd..d863e13a50b 100644
--- a/drivers/hwmon/ultra45_env.c
+++ b/drivers/hwmon/ultra45_env.c
@@ -234,7 +234,7 @@ static const struct attribute_group env_group = {
         .attrs = env_attributes,
 };
 
-static int __devinit env_probe(struct of_device *op,
+static int __devinit env_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct env *p = kzalloc(sizeof(*p), GFP_KERNEL);
@@ -276,7 +276,7 @@ out_free:
         goto out;
 }
 
-static int __devexit env_remove(struct of_device *op)
+static int __devexit env_remove(struct platform_device *op)
 {
         struct env *p = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/i2c/busses/i2c-cpm.c b/drivers/i2c/busses/i2c-cpm.c
index e591de1bc70..f7bd2613cec 100644
--- a/drivers/i2c/busses/i2c-cpm.c
+++ b/drivers/i2c/busses/i2c-cpm.c
@@ -105,7 +105,7 @@ struct i2c_reg {
 
 struct cpm_i2c {
         char *base;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         struct i2c_adapter adap;
         uint dp_addr;
         int version; /* CPM1=1, CPM2=2 */
@@ -428,7 +428,7 @@ static const struct i2c_adapter cpm_ops = {
 
 static int __devinit cpm_i2c_setup(struct cpm_i2c *cpm)
 {
-        struct of_device *ofdev = cpm->ofdev;
+        struct platform_device *ofdev = cpm->ofdev;
         const u32 *data;
         int len, ret, i;
         void __iomem *i2c_base;
@@ -634,7 +634,7 @@ static void cpm_i2c_shutdown(struct cpm_i2c *cpm)
                 cpm_muram_free(cpm->i2c_addr);
 }
 
-static int __devinit cpm_i2c_probe(struct of_device *ofdev,
+static int __devinit cpm_i2c_probe(struct platform_device *ofdev,
                          const struct of_device_id *match)
 {
         int result, len;
@@ -687,7 +687,7 @@ out_free:
         return result;
 }
 
-static int __devexit cpm_i2c_remove(struct of_device *ofdev)
+static int __devexit cpm_i2c_remove(struct platform_device *ofdev)
 {
         struct cpm_i2c *cpm = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 1168d61418c..43ca32fddde 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -661,7 +661,7 @@ static inline u8 iic_clckdiv(unsigned int opb)
         return (u8)((opb + 9) / 10 - 1);
 }
 
-static int __devinit iic_request_irq(struct of_device *ofdev,
+static int __devinit iic_request_irq(struct platform_device *ofdev,
                                      struct ibm_iic_private *dev)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -692,7 +692,7 @@ static int __devinit iic_request_irq(struct of_device *ofdev,
 /*
  * Register single IIC interface
  */
-static int __devinit iic_probe(struct of_device *ofdev,
+static int __devinit iic_probe(struct platform_device *ofdev,
                                const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -780,7 +780,7 @@ error_cleanup:
 /*
  * Cleanup initialized IIC interface
  */
-static int __devexit iic_remove(struct of_device *ofdev)
+static int __devexit iic_remove(struct platform_device *ofdev)
 {
         struct ibm_iic_private *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index 6545d1c99b6..a1c419a716a 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
@@ -560,7 +560,7 @@ static struct i2c_adapter mpc_ops = {
         .timeout = HZ,
 };
 
-static int __devinit fsl_i2c_probe(struct of_device *op,
+static int __devinit fsl_i2c_probe(struct platform_device *op,
                                    const struct of_device_id *match)
 {
         struct mpc_i2c *i2c;
@@ -646,7 +646,7 @@ static int __devinit fsl_i2c_probe(struct of_device *op,
         return result;
 };
 
-static int __devexit fsl_i2c_remove(struct of_device *op)
+static int __devexit fsl_i2c_remove(struct platform_device *op)
 {
         struct mpc_i2c *i2c = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index 0136abd50dd..aaf6023a483 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -112,7 +112,7 @@ struct ehca_sport {
 
 struct ehca_shca {
         struct ib_device ib_device;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         u8 num_ports;
         int hw_level;
         struct list_head shca_list;
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index cfc4de7a5da..c240e9972cb 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -713,7 +713,7 @@ static struct attribute_group ehca_dev_attr_grp = {
         .attrs = ehca_dev_attrs
 };
 
-static int __devinit ehca_probe(struct of_device *dev,
+static int __devinit ehca_probe(struct platform_device *dev,
                                 const struct of_device_id *id)
 {
         struct ehca_shca *shca;
@@ -879,7 +879,7 @@ probe1:
         return -EINVAL;
 }
 
-static int __devexit ehca_remove(struct of_device *dev)
+static int __devexit ehca_remove(struct platform_device *dev)
 {
         struct ehca_shca *shca = dev_get_drvdata(&dev->dev);
         unsigned long flags;
diff --git a/drivers/input/misc/sparcspkr.c b/drivers/input/misc/sparcspkr.c
index f3bb92e9755..8e130bf7d32 100644
--- a/drivers/input/misc/sparcspkr.c
+++ b/drivers/input/misc/sparcspkr.c
@@ -173,7 +173,7 @@ static int __devinit sparcspkr_probe(struct device *dev)
         return 0;
 }
 
-static int sparcspkr_shutdown(struct of_device *dev)
+static int sparcspkr_shutdown(struct platform_device *dev)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
         struct input_dev *input_dev = state->input_dev;
@@ -184,7 +184,7 @@ static int sparcspkr_shutdown(struct of_device *dev)
         return 0;
 }
 
-static int __devinit bbc_beep_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit bbc_beep_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct sparcspkr_state *state;
         struct bbc_beep_info *info;
@@ -231,7 +231,7 @@ out_err:
         return err;
 }
 
-static int __devexit bbc_remove(struct of_device *op)
+static int __devexit bbc_remove(struct platform_device *op)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
         struct input_dev *input_dev = state->input_dev;
@@ -269,7 +269,7 @@ static struct of_platform_driver bbc_beep_driver = {
         .shutdown       = sparcspkr_shutdown,
 };
 
-static int __devinit grover_beep_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit grover_beep_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct sparcspkr_state *state;
         struct grover_beep_info *info;
@@ -312,7 +312,7 @@ out_err:
         return err;
 }
 
-static int __devexit grover_remove(struct of_device *op)
+static int __devexit grover_remove(struct platform_device *op)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
         struct grover_beep_info *info = &state->u.grover;
diff --git a/drivers/input/serio/i8042-sparcio.h b/drivers/input/serio/i8042-sparcio.h
index cb2a24b9474..c5cc4508d6d 100644
--- a/drivers/input/serio/i8042-sparcio.h
+++ b/drivers/input/serio/i8042-sparcio.h
@@ -49,7 +49,7 @@ static inline void i8042_write_command(int val)
 #define OBP_PS2MS_NAME1         "kdmouse"
 #define OBP_PS2MS_NAME2         "mouse"
 
-static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit sparc_i8042_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
 
@@ -57,7 +57,7 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
         while (dp) {
                 if (!strcmp(dp->name, OBP_PS2KBD_NAME1) ||
                     !strcmp(dp->name, OBP_PS2KBD_NAME2)) {
-                        struct of_device *kbd = of_find_device_by_node(dp);
+                        struct platform_device *kbd = of_find_device_by_node(dp);
                         unsigned int irq = kbd->archdata.irqs[0];
                         if (irq == 0xffffffff)
                                 irq = op->archdata.irqs[0];
@@ -67,7 +67,7 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
                         kbd_res = &kbd->resource[0];
                 } else if (!strcmp(dp->name, OBP_PS2MS_NAME1) ||
                            !strcmp(dp->name, OBP_PS2MS_NAME2)) {
-                        struct of_device *ms = of_find_device_by_node(dp);
+                        struct platform_device *ms = of_find_device_by_node(dp);
                         unsigned int irq = ms->archdata.irqs[0];
                         if (irq == 0xffffffff)
                                 irq = op->archdata.irqs[0];
@@ -80,7 +80,7 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
         return 0;
 }
 
-static int __devexit sparc_i8042_remove(struct of_device *op)
+static int __devexit sparc_i8042_remove(struct platform_device *op)
 {
         of_iounmap(kbd_res, kbd_iobase, 8);
 
diff --git a/drivers/input/serio/xilinx_ps2.c b/drivers/input/serio/xilinx_ps2.c
index e2c028d2638..bb14449fb02 100644
--- a/drivers/input/serio/xilinx_ps2.c
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -232,7 +232,7 @@ static void sxps2_close(struct serio *pserio)
  * It returns 0, if the driver is bound to the PS/2 device, or a negative
  * value if there is an error.
  */
-static int __devinit xps2_of_probe(struct of_device *ofdev,
+static int __devinit xps2_of_probe(struct platform_device *ofdev,
                                    const struct of_device_id *match)
 {
         struct resource r_irq; /* Interrupt resources */
@@ -332,7 +332,7 @@ failed1:
  * if the driver module is being unloaded. It frees any resources allocated to
  * the device.
  */
-static int __devexit xps2_of_remove(struct of_device *of_dev)
+static int __devexit xps2_of_remove(struct platform_device *of_dev)
 {
         struct device *dev = &of_dev->dev;
         struct xps2data *drvdata = dev_get_drvdata(dev);
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index cc22eeefa10..ea57e05d08f 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -224,7 +224,7 @@ struct gpio_led_of_platform_data {
         struct gpio_led_data led_data[];
 };
 
-static int __devinit of_gpio_leds_probe(struct of_device *ofdev,
+static int __devinit of_gpio_leds_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node, *child;
@@ -283,7 +283,7 @@ err:
         return ret;
 }
 
-static int __devexit of_gpio_leds_remove(struct of_device *ofdev)
+static int __devexit of_gpio_leds_remove(struct platform_device *ofdev)
 {
         struct gpio_led_of_platform_data *pdata = dev_get_drvdata(&ofdev->dev);
         int i;
diff --git a/drivers/macintosh/macio_sysfs.c b/drivers/macintosh/macio_sysfs.c
index 6024038a5b9..8eb40afbd0f 100644
--- a/drivers/macintosh/macio_sysfs.c
+++ b/drivers/macintosh/macio_sysfs.c
@@ -15,7 +15,7 @@ field##_show (struct device *dev, struct device_attribute *attr,	\
 static ssize_t
 compatible_show (struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct of_device *of;
+        struct platform_device *of;
         const char *compat;
         int cplen;
         int length = 0;
@@ -52,9 +52,9 @@ static ssize_t modalias_show (struct device *dev, struct device_attribute *attr,
 static ssize_t devspec_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
 
-        ofdev = to_of_device(dev);
+        ofdev = to_platform_device(dev);
         return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
 }
 
diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index 2506c957712..e58c3d33e03 100644
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -75,7 +75,7 @@ struct smu_cmd_buf {
 struct smu_device {
         spinlock_t              lock;
         struct device_node      *of_node;
-        struct of_device        *of_dev;
+        struct platform_device  *of_dev;
         int                     doorbell;       /* doorbell gpio */
         u32 __iomem             *db_buf;        /* doorbell buffer */
         struct device_node      *db_node;
@@ -645,7 +645,7 @@ static void smu_expose_childs(struct work_struct *unused)
 
 static DECLARE_WORK(smu_expose_childs_work, smu_expose_childs);
 
-static int smu_platform_probe(struct of_device* dev,
+static int smu_platform_probe(struct platform_device* dev,
                               const struct of_device_id *match)
 {
         if (!smu)
@@ -695,7 +695,7 @@ static int __init smu_init_sysfs(void)
 
 device_initcall(smu_init_sysfs);
 
-struct of_device *smu_get_ofdev(void)
+struct platform_device *smu_get_ofdev(void)
 {
         if (!smu)
                 return NULL;
diff --git a/drivers/macintosh/therm_adt746x.c b/drivers/macintosh/therm_adt746x.c
index c42eeb43042..d0d221332db 100644
--- a/drivers/macintosh/therm_adt746x.c
+++ b/drivers/macintosh/therm_adt746x.c
@@ -84,7 +84,7 @@ struct thermostat {
 
 static enum {ADT7460, ADT7467} therm_type;
 static int therm_bus, therm_address;
-static struct of_device * of_dev;
+static struct platform_device * of_dev;
 static struct thermostat* thermostat;
 static struct task_struct *thread_therm = NULL;
 
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index e60605bd0ea..44549272333 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -148,7 +148,7 @@
  * Driver statics
  */
 
-static struct of_device *               of_dev;
+static struct platform_device *         of_dev;
 static struct i2c_adapter *             u3_0;
 static struct i2c_adapter *             u3_1;
 static struct i2c_adapter *             k2;
@@ -2210,7 +2210,7 @@ static void fcu_lookup_fans(struct device_node *fcu_node)
         }
 }
 
-static int fcu_of_probe(struct of_device* dev, const struct of_device_id *match)
+static int fcu_of_probe(struct platform_device* dev, const struct of_device_id *match)
 {
         state = state_detached;
 
@@ -2221,7 +2221,7 @@ static int fcu_of_probe(struct of_device* dev, const struct of_device_id *match)
         return i2c_add_driver(&therm_pm72_driver);
 }
 
-static int fcu_of_remove(struct of_device* dev)
+static int fcu_of_remove(struct platform_device* dev)
 {
         i2c_del_driver(&therm_pm72_driver);
 
diff --git a/drivers/macintosh/therm_windtunnel.c b/drivers/macintosh/therm_windtunnel.c
index 5c9367acf0c..133f195de1f 100644
--- a/drivers/macintosh/therm_windtunnel.c
+++ b/drivers/macintosh/therm_windtunnel.c
@@ -52,7 +52,7 @@ static struct {
         struct task_struct      *poll_task;
         
         struct mutex            lock;
-        struct of_device        *of_dev;
+        struct platform_device  *of_dev;
         
         struct i2c_client       *thermostat;
         struct i2c_client       *fan;
@@ -444,13 +444,13 @@ static struct i2c_driver g4fan_driver = {
 /************************************************************************/
 
 static int
-therm_of_probe( struct of_device *dev, const struct of_device_id *match )
+therm_of_probe( struct platform_device *dev, const struct of_device_id *match )
 {
         return i2c_add_driver( &g4fan_driver );
 }
 
 static int
-therm_of_remove( struct of_device *dev )
+therm_of_remove( struct platform_device *dev )
 {
         i2c_del_driver( &g4fan_driver );
         return 0;
diff --git a/drivers/media/video/fsl-viu.c b/drivers/media/video/fsl-viu.c
index 8f1c94f7e00..43d208f1f58 100644
--- a/drivers/media/video/fsl-viu.c
+++ b/drivers/media/video/fsl-viu.c
@@ -1418,7 +1418,7 @@ static struct video_device viu_template = {
         .current_norm   = V4L2_STD_NTSC_M,
 };
 
-static int __devinit viu_of_probe(struct of_device *op,
+static int __devinit viu_of_probe(struct platform_device *op,
                                   const struct of_device_id *match)
 {
         struct viu_dev *viu_dev;
@@ -1549,7 +1549,7 @@ err:
         return ret;
 }
 
-static int __devexit viu_of_remove(struct of_device *op)
+static int __devexit viu_of_remove(struct platform_device *op)
 {
         struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
         struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
@@ -1570,7 +1570,7 @@ static int __devexit viu_of_remove(struct of_device *op)
 }
 
 #ifdef CONFIG_PM
-static int viu_suspend(struct of_device *op, pm_message_t state)
+static int viu_suspend(struct platform_device *op, pm_message_t state)
 {
         struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
         struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
@@ -1579,7 +1579,7 @@ static int viu_suspend(struct of_device *op, pm_message_t state)
         return 0;
 }
 
-static int viu_resume(struct of_device *op)
+static int viu_resume(struct platform_device *op)
 {
         struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
         struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index eef78a068fd..d3f1a087ece 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1048,6 +1048,7 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
                         snprintf(s_attr->name, sizeof(s_attr->name),
                                  "attr_x%02x", attr->entries[cnt].id);
 
+                sysfs_attr_init(&s_attr->dev_attr.attr);
                 s_attr->dev_attr.attr.name = s_attr->name;
                 s_attr->dev_attr.attr.mode = S_IRUGO;
                 s_attr->dev_attr.show = mspro_block_attr_show(s_attr->id);
@@ -1338,13 +1339,14 @@ static void mspro_block_remove(struct memstick_dev *card)
         struct mspro_block_data *msb = memstick_get_drvdata(card);
         unsigned long flags;
 
-        del_gendisk(msb->disk);
-        dev_dbg(&card->dev, "mspro block remove\n");
         spin_lock_irqsave(&msb->q_lock, flags);
         msb->eject = 1;
         blk_start_queue(msb->queue);
         spin_unlock_irqrestore(&msb->q_lock, flags);
 
+        del_gendisk(msb->disk);
+        dev_dbg(&card->dev, "mspro block remove\n");
+
         blk_cleanup_queue(msb->queue);
         msb->queue = NULL;
 
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 8433cde29c8..d545f79f600 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -247,7 +247,76 @@ static u32 get_card_status(struct mmc_card *card, struct request *req)
         return cmd.resp[0];
 }
 
-static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
+static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
+{
+        struct mmc_blk_data *md = mq->data;
+        struct mmc_card *card = md->queue.card;
+        unsigned int from, nr, arg;
+        int err = 0;
+
+        mmc_claim_host(card->host);
+
+        if (!mmc_can_erase(card)) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        from = blk_rq_pos(req);
+        nr = blk_rq_sectors(req);
+
+        if (mmc_can_trim(card))
+                arg = MMC_TRIM_ARG;
+        else
+                arg = MMC_ERASE_ARG;
+
+        err = mmc_erase(card, from, nr, arg);
+out:
+        spin_lock_irq(&md->lock);
+        __blk_end_request(req, err, blk_rq_bytes(req));
+        spin_unlock_irq(&md->lock);
+
+        mmc_release_host(card->host);
+
+        return err ? 0 : 1;
+}
+
+static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
+                                       struct request *req)
+{
+        struct mmc_blk_data *md = mq->data;
+        struct mmc_card *card = md->queue.card;
+        unsigned int from, nr, arg;
+        int err = 0;
+
+        mmc_claim_host(card->host);
+
+        if (!mmc_can_secure_erase_trim(card)) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        from = blk_rq_pos(req);
+        nr = blk_rq_sectors(req);
+
+        if (mmc_can_trim(card) && !mmc_erase_group_aligned(card, from, nr))
+                arg = MMC_SECURE_TRIM1_ARG;
+        else
+                arg = MMC_SECURE_ERASE_ARG;
+
+        err = mmc_erase(card, from, nr, arg);
+        if (!err && arg == MMC_SECURE_TRIM1_ARG)
+                err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG);
+out:
+        spin_lock_irq(&md->lock);
+        __blk_end_request(req, err, blk_rq_bytes(req));
+        spin_unlock_irq(&md->lock);
+
+        mmc_release_host(card->host);
+
+        return err ? 0 : 1;
+}
+
+static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *req)
 {
         struct mmc_blk_data *md = mq->data;
         struct mmc_card *card = md->queue.card;
@@ -475,6 +544,17 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
         return 0;
 }
 
+static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
+{
+        if (req->cmd_flags & REQ_DISCARD) {
+                if (req->cmd_flags & REQ_SECURE)
+                        return mmc_blk_issue_secdiscard_rq(mq, req);
+                else
+                        return mmc_blk_issue_discard_rq(mq, req);
+        } else {
+                return mmc_blk_issue_rw_rq(mq, req);
+        }
+}
 
 static inline int mmc_blk_readonly(struct mmc_card *card)
 {
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 445d7db2277..5dd8576b5c1 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 
 #include <linux/scatterlist.h>
+#include <linux/swap.h>         /* For nr_free_buffer_pages() */
 
 #define RESULT_OK               0
 #define RESULT_FAIL             1
@@ -25,6 +26,60 @@
 #define BUFFER_ORDER            2
 #define BUFFER_SIZE             (PAGE_SIZE << BUFFER_ORDER)
 
+/*
+ * Limit the test area size to the maximum MMC HC erase group size.  Note that
+ * the maximum SD allocation unit size is just 4MiB.
+ */
+#define TEST_AREA_MAX_SIZE (128 * 1024 * 1024)
+
+/**
+ * struct mmc_test_pages - pages allocated by 'alloc_pages()'.
+ * @page: first page in the allocation
+ * @order: order of the number of pages allocated
+ */
+struct mmc_test_pages {
+        struct page *page;
+        unsigned int order;
+};
+
+/**
+ * struct mmc_test_mem - allocated memory.
+ * @arr: array of allocations
+ * @cnt: number of allocations
+ */
+struct mmc_test_mem {
+        struct mmc_test_pages *arr;
+        unsigned int cnt;
+};
+
+/**
+ * struct mmc_test_area - information for performance tests.
+ * @max_sz: test area size (in bytes)
+ * @dev_addr: address on card at which to do performance tests
+ * @max_segs: maximum segments in scatterlist @sg
+ * @blocks: number of (512 byte) blocks currently mapped by @sg
+ * @sg_len: length of currently mapped scatterlist @sg
+ * @mem: allocated memory
+ * @sg: scatterlist
+ */
+struct mmc_test_area {
+        unsigned long max_sz;
+        unsigned int dev_addr;
+        unsigned int max_segs;
+        unsigned int blocks;
+        unsigned int sg_len;
+        struct mmc_test_mem *mem;
+        struct scatterlist *sg;
+};
+
+/**
+ * struct mmc_test_card - test information.
+ * @card: card under test
+ * @scratch: transfer buffer
+ * @buffer: transfer buffer
+ * @highmem: buffer for highmem tests
+ * @area: information for performance tests
+ */
 struct mmc_test_card {
         struct mmc_card *card;
 
@@ -33,6 +88,7 @@ struct mmc_test_card {
 #ifdef CONFIG_HIGHMEM
         struct page     *highmem;
 #endif
+        struct mmc_test_area area;
 };
 
 /*******************************************************************/
@@ -97,6 +153,12 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test,
         mmc_set_data_timeout(mrq->data, test->card);
 }
 
+static int mmc_test_busy(struct mmc_command *cmd)
+{
+        return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
+                (R1_CURRENT_STATE(cmd->resp[0]) == 7);
+}
+
 /*
  * Wait for the card to finish the busy state
  */
@@ -117,13 +179,13 @@ static int mmc_test_wait_busy(struct mmc_test_card *test)
                 if (ret)
                         break;
 
-                if (!busy && !(cmd.resp[0] & R1_READY_FOR_DATA)) {
+                if (!busy && mmc_test_busy(&cmd)) {
                         busy = 1;
                         printk(KERN_INFO "%s: Warning: Host did not "
                                 "wait for busy state to end.\n",
                                 mmc_hostname(test->card->host));
                 }
-        } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
+        } while (mmc_test_busy(&cmd));
 
         return ret;
 }
@@ -170,6 +232,248 @@ static int mmc_test_buffer_transfer(struct mmc_test_card *test,
         return 0;
 }
 
+static void mmc_test_free_mem(struct mmc_test_mem *mem)
+{
+        if (!mem)
+                return;
+        while (mem->cnt--)
+                __free_pages(mem->arr[mem->cnt].page,
+                             mem->arr[mem->cnt].order);
+        kfree(mem->arr);
+        kfree(mem);
+}
+
+/*
+ * Allocate a lot of memory, preferrably max_sz but at least min_sz.  In case
+ * there isn't much memory do not exceed 1/16th total lowmem pages.
+ */
+static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
+                                               unsigned long max_sz)
+{
+        unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);
+        unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);
+        unsigned long page_cnt = 0;
+        unsigned long limit = nr_free_buffer_pages() >> 4;
+        struct mmc_test_mem *mem;
+
+        if (max_page_cnt > limit)
+                max_page_cnt = limit;
+        if (max_page_cnt < min_page_cnt)
+                max_page_cnt = min_page_cnt;
+
+        mem = kzalloc(sizeof(struct mmc_test_mem), GFP_KERNEL);
+        if (!mem)
+                return NULL;
+
+        mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_page_cnt,
+                           GFP_KERNEL);
+        if (!mem->arr)
+                goto out_free;
+
+        while (max_page_cnt) {
+                struct page *page;
+                unsigned int order;
+                gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN |
+                                __GFP_NORETRY;
+
+                order = get_order(max_page_cnt << PAGE_SHIFT);
+                while (1) {
+                        page = alloc_pages(flags, order);
+                        if (page || !order)
+                                break;
+                        order -= 1;
+                }
+                if (!page) {
+                        if (page_cnt < min_page_cnt)
+                                goto out_free;
+                        break;
+                }
+                mem->arr[mem->cnt].page = page;
+                mem->arr[mem->cnt].order = order;
+                mem->cnt += 1;
+                if (max_page_cnt <= (1UL << order))
+                        break;
+                max_page_cnt -= 1UL << order;
+                page_cnt += 1UL << order;
+        }
+
+        return mem;
+
+out_free:
+        mmc_test_free_mem(mem);
+        return NULL;
+}
+
+/*
+ * Map memory into a scatterlist.  Optionally allow the same memory to be
+ * mapped more than once.
+ */
+static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long sz,
+                           struct scatterlist *sglist, int repeat,
+                           unsigned int max_segs, unsigned int *sg_len)
+{
+        struct scatterlist *sg = NULL;
+        unsigned int i;
+
+        sg_init_table(sglist, max_segs);
+
+        *sg_len = 0;
+        do {
+                for (i = 0; i < mem->cnt; i++) {
+                        unsigned long len = PAGE_SIZE << mem->arr[i].order;
+
+                        if (sz < len)
+                                len = sz;
+                        if (sg)
+                                sg = sg_next(sg);
+                        else
+                                sg = sglist;
+                        if (!sg)
+                                return -EINVAL;
+                        sg_set_page(sg, mem->arr[i].page, len, 0);
+                        sz -= len;
+                        *sg_len += 1;
+                        if (!sz)
+                                break;
+                }
+        } while (sz && repeat);
+
+        if (sz)
+                return -EINVAL;
+
+        if (sg)
+                sg_mark_end(sg);
+
+        return 0;
+}
+
+/*
+ * Map memory into a scatterlist so that no pages are contiguous.  Allow the
+ * same memory to be mapped more than once.
+ */
+static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
+                                       unsigned long sz,
+                                       struct scatterlist *sglist,
+                                       unsigned int max_segs,
+                                       unsigned int *sg_len)
+{
+        struct scatterlist *sg = NULL;
+        unsigned int i = mem->cnt, cnt;
+        unsigned long len;
+        void *base, *addr, *last_addr = NULL;
+
+        sg_init_table(sglist, max_segs);
+
+        *sg_len = 0;
+        while (sz && i) {
+                base = page_address(mem->arr[--i].page);
+                cnt = 1 << mem->arr[i].order;
+                while (sz && cnt) {
+                        addr = base + PAGE_SIZE * --cnt;
+                        if (last_addr && last_addr + PAGE_SIZE == addr)
+                                continue;
+                        last_addr = addr;
+                        len = PAGE_SIZE;
+                        if (sz < len)
+                                len = sz;
+                        if (sg)
+                                sg = sg_next(sg);
+                        else
+                                sg = sglist;
+                        if (!sg)
+                                return -EINVAL;
+                        sg_set_page(sg, virt_to_page(addr), len, 0);
+                        sz -= len;
+                        *sg_len += 1;
+                }
+        }
+
+        if (sg)
+                sg_mark_end(sg);
+
+        return 0;
+}
+
+/*
+ * Calculate transfer rate in bytes per second.
+ */
+static unsigned int mmc_test_rate(uint64_t bytes, struct timespec *ts)
+{
+        uint64_t ns;
+
+        ns = ts->tv_sec;
+        ns *= 1000000000;
+        ns += ts->tv_nsec;
+
+        bytes *= 1000000000;
+
+        while (ns > UINT_MAX) {
+                bytes >>= 1;
+                ns >>= 1;
+        }
+
+        if (!ns)
+                return 0;
+
+        do_div(bytes, (uint32_t)ns);
+
+        return bytes;
+}
+
+/*
+ * Print the transfer rate.
+ */
+static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
+                                struct timespec *ts1, struct timespec *ts2)
+{
+        unsigned int rate, sectors = bytes >> 9;
+        struct timespec ts;
+
+        ts = timespec_sub(*ts2, *ts1);
+
+        rate = mmc_test_rate(bytes, &ts);
+
+        printk(KERN_INFO "%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
+                         "seconds (%u kB/s, %u KiB/s)\n",
+                         mmc_hostname(test->card->host), sectors, sectors >> 1,
+                         (sectors == 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
+                         (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024);
+}
+
+/*
+ * Print the average transfer rate.
+ */
+static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
+                                    unsigned int count, struct timespec *ts1,
+                                    struct timespec *ts2)
+{
+        unsigned int rate, sectors = bytes >> 9;
+        uint64_t tot = bytes * count;
+        struct timespec ts;
+
+        ts = timespec_sub(*ts2, *ts1);
+
+        rate = mmc_test_rate(tot, &ts);
+
+        printk(KERN_INFO "%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
+                         "%lu.%09lu seconds (%u kB/s, %u KiB/s)\n",
+                         mmc_hostname(test->card->host), count, sectors, count,
+                         sectors >> 1, (sectors == 1 ? ".5" : ""),
+                         (unsigned long)ts.tv_sec, (unsigned long)ts.tv_nsec,
+                         rate / 1000, rate / 1024);
+}
+
+/*
+ * Return the card size in sectors.
+ */
+static unsigned int mmc_test_capacity(struct mmc_card *card)
+{
+        if (!mmc_card_sd(card) && mmc_card_blockaddr(card))
+                return card->ext_csd.sectors;
+        else
+                return card->csd.capacity << (card->csd.read_blkbits - 9);
+}
+
 /*******************************************************************/
 /*  Test preparation and cleanup                                   */
 /*******************************************************************/
@@ -893,8 +1197,419 @@ static int mmc_test_multi_read_high(struct mmc_test_card *test)
         return 0;
 }
 
+#else
+
+static int mmc_test_no_highmem(struct mmc_test_card *test)
+{
+        printk(KERN_INFO "%s: Highmem not configured - test skipped\n",
+               mmc_hostname(test->card->host));
+        return 0;
+}
+
 #endif /* CONFIG_HIGHMEM */
 
+/*
+ * Map sz bytes so that it can be transferred.
+ */
+static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
+                             int max_scatter)
+{
+        struct mmc_test_area *t = &test->area;
+
+        t->blocks = sz >> 9;
+
+        if (max_scatter) {
+                return mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
+                                                   t->max_segs, &t->sg_len);
+        } else {
+                return mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
+                                       &t->sg_len);
+        }
+}
+
+/*
+ * Transfer bytes mapped by mmc_test_area_map().
+ */
+static int mmc_test_area_transfer(struct mmc_test_card *test,
+                                  unsigned int dev_addr, int write)
+{
+        struct mmc_test_area *t = &test->area;
+
+        return mmc_test_simple_transfer(test, t->sg, t->sg_len, dev_addr,
+                                        t->blocks, 512, write);
+}
+
+/*
+ * Map and transfer bytes.
+ */
+static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
+                            unsigned int dev_addr, int write, int max_scatter,
+                            int timed)
+{
+        struct timespec ts1, ts2;
+        int ret;
+
+        ret = mmc_test_area_map(test, sz, max_scatter);
+        if (ret)
+                return ret;
+
+        if (timed)
+                getnstimeofday(&ts1);
+
+        ret = mmc_test_area_transfer(test, dev_addr, write);
+        if (ret)
+                return ret;
+
+        if (timed)
+                getnstimeofday(&ts2);
+
+        if (timed)
+                mmc_test_print_rate(test, sz, &ts1, &ts2);
+
+        return 0;
+}
+
+/*
+ * Write the test area entirely.
+ */
+static int mmc_test_area_fill(struct mmc_test_card *test)
+{
+        return mmc_test_area_io(test, test->area.max_sz, test->area.dev_addr,
+                                1, 0, 0);
+}
+
+/*
+ * Erase the test area entirely.
+ */
+static int mmc_test_area_erase(struct mmc_test_card *test)
+{
+        struct mmc_test_area *t = &test->area;
+
+        if (!mmc_can_erase(test->card))
+                return 0;
+
+        return mmc_erase(test->card, t->dev_addr, test->area.max_sz >> 9,
+                         MMC_ERASE_ARG);
+}
+
+/*
+ * Cleanup struct mmc_test_area.
+ */
+static int mmc_test_area_cleanup(struct mmc_test_card *test)
+{
+        struct mmc_test_area *t = &test->area;
+
+        kfree(t->sg);
+        mmc_test_free_mem(t->mem);
+
+        return 0;
+}
+
+/*
+ * Initialize an area for testing large transfers.  The size of the area is the
+ * preferred erase size which is a good size for optimal transfer speed.  Note
+ * that is typically 4MiB for modern cards.  The test area is set to the middle
+ * of the card because cards may have different charateristics at the front
+ * (for FAT file system optimization).  Optionally, the area is erased (if the
+ * card supports it) which may improve write performance.  Optionally, the area
+ * is filled with data for subsequent read tests.
+ */
+static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
+{
+        struct mmc_test_area *t = &test->area;
+        unsigned long min_sz = 64 * 1024;
+        int ret;
+
+        ret = mmc_test_set_blksize(test, 512);
+        if (ret)
+                return ret;
+
+        if (test->card->pref_erase > TEST_AREA_MAX_SIZE >> 9)
+                t->max_sz = TEST_AREA_MAX_SIZE;
+        else
+                t->max_sz = (unsigned long)test->card->pref_erase << 9;
+        /*
+         * Try to allocate enough memory for the whole area.  Less is OK
+         * because the same memory can be mapped into the scatterlist more than
+         * once.
+         */
+        t->mem = mmc_test_alloc_mem(min_sz, t->max_sz);
+        if (!t->mem)
+                return -ENOMEM;
+
+        t->max_segs = DIV_ROUND_UP(t->max_sz, PAGE_SIZE);
+        t->sg = kmalloc(sizeof(struct scatterlist) * t->max_segs, GFP_KERNEL);
+        if (!t->sg) {
+                ret = -ENOMEM;
+                goto out_free;
+        }
+
+        t->dev_addr = mmc_test_capacity(test->card) / 2;
+        t->dev_addr -= t->dev_addr % (t->max_sz >> 9);
+
+        if (erase) {
+                ret = mmc_test_area_erase(test);
+                if (ret)
+                        goto out_free;
+        }
+
+        if (fill) {
+                ret = mmc_test_area_fill(test);
+                if (ret)
+                        goto out_free;
+        }
+
+        return 0;
+
+out_free:
+        mmc_test_area_cleanup(test);
+        return ret;
+}
+
+/*
+ * Prepare for large transfers.  Do not erase the test area.
+ */
+static int mmc_test_area_prepare(struct mmc_test_card *test)
+{
+        return mmc_test_area_init(test, 0, 0);
+}
+
+/*
+ * Prepare for large transfers.  Do erase the test area.
+ */
+static int mmc_test_area_prepare_erase(struct mmc_test_card *test)
+{
+        return mmc_test_area_init(test, 1, 0);
+}
+
+/*
+ * Prepare for large transfers.  Erase and fill the test area.
+ */
+static int mmc_test_area_prepare_fill(struct mmc_test_card *test)
+{
+        return mmc_test_area_init(test, 1, 1);
+}
+
+/*
+ * Test best-case performance.  Best-case performance is expected from
+ * a single large transfer.
+ *
+ * An additional option (max_scatter) allows the measurement of the same
+ * transfer but with no contiguous pages in the scatter list.  This tests
+ * the efficiency of DMA to handle scattered pages.
+ */
+static int mmc_test_best_performance(struct mmc_test_card *test, int write,
+                                     int max_scatter)
+{
+        return mmc_test_area_io(test, test->area.max_sz, test->area.dev_addr,
+                                write, max_scatter, 1);
+}
+
+/*
+ * Best-case read performance.
+ */
+static int mmc_test_best_read_performance(struct mmc_test_card *test)
+{
+        return mmc_test_best_performance(test, 0, 0);
+}
+
+/*
+ * Best-case write performance.
+ */
+static int mmc_test_best_write_performance(struct mmc_test_card *test)
+{
+        return mmc_test_best_performance(test, 1, 0);
+}
+
+/*
+ * Best-case read performance into scattered pages.
+ */
+static int mmc_test_best_read_perf_max_scatter(struct mmc_test_card *test)
+{
+        return mmc_test_best_performance(test, 0, 1);
+}
+
+/*
+ * Best-case write performance from scattered pages.
+ */
+static int mmc_test_best_write_perf_max_scatter(struct mmc_test_card *test)
+{
+        return mmc_test_best_performance(test, 1, 1);
+}
+
+/*
+ * Single read performance by transfer size.
+ */
+static int mmc_test_profile_read_perf(struct mmc_test_card *test)
+{
+        unsigned long sz;
+        unsigned int dev_addr;
+        int ret;
+
+        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
+                dev_addr = test->area.dev_addr + (sz >> 9);
+                ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
+                if (ret)
+                        return ret;
+        }
+        dev_addr = test->area.dev_addr;
+        return mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
+}
+
+/*
+ * Single write performance by transfer size.
+ */
+static int mmc_test_profile_write_perf(struct mmc_test_card *test)
+{
+        unsigned long sz;
+        unsigned int dev_addr;
+        int ret;
+
+        ret = mmc_test_area_erase(test);
+        if (ret)
+                return ret;
+        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
+                dev_addr = test->area.dev_addr + (sz >> 9);
+                ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
+                if (ret)
+                        return ret;
+        }
+        ret = mmc_test_area_erase(test);
+        if (ret)
+                return ret;
+        dev_addr = test->area.dev_addr;
+        return mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
+}
+
+/*
+ * Single trim performance by transfer size.
+ */
+static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
+{
+        unsigned long sz;
+        unsigned int dev_addr;
+        struct timespec ts1, ts2;
+        int ret;
+
+        if (!mmc_can_trim(test->card))
+                return RESULT_UNSUP_CARD;
+
+        if (!mmc_can_erase(test->card))
+                return RESULT_UNSUP_HOST;
+
+        for (sz = 512; sz < test->area.max_sz; sz <<= 1) {
+                dev_addr = test->area.dev_addr + (sz >> 9);
+                getnstimeofday(&ts1);
+                ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
+                if (ret)
+                        return ret;
+                getnstimeofday(&ts2);
+                mmc_test_print_rate(test, sz, &ts1, &ts2);
+        }
+        dev_addr = test->area.dev_addr;
+        getnstimeofday(&ts1);
+        ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
+        if (ret)
+                return ret;
+        getnstimeofday(&ts2);
+        mmc_test_print_rate(test, sz, &ts1, &ts2);
+        return 0;
+}
+
+/*
+ * Consecutive read performance by transfer size.
+ */
+static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
+{
+        unsigned long sz;
+        unsigned int dev_addr, i, cnt;
+        struct timespec ts1, ts2;
+        int ret;
+
+        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
+                cnt = test->area.max_sz / sz;
+                dev_addr = test->area.dev_addr;
+                getnstimeofday(&ts1);
+                for (i = 0; i < cnt; i++) {
+                        ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
+                        if (ret)
+                                return ret;
+                        dev_addr += (sz >> 9);
+                }
+                getnstimeofday(&ts2);
+                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        }
+        return 0;
+}
+
+/*
+ * Consecutive write performance by transfer size.
+ */
+static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
+{
+        unsigned long sz;
+        unsigned int dev_addr, i, cnt;
+        struct timespec ts1, ts2;
+        int ret;
+
+        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
+                ret = mmc_test_area_erase(test);
+                if (ret)
+                        return ret;
+                cnt = test->area.max_sz / sz;
+                dev_addr = test->area.dev_addr;
+                getnstimeofday(&ts1);
+                for (i = 0; i < cnt; i++) {
+                        ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
+                        if (ret)
+                                return ret;
+                        dev_addr += (sz >> 9);
+                }
+                getnstimeofday(&ts2);
+                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        }
+        return 0;
+}
+
+/*
+ * Consecutive trim performance by transfer size.
+ */
+static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
+{
+        unsigned long sz;
+        unsigned int dev_addr, i, cnt;
+        struct timespec ts1, ts2;
+        int ret;
+
+        if (!mmc_can_trim(test->card))
+                return RESULT_UNSUP_CARD;
+
+        if (!mmc_can_erase(test->card))
+                return RESULT_UNSUP_HOST;
+
+        for (sz = 512; sz <= test->area.max_sz; sz <<= 1) {
+                ret = mmc_test_area_erase(test);
+                if (ret)
+                        return ret;
+                ret = mmc_test_area_fill(test);
+                if (ret)
+                        return ret;
+                cnt = test->area.max_sz / sz;
+                dev_addr = test->area.dev_addr;
+                getnstimeofday(&ts1);
+                for (i = 0; i < cnt; i++) {
+                        ret = mmc_erase(test->card, dev_addr, sz >> 9,
+                                        MMC_TRIM_ARG);
+                        if (ret)
+                                return ret;
+                        dev_addr += (sz >> 9);
+                }
+                getnstimeofday(&ts2);
+                mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
+        }
+        return 0;
+}
+
 static const struct mmc_test_case mmc_test_cases[] = {
         {
                 .name = "Basic write (no data verification)",
@@ -1040,8 +1755,100 @@ static const struct mmc_test_case mmc_test_cases[] = {
                 .cleanup = mmc_test_cleanup,
         },
 
+#else
+
+        {
+                .name = "Highmem write",
+                .run = mmc_test_no_highmem,
+        },
+
+        {
+                .name = "Highmem read",
+                .run = mmc_test_no_highmem,
+        },
+
+        {
+                .name = "Multi-block highmem write",
+                .run = mmc_test_no_highmem,
+        },
+
+        {
+                .name = "Multi-block highmem read",
+                .run = mmc_test_no_highmem,
+        },
+
 #endif /* CONFIG_HIGHMEM */
 
+        {
+                .name = "Best-case read performance",
+                .prepare = mmc_test_area_prepare_fill,
+                .run = mmc_test_best_read_performance,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Best-case write performance",
+                .prepare = mmc_test_area_prepare_erase,
+                .run = mmc_test_best_write_performance,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Best-case read performance into scattered pages",
+                .prepare = mmc_test_area_prepare_fill,
+                .run = mmc_test_best_read_perf_max_scatter,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Best-case write performance from scattered pages",
+                .prepare = mmc_test_area_prepare_erase,
+                .run = mmc_test_best_write_perf_max_scatter,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Single read performance by transfer size",
+                .prepare = mmc_test_area_prepare_fill,
+                .run = mmc_test_profile_read_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Single write performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_write_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Single trim performance by transfer size",
+                .prepare = mmc_test_area_prepare_fill,
+                .run = mmc_test_profile_trim_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Consecutive read performance by transfer size",
+                .prepare = mmc_test_area_prepare_fill,
+                .run = mmc_test_profile_seq_read_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Consecutive write performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_seq_write_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
+        {
+                .name = "Consecutive trim performance by transfer size",
+                .prepare = mmc_test_area_prepare,
+                .run = mmc_test_profile_seq_trim_perf,
+                .cleanup = mmc_test_area_cleanup,
+        },
+
 };
 
 static DEFINE_MUTEX(mmc_test_lock);
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index c77eb49eda0..e876678176b 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -30,9 +30,9 @@
 static int mmc_prep_request(struct request_queue *q, struct request *req)
 {
         /*
-         * We only like normal block requests.
+         * We only like normal block requests and discards.
          */
-        if (req->cmd_type != REQ_TYPE_FS) {
+        if (req->cmd_type != REQ_TYPE_FS && !(req->cmd_flags & REQ_DISCARD)) {
                 blk_dump_rq_flags(req, "MMC bad request");
                 return BLKPREP_KILL;
         }
@@ -130,6 +130,21 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         blk_queue_ordered(mq->queue, QUEUE_ORDERED_DRAIN);
         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
+        if (mmc_can_erase(card)) {
+                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mq->queue);
+                mq->queue->limits.max_discard_sectors = UINT_MAX;
+                if (card->erased_byte == 0)
+                        mq->queue->limits.discard_zeroes_data = 1;
+                if (!mmc_can_trim(card) && is_power_of_2(card->erase_size)) {
+                        mq->queue->limits.discard_granularity =
+                                                        card->erase_size << 9;
+                        mq->queue->limits.discard_alignment =
+                                                        card->erase_size << 9;
+                }
+                if (mmc_can_secure_erase_trim(card))
+                        queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD,
+                                                mq->queue);
+        }
 
 #ifdef CONFIG_MMC_BLOCK_BOUNCE
         if (host->max_hw_segs == 1) {
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 83240faa1dc..5db49b124ff 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -1050,6 +1050,352 @@ void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 
 EXPORT_SYMBOL(mmc_detect_change);
 
+void mmc_init_erase(struct mmc_card *card)
+{
+        unsigned int sz;
+
+        if (is_power_of_2(card->erase_size))
+                card->erase_shift = ffs(card->erase_size) - 1;
+        else
+                card->erase_shift = 0;
+
+        /*
+         * It is possible to erase an arbitrarily large area of an SD or MMC
+         * card.  That is not desirable because it can take a long time
+         * (minutes) potentially delaying more important I/O, and also the
+         * timeout calculations become increasingly hugely over-estimated.
+         * Consequently, 'pref_erase' is defined as a guide to limit erases
+         * to that size and alignment.
+         *
+         * For SD cards that define Allocation Unit size, limit erases to one
+         * Allocation Unit at a time.  For MMC cards that define High Capacity
+         * Erase Size, whether it is switched on or not, limit to that size.
+         * Otherwise just have a stab at a good value.  For modern cards it
+         * will end up being 4MiB.  Note that if the value is too small, it
+         * can end up taking longer to erase.
+         */
+        if (mmc_card_sd(card) && card->ssr.au) {
+                card->pref_erase = card->ssr.au;
+                card->erase_shift = ffs(card->ssr.au) - 1;
+        } else if (card->ext_csd.hc_erase_size) {
+                card->pref_erase = card->ext_csd.hc_erase_size;
+        } else {
+                sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;
+                if (sz < 128)
+                        card->pref_erase = 512 * 1024 / 512;
+                else if (sz < 512)
+                        card->pref_erase = 1024 * 1024 / 512;
+                else if (sz < 1024)
+                        card->pref_erase = 2 * 1024 * 1024 / 512;
+                else
+                        card->pref_erase = 4 * 1024 * 1024 / 512;
+                if (card->pref_erase < card->erase_size)
+                        card->pref_erase = card->erase_size;
+                else {
+                        sz = card->pref_erase % card->erase_size;
+                        if (sz)
+                                card->pref_erase += card->erase_size - sz;
+                }
+        }
+}
+
+static void mmc_set_mmc_erase_timeout(struct mmc_card *card,
+                                      struct mmc_command *cmd,
+                                      unsigned int arg, unsigned int qty)
+{
+        unsigned int erase_timeout;
+
+        if (card->ext_csd.erase_group_def & 1) {
+                /* High Capacity Erase Group Size uses HC timeouts */
+                if (arg == MMC_TRIM_ARG)
+                        erase_timeout = card->ext_csd.trim_timeout;
+                else
+                        erase_timeout = card->ext_csd.hc_erase_timeout;
+        } else {
+                /* CSD Erase Group Size uses write timeout */
+                unsigned int mult = (10 << card->csd.r2w_factor);
+                unsigned int timeout_clks = card->csd.tacc_clks * mult;
+                unsigned int timeout_us;
+
+                /* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */
+                if (card->csd.tacc_ns < 1000000)
+                        timeout_us = (card->csd.tacc_ns * mult) / 1000;
+                else
+                        timeout_us = (card->csd.tacc_ns / 1000) * mult;
+
+                /*
+                 * ios.clock is only a target.  The real clock rate might be
+                 * less but not that much less, so fudge it by multiplying by 2.
+                 */
+                timeout_clks <<= 1;
+                timeout_us += (timeout_clks * 1000) /
+                              (card->host->ios.clock / 1000);
+
+                erase_timeout = timeout_us / 1000;
+
+                /*
+                 * Theoretically, the calculation could underflow so round up
+                 * to 1ms in that case.
+                 */
+                if (!erase_timeout)
+                        erase_timeout = 1;
+        }
+
+        /* Multiplier for secure operations */
+        if (arg & MMC_SECURE_ARGS) {
+                if (arg == MMC_SECURE_ERASE_ARG)
+                        erase_timeout *= card->ext_csd.sec_erase_mult;
+                else
+                        erase_timeout *= card->ext_csd.sec_trim_mult;
+        }
+
+        erase_timeout *= qty;
+
+        /*
+         * Ensure at least a 1 second timeout for SPI as per
+         * 'mmc_set_data_timeout()'
+         */
+        if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
+                erase_timeout = 1000;
+
+        cmd->erase_timeout = erase_timeout;
+}
+
+static void mmc_set_sd_erase_timeout(struct mmc_card *card,
+                                     struct mmc_command *cmd, unsigned int arg,
+                                     unsigned int qty)
+{
+        if (card->ssr.erase_timeout) {
+                /* Erase timeout specified in SD Status Register (SSR) */
+                cmd->erase_timeout = card->ssr.erase_timeout * qty +
+                                     card->ssr.erase_offset;
+        } else {
+                /*
+                 * Erase timeout not specified in SD Status Register (SSR) so
+                 * use 250ms per write block.
+                 */
+                cmd->erase_timeout = 250 * qty;
+        }
+
+        /* Must not be less than 1 second */
+        if (cmd->erase_timeout < 1000)
+                cmd->erase_timeout = 1000;
+}
+
+static void mmc_set_erase_timeout(struct mmc_card *card,
+                                  struct mmc_command *cmd, unsigned int arg,
+                                  unsigned int qty)
+{
+        if (mmc_card_sd(card))
+                mmc_set_sd_erase_timeout(card, cmd, arg, qty);
+        else
+                mmc_set_mmc_erase_timeout(card, cmd, arg, qty);
+}
+
+static int mmc_do_erase(struct mmc_card *card, unsigned int from,
+                        unsigned int to, unsigned int arg)
+{
+        struct mmc_command cmd;
+        unsigned int qty = 0;
+        int err;
+
+        /*
+         * qty is used to calculate the erase timeout which depends on how many
+         * erase groups (or allocation units in SD terminology) are affected.
+         * We count erasing part of an erase group as one erase group.
+         * For SD, the allocation units are always a power of 2.  For MMC, the
+         * erase group size is almost certainly also power of 2, but it does not
+         * seem to insist on that in the JEDEC standard, so we fall back to
+         * division in that case.  SD may not specify an allocation unit size,
+         * in which case the timeout is based on the number of write blocks.
+         *
+         * Note that the timeout for secure trim 2 will only be correct if the
+         * number of erase groups specified is the same as the total of all
+         * preceding secure trim 1 commands.  Since the power may have been
+         * lost since the secure trim 1 commands occurred, it is generally
+         * impossible to calculate the secure trim 2 timeout correctly.
+         */
+        if (card->erase_shift)
+                qty += ((to >> card->erase_shift) -
+                        (from >> card->erase_shift)) + 1;
+        else if (mmc_card_sd(card))
+                qty += to - from + 1;
+        else
+                qty += ((to / card->erase_size) -
+                        (from / card->erase_size)) + 1;
+
+        if (!mmc_card_blockaddr(card)) {
+                from <<= 9;
+                to <<= 9;
+        }
+
+        memset(&cmd, 0, sizeof(struct mmc_command));
+        if (mmc_card_sd(card))
+                cmd.opcode = SD_ERASE_WR_BLK_START;
+        else
+                cmd.opcode = MMC_ERASE_GROUP_START;
+        cmd.arg = from;
+        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
+        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        if (err) {
+                printk(KERN_ERR "mmc_erase: group start error %d, "
+                       "status %#x\n", err, cmd.resp[0]);
+                err = -EINVAL;
+                goto out;
+        }
+
+        memset(&cmd, 0, sizeof(struct mmc_command));
+        if (mmc_card_sd(card))
+                cmd.opcode = SD_ERASE_WR_BLK_END;
+        else
+                cmd.opcode = MMC_ERASE_GROUP_END;
+        cmd.arg = to;
+        cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
+        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        if (err) {
+                printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n",
+                       err, cmd.resp[0]);
+                err = -EINVAL;
+                goto out;
+        }
+
+        memset(&cmd, 0, sizeof(struct mmc_command));
+        cmd.opcode = MMC_ERASE;
+        cmd.arg = arg;
+        cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        mmc_set_erase_timeout(card, &cmd, arg, qty);
+        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        if (err) {
+                printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
+                       err, cmd.resp[0]);
+                err = -EIO;
+                goto out;
+        }
+
+        if (mmc_host_is_spi(card->host))
+                goto out;
+
+        do {
+                memset(&cmd, 0, sizeof(struct mmc_command));
+                cmd.opcode = MMC_SEND_STATUS;
+                cmd.arg = card->rca << 16;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+                /* Do not retry else we can't see errors */
+                err = mmc_wait_for_cmd(card->host, &cmd, 0);
+                if (err || (cmd.resp[0] & 0xFDF92000)) {
+                        printk(KERN_ERR "error %d requesting status %#x\n",
+                                err, cmd.resp[0]);
+                        err = -EIO;
+                        goto out;
+                }
+        } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
+                 R1_CURRENT_STATE(cmd.resp[0]) == 7);
+out:
+        return err;
+}
+
+/**
+ * mmc_erase - erase sectors.
+ * @card: card to erase
+ * @from: first sector to erase
+ * @nr: number of sectors to erase
+ * @arg: erase command argument (SD supports only %MMC_ERASE_ARG)
+ *
+ * Caller must claim host before calling this function.
+ */
+int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
+              unsigned int arg)
+{
+        unsigned int rem, to = from + nr;
+
+        if (!(card->host->caps & MMC_CAP_ERASE) ||
+            !(card->csd.cmdclass & CCC_ERASE))
+                return -EOPNOTSUPP;
+
+        if (!card->erase_size)
+                return -EOPNOTSUPP;
+
+        if (mmc_card_sd(card) && arg != MMC_ERASE_ARG)
+                return -EOPNOTSUPP;
+
+        if ((arg & MMC_SECURE_ARGS) &&
+            !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))
+                return -EOPNOTSUPP;
+
+        if ((arg & MMC_TRIM_ARGS) &&
+            !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))
+                return -EOPNOTSUPP;
+
+        if (arg == MMC_SECURE_ERASE_ARG) {
+                if (from % card->erase_size || nr % card->erase_size)
+                        return -EINVAL;
+        }
+
+        if (arg == MMC_ERASE_ARG) {
+                rem = from % card->erase_size;
+                if (rem) {
+                        rem = card->erase_size - rem;
+                        from += rem;
+                        if (nr > rem)
+                                nr -= rem;
+                        else
+                                return 0;
+                }
+                rem = nr % card->erase_size;
+                if (rem)
+                        nr -= rem;
+        }
+
+        if (nr == 0)
+                return 0;
+
+        to = from + nr;
+
+        if (to <= from)
+                return -EINVAL;
+
+        /* 'from' and 'to' are inclusive */
+        to -= 1;
+
+        return mmc_do_erase(card, from, to, arg);
+}
+EXPORT_SYMBOL(mmc_erase);
+
+int mmc_can_erase(struct mmc_card *card)
+{
+        if ((card->host->caps & MMC_CAP_ERASE) &&
+            (card->csd.cmdclass & CCC_ERASE) && card->erase_size)
+                return 1;
+        return 0;
+}
+EXPORT_SYMBOL(mmc_can_erase);
+
+int mmc_can_trim(struct mmc_card *card)
+{
+        if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
+                return 1;
+        return 0;
+}
+EXPORT_SYMBOL(mmc_can_trim);
+
+int mmc_can_secure_erase_trim(struct mmc_card *card)
+{
+        if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)
+                return 1;
+        return 0;
+}
+EXPORT_SYMBOL(mmc_can_secure_erase_trim);
+
+int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
+                            unsigned int nr)
+{
+        if (!card->erase_size)
+                return 0;
+        if (from % card->erase_size || nr % card->erase_size)
+                return 0;
+        return 1;
+}
+EXPORT_SYMBOL(mmc_erase_group_aligned);
 
 void mmc_rescan(struct work_struct *work)
 {
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index a811c52a165..9d9eef50e5d 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -29,6 +29,8 @@ struct mmc_bus_ops {
 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops);
 void mmc_detach_bus(struct mmc_host *host);
 
+void mmc_init_erase(struct mmc_card *card);
+
 void mmc_set_chip_select(struct mmc_host *host, int mode);
 void mmc_set_clock(struct mmc_host *host, unsigned int hz);
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index ccba3869c02..6909a54c39b 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -108,13 +108,23 @@ static int mmc_decode_cid(struct mmc_card *card)
         return 0;
 }
 
+static void mmc_set_erase_size(struct mmc_card *card)
+{
+        if (card->ext_csd.erase_group_def & 1)
+                card->erase_size = card->ext_csd.hc_erase_size;
+        else
+                card->erase_size = card->csd.erase_size;
+
+        mmc_init_erase(card);
+}
+
 /*
  * Given a 128-bit response, decode to our card CSD structure.
  */
 static int mmc_decode_csd(struct mmc_card *card)
 {
         struct mmc_csd *csd = &card->csd;
-        unsigned int e, m;
+        unsigned int e, m, a, b;
         u32 *resp = card->raw_csd;
 
         /*
@@ -152,6 +162,13 @@ static int mmc_decode_csd(struct mmc_card *card)
         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 
+        if (csd->write_blkbits >= 9) {
+                a = UNSTUFF_BITS(resp, 42, 5);
+                b = UNSTUFF_BITS(resp, 37, 5);
+                csd->erase_size = (a + 1) * (b + 1);
+                csd->erase_size <<= csd->write_blkbits - 9;
+        }
+
         return 0;
 }
 
@@ -261,8 +278,30 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                 if (sa_shift > 0 && sa_shift <= 0x17)
                         card->ext_csd.sa_timeout =
                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
+                card->ext_csd.erase_group_def =
+                        ext_csd[EXT_CSD_ERASE_GROUP_DEF];
+                card->ext_csd.hc_erase_timeout = 300 *
+                        ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
+                card->ext_csd.hc_erase_size =
+                        ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
+        }
+
+        if (card->ext_csd.rev >= 4) {
+                card->ext_csd.sec_trim_mult =
+                        ext_csd[EXT_CSD_SEC_TRIM_MULT];
+                card->ext_csd.sec_erase_mult =
+                        ext_csd[EXT_CSD_SEC_ERASE_MULT];
+                card->ext_csd.sec_feature_support =
+                        ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
+                card->ext_csd.trim_timeout = 300 *
+                        ext_csd[EXT_CSD_TRIM_MULT];
         }
 
+        if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
+                card->erased_byte = 0xFF;
+        else
+                card->erased_byte = 0x0;
+
 out:
         kfree(ext_csd);
 
@@ -274,6 +313,8 @@ MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
         card->raw_csd[2], card->raw_csd[3]);
 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
+MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
+MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
@@ -285,6 +326,8 @@ static struct attribute *mmc_std_attrs[] = {
         &dev_attr_cid.attr,
         &dev_attr_csd.attr,
         &dev_attr_date.attr,
+        &dev_attr_erase_size.attr,
+        &dev_attr_preferred_erase_size.attr,
         &dev_attr_fwrev.attr,
         &dev_attr_hwrev.attr,
         &dev_attr_manfid.attr,
@@ -421,6 +464,8 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 err = mmc_read_ext_csd(card);
                 if (err)
                         goto free_card;
+                /* Erase size depends on CSD and Extended CSD */
+                mmc_set_erase_size(card);
         }
 
         /*
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index e6d7d9fab44..0f524108555 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -119,6 +119,13 @@ static int mmc_decode_csd(struct mmc_card *card)
                 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
                 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
                 csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
+
+                if (UNSTUFF_BITS(resp, 46, 1)) {
+                        csd->erase_size = 1;
+                } else if (csd->write_blkbits >= 9) {
+                        csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
+                        csd->erase_size <<= csd->write_blkbits - 9;
+                }
                 break;
         case 1:
                 /*
@@ -147,6 +154,7 @@ static int mmc_decode_csd(struct mmc_card *card)
                 csd->r2w_factor = 4; /* Unused */
                 csd->write_blkbits = 9;
                 csd->write_partial = 0;
+                csd->erase_size = 1;
                 break;
         default:
                 printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",
@@ -154,6 +162,8 @@ static int mmc_decode_csd(struct mmc_card *card)
                 return -EINVAL;
         }
 
+        card->erase_size = csd->erase_size;
+
         return 0;
 }
 
@@ -179,10 +189,68 @@ static int mmc_decode_scr(struct mmc_card *card)
         scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
         scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 
+        if (UNSTUFF_BITS(resp, 55, 1))
+                card->erased_byte = 0xFF;
+        else
+                card->erased_byte = 0x0;
+
         return 0;
 }
 
 /*
+ * Fetch and process SD Status register.
+ */
+static int mmc_read_ssr(struct mmc_card *card)
+{
+        unsigned int au, es, et, eo;
+        int err, i;
+        u32 *ssr;
+
+        if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
+                printk(KERN_WARNING "%s: card lacks mandatory SD Status "
+                        "function.\n", mmc_hostname(card->host));
+                return 0;
+        }
+
+        ssr = kmalloc(64, GFP_KERNEL);
+        if (!ssr)
+                return -ENOMEM;
+
+        err = mmc_app_sd_status(card, ssr);
+        if (err) {
+                printk(KERN_WARNING "%s: problem reading SD Status "
+                        "register.\n", mmc_hostname(card->host));
+                err = 0;
+                goto out;
+        }
+
+        for (i = 0; i < 16; i++)
+                ssr[i] = be32_to_cpu(ssr[i]);
+
+        /*
+         * UNSTUFF_BITS only works with four u32s so we have to offset the
+         * bitfield positions accordingly.
+         */
+        au = UNSTUFF_BITS(ssr, 428 - 384, 4);
+        if (au > 0 || au <= 9) {
+                card->ssr.au = 1 << (au + 4);
+                es = UNSTUFF_BITS(ssr, 408 - 384, 16);
+                et = UNSTUFF_BITS(ssr, 402 - 384, 6);
+                eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
+                if (es && et) {
+                        card->ssr.erase_timeout = (et * 1000) / es;
+                        card->ssr.erase_offset = eo * 1000;
+                }
+        } else {
+                printk(KERN_WARNING "%s: SD Status: Invalid Allocation Unit "
+                        "size.\n", mmc_hostname(card->host));
+        }
+out:
+        kfree(ssr);
+        return err;
+}
+
+/*
  * Fetches and decodes switch information
  */
 static int mmc_read_switch(struct mmc_card *card)
@@ -289,6 +357,8 @@ MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
         card->raw_csd[2], card->raw_csd[3]);
 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
+MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
+MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
@@ -302,6 +372,8 @@ static struct attribute *sd_std_attrs[] = {
         &dev_attr_csd.attr,
         &dev_attr_scr.attr,
         &dev_attr_date.attr,
+        &dev_attr_erase_size.attr,
+        &dev_attr_preferred_erase_size.attr,
         &dev_attr_fwrev.attr,
         &dev_attr_hwrev.attr,
         &dev_attr_manfid.attr,
@@ -397,6 +469,16 @@ int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
                         return err;
 
                 /*
+                 * Fetch and process SD Status register.
+                 */
+                err = mmc_read_ssr(card);
+                if (err)
+                        return err;
+
+                /* Erase init depends on CSD and SSR */
+                mmc_init_erase(card);
+
+                /*
                  * Fetch switch information from card.
                  */
                 err = mmc_read_switch(card);
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 63772e7e760..797cdb5887f 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -346,3 +346,51 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
         return 0;
 }
 
+int mmc_app_sd_status(struct mmc_card *card, void *ssr)
+{
+        int err;
+        struct mmc_request mrq;
+        struct mmc_command cmd;
+        struct mmc_data data;
+        struct scatterlist sg;
+
+        BUG_ON(!card);
+        BUG_ON(!card->host);
+        BUG_ON(!ssr);
+
+        /* NOTE: caller guarantees ssr is heap-allocated */
+
+        err = mmc_app_cmd(card->host, card);
+        if (err)
+                return err;
+
+        memset(&mrq, 0, sizeof(struct mmc_request));
+        memset(&cmd, 0, sizeof(struct mmc_command));
+        memset(&data, 0, sizeof(struct mmc_data));
+
+        mrq.cmd = &cmd;
+        mrq.data = &data;
+
+        cmd.opcode = SD_APP_SD_STATUS;
+        cmd.arg = 0;
+        cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC;
+
+        data.blksz = 64;
+        data.blocks = 1;
+        data.flags = MMC_DATA_READ;
+        data.sg = &sg;
+        data.sg_len = 1;
+
+        sg_init_one(&sg, ssr, 64);
+
+        mmc_set_data_timeout(&data, card);
+
+        mmc_wait_for_req(card->host, &mrq);
+
+        if (cmd.error)
+                return cmd.error;
+        if (data.error)
+                return data.error;
+
+        return 0;
+}
diff --git a/drivers/mmc/core/sd_ops.h b/drivers/mmc/core/sd_ops.h
index 9742d8a3066..ffc2305d905 100644
--- a/drivers/mmc/core/sd_ops.h
+++ b/drivers/mmc/core/sd_ops.h
@@ -19,6 +19,7 @@ int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca);
 int mmc_app_send_scr(struct mmc_card *card, u32 *scr);
 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
         u8 value, u8 *resp);
+int mmc_app_sd_status(struct mmc_card *card, void *ssr);
 
 #endif
 
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 7b0f3ef50f9..1145ea0792e 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -1536,6 +1536,7 @@ static int __devexit mmc_spi_remove(struct spi_device *spi)
 #if defined(CONFIG_OF)
 static struct of_device_id mmc_spi_of_match_table[] __devinitdata = {
         { .compatible = "mmc-spi-slot", },
+        {},
 };
 #endif
 
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index dc57ef6aef4..4a8776f8afd 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -28,6 +28,7 @@
 #include <linux/clk.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/core.h>
+#include <linux/mmc/mmc.h>
 #include <linux/io.h>
 #include <linux/semaphore.h>
 #include <linux/gpio.h>
@@ -78,6 +79,7 @@
 #define INT_EN_MASK             0x307F0033
 #define BWR_ENABLE              (1 << 4)
 #define BRR_ENABLE              (1 << 5)
+#define DTO_ENABLE              (1 << 20)
 #define INIT_STREAM             (1 << 1)
 #define DP_SELECT               (1 << 21)
 #define DDIR                    (1 << 4)
@@ -523,7 +525,8 @@ static void omap_hsmmc_stop_clock(struct omap_hsmmc_host *host)
                 dev_dbg(mmc_dev(host->mmc), "MMC Clock is not stoped\n");
 }
 
-static void omap_hsmmc_enable_irq(struct omap_hsmmc_host *host)
+static void omap_hsmmc_enable_irq(struct omap_hsmmc_host *host,
+                                  struct mmc_command *cmd)
 {
         unsigned int irq_mask;
 
@@ -532,6 +535,10 @@ static void omap_hsmmc_enable_irq(struct omap_hsmmc_host *host)
         else
                 irq_mask = INT_EN_MASK;
 
+        /* Disable timeout for erases */
+        if (cmd->opcode == MMC_ERASE)
+                irq_mask &= ~DTO_ENABLE;
+
         OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR);
         OMAP_HSMMC_WRITE(host->base, ISE, irq_mask);
         OMAP_HSMMC_WRITE(host->base, IE, irq_mask);
@@ -782,7 +789,7 @@ omap_hsmmc_start_command(struct omap_hsmmc_host *host, struct mmc_command *cmd,
                 mmc_hostname(host->mmc), cmd->opcode, cmd->arg);
         host->cmd = cmd;
 
-        omap_hsmmc_enable_irq(host);
+        omap_hsmmc_enable_irq(host, cmd);
 
         host->response_busy = 0;
         if (cmd->flags & MMC_RSP_PRESENT) {
@@ -2107,7 +2114,7 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         mmc->max_seg_size = mmc->max_req_size;
 
         mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED |
-                     MMC_CAP_WAIT_WHILE_BUSY;
+                     MMC_CAP_WAIT_WHILE_BUSY | MMC_CAP_ERASE;
 
         switch (mmc_slot(host).wires) {
         case 8:
diff --git a/drivers/mmc/host/sdhci-of-core.c b/drivers/mmc/host/sdhci-of-core.c
index dd1bdd168e6..c51b71174c1 100644
--- a/drivers/mmc/host/sdhci-of-core.c
+++ b/drivers/mmc/host/sdhci-of-core.c
@@ -85,14 +85,14 @@ void sdhci_be32bs_writeb(struct sdhci_host *host, u8 val, int reg)
 
 #ifdef CONFIG_PM
 
-static int sdhci_of_suspend(struct of_device *ofdev, pm_message_t state)
+static int sdhci_of_suspend(struct platform_device *ofdev, pm_message_t state)
 {
         struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
 
         return mmc_suspend_host(host->mmc);
 }
 
-static int sdhci_of_resume(struct of_device *ofdev)
+static int sdhci_of_resume(struct platform_device *ofdev)
 {
         struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
 
@@ -115,7 +115,7 @@ static bool __devinit sdhci_of_wp_inverted(struct device_node *np)
         return machine_is(mpc837x_rdb) || machine_is(mpc837x_mds);
 }
 
-static int __devinit sdhci_of_probe(struct of_device *ofdev,
+static int __devinit sdhci_of_probe(struct platform_device *ofdev,
                                  const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -183,7 +183,7 @@ err_addr_map:
         return ret;
 }
 
-static int __devexit sdhci_of_remove(struct of_device *ofdev)
+static int __devexit sdhci_of_remove(struct platform_device *ofdev)
 {
         struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/mtd/maps/physmap_of.c b/drivers/mtd/maps/physmap_of.c
index 6ac5f9f28ac..00af55d7afb 100644
--- a/drivers/mtd/maps/physmap_of.c
+++ b/drivers/mtd/maps/physmap_of.c
@@ -43,7 +43,7 @@ struct of_flash {
 #ifdef CONFIG_MTD_PARTITIONS
 #define OF_FLASH_PARTS(info)    ((info)->parts)
 
-static int parse_obsolete_partitions(struct of_device *dev,
+static int parse_obsolete_partitions(struct platform_device *dev,
                                      struct of_flash *info,
                                      struct device_node *dp)
 {
@@ -93,7 +93,7 @@ static int parse_obsolete_partitions(struct of_device *dev,
 #define parse_partitions(info, dev)     (0)
 #endif /* MTD_PARTITIONS */
 
-static int of_flash_remove(struct of_device *dev)
+static int of_flash_remove(struct platform_device *dev)
 {
         struct of_flash *info;
         int i;
@@ -140,7 +140,7 @@ static int of_flash_remove(struct of_device *dev)
 /* Helper function to handle probing of the obsolete "direct-mapped"
  * compatible binding, which has an extra "probe-type" property
  * describing the type of flash probe necessary. */
-static struct mtd_info * __devinit obsolete_probe(struct of_device *dev,
+static struct mtd_info * __devinit obsolete_probe(struct platform_device *dev,
                                                   struct map_info *map)
 {
         struct device_node *dp = dev->dev.of_node;
@@ -215,7 +215,7 @@ static void __devinit of_free_probes(const char **probes)
 }
 #endif
 
-static int __devinit of_flash_probe(struct of_device *dev,
+static int __devinit of_flash_probe(struct platform_device *dev,
                                     const struct of_device_id *match)
 {
 #ifdef CONFIG_MTD_PARTITIONS
diff --git a/drivers/mtd/maps/sun_uflash.c b/drivers/mtd/maps/sun_uflash.c
index 8984236a8d0..3582ba1f9b0 100644
--- a/drivers/mtd/maps/sun_uflash.c
+++ b/drivers/mtd/maps/sun_uflash.c
@@ -48,7 +48,7 @@ struct map_info uflash_map_templ = {
         .bankwidth =    UFLASH_BUSWIDTH,
 };
 
-int uflash_devinit(struct of_device *op, struct device_node *dp)
+int uflash_devinit(struct platform_device *op, struct device_node *dp)
 {
         struct uflash_dev *up;
 
@@ -108,7 +108,7 @@ int uflash_devinit(struct of_device *op, struct device_node *dp)
         return 0;
 }
 
-static int __devinit uflash_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit uflash_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
 
@@ -121,7 +121,7 @@ static int __devinit uflash_probe(struct of_device *op, const struct of_device_i
         return uflash_devinit(op, dp);
 }
 
-static int __devexit uflash_remove(struct of_device *op)
+static int __devexit uflash_remove(struct platform_device *op)
 {
         struct uflash_dev *up = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 5084cc51794..80de0bff6c3 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -958,7 +958,7 @@ static int __devinit fsl_elbc_ctrl_init(struct fsl_elbc_ctrl *ctrl)
         return 0;
 }
 
-static int fsl_elbc_ctrl_remove(struct of_device *ofdev)
+static int fsl_elbc_ctrl_remove(struct platform_device *ofdev)
 {
         struct fsl_elbc_ctrl *ctrl = dev_get_drvdata(&ofdev->dev);
         int i;
@@ -1013,7 +1013,7 @@ static irqreturn_t fsl_elbc_ctrl_irq(int irqno, void *data)
  * in the chip probe function.
 */
 
-static int __devinit fsl_elbc_ctrl_probe(struct of_device *ofdev,
+static int __devinit fsl_elbc_ctrl_probe(struct platform_device *ofdev,
                                          const struct of_device_id *match)
 {
         struct device_node *child;
diff --git a/drivers/mtd/nand/fsl_upm.c b/drivers/mtd/nand/fsl_upm.c
index 1312eda57ba..4eff8b25e5a 100644
--- a/drivers/mtd/nand/fsl_upm.c
+++ b/drivers/mtd/nand/fsl_upm.c
@@ -217,7 +217,7 @@ err:
         return ret;
 }
 
-static int __devinit fun_probe(struct of_device *ofdev,
+static int __devinit fun_probe(struct platform_device *ofdev,
                                const struct of_device_id *ofid)
 {
         struct fsl_upm_nand *fun;
@@ -335,7 +335,7 @@ err1:
         return ret;
 }
 
-static int __devexit fun_remove(struct of_device *ofdev)
+static int __devexit fun_remove(struct platform_device *ofdev)
 {
         struct fsl_upm_nand *fun = dev_get_drvdata(&ofdev->dev);
         int i;
diff --git a/drivers/mtd/nand/mpc5121_nfc.c b/drivers/mtd/nand/mpc5121_nfc.c
index 0a130dcaa12..df0c1da4ff4 100644
--- a/drivers/mtd/nand/mpc5121_nfc.c
+++ b/drivers/mtd/nand/mpc5121_nfc.c
@@ -647,7 +647,7 @@ static void mpc5121_nfc_free(struct device *dev, struct mtd_info *mtd)
                 iounmap(prv->csreg);
 }
 
-static int __devinit mpc5121_nfc_probe(struct of_device *op,
+static int __devinit mpc5121_nfc_probe(struct platform_device *op,
                                         const struct of_device_id *match)
 {
         struct device_node *rootnode, *dn = op->dev.of_node;
@@ -869,7 +869,7 @@ error:
         return retval;
 }
 
-static int __devexit mpc5121_nfc_remove(struct of_device *op)
+static int __devexit mpc5121_nfc_remove(struct platform_device *op)
 {
         struct device *dev = &op->dev;
         struct mtd_info *mtd = dev_get_drvdata(dev);
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index 98fd2bdf8be..510554e6c11 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -35,7 +35,7 @@
 
 
 struct ndfc_controller {
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         void __iomem *ndfcbase;
         struct mtd_info mtd;
         struct nand_chip chip;
@@ -225,7 +225,7 @@ err:
         return ret;
 }
 
-static int __devinit ndfc_probe(struct of_device *ofdev,
+static int __devinit ndfc_probe(struct platform_device *ofdev,
                                 const struct of_device_id *match)
 {
         struct ndfc_controller *ndfc = &ndfc_ctrl;
@@ -277,7 +277,7 @@ static int __devinit ndfc_probe(struct of_device *ofdev,
         return 0;
 }
 
-static int __devexit ndfc_remove(struct of_device *ofdev)
+static int __devexit ndfc_remove(struct platform_device *ofdev)
 {
         struct ndfc_controller *ndfc = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/mtd/nand/pasemi_nand.c b/drivers/mtd/nand/pasemi_nand.c
index f02af24d033..6ddb2461d74 100644
--- a/drivers/mtd/nand/pasemi_nand.c
+++ b/drivers/mtd/nand/pasemi_nand.c
@@ -89,7 +89,7 @@ int pasemi_device_ready(struct mtd_info *mtd)
         return !!(inl(lpcctl) & LBICTRL_LPCCTL_NR);
 }
 
-static int __devinit pasemi_nand_probe(struct of_device *ofdev,
+static int __devinit pasemi_nand_probe(struct platform_device *ofdev,
                                       const struct of_device_id *match)
 {
         struct pci_dev *pdev;
@@ -185,7 +185,7 @@ static int __devinit pasemi_nand_probe(struct of_device *ofdev,
         return err;
 }
 
-static int __devexit pasemi_nand_remove(struct of_device *ofdev)
+static int __devexit pasemi_nand_remove(struct platform_device *ofdev)
 {
         struct nand_chip *chip;
 
diff --git a/drivers/mtd/nand/socrates_nand.c b/drivers/mtd/nand/socrates_nand.c
index cc728b12de8..a8e403eebed 100644
--- a/drivers/mtd/nand/socrates_nand.c
+++ b/drivers/mtd/nand/socrates_nand.c
@@ -162,7 +162,7 @@ static const char *part_probes[] = { "cmdlinepart", NULL };
 /*
  * Probe for the NAND device.
  */
-static int __devinit socrates_nand_probe(struct of_device *ofdev,
+static int __devinit socrates_nand_probe(struct platform_device *ofdev,
                                          const struct of_device_id *ofid)
 {
         struct socrates_nand_host *host;
@@ -276,7 +276,7 @@ out:
 /*
  * Remove a NAND device.
  */
-static int __devexit socrates_nand_remove(struct of_device *ofdev)
+static int __devexit socrates_nand_remove(struct platform_device *ofdev)
 {
         struct socrates_nand_host *host = dev_get_drvdata(&ofdev->dev);
         struct mtd_info *mtd = &host->mtd;
diff --git a/drivers/net/can/mscan/mpc5xxx_can.c b/drivers/net/can/mscan/mpc5xxx_can.c
index af753936e83..b1bdc909090 100644
--- a/drivers/net/can/mscan/mpc5xxx_can.c
+++ b/drivers/net/can/mscan/mpc5xxx_can.c
@@ -38,7 +38,7 @@
 
 struct mpc5xxx_can_data {
         unsigned int type;
-        u32 (*get_clock)(struct of_device *ofdev, const char *clock_name,
+        u32 (*get_clock)(struct platform_device *ofdev, const char *clock_name,
                          int *mscan_clksrc);
 };
 
@@ -48,7 +48,7 @@ static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = {
         {}
 };
 
-static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -101,7 +101,7 @@ static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
         return freq;
 }
 #else /* !CONFIG_PPC_MPC52xx */
-static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -129,7 +129,7 @@ static struct of_device_id __devinitdata mpc512x_clock_ids[] = {
         {}
 };
 
-static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -239,7 +239,7 @@ exit_unmap:
         return freq;
 }
 #else /* !CONFIG_PPC_MPC512x */
-static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
+static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
                                            const char *clock_name,
                                            int *mscan_clksrc)
 {
@@ -247,7 +247,7 @@ static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
 }
 #endif /* CONFIG_PPC_MPC512x */
 
-static int __devinit mpc5xxx_can_probe(struct of_device *ofdev,
+static int __devinit mpc5xxx_can_probe(struct platform_device *ofdev,
                                        const struct of_device_id *id)
 {
         struct mpc5xxx_can_data *data = (struct mpc5xxx_can_data *)id->data;
@@ -317,7 +317,7 @@ exit_unmap_mem:
         return err;
 }
 
-static int __devexit mpc5xxx_can_remove(struct of_device *ofdev)
+static int __devexit mpc5xxx_can_remove(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
@@ -334,7 +334,7 @@ static int __devexit mpc5xxx_can_remove(struct of_device *ofdev)
 
 #ifdef CONFIG_PM
 static struct mscan_regs saved_regs;
-static int mpc5xxx_can_suspend(struct of_device *ofdev, pm_message_t state)
+static int mpc5xxx_can_suspend(struct platform_device *ofdev, pm_message_t state)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
@@ -345,7 +345,7 @@ static int mpc5xxx_can_suspend(struct of_device *ofdev, pm_message_t state)
         return 0;
 }
 
-static int mpc5xxx_can_resume(struct of_device *ofdev)
+static int mpc5xxx_can_resume(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct mscan_priv *priv = netdev_priv(dev);
diff --git a/drivers/net/can/sja1000/sja1000_of_platform.c b/drivers/net/can/sja1000/sja1000_of_platform.c
index ac1a83d7c20..5bfccfdf3bb 100644
--- a/drivers/net/can/sja1000/sja1000_of_platform.c
+++ b/drivers/net/can/sja1000/sja1000_of_platform.c
@@ -67,7 +67,7 @@ static void sja1000_ofp_write_reg(const struct sja1000_priv *priv,
         out_8(priv->reg_base + reg, val);
 }
 
-static int __devexit sja1000_ofp_remove(struct of_device *ofdev)
+static int __devexit sja1000_ofp_remove(struct platform_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct sja1000_priv *priv = netdev_priv(dev);
@@ -87,7 +87,7 @@ static int __devexit sja1000_ofp_remove(struct of_device *ofdev)
         return 0;
 }
 
-static int __devinit sja1000_ofp_probe(struct of_device *ofdev,
+static int __devinit sja1000_ofp_probe(struct platform_device *ofdev,
                                        const struct of_device_id *id)
 {
         struct device_node *np = ofdev->dev.of_node;
diff --git a/drivers/net/ehea/ehea.h b/drivers/net/ehea/ehea.h
index 0060e422f17..99a929964e3 100644
--- a/drivers/net/ehea/ehea.h
+++ b/drivers/net/ehea/ehea.h
@@ -413,7 +413,7 @@ struct ehea_port_res {
 
 struct ehea_adapter {
         u64 handle;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         struct ehea_port *port[EHEA_MAX_PORTS];
         struct ehea_eq *neq;       /* notification event queue */
         struct tasklet_struct neq_tasklet;
@@ -465,7 +465,7 @@ struct ehea_port {
         struct net_device *netdev;
         struct net_device_stats stats;
         struct ehea_port_res port_res[EHEA_MAX_PORT_RES];
-        struct of_device  ofdev; /* Open Firmware Device */
+        struct platform_device  ofdev; /* Open Firmware Device */
         struct ehea_mc_list *mc_list;    /* Multicast MAC addresses */
         struct vlan_group *vgrp;
         struct ehea_eq *qp_eq;
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index 3beba70b7de..897719b49f9 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -107,10 +107,10 @@ struct ehea_fw_handle_array ehea_fw_handles;
 struct ehea_bcmc_reg_array ehea_bcmc_regs;
 
 
-static int __devinit ehea_probe_adapter(struct of_device *dev,
+static int __devinit ehea_probe_adapter(struct platform_device *dev,
                                         const struct of_device_id *id);
 
-static int __devexit ehea_remove(struct of_device *dev);
+static int __devexit ehea_remove(struct platform_device *dev);
 
 static struct of_device_id ehea_device_table[] = {
         {
@@ -3376,7 +3376,7 @@ static ssize_t ehea_remove_port(struct device *dev,
 static DEVICE_ATTR(probe_port, S_IWUSR, NULL, ehea_probe_port);
 static DEVICE_ATTR(remove_port, S_IWUSR, NULL, ehea_remove_port);
 
-int ehea_create_device_sysfs(struct of_device *dev)
+int ehea_create_device_sysfs(struct platform_device *dev)
 {
         int ret = device_create_file(&dev->dev, &dev_attr_probe_port);
         if (ret)
@@ -3387,13 +3387,13 @@ out:
         return ret;
 }
 
-void ehea_remove_device_sysfs(struct of_device *dev)
+void ehea_remove_device_sysfs(struct platform_device *dev)
 {
         device_remove_file(&dev->dev, &dev_attr_probe_port);
         device_remove_file(&dev->dev, &dev_attr_remove_port);
 }
 
-static int __devinit ehea_probe_adapter(struct of_device *dev,
+static int __devinit ehea_probe_adapter(struct platform_device *dev,
                                         const struct of_device_id *id)
 {
         struct ehea_adapter *adapter;
@@ -3492,7 +3492,7 @@ out:
         return ret;
 }
 
-static int __devexit ehea_remove(struct of_device *dev)
+static int __devexit ehea_remove(struct platform_device *dev)
 {
         struct ehea_adapter *adapter = dev_get_drvdata(&dev->dev);
         int i;
diff --git a/drivers/net/fec_mpc52xx.c b/drivers/net/fec_mpc52xx.c
index d1a5b17b2a9..e3e10b4add9 100644
--- a/drivers/net/fec_mpc52xx.c
+++ b/drivers/net/fec_mpc52xx.c
@@ -850,7 +850,7 @@ static const struct net_device_ops mpc52xx_fec_netdev_ops = {
 /* ======================================================================== */
 
 static int __devinit
-mpc52xx_fec_probe(struct of_device *op, const struct of_device_id *match)
+mpc52xx_fec_probe(struct platform_device *op, const struct of_device_id *match)
 {
         int rv;
         struct net_device *ndev;
@@ -995,7 +995,7 @@ err_netdev:
 }
 
 static int
-mpc52xx_fec_remove(struct of_device *op)
+mpc52xx_fec_remove(struct platform_device *op)
 {
         struct net_device *ndev;
         struct mpc52xx_fec_priv *priv;
@@ -1025,7 +1025,7 @@ mpc52xx_fec_remove(struct of_device *op)
 }
 
 #ifdef CONFIG_PM
-static int mpc52xx_fec_of_suspend(struct of_device *op, pm_message_t state)
+static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state)
 {
         struct net_device *dev = dev_get_drvdata(&op->dev);
 
@@ -1035,7 +1035,7 @@ static int mpc52xx_fec_of_suspend(struct of_device *op, pm_message_t state)
         return 0;
 }
 
-static int mpc52xx_fec_of_resume(struct of_device *op)
+static int mpc52xx_fec_of_resume(struct platform_device *op)
 {
         struct net_device *dev = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/net/fec_mpc52xx_phy.c b/drivers/net/fec_mpc52xx_phy.c
index dbaf72cbb23..0b4cb6f1598 100644
--- a/drivers/net/fec_mpc52xx_phy.c
+++ b/drivers/net/fec_mpc52xx_phy.c
@@ -61,7 +61,7 @@ static int mpc52xx_fec_mdio_write(struct mii_bus *bus, int phy_id, int reg,
                 data | FEC_MII_WRITE_FRAME);
 }
 
-static int mpc52xx_fec_mdio_probe(struct of_device *of,
+static int mpc52xx_fec_mdio_probe(struct platform_device *of,
                 const struct of_device_id *match)
 {
         struct device *dev = &of->dev;
@@ -122,7 +122,7 @@ static int mpc52xx_fec_mdio_probe(struct of_device *of,
         return err;
 }
 
-static int mpc52xx_fec_mdio_remove(struct of_device *of)
+static int mpc52xx_fec_mdio_remove(struct platform_device *of)
 {
         struct device *dev = &of->dev;
         struct mii_bus *bus = dev_get_drvdata(dev);
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index f08cff9020b..d6e3111959a 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -997,7 +997,7 @@ static const struct net_device_ops fs_enet_netdev_ops = {
 #endif
 };
 
-static int __devinit fs_enet_probe(struct of_device *ofdev,
+static int __devinit fs_enet_probe(struct platform_device *ofdev,
                                    const struct of_device_id *match)
 {
         struct net_device *ndev;
@@ -1105,7 +1105,7 @@ out_free_fpi:
         return ret;
 }
 
-static int fs_enet_remove(struct of_device *ofdev)
+static int fs_enet_remove(struct platform_device *ofdev)
 {
         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
         struct fs_enet_private *fep = netdev_priv(ndev);
diff --git a/drivers/net/fs_enet/mac-fcc.c b/drivers/net/fs_enet/mac-fcc.c
index 48e91b6242c..7a84e45487e 100644
--- a/drivers/net/fs_enet/mac-fcc.c
+++ b/drivers/net/fs_enet/mac-fcc.c
@@ -84,7 +84,7 @@ static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 op)
 
 static int do_pd_setup(struct fs_enet_private *fep)
 {
-        struct of_device *ofdev = to_of_device(fep->dev);
+        struct platform_device *ofdev = to_platform_device(fep->dev);
         struct fs_platform_info *fpi = fep->fpi;
         int ret = -EINVAL;
 
diff --git a/drivers/net/fs_enet/mac-fec.c b/drivers/net/fs_enet/mac-fec.c
index 7ca1642276d..61035fc5599 100644
--- a/drivers/net/fs_enet/mac-fec.c
+++ b/drivers/net/fs_enet/mac-fec.c
@@ -96,7 +96,7 @@ static int whack_reset(struct fec __iomem *fecp)
 
 static int do_pd_setup(struct fs_enet_private *fep)
 {
-        struct of_device *ofdev = to_of_device(fep->dev);
+        struct platform_device *ofdev = to_platform_device(fep->dev);
 
         fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
index a3c44544846..22a02a76706 100644
--- a/drivers/net/fs_enet/mac-scc.c
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -96,7 +96,7 @@ static inline int scc_cr_cmd(struct fs_enet_private *fep, u32 op)
 
 static int do_pd_setup(struct fs_enet_private *fep)
 {
-        struct of_device *ofdev = to_of_device(fep->dev);
+        struct platform_device *ofdev = to_platform_device(fep->dev);
 
         fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
diff --git a/drivers/net/fs_enet/mii-bitbang.c b/drivers/net/fs_enet/mii-bitbang.c
index 3607340f3da..3cda2b51547 100644
--- a/drivers/net/fs_enet/mii-bitbang.c
+++ b/drivers/net/fs_enet/mii-bitbang.c
@@ -150,7 +150,7 @@ static int __devinit fs_mii_bitbang_init(struct mii_bus *bus,
         return 0;
 }
 
-static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
+static int __devinit fs_enet_mdio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct mii_bus *new_bus;
@@ -200,7 +200,7 @@ out:
         return ret;
 }
 
-static int fs_enet_mdio_remove(struct of_device *ofdev)
+static int fs_enet_mdio_remove(struct platform_device *ofdev)
 {
         struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
         struct bb_info *bitbang = bus->priv;
diff --git a/drivers/net/fs_enet/mii-fec.c b/drivers/net/fs_enet/mii-fec.c
index bddffd169b9..dbb9c48623d 100644
--- a/drivers/net/fs_enet/mii-fec.c
+++ b/drivers/net/fs_enet/mii-fec.c
@@ -101,7 +101,7 @@ static int fs_enet_fec_mii_reset(struct mii_bus *bus)
         return 0;
 }
 
-static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
+static int __devinit fs_enet_mdio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct resource res;
@@ -192,7 +192,7 @@ out:
         return ret;
 }
 
-static int fs_enet_mdio_remove(struct of_device *ofdev)
+static int fs_enet_mdio_remove(struct platform_device *ofdev)
 {
         struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
         struct fec_info *fec = bus->priv;
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index f53f850b641..d4bf91aac25 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -265,7 +265,7 @@ static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id)
 #endif
 
 
-static int fsl_pq_mdio_probe(struct of_device *ofdev,
+static int fsl_pq_mdio_probe(struct platform_device *ofdev,
                 const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -425,7 +425,7 @@ err_free_priv:
 }
 
 
-static int fsl_pq_mdio_remove(struct of_device *ofdev)
+static int fsl_pq_mdio_remove(struct platform_device *ofdev)
 {
         struct device *device = &ofdev->dev;
         struct mii_bus *bus = dev_get_drvdata(device);
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index a1b6301bc67..4f7c3f3ca23 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -122,9 +122,9 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id);
 static void adjust_link(struct net_device *dev);
 static void init_registers(struct net_device *dev);
 static int init_phy(struct net_device *dev);
-static int gfar_probe(struct of_device *ofdev,
+static int gfar_probe(struct platform_device *ofdev,
                 const struct of_device_id *match);
-static int gfar_remove(struct of_device *ofdev);
+static int gfar_remove(struct platform_device *ofdev);
 static void free_skb_resources(struct gfar_private *priv);
 static void gfar_set_multi(struct net_device *dev);
 static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr);
@@ -605,7 +605,7 @@ static int gfar_parse_group(struct device_node *np,
         return 0;
 }
 
-static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
+static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
 {
         const char *model;
         const char *ctype;
@@ -959,7 +959,7 @@ static void gfar_detect_errata(struct gfar_private *priv)
 
 /* Set up the ethernet device structure, private data,
  * and anything else we need before we start */
-static int gfar_probe(struct of_device *ofdev,
+static int gfar_probe(struct platform_device *ofdev,
                 const struct of_device_id *match)
 {
         u32 tempval;
@@ -1238,7 +1238,7 @@ register_fail:
         return err;
 }
 
-static int gfar_remove(struct of_device *ofdev)
+static int gfar_remove(struct platform_device *ofdev)
 {
         struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 710810e2adb..68984eb88ae 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -1054,7 +1054,7 @@ struct gfar_private {
 
         struct device_node *node;
         struct net_device *ndev;
-        struct of_device *ofdev;
+        struct platform_device *ofdev;
         enum gfar_errata errata;
 
         struct gfar_priv_grp gfargrp[MAXGROUPS];
diff --git a/drivers/net/greth.c b/drivers/net/greth.c
index 4d09eab3548..f15c64f1cd3 100644
--- a/drivers/net/greth.c
+++ b/drivers/net/greth.c
@@ -1373,7 +1373,7 @@ error:
 }
 
 /* Initialize the GRETH MAC */
-static int __devinit greth_of_probe(struct of_device *ofdev, const struct of_device_id *match)
+static int __devinit greth_of_probe(struct platform_device *ofdev, const struct of_device_id *match)
 {
         struct net_device *dev;
         struct greth_private *greth;
@@ -1412,7 +1412,7 @@ static int __devinit greth_of_probe(struct of_device *ofdev, const struct of_dev
         }
 
         regs = (struct greth_regs *) greth->regs;
-        greth->irq = ofdev->irqs[0];
+        greth->irq = ofdev->archdata.irqs[0];
 
         dev_set_drvdata(greth->dev, dev);
         SET_NETDEV_DEV(dev, greth->dev);
@@ -1572,7 +1572,7 @@ error1:
         return err;
 }
 
-static int __devexit greth_of_remove(struct of_device *of_dev)
+static int __devexit greth_of_remove(struct platform_device *of_dev)
 {
         struct net_device *ndev = dev_get_drvdata(&of_dev->dev);
         struct greth_private *greth = netdev_priv(ndev);
diff --git a/drivers/net/greth.h b/drivers/net/greth.h
index 973388d6abc..03ad903cd67 100644
--- a/drivers/net/greth.h
+++ b/drivers/net/greth.h
@@ -118,7 +118,7 @@ struct greth_private {
 
         int irq;
 
-        struct device *dev;             /* Pointer to of_device->dev */
+        struct device *dev;             /* Pointer to platform_device->dev */
         struct net_device *netdev;
         struct napi_struct napi;
         spinlock_t devlock;
diff --git a/drivers/net/ibm_newemac/core.c b/drivers/net/ibm_newemac/core.c
index eeec7bc2ce7..3506fd6ad72 100644
--- a/drivers/net/ibm_newemac/core.c
+++ b/drivers/net/ibm_newemac/core.c
@@ -2245,7 +2245,7 @@ static int emac_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
 struct emac_depentry {
         u32                     phandle;
         struct device_node      *node;
-        struct of_device        *ofdev;
+        struct platform_device  *ofdev;
         void                    *drvdata;
 };
 
@@ -2719,7 +2719,7 @@ static const struct net_device_ops emac_gige_netdev_ops = {
         .ndo_change_mtu         = emac_change_mtu,
 };
 
-static int __devinit emac_probe(struct of_device *ofdev,
+static int __devinit emac_probe(struct platform_device *ofdev,
                                 const struct of_device_id *match)
 {
         struct net_device *ndev;
@@ -2941,7 +2941,7 @@ static int __devinit emac_probe(struct of_device *ofdev,
         return err;
 }
 
-static int __devexit emac_remove(struct of_device *ofdev)
+static int __devexit emac_remove(struct platform_device *ofdev)
 {
         struct emac_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/core.h b/drivers/net/ibm_newemac/core.h
index b1cbe6fdfc7..9e37e3d9c51 100644
--- a/drivers/net/ibm_newemac/core.h
+++ b/drivers/net/ibm_newemac/core.h
@@ -170,12 +170,12 @@ struct emac_instance {
         struct net_device               *ndev;
         struct resource                 rsrc_regs;
         struct emac_regs                __iomem *emacp;
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
         struct device_node              **blist; /* bootlist entry */
 
         /* MAL linkage */
         u32                             mal_ph;
-        struct of_device                *mal_dev;
+        struct platform_device          *mal_dev;
         u32                             mal_rx_chan;
         u32                             mal_tx_chan;
         struct mal_instance             *mal;
@@ -196,24 +196,24 @@ struct emac_instance {
 
         /* Shared MDIO if any */
         u32                             mdio_ph;
-        struct of_device                *mdio_dev;
+        struct platform_device          *mdio_dev;
         struct emac_instance            *mdio_instance;
         struct mutex                    mdio_lock;
 
         /* ZMII infos if any */
         u32                             zmii_ph;
         u32                             zmii_port;
-        struct of_device                *zmii_dev;
+        struct platform_device          *zmii_dev;
 
         /* RGMII infos if any */
         u32                             rgmii_ph;
         u32                             rgmii_port;
-        struct of_device                *rgmii_dev;
+        struct platform_device          *rgmii_dev;
 
         /* TAH infos if any */
         u32                             tah_ph;
         u32                             tah_port;
-        struct of_device                *tah_dev;
+        struct platform_device          *tah_dev;
 
         /* IRQs */
         int                             wol_irq;
diff --git a/drivers/net/ibm_newemac/mal.c b/drivers/net/ibm_newemac/mal.c
index fcff9e0bd38..d5717e2123e 100644
--- a/drivers/net/ibm_newemac/mal.c
+++ b/drivers/net/ibm_newemac/mal.c
@@ -517,7 +517,7 @@ void *mal_dump_regs(struct mal_instance *mal, void *buf)
         return regs + 1;
 }
 
-static int __devinit mal_probe(struct of_device *ofdev,
+static int __devinit mal_probe(struct platform_device *ofdev,
                                const struct of_device_id *match)
 {
         struct mal_instance *mal;
@@ -730,7 +730,7 @@ static int __devinit mal_probe(struct of_device *ofdev,
         return err;
 }
 
-static int __devexit mal_remove(struct of_device *ofdev)
+static int __devexit mal_remove(struct platform_device *ofdev)
 {
         struct mal_instance *mal = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/mal.h b/drivers/net/ibm_newemac/mal.h
index 9ededfbf072..66084214bf4 100644
--- a/drivers/net/ibm_newemac/mal.h
+++ b/drivers/net/ibm_newemac/mal.h
@@ -210,7 +210,7 @@ struct mal_instance {
         dma_addr_t              bd_dma;
         struct mal_descriptor   *bd_virt;
 
-        struct of_device        *ofdev;
+        struct platform_device  *ofdev;
         int                     index;
         spinlock_t              lock;
 
diff --git a/drivers/net/ibm_newemac/rgmii.c b/drivers/net/ibm_newemac/rgmii.c
index 108919bcdf1..dd61798897a 100644
--- a/drivers/net/ibm_newemac/rgmii.c
+++ b/drivers/net/ibm_newemac/rgmii.c
@@ -93,7 +93,7 @@ static inline u32 rgmii_mode_mask(int mode, int input)
         }
 }
 
-int __devinit rgmii_attach(struct of_device *ofdev, int input, int mode)
+int __devinit rgmii_attach(struct platform_device *ofdev, int input, int mode)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -122,7 +122,7 @@ int __devinit rgmii_attach(struct of_device *ofdev, int input, int mode)
         return 0;
 }
 
-void rgmii_set_speed(struct of_device *ofdev, int input, int speed)
+void rgmii_set_speed(struct platform_device *ofdev, int input, int speed)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -144,7 +144,7 @@ void rgmii_set_speed(struct of_device *ofdev, int input, int speed)
         mutex_unlock(&dev->lock);
 }
 
-void rgmii_get_mdio(struct of_device *ofdev, int input)
+void rgmii_get_mdio(struct platform_device *ofdev, int input)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -165,7 +165,7 @@ void rgmii_get_mdio(struct of_device *ofdev, int input)
         DBG2(dev, " fer = 0x%08x\n", fer);
 }
 
-void rgmii_put_mdio(struct of_device *ofdev, int input)
+void rgmii_put_mdio(struct platform_device *ofdev, int input)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p = dev->base;
@@ -186,7 +186,7 @@ void rgmii_put_mdio(struct of_device *ofdev, int input)
         mutex_unlock(&dev->lock);
 }
 
-void rgmii_detach(struct of_device *ofdev, int input)
+void rgmii_detach(struct platform_device *ofdev, int input)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct rgmii_regs __iomem *p;
@@ -206,13 +206,13 @@ void rgmii_detach(struct of_device *ofdev, int input)
         mutex_unlock(&dev->lock);
 }
 
-int rgmii_get_regs_len(struct of_device *ofdev)
+int rgmii_get_regs_len(struct platform_device *ofdev)
 {
         return sizeof(struct emac_ethtool_regs_subhdr) +
                 sizeof(struct rgmii_regs);
 }
 
-void *rgmii_dump_regs(struct of_device *ofdev, void *buf)
+void *rgmii_dump_regs(struct platform_device *ofdev, void *buf)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct emac_ethtool_regs_subhdr *hdr = buf;
@@ -228,7 +228,7 @@ void *rgmii_dump_regs(struct of_device *ofdev, void *buf)
 }
 
 
-static int __devinit rgmii_probe(struct of_device *ofdev,
+static int __devinit rgmii_probe(struct platform_device *ofdev,
                                  const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -293,7 +293,7 @@ static int __devinit rgmii_probe(struct of_device *ofdev,
         return rc;
 }
 
-static int __devexit rgmii_remove(struct of_device *ofdev)
+static int __devexit rgmii_remove(struct platform_device *ofdev)
 {
         struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/rgmii.h b/drivers/net/ibm_newemac/rgmii.h
index c4a4b358a27..d6979904986 100644
--- a/drivers/net/ibm_newemac/rgmii.h
+++ b/drivers/net/ibm_newemac/rgmii.h
@@ -51,20 +51,20 @@ struct rgmii_instance {
         int                             users;
 
         /* OF device instance */
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
 };
 
 #ifdef CONFIG_IBM_NEW_EMAC_RGMII
 
 extern int rgmii_init(void);
 extern void rgmii_exit(void);
-extern int rgmii_attach(struct of_device *ofdev, int input, int mode);
-extern void rgmii_detach(struct of_device *ofdev, int input);
-extern void rgmii_get_mdio(struct of_device *ofdev, int input);
-extern void rgmii_put_mdio(struct of_device *ofdev, int input);
-extern void rgmii_set_speed(struct of_device *ofdev, int input, int speed);
-extern int rgmii_get_regs_len(struct of_device *ofdev);
-extern void *rgmii_dump_regs(struct of_device *ofdev, void *buf);
+extern int rgmii_attach(struct platform_device *ofdev, int input, int mode);
+extern void rgmii_detach(struct platform_device *ofdev, int input);
+extern void rgmii_get_mdio(struct platform_device *ofdev, int input);
+extern void rgmii_put_mdio(struct platform_device *ofdev, int input);
+extern void rgmii_set_speed(struct platform_device *ofdev, int input, int speed);
+extern int rgmii_get_regs_len(struct platform_device *ofdev);
+extern void *rgmii_dump_regs(struct platform_device *ofdev, void *buf);
 
 #else
 
diff --git a/drivers/net/ibm_newemac/tah.c b/drivers/net/ibm_newemac/tah.c
index 044637144c4..299aa49490c 100644
--- a/drivers/net/ibm_newemac/tah.c
+++ b/drivers/net/ibm_newemac/tah.c
@@ -23,7 +23,7 @@
 #include "emac.h"
 #include "core.h"
 
-int __devinit tah_attach(struct of_device *ofdev, int channel)
+int __devinit tah_attach(struct platform_device *ofdev, int channel)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -35,7 +35,7 @@ int __devinit tah_attach(struct of_device *ofdev, int channel)
         return 0;
 }
 
-void tah_detach(struct of_device *ofdev, int channel)
+void tah_detach(struct platform_device *ofdev, int channel)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -44,7 +44,7 @@ void tah_detach(struct of_device *ofdev, int channel)
         mutex_unlock(&dev->lock);
 }
 
-void tah_reset(struct of_device *ofdev)
+void tah_reset(struct platform_device *ofdev)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct tah_regs __iomem *p = dev->base;
@@ -66,13 +66,13 @@ void tah_reset(struct of_device *ofdev)
                  TAH_MR_DIG);
 }
 
-int tah_get_regs_len(struct of_device *ofdev)
+int tah_get_regs_len(struct platform_device *ofdev)
 {
         return sizeof(struct emac_ethtool_regs_subhdr) +
                 sizeof(struct tah_regs);
 }
 
-void *tah_dump_regs(struct of_device *ofdev, void *buf)
+void *tah_dump_regs(struct platform_device *ofdev, void *buf)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct emac_ethtool_regs_subhdr *hdr = buf;
@@ -87,7 +87,7 @@ void *tah_dump_regs(struct of_device *ofdev, void *buf)
         return regs + 1;
 }
 
-static int __devinit tah_probe(struct of_device *ofdev,
+static int __devinit tah_probe(struct platform_device *ofdev,
                                const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -139,7 +139,7 @@ static int __devinit tah_probe(struct of_device *ofdev,
         return rc;
 }
 
-static int __devexit tah_remove(struct of_device *ofdev)
+static int __devexit tah_remove(struct platform_device *ofdev)
 {
         struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/tah.h b/drivers/net/ibm_newemac/tah.h
index a068b5658da..61dbeca006d 100644
--- a/drivers/net/ibm_newemac/tah.h
+++ b/drivers/net/ibm_newemac/tah.h
@@ -48,7 +48,7 @@ struct tah_instance {
         int                             users;
 
         /* OF device instance */
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
 };
 
 
@@ -74,11 +74,11 @@ struct tah_instance {
 
 extern int tah_init(void);
 extern void tah_exit(void);
-extern int tah_attach(struct of_device *ofdev, int channel);
-extern void tah_detach(struct of_device *ofdev, int channel);
-extern void tah_reset(struct of_device *ofdev);
-extern int tah_get_regs_len(struct of_device *ofdev);
-extern void *tah_dump_regs(struct of_device *ofdev, void *buf);
+extern int tah_attach(struct platform_device *ofdev, int channel);
+extern void tah_detach(struct platform_device *ofdev, int channel);
+extern void tah_reset(struct platform_device *ofdev);
+extern int tah_get_regs_len(struct platform_device *ofdev);
+extern void *tah_dump_regs(struct platform_device *ofdev, void *buf);
 
 #else
 
diff --git a/drivers/net/ibm_newemac/zmii.c b/drivers/net/ibm_newemac/zmii.c
index 046dcd069c4..34ed6ee8ca8 100644
--- a/drivers/net/ibm_newemac/zmii.c
+++ b/drivers/net/ibm_newemac/zmii.c
@@ -82,7 +82,7 @@ static inline u32 zmii_mode_mask(int mode, int input)
         }
 }
 
-int __devinit zmii_attach(struct of_device *ofdev, int input, int *mode)
+int __devinit zmii_attach(struct platform_device *ofdev, int input, int *mode)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct zmii_regs __iomem *p = dev->base;
@@ -148,7 +148,7 @@ int __devinit zmii_attach(struct of_device *ofdev, int input, int *mode)
         return 0;
 }
 
-void zmii_get_mdio(struct of_device *ofdev, int input)
+void zmii_get_mdio(struct platform_device *ofdev, int input)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         u32 fer;
@@ -161,7 +161,7 @@ void zmii_get_mdio(struct of_device *ofdev, int input)
         out_be32(&dev->base->fer, fer | ZMII_FER_MDI(input));
 }
 
-void zmii_put_mdio(struct of_device *ofdev, int input)
+void zmii_put_mdio(struct platform_device *ofdev, int input)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -170,7 +170,7 @@ void zmii_put_mdio(struct of_device *ofdev, int input)
 }
 
 
-void zmii_set_speed(struct of_device *ofdev, int input, int speed)
+void zmii_set_speed(struct platform_device *ofdev, int input, int speed)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         u32 ssr;
@@ -191,7 +191,7 @@ void zmii_set_speed(struct of_device *ofdev, int input, int speed)
         mutex_unlock(&dev->lock);
 }
 
-void zmii_detach(struct of_device *ofdev, int input)
+void zmii_detach(struct platform_device *ofdev, int input)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
@@ -210,13 +210,13 @@ void zmii_detach(struct of_device *ofdev, int input)
         mutex_unlock(&dev->lock);
 }
 
-int zmii_get_regs_len(struct of_device *ofdev)
+int zmii_get_regs_len(struct platform_device *ofdev)
 {
         return sizeof(struct emac_ethtool_regs_subhdr) +
                 sizeof(struct zmii_regs);
 }
 
-void *zmii_dump_regs(struct of_device *ofdev, void *buf)
+void *zmii_dump_regs(struct platform_device *ofdev, void *buf)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
         struct emac_ethtool_regs_subhdr *hdr = buf;
@@ -231,7 +231,7 @@ void *zmii_dump_regs(struct of_device *ofdev, void *buf)
         return regs + 1;
 }
 
-static int __devinit zmii_probe(struct of_device *ofdev,
+static int __devinit zmii_probe(struct platform_device *ofdev,
                                 const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -286,7 +286,7 @@ static int __devinit zmii_probe(struct of_device *ofdev,
         return rc;
 }
 
-static int __devexit zmii_remove(struct of_device *ofdev)
+static int __devexit zmii_remove(struct platform_device *ofdev)
 {
         struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/net/ibm_newemac/zmii.h b/drivers/net/ibm_newemac/zmii.h
index 6c9beba0c4b..1333fa2b278 100644
--- a/drivers/net/ibm_newemac/zmii.h
+++ b/drivers/net/ibm_newemac/zmii.h
@@ -48,20 +48,20 @@ struct zmii_instance {
         u32                             fer_save;
 
         /* OF device instance */
-        struct of_device                *ofdev;
+        struct platform_device          *ofdev;
 };
 
 #ifdef CONFIG_IBM_NEW_EMAC_ZMII
 
 extern int zmii_init(void);
 extern void zmii_exit(void);
-extern int zmii_attach(struct of_device *ofdev, int input, int *mode);
-extern void zmii_detach(struct of_device *ofdev, int input);
-extern void zmii_get_mdio(struct of_device *ofdev, int input);
-extern void zmii_put_mdio(struct of_device *ofdev, int input);
-extern void zmii_set_speed(struct of_device *ofdev, int input, int speed);
-extern int zmii_get_regs_len(struct of_device *ocpdev);
-extern void *zmii_dump_regs(struct of_device *ofdev, void *buf);
+extern int zmii_attach(struct platform_device *ofdev, int input, int *mode);
+extern void zmii_detach(struct platform_device *ofdev, int input);
+extern void zmii_get_mdio(struct platform_device *ofdev, int input);
+extern void zmii_put_mdio(struct platform_device *ofdev, int input);
+extern void zmii_set_speed(struct platform_device *ofdev, int input, int speed);
+extern int zmii_get_regs_len(struct platform_device *ocpdev);
+extern void *zmii_dump_regs(struct platform_device *ofdev, void *buf);
 
 #else
 # define zmii_init()            0
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index 4eea3f70c5c..c7b624711f5 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -159,7 +159,7 @@ static void temac_dma_dcr_out(struct temac_local *lp, int reg, u32 value)
  * temac_dcr_setup - If the DMA is DCR based, then setup the address and
  * I/O  functions
  */
-static int temac_dcr_setup(struct temac_local *lp, struct of_device *op,
+static int temac_dcr_setup(struct temac_local *lp, struct platform_device *op,
                                 struct device_node *np)
 {
         unsigned int dcrs;
@@ -184,7 +184,7 @@ static int temac_dcr_setup(struct temac_local *lp, struct of_device *op,
  * temac_dcr_setup - This is a stub for when DCR is not supported,
  * such as with MicroBlaze
  */
-static int temac_dcr_setup(struct temac_local *lp, struct of_device *op,
+static int temac_dcr_setup(struct temac_local *lp, struct platform_device *op,
                                 struct device_node *np)
 {
         return -1;
@@ -952,7 +952,7 @@ static const struct attribute_group temac_attr_group = {
 };
 
 static int __init
-temac_of_probe(struct of_device *op, const struct of_device_id *match)
+temac_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *np;
         struct temac_local *lp;
@@ -1094,7 +1094,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         return rc;
 }
 
-static int __devexit temac_of_remove(struct of_device *op)
+static int __devexit temac_of_remove(struct platform_device *op)
 {
         struct net_device *ndev = dev_get_drvdata(&op->dev);
         struct temac_local *lp = netdev_priv(ndev);
diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index 04e552aa14e..617f898ba5f 100644
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -926,7 +926,7 @@ static const struct net_device_ops myri_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit myri_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit myri_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         static unsigned version_printed;
@@ -1124,7 +1124,7 @@ err:
         return -ENODEV;
 }
 
-static int __devexit myri_sbus_remove(struct of_device *op)
+static int __devexit myri_sbus_remove(struct platform_device *op)
 {
         struct myri_eth *mp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = mp->dev;
diff --git a/drivers/net/myri_sbus.h b/drivers/net/myri_sbus.h
index ff363e95d9c..80a2fa5cf75 100644
--- a/drivers/net/myri_sbus.h
+++ b/drivers/net/myri_sbus.h
@@ -288,7 +288,7 @@ struct myri_eth {
         struct myri_eeprom              eeprom;         /* Local copy of EEPROM.      */
         unsigned int                    reg_size;       /* Size of register space.    */
         unsigned int                    shmem_base;     /* Offset to shared ram.      */
-        struct of_device                *myri_op;       /* Our OF device struct.    */
+        struct platform_device          *myri_op;       /* Our OF device struct.    */
 };
 
 /* We use this to acquire receive skb's that we can DMA directly into. */
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 404f2d55288..bc695d53cdc 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -9103,7 +9103,7 @@ retry:
 static int __devinit niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
 {
 #ifdef CONFIG_SPARC64
-        struct of_device *op = np->op;
+        struct platform_device *op = np->op;
         const u32 *int_prop;
         int i;
 
@@ -9688,7 +9688,7 @@ static void __devinit niu_driver_version(void)
 
 static struct net_device * __devinit niu_alloc_and_init(
         struct device *gen_dev, struct pci_dev *pdev,
-        struct of_device *op, const struct niu_ops *ops,
+        struct platform_device *op, const struct niu_ops *ops,
         u8 port)
 {
         struct net_device *dev;
@@ -10064,7 +10064,7 @@ static const struct niu_ops niu_phys_ops = {
         .unmap_single   = niu_phys_unmap_single,
 };
 
-static int __devinit niu_of_probe(struct of_device *op,
+static int __devinit niu_of_probe(struct platform_device *op,
                                   const struct of_device_id *match)
 {
         union niu_parent_id parent_id;
@@ -10179,7 +10179,7 @@ err_out:
         return err;
 }
 
-static int __devexit niu_of_remove(struct of_device *op)
+static int __devexit niu_of_remove(struct platform_device *op)
 {
         struct net_device *dev = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/net/phy/mdio-gpio.c b/drivers/net/phy/mdio-gpio.c
index fc5fef2a817..f62c7b717bc 100644
--- a/drivers/net/phy/mdio-gpio.c
+++ b/drivers/net/phy/mdio-gpio.c
@@ -188,7 +188,7 @@ static int __devexit mdio_gpio_remove(struct platform_device *pdev)
 
 #ifdef CONFIG_OF_GPIO
 
-static int __devinit mdio_ofgpio_probe(struct of_device *ofdev,
+static int __devinit mdio_ofgpio_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct mdio_gpio_platform_data *pdata;
@@ -224,7 +224,7 @@ out_free:
         return -ENODEV;
 }
 
-static int __devexit mdio_ofgpio_remove(struct of_device *ofdev)
+static int __devexit mdio_ofgpio_remove(struct platform_device *ofdev)
 {
         mdio_gpio_bus_destroy(&ofdev->dev);
         kfree(ofdev->dev.platform_data);
diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index 09c071bd6ad..618643e3ca3 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -97,7 +97,7 @@ static int qec_global_reset(void __iomem *gregs)
 
 static void qec_init(struct bigmac *bp)
 {
-        struct of_device *qec_op = bp->qec_op;
+        struct platform_device *qec_op = bp->qec_op;
         void __iomem *gregs = bp->gregs;
         u8 bsizes = bp->bigmac_bursts;
         u32 regval;
@@ -1083,8 +1083,8 @@ static const struct net_device_ops bigmac_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit bigmac_ether_init(struct of_device *op,
-                                       struct of_device *qec_op)
+static int __devinit bigmac_ether_init(struct platform_device *op,
+                                       struct platform_device *qec_op)
 {
         static int version_printed;
         struct net_device *dev;
@@ -1242,25 +1242,25 @@ fail_and_cleanup:
 /* QEC can be the parent of either QuadEthernet or a BigMAC.  We want
  * the latter.
  */
-static int __devinit bigmac_sbus_probe(struct of_device *op,
+static int __devinit bigmac_sbus_probe(struct platform_device *op,
                                        const struct of_device_id *match)
 {
         struct device *parent = op->dev.parent;
-        struct of_device *qec_op;
+        struct platform_device *qec_op;
 
-        qec_op = to_of_device(parent);
+        qec_op = to_platform_device(parent);
 
         return bigmac_ether_init(op, qec_op);
 }
 
-static int __devexit bigmac_sbus_remove(struct of_device *op)
+static int __devexit bigmac_sbus_remove(struct platform_device *op)
 {
         struct bigmac *bp = dev_get_drvdata(&op->dev);
         struct device *parent = op->dev.parent;
         struct net_device *net_dev = bp->dev;
-        struct of_device *qec_op;
+        struct platform_device *qec_op;
 
-        qec_op = to_of_device(parent);
+        qec_op = to_platform_device(parent);
 
         unregister_netdev(net_dev);
 
diff --git a/drivers/net/sunbmac.h b/drivers/net/sunbmac.h
index 8840bc0b840..8db88945b88 100644
--- a/drivers/net/sunbmac.h
+++ b/drivers/net/sunbmac.h
@@ -329,8 +329,8 @@ struct bigmac {
         unsigned int            timer_ticks;
 
         struct net_device_stats enet_stats;
-        struct of_device        *qec_op;
-        struct of_device        *bigmac_op;
+        struct platform_device  *qec_op;
+        struct platform_device  *bigmac_op;
         struct net_device       *dev;
 };
 
diff --git a/drivers/net/sunhme.c b/drivers/net/sunhme.c
index eec443f6407..bd0df1c1495 100644
--- a/drivers/net/sunhme.c
+++ b/drivers/net/sunhme.c
@@ -1591,7 +1591,7 @@ static int happy_meal_init(struct happy_meal *hp)
                  */
 #ifdef CONFIG_SBUS
                 if ((hp->happy_flags & HFLAG_PCI) == 0) {
-                        struct of_device *op = hp->happy_dev;
+                        struct platform_device *op = hp->happy_dev;
                         if (sbus_can_dma_64bit()) {
                                 sbus_set_sbus64(&op->dev,
                                                 hp->happy_bursts);
@@ -2480,7 +2480,7 @@ static void hme_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info
 #ifdef CONFIG_SBUS
         else {
                 const struct linux_prom_registers *regs;
-                struct of_device *op = hp->happy_dev;
+                struct platform_device *op = hp->happy_dev;
                 regs = of_get_property(op->dev.of_node, "regs", NULL);
                 if (regs)
                         sprintf(info->bus_info, "SBUS:%d",
@@ -2515,13 +2515,13 @@ static int hme_version_printed;
  *
  * Return NULL on failure.
  */
-static struct quattro * __devinit quattro_sbus_find(struct of_device *child)
+static struct quattro * __devinit quattro_sbus_find(struct platform_device *child)
 {
         struct device *parent = child->dev.parent;
-        struct of_device *op;
+        struct platform_device *op;
         struct quattro *qp;
 
-        op = to_of_device(parent);
+        op = to_platform_device(parent);
         qp = dev_get_drvdata(&op->dev);
         if (qp)
                 return qp;
@@ -2551,7 +2551,7 @@ static int __init quattro_sbus_register_irqs(void)
         struct quattro *qp;
 
         for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) {
-                struct of_device *op = qp->quattro_dev;
+                struct platform_device *op = qp->quattro_dev;
                 int err, qfe_slot, skip = 0;
 
                 for (qfe_slot = 0; qfe_slot < 4; qfe_slot++) {
@@ -2580,7 +2580,7 @@ static void quattro_sbus_free_irqs(void)
         struct quattro *qp;
 
         for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) {
-                struct of_device *op = qp->quattro_dev;
+                struct platform_device *op = qp->quattro_dev;
                 int qfe_slot, skip = 0;
 
                 for (qfe_slot = 0; qfe_slot < 4; qfe_slot++) {
@@ -2639,7 +2639,7 @@ static const struct net_device_ops hme_netdev_ops = {
 };
 
 #ifdef CONFIG_SBUS
-static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
+static int __devinit happy_meal_sbus_probe_one(struct platform_device *op, int is_qfe)
 {
         struct device_node *dp = op->dev.of_node, *sbus_dp;
         struct quattro *qp = NULL;
@@ -2648,7 +2648,7 @@ static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
         int i, qfe_slot = -1;
         int err = -ENODEV;
 
-        sbus_dp = to_of_device(op->dev.parent)->dev.of_node;
+        sbus_dp = op->dev.parent->of_node;
 
         /* We can match PCI devices too, do not accept those here. */
         if (strcmp(sbus_dp->name, "sbus"))
@@ -3235,7 +3235,7 @@ static void happy_meal_pci_exit(void)
 #endif
 
 #ifdef CONFIG_SBUS
-static int __devinit hme_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit hme_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         const char *model = of_get_property(dp, "model", NULL);
@@ -3247,7 +3247,7 @@ static int __devinit hme_sbus_probe(struct of_device *op, const struct of_device
         return happy_meal_sbus_probe_one(op, is_qfe);
 }
 
-static int __devexit hme_sbus_remove(struct of_device *op)
+static int __devexit hme_sbus_remove(struct platform_device *op)
 {
         struct happy_meal *hp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = hp->dev;
diff --git a/drivers/net/sunhme.h b/drivers/net/sunhme.h
index efd2ca0fcad..756b5bf3aa8 100644
--- a/drivers/net/sunhme.h
+++ b/drivers/net/sunhme.h
@@ -407,7 +407,7 @@ struct happy_meal {
         void (*write_rxd)(struct happy_meal_rxd *, u32, u32);
 #endif
 
-        /* This is either an of_device or a pci_dev. */
+        /* This is either an platform_device or a pci_dev. */
         void                      *happy_dev;
         struct device             *dma_dev;
 
diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index ee364fa7563..8dcb858f216 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -250,7 +250,7 @@ struct lance_private {
         int             rx_new, tx_new;
         int             rx_old, tx_old;
 
-        struct of_device *ledma;        /* If set this points to ledma  */
+        struct platform_device *ledma;  /* If set this points to ledma  */
         char            tpe;            /* cable-selection is TPE       */
         char            auto_select;    /* cable-selection by carrier   */
         char            burst_sizes;    /* ledma SBus burst sizes       */
@@ -265,8 +265,8 @@ struct lance_private {
         char                   *name;
         dma_addr_t              init_block_dvma;
         struct net_device      *dev;              /* Backpointer        */
-        struct of_device       *op;
-        struct of_device       *lebuffer;
+        struct platform_device       *op;
+        struct platform_device       *lebuffer;
         struct timer_list       multicast_timer;
 };
 
@@ -1272,7 +1272,7 @@ static void lance_free_hwresources(struct lance_private *lp)
         if (lp->lregs)
                 of_iounmap(&lp->op->resource[0], lp->lregs, LANCE_REG_SIZE);
         if (lp->dregs) {
-                struct of_device *ledma = lp->ledma;
+                struct platform_device *ledma = lp->ledma;
 
                 of_iounmap(&ledma->resource[0], lp->dregs,
                            resource_size(&ledma->resource[0]));
@@ -1319,9 +1319,9 @@ static const struct net_device_ops sparc_lance_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit sparc_lance_probe_one(struct of_device *op,
-                                           struct of_device *ledma,
-                                           struct of_device *lebuffer)
+static int __devinit sparc_lance_probe_one(struct platform_device *op,
+                                           struct platform_device *ledma,
+                                           struct platform_device *lebuffer)
 {
         struct device_node *dp = op->dev.of_node;
         static unsigned version_printed;
@@ -1503,9 +1503,9 @@ fail:
         return -ENODEV;
 }
 
-static int __devinit sunlance_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit sunlance_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
-        struct of_device *parent = to_of_device(op->dev.parent);
+        struct platform_device *parent = to_platform_device(op->dev.parent);
         struct device_node *parent_dp = parent->dev.of_node;
         int err;
 
@@ -1519,7 +1519,7 @@ static int __devinit sunlance_sbus_probe(struct of_device *op, const struct of_d
         return err;
 }
 
-static int __devexit sunlance_sbus_remove(struct of_device *op)
+static int __devexit sunlance_sbus_remove(struct platform_device *op)
 {
         struct lance_private *lp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = lp->dev;
diff --git a/drivers/net/sunqe.c b/drivers/net/sunqe.c
index 5f84a5daded..72e65d4666e 100644
--- a/drivers/net/sunqe.c
+++ b/drivers/net/sunqe.c
@@ -689,7 +689,7 @@ static void qe_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
         const struct linux_prom_registers *regs;
         struct sunqe *qep = netdev_priv(dev);
-        struct of_device *op;
+        struct platform_device *op;
 
         strcpy(info->driver, "sunqe");
         strcpy(info->version, "3.0");
@@ -720,7 +720,7 @@ static const struct ethtool_ops qe_ethtool_ops = {
 };
 
 /* This is only called once at boot time for each card probed. */
-static void qec_init_once(struct sunqec *qecp, struct of_device *op)
+static void qec_init_once(struct sunqec *qecp, struct platform_device *op)
 {
         u8 bsizes = qecp->qec_bursts;
 
@@ -770,9 +770,9 @@ static u8 __devinit qec_get_burst(struct device_node *dp)
         return bsizes;
 }
 
-static struct sunqec * __devinit get_qec(struct of_device *child)
+static struct sunqec * __devinit get_qec(struct platform_device *child)
 {
-        struct of_device *op = to_of_device(child->dev.parent);
+        struct platform_device *op = to_platform_device(child->dev.parent);
         struct sunqec *qecp;
 
         qecp = dev_get_drvdata(&op->dev);
@@ -836,7 +836,7 @@ static const struct net_device_ops qec_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-static int __devinit qec_ether_init(struct of_device *op)
+static int __devinit qec_ether_init(struct platform_device *op)
 {
         static unsigned version_printed;
         struct net_device *dev;
@@ -941,12 +941,12 @@ fail:
         return res;
 }
 
-static int __devinit qec_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit qec_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         return qec_ether_init(op);
 }
 
-static int __devexit qec_sbus_remove(struct of_device *op)
+static int __devexit qec_sbus_remove(struct platform_device *op)
 {
         struct sunqe *qp = dev_get_drvdata(&op->dev);
         struct net_device *net_dev = qp->dev;
@@ -997,7 +997,7 @@ static void __exit qec_exit(void)
 
         while (root_qec_dev) {
                 struct sunqec *next = root_qec_dev->next_module;
-                struct of_device *op = root_qec_dev->op;
+                struct platform_device *op = root_qec_dev->op;
 
                 free_irq(op->archdata.irqs[0], (void *) root_qec_dev);
                 of_iounmap(&op->resource[0], root_qec_dev->gregs,
diff --git a/drivers/net/sunqe.h b/drivers/net/sunqe.h
index 5813a7b2faa..581781b6b2f 100644
--- a/drivers/net/sunqe.h
+++ b/drivers/net/sunqe.h
@@ -314,7 +314,7 @@ struct sunqec {
         void __iomem            *gregs;         /* QEC Global Registers         */
         struct sunqe            *qes[4];        /* Each child MACE              */
         unsigned int            qec_bursts;     /* Support burst sizes          */
-        struct of_device        *op;            /* QEC's OF device              */
+        struct platform_device  *op;            /* QEC's OF device              */
         struct sunqec           *next_module;   /* List of all QECs in system   */
 };
 
@@ -342,7 +342,7 @@ struct sunqe {
         __u32                           buffers_dvma;   /* DVMA visible address.       */
         struct sunqec                   *parent;
         u8                              mconfig;        /* Base MACE mconfig value     */
-        struct of_device                *op;            /* QE's OF device struct       */
+        struct platform_device          *op;            /* QE's OF device struct       */
         struct net_device               *dev;           /* QE's netdevice struct       */
         int                             channel;        /* Who am I?                   */
 };
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 8d532f9b50d..a4c3f570824 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3601,7 +3601,7 @@ static void ucc_geth_timeout(struct net_device *dev)
 
 #ifdef CONFIG_PM
 
-static int ucc_geth_suspend(struct of_device *ofdev, pm_message_t state)
+static int ucc_geth_suspend(struct platform_device *ofdev, pm_message_t state)
 {
         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
         struct ucc_geth_private *ugeth = netdev_priv(ndev);
@@ -3629,7 +3629,7 @@ static int ucc_geth_suspend(struct of_device *ofdev, pm_message_t state)
         return 0;
 }
 
-static int ucc_geth_resume(struct of_device *ofdev)
+static int ucc_geth_resume(struct platform_device *ofdev)
 {
         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
         struct ucc_geth_private *ugeth = netdev_priv(ndev);
@@ -3732,7 +3732,7 @@ static const struct net_device_ops ucc_geth_netdev_ops = {
 #endif
 };
 
-static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *match)
+static int ucc_geth_probe(struct platform_device* ofdev, const struct of_device_id *match)
 {
         struct device *device = &ofdev->dev;
         struct device_node *np = ofdev->dev.of_node;
@@ -3954,7 +3954,7 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
         return 0;
 }
 
-static int ucc_geth_remove(struct of_device* ofdev)
+static int ucc_geth_remove(struct platform_device* ofdev)
 {
         struct device *device = &ofdev->dev;
         struct net_device *dev = dev_get_drvdata(device);
diff --git a/drivers/net/xilinx_emaclite.c b/drivers/net/xilinx_emaclite.c
index b2c2f391b29..ecbbb688eba 100644
--- a/drivers/net/xilinx_emaclite.c
+++ b/drivers/net/xilinx_emaclite.c
@@ -1086,7 +1086,7 @@ static void xemaclite_remove_ndev(struct net_device *ndev)
  *
  * Return:      Value of the parameter if the parameter is found, or 0 otherwise
  */
-static bool get_bool(struct of_device *ofdev, const char *s)
+static bool get_bool(struct platform_device *ofdev, const char *s)
 {
         u32 *p = (u32 *)of_get_property(ofdev->dev.of_node, s, NULL);
 
@@ -1115,7 +1115,7 @@ static struct net_device_ops xemaclite_netdev_ops;
  * Return:      0, if the driver is bound to the Emaclite device, or
  *              a negative error if there is failure.
  */
-static int __devinit xemaclite_of_probe(struct of_device *ofdev,
+static int __devinit xemaclite_of_probe(struct platform_device *ofdev,
                                         const struct of_device_id *match)
 {
         struct resource r_irq; /* Interrupt resources */
@@ -1240,7 +1240,7 @@ error2:
  *
  * Return:      0, always.
  */
-static int __devexit xemaclite_of_remove(struct of_device *of_dev)
+static int __devexit xemaclite_of_remove(struct platform_device *of_dev)
 {
         struct device *dev = &of_dev->dev;
         struct net_device *ndev = dev_get_drvdata(dev);
diff --git a/drivers/of/device.c b/drivers/of/device.c
index 0d8a0644f54..92de0eb74ae 100644
--- a/drivers/of/device.c
+++ b/drivers/of/device.c
@@ -14,7 +14,7 @@
  * @ids: array of of device match structures to search in
  * @dev: the of device structure to match against
  *
- * Used by a driver to check whether an of_device present in the
+ * Used by a driver to check whether an platform_device present in the
  * system is in its list of supported devices.
  */
 const struct of_device_id *of_match_device(const struct of_device_id *matches,
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index 210a6441a06..55ba118f1cf 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -286,7 +286,7 @@ static struct parport_operations parport_sunbpp_ops =
         .owner          = THIS_MODULE,
 };
 
-static int __devinit bpp_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit bpp_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct parport_operations *ops;
         struct bpp_regs __iomem *regs;
@@ -351,7 +351,7 @@ out_unmap:
         return err;
 }
 
-static int __devexit bpp_remove(struct of_device *op)
+static int __devexit bpp_remove(struct platform_device *op)
 {
         struct parport *p = dev_get_drvdata(&op->dev);
         struct parport_operations *ops = p->ops;
diff --git a/drivers/pcmcia/electra_cf.c b/drivers/pcmcia/electra_cf.c
index f94d8281cfb..546d3024b6f 100644
--- a/drivers/pcmcia/electra_cf.c
+++ b/drivers/pcmcia/electra_cf.c
@@ -44,7 +44,7 @@ struct electra_cf_socket {
         unsigned                present:1;
         unsigned                active:1;
 
-        struct of_device        *ofdev;
+        struct platform_device  *ofdev;
         unsigned long           mem_phys;
         void __iomem *          mem_base;
         unsigned long           mem_size;
@@ -181,7 +181,7 @@ static struct pccard_operations electra_cf_ops = {
         .set_mem_map            = electra_cf_set_mem_map,
 };
 
-static int __devinit electra_cf_probe(struct of_device *ofdev,
+static int __devinit electra_cf_probe(struct platform_device *ofdev,
                                       const struct of_device_id *match)
 {
         struct device *device = &ofdev->dev;
@@ -325,7 +325,7 @@ fail1:
 
 }
 
-static int __devexit electra_cf_remove(struct of_device *ofdev)
+static int __devexit electra_cf_remove(struct platform_device *ofdev)
 {
         struct device *device = &ofdev->dev;
         struct electra_cf_socket *cf;
diff --git a/drivers/pcmcia/m8xx_pcmcia.c b/drivers/pcmcia/m8xx_pcmcia.c
index f2f90a7d3e1..f0ecad99ce8 100644
--- a/drivers/pcmcia/m8xx_pcmcia.c
+++ b/drivers/pcmcia/m8xx_pcmcia.c
@@ -1149,7 +1149,7 @@ static struct pccard_operations m8xx_services = {
         .set_mem_map = m8xx_set_mem_map,
 };
 
-static int __init m8xx_probe(struct of_device *ofdev,
+static int __init m8xx_probe(struct platform_device *ofdev,
                              const struct of_device_id *match)
 {
         struct pcmcia_win *w;
@@ -1249,7 +1249,7 @@ static int __init m8xx_probe(struct of_device *ofdev,
         return 0;
 }
 
-static int m8xx_remove(struct of_device *ofdev)
+static int m8xx_remove(struct platform_device *ofdev)
 {
         u32 m, i;
         struct pcmcia_win *w;
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
index db5d8c416d2..dfcdf0901d2 100644
--- a/drivers/rtc/rtc-mpc5121.c
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -268,7 +268,7 @@ static const struct rtc_class_ops mpc5121_rtc_ops = {
         .update_irq_enable = mpc5121_rtc_update_irq_enable,
 };
 
-static int __devinit mpc5121_rtc_probe(struct of_device *op,
+static int __devinit mpc5121_rtc_probe(struct platform_device *op,
                                         const struct of_device_id *match)
 {
         struct mpc5121_rtc_data *rtc;
@@ -338,7 +338,7 @@ out_free:
         return err;
 }
 
-static int __devexit mpc5121_rtc_remove(struct of_device *op)
+static int __devexit mpc5121_rtc_remove(struct platform_device *op)
 {
         struct mpc5121_rtc_data *rtc = dev_get_drvdata(&op->dev);
         struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
diff --git a/drivers/sbus/char/bbc_envctrl.c b/drivers/sbus/char/bbc_envctrl.c
index 103fdf6b0b8..160e7510aca 100644
--- a/drivers/sbus/char/bbc_envctrl.c
+++ b/drivers/sbus/char/bbc_envctrl.c
@@ -443,7 +443,7 @@ static int kenvctrld(void *__unused)
         return 0;
 }
 
-static void attach_one_temp(struct bbc_i2c_bus *bp, struct of_device *op,
+static void attach_one_temp(struct bbc_i2c_bus *bp, struct platform_device *op,
                             int temp_idx)
 {
         struct bbc_cpu_temperature *tp;
@@ -488,7 +488,7 @@ static void attach_one_temp(struct bbc_i2c_bus *bp, struct of_device *op,
         tp->fan_todo[FAN_CPU] = FAN_SAME;
 }
 
-static void attach_one_fan(struct bbc_i2c_bus *bp, struct of_device *op,
+static void attach_one_fan(struct bbc_i2c_bus *bp, struct platform_device *op,
                            int fan_idx)
 {
         struct bbc_fan_control *fp;
@@ -559,7 +559,7 @@ static void destroy_all_fans(struct bbc_i2c_bus *bp)
 
 int bbc_envctrl_init(struct bbc_i2c_bus *bp)
 {
-        struct of_device *op;
+        struct platform_device *op;
         int temp_index = 0;
         int fan_index = 0;
         int devidx = 0;
diff --git a/drivers/sbus/char/bbc_i2c.c b/drivers/sbus/char/bbc_i2c.c
index 3e89c313e98..614a5e114a1 100644
--- a/drivers/sbus/char/bbc_i2c.c
+++ b/drivers/sbus/char/bbc_i2c.c
@@ -51,7 +51,7 @@
  * The second controller also connects to the smartcard reader, if present.
  */
 
-static void set_device_claimage(struct bbc_i2c_bus *bp, struct of_device *op, int val)
+static void set_device_claimage(struct bbc_i2c_bus *bp, struct platform_device *op, int val)
 {
         int i;
 
@@ -66,9 +66,9 @@ static void set_device_claimage(struct bbc_i2c_bus *bp, struct of_device *op, in
 #define claim_device(BP,ECHILD)         set_device_claimage(BP,ECHILD,1)
 #define release_device(BP,ECHILD)       set_device_claimage(BP,ECHILD,0)
 
-struct of_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
+struct platform_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
 {
-        struct of_device *op = NULL;
+        struct platform_device *op = NULL;
         int curidx = 0, i;
 
         for (i = 0; i < NUM_CHILDREN; i++) {
@@ -86,7 +86,7 @@ out:
         return NULL;
 }
 
-struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct of_device *op)
+struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct platform_device *op)
 {
         struct bbc_i2c_client *client;
         const u32 *reg;
@@ -114,7 +114,7 @@ struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct of_device *
 void bbc_i2c_detach(struct bbc_i2c_client *client)
 {
         struct bbc_i2c_bus *bp = client->bp;
-        struct of_device *op = client->op;
+        struct platform_device *op = client->op;
 
         release_device(bp, op);
         kfree(client);
@@ -297,7 +297,7 @@ static void __init reset_one_i2c(struct bbc_i2c_bus *bp)
         writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
 }
 
-static struct bbc_i2c_bus * __init attach_one_i2c(struct of_device *op, int index)
+static struct bbc_i2c_bus * __init attach_one_i2c(struct platform_device *op, int index)
 {
         struct bbc_i2c_bus *bp;
         struct device_node *dp;
@@ -330,7 +330,7 @@ static struct bbc_i2c_bus * __init attach_one_i2c(struct of_device *op, int inde
         for (dp = op->dev.of_node->child;
              dp && entry < 8;
              dp = dp->sibling, entry++) {
-                struct of_device *child_op;
+                struct platform_device *child_op;
 
                 child_op = of_find_device_by_node(dp);
                 bp->devs[entry].device = child_op;
@@ -361,7 +361,7 @@ fail:
 extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
 extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
 
-static int __devinit bbc_i2c_probe(struct of_device *op,
+static int __devinit bbc_i2c_probe(struct platform_device *op,
                                    const struct of_device_id *match)
 {
         struct bbc_i2c_bus *bp;
@@ -386,7 +386,7 @@ static int __devinit bbc_i2c_probe(struct of_device *op,
         return err;
 }
 
-static int __devexit bbc_i2c_remove(struct of_device *op)
+static int __devexit bbc_i2c_remove(struct platform_device *op)
 {
         struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/sbus/char/bbc_i2c.h b/drivers/sbus/char/bbc_i2c.h
index 83c4811b7b5..4b4531066e7 100644
--- a/drivers/sbus/char/bbc_i2c.h
+++ b/drivers/sbus/char/bbc_i2c.h
@@ -7,7 +7,7 @@
 
 struct bbc_i2c_client {
         struct bbc_i2c_bus              *bp;
-        struct of_device                *op;
+        struct platform_device          *op;
         int                             bus;
         int                             address;
 };
@@ -64,16 +64,16 @@ struct bbc_i2c_bus {
         struct list_head                temps;
         struct list_head                fans;
 
-        struct of_device                *op;
+        struct platform_device          *op;
         struct {
-                struct of_device        *device;
+                struct platform_device  *device;
                 int                     client_claimed;
         } devs[NUM_CHILDREN];
 };
 
 /* Probing and attachment. */
-extern struct of_device *bbc_i2c_getdev(struct bbc_i2c_bus *, int);
-extern struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct of_device *);
+extern struct platform_device *bbc_i2c_getdev(struct bbc_i2c_bus *, int);
+extern struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct platform_device *);
 extern void bbc_i2c_detach(struct bbc_i2c_client *);
 
 /* Register read/write.  NOTE: Blocking! */
diff --git a/drivers/sbus/char/display7seg.c b/drivers/sbus/char/display7seg.c
index 47db97583ea..1690e53fb84 100644
--- a/drivers/sbus/char/display7seg.c
+++ b/drivers/sbus/char/display7seg.c
@@ -170,7 +170,7 @@ static struct miscdevice d7s_miscdev = {
         .fops           = &d7s_fops
 };
 
-static int __devinit d7s_probe(struct of_device *op,
+static int __devinit d7s_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct device_node *opts;
@@ -236,7 +236,7 @@ out_free:
         goto out;
 }
 
-static int __devexit d7s_remove(struct of_device *op)
+static int __devexit d7s_remove(struct platform_device *op)
 {
         struct d7s *p = dev_get_drvdata(&op->dev);
         u8 regs = readb(p->regs);
diff --git a/drivers/sbus/char/envctrl.c b/drivers/sbus/char/envctrl.c
index 3c27f45e2b6..078e5f4520e 100644
--- a/drivers/sbus/char/envctrl.c
+++ b/drivers/sbus/char/envctrl.c
@@ -1027,7 +1027,7 @@ static int kenvctrld(void *__unused)
         return 0;
 }
 
-static int __devinit envctrl_probe(struct of_device *op,
+static int __devinit envctrl_probe(struct platform_device *op,
                                    const struct of_device_id *match)
 {
         struct device_node *dp;
@@ -1104,7 +1104,7 @@ out_iounmap:
         return err;
 }
 
-static int __devexit envctrl_remove(struct of_device *op)
+static int __devexit envctrl_remove(struct platform_device *op)
 {
         int index;
 
diff --git a/drivers/sbus/char/flash.c b/drivers/sbus/char/flash.c
index 8bb31c584b6..2b4b4b613c4 100644
--- a/drivers/sbus/char/flash.c
+++ b/drivers/sbus/char/flash.c
@@ -160,7 +160,7 @@ static const struct file_operations flash_fops = {
 
 static struct miscdevice flash_dev = { FLASH_MINOR, "flash", &flash_fops };
 
-static int __devinit flash_probe(struct of_device *op,
+static int __devinit flash_probe(struct platform_device *op,
                                  const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -192,7 +192,7 @@ static int __devinit flash_probe(struct of_device *op,
         return misc_register(&flash_dev);
 }
 
-static int __devexit flash_remove(struct of_device *op)
+static int __devexit flash_remove(struct platform_device *op)
 {
         misc_deregister(&flash_dev);
 
diff --git a/drivers/sbus/char/uctrl.c b/drivers/sbus/char/uctrl.c
index 41eb6725ff5..1b345be5cc0 100644
--- a/drivers/sbus/char/uctrl.c
+++ b/drivers/sbus/char/uctrl.c
@@ -348,7 +348,7 @@ static void uctrl_get_external_status(struct uctrl_driver *driver)
         
 }
 
-static int __devinit uctrl_probe(struct of_device *op,
+static int __devinit uctrl_probe(struct platform_device *op,
                                  const struct of_device_id *match)
 {
         struct uctrl_driver *p;
@@ -404,7 +404,7 @@ out_free:
         goto out;
 }
 
-static int __devexit uctrl_remove(struct of_device *op)
+static int __devexit uctrl_remove(struct platform_device *op)
 {
         struct uctrl_driver *p = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/scsi/qlogicpti.c b/drivers/scsi/qlogicpti.c
index 53d7ed0dc16..f8c561cf751 100644
--- a/drivers/scsi/qlogicpti.c
+++ b/drivers/scsi/qlogicpti.c
@@ -704,7 +704,7 @@ static void __devexit qpti_chain_del(struct qlogicpti *qpti)
 
 static int __devinit qpti_map_regs(struct qlogicpti *qpti)
 {
-        struct of_device *op = qpti->op;
+        struct platform_device *op = qpti->op;
 
         qpti->qregs = of_ioremap(&op->resource[0], 0,
                                  resource_size(&op->resource[0]),
@@ -727,7 +727,7 @@ static int __devinit qpti_map_regs(struct qlogicpti *qpti)
 
 static int __devinit qpti_register_irq(struct qlogicpti *qpti)
 {
-        struct of_device *op = qpti->op;
+        struct platform_device *op = qpti->op;
 
         qpti->qhost->irq = qpti->irq = op->archdata.irqs[0];
 
@@ -752,7 +752,7 @@ fail:
 
 static void __devinit qpti_get_scsi_id(struct qlogicpti *qpti)
 {
-        struct of_device *op = qpti->op;
+        struct platform_device *op = qpti->op;
         struct device_node *dp;
 
         dp = op->dev.of_node;
@@ -773,7 +773,7 @@ static void __devinit qpti_get_scsi_id(struct qlogicpti *qpti)
 
 static void qpti_get_bursts(struct qlogicpti *qpti)
 {
-        struct of_device *op = qpti->op;
+        struct platform_device *op = qpti->op;
         u8 bursts, bmask;
 
         bursts = of_getintprop_default(op->dev.of_node, "burst-sizes", 0xff);
@@ -806,7 +806,7 @@ static void qpti_get_clock(struct qlogicpti *qpti)
  */
 static int __devinit qpti_map_queues(struct qlogicpti *qpti)
 {
-        struct of_device *op = qpti->op;
+        struct platform_device *op = qpti->op;
 
 #define QSIZE(entries)  (((entries) + 1) * QUEUE_ENTRY_LEN)
         qpti->res_cpu = dma_alloc_coherent(&op->dev,
@@ -1290,7 +1290,7 @@ static struct scsi_host_template qpti_template = {
         .use_clustering         = ENABLE_CLUSTERING,
 };
 
-static int __devinit qpti_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit qpti_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct scsi_host_template *tpnt = match->data;
         struct device_node *dp = op->dev.of_node;
@@ -1401,7 +1401,7 @@ fail_unlink:
         return -ENODEV;
 }
 
-static int __devexit qpti_sbus_remove(struct of_device *op)
+static int __devexit qpti_sbus_remove(struct platform_device *op)
 {
         struct qlogicpti *qpti = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/scsi/qlogicpti.h b/drivers/scsi/qlogicpti.h
index e3c74d1ee2d..4377e87ee79 100644
--- a/drivers/scsi/qlogicpti.h
+++ b/drivers/scsi/qlogicpti.h
@@ -342,7 +342,7 @@ struct qlogicpti {
         u_int                     req_in_ptr;           /* index of next request slot */
         u_int                     res_out_ptr;          /* index of next result slot  */
         long                      send_marker;          /* must we send a marker?     */
-        struct of_device         *op;
+        struct platform_device   *op;
         unsigned long             __pad;
 
         int                       cmd_count[MAX_TARGETS];
diff --git a/drivers/scsi/sun_esp.c b/drivers/scsi/sun_esp.c
index 89ba6fe02f8..193b37ba183 100644
--- a/drivers/scsi/sun_esp.c
+++ b/drivers/scsi/sun_esp.c
@@ -44,7 +44,7 @@ enum dvma_rev {
 };
 
 static int __devinit esp_sbus_setup_dma(struct esp *esp,
-                                        struct of_device *dma_of)
+                                        struct platform_device *dma_of)
 {
         esp->dma = dma_of;
 
@@ -81,7 +81,7 @@ static int __devinit esp_sbus_setup_dma(struct esp *esp,
 
 static int __devinit esp_sbus_map_regs(struct esp *esp, int hme)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
         struct resource *res;
 
         /* On HME, two reg sets exist, first is DVMA,
@@ -101,7 +101,7 @@ static int __devinit esp_sbus_map_regs(struct esp *esp, int hme)
 
 static int __devinit esp_sbus_map_command_block(struct esp *esp)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
 
         esp->command_block = dma_alloc_coherent(&op->dev, 16,
                                                 &esp->command_block_dma,
@@ -114,15 +114,15 @@ static int __devinit esp_sbus_map_command_block(struct esp *esp)
 static int __devinit esp_sbus_register_irq(struct esp *esp)
 {
         struct Scsi_Host *host = esp->host;
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
 
         host->irq = op->archdata.irqs[0];
         return request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp);
 }
 
-static void __devinit esp_get_scsi_id(struct esp *esp, struct of_device *espdma)
+static void __devinit esp_get_scsi_id(struct esp *esp, struct platform_device *espdma)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
         struct device_node *dp;
 
         dp = op->dev.of_node;
@@ -144,7 +144,7 @@ done:
 
 static void __devinit esp_get_differential(struct esp *esp)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
         struct device_node *dp;
 
         dp = op->dev.of_node;
@@ -156,7 +156,7 @@ static void __devinit esp_get_differential(struct esp *esp)
 
 static void __devinit esp_get_clock_params(struct esp *esp)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
         struct device_node *bus_dp, *dp;
         int fmhz;
 
@@ -170,10 +170,10 @@ static void __devinit esp_get_clock_params(struct esp *esp)
         esp->cfreq = fmhz;
 }
 
-static void __devinit esp_get_bursts(struct esp *esp, struct of_device *dma_of)
+static void __devinit esp_get_bursts(struct esp *esp, struct platform_device *dma_of)
 {
         struct device_node *dma_dp = dma_of->dev.of_node;
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
         struct device_node *dp;
         u8 bursts, val;
 
@@ -195,7 +195,7 @@ static void __devinit esp_get_bursts(struct esp *esp, struct of_device *dma_of)
         esp->bursts = bursts;
 }
 
-static void __devinit esp_sbus_get_props(struct esp *esp, struct of_device *espdma)
+static void __devinit esp_sbus_get_props(struct esp *esp, struct platform_device *espdma)
 {
         esp_get_scsi_id(esp, espdma);
         esp_get_differential(esp);
@@ -216,7 +216,7 @@ static u8 sbus_esp_read8(struct esp *esp, unsigned long reg)
 static dma_addr_t sbus_esp_map_single(struct esp *esp, void *buf,
                                       size_t sz, int dir)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
 
         return dma_map_single(&op->dev, buf, sz, dir);
 }
@@ -224,7 +224,7 @@ static dma_addr_t sbus_esp_map_single(struct esp *esp, void *buf,
 static int sbus_esp_map_sg(struct esp *esp, struct scatterlist *sg,
                                   int num_sg, int dir)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
 
         return dma_map_sg(&op->dev, sg, num_sg, dir);
 }
@@ -232,7 +232,7 @@ static int sbus_esp_map_sg(struct esp *esp, struct scatterlist *sg,
 static void sbus_esp_unmap_single(struct esp *esp, dma_addr_t addr,
                                   size_t sz, int dir)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
 
         dma_unmap_single(&op->dev, addr, sz, dir);
 }
@@ -240,7 +240,7 @@ static void sbus_esp_unmap_single(struct esp *esp, dma_addr_t addr,
 static void sbus_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
                               int num_sg, int dir)
 {
-        struct of_device *op = esp->dev;
+        struct platform_device *op = esp->dev;
 
         dma_unmap_sg(&op->dev, sg, num_sg, dir);
 }
@@ -256,7 +256,7 @@ static void sbus_esp_reset_dma(struct esp *esp)
 {
         int can_do_burst16, can_do_burst32, can_do_burst64;
         int can_do_sbus64, lim;
-        struct of_device *op;
+        struct platform_device *op;
         u32 val;
 
         can_do_burst16 = (esp->bursts & DMA_BURST16) != 0;
@@ -487,8 +487,8 @@ static const struct esp_driver_ops sbus_esp_ops = {
         .dma_error      =       sbus_esp_dma_error,
 };
 
-static int __devinit esp_sbus_probe_one(struct of_device *op,
-                                        struct of_device *espdma,
+static int __devinit esp_sbus_probe_one(struct platform_device *op,
+                                        struct platform_device *espdma,
                                         int hme)
 {
         struct scsi_host_template *tpnt = &scsi_esp_template;
@@ -562,11 +562,11 @@ fail:
         return err;
 }
 
-static int __devinit esp_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit esp_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dma_node = NULL;
         struct device_node *dp = op->dev.of_node;
-        struct of_device *dma_of = NULL;
+        struct platform_device *dma_of = NULL;
         int hme = 0;
 
         if (dp->parent &&
@@ -585,10 +585,10 @@ static int __devinit esp_sbus_probe(struct of_device *op, const struct of_device
         return esp_sbus_probe_one(op, dma_of, hme);
 }
 
-static int __devexit esp_sbus_remove(struct of_device *op)
+static int __devexit esp_sbus_remove(struct platform_device *op)
 {
         struct esp *esp = dev_get_drvdata(&op->dev);
-        struct of_device *dma_of = esp->dma;
+        struct platform_device *dma_of = esp->dma;
         unsigned int irq = esp->host->irq;
         bool is_hme;
         u32 val;
diff --git a/drivers/serial/apbuart.c b/drivers/serial/apbuart.c
index 0099b8692b6..cc01c650a14 100644
--- a/drivers/serial/apbuart.c
+++ b/drivers/serial/apbuart.c
@@ -551,7 +551,7 @@ static struct uart_driver grlib_apbuart_driver = {
 /* OF Platform Driver                                                       */
 /* ======================================================================== */
 
-static int __devinit apbuart_probe(struct of_device *op,
+static int __devinit apbuart_probe(struct platform_device *op,
                                    const struct of_device_id *match)
 {
         int i = -1;
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index 6016179db53..f2b8adcc6c9 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -1340,7 +1340,7 @@ static struct uart_driver cpm_reg = {
 
 static int probe_index;
 
-static int __devinit cpm_uart_probe(struct of_device *ofdev,
+static int __devinit cpm_uart_probe(struct platform_device *ofdev,
                                     const struct of_device_id *match)
 {
         int index = probe_index++;
@@ -1364,7 +1364,7 @@ static int __devinit cpm_uart_probe(struct of_device *ofdev,
         return uart_add_one_port(&cpm_reg, &pinfo->port);
 }
 
-static int __devexit cpm_uart_remove(struct of_device *ofdev)
+static int __devexit cpm_uart_remove(struct platform_device *ofdev)
 {
         struct uart_cpm_port *pinfo = dev_get_drvdata(&ofdev->dev);
         return uart_remove_one_port(&cpm_reg, &pinfo->port);
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index 1a88b363005..8dedb266f14 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -1298,7 +1298,7 @@ static struct of_device_id mpc52xx_uart_of_match[] = {
 };
 
 static int __devinit
-mpc52xx_uart_of_probe(struct of_device *op, const struct of_device_id *match)
+mpc52xx_uart_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         int idx = -1;
         unsigned int uartclk;
@@ -1369,7 +1369,7 @@ mpc52xx_uart_of_probe(struct of_device *op, const struct of_device_id *match)
 }
 
 static int
-mpc52xx_uart_of_remove(struct of_device *op)
+mpc52xx_uart_of_remove(struct platform_device *op)
 {
         struct uart_port *port = dev_get_drvdata(&op->dev);
         dev_set_drvdata(&op->dev, NULL);
@@ -1382,7 +1382,7 @@ mpc52xx_uart_of_remove(struct of_device *op)
 
 #ifdef CONFIG_PM
 static int
-mpc52xx_uart_of_suspend(struct of_device *op, pm_message_t state)
+mpc52xx_uart_of_suspend(struct platform_device *op, pm_message_t state)
 {
         struct uart_port *port = (struct uart_port *) dev_get_drvdata(&op->dev);
 
@@ -1393,7 +1393,7 @@ mpc52xx_uart_of_suspend(struct of_device *op, pm_message_t state)
 }
 
 static int
-mpc52xx_uart_of_resume(struct of_device *op)
+mpc52xx_uart_of_resume(struct platform_device *op)
 {
         struct uart_port *port = (struct uart_port *) dev_get_drvdata(&op->dev);
 
diff --git a/drivers/serial/nwpserial.c b/drivers/serial/nwpserial.c
index e65b0d9202a..de173671e3d 100644
--- a/drivers/serial/nwpserial.c
+++ b/drivers/serial/nwpserial.c
@@ -344,7 +344,7 @@ int nwpserial_register_port(struct uart_port *port)
 
         mutex_lock(&nwpserial_mutex);
 
-        dn = to_of_device(port->dev)->dev.of_node;
+        dn = port->dev->of_node;
         if (dn == NULL)
                 goto out;
 
diff --git a/drivers/serial/of_serial.c b/drivers/serial/of_serial.c
index a48d9080f55..659a695bdad 100644
--- a/drivers/serial/of_serial.c
+++ b/drivers/serial/of_serial.c
@@ -27,7 +27,7 @@ struct of_serial_info {
 /*
  * Fill a struct uart_port for a given device node
  */
-static int __devinit of_platform_serial_setup(struct of_device *ofdev,
+static int __devinit of_platform_serial_setup(struct platform_device *ofdev,
                                         int type, struct uart_port *port)
 {
         struct resource resource;
@@ -80,7 +80,7 @@ static int __devinit of_platform_serial_setup(struct of_device *ofdev,
 /*
  * Try to register a serial port
  */
-static int __devinit of_platform_serial_probe(struct of_device *ofdev,
+static int __devinit of_platform_serial_probe(struct platform_device *ofdev,
                                                 const struct of_device_id *id)
 {
         struct of_serial_info *info;
@@ -134,7 +134,7 @@ out:
 /*
  * Release a line
  */
-static int of_platform_serial_remove(struct of_device *ofdev)
+static int of_platform_serial_remove(struct platform_device *ofdev)
 {
         struct of_serial_info *info = dev_get_drvdata(&ofdev->dev);
         switch (info->type) {
diff --git a/drivers/serial/sunhv.c b/drivers/serial/sunhv.c
index a779e22d213..c9014868297 100644
--- a/drivers/serial/sunhv.c
+++ b/drivers/serial/sunhv.c
@@ -519,7 +519,7 @@ static struct console sunhv_console = {
         .data   =       &sunhv_reg,
 };
 
-static int __devinit hv_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit hv_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct uart_port *port;
         unsigned long minor;
@@ -598,7 +598,7 @@ out_free_port:
         return err;
 }
 
-static int __devexit hv_remove(struct of_device *dev)
+static int __devexit hv_remove(struct platform_device *dev)
 {
         struct uart_port *port = dev_get_drvdata(&dev->dev);
 
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index 9845fb1cfb1..5b246b18f42 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -883,7 +883,7 @@ static int sunsab_console_setup(struct console *con, char *options)
         printk("Console: ttyS%d (SAB82532)\n",
                (sunsab_reg.minor - 64) + con->index);
 
-        sunserial_console_termios(con, to_of_device(up->port.dev)->dev.of_node);
+        sunserial_console_termios(con, up->port.dev->of_node);
 
         switch (con->cflag & CBAUD) {
         case B150: baud = 150; break;
@@ -954,7 +954,7 @@ static inline struct console *SUNSAB_CONSOLE(void)
 #endif
 
 static int __devinit sunsab_init_one(struct uart_sunsab_port *up,
-                                     struct of_device *op,
+                                     struct platform_device *op,
                                      unsigned long offset,
                                      int line)
 {
@@ -1006,7 +1006,7 @@ static int __devinit sunsab_init_one(struct uart_sunsab_port *up,
         return 0;
 }
 
-static int __devinit sab_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit sab_probe(struct platform_device *op, const struct of_device_id *match)
 {
         static int inst;
         struct uart_sunsab_port *up;
@@ -1062,7 +1062,7 @@ out:
         return err;
 }
 
-static int __devexit sab_remove(struct of_device *op)
+static int __devexit sab_remove(struct platform_device *op)
 {
         struct uart_sunsab_port *up = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 3cdf74822db..551ebfe3ccb 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -1200,7 +1200,7 @@ static int __devinit sunsu_kbd_ms_init(struct uart_sunsu_port *up)
                 return -ENODEV;
 
         printk("%s: %s port at %llx, irq %u\n",
-               to_of_device(up->port.dev)->dev.of_node->full_name,
+               up->port.dev->of_node->full_name,
                (up->su_type == SU_PORT_KBD) ? "Keyboard" : "Mouse",
                (unsigned long long) up->port.mapbase,
                up->port.irq);
@@ -1352,7 +1352,7 @@ static int __init sunsu_console_setup(struct console *co, char *options)
         spin_lock_init(&port->lock);
 
         /* Get firmware console settings.  */
-        sunserial_console_termios(co, to_of_device(port->dev)->dev.of_node);
+        sunserial_console_termios(co, port->dev->of_node);
 
         memset(&termios, 0, sizeof(struct ktermios));
         termios.c_cflag = co->cflag;
@@ -1406,7 +1406,7 @@ static enum su_type __devinit su_get_type(struct device_node *dp)
         return SU_PORT_PORT;
 }
 
-static int __devinit su_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit su_probe(struct platform_device *op, const struct of_device_id *match)
 {
         static int inst;
         struct device_node *dp = op->dev.of_node;
@@ -1497,7 +1497,7 @@ out_unmap:
         return err;
 }
 
-static int __devexit su_remove(struct of_device *op)
+static int __devexit su_remove(struct platform_device *op)
 {
         struct uart_sunsu_port *up = dev_get_drvdata(&op->dev);
         bool kbdms = false;
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index d1e6bcb5954..c1967ac1c07 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -1230,7 +1230,7 @@ static int __init sunzilog_console_setup(struct console *con, char *options)
                (sunzilog_reg.minor - 64) + con->index, con->index);
 
         /* Get firmware console settings.  */
-        sunserial_console_termios(con, to_of_device(up->port.dev)->dev.of_node);
+        sunserial_console_termios(con, up->port.dev->of_node);
 
         /* Firmware console speed is limited to 150-->38400 baud so
          * this hackish cflag thing is OK.
@@ -1399,7 +1399,7 @@ static void __devinit sunzilog_init_hw(struct uart_sunzilog_port *up)
 
 static int zilog_irq = -1;
 
-static int __devinit zs_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit zs_probe(struct platform_device *op, const struct of_device_id *match)
 {
         static int kbm_inst, uart_inst;
         int inst;
@@ -1516,7 +1516,7 @@ static void __devexit zs_remove_one(struct uart_sunzilog_port *up)
                 uart_remove_one_port(&sunzilog_reg, &up->port);
 }
 
-static int __devexit zs_remove(struct of_device *op)
+static int __devexit zs_remove(struct platform_device *op)
 {
         struct uart_sunzilog_port *up = dev_get_drvdata(&op->dev);
         struct zilog_layout __iomem *regs;
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index caf085d3a76..9b03d7b3e45 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -584,7 +584,7 @@ static struct platform_driver ulite_platform_driver = {
  */
 #if defined(CONFIG_OF) && (defined(CONFIG_PPC32) || defined(CONFIG_MICROBLAZE))
 static int __devinit
-ulite_of_probe(struct of_device *op, const struct of_device_id *match)
+ulite_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource res;
         const unsigned int *id;
@@ -605,7 +605,7 @@ ulite_of_probe(struct of_device *op, const struct of_device_id *match)
         return ulite_assign(&op->dev, id ? *id : -1, res.start, irq);
 }
 
-static int __devexit ulite_of_remove(struct of_device *op)
+static int __devexit ulite_of_remove(struct platform_device *op)
 {
         return ulite_release(&op->dev);
 }
diff --git a/drivers/serial/ucc_uart.c b/drivers/serial/ucc_uart.c
index 907b06f5c44..3f4848e2174 100644
--- a/drivers/serial/ucc_uart.c
+++ b/drivers/serial/ucc_uart.c
@@ -1194,7 +1194,7 @@ static void uart_firmware_cont(const struct firmware *fw, void *context)
         release_firmware(fw);
 }
 
-static int ucc_uart_probe(struct of_device *ofdev,
+static int ucc_uart_probe(struct platform_device *ofdev,
         const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -1462,7 +1462,7 @@ static int ucc_uart_probe(struct of_device *ofdev,
         return 0;
 }
 
-static int ucc_uart_remove(struct of_device *ofdev)
+static int ucc_uart_remove(struct platform_device *ofdev)
 {
         struct uart_qe_port *qe_port = dev_get_drvdata(&ofdev->dev);
 
diff --git a/drivers/spi/mpc512x_psc_spi.c b/drivers/spi/mpc512x_psc_spi.c
index 10baac3f8ea..cddbfceb324 100644
--- a/drivers/spi/mpc512x_psc_spi.c
+++ b/drivers/spi/mpc512x_psc_spi.c
@@ -507,7 +507,7 @@ static int __exit mpc512x_psc_spi_do_remove(struct device *dev)
         return 0;
 }
 
-static int __init mpc512x_psc_spi_of_probe(struct of_device *op,
+static int __init mpc512x_psc_spi_of_probe(struct platform_device *op,
                                            const struct of_device_id *match)
 {
         const u32 *regaddr_p;
@@ -539,7 +539,7 @@ static int __init mpc512x_psc_spi_of_probe(struct of_device *op,
                                 irq_of_parse_and_map(op->dev.of_node, 0), id);
 }
 
-static int __exit mpc512x_psc_spi_of_remove(struct of_device *op)
+static int __exit mpc512x_psc_spi_of_remove(struct platform_device *op)
 {
         return mpc512x_psc_spi_do_remove(&op->dev);
 }
diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index 66d170147dc..983fbbfce76 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -465,7 +465,7 @@ static int __exit mpc52xx_psc_spi_do_remove(struct device *dev)
         return 0;
 }
 
-static int __init mpc52xx_psc_spi_of_probe(struct of_device *op,
+static int __init mpc52xx_psc_spi_of_probe(struct platform_device *op,
         const struct of_device_id *match)
 {
         const u32 *regaddr_p;
@@ -495,7 +495,7 @@ static int __init mpc52xx_psc_spi_of_probe(struct of_device *op,
                                 irq_of_parse_and_map(op->dev.of_node, 0), id);
 }
 
-static int __exit mpc52xx_psc_spi_of_remove(struct of_device *op)
+static int __exit mpc52xx_psc_spi_of_remove(struct platform_device *op)
 {
         return mpc52xx_psc_spi_do_remove(&op->dev);
 }
diff --git a/drivers/spi/mpc52xx_spi.c b/drivers/spi/mpc52xx_spi.c
index 56136ff00e0..ec9f0b1bf86 100644
--- a/drivers/spi/mpc52xx_spi.c
+++ b/drivers/spi/mpc52xx_spi.c
@@ -390,7 +390,7 @@ static int mpc52xx_spi_transfer(struct spi_device *spi, struct spi_message *m)
 /*
  * OF Platform Bus Binding
  */
-static int __devinit mpc52xx_spi_probe(struct of_device *op,
+static int __devinit mpc52xx_spi_probe(struct platform_device *op,
                                        const struct of_device_id *match)
 {
         struct spi_master *master;
@@ -530,7 +530,7 @@ static int __devinit mpc52xx_spi_probe(struct of_device *op,
         return rc;
 }
 
-static int __devexit mpc52xx_spi_remove(struct of_device *op)
+static int __devexit mpc52xx_spi_remove(struct platform_device *op)
 {
         struct spi_master *master = dev_get_drvdata(&op->dev);
         struct mpc52xx_spi *ms = spi_master_get_devdata(master);
diff --git a/drivers/spi/spi_mpc8xxx.c b/drivers/spi/spi_mpc8xxx.c
index aad9ae1b9c6..d31b57f7baa 100644
--- a/drivers/spi/spi_mpc8xxx.c
+++ b/drivers/spi/spi_mpc8xxx.c
@@ -1236,7 +1236,7 @@ static int of_mpc8xxx_spi_free_chipselects(struct device *dev)
         return 0;
 }
 
-static int __devinit of_mpc8xxx_spi_probe(struct of_device *ofdev,
+static int __devinit of_mpc8xxx_spi_probe(struct platform_device *ofdev,
                                           const struct of_device_id *ofid)
 {
         struct device *dev = &ofdev->dev;
@@ -1308,7 +1308,7 @@ err_clk:
         return ret;
 }
 
-static int __devexit of_mpc8xxx_spi_remove(struct of_device *ofdev)
+static int __devexit of_mpc8xxx_spi_remove(struct platform_device *ofdev)
 {
         int ret;
 
diff --git a/drivers/spi/spi_ppc4xx.c b/drivers/spi/spi_ppc4xx.c
index 0f5fa7e2a55..80e172d3e72 100644
--- a/drivers/spi/spi_ppc4xx.c
+++ b/drivers/spi/spi_ppc4xx.c
@@ -388,9 +388,9 @@ static void free_gpios(struct ppc4xx_spi *hw)
 }
 
 /*
- * of_device layer stuff...
+ * platform_device layer stuff...
  */
-static int __init spi_ppc4xx_of_probe(struct of_device *op,
+static int __init spi_ppc4xx_of_probe(struct platform_device *op,
                                       const struct of_device_id *match)
 {
         struct ppc4xx_spi *hw;
@@ -565,7 +565,7 @@ free_master:
         return ret;
 }
 
-static int __exit spi_ppc4xx_of_remove(struct of_device *op)
+static int __exit spi_ppc4xx_of_remove(struct platform_device *op)
 {
         struct spi_master *master = dev_get_drvdata(&op->dev);
         struct ppc4xx_spi *hw = spi_master_get_devdata(master);
diff --git a/drivers/spi/xilinx_spi_of.c b/drivers/spi/xilinx_spi_of.c
index f53d3f6b9f6..b66c2dbf20a 100644
--- a/drivers/spi/xilinx_spi_of.c
+++ b/drivers/spi/xilinx_spi_of.c
@@ -38,7 +38,7 @@
 #include "xilinx_spi.h"
 
 
-static int __devinit xilinx_spi_of_probe(struct of_device *ofdev,
+static int __devinit xilinx_spi_of_probe(struct platform_device *ofdev,
         const struct of_device_id *match)
 {
         struct spi_master *master;
@@ -84,7 +84,7 @@ static int __devinit xilinx_spi_of_probe(struct of_device *ofdev,
         return 0;
 }
 
-static int __devexit xilinx_spi_remove(struct of_device *ofdev)
+static int __devexit xilinx_spi_remove(struct platform_device *ofdev)
 {
         xilinx_spi_deinit(dev_get_drvdata(&ofdev->dev));
         dev_set_drvdata(&ofdev->dev, 0);
@@ -93,7 +93,7 @@ static int __devexit xilinx_spi_remove(struct of_device *ofdev)
         return 0;
 }
 
-static int __exit xilinx_spi_of_remove(struct of_device *op)
+static int __exit xilinx_spi_of_remove(struct platform_device *op)
 {
         return xilinx_spi_remove(op);
 }
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index 9648b75f028..a5ea2c1d8c9 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -2398,7 +2398,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 EXPORT_SYMBOL(usb_gadget_unregister_driver);
 
 /* udc structure's alloc and setup, include ep-param alloc */
-static struct qe_udc __devinit *qe_udc_config(struct of_device *ofdev)
+static struct qe_udc __devinit *qe_udc_config(struct platform_device *ofdev)
 {
         struct qe_udc *udc;
         struct device_node *np = ofdev->dev.of_node;
@@ -2523,7 +2523,7 @@ static void qe_udc_release(struct device *dev)
 }
 
 /* Driver probe functions */
-static int __devinit qe_udc_probe(struct of_device *ofdev,
+static int __devinit qe_udc_probe(struct platform_device *ofdev,
                         const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -2679,18 +2679,18 @@ err1:
 }
 
 #ifdef CONFIG_PM
-static int qe_udc_suspend(struct of_device *dev, pm_message_t state)
+static int qe_udc_suspend(struct platform_device *dev, pm_message_t state)
 {
         return -ENOTSUPP;
 }
 
-static int qe_udc_resume(struct of_device *dev)
+static int qe_udc_resume(struct platform_device *dev)
 {
         return -ENOTSUPP;
 }
 #endif
 
-static int __devexit qe_udc_remove(struct of_device *ofdev)
+static int __devexit qe_udc_remove(struct platform_device *ofdev)
 {
         struct qe_ep *ep;
         unsigned int size;
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 5aec92866ab..335ee699fd8 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -106,7 +106,7 @@ ppc44x_enable_bmt(struct device_node *dn)
 
 
 static int __devinit
-ehci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
+ehci_hcd_ppc_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dn = op->dev.of_node;
         struct usb_hcd *hcd;
@@ -210,7 +210,7 @@ err_rmr:
 }
 
 
-static int ehci_hcd_ppc_of_remove(struct of_device *op)
+static int ehci_hcd_ppc_of_remove(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
@@ -253,7 +253,7 @@ static int ehci_hcd_ppc_of_remove(struct of_device *op)
 }
 
 
-static int ehci_hcd_ppc_of_shutdown(struct of_device *op)
+static int ehci_hcd_ppc_of_shutdown(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index 4899f451add..6c8076ad821 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -140,7 +140,7 @@ static const struct hc_driver ehci_xilinx_of_hc_driver = {
 
 /**
  * ehci_hcd_xilinx_of_probe - Probe method for the USB host controller
- * @op:         pointer to the of_device to which the host controller bound
+ * @op:         pointer to the platform_device bound to the host controller
  * @match:      pointer to of_device_id structure, not used
  *
  * This function requests resources and sets up appropriate properties for the
@@ -149,7 +149,7 @@ static const struct hc_driver ehci_xilinx_of_hc_driver = {
  * entry, and sets an appropriate value for hcd->has_tt.
  */
 static int __devinit
-ehci_hcd_xilinx_of_probe(struct of_device *op, const struct of_device_id *match)
+ehci_hcd_xilinx_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dn = op->dev.of_node;
         struct usb_hcd *hcd;
@@ -242,12 +242,12 @@ err_rmr:
 
 /**
  * ehci_hcd_xilinx_of_remove - shutdown hcd and release resources
- * @op:         pointer to of_device structure that is to be removed
+ * @op:         pointer to platform_device structure that is to be removed
  *
  * Remove the hcd structure, and release resources that has been requested
  * during probe.
  */
-static int ehci_hcd_xilinx_of_remove(struct of_device *op)
+static int ehci_hcd_xilinx_of_remove(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
         dev_set_drvdata(&op->dev, NULL);
@@ -266,11 +266,11 @@ static int ehci_hcd_xilinx_of_remove(struct of_device *op)
 
 /**
  * ehci_hcd_xilinx_of_shutdown - shutdown the hcd
- * @op:         pointer to of_device structure that is to be removed
+ * @op:         pointer to platform_device structure that is to be removed
  *
  * Properly shutdown the hcd, call driver's shutdown routine.
  */
-static int ehci_hcd_xilinx_of_shutdown(struct of_device *op)
+static int ehci_hcd_xilinx_of_shutdown(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index c7c8392a88b..20092a27a1e 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -561,7 +561,7 @@ static const struct hc_driver fhci_driver = {
         .hub_control = fhci_hub_control,
 };
 
-static int __devinit of_fhci_probe(struct of_device *ofdev,
+static int __devinit of_fhci_probe(struct platform_device *ofdev,
                                    const struct of_device_id *ofid)
 {
         struct device *dev = &ofdev->dev;
@@ -801,7 +801,7 @@ static int __devexit fhci_remove(struct device *dev)
         return 0;
 }
 
-static int __devexit of_fhci_remove(struct of_device *ofdev)
+static int __devexit of_fhci_remove(struct platform_device *ofdev)
 {
         return fhci_remove(&ofdev->dev);
 }
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index ec85d0c3cc3..3b28dbfca05 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -27,7 +27,7 @@
 #endif
 
 #ifdef CONFIG_PPC_OF
-static int of_isp1760_probe(struct of_device *dev,
+static int of_isp1760_probe(struct platform_device *dev,
                 const struct of_device_id *match)
 {
         struct usb_hcd *hcd;
@@ -95,7 +95,7 @@ release_reg:
         return ret;
 }
 
-static int of_isp1760_remove(struct of_device *dev)
+static int of_isp1760_remove(struct platform_device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&dev->dev);
 
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index df165917412..b2c2dbf0876 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -81,7 +81,7 @@ static const struct hc_driver ohci_ppc_of_hc_driver = {
 
 
 static int __devinit
-ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
+ohci_hcd_ppc_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dn = op->dev.of_node;
         struct usb_hcd *hcd;
@@ -183,7 +183,7 @@ err_rmr:
         return rv;
 }
 
-static int ohci_hcd_ppc_of_remove(struct of_device *op)
+static int ohci_hcd_ppc_of_remove(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
         dev_set_drvdata(&op->dev, NULL);
@@ -201,7 +201,7 @@ static int ohci_hcd_ppc_of_remove(struct of_device *op)
         return 0;
 }
 
-static int ohci_hcd_ppc_of_shutdown(struct of_device *op)
+static int ohci_hcd_ppc_of_shutdown(struct platform_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/video/bw2.c b/drivers/video/bw2.c
index c7796637baf..4dc13467281 100644
--- a/drivers/video/bw2.c
+++ b/drivers/video/bw2.c
@@ -273,7 +273,7 @@ static int __devinit bw2_do_default_mode(struct bw2_par *par,
         return 0;
 }
 
-static int __devinit bw2_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit bw2_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         struct fb_info *info;
@@ -350,7 +350,7 @@ out_err:
         return err;
 }
 
-static int __devexit bw2_remove(struct of_device *op)
+static int __devexit bw2_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct bw2_par *par = info->par;
diff --git a/drivers/video/cg14.c b/drivers/video/cg14.c
index d09fde8beb6..24249535ac8 100644
--- a/drivers/video/cg14.c
+++ b/drivers/video/cg14.c
@@ -446,7 +446,7 @@ static struct sbus_mmap_map __cg14_mmap_map[CG14_MMAP_ENTRIES] __devinitdata = {
         { .size = 0 }
 };
 
-static void cg14_unmap_regs(struct of_device *op, struct fb_info *info,
+static void cg14_unmap_regs(struct platform_device *op, struct fb_info *info,
                             struct cg14_par *par)
 {
         if (par->regs)
@@ -463,7 +463,7 @@ static void cg14_unmap_regs(struct of_device *op, struct fb_info *info,
                            info->screen_base, info->fix.smem_len);
 }
 
-static int __devinit cg14_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cg14_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         struct fb_info *info;
@@ -570,7 +570,7 @@ out_err:
         return err;
 }
 
-static int __devexit cg14_remove(struct of_device *op)
+static int __devexit cg14_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct cg14_par *par = info->par;
diff --git a/drivers/video/cg3.c b/drivers/video/cg3.c
index 64aa29809fb..09c0c3c4248 100644
--- a/drivers/video/cg3.c
+++ b/drivers/video/cg3.c
@@ -346,7 +346,7 @@ static int __devinit cg3_do_default_mode(struct cg3_par *par)
         return 0;
 }
 
-static int __devinit cg3_probe(struct of_device *op,
+static int __devinit cg3_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -433,7 +433,7 @@ out_err:
         return err;
 }
 
-static int __devexit cg3_remove(struct of_device *op)
+static int __devexit cg3_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct cg3_par *par = info->par;
diff --git a/drivers/video/cg6.c b/drivers/video/cg6.c
index 2389a719dcc..2b5a97058b0 100644
--- a/drivers/video/cg6.c
+++ b/drivers/video/cg6.c
@@ -718,7 +718,7 @@ static void __devinit cg6_chip_init(struct fb_info *info)
         sbus_writel(info->var.yres - 1, &fbc->clipmaxy);
 }
 
-static void cg6_unmap_regs(struct of_device *op, struct fb_info *info,
+static void cg6_unmap_regs(struct platform_device *op, struct fb_info *info,
                            struct cg6_par *par)
 {
         if (par->fbc)
@@ -737,7 +737,7 @@ static void cg6_unmap_regs(struct of_device *op, struct fb_info *info,
                            info->fix.smem_len);
 }
 
-static int __devinit cg6_probe(struct of_device *op,
+static int __devinit cg6_probe(struct platform_device *op,
                                 const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -827,7 +827,7 @@ out_err:
         return err;
 }
 
-static int __devexit cg6_remove(struct of_device *op)
+static int __devexit cg6_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct cg6_par *par = info->par;
diff --git a/drivers/video/ffb.c b/drivers/video/ffb.c
index f6ecfab296d..6739b2af3bc 100644
--- a/drivers/video/ffb.c
+++ b/drivers/video/ffb.c
@@ -893,7 +893,7 @@ static void ffb_init_fix(struct fb_info *info)
         info->fix.accel = FB_ACCEL_SUN_CREATOR;
 }
 
-static int __devinit ffb_probe(struct of_device *op,
+static int __devinit ffb_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -1023,7 +1023,7 @@ out_err:
         return err;
 }
 
-static int __devexit ffb_remove(struct of_device *op)
+static int __devexit ffb_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct ffb_par *par = info->par;
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index e38ad222454..8bbbf08fa3c 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -1393,7 +1393,7 @@ static void free_irq_local(int irq)
  * Power management hooks. Note that we won't be called from IRQ context,
  * unlike the blank functions above, so we may sleep.
  */
-static int fsl_diu_suspend(struct of_device *ofdev, pm_message_t state)
+static int fsl_diu_suspend(struct platform_device *ofdev, pm_message_t state)
 {
         struct fsl_diu_data *machine_data;
 
@@ -1403,7 +1403,7 @@ static int fsl_diu_suspend(struct of_device *ofdev, pm_message_t state)
         return 0;
 }
 
-static int fsl_diu_resume(struct of_device *ofdev)
+static int fsl_diu_resume(struct platform_device *ofdev)
 {
         struct fsl_diu_data *machine_data;
 
@@ -1487,7 +1487,7 @@ static ssize_t show_monitor(struct device *device,
         return diu_ops.show_monitor_port(machine_data->monitor_port, buf);
 }
 
-static int __devinit fsl_diu_probe(struct of_device *ofdev,
+static int __devinit fsl_diu_probe(struct platform_device *ofdev,
         const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -1667,7 +1667,7 @@ error2:
 }
 
 
-static int fsl_diu_remove(struct of_device *ofdev)
+static int fsl_diu_remove(struct platform_device *ofdev)
 {
         struct fsl_diu_data *machine_data;
         int i;
diff --git a/drivers/video/leo.c b/drivers/video/leo.c
index ad677637ffb..b599e5e36ce 100644
--- a/drivers/video/leo.c
+++ b/drivers/video/leo.c
@@ -529,7 +529,7 @@ static void leo_fixup_var_rgb(struct fb_var_screeninfo *var)
         var->transp.length = 0;
 }
 
-static void leo_unmap_regs(struct of_device *op, struct fb_info *info,
+static void leo_unmap_regs(struct platform_device *op, struct fb_info *info,
                            struct leo_par *par)
 {
         if (par->lc_ss0_usr)
@@ -547,7 +547,7 @@ static void leo_unmap_regs(struct of_device *op, struct fb_info *info,
                 of_iounmap(&op->resource[0], info->screen_base, 0x800000);
 }
 
-static int __devinit leo_probe(struct of_device *op,
+static int __devinit leo_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -637,7 +637,7 @@ out_err:
         return err;
 }
 
-static int __devexit leo_remove(struct of_device *op)
+static int __devexit leo_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct leo_par *par = info->par;
diff --git a/drivers/video/mb862xx/mb862xxfb.c b/drivers/video/mb862xx/mb862xxfb.c
index 4e2b8cc3d46..b1c4374cf94 100644
--- a/drivers/video/mb862xx/mb862xxfb.c
+++ b/drivers/video/mb862xx/mb862xxfb.c
@@ -550,7 +550,7 @@ static int mb862xx_gdc_init(struct mb862xxfb_par *par)
         return 0;
 }
 
-static int __devinit of_platform_mb862xx_probe(struct of_device *ofdev,
+static int __devinit of_platform_mb862xx_probe(struct platform_device *ofdev,
                                                const struct of_device_id *id)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -669,7 +669,7 @@ fbrel:
         return ret;
 }
 
-static int __devexit of_platform_mb862xx_remove(struct of_device *ofdev)
+static int __devexit of_platform_mb862xx_remove(struct platform_device *ofdev)
 {
         struct fb_info *fbi = dev_get_drvdata(&ofdev->dev);
         struct mb862xxfb_par *par = fbi->par;
diff --git a/drivers/video/p9100.c b/drivers/video/p9100.c
index 688b055abab..b6c3fc2db63 100644
--- a/drivers/video/p9100.c
+++ b/drivers/video/p9100.c
@@ -249,7 +249,7 @@ static void p9100_init_fix(struct fb_info *info, int linebytes, struct device_no
         info->fix.accel = FB_ACCEL_SUN_CGTHREE;
 }
 
-static int __devinit p9100_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit p9100_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
         struct fb_info *info;
@@ -326,7 +326,7 @@ out_err:
         return err;
 }
 
-static int __devexit p9100_remove(struct of_device *op)
+static int __devexit p9100_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct p9100_par *par = info->par;
diff --git a/drivers/video/platinumfb.c b/drivers/video/platinumfb.c
index 72a1f4c0473..a50e1977b31 100644
--- a/drivers/video/platinumfb.c
+++ b/drivers/video/platinumfb.c
@@ -533,7 +533,7 @@ static int __init platinumfb_setup(char *options)
 #define invalidate_cache(addr)
 #endif
 
-static int __devinit platinumfb_probe(struct of_device* odev,
+static int __devinit platinumfb_probe(struct platform_device* odev,
                                       const struct of_device_id *match)
 {
         struct device_node      *dp = odev->dev.of_node;
@@ -646,7 +646,7 @@ static int __devinit platinumfb_probe(struct of_device* odev,
         return rc;
 }
 
-static int __devexit platinumfb_remove(struct of_device* odev)
+static int __devexit platinumfb_remove(struct platform_device* odev)
 {
         struct fb_info          *info = dev_get_drvdata(&odev->dev);
         struct fb_info_platinum *pinfo = info->par;
diff --git a/drivers/video/sunxvr1000.c b/drivers/video/sunxvr1000.c
index 7288934c0d4..5dbe06af222 100644
--- a/drivers/video/sunxvr1000.c
+++ b/drivers/video/sunxvr1000.c
@@ -111,7 +111,7 @@ static int __devinit gfb_set_fbinfo(struct gfb_info *gp)
         return 0;
 }
 
-static int __devinit gfb_probe(struct of_device *op,
+static int __devinit gfb_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -172,7 +172,7 @@ err_out:
         return err;
 }
 
-static int __devexit gfb_remove(struct of_device *op)
+static int __devexit gfb_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct gfb_info *gp = info->par;
diff --git a/drivers/video/tcx.c b/drivers/video/tcx.c
index f375e0db677..77ad27955cf 100644
--- a/drivers/video/tcx.c
+++ b/drivers/video/tcx.c
@@ -342,7 +342,7 @@ tcx_init_fix(struct fb_info *info, int linebytes)
         info->fix.accel = FB_ACCEL_SUN_TCX;
 }
 
-static void tcx_unmap_regs(struct of_device *op, struct fb_info *info,
+static void tcx_unmap_regs(struct platform_device *op, struct fb_info *info,
                            struct tcx_par *par)
 {
         if (par->tec)
@@ -362,7 +362,7 @@ static void tcx_unmap_regs(struct of_device *op, struct fb_info *info,
                            info->screen_base, info->fix.smem_len);
 }
 
-static int __devinit tcx_probe(struct of_device *op,
+static int __devinit tcx_probe(struct platform_device *op,
                                const struct of_device_id *match)
 {
         struct device_node *dp = op->dev.of_node;
@@ -486,7 +486,7 @@ out_err:
         return err;
 }
 
-static int __devexit tcx_remove(struct of_device *op)
+static int __devexit tcx_remove(struct platform_device *op)
 {
         struct fb_info *info = dev_get_drvdata(&op->dev);
         struct tcx_par *par = info->par;
diff --git a/drivers/video/xilinxfb.c b/drivers/video/xilinxfb.c
index 29b5daacc21..0c9ce88e95e 100644
--- a/drivers/video/xilinxfb.c
+++ b/drivers/video/xilinxfb.c
@@ -397,7 +397,7 @@ static int xilinxfb_release(struct device *dev)
  */
 
 static int __devinit
-xilinxfb_of_probe(struct of_device *op, const struct of_device_id *match)
+xilinxfb_of_probe(struct platform_device *op, const struct of_device_id *match)
 {
         const u32 *prop;
         u32 *p;
@@ -477,7 +477,7 @@ xilinxfb_of_probe(struct of_device *op, const struct of_device_id *match)
         return -ENODEV;
 }
 
-static int __devexit xilinxfb_of_remove(struct of_device *op)
+static int __devexit xilinxfb_of_remove(struct platform_device *op)
 {
         return xilinxfb_release(&op->dev);
 }
diff --git a/drivers/watchdog/cpwd.c b/drivers/watchdog/cpwd.c
index 30a2512fd52..566343b3c13 100644
--- a/drivers/watchdog/cpwd.c
+++ b/drivers/watchdog/cpwd.c
@@ -526,7 +526,7 @@ static const struct file_operations cpwd_fops = {
         .release =              cpwd_release,
 };
 
-static int __devinit cpwd_probe(struct of_device *op,
+static int __devinit cpwd_probe(struct platform_device *op,
                                 const struct of_device_id *match)
 {
         struct device_node *options;
@@ -639,7 +639,7 @@ out_free:
         goto out;
 }
 
-static int __devexit cpwd_remove(struct of_device *op)
+static int __devexit cpwd_remove(struct platform_device *op)
 {
         struct cpwd *p = dev_get_drvdata(&op->dev);
         int i;
diff --git a/drivers/watchdog/gef_wdt.c b/drivers/watchdog/gef_wdt.c
index 1df284f9c2a..9c21d19043a 100644
--- a/drivers/watchdog/gef_wdt.c
+++ b/drivers/watchdog/gef_wdt.c
@@ -260,7 +260,7 @@ static struct miscdevice gef_wdt_miscdev = {
 };
 
 
-static int __devinit gef_wdt_probe(struct of_device *dev,
+static int __devinit gef_wdt_probe(struct platform_device *dev,
         const struct of_device_id *match)
 {
         int timeout = 10;
diff --git a/drivers/watchdog/mpc8xxx_wdt.c b/drivers/watchdog/mpc8xxx_wdt.c
index 4cda64dd309..8fa213cdb49 100644
--- a/drivers/watchdog/mpc8xxx_wdt.c
+++ b/drivers/watchdog/mpc8xxx_wdt.c
@@ -185,7 +185,7 @@ static struct miscdevice mpc8xxx_wdt_miscdev = {
         .fops   = &mpc8xxx_wdt_fops,
 };
 
-static int __devinit mpc8xxx_wdt_probe(struct of_device *ofdev,
+static int __devinit mpc8xxx_wdt_probe(struct platform_device *ofdev,
                                        const struct of_device_id *match)
 {
         int ret;
@@ -238,7 +238,7 @@ err_unmap:
         return ret;
 }
 
-static int __devexit mpc8xxx_wdt_remove(struct of_device *ofdev)
+static int __devexit mpc8xxx_wdt_remove(struct platform_device *ofdev)
 {
         mpc8xxx_wdt_pr_warn("watchdog removed");
         del_timer_sync(&wdt_timer);
diff --git a/drivers/watchdog/riowd.c b/drivers/watchdog/riowd.c
index 4082b4ace1f..3faee1ae64b 100644
--- a/drivers/watchdog/riowd.c
+++ b/drivers/watchdog/riowd.c
@@ -172,7 +172,7 @@ static struct miscdevice riowd_miscdev = {
         .fops   = &riowd_fops
 };
 
-static int __devinit riowd_probe(struct of_device *op,
+static int __devinit riowd_probe(struct platform_device *op,
                                  const struct of_device_id *match)
 {
         struct riowd *p;
@@ -219,7 +219,7 @@ out:
         return err;
 }
 
-static int __devexit riowd_remove(struct of_device *op)
+static int __devexit riowd_remove(struct platform_device *op)
 {
         struct riowd *p = dev_get_drvdata(&op->dev);
 
diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index 0a882693663..60d71e9abe9 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -71,4 +71,9 @@ config XEN_PLATFORM_PCI
           initializing xenbus and grant_table when running in a Xen HVM
           domain. As a consequence this driver is required to run any Xen PV
           frontend on Xen HVM.
+
+config SWIOTLB_XEN
+        def_bool y
+        depends on SWIOTLB
+
 endmenu
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index e392fb776af..fcaf838f54b 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -11,3 +11,4 @@ obj-$(CONFIG_XEN_DEV_EVTCHN)	+= evtchn.o
 obj-$(CONFIG_XENFS)             += xenfs/
 obj-$(CONFIG_XEN_SYS_HYPERVISOR)        += sys-hypervisor.o
 obj-$(CONFIG_XEN_PLATFORM_PCI)  += platform-pci.o
+obj-$(CONFIG_SWIOTLB_XEN)       += swiotlb-xen.o
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 1a0d8c2a035..500290b150b 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -85,13 +85,6 @@ static struct sys_device balloon_sysdev;
 
 static int register_balloon(struct sys_device *sysdev);
 
-/*
- * Protects atomic reservation decrease/increase against concurrent increases.
- * Also protects non-atomic updates of current_pages and driver_pages, and
- * balloon lists.
- */
-static DEFINE_SPINLOCK(balloon_lock);
-
 static struct balloon_stats balloon_stats;
 
 /* We increase/decrease in batches which fit in a page */
@@ -210,7 +203,7 @@ static int increase_reservation(unsigned long nr_pages)
         if (nr_pages > ARRAY_SIZE(frame_list))
                 nr_pages = ARRAY_SIZE(frame_list);
 
-        spin_lock_irqsave(&balloon_lock, flags);
+        spin_lock_irqsave(&xen_reservation_lock, flags);
 
         page = balloon_first_page();
         for (i = 0; i < nr_pages; i++) {
@@ -254,7 +247,7 @@ static int increase_reservation(unsigned long nr_pages)
         balloon_stats.current_pages += rc;
 
  out:
-        spin_unlock_irqrestore(&balloon_lock, flags);
+        spin_unlock_irqrestore(&xen_reservation_lock, flags);
 
         return rc < 0 ? rc : rc != nr_pages;
 }
@@ -299,7 +292,7 @@ static int decrease_reservation(unsigned long nr_pages)
         kmap_flush_unused();
         flush_tlb_all();
 
-        spin_lock_irqsave(&balloon_lock, flags);
+        spin_lock_irqsave(&xen_reservation_lock, flags);
 
         /* No more mappings: invalidate P2M and add to balloon. */
         for (i = 0; i < nr_pages; i++) {
@@ -315,7 +308,7 @@ static int decrease_reservation(unsigned long nr_pages)
 
         balloon_stats.current_pages -= nr_pages;
 
-        spin_unlock_irqrestore(&balloon_lock, flags);
+        spin_unlock_irqrestore(&xen_reservation_lock, flags);
 
         return need_sleep;
 }
diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
new file mode 100644
index 00000000000..54469c3eeac
--- /dev/null
+++ b/drivers/xen/swiotlb-xen.c
@@ -0,0 +1,515 @@
+/*
+ *  Copyright 2010
+ *  by Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
+ *
+ * This code provides a IOMMU for Xen PV guests with PCI passthrough.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2.0 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.
+ *
+ * PV guests under Xen are running in an non-contiguous memory architecture.
+ *
+ * When PCI pass-through is utilized, this necessitates an IOMMU for
+ * translating bus (DMA) to virtual and vice-versa and also providing a
+ * mechanism to have contiguous pages for device drivers operations (say DMA
+ * operations).
+ *
+ * Specifically, under Xen the Linux idea of pages is an illusion. It
+ * assumes that pages start at zero and go up to the available memory. To
+ * help with that, the Linux Xen MMU provides a lookup mechanism to
+ * translate the page frame numbers (PFN) to machine frame numbers (MFN)
+ * and vice-versa. The MFN are the "real" frame numbers. Furthermore
+ * memory is not contiguous. Xen hypervisor stitches memory for guests
+ * from different pools, which means there is no guarantee that PFN==MFN
+ * and PFN+1==MFN+1. Lastly with Xen 4.0, pages (in debug mode) are
+ * allocated in descending order (high to low), meaning the guest might
+ * never get any MFN's under the 4GB mark.
+ *
+ */
+
+#include <linux/bootmem.h>
+#include <linux/dma-mapping.h>
+#include <xen/swiotlb-xen.h>
+#include <xen/page.h>
+#include <xen/xen-ops.h>
+/*
+ * Used to do a quick range check in swiotlb_tbl_unmap_single and
+ * swiotlb_tbl_sync_single_*, to see if the memory was in fact allocated by this
+ * API.
+ */
+
+static char *xen_io_tlb_start, *xen_io_tlb_end;
+static unsigned long xen_io_tlb_nslabs;
+/*
+ * Quick lookup value of the bus address of the IOTLB.
+ */
+
+u64 start_dma_addr;
+
+static dma_addr_t xen_phys_to_bus(phys_addr_t paddr)
+{
+        return phys_to_machine(XPADDR(paddr)).maddr;;
+}
+
+static phys_addr_t xen_bus_to_phys(dma_addr_t baddr)
+{
+        return machine_to_phys(XMADDR(baddr)).paddr;
+}
+
+static dma_addr_t xen_virt_to_bus(void *address)
+{
+        return xen_phys_to_bus(virt_to_phys(address));
+}
+
+static int check_pages_physically_contiguous(unsigned long pfn,
+                                             unsigned int offset,
+                                             size_t length)
+{
+        unsigned long next_mfn;
+        int i;
+        int nr_pages;
+
+        next_mfn = pfn_to_mfn(pfn);
+        nr_pages = (offset + length + PAGE_SIZE-1) >> PAGE_SHIFT;
+
+        for (i = 1; i < nr_pages; i++) {
+                if (pfn_to_mfn(++pfn) != ++next_mfn)
+                        return 0;
+        }
+        return 1;
+}
+
+static int range_straddles_page_boundary(phys_addr_t p, size_t size)
+{
+        unsigned long pfn = PFN_DOWN(p);
+        unsigned int offset = p & ~PAGE_MASK;
+
+        if (offset + size <= PAGE_SIZE)
+                return 0;
+        if (check_pages_physically_contiguous(pfn, offset, size))
+                return 0;
+        return 1;
+}
+
+static int is_xen_swiotlb_buffer(dma_addr_t dma_addr)
+{
+        unsigned long mfn = PFN_DOWN(dma_addr);
+        unsigned long pfn = mfn_to_local_pfn(mfn);
+        phys_addr_t paddr;
+
+        /* If the address is outside our domain, it CAN
+         * have the same virtual address as another address
+         * in our domain. Therefore _only_ check address within our domain.
+         */
+        if (pfn_valid(pfn)) {
+                paddr = PFN_PHYS(pfn);
+                return paddr >= virt_to_phys(xen_io_tlb_start) &&
+                       paddr < virt_to_phys(xen_io_tlb_end);
+        }
+        return 0;
+}
+
+static int max_dma_bits = 32;
+
+static int
+xen_swiotlb_fixup(void *buf, size_t size, unsigned long nslabs)
+{
+        int i, rc;
+        int dma_bits;
+
+        dma_bits = get_order(IO_TLB_SEGSIZE << IO_TLB_SHIFT) + PAGE_SHIFT;
+
+        i = 0;
+        do {
+                int slabs = min(nslabs - i, (unsigned long)IO_TLB_SEGSIZE);
+
+                do {
+                        rc = xen_create_contiguous_region(
+                                (unsigned long)buf + (i << IO_TLB_SHIFT),
+                                get_order(slabs << IO_TLB_SHIFT),
+                                dma_bits);
+                } while (rc && dma_bits++ < max_dma_bits);
+                if (rc)
+                        return rc;
+
+                i += slabs;
+        } while (i < nslabs);
+        return 0;
+}
+
+void __init xen_swiotlb_init(int verbose)
+{
+        unsigned long bytes;
+        int rc;
+
+        xen_io_tlb_nslabs = (64 * 1024 * 1024 >> IO_TLB_SHIFT);
+        xen_io_tlb_nslabs = ALIGN(xen_io_tlb_nslabs, IO_TLB_SEGSIZE);
+
+        bytes = xen_io_tlb_nslabs << IO_TLB_SHIFT;
+
+        /*
+         * Get IO TLB memory from any location.
+         */
+        xen_io_tlb_start = alloc_bootmem(bytes);
+        if (!xen_io_tlb_start)
+                panic("Cannot allocate SWIOTLB buffer");
+
+        xen_io_tlb_end = xen_io_tlb_start + bytes;
+        /*
+         * And replace that memory with pages under 4GB.
+         */
+        rc = xen_swiotlb_fixup(xen_io_tlb_start,
+                               bytes,
+                               xen_io_tlb_nslabs);
+        if (rc)
+                goto error;
+
+        start_dma_addr = xen_virt_to_bus(xen_io_tlb_start);
+        swiotlb_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs, verbose);
+
+        return;
+error:
+        panic("DMA(%d): Failed to exchange pages allocated for DMA with Xen! "\
+              "We either don't have the permission or you do not have enough"\
+              "free memory under 4GB!\n", rc);
+}
+
+void *
+xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+                           dma_addr_t *dma_handle, gfp_t flags)
+{
+        void *ret;
+        int order = get_order(size);
+        u64 dma_mask = DMA_BIT_MASK(32);
+        unsigned long vstart;
+
+        /*
+        * Ignore region specifiers - the kernel's ideas of
+        * pseudo-phys memory layout has nothing to do with the
+        * machine physical layout.  We can't allocate highmem
+        * because we can't return a pointer to it.
+        */
+        flags &= ~(__GFP_DMA | __GFP_HIGHMEM);
+
+        if (dma_alloc_from_coherent(hwdev, size, dma_handle, &ret))
+                return ret;
+
+        vstart = __get_free_pages(flags, order);
+        ret = (void *)vstart;
+
+        if (hwdev && hwdev->coherent_dma_mask)
+                dma_mask = dma_alloc_coherent_mask(hwdev, flags);
+
+        if (ret) {
+                if (xen_create_contiguous_region(vstart, order,
+                                                 fls64(dma_mask)) != 0) {
+                        free_pages(vstart, order);
+                        return NULL;
+                }
+                memset(ret, 0, size);
+                *dma_handle = virt_to_machine(ret).maddr;
+        }
+        return ret;
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent);
+
+void
+xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
+                          dma_addr_t dev_addr)
+{
+        int order = get_order(size);
+
+        if (dma_release_from_coherent(hwdev, order, vaddr))
+                return;
+
+        xen_destroy_contiguous_region((unsigned long)vaddr, order);
+        free_pages((unsigned long)vaddr, order);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent);
+
+
+/*
+ * Map a single buffer of the indicated size for DMA in streaming mode.  The
+ * physical address to use is returned.
+ *
+ * Once the device is given the dma address, the device owns this memory until
+ * either xen_swiotlb_unmap_page or xen_swiotlb_dma_sync_single is performed.
+ */
+dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
+                                unsigned long offset, size_t size,
+                                enum dma_data_direction dir,
+                                struct dma_attrs *attrs)
+{
+        phys_addr_t phys = page_to_phys(page) + offset;
+        dma_addr_t dev_addr = xen_phys_to_bus(phys);
+        void *map;
+
+        BUG_ON(dir == DMA_NONE);
+        /*
+         * If the address happens to be in the device's DMA window,
+         * we can safely return the device addr and not worry about bounce
+         * buffering it.
+         */
+        if (dma_capable(dev, dev_addr, size) &&
+            !range_straddles_page_boundary(phys, size) && !swiotlb_force)
+                return dev_addr;
+
+        /*
+         * Oh well, have to allocate and map a bounce buffer.
+         */
+        map = swiotlb_tbl_map_single(dev, start_dma_addr, phys, size, dir);
+        if (!map)
+                return DMA_ERROR_CODE;
+
+        dev_addr = xen_virt_to_bus(map);
+
+        /*
+         * Ensure that the address returned is DMA'ble
+         */
+        if (!dma_capable(dev, dev_addr, size))
+                panic("map_single: bounce buffer is not DMA'ble");
+
+        return dev_addr;
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_map_page);
+
+/*
+ * Unmap a single streaming mode DMA translation.  The dma_addr and size must
+ * match what was provided for in a previous xen_swiotlb_map_page call.  All
+ * other usages are undefined.
+ *
+ * After this call, reads by the cpu to the buffer are guaranteed to see
+ * whatever the device wrote there.
+ */
+static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
+                             size_t size, enum dma_data_direction dir)
+{
+        phys_addr_t paddr = xen_bus_to_phys(dev_addr);
+
+        BUG_ON(dir == DMA_NONE);
+
+        /* NOTE: We use dev_addr here, not paddr! */
+        if (is_xen_swiotlb_buffer(dev_addr)) {
+                swiotlb_tbl_unmap_single(hwdev, phys_to_virt(paddr), size, dir);
+                return;
+        }
+
+        if (dir != DMA_FROM_DEVICE)
+                return;
+
+        /*
+         * phys_to_virt doesn't work with hihgmem page but we could
+         * call dma_mark_clean() with hihgmem page here. However, we
+         * are fine since dma_mark_clean() is null on POWERPC. We can
+         * make dma_mark_clean() take a physical address if necessary.
+         */
+        dma_mark_clean(phys_to_virt(paddr), size);
+}
+
+void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
+                            size_t size, enum dma_data_direction dir,
+                            struct dma_attrs *attrs)
+{
+        xen_unmap_single(hwdev, dev_addr, size, dir);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_page);
+
+/*
+ * Make physical memory consistent for a single streaming mode DMA translation
+ * after a transfer.
+ *
+ * If you perform a xen_swiotlb_map_page() but wish to interrogate the buffer
+ * using the cpu, yet do not wish to teardown the dma mapping, you must
+ * call this function before doing so.  At the next point you give the dma
+ * address back to the card, you must first perform a
+ * xen_swiotlb_dma_sync_for_device, and then the device again owns the buffer
+ */
+static void
+xen_swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
+                        size_t size, enum dma_data_direction dir,
+                        enum dma_sync_target target)
+{
+        phys_addr_t paddr = xen_bus_to_phys(dev_addr);
+
+        BUG_ON(dir == DMA_NONE);
+
+        /* NOTE: We use dev_addr here, not paddr! */
+        if (is_xen_swiotlb_buffer(dev_addr)) {
+                swiotlb_tbl_sync_single(hwdev, phys_to_virt(paddr), size, dir,
+                                       target);
+                return;
+        }
+
+        if (dir != DMA_FROM_DEVICE)
+                return;
+
+        dma_mark_clean(phys_to_virt(paddr), size);
+}
+
+void
+xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
+                                size_t size, enum dma_data_direction dir)
+{
+        xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_CPU);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_cpu);
+
+void
+xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr,
+                                   size_t size, enum dma_data_direction dir)
+{
+        xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_DEVICE);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device);
+
+/*
+ * Map a set of buffers described by scatterlist in streaming mode for DMA.
+ * This is the scatter-gather version of the above xen_swiotlb_map_page
+ * interface.  Here the scatter gather list elements are each tagged with the
+ * appropriate dma address and length.  They are obtained via
+ * sg_dma_{address,length}(SG).
+ *
+ * NOTE: An implementation may be able to use a smaller number of
+ *       DMA address/length pairs than there are SG table elements.
+ *       (for example via virtual mapping capabilities)
+ *       The routine returns the number of addr/length pairs actually
+ *       used, at most nents.
+ *
+ * Device ownership issues as mentioned above for xen_swiotlb_map_page are the
+ * same here.
+ */
+int
+xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
+                         int nelems, enum dma_data_direction dir,
+                         struct dma_attrs *attrs)
+{
+        struct scatterlist *sg;
+        int i;
+
+        BUG_ON(dir == DMA_NONE);
+
+        for_each_sg(sgl, sg, nelems, i) {
+                phys_addr_t paddr = sg_phys(sg);
+                dma_addr_t dev_addr = xen_phys_to_bus(paddr);
+
+                if (swiotlb_force ||
+                    !dma_capable(hwdev, dev_addr, sg->length) ||
+                    range_straddles_page_boundary(paddr, sg->length)) {
+                        void *map = swiotlb_tbl_map_single(hwdev,
+                                                           start_dma_addr,
+                                                           sg_phys(sg),
+                                                           sg->length, dir);
+                        if (!map) {
+                                /* Don't panic here, we expect map_sg users
+                                   to do proper error handling. */
+                                xen_swiotlb_unmap_sg_attrs(hwdev, sgl, i, dir,
+                                                           attrs);
+                                sgl[0].dma_length = 0;
+                                return DMA_ERROR_CODE;
+                        }
+                        sg->dma_address = xen_virt_to_bus(map);
+                } else
+                        sg->dma_address = dev_addr;
+                sg->dma_length = sg->length;
+        }
+        return nelems;
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs);
+
+int
+xen_swiotlb_map_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
+                   enum dma_data_direction dir)
+{
+        return xen_swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, NULL);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg);
+
+/*
+ * Unmap a set of streaming mode DMA translations.  Again, cpu read rules
+ * concerning calls here are the same as for swiotlb_unmap_page() above.
+ */
+void
+xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
+                           int nelems, enum dma_data_direction dir,
+                           struct dma_attrs *attrs)
+{
+        struct scatterlist *sg;
+        int i;
+
+        BUG_ON(dir == DMA_NONE);
+
+        for_each_sg(sgl, sg, nelems, i)
+                xen_unmap_single(hwdev, sg->dma_address, sg->dma_length, dir);
+
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg_attrs);
+
+void
+xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
+                     enum dma_data_direction dir)
+{
+        return xen_swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, NULL);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg);
+
+/*
+ * Make physical memory consistent for a set of streaming mode DMA translations
+ * after a transfer.
+ *
+ * The same as swiotlb_sync_single_* but for a scatter-gather list, same rules
+ * and usage.
+ */
+static void
+xen_swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl,
+                    int nelems, enum dma_data_direction dir,
+                    enum dma_sync_target target)
+{
+        struct scatterlist *sg;
+        int i;
+
+        for_each_sg(sgl, sg, nelems, i)
+                xen_swiotlb_sync_single(hwdev, sg->dma_address,
+                                        sg->dma_length, dir, target);
+}
+
+void
+xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
+                            int nelems, enum dma_data_direction dir)
+{
+        xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_CPU);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_cpu);
+
+void
+xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
+                               int nelems, enum dma_data_direction dir)
+{
+        xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_DEVICE);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device);
+
+int
+xen_swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr)
+{
+        return !dma_addr;
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_dma_mapping_error);
+
+/*
+ * Return whether the given device DMA address mask can be supported
+ * properly.  For example, if your device can only drive the low 24-bits
+ * during bus mastering, then you would pass 0x00ffffff as the mask to
+ * this function.
+ */
+int
+xen_swiotlb_dma_supported(struct device *hwdev, u64 mask)
+{
+        return xen_virt_to_bus(xen_io_tlb_end - 1) <= mask;
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_dma_supported);
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 2f76c4a081a..7d9d06ba184 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -68,7 +68,7 @@ int nr_pdflush_threads;
  */
 int writeback_in_progress(struct backing_dev_info *bdi)
 {
-        return !list_empty(&bdi->work_list);
+        return test_bit(BDI_writeback_running, &bdi->state);
 }
 
 static void bdi_queue_work(struct backing_dev_info *bdi,
@@ -249,10 +249,18 @@ static void move_expired_inodes(struct list_head *delaying_queue,
 
 /*
  * Queue all expired dirty inodes for io, eldest first.
+ * Before
+ *         newly dirtied     b_dirty    b_io    b_more_io
+ *         =============>    gf         edc     BA
+ * After
+ *         newly dirtied     b_dirty    b_io    b_more_io
+ *         =============>    g          fBAedc
+ *                                           |
+ *                                           +--> dequeue for IO
  */
 static void queue_io(struct bdi_writeback *wb, unsigned long *older_than_this)
 {
-        list_splice_init(&wb->b_more_io, wb->b_io.prev);
+        list_splice_init(&wb->b_more_io, &wb->b_io);
         move_expired_inodes(&wb->b_dirty, &wb->b_io, older_than_this);
 }
 
@@ -363,62 +371,35 @@ writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
         spin_lock(&inode_lock);
         inode->i_state &= ~I_SYNC;
         if (!(inode->i_state & I_FREEING)) {
-                if ((inode->i_state & I_DIRTY_PAGES) && wbc->for_kupdate) {
-                        /*
-                         * More pages get dirtied by a fast dirtier.
-                         */
-                        goto select_queue;
-                } else if (inode->i_state & I_DIRTY) {
-                        /*
-                         * At least XFS will redirty the inode during the
-                         * writeback (delalloc) and on io completion (isize).
-                         */
-                        redirty_tail(inode);
-                } else if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
+                if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
                         /*
                          * We didn't write back all the pages.  nfs_writepages()
-                         * sometimes bales out without doing anything. Redirty
-                         * the inode; Move it from b_io onto b_more_io/b_dirty.
+                         * sometimes bales out without doing anything.
                          */
-                        /*
-                         * akpm: if the caller was the kupdate function we put
-                         * this inode at the head of b_dirty so it gets first
-                         * consideration.  Otherwise, move it to the tail, for
-                         * the reasons described there.  I'm not really sure
-                         * how much sense this makes.  Presumably I had a good
-                         * reasons for doing it this way, and I'd rather not
-                         * muck with it at present.
-                         */
-                        if (wbc->for_kupdate) {
+                        inode->i_state |= I_DIRTY_PAGES;
+                        if (wbc->nr_to_write <= 0) {
                                 /*
-                                 * For the kupdate function we move the inode
-                                 * to b_more_io so it will get more writeout as
-                                 * soon as the queue becomes uncongested.
+                                 * slice used up: queue for next turn
                                  */
-                                inode->i_state |= I_DIRTY_PAGES;
-select_queue:
-                                if (wbc->nr_to_write <= 0) {
-                                        /*
-                                         * slice used up: queue for next turn
-                                         */
-                                        requeue_io(inode);
-                                } else {
-                                        /*
-                                         * somehow blocked: retry later
-                                         */
-                                        redirty_tail(inode);
-                                }
+                                requeue_io(inode);
                         } else {
                                 /*
-                                 * Otherwise fully redirty the inode so that
-                                 * other inodes on this superblock will get some
-                                 * writeout.  Otherwise heavy writing to one
-                                 * file would indefinitely suspend writeout of
-                                 * all the other files.
+                                 * Writeback blocked by something other than
+                                 * congestion. Delay the inode for some time to
+                                 * avoid spinning on the CPU (100% iowait)
+                                 * retrying writeback of the dirty page/inode
+                                 * that cannot be performed immediately.
                                  */
-                                inode->i_state |= I_DIRTY_PAGES;
                                 redirty_tail(inode);
                         }
+                } else if (inode->i_state & I_DIRTY) {
+                        /*
+                         * Filesystems can dirty the inode during writeback
+                         * operations, such as delayed allocation during
+                         * submission or metadata updates after data IO
+                         * completion.
+                         */
+                        redirty_tail(inode);
                 } else if (atomic_read(&inode->i_count)) {
                         /*
                          * The inode is clean, inuse
@@ -590,7 +571,7 @@ static inline bool over_bground_thresh(void)
 {
         unsigned long background_thresh, dirty_thresh;
 
-        get_dirty_limits(&background_thresh, &dirty_thresh, NULL, NULL);
+        global_dirty_limits(&background_thresh, &dirty_thresh);
 
         return (global_page_state(NR_FILE_DIRTY) +
                 global_page_state(NR_UNSTABLE_NFS) >= background_thresh);
@@ -759,6 +740,7 @@ long wb_do_writeback(struct bdi_writeback *wb, int force_wait)
         struct wb_writeback_work *work;
         long wrote = 0;
 
+        set_bit(BDI_writeback_running, &wb->bdi->state);
         while ((work = get_next_work_item(bdi)) != NULL) {
                 /*
                  * Override sync mode, in case we must wait for completion
@@ -785,6 +767,7 @@ long wb_do_writeback(struct bdi_writeback *wb, int force_wait)
          * Check for periodic writeback, kupdated() style
          */
         wrote += wb_check_old_data_flush(wb);
+        clear_bit(BDI_writeback_running, &wb->bdi->state);
 
         return wrote;
 }
diff --git a/include/acpi/platform/aclinux.h b/include/acpi/platform/aclinux.h
index e5039a2856f..103f08aca76 100644
--- a/include/acpi/platform/aclinux.h
+++ b/include/acpi/platform/aclinux.h
@@ -148,13 +148,17 @@ static inline void *acpi_os_acquire_object(acpi_cache_t * cache)
 #define ACPI_ALLOCATE_ZEROED(a) acpi_os_allocate_zeroed(a)
 #define ACPI_FREE(a)            kfree(a)
 
-/* Used within ACPICA to show where it is safe to preempt execution */
-#include <linux/hardirq.h>
+#ifndef CONFIG_PREEMPT
+/*
+ * Used within ACPICA to show where it is safe to preempt execution
+ * when CONFIG_PREEMPT=n
+ */
 #define ACPI_PREEMPTION_POINT() \
         do { \
-                if (!in_atomic_preempt_off() && !irqs_disabled()) \
+                if (!irqs_disabled()) \
                         cond_resched(); \
         } while (0)
+#endif
 
 #endif /* __KERNEL__ */
 
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index e2a4da7d7fa..2a512bc0d4a 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -1075,7 +1075,6 @@ static __inline__ int drm_core_check_feature(struct drm_device *dev,
         return ((dev->driver->driver_features & feature) ? 1 : 0);
 }
 
-
 static inline int drm_dev_to_irq(struct drm_device *dev)
 {
         if (drm_core_check_feature(dev, DRIVER_USE_PLATFORM_DEVICE))
@@ -1084,11 +1083,22 @@ static inline int drm_dev_to_irq(struct drm_device *dev)
                 return dev->pdev->irq;
 }
 
-#ifdef __alpha__
-#define drm_get_pci_domain(dev) dev->hose->index
-#else
-#define drm_get_pci_domain(dev) 0
-#endif
+static inline int drm_get_pci_domain(struct drm_device *dev)
+{
+        if (drm_core_check_feature(dev, DRIVER_USE_PLATFORM_DEVICE))
+                return 0;
+
+#ifndef __alpha__
+        /* For historical reasons, drm_get_pci_domain() is busticated
+         * on most archs and has to remain so for userspace interface
+         * < 1.4, except on alpha which was right from the beginning
+         */
+        if (dev->if_version < 0x10004)
+                return 0;
+#endif /* __alpha__ */
+
+        return pci_domain_nr(dev->pdev->bus);
+}
 
 #if __OS_HAS_AGP
 static inline int drm_core_has_AGP(struct drm_device *dev)
diff --git a/include/drm/drm_core.h b/include/drm/drm_core.h
index 31673903607..4e7523863a4 100644
--- a/include/drm/drm_core.h
+++ b/include/drm/drm_core.h
@@ -27,7 +27,7 @@
 #define CORE_DATE               "20060810"
 
 #define DRM_IF_MAJOR    1
-#define DRM_IF_MINOR    3
+#define DRM_IF_MINOR    4
 
 #define CORE_MAJOR      1
 #define CORE_MINOR      1
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index c707270bff5..c9f3cc5949a 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -189,49 +189,16 @@ enum subpixel_order {
  */
 struct drm_display_info {
         char name[DRM_DISPLAY_INFO_LEN];
-        /* Input info */
-        bool serration_vsync;
-        bool sync_on_green;
-        bool composite_sync;
-        bool separate_syncs;
-        bool blank_to_black;
-        unsigned char video_level;
-        bool digital;
+
         /* Physical size */
         unsigned int width_mm;
         unsigned int height_mm;
 
-        /* Display parameters */
-        unsigned char gamma; /* FIXME: storage format */
-        bool gtf_supported;
-        bool standard_color;
-        enum {
-                monochrome = 0,
-                rgb,
-                other,
-                unknown,
-        } display_type;
-        bool active_off_supported;
-        bool suspend_supported;
-        bool standby_supported;
-
-        /* Color info FIXME: storage format */
-        unsigned short redx, redy;
-        unsigned short greenx, greeny;
-        unsigned short bluex, bluey;
-        unsigned short whitex, whitey;
-
         /* Clock limits FIXME: storage format */
         unsigned int min_vfreq, max_vfreq;
         unsigned int min_hfreq, max_hfreq;
         unsigned int pixel_clock;
 
-        /* White point indices FIXME: storage format */
-        unsigned int wpx1, wpy1;
-        unsigned int wpgamma1;
-        unsigned int wpx2, wpy2;
-        unsigned int wpgamma2;
-
         enum subpixel_order subpixel_order;
 
         char *raw_edid; /* if any */
@@ -342,7 +309,7 @@ struct drm_crtc_funcs {
 
         /* Set gamma on the CRTC */
         void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
-                          uint32_t size);
+                          uint32_t start, uint32_t size);
         /* Object destroy routine */
         void (*destroy)(struct drm_crtc *crtc);
 
diff --git a/include/drm/drm_edid.h b/include/drm/drm_edid.h
index 39e2cc5c7e6..5881fad91fa 100644
--- a/include/drm/drm_edid.h
+++ b/include/drm/drm_edid.h
@@ -28,6 +28,12 @@
 #define EDID_LENGTH 128
 #define DDC_ADDR 0x50
 
+#define CEA_EXT     0x02
+#define VTB_EXT     0x10
+#define DI_EXT      0x40
+#define LS_EXT      0x50
+#define MI_EXT      0x60
+
 struct est_timings {
         u8 t1;
         u8 t2;
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 7628219e538..35b00746c71 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -31,6 +31,7 @@ enum bdi_state {
         BDI_async_congested,    /* The async (write) queue is getting full */
         BDI_sync_congested,     /* The sync queue is getting full */
         BDI_registered,         /* bdi_register() was done */
+        BDI_writeback_running,  /* Writeback is in progress */
         BDI_unused,             /* Available bits start here */
 };
 
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 53691774d34..ca83a97c971 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -150,6 +150,7 @@ enum rq_flag_bits {
         __REQ_FLUSH,            /* request for cache flush */
         __REQ_IO_STAT,          /* account I/O stat */
         __REQ_MIXED_MERGE,      /* merge of different types, fail separately */
+        __REQ_SECURE,           /* secure discard (used with __REQ_DISCARD) */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -190,5 +191,6 @@ enum rq_flag_bits {
 #define REQ_FLUSH               (1 << __REQ_FLUSH)
 #define REQ_IO_STAT             (1 << __REQ_IO_STAT)
 #define REQ_MIXED_MERGE         (1 << __REQ_MIXED_MERGE)
+#define REQ_SECURE              (1 << __REQ_SECURE)
 
 #endif /* __LINUX_BLK_TYPES_H */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 89c855c5655..2c54906f678 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -389,6 +389,7 @@ struct request_queue
 #define QUEUE_FLAG_DISCARD     16       /* supports DISCARD */
 #define QUEUE_FLAG_NOXMERGES   17       /* No extended merges */
 #define QUEUE_FLAG_ADD_RANDOM  18       /* Contributes to random pool */
+#define QUEUE_FLAG_SECDISCARD  19       /* supports SECDISCARD */
 
 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
                                  (1 << QUEUE_FLAG_CLUSTER) |            \
@@ -524,6 +525,8 @@ enum {
 #define blk_queue_stackable(q)  \
         test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
 #define blk_queue_discard(q)    test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
+#define blk_queue_secdiscard(q) (blk_queue_discard(q) && \
+        test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
 
 #define blk_noretry_request(rq) \
         ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
@@ -918,10 +921,12 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
 }
 enum{
         BLKDEV_WAIT,    /* wait for completion */
-        BLKDEV_BARRIER, /*issue request with barrier */
+        BLKDEV_BARRIER, /* issue request with barrier */
+        BLKDEV_SECURE,  /* secure discard */
 };
 #define BLKDEV_IFL_WAIT         (1 << BLKDEV_WAIT)
 #define BLKDEV_IFL_BARRIER      (1 << BLKDEV_BARRIER)
+#define BLKDEV_IFL_SECURE       (1 << BLKDEV_SECURE)
 extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *,
                         unsigned long);
 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 267d0263051..7a0625e26a3 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -174,6 +174,7 @@ struct inodes_stat_t {
  */
 #define DISCARD_NOBARRIER       (WRITE | REQ_DISCARD)
 #define DISCARD_BARRIER         (WRITE | REQ_DISCARD | REQ_HARDBARRIER)
+#define DISCARD_SECURE          (DISCARD_NOBARRIER | REQ_SECURE)
 
 #define SEL_IN          1
 #define SEL_OUT         2
@@ -317,6 +318,7 @@ struct inodes_stat_t {
 #define BLKALIGNOFF _IO(0x12,122)
 #define BLKPBSZGET _IO(0x12,123)
 #define BLKDISCARDZEROES _IO(0x12,124)
+#define BLKSECDISCARD _IO(0x12,125)
 
 #define BMAP_IOCTL 1            /* obsolete - kept for compatibility */
 #define FIBMAP     _IO(0x00,1)  /* bmap access */
diff --git a/include/linux/io-mapping.h b/include/linux/io-mapping.h
index e0ea40f6c51..0a6b3d5c490 100644
--- a/include/linux/io-mapping.h
+++ b/include/linux/io-mapping.h
@@ -22,7 +22,6 @@
 #include <linux/slab.h>
 #include <asm/io.h>
 #include <asm/page.h>
-#include <asm/iomap.h>
 
 /*
  * The io_mapping mechanism provides an abstraction for mapping
@@ -33,6 +32,8 @@
 
 #ifdef CONFIG_HAVE_ATOMIC_IOMAP
 
+#include <asm/iomap.h>
+
 struct io_mapping {
         resource_size_t base;
         unsigned long size;
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 4d893eaf817..6b7525099e5 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -31,6 +31,7 @@ struct mmc_csd {
         unsigned int            tacc_ns;
         unsigned int            r2w_factor;
         unsigned int            max_dtr;
+        unsigned int            erase_size;             /* In sectors */
         unsigned int            read_blkbits;
         unsigned int            write_blkbits;
         unsigned int            capacity;
@@ -42,9 +43,16 @@ struct mmc_csd {
 
 struct mmc_ext_csd {
         u8                      rev;
+        u8                      erase_group_def;
+        u8                      sec_feature_support;
         unsigned int            sa_timeout;             /* Units: 100ns */
         unsigned int            hs_max_dtr;
         unsigned int            sectors;
+        unsigned int            hc_erase_size;          /* In sectors */
+        unsigned int            hc_erase_timeout;       /* In milliseconds */
+        unsigned int            sec_trim_mult;  /* Secure trim multiplier  */
+        unsigned int            sec_erase_mult; /* Secure erase multiplier */
+        unsigned int            trim_timeout;           /* In milliseconds */
 };
 
 struct sd_scr {
@@ -54,6 +62,12 @@ struct sd_scr {
 #define SD_SCR_BUS_WIDTH_4      (1<<2)
 };
 
+struct sd_ssr {
+        unsigned int            au;                     /* In sectors */
+        unsigned int            erase_timeout;          /* In milliseconds */
+        unsigned int            erase_offset;           /* In milliseconds */
+};
+
 struct sd_switch_caps {
         unsigned int            hs_max_dtr;
 };
@@ -106,6 +120,11 @@ struct mmc_card {
 #define MMC_QUIRK_NONSTD_SDIO   (1<<2)          /* non-standard SDIO card attached */
                                                 /* (missing CIA registers) */
 
+        unsigned int            erase_size;     /* erase size in sectors */
+        unsigned int            erase_shift;    /* if erase unit is power 2 */
+        unsigned int            pref_erase;     /* in sectors */
+        u8                      erased_byte;    /* value of erased bytes */
+
         u32                     raw_cid[4];     /* raw card CID */
         u32                     raw_csd[4];     /* raw card CSD */
         u32                     raw_scr[2];     /* raw card SCR */
@@ -113,6 +132,7 @@ struct mmc_card {
         struct mmc_csd          csd;            /* card specific */
         struct mmc_ext_csd      ext_csd;        /* mmc v4 extended card specific */
         struct sd_scr           scr;            /* extra SD information */
+        struct sd_ssr           ssr;            /* yet more SD information */
         struct sd_switch_caps   sw_caps;        /* switch (CMD6) caps */
 
         unsigned int            sdio_funcs;     /* number of SDIO functions */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index e4898e9eeb5..7429033acb6 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -92,6 +92,8 @@ struct mmc_command {
  *              actively failing requests
  */
 
+        unsigned int            erase_timeout;  /* in milliseconds */
+
         struct mmc_data         *data;          /* data segment associated with cmd */
         struct mmc_request      *mrq;           /* associated request */
 };
@@ -134,6 +136,23 @@ extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
         struct mmc_command *, int);
 
+#define MMC_ERASE_ARG           0x00000000
+#define MMC_SECURE_ERASE_ARG    0x80000000
+#define MMC_TRIM_ARG            0x00000001
+#define MMC_SECURE_TRIM1_ARG    0x80000001
+#define MMC_SECURE_TRIM2_ARG    0x80008000
+
+#define MMC_SECURE_ARGS         0x80000000
+#define MMC_TRIM_ARGS           0x00008001
+
+extern int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
+                     unsigned int arg);
+extern int mmc_can_erase(struct mmc_card *card);
+extern int mmc_can_trim(struct mmc_card *card);
+extern int mmc_can_secure_erase_trim(struct mmc_card *card);
+extern int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
+                                   unsigned int nr);
+
 extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *);
 extern unsigned int mmc_align_data_size(struct mmc_card *, unsigned int);
 
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 513ff0376b0..1575b52c3bf 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -156,6 +156,7 @@ struct mmc_host {
 #define MMC_CAP_DISABLE         (1 << 7)        /* Can the host be disabled */
 #define MMC_CAP_NONREMOVABLE    (1 << 8)        /* Nonremovable e.g. eMMC */
 #define MMC_CAP_WAIT_WHILE_BUSY (1 << 9)        /* Waits while card is busy */
+#define MMC_CAP_ERASE           (1 << 10)       /* Allow erase/trim commands */
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
 
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 52ce9886628..dd11ae51fb6 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -251,13 +251,21 @@ struct _mmc_csd {
  * EXT_CSD fields
  */
 
-#define EXT_CSD_BUS_WIDTH       183     /* R/W */
-#define EXT_CSD_HS_TIMING       185     /* R/W */
-#define EXT_CSD_CARD_TYPE       196     /* RO */
-#define EXT_CSD_STRUCTURE       194     /* RO */
-#define EXT_CSD_REV             192     /* RO */
-#define EXT_CSD_SEC_CNT         212     /* RO, 4 bytes */
-#define EXT_CSD_S_A_TIMEOUT     217
+#define EXT_CSD_ERASE_GROUP_DEF         175     /* R/W */
+#define EXT_CSD_ERASED_MEM_CONT         181     /* RO */
+#define EXT_CSD_BUS_WIDTH               183     /* R/W */
+#define EXT_CSD_HS_TIMING               185     /* R/W */
+#define EXT_CSD_REV                     192     /* RO */
+#define EXT_CSD_STRUCTURE               194     /* RO */
+#define EXT_CSD_CARD_TYPE               196     /* RO */
+#define EXT_CSD_SEC_CNT                 212     /* RO, 4 bytes */
+#define EXT_CSD_S_A_TIMEOUT             217     /* RO */
+#define EXT_CSD_ERASE_TIMEOUT_MULT      223     /* RO */
+#define EXT_CSD_HC_ERASE_GRP_SIZE       224     /* RO */
+#define EXT_CSD_SEC_TRIM_MULT           229     /* RO */
+#define EXT_CSD_SEC_ERASE_MULT          230     /* RO */
+#define EXT_CSD_SEC_FEATURE_SUPPORT     231     /* RO */
+#define EXT_CSD_TRIM_MULT               232     /* RO */
 
 /*
  * EXT_CSD field definitions
@@ -275,6 +283,10 @@ struct _mmc_csd {
 #define EXT_CSD_BUS_WIDTH_4     1       /* Card is in 4 bit mode */
 #define EXT_CSD_BUS_WIDTH_8     2       /* Card is in 8 bit mode */
 
+#define EXT_CSD_SEC_ER_EN       BIT(0)
+#define EXT_CSD_SEC_BD_BLK_EN   BIT(2)
+#define EXT_CSD_SEC_GB_CL_EN    BIT(4)
+
 /*
  * MMC_SWITCH access modes
  */
diff --git a/include/linux/mmc/sd.h b/include/linux/mmc/sd.h
index f310062cffb..3fd85e088cc 100644
--- a/include/linux/mmc/sd.h
+++ b/include/linux/mmc/sd.h
@@ -21,8 +21,13 @@
   /* class 10 */
 #define SD_SWITCH                 6   /* adtc [31:0] See below   R1  */
 
+  /* class 5 */
+#define SD_ERASE_WR_BLK_START    32   /* ac   [31:0] data addr   R1  */
+#define SD_ERASE_WR_BLK_END      33   /* ac   [31:0] data addr   R1  */
+
   /* Application commands */
 #define SD_APP_SET_BUS_WIDTH      6   /* ac   [1:0] bus width    R1  */
+#define SD_APP_SD_STATUS         13   /* adtc                    R1  */
 #define SD_APP_SEND_NUM_WR_BLKS  22   /* adtc                    R1  */
 #define SD_APP_OP_COND           41   /* bcr  [31:0] OCR         R3  */
 #define SD_APP_SEND_SCR          51   /* adtc                    R1  */
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index 35aa44ad9f2..835f85ecd2d 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -1,20 +1,6 @@
 #ifndef _LINUX_OF_DEVICE_H
 #define _LINUX_OF_DEVICE_H
 
-/*
- * The of_device *was* a kind of "base class" that was a superset of
- * struct device for use by devices attached to an OF node and probed
- * using OF properties.  However, the important bit of OF-style
- * probing, namely the device node pointer, has been moved into the
- * common struct device when CONFIG_OF is set to make OF-style probing
- * available to all bus types.  So now, just make of_device and
- * platform_device equivalent so that current of_platform bus users
- * can be transparently migrated over to using the platform bus.
- *
- * This line will go away once all references to of_device are removed
- * from the kernel.
- */
-#define of_device platform_device
 #include <linux/platform_device.h>
 #include <linux/of_platform.h> /* temporary until merge */
 
@@ -23,8 +9,6 @@
 #include <linux/of.h>
 #include <linux/mod_devicetable.h>
 
-#define to_of_device(d) container_of(d, struct of_device, dev)
-
 extern const struct of_device_id *of_match_device(
         const struct of_device_id *matches, const struct device *dev);
 extern void of_device_make_bus_id(struct device *dev);
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index 4e6d989c06d..a68716ad38c 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -19,9 +19,17 @@
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 
-/*
- * An of_platform_driver driver is attached to a basic of_device on
- * the "platform bus" (platform_bus_type).
+/**
+ * of_platform_driver - Legacy of-aware driver for platform devices.
+ *
+ * An of_platform_driver driver is attached to a basic platform_device on
+ * ether the "platform bus" (platform_bus_type), or the ibm ebus
+ * (ibmebus_bus_type).
+ *
+ * of_platform_driver is being phased out when used with the platform_bus_type,
+ * and regular platform_drivers should be used instead.  When the transition
+ * is complete, only ibmebus will be using this structure, and the
+ * platform_driver member of this structure will be removed.
  */
 struct of_platform_driver
 {
diff --git a/include/linux/vgaarb.h b/include/linux/vgaarb.h
index 814f294d4cd..6228b5b77d3 100644
--- a/include/linux/vgaarb.h
+++ b/include/linux/vgaarb.h
@@ -31,7 +31,6 @@
 #ifndef LINUX_VGA_H
 #define LINUX_VGA_H
 
-#include <asm/vga.h>
 
 /* Legacy VGA regions */
 #define VGA_RSRC_NONE          0x00
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index de05e96e0a7..01c2145118d 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -7,6 +7,8 @@
 
 struct vm_area_struct;          /* vma defining user mapping in mm_types.h */
 
+extern bool vmap_lazy_unmap;
+
 /* bits in flags of vmalloc's vm_struct below */
 #define VM_IOREMAP      0x00000001      /* ioremap() and friends */
 #define VM_ALLOC        0x00000002      /* vmalloc() */
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index c24eca71e80..72a5d647a5f 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -124,8 +124,9 @@ struct ctl_table;
 int dirty_writeback_centisecs_handler(struct ctl_table *, int,
                                       void __user *, size_t *, loff_t *);
 
-void get_dirty_limits(unsigned long *pbackground, unsigned long *pdirty,
-                      unsigned long *pbdi_dirty, struct backing_dev_info *bdi);
+void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
+unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
+                               unsigned long dirty);
 
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
diff --git a/include/xen/interface/memory.h b/include/xen/interface/memory.h
index af36ead1681..d3938d3e71f 100644
--- a/include/xen/interface/memory.h
+++ b/include/xen/interface/memory.h
@@ -9,6 +9,8 @@
 #ifndef __XEN_PUBLIC_MEMORY_H__
 #define __XEN_PUBLIC_MEMORY_H__
 
+#include <linux/spinlock.h>
+
 /*
  * Increase or decrease the specified domain's memory reservation. Returns a
  * -ve errcode on failure, or the # extents successfully allocated or freed.
@@ -53,6 +55,48 @@ struct xen_memory_reservation {
 DEFINE_GUEST_HANDLE_STRUCT(xen_memory_reservation);
 
 /*
+ * An atomic exchange of memory pages. If return code is zero then
+ * @out.extent_list provides GMFNs of the newly-allocated memory.
+ * Returns zero on complete success, otherwise a negative error code.
+ * On complete success then always @nr_exchanged == @in.nr_extents.
+ * On partial success @nr_exchanged indicates how much work was done.
+ */
+#define XENMEM_exchange             11
+struct xen_memory_exchange {
+    /*
+     * [IN] Details of memory extents to be exchanged (GMFN bases).
+     * Note that @in.address_bits is ignored and unused.
+     */
+    struct xen_memory_reservation in;
+
+    /*
+     * [IN/OUT] Details of new memory extents.
+     * We require that:
+     *  1. @in.domid == @out.domid
+     *  2. @in.nr_extents  << @in.extent_order ==
+     *     @out.nr_extents << @out.extent_order
+     *  3. @in.extent_start and @out.extent_start lists must not overlap
+     *  4. @out.extent_start lists GPFN bases to be populated
+     *  5. @out.extent_start is overwritten with allocated GMFN bases
+     */
+    struct xen_memory_reservation out;
+
+    /*
+     * [OUT] Number of input extents that were successfully exchanged:
+     *  1. The first @nr_exchanged input extents were successfully
+     *     deallocated.
+     *  2. The corresponding first entries in the output extent list correctly
+     *     indicate the GMFNs that were successfully exchanged.
+     *  3. All other input and output extents are untouched.
+     *  4. If not all input exents are exchanged then the return code of this
+     *     command will be non-zero.
+     *  5. THIS FIELD MUST BE INITIALISED TO ZERO BY THE CALLER!
+     */
+    unsigned long nr_exchanged;
+};
+
+DEFINE_GUEST_HANDLE_STRUCT(xen_memory_exchange);
+/*
  * Returns the maximum machine frame number of mapped RAM in this system.
  * This command always succeeds (it never returns an error code).
  * arg == NULL.
@@ -142,4 +186,10 @@ struct xen_translate_gpfn_list {
 };
 DEFINE_GUEST_HANDLE_STRUCT(xen_translate_gpfn_list);
 
+
+/*
+ * Prevent the balloon driver from changing the memory reservation
+ * during a driver critical region.
+ */
+extern spinlock_t xen_reservation_lock;
 #endif /* __XEN_PUBLIC_MEMORY_H__ */
diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h
new file mode 100644
index 00000000000..2ea2fdc79c1
--- /dev/null
+++ b/include/xen/swiotlb-xen.h
@@ -0,0 +1,65 @@
+#ifndef __LINUX_SWIOTLB_XEN_H
+#define __LINUX_SWIOTLB_XEN_H
+
+#include <linux/swiotlb.h>
+
+extern void xen_swiotlb_init(int verbose);
+
+extern void
+*xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+                            dma_addr_t *dma_handle, gfp_t flags);
+
+extern void
+xen_swiotlb_free_coherent(struct device *hwdev, size_t size,
+                          void *vaddr, dma_addr_t dma_handle);
+
+extern dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
+                                       unsigned long offset, size_t size,
+                                       enum dma_data_direction dir,
+                                       struct dma_attrs *attrs);
+
+extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
+                                   size_t size, enum dma_data_direction dir,
+                                   struct dma_attrs *attrs);
+/*
+extern int
+xen_swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents,
+                   enum dma_data_direction dir);
+
+extern void
+xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents,
+                     enum dma_data_direction dir);
+*/
+extern int
+xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
+                         int nelems, enum dma_data_direction dir,
+                         struct dma_attrs *attrs);
+
+extern void
+xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
+                           int nelems, enum dma_data_direction dir,
+                           struct dma_attrs *attrs);
+
+extern void
+xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
+                                size_t size, enum dma_data_direction dir);
+
+extern void
+xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
+                            int nelems, enum dma_data_direction dir);
+
+extern void
+xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr,
+                                   size_t size, enum dma_data_direction dir);
+
+extern void
+xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
+                               int nelems, enum dma_data_direction dir);
+
+extern int
+xen_swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr);
+
+extern int
+xen_swiotlb_dma_supported(struct device *hwdev, u64 mask);
+
+#endif /* __LINUX_SWIOTLB_XEN_H */
diff --git a/include/xen/xen-ops.h b/include/xen/xen-ops.h
index 46bc81ef74c..351f4051f6d 100644
--- a/include/xen/xen-ops.h
+++ b/include/xen/xen-ops.h
@@ -17,4 +17,10 @@ void xen_arch_resume(void);
 
 int xen_setup_shutdown_event(void);
 
+extern unsigned long *xen_contiguous_bitmap;
+int xen_create_contiguous_region(unsigned long vstart, unsigned int order,
+                                unsigned int address_bits);
+
+void xen_destroy_contiguous_region(unsigned long vstart, unsigned int order);
+
 #endif /* INCLUDE_XEN_OPS_H */
diff --git a/kernel/kfifo.c b/kernel/kfifo.c
index 02192dd905c..4502604ecad 100644
--- a/kernel/kfifo.c
+++ b/kernel/kfifo.c
@@ -10,7 +10,7 @@
  *
  * 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
+ * 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
@@ -333,17 +333,16 @@ static int setup_sgl_buf(struct scatterlist *sgl, void *buf,
                 buf += PAGE_SIZE;
                 npage = virt_to_page(buf);
                 if (page_to_phys(page) != page_to_phys(npage) - l) {
-                        sgl->page_link = 0;
-                        sg_set_page(sgl++, page, l - off, off);
-                        if (++n == nents)
+                        sg_set_page(sgl, page, l - off, off);
+                        sgl = sg_next(sgl);
+                        if (++n == nents || sgl == NULL)
                                 return n;
                         page = npage;
                         len -= l - off;
                         l = off = 0;
                 }
         }
-        sgl->page_link = 0;
-        sg_set_page(sgl++, page, len, off);
+        sg_set_page(sgl, page, len, off);
         return n + 1;
 }
 
@@ -363,7 +362,7 @@ static unsigned int setup_sgl(struct __kfifo *fifo, struct scatterlist *sgl,
         }
         l = min(len, size - off);
 
-        n  = setup_sgl_buf(sgl, fifo->data + off, nents, l);
+        n = setup_sgl_buf(sgl, fifo->data + off, nents, l);
         n += setup_sgl_buf(sgl + n, fifo->data, nents - n, len - l);
 
         if (n)
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 82499a5bdcb..959f8d6c8cc 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -710,6 +710,9 @@ static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
         if (rq->cmd_flags & REQ_DISCARD)
                 rw |= REQ_DISCARD;
 
+        if (rq->cmd_flags & REQ_SECURE)
+                rw |= REQ_SECURE;
+
         if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                 what |= BLK_TC_ACT(BLK_TC_PC);
                 __blk_add_trace(bt, 0, blk_rq_bytes(rq), rw,
@@ -1816,6 +1819,8 @@ void blk_fill_rwbs(char *rwbs, u32 rw, int bytes)
                 rwbs[i++] = 'S';
         if (rw & REQ_META)
                 rwbs[i++] = 'M';
+        if (rw & REQ_SECURE)
+                rwbs[i++] = 'E';
 
         rwbs[i] = '\0';
 }
@@ -1828,6 +1833,9 @@ void blk_fill_rwbs_rq(char *rwbs, struct request *rq)
         if (rq->cmd_flags & REQ_DISCARD)
                 rw |= REQ_DISCARD;
 
+        if (rq->cmd_flags & REQ_SECURE)
+                rw |= REQ_SECURE;
+
         bytes = blk_rq_bytes(rq);
 
         blk_fill_rwbs(rwbs, rw, bytes);
diff --git a/mm/backing-dev.c b/mm/backing-dev.c
index 08d357522e7..eaa4a5bbe06 100644
--- a/mm/backing-dev.c
+++ b/mm/backing-dev.c
@@ -81,7 +81,8 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
                 nr_more_io++;
         spin_unlock(&inode_lock);
 
-        get_dirty_limits(&background_thresh, &dirty_thresh, &bdi_thresh, bdi);
+        global_dirty_limits(&background_thresh, &dirty_thresh);
+        bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
 
 #define K(x) ((x) << (PAGE_SHIFT - 10))
         seq_printf(m,
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 0c6258bd1ba..20890d80c7e 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -253,32 +253,6 @@ static void bdi_writeout_fraction(struct backing_dev_info *bdi,
         }
 }
 
-/*
- * Clip the earned share of dirty pages to that which is actually available.
- * This avoids exceeding the total dirty_limit when the floating averages
- * fluctuate too quickly.
- */
-static void clip_bdi_dirty_limit(struct backing_dev_info *bdi,
-                unsigned long dirty, unsigned long *pbdi_dirty)
-{
-        unsigned long avail_dirty;
-
-        avail_dirty = global_page_state(NR_FILE_DIRTY) +
-                 global_page_state(NR_WRITEBACK) +
-                 global_page_state(NR_UNSTABLE_NFS) +
-                 global_page_state(NR_WRITEBACK_TEMP);
-
-        if (avail_dirty < dirty)
-                avail_dirty = dirty - avail_dirty;
-        else
-                avail_dirty = 0;
-
-        avail_dirty += bdi_stat(bdi, BDI_RECLAIMABLE) +
-                bdi_stat(bdi, BDI_WRITEBACK);
-
-        *pbdi_dirty = min(*pbdi_dirty, avail_dirty);
-}
-
 static inline void task_dirties_fraction(struct task_struct *tsk,
                 long *numerator, long *denominator)
 {
@@ -287,16 +261,24 @@ static inline void task_dirties_fraction(struct task_struct *tsk,
 }
 
 /*
- * scale the dirty limit
+ * task_dirty_limit - scale down dirty throttling threshold for one task
  *
  * task specific dirty limit:
  *
  *   dirty -= (dirty/8) * p_{t}
+ *
+ * To protect light/slow dirtying tasks from heavier/fast ones, we start
+ * throttling individual tasks before reaching the bdi dirty limit.
+ * Relatively low thresholds will be allocated to heavy dirtiers. So when
+ * dirty pages grow large, heavy dirtiers will be throttled first, which will
+ * effectively curb the growth of dirty pages. Light dirtiers with high enough
+ * dirty threshold may never get throttled.
  */
-static void task_dirty_limit(struct task_struct *tsk, unsigned long *pdirty)
+static unsigned long task_dirty_limit(struct task_struct *tsk,
+                                       unsigned long bdi_dirty)
 {
         long numerator, denominator;
-        unsigned long dirty = *pdirty;
+        unsigned long dirty = bdi_dirty;
         u64 inv = dirty >> 3;
 
         task_dirties_fraction(tsk, &numerator, &denominator);
@@ -304,10 +286,8 @@ static void task_dirty_limit(struct task_struct *tsk, unsigned long *pdirty)
         do_div(inv, denominator);
 
         dirty -= inv;
-        if (dirty < *pdirty/2)
-                dirty = *pdirty/2;
 
-        *pdirty = dirty;
+        return max(dirty, bdi_dirty/2);
 }
 
 /*
@@ -417,9 +397,16 @@ unsigned long determine_dirtyable_memory(void)
         return x + 1;   /* Ensure that we never return 0 */
 }
 
-void
-get_dirty_limits(unsigned long *pbackground, unsigned long *pdirty,
-                 unsigned long *pbdi_dirty, struct backing_dev_info *bdi)
+/**
+ * global_dirty_limits - background-writeback and dirty-throttling thresholds
+ *
+ * Calculate the dirty thresholds based on sysctl parameters
+ * - vm.dirty_background_ratio  or  vm.dirty_background_bytes
+ * - vm.dirty_ratio             or  vm.dirty_bytes
+ * The dirty limits will be lifted by 1/4 for PF_LESS_THROTTLE (ie. nfsd) and
+ * runtime tasks.
+ */
+void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty)
 {
         unsigned long background;
         unsigned long dirty;
@@ -451,27 +438,37 @@ get_dirty_limits(unsigned long *pbackground, unsigned long *pdirty,
         }
         *pbackground = background;
         *pdirty = dirty;
+}
+
+/**
+ * bdi_dirty_limit - @bdi's share of dirty throttling threshold
+ *
+ * Allocate high/low dirty limits to fast/slow devices, in order to prevent
+ * - starving fast devices
+ * - piling up dirty pages (that will take long time to sync) on slow devices
+ *
+ * The bdi's share of dirty limit will be adapting to its throughput and
+ * bounded by the bdi->min_ratio and/or bdi->max_ratio parameters, if set.
+ */
+unsigned long bdi_dirty_limit(struct backing_dev_info *bdi, unsigned long dirty)
+{
+        u64 bdi_dirty;
+        long numerator, denominator;
+
+        /*
+         * Calculate this BDI's share of the dirty ratio.
+         */
+        bdi_writeout_fraction(bdi, &numerator, &denominator);
 
-        if (bdi) {
-                u64 bdi_dirty;
-                long numerator, denominator;
+        bdi_dirty = (dirty * (100 - bdi_min_ratio)) / 100;
+        bdi_dirty *= numerator;
+        do_div(bdi_dirty, denominator);
 
-                /*
-                 * Calculate this BDI's share of the dirty ratio.
-                 */
-                bdi_writeout_fraction(bdi, &numerator, &denominator);
-
-                bdi_dirty = (dirty * (100 - bdi_min_ratio)) / 100;
-                bdi_dirty *= numerator;
-                do_div(bdi_dirty, denominator);
-                bdi_dirty += (dirty * bdi->min_ratio) / 100;
-                if (bdi_dirty > (dirty * bdi->max_ratio) / 100)
-                        bdi_dirty = dirty * bdi->max_ratio / 100;
-
-                *pbdi_dirty = bdi_dirty;
-                clip_bdi_dirty_limit(bdi, dirty, pbdi_dirty);
-                task_dirty_limit(current, pbdi_dirty);
-        }
+        bdi_dirty += (dirty * bdi->min_ratio) / 100;
+        if (bdi_dirty > (dirty * bdi->max_ratio) / 100)
+                bdi_dirty = dirty * bdi->max_ratio / 100;
+
+        return bdi_dirty;
 }
 
 /*
@@ -491,7 +488,7 @@ static void balance_dirty_pages(struct address_space *mapping,
         unsigned long bdi_thresh;
         unsigned long pages_written = 0;
         unsigned long pause = 1;
-
+        bool dirty_exceeded = false;
         struct backing_dev_info *bdi = mapping->backing_dev_info;
 
         for (;;) {
@@ -502,18 +499,11 @@ static void balance_dirty_pages(struct address_space *mapping,
                         .range_cyclic   = 1,
                 };
 
-                get_dirty_limits(&background_thresh, &dirty_thresh,
-                                &bdi_thresh, bdi);
-
                 nr_reclaimable = global_page_state(NR_FILE_DIRTY) +
                                         global_page_state(NR_UNSTABLE_NFS);
                 nr_writeback = global_page_state(NR_WRITEBACK);
 
-                bdi_nr_reclaimable = bdi_stat(bdi, BDI_RECLAIMABLE);
-                bdi_nr_writeback = bdi_stat(bdi, BDI_WRITEBACK);
-
-                if (bdi_nr_reclaimable + bdi_nr_writeback <= bdi_thresh)
-                        break;
+                global_dirty_limits(&background_thresh, &dirty_thresh);
 
                 /*
                  * Throttle it only when the background writeback cannot
@@ -524,26 +514,8 @@ static void balance_dirty_pages(struct address_space *mapping,
                                 (background_thresh + dirty_thresh) / 2)
                         break;
 
-                if (!bdi->dirty_exceeded)
-                        bdi->dirty_exceeded = 1;
-
-                /* Note: nr_reclaimable denotes nr_dirty + nr_unstable.
-                 * Unstable writes are a feature of certain networked
-                 * filesystems (i.e. NFS) in which data may have been
-                 * written to the server's write cache, but has not yet
-                 * been flushed to permanent storage.
-                 * Only move pages to writeback if this bdi is over its
-                 * threshold otherwise wait until the disk writes catch
-                 * up.
-                 */
-                trace_wbc_balance_dirty_start(&wbc, bdi);
-                if (bdi_nr_reclaimable > bdi_thresh) {
-                        writeback_inodes_wb(&bdi->wb, &wbc);
-                        pages_written += write_chunk - wbc.nr_to_write;
-                        get_dirty_limits(&background_thresh, &dirty_thresh,
-                                       &bdi_thresh, bdi);
-                        trace_wbc_balance_dirty_written(&wbc, bdi);
-                }
+                bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
+                bdi_thresh = task_dirty_limit(current, bdi_thresh);
 
                 /*
                  * In order to avoid the stacked BDI deadlock we need
@@ -558,16 +530,44 @@ static void balance_dirty_pages(struct address_space *mapping,
                 if (bdi_thresh < 2*bdi_stat_error(bdi)) {
                         bdi_nr_reclaimable = bdi_stat_sum(bdi, BDI_RECLAIMABLE);
                         bdi_nr_writeback = bdi_stat_sum(bdi, BDI_WRITEBACK);
-                } else if (bdi_nr_reclaimable) {
+                } else {
                         bdi_nr_reclaimable = bdi_stat(bdi, BDI_RECLAIMABLE);
                         bdi_nr_writeback = bdi_stat(bdi, BDI_WRITEBACK);
                 }
 
-                if (bdi_nr_reclaimable + bdi_nr_writeback <= bdi_thresh)
+                /*
+                 * The bdi thresh is somehow "soft" limit derived from the
+                 * global "hard" limit. The former helps to prevent heavy IO
+                 * bdi or process from holding back light ones; The latter is
+                 * the last resort safeguard.
+                 */
+                dirty_exceeded =
+                        (bdi_nr_reclaimable + bdi_nr_writeback >= bdi_thresh)
+                        || (nr_reclaimable + nr_writeback >= dirty_thresh);
+
+                if (!dirty_exceeded)
                         break;
-                if (pages_written >= write_chunk)
-                        break;          /* We've done our duty */
 
+                if (!bdi->dirty_exceeded)
+                        bdi->dirty_exceeded = 1;
+
+                /* Note: nr_reclaimable denotes nr_dirty + nr_unstable.
+                 * Unstable writes are a feature of certain networked
+                 * filesystems (i.e. NFS) in which data may have been
+                 * written to the server's write cache, but has not yet
+                 * been flushed to permanent storage.
+                 * Only move pages to writeback if this bdi is over its
+                 * threshold otherwise wait until the disk writes catch
+                 * up.
+                 */
+                trace_wbc_balance_dirty_start(&wbc, bdi);
+                if (bdi_nr_reclaimable > bdi_thresh) {
+                        writeback_inodes_wb(&bdi->wb, &wbc);
+                        pages_written += write_chunk - wbc.nr_to_write;
+                        trace_wbc_balance_dirty_written(&wbc, bdi);
+                        if (pages_written >= write_chunk)
+                                break;          /* We've done our duty */
+                }
                 trace_wbc_balance_dirty_wait(&wbc, bdi);
                 __set_current_state(TASK_INTERRUPTIBLE);
                 io_schedule_timeout(pause);
@@ -581,8 +581,7 @@ static void balance_dirty_pages(struct address_space *mapping,
                         pause = HZ / 10;
         }
 
-        if (bdi_nr_reclaimable + bdi_nr_writeback < bdi_thresh &&
-                        bdi->dirty_exceeded)
+        if (!dirty_exceeded && bdi->dirty_exceeded)
                 bdi->dirty_exceeded = 0;
 
         if (writeback_in_progress(bdi))
@@ -597,9 +596,7 @@ static void balance_dirty_pages(struct address_space *mapping,
          * background_thresh, to keep the amount of dirty memory low.
          */
         if ((laptop_mode && pages_written) ||
-            (!laptop_mode && ((global_page_state(NR_FILE_DIRTY)
-                               + global_page_state(NR_UNSTABLE_NFS))
-                                          > background_thresh)))
+            (!laptop_mode && (nr_reclaimable > background_thresh)))
                 bdi_start_background_writeback(bdi);
 }
 
@@ -663,7 +660,7 @@ void throttle_vm_writeout(gfp_t gfp_mask)
         unsigned long dirty_thresh;
 
         for ( ; ; ) {
-                get_dirty_limits(&background_thresh, &dirty_thresh, NULL, NULL);
+                global_dirty_limits(&background_thresh, &dirty_thresh);
 
                 /*
                  * Boost the allowable dirty threshold a bit for page
@@ -825,10 +822,10 @@ void __init page_writeback_init(void)
 /*
  * We tag pages in batches of WRITEBACK_TAG_BATCH to reduce tree_lock latency.
  */
-#define WRITEBACK_TAG_BATCH 4096
 void tag_pages_for_writeback(struct address_space *mapping,
                              pgoff_t start, pgoff_t end)
 {
+#define WRITEBACK_TAG_BATCH 4096
         unsigned long tagged;
 
         do {
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 918c51335d6..6b8889da69a 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -31,6 +31,7 @@
 #include <asm/tlbflush.h>
 #include <asm/shmparam.h>
 
+bool vmap_lazy_unmap __read_mostly = true;
 
 /*** Page table manipulation functions ***/
 
@@ -502,6 +503,9 @@ static unsigned long lazy_max_pages(void)
 {
         unsigned int log;
 
+        if (!vmap_lazy_unmap)
+                return 0;
+
         log = fls(num_online_cpus());
 
         return log * (32UL * 1024 * 1024 / PAGE_SIZE);
diff --git a/sound/aoa/soundbus/core.c b/sound/aoa/soundbus/core.c
index 99ca7120e26..7487eb76e03 100644
--- a/sound/aoa/soundbus/core.c
+++ b/sound/aoa/soundbus/core.c
@@ -59,7 +59,7 @@ static int soundbus_probe(struct device *dev)
 static int soundbus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct soundbus_dev * soundbus_dev;
-        struct of_device * of;
+        struct platform_device * of;
         const char *compat;
         int retval = 0;
         int cplen, seen = 0;
diff --git a/sound/aoa/soundbus/soundbus.h b/sound/aoa/soundbus/soundbus.h
index a0f223c13f6..adecbf36f4f 100644
--- a/sound/aoa/soundbus/soundbus.h
+++ b/sound/aoa/soundbus/soundbus.h
@@ -141,7 +141,7 @@ struct soundbus_dev {
         struct list_head onbuslist;
 
         /* the of device it represents */
-        struct of_device ofdev;
+        struct platform_device ofdev;
 
         /* what modules go by */
         char modalias[32];
diff --git a/sound/aoa/soundbus/sysfs.c b/sound/aoa/soundbus/sysfs.c
index 6496e754f00..e0980b5c2cd 100644
--- a/sound/aoa/soundbus/sysfs.c
+++ b/sound/aoa/soundbus/sysfs.c
@@ -16,7 +16,7 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
         struct soundbus_dev *sdev = to_soundbus_device(dev);
-        struct of_device *of = &sdev->ofdev;
+        struct platform_device *of = &sdev->ofdev;
         int length;
 
         if (*sdev->modalias) {
diff --git a/sound/soc/fsl/mpc5200_dma.c b/sound/soc/fsl/mpc5200_dma.c
index 1d4e7164e80..3dcd1469f28 100644
--- a/sound/soc/fsl/mpc5200_dma.c
+++ b/sound/soc/fsl/mpc5200_dma.c
@@ -369,7 +369,7 @@ struct snd_soc_platform mpc5200_audio_dma_platform = {
 };
 EXPORT_SYMBOL_GPL(mpc5200_audio_dma_platform);
 
-int mpc5200_audio_dma_create(struct of_device *op)
+int mpc5200_audio_dma_create(struct platform_device *op)
 {
         phys_addr_t fifo;
         struct psc_dma *psc_dma;
@@ -488,7 +488,7 @@ out_unmap:
 }
 EXPORT_SYMBOL_GPL(mpc5200_audio_dma_create);
 
-int mpc5200_audio_dma_destroy(struct of_device *op)
+int mpc5200_audio_dma_destroy(struct platform_device *op)
 {
         struct psc_dma *psc_dma = dev_get_drvdata(&op->dev);
 
diff --git a/sound/soc/fsl/mpc5200_dma.h b/sound/soc/fsl/mpc5200_dma.h
index e1ec6d91ea3..ca99586f2ad 100644
--- a/sound/soc/fsl/mpc5200_dma.h
+++ b/sound/soc/fsl/mpc5200_dma.h
@@ -81,8 +81,8 @@ to_psc_dma_stream(struct snd_pcm_substream *substream, struct psc_dma *psc_dma)
         return &psc_dma->playback;
 }
 
-int mpc5200_audio_dma_create(struct of_device *op);
-int mpc5200_audio_dma_destroy(struct of_device *op);
+int mpc5200_audio_dma_create(struct platform_device *op);
+int mpc5200_audio_dma_destroy(struct platform_device *op);
 
 extern struct snd_soc_platform mpc5200_audio_dma_platform;
 
diff --git a/sound/soc/fsl/mpc5200_psc_ac97.c b/sound/soc/fsl/mpc5200_psc_ac97.c
index e7f5d50ed08..a9560235dae 100644
--- a/sound/soc/fsl/mpc5200_psc_ac97.c
+++ b/sound/soc/fsl/mpc5200_psc_ac97.c
@@ -277,7 +277,7 @@ EXPORT_SYMBOL_GPL(psc_ac97_dai);
  * - Probe/remove operations
  * - OF device match table
  */
-static int __devinit psc_ac97_of_probe(struct of_device *op,
+static int __devinit psc_ac97_of_probe(struct platform_device *op,
                                       const struct of_device_id *match)
 {
         int rc, i;
@@ -317,7 +317,7 @@ static int __devinit psc_ac97_of_probe(struct of_device *op,
         return 0;
 }
 
-static int __devexit psc_ac97_of_remove(struct of_device *op)
+static int __devexit psc_ac97_of_remove(struct platform_device *op)
 {
         return mpc5200_audio_dma_destroy(op);
 }
diff --git a/sound/soc/fsl/mpc5200_psc_i2s.c b/sound/soc/fsl/mpc5200_psc_i2s.c
index 676841cbae9..534f04cb15d 100644
--- a/sound/soc/fsl/mpc5200_psc_i2s.c
+++ b/sound/soc/fsl/mpc5200_psc_i2s.c
@@ -152,7 +152,7 @@ EXPORT_SYMBOL_GPL(psc_i2s_dai);
  * - Probe/remove operations
  * - OF device match table
  */
-static int __devinit psc_i2s_of_probe(struct of_device *op,
+static int __devinit psc_i2s_of_probe(struct platform_device *op,
                                       const struct of_device_id *match)
 {
         int rc;
@@ -205,7 +205,7 @@ static int __devinit psc_i2s_of_probe(struct of_device *op,
 
 }
 
-static int __devexit psc_i2s_of_remove(struct of_device *op)
+static int __devexit psc_i2s_of_remove(struct platform_device *op)
 {
         return mpc5200_audio_dma_destroy(op);
 }
diff --git a/sound/soc/fsl/mpc8610_hpcd.c b/sound/soc/fsl/mpc8610_hpcd.c
index 3a501062c24..3b13b8d6526 100644
--- a/sound/soc/fsl/mpc8610_hpcd.c
+++ b/sound/soc/fsl/mpc8610_hpcd.c
@@ -200,7 +200,7 @@ static struct snd_soc_ops mpc8610_hpcd_ops = {
  * SSI devices.  We also probably aren't compatible with the generic Elo DMA
  * device driver.
  */
-static int mpc8610_hpcd_probe(struct of_device *ofdev,
+static int mpc8610_hpcd_probe(struct platform_device *ofdev,
         const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -534,7 +534,7 @@ error:
  *
  * This function is called when the OF device is removed.
  */
-static int mpc8610_hpcd_remove(struct of_device *ofdev)
+static int mpc8610_hpcd_remove(struct platform_device *ofdev)
 {
         struct platform_device *sound_device = dev_get_drvdata(&ofdev->dev);
         struct mpc8610_hpcd_data *machine_data =
diff --git a/sound/sparc/amd7930.c b/sound/sparc/amd7930.c
index 9eb1a4e0363..f8bcfc30f80 100644
--- a/sound/sparc/amd7930.c
+++ b/sound/sparc/amd7930.c
@@ -336,7 +336,7 @@ struct snd_amd7930 {
         int                     pgain;
         int                     mgain;
 
-        struct of_device        *op;
+        struct platform_device  *op;
         unsigned int            irq;
         struct snd_amd7930      *next;
 };
@@ -906,7 +906,7 @@ static int __devinit snd_amd7930_mixer(struct snd_amd7930 *amd)
 
 static int snd_amd7930_free(struct snd_amd7930 *amd)
 {
-        struct of_device *op = amd->op;
+        struct platform_device *op = amd->op;
 
         amd7930_idle(amd);
 
@@ -934,7 +934,7 @@ static struct snd_device_ops snd_amd7930_dev_ops = {
 };
 
 static int __devinit snd_amd7930_create(struct snd_card *card,
-                                        struct of_device *op,
+                                        struct platform_device *op,
                                         int irq, int dev,
                                         struct snd_amd7930 **ramd)
 {
@@ -1002,7 +1002,7 @@ static int __devinit snd_amd7930_create(struct snd_card *card,
         return 0;
 }
 
-static int __devinit amd7930_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit amd7930_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource *rp = &op->resource[0];
         static int dev_num;
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index 68570ee2c9b..c276086c3b5 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -111,7 +111,7 @@ struct snd_cs4231 {
         struct mutex            mce_mutex;      /* mutex for mce register */
         struct mutex            open_mutex;     /* mutex for ALSA open/close */
 
-        struct of_device        *op;
+        struct platform_device  *op;
         unsigned int            irq[2];
         unsigned int            regs_size;
         struct snd_cs4231       *next;
@@ -1771,7 +1771,7 @@ static unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont)
 
 static int snd_cs4231_sbus_free(struct snd_cs4231 *chip)
 {
-        struct of_device *op = chip->op;
+        struct platform_device *op = chip->op;
 
         if (chip->irq[0])
                 free_irq(chip->irq[0], chip);
@@ -1794,7 +1794,7 @@ static struct snd_device_ops snd_cs4231_sbus_dev_ops = {
 };
 
 static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
-                                            struct of_device *op,
+                                            struct platform_device *op,
                                             int dev)
 {
         struct snd_cs4231 *chip = card->private_data;
@@ -1856,7 +1856,7 @@ static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
         return 0;
 }
 
-static int __devinit cs4231_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource *rp = &op->resource[0];
         struct snd_card *card;
@@ -1931,7 +1931,7 @@ static unsigned int _ebus_dma_addr(struct cs4231_dma_control *dma_cont)
 
 static int snd_cs4231_ebus_free(struct snd_cs4231 *chip)
 {
-        struct of_device *op = chip->op;
+        struct platform_device *op = chip->op;
 
         if (chip->c_dma.ebus_info.regs) {
                 ebus_dma_unregister(&chip->c_dma.ebus_info);
@@ -1960,7 +1960,7 @@ static struct snd_device_ops snd_cs4231_ebus_dev_ops = {
 };
 
 static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
-                                            struct of_device *op,
+                                            struct platform_device *op,
                                             int dev)
 {
         struct snd_cs4231 *chip = card->private_data;
@@ -2048,7 +2048,7 @@ static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
         return 0;
 }
 
-static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_ebus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct snd_card *card;
         int err;
@@ -2072,7 +2072,7 @@ static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_dev
 }
 #endif
 
-static int __devinit cs4231_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_probe(struct platform_device *op, const struct of_device_id *match)
 {
 #ifdef EBUS_SUPPORT
         if (!strcmp(op->dev.of_node->parent->name, "ebus"))
@@ -2086,7 +2086,7 @@ static int __devinit cs4231_probe(struct of_device *op, const struct of_device_i
         return -ENODEV;
 }
 
-static int __devexit cs4231_remove(struct of_device *op)
+static int __devexit cs4231_remove(struct platform_device *op)
 {
         struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
 
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index c421901c48d..39cd5d69d05 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -299,7 +299,7 @@ struct dbri_streaminfo {
 /* This structure holds the information for both chips (DBRI & CS4215) */
 struct snd_dbri {
         int regs_size, irq;     /* Needed for unload */
-        struct of_device *op;   /* OF device info */
+        struct platform_device *op;     /* OF device info */
         spinlock_t lock;
 
         struct dbri_dma *dma;   /* Pointer to our DMA block */
@@ -2523,7 +2523,7 @@ static void __devinit snd_dbri_proc(struct snd_card *card)
 static void snd_dbri_free(struct snd_dbri *dbri);
 
 static int __devinit snd_dbri_create(struct snd_card *card,
-                                     struct of_device *op,
+                                     struct platform_device *op,
                                      int irq, int dev)
 {
         struct snd_dbri *dbri = card->private_data;
@@ -2592,7 +2592,7 @@ static void snd_dbri_free(struct snd_dbri *dbri)
                                   (void *)dbri->dma, dbri->dma_dvma);
 }
 
-static int __devinit dbri_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit dbri_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct snd_dbri *dbri;
         struct resource *rp;
@@ -2662,7 +2662,7 @@ _err:
         return err;
 }
 
-static int __devexit dbri_remove(struct of_device *op)
+static int __devexit dbri_remove(struct platform_device *op)
 {
         struct snd_card *card = dev_get_drvdata(&op->dev);