Merge branch 'drm-nouveau-next' of git://anongit.freedesktop.org/git/nouveau/linux-2.6 into drm-next

This is a major rework of the nouveau driver core, to reflect more closely
how the hw is used and to make it easier to implement newer features now
that the GPUs are more clearly understood than when nouveau started.

It also contains a few other bits:
thermal patches
nv41/44 pcie gart fixes
i2c unregistering fixes.

* 'drm-nouveau-next' of git://anongit.freedesktop.org/git/nouveau/linux-2.6: (191 commits)
  drm/nv98/crypt: fix fuc build with latest envyas
  drm/nouveau/devinit: fixup various issues with subdev ctor/init ordering
  drm/nv41/vm: fix and enable use of "real" pciegart
  drm/nv44/vm: fix and enable use of "real" pciegart
  drm/nv04/dmaobj: fixup vm target handling in preparation for nv4x pcie
  drm/nouveau: store supported dma mask in vmmgr
  drm/nvc0/ibus: initial implementation of subdev
  drm/nouveau/therm: add support for fan-control modes
  drm/nouveau/hwmon: rename pwm0* to pmw1* to follow hwmon's rules
  drm/nouveau/therm: calculate the pwm divisor on nv50+
  drm/nouveau/fan: rewrite the fan tachometer driver to get more precision, faster
  drm/nouveau/therm: move thermal-related functions to the therm subdev
  drm/nouveau/bios: parse the pwm divisor from the perf table
  drm/nouveau/therm: use the EXTDEV table to detect i2c monitoring devices
  drm/nouveau/therm: rework thermal table parsing
  drm/nouveau/gpio: expose the PWM/TOGGLE parameter found in the gpio vbios table
  drm/nouveau: fix pm initialization order
  drm/nouveau/bios: check that fixed tvdac gpio data is valid before using it
  drm/nouveau: log channel debug/error messages from client object rather than drm client
  drm/nouveau: have drm debugging macros build on top of core macros
  ...

Conflicts:
	drivers/gpu/drm/nouveau/nouveau_dp.c

469 files changed, 54203 insertions, 38085 deletions

diff --git a/Documentation/vfio.txt b/Documentation/vfio.txt
index 0cb6685c8029..8eda3635a17d 100644
--- a/Documentation/vfio.txt
+++ b/Documentation/vfio.txt
@@ -133,7 +133,7 @@ character devices for this group:
 $ lspci -n -s 0000:06:0d.0
 06:0d.0 0401: 1102:0002 (rev 08)
 # echo 0000:06:0d.0 > /sys/bus/pci/devices/0000:06:0d.0/driver/unbind
-# echo 1102 0002 > /sys/bus/pci/drivers/vfio/new_id
+# echo 1102 0002 > /sys/bus/pci/drivers/vfio-pci/new_id
 
 Now we need to look at what other devices are in the group to free
 it for use by VFIO:
diff --git a/MAINTAINERS b/MAINTAINERS
index b17587d9412f..9a6c4da3b2ff 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3552,11 +3552,12 @@ K:	\b(ABS|SYN)_MT_
 
 INTEL C600 SERIES SAS CONTROLLER DRIVER
 M:      Intel SCU Linux support <intel-linux-scu@intel.com>
+M:      Lukasz Dorau <lukasz.dorau@intel.com>
+M:      Maciej Patelczyk <maciej.patelczyk@intel.com>
 M:      Dave Jiang <dave.jiang@intel.com>
-M:      Ed Nadolski <edmund.nadolski@intel.com>
 L:      linux-scsi@vger.kernel.org
-T:      git git://git.kernel.org/pub/scm/linux/kernel/git/djbw/isci.git
-S:      Maintained
+T:      git git://git.code.sf.net/p/intel-sas/isci
+S:      Supported
 F:      drivers/scsi/isci/
 F:      firmware/isci/
 
@@ -5544,6 +5545,8 @@ F:	Documentation/devicetree/bindings/pwm/
 F:      include/linux/pwm.h
 F:      include/linux/of_pwm.h
 F:      drivers/pwm/
+F:      drivers/video/backlight/pwm_bl.c
+F:      include/linux/pwm_backlight.h
 
 PXA2xx/PXA3xx SUPPORT
 M:      Eric Miao <eric.y.miao@gmail.com>
diff --git a/Makefile b/Makefile
index a3c11d589681..bb9fff26f078 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 3
 PATCHLEVEL = 6
 SUBLEVEL = 0
-EXTRAVERSION = -rc7
+EXTRAVERSION =
 NAME = Terrified Chipmunk
 
 # *DOCUMENTATION*
diff --git a/arch/arm/mach-mxs/mach-mxs.c b/arch/arm/mach-mxs/mach-mxs.c
index 8dabfe81d07c..ff886e01a0b0 100644
--- a/arch/arm/mach-mxs/mach-mxs.c
+++ b/arch/arm/mach-mxs/mach-mxs.c
@@ -261,7 +261,7 @@ static void __init apx4devkit_init(void)
         enable_clk_enet_out();
 
         if (IS_BUILTIN(CONFIG_PHYLIB))
-                phy_register_fixup_for_uid(PHY_ID_KS8051, MICREL_PHY_ID_MASK,
+                phy_register_fixup_for_uid(PHY_ID_KSZ8051, MICREL_PHY_ID_MASK,
                                            apx4devkit_phy_fixup);
 
         mxsfb_pdata.mode_list = apx4devkit_video_modes;
diff --git a/arch/arm/mach-orion5x/common.c b/arch/arm/mach-orion5x/common.c
index 410291c67666..a6cd14ab1e4e 100644
--- a/arch/arm/mach-orion5x/common.c
+++ b/arch/arm/mach-orion5x/common.c
@@ -204,6 +204,13 @@ void __init orion5x_wdt_init(void)
 void __init orion5x_init_early(void)
 {
         orion_time_set_base(TIMER_VIRT_BASE);
+
+        /*
+         * Some Orion5x devices allocate their coherent buffers from atomic
+         * context. Increase size of atomic coherent pool to make sure such
+         * the allocations won't fail.
+         */
+        init_dma_coherent_pool_size(SZ_1M);
 }
 
 int orion5x_tclk;
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index e59c4ab71bcb..13f555d62491 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -346,6 +346,8 @@ static int __init atomic_pool_init(void)
                        (unsigned)pool->size / 1024);
                 return 0;
         }
+
+        kfree(pages);
 no_pages:
         kfree(bitmap);
 no_bitmap:
diff --git a/arch/c6x/include/asm/Kbuild b/arch/c6x/include/asm/Kbuild
index 3af601e31e66..f08e89183cda 100644
--- a/arch/c6x/include/asm/Kbuild
+++ b/arch/c6x/include/asm/Kbuild
@@ -2,6 +2,7 @@ include include/asm-generic/Kbuild.asm
 
 generic-y += atomic.h
 generic-y += auxvec.h
+generic-y += barrier.h
 generic-y += bitsperlong.h
 generic-y += bugs.h
 generic-y += cputime.h
diff --git a/arch/c6x/include/asm/barrier.h b/arch/c6x/include/asm/barrier.h
deleted file mode 100644
index 538240e85909..000000000000
--- a/arch/c6x/include/asm/barrier.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- *  Port on Texas Instruments TMS320C6x architecture
- *
- *  Copyright (C) 2004, 2009, 2010, 2011 Texas Instruments Incorporated
- *  Author: Aurelien Jacquiot (aurelien.jacquiot@jaluna.com)
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- */
-#ifndef _ASM_C6X_BARRIER_H
-#define _ASM_C6X_BARRIER_H
-
-#define nop()                    asm("NOP\n");
-
-#define mb()                     barrier()
-#define rmb()                    barrier()
-#define wmb()                    barrier()
-#define set_mb(var, value)       do { var = value;  mb(); } while (0)
-#define set_wmb(var, value)      do { var = value; wmb(); } while (0)
-
-#define smp_mb()                 barrier()
-#define smp_rmb()                barrier()
-#define smp_wmb()                barrier()
-#define smp_read_barrier_depends()      do { } while (0)
-
-#endif /* _ASM_C6X_BARRIER_H */
diff --git a/arch/tile/include/gxio/iorpc_trio.h b/arch/tile/include/gxio/iorpc_trio.h
index 15fb77992083..58105c31228b 100644
--- a/arch/tile/include/gxio/iorpc_trio.h
+++ b/arch/tile/include/gxio/iorpc_trio.h
@@ -25,21 +25,23 @@
 #include <linux/module.h>
 #include <asm/pgtable.h>
 
-#define GXIO_TRIO_OP_ALLOC_ASIDS       IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1400)
+#define GXIO_TRIO_OP_DEALLOC_ASID      IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1400)
+#define GXIO_TRIO_OP_ALLOC_ASIDS       IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1401)
 
-#define GXIO_TRIO_OP_ALLOC_MEMORY_MAPS IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1402)
+#define GXIO_TRIO_OP_ALLOC_MEMORY_MAPS IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1404)
 
-#define GXIO_TRIO_OP_ALLOC_PIO_REGIONS IORPC_OPCODE(IORPC_FORMAT_NONE, 0x140e)
-#define GXIO_TRIO_OP_INIT_PIO_REGION_AUX IORPC_OPCODE(IORPC_FORMAT_NONE, 0x140f)
+#define GXIO_TRIO_OP_ALLOC_PIO_REGIONS IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1412)
 
-#define GXIO_TRIO_OP_INIT_MEMORY_MAP_MMU_AUX IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x1417)
-#define GXIO_TRIO_OP_GET_PORT_PROPERTY IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x1418)
-#define GXIO_TRIO_OP_CONFIG_LEGACY_INTR IORPC_OPCODE(IORPC_FORMAT_KERNEL_INTERRUPT, 0x1419)
-#define GXIO_TRIO_OP_CONFIG_MSI_INTR   IORPC_OPCODE(IORPC_FORMAT_KERNEL_INTERRUPT, 0x141a)
+#define GXIO_TRIO_OP_INIT_PIO_REGION_AUX IORPC_OPCODE(IORPC_FORMAT_NONE, 0x1414)
 
-#define GXIO_TRIO_OP_SET_MPS_MRS       IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x141c)
-#define GXIO_TRIO_OP_FORCE_RC_LINK_UP  IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x141d)
-#define GXIO_TRIO_OP_FORCE_EP_LINK_UP  IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x141e)
+#define GXIO_TRIO_OP_INIT_MEMORY_MAP_MMU_AUX IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x141e)
+#define GXIO_TRIO_OP_GET_PORT_PROPERTY IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x141f)
+#define GXIO_TRIO_OP_CONFIG_LEGACY_INTR IORPC_OPCODE(IORPC_FORMAT_KERNEL_INTERRUPT, 0x1420)
+#define GXIO_TRIO_OP_CONFIG_MSI_INTR   IORPC_OPCODE(IORPC_FORMAT_KERNEL_INTERRUPT, 0x1421)
+
+#define GXIO_TRIO_OP_SET_MPS_MRS       IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x1423)
+#define GXIO_TRIO_OP_FORCE_RC_LINK_UP  IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x1424)
+#define GXIO_TRIO_OP_FORCE_EP_LINK_UP  IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x1425)
 #define GXIO_TRIO_OP_GET_MMIO_BASE     IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x8000)
 #define GXIO_TRIO_OP_CHECK_MMIO_OFFSET IORPC_OPCODE(IORPC_FORMAT_NONE_NOUSER, 0x8001)
 
diff --git a/arch/um/include/asm/processor-generic.h b/arch/um/include/asm/processor-generic.h
index 69f1c57a8d0d..33a6a2423bd2 100644
--- a/arch/um/include/asm/processor-generic.h
+++ b/arch/um/include/asm/processor-generic.h
@@ -20,14 +20,6 @@ struct mm_struct;
 
 struct thread_struct {
         struct task_struct *saved_task;
-        /*
-         * This flag is set to 1 before calling do_fork (and analyzed in
-         * copy_thread) to mark that we are begin called from userspace (fork /
-         * vfork / clone), and reset to 0 after. It is left to 0 when called
-         * from kernelspace (i.e. kernel_thread() or fork_idle(),
-         * as of 2.6.11).
-         */
-        int forking;
         struct pt_regs regs;
         int singlestep_syscall;
         void *fault_addr;
@@ -58,7 +50,6 @@ struct thread_struct {
 
 #define INIT_THREAD \
 { \
-        .forking                = 0, \
         .regs                   = EMPTY_REGS,   \
         .fault_addr             = NULL, \
         .prev_sched             = NULL, \
diff --git a/arch/um/include/shared/common-offsets.h b/arch/um/include/shared/common-offsets.h
index 40db8f71deae..2df313b6a586 100644
--- a/arch/um/include/shared/common-offsets.h
+++ b/arch/um/include/shared/common-offsets.h
@@ -7,16 +7,6 @@ DEFINE(UM_KERN_PAGE_MASK, PAGE_MASK);
 DEFINE(UM_KERN_PAGE_SHIFT, PAGE_SHIFT);
 DEFINE(UM_NSEC_PER_SEC, NSEC_PER_SEC);
 
-DEFINE_STR(UM_KERN_EMERG, KERN_EMERG);
-DEFINE_STR(UM_KERN_ALERT, KERN_ALERT);
-DEFINE_STR(UM_KERN_CRIT, KERN_CRIT);
-DEFINE_STR(UM_KERN_ERR, KERN_ERR);
-DEFINE_STR(UM_KERN_WARNING, KERN_WARNING);
-DEFINE_STR(UM_KERN_NOTICE, KERN_NOTICE);
-DEFINE_STR(UM_KERN_INFO, KERN_INFO);
-DEFINE_STR(UM_KERN_DEBUG, KERN_DEBUG);
-DEFINE_STR(UM_KERN_CONT, KERN_CONT);
-
 DEFINE(UM_ELF_CLASS, ELF_CLASS);
 DEFINE(UM_ELFCLASS32, ELFCLASS32);
 DEFINE(UM_ELFCLASS64, ELFCLASS64);
diff --git a/arch/um/include/shared/user.h b/arch/um/include/shared/user.h
index 4fa82c055aab..cef068563336 100644
--- a/arch/um/include/shared/user.h
+++ b/arch/um/include/shared/user.h
@@ -26,6 +26,17 @@
 extern void panic(const char *fmt, ...)
         __attribute__ ((format (printf, 1, 2)));
 
+/* Requires preincluding include/linux/kern_levels.h */
+#define UM_KERN_EMERG   KERN_EMERG
+#define UM_KERN_ALERT   KERN_ALERT
+#define UM_KERN_CRIT    KERN_CRIT
+#define UM_KERN_ERR     KERN_ERR
+#define UM_KERN_WARNING KERN_WARNING
+#define UM_KERN_NOTICE  KERN_NOTICE
+#define UM_KERN_INFO    KERN_INFO
+#define UM_KERN_DEBUG   KERN_DEBUG
+#define UM_KERN_CONT    KERN_CONT
+
 #ifdef UML_CONFIG_PRINTK
 extern int printk(const char *fmt, ...)
         __attribute__ ((format (printf, 1, 2)));
diff --git a/arch/um/kernel/exec.c b/arch/um/kernel/exec.c
index 6cade9366364..8c82786da823 100644
--- a/arch/um/kernel/exec.c
+++ b/arch/um/kernel/exec.c
@@ -39,34 +39,21 @@ void flush_thread(void)
 
 void start_thread(struct pt_regs *regs, unsigned long eip, unsigned long esp)
 {
+        get_safe_registers(regs->regs.gp, regs->regs.fp);
         PT_REGS_IP(regs) = eip;
         PT_REGS_SP(regs) = esp;
-}
-EXPORT_SYMBOL(start_thread);
-
-static long execve1(const char *file,
-                    const char __user *const __user *argv,
-                    const char __user *const __user *env)
-{
-        long error;
-
-        error = do_execve(file, argv, env, &current->thread.regs);
-        if (error == 0) {
-                task_lock(current);
-                current->ptrace &= ~PT_DTRACE;
+        current->ptrace &= ~PT_DTRACE;
 #ifdef SUBARCH_EXECVE1
-                SUBARCH_EXECVE1(&current->thread.regs.regs);
+        SUBARCH_EXECVE1(regs->regs);
 #endif
-                task_unlock(current);
-        }
-        return error;
 }
+EXPORT_SYMBOL(start_thread);
 
 long um_execve(const char *file, const char __user *const __user *argv, const char __user *const __user *env)
 {
         long err;
 
-        err = execve1(file, argv, env);
+        err = do_execve(file, argv, env, &current->thread.regs);
         if (!err)
                 UML_LONGJMP(current->thread.exec_buf, 1);
         return err;
@@ -81,7 +68,7 @@ long sys_execve(const char __user *file, const char __user *const __user *argv,
         filename = getname(file);
         error = PTR_ERR(filename);
         if (IS_ERR(filename)) goto out;
-        error = execve1(filename, argv, env);
+        error = do_execve(filename, argv, env, &current->thread.regs);
         putname(filename);
  out:
         return error;
diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
index 57fc7028714a..c5f5afa50745 100644
--- a/arch/um/kernel/process.c
+++ b/arch/um/kernel/process.c
@@ -181,11 +181,12 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
                 struct pt_regs *regs)
 {
         void (*handler)(void);
+        int kthread = current->flags & PF_KTHREAD;
         int ret = 0;
 
         p->thread = (struct thread_struct) INIT_THREAD;
 
-        if (current->thread.forking) {
+        if (!kthread) {
                 memcpy(&p->thread.regs.regs, &regs->regs,
                        sizeof(p->thread.regs.regs));
                 PT_REGS_SET_SYSCALL_RETURN(&p->thread.regs, 0);
@@ -195,8 +196,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
                 handler = fork_handler;
 
                 arch_copy_thread(&current->thread.arch, &p->thread.arch);
-        }
-        else {
+        } else {
                 get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp);
                 p->thread.request.u.thread = current->thread.request.u.thread;
                 handler = new_thread_handler;
@@ -204,7 +204,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
 
         new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
 
-        if (current->thread.forking) {
+        if (!kthread) {
                 clear_flushed_tls(p);
 
                 /*
diff --git a/arch/um/kernel/signal.c b/arch/um/kernel/signal.c
index 7362d58efc29..cc9c2350e417 100644
--- a/arch/um/kernel/signal.c
+++ b/arch/um/kernel/signal.c
@@ -22,9 +22,13 @@ static void handle_signal(struct pt_regs *regs, unsigned long signr,
                          struct k_sigaction *ka, siginfo_t *info)
 {
         sigset_t *oldset = sigmask_to_save();
+        int singlestep = 0;
         unsigned long sp;
         int err;
 
+        if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
+                singlestep = 1;
+
         /* Did we come from a system call? */
         if (PT_REGS_SYSCALL_NR(regs) >= 0) {
                 /* If so, check system call restarting.. */
@@ -61,7 +65,7 @@ static void handle_signal(struct pt_regs *regs, unsigned long signr,
         if (err)
                 force_sigsegv(signr, current);
         else
-                signal_delivered(signr, info, ka, regs, 0);
+                signal_delivered(signr, info, ka, regs, singlestep);
 }
 
 static int kern_do_signal(struct pt_regs *regs)
diff --git a/arch/um/kernel/syscall.c b/arch/um/kernel/syscall.c
index f958cb876ee3..a4c6d8eee74c 100644
--- a/arch/um/kernel/syscall.c
+++ b/arch/um/kernel/syscall.c
@@ -17,25 +17,25 @@
 
 long sys_fork(void)
 {
-        long ret;
-
-        current->thread.forking = 1;
-        ret = do_fork(SIGCHLD, UPT_SP(&current->thread.regs.regs),
+        return do_fork(SIGCHLD, UPT_SP(&current->thread.regs.regs),
                       &current->thread.regs, 0, NULL, NULL);
-        current->thread.forking = 0;
-        return ret;
 }
 
 long sys_vfork(void)
 {
-        long ret;
-
-        current->thread.forking = 1;
-        ret = do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
                       UPT_SP(&current->thread.regs.regs),
                       &current->thread.regs, 0, NULL, NULL);
-        current->thread.forking = 0;
-        return ret;
+}
+
+long sys_clone(unsigned long clone_flags, unsigned long newsp,
+               void __user *parent_tid, void __user *child_tid)
+{
+        if (!newsp)
+                newsp = UPT_SP(&current->thread.regs.regs);
+
+        return do_fork(clone_flags, newsp, &current->thread.regs, 0, parent_tid,
+                      child_tid);
 }
 
 long old_mmap(unsigned long addr, unsigned long len,
diff --git a/arch/um/scripts/Makefile.rules b/arch/um/scripts/Makefile.rules
index d50270d26b42..15889df9b466 100644
--- a/arch/um/scripts/Makefile.rules
+++ b/arch/um/scripts/Makefile.rules
@@ -8,7 +8,7 @@ USER_OBJS += $(filter %_user.o,$(obj-y) $(obj-m)  $(USER_SINGLE_OBJS))
 USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
 
 $(USER_OBJS:.o=.%): \
-        c_flags = -Wp,-MD,$(depfile) $(USER_CFLAGS) -include user.h $(CFLAGS_$(basetarget).o)
+        c_flags = -Wp,-MD,$(depfile) $(USER_CFLAGS) -include $(srctree)/include/linux/kern_levels.h -include user.h $(CFLAGS_$(basetarget).o)
 
 # These are like USER_OBJS but filter USER_CFLAGS through unprofile instead of
 # using it directly.
diff --git a/arch/x86/um/Kconfig b/arch/x86/um/Kconfig
index 9926e11a772d..aeaff8bef2f1 100644
--- a/arch/x86/um/Kconfig
+++ b/arch/x86/um/Kconfig
@@ -21,6 +21,7 @@ config 64BIT
 config X86_32
         def_bool !64BIT
         select HAVE_AOUT
+        select ARCH_WANT_IPC_PARSE_VERSION
 
 config X86_64
         def_bool 64BIT
diff --git a/arch/x86/um/shared/sysdep/kernel-offsets.h b/arch/x86/um/shared/sysdep/kernel-offsets.h
index 5868526b5eef..46a9df99f3c5 100644
--- a/arch/x86/um/shared/sysdep/kernel-offsets.h
+++ b/arch/x86/um/shared/sysdep/kernel-offsets.h
@@ -7,9 +7,6 @@
 #define DEFINE(sym, val) \
         asm volatile("\n->" #sym " %0 " #val : : "i" (val))
 
-#define STR(x) #x
-#define DEFINE_STR(sym, val) asm volatile("\n->" #sym " " STR(val) " " #val: : )
-
 #define BLANK() asm volatile("\n->" : : )
 
 #define OFFSET(sym, str, mem) \
diff --git a/arch/x86/um/shared/sysdep/syscalls.h b/arch/x86/um/shared/sysdep/syscalls.h
index bd9a89b67e41..ca255a805ed9 100644
--- a/arch/x86/um/shared/sysdep/syscalls.h
+++ b/arch/x86/um/shared/sysdep/syscalls.h
@@ -1,3 +1,5 @@
+extern long sys_clone(unsigned long clone_flags, unsigned long newsp,
+               void __user *parent_tid, void __user *child_tid);
 #ifdef __i386__
 #include "syscalls_32.h"
 #else
diff --git a/arch/x86/um/signal.c b/arch/x86/um/signal.c
index a508cea13503..ba7363ecf896 100644
--- a/arch/x86/um/signal.c
+++ b/arch/x86/um/signal.c
@@ -416,9 +416,6 @@ int setup_signal_stack_sc(unsigned long stack_top, int sig,
         PT_REGS_AX(regs) = (unsigned long) sig;
         PT_REGS_DX(regs) = (unsigned long) 0;
         PT_REGS_CX(regs) = (unsigned long) 0;
-
-        if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
-                ptrace_notify(SIGTRAP);
         return 0;
 }
 
@@ -466,9 +463,6 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
         PT_REGS_AX(regs) = (unsigned long) sig;
         PT_REGS_DX(regs) = (unsigned long) &frame->info;
         PT_REGS_CX(regs) = (unsigned long) &frame->uc;
-
-        if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
-                ptrace_notify(SIGTRAP);
         return 0;
 }
 
diff --git a/arch/x86/um/sys_call_table_32.c b/arch/x86/um/sys_call_table_32.c
index 68d1dc91b37b..b5408cecac6c 100644
--- a/arch/x86/um/sys_call_table_32.c
+++ b/arch/x86/um/sys_call_table_32.c
@@ -28,7 +28,7 @@
 #define ptregs_execve sys_execve
 #define ptregs_iopl sys_iopl
 #define ptregs_vm86old sys_vm86old
-#define ptregs_clone sys_clone
+#define ptregs_clone i386_clone
 #define ptregs_vm86 sys_vm86
 #define ptregs_sigaltstack sys_sigaltstack
 #define ptregs_vfork sys_vfork
diff --git a/arch/x86/um/syscalls_32.c b/arch/x86/um/syscalls_32.c
index b853e8600b9d..db444c7218fe 100644
--- a/arch/x86/um/syscalls_32.c
+++ b/arch/x86/um/syscalls_32.c
@@ -3,37 +3,24 @@
  * Licensed under the GPL
  */
 
-#include "linux/sched.h"
-#include "linux/shm.h"
-#include "linux/ipc.h"
-#include "linux/syscalls.h"
-#include "asm/mman.h"
-#include "asm/uaccess.h"
-#include "asm/unistd.h"
+#include <linux/syscalls.h>
+#include <sysdep/syscalls.h>
 
 /*
  * The prototype on i386 is:
  *
- *     int clone(int flags, void * child_stack, int * parent_tidptr, struct user_desc * newtls, int * child_tidptr)
+ *     int clone(int flags, void * child_stack, int * parent_tidptr, struct user_desc * newtls
  *
  * and the "newtls" arg. on i386 is read by copy_thread directly from the
  * register saved on the stack.
  */
-long sys_clone(unsigned long clone_flags, unsigned long newsp,
-               int __user *parent_tid, void *newtls, int __user *child_tid)
+long i386_clone(unsigned long clone_flags, unsigned long newsp,
+                int __user *parent_tid, void *newtls, int __user *child_tid)
 {
-        long ret;
-
-        if (!newsp)
-                newsp = UPT_SP(&current->thread.regs.regs);
-
-        current->thread.forking = 1;
-        ret = do_fork(clone_flags, newsp, &current->thread.regs, 0, parent_tid,
-                      child_tid);
-        current->thread.forking = 0;
-        return ret;
+        return sys_clone(clone_flags, newsp, parent_tid, child_tid);
 }
 
+
 long sys_sigaction(int sig, const struct old_sigaction __user *act,
                          struct old_sigaction __user *oact)
 {
diff --git a/arch/x86/um/syscalls_64.c b/arch/x86/um/syscalls_64.c
index f3d82bb6e15a..adb08eb5c22a 100644
--- a/arch/x86/um/syscalls_64.c
+++ b/arch/x86/um/syscalls_64.c
@@ -5,12 +5,9 @@
  * Licensed under the GPL
  */
 
-#include "linux/linkage.h"
-#include "linux/personality.h"
-#include "linux/utsname.h"
-#include "asm/prctl.h" /* XXX This should get the constants from libc */
-#include "asm/uaccess.h"
-#include "os.h"
+#include <linux/sched.h>
+#include <asm/prctl.h> /* XXX This should get the constants from libc */
+#include <os.h>
 
 long arch_prctl(struct task_struct *task, int code, unsigned long __user *addr)
 {
@@ -79,20 +76,6 @@ long sys_arch_prctl(int code, unsigned long addr)
         return arch_prctl(current, code, (unsigned long __user *) addr);
 }
 
-long sys_clone(unsigned long clone_flags, unsigned long newsp,
-               void __user *parent_tid, void __user *child_tid)
-{
-        long ret;
-
-        if (!newsp)
-                newsp = UPT_SP(&current->thread.regs.regs);
-        current->thread.forking = 1;
-        ret = do_fork(clone_flags, newsp, &current->thread.regs, 0, parent_tid,
-                      child_tid);
-        current->thread.forking = 0;
-        return ret;
-}
-
 void arch_switch_to(struct task_struct *to)
 {
         if ((to->thread.arch.fs == 0) || (to->mm == NULL))
diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index d11ca11d14fc..e2d62d697b5d 100644
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -17,6 +17,7 @@
 #include <asm/e820.h>
 #include <asm/setup.h>
 #include <asm/acpi.h>
+#include <asm/numa.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
 
@@ -544,4 +545,7 @@ void __init xen_arch_setup(void)
         disable_cpufreq();
         WARN_ON(set_pm_idle_to_default());
         fiddle_vdso();
+#ifdef CONFIG_NUMA
+        numa_off = 1;
+#endif
 }
diff --git a/drivers/block/nvme.c b/drivers/block/nvme.c
index 38a2d0631882..ad16c68c8645 100644
--- a/drivers/block/nvme.c
+++ b/drivers/block/nvme.c
@@ -79,6 +79,7 @@ struct nvme_dev {
         char serial[20];
         char model[40];
         char firmware_rev[8];
+        u32 max_hw_sectors;
 };
 
 /*
@@ -835,15 +836,15 @@ static int nvme_identify(struct nvme_dev *dev, unsigned nsid, unsigned cns,
 }
 
 static int nvme_get_features(struct nvme_dev *dev, unsigned fid,
-                                unsigned dword11, dma_addr_t dma_addr)
+                                unsigned nsid, dma_addr_t dma_addr)
 {
         struct nvme_command c;
 
         memset(&c, 0, sizeof(c));
         c.features.opcode = nvme_admin_get_features;
+        c.features.nsid = cpu_to_le32(nsid);
         c.features.prp1 = cpu_to_le64(dma_addr);
         c.features.fid = cpu_to_le32(fid);
-        c.features.dword11 = cpu_to_le32(dword11);
 
         return nvme_submit_admin_cmd(dev, &c, NULL);
 }
@@ -862,11 +863,51 @@ static int nvme_set_features(struct nvme_dev *dev, unsigned fid,
         return nvme_submit_admin_cmd(dev, &c, result);
 }
 
+/**
+ * nvme_cancel_ios - Cancel outstanding I/Os
+ * @queue: The queue to cancel I/Os on
+ * @timeout: True to only cancel I/Os which have timed out
+ */
+static void nvme_cancel_ios(struct nvme_queue *nvmeq, bool timeout)
+{
+        int depth = nvmeq->q_depth - 1;
+        struct nvme_cmd_info *info = nvme_cmd_info(nvmeq);
+        unsigned long now = jiffies;
+        int cmdid;
+
+        for_each_set_bit(cmdid, nvmeq->cmdid_data, depth) {
+                void *ctx;
+                nvme_completion_fn fn;
+                static struct nvme_completion cqe = {
+                        .status = cpu_to_le16(NVME_SC_ABORT_REQ) << 1,
+                };
+
+                if (timeout && !time_after(now, info[cmdid].timeout))
+                        continue;
+                dev_warn(nvmeq->q_dmadev, "Cancelling I/O %d\n", cmdid);
+                ctx = cancel_cmdid(nvmeq, cmdid, &fn);
+                fn(nvmeq->dev, ctx, &cqe);
+        }
+}
+
+static void nvme_free_queue_mem(struct nvme_queue *nvmeq)
+{
+        dma_free_coherent(nvmeq->q_dmadev, CQ_SIZE(nvmeq->q_depth),
+                                (void *)nvmeq->cqes, nvmeq->cq_dma_addr);
+        dma_free_coherent(nvmeq->q_dmadev, SQ_SIZE(nvmeq->q_depth),
+                                        nvmeq->sq_cmds, nvmeq->sq_dma_addr);
+        kfree(nvmeq);
+}
+
 static void nvme_free_queue(struct nvme_dev *dev, int qid)
 {
         struct nvme_queue *nvmeq = dev->queues[qid];
         int vector = dev->entry[nvmeq->cq_vector].vector;
 
+        spin_lock_irq(&nvmeq->q_lock);
+        nvme_cancel_ios(nvmeq, false);
+        spin_unlock_irq(&nvmeq->q_lock);
+
         irq_set_affinity_hint(vector, NULL);
         free_irq(vector, nvmeq);
 
@@ -876,18 +917,15 @@ static void nvme_free_queue(struct nvme_dev *dev, int qid)
                 adapter_delete_cq(dev, qid);
         }
 
-        dma_free_coherent(nvmeq->q_dmadev, CQ_SIZE(nvmeq->q_depth),
-                                (void *)nvmeq->cqes, nvmeq->cq_dma_addr);
-        dma_free_coherent(nvmeq->q_dmadev, SQ_SIZE(nvmeq->q_depth),
-                                        nvmeq->sq_cmds, nvmeq->sq_dma_addr);
-        kfree(nvmeq);
+        nvme_free_queue_mem(nvmeq);
 }
 
 static struct nvme_queue *nvme_alloc_queue(struct nvme_dev *dev, int qid,
                                                         int depth, int vector)
 {
         struct device *dmadev = &dev->pci_dev->dev;
-        unsigned extra = (depth / 8) + (depth * sizeof(struct nvme_cmd_info));
+        unsigned extra = DIV_ROUND_UP(depth, 8) + (depth *
+                                                sizeof(struct nvme_cmd_info));
         struct nvme_queue *nvmeq = kzalloc(sizeof(*nvmeq) + extra, GFP_KERNEL);
         if (!nvmeq)
                 return NULL;
@@ -975,7 +1013,7 @@ static __devinit struct nvme_queue *nvme_create_queue(struct nvme_dev *dev,
 
 static int __devinit nvme_configure_admin_queue(struct nvme_dev *dev)
 {
-        int result;
+        int result = 0;
         u32 aqa;
         u64 cap;
         unsigned long timeout;
@@ -1005,17 +1043,22 @@ static int __devinit nvme_configure_admin_queue(struct nvme_dev *dev)
         timeout = ((NVME_CAP_TIMEOUT(cap) + 1) * HZ / 2) + jiffies;
         dev->db_stride = NVME_CAP_STRIDE(cap);
 
-        while (!(readl(&dev->bar->csts) & NVME_CSTS_RDY)) {
+        while (!result && !(readl(&dev->bar->csts) & NVME_CSTS_RDY)) {
                 msleep(100);
                 if (fatal_signal_pending(current))
-                        return -EINTR;
+                        result = -EINTR;
                 if (time_after(jiffies, timeout)) {
                         dev_err(&dev->pci_dev->dev,
                                 "Device not ready; aborting initialisation\n");
-                        return -ENODEV;
+                        result = -ENODEV;
                 }
         }
 
+        if (result) {
+                nvme_free_queue_mem(nvmeq);
+                return result;
+        }
+
         result = queue_request_irq(dev, nvmeq, "nvme admin");
         dev->queues[0] = nvmeq;
         return result;
@@ -1037,6 +1080,8 @@ static struct nvme_iod *nvme_map_user_pages(struct nvme_dev *dev, int write,
         offset = offset_in_page(addr);
         count = DIV_ROUND_UP(offset + length, PAGE_SIZE);
         pages = kcalloc(count, sizeof(*pages), GFP_KERNEL);
+        if (!pages)
+                return ERR_PTR(-ENOMEM);
 
         err = get_user_pages_fast(addr, count, 1, pages);
         if (err < count) {
@@ -1146,14 +1191,13 @@ static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)
         return status;
 }
 
-static int nvme_user_admin_cmd(struct nvme_ns *ns,
+static int nvme_user_admin_cmd(struct nvme_dev *dev,
                                         struct nvme_admin_cmd __user *ucmd)
 {
-        struct nvme_dev *dev = ns->dev;
         struct nvme_admin_cmd cmd;
         struct nvme_command c;
         int status, length;
-        struct nvme_iod *iod;
+        struct nvme_iod *uninitialized_var(iod);
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
@@ -1204,7 +1248,7 @@ static int nvme_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         case NVME_IOCTL_ID:
                 return ns->ns_id;
         case NVME_IOCTL_ADMIN_CMD:
-                return nvme_user_admin_cmd(ns, (void __user *)arg);
+                return nvme_user_admin_cmd(ns->dev, (void __user *)arg);
         case NVME_IOCTL_SUBMIT_IO:
                 return nvme_submit_io(ns, (void __user *)arg);
         default:
@@ -1218,26 +1262,6 @@ static const struct block_device_operations nvme_fops = {
         .compat_ioctl   = nvme_ioctl,
 };
 
-static void nvme_timeout_ios(struct nvme_queue *nvmeq)
-{
-        int depth = nvmeq->q_depth - 1;
-        struct nvme_cmd_info *info = nvme_cmd_info(nvmeq);
-        unsigned long now = jiffies;
-        int cmdid;
-
-        for_each_set_bit(cmdid, nvmeq->cmdid_data, depth) {
-                void *ctx;
-                nvme_completion_fn fn;
-                static struct nvme_completion cqe = { .status = cpu_to_le16(NVME_SC_ABORT_REQ) << 1, };
-
-                if (!time_after(now, info[cmdid].timeout))
-                        continue;
-                dev_warn(nvmeq->q_dmadev, "Timing out I/O %d\n", cmdid);
-                ctx = cancel_cmdid(nvmeq, cmdid, &fn);
-                fn(nvmeq->dev, ctx, &cqe);
-        }
-}
-
 static void nvme_resubmit_bios(struct nvme_queue *nvmeq)
 {
         while (bio_list_peek(&nvmeq->sq_cong)) {
@@ -1269,7 +1293,7 @@ static int nvme_kthread(void *data)
                                 spin_lock_irq(&nvmeq->q_lock);
                                 if (nvme_process_cq(nvmeq))
                                         printk("process_cq did something\n");
-                                nvme_timeout_ios(nvmeq);
+                                nvme_cancel_ios(nvmeq, true);
                                 nvme_resubmit_bios(nvmeq);
                                 spin_unlock_irq(&nvmeq->q_lock);
                         }
@@ -1339,6 +1363,9 @@ static struct nvme_ns *nvme_alloc_ns(struct nvme_dev *dev, int nsid,
         ns->disk = disk;
         lbaf = id->flbas & 0xf;
         ns->lba_shift = id->lbaf[lbaf].ds;
+        blk_queue_logical_block_size(ns->queue, 1 << ns->lba_shift);
+        if (dev->max_hw_sectors)
+                blk_queue_max_hw_sectors(ns->queue, dev->max_hw_sectors);
 
         disk->major = nvme_major;
         disk->minors = NVME_MINORS;
@@ -1383,7 +1410,7 @@ static int set_queue_count(struct nvme_dev *dev, int count)
 
 static int __devinit nvme_setup_io_queues(struct nvme_dev *dev)
 {
-        int result, cpu, i, nr_io_queues, db_bar_size;
+        int result, cpu, i, nr_io_queues, db_bar_size, q_depth;
 
         nr_io_queues = num_online_cpus();
         result = set_queue_count(dev, nr_io_queues);
@@ -1429,9 +1456,10 @@ static int __devinit nvme_setup_io_queues(struct nvme_dev *dev)
                 cpu = cpumask_next(cpu, cpu_online_mask);
         }
 
+        q_depth = min_t(int, NVME_CAP_MQES(readq(&dev->bar->cap)) + 1,
+                                                                NVME_Q_DEPTH);
         for (i = 0; i < nr_io_queues; i++) {
-                dev->queues[i + 1] = nvme_create_queue(dev, i + 1,
-                                                        NVME_Q_DEPTH, i);
+                dev->queues[i + 1] = nvme_create_queue(dev, i + 1, q_depth, i);
                 if (IS_ERR(dev->queues[i + 1]))
                         return PTR_ERR(dev->queues[i + 1]);
                 dev->queue_count++;
@@ -1480,6 +1508,10 @@ static int __devinit nvme_dev_add(struct nvme_dev *dev)
         memcpy(dev->serial, ctrl->sn, sizeof(ctrl->sn));
         memcpy(dev->model, ctrl->mn, sizeof(ctrl->mn));
         memcpy(dev->firmware_rev, ctrl->fr, sizeof(ctrl->fr));
+        if (ctrl->mdts) {
+                int shift = NVME_CAP_MPSMIN(readq(&dev->bar->cap)) + 12;
+                dev->max_hw_sectors = 1 << (ctrl->mdts + shift - 9);
+        }
 
         id_ns = mem;
         for (i = 1; i <= nn; i++) {
@@ -1523,8 +1555,6 @@ static int nvme_dev_remove(struct nvme_dev *dev)
         list_del(&dev->node);
         spin_unlock(&dev_list_lock);
 
-        /* TODO: wait all I/O finished or cancel them */
-
         list_for_each_entry_safe(ns, next, &dev->namespaces, list) {
                 list_del(&ns->list);
                 del_gendisk(ns->disk);
@@ -1560,15 +1590,33 @@ static void nvme_release_prp_pools(struct nvme_dev *dev)
         dma_pool_destroy(dev->prp_small_pool);
 }
 
-/* XXX: Use an ida or something to let remove / add work correctly */
-static void nvme_set_instance(struct nvme_dev *dev)
+static DEFINE_IDA(nvme_instance_ida);
+
+static int nvme_set_instance(struct nvme_dev *dev)
 {
-        static int instance;
-        dev->instance = instance++;
+        int instance, error;
+
+        do {
+                if (!ida_pre_get(&nvme_instance_ida, GFP_KERNEL))
+                        return -ENODEV;
+
+                spin_lock(&dev_list_lock);
+                error = ida_get_new(&nvme_instance_ida, &instance);
+                spin_unlock(&dev_list_lock);
+        } while (error == -EAGAIN);
+
+        if (error)
+                return -ENODEV;
+
+        dev->instance = instance;
+        return 0;
 }
 
 static void nvme_release_instance(struct nvme_dev *dev)
 {
+        spin_lock(&dev_list_lock);
+        ida_remove(&nvme_instance_ida, dev->instance);
+        spin_unlock(&dev_list_lock);
 }
 
 static int __devinit nvme_probe(struct pci_dev *pdev,
@@ -1601,7 +1649,10 @@ static int __devinit nvme_probe(struct pci_dev *pdev,
         pci_set_drvdata(pdev, dev);
         dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
         dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
-        nvme_set_instance(dev);
+        result = nvme_set_instance(dev);
+        if (result)
+                goto disable;
+
         dev->entry[0].vector = pdev->irq;
 
         result = nvme_setup_prp_pools(dev);
@@ -1704,15 +1755,17 @@ static struct pci_driver nvme_driver = {
 
 static int __init nvme_init(void)
 {
-        int result = -EBUSY;
+        int result;
 
         nvme_thread = kthread_run(nvme_kthread, NULL, "nvme");
         if (IS_ERR(nvme_thread))
                 return PTR_ERR(nvme_thread);
 
-        nvme_major = register_blkdev(nvme_major, "nvme");
-        if (nvme_major <= 0)
+        result = register_blkdev(nvme_major, "nvme");
+        if (result < 0)
                 goto kill_kthread;
+        else if (result > 0)
+                nvme_major = result;
 
         result = pci_register_driver(&nvme_driver);
         if (result)
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 9917943a3572..54a55f03115d 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -246,13 +246,12 @@ static int rbd_open(struct block_device *bdev, fmode_t mode)
 {
         struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
 
-        rbd_get_dev(rbd_dev);
-
-        set_device_ro(bdev, rbd_dev->read_only);
-
         if ((mode & FMODE_WRITE) && rbd_dev->read_only)
                 return -EROFS;
 
+        rbd_get_dev(rbd_dev);
+        set_device_ro(bdev, rbd_dev->read_only);
+
         return 0;
 }
 
diff --git a/drivers/edac/i3200_edac.c b/drivers/edac/i3200_edac.c
index 47180a08edad..b6653a6fc5d5 100644
--- a/drivers/edac/i3200_edac.c
+++ b/drivers/edac/i3200_edac.c
@@ -391,7 +391,7 @@ static int i3200_probe1(struct pci_dev *pdev, int dev_idx)
                 for (j = 0; j < nr_channels; j++) {
                         struct dimm_info *dimm = csrow->channels[j]->dimm;
 
-                        dimm->nr_pages = nr_pages / nr_channels;
+                        dimm->nr_pages = nr_pages;
                         dimm->grain = nr_pages << PAGE_SHIFT;
                         dimm->mtype = MEM_DDR2;
                         dimm->dtype = DEV_UNKNOWN;
diff --git a/drivers/edac/i5000_edac.c b/drivers/edac/i5000_edac.c
index 39c63757c2a1..6a49dd00b81b 100644
--- a/drivers/edac/i5000_edac.c
+++ b/drivers/edac/i5000_edac.c
@@ -1012,6 +1012,10 @@ static void handle_channel(struct i5000_pvt *pvt, int slot, int channel,
                         /* add the number of COLUMN bits */
                         addrBits += MTR_DIMM_COLS_ADDR_BITS(mtr);
 
+                        /* Dual-rank memories have twice the size */
+                        if (dinfo->dual_rank)
+                                addrBits++;
+
                         addrBits += 6;  /* add 64 bits per DIMM */
                         addrBits -= 20; /* divide by 2^^20 */
                         addrBits -= 3;  /* 8 bits per bytes */
diff --git a/drivers/edac/sb_edac.c b/drivers/edac/sb_edac.c
index f3b1f9fafa4b..5715b7c2c517 100644
--- a/drivers/edac/sb_edac.c
+++ b/drivers/edac/sb_edac.c
@@ -513,7 +513,8 @@ static int get_dimm_config(struct mem_ctl_info *mci)
 {
         struct sbridge_pvt *pvt = mci->pvt_info;
         struct dimm_info *dimm;
-        int i, j, banks, ranks, rows, cols, size, npages;
+        unsigned i, j, banks, ranks, rows, cols, npages;
+        u64 size;
         u32 reg;
         enum edac_type mode;
         enum mem_type mtype;
@@ -585,10 +586,10 @@ static int get_dimm_config(struct mem_ctl_info *mci)
                                 cols = numcol(mtr);
 
                                 /* DDR3 has 8 I/O banks */
-                                size = (rows * cols * banks * ranks) >> (20 - 3);
+                                size = ((u64)rows * cols * banks * ranks) >> (20 - 3);
                                 npages = MiB_TO_PAGES(size);
 
-                                edac_dbg(0, "mc#%d: channel %d, dimm %d, %d Mb (%d pages) bank: %d, rank: %d, row: %#x, col: %#x\n",
+                                edac_dbg(0, "mc#%d: channel %d, dimm %d, %Ld Mb (%d pages) bank: %d, rank: %d, row: %#x, col: %#x\n",
                                          pvt->sbridge_dev->mc, i, j,
                                          size, npages,
                                          banks, ranks, rows, cols);
diff --git a/drivers/gpio/gpio-lpc32xx.c b/drivers/gpio/gpio-lpc32xx.c
index 8a420f13905e..ed94b4ea72e9 100644
--- a/drivers/gpio/gpio-lpc32xx.c
+++ b/drivers/gpio/gpio-lpc32xx.c
@@ -308,6 +308,7 @@ static int lpc32xx_gpio_dir_output_p012(struct gpio_chip *chip, unsigned pin,
 {
         struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
 
+        __set_gpio_level_p012(group, pin, value);
         __set_gpio_dir_p012(group, pin, 0);
 
         return 0;
@@ -318,6 +319,7 @@ static int lpc32xx_gpio_dir_output_p3(struct gpio_chip *chip, unsigned pin,
 {
         struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
 
+        __set_gpio_level_p3(group, pin, value);
         __set_gpio_dir_p3(group, pin, 0);
 
         return 0;
@@ -326,6 +328,9 @@ static int lpc32xx_gpio_dir_output_p3(struct gpio_chip *chip, unsigned pin,
 static int lpc32xx_gpio_dir_out_always(struct gpio_chip *chip, unsigned pin,
         int value)
 {
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpo_level_p3(group, pin, value);
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/Kconfig b/drivers/gpu/drm/nouveau/Kconfig
index 97a81260485a..8a55beeb8bdc 100644
--- a/drivers/gpu/drm/nouveau/Kconfig
+++ b/drivers/gpu/drm/nouveau/Kconfig
@@ -17,6 +17,34 @@ config DRM_NOUVEAU
         help
           Choose this option for open-source nVidia support.
 
+config NOUVEAU_DEBUG
+        int "Maximum debug level"
+        depends on DRM_NOUVEAU
+        range 0 7
+        default 5
+        help
+          Selects the maximum debug level to compile support for.
+
+          0 - fatal
+          1 - error
+          2 - warning
+          3 - info
+          4 - debug
+          5 - trace (recommended)
+          6 - paranoia
+          7 - spam
+
+          The paranoia and spam levels will add a lot of extra checks which
+          may potentially slow down driver operation.
+
+config NOUVEAU_DEBUG_DEFAULT
+        int "Default debug level"
+        depends on DRM_NOUVEAU
+        range 0 7
+        default 3
+        help
+          Selects the default debug level
+
 config DRM_NOUVEAU_BACKLIGHT
         bool "Support for backlight control"
         depends on DRM_NOUVEAU
@@ -25,14 +53,6 @@ config DRM_NOUVEAU_BACKLIGHT
           Say Y here if you want to control the backlight of your display
           (e.g. a laptop panel).
 
-config DRM_NOUVEAU_DEBUG
-        bool "Build in Nouveau's debugfs support"
-        depends on DRM_NOUVEAU && DEBUG_FS
-        default y
-        help
-          Say Y here if you want Nouveau to output debugging information
-          via debugfs.
-
 menu "I2C encoder or helper chips"
      depends on DRM && DRM_KMS_HELPER && I2C
 
diff --git a/drivers/gpu/drm/nouveau/Makefile b/drivers/gpu/drm/nouveau/Makefile
index 1cece6a78f39..a990df4d6c04 100644
--- a/drivers/gpu/drm/nouveau/Makefile
+++ b/drivers/gpu/drm/nouveau/Makefile
@@ -3,49 +3,190 @@
 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
 
 ccflags-y := -Iinclude/drm
-nouveau-y := nouveau_drv.o nouveau_state.o nouveau_channel.o nouveau_mem.o \
-             nouveau_gpuobj.o nouveau_irq.o nouveau_notifier.o \
-             nouveau_sgdma.o nouveau_dma.o nouveau_util.o \
-             nouveau_bo.o nouveau_fence.o nouveau_gem.o nouveau_ttm.o \
-             nouveau_hw.o nouveau_calc.o nouveau_bios.o nouveau_i2c.o \
-             nouveau_display.o nouveau_connector.o nouveau_fbcon.o \
-             nouveau_hdmi.o nouveau_dp.o nouveau_ramht.o \
-             nouveau_pm.o nouveau_volt.o nouveau_perf.o nouveau_temp.o \
-             nouveau_mm.o nouveau_vm.o nouveau_mxm.o nouveau_gpio.o \
-             nouveau_abi16.o \
-             nv04_timer.o \
-             nv04_mc.o nv40_mc.o nv50_mc.o \
-             nv04_fb.o nv10_fb.o nv20_fb.o nv30_fb.o nv40_fb.o \
-             nv50_fb.o nvc0_fb.o \
-             nv04_fifo.o nv10_fifo.o nv17_fifo.o nv40_fifo.o nv50_fifo.o \
-             nv84_fifo.o nvc0_fifo.o nve0_fifo.o \
-             nv04_fence.o nv10_fence.o nv84_fence.o nvc0_fence.o \
-             nv04_software.o nv50_software.o nvc0_software.o \
-             nv04_graph.o nv10_graph.o nv20_graph.o \
-             nv40_graph.o nv50_graph.o nvc0_graph.o nve0_graph.o \
-             nv40_grctx.o nv50_grctx.o nvc0_grctx.o nve0_grctx.o \
-             nv84_crypt.o nv98_crypt.o \
-             nva3_copy.o nvc0_copy.o \
-             nv31_mpeg.o nv50_mpeg.o \
-             nv84_bsp.o \
-             nv84_vp.o \
-             nv98_ppp.o \
-             nv04_instmem.o nv50_instmem.o nvc0_instmem.o \
-             nv04_dac.o nv04_dfp.o nv04_tv.o nv17_tv.o nv17_tv_modes.o \
-             nv04_crtc.o nv04_display.o nv04_cursor.o \
-             nv50_evo.o nv50_crtc.o nv50_dac.o nv50_sor.o \
-             nv50_cursor.o nv50_display.o \
-             nvd0_display.o \
-             nv04_fbcon.o nv50_fbcon.o nvc0_fbcon.o \
-             nv10_gpio.o nv50_gpio.o \
-             nv50_calc.o \
-             nv04_pm.o nv40_pm.o nv50_pm.o nva3_pm.o nvc0_pm.o \
-             nv50_vram.o nvc0_vram.o \
-             nv50_vm.o nvc0_vm.o nouveau_prime.o
-
-nouveau-$(CONFIG_DRM_NOUVEAU_DEBUG) += nouveau_debugfs.o
+ccflags-y += -I$(src)/core/include
+ccflags-y += -I$(src)/core
+ccflags-y += -I$(src)
+
+nouveau-y := core/core/client.o
+nouveau-y += core/core/engctx.o
+nouveau-y += core/core/engine.o
+nouveau-y += core/core/enum.o
+nouveau-y += core/core/gpuobj.o
+nouveau-y += core/core/handle.o
+nouveau-y += core/core/mm.o
+nouveau-y += core/core/namedb.o
+nouveau-y += core/core/object.o
+nouveau-y += core/core/option.o
+nouveau-y += core/core/parent.o
+nouveau-y += core/core/printk.o
+nouveau-y += core/core/ramht.o
+nouveau-y += core/core/subdev.o
+
+nouveau-y += core/subdev/bar/base.o
+nouveau-y += core/subdev/bar/nv50.o
+nouveau-y += core/subdev/bar/nvc0.o
+nouveau-y += core/subdev/bios/base.o
+nouveau-y += core/subdev/bios/bit.o
+nouveau-y += core/subdev/bios/conn.o
+nouveau-y += core/subdev/bios/dcb.o
+nouveau-y += core/subdev/bios/dp.o
+nouveau-y += core/subdev/bios/extdev.o
+nouveau-y += core/subdev/bios/gpio.o
+nouveau-y += core/subdev/bios/i2c.o
+nouveau-y += core/subdev/bios/init.o
+nouveau-y += core/subdev/bios/mxm.o
+nouveau-y += core/subdev/bios/perf.o
+nouveau-y += core/subdev/bios/pll.o
+nouveau-y += core/subdev/bios/therm.o
+nouveau-y += core/subdev/clock/nv04.o
+nouveau-y += core/subdev/clock/nv40.o
+nouveau-y += core/subdev/clock/nv50.o
+nouveau-y += core/subdev/clock/nva3.o
+nouveau-y += core/subdev/clock/nvc0.o
+nouveau-y += core/subdev/clock/pllnv04.o
+nouveau-y += core/subdev/clock/pllnva3.o
+nouveau-y += core/subdev/device/base.o
+nouveau-y += core/subdev/device/nv04.o
+nouveau-y += core/subdev/device/nv10.o
+nouveau-y += core/subdev/device/nv20.o
+nouveau-y += core/subdev/device/nv30.o
+nouveau-y += core/subdev/device/nv40.o
+nouveau-y += core/subdev/device/nv50.o
+nouveau-y += core/subdev/device/nvc0.o
+nouveau-y += core/subdev/device/nve0.o
+nouveau-y += core/subdev/devinit/base.o
+nouveau-y += core/subdev/devinit/nv04.o
+nouveau-y += core/subdev/devinit/nv05.o
+nouveau-y += core/subdev/devinit/nv10.o
+nouveau-y += core/subdev/devinit/nv1a.o
+nouveau-y += core/subdev/devinit/nv20.o
+nouveau-y += core/subdev/devinit/nv50.o
+nouveau-y += core/subdev/fb/base.o
+nouveau-y += core/subdev/fb/nv04.o
+nouveau-y += core/subdev/fb/nv10.o
+nouveau-y += core/subdev/fb/nv20.o
+nouveau-y += core/subdev/fb/nv30.o
+nouveau-y += core/subdev/fb/nv40.o
+nouveau-y += core/subdev/fb/nv50.o
+nouveau-y += core/subdev/fb/nvc0.o
+nouveau-y += core/subdev/gpio/base.o
+nouveau-y += core/subdev/gpio/nv10.o
+nouveau-y += core/subdev/gpio/nv50.o
+nouveau-y += core/subdev/gpio/nvd0.o
+nouveau-y += core/subdev/i2c/base.o
+nouveau-y += core/subdev/i2c/aux.o
+nouveau-y += core/subdev/i2c/bit.o
+nouveau-y += core/subdev/ibus/nvc0.o
+nouveau-y += core/subdev/ibus/nve0.o
+nouveau-y += core/subdev/instmem/base.o
+nouveau-y += core/subdev/instmem/nv04.o
+nouveau-y += core/subdev/instmem/nv40.o
+nouveau-y += core/subdev/instmem/nv50.o
+nouveau-y += core/subdev/ltcg/nvc0.o
+nouveau-y += core/subdev/mc/base.o
+nouveau-y += core/subdev/mc/nv04.o
+nouveau-y += core/subdev/mc/nv44.o
+nouveau-y += core/subdev/mc/nv50.o
+nouveau-y += core/subdev/mc/nv98.o
+nouveau-y += core/subdev/mc/nvc0.o
+nouveau-y += core/subdev/mxm/base.o
+nouveau-y += core/subdev/mxm/mxms.o
+nouveau-y += core/subdev/mxm/nv50.o
+nouveau-y += core/subdev/therm/base.o
+nouveau-y += core/subdev/therm/fan.o
+nouveau-y += core/subdev/therm/ic.o
+nouveau-y += core/subdev/therm/nv40.o
+nouveau-y += core/subdev/therm/nv50.o
+nouveau-y += core/subdev/therm/temp.o
+nouveau-y += core/subdev/timer/base.o
+nouveau-y += core/subdev/timer/nv04.o
+nouveau-y += core/subdev/vm/base.o
+nouveau-y += core/subdev/vm/nv04.o
+nouveau-y += core/subdev/vm/nv41.o
+nouveau-y += core/subdev/vm/nv44.o
+nouveau-y += core/subdev/vm/nv50.o
+nouveau-y += core/subdev/vm/nvc0.o
+
+nouveau-y += core/engine/dmaobj/base.o
+nouveau-y += core/engine/dmaobj/nv04.o
+nouveau-y += core/engine/dmaobj/nv50.o
+nouveau-y += core/engine/dmaobj/nvc0.o
+nouveau-y += core/engine/bsp/nv84.o
+nouveau-y += core/engine/copy/nva3.o
+nouveau-y += core/engine/copy/nvc0.o
+nouveau-y += core/engine/copy/nve0.o
+nouveau-y += core/engine/crypt/nv84.o
+nouveau-y += core/engine/crypt/nv98.o
+nouveau-y += core/engine/disp/nv04.o
+nouveau-y += core/engine/disp/nv50.o
+nouveau-y += core/engine/disp/nvd0.o
+nouveau-y += core/engine/disp/vga.o
+nouveau-y += core/engine/fifo/base.o
+nouveau-y += core/engine/fifo/nv04.o
+nouveau-y += core/engine/fifo/nv10.o
+nouveau-y += core/engine/fifo/nv17.o
+nouveau-y += core/engine/fifo/nv40.o
+nouveau-y += core/engine/fifo/nv50.o
+nouveau-y += core/engine/fifo/nv84.o
+nouveau-y += core/engine/fifo/nvc0.o
+nouveau-y += core/engine/fifo/nve0.o
+nouveau-y += core/engine/graph/ctxnv40.o
+nouveau-y += core/engine/graph/ctxnv50.o
+nouveau-y += core/engine/graph/ctxnvc0.o
+nouveau-y += core/engine/graph/ctxnve0.o
+nouveau-y += core/engine/graph/nv04.o
+nouveau-y += core/engine/graph/nv10.o
+nouveau-y += core/engine/graph/nv20.o
+nouveau-y += core/engine/graph/nv25.o
+nouveau-y += core/engine/graph/nv2a.o
+nouveau-y += core/engine/graph/nv30.o
+nouveau-y += core/engine/graph/nv34.o
+nouveau-y += core/engine/graph/nv35.o
+nouveau-y += core/engine/graph/nv40.o
+nouveau-y += core/engine/graph/nv50.o
+nouveau-y += core/engine/graph/nvc0.o
+nouveau-y += core/engine/graph/nve0.o
+nouveau-y += core/engine/mpeg/nv31.o
+nouveau-y += core/engine/mpeg/nv40.o
+nouveau-y += core/engine/mpeg/nv50.o
+nouveau-y += core/engine/mpeg/nv84.o
+nouveau-y += core/engine/ppp/nv98.o
+nouveau-y += core/engine/software/nv04.o
+nouveau-y += core/engine/software/nv10.o
+nouveau-y += core/engine/software/nv50.o
+nouveau-y += core/engine/software/nvc0.o
+nouveau-y += core/engine/vp/nv84.o
+
+# drm/core
+nouveau-y += nouveau_drm.o nouveau_chan.o nouveau_dma.o nouveau_fence.o
+nouveau-y += nouveau_irq.o nouveau_vga.o nouveau_agp.o
+nouveau-y += nouveau_ttm.o nouveau_sgdma.o nouveau_bo.o nouveau_gem.o
+nouveau-y += nouveau_prime.o nouveau_abi16.o
+nouveau-y += nv04_fence.o nv10_fence.o nv50_fence.o nv84_fence.o nvc0_fence.o
+
+# drm/kms
+nouveau-y += nouveau_bios.o nouveau_fbcon.o nouveau_display.o
+nouveau-y += nouveau_connector.o nouveau_hdmi.o nouveau_dp.o
+nouveau-y += nv04_fbcon.o nv50_fbcon.o nvc0_fbcon.o
+
+# drm/kms/nv04:nv50
+nouveau-y += nouveau_hw.o nouveau_calc.o
+nouveau-y += nv04_dac.o nv04_dfp.o nv04_tv.o nv17_tv.o nv17_tv_modes.o
+nouveau-y += nv04_crtc.o nv04_display.o nv04_cursor.o
+
+# drm/kms/nv50-
+nouveau-y += nv50_display.o nvd0_display.o
+nouveau-y += nv50_crtc.o nv50_dac.o nv50_sor.o nv50_cursor.o
+nouveau-y += nv50_evo.o
+
+# drm/pm
+nouveau-y += nouveau_pm.o nouveau_volt.o nouveau_perf.o
+nouveau-y += nv04_pm.o nv40_pm.o nv50_pm.o nva3_pm.o nvc0_pm.o
+nouveau-y += nouveau_mem.o
+
+# other random bits
 nouveau-$(CONFIG_COMPAT) += nouveau_ioc32.o
-nouveau-$(CONFIG_DRM_NOUVEAU_BACKLIGHT) += nouveau_backlight.o
 nouveau-$(CONFIG_ACPI) += nouveau_acpi.o
+nouveau-$(CONFIG_DRM_NOUVEAU_BACKLIGHT) += nouveau_backlight.o
 
 obj-$(CONFIG_DRM_NOUVEAU)+= nouveau.o
diff --git a/drivers/gpu/drm/nouveau/core/core/client.c b/drivers/gpu/drm/nouveau/core/core/client.c
new file mode 100644
index 000000000000..c617f0480071
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/client.c
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/client.h>
+#include <core/handle.h>
+#include <core/option.h>
+
+#include <subdev/device.h>
+
+static void
+nouveau_client_dtor(struct nouveau_object *object)
+{
+        struct nouveau_client *client = (void *)object;
+        nouveau_object_ref(NULL, &client->device);
+        nouveau_handle_destroy(client->root);
+        nouveau_namedb_destroy(&client->base);
+}
+
+static struct nouveau_oclass
+nouveau_client_oclass = {
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .dtor = nouveau_client_dtor,
+        },
+};
+
+int
+nouveau_client_create_(const char *name, u64 devname, const char *cfg,
+                       const char *dbg, int length, void **pobject)
+{
+        struct nouveau_object *device;
+        struct nouveau_client *client;
+        int ret;
+
+        device = (void *)nouveau_device_find(devname);
+        if (!device)
+                return -ENODEV;
+
+        ret = nouveau_namedb_create_(NULL, NULL, &nouveau_client_oclass,
+                                     NV_CLIENT_CLASS, nouveau_device_sclass,
+                                     0, length, pobject);
+        client = *pobject;
+        if (ret)
+                return ret;
+
+        ret = nouveau_handle_create(nv_object(client), ~0, ~0,
+                                    nv_object(client), &client->root);
+        if (ret) {
+                nouveau_namedb_destroy(&client->base);
+                return ret;
+        }
+
+        /* prevent init/fini being called, os in in charge of this */
+        atomic_set(&nv_object(client)->usecount, 2);
+
+        nouveau_object_ref(device, &client->device);
+        snprintf(client->name, sizeof(client->name), "%s", name);
+        client->debug = nouveau_dbgopt(dbg, "CLIENT");
+        return 0;
+}
+
+int
+nouveau_client_init(struct nouveau_client *client)
+{
+        int ret;
+        nv_debug(client, "init running\n");
+        ret = nouveau_handle_init(client->root);
+        nv_debug(client, "init completed with %d\n", ret);
+        return ret;
+}
+
+int
+nouveau_client_fini(struct nouveau_client *client, bool suspend)
+{
+        const char *name[2] = { "fini", "suspend" };
+        int ret;
+
+        nv_debug(client, "%s running\n", name[suspend]);
+        ret = nouveau_handle_fini(client->root, suspend);
+        nv_debug(client, "%s completed with %d\n", name[suspend], ret);
+        return ret;
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/engctx.c b/drivers/gpu/drm/nouveau/core/core/engctx.c
new file mode 100644
index 000000000000..e41b10d5eb59
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/engctx.c
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/namedb.h>
+#include <core/handle.h>
+#include <core/client.h>
+#include <core/engctx.h>
+
+#include <subdev/vm.h>
+
+static inline int
+nouveau_engctx_exists(struct nouveau_object *parent,
+                      struct nouveau_engine *engine, void **pobject)
+{
+        struct nouveau_engctx *engctx;
+        struct nouveau_object *parctx;
+
+        list_for_each_entry(engctx, &engine->contexts, head) {
+                parctx = nv_pclass(nv_object(engctx), NV_PARENT_CLASS);
+                if (parctx == parent) {
+                        atomic_inc(&nv_object(engctx)->refcount);
+                        *pobject = engctx;
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+int
+nouveau_engctx_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engobj,
+                       struct nouveau_oclass *oclass,
+                       struct nouveau_object *pargpu,
+                       u32 size, u32 align, u32 flags,
+                       int length, void **pobject)
+{
+        struct nouveau_client *client = nouveau_client(parent);
+        struct nouveau_engine *engine = nv_engine(engobj);
+        struct nouveau_object *engctx;
+        unsigned long save;
+        int ret;
+
+        /* check if this engine already has a context for the parent object,
+         * and reference it instead of creating a new one
+         */
+        spin_lock_irqsave(&engine->lock, save);
+        ret = nouveau_engctx_exists(parent, engine, pobject);
+        spin_unlock_irqrestore(&engine->lock, save);
+        if (ret)
+                return ret;
+
+        /* create the new context, supports creating both raw objects and
+         * objects backed by instance memory
+         */
+        if (size) {
+                ret = nouveau_gpuobj_create_(parent, engobj, oclass,
+                                             NV_ENGCTX_CLASS,
+                                             pargpu, size, align, flags,
+                                             length, pobject);
+        } else {
+                ret = nouveau_object_create_(parent, engobj, oclass,
+                                             NV_ENGCTX_CLASS, length, pobject);
+        }
+
+        engctx = *pobject;
+        if (ret)
+                return ret;
+
+        /* must take the lock again and re-check a context doesn't already
+         * exist (in case of a race) - the lock had to be dropped before as
+         * it's not possible to allocate the object with it held.
+         */
+        spin_lock_irqsave(&engine->lock, save);
+        ret = nouveau_engctx_exists(parent, engine, pobject);
+        if (ret) {
+                spin_unlock_irqrestore(&engine->lock, save);
+                nouveau_object_ref(NULL, &engctx);
+                return ret;
+        }
+
+        if (client->vm)
+                atomic_inc(&client->vm->engref[nv_engidx(engobj)]);
+        list_add(&nv_engctx(engctx)->head, &engine->contexts);
+        nv_engctx(engctx)->addr = ~0ULL;
+        spin_unlock_irqrestore(&engine->lock, save);
+        return 0;
+}
+
+void
+nouveau_engctx_destroy(struct nouveau_engctx *engctx)
+{
+        struct nouveau_object *engobj = nv_object(engctx)->engine;
+        struct nouveau_engine *engine = nv_engine(engobj);
+        struct nouveau_client *client = nouveau_client(engctx);
+        unsigned long save;
+
+        nouveau_gpuobj_unmap(&engctx->vma);
+        spin_lock_irqsave(&engine->lock, save);
+        list_del(&engctx->head);
+        spin_unlock_irqrestore(&engine->lock, save);
+
+        if (client->vm)
+                atomic_dec(&client->vm->engref[nv_engidx(engobj)]);
+
+        if (engctx->base.size)
+                nouveau_gpuobj_destroy(&engctx->base);
+        else
+                nouveau_object_destroy(&engctx->base.base);
+}
+
+int
+nouveau_engctx_init(struct nouveau_engctx *engctx)
+{
+        struct nouveau_object *object = nv_object(engctx);
+        struct nouveau_subdev *subdev = nv_subdev(object->engine);
+        struct nouveau_object *parent;
+        struct nouveau_subdev *pardev;
+        int ret;
+
+        ret = nouveau_gpuobj_init(&engctx->base);
+        if (ret)
+                return ret;
+
+        parent = nv_pclass(object->parent, NV_PARENT_CLASS);
+        pardev = nv_subdev(parent->engine);
+        if (nv_parent(parent)->context_attach) {
+                mutex_lock(&pardev->mutex);
+                ret = nv_parent(parent)->context_attach(parent, object);
+                mutex_unlock(&pardev->mutex);
+        }
+
+        if (ret) {
+                nv_error(parent, "failed to attach %s context, %d\n",
+                         subdev->name, ret);
+                return ret;
+        }
+
+        nv_debug(parent, "attached %s context\n", subdev->name);
+        return 0;
+}
+
+int
+nouveau_engctx_fini(struct nouveau_engctx *engctx, bool suspend)
+{
+        struct nouveau_object *object = nv_object(engctx);
+        struct nouveau_subdev *subdev = nv_subdev(object->engine);
+        struct nouveau_object *parent;
+        struct nouveau_subdev *pardev;
+        int ret = 0;
+
+        parent = nv_pclass(object->parent, NV_PARENT_CLASS);
+        pardev = nv_subdev(parent->engine);
+        if (nv_parent(parent)->context_detach) {
+                mutex_lock(&pardev->mutex);
+                ret = nv_parent(parent)->context_detach(parent, suspend, object);
+                mutex_unlock(&pardev->mutex);
+        }
+
+        if (ret) {
+                nv_error(parent, "failed to detach %s context, %d\n",
+                         subdev->name, ret);
+                return ret;
+        }
+
+        nv_debug(parent, "detached %s context\n", subdev->name);
+        return nouveau_gpuobj_fini(&engctx->base, suspend);
+}
+
+void
+_nouveau_engctx_dtor(struct nouveau_object *object)
+{
+        nouveau_engctx_destroy(nv_engctx(object));
+}
+
+int
+_nouveau_engctx_init(struct nouveau_object *object)
+{
+        return nouveau_engctx_init(nv_engctx(object));
+}
+
+
+int
+_nouveau_engctx_fini(struct nouveau_object *object, bool suspend)
+{
+        return nouveau_engctx_fini(nv_engctx(object), suspend);
+}
+
+struct nouveau_object *
+nouveau_engctx_get(struct nouveau_engine *engine, u64 addr)
+{
+        struct nouveau_engctx *engctx;
+        unsigned long flags;
+
+        spin_lock_irqsave(&engine->lock, flags);
+        list_for_each_entry(engctx, &engine->contexts, head) {
+                if (engctx->addr == addr) {
+                        engctx->save = flags;
+                        return nv_object(engctx);
+                }
+        }
+        spin_unlock_irqrestore(&engine->lock, flags);
+        return NULL;
+}
+
+void
+nouveau_engctx_put(struct nouveau_object *object)
+{
+        if (object) {
+                struct nouveau_engine *engine = nv_engine(object->engine);
+                struct nouveau_engctx *engctx = nv_engctx(object);
+                spin_unlock_irqrestore(&engine->lock, engctx->save);
+        }
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/engine.c b/drivers/gpu/drm/nouveau/core/core/engine.c
new file mode 100644
index 000000000000..09b3bd502fd0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/engine.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2012 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 <core/device.h>
+#include <core/engine.h>
+#include <core/option.h>
+
+int
+nouveau_engine_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engobj,
+                       struct nouveau_oclass *oclass, bool enable,
+                       const char *iname, const char *fname,
+                       int length, void **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_engine *engine;
+        int ret;
+
+        ret = nouveau_subdev_create_(parent, engobj, oclass, NV_ENGINE_CLASS,
+                                     iname, fname, length, pobject);
+        engine = *pobject;
+        if (ret)
+                return ret;
+
+        if (!nouveau_boolopt(device->cfgopt, iname, enable)) {
+                if (!enable)
+                        nv_warn(engine, "disabled, %s=1 to enable\n", iname);
+                return -ENODEV;
+        }
+
+        INIT_LIST_HEAD(&engine->contexts);
+        spin_lock_init(&engine->lock);
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/nouveau_util.c b/drivers/gpu/drm/nouveau/core/core/enum.c
index e51b51503baa..7cc7133d82de 100644
--- a/drivers/gpu/drm/nouveau/nouveau_util.c
+++ b/drivers/gpu/drm/nouveau/core/core/enum.c
@@ -25,27 +25,8 @@
  *
  */
 
-#include <linux/ratelimit.h>
-
-#include "nouveau_util.h"
-
-static DEFINE_RATELIMIT_STATE(nouveau_ratelimit_state, 3 * HZ, 20);
-
-void
-nouveau_bitfield_print(const struct nouveau_bitfield *bf, u32 value)
-{
-        while (bf->name) {
-                if (value & bf->mask) {
-                        printk(" %s", bf->name);
-                        value &= ~bf->mask;
-                }
-
-                bf++;
-        }
-
-        if (value)
-                printk(" (unknown bits 0x%08x)", value);
-}
+#include <core/os.h>
+#include <core/enum.h>
 
 const struct nouveau_enum *
 nouveau_enum_find(const struct nouveau_enum *en, u32 value)
@@ -63,16 +44,24 @@ void
 nouveau_enum_print(const struct nouveau_enum *en, u32 value)
 {
         en = nouveau_enum_find(en, value);
-        if (en) {
+        if (en)
                 printk("%s", en->name);
-                return;
-        }
-
-        printk("(unknown enum 0x%08x)", value);
+        else
+                printk("(unknown enum 0x%08x)", value);
 }
 
-int
-nouveau_ratelimit(void)
+void
+nouveau_bitfield_print(const struct nouveau_bitfield *bf, u32 value)
 {
-        return __ratelimit(&nouveau_ratelimit_state);
+        while (bf->name) {
+                if (value & bf->mask) {
+                        printk(" %s", bf->name);
+                        value &= ~bf->mask;
+                }
+
+                bf++;
+        }
+
+        if (value)
+                printk(" (unknown bits 0x%08x)", value);
 }
diff --git a/drivers/gpu/drm/nouveau/core/core/gpuobj.c b/drivers/gpu/drm/nouveau/core/core/gpuobj.c
new file mode 100644
index 000000000000..1f34549aff18
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/gpuobj.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/gpuobj.h>
+
+#include <subdev/instmem.h>
+#include <subdev/bar.h>
+#include <subdev/vm.h>
+
+void
+nouveau_gpuobj_destroy(struct nouveau_gpuobj *gpuobj)
+{
+        int i;
+
+        if (gpuobj->flags & NVOBJ_FLAG_ZERO_FREE) {
+                for (i = 0; i < gpuobj->size; i += 4)
+                        nv_wo32(gpuobj, i, 0x00000000);
+        }
+
+        if (gpuobj->heap.block_size)
+                nouveau_mm_fini(&gpuobj->heap);
+
+        nouveau_object_destroy(&gpuobj->base);
+}
+
+int
+nouveau_gpuobj_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, u32 pclass,
+                       struct nouveau_object *pargpu,
+                       u32 size, u32 align, u32 flags,
+                       int length, void **pobject)
+{
+        struct nouveau_instmem *imem = nouveau_instmem(parent);
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nouveau_gpuobj *gpuobj;
+        struct nouveau_mm *heap = NULL;
+        int ret, i;
+        u64 addr;
+
+        *pobject = NULL;
+
+        if (pargpu) {
+                while ((pargpu = nv_pclass(pargpu, NV_GPUOBJ_CLASS))) {
+                        if (nv_gpuobj(pargpu)->heap.block_size)
+                                break;
+                        pargpu = pargpu->parent;
+                }
+
+                if (unlikely(pargpu == NULL)) {
+                        nv_error(parent, "no gpuobj heap\n");
+                        return -EINVAL;
+                }
+
+                addr =  nv_gpuobj(pargpu)->addr;
+                heap = &nv_gpuobj(pargpu)->heap;
+                atomic_inc(&parent->refcount);
+        } else {
+                ret = imem->alloc(imem, parent, size, align, &parent);
+                pargpu = parent;
+                if (ret)
+                        return ret;
+
+                addr = nv_memobj(pargpu)->addr;
+                size = nv_memobj(pargpu)->size;
+
+                if (bar && bar->alloc) {
+                        struct nouveau_instobj *iobj = (void *)parent;
+                        struct nouveau_mem **mem = (void *)(iobj + 1);
+                        struct nouveau_mem *node = *mem;
+                        if (!bar->alloc(bar, parent, node, &pargpu)) {
+                                nouveau_object_ref(NULL, &parent);
+                                parent = pargpu;
+                        }
+                }
+        }
+
+        ret = nouveau_object_create_(parent, engine, oclass, pclass |
+                                     NV_GPUOBJ_CLASS, length, pobject);
+        nouveau_object_ref(NULL, &parent);
+        gpuobj = *pobject;
+        if (ret)
+                return ret;
+
+        gpuobj->parent = pargpu;
+        gpuobj->flags = flags;
+        gpuobj->addr = addr;
+        gpuobj->size = size;
+
+        if (heap) {
+                ret = nouveau_mm_head(heap, 1, size, size,
+                                      max(align, (u32)1), &gpuobj->node);
+                if (ret)
+                        return ret;
+
+                gpuobj->addr += gpuobj->node->offset;
+        }
+
+        if (gpuobj->flags & NVOBJ_FLAG_HEAP) {
+                ret = nouveau_mm_init(&gpuobj->heap, 0, gpuobj->size, 1);
+                if (ret)
+                        return ret;
+        }
+
+        if (flags & NVOBJ_FLAG_ZERO_ALLOC) {
+                for (i = 0; i < gpuobj->size; i += 4)
+                        nv_wo32(gpuobj, i, 0x00000000);
+        }
+
+        return ret;
+}
+
+struct nouveau_gpuobj_class {
+        struct nouveau_object *pargpu;
+        u64 size;
+        u32 align;
+        u32 flags;
+};
+
+static int
+_nouveau_gpuobj_ctor(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass, void *data, u32 size,
+                     struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj_class *args = data;
+        struct nouveau_gpuobj *object;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, args->pargpu,
+                                    args->size, args->align, args->flags,
+                                    &object);
+        *pobject = nv_object(object);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+void
+_nouveau_gpuobj_dtor(struct nouveau_object *object)
+{
+        nouveau_gpuobj_destroy(nv_gpuobj(object));
+}
+
+int
+_nouveau_gpuobj_init(struct nouveau_object *object)
+{
+        return nouveau_gpuobj_init(nv_gpuobj(object));
+}
+
+int
+_nouveau_gpuobj_fini(struct nouveau_object *object, bool suspend)
+{
+        return nouveau_gpuobj_fini(nv_gpuobj(object), suspend);
+}
+
+u32
+_nouveau_gpuobj_rd32(struct nouveau_object *object, u32 addr)
+{
+        struct nouveau_gpuobj *gpuobj = nv_gpuobj(object);
+        struct nouveau_ofuncs *pfuncs = nv_ofuncs(gpuobj->parent);
+        if (gpuobj->node)
+                addr += gpuobj->node->offset;
+        return pfuncs->rd32(gpuobj->parent, addr);
+}
+
+void
+_nouveau_gpuobj_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        struct nouveau_gpuobj *gpuobj = nv_gpuobj(object);
+        struct nouveau_ofuncs *pfuncs = nv_ofuncs(gpuobj->parent);
+        if (gpuobj->node)
+                addr += gpuobj->node->offset;
+        pfuncs->wr32(gpuobj->parent, addr, data);
+}
+
+static struct nouveau_oclass
+_nouveau_gpuobj_oclass = {
+        .handle = 0x00000000,
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = _nouveau_gpuobj_ctor,
+                .dtor = _nouveau_gpuobj_dtor,
+                .init = _nouveau_gpuobj_init,
+                .fini = _nouveau_gpuobj_fini,
+                .rd32 = _nouveau_gpuobj_rd32,
+                .wr32 = _nouveau_gpuobj_wr32,
+        },
+};
+
+int
+nouveau_gpuobj_new(struct nouveau_object *parent, struct nouveau_object *pargpu,
+                   u32 size, u32 align, u32 flags,
+                   struct nouveau_gpuobj **pgpuobj)
+{
+        struct nouveau_object *engine = parent;
+        struct nouveau_gpuobj_class args = {
+                .pargpu = pargpu,
+                .size = size,
+                .align = align,
+                .flags = flags,
+        };
+
+        if (!nv_iclass(engine, NV_SUBDEV_CLASS))
+                engine = engine->engine;
+        BUG_ON(engine == NULL);
+
+        return nouveau_object_ctor(parent, engine, &_nouveau_gpuobj_oclass,
+                                   &args, sizeof(args),
+                                   (struct nouveau_object **)pgpuobj);
+}
+
+int
+nouveau_gpuobj_map(struct nouveau_gpuobj *gpuobj, u32 access,
+                   struct nouveau_vma *vma)
+{
+        struct nouveau_bar *bar = nouveau_bar(gpuobj);
+        int ret = -EINVAL;
+
+        if (bar && bar->umap) {
+                struct nouveau_instobj *iobj = (void *)
+                        nv_pclass(nv_object(gpuobj), NV_MEMOBJ_CLASS);
+                struct nouveau_mem **mem = (void *)(iobj + 1);
+                ret = bar->umap(bar, *mem, access, vma);
+        }
+
+        return ret;
+}
+
+int
+nouveau_gpuobj_map_vm(struct nouveau_gpuobj *gpuobj, struct nouveau_vm *vm,
+                      u32 access, struct nouveau_vma *vma)
+{
+        struct nouveau_instobj *iobj = (void *)
+                nv_pclass(nv_object(gpuobj), NV_MEMOBJ_CLASS);
+        struct nouveau_mem **mem = (void *)(iobj + 1);
+        int ret;
+
+        ret = nouveau_vm_get(vm, gpuobj->size, 12, access, vma);
+        if (ret)
+                return ret;
+
+        nouveau_vm_map(vma, *mem);
+        return 0;
+}
+
+void
+nouveau_gpuobj_unmap(struct nouveau_vma *vma)
+{
+        if (vma->node) {
+                nouveau_vm_unmap(vma);
+                nouveau_vm_put(vma);
+        }
+}
+
+/* the below is basically only here to support sharing the paged dma object
+ * for PCI(E)GART on <=nv4x chipsets, and should *not* be expected to work
+ * anywhere else.
+ */
+
+static void
+nouveau_gpudup_dtor(struct nouveau_object *object)
+{
+        struct nouveau_gpuobj *gpuobj = (void *)object;
+        nouveau_object_ref(NULL, &gpuobj->parent);
+        nouveau_object_destroy(&gpuobj->base);
+}
+
+static struct nouveau_oclass
+nouveau_gpudup_oclass = {
+        .handle = NV_GPUOBJ_CLASS,
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .dtor = nouveau_gpudup_dtor,
+                .init = nouveau_object_init,
+                .fini = nouveau_object_fini,
+        },
+};
+
+int
+nouveau_gpuobj_dup(struct nouveau_object *parent, struct nouveau_gpuobj *base,
+                   struct nouveau_gpuobj **pgpuobj)
+{
+        struct nouveau_gpuobj *gpuobj;
+        int ret;
+
+        ret = nouveau_object_create(parent, parent->engine,
+                                   &nouveau_gpudup_oclass, 0, &gpuobj);
+        *pgpuobj = gpuobj;
+        if (ret)
+                return ret;
+
+        nouveau_object_ref(nv_object(base), &gpuobj->parent);
+        gpuobj->addr = base->addr;
+        gpuobj->size = base->size;
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/handle.c b/drivers/gpu/drm/nouveau/core/core/handle.c
new file mode 100644
index 000000000000..b8d2cbf8a7a7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/handle.c
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/handle.h>
+#include <core/client.h>
+
+#define hprintk(h,l,f,a...) do {                                               \
+        struct nouveau_client *c = nouveau_client((h)->object);                \
+        struct nouveau_handle *p = (h)->parent; u32 n = p ? p->name : ~0;      \
+        nv_printk((c), l, "0x%08x:0x%08x "f, n, (h)->name, ##a);               \
+} while(0)
+
+int
+nouveau_handle_init(struct nouveau_handle *handle)
+{
+        struct nouveau_handle *item;
+        int ret;
+
+        hprintk(handle, TRACE, "init running\n");
+        ret = nouveau_object_inc(handle->object);
+        if (ret)
+                return ret;
+
+        hprintk(handle, TRACE, "init children\n");
+        list_for_each_entry(item, &handle->tree, head) {
+                ret = nouveau_handle_init(item);
+                if (ret)
+                        goto fail;
+        }
+
+        hprintk(handle, TRACE, "init completed\n");
+        return 0;
+fail:
+        hprintk(handle, ERROR, "init failed with %d\n", ret);
+        list_for_each_entry_continue_reverse(item, &handle->tree, head) {
+                nouveau_handle_fini(item, false);
+        }
+
+        nouveau_object_dec(handle->object, false);
+        return ret;
+}
+
+int
+nouveau_handle_fini(struct nouveau_handle *handle, bool suspend)
+{
+        static char *name[2] = { "fini", "suspend" };
+        struct nouveau_handle *item;
+        int ret;
+
+        hprintk(handle, TRACE, "%s children\n", name[suspend]);
+        list_for_each_entry(item, &handle->tree, head) {
+                ret = nouveau_handle_fini(item, suspend);
+                if (ret && suspend)
+                        goto fail;
+        }
+
+        hprintk(handle, TRACE, "%s running\n", name[suspend]);
+        if (handle->object) {
+                ret = nouveau_object_dec(handle->object, suspend);
+                if (ret && suspend)
+                        goto fail;
+        }
+
+        hprintk(handle, TRACE, "%s completed\n", name[suspend]);
+        return 0;
+fail:
+        hprintk(handle, ERROR, "%s failed with %d\n", name[suspend], ret);
+        list_for_each_entry_continue_reverse(item, &handle->tree, head) {
+                int rret = nouveau_handle_init(item);
+                if (rret)
+                        hprintk(handle, FATAL, "failed to restart, %d\n", rret);
+        }
+
+        return ret;
+}
+
+int
+nouveau_handle_create(struct nouveau_object *parent, u32 _parent, u32 _handle,
+                      struct nouveau_object *object,
+                      struct nouveau_handle **phandle)
+{
+        struct nouveau_object *namedb;
+        struct nouveau_handle *handle;
+        int ret;
+
+        namedb = parent;
+        while (!nv_iclass(namedb, NV_NAMEDB_CLASS))
+                namedb = namedb->parent;
+
+        handle = *phandle = kzalloc(sizeof(*handle), GFP_KERNEL);
+        if (!handle)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&handle->head);
+        INIT_LIST_HEAD(&handle->tree);
+        handle->name = _handle;
+        handle->priv = ~0;
+
+        ret = nouveau_namedb_insert(nv_namedb(namedb), _handle, object, handle);
+        if (ret) {
+                kfree(handle);
+                return ret;
+        }
+
+        if (nv_parent(parent)->object_attach) {
+                ret = nv_parent(parent)->object_attach(parent, object, _handle);
+                if (ret < 0) {
+                        nouveau_handle_destroy(handle);
+                        return ret;
+                }
+
+                handle->priv = ret;
+        }
+
+        if (object != namedb) {
+                while (!nv_iclass(namedb, NV_CLIENT_CLASS))
+                        namedb = namedb->parent;
+
+                handle->parent = nouveau_namedb_get(nv_namedb(namedb), _parent);
+                if (handle->parent) {
+                        list_add(&handle->head, &handle->parent->tree);
+                        nouveau_namedb_put(handle->parent);
+                }
+        }
+
+        hprintk(handle, TRACE, "created\n");
+        return 0;
+}
+
+void
+nouveau_handle_destroy(struct nouveau_handle *handle)
+{
+        struct nouveau_handle *item, *temp;
+
+        hprintk(handle, TRACE, "destroy running\n");
+        list_for_each_entry_safe(item, temp, &handle->tree, head) {
+                nouveau_handle_destroy(item);
+        }
+        list_del(&handle->head);
+
+        if (handle->priv != ~0) {
+                struct nouveau_object *parent = handle->parent->object;
+                nv_parent(parent)->object_detach(parent, handle->priv);
+        }
+
+        hprintk(handle, TRACE, "destroy completed\n");
+        nouveau_namedb_remove(handle);
+        kfree(handle);
+}
+
+struct nouveau_object *
+nouveau_handle_ref(struct nouveau_object *parent, u32 name)
+{
+        struct nouveau_object *object = NULL;
+        struct nouveau_handle *handle;
+
+        while (!nv_iclass(parent, NV_NAMEDB_CLASS))
+                parent = parent->parent;
+
+        handle = nouveau_namedb_get(nv_namedb(parent), name);
+        if (handle) {
+                nouveau_object_ref(handle->object, &object);
+                nouveau_namedb_put(handle);
+        }
+
+        return object;
+}
+
+struct nouveau_handle *
+nouveau_handle_get_class(struct nouveau_object *engctx, u16 oclass)
+{
+        struct nouveau_namedb *namedb;
+        if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS)))
+                return nouveau_namedb_get_class(namedb, oclass);
+        return NULL;
+}
+
+struct nouveau_handle *
+nouveau_handle_get_vinst(struct nouveau_object *engctx, u64 vinst)
+{
+        struct nouveau_namedb *namedb;
+        if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS)))
+                return nouveau_namedb_get_vinst(namedb, vinst);
+        return NULL;
+}
+
+struct nouveau_handle *
+nouveau_handle_get_cinst(struct nouveau_object *engctx, u32 cinst)
+{
+        struct nouveau_namedb *namedb;
+        if (engctx && (namedb = (void *)nv_pclass(engctx, NV_NAMEDB_CLASS)))
+                return nouveau_namedb_get_cinst(namedb, cinst);
+        return NULL;
+}
+
+void
+nouveau_handle_put(struct nouveau_handle *handle)
+{
+        if (handle)
+                nouveau_namedb_put(handle);
+}
diff --git a/drivers/gpu/drm/nouveau/nouveau_mm.c b/drivers/gpu/drm/nouveau/core/core/mm.c
index b29ffb3d1408..bfddf87926dd 100644
--- a/drivers/gpu/drm/nouveau/nouveau_mm.c
+++ b/drivers/gpu/drm/nouveau/core/core/mm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010 Red Hat Inc.
+ * Copyright 2012 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"),
@@ -22,20 +22,52 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_mm.h"
+#include "core/os.h"
+#include "core/mm.h"
 
-static inline void
-region_put(struct nouveau_mm *mm, struct nouveau_mm_node *a)
+#define node(root, dir) ((root)->nl_entry.dir == &mm->nodes) ? NULL : \
+        list_entry((root)->nl_entry.dir, struct nouveau_mm_node, nl_entry)
+
+void
+nouveau_mm_free(struct nouveau_mm *mm, struct nouveau_mm_node **pthis)
 {
-        list_del(&a->nl_entry);
-        list_del(&a->fl_entry);
-        kfree(a);
+        struct nouveau_mm_node *this = *pthis;
+
+        if (this) {
+                struct nouveau_mm_node *prev = node(this, prev);
+                struct nouveau_mm_node *next = node(this, next);
+
+                if (prev && prev->type == 0) {
+                        prev->length += this->length;
+                        list_del(&this->nl_entry);
+                        kfree(this); this = prev;
+                }
+
+                if (next && next->type == 0) {
+                        next->offset  = this->offset;
+                        next->length += this->length;
+                        if (this->type == 0)
+                                list_del(&this->fl_entry);
+                        list_del(&this->nl_entry);
+                        kfree(this); this = NULL;
+                }
+
+                if (this && this->type != 0) {
+                        list_for_each_entry(prev, &mm->free, fl_entry) {
+                                if (this->offset < prev->offset)
+                                        break;
+                        }
+
+                        list_add_tail(&this->fl_entry, &prev->fl_entry);
+                        this->type = 0;
+                }
+        }
+
+        *pthis = NULL;
 }
 
 static struct nouveau_mm_node *
-region_split(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size)
+region_head(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size)
 {
         struct nouveau_mm_node *b;
 
@@ -57,38 +89,12 @@ region_split(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size)
         return b;
 }
 
-#define node(root, dir) ((root)->nl_entry.dir == &mm->nodes) ? NULL : \
-        list_entry((root)->nl_entry.dir, struct nouveau_mm_node, nl_entry)
-
-void
-nouveau_mm_put(struct nouveau_mm *mm, struct nouveau_mm_node *this)
-{
-        struct nouveau_mm_node *prev = node(this, prev);
-        struct nouveau_mm_node *next = node(this, next);
-
-        list_add(&this->fl_entry, &mm->free);
-        this->type = 0;
-
-        if (prev && prev->type == 0) {
-                prev->length += this->length;
-                region_put(mm, this);
-                this = prev;
-        }
-
-        if (next && next->type == 0) {
-                next->offset  = this->offset;
-                next->length += this->length;
-                region_put(mm, this);
-        }
-}
-
 int
-nouveau_mm_get(struct nouveau_mm *mm, int type, u32 size, u32 size_nc,
-               u32 align, struct nouveau_mm_node **pnode)
+nouveau_mm_head(struct nouveau_mm *mm, u8 type, u32 size_max, u32 size_min,
+                u32 align, struct nouveau_mm_node **pnode)
 {
         struct nouveau_mm_node *prev, *this, *next;
-        u32 min = size_nc ? size_nc : size;
-        u32 align_mask = align - 1;
+        u32 mask = align - 1;
         u32 splitoff;
         u32 s, e;
 
@@ -104,16 +110,86 @@ nouveau_mm_get(struct nouveau_mm *mm, int type, u32 size, u32 size_nc,
                 if (next && next->type != type)
                         e = rounddown(e, mm->block_size);
 
-                s  = (s + align_mask) & ~align_mask;
-                e &= ~align_mask;
-                if (s > e || e - s < min)
+                s  = (s + mask) & ~mask;
+                e &= ~mask;
+                if (s > e || e - s < size_min)
                         continue;
 
                 splitoff = s - this->offset;
-                if (splitoff && !region_split(mm, this, splitoff))
+                if (splitoff && !region_head(mm, this, splitoff))
+                        return -ENOMEM;
+
+                this = region_head(mm, this, min(size_max, e - s));
+                if (!this)
+                        return -ENOMEM;
+
+                this->type = type;
+                list_del(&this->fl_entry);
+                *pnode = this;
+                return 0;
+        }
+
+        return -ENOSPC;
+}
+
+static struct nouveau_mm_node *
+region_tail(struct nouveau_mm *mm, struct nouveau_mm_node *a, u32 size)
+{
+        struct nouveau_mm_node *b;
+
+        if (a->length == size)
+                return a;
+
+        b = kmalloc(sizeof(*b), GFP_KERNEL);
+        if (unlikely(b == NULL))
+                return NULL;
+
+        a->length -= size;
+        b->offset  = a->offset + a->length;
+        b->length  = size;
+        b->type    = a->type;
+
+        list_add(&b->nl_entry, &a->nl_entry);
+        if (b->type == 0)
+                list_add(&b->fl_entry, &a->fl_entry);
+        return b;
+}
+
+int
+nouveau_mm_tail(struct nouveau_mm *mm, u8 type, u32 size_max, u32 size_min,
+                u32 align, struct nouveau_mm_node **pnode)
+{
+        struct nouveau_mm_node *prev, *this, *next;
+        u32 mask = align - 1;
+
+        list_for_each_entry_reverse(this, &mm->free, fl_entry) {
+                u32 e = this->offset + this->length;
+                u32 s = this->offset;
+                u32 c = 0, a;
+
+                prev = node(this, prev);
+                if (prev && prev->type != type)
+                        s = roundup(s, mm->block_size);
+
+                next = node(this, next);
+                if (next && next->type != type) {
+                        e = rounddown(e, mm->block_size);
+                        c = next->offset - e;
+                }
+
+                s = (s + mask) & ~mask;
+                a = e - s;
+                if (s > e || a < size_min)
+                        continue;
+
+                a  = min(a, size_max);
+                s  = (e - a) & ~mask;
+                c += (e - s) - a;
+
+                if (c && !region_tail(mm, this, c))
                         return -ENOMEM;
 
-                this = region_split(mm, this, min(size, e - s));
+                this = region_tail(mm, this, a);
                 if (!this)
                         return -ENOMEM;
 
@@ -148,6 +224,7 @@ nouveau_mm_init(struct nouveau_mm *mm, u32 offset, u32 length, u32 block)
         list_add_tail(&node->nl_entry, &mm->nodes);
         list_add_tail(&node->fl_entry, &mm->free);
         mm->heap_nodes++;
+        mm->heap_size += length;
         return 0;
 }
 
@@ -159,15 +236,8 @@ nouveau_mm_fini(struct nouveau_mm *mm)
         int nodes = 0;
 
         list_for_each_entry(node, &mm->nodes, nl_entry) {
-                if (nodes++ == mm->heap_nodes) {
-                        printk(KERN_ERR "nouveau_mm in use at destroy time!\n");
-                        list_for_each_entry(node, &mm->nodes, nl_entry) {
-                                printk(KERN_ERR "0x%02x: 0x%08x 0x%08x\n",
-                                       node->type, node->offset, node->length);
-                        }
-                        WARN_ON(1);
+                if (nodes++ == mm->heap_nodes)
                         return -EBUSY;
-                }
         }
 
         kfree(heap);
diff --git a/drivers/gpu/drm/nouveau/core/core/namedb.c b/drivers/gpu/drm/nouveau/core/core/namedb.c
new file mode 100644
index 000000000000..1ce95a8709df
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/namedb.c
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/namedb.h>
+#include <core/handle.h>
+#include <core/gpuobj.h>
+
+static struct nouveau_handle *
+nouveau_namedb_lookup(struct nouveau_namedb *namedb, u32 name)
+{
+        struct nouveau_handle *handle;
+
+        list_for_each_entry(handle, &namedb->list, node) {
+                if (handle->name == name)
+                        return handle;
+        }
+
+        return NULL;
+}
+
+static struct nouveau_handle *
+nouveau_namedb_lookup_class(struct nouveau_namedb *namedb, u16 oclass)
+{
+        struct nouveau_handle *handle;
+
+        list_for_each_entry(handle, &namedb->list, node) {
+                if (nv_mclass(handle->object) == oclass)
+                        return handle;
+        }
+
+        return NULL;
+}
+
+static struct nouveau_handle *
+nouveau_namedb_lookup_vinst(struct nouveau_namedb *namedb, u64 vinst)
+{
+        struct nouveau_handle *handle;
+
+        list_for_each_entry(handle, &namedb->list, node) {
+                if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) {
+                        if (nv_gpuobj(handle->object)->addr == vinst)
+                                return handle;
+                }
+        }
+
+        return NULL;
+}
+
+static struct nouveau_handle *
+nouveau_namedb_lookup_cinst(struct nouveau_namedb *namedb, u32 cinst)
+{
+        struct nouveau_handle *handle;
+
+        list_for_each_entry(handle, &namedb->list, node) {
+                if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) {
+                        if (nv_gpuobj(handle->object)->node &&
+                            nv_gpuobj(handle->object)->node->offset == cinst)
+                                return handle;
+                }
+        }
+
+        return NULL;
+}
+
+int
+nouveau_namedb_insert(struct nouveau_namedb *namedb, u32 name,
+                      struct nouveau_object *object,
+                      struct nouveau_handle *handle)
+{
+        int ret = -EEXIST;
+        write_lock_irq(&namedb->lock);
+        if (!nouveau_namedb_lookup(namedb, name)) {
+                nouveau_object_ref(object, &handle->object);
+                handle->namedb = namedb;
+                list_add(&handle->node, &namedb->list);
+                ret = 0;
+        }
+        write_unlock_irq(&namedb->lock);
+        return ret;
+}
+
+void
+nouveau_namedb_remove(struct nouveau_handle *handle)
+{
+        struct nouveau_namedb *namedb = handle->namedb;
+        struct nouveau_object *object = handle->object;
+        write_lock_irq(&namedb->lock);
+        list_del(&handle->node);
+        write_unlock_irq(&namedb->lock);
+        nouveau_object_ref(NULL, &object);
+}
+
+struct nouveau_handle *
+nouveau_namedb_get(struct nouveau_namedb *namedb, u32 name)
+{
+        struct nouveau_handle *handle;
+        read_lock(&namedb->lock);
+        handle = nouveau_namedb_lookup(namedb, name);
+        if (handle == NULL)
+                read_unlock(&namedb->lock);
+        return handle;
+}
+
+struct nouveau_handle *
+nouveau_namedb_get_class(struct nouveau_namedb *namedb, u16 oclass)
+{
+        struct nouveau_handle *handle;
+        read_lock(&namedb->lock);
+        handle = nouveau_namedb_lookup_class(namedb, oclass);
+        if (handle == NULL)
+                read_unlock(&namedb->lock);
+        return handle;
+}
+
+struct nouveau_handle *
+nouveau_namedb_get_vinst(struct nouveau_namedb *namedb, u64 vinst)
+{
+        struct nouveau_handle *handle;
+        read_lock(&namedb->lock);
+        handle = nouveau_namedb_lookup_vinst(namedb, vinst);
+        if (handle == NULL)
+                read_unlock(&namedb->lock);
+        return handle;
+}
+
+struct nouveau_handle *
+nouveau_namedb_get_cinst(struct nouveau_namedb *namedb, u32 cinst)
+{
+        struct nouveau_handle *handle;
+        read_lock(&namedb->lock);
+        handle = nouveau_namedb_lookup_cinst(namedb, cinst);
+        if (handle == NULL)
+                read_unlock(&namedb->lock);
+        return handle;
+}
+
+void
+nouveau_namedb_put(struct nouveau_handle *handle)
+{
+        if (handle)
+                read_unlock(&handle->namedb->lock);
+}
+
+int
+nouveau_namedb_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, u32 pclass,
+                       struct nouveau_oclass *sclass, u32 engcls,
+                       int length, void **pobject)
+{
+        struct nouveau_namedb *namedb;
+        int ret;
+
+        ret = nouveau_parent_create_(parent, engine, oclass, pclass |
+                                     NV_NAMEDB_CLASS, sclass, engcls,
+                                     length, pobject);
+        namedb = *pobject;
+        if (ret)
+                return ret;
+
+        rwlock_init(&namedb->lock);
+        INIT_LIST_HEAD(&namedb->list);
+        return 0;
+}
+
+int
+_nouveau_namedb_ctor(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass, void *data, u32 size,
+                     struct nouveau_object **pobject)
+{
+        struct nouveau_namedb *object;
+        int ret;
+
+        ret = nouveau_namedb_create(parent, engine, oclass, 0, NULL, 0, &object);
+        *pobject = nv_object(object);
+        if (ret)
+                return ret;
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/object.c b/drivers/gpu/drm/nouveau/core/core/object.c
new file mode 100644
index 000000000000..0daab62ea14c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/object.c
@@ -0,0 +1,468 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/parent.h>
+#include <core/namedb.h>
+#include <core/handle.h>
+#include <core/engine.h>
+
+#ifdef NOUVEAU_OBJECT_MAGIC
+static struct list_head _objlist = LIST_HEAD_INIT(_objlist);
+static DEFINE_SPINLOCK(_objlist_lock);
+#endif
+
+int
+nouveau_object_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, u32 pclass,
+                       int size, void **pobject)
+{
+        struct nouveau_object *object;
+
+        object = *pobject = kzalloc(size, GFP_KERNEL);
+        if (!object)
+                return -ENOMEM;
+
+        nouveau_object_ref(parent, &object->parent);
+        nouveau_object_ref(engine, &object->engine);
+        object->oclass = oclass;
+        object->oclass->handle |= pclass;
+        atomic_set(&object->refcount, 1);
+        atomic_set(&object->usecount, 0);
+
+#ifdef NOUVEAU_OBJECT_MAGIC
+        object->_magic = NOUVEAU_OBJECT_MAGIC;
+        spin_lock(&_objlist_lock);
+        list_add(&object->list, &_objlist);
+        spin_unlock(&_objlist_lock);
+#endif
+        return 0;
+}
+
+static int
+_nouveau_object_ctor(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass, void *data, u32 size,
+                     struct nouveau_object **pobject)
+{
+        struct nouveau_object *object;
+        int ret;
+
+        ret = nouveau_object_create(parent, engine, oclass, 0, &object);
+        *pobject = nv_object(object);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+void
+nouveau_object_destroy(struct nouveau_object *object)
+{
+#ifdef NOUVEAU_OBJECT_MAGIC
+        spin_lock(&_objlist_lock);
+        list_del(&object->list);
+        spin_unlock(&_objlist_lock);
+#endif
+        nouveau_object_ref(NULL, &object->engine);
+        nouveau_object_ref(NULL, &object->parent);
+        kfree(object);
+}
+
+static void
+_nouveau_object_dtor(struct nouveau_object *object)
+{
+        nouveau_object_destroy(object);
+}
+
+int
+nouveau_object_init(struct nouveau_object *object)
+{
+        return 0;
+}
+
+static int
+_nouveau_object_init(struct nouveau_object *object)
+{
+        return nouveau_object_init(object);
+}
+
+int
+nouveau_object_fini(struct nouveau_object *object, bool suspend)
+{
+        return 0;
+}
+
+static int
+_nouveau_object_fini(struct nouveau_object *object, bool suspend)
+{
+        return nouveau_object_fini(object, suspend);
+}
+
+struct nouveau_ofuncs
+nouveau_object_ofuncs = {
+        .ctor = _nouveau_object_ctor,
+        .dtor = _nouveau_object_dtor,
+        .init = _nouveau_object_init,
+        .fini = _nouveau_object_fini,
+};
+
+int
+nouveau_object_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nouveau_ofuncs *ofuncs = oclass->ofuncs;
+        int ret;
+
+        *pobject = NULL;
+
+        ret = ofuncs->ctor(parent, engine, oclass, data, size, pobject);
+        if (ret < 0) {
+                if (ret != -ENODEV) {
+                        nv_error(parent, "failed to create 0x%08x, %d\n",
+                                 oclass->handle, ret);
+                }
+
+                if (*pobject) {
+                        ofuncs->dtor(*pobject);
+                        *pobject = NULL;
+                }
+
+                return ret;
+        }
+
+        nv_debug(*pobject, "created\n");
+        return 0;
+}
+
+static void
+nouveau_object_dtor(struct nouveau_object *object)
+{
+        nv_debug(object, "destroying\n");
+        nv_ofuncs(object)->dtor(object);
+}
+
+void
+nouveau_object_ref(struct nouveau_object *obj, struct nouveau_object **ref)
+{
+        if (obj) {
+                atomic_inc(&obj->refcount);
+                nv_trace(obj, "inc() == %d\n", atomic_read(&obj->refcount));
+        }
+
+        if (*ref) {
+                int dead = atomic_dec_and_test(&(*ref)->refcount);
+                nv_trace(*ref, "dec() == %d\n", atomic_read(&(*ref)->refcount));
+                if (dead)
+                        nouveau_object_dtor(*ref);
+        }
+
+        *ref = obj;
+}
+
+int
+nouveau_object_new(struct nouveau_object *client, u32 _parent, u32 _handle,
+                   u16 _oclass, void *data, u32 size,
+                   struct nouveau_object **pobject)
+{
+        struct nouveau_object *parent = NULL;
+        struct nouveau_object *engctx = NULL;
+        struct nouveau_object *object = NULL;
+        struct nouveau_object *engine;
+        struct nouveau_oclass *oclass;
+        struct nouveau_handle *handle;
+        int ret;
+
+        /* lookup parent object and ensure it *is* a parent */
+        parent = nouveau_handle_ref(client, _parent);
+        if (!parent) {
+                nv_error(client, "parent 0x%08x not found\n", _parent);
+                return -ENOENT;
+        }
+
+        if (!nv_iclass(parent, NV_PARENT_CLASS)) {
+                nv_error(parent, "cannot have children\n");
+                ret = -EINVAL;
+                goto fail_class;
+        }
+
+        /* check that parent supports the requested subclass */
+        ret = nouveau_parent_sclass(parent, _oclass, &engine, &oclass);
+        if (ret) {
+                nv_debug(parent, "illegal class 0x%04x\n", _oclass);
+                goto fail_class;
+        }
+
+        /* make sure engine init has been completed *before* any objects
+         * it controls are created - the constructors may depend on
+         * state calculated at init (ie. default context construction)
+         */
+        if (engine) {
+                ret = nouveau_object_inc(engine);
+                if (ret)
+                        goto fail_class;
+        }
+
+        /* if engine requires it, create a context object to insert
+         * between the parent and its children (eg. PGRAPH context)
+         */
+        if (engine && nv_engine(engine)->cclass) {
+                ret = nouveau_object_ctor(parent, engine,
+                                          nv_engine(engine)->cclass,
+                                          data, size, &engctx);
+                if (ret)
+                        goto fail_engctx;
+        } else {
+                nouveau_object_ref(parent, &engctx);
+        }
+
+        /* finally, create new object and bind it to its handle */
+        ret = nouveau_object_ctor(engctx, engine, oclass, data, size, &object);
+        *pobject = object;
+        if (ret)
+                goto fail_ctor;
+
+        ret = nouveau_object_inc(object);
+        if (ret)
+                goto fail_init;
+
+        ret = nouveau_handle_create(parent, _parent, _handle, object, &handle);
+        if (ret)
+                goto fail_handle;
+
+        ret = nouveau_handle_init(handle);
+        if (ret)
+                nouveau_handle_destroy(handle);
+
+fail_handle:
+        nouveau_object_dec(object, false);
+fail_init:
+        nouveau_object_ref(NULL, &object);
+fail_ctor:
+        nouveau_object_ref(NULL, &engctx);
+fail_engctx:
+        if (engine)
+                nouveau_object_dec(engine, false);
+fail_class:
+        nouveau_object_ref(NULL, &parent);
+        return ret;
+}
+
+int
+nouveau_object_del(struct nouveau_object *client, u32 _parent, u32 _handle)
+{
+        struct nouveau_object *parent = NULL;
+        struct nouveau_object *namedb = NULL;
+        struct nouveau_handle *handle = NULL;
+        int ret = -EINVAL;
+
+        parent = nouveau_handle_ref(client, _parent);
+        if (!parent)
+                return -ENOENT;
+
+        namedb = nv_pclass(parent, NV_NAMEDB_CLASS);
+        if (namedb) {
+                handle = nouveau_namedb_get(nv_namedb(namedb), _handle);
+                if (handle) {
+                        nouveau_namedb_put(handle);
+                        nouveau_handle_fini(handle, false);
+                        nouveau_handle_destroy(handle);
+                }
+        }
+
+        nouveau_object_ref(NULL, &parent);
+        return ret;
+}
+
+int
+nouveau_object_inc(struct nouveau_object *object)
+{
+        int ref = atomic_add_return(1, &object->usecount);
+        int ret;
+
+        nv_trace(object, "use(+1) == %d\n", atomic_read(&object->usecount));
+        if (ref != 1)
+                return 0;
+
+        nv_trace(object, "initialising...\n");
+        if (object->parent) {
+                ret = nouveau_object_inc(object->parent);
+                if (ret) {
+                        nv_error(object, "parent failed, %d\n", ret);
+                        goto fail_parent;
+                }
+        }
+
+        if (object->engine) {
+                mutex_lock(&nv_subdev(object->engine)->mutex);
+                ret = nouveau_object_inc(object->engine);
+                mutex_unlock(&nv_subdev(object->engine)->mutex);
+                if (ret) {
+                        nv_error(object, "engine failed, %d\n", ret);
+                        goto fail_engine;
+                }
+        }
+
+        ret = nv_ofuncs(object)->init(object);
+        if (ret) {
+                nv_error(object, "init failed, %d\n", ret);
+                goto fail_self;
+        }
+
+        nv_debug(object, "initialised\n");
+        return 0;
+
+fail_self:
+        if (object->engine) {
+                mutex_lock(&nv_subdev(object->engine)->mutex);
+                nouveau_object_dec(object->engine, false);
+                mutex_unlock(&nv_subdev(object->engine)->mutex);
+        }
+fail_engine:
+        if (object->parent)
+                 nouveau_object_dec(object->parent, false);
+fail_parent:
+        atomic_dec(&object->usecount);
+        return ret;
+}
+
+static int
+nouveau_object_decf(struct nouveau_object *object)
+{
+        int ret;
+
+        nv_trace(object, "stopping...\n");
+
+        ret = nv_ofuncs(object)->fini(object, false);
+        if (ret)
+                nv_warn(object, "failed fini, %d\n", ret);
+
+        if (object->engine) {
+                mutex_lock(&nv_subdev(object->engine)->mutex);
+                nouveau_object_dec(object->engine, false);
+                mutex_unlock(&nv_subdev(object->engine)->mutex);
+        }
+
+        if (object->parent)
+                nouveau_object_dec(object->parent, false);
+
+        nv_debug(object, "stopped\n");
+        return 0;
+}
+
+static int
+nouveau_object_decs(struct nouveau_object *object)
+{
+        int ret, rret;
+
+        nv_trace(object, "suspending...\n");
+
+        ret = nv_ofuncs(object)->fini(object, true);
+        if (ret) {
+                nv_error(object, "failed suspend, %d\n", ret);
+                return ret;
+        }
+
+        if (object->engine) {
+                mutex_lock(&nv_subdev(object->engine)->mutex);
+                ret = nouveau_object_dec(object->engine, true);
+                mutex_unlock(&nv_subdev(object->engine)->mutex);
+                if (ret) {
+                        nv_warn(object, "engine failed suspend, %d\n", ret);
+                        goto fail_engine;
+                }
+        }
+
+        if (object->parent) {
+                ret = nouveau_object_dec(object->parent, true);
+                if (ret) {
+                        nv_warn(object, "parent failed suspend, %d\n", ret);
+                        goto fail_parent;
+                }
+        }
+
+        nv_debug(object, "suspended\n");
+        return 0;
+
+fail_parent:
+        if (object->engine) {
+                mutex_lock(&nv_subdev(object->engine)->mutex);
+                rret = nouveau_object_inc(object->engine);
+                mutex_unlock(&nv_subdev(object->engine)->mutex);
+                if (rret)
+                        nv_fatal(object, "engine failed to reinit, %d\n", rret);
+        }
+
+fail_engine:
+        rret = nv_ofuncs(object)->init(object);
+        if (rret)
+                nv_fatal(object, "failed to reinit, %d\n", rret);
+
+        return ret;
+}
+
+int
+nouveau_object_dec(struct nouveau_object *object, bool suspend)
+{
+        int ref = atomic_add_return(-1, &object->usecount);
+        int ret;
+
+        nv_trace(object, "use(-1) == %d\n", atomic_read(&object->usecount));
+
+        if (ref == 0) {
+                if (suspend)
+                        ret = nouveau_object_decs(object);
+                else
+                        ret = nouveau_object_decf(object);
+
+                if (ret) {
+                        atomic_inc(&object->usecount);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+void
+nouveau_object_debug(void)
+{
+#ifdef NOUVEAU_OBJECT_MAGIC
+        struct nouveau_object *object;
+        if (!list_empty(&_objlist)) {
+                nv_fatal(NULL, "*******************************************\n");
+                nv_fatal(NULL, "* AIIIII! object(s) still exist!!!\n");
+                nv_fatal(NULL, "*******************************************\n");
+                list_for_each_entry(object, &_objlist, list) {
+                        nv_fatal(object, "%p/%p/%d/%d\n",
+                                 object->parent, object->engine,
+                                 atomic_read(&object->refcount),
+                                 atomic_read(&object->usecount));
+                }
+        }
+#endif
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/option.c b/drivers/gpu/drm/nouveau/core/core/option.c
new file mode 100644
index 000000000000..62a432ea39e5
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/option.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2012 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 <core/option.h>
+#include <core/debug.h>
+
+/* compares unterminated string 'str' with zero-terminated string 'cmp' */
+static inline int
+strncasecmpz(const char *str, const char *cmp, size_t len)
+{
+        if (strlen(cmp) != len)
+                return len;
+        return strncasecmp(str, cmp, len);
+}
+
+const char *
+nouveau_stropt(const char *optstr, const char *opt, int *arglen)
+{
+        while (optstr && *optstr != '\0') {
+                int len = strcspn(optstr, ",=");
+                switch (optstr[len]) {
+                case '=':
+                        if (!strncasecmpz(optstr, opt, len)) {
+                                optstr += len + 1;
+                                *arglen = strcspn(optstr, ",=");
+                                return *arglen ? optstr : NULL;
+                        }
+                        optstr++;
+                        break;
+                case ',':
+                        optstr++;
+                        break;
+                default:
+                        break;
+                }
+                optstr += len;
+        }
+
+        return NULL;
+}
+
+bool
+nouveau_boolopt(const char *optstr, const char *opt, bool value)
+{
+        int arglen;
+
+        optstr = nouveau_stropt(optstr, opt, &arglen);
+        if (optstr) {
+                if (!strncasecmpz(optstr, "0", arglen) ||
+                    !strncasecmpz(optstr, "no", arglen) ||
+                    !strncasecmpz(optstr, "off", arglen) ||
+                    !strncasecmpz(optstr, "false", arglen))
+                        value = false;
+                else
+                if (!strncasecmpz(optstr, "1", arglen) ||
+                    !strncasecmpz(optstr, "yes", arglen) ||
+                    !strncasecmpz(optstr, "on", arglen) ||
+                    !strncasecmpz(optstr, "true", arglen))
+                        value = true;
+        }
+
+        return value;
+}
+
+int
+nouveau_dbgopt(const char *optstr, const char *sub)
+{
+        int mode = 1, level = CONFIG_NOUVEAU_DEBUG_DEFAULT;
+
+        while (optstr) {
+                int len = strcspn(optstr, ",=");
+                switch (optstr[len]) {
+                case '=':
+                        if (strncasecmpz(optstr, sub, len))
+                                mode = 0;
+                        optstr++;
+                        break;
+                default:
+                        if (mode) {
+                                if (!strncasecmpz(optstr, "fatal", len))
+                                        level = NV_DBG_FATAL;
+                                else if (!strncasecmpz(optstr, "error", len))
+                                        level = NV_DBG_ERROR;
+                                else if (!strncasecmpz(optstr, "warn", len))
+                                        level = NV_DBG_WARN;
+                                else if (!strncasecmpz(optstr, "info", len))
+                                        level = NV_DBG_INFO;
+                                else if (!strncasecmpz(optstr, "debug", len))
+                                        level = NV_DBG_DEBUG;
+                                else if (!strncasecmpz(optstr, "trace", len))
+                                        level = NV_DBG_TRACE;
+                                else if (!strncasecmpz(optstr, "paranoia", len))
+                                        level = NV_DBG_PARANOIA;
+                                else if (!strncasecmpz(optstr, "spam", len))
+                                        level = NV_DBG_SPAM;
+                        }
+
+                        if (optstr[len] != '\0') {
+                                optstr++;
+                                mode = 1;
+                                break;
+                        }
+
+                        return level;
+                }
+                optstr += len;
+        }
+
+        return level;
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/parent.c b/drivers/gpu/drm/nouveau/core/core/parent.c
new file mode 100644
index 000000000000..a1ea034611d5
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/parent.c
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/parent.h>
+
+int
+nouveau_parent_sclass(struct nouveau_object *parent, u16 handle,
+                      struct nouveau_object **pengine,
+                      struct nouveau_oclass **poclass)
+{
+        struct nouveau_sclass *sclass;
+        struct nouveau_engine *engine;
+        struct nouveau_oclass *oclass;
+        u64 mask;
+
+        sclass = nv_parent(parent)->sclass;
+        while (sclass) {
+                if ((sclass->oclass->handle & 0xffff) == handle) {
+                        *pengine = parent->engine;
+                        *poclass = sclass->oclass;
+                        return 0;
+                }
+
+                sclass = sclass->sclass;
+        }
+
+        mask = nv_parent(parent)->engine;
+        while (mask) {
+                int i = ffsll(mask) - 1;
+
+                if ((engine = nouveau_engine(parent, i))) {
+                        oclass = engine->sclass;
+                        while (oclass->ofuncs) {
+                                if ((oclass->handle & 0xffff) == handle) {
+                                        *pengine = nv_object(engine);
+                                        *poclass = oclass;
+                                        return 0;
+                                }
+                                oclass++;
+                        }
+                }
+
+                mask &= ~(1ULL << i);
+        }
+
+        return -EINVAL;
+}
+
+int
+nouveau_parent_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, u32 pclass,
+                       struct nouveau_oclass *sclass, u64 engcls,
+                       int size, void **pobject)
+{
+        struct nouveau_parent *object;
+        struct nouveau_sclass *nclass;
+        int ret;
+
+        ret = nouveau_object_create_(parent, engine, oclass, pclass |
+                                     NV_PARENT_CLASS, size, pobject);
+        object = *pobject;
+        if (ret)
+                return ret;
+
+        while (sclass && sclass->ofuncs) {
+                nclass = kzalloc(sizeof(*nclass), GFP_KERNEL);
+                if (!nclass)
+                        return -ENOMEM;
+
+                nclass->sclass = object->sclass;
+                object->sclass = nclass;
+                nclass->engine = engine ? nv_engine(engine) : NULL;
+                nclass->oclass = sclass;
+                sclass++;
+        }
+
+        object->engine = engcls;
+        return 0;
+}
+
+int
+_nouveau_parent_ctor(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass, void *data, u32 size,
+                     struct nouveau_object **pobject)
+{
+        struct nouveau_parent *object;
+        int ret;
+
+        ret = nouveau_parent_create(parent, engine, oclass, 0, NULL, 0, &object);
+        *pobject = nv_object(object);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+void
+nouveau_parent_destroy(struct nouveau_parent *parent)
+{
+        struct nouveau_sclass *sclass;
+
+        while ((sclass = parent->sclass)) {
+                parent->sclass = sclass->sclass;
+                kfree(sclass);
+        }
+
+        nouveau_object_destroy(&parent->base);
+}
+
+
+void
+_nouveau_parent_dtor(struct nouveau_object *object)
+{
+        nouveau_parent_destroy(nv_parent(object));
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/printk.c b/drivers/gpu/drm/nouveau/core/core/printk.c
new file mode 100644
index 000000000000..6161eaf5447c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/printk.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/client.h>
+#include <core/subdev.h>
+#include <core/printk.h>
+
+void
+nv_printk_(struct nouveau_object *object, const char *pfx, int level,
+           const char *fmt, ...)
+{
+        static const char name[] = { '!', 'E', 'W', ' ', 'D', 'T', 'P', 'S' };
+        char mfmt[256];
+        va_list args;
+
+        if (object && !nv_iclass(object, NV_CLIENT_CLASS)) {
+                struct nouveau_object *device = object;
+                struct nouveau_object *subdev = object;
+                char obuf[64], *ofmt = "";
+
+                if (object->engine) {
+                        snprintf(obuf, sizeof(obuf), "[0x%08x][%p]",
+                                 nv_hclass(object), object);
+                        ofmt = obuf;
+                        subdev = object->engine;
+                        device = object->engine;
+                }
+
+                if (subdev->parent)
+                        device = subdev->parent;
+
+                if (level > nv_subdev(subdev)->debug)
+                        return;
+
+                snprintf(mfmt, sizeof(mfmt), "%snouveau %c[%8s][%s]%s %s", pfx,
+                         name[level], nv_subdev(subdev)->name,
+                         nv_device(device)->name, ofmt, fmt);
+        } else
+        if (object && nv_iclass(object, NV_CLIENT_CLASS)) {
+                if (level > nv_client(object)->debug)
+                        return;
+
+                snprintf(mfmt, sizeof(mfmt), "%snouveau %c[%8s] %s", pfx,
+                         name[level], nv_client(object)->name, fmt);
+        } else {
+                snprintf(mfmt, sizeof(mfmt), "%snouveau: %s", pfx, fmt);
+        }
+
+        va_start(args, fmt);
+        vprintk(mfmt, args);
+        va_end(args);
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/ramht.c b/drivers/gpu/drm/nouveau/core/core/ramht.c
new file mode 100644
index 000000000000..86a64045dd60
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/ramht.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2012 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.
+ */
+
+#include <core/object.h>
+#include <core/ramht.h>
+#include <core/math.h>
+
+#include <subdev/bar.h>
+
+static u32
+nouveau_ramht_hash(struct nouveau_ramht *ramht, int chid, u32 handle)
+{
+        u32 hash = 0;
+
+        while (handle) {
+                hash ^= (handle & ((1 << ramht->bits) - 1));
+                handle >>= ramht->bits;
+        }
+
+        hash ^= chid << (ramht->bits - 4);
+        hash  = hash << 3;
+        return hash;
+}
+
+int
+nouveau_ramht_insert(struct nouveau_ramht *ramht, int chid,
+                     u32 handle, u32 context)
+{
+        struct nouveau_bar *bar = nouveau_bar(ramht);
+        u32 co, ho;
+
+        co = ho = nouveau_ramht_hash(ramht, chid, handle);
+        do {
+                if (!nv_ro32(ramht, co + 4)) {
+                        nv_wo32(ramht, co + 0, handle);
+                        nv_wo32(ramht, co + 4, context);
+                        if (bar)
+                                bar->flush(bar);
+                        return co;
+                }
+
+                co += 8;
+                if (co >= nv_gpuobj(ramht)->size)
+                        co = 0;
+        } while (co != ho);
+
+        return -ENOMEM;
+}
+
+void
+nouveau_ramht_remove(struct nouveau_ramht *ramht, int cookie)
+{
+        struct nouveau_bar *bar = nouveau_bar(ramht);
+        nv_wo32(ramht, cookie + 0, 0x00000000);
+        nv_wo32(ramht, cookie + 4, 0x00000000);
+        if (bar)
+                bar->flush(bar);
+}
+
+static struct nouveau_oclass
+nouveau_ramht_oclass = {
+        .handle = 0x0000abcd,
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = NULL,
+                .dtor = _nouveau_gpuobj_dtor,
+                .init = _nouveau_gpuobj_init,
+                .fini = _nouveau_gpuobj_fini,
+                .rd32 = _nouveau_gpuobj_rd32,
+                .wr32 = _nouveau_gpuobj_wr32,
+        },
+};
+
+int
+nouveau_ramht_new(struct nouveau_object *parent, struct nouveau_object *pargpu,
+                  u32 size, u32 align, struct nouveau_ramht **pramht)
+{
+        struct nouveau_ramht *ramht;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, parent->engine ?
+                                    parent->engine : parent, /* <nv50 ramht */
+                                    &nouveau_ramht_oclass, 0, pargpu, size,
+                                    align, NVOBJ_FLAG_ZERO_ALLOC, &ramht);
+        *pramht = ramht;
+        if (ret)
+                return ret;
+
+        ramht->bits = log2i(nv_gpuobj(ramht)->size >> 3);
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/core/subdev.c b/drivers/gpu/drm/nouveau/core/core/subdev.c
new file mode 100644
index 000000000000..f74c30aa33a0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/core/subdev.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/subdev.h>
+#include <core/device.h>
+#include <core/option.h>
+
+void
+nouveau_subdev_reset(struct nouveau_object *subdev)
+{
+        nv_trace(subdev, "resetting...\n");
+        nv_ofuncs(subdev)->fini(subdev, false);
+        nv_debug(subdev, "reset\n");
+}
+
+int
+nouveau_subdev_init(struct nouveau_subdev *subdev)
+{
+        int ret = nouveau_object_init(&subdev->base);
+        if (ret)
+                return ret;
+
+        nouveau_subdev_reset(&subdev->base);
+        return 0;
+}
+
+int
+_nouveau_subdev_init(struct nouveau_object *object)
+{
+        return nouveau_subdev_init(nv_subdev(object));
+}
+
+int
+nouveau_subdev_fini(struct nouveau_subdev *subdev, bool suspend)
+{
+        if (subdev->unit) {
+                nv_mask(subdev, 0x000200, subdev->unit, 0x00000000);
+                nv_mask(subdev, 0x000200, subdev->unit, subdev->unit);
+        }
+
+        return nouveau_object_fini(&subdev->base, suspend);
+}
+
+int
+_nouveau_subdev_fini(struct nouveau_object *object, bool suspend)
+{
+        return nouveau_subdev_fini(nv_subdev(object), suspend);
+}
+
+void
+nouveau_subdev_destroy(struct nouveau_subdev *subdev)
+{
+        int subidx = nv_hclass(subdev) & 0xff;
+        nv_device(subdev)->subdev[subidx] = NULL;
+        nouveau_object_destroy(&subdev->base);
+}
+
+void
+_nouveau_subdev_dtor(struct nouveau_object *object)
+{
+        nouveau_subdev_destroy(nv_subdev(object));
+}
+
+int
+nouveau_subdev_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, u32 pclass,
+                       const char *subname, const char *sysname,
+                       int size, void **pobject)
+{
+        struct nouveau_subdev *subdev;
+        int ret;
+
+        ret = nouveau_object_create_(parent, engine, oclass, pclass |
+                                     NV_SUBDEV_CLASS, size, pobject);
+        subdev = *pobject;
+        if (ret)
+                return ret;
+
+        mutex_init(&subdev->mutex);
+        subdev->name = subname;
+
+        if (parent) {
+                struct nouveau_device *device = nv_device(parent);
+                int subidx = nv_hclass(subdev) & 0xff;
+
+                subdev->debug = nouveau_dbgopt(device->dbgopt, subname);
+                subdev->mmio  = nv_subdev(device)->mmio;
+                device->subdev[subidx] = *pobject;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/engine/bsp/nv84.c b/drivers/gpu/drm/nouveau/core/engine/bsp/nv84.c
new file mode 100644
index 000000000000..66f7dfd907ee
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/bsp/nv84.c
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/bsp.h>
+
+struct nv84_bsp_priv {
+        struct nouveau_bsp base;
+};
+
+struct nv84_bsp_chan {
+        struct nouveau_bsp_chan base;
+};
+
+/*******************************************************************************
+ * BSP object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv84_bsp_sclass[] = {
+        {},
+};
+
+/*******************************************************************************
+ * BSP context
+ ******************************************************************************/
+
+static int
+nv84_bsp_context_ctor(struct nouveau_object *parent,
+                      struct nouveau_object *engine,
+                      struct nouveau_oclass *oclass, void *data, u32 size,
+                      struct nouveau_object **pobject)
+{
+        struct nv84_bsp_chan *priv;
+        int ret;
+
+        ret = nouveau_bsp_context_create(parent, engine, oclass, NULL,
+                                         0, 0, 0, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nv84_bsp_context_dtor(struct nouveau_object *object)
+{
+        struct nv84_bsp_chan *priv = (void *)object;
+        nouveau_bsp_context_destroy(&priv->base);
+}
+
+static int
+nv84_bsp_context_init(struct nouveau_object *object)
+{
+        struct nv84_bsp_chan *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_bsp_context_init(&priv->base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv84_bsp_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv84_bsp_chan *priv = (void *)object;
+        return nouveau_bsp_context_fini(&priv->base, suspend);
+}
+
+static struct nouveau_oclass
+nv84_bsp_cclass = {
+        .handle = NV_ENGCTX(BSP, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_bsp_context_ctor,
+                .dtor = nv84_bsp_context_dtor,
+                .init = nv84_bsp_context_init,
+                .fini = nv84_bsp_context_fini,
+                .rd32 = _nouveau_bsp_context_rd32,
+                .wr32 = _nouveau_bsp_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * BSP engine/subdev functions
+ ******************************************************************************/
+
+static void
+nv84_bsp_intr(struct nouveau_subdev *subdev)
+{
+}
+
+static int
+nv84_bsp_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nv84_bsp_priv *priv;
+        int ret;
+
+        ret = nouveau_bsp_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x04008000;
+        nv_subdev(priv)->intr = nv84_bsp_intr;
+        nv_engine(priv)->cclass = &nv84_bsp_cclass;
+        nv_engine(priv)->sclass = nv84_bsp_sclass;
+        return 0;
+}
+
+static void
+nv84_bsp_dtor(struct nouveau_object *object)
+{
+        struct nv84_bsp_priv *priv = (void *)object;
+        nouveau_bsp_destroy(&priv->base);
+}
+
+static int
+nv84_bsp_init(struct nouveau_object *object)
+{
+        struct nv84_bsp_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_bsp_init(&priv->base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv84_bsp_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv84_bsp_priv *priv = (void *)object;
+        return nouveau_bsp_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv84_bsp_oclass = {
+        .handle = NV_ENGINE(BSP, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_bsp_ctor,
+                .dtor = nv84_bsp_dtor,
+                .init = nv84_bsp_init,
+                .fini = nv84_bsp_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nva3_copy.fuc b/drivers/gpu/drm/nouveau/core/engine/copy/fuc/nva3.fuc
index 219850d53286..219850d53286 100644
--- a/drivers/gpu/drm/nouveau/nva3_copy.fuc
+++ b/drivers/gpu/drm/nouveau/core/engine/copy/fuc/nva3.fuc
diff --git a/drivers/gpu/drm/nouveau/nva3_copy.fuc.h b/drivers/gpu/drm/nouveau/core/engine/copy/fuc/nva3.fuc.h
index 37d6de3c9d61..c92520f3ed46 100644
--- a/drivers/gpu/drm/nouveau/nva3_copy.fuc.h
+++ b/drivers/gpu/drm/nouveau/core/engine/copy/fuc/nva3.fuc.h
@@ -1,4 +1,4 @@
-u32 nva3_pcopy_data[] = {
+static u32 nva3_pcopy_data[] = {
 /* 0x0000: ctx_object */
         0x00000000,
 /* 0x0004: ctx_dma */
@@ -183,7 +183,7 @@ u32 nva3_pcopy_data[] = {
         0x00000800,
 };
 
-u32 nva3_pcopy_code[] = {
+static u32 nva3_pcopy_code[] = {
 /* 0x0000: main */
         0x04fe04bd,
         0x3517f000,
diff --git a/drivers/gpu/drm/nouveau/nvc0_copy.fuc.h b/drivers/gpu/drm/nouveau/core/engine/copy/fuc/nvc0.fuc.h
index cd879f31bb38..0d98c6c0958d 100644
--- a/drivers/gpu/drm/nouveau/nvc0_copy.fuc.h
+++ b/drivers/gpu/drm/nouveau/core/engine/copy/fuc/nvc0.fuc.h
@@ -1,4 +1,4 @@
-u32 nvc0_pcopy_data[] = {
+static u32 nvc0_pcopy_data[] = {
 /* 0x0000: ctx_object */
         0x00000000,
 /* 0x0004: ctx_query_address_high */
@@ -171,7 +171,7 @@ u32 nvc0_pcopy_data[] = {
         0x00000800,
 };
 
-u32 nvc0_pcopy_code[] = {
+static u32 nvc0_pcopy_code[] = {
 /* 0x0000: main */
         0x04fe04bd,
         0x3517f000,
diff --git a/drivers/gpu/drm/nouveau/core/engine/copy/nva3.c b/drivers/gpu/drm/nouveau/core/engine/copy/nva3.c
new file mode 100644
index 000000000000..4df6da0af740
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/copy/nva3.c
@@ -0,0 +1,222 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/enum.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+
+#include <engine/fifo.h>
+#include <engine/copy.h>
+
+#include "fuc/nva3.fuc.h"
+
+struct nva3_copy_priv {
+        struct nouveau_copy base;
+};
+
+struct nva3_copy_chan {
+        struct nouveau_copy_chan base;
+};
+
+/*******************************************************************************
+ * Copy object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nva3_copy_sclass[] = {
+        { 0x85b5, &nouveau_object_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PCOPY context
+ ******************************************************************************/
+
+static int
+nva3_copy_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nva3_copy_chan *priv;
+        int ret;
+
+        ret = nouveau_copy_context_create(parent, engine, oclass, NULL, 256, 0,
+                                          NVOBJ_FLAG_ZERO_ALLOC, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nva3_copy_cclass = {
+        .handle = NV_ENGCTX(COPY0, 0xa3),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nva3_copy_context_ctor,
+                .dtor = _nouveau_copy_context_dtor,
+                .init = _nouveau_copy_context_init,
+                .fini = _nouveau_copy_context_fini,
+                .rd32 = _nouveau_copy_context_rd32,
+                .wr32 = _nouveau_copy_context_wr32,
+
+        },
+};
+
+/*******************************************************************************
+ * PCOPY engine/subdev functions
+ ******************************************************************************/
+
+static const struct nouveau_enum nva3_copy_isr_error_name[] = {
+        { 0x0001, "ILLEGAL_MTHD" },
+        { 0x0002, "INVALID_ENUM" },
+        { 0x0003, "INVALID_BITFIELD" },
+        {}
+};
+
+static void
+nva3_copy_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nva3_copy_priv *priv = (void *)subdev;
+        u32 dispatch = nv_rd32(priv, 0x10401c);
+        u32 stat = nv_rd32(priv, 0x104008) & dispatch & ~(dispatch >> 16);
+        u64 inst = nv_rd32(priv, 0x104050) & 0x3fffffff;
+        u32 ssta = nv_rd32(priv, 0x104040) & 0x0000ffff;
+        u32 addr = nv_rd32(priv, 0x104040) >> 16;
+        u32 mthd = (addr & 0x07ff) << 2;
+        u32 subc = (addr & 0x3800) >> 11;
+        u32 data = nv_rd32(priv, 0x104044);
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x00000040) {
+                nv_error(priv, "DISPATCH_ERROR [");
+                nouveau_enum_print(nva3_copy_isr_error_name, ssta);
+                printk("] ch %d [0x%010llx] subc %d mthd 0x%04x data 0x%08x\n",
+                       chid, inst << 12, subc, mthd, data);
+                nv_wr32(priv, 0x104004, 0x00000040);
+                stat &= ~0x00000040;
+        }
+
+        if (stat) {
+                nv_error(priv, "unhandled intr 0x%08x\n", stat);
+                nv_wr32(priv, 0x104004, stat);
+        }
+
+        nv50_fb_trap(nouveau_fb(priv), 1);
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nva3_copy_tlb_flush(struct nouveau_engine *engine)
+{
+        nv50_vm_flush_engine(&engine->base, 0x0d);
+        return 0;
+}
+
+static int
+nva3_copy_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        bool enable = (nv_device(parent)->chipset != 0xaf);
+        struct nva3_copy_priv *priv;
+        int ret;
+
+        ret = nouveau_copy_create(parent, engine, oclass, enable, 0, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00802000;
+        nv_subdev(priv)->intr = nva3_copy_intr;
+        nv_engine(priv)->cclass = &nva3_copy_cclass;
+        nv_engine(priv)->sclass = nva3_copy_sclass;
+        nv_engine(priv)->tlb_flush = nva3_copy_tlb_flush;
+        return 0;
+}
+
+static int
+nva3_copy_init(struct nouveau_object *object)
+{
+        struct nva3_copy_priv *priv = (void *)object;
+        int ret, i;
+
+        ret = nouveau_copy_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* disable all interrupts */
+        nv_wr32(priv, 0x104014, 0xffffffff);
+
+        /* upload ucode */
+        nv_wr32(priv, 0x1041c0, 0x01000000);
+        for (i = 0; i < sizeof(nva3_pcopy_data) / 4; i++)
+                nv_wr32(priv, 0x1041c4, nva3_pcopy_data[i]);
+
+        nv_wr32(priv, 0x104180, 0x01000000);
+        for (i = 0; i < sizeof(nva3_pcopy_code) / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, 0x104188, i >> 6);
+                nv_wr32(priv, 0x104184, nva3_pcopy_code[i]);
+        }
+
+        /* start it running */
+        nv_wr32(priv, 0x10410c, 0x00000000);
+        nv_wr32(priv, 0x104104, 0x00000000); /* ENTRY */
+        nv_wr32(priv, 0x104100, 0x00000002); /* TRIGGER */
+        return 0;
+}
+
+static int
+nva3_copy_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nva3_copy_priv *priv = (void *)object;
+
+        nv_mask(priv, 0x104048, 0x00000003, 0x00000000);
+        nv_wr32(priv, 0x104014, 0xffffffff);
+
+        return nouveau_copy_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nva3_copy_oclass = {
+        .handle = NV_ENGINE(COPY0, 0xa3),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nva3_copy_ctor,
+                .dtor = _nouveau_copy_dtor,
+                .init = nva3_copy_init,
+                .fini = nva3_copy_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/copy/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/copy/nvc0.c
new file mode 100644
index 000000000000..06d4a8791055
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/copy/nvc0.c
@@ -0,0 +1,265 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/enum.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/fifo.h>
+#include <engine/copy.h>
+
+#include "fuc/nvc0.fuc.h"
+
+struct nvc0_copy_priv {
+        struct nouveau_copy base;
+};
+
+struct nvc0_copy_chan {
+        struct nouveau_copy_chan base;
+};
+
+/*******************************************************************************
+ * Copy object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nvc0_copy0_sclass[] = {
+        { 0x90b5, &nouveau_object_ofuncs },
+        {},
+};
+
+static struct nouveau_oclass
+nvc0_copy1_sclass[] = {
+        { 0x90b8, &nouveau_object_ofuncs },
+        {},
+};
+
+/*******************************************************************************
+ * PCOPY context
+ ******************************************************************************/
+
+static int
+nvc0_copy_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nvc0_copy_chan *priv;
+        int ret;
+
+        ret = nouveau_copy_context_create(parent, engine, oclass, NULL, 256,
+                                          256, NVOBJ_FLAG_ZERO_ALLOC, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nvc0_copy_context_ofuncs = {
+        .ctor = nvc0_copy_context_ctor,
+        .dtor = _nouveau_copy_context_dtor,
+        .init = _nouveau_copy_context_init,
+        .fini = _nouveau_copy_context_fini,
+        .rd32 = _nouveau_copy_context_rd32,
+        .wr32 = _nouveau_copy_context_wr32,
+};
+
+static struct nouveau_oclass
+nvc0_copy0_cclass = {
+        .handle = NV_ENGCTX(COPY0, 0xc0),
+        .ofuncs = &nvc0_copy_context_ofuncs,
+};
+
+static struct nouveau_oclass
+nvc0_copy1_cclass = {
+        .handle = NV_ENGCTX(COPY1, 0xc0),
+        .ofuncs = &nvc0_copy_context_ofuncs,
+};
+
+/*******************************************************************************
+ * PCOPY engine/subdev functions
+ ******************************************************************************/
+
+static const struct nouveau_enum nvc0_copy_isr_error_name[] = {
+        { 0x0001, "ILLEGAL_MTHD" },
+        { 0x0002, "INVALID_ENUM" },
+        { 0x0003, "INVALID_BITFIELD" },
+        {}
+};
+
+static void
+nvc0_copy_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        int idx = nv_engidx(nv_object(subdev)) - NVDEV_ENGINE_COPY0;
+        struct nvc0_copy_priv *priv = (void *)subdev;
+        u32 disp = nv_rd32(priv, 0x10401c + (idx * 0x1000));
+        u32 intr = nv_rd32(priv, 0x104008 + (idx * 0x1000));
+        u32 stat = intr & disp & ~(disp >> 16);
+        u64 inst = nv_rd32(priv, 0x104050 + (idx * 0x1000)) & 0x0fffffff;
+        u32 ssta = nv_rd32(priv, 0x104040 + (idx * 0x1000)) & 0x0000ffff;
+        u32 addr = nv_rd32(priv, 0x104040 + (idx * 0x1000)) >> 16;
+        u32 mthd = (addr & 0x07ff) << 2;
+        u32 subc = (addr & 0x3800) >> 11;
+        u32 data = nv_rd32(priv, 0x104044 + (idx * 0x1000));
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x00000040) {
+                nv_error(priv, "DISPATCH_ERROR [");
+                nouveau_enum_print(nvc0_copy_isr_error_name, ssta);
+                printk("] ch %d [0x%010llx] subc %d mthd 0x%04x data 0x%08x\n",
+                       chid, (u64)inst << 12, subc, mthd, data);
+                nv_wr32(priv, 0x104004 + (idx * 0x1000), 0x00000040);
+                stat &= ~0x00000040;
+        }
+
+        if (stat) {
+                nv_error(priv, "unhandled intr 0x%08x\n", stat);
+                nv_wr32(priv, 0x104004 + (idx * 0x1000), stat);
+        }
+
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nvc0_copy0_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nvc0_copy_priv *priv;
+        int ret;
+
+        if (nv_rd32(parent, 0x022500) & 0x00000100)
+                return -ENODEV;
+
+        ret = nouveau_copy_create(parent, engine, oclass, true, 0, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000040;
+        nv_subdev(priv)->intr = nvc0_copy_intr;
+        nv_engine(priv)->cclass = &nvc0_copy0_cclass;
+        nv_engine(priv)->sclass = nvc0_copy0_sclass;
+        return 0;
+}
+
+static int
+nvc0_copy1_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nvc0_copy_priv *priv;
+        int ret;
+
+        if (nv_rd32(parent, 0x022500) & 0x00000200)
+                return -ENODEV;
+
+        ret = nouveau_copy_create(parent, engine, oclass, true, 1, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000080;
+        nv_subdev(priv)->intr = nvc0_copy_intr;
+        nv_engine(priv)->cclass = &nvc0_copy1_cclass;
+        nv_engine(priv)->sclass = nvc0_copy1_sclass;
+        return 0;
+}
+
+static int
+nvc0_copy_init(struct nouveau_object *object)
+{
+        int idx = nv_engidx(object) - NVDEV_ENGINE_COPY0;
+        struct nvc0_copy_priv *priv = (void *)object;
+        int ret, i;
+
+        ret = nouveau_copy_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* disable all interrupts */
+        nv_wr32(priv, 0x104014 + (idx * 0x1000), 0xffffffff);
+
+        /* upload ucode */
+        nv_wr32(priv, 0x1041c0 + (idx * 0x1000), 0x01000000);
+        for (i = 0; i < sizeof(nvc0_pcopy_data) / 4; i++)
+                nv_wr32(priv, 0x1041c4 + (idx * 0x1000), nvc0_pcopy_data[i]);
+
+        nv_wr32(priv, 0x104180 + (idx * 0x1000), 0x01000000);
+        for (i = 0; i < sizeof(nvc0_pcopy_code) / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, 0x104188 + (idx * 0x1000), i >> 6);
+                nv_wr32(priv, 0x104184 + (idx * 0x1000), nvc0_pcopy_code[i]);
+        }
+
+        /* start it running */
+        nv_wr32(priv, 0x104084 + (idx * 0x1000), idx);
+        nv_wr32(priv, 0x10410c + (idx * 0x1000), 0x00000000);
+        nv_wr32(priv, 0x104104 + (idx * 0x1000), 0x00000000); /* ENTRY */
+        nv_wr32(priv, 0x104100 + (idx * 0x1000), 0x00000002); /* TRIGGER */
+        return 0;
+}
+
+static int
+nvc0_copy_fini(struct nouveau_object *object, bool suspend)
+{
+        int idx = nv_engidx(object) - NVDEV_ENGINE_COPY0;
+        struct nvc0_copy_priv *priv = (void *)object;
+
+        nv_mask(priv, 0x104048 + (idx * 0x1000), 0x00000003, 0x00000000);
+        nv_wr32(priv, 0x104014 + (idx * 0x1000), 0xffffffff);
+
+        return nouveau_copy_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nvc0_copy0_oclass = {
+        .handle = NV_ENGINE(COPY0, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_copy0_ctor,
+                .dtor = _nouveau_copy_dtor,
+                .init = nvc0_copy_init,
+                .fini = nvc0_copy_fini,
+        },
+};
+
+struct nouveau_oclass
+nvc0_copy1_oclass = {
+        .handle = NV_ENGINE(COPY1, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_copy1_ctor,
+                .dtor = _nouveau_copy_dtor,
+                .init = nvc0_copy_init,
+                .fini = nvc0_copy_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/copy/nve0.c b/drivers/gpu/drm/nouveau/core/engine/copy/nve0.c
new file mode 100644
index 000000000000..2017c1579ac5
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/copy/nve0.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/enum.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/copy.h>
+
+struct nve0_copy_priv {
+        struct nouveau_copy base;
+};
+
+struct nve0_copy_chan {
+        struct nouveau_copy_chan base;
+};
+
+/*******************************************************************************
+ * Copy object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nve0_copy_sclass[] = {
+        { 0xa0b5, &nouveau_object_ofuncs },
+        {},
+};
+
+/*******************************************************************************
+ * PCOPY context
+ ******************************************************************************/
+
+static int
+nve0_copy_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nve0_copy_chan *priv;
+        int ret;
+
+        ret = nouveau_copy_context_create(parent, engine, oclass, NULL, 256,
+                                          256, NVOBJ_FLAG_ZERO_ALLOC, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nve0_copy_context_ofuncs = {
+        .ctor = nve0_copy_context_ctor,
+        .dtor = _nouveau_copy_context_dtor,
+        .init = _nouveau_copy_context_init,
+        .fini = _nouveau_copy_context_fini,
+        .rd32 = _nouveau_copy_context_rd32,
+        .wr32 = _nouveau_copy_context_wr32,
+};
+
+static struct nouveau_oclass
+nve0_copy_cclass = {
+        .handle = NV_ENGCTX(COPY0, 0xc0),
+        .ofuncs = &nve0_copy_context_ofuncs,
+};
+
+/*******************************************************************************
+ * PCOPY engine/subdev functions
+ ******************************************************************************/
+
+static int
+nve0_copy0_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nve0_copy_priv *priv;
+        int ret;
+
+        if (nv_rd32(parent, 0x022500) & 0x00000100)
+                return -ENODEV;
+
+        ret = nouveau_copy_create(parent, engine, oclass, true, 0, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000040;
+        nv_engine(priv)->cclass = &nve0_copy_cclass;
+        nv_engine(priv)->sclass = nve0_copy_sclass;
+        return 0;
+}
+
+static int
+nve0_copy1_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nve0_copy_priv *priv;
+        int ret;
+
+        if (nv_rd32(parent, 0x022500) & 0x00000200)
+                return -ENODEV;
+
+        ret = nouveau_copy_create(parent, engine, oclass, true, 1, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000080;
+        nv_engine(priv)->cclass = &nve0_copy_cclass;
+        nv_engine(priv)->sclass = nve0_copy_sclass;
+        return 0;
+}
+
+struct nouveau_oclass
+nve0_copy0_oclass = {
+        .handle = NV_ENGINE(COPY0, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nve0_copy0_ctor,
+                .dtor = _nouveau_copy_dtor,
+                .init = _nouveau_copy_init,
+                .fini = _nouveau_copy_fini,
+        },
+};
+
+struct nouveau_oclass
+nve0_copy1_oclass = {
+        .handle = NV_ENGINE(COPY1, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nve0_copy1_ctor,
+                .dtor = _nouveau_copy_dtor,
+                .init = _nouveau_copy_init,
+                .fini = _nouveau_copy_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nv98_crypt.fuc b/drivers/gpu/drm/nouveau/core/engine/crypt/fuc/nv98.fuc
index 7393813044de..629da02dc352 100644
--- a/drivers/gpu/drm/nouveau/nv98_crypt.fuc
+++ b/drivers/gpu/drm/nouveau/core/engine/crypt/fuc/nv98.fuc
@@ -238,7 +238,7 @@ ih:
                         cmpu b32 $r4 0x60+#dma_count
                         bra nc #illegal_mthd
                         shl b32 $r5 $r4 2
-                        add b32 $r5 (#ctx_dma - 0x60 * 4) & 0xffff
+                        add b32 $r5 ((#ctx_dma - 0x60 * 4) & 0xffff)
                         bset $r3 0x1e
                         st b32 D[$r5] $r3
                         add b32 $r4 0x180 - 0x60
diff --git a/drivers/gpu/drm/nouveau/nv98_crypt.fuc.h b/drivers/gpu/drm/nouveau/core/engine/crypt/fuc/nv98.fuc.h
index 38676c74e6e0..09962e4210e9 100644
--- a/drivers/gpu/drm/nouveau/nv98_crypt.fuc.h
+++ b/drivers/gpu/drm/nouveau/core/engine/crypt/fuc/nv98.fuc.h
@@ -1,4 +1,4 @@
-uint32_t nv98_pcrypt_data[] = {
+static uint32_t nv98_pcrypt_data[] = {
 /* 0x0000: ctx_dma */
 /* 0x0000: ctx_dma_query */
         0x00000000,
@@ -150,7 +150,7 @@ uint32_t nv98_pcrypt_data[] = {
         0x00000000,
 };
 
-uint32_t nv98_pcrypt_code[] = {
+static uint32_t nv98_pcrypt_code[] = {
         0x17f004bd,
         0x0010fe35,
         0xf10004fe,
diff --git a/drivers/gpu/drm/nouveau/core/engine/crypt/nv84.c b/drivers/gpu/drm/nouveau/core/engine/crypt/nv84.c
new file mode 100644
index 000000000000..1d85e5b66ca0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/crypt/nv84.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/enum.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/gpuobj.h>
+
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+#include <engine/crypt.h>
+
+struct nv84_crypt_priv {
+        struct nouveau_crypt base;
+};
+
+struct nv84_crypt_chan {
+        struct nouveau_crypt_chan base;
+};
+
+/*******************************************************************************
+ * Crypt object classes
+ ******************************************************************************/
+
+static int
+nv84_crypt_object_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj *obj;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, parent,
+                                    16, 16, 0, &obj);
+        *pobject = nv_object(obj);
+        if (ret)
+                return ret;
+
+        nv_wo32(obj, 0x00, nv_mclass(obj));
+        nv_wo32(obj, 0x04, 0x00000000);
+        nv_wo32(obj, 0x08, 0x00000000);
+        nv_wo32(obj, 0x0c, 0x00000000);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv84_crypt_ofuncs = {
+        .ctor = nv84_crypt_object_ctor,
+        .dtor = _nouveau_gpuobj_dtor,
+        .init = _nouveau_gpuobj_init,
+        .fini = _nouveau_gpuobj_fini,
+        .rd32 = _nouveau_gpuobj_rd32,
+        .wr32 = _nouveau_gpuobj_wr32,
+};
+
+static struct nouveau_oclass
+nv84_crypt_sclass[] = {
+        { 0x74c1, &nv84_crypt_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PCRYPT context
+ ******************************************************************************/
+
+static int
+nv84_crypt_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv84_crypt_chan *priv;
+        int ret;
+
+        ret = nouveau_crypt_context_create(parent, engine, oclass, NULL, 256,
+                                           0, NVOBJ_FLAG_ZERO_ALLOC, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nv84_crypt_cclass = {
+        .handle = NV_ENGCTX(CRYPT, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_crypt_context_ctor,
+                .dtor = _nouveau_crypt_context_dtor,
+                .init = _nouveau_crypt_context_init,
+                .fini = _nouveau_crypt_context_fini,
+                .rd32 = _nouveau_crypt_context_rd32,
+                .wr32 = _nouveau_crypt_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PCRYPT engine/subdev functions
+ ******************************************************************************/
+
+static const struct nouveau_bitfield nv84_crypt_intr_mask[] = {
+        { 0x00000001, "INVALID_STATE" },
+        { 0x00000002, "ILLEGAL_MTHD" },
+        { 0x00000004, "ILLEGAL_CLASS" },
+        { 0x00000080, "QUERY" },
+        { 0x00000100, "FAULT" },
+        {}
+};
+
+static void
+nv84_crypt_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nv84_crypt_priv *priv = (void *)subdev;
+        u32 stat = nv_rd32(priv, 0x102130);
+        u32 mthd = nv_rd32(priv, 0x102190);
+        u32 data = nv_rd32(priv, 0x102194);
+        u32 inst = nv_rd32(priv, 0x102188) & 0x7fffffff;
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat) {
+                nv_error(priv, "");
+                nouveau_bitfield_print(nv84_crypt_intr_mask, stat);
+                printk(" ch %d [0x%010llx] mthd 0x%04x data 0x%08x\n",
+                       chid, (u64)inst << 12, mthd, data);
+        }
+
+        nv_wr32(priv, 0x102130, stat);
+        nv_wr32(priv, 0x10200c, 0x10);
+
+        nv50_fb_trap(nouveau_fb(priv), 1);
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nv84_crypt_tlb_flush(struct nouveau_engine *engine)
+{
+        nv50_vm_flush_engine(&engine->base, 0x0a);
+        return 0;
+}
+
+static int
+nv84_crypt_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv84_crypt_priv *priv;
+        int ret;
+
+        ret = nouveau_crypt_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00004000;
+        nv_subdev(priv)->intr = nv84_crypt_intr;
+        nv_engine(priv)->cclass = &nv84_crypt_cclass;
+        nv_engine(priv)->sclass = nv84_crypt_sclass;
+        nv_engine(priv)->tlb_flush = nv84_crypt_tlb_flush;
+        return 0;
+}
+
+static int
+nv84_crypt_init(struct nouveau_object *object)
+{
+        struct nv84_crypt_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_crypt_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x102130, 0xffffffff);
+        nv_wr32(priv, 0x102140, 0xffffffbf);
+        nv_wr32(priv, 0x10200c, 0x00000010);
+        return 0;
+}
+
+struct nouveau_oclass
+nv84_crypt_oclass = {
+        .handle = NV_ENGINE(CRYPT, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_crypt_ctor,
+                .dtor = _nouveau_crypt_dtor,
+                .init = nv84_crypt_init,
+                .fini = _nouveau_crypt_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/crypt/nv98.c b/drivers/gpu/drm/nouveau/core/engine/crypt/nv98.c
new file mode 100644
index 000000000000..9e3876c89b96
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/crypt/nv98.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/enum.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+#include <engine/crypt.h>
+
+#include "fuc/nv98.fuc.h"
+
+struct nv98_crypt_priv {
+        struct nouveau_crypt base;
+};
+
+struct nv98_crypt_chan {
+        struct nouveau_crypt_chan base;
+};
+
+/*******************************************************************************
+ * Crypt object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv98_crypt_sclass[] = {
+        { 0x88b4, &nouveau_object_ofuncs },
+        {},
+};
+
+/*******************************************************************************
+ * PCRYPT context
+ ******************************************************************************/
+
+static int
+nv98_crypt_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv98_crypt_chan *priv;
+        int ret;
+
+        ret = nouveau_crypt_context_create(parent, engine, oclass, NULL, 256,
+                                           256, NVOBJ_FLAG_ZERO_ALLOC, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nv98_crypt_cclass = {
+        .handle = NV_ENGCTX(CRYPT, 0x98),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv98_crypt_context_ctor,
+                .dtor = _nouveau_crypt_context_dtor,
+                .init = _nouveau_crypt_context_init,
+                .fini = _nouveau_crypt_context_fini,
+                .rd32 = _nouveau_crypt_context_rd32,
+                .wr32 = _nouveau_crypt_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PCRYPT engine/subdev functions
+ ******************************************************************************/
+
+static const struct nouveau_enum nv98_crypt_isr_error_name[] = {
+        { 0x0000, "ILLEGAL_MTHD" },
+        { 0x0001, "INVALID_BITFIELD" },
+        { 0x0002, "INVALID_ENUM" },
+        { 0x0003, "QUERY" },
+        {}
+};
+
+static void
+nv98_crypt_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nv98_crypt_priv *priv = (void *)subdev;
+        u32 disp = nv_rd32(priv, 0x08701c);
+        u32 stat = nv_rd32(priv, 0x087008) & disp & ~(disp >> 16);
+        u32 inst = nv_rd32(priv, 0x087050) & 0x3fffffff;
+        u32 ssta = nv_rd32(priv, 0x087040) & 0x0000ffff;
+        u32 addr = nv_rd32(priv, 0x087040) >> 16;
+        u32 mthd = (addr & 0x07ff) << 2;
+        u32 subc = (addr & 0x3800) >> 11;
+        u32 data = nv_rd32(priv, 0x087044);
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x00000040) {
+                nv_error(priv, "DISPATCH_ERROR [");
+                nouveau_enum_print(nv98_crypt_isr_error_name, ssta);
+                printk("] ch %d [0x%010llx] subc %d mthd 0x%04x data 0x%08x\n",
+                       chid, (u64)inst << 12, subc, mthd, data);
+                nv_wr32(priv, 0x087004, 0x00000040);
+                stat &= ~0x00000040;
+        }
+
+        if (stat) {
+                nv_error(priv, "unhandled intr 0x%08x\n", stat);
+                nv_wr32(priv, 0x087004, stat);
+        }
+
+        nv50_fb_trap(nouveau_fb(priv), 1);
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nv98_crypt_tlb_flush(struct nouveau_engine *engine)
+{
+        nv50_vm_flush_engine(&engine->base, 0x0a);
+        return 0;
+}
+
+static int
+nv98_crypt_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv98_crypt_priv *priv;
+        int ret;
+
+        ret = nouveau_crypt_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00004000;
+        nv_subdev(priv)->intr = nv98_crypt_intr;
+        nv_engine(priv)->cclass = &nv98_crypt_cclass;
+        nv_engine(priv)->sclass = nv98_crypt_sclass;
+        nv_engine(priv)->tlb_flush = nv98_crypt_tlb_flush;
+        return 0;
+}
+
+static int
+nv98_crypt_init(struct nouveau_object *object)
+{
+        struct nv98_crypt_priv *priv = (void *)object;
+        int ret, i;
+
+        ret = nouveau_crypt_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* wait for exit interrupt to signal */
+        nv_wait(priv, 0x087008, 0x00000010, 0x00000010);
+        nv_wr32(priv, 0x087004, 0x00000010);
+
+        /* upload microcode code and data segments */
+        nv_wr32(priv, 0x087ff8, 0x00100000);
+        for (i = 0; i < ARRAY_SIZE(nv98_pcrypt_code); i++)
+                nv_wr32(priv, 0x087ff4, nv98_pcrypt_code[i]);
+
+        nv_wr32(priv, 0x087ff8, 0x00000000);
+        for (i = 0; i < ARRAY_SIZE(nv98_pcrypt_data); i++)
+                nv_wr32(priv, 0x087ff4, nv98_pcrypt_data[i]);
+
+        /* start it running */
+        nv_wr32(priv, 0x08710c, 0x00000000);
+        nv_wr32(priv, 0x087104, 0x00000000); /* ENTRY */
+        nv_wr32(priv, 0x087100, 0x00000002); /* TRIGGER */
+        return 0;
+}
+
+struct nouveau_oclass
+nv98_crypt_oclass = {
+        .handle = NV_ENGINE(CRYPT, 0x98),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv98_crypt_ctor,
+                .dtor = _nouveau_crypt_dtor,
+                .init = nv98_crypt_init,
+                .fini = _nouveau_crypt_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/disp/nv04.c b/drivers/gpu/drm/nouveau/core/engine/disp/nv04.c
new file mode 100644
index 000000000000..1c919f2af89f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/disp/nv04.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2012 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 <engine/disp.h>
+
+struct nv04_disp_priv {
+        struct nouveau_disp base;
+};
+
+static struct nouveau_oclass
+nv04_disp_sclass[] = {
+        {},
+};
+
+static void
+nv04_disp_intr_vblank(struct nv04_disp_priv *priv, int crtc)
+{
+        struct nouveau_disp *disp = &priv->base;
+        if (disp->vblank.notify)
+                disp->vblank.notify(disp->vblank.data, crtc);
+}
+
+static void
+nv04_disp_intr(struct nouveau_subdev *subdev)
+{
+        struct nv04_disp_priv *priv = (void *)subdev;
+        u32 crtc0 = nv_rd32(priv, 0x600100);
+        u32 crtc1 = nv_rd32(priv, 0x602100);
+
+        if (crtc0 & 0x00000001) {
+                nv04_disp_intr_vblank(priv, 0);
+                nv_wr32(priv, 0x600100, 0x00000001);
+        }
+
+        if (crtc1 & 0x00000001) {
+                nv04_disp_intr_vblank(priv, 1);
+                nv_wr32(priv, 0x602100, 0x00000001);
+        }
+}
+
+static int
+nv04_disp_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv04_disp_priv *priv;
+        int ret;
+
+        ret = nouveau_disp_create(parent, engine, oclass, "DISPLAY",
+                                  "display", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->sclass = nv04_disp_sclass;
+        nv_subdev(priv)->intr = nv04_disp_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nv04_disp_oclass = {
+        .handle = NV_ENGINE(DISP, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_disp_ctor,
+                .dtor = _nouveau_disp_dtor,
+                .init = _nouveau_disp_init,
+                .fini = _nouveau_disp_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c b/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c
new file mode 100644
index 000000000000..16a9afb1060b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2012 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 <engine/software.h>
+#include <engine/disp.h>
+
+struct nv50_disp_priv {
+        struct nouveau_disp base;
+};
+
+static struct nouveau_oclass
+nv50_disp_sclass[] = {
+        {},
+};
+
+static void
+nv50_disp_intr_vblank(struct nv50_disp_priv *priv, int crtc)
+{
+        struct nouveau_disp *disp = &priv->base;
+        struct nouveau_software_chan *chan, *temp;
+        unsigned long flags;
+
+        spin_lock_irqsave(&disp->vblank.lock, flags);
+        list_for_each_entry_safe(chan, temp, &disp->vblank.list, vblank.head) {
+                if (chan->vblank.crtc != crtc)
+                        continue;
+
+                nv_wr32(priv, 0x001704, chan->vblank.channel);
+                nv_wr32(priv, 0x001710, 0x80000000 | chan->vblank.ctxdma);
+
+                if (nv_device(priv)->chipset == 0x50) {
+                        nv_wr32(priv, 0x001570, chan->vblank.offset);
+                        nv_wr32(priv, 0x001574, chan->vblank.value);
+                } else {
+                        if (nv_device(priv)->chipset >= 0xc0) {
+                                nv_wr32(priv, 0x06000c,
+                                        upper_32_bits(chan->vblank.offset));
+                        }
+                        nv_wr32(priv, 0x060010, chan->vblank.offset);
+                        nv_wr32(priv, 0x060014, chan->vblank.value);
+                }
+
+                list_del(&chan->vblank.head);
+                if (disp->vblank.put)
+                        disp->vblank.put(disp->vblank.data, crtc);
+        }
+        spin_unlock_irqrestore(&disp->vblank.lock, flags);
+
+        if (disp->vblank.notify)
+                disp->vblank.notify(disp->vblank.data, crtc);
+}
+
+static void
+nv50_disp_intr(struct nouveau_subdev *subdev)
+{
+        struct nv50_disp_priv *priv = (void *)subdev;
+        u32 stat1 = nv_rd32(priv, 0x610024);
+
+        if (stat1 & 0x00000004) {
+                nv50_disp_intr_vblank(priv, 0);
+                nv_wr32(priv, 0x610024, 0x00000004);
+                stat1 &= ~0x00000004;
+        }
+
+        if (stat1 & 0x00000008) {
+                nv50_disp_intr_vblank(priv, 1);
+                nv_wr32(priv, 0x610024, 0x00000008);
+                stat1 &= ~0x00000008;
+        }
+
+}
+
+static int
+nv50_disp_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv50_disp_priv *priv;
+        int ret;
+
+        ret = nouveau_disp_create(parent, engine, oclass, "PDISP",
+                                  "display", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->sclass = nv50_disp_sclass;
+        nv_subdev(priv)->intr = nv50_disp_intr;
+
+        INIT_LIST_HEAD(&priv->base.vblank.list);
+        spin_lock_init(&priv->base.vblank.lock);
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_disp_oclass = {
+        .handle = NV_ENGINE(DISP, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_disp_ctor,
+                .dtor = _nouveau_disp_dtor,
+                .init = _nouveau_disp_init,
+                .fini = _nouveau_disp_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c b/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c
new file mode 100644
index 000000000000..d93efbcf75b8
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2012 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 <subdev/bar.h>
+
+#include <engine/software.h>
+#include <engine/disp.h>
+
+struct nvd0_disp_priv {
+        struct nouveau_disp base;
+};
+
+static struct nouveau_oclass
+nvd0_disp_sclass[] = {
+        {},
+};
+
+static void
+nvd0_disp_intr_vblank(struct nvd0_disp_priv *priv, int crtc)
+{
+        struct nouveau_bar *bar = nouveau_bar(priv);
+        struct nouveau_disp *disp = &priv->base;
+        struct nouveau_software_chan *chan, *temp;
+        unsigned long flags;
+
+        spin_lock_irqsave(&disp->vblank.lock, flags);
+        list_for_each_entry_safe(chan, temp, &disp->vblank.list, vblank.head) {
+                if (chan->vblank.crtc != crtc)
+                        continue;
+
+                nv_wr32(priv, 0x001718, 0x80000000 | chan->vblank.channel);
+                bar->flush(bar);
+                nv_wr32(priv, 0x06000c, upper_32_bits(chan->vblank.offset));
+                nv_wr32(priv, 0x060010, lower_32_bits(chan->vblank.offset));
+                nv_wr32(priv, 0x060014, chan->vblank.value);
+
+                list_del(&chan->vblank.head);
+                if (disp->vblank.put)
+                        disp->vblank.put(disp->vblank.data, crtc);
+        }
+        spin_unlock_irqrestore(&disp->vblank.lock, flags);
+
+        if (disp->vblank.notify)
+                disp->vblank.notify(disp->vblank.data, crtc);
+}
+
+static void
+nvd0_disp_intr(struct nouveau_subdev *subdev)
+{
+        struct nvd0_disp_priv *priv = (void *)subdev;
+        u32 intr = nv_rd32(priv, 0x610088);
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                u32 mask = 0x01000000 << i;
+                if (mask & intr) {
+                        u32 stat = nv_rd32(priv, 0x6100bc + (i * 0x800));
+                        if (stat & 0x00000001)
+                                nvd0_disp_intr_vblank(priv, i);
+                        nv_mask(priv, 0x6100bc + (i * 0x800), 0, 0);
+                        nv_rd32(priv, 0x6100c0 + (i * 0x800));
+                }
+        }
+}
+
+static int
+nvd0_disp_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nvd0_disp_priv *priv;
+        int ret;
+
+        ret = nouveau_disp_create(parent, engine, oclass, "PDISP",
+                                  "display", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->sclass = nvd0_disp_sclass;
+        nv_subdev(priv)->intr = nvd0_disp_intr;
+
+        INIT_LIST_HEAD(&priv->base.vblank.list);
+        spin_lock_init(&priv->base.vblank.lock);
+        return 0;
+}
+
+struct nouveau_oclass
+nvd0_disp_oclass = {
+        .handle = NV_ENGINE(DISP, 0xd0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvd0_disp_ctor,
+                .dtor = _nouveau_disp_dtor,
+                .init = _nouveau_disp_init,
+                .fini = _nouveau_disp_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/disp/vga.c b/drivers/gpu/drm/nouveau/core/engine/disp/vga.c
new file mode 100644
index 000000000000..5a1c68474597
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/disp/vga.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2012 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 <core/subdev.h>
+#include <core/device.h>
+#include <subdev/vga.h>
+
+u8
+nv_rdport(void *obj, int head, u16 port)
+{
+        struct nouveau_device *device = nv_device(obj);
+
+        if (device->card_type >= NV_50)
+                return nv_rd08(obj, 0x601000 + port);
+
+        if (port == 0x03c0 || port == 0x03c1 || /* AR */
+            port == 0x03c2 || port == 0x03da || /* INP0 */
+            port == 0x03d4 || port == 0x03d5)   /* CR */
+                return nv_rd08(obj, 0x601000 + (head * 0x2000) + port);
+
+        if (port == 0x03c2 || port == 0x03cc || /* MISC */
+            port == 0x03c4 || port == 0x03c5 || /* SR */
+            port == 0x03ce || port == 0x03cf) { /* GR */
+                if (device->card_type < NV_40)
+                        head = 0; /* CR44 selects head */
+                return nv_rd08(obj, 0x0c0000 + (head * 0x2000) + port);
+        }
+
+        nv_error(obj, "unknown vga port 0x%04x\n", port);
+        return 0x00;
+}
+
+void
+nv_wrport(void *obj, int head, u16 port, u8 data)
+{
+        struct nouveau_device *device = nv_device(obj);
+
+        if (device->card_type >= NV_50)
+                nv_wr08(obj, 0x601000 + port, data);
+        else
+        if (port == 0x03c0 || port == 0x03c1 || /* AR */
+            port == 0x03c2 || port == 0x03da || /* INP0 */
+            port == 0x03d4 || port == 0x03d5)   /* CR */
+                nv_wr08(obj, 0x601000 + (head * 0x2000) + port, data);
+        else
+        if (port == 0x03c2 || port == 0x03cc || /* MISC */
+            port == 0x03c4 || port == 0x03c5 || /* SR */
+            port == 0x03ce || port == 0x03cf) { /* GR */
+                if (device->card_type < NV_40)
+                        head = 0; /* CR44 selects head */
+                nv_wr08(obj, 0x0c0000 + (head * 0x2000) + port, data);
+        } else
+                nv_error(obj, "unknown vga port 0x%04x\n", port);
+}
+
+u8
+nv_rdvgas(void *obj, int head, u8 index)
+{
+        nv_wrport(obj, head, 0x03c4, index);
+        return nv_rdport(obj, head, 0x03c5);
+}
+
+void
+nv_wrvgas(void *obj, int head, u8 index, u8 value)
+{
+        nv_wrport(obj, head, 0x03c4, index);
+        nv_wrport(obj, head, 0x03c5, value);
+}
+
+u8
+nv_rdvgag(void *obj, int head, u8 index)
+{
+        nv_wrport(obj, head, 0x03ce, index);
+        return nv_rdport(obj, head, 0x03cf);
+}
+
+void
+nv_wrvgag(void *obj, int head, u8 index, u8 value)
+{
+        nv_wrport(obj, head, 0x03ce, index);
+        nv_wrport(obj, head, 0x03cf, value);
+}
+
+u8
+nv_rdvgac(void *obj, int head, u8 index)
+{
+        nv_wrport(obj, head, 0x03d4, index);
+        return nv_rdport(obj, head, 0x03d5);
+}
+
+void
+nv_wrvgac(void *obj, int head, u8 index, u8 value)
+{
+        nv_wrport(obj, head, 0x03d4, index);
+        nv_wrport(obj, head, 0x03d5, value);
+}
+
+u8
+nv_rdvgai(void *obj, int head, u16 port, u8 index)
+{
+        if (port == 0x03c4) return nv_rdvgas(obj, head, index);
+        if (port == 0x03ce) return nv_rdvgag(obj, head, index);
+        if (port == 0x03d4) return nv_rdvgac(obj, head, index);
+        nv_error(obj, "unknown indexed vga port 0x%04x\n", port);
+        return 0x00;
+}
+
+void
+nv_wrvgai(void *obj, int head, u16 port, u8 index, u8 value)
+{
+        if      (port == 0x03c4) nv_wrvgas(obj, head, index, value);
+        else if (port == 0x03ce) nv_wrvgag(obj, head, index, value);
+        else if (port == 0x03d4) nv_wrvgac(obj, head, index, value);
+        else nv_error(obj, "unknown indexed vga port 0x%04x\n", port);
+}
+
+bool
+nv_lockvgac(void *obj, bool lock)
+{
+        bool locked = !nv_rdvgac(obj, 0, 0x1f);
+        u8 data = lock ? 0x99 : 0x57;
+        nv_wrvgac(obj, 0, 0x1f, data);
+        if (nv_device(obj)->chipset == 0x11) {
+                if (!(nv_rd32(obj, 0x001084) & 0x10000000))
+                        nv_wrvgac(obj, 1, 0x1f, data);
+        }
+        return locked;
+}
+
+/* CR44 takes values 0 (head A), 3 (head B) and 4 (heads tied)
+ * it affects only the 8 bit vga io regs, which we access using mmio at
+ * 0xc{0,2}3c*, 0x60{1,3}3*, and 0x68{1,3}3d*
+ * in general, the set value of cr44 does not matter: reg access works as
+ * expected and values can be set for the appropriate head by using a 0x2000
+ * offset as required
+ * however:
+ * a) pre nv40, the head B range of PRMVIO regs at 0xc23c* was not exposed and
+ *    cr44 must be set to 0 or 3 for accessing values on the correct head
+ *    through the common 0xc03c* addresses
+ * b) in tied mode (4) head B is programmed to the values set on head A, and
+ *    access using the head B addresses can have strange results, ergo we leave
+ *    tied mode in init once we know to what cr44 should be restored on exit
+ *
+ * the owner parameter is slightly abused:
+ * 0 and 1 are treated as head values and so the set value is (owner * 3)
+ * other values are treated as literal values to set
+ */
+u8
+nv_rdvgaowner(void *obj)
+{
+        if (nv_device(obj)->card_type < NV_50) {
+                if (nv_device(obj)->chipset == 0x11) {
+                        u32 tied = nv_rd32(obj, 0x001084) & 0x10000000;
+                        if (tied == 0) {
+                                u8 slA = nv_rdvgac(obj, 0, 0x28) & 0x80;
+                                u8 tvA = nv_rdvgac(obj, 0, 0x33) & 0x01;
+                                u8 slB = nv_rdvgac(obj, 1, 0x28) & 0x80;
+                                u8 tvB = nv_rdvgac(obj, 1, 0x33) & 0x01;
+                                if (slA && !tvA) return 0x00;
+                                if (slB && !tvB) return 0x03;
+                                if (slA) return 0x00;
+                                if (slB) return 0x03;
+                                return 0x00;
+                        }
+                        return 0x04;
+                }
+
+                return nv_rdvgac(obj, 0, 0x44);
+        }
+
+        nv_error(obj, "rdvgaowner after nv4x\n");
+        return 0x00;
+}
+
+void
+nv_wrvgaowner(void *obj, u8 select)
+{
+        if (nv_device(obj)->card_type < NV_50) {
+                u8 owner = (select == 1) ? 3 : select;
+                if (nv_device(obj)->chipset == 0x11) {
+                        /* workaround hw lockup bug */
+                        nv_rdvgac(obj, 0, 0x1f);
+                        nv_rdvgac(obj, 1, 0x1f);
+                }
+
+                nv_wrvgac(obj, 0, 0x44, owner);
+
+                if (nv_device(obj)->chipset == 0x11) {
+                        nv_wrvgac(obj, 0, 0x2e, owner);
+                        nv_wrvgac(obj, 0, 0x2e, owner);
+                }
+        } else
+                nv_error(obj, "wrvgaowner after nv4x\n");
+}
diff --git a/drivers/gpu/drm/nouveau/core/engine/dmaobj/base.c b/drivers/gpu/drm/nouveau/core/engine/dmaobj/base.c
new file mode 100644
index 000000000000..e1f013d39768
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/dmaobj/base.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/class.h>
+
+#include <subdev/fb.h>
+#include <engine/dmaobj.h>
+
+int
+nouveau_dmaobj_create_(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass,
+                       void *data, u32 size, int len, void **pobject)
+{
+        struct nv_dma_class *args = data;
+        struct nouveau_dmaobj *object;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_object_create_(parent, engine, oclass, 0, len, pobject);
+        object = *pobject;
+        if (ret)
+                return ret;
+
+        switch (args->flags & NV_DMA_TARGET_MASK) {
+        case NV_DMA_TARGET_VM:
+                object->target = NV_MEM_TARGET_VM;
+                break;
+        case NV_DMA_TARGET_VRAM:
+                object->target = NV_MEM_TARGET_VRAM;
+                break;
+        case NV_DMA_TARGET_PCI:
+                object->target = NV_MEM_TARGET_PCI;
+                break;
+        case NV_DMA_TARGET_PCI_US:
+        case NV_DMA_TARGET_AGP:
+                object->target = NV_MEM_TARGET_PCI_NOSNOOP;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (args->flags & NV_DMA_ACCESS_MASK) {
+        case NV_DMA_ACCESS_VM:
+                object->access = NV_MEM_ACCESS_VM;
+                break;
+        case NV_DMA_ACCESS_RD:
+                object->access = NV_MEM_ACCESS_RO;
+                break;
+        case NV_DMA_ACCESS_WR:
+                object->access = NV_MEM_ACCESS_WO;
+                break;
+        case NV_DMA_ACCESS_RDWR:
+                object->access = NV_MEM_ACCESS_RW;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        object->start = args->start;
+        object->limit = args->limit;
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/engine/dmaobj/nv04.c b/drivers/gpu/drm/nouveau/core/engine/dmaobj/nv04.c
new file mode 100644
index 000000000000..9f4cc2f31994
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/dmaobj/nv04.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+#include <core/class.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm/nv04.h>
+
+#include <engine/dmaobj.h>
+
+struct nv04_dmaeng_priv {
+        struct nouveau_dmaeng base;
+};
+
+struct nv04_dmaobj_priv {
+        struct nouveau_dmaobj base;
+};
+
+static int
+nv04_dmaobj_bind(struct nouveau_dmaeng *dmaeng,
+                 struct nouveau_object *parent,
+                 struct nouveau_dmaobj *dmaobj,
+                 struct nouveau_gpuobj **pgpuobj)
+{
+        struct nv04_vmmgr_priv *vmm = nv04_vmmgr(dmaeng);
+        struct nouveau_gpuobj *gpuobj;
+        u32 flags0 = nv_mclass(dmaobj);
+        u32 flags2 = 0x00000000;
+        u64 offset = dmaobj->start & 0xfffff000;
+        u64 adjust = dmaobj->start & 0x00000fff;
+        u32 length = dmaobj->limit - dmaobj->start;
+        int ret;
+
+        if (dmaobj->target == NV_MEM_TARGET_VM) {
+                if (nv_object(vmm)->oclass == &nv04_vmmgr_oclass) {
+                        struct nouveau_gpuobj *pgt = vmm->vm->pgt[0].obj[0];
+                        if (!dmaobj->start)
+                                return nouveau_gpuobj_dup(parent, pgt, pgpuobj);
+                        offset  = nv_ro32(pgt, 8 + (offset >> 10));
+                        offset &= 0xfffff000;
+                }
+
+                dmaobj->target = NV_MEM_TARGET_PCI;
+                dmaobj->access = NV_MEM_ACCESS_RW;
+        }
+
+        switch (dmaobj->target) {
+        case NV_MEM_TARGET_VRAM:
+                flags0 |= 0x00003000;
+                break;
+        case NV_MEM_TARGET_PCI:
+                flags0 |= 0x00023000;
+                break;
+        case NV_MEM_TARGET_PCI_NOSNOOP:
+                flags0 |= 0x00033000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (dmaobj->access) {
+        case NV_MEM_ACCESS_RO:
+                flags0 |= 0x00004000;
+                break;
+        case NV_MEM_ACCESS_WO:
+                flags0 |= 0x00008000;
+        case NV_MEM_ACCESS_RW:
+                flags2 |= 0x00000002;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = nouveau_gpuobj_new(parent, parent, 16, 16, 0, &gpuobj);
+        *pgpuobj = gpuobj;
+        if (ret == 0) {
+                nv_wo32(*pgpuobj, 0x00, flags0 | (adjust << 20));
+                nv_wo32(*pgpuobj, 0x04, length);
+                nv_wo32(*pgpuobj, 0x08, flags2 | offset);
+                nv_wo32(*pgpuobj, 0x0c, flags2 | offset);
+        }
+
+        return ret;
+}
+
+static int
+nv04_dmaobj_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nouveau_dmaeng *dmaeng = (void *)engine;
+        struct nv04_dmaobj_priv *dmaobj;
+        struct nouveau_gpuobj *gpuobj;
+        int ret;
+
+        ret = nouveau_dmaobj_create(parent, engine, oclass,
+                                    data, size, &dmaobj);
+        *pobject = nv_object(dmaobj);
+        if (ret)
+                return ret;
+
+        switch (nv_mclass(parent)) {
+        case NV_DEVICE_CLASS:
+                break;
+        case NV03_CHANNEL_DMA_CLASS:
+        case NV10_CHANNEL_DMA_CLASS:
+        case NV17_CHANNEL_DMA_CLASS:
+        case NV40_CHANNEL_DMA_CLASS:
+                ret = dmaeng->bind(dmaeng, *pobject, &dmaobj->base, &gpuobj);
+                nouveau_object_ref(NULL, pobject);
+                *pobject = nv_object(gpuobj);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return ret;
+}
+
+static struct nouveau_ofuncs
+nv04_dmaobj_ofuncs = {
+        .ctor = nv04_dmaobj_ctor,
+        .dtor = _nouveau_dmaobj_dtor,
+        .init = _nouveau_dmaobj_init,
+        .fini = _nouveau_dmaobj_fini,
+};
+
+static struct nouveau_oclass
+nv04_dmaobj_sclass[] = {
+        { 0x0002, &nv04_dmaobj_ofuncs },
+        { 0x0003, &nv04_dmaobj_ofuncs },
+        { 0x003d, &nv04_dmaobj_ofuncs },
+        {}
+};
+
+static int
+nv04_dmaeng_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nv04_dmaeng_priv *priv;
+        int ret;
+
+        ret = nouveau_dmaeng_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.base.sclass = nv04_dmaobj_sclass;
+        priv->base.bind = nv04_dmaobj_bind;
+        return 0;
+}
+
+struct nouveau_oclass
+nv04_dmaeng_oclass = {
+        .handle = NV_ENGINE(DMAOBJ, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_dmaeng_ctor,
+                .dtor = _nouveau_dmaeng_dtor,
+                .init = _nouveau_dmaeng_init,
+                .fini = _nouveau_dmaeng_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/dmaobj/nv50.c b/drivers/gpu/drm/nouveau/core/engine/dmaobj/nv50.c
new file mode 100644
index 000000000000..045d2565e289
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/dmaobj/nv50.c
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+#include <core/class.h>
+
+#include <subdev/fb.h>
+#include <engine/dmaobj.h>
+
+struct nv50_dmaeng_priv {
+        struct nouveau_dmaeng base;
+};
+
+struct nv50_dmaobj_priv {
+        struct nouveau_dmaobj base;
+};
+
+static int
+nv50_dmaobj_bind(struct nouveau_dmaeng *dmaeng,
+                 struct nouveau_object *parent,
+                 struct nouveau_dmaobj *dmaobj,
+                 struct nouveau_gpuobj **pgpuobj)
+{
+        u32 flags = nv_mclass(dmaobj);
+        int ret;
+
+        switch (dmaobj->target) {
+        case NV_MEM_TARGET_VM:
+                flags |= 0x00000000;
+                flags |= 0x60000000; /* COMPRESSION_USEVM */
+                flags |= 0x1fc00000; /* STORAGE_TYPE_USEVM */
+                break;
+        case NV_MEM_TARGET_VRAM:
+                flags |= 0x00010000;
+                flags |= 0x00100000; /* ACCESSUS_USER_SYSTEM */
+                break;
+        case NV_MEM_TARGET_PCI:
+                flags |= 0x00020000;
+                flags |= 0x00100000; /* ACCESSUS_USER_SYSTEM */
+                break;
+        case NV_MEM_TARGET_PCI_NOSNOOP:
+                flags |= 0x00030000;
+                flags |= 0x00100000; /* ACCESSUS_USER_SYSTEM */
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (dmaobj->access) {
+        case NV_MEM_ACCESS_VM:
+                break;
+        case NV_MEM_ACCESS_RO:
+                flags |= 0x00040000;
+                break;
+        case NV_MEM_ACCESS_WO:
+        case NV_MEM_ACCESS_RW:
+                flags |= 0x00080000;
+                break;
+        }
+
+        ret = nouveau_gpuobj_new(parent, parent, 24, 32, 0, pgpuobj);
+        if (ret == 0) {
+                nv_wo32(*pgpuobj, 0x00, flags);
+                nv_wo32(*pgpuobj, 0x04, lower_32_bits(dmaobj->limit));
+                nv_wo32(*pgpuobj, 0x08, lower_32_bits(dmaobj->start));
+                nv_wo32(*pgpuobj, 0x0c, upper_32_bits(dmaobj->limit) << 24 |
+                                        upper_32_bits(dmaobj->start));
+                nv_wo32(*pgpuobj, 0x10, 0x00000000);
+                nv_wo32(*pgpuobj, 0x14, 0x00000000);
+        }
+
+        return ret;
+}
+
+static int
+nv50_dmaobj_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nouveau_dmaeng *dmaeng = (void *)engine;
+        struct nv50_dmaobj_priv *dmaobj;
+        struct nouveau_gpuobj *gpuobj;
+        int ret;
+
+        ret = nouveau_dmaobj_create(parent, engine, oclass,
+                                    data, size, &dmaobj);
+        *pobject = nv_object(dmaobj);
+        if (ret)
+                return ret;
+
+        switch (nv_mclass(parent)) {
+        case NV_DEVICE_CLASS:
+                break;
+        case NV50_CHANNEL_DMA_CLASS:
+        case NV84_CHANNEL_DMA_CLASS:
+        case NV50_CHANNEL_IND_CLASS:
+        case NV84_CHANNEL_IND_CLASS:
+                ret = dmaeng->bind(dmaeng, *pobject, &dmaobj->base, &gpuobj);
+                nouveau_object_ref(NULL, pobject);
+                *pobject = nv_object(gpuobj);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return ret;
+}
+
+static struct nouveau_ofuncs
+nv50_dmaobj_ofuncs = {
+        .ctor = nv50_dmaobj_ctor,
+        .dtor = _nouveau_dmaobj_dtor,
+        .init = _nouveau_dmaobj_init,
+        .fini = _nouveau_dmaobj_fini,
+};
+
+static struct nouveau_oclass
+nv50_dmaobj_sclass[] = {
+        { 0x0002, &nv50_dmaobj_ofuncs },
+        { 0x0003, &nv50_dmaobj_ofuncs },
+        { 0x003d, &nv50_dmaobj_ofuncs },
+        {}
+};
+
+static int
+nv50_dmaeng_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nv50_dmaeng_priv *priv;
+        int ret;
+
+        ret = nouveau_dmaeng_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.base.sclass = nv50_dmaobj_sclass;
+        priv->base.bind = nv50_dmaobj_bind;
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_dmaeng_oclass = {
+        .handle = NV_ENGINE(DMAOBJ, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_dmaeng_ctor,
+                .dtor = _nouveau_dmaeng_dtor,
+                .init = _nouveau_dmaeng_init,
+                .fini = _nouveau_dmaeng_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/dmaobj/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/dmaobj/nvc0.c
new file mode 100644
index 000000000000..5baa08695535
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/dmaobj/nvc0.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+
+#include <subdev/fb.h>
+#include <engine/dmaobj.h>
+
+struct nvc0_dmaeng_priv {
+        struct nouveau_dmaeng base;
+};
+
+struct nvc0_dmaobj_priv {
+        struct nouveau_dmaobj base;
+};
+
+static int
+nvc0_dmaobj_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nvc0_dmaobj_priv *dmaobj;
+        int ret;
+
+        ret = nouveau_dmaobj_create(parent, engine, oclass, data, size, &dmaobj);
+        *pobject = nv_object(dmaobj);
+        if (ret)
+                return ret;
+
+        if (dmaobj->base.target != NV_MEM_TARGET_VM || dmaobj->base.start)
+                return -EINVAL;
+
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nvc0_dmaobj_ofuncs = {
+        .ctor = nvc0_dmaobj_ctor,
+        .dtor = _nouveau_dmaobj_dtor,
+        .init = _nouveau_dmaobj_init,
+        .fini = _nouveau_dmaobj_fini,
+};
+
+static struct nouveau_oclass
+nvc0_dmaobj_sclass[] = {
+        { 0x0002, &nvc0_dmaobj_ofuncs },
+        { 0x0003, &nvc0_dmaobj_ofuncs },
+        { 0x003d, &nvc0_dmaobj_ofuncs },
+        {}
+};
+
+static int
+nvc0_dmaeng_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nvc0_dmaeng_priv *priv;
+        int ret;
+
+        ret = nouveau_dmaeng_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.base.sclass = nvc0_dmaobj_sclass;
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_dmaeng_oclass = {
+        .handle = NV_ENGINE(DMAOBJ, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_dmaeng_ctor,
+                .dtor = _nouveau_dmaeng_dtor,
+                .init = _nouveau_dmaeng_init,
+                .fini = _nouveau_dmaeng_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/base.c b/drivers/gpu/drm/nouveau/core/engine/fifo/base.c
new file mode 100644
index 000000000000..bbb43c67c2ae
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/base.c
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/handle.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+
+int
+nouveau_fifo_channel_create_(struct nouveau_object *parent,
+                             struct nouveau_object *engine,
+                             struct nouveau_oclass *oclass,
+                             int bar, u32 addr, u32 size, u32 pushbuf,
+                             u32 engmask, int len, void **ptr)
+{
+        struct nouveau_device *device = nv_device(engine);
+        struct nouveau_fifo *priv = (void *)engine;
+        struct nouveau_fifo_chan *chan;
+        struct nouveau_dmaeng *dmaeng;
+        unsigned long flags;
+        int ret;
+
+        /* create base object class */
+        ret = nouveau_namedb_create_(parent, engine, oclass, 0, NULL,
+                                     engmask, len, ptr);
+        chan = *ptr;
+        if (ret)
+                return ret;
+
+        /* validate dma object representing push buffer */
+        chan->pushdma = (void *)nouveau_handle_ref(parent, pushbuf);
+        if (!chan->pushdma)
+                return -ENOENT;
+
+        dmaeng = (void *)chan->pushdma->base.engine;
+        switch (chan->pushdma->base.oclass->handle) {
+        case 0x0002:
+        case 0x003d:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (dmaeng->bind) {
+                ret = dmaeng->bind(dmaeng, parent, chan->pushdma, &chan->pushgpu);
+                if (ret)
+                        return ret;
+        }
+
+        /* find a free fifo channel */
+        spin_lock_irqsave(&priv->lock, flags);
+        for (chan->chid = priv->min; chan->chid < priv->max; chan->chid++) {
+                if (!priv->channel[chan->chid]) {
+                        priv->channel[chan->chid] = nv_object(chan);
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        if (chan->chid == priv->max) {
+                nv_error(priv, "no free channels\n");
+                return -ENOSPC;
+        }
+
+        /* map fifo control registers */
+        chan->user = ioremap(pci_resource_start(device->pdev, bar) + addr +
+                             (chan->chid * size), size);
+        if (!chan->user)
+                return -EFAULT;
+
+        chan->size = size;
+        return 0;
+}
+
+void
+nouveau_fifo_channel_destroy(struct nouveau_fifo_chan *chan)
+{
+        struct nouveau_fifo *priv = (void *)nv_object(chan)->engine;
+        unsigned long flags;
+
+        iounmap(chan->user);
+
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->channel[chan->chid] = NULL;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        nouveau_gpuobj_ref(NULL, &chan->pushgpu);
+        nouveau_object_ref(NULL, (struct nouveau_object **)&chan->pushdma);
+        nouveau_namedb_destroy(&chan->base);
+}
+
+void
+_nouveau_fifo_channel_dtor(struct nouveau_object *object)
+{
+        struct nouveau_fifo_chan *chan = (void *)object;
+        nouveau_fifo_channel_destroy(chan);
+}
+
+u32
+_nouveau_fifo_channel_rd32(struct nouveau_object *object, u32 addr)
+{
+        struct nouveau_fifo_chan *chan = (void *)object;
+        return ioread32_native(chan->user + addr);
+}
+
+void
+_nouveau_fifo_channel_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        struct nouveau_fifo_chan *chan = (void *)object;
+        iowrite32_native(data, chan->user + addr);
+}
+
+static int
+nouveau_fifo_chid(struct nouveau_fifo *priv, struct nouveau_object *object)
+{
+        int engidx = nv_hclass(priv) & 0xff;
+
+        while (object && object->parent) {
+                if ( nv_iclass(object->parent, NV_ENGCTX_CLASS) &&
+                    (nv_hclass(object->parent) & 0xff) == engidx)
+                        return nouveau_fifo_chan(object)->chid;
+                object = object->parent;
+        }
+
+        return -1;
+}
+
+void
+nouveau_fifo_destroy(struct nouveau_fifo *priv)
+{
+        kfree(priv->channel);
+        nouveau_engine_destroy(&priv->base);
+}
+
+int
+nouveau_fifo_create_(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass,
+                     int min, int max, int length, void **pobject)
+{
+        struct nouveau_fifo *priv;
+        int ret;
+
+        ret = nouveau_engine_create_(parent, engine, oclass, true, "PFIFO",
+                                     "fifo", length, pobject);
+        priv = *pobject;
+        if (ret)
+                return ret;
+
+        priv->min = min;
+        priv->max = max;
+        priv->channel = kzalloc(sizeof(*priv->channel) * (max + 1), GFP_KERNEL);
+        if (!priv->channel)
+                return -ENOMEM;
+
+        priv->chid = nouveau_fifo_chid;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c
new file mode 100644
index 000000000000..ea76e3e8c9c2
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.c
@@ -0,0 +1,630 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/namedb.h>
+#include <core/handle.h>
+#include <core/ramht.h>
+
+#include <subdev/instmem.h>
+#include <subdev/instmem/nv04.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+
+#include "nv04.h"
+
+static struct ramfc_desc
+nv04_ramfc[] = {
+        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
+        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
+        { 16,  0, 0x08,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
+        { 16, 16, 0x08,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
+        { 32,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_STATE },
+        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
+        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_ENGINE },
+        { 32,  0, 0x18,  0, NV04_PFIFO_CACHE1_PULL1 },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+int
+nv04_fifo_object_attach(struct nouveau_object *parent,
+                        struct nouveau_object *object, u32 handle)
+{
+        struct nv04_fifo_priv *priv = (void *)parent->engine;
+        struct nv04_fifo_chan *chan = (void *)parent;
+        u32 context, chid = chan->base.chid;
+        int ret;
+
+        if (nv_iclass(object, NV_GPUOBJ_CLASS))
+                context = nv_gpuobj(object)->addr >> 4;
+        else
+                context = 0x00000004; /* just non-zero */
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_DMAOBJ:
+        case NVDEV_ENGINE_SW:
+                context |= 0x00000000;
+                break;
+        case NVDEV_ENGINE_GR:
+                context |= 0x00010000;
+                break;
+        case NVDEV_ENGINE_MPEG:
+                context |= 0x00020000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        context |= 0x80000000; /* valid */
+        context |= chid << 24;
+
+        mutex_lock(&nv_subdev(priv)->mutex);
+        ret = nouveau_ramht_insert(priv->ramht, chid, handle, context);
+        mutex_unlock(&nv_subdev(priv)->mutex);
+        return ret;
+}
+
+void
+nv04_fifo_object_detach(struct nouveau_object *parent, int cookie)
+{
+        struct nv04_fifo_priv *priv = (void *)parent->engine;
+        mutex_lock(&nv_subdev(priv)->mutex);
+        nouveau_ramht_remove(priv->ramht, cookie);
+        mutex_unlock(&nv_subdev(priv)->mutex);
+}
+
+int
+nv04_fifo_context_attach(struct nouveau_object *parent,
+                         struct nouveau_object *object)
+{
+        nv_engctx(object)->addr = nouveau_fifo_chan(parent)->chid;
+        return 0;
+}
+
+static int
+nv04_fifo_chan_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nv04_fifo_priv *priv = (void *)engine;
+        struct nv04_fifo_chan *chan;
+        struct nv03_channel_dma_class *args = data;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0x800000,
+                                          0x10000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->object_attach = nv04_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv04_fifo_object_detach;
+        nv_parent(chan)->context_attach = nv04_fifo_context_attach;
+        chan->ramfc = chan->base.chid * 32;
+
+        nv_wo32(priv->ramfc, chan->ramfc + 0x00, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x04, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x08, chan->base.pushgpu->addr >> 4);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x10,
+                             NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
+                             NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
+#ifdef __BIG_ENDIAN
+                             NV_PFIFO_CACHE1_BIG_ENDIAN |
+#endif
+                             NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
+        return 0;
+}
+
+void
+nv04_fifo_chan_dtor(struct nouveau_object *object)
+{
+        struct nv04_fifo_priv *priv = (void *)object->engine;
+        struct nv04_fifo_chan *chan = (void *)object;
+        struct ramfc_desc *c = priv->ramfc_desc;
+
+        do {
+                nv_wo32(priv->ramfc, chan->ramfc + c->ctxp, 0x00000000);
+        } while ((++c)->bits);
+
+        nouveau_fifo_channel_destroy(&chan->base);
+}
+
+int
+nv04_fifo_chan_init(struct nouveau_object *object)
+{
+        struct nv04_fifo_priv *priv = (void *)object->engine;
+        struct nv04_fifo_chan *chan = (void *)object;
+        u32 mask = 1 << chan->base.chid;
+        unsigned long flags;
+        int ret;
+
+        ret = nouveau_fifo_channel_init(&chan->base);
+        if (ret)
+                return ret;
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        nv_mask(priv, NV04_PFIFO_MODE, mask, mask);
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+        return 0;
+}
+
+int
+nv04_fifo_chan_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv04_fifo_priv *priv = (void *)object->engine;
+        struct nv04_fifo_chan *chan = (void *)object;
+        struct nouveau_gpuobj *fctx = priv->ramfc;
+        struct ramfc_desc *c;
+        unsigned long flags;
+        u32 data = chan->ramfc;
+        u32 chid;
+
+        /* prevent fifo context switches */
+        spin_lock_irqsave(&priv->base.lock, flags);
+        nv_wr32(priv, NV03_PFIFO_CACHES, 0);
+
+        /* if this channel is active, replace it with a null context */
+        chid = nv_rd32(priv, NV03_PFIFO_CACHE1_PUSH1) & priv->base.max;
+        if (chid == chan->base.chid) {
+                nv_mask(priv, NV04_PFIFO_CACHE1_DMA_PUSH, 0x00000001, 0);
+                nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0, 0);
+                nv_mask(priv, NV04_PFIFO_CACHE1_PULL0, 0x00000001, 0);
+
+                c = priv->ramfc_desc;
+                do {
+                        u32 rm = ((1ULL << c->bits) - 1) << c->regs;
+                        u32 cm = ((1ULL << c->bits) - 1) << c->ctxs;
+                        u32 rv = (nv_rd32(priv, c->regp) &  rm) >> c->regs;
+                        u32 cv = (nv_ro32(fctx, c->ctxp + data) & ~cm);
+                        nv_wo32(fctx, c->ctxp + data, cv | (rv << c->ctxs));
+                } while ((++c)->bits);
+
+                c = priv->ramfc_desc;
+                do {
+                        nv_wr32(priv, c->regp, 0x00000000);
+                } while ((++c)->bits);
+
+                nv_wr32(priv, NV03_PFIFO_CACHE1_GET, 0);
+                nv_wr32(priv, NV03_PFIFO_CACHE1_PUT, 0);
+                nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH1, priv->base.max);
+                nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0, 1);
+                nv_wr32(priv, NV04_PFIFO_CACHE1_PULL0, 1);
+        }
+
+        /* restore normal operation, after disabling dma mode */
+        nv_mask(priv, NV04_PFIFO_MODE, 1 << chan->base.chid, 0);
+        nv_wr32(priv, NV03_PFIFO_CACHES, 1);
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+
+        return nouveau_fifo_channel_fini(&chan->base, suspend);
+}
+
+static struct nouveau_ofuncs
+nv04_fifo_ofuncs = {
+        .ctor = nv04_fifo_chan_ctor,
+        .dtor = nv04_fifo_chan_dtor,
+        .init = nv04_fifo_chan_init,
+        .fini = nv04_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nv04_fifo_sclass[] = {
+        { NV03_CHANNEL_DMA_CLASS, &nv04_fifo_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - basically just the instmem reserved for the channel
+ ******************************************************************************/
+
+int
+nv04_fifo_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nv04_fifo_base *base;
+        int ret;
+
+        ret = nouveau_fifo_context_create(parent, engine, oclass, NULL, 0x1000,
+                                          0x1000, NVOBJ_FLAG_HEAP, &base);
+        *pobject = nv_object(base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nv04_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_fifo_context_ctor,
+                .dtor = _nouveau_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+void
+nv04_fifo_pause(struct nouveau_fifo *pfifo, unsigned long *pflags)
+__acquires(priv->base.lock)
+{
+        struct nv04_fifo_priv *priv = (void *)pfifo;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        *pflags = flags;
+
+        nv_wr32(priv, NV03_PFIFO_CACHES, 0x00000000);
+        nv_mask(priv, NV04_PFIFO_CACHE1_PULL0, 0x00000001, 0x00000000);
+
+        /* in some cases the puller may be left in an inconsistent state
+         * if you try to stop it while it's busy translating handles.
+         * sometimes you get a CACHE_ERROR, sometimes it just fails
+         * silently; sending incorrect instance offsets to PGRAPH after
+         * it's started up again.
+         *
+         * to avoid this, we invalidate the most recently calculated
+         * instance.
+         */
+        if (!nv_wait(priv, NV04_PFIFO_CACHE1_PULL0,
+                           NV04_PFIFO_CACHE1_PULL0_HASH_BUSY, 0x00000000))
+                nv_warn(priv, "timeout idling puller\n");
+
+        if (nv_rd32(priv, NV04_PFIFO_CACHE1_PULL0) &
+                          NV04_PFIFO_CACHE1_PULL0_HASH_FAILED)
+                nv_wr32(priv, NV03_PFIFO_INTR_0, NV_PFIFO_INTR_CACHE_ERROR);
+
+        nv_wr32(priv, NV04_PFIFO_CACHE1_HASH, 0x00000000);
+}
+
+void
+nv04_fifo_start(struct nouveau_fifo *pfifo, unsigned long *pflags)
+__releases(priv->base.lock)
+{
+        struct nv04_fifo_priv *priv = (void *)pfifo;
+        unsigned long flags = *pflags;
+
+        nv_mask(priv, NV04_PFIFO_CACHE1_PULL0, 0x00000001, 0x00000001);
+        nv_wr32(priv, NV03_PFIFO_CACHES, 0x00000001);
+
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+}
+
+static const char *
+nv_dma_state_err(u32 state)
+{
+        static const char * const desc[] = {
+                "NONE", "CALL_SUBR_ACTIVE", "INVALID_MTHD", "RET_SUBR_INACTIVE",
+                "INVALID_CMD", "IB_EMPTY"/* NV50+ */, "MEM_FAULT", "UNK"
+        };
+        return desc[(state >> 29) & 0x7];
+}
+
+static bool
+nv04_fifo_swmthd(struct nv04_fifo_priv *priv, u32 chid, u32 addr, u32 data)
+{
+        struct nv04_fifo_chan *chan = NULL;
+        struct nouveau_handle *bind;
+        const int subc = (addr >> 13) & 0x7;
+        const int mthd = addr & 0x1ffc;
+        bool handled = false;
+        unsigned long flags;
+        u32 engine;
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        if (likely(chid >= priv->base.min && chid <= priv->base.max))
+                chan = (void *)priv->base.channel[chid];
+        if (unlikely(!chan))
+                goto out;
+
+        switch (mthd) {
+        case 0x0000:
+                bind = nouveau_namedb_get(nv_namedb(chan), data);
+                if (unlikely(!bind))
+                        break;
+
+                if (nv_engidx(bind->object->engine) == NVDEV_ENGINE_SW) {
+                        engine = 0x0000000f << (subc * 4);
+                        chan->subc[subc] = data;
+                        handled = true;
+
+                        nv_mask(priv, NV04_PFIFO_CACHE1_ENGINE, engine, 0);
+                }
+
+                nouveau_namedb_put(bind);
+                break;
+        default:
+                engine = nv_rd32(priv, NV04_PFIFO_CACHE1_ENGINE);
+                if (unlikely(((engine >> (subc * 4)) & 0xf) != 0))
+                        break;
+
+                bind = nouveau_namedb_get(nv_namedb(chan), chan->subc[subc]);
+                if (likely(bind)) {
+                        if (!nv_call(bind->object, mthd, data))
+                                handled = true;
+                        nouveau_namedb_put(bind);
+                }
+                break;
+        }
+
+out:
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+        return handled;
+}
+
+void
+nv04_fifo_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_device *device = nv_device(subdev);
+        struct nv04_fifo_priv *priv = (void *)subdev;
+        uint32_t status, reassign;
+        int cnt = 0;
+
+        reassign = nv_rd32(priv, NV03_PFIFO_CACHES) & 1;
+        while ((status = nv_rd32(priv, NV03_PFIFO_INTR_0)) && (cnt++ < 100)) {
+                uint32_t chid, get;
+
+                nv_wr32(priv, NV03_PFIFO_CACHES, 0);
+
+                chid = nv_rd32(priv, NV03_PFIFO_CACHE1_PUSH1) & priv->base.max;
+                get  = nv_rd32(priv, NV03_PFIFO_CACHE1_GET);
+
+                if (status & NV_PFIFO_INTR_CACHE_ERROR) {
+                        uint32_t mthd, data;
+                        int ptr;
+
+                        /* NV_PFIFO_CACHE1_GET actually goes to 0xffc before
+                         * wrapping on my G80 chips, but CACHE1 isn't big
+                         * enough for this much data.. Tests show that it
+                         * wraps around to the start at GET=0x800.. No clue
+                         * as to why..
+                         */
+                        ptr = (get & 0x7ff) >> 2;
+
+                        if (device->card_type < NV_40) {
+                                mthd = nv_rd32(priv,
+                                        NV04_PFIFO_CACHE1_METHOD(ptr));
+                                data = nv_rd32(priv,
+                                        NV04_PFIFO_CACHE1_DATA(ptr));
+                        } else {
+                                mthd = nv_rd32(priv,
+                                        NV40_PFIFO_CACHE1_METHOD(ptr));
+                                data = nv_rd32(priv,
+                                        NV40_PFIFO_CACHE1_DATA(ptr));
+                        }
+
+                        if (!nv04_fifo_swmthd(priv, chid, mthd, data)) {
+                                nv_info(priv, "CACHE_ERROR - Ch %d/%d "
+                                              "Mthd 0x%04x Data 0x%08x\n",
+                                        chid, (mthd >> 13) & 7, mthd & 0x1ffc,
+                                        data);
+                        }
+
+                        nv_wr32(priv, NV04_PFIFO_CACHE1_DMA_PUSH, 0);
+                        nv_wr32(priv, NV03_PFIFO_INTR_0,
+                                                NV_PFIFO_INTR_CACHE_ERROR);
+
+                        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0,
+                                nv_rd32(priv, NV03_PFIFO_CACHE1_PUSH0) & ~1);
+                        nv_wr32(priv, NV03_PFIFO_CACHE1_GET, get + 4);
+                        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0,
+                                nv_rd32(priv, NV03_PFIFO_CACHE1_PUSH0) | 1);
+                        nv_wr32(priv, NV04_PFIFO_CACHE1_HASH, 0);
+
+                        nv_wr32(priv, NV04_PFIFO_CACHE1_DMA_PUSH,
+                                nv_rd32(priv, NV04_PFIFO_CACHE1_DMA_PUSH) | 1);
+                        nv_wr32(priv, NV04_PFIFO_CACHE1_PULL0, 1);
+
+                        status &= ~NV_PFIFO_INTR_CACHE_ERROR;
+                }
+
+                if (status & NV_PFIFO_INTR_DMA_PUSHER) {
+                        u32 dma_get = nv_rd32(priv, 0x003244);
+                        u32 dma_put = nv_rd32(priv, 0x003240);
+                        u32 push = nv_rd32(priv, 0x003220);
+                        u32 state = nv_rd32(priv, 0x003228);
+
+                        if (device->card_type == NV_50) {
+                                u32 ho_get = nv_rd32(priv, 0x003328);
+                                u32 ho_put = nv_rd32(priv, 0x003320);
+                                u32 ib_get = nv_rd32(priv, 0x003334);
+                                u32 ib_put = nv_rd32(priv, 0x003330);
+
+                                nv_info(priv, "DMA_PUSHER - Ch %d Get 0x%02x%08x "
+                                     "Put 0x%02x%08x IbGet 0x%08x IbPut 0x%08x "
+                                     "State 0x%08x (err: %s) Push 0x%08x\n",
+                                        chid, ho_get, dma_get, ho_put,
+                                        dma_put, ib_get, ib_put, state,
+                                        nv_dma_state_err(state),
+                                        push);
+
+                                /* METHOD_COUNT, in DMA_STATE on earlier chipsets */
+                                nv_wr32(priv, 0x003364, 0x00000000);
+                                if (dma_get != dma_put || ho_get != ho_put) {
+                                        nv_wr32(priv, 0x003244, dma_put);
+                                        nv_wr32(priv, 0x003328, ho_put);
+                                } else
+                                if (ib_get != ib_put) {
+                                        nv_wr32(priv, 0x003334, ib_put);
+                                }
+                        } else {
+                                nv_info(priv, "DMA_PUSHER - Ch %d Get 0x%08x "
+                                             "Put 0x%08x State 0x%08x (err: %s) Push 0x%08x\n",
+                                        chid, dma_get, dma_put, state,
+                                        nv_dma_state_err(state), push);
+
+                                if (dma_get != dma_put)
+                                        nv_wr32(priv, 0x003244, dma_put);
+                        }
+
+                        nv_wr32(priv, 0x003228, 0x00000000);
+                        nv_wr32(priv, 0x003220, 0x00000001);
+                        nv_wr32(priv, 0x002100, NV_PFIFO_INTR_DMA_PUSHER);
+                        status &= ~NV_PFIFO_INTR_DMA_PUSHER;
+                }
+
+                if (status & NV_PFIFO_INTR_SEMAPHORE) {
+                        uint32_t sem;
+
+                        status &= ~NV_PFIFO_INTR_SEMAPHORE;
+                        nv_wr32(priv, NV03_PFIFO_INTR_0,
+                                NV_PFIFO_INTR_SEMAPHORE);
+
+                        sem = nv_rd32(priv, NV10_PFIFO_CACHE1_SEMAPHORE);
+                        nv_wr32(priv, NV10_PFIFO_CACHE1_SEMAPHORE, sem | 0x1);
+
+                        nv_wr32(priv, NV03_PFIFO_CACHE1_GET, get + 4);
+                        nv_wr32(priv, NV04_PFIFO_CACHE1_PULL0, 1);
+                }
+
+                if (device->card_type == NV_50) {
+                        if (status & 0x00000010) {
+                                nv50_fb_trap(nouveau_fb(priv), 1);
+                                status &= ~0x00000010;
+                                nv_wr32(priv, 0x002100, 0x00000010);
+                        }
+                }
+
+                if (status) {
+                        nv_info(priv, "unknown intr 0x%08x, ch %d\n",
+                                status, chid);
+                        nv_wr32(priv, NV03_PFIFO_INTR_0, status);
+                        status = 0;
+                }
+
+                nv_wr32(priv, NV03_PFIFO_CACHES, reassign);
+        }
+
+        if (status) {
+                nv_info(priv, "still angry after %d spins, halt\n", cnt);
+                nv_wr32(priv, 0x002140, 0);
+                nv_wr32(priv, 0x000140, 0);
+        }
+
+        nv_wr32(priv, 0x000100, 0x00000100);
+}
+
+static int
+nv04_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv04_instmem_priv *imem = nv04_instmem(parent);
+        struct nv04_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 0, 15, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nouveau_ramht_ref(imem->ramht, &priv->ramht);
+        nouveau_gpuobj_ref(imem->ramro, &priv->ramro);
+        nouveau_gpuobj_ref(imem->ramfc, &priv->ramfc);
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nv04_fifo_intr;
+        nv_engine(priv)->cclass = &nv04_fifo_cclass;
+        nv_engine(priv)->sclass = nv04_fifo_sclass;
+        priv->base.pause = nv04_fifo_pause;
+        priv->base.start = nv04_fifo_start;
+        priv->ramfc_desc = nv04_ramfc;
+        return 0;
+}
+
+void
+nv04_fifo_dtor(struct nouveau_object *object)
+{
+        struct nv04_fifo_priv *priv = (void *)object;
+        nouveau_gpuobj_ref(NULL, &priv->ramfc);
+        nouveau_gpuobj_ref(NULL, &priv->ramro);
+        nouveau_ramht_ref(NULL, &priv->ramht);
+        nouveau_fifo_destroy(&priv->base);
+}
+
+int
+nv04_fifo_init(struct nouveau_object *object)
+{
+        struct nv04_fifo_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_fifo_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, NV04_PFIFO_DELAY_0, 0x000000ff);
+        nv_wr32(priv, NV04_PFIFO_DMA_TIMESLICE, 0x0101ffff);
+
+        nv_wr32(priv, NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ |
+                                       ((priv->ramht->bits - 9) << 16) |
+                                        (priv->ramht->base.addr >> 8));
+        nv_wr32(priv, NV03_PFIFO_RAMRO, priv->ramro->addr >> 8);
+        nv_wr32(priv, NV03_PFIFO_RAMFC, priv->ramfc->addr >> 8);
+
+        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH1, priv->base.max);
+
+        nv_wr32(priv, NV03_PFIFO_INTR_0, 0xffffffff);
+        nv_wr32(priv, NV03_PFIFO_INTR_EN_0, 0xffffffff);
+
+        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0, 1);
+        nv_wr32(priv, NV04_PFIFO_CACHE1_PULL0, 1);
+        nv_wr32(priv, NV03_PFIFO_CACHES, 1);
+        return 0;
+}
+
+struct nouveau_oclass
+nv04_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_fifo_ctor,
+                .dtor = nv04_fifo_dtor,
+                .init = nv04_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.h b/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.h
new file mode 100644
index 000000000000..496a4b4fdfaf
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv04.h
@@ -0,0 +1,178 @@
+#ifndef __NV04_FIFO_H__
+#define __NV04_FIFO_H__
+
+#include <engine/fifo.h>
+
+#define NV04_PFIFO_DELAY_0                                 0x00002040
+#define NV04_PFIFO_DMA_TIMESLICE                           0x00002044
+#define NV04_PFIFO_NEXT_CHANNEL                            0x00002050
+#define NV03_PFIFO_INTR_0                                  0x00002100
+#define NV03_PFIFO_INTR_EN_0                               0x00002140
+#    define NV_PFIFO_INTR_CACHE_ERROR                          (1<<0)
+#    define NV_PFIFO_INTR_RUNOUT                               (1<<4)
+#    define NV_PFIFO_INTR_RUNOUT_OVERFLOW                      (1<<8)
+#    define NV_PFIFO_INTR_DMA_PUSHER                          (1<<12)
+#    define NV_PFIFO_INTR_DMA_PT                              (1<<16)
+#    define NV_PFIFO_INTR_SEMAPHORE                           (1<<20)
+#    define NV_PFIFO_INTR_ACQUIRE_TIMEOUT                     (1<<24)
+#define NV03_PFIFO_RAMHT                                   0x00002210
+#define NV03_PFIFO_RAMFC                                   0x00002214
+#define NV03_PFIFO_RAMRO                                   0x00002218
+#define NV40_PFIFO_RAMFC                                   0x00002220
+#define NV03_PFIFO_CACHES                                  0x00002500
+#define NV04_PFIFO_MODE                                    0x00002504
+#define NV04_PFIFO_DMA                                     0x00002508
+#define NV04_PFIFO_SIZE                                    0x0000250c
+#define NV50_PFIFO_CTX_TABLE(c)                        (0x2600+(c)*4)
+#define NV50_PFIFO_CTX_TABLE__SIZE                                128
+#define NV50_PFIFO_CTX_TABLE_CHANNEL_ENABLED                  (1<<31)
+#define NV50_PFIFO_CTX_TABLE_UNK30_BAD                        (1<<30)
+#define NV50_PFIFO_CTX_TABLE_INSTANCE_MASK_G80             0x0FFFFFFF
+#define NV50_PFIFO_CTX_TABLE_INSTANCE_MASK_G84             0x00FFFFFF
+#define NV03_PFIFO_CACHE0_PUSH0                            0x00003000
+#define NV03_PFIFO_CACHE0_PULL0                            0x00003040
+#define NV04_PFIFO_CACHE0_PULL0                            0x00003050
+#define NV04_PFIFO_CACHE0_PULL1                            0x00003054
+#define NV03_PFIFO_CACHE1_PUSH0                            0x00003200
+#define NV03_PFIFO_CACHE1_PUSH1                            0x00003204
+#define NV03_PFIFO_CACHE1_PUSH1_DMA                            (1<<8)
+#define NV40_PFIFO_CACHE1_PUSH1_DMA                           (1<<16)
+#define NV03_PFIFO_CACHE1_PUSH1_CHID_MASK                  0x0000000f
+#define NV10_PFIFO_CACHE1_PUSH1_CHID_MASK                  0x0000001f
+#define NV50_PFIFO_CACHE1_PUSH1_CHID_MASK                  0x0000007f
+#define NV03_PFIFO_CACHE1_PUT                              0x00003210
+#define NV04_PFIFO_CACHE1_DMA_PUSH                         0x00003220
+#define NV04_PFIFO_CACHE1_DMA_FETCH                        0x00003224
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_8_BYTES         0x00000000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_16_BYTES        0x00000008
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_24_BYTES        0x00000010
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_32_BYTES        0x00000018
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_40_BYTES        0x00000020
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_48_BYTES        0x00000028
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_56_BYTES        0x00000030
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_64_BYTES        0x00000038
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_72_BYTES        0x00000040
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_80_BYTES        0x00000048
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_88_BYTES        0x00000050
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_96_BYTES        0x00000058
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_104_BYTES       0x00000060
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_112_BYTES       0x00000068
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_120_BYTES       0x00000070
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES       0x00000078
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_136_BYTES       0x00000080
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_144_BYTES       0x00000088
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_152_BYTES       0x00000090
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_160_BYTES       0x00000098
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_168_BYTES       0x000000A0
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_176_BYTES       0x000000A8
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_184_BYTES       0x000000B0
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_192_BYTES       0x000000B8
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_200_BYTES       0x000000C0
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_208_BYTES       0x000000C8
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_216_BYTES       0x000000D0
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_224_BYTES       0x000000D8
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_232_BYTES       0x000000E0
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_240_BYTES       0x000000E8
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_248_BYTES       0x000000F0
+#    define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_256_BYTES       0x000000F8
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE                 0x0000E000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_32_BYTES        0x00000000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_64_BYTES        0x00002000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_96_BYTES        0x00004000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES       0x00006000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_160_BYTES       0x00008000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_192_BYTES       0x0000A000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_224_BYTES       0x0000C000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_256_BYTES       0x0000E000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS             0x001F0000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_0           0x00000000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_1           0x00010000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_2           0x00020000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_3           0x00030000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_4           0x00040000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_5           0x00050000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_6           0x00060000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_7           0x00070000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8           0x00080000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_9           0x00090000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_10          0x000A0000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_11          0x000B0000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_12          0x000C0000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_13          0x000D0000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_14          0x000E0000
+#    define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_15          0x000F0000
+#    define NV_PFIFO_CACHE1_ENDIAN                         0x80000000
+#    define NV_PFIFO_CACHE1_LITTLE_ENDIAN                  0x7FFFFFFF
+#    define NV_PFIFO_CACHE1_BIG_ENDIAN                     0x80000000
+#define NV04_PFIFO_CACHE1_DMA_STATE                        0x00003228
+#define NV04_PFIFO_CACHE1_DMA_INSTANCE                     0x0000322c
+#define NV04_PFIFO_CACHE1_DMA_CTL                          0x00003230
+#define NV04_PFIFO_CACHE1_DMA_PUT                          0x00003240
+#define NV04_PFIFO_CACHE1_DMA_GET                          0x00003244
+#define NV10_PFIFO_CACHE1_REF_CNT                          0x00003248
+#define NV10_PFIFO_CACHE1_DMA_SUBROUTINE                   0x0000324C
+#define NV03_PFIFO_CACHE1_PULL0                            0x00003240
+#define NV04_PFIFO_CACHE1_PULL0                            0x00003250
+#    define NV04_PFIFO_CACHE1_PULL0_HASH_FAILED            0x00000010
+#    define NV04_PFIFO_CACHE1_PULL0_HASH_BUSY              0x00001000
+#define NV03_PFIFO_CACHE1_PULL1                            0x00003250
+#define NV04_PFIFO_CACHE1_PULL1                            0x00003254
+#define NV04_PFIFO_CACHE1_HASH                             0x00003258
+#define NV10_PFIFO_CACHE1_ACQUIRE_TIMEOUT                  0x00003260
+#define NV10_PFIFO_CACHE1_ACQUIRE_TIMESTAMP                0x00003264
+#define NV10_PFIFO_CACHE1_ACQUIRE_VALUE                    0x00003268
+#define NV10_PFIFO_CACHE1_SEMAPHORE                        0x0000326C
+#define NV03_PFIFO_CACHE1_GET                              0x00003270
+#define NV04_PFIFO_CACHE1_ENGINE                           0x00003280
+#define NV04_PFIFO_CACHE1_DMA_DCOUNT                       0x000032A0
+#define NV40_PFIFO_GRCTX_INSTANCE                          0x000032E0
+#define NV40_PFIFO_UNK32E4                                 0x000032E4
+#define NV04_PFIFO_CACHE1_METHOD(i)                (0x00003800+(i*8))
+#define NV04_PFIFO_CACHE1_DATA(i)                  (0x00003804+(i*8))
+#define NV40_PFIFO_CACHE1_METHOD(i)                (0x00090000+(i*8))
+#define NV40_PFIFO_CACHE1_DATA(i)                  (0x00090004+(i*8))
+
+struct ramfc_desc {
+        unsigned bits:6;
+        unsigned ctxs:5;
+        unsigned ctxp:8;
+        unsigned regs:5;
+        unsigned regp;
+};
+
+struct nv04_fifo_priv {
+        struct nouveau_fifo base;
+        struct ramfc_desc *ramfc_desc;
+        struct nouveau_ramht  *ramht;
+        struct nouveau_gpuobj *ramro;
+        struct nouveau_gpuobj *ramfc;
+};
+
+struct nv04_fifo_base {
+        struct nouveau_fifo_base base;
+};
+
+struct nv04_fifo_chan {
+        struct nouveau_fifo_chan base;
+        u32 subc[8];
+        u32 ramfc;
+};
+
+int  nv04_fifo_object_attach(struct nouveau_object *,
+                             struct nouveau_object *, u32);
+void nv04_fifo_object_detach(struct nouveau_object *, int);
+
+void nv04_fifo_chan_dtor(struct nouveau_object *);
+int  nv04_fifo_chan_init(struct nouveau_object *);
+int  nv04_fifo_chan_fini(struct nouveau_object *, bool suspend);
+
+int  nv04_fifo_context_ctor(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, void *, u32,
+                            struct nouveau_object **);
+
+void nv04_fifo_dtor(struct nouveau_object *);
+int  nv04_fifo_init(struct nouveau_object *);
+void nv04_fifo_pause(struct nouveau_fifo *, unsigned long *);
+void nv04_fifo_start(struct nouveau_fifo *, unsigned long *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv10.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv10.c
new file mode 100644
index 000000000000..4ba75422b89d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv10.c
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/ramht.h>
+
+#include <subdev/instmem.h>
+#include <subdev/instmem/nv04.h>
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+
+#include "nv04.h"
+
+static struct ramfc_desc
+nv10_ramfc[] = {
+        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
+        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
+        { 32,  0, 0x08,  0, NV10_PFIFO_CACHE1_REF_CNT },
+        { 16,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
+        { 16, 16, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
+        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_STATE },
+        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
+        { 32,  0, 0x18,  0, NV04_PFIFO_CACHE1_ENGINE },
+        { 32,  0, 0x1c,  0, NV04_PFIFO_CACHE1_PULL1 },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+static int
+nv10_fifo_chan_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nv04_fifo_priv *priv = (void *)engine;
+        struct nv04_fifo_chan *chan;
+        struct nv03_channel_dma_class *args = data;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0x800000,
+                                          0x10000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->object_attach = nv04_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv04_fifo_object_detach;
+        nv_parent(chan)->context_attach = nv04_fifo_context_attach;
+        chan->ramfc = chan->base.chid * 32;
+
+        nv_wo32(priv->ramfc, chan->ramfc + 0x00, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x04, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x0c, chan->base.pushgpu->addr >> 4);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x14,
+                             NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
+                             NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
+#ifdef __BIG_ENDIAN
+                             NV_PFIFO_CACHE1_BIG_ENDIAN |
+#endif
+                             NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv10_fifo_ofuncs = {
+        .ctor = nv10_fifo_chan_ctor,
+        .dtor = nv04_fifo_chan_dtor,
+        .init = nv04_fifo_chan_init,
+        .fini = nv04_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nv10_fifo_sclass[] = {
+        { NV10_CHANNEL_DMA_CLASS, &nv10_fifo_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - basically just the instmem reserved for the channel
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv10_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_fifo_context_ctor,
+                .dtor = _nouveau_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static int
+nv10_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv04_instmem_priv *imem = nv04_instmem(parent);
+        struct nv04_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 0, 31, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nouveau_ramht_ref(imem->ramht, &priv->ramht);
+        nouveau_gpuobj_ref(imem->ramro, &priv->ramro);
+        nouveau_gpuobj_ref(imem->ramfc, &priv->ramfc);
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nv04_fifo_intr;
+        nv_engine(priv)->cclass = &nv10_fifo_cclass;
+        nv_engine(priv)->sclass = nv10_fifo_sclass;
+        priv->base.pause = nv04_fifo_pause;
+        priv->base.start = nv04_fifo_start;
+        priv->ramfc_desc = nv10_ramfc;
+        return 0;
+}
+
+struct nouveau_oclass
+nv10_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_fifo_ctor,
+                .dtor = nv04_fifo_dtor,
+                .init = nv04_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv17.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv17.c
new file mode 100644
index 000000000000..b96e6b0ae2b1
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv17.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/ramht.h>
+
+#include <subdev/instmem.h>
+#include <subdev/instmem/nv04.h>
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+
+#include "nv04.h"
+
+static struct ramfc_desc
+nv17_ramfc[] = {
+        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
+        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
+        { 32,  0, 0x08,  0, NV10_PFIFO_CACHE1_REF_CNT },
+        { 16,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
+        { 16, 16, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
+        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_STATE },
+        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
+        { 32,  0, 0x18,  0, NV04_PFIFO_CACHE1_ENGINE },
+        { 32,  0, 0x1c,  0, NV04_PFIFO_CACHE1_PULL1 },
+        { 32,  0, 0x20,  0, NV10_PFIFO_CACHE1_ACQUIRE_VALUE },
+        { 32,  0, 0x24,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMESTAMP },
+        { 32,  0, 0x28,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMEOUT },
+        { 32,  0, 0x2c,  0, NV10_PFIFO_CACHE1_SEMAPHORE },
+        { 32,  0, 0x30,  0, NV10_PFIFO_CACHE1_DMA_SUBROUTINE },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+static int
+nv17_fifo_chan_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nv04_fifo_priv *priv = (void *)engine;
+        struct nv04_fifo_chan *chan;
+        struct nv03_channel_dma_class *args = data;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0x800000,
+                                          0x10000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_MPEG), /* NV31- */
+                                          &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->object_attach = nv04_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv04_fifo_object_detach;
+        nv_parent(chan)->context_attach = nv04_fifo_context_attach;
+        chan->ramfc = chan->base.chid * 64;
+
+        nv_wo32(priv->ramfc, chan->ramfc + 0x00, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x04, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x0c, chan->base.pushgpu->addr >> 4);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x14,
+                             NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
+                             NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
+#ifdef __BIG_ENDIAN
+                             NV_PFIFO_CACHE1_BIG_ENDIAN |
+#endif
+                             NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv17_fifo_ofuncs = {
+        .ctor = nv17_fifo_chan_ctor,
+        .dtor = nv04_fifo_chan_dtor,
+        .init = nv04_fifo_chan_init,
+        .fini = nv04_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nv17_fifo_sclass[] = {
+        { NV17_CHANNEL_DMA_CLASS, &nv17_fifo_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - basically just the instmem reserved for the channel
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv17_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0x17),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_fifo_context_ctor,
+                .dtor = _nouveau_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static int
+nv17_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv04_instmem_priv *imem = nv04_instmem(parent);
+        struct nv04_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 0, 31, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nouveau_ramht_ref(imem->ramht, &priv->ramht);
+        nouveau_gpuobj_ref(imem->ramro, &priv->ramro);
+        nouveau_gpuobj_ref(imem->ramfc, &priv->ramfc);
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nv04_fifo_intr;
+        nv_engine(priv)->cclass = &nv17_fifo_cclass;
+        nv_engine(priv)->sclass = nv17_fifo_sclass;
+        priv->base.pause = nv04_fifo_pause;
+        priv->base.start = nv04_fifo_start;
+        priv->ramfc_desc = nv17_ramfc;
+        return 0;
+}
+
+static int
+nv17_fifo_init(struct nouveau_object *object)
+{
+        struct nv04_fifo_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_fifo_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, NV04_PFIFO_DELAY_0, 0x000000ff);
+        nv_wr32(priv, NV04_PFIFO_DMA_TIMESLICE, 0x0101ffff);
+
+        nv_wr32(priv, NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ |
+                                       ((priv->ramht->bits - 9) << 16) |
+                                        (priv->ramht->base.addr >> 8));
+        nv_wr32(priv, NV03_PFIFO_RAMRO, priv->ramro->addr >> 8);
+        nv_wr32(priv, NV03_PFIFO_RAMFC, priv->ramfc->addr >> 8 | 0x00010000);
+
+        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH1, priv->base.max);
+
+        nv_wr32(priv, NV03_PFIFO_INTR_0, 0xffffffff);
+        nv_wr32(priv, NV03_PFIFO_INTR_EN_0, 0xffffffff);
+
+        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0, 1);
+        nv_wr32(priv, NV04_PFIFO_CACHE1_PULL0, 1);
+        nv_wr32(priv, NV03_PFIFO_CACHES, 1);
+        return 0;
+}
+
+struct nouveau_oclass
+nv17_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0x17),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv17_fifo_ctor,
+                .dtor = nv04_fifo_dtor,
+                .init = nv17_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv40.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv40.c
new file mode 100644
index 000000000000..559c3b4e1b86
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv40.c
@@ -0,0 +1,349 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/ramht.h>
+
+#include <subdev/instmem.h>
+#include <subdev/instmem/nv04.h>
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+
+#include "nv04.h"
+
+static struct ramfc_desc
+nv40_ramfc[] = {
+        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
+        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
+        { 32,  0, 0x08,  0, NV10_PFIFO_CACHE1_REF_CNT },
+        { 32,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
+        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
+        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_DMA_STATE },
+        { 28,  0, 0x18,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
+        {  2, 28, 0x18, 28, 0x002058 },
+        { 32,  0, 0x1c,  0, NV04_PFIFO_CACHE1_ENGINE },
+        { 32,  0, 0x20,  0, NV04_PFIFO_CACHE1_PULL1 },
+        { 32,  0, 0x24,  0, NV10_PFIFO_CACHE1_ACQUIRE_VALUE },
+        { 32,  0, 0x28,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMESTAMP },
+        { 32,  0, 0x2c,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMEOUT },
+        { 32,  0, 0x30,  0, NV10_PFIFO_CACHE1_SEMAPHORE },
+        { 32,  0, 0x34,  0, NV10_PFIFO_CACHE1_DMA_SUBROUTINE },
+        { 32,  0, 0x38,  0, NV40_PFIFO_GRCTX_INSTANCE },
+        { 17,  0, 0x3c,  0, NV04_PFIFO_DMA_TIMESLICE },
+        { 32,  0, 0x40,  0, 0x0032e4 },
+        { 32,  0, 0x44,  0, 0x0032e8 },
+        { 32,  0, 0x4c,  0, 0x002088 },
+        { 32,  0, 0x50,  0, 0x003300 },
+        { 32,  0, 0x54,  0, 0x00330c },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+static int
+nv40_fifo_object_attach(struct nouveau_object *parent,
+                        struct nouveau_object *object, u32 handle)
+{
+        struct nv04_fifo_priv *priv = (void *)parent->engine;
+        struct nv04_fifo_chan *chan = (void *)parent;
+        u32 context, chid = chan->base.chid;
+        int ret;
+
+        if (nv_iclass(object, NV_GPUOBJ_CLASS))
+                context = nv_gpuobj(object)->addr >> 4;
+        else
+                context = 0x00000004; /* just non-zero */
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_DMAOBJ:
+        case NVDEV_ENGINE_SW:
+                context |= 0x00000000;
+                break;
+        case NVDEV_ENGINE_GR:
+                context |= 0x00100000;
+                break;
+        case NVDEV_ENGINE_MPEG:
+                context |= 0x00200000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        context |= chid << 23;
+
+        mutex_lock(&nv_subdev(priv)->mutex);
+        ret = nouveau_ramht_insert(priv->ramht, chid, handle, context);
+        mutex_unlock(&nv_subdev(priv)->mutex);
+        return ret;
+}
+
+static int
+nv40_fifo_context_attach(struct nouveau_object *parent,
+                         struct nouveau_object *engctx)
+{
+        struct nv04_fifo_priv *priv = (void *)parent->engine;
+        struct nv04_fifo_chan *chan = (void *)parent;
+        unsigned long flags;
+        u32 reg, ctx;
+
+        switch (nv_engidx(engctx->engine)) {
+        case NVDEV_ENGINE_SW:
+                return 0;
+        case NVDEV_ENGINE_GR:
+                reg = 0x32e0;
+                ctx = 0x38;
+                break;
+        case NVDEV_ENGINE_MPEG:
+                reg = 0x330c;
+                ctx = 0x54;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        nv_engctx(engctx)->addr = nv_gpuobj(engctx)->addr >> 4;
+        nv_mask(priv, 0x002500, 0x00000001, 0x00000000);
+
+        if ((nv_rd32(priv, 0x003204) & priv->base.max) == chan->base.chid)
+                nv_wr32(priv, reg, nv_engctx(engctx)->addr);
+        nv_wo32(priv->ramfc, chan->ramfc + ctx, nv_engctx(engctx)->addr);
+
+        nv_mask(priv, 0x002500, 0x00000001, 0x00000001);
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+        return 0;
+}
+
+static int
+nv40_fifo_context_detach(struct nouveau_object *parent, bool suspend,
+                         struct nouveau_object *engctx)
+{
+        struct nv04_fifo_priv *priv = (void *)parent->engine;
+        struct nv04_fifo_chan *chan = (void *)parent;
+        unsigned long flags;
+        u32 reg, ctx;
+
+        switch (nv_engidx(engctx->engine)) {
+        case NVDEV_ENGINE_SW:
+                return 0;
+        case NVDEV_ENGINE_GR:
+                reg = 0x32e0;
+                ctx = 0x38;
+                break;
+        case NVDEV_ENGINE_MPEG:
+                reg = 0x330c;
+                ctx = 0x54;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        nv_mask(priv, 0x002500, 0x00000001, 0x00000000);
+
+        if ((nv_rd32(priv, 0x003204) & priv->base.max) == chan->base.chid)
+                nv_wr32(priv, reg, 0x00000000);
+        nv_wo32(priv->ramfc, chan->ramfc + ctx, 0x00000000);
+
+        nv_mask(priv, 0x002500, 0x00000001, 0x00000001);
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+        return 0;
+}
+
+static int
+nv40_fifo_chan_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nv04_fifo_priv *priv = (void *)engine;
+        struct nv04_fifo_chan *chan;
+        struct nv03_channel_dma_class *args = data;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0xc00000,
+                                          0x1000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_MPEG), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nv40_fifo_context_attach;
+        nv_parent(chan)->context_detach = nv40_fifo_context_detach;
+        nv_parent(chan)->object_attach = nv40_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv04_fifo_object_detach;
+        chan->ramfc = chan->base.chid * 128;
+
+        nv_wo32(priv->ramfc, chan->ramfc + 0x00, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x04, args->offset);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x0c, chan->base.pushgpu->addr >> 4);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x18, 0x30000000 |
+                             NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
+                             NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
+#ifdef __BIG_ENDIAN
+                             NV_PFIFO_CACHE1_BIG_ENDIAN |
+#endif
+                             NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
+        nv_wo32(priv->ramfc, chan->ramfc + 0x3c, 0x0001ffff);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv40_fifo_ofuncs = {
+        .ctor = nv40_fifo_chan_ctor,
+        .dtor = nv04_fifo_chan_dtor,
+        .init = nv04_fifo_chan_init,
+        .fini = nv04_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nv40_fifo_sclass[] = {
+        { NV40_CHANNEL_DMA_CLASS, &nv40_fifo_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - basically just the instmem reserved for the channel
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv40_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_fifo_context_ctor,
+                .dtor = _nouveau_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static int
+nv40_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv04_instmem_priv *imem = nv04_instmem(parent);
+        struct nv04_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 0, 31, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nouveau_ramht_ref(imem->ramht, &priv->ramht);
+        nouveau_gpuobj_ref(imem->ramro, &priv->ramro);
+        nouveau_gpuobj_ref(imem->ramfc, &priv->ramfc);
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nv04_fifo_intr;
+        nv_engine(priv)->cclass = &nv40_fifo_cclass;
+        nv_engine(priv)->sclass = nv40_fifo_sclass;
+        priv->base.pause = nv04_fifo_pause;
+        priv->base.start = nv04_fifo_start;
+        priv->ramfc_desc = nv40_ramfc;
+        return 0;
+}
+
+static int
+nv40_fifo_init(struct nouveau_object *object)
+{
+        struct nv04_fifo_priv *priv = (void *)object;
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        int ret;
+
+        ret = nouveau_fifo_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x002040, 0x000000ff);
+        nv_wr32(priv, 0x002044, 0x2101ffff);
+        nv_wr32(priv, 0x002058, 0x00000001);
+
+        nv_wr32(priv, NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ |
+                                       ((priv->ramht->bits - 9) << 16) |
+                                        (priv->ramht->base.addr >> 8));
+        nv_wr32(priv, NV03_PFIFO_RAMRO, priv->ramro->addr >> 8);
+
+        switch (nv_device(priv)->chipset) {
+        case 0x47:
+        case 0x49:
+        case 0x4b:
+                nv_wr32(priv, 0x002230, 0x00000001);
+        case 0x40:
+        case 0x41:
+        case 0x42:
+        case 0x43:
+        case 0x45:
+        case 0x48:
+                nv_wr32(priv, 0x002220, 0x00030002);
+                break;
+        default:
+                nv_wr32(priv, 0x002230, 0x00000000);
+                nv_wr32(priv, 0x002220, ((pfb->ram.size - 512 * 1024 +
+                                         priv->ramfc->addr) >> 16) |
+                                        0x00030000);
+                break;
+        }
+
+        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH1, priv->base.max);
+
+        nv_wr32(priv, NV03_PFIFO_INTR_0, 0xffffffff);
+        nv_wr32(priv, NV03_PFIFO_INTR_EN_0, 0xffffffff);
+
+        nv_wr32(priv, NV03_PFIFO_CACHE1_PUSH0, 1);
+        nv_wr32(priv, NV04_PFIFO_CACHE1_PULL0, 1);
+        nv_wr32(priv, NV03_PFIFO_CACHES, 1);
+        return 0;
+}
+
+struct nouveau_oclass
+nv40_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_fifo_ctor,
+                .dtor = nv04_fifo_dtor,
+                .init = nv40_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv50.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv50.c
new file mode 100644
index 000000000000..536e7634a00d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv50.c
@@ -0,0 +1,502 @@
+/*
+ * Copyright 2012 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 <core/client.h>
+#include <core/engctx.h>
+#include <core/ramht.h>
+#include <core/class.h>
+#include <core/math.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+
+#include "nv50.h"
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+void
+nv50_fifo_playlist_update(struct nv50_fifo_priv *priv)
+{
+        struct nouveau_bar *bar = nouveau_bar(priv);
+        struct nouveau_gpuobj *cur;
+        int i, p;
+
+        cur = priv->playlist[priv->cur_playlist];
+        priv->cur_playlist = !priv->cur_playlist;
+
+        for (i = priv->base.min, p = 0; i < priv->base.max; i++) {
+                if (nv_rd32(priv, 0x002600 + (i * 4)) & 0x80000000)
+                        nv_wo32(cur, p++ * 4, i);
+        }
+
+        bar->flush(bar);
+
+        nv_wr32(priv, 0x0032f4, cur->addr >> 12);
+        nv_wr32(priv, 0x0032ec, p);
+        nv_wr32(priv, 0x002500, 0x00000101);
+}
+
+static int
+nv50_fifo_context_attach(struct nouveau_object *parent,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_base *base = (void *)parent->parent;
+        struct nouveau_gpuobj *ectx = (void *)object;
+        u64 limit = ectx->addr + ectx->size - 1;
+        u64 start = ectx->addr;
+        u32 addr;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   : addr = 0x0000; break;
+        case NVDEV_ENGINE_MPEG : addr = 0x0060; break;
+        default:
+                return -EINVAL;
+        }
+
+        nv_engctx(ectx)->addr = nv_gpuobj(base)->addr >> 12;
+        nv_wo32(base->eng, addr + 0x00, 0x00190000);
+        nv_wo32(base->eng, addr + 0x04, lower_32_bits(limit));
+        nv_wo32(base->eng, addr + 0x08, lower_32_bits(start));
+        nv_wo32(base->eng, addr + 0x0c, upper_32_bits(limit) << 24 |
+                                        upper_32_bits(start));
+        nv_wo32(base->eng, addr + 0x10, 0x00000000);
+        nv_wo32(base->eng, addr + 0x14, 0x00000000);
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nv50_fifo_context_detach(struct nouveau_object *parent, bool suspend,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_priv *priv = (void *)parent->engine;
+        struct nv50_fifo_base *base = (void *)parent->parent;
+        struct nv50_fifo_chan *chan = (void *)parent;
+        u32 addr, me;
+        int ret = 0;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   : addr = 0x0000; break;
+        case NVDEV_ENGINE_MPEG : addr = 0x0060; break;
+        default:
+                return -EINVAL;
+        }
+
+        nv_wo32(base->eng, addr + 0x00, 0x00000000);
+        nv_wo32(base->eng, addr + 0x04, 0x00000000);
+        nv_wo32(base->eng, addr + 0x08, 0x00000000);
+        nv_wo32(base->eng, addr + 0x0c, 0x00000000);
+        nv_wo32(base->eng, addr + 0x10, 0x00000000);
+        nv_wo32(base->eng, addr + 0x14, 0x00000000);
+        bar->flush(bar);
+
+        /* HW bug workaround:
+         *
+         * PFIFO will hang forever if the connected engines don't report
+         * that they've processed the context switch request.
+         *
+         * In order for the kickoff to work, we need to ensure all the
+         * connected engines are in a state where they can answer.
+         *
+         * Newer chipsets don't seem to suffer from this issue, and well,
+         * there's also a "ignore these engines" bitmask reg we can use
+         * if we hit the issue there..
+         */
+        me = nv_mask(priv, 0x00b860, 0x00000001, 0x00000001);
+
+        /* do the kickoff... */
+        nv_wr32(priv, 0x0032fc, nv_gpuobj(base)->addr >> 12);
+        if (!nv_wait_ne(priv, 0x0032fc, 0xffffffff, 0xffffffff)) {
+                nv_error(priv, "channel %d unload timeout\n", chan->base.chid);
+                if (suspend)
+                        ret = -EBUSY;
+        }
+
+        nv_wr32(priv, 0x00b860, me);
+        return ret;
+}
+
+static int
+nv50_fifo_object_attach(struct nouveau_object *parent,
+                        struct nouveau_object *object, u32 handle)
+{
+        struct nv50_fifo_chan *chan = (void *)parent;
+        u32 context;
+
+        if (nv_iclass(object, NV_GPUOBJ_CLASS))
+                context = nv_gpuobj(object)->node->offset >> 4;
+        else
+                context = 0x00000004; /* just non-zero */
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_DMAOBJ:
+        case NVDEV_ENGINE_SW    : context |= 0x00000000; break;
+        case NVDEV_ENGINE_GR    : context |= 0x00100000; break;
+        case NVDEV_ENGINE_MPEG  : context |= 0x00200000; break;
+        default:
+                return -EINVAL;
+        }
+
+        return nouveau_ramht_insert(chan->ramht, 0, handle, context);
+}
+
+void
+nv50_fifo_object_detach(struct nouveau_object *parent, int cookie)
+{
+        struct nv50_fifo_chan *chan = (void *)parent;
+        nouveau_ramht_remove(chan->ramht, cookie);
+}
+
+static int
+nv50_fifo_chan_ctor_dma(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_base *base = (void *)parent;
+        struct nv50_fifo_chan *chan;
+        struct nv03_channel_dma_class *args = data;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0xc00000,
+                                          0x2000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_MPEG), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nv50_fifo_context_attach;
+        nv_parent(chan)->context_detach = nv50_fifo_context_detach;
+        nv_parent(chan)->object_attach = nv50_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv50_fifo_object_detach;
+
+        ret = nouveau_ramht_new(parent, parent, 0x8000, 16, &chan->ramht);
+        if (ret)
+                return ret;
+
+        nv_wo32(base->ramfc, 0x08, lower_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x0c, upper_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x10, lower_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x14, upper_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x3c, 0x003f6078);
+        nv_wo32(base->ramfc, 0x44, 0x01003fff);
+        nv_wo32(base->ramfc, 0x48, chan->base.pushgpu->node->offset >> 4);
+        nv_wo32(base->ramfc, 0x4c, 0xffffffff);
+        nv_wo32(base->ramfc, 0x60, 0x7fffffff);
+        nv_wo32(base->ramfc, 0x78, 0x00000000);
+        nv_wo32(base->ramfc, 0x7c, 0x30000001);
+        nv_wo32(base->ramfc, 0x80, ((chan->ramht->bits - 9) << 27) |
+                                   (4 << 24) /* SEARCH_FULL */ |
+                                   (chan->ramht->base.node->offset >> 4));
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nv50_fifo_chan_ctor_ind(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv50_channel_ind_class *args = data;
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_base *base = (void *)parent;
+        struct nv50_fifo_chan *chan;
+        u64 ioffset, ilength;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0xc00000,
+                                          0x2000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_MPEG), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nv50_fifo_context_attach;
+        nv_parent(chan)->context_detach = nv50_fifo_context_detach;
+        nv_parent(chan)->object_attach = nv50_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv50_fifo_object_detach;
+
+        ret = nouveau_ramht_new(parent, parent, 0x8000, 16, &chan->ramht);
+        if (ret)
+                return ret;
+
+        ioffset = args->ioffset;
+        ilength = log2i(args->ilength / 8);
+
+        nv_wo32(base->ramfc, 0x3c, 0x403f6078);
+        nv_wo32(base->ramfc, 0x44, 0x01003fff);
+        nv_wo32(base->ramfc, 0x48, chan->base.pushgpu->node->offset >> 4);
+        nv_wo32(base->ramfc, 0x50, lower_32_bits(ioffset));
+        nv_wo32(base->ramfc, 0x54, upper_32_bits(ioffset) | (ilength << 16));
+        nv_wo32(base->ramfc, 0x60, 0x7fffffff);
+        nv_wo32(base->ramfc, 0x78, 0x00000000);
+        nv_wo32(base->ramfc, 0x7c, 0x30000001);
+        nv_wo32(base->ramfc, 0x80, ((chan->ramht->bits - 9) << 27) |
+                                   (4 << 24) /* SEARCH_FULL */ |
+                                   (chan->ramht->base.node->offset >> 4));
+        bar->flush(bar);
+        return 0;
+}
+
+void
+nv50_fifo_chan_dtor(struct nouveau_object *object)
+{
+        struct nv50_fifo_chan *chan = (void *)object;
+        nouveau_ramht_ref(NULL, &chan->ramht);
+        nouveau_fifo_channel_destroy(&chan->base);
+}
+
+static int
+nv50_fifo_chan_init(struct nouveau_object *object)
+{
+        struct nv50_fifo_priv *priv = (void *)object->engine;
+        struct nv50_fifo_base *base = (void *)object->parent;
+        struct nv50_fifo_chan *chan = (void *)object;
+        struct nouveau_gpuobj *ramfc = base->ramfc;
+        u32 chid = chan->base.chid;
+        int ret;
+
+        ret = nouveau_fifo_channel_init(&chan->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x002600 + (chid * 4), 0x80000000 | ramfc->addr >> 12);
+        nv50_fifo_playlist_update(priv);
+        return 0;
+}
+
+int
+nv50_fifo_chan_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv50_fifo_priv *priv = (void *)object->engine;
+        struct nv50_fifo_chan *chan = (void *)object;
+        u32 chid = chan->base.chid;
+
+        /* remove channel from playlist, fifo will unload context */
+        nv_mask(priv, 0x002600 + (chid * 4), 0x80000000, 0x00000000);
+        nv50_fifo_playlist_update(priv);
+        nv_wr32(priv, 0x002600 + (chid * 4), 0x00000000);
+
+        return nouveau_fifo_channel_fini(&chan->base, suspend);
+}
+
+static struct nouveau_ofuncs
+nv50_fifo_ofuncs_dma = {
+        .ctor = nv50_fifo_chan_ctor_dma,
+        .dtor = nv50_fifo_chan_dtor,
+        .init = nv50_fifo_chan_init,
+        .fini = nv50_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_ofuncs
+nv50_fifo_ofuncs_ind = {
+        .ctor = nv50_fifo_chan_ctor_ind,
+        .dtor = nv50_fifo_chan_dtor,
+        .init = nv50_fifo_chan_init,
+        .fini = nv50_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nv50_fifo_sclass[] = {
+        { NV50_CHANNEL_DMA_CLASS, &nv50_fifo_ofuncs_dma },
+        { NV50_CHANNEL_IND_CLASS, &nv50_fifo_ofuncs_ind },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - basically just the instmem reserved for the channel
+ ******************************************************************************/
+
+static int
+nv50_fifo_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nv50_fifo_base *base;
+        int ret;
+
+        ret = nouveau_fifo_context_create(parent, engine, oclass, NULL, 0x10000,
+                                          0x1000, NVOBJ_FLAG_HEAP, &base);
+        *pobject = nv_object(base);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x0200, 0x1000,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &base->ramfc);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x1200, 0,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &base->eng);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x4000, 0, 0,
+                                &base->pgd);
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_ref(nouveau_client(parent)->vm, &base->vm, base->pgd);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+void
+nv50_fifo_context_dtor(struct nouveau_object *object)
+{
+        struct nv50_fifo_base *base = (void *)object;
+        nouveau_vm_ref(NULL, &base->vm, base->pgd);
+        nouveau_gpuobj_ref(NULL, &base->pgd);
+        nouveau_gpuobj_ref(NULL, &base->eng);
+        nouveau_gpuobj_ref(NULL, &base->ramfc);
+        nouveau_gpuobj_ref(NULL, &base->cache);
+        nouveau_fifo_context_destroy(&base->base);
+}
+
+static struct nouveau_oclass
+nv50_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_fifo_context_ctor,
+                .dtor = nv50_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static int
+nv50_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv50_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 1, 127, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 128 * 4, 0x1000, 0,
+                                &priv->playlist[0]);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 128 * 4, 0x1000, 0,
+                                &priv->playlist[1]);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nv04_fifo_intr;
+        nv_engine(priv)->cclass = &nv50_fifo_cclass;
+        nv_engine(priv)->sclass = nv50_fifo_sclass;
+        return 0;
+}
+
+void
+nv50_fifo_dtor(struct nouveau_object *object)
+{
+        struct nv50_fifo_priv *priv = (void *)object;
+
+        nouveau_gpuobj_ref(NULL, &priv->playlist[1]);
+        nouveau_gpuobj_ref(NULL, &priv->playlist[0]);
+
+        nouveau_fifo_destroy(&priv->base);
+}
+
+int
+nv50_fifo_init(struct nouveau_object *object)
+{
+        struct nv50_fifo_priv *priv = (void *)object;
+        int ret, i;
+
+        ret = nouveau_fifo_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_mask(priv, 0x000200, 0x00000100, 0x00000000);
+        nv_mask(priv, 0x000200, 0x00000100, 0x00000100);
+        nv_wr32(priv, 0x00250c, 0x6f3cfc34);
+        nv_wr32(priv, 0x002044, 0x01003fff);
+
+        nv_wr32(priv, 0x002100, 0xffffffff);
+        nv_wr32(priv, 0x002140, 0xffffffff);
+
+        for (i = 0; i < 128; i++)
+                nv_wr32(priv, 0x002600 + (i * 4), 0x00000000);
+        nv50_fifo_playlist_update(priv);
+
+        nv_wr32(priv, 0x003200, 0x00000001);
+        nv_wr32(priv, 0x003250, 0x00000001);
+        nv_wr32(priv, 0x002500, 0x00000001);
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_fifo_ctor,
+                .dtor = nv50_fifo_dtor,
+                .init = nv50_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv50.h b/drivers/gpu/drm/nouveau/core/engine/fifo/nv50.h
new file mode 100644
index 000000000000..3a9ceb315c20
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv50.h
@@ -0,0 +1,36 @@
+#ifndef __NV50_FIFO_H__
+#define __NV50_FIFO_H__
+
+struct nv50_fifo_priv {
+        struct nouveau_fifo base;
+        struct nouveau_gpuobj *playlist[2];
+        int cur_playlist;
+};
+
+struct nv50_fifo_base {
+        struct nouveau_fifo_base base;
+        struct nouveau_gpuobj *ramfc;
+        struct nouveau_gpuobj *cache;
+        struct nouveau_gpuobj *eng;
+        struct nouveau_gpuobj *pgd;
+        struct nouveau_vm *vm;
+};
+
+struct nv50_fifo_chan {
+        struct nouveau_fifo_chan base;
+        u32 subc[8];
+        struct nouveau_ramht *ramht;
+};
+
+void nv50_fifo_playlist_update(struct nv50_fifo_priv *);
+
+void nv50_fifo_object_detach(struct nouveau_object *, int);
+void nv50_fifo_chan_dtor(struct nouveau_object *);
+int  nv50_fifo_chan_fini(struct nouveau_object *, bool);
+
+void nv50_fifo_context_dtor(struct nouveau_object *);
+
+void nv50_fifo_dtor(struct nouveau_object *);
+int  nv50_fifo_init(struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nv84.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nv84.c
new file mode 100644
index 000000000000..b4fd26d8f166
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nv84.c
@@ -0,0 +1,420 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/client.h>
+#include <core/engctx.h>
+#include <core/ramht.h>
+#include <core/class.h>
+#include <core/math.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+
+#include "nv50.h"
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+static int
+nv84_fifo_context_attach(struct nouveau_object *parent,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_base *base = (void *)parent->parent;
+        struct nouveau_gpuobj *ectx = (void *)object;
+        u64 limit = ectx->addr + ectx->size - 1;
+        u64 start = ectx->addr;
+        u32 addr;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   : addr = 0x0020; break;
+        case NVDEV_ENGINE_MPEG : addr = 0x0060; break;
+        case NVDEV_ENGINE_CRYPT: addr = 0x00a0; break;
+        case NVDEV_ENGINE_COPY0: addr = 0x00c0; break;
+        default:
+                return -EINVAL;
+        }
+
+        nv_engctx(ectx)->addr = nv_gpuobj(base)->addr >> 12;
+        nv_wo32(base->eng, addr + 0x00, 0x00190000);
+        nv_wo32(base->eng, addr + 0x04, lower_32_bits(limit));
+        nv_wo32(base->eng, addr + 0x08, lower_32_bits(start));
+        nv_wo32(base->eng, addr + 0x0c, upper_32_bits(limit) << 24 |
+                                        upper_32_bits(start));
+        nv_wo32(base->eng, addr + 0x10, 0x00000000);
+        nv_wo32(base->eng, addr + 0x14, 0x00000000);
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nv84_fifo_context_detach(struct nouveau_object *parent, bool suspend,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_priv *priv = (void *)parent->engine;
+        struct nv50_fifo_base *base = (void *)parent->parent;
+        struct nv50_fifo_chan *chan = (void *)parent;
+        u32 addr, save, engn;
+        bool done;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   : engn = 0; addr = 0x0020; break;
+        case NVDEV_ENGINE_MPEG : engn = 1; addr = 0x0060; break;
+        case NVDEV_ENGINE_CRYPT: engn = 4; addr = 0x00a0; break;
+        case NVDEV_ENGINE_COPY0: engn = 2; addr = 0x00c0; break;
+        default:
+                return -EINVAL;
+        }
+
+        nv_wo32(base->eng, addr + 0x00, 0x00000000);
+        nv_wo32(base->eng, addr + 0x04, 0x00000000);
+        nv_wo32(base->eng, addr + 0x08, 0x00000000);
+        nv_wo32(base->eng, addr + 0x0c, 0x00000000);
+        nv_wo32(base->eng, addr + 0x10, 0x00000000);
+        nv_wo32(base->eng, addr + 0x14, 0x00000000);
+        bar->flush(bar);
+
+        save = nv_mask(priv, 0x002520, 0x0000003f, 1 << engn);
+        nv_wr32(priv, 0x0032fc, nv_gpuobj(base)->addr >> 12);
+        done = nv_wait_ne(priv, 0x0032fc, 0xffffffff, 0xffffffff);
+        nv_wr32(priv, 0x002520, save);
+        if (!done) {
+                nv_error(priv, "channel %d unload timeout\n", chan->base.chid);
+                if (suspend)
+                        return -EBUSY;
+        }
+        return 0;
+}
+
+static int
+nv84_fifo_object_attach(struct nouveau_object *parent,
+                        struct nouveau_object *object, u32 handle)
+{
+        struct nv50_fifo_chan *chan = (void *)parent;
+        u32 context;
+
+        if (nv_iclass(object, NV_GPUOBJ_CLASS))
+                context = nv_gpuobj(object)->node->offset >> 4;
+        else
+                context = 0x00000004; /* just non-zero */
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_DMAOBJ:
+        case NVDEV_ENGINE_SW    : context |= 0x00000000; break;
+        case NVDEV_ENGINE_GR    : context |= 0x00100000; break;
+        case NVDEV_ENGINE_MPEG  :
+        case NVDEV_ENGINE_PPP   : context |= 0x00200000; break;
+        case NVDEV_ENGINE_ME    :
+        case NVDEV_ENGINE_COPY0 : context |= 0x00300000; break;
+        case NVDEV_ENGINE_VP    : context |= 0x00400000; break;
+        case NVDEV_ENGINE_CRYPT :
+        case NVDEV_ENGINE_UNK1C1: context |= 0x00500000; break;
+        case NVDEV_ENGINE_BSP   : context |= 0x00600000; break;
+        default:
+                return -EINVAL;
+        }
+
+        return nouveau_ramht_insert(chan->ramht, 0, handle, context);
+}
+
+static int
+nv84_fifo_chan_ctor_dma(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_base *base = (void *)parent;
+        struct nv50_fifo_chan *chan;
+        struct nv03_channel_dma_class *args = data;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0xc00000,
+                                          0x2000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_MPEG) |
+                                          (1 << NVDEV_ENGINE_ME) |
+                                          (1 << NVDEV_ENGINE_VP) |
+                                          (1 << NVDEV_ENGINE_CRYPT) |
+                                          (1 << NVDEV_ENGINE_BSP) |
+                                          (1 << NVDEV_ENGINE_PPP) |
+                                          (1 << NVDEV_ENGINE_COPY0) |
+                                          (1 << NVDEV_ENGINE_UNK1C1), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        ret = nouveau_ramht_new(parent, parent, 0x8000, 16, &chan->ramht);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nv84_fifo_context_attach;
+        nv_parent(chan)->context_detach = nv84_fifo_context_detach;
+        nv_parent(chan)->object_attach = nv84_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv50_fifo_object_detach;
+
+        nv_wo32(base->ramfc, 0x08, lower_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x0c, upper_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x10, lower_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x14, upper_32_bits(args->offset));
+        nv_wo32(base->ramfc, 0x3c, 0x003f6078);
+        nv_wo32(base->ramfc, 0x44, 0x01003fff);
+        nv_wo32(base->ramfc, 0x48, chan->base.pushgpu->node->offset >> 4);
+        nv_wo32(base->ramfc, 0x4c, 0xffffffff);
+        nv_wo32(base->ramfc, 0x60, 0x7fffffff);
+        nv_wo32(base->ramfc, 0x78, 0x00000000);
+        nv_wo32(base->ramfc, 0x7c, 0x30000001);
+        nv_wo32(base->ramfc, 0x80, ((chan->ramht->bits - 9) << 27) |
+                                   (4 << 24) /* SEARCH_FULL */ |
+                                   (chan->ramht->base.node->offset >> 4));
+        nv_wo32(base->ramfc, 0x88, base->cache->addr >> 10);
+        nv_wo32(base->ramfc, 0x98, nv_gpuobj(base)->addr >> 12);
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nv84_fifo_chan_ctor_ind(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_fifo_base *base = (void *)parent;
+        struct nv50_fifo_chan *chan;
+        struct nv50_channel_ind_class *args = data;
+        u64 ioffset, ilength;
+        int ret;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 0, 0xc00000,
+                                          0x2000, args->pushbuf,
+                                          (1 << NVDEV_ENGINE_DMAOBJ) |
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_MPEG) |
+                                          (1 << NVDEV_ENGINE_ME) |
+                                          (1 << NVDEV_ENGINE_VP) |
+                                          (1 << NVDEV_ENGINE_CRYPT) |
+                                          (1 << NVDEV_ENGINE_BSP) |
+                                          (1 << NVDEV_ENGINE_PPP) |
+                                          (1 << NVDEV_ENGINE_COPY0) |
+                                          (1 << NVDEV_ENGINE_UNK1C1), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        ret = nouveau_ramht_new(parent, parent, 0x8000, 16, &chan->ramht);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nv84_fifo_context_attach;
+        nv_parent(chan)->context_detach = nv84_fifo_context_detach;
+        nv_parent(chan)->object_attach = nv84_fifo_object_attach;
+        nv_parent(chan)->object_detach = nv50_fifo_object_detach;
+
+        ioffset = args->ioffset;
+        ilength = log2i(args->ilength / 8);
+
+        nv_wo32(base->ramfc, 0x3c, 0x403f6078);
+        nv_wo32(base->ramfc, 0x44, 0x01003fff);
+        nv_wo32(base->ramfc, 0x48, chan->base.pushgpu->node->offset >> 4);
+        nv_wo32(base->ramfc, 0x50, lower_32_bits(ioffset));
+        nv_wo32(base->ramfc, 0x54, upper_32_bits(ioffset) | (ilength << 16));
+        nv_wo32(base->ramfc, 0x60, 0x7fffffff);
+        nv_wo32(base->ramfc, 0x78, 0x00000000);
+        nv_wo32(base->ramfc, 0x7c, 0x30000001);
+        nv_wo32(base->ramfc, 0x80, ((chan->ramht->bits - 9) << 27) |
+                                   (4 << 24) /* SEARCH_FULL */ |
+                                   (chan->ramht->base.node->offset >> 4));
+        nv_wo32(base->ramfc, 0x88, base->cache->addr >> 10);
+        nv_wo32(base->ramfc, 0x98, nv_gpuobj(base)->addr >> 12);
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nv84_fifo_chan_init(struct nouveau_object *object)
+{
+        struct nv50_fifo_priv *priv = (void *)object->engine;
+        struct nv50_fifo_base *base = (void *)object->parent;
+        struct nv50_fifo_chan *chan = (void *)object;
+        struct nouveau_gpuobj *ramfc = base->ramfc;
+        u32 chid = chan->base.chid;
+        int ret;
+
+        ret = nouveau_fifo_channel_init(&chan->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x002600 + (chid * 4), 0x80000000 | ramfc->addr >> 8);
+        nv50_fifo_playlist_update(priv);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv84_fifo_ofuncs_dma = {
+        .ctor = nv84_fifo_chan_ctor_dma,
+        .dtor = nv50_fifo_chan_dtor,
+        .init = nv84_fifo_chan_init,
+        .fini = nv50_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_ofuncs
+nv84_fifo_ofuncs_ind = {
+        .ctor = nv84_fifo_chan_ctor_ind,
+        .dtor = nv50_fifo_chan_dtor,
+        .init = nv84_fifo_chan_init,
+        .fini = nv50_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nv84_fifo_sclass[] = {
+        { NV84_CHANNEL_DMA_CLASS, &nv84_fifo_ofuncs_dma },
+        { NV84_CHANNEL_IND_CLASS, &nv84_fifo_ofuncs_ind },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - basically just the instmem reserved for the channel
+ ******************************************************************************/
+
+static int
+nv84_fifo_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nv50_fifo_base *base;
+        int ret;
+
+        ret = nouveau_fifo_context_create(parent, engine, oclass, NULL, 0x10000,
+                                          0x1000, NVOBJ_FLAG_HEAP, &base);
+        *pobject = nv_object(base);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x0200, 0,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &base->eng);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x4000, 0,
+                                 0, &base->pgd);
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_ref(nouveau_client(parent)->vm, &base->vm, base->pgd);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x1000, 0x400,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &base->cache);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, nv_object(base), 0x0100, 0x100,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &base->ramfc);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nv84_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_fifo_context_ctor,
+                .dtor = nv50_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static int
+nv84_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv50_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 1, 127, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 128 * 4, 0x1000, 0,
+                                &priv->playlist[0]);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 128 * 4, 0x1000, 0,
+                                &priv->playlist[1]);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nv04_fifo_intr;
+        nv_engine(priv)->cclass = &nv84_fifo_cclass;
+        nv_engine(priv)->sclass = nv84_fifo_sclass;
+        return 0;
+}
+
+struct nouveau_oclass
+nv84_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_fifo_ctor,
+                .dtor = nv50_fifo_dtor,
+                .init = nv50_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c
new file mode 100644
index 000000000000..6f21be600557
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nvc0.c
@@ -0,0 +1,647 @@
+/*
+ * Copyright 2012 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 <core/client.h>
+#include <core/handle.h>
+#include <core/namedb.h>
+#include <core/gpuobj.h>
+#include <core/engctx.h>
+#include <core/class.h>
+#include <core/math.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+
+struct nvc0_fifo_priv {
+        struct nouveau_fifo base;
+        struct nouveau_gpuobj *playlist[2];
+        int cur_playlist;
+        struct {
+                struct nouveau_gpuobj *mem;
+                struct nouveau_vma bar;
+        } user;
+        int spoon_nr;
+};
+
+struct nvc0_fifo_base {
+        struct nouveau_fifo_base base;
+        struct nouveau_gpuobj *pgd;
+        struct nouveau_vm *vm;
+};
+
+struct nvc0_fifo_chan {
+        struct nouveau_fifo_chan base;
+};
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+static void
+nvc0_fifo_playlist_update(struct nvc0_fifo_priv *priv)
+{
+        struct nouveau_bar *bar = nouveau_bar(priv);
+        struct nouveau_gpuobj *cur;
+        int i, p;
+
+        cur = priv->playlist[priv->cur_playlist];
+        priv->cur_playlist = !priv->cur_playlist;
+
+        for (i = 0, p = 0; i < 128; i++) {
+                if (!(nv_rd32(priv, 0x003004 + (i * 8)) & 1))
+                        continue;
+                nv_wo32(cur, p + 0, i);
+                nv_wo32(cur, p + 4, 0x00000004);
+                p += 8;
+        }
+        bar->flush(bar);
+
+        nv_wr32(priv, 0x002270, cur->addr >> 12);
+        nv_wr32(priv, 0x002274, 0x01f00000 | (p >> 3));
+        if (!nv_wait(priv, 0x00227c, 0x00100000, 0x00000000))
+                nv_error(priv, "playlist update failed\n");
+}
+
+static int
+nvc0_fifo_context_attach(struct nouveau_object *parent,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nvc0_fifo_base *base = (void *)parent->parent;
+        struct nouveau_engctx *ectx = (void *)object;
+        u32 addr;
+        int ret;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   : addr = 0x0210; break;
+        case NVDEV_ENGINE_COPY0: addr = 0x0230; break;
+        case NVDEV_ENGINE_COPY1: addr = 0x0240; break;
+        default:
+                return -EINVAL;
+        }
+
+        if (!ectx->vma.node) {
+                ret = nouveau_gpuobj_map_vm(nv_gpuobj(ectx), base->vm,
+                                            NV_MEM_ACCESS_RW, &ectx->vma);
+                if (ret)
+                        return ret;
+
+                nv_engctx(ectx)->addr = nv_gpuobj(base)->addr >> 12;
+        }
+
+        nv_wo32(base, addr + 0x00, lower_32_bits(ectx->vma.offset) | 4);
+        nv_wo32(base, addr + 0x04, upper_32_bits(ectx->vma.offset));
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nvc0_fifo_context_detach(struct nouveau_object *parent, bool suspend,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nvc0_fifo_priv *priv = (void *)parent->engine;
+        struct nvc0_fifo_base *base = (void *)parent->parent;
+        struct nvc0_fifo_chan *chan = (void *)parent;
+        u32 addr;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   : addr = 0x0210; break;
+        case NVDEV_ENGINE_COPY0: addr = 0x0230; break;
+        case NVDEV_ENGINE_COPY1: addr = 0x0240; break;
+        default:
+                return -EINVAL;
+        }
+
+        nv_wo32(base, addr + 0x00, 0x00000000);
+        nv_wo32(base, addr + 0x04, 0x00000000);
+        bar->flush(bar);
+
+        nv_wr32(priv, 0x002634, chan->base.chid);
+        if (!nv_wait(priv, 0x002634, 0xffffffff, chan->base.chid)) {
+                nv_error(priv, "channel %d kick timeout\n", chan->base.chid);
+                if (suspend)
+                        return -EBUSY;
+        }
+
+        return 0;
+}
+
+static int
+nvc0_fifo_chan_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nvc0_fifo_priv *priv = (void *)engine;
+        struct nvc0_fifo_base *base = (void *)parent;
+        struct nvc0_fifo_chan *chan;
+        struct nv50_channel_ind_class *args = data;
+        u64 usermem, ioffset, ilength;
+        int ret, i;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 1,
+                                          priv->user.bar.offset, 0x1000,
+                                          args->pushbuf,
+                                          (1 << NVDEV_ENGINE_SW) |
+                                          (1 << NVDEV_ENGINE_GR) |
+                                          (1 << NVDEV_ENGINE_COPY0) |
+                                          (1 << NVDEV_ENGINE_COPY1), &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nvc0_fifo_context_attach;
+        nv_parent(chan)->context_detach = nvc0_fifo_context_detach;
+
+        usermem = chan->base.chid * 0x1000;
+        ioffset = args->ioffset;
+        ilength = log2i(args->ilength / 8);
+
+        for (i = 0; i < 0x1000; i += 4)
+                nv_wo32(priv->user.mem, usermem + i, 0x00000000);
+
+        nv_wo32(base, 0x08, lower_32_bits(priv->user.mem->addr + usermem));
+        nv_wo32(base, 0x0c, upper_32_bits(priv->user.mem->addr + usermem));
+        nv_wo32(base, 0x10, 0x0000face);
+        nv_wo32(base, 0x30, 0xfffff902);
+        nv_wo32(base, 0x48, lower_32_bits(ioffset));
+        nv_wo32(base, 0x4c, upper_32_bits(ioffset) | (ilength << 16));
+        nv_wo32(base, 0x54, 0x00000002);
+        nv_wo32(base, 0x84, 0x20400000);
+        nv_wo32(base, 0x94, 0x30000001);
+        nv_wo32(base, 0x9c, 0x00000100);
+        nv_wo32(base, 0xa4, 0x1f1f1f1f);
+        nv_wo32(base, 0xa8, 0x1f1f1f1f);
+        nv_wo32(base, 0xac, 0x0000001f);
+        nv_wo32(base, 0xb8, 0xf8000000);
+        nv_wo32(base, 0xf8, 0x10003080); /* 0x002310 */
+        nv_wo32(base, 0xfc, 0x10000010); /* 0x002350 */
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nvc0_fifo_chan_init(struct nouveau_object *object)
+{
+        struct nouveau_gpuobj *base = nv_gpuobj(object->parent);
+        struct nvc0_fifo_priv *priv = (void *)object->engine;
+        struct nvc0_fifo_chan *chan = (void *)object;
+        u32 chid = chan->base.chid;
+        int ret;
+
+        ret = nouveau_fifo_channel_init(&chan->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x003000 + (chid * 8), 0xc0000000 | base->addr >> 12);
+        nv_wr32(priv, 0x003004 + (chid * 8), 0x001f0001);
+        nvc0_fifo_playlist_update(priv);
+        return 0;
+}
+
+static int
+nvc0_fifo_chan_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nvc0_fifo_priv *priv = (void *)object->engine;
+        struct nvc0_fifo_chan *chan = (void *)object;
+        u32 chid = chan->base.chid;
+
+        nv_mask(priv, 0x003004 + (chid * 8), 0x00000001, 0x00000000);
+        nvc0_fifo_playlist_update(priv);
+        nv_wr32(priv, 0x003000 + (chid * 8), 0x00000000);
+
+        return nouveau_fifo_channel_fini(&chan->base, suspend);
+}
+
+static struct nouveau_ofuncs
+nvc0_fifo_ofuncs = {
+        .ctor = nvc0_fifo_chan_ctor,
+        .dtor = _nouveau_fifo_channel_dtor,
+        .init = nvc0_fifo_chan_init,
+        .fini = nvc0_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nvc0_fifo_sclass[] = {
+        { NVC0_CHANNEL_IND_CLASS, &nvc0_fifo_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - instmem heap and vm setup
+ ******************************************************************************/
+
+static int
+nvc0_fifo_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nvc0_fifo_base *base;
+        int ret;
+
+        ret = nouveau_fifo_context_create(parent, engine, oclass, NULL, 0x1000,
+                                          0x1000, NVOBJ_FLAG_ZERO_ALLOC |
+                                          NVOBJ_FLAG_HEAP, &base);
+        *pobject = nv_object(base);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x10000, 0x1000, 0, &base->pgd);
+        if (ret)
+                return ret;
+
+        nv_wo32(base, 0x0200, lower_32_bits(base->pgd->addr));
+        nv_wo32(base, 0x0204, upper_32_bits(base->pgd->addr));
+        nv_wo32(base, 0x0208, 0xffffffff);
+        nv_wo32(base, 0x020c, 0x000000ff);
+
+        ret = nouveau_vm_ref(nouveau_client(parent)->vm, &base->vm, base->pgd);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nvc0_fifo_context_dtor(struct nouveau_object *object)
+{
+        struct nvc0_fifo_base *base = (void *)object;
+        nouveau_vm_ref(NULL, &base->vm, base->pgd);
+        nouveau_gpuobj_ref(NULL, &base->pgd);
+        nouveau_fifo_context_destroy(&base->base);
+}
+
+static struct nouveau_oclass
+nvc0_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_fifo_context_ctor,
+                .dtor = nvc0_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static const struct nouveau_enum nvc0_fifo_fault_unit[] = {
+        { 0x00, "PGRAPH" },
+        { 0x03, "PEEPHOLE" },
+        { 0x04, "BAR1" },
+        { 0x05, "BAR3" },
+        { 0x07, "PFIFO" },
+        { 0x10, "PBSP" },
+        { 0x11, "PPPP" },
+        { 0x13, "PCOUNTER" },
+        { 0x14, "PVP" },
+        { 0x15, "PCOPY0" },
+        { 0x16, "PCOPY1" },
+        { 0x17, "PDAEMON" },
+        {}
+};
+
+static const struct nouveau_enum nvc0_fifo_fault_reason[] = {
+        { 0x00, "PT_NOT_PRESENT" },
+        { 0x01, "PT_TOO_SHORT" },
+        { 0x02, "PAGE_NOT_PRESENT" },
+        { 0x03, "VM_LIMIT_EXCEEDED" },
+        { 0x04, "NO_CHANNEL" },
+        { 0x05, "PAGE_SYSTEM_ONLY" },
+        { 0x06, "PAGE_READ_ONLY" },
+        { 0x0a, "COMPRESSED_SYSRAM" },
+        { 0x0c, "INVALID_STORAGE_TYPE" },
+        {}
+};
+
+static const struct nouveau_enum nvc0_fifo_fault_hubclient[] = {
+        { 0x01, "PCOPY0" },
+        { 0x02, "PCOPY1" },
+        { 0x04, "DISPATCH" },
+        { 0x05, "CTXCTL" },
+        { 0x06, "PFIFO" },
+        { 0x07, "BAR_READ" },
+        { 0x08, "BAR_WRITE" },
+        { 0x0b, "PVP" },
+        { 0x0c, "PPPP" },
+        { 0x0d, "PBSP" },
+        { 0x11, "PCOUNTER" },
+        { 0x12, "PDAEMON" },
+        { 0x14, "CCACHE" },
+        { 0x15, "CCACHE_POST" },
+        {}
+};
+
+static const struct nouveau_enum nvc0_fifo_fault_gpcclient[] = {
+        { 0x01, "TEX" },
+        { 0x0c, "ESETUP" },
+        { 0x0e, "CTXCTL" },
+        { 0x0f, "PROP" },
+        {}
+};
+
+static const struct nouveau_bitfield nvc0_fifo_subfifo_intr[] = {
+/*      { 0x00008000, "" }      seen with null ib push */
+        { 0x00200000, "ILLEGAL_MTHD" },
+        { 0x00800000, "EMPTY_SUBC" },
+        {}
+};
+
+static void
+nvc0_fifo_isr_vm_fault(struct nvc0_fifo_priv *priv, int unit)
+{
+        u32 inst = nv_rd32(priv, 0x002800 + (unit * 0x10));
+        u32 valo = nv_rd32(priv, 0x002804 + (unit * 0x10));
+        u32 vahi = nv_rd32(priv, 0x002808 + (unit * 0x10));
+        u32 stat = nv_rd32(priv, 0x00280c + (unit * 0x10));
+        u32 client = (stat & 0x00001f00) >> 8;
+
+        switch (unit) {
+        case 3: /* PEEPHOLE */
+                nv_mask(priv, 0x001718, 0x00000000, 0x00000000);
+                break;
+        case 4: /* BAR1 */
+                nv_mask(priv, 0x001704, 0x00000000, 0x00000000);
+                break;
+        case 5: /* BAR3 */
+                nv_mask(priv, 0x001714, 0x00000000, 0x00000000);
+                break;
+        default:
+                break;
+        }
+
+        nv_error(priv, "%s fault at 0x%010llx [", (stat & 0x00000080) ?
+                 "write" : "read", (u64)vahi << 32 | valo);
+        nouveau_enum_print(nvc0_fifo_fault_reason, stat & 0x0000000f);
+        printk("] from ");
+        nouveau_enum_print(nvc0_fifo_fault_unit, unit);
+        if (stat & 0x00000040) {
+                printk("/");
+                nouveau_enum_print(nvc0_fifo_fault_hubclient, client);
+        } else {
+                printk("/GPC%d/", (stat & 0x1f000000) >> 24);
+                nouveau_enum_print(nvc0_fifo_fault_gpcclient, client);
+        }
+        printk(" on channel 0x%010llx\n", (u64)inst << 12);
+}
+
+static int
+nvc0_fifo_swmthd(struct nvc0_fifo_priv *priv, u32 chid, u32 mthd, u32 data)
+{
+        struct nvc0_fifo_chan *chan = NULL;
+        struct nouveau_handle *bind;
+        unsigned long flags;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        if (likely(chid >= priv->base.min && chid <= priv->base.max))
+                chan = (void *)priv->base.channel[chid];
+        if (unlikely(!chan))
+                goto out;
+
+        bind = nouveau_namedb_get_class(nv_namedb(chan), 0x906e);
+        if (likely(bind)) {
+                if (!mthd || !nv_call(bind->object, mthd, data))
+                        ret = 0;
+                nouveau_namedb_put(bind);
+        }
+
+out:
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+        return ret;
+}
+
+static void
+nvc0_fifo_isr_subfifo_intr(struct nvc0_fifo_priv *priv, int unit)
+{
+        u32 stat = nv_rd32(priv, 0x040108 + (unit * 0x2000));
+        u32 addr = nv_rd32(priv, 0x0400c0 + (unit * 0x2000));
+        u32 data = nv_rd32(priv, 0x0400c4 + (unit * 0x2000));
+        u32 chid = nv_rd32(priv, 0x040120 + (unit * 0x2000)) & 0x7f;
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 mthd = (addr & 0x00003ffc);
+        u32 show = stat;
+
+        if (stat & 0x00200000) {
+                if (mthd == 0x0054) {
+                        if (!nvc0_fifo_swmthd(priv, chid, 0x0500, 0x00000000))
+                                show &= ~0x00200000;
+                }
+        }
+
+        if (stat & 0x00800000) {
+                if (!nvc0_fifo_swmthd(priv, chid, mthd, data))
+                        show &= ~0x00800000;
+        }
+
+        if (show) {
+                nv_error(priv, "SUBFIFO%d:", unit);
+                nouveau_bitfield_print(nvc0_fifo_subfifo_intr, show);
+                printk("\n");
+                nv_error(priv, "SUBFIFO%d: ch %d subc %d mthd 0x%04x "
+                               "data 0x%08x\n",
+                         unit, chid, subc, mthd, data);
+        }
+
+        nv_wr32(priv, 0x0400c0 + (unit * 0x2000), 0x80600008);
+        nv_wr32(priv, 0x040108 + (unit * 0x2000), stat);
+}
+
+static void
+nvc0_fifo_intr(struct nouveau_subdev *subdev)
+{
+        struct nvc0_fifo_priv *priv = (void *)subdev;
+        u32 mask = nv_rd32(priv, 0x002140);
+        u32 stat = nv_rd32(priv, 0x002100) & mask;
+
+        if (stat & 0x00000100) {
+                nv_info(priv, "unknown status 0x00000100\n");
+                nv_wr32(priv, 0x002100, 0x00000100);
+                stat &= ~0x00000100;
+        }
+
+        if (stat & 0x10000000) {
+                u32 units = nv_rd32(priv, 0x00259c);
+                u32 u = units;
+
+                while (u) {
+                        int i = ffs(u) - 1;
+                        nvc0_fifo_isr_vm_fault(priv, i);
+                        u &= ~(1 << i);
+                }
+
+                nv_wr32(priv, 0x00259c, units);
+                stat &= ~0x10000000;
+        }
+
+        if (stat & 0x20000000) {
+                u32 units = nv_rd32(priv, 0x0025a0);
+                u32 u = units;
+
+                while (u) {
+                        int i = ffs(u) - 1;
+                        nvc0_fifo_isr_subfifo_intr(priv, i);
+                        u &= ~(1 << i);
+                }
+
+                nv_wr32(priv, 0x0025a0, units);
+                stat &= ~0x20000000;
+        }
+
+        if (stat & 0x40000000) {
+                nv_warn(priv, "unknown status 0x40000000\n");
+                nv_mask(priv, 0x002a00, 0x00000000, 0x00000000);
+                stat &= ~0x40000000;
+        }
+
+        if (stat) {
+                nv_fatal(priv, "unhandled status 0x%08x\n", stat);
+                nv_wr32(priv, 0x002100, stat);
+                nv_wr32(priv, 0x002140, 0);
+        }
+}
+
+static int
+nvc0_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nvc0_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 0, 127, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 0x1000, 0,
+                                &priv->playlist[0]);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 0x1000, 0,
+                                &priv->playlist[1]);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 128 * 0x1000, 0x1000, 0,
+                                &priv->user.mem);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_map(priv->user.mem, NV_MEM_ACCESS_RW,
+                                &priv->user.bar);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nvc0_fifo_intr;
+        nv_engine(priv)->cclass = &nvc0_fifo_cclass;
+        nv_engine(priv)->sclass = nvc0_fifo_sclass;
+        return 0;
+}
+
+static void
+nvc0_fifo_dtor(struct nouveau_object *object)
+{
+        struct nvc0_fifo_priv *priv = (void *)object;
+
+        nouveau_gpuobj_unmap(&priv->user.bar);
+        nouveau_gpuobj_ref(NULL, &priv->user.mem);
+        nouveau_gpuobj_ref(NULL, &priv->playlist[1]);
+        nouveau_gpuobj_ref(NULL, &priv->playlist[0]);
+
+        nouveau_fifo_destroy(&priv->base);
+}
+
+static int
+nvc0_fifo_init(struct nouveau_object *object)
+{
+        struct nvc0_fifo_priv *priv = (void *)object;
+        int ret, i;
+
+        ret = nouveau_fifo_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x000204, 0xffffffff);
+        nv_wr32(priv, 0x002204, 0xffffffff);
+
+        priv->spoon_nr = hweight32(nv_rd32(priv, 0x002204));
+        nv_debug(priv, "%d subfifo(s)\n", priv->spoon_nr);
+
+        /* assign engines to subfifos */
+        if (priv->spoon_nr >= 3) {
+                nv_wr32(priv, 0x002208, ~(1 << 0)); /* PGRAPH */
+                nv_wr32(priv, 0x00220c, ~(1 << 1)); /* PVP */
+                nv_wr32(priv, 0x002210, ~(1 << 1)); /* PPP */
+                nv_wr32(priv, 0x002214, ~(1 << 1)); /* PBSP */
+                nv_wr32(priv, 0x002218, ~(1 << 2)); /* PCE0 */
+                nv_wr32(priv, 0x00221c, ~(1 << 1)); /* PCE1 */
+        }
+
+        /* PSUBFIFO[n] */
+        for (i = 0; i < priv->spoon_nr; i++) {
+                nv_mask(priv, 0x04013c + (i * 0x2000), 0x10000100, 0x00000000);
+                nv_wr32(priv, 0x040108 + (i * 0x2000), 0xffffffff); /* INTR */
+                nv_wr32(priv, 0x04010c + (i * 0x2000), 0xfffffeff); /* INTREN */
+        }
+
+        nv_mask(priv, 0x002200, 0x00000001, 0x00000001);
+        nv_wr32(priv, 0x002254, 0x10000000 | priv->user.bar.offset >> 12);
+
+        nv_wr32(priv, 0x002a00, 0xffffffff); /* clears PFIFO.INTR bit 30 */
+        nv_wr32(priv, 0x002100, 0xffffffff);
+        nv_wr32(priv, 0x002140, 0xbfffffff);
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_fifo_ctor,
+                .dtor = nvc0_fifo_dtor,
+                .init = nvc0_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c b/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c
new file mode 100644
index 000000000000..36e81b6fafbc
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/fifo/nve0.c
@@ -0,0 +1,628 @@
+/*
+ * Copyright 2012 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 <core/client.h>
+#include <core/handle.h>
+#include <core/namedb.h>
+#include <core/gpuobj.h>
+#include <core/engctx.h>
+#include <core/class.h>
+#include <core/math.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+
+#define _(a,b) { (a), ((1 << (a)) | (b)) }
+static const struct {
+        int subdev;
+        u32 mask;
+} fifo_engine[] = {
+        _(NVDEV_ENGINE_GR      , (1 << NVDEV_ENGINE_SW)),
+        _(NVDEV_ENGINE_VP      , 0),
+        _(NVDEV_ENGINE_PPP     , 0),
+        _(NVDEV_ENGINE_BSP     , 0),
+        _(NVDEV_ENGINE_COPY0   , 0),
+        _(NVDEV_ENGINE_COPY1   , 0),
+        _(NVDEV_ENGINE_VENC    , 0),
+};
+#undef _
+#define FIFO_ENGINE_NR ARRAY_SIZE(fifo_engine)
+
+struct nve0_fifo_engn {
+        struct nouveau_gpuobj *playlist[2];
+        int cur_playlist;
+};
+
+struct nve0_fifo_priv {
+        struct nouveau_fifo base;
+        struct nve0_fifo_engn engine[FIFO_ENGINE_NR];
+        struct {
+                struct nouveau_gpuobj *mem;
+                struct nouveau_vma bar;
+        } user;
+        int spoon_nr;
+};
+
+struct nve0_fifo_base {
+        struct nouveau_fifo_base base;
+        struct nouveau_gpuobj *pgd;
+        struct nouveau_vm *vm;
+};
+
+struct nve0_fifo_chan {
+        struct nouveau_fifo_chan base;
+        u32 engine;
+};
+
+/*******************************************************************************
+ * FIFO channel objects
+ ******************************************************************************/
+
+static void
+nve0_fifo_playlist_update(struct nve0_fifo_priv *priv, u32 engine)
+{
+        struct nouveau_bar *bar = nouveau_bar(priv);
+        struct nve0_fifo_engn *engn = &priv->engine[engine];
+        struct nouveau_gpuobj *cur;
+        u32 match = (engine << 16) | 0x00000001;
+        int i, p;
+
+        cur = engn->playlist[engn->cur_playlist];
+        if (unlikely(cur == NULL)) {
+                int ret = nouveau_gpuobj_new(nv_object(priv)->parent, NULL,
+                                             0x8000, 0x1000, 0, &cur);
+                if (ret) {
+                        nv_error(priv, "playlist alloc failed\n");
+                        return;
+                }
+
+                engn->playlist[engn->cur_playlist] = cur;
+        }
+
+        engn->cur_playlist = !engn->cur_playlist;
+
+        for (i = 0, p = 0; i < priv->base.max; i++) {
+                u32 ctrl = nv_rd32(priv, 0x800004 + (i * 8)) & 0x001f0001;
+                if (ctrl != match)
+                        continue;
+                nv_wo32(cur, p + 0, i);
+                nv_wo32(cur, p + 4, 0x00000000);
+                p += 8;
+        }
+        bar->flush(bar);
+
+        nv_wr32(priv, 0x002270, cur->addr >> 12);
+        nv_wr32(priv, 0x002274, (engine << 20) | (p >> 3));
+        if (!nv_wait(priv, 0x002284 + (engine * 4), 0x00100000, 0x00000000))
+                nv_error(priv, "playlist %d update timeout\n", engine);
+}
+
+static int
+nve0_fifo_context_attach(struct nouveau_object *parent,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nve0_fifo_base *base = (void *)parent->parent;
+        struct nouveau_engctx *ectx = (void *)object;
+        u32 addr;
+        int ret;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   :
+        case NVDEV_ENGINE_COPY0:
+        case NVDEV_ENGINE_COPY1: addr = 0x0210; break;
+        default:
+                return -EINVAL;
+        }
+
+        if (!ectx->vma.node) {
+                ret = nouveau_gpuobj_map_vm(nv_gpuobj(ectx), base->vm,
+                                            NV_MEM_ACCESS_RW, &ectx->vma);
+                if (ret)
+                        return ret;
+
+                nv_engctx(ectx)->addr = nv_gpuobj(base)->addr >> 12;
+        }
+
+        nv_wo32(base, addr + 0x00, lower_32_bits(ectx->vma.offset) | 4);
+        nv_wo32(base, addr + 0x04, upper_32_bits(ectx->vma.offset));
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nve0_fifo_context_detach(struct nouveau_object *parent, bool suspend,
+                         struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nve0_fifo_priv *priv = (void *)parent->engine;
+        struct nve0_fifo_base *base = (void *)parent->parent;
+        struct nve0_fifo_chan *chan = (void *)parent;
+        u32 addr;
+
+        switch (nv_engidx(object->engine)) {
+        case NVDEV_ENGINE_SW   : return 0;
+        case NVDEV_ENGINE_GR   :
+        case NVDEV_ENGINE_COPY0:
+        case NVDEV_ENGINE_COPY1: addr = 0x0210; break;
+        default:
+                return -EINVAL;
+        }
+
+        nv_wo32(base, addr + 0x00, 0x00000000);
+        nv_wo32(base, addr + 0x04, 0x00000000);
+        bar->flush(bar);
+
+        nv_wr32(priv, 0x002634, chan->base.chid);
+        if (!nv_wait(priv, 0x002634, 0xffffffff, chan->base.chid)) {
+                nv_error(priv, "channel %d kick timeout\n", chan->base.chid);
+                if (suspend)
+                        return -EBUSY;
+        }
+
+        return 0;
+}
+
+static int
+nve0_fifo_chan_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nve0_fifo_priv *priv = (void *)engine;
+        struct nve0_fifo_base *base = (void *)parent;
+        struct nve0_fifo_chan *chan;
+        struct nve0_channel_ind_class *args = data;
+        u64 usermem, ioffset, ilength;
+        int ret, i;
+
+        if (size < sizeof(*args))
+                return -EINVAL;
+
+        for (i = 0; i < FIFO_ENGINE_NR; i++) {
+                if (args->engine & (1 << i)) {
+                        if (nouveau_engine(parent, fifo_engine[i].subdev)) {
+                                args->engine = (1 << i);
+                                break;
+                        }
+                }
+        }
+
+        if (i == FIFO_ENGINE_NR)
+                return -ENODEV;
+
+        ret = nouveau_fifo_channel_create(parent, engine, oclass, 1,
+                                          priv->user.bar.offset, 0x200,
+                                          args->pushbuf,
+                                          fifo_engine[i].mask, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_parent(chan)->context_attach = nve0_fifo_context_attach;
+        nv_parent(chan)->context_detach = nve0_fifo_context_detach;
+        chan->engine = i;
+
+        usermem = chan->base.chid * 0x200;
+        ioffset = args->ioffset;
+        ilength = log2i(args->ilength / 8);
+
+        for (i = 0; i < 0x200; i += 4)
+                nv_wo32(priv->user.mem, usermem + i, 0x00000000);
+
+        nv_wo32(base, 0x08, lower_32_bits(priv->user.mem->addr + usermem));
+        nv_wo32(base, 0x0c, upper_32_bits(priv->user.mem->addr + usermem));
+        nv_wo32(base, 0x10, 0x0000face);
+        nv_wo32(base, 0x30, 0xfffff902);
+        nv_wo32(base, 0x48, lower_32_bits(ioffset));
+        nv_wo32(base, 0x4c, upper_32_bits(ioffset) | (ilength << 16));
+        nv_wo32(base, 0x84, 0x20400000);
+        nv_wo32(base, 0x94, 0x30000001);
+        nv_wo32(base, 0x9c, 0x00000100);
+        nv_wo32(base, 0xac, 0x0000001f);
+        nv_wo32(base, 0xe8, chan->base.chid);
+        nv_wo32(base, 0xb8, 0xf8000000);
+        nv_wo32(base, 0xf8, 0x10003080); /* 0x002310 */
+        nv_wo32(base, 0xfc, 0x10000010); /* 0x002350 */
+        bar->flush(bar);
+        return 0;
+}
+
+static int
+nve0_fifo_chan_init(struct nouveau_object *object)
+{
+        struct nouveau_gpuobj *base = nv_gpuobj(object->parent);
+        struct nve0_fifo_priv *priv = (void *)object->engine;
+        struct nve0_fifo_chan *chan = (void *)object;
+        u32 chid = chan->base.chid;
+        int ret;
+
+        ret = nouveau_fifo_channel_init(&chan->base);
+        if (ret)
+                return ret;
+
+        nv_mask(priv, 0x800004 + (chid * 8), 0x000f0000, chan->engine << 16);
+        nv_wr32(priv, 0x800000 + (chid * 8), 0x80000000 | base->addr >> 12);
+        nv_mask(priv, 0x800004 + (chid * 8), 0x00000400, 0x00000400);
+        nve0_fifo_playlist_update(priv, chan->engine);
+        nv_mask(priv, 0x800004 + (chid * 8), 0x00000400, 0x00000400);
+        return 0;
+}
+
+static int
+nve0_fifo_chan_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nve0_fifo_priv *priv = (void *)object->engine;
+        struct nve0_fifo_chan *chan = (void *)object;
+        u32 chid = chan->base.chid;
+
+        nv_mask(priv, 0x800004 + (chid * 8), 0x00000800, 0x00000800);
+        nve0_fifo_playlist_update(priv, chan->engine);
+        nv_wr32(priv, 0x800000 + (chid * 8), 0x00000000);
+
+        return nouveau_fifo_channel_fini(&chan->base, suspend);
+}
+
+static struct nouveau_ofuncs
+nve0_fifo_ofuncs = {
+        .ctor = nve0_fifo_chan_ctor,
+        .dtor = _nouveau_fifo_channel_dtor,
+        .init = nve0_fifo_chan_init,
+        .fini = nve0_fifo_chan_fini,
+        .rd32 = _nouveau_fifo_channel_rd32,
+        .wr32 = _nouveau_fifo_channel_wr32,
+};
+
+static struct nouveau_oclass
+nve0_fifo_sclass[] = {
+        { NVE0_CHANNEL_IND_CLASS, &nve0_fifo_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * FIFO context - instmem heap and vm setup
+ ******************************************************************************/
+
+static int
+nve0_fifo_context_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nve0_fifo_base *base;
+        int ret;
+
+        ret = nouveau_fifo_context_create(parent, engine, oclass, NULL, 0x1000,
+                                          0x1000, NVOBJ_FLAG_ZERO_ALLOC, &base);
+        *pobject = nv_object(base);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x10000, 0x1000, 0, &base->pgd);
+        if (ret)
+                return ret;
+
+        nv_wo32(base, 0x0200, lower_32_bits(base->pgd->addr));
+        nv_wo32(base, 0x0204, upper_32_bits(base->pgd->addr));
+        nv_wo32(base, 0x0208, 0xffffffff);
+        nv_wo32(base, 0x020c, 0x000000ff);
+
+        ret = nouveau_vm_ref(nouveau_client(parent)->vm, &base->vm, base->pgd);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nve0_fifo_context_dtor(struct nouveau_object *object)
+{
+        struct nve0_fifo_base *base = (void *)object;
+        nouveau_vm_ref(NULL, &base->vm, base->pgd);
+        nouveau_gpuobj_ref(NULL, &base->pgd);
+        nouveau_fifo_context_destroy(&base->base);
+}
+
+static struct nouveau_oclass
+nve0_fifo_cclass = {
+        .handle = NV_ENGCTX(FIFO, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nve0_fifo_context_ctor,
+                .dtor = nve0_fifo_context_dtor,
+                .init = _nouveau_fifo_context_init,
+                .fini = _nouveau_fifo_context_fini,
+                .rd32 = _nouveau_fifo_context_rd32,
+                .wr32 = _nouveau_fifo_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PFIFO engine
+ ******************************************************************************/
+
+static const struct nouveau_enum nve0_fifo_fault_unit[] = {
+        {}
+};
+
+static const struct nouveau_enum nve0_fifo_fault_reason[] = {
+        { 0x00, "PT_NOT_PRESENT" },
+        { 0x01, "PT_TOO_SHORT" },
+        { 0x02, "PAGE_NOT_PRESENT" },
+        { 0x03, "VM_LIMIT_EXCEEDED" },
+        { 0x04, "NO_CHANNEL" },
+        { 0x05, "PAGE_SYSTEM_ONLY" },
+        { 0x06, "PAGE_READ_ONLY" },
+        { 0x0a, "COMPRESSED_SYSRAM" },
+        { 0x0c, "INVALID_STORAGE_TYPE" },
+        {}
+};
+
+static const struct nouveau_enum nve0_fifo_fault_hubclient[] = {
+        {}
+};
+
+static const struct nouveau_enum nve0_fifo_fault_gpcclient[] = {
+        {}
+};
+
+static const struct nouveau_bitfield nve0_fifo_subfifo_intr[] = {
+        { 0x00200000, "ILLEGAL_MTHD" },
+        { 0x00800000, "EMPTY_SUBC" },
+        {}
+};
+
+static void
+nve0_fifo_isr_vm_fault(struct nve0_fifo_priv *priv, int unit)
+{
+        u32 inst = nv_rd32(priv, 0x2800 + (unit * 0x10));
+        u32 valo = nv_rd32(priv, 0x2804 + (unit * 0x10));
+        u32 vahi = nv_rd32(priv, 0x2808 + (unit * 0x10));
+        u32 stat = nv_rd32(priv, 0x280c + (unit * 0x10));
+        u32 client = (stat & 0x00001f00) >> 8;
+
+        nv_error(priv, "PFIFO: %s fault at 0x%010llx [", (stat & 0x00000080) ?
+                       "write" : "read", (u64)vahi << 32 | valo);
+        nouveau_enum_print(nve0_fifo_fault_reason, stat & 0x0000000f);
+        printk("] from ");
+        nouveau_enum_print(nve0_fifo_fault_unit, unit);
+        if (stat & 0x00000040) {
+                printk("/");
+                nouveau_enum_print(nve0_fifo_fault_hubclient, client);
+        } else {
+                printk("/GPC%d/", (stat & 0x1f000000) >> 24);
+                nouveau_enum_print(nve0_fifo_fault_gpcclient, client);
+        }
+        printk(" on channel 0x%010llx\n", (u64)inst << 12);
+}
+
+static int
+nve0_fifo_swmthd(struct nve0_fifo_priv *priv, u32 chid, u32 mthd, u32 data)
+{
+        struct nve0_fifo_chan *chan = NULL;
+        struct nouveau_handle *bind;
+        unsigned long flags;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&priv->base.lock, flags);
+        if (likely(chid >= priv->base.min && chid <= priv->base.max))
+                chan = (void *)priv->base.channel[chid];
+        if (unlikely(!chan))
+                goto out;
+
+        bind = nouveau_namedb_get_class(nv_namedb(chan), 0x906e);
+        if (likely(bind)) {
+                if (!mthd || !nv_call(bind->object, mthd, data))
+                        ret = 0;
+                nouveau_namedb_put(bind);
+        }
+
+out:
+        spin_unlock_irqrestore(&priv->base.lock, flags);
+        return ret;
+}
+
+static void
+nve0_fifo_isr_subfifo_intr(struct nve0_fifo_priv *priv, int unit)
+{
+        u32 stat = nv_rd32(priv, 0x040108 + (unit * 0x2000));
+        u32 addr = nv_rd32(priv, 0x0400c0 + (unit * 0x2000));
+        u32 data = nv_rd32(priv, 0x0400c4 + (unit * 0x2000));
+        u32 chid = nv_rd32(priv, 0x040120 + (unit * 0x2000)) & 0xfff;
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 mthd = (addr & 0x00003ffc);
+        u32 show = stat;
+
+        if (stat & 0x00200000) {
+                if (mthd == 0x0054) {
+                        if (!nve0_fifo_swmthd(priv, chid, 0x0500, 0x00000000))
+                                show &= ~0x00200000;
+                }
+        }
+
+        if (stat & 0x00800000) {
+                if (!nve0_fifo_swmthd(priv, chid, mthd, data))
+                        show &= ~0x00800000;
+        }
+
+        if (show) {
+                nv_error(priv, "SUBFIFO%d:", unit);
+                nouveau_bitfield_print(nve0_fifo_subfifo_intr, show);
+                printk("\n");
+                nv_error(priv, "SUBFIFO%d: ch %d subc %d mthd 0x%04x "
+                               "data 0x%08x\n",
+                         unit, chid, subc, mthd, data);
+        }
+
+        nv_wr32(priv, 0x0400c0 + (unit * 0x2000), 0x80600008);
+        nv_wr32(priv, 0x040108 + (unit * 0x2000), stat);
+}
+
+static void
+nve0_fifo_intr(struct nouveau_subdev *subdev)
+{
+        struct nve0_fifo_priv *priv = (void *)subdev;
+        u32 mask = nv_rd32(priv, 0x002140);
+        u32 stat = nv_rd32(priv, 0x002100) & mask;
+
+        if (stat & 0x00000100) {
+                nv_warn(priv, "unknown status 0x00000100\n");
+                nv_wr32(priv, 0x002100, 0x00000100);
+                stat &= ~0x00000100;
+        }
+
+        if (stat & 0x10000000) {
+                u32 units = nv_rd32(priv, 0x00259c);
+                u32 u = units;
+
+                while (u) {
+                        int i = ffs(u) - 1;
+                        nve0_fifo_isr_vm_fault(priv, i);
+                        u &= ~(1 << i);
+                }
+
+                nv_wr32(priv, 0x00259c, units);
+                stat &= ~0x10000000;
+        }
+
+        if (stat & 0x20000000) {
+                u32 units = nv_rd32(priv, 0x0025a0);
+                u32 u = units;
+
+                while (u) {
+                        int i = ffs(u) - 1;
+                        nve0_fifo_isr_subfifo_intr(priv, i);
+                        u &= ~(1 << i);
+                }
+
+                nv_wr32(priv, 0x0025a0, units);
+                stat &= ~0x20000000;
+        }
+
+        if (stat & 0x40000000) {
+                nv_warn(priv, "unknown status 0x40000000\n");
+                nv_mask(priv, 0x002a00, 0x00000000, 0x00000000);
+                stat &= ~0x40000000;
+        }
+
+        if (stat) {
+                nv_fatal(priv, "unhandled status 0x%08x\n", stat);
+                nv_wr32(priv, 0x002100, stat);
+                nv_wr32(priv, 0x002140, 0);
+        }
+}
+
+static int
+nve0_fifo_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nve0_fifo_priv *priv;
+        int ret;
+
+        ret = nouveau_fifo_create(parent, engine, oclass, 0, 4095, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 4096 * 0x200, 0x1000,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->user.mem);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_map(priv->user.mem, NV_MEM_ACCESS_RW,
+                                &priv->user.bar);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000100;
+        nv_subdev(priv)->intr = nve0_fifo_intr;
+        nv_engine(priv)->cclass = &nve0_fifo_cclass;
+        nv_engine(priv)->sclass = nve0_fifo_sclass;
+        return 0;
+}
+
+static void
+nve0_fifo_dtor(struct nouveau_object *object)
+{
+        struct nve0_fifo_priv *priv = (void *)object;
+        int i;
+
+        nouveau_gpuobj_unmap(&priv->user.bar);
+        nouveau_gpuobj_ref(NULL, &priv->user.mem);
+
+        for (i = 0; i < ARRAY_SIZE(priv->engine); i++) {
+                nouveau_gpuobj_ref(NULL, &priv->engine[i].playlist[1]);
+                nouveau_gpuobj_ref(NULL, &priv->engine[i].playlist[0]);
+        }
+
+        nouveau_fifo_destroy(&priv->base);
+}
+
+static int
+nve0_fifo_init(struct nouveau_object *object)
+{
+        struct nve0_fifo_priv *priv = (void *)object;
+        int ret, i;
+
+        ret = nouveau_fifo_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* enable all available PSUBFIFOs */
+        nv_wr32(priv, 0x000204, 0xffffffff);
+        priv->spoon_nr = hweight32(nv_rd32(priv, 0x000204));
+        nv_debug(priv, "%d subfifo(s)\n", priv->spoon_nr);
+
+        /* PSUBFIFO[n] */
+        for (i = 0; i < priv->spoon_nr; i++) {
+                nv_mask(priv, 0x04013c + (i * 0x2000), 0x10000100, 0x00000000);
+                nv_wr32(priv, 0x040108 + (i * 0x2000), 0xffffffff); /* INTR */
+                nv_wr32(priv, 0x04010c + (i * 0x2000), 0xfffffeff); /* INTREN */
+        }
+
+        nv_wr32(priv, 0x002254, 0x10000000 | priv->user.bar.offset >> 12);
+
+        nv_wr32(priv, 0x002a00, 0xffffffff);
+        nv_wr32(priv, 0x002100, 0xffffffff);
+        nv_wr32(priv, 0x002140, 0xbfffffff);
+        return 0;
+}
+
+struct nouveau_oclass
+nve0_fifo_oclass = {
+        .handle = NV_ENGINE(FIFO, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nve0_fifo_ctor,
+                .dtor = nve0_fifo_dtor,
+                .init = nve0_fifo_init,
+                .fini = _nouveau_fifo_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_grctx.h b/drivers/gpu/drm/nouveau/core/engine/graph/ctx.h
index b0795ececbda..e1947013d3bc 100644
--- a/drivers/gpu/drm/nouveau/nouveau_grctx.h
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctx.h
@@ -2,7 +2,7 @@
 #define __NOUVEAU_GRCTX_H__
 
 struct nouveau_grctx {
-        struct drm_device *dev;
+        struct nouveau_device *device;
 
         enum {
                 NOUVEAU_GRCTX_PROG,
@@ -10,18 +10,18 @@ struct nouveau_grctx {
         } mode;
         void *data;
 
-        uint32_t ctxprog_max;
-        uint32_t ctxprog_len;
-        uint32_t ctxprog_reg;
-        int      ctxprog_label[32];
-        uint32_t ctxvals_pos;
-        uint32_t ctxvals_base;
+        u32 ctxprog_max;
+        u32 ctxprog_len;
+        u32 ctxprog_reg;
+        int ctxprog_label[32];
+        u32 ctxvals_pos;
+        u32 ctxvals_base;
 };
 
 static inline void
-cp_out(struct nouveau_grctx *ctx, uint32_t inst)
+cp_out(struct nouveau_grctx *ctx, u32 inst)
 {
-        uint32_t *ctxprog = ctx->data;
+        u32 *ctxprog = ctx->data;
 
         if (ctx->mode != NOUVEAU_GRCTX_PROG)
                 return;
@@ -31,13 +31,13 @@ cp_out(struct nouveau_grctx *ctx, uint32_t inst)
 }
 
 static inline void
-cp_lsr(struct nouveau_grctx *ctx, uint32_t val)
+cp_lsr(struct nouveau_grctx *ctx, u32 val)
 {
         cp_out(ctx, CP_LOAD_SR | val);
 }
 
 static inline void
-cp_ctx(struct nouveau_grctx *ctx, uint32_t reg, uint32_t length)
+cp_ctx(struct nouveau_grctx *ctx, u32 reg, u32 length)
 {
         ctx->ctxprog_reg = (reg - 0x00400000) >> 2;
 
@@ -55,7 +55,7 @@ cp_ctx(struct nouveau_grctx *ctx, uint32_t reg, uint32_t length)
 static inline void
 cp_name(struct nouveau_grctx *ctx, int name)
 {
-        uint32_t *ctxprog = ctx->data;
+        u32 *ctxprog = ctx->data;
         int i;
 
         if (ctx->mode != NOUVEAU_GRCTX_PROG)
@@ -115,7 +115,7 @@ cp_pos(struct nouveau_grctx *ctx, int offset)
 }
 
 static inline void
-gr_def(struct nouveau_grctx *ctx, uint32_t reg, uint32_t val)
+gr_def(struct nouveau_grctx *ctx, u32 reg, u32 val)
 {
         if (ctx->mode != NOUVEAU_GRCTX_VALS)
                 return;
diff --git a/drivers/gpu/drm/nouveau/nv40_grctx.c b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv40.c
index be0a74750fb1..e45035efb8ca 100644
--- a/drivers/gpu/drm/nouveau/nv40_grctx.c
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv40.c
@@ -22,6 +22,8 @@
  * Authors: Ben Skeggs
  */
 
+#include <core/gpuobj.h>
+
 /* NVIDIA context programs handle a number of other conditions which are
  * not implemented in our versions.  It's not clear why NVIDIA context
  * programs have this code, nor whether it's strictly necessary for
@@ -109,20 +111,18 @@
 #define CP_LOAD_MAGIC_NV44TCL    0x00800029 /* per-vs state (0x4497) */
 #define CP_LOAD_MAGIC_NV40TCL    0x00800041 /* per-vs state (0x4097) */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_grctx.h"
+#include "nv40.h"
+#include "ctx.h"
 
 /* TODO:
  *  - get vs count from 0x1540
  */
 
 static int
-nv40_graph_vs_count(struct drm_device *dev)
+nv40_graph_vs_count(struct nouveau_device *device)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
 
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x47:
         case 0x49:
         case 0x4b:
@@ -160,7 +160,7 @@ enum cp_label {
 static void
 nv40_graph_construct_general(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
 
         cp_ctx(ctx, 0x4000a4, 1);
@@ -187,7 +187,7 @@ nv40_graph_construct_general(struct nouveau_grctx *ctx)
         cp_ctx(ctx, 0x400724, 1);
         gr_def(ctx, 0x400724, 0x02008821);
         cp_ctx(ctx, 0x400770, 3);
-        if (dev_priv->chipset == 0x40) {
+        if (device->chipset == 0x40) {
                 cp_ctx(ctx, 0x400814, 4);
                 cp_ctx(ctx, 0x400828, 5);
                 cp_ctx(ctx, 0x400840, 5);
@@ -208,7 +208,7 @@ nv40_graph_construct_general(struct nouveau_grctx *ctx)
                 gr_def(ctx, 0x4009dc, 0x80000000);
         } else {
                 cp_ctx(ctx, 0x400840, 20);
-                if (nv44_graph_class(ctx->dev)) {
+                if (nv44_graph_class(ctx->device)) {
                         for (i = 0; i < 8; i++)
                                 gr_def(ctx, 0x400860 + (i * 4), 0x00000001);
                 }
@@ -217,21 +217,21 @@ nv40_graph_construct_general(struct nouveau_grctx *ctx)
                 gr_def(ctx, 0x400888, 0x00000040);
                 cp_ctx(ctx, 0x400894, 11);
                 gr_def(ctx, 0x400894, 0x00000040);
-                if (!nv44_graph_class(ctx->dev)) {
+                if (!nv44_graph_class(ctx->device)) {
                         for (i = 0; i < 8; i++)
                                 gr_def(ctx, 0x4008a0 + (i * 4), 0x80000000);
                 }
                 cp_ctx(ctx, 0x4008e0, 2);
                 cp_ctx(ctx, 0x4008f8, 2);
-                if (dev_priv->chipset == 0x4c ||
-                    (dev_priv->chipset & 0xf0) == 0x60)
+                if (device->chipset == 0x4c ||
+                    (device->chipset & 0xf0) == 0x60)
                         cp_ctx(ctx, 0x4009f8, 1);
         }
         cp_ctx(ctx, 0x400a00, 73);
         gr_def(ctx, 0x400b0c, 0x0b0b0b0c);
         cp_ctx(ctx, 0x401000, 4);
         cp_ctx(ctx, 0x405004, 1);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x47:
         case 0x49:
         case 0x4b:
@@ -240,7 +240,7 @@ nv40_graph_construct_general(struct nouveau_grctx *ctx)
                 break;
         default:
                 cp_ctx(ctx, 0x403440, 1);
-                switch (dev_priv->chipset) {
+                switch (device->chipset) {
                 case 0x40:
                         gr_def(ctx, 0x403440, 0x00000010);
                         break;
@@ -266,19 +266,19 @@ nv40_graph_construct_general(struct nouveau_grctx *ctx)
 static void
 nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
 
-        if (dev_priv->chipset == 0x40) {
+        if (device->chipset == 0x40) {
                 cp_ctx(ctx, 0x401880, 51);
                 gr_def(ctx, 0x401940, 0x00000100);
         } else
-        if (dev_priv->chipset == 0x46 || dev_priv->chipset == 0x47 ||
-            dev_priv->chipset == 0x49 || dev_priv->chipset == 0x4b) {
+        if (device->chipset == 0x46 || device->chipset == 0x47 ||
+            device->chipset == 0x49 || device->chipset == 0x4b) {
                 cp_ctx(ctx, 0x401880, 32);
                 for (i = 0; i < 16; i++)
                         gr_def(ctx, 0x401880 + (i * 4), 0x00000111);
-                if (dev_priv->chipset == 0x46)
+                if (device->chipset == 0x46)
                         cp_ctx(ctx, 0x401900, 16);
                 cp_ctx(ctx, 0x401940, 3);
         }
@@ -289,7 +289,7 @@ nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
         gr_def(ctx, 0x401978, 0xffff0000);
         gr_def(ctx, 0x40197c, 0x00000001);
         gr_def(ctx, 0x401990, 0x46400000);
-        if (dev_priv->chipset == 0x40) {
+        if (device->chipset == 0x40) {
                 cp_ctx(ctx, 0x4019a0, 2);
                 cp_ctx(ctx, 0x4019ac, 5);
         } else {
@@ -297,7 +297,7 @@ nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
                 cp_ctx(ctx, 0x4019b4, 3);
         }
         gr_def(ctx, 0x4019bc, 0xffff0000);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x46:
         case 0x47:
         case 0x49:
@@ -316,7 +316,7 @@ nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
         for (i = 0; i < 16; i++)
                 gr_def(ctx, 0x401a44 + (i * 4), 0x07ff0000);
         gr_def(ctx, 0x401a8c, 0x4b7fffff);
-        if (dev_priv->chipset == 0x40) {
+        if (device->chipset == 0x40) {
                 cp_ctx(ctx, 0x401ab8, 3);
         } else {
                 cp_ctx(ctx, 0x401ab8, 1);
@@ -327,10 +327,10 @@ nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
         gr_def(ctx, 0x401ad4, 0x70605040);
         gr_def(ctx, 0x401ad8, 0xb8a89888);
         gr_def(ctx, 0x401adc, 0xf8e8d8c8);
-        cp_ctx(ctx, 0x401b10, dev_priv->chipset == 0x40 ? 2 : 1);
+        cp_ctx(ctx, 0x401b10, device->chipset == 0x40 ? 2 : 1);
         gr_def(ctx, 0x401b10, 0x40100000);
-        cp_ctx(ctx, 0x401b18, dev_priv->chipset == 0x40 ? 6 : 5);
-        gr_def(ctx, 0x401b28, dev_priv->chipset == 0x40 ?
+        cp_ctx(ctx, 0x401b18, device->chipset == 0x40 ? 6 : 5);
+        gr_def(ctx, 0x401b28, device->chipset == 0x40 ?
                               0x00000004 : 0x00000000);
         cp_ctx(ctx, 0x401b30, 25);
         gr_def(ctx, 0x401b34, 0x0000ffff);
@@ -341,8 +341,8 @@ nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
         gr_def(ctx, 0x401b84, 0xffffffff);
         gr_def(ctx, 0x401b88, 0x00ff7000);
         gr_def(ctx, 0x401b8c, 0x0000ffff);
-        if (dev_priv->chipset != 0x44 && dev_priv->chipset != 0x4a &&
-            dev_priv->chipset != 0x4e)
+        if (device->chipset != 0x44 && device->chipset != 0x4a &&
+            device->chipset != 0x4e)
                 cp_ctx(ctx, 0x401b94, 1);
         cp_ctx(ctx, 0x401b98, 8);
         gr_def(ctx, 0x401b9c, 0x00ff0000);
@@ -371,12 +371,12 @@ nv40_graph_construct_state3d(struct nouveau_grctx *ctx)
 static void
 nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
 
         cp_ctx(ctx, 0x402000, 1);
-        cp_ctx(ctx, 0x402404, dev_priv->chipset == 0x40 ? 1 : 2);
-        switch (dev_priv->chipset) {
+        cp_ctx(ctx, 0x402404, device->chipset == 0x40 ? 1 : 2);
+        switch (device->chipset) {
         case 0x40:
                 gr_def(ctx, 0x402404, 0x00000001);
                 break;
@@ -393,9 +393,9 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
         default:
                 gr_def(ctx, 0x402404, 0x00000021);
         }
-        if (dev_priv->chipset != 0x40)
+        if (device->chipset != 0x40)
                 gr_def(ctx, 0x402408, 0x030c30c3);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x44:
         case 0x46:
         case 0x4a:
@@ -408,10 +408,10 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
         default:
                 break;
         }
-        cp_ctx(ctx, 0x402480, dev_priv->chipset == 0x40 ? 8 : 9);
+        cp_ctx(ctx, 0x402480, device->chipset == 0x40 ? 8 : 9);
         gr_def(ctx, 0x402488, 0x3e020200);
         gr_def(ctx, 0x40248c, 0x00ffffff);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x40:
                 gr_def(ctx, 0x402490, 0x60103f00);
                 break;
@@ -428,16 +428,16 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
                 gr_def(ctx, 0x402490, 0x0c103f00);
                 break;
         }
-        gr_def(ctx, 0x40249c, dev_priv->chipset <= 0x43 ?
+        gr_def(ctx, 0x40249c, device->chipset <= 0x43 ?
                               0x00020000 : 0x00040000);
         cp_ctx(ctx, 0x402500, 31);
         gr_def(ctx, 0x402530, 0x00008100);
-        if (dev_priv->chipset == 0x40)
+        if (device->chipset == 0x40)
                 cp_ctx(ctx, 0x40257c, 6);
         cp_ctx(ctx, 0x402594, 16);
         cp_ctx(ctx, 0x402800, 17);
         gr_def(ctx, 0x402800, 0x00000001);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x47:
         case 0x49:
         case 0x4b:
@@ -445,7 +445,7 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
                 gr_def(ctx, 0x402864, 0x00001001);
                 cp_ctx(ctx, 0x402870, 3);
                 gr_def(ctx, 0x402878, 0x00000003);
-                if (dev_priv->chipset != 0x47) { /* belong at end!! */
+                if (device->chipset != 0x47) { /* belong at end!! */
                         cp_ctx(ctx, 0x402900, 1);
                         cp_ctx(ctx, 0x402940, 1);
                         cp_ctx(ctx, 0x402980, 1);
@@ -470,9 +470,9 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
         }
 
         cp_ctx(ctx, 0x402c00, 4);
-        gr_def(ctx, 0x402c00, dev_priv->chipset == 0x40 ?
+        gr_def(ctx, 0x402c00, device->chipset == 0x40 ?
                               0x80800001 : 0x00888001);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x47:
         case 0x49:
         case 0x4b:
@@ -485,30 +485,30 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
                 break;
         default:
                 cp_ctx(ctx, 0x402c10, 4);
-                if (dev_priv->chipset == 0x40)
+                if (device->chipset == 0x40)
                         cp_ctx(ctx, 0x402c20, 36);
                 else
-                if (dev_priv->chipset <= 0x42)
+                if (device->chipset <= 0x42)
                         cp_ctx(ctx, 0x402c20, 24);
                 else
-                if (dev_priv->chipset <= 0x4a)
+                if (device->chipset <= 0x4a)
                         cp_ctx(ctx, 0x402c20, 16);
                 else
                         cp_ctx(ctx, 0x402c20, 8);
-                cp_ctx(ctx, 0x402cb0, dev_priv->chipset == 0x40 ? 12 : 13);
+                cp_ctx(ctx, 0x402cb0, device->chipset == 0x40 ? 12 : 13);
                 gr_def(ctx, 0x402cd4, 0x00000005);
-                if (dev_priv->chipset != 0x40)
+                if (device->chipset != 0x40)
                         gr_def(ctx, 0x402ce0, 0x0000ffff);
                 break;
         }
 
-        cp_ctx(ctx, 0x403400, dev_priv->chipset == 0x40 ? 4 : 3);
-        cp_ctx(ctx, 0x403410, dev_priv->chipset == 0x40 ? 4 : 3);
-        cp_ctx(ctx, 0x403420, nv40_graph_vs_count(ctx->dev));
-        for (i = 0; i < nv40_graph_vs_count(ctx->dev); i++)
+        cp_ctx(ctx, 0x403400, device->chipset == 0x40 ? 4 : 3);
+        cp_ctx(ctx, 0x403410, device->chipset == 0x40 ? 4 : 3);
+        cp_ctx(ctx, 0x403420, nv40_graph_vs_count(ctx->device));
+        for (i = 0; i < nv40_graph_vs_count(ctx->device); i++)
                 gr_def(ctx, 0x403420 + (i * 4), 0x00005555);
 
-        if (dev_priv->chipset != 0x40) {
+        if (device->chipset != 0x40) {
                 cp_ctx(ctx, 0x403600, 1);
                 gr_def(ctx, 0x403600, 0x00000001);
         }
@@ -516,7 +516,7 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
 
         cp_ctx(ctx, 0x403c18, 1);
         gr_def(ctx, 0x403c18, 0x00000001);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x46:
         case 0x47:
         case 0x49:
@@ -527,7 +527,7 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
                 gr_def(ctx, 0x405c24, 0x000e3000);
                 break;
         }
-        if (dev_priv->chipset != 0x4e)
+        if (device->chipset != 0x4e)
                 cp_ctx(ctx, 0x405800, 11);
         cp_ctx(ctx, 0x407000, 1);
 }
@@ -535,7 +535,7 @@ nv40_graph_construct_state3d_2(struct nouveau_grctx *ctx)
 static void
 nv40_graph_construct_state3d_3(struct nouveau_grctx *ctx)
 {
-        int len = nv44_graph_class(ctx->dev) ? 0x0084 : 0x0684;
+        int len = nv44_graph_class(ctx->device) ? 0x0084 : 0x0684;
 
         cp_out (ctx, 0x300000);
         cp_lsr (ctx, len - 4);
@@ -550,32 +550,31 @@ nv40_graph_construct_state3d_3(struct nouveau_grctx *ctx)
 static void
 nv40_graph_construct_shader(struct nouveau_grctx *ctx)
 {
-        struct drm_device *dev = ctx->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         struct nouveau_gpuobj *obj = ctx->data;
         int vs, vs_nr, vs_len, vs_nr_b0, vs_nr_b1, b0_offset, b1_offset;
         int offset, i;
 
-        vs_nr    = nv40_graph_vs_count(ctx->dev);
+        vs_nr    = nv40_graph_vs_count(ctx->device);
         vs_nr_b0 = 363;
-        vs_nr_b1 = dev_priv->chipset == 0x40 ? 128 : 64;
-        if (dev_priv->chipset == 0x40) {
+        vs_nr_b1 = device->chipset == 0x40 ? 128 : 64;
+        if (device->chipset == 0x40) {
                 b0_offset = 0x2200/4; /* 33a0 */
                 b1_offset = 0x55a0/4; /* 1500 */
                 vs_len = 0x6aa0/4;
         } else
-        if (dev_priv->chipset == 0x41 || dev_priv->chipset == 0x42) {
+        if (device->chipset == 0x41 || device->chipset == 0x42) {
                 b0_offset = 0x2200/4; /* 2200 */
                 b1_offset = 0x4400/4; /* 0b00 */
                 vs_len = 0x4f00/4;
         } else {
                 b0_offset = 0x1d40/4; /* 2200 */
                 b1_offset = 0x3f40/4; /* 0b00 : 0a40 */
-                vs_len = nv44_graph_class(dev) ? 0x4980/4 : 0x4a40/4;
+                vs_len = nv44_graph_class(device) ? 0x4980/4 : 0x4a40/4;
         }
 
         cp_lsr(ctx, vs_len * vs_nr + 0x300/4);
-        cp_out(ctx, nv44_graph_class(dev) ? 0x800029 : 0x800041);
+        cp_out(ctx, nv44_graph_class(device) ? 0x800029 : 0x800041);
 
         offset = ctx->ctxvals_pos;
         ctx->ctxvals_pos += (0x0300/4 + (vs_nr * vs_len));
@@ -661,21 +660,21 @@ nv40_grctx_generate(struct nouveau_grctx *ctx)
 }
 
 void
-nv40_grctx_fill(struct drm_device *dev, struct nouveau_gpuobj *mem)
+nv40_grctx_fill(struct nouveau_device *device, struct nouveau_gpuobj *mem)
 {
         nv40_grctx_generate(&(struct nouveau_grctx) {
-                             .dev = dev,
+                             .device = device,
                              .mode = NOUVEAU_GRCTX_VALS,
                              .data = mem,
                            });
 }
 
 void
-nv40_grctx_init(struct drm_device *dev, u32 *size)
+nv40_grctx_init(struct nouveau_device *device, u32 *size)
 {
         u32 ctxprog[256], i;
         struct nouveau_grctx ctx = {
-                .dev = dev,
+                .device = device,
                 .mode = NOUVEAU_GRCTX_PROG,
                 .data = ctxprog,
                 .ctxprog_max = ARRAY_SIZE(ctxprog)
@@ -683,8 +682,8 @@ nv40_grctx_init(struct drm_device *dev, u32 *size)
 
         nv40_grctx_generate(&ctx);
 
-        nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_INDEX, 0);
+        nv_wr32(device, 0x400324, 0);
         for (i = 0; i < ctx.ctxprog_len; i++)
-                nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_DATA, ctxprog[i]);
+                nv_wr32(device, 0x400328, ctxprog[i]);
         *size = ctx.ctxvals_pos * 4;
 }
diff --git a/drivers/gpu/drm/nouveau/nv50_grctx.c b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv50.c
index 881e22b249fc..552fdbd45ebe 100644
--- a/drivers/gpu/drm/nouveau/nv50_grctx.c
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv50.c
@@ -20,6 +20,8 @@
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#include <core/gpuobj.h>
+
 #define CP_FLAG_CLEAR                 0
 #define CP_FLAG_SET                   1
 #define CP_FLAG_SWAP_DIRECTION        ((0 * 32) + 0)
@@ -105,9 +107,8 @@
 #define CP_SEEK_1      0x00c000ff
 #define CP_SEEK_2      0x00c800ff
 
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_grctx.h"
+#include "nv50.h"
+#include "ctx.h"
 
 #define IS_NVA3F(x) (((x) > 0xa0 && (x) < 0xaa) || (x) == 0xaf)
 #define IS_NVAAF(x) ((x) >= 0xaa && (x) <= 0xac)
@@ -175,32 +176,6 @@ static void nv50_graph_construct_xfer2(struct nouveau_grctx *ctx);
 static int
 nv50_grctx_generate(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
-
-        switch (dev_priv->chipset) {
-        case 0x50:
-        case 0x84:
-        case 0x86:
-        case 0x92:
-        case 0x94:
-        case 0x96:
-        case 0x98:
-        case 0xa0:
-        case 0xa3:
-        case 0xa5:
-        case 0xa8:
-        case 0xaa:
-        case 0xac:
-        case 0xaf:
-                break;
-        default:
-                NV_ERROR(ctx->dev, "I don't know how to make a ctxprog for "
-                                   "your NV%x card.\n", dev_priv->chipset);
-                NV_ERROR(ctx->dev, "Disabling acceleration. Please contact "
-                                   "the devs.\n");
-                return -ENOSYS;
-        }
-
         cp_set (ctx, STATE, RUNNING);
         cp_set (ctx, XFER_SWITCH, ENABLE);
         /* decide whether we're loading/unloading the context */
@@ -278,30 +253,36 @@ nv50_grctx_generate(struct nouveau_grctx *ctx)
 }
 
 void
-nv50_grctx_fill(struct drm_device *dev, struct nouveau_gpuobj *mem)
+nv50_grctx_fill(struct nouveau_device *device, struct nouveau_gpuobj *mem)
 {
         nv50_grctx_generate(&(struct nouveau_grctx) {
-                             .dev = dev,
+                             .device = device,
                              .mode = NOUVEAU_GRCTX_VALS,
                              .data = mem,
                            });
 }
 
 int
-nv50_grctx_init(struct drm_device *dev, u32 *data, u32 max, u32 *len, u32 *cnt)
+nv50_grctx_init(struct nouveau_device *device, u32 *size)
 {
+        u32 *ctxprog = kmalloc(512 * 4, GFP_KERNEL), i;
         struct nouveau_grctx ctx = {
-                .dev = dev,
+                .device = device,
                 .mode = NOUVEAU_GRCTX_PROG,
-                .data = data,
-                .ctxprog_max = max
+                .data = ctxprog,
+                .ctxprog_max = 512,
         };
-        int ret;
 
-        ret = nv50_grctx_generate(&ctx);
-        *cnt = ctx.ctxvals_pos * 4;
-        *len = ctx.ctxprog_len;
-        return ret;
+        if (!ctxprog)
+                return -ENOMEM;
+        nv50_grctx_generate(&ctx);
+
+        nv_wr32(device, 0x400324, 0);
+        for (i = 0; i < ctx.ctxprog_len; i++)
+                nv_wr32(device, 0x400328, ctxprog[i]);
+        *size = ctx.ctxvals_pos * 4;
+        kfree(ctxprog);
+        return 0;
 }
 
 /*
@@ -315,36 +296,36 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx);
 static void
 nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i, j;
         int offset, base;
-        uint32_t units = nv_rd32 (ctx->dev, 0x1540);
+        u32 units = nv_rd32 (ctx->device, 0x1540);
 
         /* 0800: DISPATCH */
         cp_ctx(ctx, 0x400808, 7);
         gr_def(ctx, 0x400814, 0x00000030);
         cp_ctx(ctx, 0x400834, 0x32);
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 gr_def(ctx, 0x400834, 0xff400040);
                 gr_def(ctx, 0x400838, 0xfff00080);
                 gr_def(ctx, 0x40083c, 0xfff70090);
                 gr_def(ctx, 0x400840, 0xffe806a8);
         }
         gr_def(ctx, 0x400844, 0x00000002);
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 gr_def(ctx, 0x400894, 0x00001000);
         gr_def(ctx, 0x4008e8, 0x00000003);
         gr_def(ctx, 0x4008ec, 0x00001000);
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 cp_ctx(ctx, 0x400908, 0xb);
-        else if (dev_priv->chipset < 0xa0)
+        else if (device->chipset < 0xa0)
                 cp_ctx(ctx, 0x400908, 0xc);
         else
                 cp_ctx(ctx, 0x400908, 0xe);
 
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 cp_ctx(ctx, 0x400b00, 0x1);
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 cp_ctx(ctx, 0x400b10, 0x1);
                 gr_def(ctx, 0x400b10, 0x0001629d);
                 cp_ctx(ctx, 0x400b20, 0x1);
@@ -358,10 +339,10 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         gr_def(ctx, 0x400c08, 0x0000fe0c);
 
         /* 1000 */
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 cp_ctx(ctx, 0x401008, 0x4);
                 gr_def(ctx, 0x401014, 0x00001000);
-        } else if (!IS_NVA3F(dev_priv->chipset)) {
+        } else if (!IS_NVA3F(device->chipset)) {
                 cp_ctx(ctx, 0x401008, 0x5);
                 gr_def(ctx, 0x401018, 0x00001000);
         } else {
@@ -372,7 +353,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         /* 1400 */
         cp_ctx(ctx, 0x401400, 0x8);
         cp_ctx(ctx, 0x401424, 0x3);
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 gr_def(ctx, 0x40142c, 0x0001fd87);
         else
                 gr_def(ctx, 0x40142c, 0x00000187);
@@ -382,10 +363,10 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         /* 1800: STREAMOUT */
         cp_ctx(ctx, 0x401814, 0x1);
         gr_def(ctx, 0x401814, 0x000000ff);
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 cp_ctx(ctx, 0x40181c, 0xe);
                 gr_def(ctx, 0x401850, 0x00000004);
-        } else if (dev_priv->chipset < 0xa0) {
+        } else if (device->chipset < 0xa0) {
                 cp_ctx(ctx, 0x40181c, 0xf);
                 gr_def(ctx, 0x401854, 0x00000004);
         } else {
@@ -395,7 +376,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
 
         /* 1C00 */
         cp_ctx(ctx, 0x401c00, 0x1);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x50:
                 gr_def(ctx, 0x401c00, 0x0001005f);
                 break;
@@ -424,7 +405,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
 
         /* 2400 */
         cp_ctx(ctx, 0x402400, 0x1);
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 cp_ctx(ctx, 0x402408, 0x1);
         else
                 cp_ctx(ctx, 0x402408, 0x2);
@@ -432,21 +413,21 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
 
         /* 2800: CSCHED */
         cp_ctx(ctx, 0x402800, 0x1);
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 gr_def(ctx, 0x402800, 0x00000006);
 
         /* 2C00: ZCULL */
         cp_ctx(ctx, 0x402c08, 0x6);
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 gr_def(ctx, 0x402c14, 0x01000000);
         gr_def(ctx, 0x402c18, 0x000000ff);
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 cp_ctx(ctx, 0x402ca0, 0x1);
         else
                 cp_ctx(ctx, 0x402ca0, 0x2);
-        if (dev_priv->chipset < 0xa0)
+        if (device->chipset < 0xa0)
                 gr_def(ctx, 0x402ca0, 0x00000400);
-        else if (!IS_NVA3F(dev_priv->chipset))
+        else if (!IS_NVA3F(device->chipset))
                 gr_def(ctx, 0x402ca0, 0x00000800);
         else
                 gr_def(ctx, 0x402ca0, 0x00000400);
@@ -457,14 +438,14 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         gr_def(ctx, 0x403004, 0x00000001);
 
         /* 3400 */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 cp_ctx(ctx, 0x403404, 0x1);
                 gr_def(ctx, 0x403404, 0x00000001);
         }
 
         /* 5000: CCACHE */
         cp_ctx(ctx, 0x405000, 0x1);
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x50:
                 gr_def(ctx, 0x405000, 0x00300080);
                 break;
@@ -493,22 +474,22 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         cp_ctx(ctx, 0x40502c, 0x1);
 
         /* 6000? */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 cp_ctx(ctx, 0x4063e0, 0x1);
 
         /* 6800: M2MF */
-        if (dev_priv->chipset < 0x90) {
+        if (device->chipset < 0x90) {
                 cp_ctx(ctx, 0x406814, 0x2b);
                 gr_def(ctx, 0x406818, 0x00000f80);
                 gr_def(ctx, 0x406860, 0x007f0080);
                 gr_def(ctx, 0x40689c, 0x007f0080);
         } else {
                 cp_ctx(ctx, 0x406814, 0x4);
-                if (dev_priv->chipset == 0x98)
+                if (device->chipset == 0x98)
                         gr_def(ctx, 0x406818, 0x00000f80);
                 else
                         gr_def(ctx, 0x406818, 0x00001f80);
-                if (IS_NVA3F(dev_priv->chipset))
+                if (IS_NVA3F(device->chipset))
                         gr_def(ctx, 0x40681c, 0x00000030);
                 cp_ctx(ctx, 0x406830, 0x3);
         }
@@ -517,43 +498,43 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         for (i = 0; i < 8; i++) {
                 if (units & (1<<(i+16))) {
                         cp_ctx(ctx, 0x407000 + (i<<8), 3);
-                        if (dev_priv->chipset == 0x50)
+                        if (device->chipset == 0x50)
                                 gr_def(ctx, 0x407000 + (i<<8), 0x1b74f820);
-                        else if (dev_priv->chipset != 0xa5)
+                        else if (device->chipset != 0xa5)
                                 gr_def(ctx, 0x407000 + (i<<8), 0x3b74f821);
                         else
                                 gr_def(ctx, 0x407000 + (i<<8), 0x7b74f821);
                         gr_def(ctx, 0x407004 + (i<<8), 0x89058001);
 
-                        if (dev_priv->chipset == 0x50) {
+                        if (device->chipset == 0x50) {
                                 cp_ctx(ctx, 0x407010 + (i<<8), 1);
-                        } else if (dev_priv->chipset < 0xa0) {
+                        } else if (device->chipset < 0xa0) {
                                 cp_ctx(ctx, 0x407010 + (i<<8), 2);
                                 gr_def(ctx, 0x407010 + (i<<8), 0x00001000);
                                 gr_def(ctx, 0x407014 + (i<<8), 0x0000001f);
                         } else {
                                 cp_ctx(ctx, 0x407010 + (i<<8), 3);
                                 gr_def(ctx, 0x407010 + (i<<8), 0x00001000);
-                                if (dev_priv->chipset != 0xa5)
+                                if (device->chipset != 0xa5)
                                         gr_def(ctx, 0x407014 + (i<<8), 0x000000ff);
                                 else
                                         gr_def(ctx, 0x407014 + (i<<8), 0x000001ff);
                         }
 
                         cp_ctx(ctx, 0x407080 + (i<<8), 4);
-                        if (dev_priv->chipset != 0xa5)
+                        if (device->chipset != 0xa5)
                                 gr_def(ctx, 0x407080 + (i<<8), 0x027c10fa);
                         else
                                 gr_def(ctx, 0x407080 + (i<<8), 0x827c10fa);
-                        if (dev_priv->chipset == 0x50)
+                        if (device->chipset == 0x50)
                                 gr_def(ctx, 0x407084 + (i<<8), 0x000000c0);
                         else
                                 gr_def(ctx, 0x407084 + (i<<8), 0x400000c0);
                         gr_def(ctx, 0x407088 + (i<<8), 0xb7892080);
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 cp_ctx(ctx, 0x407094 + (i<<8), 1);
-                        else if (!IS_NVA3F(dev_priv->chipset))
+                        else if (!IS_NVA3F(device->chipset))
                                 cp_ctx(ctx, 0x407094 + (i<<8), 3);
                         else {
                                 cp_ctx(ctx, 0x407094 + (i<<8), 4);
@@ -563,30 +544,30 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         }
 
         cp_ctx(ctx, 0x407c00, 0x3);
-        if (dev_priv->chipset < 0x90)
+        if (device->chipset < 0x90)
                 gr_def(ctx, 0x407c00, 0x00010040);
-        else if (dev_priv->chipset < 0xa0)
+        else if (device->chipset < 0xa0)
                 gr_def(ctx, 0x407c00, 0x00390040);
         else
                 gr_def(ctx, 0x407c00, 0x003d0040);
         gr_def(ctx, 0x407c08, 0x00000022);
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 cp_ctx(ctx, 0x407c10, 0x3);
                 cp_ctx(ctx, 0x407c20, 0x1);
                 cp_ctx(ctx, 0x407c2c, 0x1);
         }
 
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 cp_ctx(ctx, 0x407d00, 0x9);
         } else {
                 cp_ctx(ctx, 0x407d00, 0x15);
         }
-        if (dev_priv->chipset == 0x98)
+        if (device->chipset == 0x98)
                 gr_def(ctx, 0x407d08, 0x00380040);
         else {
-                if (dev_priv->chipset < 0x90)
+                if (device->chipset < 0x90)
                         gr_def(ctx, 0x407d08, 0x00010040);
-                else if (dev_priv->chipset < 0xa0)
+                else if (device->chipset < 0xa0)
                         gr_def(ctx, 0x407d08, 0x00390040);
                 else
                         gr_def(ctx, 0x407d08, 0x003d0040);
@@ -596,11 +577,11 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
         /* 8000+: per-TP state */
         for (i = 0; i < 10; i++) {
                 if (units & (1<<i)) {
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 base = 0x408000 + (i<<12);
                         else
                                 base = 0x408000 + (i<<11);
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 offset = base + 0xc00;
                         else
                                 offset = base + 0x80;
@@ -609,9 +590,9 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                         cp_ctx(ctx, offset + 0x08, 1);
 
                         /* per-MP state */
-                        for (j = 0; j < (dev_priv->chipset < 0xa0 ? 2 : 4); j++) {
+                        for (j = 0; j < (device->chipset < 0xa0 ? 2 : 4); j++) {
                                 if (!(units & (1 << (j+24)))) continue;
-                                if (dev_priv->chipset < 0xa0)
+                                if (device->chipset < 0xa0)
                                         offset = base + 0x200 + (j<<7);
                                 else
                                         offset = base + 0x100 + (j<<7);
@@ -620,7 +601,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                                 gr_def(ctx, offset + 0x04, 0x00160000);
                                 gr_def(ctx, offset + 0x08, 0x01800000);
                                 gr_def(ctx, offset + 0x18, 0x0003ffff);
-                                switch (dev_priv->chipset) {
+                                switch (device->chipset) {
                                 case 0x50:
                                         gr_def(ctx, offset + 0x1c, 0x00080000);
                                         break;
@@ -651,53 +632,53 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                                         break;
                                 }
                                 gr_def(ctx, offset + 0x40, 0x00010401);
-                                if (dev_priv->chipset == 0x50)
+                                if (device->chipset == 0x50)
                                         gr_def(ctx, offset + 0x48, 0x00000040);
                                 else
                                         gr_def(ctx, offset + 0x48, 0x00000078);
                                 gr_def(ctx, offset + 0x50, 0x000000bf);
                                 gr_def(ctx, offset + 0x58, 0x00001210);
-                                if (dev_priv->chipset == 0x50)
+                                if (device->chipset == 0x50)
                                         gr_def(ctx, offset + 0x5c, 0x00000080);
                                 else
                                         gr_def(ctx, offset + 0x5c, 0x08000080);
-                                if (dev_priv->chipset >= 0xa0)
+                                if (device->chipset >= 0xa0)
                                         gr_def(ctx, offset + 0x68, 0x0000003e);
                         }
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 cp_ctx(ctx, base + 0x300, 0x4);
                         else
                                 cp_ctx(ctx, base + 0x300, 0x5);
-                        if (dev_priv->chipset == 0x50)
+                        if (device->chipset == 0x50)
                                 gr_def(ctx, base + 0x304, 0x00007070);
-                        else if (dev_priv->chipset < 0xa0)
+                        else if (device->chipset < 0xa0)
                                 gr_def(ctx, base + 0x304, 0x00027070);
-                        else if (!IS_NVA3F(dev_priv->chipset))
+                        else if (!IS_NVA3F(device->chipset))
                                 gr_def(ctx, base + 0x304, 0x01127070);
                         else
                                 gr_def(ctx, base + 0x304, 0x05127070);
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 cp_ctx(ctx, base + 0x318, 1);
                         else
                                 cp_ctx(ctx, base + 0x320, 1);
-                        if (dev_priv->chipset == 0x50)
+                        if (device->chipset == 0x50)
                                 gr_def(ctx, base + 0x318, 0x0003ffff);
-                        else if (dev_priv->chipset < 0xa0)
+                        else if (device->chipset < 0xa0)
                                 gr_def(ctx, base + 0x318, 0x03ffffff);
                         else
                                 gr_def(ctx, base + 0x320, 0x07ffffff);
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 cp_ctx(ctx, base + 0x324, 5);
                         else
                                 cp_ctx(ctx, base + 0x328, 4);
 
-                        if (dev_priv->chipset < 0xa0) {
+                        if (device->chipset < 0xa0) {
                                 cp_ctx(ctx, base + 0x340, 9);
                                 offset = base + 0x340;
-                        } else if (!IS_NVA3F(dev_priv->chipset)) {
+                        } else if (!IS_NVA3F(device->chipset)) {
                                 cp_ctx(ctx, base + 0x33c, 0xb);
                                 offset = base + 0x344;
                         } else {
@@ -706,12 +687,12 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                         }
                         gr_def(ctx, offset + 0x0, 0x00120407);
                         gr_def(ctx, offset + 0x4, 0x05091507);
-                        if (dev_priv->chipset == 0x84)
+                        if (device->chipset == 0x84)
                                 gr_def(ctx, offset + 0x8, 0x05100202);
                         else
                                 gr_def(ctx, offset + 0x8, 0x05010202);
                         gr_def(ctx, offset + 0xc, 0x00030201);
-                        if (dev_priv->chipset == 0xa3)
+                        if (device->chipset == 0xa3)
                                 cp_ctx(ctx, base + 0x36c, 1);
 
                         cp_ctx(ctx, base + 0x400, 2);
@@ -720,7 +701,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                         gr_def(ctx, base + 0x40c, 0x0d0c0b0a);
                         gr_def(ctx, base + 0x410, 0x00141210);
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 offset = base + 0x800;
                         else
                                 offset = base + 0x500;
@@ -728,55 +709,55 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                         gr_def(ctx, offset + 0x0, 0x000001f0);
                         gr_def(ctx, offset + 0x4, 0x00000001);
                         gr_def(ctx, offset + 0x8, 0x00000003);
-                        if (dev_priv->chipset == 0x50 || IS_NVAAF(dev_priv->chipset))
+                        if (device->chipset == 0x50 || IS_NVAAF(device->chipset))
                                 gr_def(ctx, offset + 0xc, 0x00008000);
                         gr_def(ctx, offset + 0x14, 0x00039e00);
                         cp_ctx(ctx, offset + 0x1c, 2);
-                        if (dev_priv->chipset == 0x50)
+                        if (device->chipset == 0x50)
                                 gr_def(ctx, offset + 0x1c, 0x00000040);
                         else
                                 gr_def(ctx, offset + 0x1c, 0x00000100);
                         gr_def(ctx, offset + 0x20, 0x00003800);
 
-                        if (dev_priv->chipset >= 0xa0) {
+                        if (device->chipset >= 0xa0) {
                                 cp_ctx(ctx, base + 0x54c, 2);
-                                if (!IS_NVA3F(dev_priv->chipset))
+                                if (!IS_NVA3F(device->chipset))
                                         gr_def(ctx, base + 0x54c, 0x003fe006);
                                 else
                                         gr_def(ctx, base + 0x54c, 0x003fe007);
                                 gr_def(ctx, base + 0x550, 0x003fe000);
                         }
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 offset = base + 0xa00;
                         else
                                 offset = base + 0x680;
                         cp_ctx(ctx, offset, 1);
                         gr_def(ctx, offset, 0x00404040);
 
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 offset = base + 0xe00;
                         else
                                 offset = base + 0x700;
                         cp_ctx(ctx, offset, 2);
-                        if (dev_priv->chipset < 0xa0)
+                        if (device->chipset < 0xa0)
                                 gr_def(ctx, offset, 0x0077f005);
-                        else if (dev_priv->chipset == 0xa5)
+                        else if (device->chipset == 0xa5)
                                 gr_def(ctx, offset, 0x6cf7f007);
-                        else if (dev_priv->chipset == 0xa8)
+                        else if (device->chipset == 0xa8)
                                 gr_def(ctx, offset, 0x6cfff007);
-                        else if (dev_priv->chipset == 0xac)
+                        else if (device->chipset == 0xac)
                                 gr_def(ctx, offset, 0x0cfff007);
                         else
                                 gr_def(ctx, offset, 0x0cf7f007);
-                        if (dev_priv->chipset == 0x50)
+                        if (device->chipset == 0x50)
                                 gr_def(ctx, offset + 0x4, 0x00007fff);
-                        else if (dev_priv->chipset < 0xa0)
+                        else if (device->chipset < 0xa0)
                                 gr_def(ctx, offset + 0x4, 0x003f7fff);
                         else
                                 gr_def(ctx, offset + 0x4, 0x02bf7fff);
                         cp_ctx(ctx, offset + 0x2c, 1);
-                        if (dev_priv->chipset == 0x50) {
+                        if (device->chipset == 0x50) {
                                 cp_ctx(ctx, offset + 0x50, 9);
                                 gr_def(ctx, offset + 0x54, 0x000003ff);
                                 gr_def(ctx, offset + 0x58, 0x00000003);
@@ -785,7 +766,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
                                 gr_def(ctx, offset + 0x64, 0x0000001f);
                                 gr_def(ctx, offset + 0x68, 0x0000000f);
                                 gr_def(ctx, offset + 0x6c, 0x0000000f);
-                        } else if (dev_priv->chipset < 0xa0) {
+                        } else if (device->chipset < 0xa0) {
                                 cp_ctx(ctx, offset + 0x50, 1);
                                 cp_ctx(ctx, offset + 0x70, 1);
                         } else {
@@ -797,7 +778,7 @@ nv50_graph_construct_mmio(struct nouveau_grctx *ctx)
 }
 
 static void
-dd_emit(struct nouveau_grctx *ctx, int num, uint32_t val) {
+dd_emit(struct nouveau_grctx *ctx, int num, u32 val) {
         int i;
         if (val && ctx->mode == NOUVEAU_GRCTX_VALS)
                 for (i = 0; i < num; i++)
@@ -808,7 +789,7 @@ dd_emit(struct nouveau_grctx *ctx, int num, uint32_t val) {
 static void
 nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int base, num;
         base = ctx->ctxvals_pos;
 
@@ -822,7 +803,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 1);     /* 00000001 SRC_LINEAR #1 */
         dd_emit(ctx, 1, 0);     /* 000000ff SRC_ADDRESS_HIGH */
         dd_emit(ctx, 1, 0);     /* 00000001 SRC_SRGB */
-        if (dev_priv->chipset >= 0x94)
+        if (device->chipset >= 0x94)
                 dd_emit(ctx, 1, 0);     /* 00000003 eng2d UNK0258 */
         dd_emit(ctx, 1, 1);     /* 00000fff SRC_DEPTH */
         dd_emit(ctx, 1, 0x100); /* 0000ffff SRC_HEIGHT */
@@ -851,7 +832,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 1);             /* 0000007f BLOCKDIM_Z */
         dd_emit(ctx, 1, 4);             /* 000000ff CP_REG_ALLOC_TEMP */
         dd_emit(ctx, 1, 1);             /* 00000001 BLOCKDIM_DIRTY */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 dd_emit(ctx, 1, 0);     /* 00000003 UNK03E8 */
         dd_emit(ctx, 1, 1);             /* 0000007f BLOCK_ALLOC_HALFWARPS */
         dd_emit(ctx, 1, 1);             /* 00000007 LOCAL_WARPS_NO_CLAMP */
@@ -863,7 +844,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 1);             /* 000007ff BLOCK_ALLOC_THREADS */
 
         /* compat 2d state */
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 dd_emit(ctx, 4, 0);             /* 0000ffff clip X, Y, W, H */
 
                 dd_emit(ctx, 1, 1);             /* ffffffff chroma COLOR_FORMAT */
@@ -923,7 +904,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 0x100);         /* ffffffff m2mf TILING_PITCH_IN */
 
         /* more compat 2d state */
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 dd_emit(ctx, 1, 1);             /* ffffffff line COLOR_FORMAT */
                 dd_emit(ctx, 1, 0);             /* ffffffff line OPERATION */
 
@@ -957,18 +938,18 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 0);             /* 000000ff UNK12B0_2 */
         dd_emit(ctx, 1, 0);             /* 0000000f FP_TEXTURES_LOG2 */
         dd_emit(ctx, 1, 0);             /* 0000000f FP_SAMPLERS_LOG2 */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 dd_emit(ctx, 1, 0);     /* ffffffff */
                 dd_emit(ctx, 1, 0);     /* 0000007f MULTISAMPLE_SAMPLES_LOG2 */
         } else {
                 dd_emit(ctx, 1, 0);     /* 0000000f MULTISAMPLE_SAMPLES_LOG2 */
         }
         dd_emit(ctx, 1, 0xc);           /* 000000ff SEMANTIC_COLOR.BFC0_ID */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 dd_emit(ctx, 1, 0);     /* 00000001 SEMANTIC_COLOR.CLMP_EN */
         dd_emit(ctx, 1, 8);             /* 000000ff SEMANTIC_COLOR.COLR_NR */
         dd_emit(ctx, 1, 0x14);          /* 000000ff SEMANTIC_COLOR.FFC0_ID */
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 dd_emit(ctx, 1, 0);     /* 000000ff SEMANTIC_LAYER */
                 dd_emit(ctx, 1, 0);     /* 00000001 */
         } else {
@@ -994,7 +975,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 8, 0);             /* ffffffff RT_ADDRESS_LOW */
         dd_emit(ctx, 1, 0xcf);          /* 000000ff RT_FORMAT */
         dd_emit(ctx, 7, 0);             /* 000000ff RT_FORMAT */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 dd_emit(ctx, 3, 0);     /* 1, 1, 1 */
         else
                 dd_emit(ctx, 2, 0);     /* 1, 1 */
@@ -1002,15 +983,15 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 0x80);          /* 0000ffff GP_VERTEX_OUTPUT_COUNT*/
         dd_emit(ctx, 1, 4);             /* 000000ff GP_REG_ALLOC_RESULT */
         dd_emit(ctx, 1, 4);             /* 000000ff GP_RESULT_MAP_SIZE */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 dd_emit(ctx, 1, 3);     /* 00000003 */
                 dd_emit(ctx, 1, 0);     /* 00000001 UNK1418. Alone. */
         }
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 dd_emit(ctx, 1, 3);     /* 00000003 UNK15AC */
         dd_emit(ctx, 1, 1);             /* ffffffff RASTERIZE_ENABLE */
         dd_emit(ctx, 1, 0);             /* 00000001 FP_CONTROL.EXPORTS_Z */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 dd_emit(ctx, 1, 0);     /* 00000001 FP_CONTROL.MULTIPLE_RESULTS */
         dd_emit(ctx, 1, 0x12);          /* 000000ff FP_INTERPOLANT_CTRL.COUNT */
         dd_emit(ctx, 1, 0x10);          /* 000000ff FP_INTERPOLANT_CTRL.COUNT_NONFLAT */
@@ -1022,16 +1003,16 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 4);             /* 000000ff FP_RESULT_COUNT */
         dd_emit(ctx, 1, 2);             /* ffffffff REG_MODE */
         dd_emit(ctx, 1, 4);             /* 000000ff FP_REG_ALLOC_TEMP */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 dd_emit(ctx, 1, 0);     /* ffffffff */
         dd_emit(ctx, 1, 0);             /* 00000001 GP_BUILTIN_RESULT_EN.LAYER_IDX */
         dd_emit(ctx, 1, 0);             /* ffffffff STRMOUT_ENABLE */
         dd_emit(ctx, 1, 0x3fffff);      /* 003fffff TIC_LIMIT */
         dd_emit(ctx, 1, 0x1fff);        /* 000fffff TSC_LIMIT */
         dd_emit(ctx, 1, 0);             /* 00000001 VERTEX_TWO_SIDE_ENABLE*/
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 dd_emit(ctx, 8, 0);     /* 00000001 */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 dd_emit(ctx, 1, 1);     /* 00000007 VTX_ATTR_DEFINE.COMP */
                 dd_emit(ctx, 1, 1);     /* 00000007 VTX_ATTR_DEFINE.SIZE */
                 dd_emit(ctx, 1, 2);     /* 00000007 VTX_ATTR_DEFINE.TYPE */
@@ -1042,20 +1023,20 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 1);             /* 00000001 ZETA_ENABLE */
         dd_emit(ctx, 1, 0);             /* 0000000f VP_TEXTURES_LOG2 */
         dd_emit(ctx, 1, 0);             /* 0000000f VP_SAMPLERS_LOG2 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 dd_emit(ctx, 1, 0);     /* 00000001 */
         dd_emit(ctx, 1, 2);             /* 00000003 POLYGON_MODE_BACK */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 dd_emit(ctx, 1, 0);     /* 00000003 VTX_ATTR_DEFINE.SIZE - 1 */
         dd_emit(ctx, 1, 0);             /* 0000ffff CB_ADDR_INDEX */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 dd_emit(ctx, 1, 0);     /* 00000003 */
         dd_emit(ctx, 1, 0);             /* 00000001 CULL_FACE_ENABLE */
         dd_emit(ctx, 1, 1);             /* 00000003 CULL_FACE */
         dd_emit(ctx, 1, 0);             /* 00000001 FRONT_FACE */
         dd_emit(ctx, 1, 2);             /* 00000003 POLYGON_MODE_FRONT */
         dd_emit(ctx, 1, 0x1000);        /* 00007fff UNK141C */
-        if (dev_priv->chipset != 0x50) {
+        if (device->chipset != 0x50) {
                 dd_emit(ctx, 1, 0xe00);         /* 7fff */
                 dd_emit(ctx, 1, 0x1000);        /* 7fff */
                 dd_emit(ctx, 1, 0x1e00);        /* 7fff */
@@ -1070,10 +1051,10 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
         dd_emit(ctx, 1, 0);             /* 00000001 VTX_ATTR_MASK_UNK0 nonempty */
         dd_emit(ctx, 1, 0);             /* 00000001 VTX_ATTR_MASK_UNK1 nonempty */
         dd_emit(ctx, 1, 0x200);         /* 0003ffff GP_VERTEX_OUTPUT_COUNT*GP_REG_ALLOC_RESULT */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 dd_emit(ctx, 1, 0x200);
         dd_emit(ctx, 1, 0);             /* 00000001 */
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 dd_emit(ctx, 1, 1);     /* 00000001 */
                 dd_emit(ctx, 1, 0x70);  /* 000000ff */
                 dd_emit(ctx, 1, 0x80);  /* 000000ff */
@@ -1120,7 +1101,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
 
         num = ctx->ctxvals_pos - base;
         ctx->ctxvals_pos = base;
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 cp_ctx(ctx, 0x404800, num);
         else
                 cp_ctx(ctx, 0x405400, num);
@@ -1169,7 +1150,7 @@ nv50_graph_construct_mmio_ddata(struct nouveau_grctx *ctx)
  */
 
 static void
-xf_emit(struct nouveau_grctx *ctx, int num, uint32_t val) {
+xf_emit(struct nouveau_grctx *ctx, int num, u32 val) {
         int i;
         if (val && ctx->mode == NOUVEAU_GRCTX_VALS)
                 for (i = 0; i < num; i++)
@@ -1201,16 +1182,16 @@ static void nv50_graph_construct_xfer_tp(struct nouveau_grctx *ctx);
 static void
 nv50_graph_construct_xfer1(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
         int offset;
         int size = 0;
-        uint32_t units = nv_rd32 (ctx->dev, 0x1540);
+        u32 units = nv_rd32 (ctx->device, 0x1540);
 
         offset = (ctx->ctxvals_pos+0x3f)&~0x3f;
         ctx->ctxvals_base = offset;
 
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 /* Strand 0 */
                 ctx->ctxvals_pos = offset;
                 nv50_graph_construct_gene_dispatch(ctx);
@@ -1280,7 +1261,7 @@ nv50_graph_construct_xfer1(struct nouveau_grctx *ctx)
 
                 /* Strand 2 */
                 ctx->ctxvals_pos = offset + 2;
-                if (dev_priv->chipset == 0xa0)
+                if (device->chipset == 0xa0)
                         nv50_graph_construct_gene_unk14xx(ctx);
                 nv50_graph_construct_gene_unk24xx(ctx);
                 if ((ctx->ctxvals_pos-offset)/8 > size)
@@ -1327,7 +1308,7 @@ nv50_graph_construct_xfer1(struct nouveau_grctx *ctx)
 
                 /* Strand 7 */
                 ctx->ctxvals_pos = offset + 7;
-                if (dev_priv->chipset == 0xa0) {
+                if (device->chipset == 0xa0) {
                         if (units & (1 << 4))
                                 nv50_graph_construct_xfer_tp(ctx);
                         if (units & (1 << 5))
@@ -1365,24 +1346,24 @@ static void
 nv50_graph_construct_gene_dispatch(struct nouveau_grctx *ctx)
 {
         /* start of strand 0 */
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* SEEK */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 5, 0);
-        else if (!IS_NVA3F(dev_priv->chipset))
+        else if (!IS_NVA3F(device->chipset))
                 xf_emit(ctx, 6, 0);
         else
                 xf_emit(ctx, 4, 0);
         /* SEEK */
         /* the PGRAPH's internal FIFO */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 8*3, 0);
         else
                 xf_emit(ctx, 0x100*3, 0);
         /* and another bonus slot?!? */
         xf_emit(ctx, 3, 0);
         /* and YET ANOTHER bonus slot? */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 3, 0);
         /* SEEK */
         /* CTX_SWITCH: caches of gr objects bound to subchannels. 8 values, last used index */
@@ -1394,7 +1375,7 @@ nv50_graph_construct_gene_dispatch(struct nouveau_grctx *ctx)
         /* SEEK */
         xf_emit(ctx, 9, 0);
         /* SEEK */
-        if (dev_priv->chipset < 0x90)
+        if (device->chipset < 0x90)
                 xf_emit(ctx, 4, 0);
         /* SEEK */
         xf_emit(ctx, 2, 0);
@@ -1407,9 +1388,9 @@ nv50_graph_construct_gene_dispatch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 6*2, 0);
         xf_emit(ctx, 2, 0);
         /* SEEK */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 0x1c, 0);
-        else if (dev_priv->chipset < 0xa0)
+        else if (device->chipset < 0xa0)
                 xf_emit(ctx, 0x1e, 0);
         else
                 xf_emit(ctx, 0x22, 0);
@@ -1421,9 +1402,9 @@ static void
 nv50_graph_construct_gene_m2mf(struct nouveau_grctx *ctx)
 {
         /* Strand 0, right after dispatch */
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int smallm2mf = 0;
-        if (dev_priv->chipset < 0x92 || dev_priv->chipset == 0x98)
+        if (device->chipset < 0x92 || device->chipset == 0x98)
                 smallm2mf = 1;
         /* SEEK */
         xf_emit (ctx, 1, 0);            /* DMA_NOTIFY instance >> 4 */
@@ -1472,10 +1453,10 @@ nv50_graph_construct_gene_m2mf(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_ccache(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         xf_emit(ctx, 2, 0);             /* RO */
         xf_emit(ctx, 0x800, 0);         /* ffffffff */
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x50:
         case 0x92:
         case 0xa0:
@@ -1540,7 +1521,7 @@ nv50_graph_construct_gene_ccache(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_unk10xx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
         /* end of area 2 on pre-NVA0, area 1 on NVAx */
         xf_emit(ctx, 1, 4);             /* 000000ff GP_RESULT_MAP_SIZE */
@@ -1550,14 +1531,14 @@ nv50_graph_construct_gene_unk10xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 4);             /* 000000ff GP_REG_ALLOC_RESULT */
         xf_emit(ctx, 1, 0x80c14);       /* 01ffffff SEMANTIC_COLOR */
         xf_emit(ctx, 1, 0);             /* 00000001 VERTEX_TWO_SIDE_ENABLE */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 1, 0x3ff);
         else
                 xf_emit(ctx, 1, 0x7ff); /* 000007ff */
         xf_emit(ctx, 1, 0);             /* 111/113 */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A30 */
         for (i = 0; i < 8; i++) {
-                switch (dev_priv->chipset) {
+                switch (device->chipset) {
                 case 0x50:
                 case 0x86:
                 case 0x98:
@@ -1600,7 +1581,7 @@ nv50_graph_construct_gene_unk10xx(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_unk34xx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* end of area 2 on pre-NVA0, area 1 on NVAx */
         xf_emit(ctx, 1, 0);             /* 00000001 VIEWPORT_CLIP_RECTS_EN */
         xf_emit(ctx, 1, 0);             /* 00000003 VIEWPORT_CLIP_MODE */
@@ -1614,9 +1595,9 @@ nv50_graph_construct_gene_unk34xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000003 WINDOW_ORIGIN */
         xf_emit(ctx, 1, 0);             /* 00000007 */
         xf_emit(ctx, 1, 0x1fe21);       /* 0001ffff tesla UNK0FAC */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 1, 0x0fac6881);
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 1);
                 xf_emit(ctx, 3, 0);
         }
@@ -1625,9 +1606,9 @@ nv50_graph_construct_gene_unk34xx(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_unk14xx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* middle of area 2 on pre-NVA0, beginning of area 2 on NVA0, area 7 on >NVA0 */
-        if (dev_priv->chipset != 0x50) {
+        if (device->chipset != 0x50) {
                 xf_emit(ctx, 5, 0);             /* ffffffff */
                 xf_emit(ctx, 1, 0x80c14);       /* 01ffffff SEMANTIC_COLOR */
                 xf_emit(ctx, 1, 0);             /* 00000001 */
@@ -1643,14 +1624,14 @@ nv50_graph_construct_gene_unk14xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);                     /* 00000001 GP_ENABLE */
         xf_emit(ctx, 1, 0x10);                  /* 7f/ff VIEW_VOLUME_CLIP_CTRL */
         xf_emit(ctx, 1, 0);                     /* 000000ff VP_CLIP_DISTANCE_ENABLE */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 0);             /* 3ff */
         xf_emit(ctx, 1, 0);                     /* 000000ff tesla UNK1940 */
         xf_emit(ctx, 1, 0);                     /* 00000001 tesla UNK0D7C */
         xf_emit(ctx, 1, 0x804);                 /* 00000fff SEMANTIC_CLIP */
         xf_emit(ctx, 1, 1);                     /* 00000001 VIEWPORT_TRANSFORM_EN */
         xf_emit(ctx, 1, 0x1a);                  /* 0000001f POLYGON_MODE */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 0x7f);          /* 000000ff tesla UNK0FFC */
         xf_emit(ctx, 1, 0);                     /* ffffffff tesla UNK1A30 */
         xf_emit(ctx, 1, 1);                     /* 00000001 SHADE_MODEL */
@@ -1669,7 +1650,7 @@ nv50_graph_construct_gene_unk14xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 4, 0);                     /* ffffffff NOPERSPECTIVE_BITMAP */
         xf_emit(ctx, 1, 0);                     /* 00000001 tesla UNK1900 */
         xf_emit(ctx, 1, 0);                     /* 0000000f */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 1, 0x3ff);         /* 000003ff tesla UNK0D68 */
         else
                 xf_emit(ctx, 1, 0x7ff);         /* 000007ff tesla UNK0D68 */
@@ -1704,11 +1685,11 @@ nv50_graph_construct_gene_unk14xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);                     /* 00000001 LINE_STIPPLE_ENABLE */
         xf_emit(ctx, 1, 0);                     /* 00000001 LINE_SMOOTH_ENABLE */
         xf_emit(ctx, 1, 0);                     /* 00000007 MULTISAMPLE_SAMPLES_LOG2 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 0);             /* 00000001 */
         xf_emit(ctx, 1, 0x1a);                  /* 0000001f POLYGON_MODE */
         xf_emit(ctx, 1, 0x10);                  /* 000000ff VIEW_VOLUME_CLIP_CTRL */
-        if (dev_priv->chipset != 0x50) {
+        if (device->chipset != 0x50) {
                 xf_emit(ctx, 1, 0);             /* ffffffff */
                 xf_emit(ctx, 1, 0);             /* 00000001 */
                 xf_emit(ctx, 1, 0);             /* 000003ff */
@@ -1736,7 +1717,7 @@ nv50_graph_construct_gene_unk14xx(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_zcull(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* end of strand 0 on pre-NVA0, beginning of strand 6 on NVAx */
         /* SEEK */
         xf_emit(ctx, 1, 0x3f);          /* 0000003f UNK1590 */
@@ -1774,7 +1755,7 @@ nv50_graph_construct_gene_zcull(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 STENCIL_BACK_ENABLE */
         xf_emit(ctx, 1, 0);             /* ffffffff CLEAR_DEPTH */
         xf_emit(ctx, 1, 0);             /* 00000007 */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 0);     /* 00000003 tesla UNK1108 */
         xf_emit(ctx, 1, 0);             /* 00000001 SAMPLECNT_ENABLE */
         xf_emit(ctx, 1, 0);             /* 0000000f ZETA_FORMAT */
@@ -1789,7 +1770,7 @@ nv50_graph_construct_gene_zcull(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 VIEWPORT_CLIP_RECTS_EN */
         xf_emit(ctx, 1, 3);             /* 00000003 FP_CTRL_UNK196C */
         xf_emit(ctx, 1, 0);             /* 00000003 tesla UNK1968 */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 0);     /* 0fffffff tesla UNK1104 */
         xf_emit(ctx, 1, 0);             /* 00000001 tesla UNK151C */
 }
@@ -1817,7 +1798,7 @@ nv50_graph_construct_gene_clipid(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_unk24xx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
         /* middle of strand 0 on pre-NVA0 [after m2mf], end of strand 2 on NVAx */
         /* SEEK */
@@ -1829,7 +1810,7 @@ nv50_graph_construct_gene_unk24xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 4);             /* 0000007f VP_RESULT_MAP_SIZE */
         xf_emit(ctx, 1, 4);             /* 000000ff GP_RESULT_MAP_SIZE */
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 4, 0);     /* RO */
                 xf_emit(ctx, 0xe10, 0); /* 190 * 9: 8*ffffffff, 7ff */
                 xf_emit(ctx, 1, 0);     /* 1ff */
@@ -1860,7 +1841,7 @@ nv50_graph_construct_gene_unk24xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 4);             /* 000000ff GP_RESULT_MAP_SIZE */
         xf_emit(ctx, 1, 4);             /* 0000007f VP_RESULT_MAP_SIZE */
         xf_emit(ctx, 1, 0x8100c12);     /* 1fffffff FP_INTERPOLANT_CTRL */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 3);     /* 00000003 tesla UNK1100 */
         /* SEEK */
         xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
@@ -1869,7 +1850,7 @@ nv50_graph_construct_gene_unk24xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0x80c14);       /* 01ffffff SEMANTIC_COLOR */
         xf_emit(ctx, 1, 1);             /* 00000001 */
         /* SEEK */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 2, 4);     /* 000000ff */
         xf_emit(ctx, 1, 0x80c14);       /* 01ffffff SEMANTIC_COLOR */
         xf_emit(ctx, 1, 0);             /* 00000001 VERTEX_TWO_SIDE_ENABLE */
@@ -1893,20 +1874,20 @@ nv50_graph_construct_gene_unk24xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 0x10, 0);          /* 00ffffff POINT_COORD_REPLACE_MAP */
         xf_emit(ctx, 1, 0);             /* 00000003 WINDOW_ORIGIN */
         xf_emit(ctx, 1, 0x8100c12);     /* 1fffffff FP_INTERPOLANT_CTRL */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 0);     /* 000003ff */
 }
 
 static void
 nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int acnt = 0x10, rep, i;
         /* beginning of strand 1 on pre-NVA0, strand 3 on NVAx */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 acnt = 0x20;
         /* SEEK */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 1, 0);     /* ffffffff tesla UNK13A4 */
                 xf_emit(ctx, 1, 1);     /* 00000fff tesla UNK1318 */
         }
@@ -1923,9 +1904,9 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 0000ffff turing USER_PARAM_COUNT */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A30 */
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0xb, 0);   /* RO */
-        else if (dev_priv->chipset >= 0xa0)
+        else if (device->chipset >= 0xa0)
                 xf_emit(ctx, 0x9, 0);   /* RO */
         else
                 xf_emit(ctx, 0x8, 0);   /* RO */
@@ -1944,11 +1925,11 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 4);             /* 000001ff UNK1A28 */
         xf_emit(ctx, 1, 8);             /* 000001ff UNK0DF0 */
         xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 1, 0x3ff); /* 3ff tesla UNK0D68 */
         else
                 xf_emit(ctx, 1, 0x7ff); /* 7ff tesla UNK0D68 */
-        if (dev_priv->chipset == 0xa8)
+        if (device->chipset == 0xa8)
                 xf_emit(ctx, 1, 0x1e00);        /* 7fff */
         /* SEEK */
         xf_emit(ctx, 0xc, 0);           /* RO or close */
@@ -1956,13 +1937,13 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0xf);           /* ffffffff VP_ATTR_EN */
         xf_emit(ctx, (acnt/8)-1, 0);    /* ffffffff VP_ATTR_EN */
         xf_emit(ctx, 1, 0);             /* 0000000f VP_GP_BUILTIN_ATTR_EN */
-        if (dev_priv->chipset > 0x50 && dev_priv->chipset < 0xa0)
+        if (device->chipset > 0x50 && device->chipset < 0xa0)
                 xf_emit(ctx, 2, 0);     /* ffffffff */
         else
                 xf_emit(ctx, 1, 0);     /* ffffffff */
         xf_emit(ctx, 1, 0);             /* 00000003 tesla UNK0FD8 */
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 0x10, 0);  /* 0? */
                 xf_emit(ctx, 2, 0);     /* weird... */
                 xf_emit(ctx, 2, 0);     /* RO */
@@ -1975,7 +1956,7 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* ffffffff VB_ELEMENT_BASE */
         xf_emit(ctx, 1, 0);             /* ffffffff UNK1438 */
         xf_emit(ctx, acnt, 0);          /* 1 tesla UNK1000 */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 1, 0);     /* ffffffff tesla UNK1118? */
         /* SEEK */
         xf_emit(ctx, acnt, 0);          /* ffffffff VERTEX_ARRAY_UNK90C */
@@ -2013,23 +1994,23 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, acnt, 0);          /* 000000ff VERTEX_LIMIT_HIGH */
         xf_emit(ctx, 3, 0);             /* f/1f */
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, acnt, 0);          /* f */
                 xf_emit(ctx, 3, 0);             /* f/1f */
         }
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 2, 0);     /* RO */
         else
                 xf_emit(ctx, 5, 0);     /* RO */
         /* SEEK */
         xf_emit(ctx, 1, 0);             /* ffff DMA_VTXBUF */
         /* SEEK */
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 xf_emit(ctx, 0x41, 0);  /* RO */
                 /* SEEK */
                 xf_emit(ctx, 0x11, 0);  /* RO */
-        } else if (!IS_NVA3F(dev_priv->chipset))
+        } else if (!IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0x50, 0);  /* RO */
         else
                 xf_emit(ctx, 0x58, 0);  /* RO */
@@ -2041,7 +2022,7 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, acnt*4, 0);        /* ffffffff VTX_ATTR */
         xf_emit(ctx, 4, 0);             /* f/1f, 0, 0, 0 */
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0x1d, 0);  /* RO */
         else
                 xf_emit(ctx, 0x16, 0);  /* RO */
@@ -2049,21 +2030,21 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0xf);           /* ffffffff VP_ATTR_EN */
         xf_emit(ctx, (acnt/8)-1, 0);    /* ffffffff VP_ATTR_EN */
         /* SEEK */
-        if (dev_priv->chipset < 0xa0)
+        if (device->chipset < 0xa0)
                 xf_emit(ctx, 8, 0);     /* RO */
-        else if (IS_NVA3F(dev_priv->chipset))
+        else if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0xc, 0);   /* RO */
         else
                 xf_emit(ctx, 7, 0);     /* RO */
         /* SEEK */
         xf_emit(ctx, 0xa, 0);           /* RO */
-        if (dev_priv->chipset == 0xa0)
+        if (device->chipset == 0xa0)
                 rep = 0xc;
         else
                 rep = 4;
         for (i = 0; i < rep; i++) {
                 /* SEEK */
-                if (IS_NVA3F(dev_priv->chipset))
+                if (IS_NVA3F(device->chipset))
                         xf_emit(ctx, 0x20, 0);  /* ffffffff */
                 xf_emit(ctx, 0x200, 0); /* ffffffff */
                 xf_emit(ctx, 4, 0);     /* 7f/ff, 0, 0, 0 */
@@ -2077,7 +2058,7 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 0000000f VP_GP_BUILTIN_ATTR_EN */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A30 */
         /* SEEK */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 7, 0);     /* weird... */
         else
                 xf_emit(ctx, 5, 0);     /* weird... */
@@ -2086,13 +2067,13 @@ nv50_graph_construct_gene_vfetch(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_eng2d(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* middle of strand 1 on pre-NVA0 [after vfetch], middle of strand 6 on NVAx */
         /* SEEK */
         xf_emit(ctx, 2, 0);             /* 0001ffff CLIP_X, CLIP_Y */
         xf_emit(ctx, 2, 0);             /* 0000ffff CLIP_W, CLIP_H */
         xf_emit(ctx, 1, 0);             /* 00000001 CLIP_ENABLE */
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 /* this is useless on everything but the original NV50,
                  * guess they forgot to nuke it. Or just didn't bother. */
                 xf_emit(ctx, 2, 0);     /* 0000ffff IFC_CLIP_X, Y */
@@ -2148,7 +2129,7 @@ nv50_graph_construct_gene_eng2d(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_csched(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* middle of strand 1 on pre-NVA0 [after eng2d], middle of strand 0 on NVAx */
         /* SEEK */
         xf_emit(ctx, 2, 0);             /* 00007fff WINDOW_OFFSET_XY... what is it doing here??? */
@@ -2173,7 +2154,7 @@ nv50_graph_construct_gene_csched(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 2);             /* 00000003 REG_MODE */
         /* SEEK */
         xf_emit(ctx, 0x40, 0);          /* ffffffff USER_PARAM */
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x50:
         case 0x92:
                 xf_emit(ctx, 8, 0);     /* 7, 0, 0, 0, ... */
@@ -2247,7 +2228,7 @@ nv50_graph_construct_gene_csched(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_unk1cxx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         xf_emit(ctx, 2, 0);             /* 00007fff WINDOW_OFFSET_XY */
         xf_emit(ctx, 1, 0x3f800000);    /* ffffffff LINE_WIDTH */
         xf_emit(ctx, 1, 0);             /* 00000001 LINE_SMOOTH_ENABLE */
@@ -2277,9 +2258,9 @@ nv50_graph_construct_gene_unk1cxx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 4);             /* 00000007 FP_CONTROL */
         xf_emit(ctx, 1, 0);             /* 00000001 ALPHA_TEST_ENABLE */
         xf_emit(ctx, 1, 0);             /* 00000007 ALPHA_TEST_FUNC */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 3);     /* 00000003 UNK16B4 */
-        else if (dev_priv->chipset >= 0xa0)
+        else if (device->chipset >= 0xa0)
                 xf_emit(ctx, 1, 1);     /* 00000001 UNK16B4 */
         xf_emit(ctx, 1, 0);             /* 00000003 MULTISAMPLE_CTRL */
         xf_emit(ctx, 1, 0);             /* 00000003 tesla UNK0F90 */
@@ -2293,11 +2274,11 @@ nv50_graph_construct_gene_unk1cxx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* ffffffff POINT_SIZE */
         xf_emit(ctx, 1, 0);             /* 00000001 */
         xf_emit(ctx, 1, 0);             /* 00000007 tesla UNK0FB4 */
-        if (dev_priv->chipset != 0x50) {
+        if (device->chipset != 0x50) {
                 xf_emit(ctx, 1, 0);     /* 3ff */
                 xf_emit(ctx, 1, 1);     /* 00000001 tesla UNK1110 */
         }
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 0);     /* 00000003 tesla UNK1928 */
         xf_emit(ctx, 0x10, 0);          /* ffffffff DEPTH_RANGE_NEAR */
         xf_emit(ctx, 0x10, 0x3f800000); /* ffffffff DEPTH_RANGE_FAR */
@@ -2316,11 +2297,11 @@ nv50_graph_construct_gene_unk1cxx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 1);             /* 00000001 ZETA_ENABLE */
         xf_emit(ctx, 1, 0);             /* 00000001 VERTEX_TWO_SIDE_ENABLE */
         xf_emit(ctx, 4, 0xffff);        /* 0000ffff MSAA_MASK */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 3);     /* 00000003 tesla UNK1100 */
-        if (dev_priv->chipset < 0xa0)
+        if (device->chipset < 0xa0)
                 xf_emit(ctx, 0x1c, 0);  /* RO */
-        else if (IS_NVA3F(dev_priv->chipset))
+        else if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0x9, 0);
         xf_emit(ctx, 1, 0);             /* 00000001 UNK1534 */
         xf_emit(ctx, 1, 0);             /* 00000001 LINE_SMOOTH_ENABLE */
@@ -2328,13 +2309,13 @@ nv50_graph_construct_gene_unk1cxx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0x00ffff00);    /* 00ffffff LINE_STIPPLE_PATTERN */
         xf_emit(ctx, 1, 0x1a);          /* 0000001f POLYGON_MODE */
         xf_emit(ctx, 1, 0);             /* 00000003 WINDOW_ORIGIN */
-        if (dev_priv->chipset != 0x50) {
+        if (device->chipset != 0x50) {
                 xf_emit(ctx, 1, 3);     /* 00000003 tesla UNK1100 */
                 xf_emit(ctx, 1, 0);     /* 3ff */
         }
         /* XXX: the following block could belong either to unk1cxx, or
          * to STRMOUT. Rather hard to tell. */
-        if (dev_priv->chipset < 0xa0)
+        if (device->chipset < 0xa0)
                 xf_emit(ctx, 0x25, 0);
         else
                 xf_emit(ctx, 0x3b, 0);
@@ -2343,18 +2324,18 @@ nv50_graph_construct_gene_unk1cxx(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_strmout(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         xf_emit(ctx, 1, 0x102);         /* 0000ffff STRMOUT_BUFFER_CTRL */
         xf_emit(ctx, 1, 0);             /* ffffffff STRMOUT_PRIMITIVE_COUNT */
         xf_emit(ctx, 4, 4);             /* 000000ff STRMOUT_NUM_ATTRIBS */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 4, 0);     /* ffffffff UNK1A8C */
                 xf_emit(ctx, 4, 0);     /* ffffffff UNK1780 */
         }
         xf_emit(ctx, 1, 4);             /* 000000ff GP_RESULT_MAP_SIZE */
         xf_emit(ctx, 1, 4);             /* 0000007f VP_RESULT_MAP_SIZE */
         xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 1, 0x3ff); /* 000003ff tesla UNK0D68 */
         else
                 xf_emit(ctx, 1, 0x7ff); /* 000007ff tesla UNK0D68 */
@@ -2365,7 +2346,7 @@ nv50_graph_construct_gene_strmout(struct nouveau_grctx *ctx)
         xf_emit(ctx, 4, 0);             /* 000000ff STRMOUT_ADDRESS_HIGH */
         xf_emit(ctx, 4, 0);             /* ffffffff STRMOUT_ADDRESS_LOW */
         xf_emit(ctx, 4, 4);             /* 000000ff STRMOUT_NUM_ATTRIBS */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 4, 0);     /* ffffffff UNK1A8C */
                 xf_emit(ctx, 4, 0);     /* ffffffff UNK1780 */
         }
@@ -2385,12 +2366,12 @@ nv50_graph_construct_gene_strmout(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_ropm1(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         xf_emit(ctx, 1, 0x4e3bfdf);     /* ffffffff UNK0D64 */
         xf_emit(ctx, 1, 0x4e3bfdf);     /* ffffffff UNK0DF4 */
         xf_emit(ctx, 1, 0);             /* 00000007 */
         xf_emit(ctx, 1, 0);             /* 000003ff */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 0x11);  /* 000000ff tesla UNK1968 */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
 }
@@ -2398,7 +2379,7 @@ nv50_graph_construct_gene_ropm1(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_ropm2(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         /* SEEK */
         xf_emit(ctx, 1, 0);             /* 0000ffff DMA_QUERY */
         xf_emit(ctx, 1, 0x0fac6881);    /* 0fffffff RT_CONTROL */
@@ -2416,7 +2397,7 @@ nv50_graph_construct_gene_ropm2(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 eng2d UNK260 */
         xf_emit(ctx, 1, 0);             /* ff/3ff */
         xf_emit(ctx, 1, 0);             /* 00000007 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 0x11);  /* 000000ff tesla UNK1968 */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
 }
@@ -2424,11 +2405,11 @@ nv50_graph_construct_gene_ropm2(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int magic2;
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 magic2 = 0x00003e60;
-        } else if (!IS_NVA3F(dev_priv->chipset)) {
+        } else if (!IS_NVA3F(device->chipset)) {
                 magic2 = 0x001ffe67;
         } else {
                 magic2 = 0x00087e67;
@@ -2446,14 +2427,14 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000007 DEPTH_TEST_FUNC */
         xf_emit(ctx, 1, 0);             /* 00000001 DEPTH_TEST_ENABLE */
         xf_emit(ctx, 1, 0);             /* 00000001 DEPTH_WRITE_ENABLE */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
         xf_emit(ctx, 1, 0);             /* 00000007 STENCIL_FRONT_FUNC_FUNC */
         xf_emit(ctx, 1, 0);             /* 000000ff STENCIL_FRONT_FUNC_MASK */
         xf_emit(ctx, 1, 0);             /* 000000ff STENCIL_FRONT_MASK */
         xf_emit(ctx, 3, 0);             /* 00000007 STENCIL_FRONT_OP_FAIL, ZFAIL, ZPASS */
         xf_emit(ctx, 1, 0);             /* 00000001 STENCIL_FRONT_ENABLE */
-        if (dev_priv->chipset >= 0xa0 && !IS_NVAAF(dev_priv->chipset))
+        if (device->chipset >= 0xa0 && !IS_NVAAF(device->chipset))
                 xf_emit(ctx, 1, 0x15);  /* 000000ff */
         xf_emit(ctx, 1, 0);             /* 00000001 STENCIL_BACK_ENABLE */
         xf_emit(ctx, 1, 1);             /* 00000001 tesla UNK15B4 */
@@ -2462,14 +2443,14 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 0000000f ZETA_FORMAT */
         xf_emit(ctx, 1, 1);             /* 00000001 ZETA_ENABLE */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
-        if (dev_priv->chipset == 0x86 || dev_priv->chipset == 0x92 || dev_priv->chipset == 0x98 || dev_priv->chipset >= 0xa0) {
+        if (device->chipset == 0x86 || device->chipset == 0x92 || device->chipset == 0x98 || device->chipset >= 0xa0) {
                 xf_emit(ctx, 3, 0);     /* ff, ffffffff, ffffffff */
                 xf_emit(ctx, 1, 4);     /* 7 */
                 xf_emit(ctx, 1, 0x400); /* fffffff */
                 xf_emit(ctx, 1, 0x300); /* ffff */
                 xf_emit(ctx, 1, 0x1001);        /* 1fff */
-                if (dev_priv->chipset != 0xa0) {
-                        if (IS_NVA3F(dev_priv->chipset))
+                if (device->chipset != 0xa0) {
+                        if (IS_NVA3F(device->chipset))
                                 xf_emit(ctx, 1, 0);     /* 0000000f UNK15C8 */
                         else
                                 xf_emit(ctx, 1, 0x15);  /* ff */
@@ -2547,7 +2528,7 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 1);             /* 00000001 ZETA_ENABLE */
         xf_emit(ctx, 1, 0);             /* ffffffff CLEAR_DEPTH */
         xf_emit(ctx, 1, 1);             /* 00000001 tesla UNK19CC */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 2, 0);
                 xf_emit(ctx, 1, 0x1001);
                 xf_emit(ctx, 0xb, 0);
@@ -2564,7 +2545,7 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 7, 0);             /* 0000000f COLOR_MASK */
         xf_emit(ctx, 1, 0x11);          /* 3f/7f */
         xf_emit(ctx, 1, 0);             /* 00000001 LOGIC_OP_ENABLE */
-        if (dev_priv->chipset != 0x50) {
+        if (device->chipset != 0x50) {
                 xf_emit(ctx, 1, 0);     /* 0000000f LOGIC_OP */
                 xf_emit(ctx, 1, 0);     /* 000000ff */
         }
@@ -2581,7 +2562,7 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, magic2);        /* 001fffff tesla UNK0F78 */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
         xf_emit(ctx, 1, 0x0fac6881);    /* 0fffffff RT_CONTROL */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 0);     /* 00000001 tesla UNK12E4 */
                 xf_emit(ctx, 8, 1);     /* 00000007 IBLEND_EQUATION_RGB */
                 xf_emit(ctx, 8, 1);     /* 00000007 IBLEND_EQUATION_ALPHA */
@@ -2600,7 +2581,7 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
                 xf_emit(ctx, 1, 0);     /* 00000001 */
                 xf_emit(ctx, 1, 0);     /* 000003ff */
-        } else if (dev_priv->chipset >= 0xa0) {
+        } else if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 2, 0);     /* 00000001 */
                 xf_emit(ctx, 1, 0);     /* 00000007 */
                 xf_emit(ctx, 1, 0);     /* 00000003 */
@@ -2614,7 +2595,7 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 4, 0);             /* ffffffff CLEAR_COLOR */
         xf_emit(ctx, 4, 0);             /* ffffffff BLEND_COLOR A R G B */
         xf_emit(ctx, 1, 0);             /* 00000fff eng2d UNK2B0 */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 2, 0);     /* 00000001 */
         xf_emit(ctx, 1, 0);             /* 000003ff */
         xf_emit(ctx, 8, 0);             /* 00000001 BLEND_ENABLE */
@@ -2628,9 +2609,9 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 UNK19C0 */
         xf_emit(ctx, 1, 0);             /* 00000001 LOGIC_OP_ENABLE */
         xf_emit(ctx, 1, 0);             /* 0000000f LOGIC_OP */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 1, 0);     /* 00000001 UNK12E4? NVA3+ only? */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 8, 1);     /* 00000001 IBLEND_UNK00 */
                 xf_emit(ctx, 8, 1);     /* 00000007 IBLEND_EQUATION_RGB */
                 xf_emit(ctx, 8, 2);     /* 0000001f IBLEND_FUNC_SRC_RGB */
@@ -2659,9 +2640,9 @@ nv50_graph_construct_gene_ropc(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer_unk84xx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int magic3;
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
         case 0x50:
                 magic3 = 0x1000;
                 break;
@@ -2681,16 +2662,16 @@ nv50_graph_construct_xfer_unk84xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A30 */
         xf_emit(ctx, 1, 0);             /* 111/113[NVA0+] */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0x1f, 0);  /* ffffffff */
-        else if (dev_priv->chipset >= 0xa0)
+        else if (device->chipset >= 0xa0)
                 xf_emit(ctx, 0x0f, 0);  /* ffffffff */
         else
                 xf_emit(ctx, 0x10, 0);  /* fffffff VP_RESULT_MAP_1 up */
         xf_emit(ctx, 2, 0);             /* f/1f[NVA3], fffffff/ffffffff[NVA0+] */
         xf_emit(ctx, 1, 4);             /* 7f/ff VP_REG_ALLOC_RESULT */
         xf_emit(ctx, 1, 4);             /* 7f/ff VP_RESULT_MAP_SIZE */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 1, 0x03020100);    /* ffffffff */
         else
                 xf_emit(ctx, 1, 0x00608080);    /* fffffff VP_RESULT_MAP_0 */
@@ -2733,11 +2714,11 @@ nv50_graph_construct_xfer_unk84xx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A30 */
         xf_emit(ctx, 1, 0);             /* 111/113 */
-        if (dev_priv->chipset == 0x94 || dev_priv->chipset == 0x96)
+        if (device->chipset == 0x94 || device->chipset == 0x96)
                 xf_emit(ctx, 0x1020, 0);        /* 4 x (0x400 x 0xffffffff, ff, 0, 0, 0, 4 x ffffffff) */
-        else if (dev_priv->chipset < 0xa0)
+        else if (device->chipset < 0xa0)
                 xf_emit(ctx, 0xa20, 0); /* 4 x (0x280 x 0xffffffff, ff, 0, 0, 0, 4 x ffffffff) */
-        else if (!IS_NVA3F(dev_priv->chipset))
+        else if (!IS_NVA3F(device->chipset))
                 xf_emit(ctx, 0x210, 0); /* ffffffff */
         else
                 xf_emit(ctx, 0x410, 0); /* ffffffff */
@@ -2751,12 +2732,12 @@ nv50_graph_construct_xfer_unk84xx(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int magic1, magic2;
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 magic1 = 0x3ff;
                 magic2 = 0x00003e60;
-        } else if (!IS_NVA3F(dev_priv->chipset)) {
+        } else if (!IS_NVA3F(device->chipset)) {
                 magic1 = 0x7ff;
                 magic2 = 0x001ffe67;
         } else {
@@ -2766,7 +2747,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000007 ALPHA_TEST_FUNC */
         xf_emit(ctx, 1, 0);             /* ffffffff ALPHA_TEST_REF */
         xf_emit(ctx, 1, 0);             /* 00000001 ALPHA_TEST_ENABLE */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000000f UNK16A0 */
         xf_emit(ctx, 1, 0);             /* 7/f MULTISAMPLE_SAMPLES_LOG2 */
         xf_emit(ctx, 1, 0);             /* 00000001 tesla UNK1534 */
@@ -2800,11 +2781,11 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 1);             /* 00000001 SIFC_BITMAP_WRITE_BIT0_ENABLE */
         xf_emit(ctx, 1, 0);             /* 00000007 ALPHA_TEST_FUNC */
         xf_emit(ctx, 1, 0);             /* 00000001 ALPHA_TEST_ENABLE */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 3);     /* 00000003 tesla UNK16B4 */
                 xf_emit(ctx, 1, 0);     /* 00000003 */
                 xf_emit(ctx, 1, 0);     /* 00000003 tesla UNK1298 */
-        } else if (dev_priv->chipset >= 0xa0) {
+        } else if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 1, 1);     /* 00000001 tesla UNK16B4 */
                 xf_emit(ctx, 1, 0);     /* 00000003 */
         } else {
@@ -2818,7 +2799,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 1);             /* 0000001f BLEND_FUNC_DST_RGB */
         xf_emit(ctx, 1, 1);             /* 00000007 BLEND_EQUATION_RGB */
         xf_emit(ctx, 1, 2);             /* 0000001f BLEND_FUNC_SRC_RGB */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 0);     /* 00000001 UNK12E4 */
                 xf_emit(ctx, 8, 1);     /* 00000007 IBLEND_EQUATION_RGB */
                 xf_emit(ctx, 8, 1);     /* 00000007 IBLEND_EQUATION_ALPHA */
@@ -2846,7 +2827,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0xcf);          /* 000000ff SIFC_FORMAT */
         xf_emit(ctx, 1, 0xcf);          /* 000000ff DRAW_COLOR_FORMAT */
         xf_emit(ctx, 1, 0xcf);          /* 000000ff SRC_FORMAT */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
         xf_emit(ctx, 1, 0);             /* 7/f[NVA3] MULTISAMPLE_SAMPLES_LOG2 */
@@ -2870,9 +2851,9 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 DEPTH_TEST_ENABLE */
         xf_emit(ctx, 1, 0x11);          /* 3f/7f DST_FORMAT */
         xf_emit(ctx, 1, 1);             /* 00000001 DST_LINEAR */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 1, 0);     /* ff */
         else
                 xf_emit(ctx, 3, 0);     /* 1, 7, 3ff */
@@ -2907,7 +2888,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 1);             /* 00000001 ZETA_ENABLE */
         xf_emit(ctx, 1, 0);             /* 00000007 */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
         xf_emit(ctx, 8, 0);             /* 0000ffff DMA_COLOR */
         xf_emit(ctx, 1, 0);             /* 0000ffff DMA_GLOBAL */
@@ -2945,7 +2926,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 0001ffff GP_BUILTIN_RESULT_EN */
         xf_emit(ctx, 1, 0);             /* 00000003 UNK0F90 */
         xf_emit(ctx, 1, 0);             /* 00000007 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
         xf_emit(ctx, 1, magic2);        /* 001fffff tesla UNK0F78 */
         xf_emit(ctx, 1, 0);             /* 7/f MULTISAMPLE_SAMPLES_LOG2 */
@@ -2974,7 +2955,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0x1001);        /* 00001fff ZETA_ARRAY_MODE */
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
         xf_emit(ctx, 1, 0);             /* 7/f MULTISAMPLE_SAMPLES_LOG2 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 0);     /* 00000001 */
         xf_emit(ctx, 1, 0);             /* ffff0ff3 */
         xf_emit(ctx, 1, 0x11);          /* 3f/7f RT_FORMAT */
@@ -2988,14 +2969,14 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 FRAMEBUFFER_SRGB */
         xf_emit(ctx, 1, 0);             /* 7 */
         xf_emit(ctx, 1, 0);             /* 00000001 LOGIC_OP_ENABLE */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 0);     /* 00000001 UNK1140 */
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
         }
         xf_emit(ctx, 1, 0);             /* 7/f MULTISAMPLE_SAMPLES_LOG2 */
         xf_emit(ctx, 1, 0);             /* 00000001 UNK1534 */
         xf_emit(ctx, 1, 0);             /* ffff0ff3 */
-        if (dev_priv->chipset >= 0xa0)
+        if (device->chipset >= 0xa0)
                 xf_emit(ctx, 1, 0x0fac6881);    /* fffffff */
         xf_emit(ctx, 1, magic2);        /* 001fffff tesla UNK0F78 */
         xf_emit(ctx, 1, 0);             /* 00000001 DEPTH_BOUNDS_EN */
@@ -3012,12 +2993,12 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 SAMPLECNT_ENABLE */
         xf_emit(ctx, 1, 0);             /* 0000000f ZETA_FORMAT */
         xf_emit(ctx, 1, 1);             /* 00000001 ZETA_ENABLE */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
                 xf_emit(ctx, 1, 0);     /* 0000000f tesla UNK15C8 */
         }
         xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A3C */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 3, 0);             /* 7/f, 1, ffff0ff3 */
                 xf_emit(ctx, 1, 0xfac6881);     /* fffffff */
                 xf_emit(ctx, 4, 0);             /* 1, 1, 1, 3ff */
@@ -3027,7 +3008,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
                 xf_emit(ctx, 2, 0);             /* 7, f */
                 xf_emit(ctx, 1, 1);             /* 1 */
                 xf_emit(ctx, 1, 0);             /* 7/f */
-                if (IS_NVA3F(dev_priv->chipset))
+                if (IS_NVA3F(device->chipset))
                         xf_emit(ctx, 0x9, 0);   /* 1 */
                 else
                         xf_emit(ctx, 0x8, 0);   /* 1 */
@@ -3041,7 +3022,7 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
                 xf_emit(ctx, 1, 0x11);          /* 7f */
                 xf_emit(ctx, 1, 1);             /* 1 */
                 xf_emit(ctx, 5, 0);             /* 1, 7, 3ff, 3, 7 */
-                if (IS_NVA3F(dev_priv->chipset)) {
+                if (IS_NVA3F(device->chipset)) {
                         xf_emit(ctx, 1, 0);     /* 00000001 UNK1140 */
                         xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
                 }
@@ -3051,15 +3032,15 @@ nv50_graph_construct_xfer_tprop(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer_tex(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         xf_emit(ctx, 2, 0);             /* 1 LINKED_TSC. yes, 2. */
-        if (dev_priv->chipset != 0x50)
+        if (device->chipset != 0x50)
                 xf_emit(ctx, 1, 0);     /* 3 */
         xf_emit(ctx, 1, 1);             /* 1ffff BLIT_DU_DX_INT */
         xf_emit(ctx, 1, 0);             /* fffff BLIT_DU_DX_FRACT */
         xf_emit(ctx, 1, 1);             /* 1ffff BLIT_DV_DY_INT */
         xf_emit(ctx, 1, 0);             /* fffff BLIT_DV_DY_FRACT */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 1, 0);     /* 3 BLIT_CONTROL */
         else
                 xf_emit(ctx, 2, 0);     /* 3ff, 1 */
@@ -3071,13 +3052,13 @@ nv50_graph_construct_xfer_tex(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0x10100);       /* ffffffff SRC_TIC_5 */
         xf_emit(ctx, 1, 0x02800000);    /* ffffffff SRC_TIC_6 */
         xf_emit(ctx, 1, 0);             /* ffffffff SRC_TIC_7 */
-        if (dev_priv->chipset == 0x50) {
+        if (device->chipset == 0x50) {
                 xf_emit(ctx, 1, 0);     /* 00000001 turing UNK358 */
                 xf_emit(ctx, 1, 0);     /* ffffffff tesla UNK1A34? */
                 xf_emit(ctx, 1, 0);     /* 00000003 turing UNK37C tesla UNK1690 */
                 xf_emit(ctx, 1, 0);     /* 00000003 BLIT_CONTROL */
                 xf_emit(ctx, 1, 0);     /* 00000001 turing UNK32C tesla UNK0F94 */
-        } else if (!IS_NVAAF(dev_priv->chipset)) {
+        } else if (!IS_NVAAF(device->chipset)) {
                 xf_emit(ctx, 1, 0);     /* ffffffff tesla UNK1A34? */
                 xf_emit(ctx, 1, 0);     /* 00000003 */
                 xf_emit(ctx, 1, 0);     /* 000003ff */
@@ -3097,7 +3078,7 @@ nv50_graph_construct_xfer_tex(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer_unk8cxx(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         xf_emit(ctx, 1, 0);             /* 00000001 UNK1534 */
         xf_emit(ctx, 1, 0);             /* 7/f MULTISAMPLE_SAMPLES_LOG2 */
         xf_emit(ctx, 2, 0);             /* 7, ffff0ff3 */
@@ -3109,7 +3090,7 @@ nv50_graph_construct_xfer_unk8cxx(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);             /* 00000001 LINE_STIPPLE_ENABLE */
         xf_emit(ctx, 1, 0x00ffff00);    /* 00ffffff LINE_STIPPLE_PATTERN */
         xf_emit(ctx, 1, 1);             /* 00000001 tesla UNK0F98 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);     /* 0000001f tesla UNK169C */
         xf_emit(ctx, 1, 0);             /* 00000003 tesla UNK1668 */
         xf_emit(ctx, 1, 0);             /* 00000001 LINE_STIPPLE_ENABLE */
@@ -3136,8 +3117,8 @@ nv50_graph_construct_xfer_unk8cxx(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer_tp(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
-        if (dev_priv->chipset < 0xa0) {
+        struct nouveau_device *device = ctx->device;
+        if (device->chipset < 0xa0) {
                 nv50_graph_construct_xfer_unk84xx(ctx);
                 nv50_graph_construct_xfer_tprop(ctx);
                 nv50_graph_construct_xfer_tex(ctx);
@@ -3153,9 +3134,9 @@ nv50_graph_construct_xfer_tp(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i, mpcnt = 2;
-        switch (dev_priv->chipset) {
+        switch (device->chipset) {
                 case 0x98:
                 case 0xaa:
                         mpcnt = 1;
@@ -3182,34 +3163,34 @@ nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
                 xf_emit(ctx, 1, 0x80);          /* ffffffff tesla UNK1404 */
                 xf_emit(ctx, 1, 0x80007004);    /* ffffffff tesla UNK12B0 */
                 xf_emit(ctx, 1, 0x04000400);    /* ffffffff */
-                if (dev_priv->chipset >= 0xa0)
+                if (device->chipset >= 0xa0)
                         xf_emit(ctx, 1, 0xc0);  /* 00007fff tesla UNK152C */
                 xf_emit(ctx, 1, 0x1000);        /* 0000ffff tesla UNK0D60 */
                 xf_emit(ctx, 1, 0);             /* ff/3ff */
                 xf_emit(ctx, 1, 0);             /* ffffffff tesla UNK1A30 */
-                if (dev_priv->chipset == 0x86 || dev_priv->chipset == 0x98 || dev_priv->chipset == 0xa8 || IS_NVAAF(dev_priv->chipset)) {
+                if (device->chipset == 0x86 || device->chipset == 0x98 || device->chipset == 0xa8 || IS_NVAAF(device->chipset)) {
                         xf_emit(ctx, 1, 0xe00);         /* 7fff */
                         xf_emit(ctx, 1, 0x1e00);        /* 7fff */
                 }
                 xf_emit(ctx, 1, 1);             /* 000000ff VP_REG_ALLOC_TEMP */
                 xf_emit(ctx, 1, 0);             /* 00000001 LINKED_TSC */
                 xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
-                if (dev_priv->chipset == 0x50)
+                if (device->chipset == 0x50)
                         xf_emit(ctx, 2, 0x1000);        /* 7fff tesla UNK141C */
                 xf_emit(ctx, 1, 1);             /* 000000ff GP_REG_ALLOC_TEMP */
                 xf_emit(ctx, 1, 0);             /* 00000001 GP_ENABLE */
                 xf_emit(ctx, 1, 4);             /* 000000ff FP_REG_ALLOC_TEMP */
                 xf_emit(ctx, 1, 2);             /* 00000003 REG_MODE */
-                if (IS_NVAAF(dev_priv->chipset))
+                if (IS_NVAAF(device->chipset))
                         xf_emit(ctx, 0xb, 0);   /* RO */
-                else if (dev_priv->chipset >= 0xa0)
+                else if (device->chipset >= 0xa0)
                         xf_emit(ctx, 0xc, 0);   /* RO */
                 else
                         xf_emit(ctx, 0xa, 0);   /* RO */
         }
         xf_emit(ctx, 1, 0x08100c12);            /* 1fffffff FP_INTERPOLANT_CTRL */
         xf_emit(ctx, 1, 0);                     /* ff/3ff */
-        if (dev_priv->chipset >= 0xa0) {
+        if (device->chipset >= 0xa0) {
                 xf_emit(ctx, 1, 0x1fe21);       /* 0003ffff tesla UNK0FAC */
         }
         xf_emit(ctx, 3, 0);                     /* 7fff, 0, 0 */
@@ -3223,7 +3204,7 @@ nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);                     /* ffffffff SHARED_SIZE */
         xf_emit(ctx, 1, 0x1fe21);               /* 1ffff/3ffff[NVA0+] tesla UNk0FAC */
         xf_emit(ctx, 1, 0);                     /* ffffffff tesla UNK1A34 */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 1);             /* 0000001f tesla UNK169C */
         xf_emit(ctx, 1, 0);                     /* ff/3ff */
         xf_emit(ctx, 1, 0);                     /* 1 LINKED_TSC */
@@ -3238,7 +3219,7 @@ nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);                     /* 00000007 */
         xf_emit(ctx, 1, 0xfac6881);             /* 0fffffff RT_CONTROL */
         xf_emit(ctx, 1, 0);                     /* 00000003 MULTISAMPLE_CTRL */
-        if (IS_NVA3F(dev_priv->chipset))
+        if (IS_NVA3F(device->chipset))
                 xf_emit(ctx, 1, 3);             /* 00000003 tesla UNK16B4 */
         xf_emit(ctx, 1, 0);                     /* 00000001 ALPHA_TEST_ENABLE */
         xf_emit(ctx, 1, 0);                     /* 00000007 ALPHA_TEST_FUNC */
@@ -3253,7 +3234,7 @@ nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 1);                     /* 0000001f BLEND_FUNC_DST_ALPHA */
         xf_emit(ctx, 1, 1);                     /* 00000007 BLEND_EQUATION_ALPHA */
         xf_emit(ctx, 1, 1);                     /* 00000001 UNK133C */
-        if (IS_NVA3F(dev_priv->chipset)) {
+        if (IS_NVA3F(device->chipset)) {
                 xf_emit(ctx, 1, 0);             /* 00000001 UNK12E4 */
                 xf_emit(ctx, 8, 2);             /* 0000001f IBLEND_FUNC_SRC_RGB */
                 xf_emit(ctx, 8, 1);             /* 0000001f IBLEND_FUNC_DST_RGB */
@@ -3268,11 +3249,11 @@ nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
         xf_emit(ctx, 1, 0);                     /* 00000003 tesla UNK0F90 */
         xf_emit(ctx, 1, 4);                     /* 000000ff FP_RESULT_COUNT */
         /* XXX: demagic this part some day */
-        if (dev_priv->chipset == 0x50)
+        if (device->chipset == 0x50)
                 xf_emit(ctx, 0x3a0, 0);
-        else if (dev_priv->chipset < 0x94)
+        else if (device->chipset < 0x94)
                 xf_emit(ctx, 0x3a2, 0);
-        else if (dev_priv->chipset == 0x98 || dev_priv->chipset == 0xaa)
+        else if (device->chipset == 0x98 || device->chipset == 0xaa)
                 xf_emit(ctx, 0x39f, 0);
         else
                 xf_emit(ctx, 0x3a3, 0);
@@ -3285,15 +3266,15 @@ nv50_graph_construct_xfer_mpc(struct nouveau_grctx *ctx)
 static void
 nv50_graph_construct_xfer2(struct nouveau_grctx *ctx)
 {
-        struct drm_nouveau_private *dev_priv = ctx->dev->dev_private;
+        struct nouveau_device *device = ctx->device;
         int i;
-        uint32_t offset;
-        uint32_t units = nv_rd32 (ctx->dev, 0x1540);
+        u32 offset;
+        u32 units = nv_rd32 (ctx->device, 0x1540);
         int size = 0;
 
         offset = (ctx->ctxvals_pos+0x3f)&~0x3f;
 
-        if (dev_priv->chipset < 0xa0) {
+        if (device->chipset < 0xa0) {
                 for (i = 0; i < 8; i++) {
                         ctx->ctxvals_pos = offset + i;
                         /* that little bugger belongs to csched. No idea
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/ctxnvc0.c b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnvc0.c
new file mode 100644
index 000000000000..0b7951a85943
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnvc0.c
@@ -0,0 +1,3039 @@
+/*
+ * 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 "nvc0.h"
+
+void
+nv_icmd(struct nvc0_graph_priv *priv, u32 icmd, u32 data)
+{
+        nv_wr32(priv, 0x400204, data);
+        nv_wr32(priv, 0x400200, icmd);
+        while (nv_rd32(priv, 0x400700) & 2) {}
+}
+
+int
+nvc0_grctx_init(struct nvc0_graph_priv *priv, struct nvc0_grctx *info)
+{
+        struct nouveau_bar *bar = nouveau_bar(priv);
+        struct nouveau_object *parent = nv_object(priv);
+        struct nouveau_gpuobj *chan;
+        u32 size = (0x80000 + priv->size + 4095) & ~4095;
+        int ret, i;
+
+        /* allocate memory to for a "channel", which we'll use to generate
+         * the default context values
+         */
+        ret = nouveau_gpuobj_new(parent, NULL, size, 0x1000,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &info->chan);
+        chan = info->chan;
+        if (ret) {
+                nv_error(priv, "failed to allocate channel memory, %d\n", ret);
+                return ret;
+        }
+
+        /* PGD pointer */
+        nv_wo32(chan, 0x0200, lower_32_bits(chan->addr + 0x1000));
+        nv_wo32(chan, 0x0204, upper_32_bits(chan->addr + 0x1000));
+        nv_wo32(chan, 0x0208, 0xffffffff);
+        nv_wo32(chan, 0x020c, 0x000000ff);
+
+        /* PGT[0] pointer */
+        nv_wo32(chan, 0x1000, 0x00000000);
+        nv_wo32(chan, 0x1004, 0x00000001 | (chan->addr + 0x2000) >> 8);
+
+        /* identity-map the whole "channel" into its own vm */
+        for (i = 0; i < size / 4096; i++) {
+                u64 addr = ((chan->addr + (i * 4096)) >> 8) | 1;
+                nv_wo32(chan, 0x2000 + (i * 8), lower_32_bits(addr));
+                nv_wo32(chan, 0x2004 + (i * 8), upper_32_bits(addr));
+        }
+
+        /* context pointer (virt) */
+        nv_wo32(chan, 0x0210, 0x00080004);
+        nv_wo32(chan, 0x0214, 0x00000000);
+
+        bar->flush(bar);
+
+        nv_wr32(priv, 0x100cb8, (chan->addr + 0x1000) >> 8);
+        nv_wr32(priv, 0x100cbc, 0x80000001);
+        nv_wait(priv, 0x100c80, 0x00008000, 0x00008000);
+
+        /* setup default state for mmio list construction */
+        info->data = priv->mmio_data;
+        info->mmio = priv->mmio_list;
+        info->addr = 0x2000 + (i * 8);
+        info->priv = priv;
+        info->buffer_nr = 0;
+
+        if (priv->firmware) {
+                nv_wr32(priv, 0x409840, 0x00000030);
+                nv_wr32(priv, 0x409500, 0x80000000 | chan->addr >> 12);
+                nv_wr32(priv, 0x409504, 0x00000003);
+                if (!nv_wait(priv, 0x409800, 0x00000010, 0x00000010))
+                        nv_error(priv, "load_ctx timeout\n");
+
+                nv_wo32(chan, 0x8001c, 1);
+                nv_wo32(chan, 0x80020, 0);
+                nv_wo32(chan, 0x80028, 0);
+                nv_wo32(chan, 0x8002c, 0);
+                bar->flush(bar);
+                return 0;
+        }
+
+        /* HUB_FUC(SET_CHAN) */
+        nv_wr32(priv, 0x409840, 0x80000000);
+        nv_wr32(priv, 0x409500, 0x80000000 | chan->addr >> 12);
+        nv_wr32(priv, 0x409504, 0x00000001);
+        if (!nv_wait(priv, 0x409800, 0x80000000, 0x80000000)) {
+                nv_error(priv, "HUB_SET_CHAN timeout\n");
+                nvc0_graph_ctxctl_debug(priv);
+                nouveau_gpuobj_ref(NULL, &info->chan);
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+void
+nvc0_grctx_data(struct nvc0_grctx *info, u32 size, u32 align, u32 access)
+{
+        info->buffer[info->buffer_nr]  = info->addr;
+        info->buffer[info->buffer_nr] +=  (align - 1);
+        info->buffer[info->buffer_nr] &= ~(align - 1);
+        info->addr = info->buffer[info->buffer_nr++] + size;
+
+        info->data->size = size;
+        info->data->align = align;
+        info->data->access = access;
+        info->data++;
+}
+
+void
+nvc0_grctx_mmio(struct nvc0_grctx *info, u32 addr, u32 data, u32 shift, u32 buf)
+{
+        struct nvc0_graph_priv *priv = info->priv;
+
+        info->mmio->addr = addr;
+        info->mmio->data = data;
+        info->mmio->shift = shift;
+        info->mmio->buffer = buf;
+        info->mmio++;
+
+        if (shift)
+                data |= info->buffer[buf] >> shift;
+        nv_wr32(priv, addr, data);
+}
+
+int
+nvc0_grctx_fini(struct nvc0_grctx *info)
+{
+        struct nvc0_graph_priv *priv = info->priv;
+        int i;
+
+        /* trigger a context unload by unsetting the "next channel valid" bit
+         * and faking a context switch interrupt
+         */
+        nv_mask(priv, 0x409b04, 0x80000000, 0x00000000);
+        nv_wr32(priv, 0x409000, 0x00000100);
+        if (!nv_wait(priv, 0x409b00, 0x80000000, 0x00000000)) {
+                nv_error(priv, "grctx template channel unload timeout\n");
+                return -EBUSY;
+        }
+
+        priv->data = kmalloc(priv->size, GFP_KERNEL);
+        if (priv->data) {
+                for (i = 0; i < priv->size; i += 4)
+                        priv->data[i / 4] = nv_ro32(info->chan, 0x80000 + i);
+        }
+
+        nouveau_gpuobj_ref(NULL, &info->chan);
+        return priv->data ? 0 : -ENOMEM;
+}
+
+static void
+nvc0_grctx_generate_9097(struct nvc0_graph_priv *priv)
+{
+        u32 fermi = nvc0_graph_class(priv);
+        u32 mthd;
+
+        nv_mthd(priv, 0x9097, 0x0800, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0840, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0880, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x08c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0900, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0940, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0980, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x09c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0804, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0844, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0884, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x08c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0904, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0944, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0984, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x09c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0808, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x0848, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x0888, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x08c8, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x0908, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x0948, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x0988, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x09c8, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x080c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x084c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x088c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x08cc, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x090c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x094c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x098c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x09cc, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x0810, 0x000000cf);
+        nv_mthd(priv, 0x9097, 0x0850, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0890, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x08d0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0910, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0950, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0990, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x09d0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0814, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0854, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0894, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x08d4, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0914, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0954, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0994, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x09d4, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0818, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0858, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0898, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x08d8, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0918, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0958, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0998, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x09d8, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x081c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x085c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x089c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x08dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x091c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x095c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x099c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x09dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0820, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0860, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x08a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x08e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0920, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0960, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x09a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x09e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2700, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2720, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2740, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2760, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2780, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2704, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2724, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2744, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2764, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2784, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2708, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2728, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2748, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2768, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2788, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27a8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27c8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x270c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x272c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x274c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x276c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x278c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27ac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x27ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2710, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x2730, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x2750, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x2770, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x2790, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x27b0, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x27d0, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x27f0, 0x00014000);
+        nv_mthd(priv, 0x9097, 0x2714, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x2734, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x2754, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x2774, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x2794, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x27b4, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x27d4, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x27f4, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x1c00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ca0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cb0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cc0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cd0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ce0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cf0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c24, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c34, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c64, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c94, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ca4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cb4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cc4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cd4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ce4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cf4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c18, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c28, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c38, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c58, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c68, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c78, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c98, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ca8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cb8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cc8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cd8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ce8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cf8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c0c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c1c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c2c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c3c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c4c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c5c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c6c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c7c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1c9c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cbc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ccc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cdc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1cfc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1da0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1db0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dc0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dd0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1de0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1df0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d24, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d34, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d64, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d94, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1da4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1db4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dc4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dd4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1de4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1df4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d18, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d28, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d38, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d58, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d68, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d78, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d98, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1da8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1db8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dc8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dd8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1de8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1df8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d0c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d1c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d2c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d3c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d4c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d5c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d6c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d7c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1d9c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dbc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dcc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ddc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1dfc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f18, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f28, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f38, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f58, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f68, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f78, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f0c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f1c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f24, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f2c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f34, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f3c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f4c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f5c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f64, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f6c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f7c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f98, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fa0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fa8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fb0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fb8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fc0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fc8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fd0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fd8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fe0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fe8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ff0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ff8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f94, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1f9c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fa4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fb4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fbc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fc4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fcc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fd4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fdc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fe4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1fec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ff4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1ffc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2200, 0x00000022);
+        nv_mthd(priv, 0x9097, 0x2210, 0x00000022);
+        nv_mthd(priv, 0x9097, 0x2220, 0x00000022);
+        nv_mthd(priv, 0x9097, 0x2230, 0x00000022);
+        nv_mthd(priv, 0x9097, 0x2240, 0x00000022);
+        nv_mthd(priv, 0x9097, 0x2000, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2040, 0x00000011);
+        nv_mthd(priv, 0x9097, 0x2080, 0x00000020);
+        nv_mthd(priv, 0x9097, 0x20c0, 0x00000030);
+        nv_mthd(priv, 0x9097, 0x2100, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x2140, 0x00000051);
+        nv_mthd(priv, 0x9097, 0x200c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x204c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x208c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x20cc, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x210c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x214c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x2010, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2050, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2090, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x20d0, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x2110, 0x00000003);
+        nv_mthd(priv, 0x9097, 0x2150, 0x00000004);
+        nv_mthd(priv, 0x9097, 0x0380, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0384, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0388, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03a8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03c8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x038c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03ac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x03ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0700, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0710, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0720, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0730, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0704, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0714, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0724, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0734, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0708, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0718, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0728, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0738, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2800, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2804, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2808, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x280c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2810, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2814, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2818, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x281c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2820, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2824, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2828, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x282c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2830, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2834, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2838, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x283c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2840, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2844, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2848, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x284c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2850, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2854, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2858, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x285c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2860, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2864, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2868, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x286c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2870, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2874, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2878, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x287c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2880, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2884, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2888, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x288c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2890, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2894, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2898, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x289c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28a8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28ac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28b0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28b4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28b8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28bc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28c8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28d0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28d4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28d8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28f0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28f4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28f8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x28fc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2900, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2904, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2908, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x290c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2910, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2914, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2918, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x291c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2920, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2924, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2928, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x292c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2930, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2934, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2938, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x293c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2940, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2944, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2948, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x294c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2950, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2954, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2958, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x295c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2960, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2964, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2968, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x296c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2970, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2974, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2978, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x297c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2980, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2984, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2988, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x298c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2990, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2994, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2998, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x299c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29a8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29ac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29b0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29b4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29b8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29bc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29c8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29d0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29d4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29d8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29f0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29f4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29f8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x29fc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0aa0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ac0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ae0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ba0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bc0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0be0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a24, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a64, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0aa4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ac4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ae4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b24, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b64, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ba4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bc4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0be4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a28, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a68, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0aa8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ac8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ae8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b28, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b68, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ba8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bc8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0be8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a0c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a2c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a4c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a6c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0aac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0acc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0aec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b0c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b2c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b4c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b6c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bcc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ab0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ad0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0af0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bb0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bd0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bf0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a34, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0a94, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ab4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ad4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0af4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b34, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0b94, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bb4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bd4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0bf4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ca0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cb0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cc0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cd0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ce0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cf0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c24, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c34, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c64, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c94, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ca4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cb4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cc4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cd4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ce4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cf4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c18, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c28, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c38, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c58, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c68, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c78, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c98, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ca8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cb8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cc8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cd8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ce8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0cf8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0c0c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c1c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c2c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c3c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c4c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c5c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c6c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c7c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c8c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0c9c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0cac, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0cbc, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0ccc, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0cdc, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0cec, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0cfc, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0d00, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d08, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d10, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d18, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d20, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d28, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d30, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d38, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d04, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d0c, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d14, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d1c, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d24, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d2c, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d34, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d3c, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e00, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e20, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e30, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e60, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e70, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ea0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0eb0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ec0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ed0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ee0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ef0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0e04, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e14, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e24, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e34, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e44, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e54, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e64, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e74, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e84, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e94, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ea4, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0eb4, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ec4, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ed4, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ee4, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ef4, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e08, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e18, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e28, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e38, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e48, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e58, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e68, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e78, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e88, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0e98, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ea8, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0eb8, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ec8, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ed8, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ee8, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0ef8, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d40, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d48, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d50, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d58, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d44, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d4c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d5c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1e00, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e20, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e40, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e60, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e80, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ea0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ec0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ee0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e04, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e24, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e44, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e64, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e84, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ea4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ec4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ee4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e08, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e28, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e48, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e68, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e88, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1ea8, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1ec8, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1ee8, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e0c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e2c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e4c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e6c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e8c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1eac, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ecc, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1eec, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e10, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e30, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e50, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e70, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e90, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1eb0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ed0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ef0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e14, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e34, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e54, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e74, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e94, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1eb4, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1ed4, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1ef4, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1e18, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e38, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e58, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e78, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1e98, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1eb8, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ed8, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1ef8, 0x00000001);
+        if (fermi == 0x9097) {
+                for (mthd = 0x3400; mthd <= 0x35fc; mthd += 4)
+                        nv_mthd(priv, 0x9097, mthd, 0x00000000);
+        }
+        nv_mthd(priv, 0x9097, 0x030c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1944, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1514, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d68, 0x0000ffff);
+        nv_mthd(priv, 0x9097, 0x121c, 0x0fac6881);
+        nv_mthd(priv, 0x9097, 0x0fac, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1538, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0fe0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0fe4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0fe8, 0x00000014);
+        nv_mthd(priv, 0x9097, 0x0fec, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x0ff0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x179c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1228, 0x00000400);
+        nv_mthd(priv, 0x9097, 0x122c, 0x00000300);
+        nv_mthd(priv, 0x9097, 0x1230, 0x00010001);
+        nv_mthd(priv, 0x9097, 0x07f8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x15b4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x15cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1534, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0fb0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x15d0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x153c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x16b4, 0x00000003);
+        nv_mthd(priv, 0x9097, 0x0fbc, 0x0000ffff);
+        nv_mthd(priv, 0x9097, 0x0fc0, 0x0000ffff);
+        nv_mthd(priv, 0x9097, 0x0fc4, 0x0000ffff);
+        nv_mthd(priv, 0x9097, 0x0fc8, 0x0000ffff);
+        nv_mthd(priv, 0x9097, 0x0df8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0dfc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1948, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1970, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x161c, 0x000009f0);
+        nv_mthd(priv, 0x9097, 0x0dcc, 0x00000010);
+        nv_mthd(priv, 0x9097, 0x163c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x15e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1160, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1164, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1168, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x116c, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1170, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1174, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1178, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x117c, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1180, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1184, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1188, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x118c, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1190, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1194, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1198, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x119c, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11a0, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11a4, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11a8, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11ac, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11b0, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11b4, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11b8, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11bc, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11c0, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11c4, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11c8, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11cc, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11d0, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11d4, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11d8, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x11dc, 0x25e00040);
+        nv_mthd(priv, 0x9097, 0x1880, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1884, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1888, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x188c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1890, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1894, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1898, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x189c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18a8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18ac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18b0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18b4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18b8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18bc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18c8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18d0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18d4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18d8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18e0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18f0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18f4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18f8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x18fc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x17c8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x17cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x17d0, 0x000000ff);
+        nv_mthd(priv, 0x9097, 0x17d4, 0xffffffff);
+        nv_mthd(priv, 0x9097, 0x17d8, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x17dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x15f4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x15f8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1434, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1438, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d74, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0dec, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x13a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1318, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1644, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0748, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0de8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1648, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x12a4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1120, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1124, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1128, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x112c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1118, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x164c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1658, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1910, 0x00000290);
+        nv_mthd(priv, 0x9097, 0x1518, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x165c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1520, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1604, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1570, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x13b0, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x13b4, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x020c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1670, 0x30201000);
+        nv_mthd(priv, 0x9097, 0x1674, 0x70605040);
+        nv_mthd(priv, 0x9097, 0x1678, 0xb8a89888);
+        nv_mthd(priv, 0x9097, 0x167c, 0xf8e8d8c8);
+        nv_mthd(priv, 0x9097, 0x166c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1680, 0x00ffff00);
+        nv_mthd(priv, 0x9097, 0x12d0, 0x00000003);
+        nv_mthd(priv, 0x9097, 0x12d4, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1684, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1688, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0dac, 0x00001b02);
+        nv_mthd(priv, 0x9097, 0x0db0, 0x00001b02);
+        nv_mthd(priv, 0x9097, 0x0db4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x168c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x15bc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x156c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x187c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1110, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0dc0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0dc4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0dc8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1234, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1690, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x12ac, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x02c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0790, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0794, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0798, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x079c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x07a0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x077c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1000, 0x00000010);
+        nv_mthd(priv, 0x9097, 0x10fc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1290, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0218, 0x00000010);
+        nv_mthd(priv, 0x9097, 0x12d8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x12dc, 0x00000010);
+        nv_mthd(priv, 0x9097, 0x0d94, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x155c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1560, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1564, 0x00001fff);
+        nv_mthd(priv, 0x9097, 0x1574, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1578, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x157c, 0x003fffff);
+        nv_mthd(priv, 0x9097, 0x1354, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1664, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1610, 0x00000012);
+        nv_mthd(priv, 0x9097, 0x1608, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x160c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x162c, 0x00000003);
+        nv_mthd(priv, 0x9097, 0x0210, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0320, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0324, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0328, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x032c, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0330, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0334, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0338, 0x3f800000);
+        nv_mthd(priv, 0x9097, 0x0750, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0760, 0x39291909);
+        nv_mthd(priv, 0x9097, 0x0764, 0x79695949);
+        nv_mthd(priv, 0x9097, 0x0768, 0xb9a99989);
+        nv_mthd(priv, 0x9097, 0x076c, 0xf9e9d9c9);
+        nv_mthd(priv, 0x9097, 0x0770, 0x30201000);
+        nv_mthd(priv, 0x9097, 0x0774, 0x70605040);
+        nv_mthd(priv, 0x9097, 0x0778, 0x00009080);
+        nv_mthd(priv, 0x9097, 0x0780, 0x39291909);
+        nv_mthd(priv, 0x9097, 0x0784, 0x79695949);
+        nv_mthd(priv, 0x9097, 0x0788, 0xb9a99989);
+        nv_mthd(priv, 0x9097, 0x078c, 0xf9e9d9c9);
+        nv_mthd(priv, 0x9097, 0x07d0, 0x30201000);
+        nv_mthd(priv, 0x9097, 0x07d4, 0x70605040);
+        nv_mthd(priv, 0x9097, 0x07d8, 0x00009080);
+        nv_mthd(priv, 0x9097, 0x037c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0740, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0744, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x2600, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1918, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x191c, 0x00000900);
+        nv_mthd(priv, 0x9097, 0x1920, 0x00000405);
+        nv_mthd(priv, 0x9097, 0x1308, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1924, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x13ac, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x192c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x193c, 0x00002c1c);
+        nv_mthd(priv, 0x9097, 0x0d7c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x02c0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1510, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1940, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ff4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0ff8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x194c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1950, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1968, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1590, 0x0000003f);
+        nv_mthd(priv, 0x9097, 0x07e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x07ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x07f0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x07f4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x196c, 0x00000011);
+        nv_mthd(priv, 0x9097, 0x197c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0fcc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0fd0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x02d8, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x1980, 0x00000080);
+        nv_mthd(priv, 0x9097, 0x1504, 0x00000080);
+        nv_mthd(priv, 0x9097, 0x1984, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0300, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x13a8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x12ec, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1310, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1314, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1380, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1384, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1388, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x138c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1390, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1394, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x139c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1398, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1594, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1598, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x159c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x15a0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x15a4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x0f54, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f58, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f5c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x19bc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f9c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0fa0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x12cc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x12e8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x130c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1360, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1364, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1368, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x136c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1370, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1374, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1378, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x137c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x133c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1340, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1344, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1348, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x134c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1350, 0x00000002);
+        nv_mthd(priv, 0x9097, 0x1358, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x12e4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x131c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1320, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1324, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1328, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x19c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1140, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x19c4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x19c8, 0x00001500);
+        nv_mthd(priv, 0x9097, 0x135c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x19e0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19e4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19e8, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19ec, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19f0, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19f4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19f8, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19fc, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x19cc, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x15b8, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a00, 0x00001111);
+        nv_mthd(priv, 0x9097, 0x1a04, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a08, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a0c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a10, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a14, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a18, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1a1c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d6c, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x0d70, 0xffff0000);
+        nv_mthd(priv, 0x9097, 0x10f8, 0x00001010);
+        nv_mthd(priv, 0x9097, 0x0d80, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d84, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d88, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d8c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0d90, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0da0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1508, 0x80000000);
+        nv_mthd(priv, 0x9097, 0x150c, 0x40000000);
+        nv_mthd(priv, 0x9097, 0x1668, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0318, 0x00000008);
+        nv_mthd(priv, 0x9097, 0x031c, 0x00000008);
+        nv_mthd(priv, 0x9097, 0x0d9c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x07dc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x074c, 0x00000055);
+        nv_mthd(priv, 0x9097, 0x1420, 0x00000003);
+        nv_mthd(priv, 0x9097, 0x17bc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x17c0, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x17c4, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1008, 0x00000008);
+        nv_mthd(priv, 0x9097, 0x100c, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x1010, 0x0000012c);
+        nv_mthd(priv, 0x9097, 0x0d60, 0x00000040);
+        nv_mthd(priv, 0x9097, 0x075c, 0x00000003);
+        nv_mthd(priv, 0x9097, 0x1018, 0x00000020);
+        nv_mthd(priv, 0x9097, 0x101c, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1020, 0x00000020);
+        nv_mthd(priv, 0x9097, 0x1024, 0x00000001);
+        nv_mthd(priv, 0x9097, 0x1444, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x1448, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x144c, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0360, 0x20164010);
+        nv_mthd(priv, 0x9097, 0x0364, 0x00000020);
+        nv_mthd(priv, 0x9097, 0x0368, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0de4, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0204, 0x00000006);
+        nv_mthd(priv, 0x9097, 0x0208, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x02cc, 0x003fffff);
+        nv_mthd(priv, 0x9097, 0x02d0, 0x00000c48);
+        nv_mthd(priv, 0x9097, 0x1220, 0x00000005);
+        nv_mthd(priv, 0x9097, 0x0fdc, 0x00000000);
+        nv_mthd(priv, 0x9097, 0x0f98, 0x00300008);
+        nv_mthd(priv, 0x9097, 0x1284, 0x04000080);
+        nv_mthd(priv, 0x9097, 0x1450, 0x00300008);
+        nv_mthd(priv, 0x9097, 0x1454, 0x04000080);
+        nv_mthd(priv, 0x9097, 0x0214, 0x00000000);
+        /* in trace, right after 0x90c0, not here */
+        nv_mthd(priv, 0x9097, 0x3410, 0x80002006);
+}
+
+static void
+nvc0_grctx_generate_9197(struct nvc0_graph_priv *priv)
+{
+        u32 fermi = nvc0_graph_class(priv);
+        u32 mthd;
+
+        if (fermi == 0x9197) {
+                for (mthd = 0x3400; mthd <= 0x35fc; mthd += 4)
+                        nv_mthd(priv, 0x9197, mthd, 0x00000000);
+        }
+        nv_mthd(priv, 0x9197, 0x02e4, 0x0000b001);
+}
+
+static void
+nvc0_grctx_generate_9297(struct nvc0_graph_priv *priv)
+{
+        u32 fermi = nvc0_graph_class(priv);
+        u32 mthd;
+
+        if (fermi == 0x9297) {
+                for (mthd = 0x3400; mthd <= 0x35fc; mthd += 4)
+                        nv_mthd(priv, 0x9297, mthd, 0x00000000);
+        }
+        nv_mthd(priv, 0x9297, 0x036c, 0x00000000);
+        nv_mthd(priv, 0x9297, 0x0370, 0x00000000);
+        nv_mthd(priv, 0x9297, 0x07a4, 0x00000000);
+        nv_mthd(priv, 0x9297, 0x07a8, 0x00000000);
+        nv_mthd(priv, 0x9297, 0x0374, 0x00000000);
+        nv_mthd(priv, 0x9297, 0x0378, 0x00000020);
+}
+
+static void
+nvc0_grctx_generate_902d(struct nvc0_graph_priv *priv)
+{
+        nv_mthd(priv, 0x902d, 0x0200, 0x000000cf);
+        nv_mthd(priv, 0x902d, 0x0204, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0208, 0x00000020);
+        nv_mthd(priv, 0x902d, 0x020c, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0210, 0x00000000);
+        nv_mthd(priv, 0x902d, 0x0214, 0x00000080);
+        nv_mthd(priv, 0x902d, 0x0218, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x021c, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x0220, 0x00000000);
+        nv_mthd(priv, 0x902d, 0x0224, 0x00000000);
+        nv_mthd(priv, 0x902d, 0x0230, 0x000000cf);
+        nv_mthd(priv, 0x902d, 0x0234, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0238, 0x00000020);
+        nv_mthd(priv, 0x902d, 0x023c, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0244, 0x00000080);
+        nv_mthd(priv, 0x902d, 0x0248, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x024c, 0x00000100);
+}
+
+static void
+nvc0_grctx_generate_9039(struct nvc0_graph_priv *priv)
+{
+        nv_mthd(priv, 0x9039, 0x030c, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x0310, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x0314, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x0320, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x0238, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x023c, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x0318, 0x00000000);
+        nv_mthd(priv, 0x9039, 0x031c, 0x00000000);
+}
+
+static void
+nvc0_grctx_generate_90c0(struct nvc0_graph_priv *priv)
+{
+        int i;
+
+        for (i = 0; nv_device(priv)->chipset == 0xd9 && i < 4; i++) {
+                nv_mthd(priv, 0x90c0, 0x2700 + (i * 0x40), 0x00000000);
+                nv_mthd(priv, 0x90c0, 0x2720 + (i * 0x40), 0x00000000);
+                nv_mthd(priv, 0x90c0, 0x2704 + (i * 0x40), 0x00000000);
+                nv_mthd(priv, 0x90c0, 0x2724 + (i * 0x40), 0x00000000);
+                nv_mthd(priv, 0x90c0, 0x2708 + (i * 0x40), 0x00000000);
+                nv_mthd(priv, 0x90c0, 0x2728 + (i * 0x40), 0x00000000);
+        }
+        nv_mthd(priv, 0x90c0, 0x270c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x272c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x274c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x276c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x278c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x27ac, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x27cc, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x27ec, 0x00000000);
+        for (i = 0; nv_device(priv)->chipset == 0xd9 && i < 4; i++) {
+                nv_mthd(priv, 0x90c0, 0x2710 + (i * 0x40), 0x00014000);
+                nv_mthd(priv, 0x90c0, 0x2730 + (i * 0x40), 0x00014000);
+                nv_mthd(priv, 0x90c0, 0x2714 + (i * 0x40), 0x00000040);
+                nv_mthd(priv, 0x90c0, 0x2734 + (i * 0x40), 0x00000040);
+        }
+        nv_mthd(priv, 0x90c0, 0x030c, 0x00000001);
+        nv_mthd(priv, 0x90c0, 0x1944, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0758, 0x00000100);
+        nv_mthd(priv, 0x90c0, 0x02c4, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0790, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0794, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0798, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x079c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x07a0, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x077c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0204, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0208, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x020c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0214, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x024c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x0d94, 0x00000001);
+        nv_mthd(priv, 0x90c0, 0x1608, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x160c, 0x00000000);
+        nv_mthd(priv, 0x90c0, 0x1664, 0x00000000);
+}
+
+static void
+nvc0_grctx_generate_dispatch(struct nvc0_graph_priv *priv)
+{
+        int i;
+
+        nv_wr32(priv, 0x404004, 0x00000000);
+        nv_wr32(priv, 0x404008, 0x00000000);
+        nv_wr32(priv, 0x40400c, 0x00000000);
+        nv_wr32(priv, 0x404010, 0x00000000);
+        nv_wr32(priv, 0x404014, 0x00000000);
+        nv_wr32(priv, 0x404018, 0x00000000);
+        nv_wr32(priv, 0x40401c, 0x00000000);
+        nv_wr32(priv, 0x404020, 0x00000000);
+        nv_wr32(priv, 0x404024, 0x00000000);
+        nv_wr32(priv, 0x404028, 0x00000000);
+        nv_wr32(priv, 0x40402c, 0x00000000);
+        nv_wr32(priv, 0x404044, 0x00000000);
+        nv_wr32(priv, 0x404094, 0x00000000);
+        nv_wr32(priv, 0x404098, 0x00000000);
+        nv_wr32(priv, 0x40409c, 0x00000000);
+        nv_wr32(priv, 0x4040a0, 0x00000000);
+        nv_wr32(priv, 0x4040a4, 0x00000000);
+        nv_wr32(priv, 0x4040a8, 0x00000000);
+        nv_wr32(priv, 0x4040ac, 0x00000000);
+        nv_wr32(priv, 0x4040b0, 0x00000000);
+        nv_wr32(priv, 0x4040b4, 0x00000000);
+        nv_wr32(priv, 0x4040b8, 0x00000000);
+        nv_wr32(priv, 0x4040bc, 0x00000000);
+        nv_wr32(priv, 0x4040c0, 0x00000000);
+        nv_wr32(priv, 0x4040c4, 0x00000000);
+        nv_wr32(priv, 0x4040c8, 0xf0000087);
+        nv_wr32(priv, 0x4040d4, 0x00000000);
+        nv_wr32(priv, 0x4040d8, 0x00000000);
+        nv_wr32(priv, 0x4040dc, 0x00000000);
+        nv_wr32(priv, 0x4040e0, 0x00000000);
+        nv_wr32(priv, 0x4040e4, 0x00000000);
+        nv_wr32(priv, 0x4040e8, 0x00001000);
+        nv_wr32(priv, 0x4040f8, 0x00000000);
+        nv_wr32(priv, 0x404130, 0x00000000);
+        nv_wr32(priv, 0x404134, 0x00000000);
+        nv_wr32(priv, 0x404138, 0x20000040);
+        nv_wr32(priv, 0x404150, 0x0000002e);
+        nv_wr32(priv, 0x404154, 0x00000400);
+        nv_wr32(priv, 0x404158, 0x00000200);
+        nv_wr32(priv, 0x404164, 0x00000055);
+        nv_wr32(priv, 0x404168, 0x00000000);
+        nv_wr32(priv, 0x404174, 0x00000000);
+        nv_wr32(priv, 0x404178, 0x00000000);
+        nv_wr32(priv, 0x40417c, 0x00000000);
+        for (i = 0; i < 8; i++)
+                nv_wr32(priv, 0x404200 + (i * 4), 0x00000000); /* subc */
+}
+
+static void
+nvc0_grctx_generate_macro(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404404, 0x00000000);
+        nv_wr32(priv, 0x404408, 0x00000000);
+        nv_wr32(priv, 0x40440c, 0x00000000);
+        nv_wr32(priv, 0x404410, 0x00000000);
+        nv_wr32(priv, 0x404414, 0x00000000);
+        nv_wr32(priv, 0x404418, 0x00000000);
+        nv_wr32(priv, 0x40441c, 0x00000000);
+        nv_wr32(priv, 0x404420, 0x00000000);
+        nv_wr32(priv, 0x404424, 0x00000000);
+        nv_wr32(priv, 0x404428, 0x00000000);
+        nv_wr32(priv, 0x40442c, 0x00000000);
+        nv_wr32(priv, 0x404430, 0x00000000);
+        nv_wr32(priv, 0x404434, 0x00000000);
+        nv_wr32(priv, 0x404438, 0x00000000);
+        nv_wr32(priv, 0x404460, 0x00000000);
+        nv_wr32(priv, 0x404464, 0x00000000);
+        nv_wr32(priv, 0x404468, 0x00ffffff);
+        nv_wr32(priv, 0x40446c, 0x00000000);
+        nv_wr32(priv, 0x404480, 0x00000001);
+        nv_wr32(priv, 0x404498, 0x00000001);
+}
+
+static void
+nvc0_grctx_generate_m2mf(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404604, 0x00000015);
+        nv_wr32(priv, 0x404608, 0x00000000);
+        nv_wr32(priv, 0x40460c, 0x00002e00);
+        nv_wr32(priv, 0x404610, 0x00000100);
+        nv_wr32(priv, 0x404618, 0x00000000);
+        nv_wr32(priv, 0x40461c, 0x00000000);
+        nv_wr32(priv, 0x404620, 0x00000000);
+        nv_wr32(priv, 0x404624, 0x00000000);
+        nv_wr32(priv, 0x404628, 0x00000000);
+        nv_wr32(priv, 0x40462c, 0x00000000);
+        nv_wr32(priv, 0x404630, 0x00000000);
+        nv_wr32(priv, 0x404634, 0x00000000);
+        nv_wr32(priv, 0x404638, 0x00000004);
+        nv_wr32(priv, 0x40463c, 0x00000000);
+        nv_wr32(priv, 0x404640, 0x00000000);
+        nv_wr32(priv, 0x404644, 0x00000000);
+        nv_wr32(priv, 0x404648, 0x00000000);
+        nv_wr32(priv, 0x40464c, 0x00000000);
+        nv_wr32(priv, 0x404650, 0x00000000);
+        nv_wr32(priv, 0x404654, 0x00000000);
+        nv_wr32(priv, 0x404658, 0x00000000);
+        nv_wr32(priv, 0x40465c, 0x007f0100);
+        nv_wr32(priv, 0x404660, 0x00000000);
+        nv_wr32(priv, 0x404664, 0x00000000);
+        nv_wr32(priv, 0x404668, 0x00000000);
+        nv_wr32(priv, 0x40466c, 0x00000000);
+        nv_wr32(priv, 0x404670, 0x00000000);
+        nv_wr32(priv, 0x404674, 0x00000000);
+        nv_wr32(priv, 0x404678, 0x00000000);
+        nv_wr32(priv, 0x40467c, 0x00000002);
+        nv_wr32(priv, 0x404680, 0x00000000);
+        nv_wr32(priv, 0x404684, 0x00000000);
+        nv_wr32(priv, 0x404688, 0x00000000);
+        nv_wr32(priv, 0x40468c, 0x00000000);
+        nv_wr32(priv, 0x404690, 0x00000000);
+        nv_wr32(priv, 0x404694, 0x00000000);
+        nv_wr32(priv, 0x404698, 0x00000000);
+        nv_wr32(priv, 0x40469c, 0x00000000);
+        nv_wr32(priv, 0x4046a0, 0x007f0080);
+        nv_wr32(priv, 0x4046a4, 0x00000000);
+        nv_wr32(priv, 0x4046a8, 0x00000000);
+        nv_wr32(priv, 0x4046ac, 0x00000000);
+        nv_wr32(priv, 0x4046b0, 0x00000000);
+        nv_wr32(priv, 0x4046b4, 0x00000000);
+        nv_wr32(priv, 0x4046b8, 0x00000000);
+        nv_wr32(priv, 0x4046bc, 0x00000000);
+        nv_wr32(priv, 0x4046c0, 0x00000000);
+        nv_wr32(priv, 0x4046c4, 0x00000000);
+        nv_wr32(priv, 0x4046c8, 0x00000000);
+        nv_wr32(priv, 0x4046cc, 0x00000000);
+        nv_wr32(priv, 0x4046d0, 0x00000000);
+        nv_wr32(priv, 0x4046d4, 0x00000000);
+        nv_wr32(priv, 0x4046d8, 0x00000000);
+        nv_wr32(priv, 0x4046dc, 0x00000000);
+        nv_wr32(priv, 0x4046e0, 0x00000000);
+        nv_wr32(priv, 0x4046e4, 0x00000000);
+        nv_wr32(priv, 0x4046e8, 0x00000000);
+        nv_wr32(priv, 0x4046f0, 0x00000000);
+        nv_wr32(priv, 0x4046f4, 0x00000000);
+}
+
+static void
+nvc0_grctx_generate_unk47xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404700, 0x00000000);
+        nv_wr32(priv, 0x404704, 0x00000000);
+        nv_wr32(priv, 0x404708, 0x00000000);
+        nv_wr32(priv, 0x40470c, 0x00000000);
+        nv_wr32(priv, 0x404710, 0x00000000);
+        nv_wr32(priv, 0x404714, 0x00000000);
+        nv_wr32(priv, 0x404718, 0x00000000);
+        nv_wr32(priv, 0x40471c, 0x00000000);
+        nv_wr32(priv, 0x404720, 0x00000000);
+        nv_wr32(priv, 0x404724, 0x00000000);
+        nv_wr32(priv, 0x404728, 0x00000000);
+        nv_wr32(priv, 0x40472c, 0x00000000);
+        nv_wr32(priv, 0x404730, 0x00000000);
+        nv_wr32(priv, 0x404734, 0x00000100);
+        nv_wr32(priv, 0x404738, 0x00000000);
+        nv_wr32(priv, 0x40473c, 0x00000000);
+        nv_wr32(priv, 0x404740, 0x00000000);
+        nv_wr32(priv, 0x404744, 0x00000000);
+        nv_wr32(priv, 0x404748, 0x00000000);
+        nv_wr32(priv, 0x40474c, 0x00000000);
+        nv_wr32(priv, 0x404750, 0x00000000);
+        nv_wr32(priv, 0x404754, 0x00000000);
+}
+
+static void
+nvc0_grctx_generate_shaders(struct nvc0_graph_priv *priv)
+{
+
+        if (nv_device(priv)->chipset == 0xd9) {
+                nv_wr32(priv, 0x405800, 0x0f8000bf);
+                nv_wr32(priv, 0x405830, 0x02180218);
+                nv_wr32(priv, 0x405834, 0x08000000);
+        } else
+        if (nv_device(priv)->chipset == 0xc1) {
+                nv_wr32(priv, 0x405800, 0x0f8000bf);
+                nv_wr32(priv, 0x405830, 0x02180218);
+                nv_wr32(priv, 0x405834, 0x00000000);
+        } else {
+                nv_wr32(priv, 0x405800, 0x078000bf);
+                nv_wr32(priv, 0x405830, 0x02180000);
+                nv_wr32(priv, 0x405834, 0x00000000);
+        }
+        nv_wr32(priv, 0x405838, 0x00000000);
+        nv_wr32(priv, 0x405854, 0x00000000);
+        nv_wr32(priv, 0x405870, 0x00000001);
+        nv_wr32(priv, 0x405874, 0x00000001);
+        nv_wr32(priv, 0x405878, 0x00000001);
+        nv_wr32(priv, 0x40587c, 0x00000001);
+        nv_wr32(priv, 0x405a00, 0x00000000);
+        nv_wr32(priv, 0x405a04, 0x00000000);
+        nv_wr32(priv, 0x405a18, 0x00000000);
+}
+
+static void
+nvc0_grctx_generate_unk60xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x406020, 0x000103c1);
+        nv_wr32(priv, 0x406028, 0x00000001);
+        nv_wr32(priv, 0x40602c, 0x00000001);
+        nv_wr32(priv, 0x406030, 0x00000001);
+        nv_wr32(priv, 0x406034, 0x00000001);
+}
+
+static void
+nvc0_grctx_generate_unk64xx(struct nvc0_graph_priv *priv)
+{
+
+        nv_wr32(priv, 0x4064a8, 0x00000000);
+        nv_wr32(priv, 0x4064ac, 0x00003fff);
+        nv_wr32(priv, 0x4064b4, 0x00000000);
+        nv_wr32(priv, 0x4064b8, 0x00000000);
+        if (nv_device(priv)->chipset == 0xd9)
+                nv_wr32(priv, 0x4064bc, 0x00000000);
+        if (nv_device(priv)->chipset == 0xc1 ||
+            nv_device(priv)->chipset == 0xd9) {
+                nv_wr32(priv, 0x4064c0, 0x80140078);
+                nv_wr32(priv, 0x4064c4, 0x0086ffff);
+        }
+}
+
+static void
+nvc0_grctx_generate_tpbus(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x407804, 0x00000023);
+        nv_wr32(priv, 0x40780c, 0x0a418820);
+        nv_wr32(priv, 0x407810, 0x062080e6);
+        nv_wr32(priv, 0x407814, 0x020398a4);
+        nv_wr32(priv, 0x407818, 0x0e629062);
+        nv_wr32(priv, 0x40781c, 0x0a418820);
+        nv_wr32(priv, 0x407820, 0x000000e6);
+        nv_wr32(priv, 0x4078bc, 0x00000103);
+}
+
+static void
+nvc0_grctx_generate_ccache(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x408000, 0x00000000);
+        nv_wr32(priv, 0x408004, 0x00000000);
+        nv_wr32(priv, 0x408008, 0x00000018);
+        nv_wr32(priv, 0x40800c, 0x00000000);
+        nv_wr32(priv, 0x408010, 0x00000000);
+        nv_wr32(priv, 0x408014, 0x00000069);
+        nv_wr32(priv, 0x408018, 0xe100e100);
+        nv_wr32(priv, 0x408064, 0x00000000);
+}
+
+static void
+nvc0_grctx_generate_rop(struct nvc0_graph_priv *priv)
+{
+        int chipset = nv_device(priv)->chipset;
+
+        /* ROPC_BROADCAST */
+        nv_wr32(priv, 0x408800, 0x02802a3c);
+        nv_wr32(priv, 0x408804, 0x00000040);
+        if (chipset == 0xd9) {
+                nv_wr32(priv, 0x408808, 0x1043e005);
+                nv_wr32(priv, 0x408900, 0x3080b801);
+                nv_wr32(priv, 0x408904, 0x1043e005);
+                nv_wr32(priv, 0x408908, 0x00c8102f);
+        } else
+        if (chipset == 0xc1) {
+                nv_wr32(priv, 0x408808, 0x1003e005);
+                nv_wr32(priv, 0x408900, 0x3080b801);
+                nv_wr32(priv, 0x408904, 0x62000001);
+                nv_wr32(priv, 0x408908, 0x00c80929);
+        } else {
+                nv_wr32(priv, 0x408808, 0x0003e00d);
+                nv_wr32(priv, 0x408900, 0x3080b801);
+                nv_wr32(priv, 0x408904, 0x02000001);
+                nv_wr32(priv, 0x408908, 0x00c80929);
+        }
+        nv_wr32(priv, 0x40890c, 0x00000000);
+        nv_wr32(priv, 0x408980, 0x0000011d);
+}
+
+static void
+nvc0_grctx_generate_gpc(struct nvc0_graph_priv *priv)
+{
+        int chipset = nv_device(priv)->chipset;
+        int i;
+
+        /* GPC_BROADCAST */
+        nv_wr32(priv, 0x418380, 0x00000016);
+        nv_wr32(priv, 0x418400, 0x38004e00);
+        nv_wr32(priv, 0x418404, 0x71e0ffff);
+        nv_wr32(priv, 0x418408, 0x00000000);
+        nv_wr32(priv, 0x41840c, 0x00001008);
+        nv_wr32(priv, 0x418410, 0x0fff0fff);
+        nv_wr32(priv, 0x418414, chipset != 0xd9 ? 0x00200fff : 0x02200fff);
+        nv_wr32(priv, 0x418450, 0x00000000);
+        nv_wr32(priv, 0x418454, 0x00000000);
+        nv_wr32(priv, 0x418458, 0x00000000);
+        nv_wr32(priv, 0x41845c, 0x00000000);
+        nv_wr32(priv, 0x418460, 0x00000000);
+        nv_wr32(priv, 0x418464, 0x00000000);
+        nv_wr32(priv, 0x418468, 0x00000001);
+        nv_wr32(priv, 0x41846c, 0x00000000);
+        nv_wr32(priv, 0x418470, 0x00000000);
+        nv_wr32(priv, 0x418600, 0x0000001f);
+        nv_wr32(priv, 0x418684, 0x0000000f);
+        nv_wr32(priv, 0x418700, 0x00000002);
+        nv_wr32(priv, 0x418704, 0x00000080);
+        nv_wr32(priv, 0x418708, 0x00000000);
+        nv_wr32(priv, 0x41870c, chipset != 0xd9 ? 0x07c80000 : 0x00000000);
+        nv_wr32(priv, 0x418710, 0x00000000);
+        nv_wr32(priv, 0x418800, chipset != 0xd9 ? 0x0006860a : 0x7006860a);
+        nv_wr32(priv, 0x418808, 0x00000000);
+        nv_wr32(priv, 0x41880c, 0x00000000);
+        nv_wr32(priv, 0x418810, 0x00000000);
+        nv_wr32(priv, 0x418828, 0x00008442);
+        if (chipset == 0xc1 || chipset == 0xd9)
+                nv_wr32(priv, 0x418830, 0x10000001);
+        else
+                nv_wr32(priv, 0x418830, 0x00000001);
+        nv_wr32(priv, 0x4188d8, 0x00000008);
+        nv_wr32(priv, 0x4188e0, 0x01000000);
+        nv_wr32(priv, 0x4188e8, 0x00000000);
+        nv_wr32(priv, 0x4188ec, 0x00000000);
+        nv_wr32(priv, 0x4188f0, 0x00000000);
+        nv_wr32(priv, 0x4188f4, 0x00000000);
+        nv_wr32(priv, 0x4188f8, 0x00000000);
+        if (chipset == 0xd9)
+                nv_wr32(priv, 0x4188fc, 0x20100008);
+        else if (chipset == 0xc1)
+                nv_wr32(priv, 0x4188fc, 0x00100018);
+        else
+                nv_wr32(priv, 0x4188fc, 0x00100000);
+        nv_wr32(priv, 0x41891c, 0x00ff00ff);
+        nv_wr32(priv, 0x418924, 0x00000000);
+        nv_wr32(priv, 0x418928, 0x00ffff00);
+        nv_wr32(priv, 0x41892c, 0x0000ff00);
+        for (i = 0; i < 8; i++) {
+                nv_wr32(priv, 0x418a00 + (i * 0x20), 0x00000000);
+                nv_wr32(priv, 0x418a04 + (i * 0x20), 0x00000000);
+                nv_wr32(priv, 0x418a08 + (i * 0x20), 0x00000000);
+                nv_wr32(priv, 0x418a0c + (i * 0x20), 0x00010000);
+                nv_wr32(priv, 0x418a10 + (i * 0x20), 0x00000000);
+                nv_wr32(priv, 0x418a14 + (i * 0x20), 0x00000000);
+                nv_wr32(priv, 0x418a18 + (i * 0x20), 0x00000000);
+        }
+        nv_wr32(priv, 0x418b00, chipset != 0xd9 ? 0x00000000 : 0x00000006);
+        nv_wr32(priv, 0x418b08, 0x0a418820);
+        nv_wr32(priv, 0x418b0c, 0x062080e6);
+        nv_wr32(priv, 0x418b10, 0x020398a4);
+        nv_wr32(priv, 0x418b14, 0x0e629062);
+        nv_wr32(priv, 0x418b18, 0x0a418820);
+        nv_wr32(priv, 0x418b1c, 0x000000e6);
+        nv_wr32(priv, 0x418bb8, 0x00000103);
+        nv_wr32(priv, 0x418c08, 0x00000001);
+        nv_wr32(priv, 0x418c10, 0x00000000);
+        nv_wr32(priv, 0x418c14, 0x00000000);
+        nv_wr32(priv, 0x418c18, 0x00000000);
+        nv_wr32(priv, 0x418c1c, 0x00000000);
+        nv_wr32(priv, 0x418c20, 0x00000000);
+        nv_wr32(priv, 0x418c24, 0x00000000);
+        nv_wr32(priv, 0x418c28, 0x00000000);
+        nv_wr32(priv, 0x418c2c, 0x00000000);
+        if (chipset == 0xc1 || chipset == 0xd9)
+                nv_wr32(priv, 0x418c6c, 0x00000001);
+        nv_wr32(priv, 0x418c80, 0x20200004);
+        nv_wr32(priv, 0x418c8c, 0x00000001);
+        nv_wr32(priv, 0x419000, 0x00000780);
+        nv_wr32(priv, 0x419004, 0x00000000);
+        nv_wr32(priv, 0x419008, 0x00000000);
+        nv_wr32(priv, 0x419014, 0x00000004);
+}
+
+static void
+nvc0_grctx_generate_tp(struct nvc0_graph_priv *priv)
+{
+        int chipset = nv_device(priv)->chipset;
+
+        /* GPC_BROADCAST.TP_BROADCAST */
+        nv_wr32(priv, 0x419818, 0x00000000);
+        nv_wr32(priv, 0x41983c, 0x00038bc7);
+        nv_wr32(priv, 0x419848, 0x00000000);
+        if (chipset == 0xc1 || chipset == 0xd9)
+                nv_wr32(priv, 0x419864, 0x00000129);
+        else
+                nv_wr32(priv, 0x419864, 0x0000012a);
+        nv_wr32(priv, 0x419888, 0x00000000);
+        nv_wr32(priv, 0x419a00, 0x000001f0);
+        nv_wr32(priv, 0x419a04, 0x00000001);
+        nv_wr32(priv, 0x419a08, 0x00000023);
+        nv_wr32(priv, 0x419a0c, 0x00020000);
+        nv_wr32(priv, 0x419a10, 0x00000000);
+        nv_wr32(priv, 0x419a14, 0x00000200);
+        nv_wr32(priv, 0x419a1c, 0x00000000);
+        nv_wr32(priv, 0x419a20, 0x00000800);
+        if (chipset == 0xd9)
+                nv_wr32(priv, 0x00419ac4, 0x0017f440);
+        else if (chipset != 0xc0 && chipset != 0xc8)
+                nv_wr32(priv, 0x00419ac4, 0x0007f440);
+        nv_wr32(priv, 0x419b00, 0x0a418820);
+        nv_wr32(priv, 0x419b04, 0x062080e6);
+        nv_wr32(priv, 0x419b08, 0x020398a4);
+        nv_wr32(priv, 0x419b0c, 0x0e629062);
+        nv_wr32(priv, 0x419b10, 0x0a418820);
+        nv_wr32(priv, 0x419b14, 0x000000e6);
+        nv_wr32(priv, 0x419bd0, 0x00900103);
+        if (chipset == 0xc1 || chipset == 0xd9)
+                nv_wr32(priv, 0x419be0, 0x00400001);
+        else
+                nv_wr32(priv, 0x419be0, 0x00000001);
+        nv_wr32(priv, 0x419be4, 0x00000000);
+        nv_wr32(priv, 0x419c00, chipset != 0xd9 ? 0x00000002 : 0x0000000a);
+        nv_wr32(priv, 0x419c04, 0x00000006);
+        nv_wr32(priv, 0x419c08, 0x00000002);
+        nv_wr32(priv, 0x419c20, 0x00000000);
+        if (nv_device(priv)->chipset == 0xd9) {
+                nv_wr32(priv, 0x419c24, 0x00084210);
+                nv_wr32(priv, 0x419c28, 0x3cf3cf3c);
+                nv_wr32(priv, 0x419cb0, 0x00020048);
+        } else
+        if (chipset == 0xce || chipset == 0xcf) {
+                nv_wr32(priv, 0x419cb0, 0x00020048);
+        } else {
+                nv_wr32(priv, 0x419cb0, 0x00060048);
+        }
+        nv_wr32(priv, 0x419ce8, 0x00000000);
+        nv_wr32(priv, 0x419cf4, 0x00000183);
+        if (chipset == 0xc1 || chipset == 0xd9)
+                nv_wr32(priv, 0x419d20, 0x12180000);
+        else
+                nv_wr32(priv, 0x419d20, 0x02180000);
+        nv_wr32(priv, 0x419d24, 0x00001fff);
+        if (chipset == 0xc1 || chipset == 0xd9)
+                nv_wr32(priv, 0x419d44, 0x02180218);
+        nv_wr32(priv, 0x419e04, 0x00000000);
+        nv_wr32(priv, 0x419e08, 0x00000000);
+        nv_wr32(priv, 0x419e0c, 0x00000000);
+        nv_wr32(priv, 0x419e10, 0x00000002);
+        nv_wr32(priv, 0x419e44, 0x001beff2);
+        nv_wr32(priv, 0x419e48, 0x00000000);
+        nv_wr32(priv, 0x419e4c, 0x0000000f);
+        nv_wr32(priv, 0x419e50, 0x00000000);
+        nv_wr32(priv, 0x419e54, 0x00000000);
+        nv_wr32(priv, 0x419e58, 0x00000000);
+        nv_wr32(priv, 0x419e5c, 0x00000000);
+        nv_wr32(priv, 0x419e60, 0x00000000);
+        nv_wr32(priv, 0x419e64, 0x00000000);
+        nv_wr32(priv, 0x419e68, 0x00000000);
+        nv_wr32(priv, 0x419e6c, 0x00000000);
+        nv_wr32(priv, 0x419e70, 0x00000000);
+        nv_wr32(priv, 0x419e74, 0x00000000);
+        nv_wr32(priv, 0x419e78, 0x00000000);
+        nv_wr32(priv, 0x419e7c, 0x00000000);
+        nv_wr32(priv, 0x419e80, 0x00000000);
+        nv_wr32(priv, 0x419e84, 0x00000000);
+        nv_wr32(priv, 0x419e88, 0x00000000);
+        nv_wr32(priv, 0x419e8c, 0x00000000);
+        nv_wr32(priv, 0x419e90, 0x00000000);
+        nv_wr32(priv, 0x419e98, 0x00000000);
+        if (chipset != 0xc0 && chipset != 0xc8)
+                nv_wr32(priv, 0x419ee0, 0x00011110);
+        nv_wr32(priv, 0x419f50, 0x00000000);
+        nv_wr32(priv, 0x419f54, 0x00000000);
+        if (chipset != 0xc0 && chipset != 0xc8)
+                nv_wr32(priv, 0x419f58, 0x00000000);
+}
+
+int
+nvc0_grctx_generate(struct nvc0_graph_priv *priv)
+{
+        struct nvc0_grctx info;
+        int ret, i, gpc, tpc, id;
+        u32 fermi = nvc0_graph_class(priv);
+        u32 r000260, tmp;
+
+        ret = nvc0_grctx_init(priv, &info);
+        if (ret)
+                return ret;
+
+        r000260 = nv_rd32(priv, 0x000260);
+        nv_wr32(priv, 0x000260, r000260 & ~1);
+        nv_wr32(priv, 0x400208, 0x00000000);
+
+        nvc0_grctx_generate_dispatch(priv);
+        nvc0_grctx_generate_macro(priv);
+        nvc0_grctx_generate_m2mf(priv);
+        nvc0_grctx_generate_unk47xx(priv);
+        nvc0_grctx_generate_shaders(priv);
+        nvc0_grctx_generate_unk60xx(priv);
+        nvc0_grctx_generate_unk64xx(priv);
+        nvc0_grctx_generate_tpbus(priv);
+        nvc0_grctx_generate_ccache(priv);
+        nvc0_grctx_generate_rop(priv);
+        nvc0_grctx_generate_gpc(priv);
+        nvc0_grctx_generate_tp(priv);
+
+        nv_wr32(priv, 0x404154, 0x00000000);
+
+        /* generate per-context mmio list data */
+        mmio_data(0x002000, 0x0100, NV_MEM_ACCESS_RW | NV_MEM_ACCESS_SYS);
+        mmio_data(0x008000, 0x0100, NV_MEM_ACCESS_RW | NV_MEM_ACCESS_SYS);
+        mmio_data(0x060000, 0x1000, NV_MEM_ACCESS_RW);
+        mmio_list(0x408004, 0x00000000,  8, 0);
+        mmio_list(0x408008, 0x80000018,  0, 0);
+        mmio_list(0x40800c, 0x00000000,  8, 1);
+        mmio_list(0x408010, 0x80000000,  0, 0);
+        mmio_list(0x418810, 0x80000000, 12, 2);
+        mmio_list(0x419848, 0x10000000, 12, 2);
+        mmio_list(0x419004, 0x00000000,  8, 1);
+        mmio_list(0x419008, 0x00000000,  0, 0);
+        mmio_list(0x418808, 0x00000000,  8, 0);
+        mmio_list(0x41880c, 0x80000018,  0, 0);
+        if (nv_device(priv)->chipset != 0xc1) {
+                tmp = 0x02180000;
+                mmio_list(0x405830, tmp, 0, 0);
+                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                        for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
+                                u32 reg = TPC_UNIT(gpc, tpc, 0x0520);
+                                mmio_list(reg, tmp, 0, 0);
+                                tmp += 0x0324;
+                        }
+                }
+        } else {
+                tmp = 0x02180000;
+                mmio_list(0x405830, 0x00000218 | tmp, 0, 0);
+                mmio_list(0x4064c4, 0x0086ffff, 0, 0);
+                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                        for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
+                                u32 reg = TPC_UNIT(gpc, tpc, 0x0520);
+                                mmio_list(reg, 0x10000000 | tmp, 0, 0);
+                                tmp += 0x0324;
+                        }
+                        for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
+                                u32 reg = TPC_UNIT(gpc, tpc, 0x0544);
+                                mmio_list(reg, tmp, 0, 0);
+                                tmp += 0x0324;
+                        }
+                }
+        }
+
+        for (tpc = 0, id = 0; tpc < 4; tpc++) {
+                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                        if (tpc < priv->tpc_nr[gpc]) {
+                                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x698), id);
+                                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x4e8), id);
+                                nv_wr32(priv, GPC_UNIT(gpc, 0x0c10 + tpc * 4), id);
+                                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x088), id);
+                                id++;
+                        }
+
+                        nv_wr32(priv, GPC_UNIT(gpc, 0x0c08), priv->tpc_nr[gpc]);
+                        nv_wr32(priv, GPC_UNIT(gpc, 0x0c8c), priv->tpc_nr[gpc]);
+                }
+        }
+
+        tmp = 0;
+        for (i = 0; i < priv->gpc_nr; i++)
+                tmp |= priv->tpc_nr[i] << (i * 4);
+        nv_wr32(priv, 0x406028, tmp);
+        nv_wr32(priv, 0x405870, tmp);
+
+        nv_wr32(priv, 0x40602c, 0x00000000);
+        nv_wr32(priv, 0x405874, 0x00000000);
+        nv_wr32(priv, 0x406030, 0x00000000);
+        nv_wr32(priv, 0x405878, 0x00000000);
+        nv_wr32(priv, 0x406034, 0x00000000);
+        nv_wr32(priv, 0x40587c, 0x00000000);
+
+        if (1) {
+                u8 tpcnr[GPC_MAX], data[TPC_MAX];
+
+                memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+                memset(data, 0x1f, sizeof(data));
+
+                gpc = -1;
+                for (tpc = 0; tpc < priv->tpc_total; tpc++) {
+                        do {
+                                gpc = (gpc + 1) % priv->gpc_nr;
+                        } while (!tpcnr[gpc]);
+                        tpcnr[gpc]--;
+                        data[tpc] = gpc;
+                }
+
+                for (i = 0; i < 4; i++)
+                        nv_wr32(priv, 0x4060a8 + (i * 4), ((u32 *)data)[i]);
+        }
+
+        if (1) {
+                u32 data[6] = {}, data2[2] = {};
+                u8 tpcnr[GPC_MAX];
+                u8 shift, ntpcv;
+
+                /* calculate first set of magics */
+                memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+
+                gpc = -1;
+                for (tpc = 0; tpc < priv->tpc_total; tpc++) {
+                        do {
+                                gpc = (gpc + 1) % priv->gpc_nr;
+                        } while (!tpcnr[gpc]);
+                        tpcnr[gpc]--;
+
+                        data[tpc / 6] |= gpc << ((tpc % 6) * 5);
+                }
+
+                for (; tpc < 32; tpc++)
+                        data[tpc / 6] |= 7 << ((tpc % 6) * 5);
+
+                /* and the second... */
+                shift = 0;
+                ntpcv = priv->tpc_total;
+                while (!(ntpcv & (1 << 4))) {
+                        ntpcv <<= 1;
+                        shift++;
+                }
+
+                data2[0]  = (ntpcv << 16);
+                data2[0] |= (shift << 21);
+                data2[0] |= (((1 << (0 + 5)) % ntpcv) << 24);
+                for (i = 1; i < 7; i++)
+                        data2[1] |= ((1 << (i + 5)) % ntpcv) << ((i - 1) * 5);
+
+                /* GPC_BROADCAST */
+                nv_wr32(priv, 0x418bb8, (priv->tpc_total << 8) |
+                                        priv->magic_not_rop_nr);
+                for (i = 0; i < 6; i++)
+                        nv_wr32(priv, 0x418b08 + (i * 4), data[i]);
+
+                /* GPC_BROADCAST.TP_BROADCAST */
+                nv_wr32(priv, 0x419bd0, (priv->tpc_total << 8) |
+                                       priv->magic_not_rop_nr |
+                                       data2[0]);
+                nv_wr32(priv, 0x419be4, data2[1]);
+                for (i = 0; i < 6; i++)
+                        nv_wr32(priv, 0x419b00 + (i * 4), data[i]);
+
+                /* UNK78xx */
+                nv_wr32(priv, 0x4078bc, (priv->tpc_total << 8) |
+                                        priv->magic_not_rop_nr);
+                for (i = 0; i < 6; i++)
+                        nv_wr32(priv, 0x40780c + (i * 4), data[i]);
+        }
+
+        if (1) {
+                u32 tpc_mask = 0, tpc_set = 0;
+                u8  tpcnr[GPC_MAX], a, b;
+
+                memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+                for (gpc = 0; gpc < priv->gpc_nr; gpc++)
+                        tpc_mask |= ((1 << priv->tpc_nr[gpc]) - 1) << (gpc * 8);
+
+                for (i = 0, gpc = -1, b = -1; i < 32; i++) {
+                        a = (i * (priv->tpc_total - 1)) / 32;
+                        if (a != b) {
+                                b = a;
+                                do {
+                                        gpc = (gpc + 1) % priv->gpc_nr;
+                                } while (!tpcnr[gpc]);
+                                tpc = priv->tpc_nr[gpc] - tpcnr[gpc]--;
+
+                                tpc_set |= 1 << ((gpc * 8) + tpc);
+                        }
+
+                        nv_wr32(priv, 0x406800 + (i * 0x20), tpc_set);
+                        nv_wr32(priv, 0x406c00 + (i * 0x20), tpc_set ^ tpc_mask);
+                }
+        }
+
+        nv_wr32(priv, 0x400208, 0x80000000);
+
+        nv_icmd(priv, 0x00001000, 0x00000004);
+        nv_icmd(priv, 0x000000a9, 0x0000ffff);
+        nv_icmd(priv, 0x00000038, 0x0fac6881);
+        nv_icmd(priv, 0x0000003d, 0x00000001);
+        nv_icmd(priv, 0x000000e8, 0x00000400);
+        nv_icmd(priv, 0x000000e9, 0x00000400);
+        nv_icmd(priv, 0x000000ea, 0x00000400);
+        nv_icmd(priv, 0x000000eb, 0x00000400);
+        nv_icmd(priv, 0x000000ec, 0x00000400);
+        nv_icmd(priv, 0x000000ed, 0x00000400);
+        nv_icmd(priv, 0x000000ee, 0x00000400);
+        nv_icmd(priv, 0x000000ef, 0x00000400);
+        nv_icmd(priv, 0x00000078, 0x00000300);
+        nv_icmd(priv, 0x00000079, 0x00000300);
+        nv_icmd(priv, 0x0000007a, 0x00000300);
+        nv_icmd(priv, 0x0000007b, 0x00000300);
+        nv_icmd(priv, 0x0000007c, 0x00000300);
+        nv_icmd(priv, 0x0000007d, 0x00000300);
+        nv_icmd(priv, 0x0000007e, 0x00000300);
+        nv_icmd(priv, 0x0000007f, 0x00000300);
+        nv_icmd(priv, 0x00000050, 0x00000011);
+        nv_icmd(priv, 0x00000058, 0x00000008);
+        nv_icmd(priv, 0x00000059, 0x00000008);
+        nv_icmd(priv, 0x0000005a, 0x00000008);
+        nv_icmd(priv, 0x0000005b, 0x00000008);
+        nv_icmd(priv, 0x0000005c, 0x00000008);
+        nv_icmd(priv, 0x0000005d, 0x00000008);
+        nv_icmd(priv, 0x0000005e, 0x00000008);
+        nv_icmd(priv, 0x0000005f, 0x00000008);
+        nv_icmd(priv, 0x00000208, 0x00000001);
+        nv_icmd(priv, 0x00000209, 0x00000001);
+        nv_icmd(priv, 0x0000020a, 0x00000001);
+        nv_icmd(priv, 0x0000020b, 0x00000001);
+        nv_icmd(priv, 0x0000020c, 0x00000001);
+        nv_icmd(priv, 0x0000020d, 0x00000001);
+        nv_icmd(priv, 0x0000020e, 0x00000001);
+        nv_icmd(priv, 0x0000020f, 0x00000001);
+        nv_icmd(priv, 0x00000081, 0x00000001);
+        nv_icmd(priv, 0x00000085, 0x00000004);
+        nv_icmd(priv, 0x00000088, 0x00000400);
+        nv_icmd(priv, 0x00000090, 0x00000300);
+        nv_icmd(priv, 0x00000098, 0x00001001);
+        nv_icmd(priv, 0x000000e3, 0x00000001);
+        nv_icmd(priv, 0x000000da, 0x00000001);
+        nv_icmd(priv, 0x000000f8, 0x00000003);
+        nv_icmd(priv, 0x000000fa, 0x00000001);
+        nv_icmd(priv, 0x0000009f, 0x0000ffff);
+        nv_icmd(priv, 0x000000a0, 0x0000ffff);
+        nv_icmd(priv, 0x000000a1, 0x0000ffff);
+        nv_icmd(priv, 0x000000a2, 0x0000ffff);
+        nv_icmd(priv, 0x000000b1, 0x00000001);
+        nv_icmd(priv, 0x000000b2, 0x00000000);
+        nv_icmd(priv, 0x000000b3, 0x00000000);
+        nv_icmd(priv, 0x000000b4, 0x00000000);
+        nv_icmd(priv, 0x000000b5, 0x00000000);
+        nv_icmd(priv, 0x000000b6, 0x00000000);
+        nv_icmd(priv, 0x000000b7, 0x00000000);
+        nv_icmd(priv, 0x000000b8, 0x00000000);
+        nv_icmd(priv, 0x000000b9, 0x00000000);
+        nv_icmd(priv, 0x000000ba, 0x00000000);
+        nv_icmd(priv, 0x000000bb, 0x00000000);
+        nv_icmd(priv, 0x000000bc, 0x00000000);
+        nv_icmd(priv, 0x000000bd, 0x00000000);
+        nv_icmd(priv, 0x000000be, 0x00000000);
+        nv_icmd(priv, 0x000000bf, 0x00000000);
+        nv_icmd(priv, 0x000000c0, 0x00000000);
+        nv_icmd(priv, 0x000000c1, 0x00000000);
+        nv_icmd(priv, 0x000000c2, 0x00000000);
+        nv_icmd(priv, 0x000000c3, 0x00000000);
+        nv_icmd(priv, 0x000000c4, 0x00000000);
+        nv_icmd(priv, 0x000000c5, 0x00000000);
+        nv_icmd(priv, 0x000000c6, 0x00000000);
+        nv_icmd(priv, 0x000000c7, 0x00000000);
+        nv_icmd(priv, 0x000000c8, 0x00000000);
+        nv_icmd(priv, 0x000000c9, 0x00000000);
+        nv_icmd(priv, 0x000000ca, 0x00000000);
+        nv_icmd(priv, 0x000000cb, 0x00000000);
+        nv_icmd(priv, 0x000000cc, 0x00000000);
+        nv_icmd(priv, 0x000000cd, 0x00000000);
+        nv_icmd(priv, 0x000000ce, 0x00000000);
+        nv_icmd(priv, 0x000000cf, 0x00000000);
+        nv_icmd(priv, 0x000000d0, 0x00000000);
+        nv_icmd(priv, 0x000000d1, 0x00000000);
+        nv_icmd(priv, 0x000000d2, 0x00000000);
+        nv_icmd(priv, 0x000000d3, 0x00000000);
+        nv_icmd(priv, 0x000000d4, 0x00000000);
+        nv_icmd(priv, 0x000000d5, 0x00000000);
+        nv_icmd(priv, 0x000000d6, 0x00000000);
+        nv_icmd(priv, 0x000000d7, 0x00000000);
+        nv_icmd(priv, 0x000000d8, 0x00000000);
+        nv_icmd(priv, 0x000000d9, 0x00000000);
+        nv_icmd(priv, 0x00000210, 0x00000040);
+        nv_icmd(priv, 0x00000211, 0x00000040);
+        nv_icmd(priv, 0x00000212, 0x00000040);
+        nv_icmd(priv, 0x00000213, 0x00000040);
+        nv_icmd(priv, 0x00000214, 0x00000040);
+        nv_icmd(priv, 0x00000215, 0x00000040);
+        nv_icmd(priv, 0x00000216, 0x00000040);
+        nv_icmd(priv, 0x00000217, 0x00000040);
+        if (nv_device(priv)->chipset == 0xd9) {
+                for (i = 0x0400; i <= 0x0417; i++)
+                        nv_icmd(priv, i, 0x00000040);
+        }
+        nv_icmd(priv, 0x00000218, 0x0000c080);
+        nv_icmd(priv, 0x00000219, 0x0000c080);
+        nv_icmd(priv, 0x0000021a, 0x0000c080);
+        nv_icmd(priv, 0x0000021b, 0x0000c080);
+        nv_icmd(priv, 0x0000021c, 0x0000c080);
+        nv_icmd(priv, 0x0000021d, 0x0000c080);
+        nv_icmd(priv, 0x0000021e, 0x0000c080);
+        nv_icmd(priv, 0x0000021f, 0x0000c080);
+        if (nv_device(priv)->chipset == 0xd9) {
+                for (i = 0x0440; i <= 0x0457; i++)
+                        nv_icmd(priv, i, 0x0000c080);
+        }
+        nv_icmd(priv, 0x000000ad, 0x0000013e);
+        nv_icmd(priv, 0x000000e1, 0x00000010);
+        nv_icmd(priv, 0x00000290, 0x00000000);
+        nv_icmd(priv, 0x00000291, 0x00000000);
+        nv_icmd(priv, 0x00000292, 0x00000000);
+        nv_icmd(priv, 0x00000293, 0x00000000);
+        nv_icmd(priv, 0x00000294, 0x00000000);
+        nv_icmd(priv, 0x00000295, 0x00000000);
+        nv_icmd(priv, 0x00000296, 0x00000000);
+        nv_icmd(priv, 0x00000297, 0x00000000);
+        nv_icmd(priv, 0x00000298, 0x00000000);
+        nv_icmd(priv, 0x00000299, 0x00000000);
+        nv_icmd(priv, 0x0000029a, 0x00000000);
+        nv_icmd(priv, 0x0000029b, 0x00000000);
+        nv_icmd(priv, 0x0000029c, 0x00000000);
+        nv_icmd(priv, 0x0000029d, 0x00000000);
+        nv_icmd(priv, 0x0000029e, 0x00000000);
+        nv_icmd(priv, 0x0000029f, 0x00000000);
+        nv_icmd(priv, 0x000003b0, 0x00000000);
+        nv_icmd(priv, 0x000003b1, 0x00000000);
+        nv_icmd(priv, 0x000003b2, 0x00000000);
+        nv_icmd(priv, 0x000003b3, 0x00000000);
+        nv_icmd(priv, 0x000003b4, 0x00000000);
+        nv_icmd(priv, 0x000003b5, 0x00000000);
+        nv_icmd(priv, 0x000003b6, 0x00000000);
+        nv_icmd(priv, 0x000003b7, 0x00000000);
+        nv_icmd(priv, 0x000003b8, 0x00000000);
+        nv_icmd(priv, 0x000003b9, 0x00000000);
+        nv_icmd(priv, 0x000003ba, 0x00000000);
+        nv_icmd(priv, 0x000003bb, 0x00000000);
+        nv_icmd(priv, 0x000003bc, 0x00000000);
+        nv_icmd(priv, 0x000003bd, 0x00000000);
+        nv_icmd(priv, 0x000003be, 0x00000000);
+        nv_icmd(priv, 0x000003bf, 0x00000000);
+        nv_icmd(priv, 0x000002a0, 0x00000000);
+        nv_icmd(priv, 0x000002a1, 0x00000000);
+        nv_icmd(priv, 0x000002a2, 0x00000000);
+        nv_icmd(priv, 0x000002a3, 0x00000000);
+        nv_icmd(priv, 0x000002a4, 0x00000000);
+        nv_icmd(priv, 0x000002a5, 0x00000000);
+        nv_icmd(priv, 0x000002a6, 0x00000000);
+        nv_icmd(priv, 0x000002a7, 0x00000000);
+        nv_icmd(priv, 0x000002a8, 0x00000000);
+        nv_icmd(priv, 0x000002a9, 0x00000000);
+        nv_icmd(priv, 0x000002aa, 0x00000000);
+        nv_icmd(priv, 0x000002ab, 0x00000000);
+        nv_icmd(priv, 0x000002ac, 0x00000000);
+        nv_icmd(priv, 0x000002ad, 0x00000000);
+        nv_icmd(priv, 0x000002ae, 0x00000000);
+        nv_icmd(priv, 0x000002af, 0x00000000);
+        nv_icmd(priv, 0x00000420, 0x00000000);
+        nv_icmd(priv, 0x00000421, 0x00000000);
+        nv_icmd(priv, 0x00000422, 0x00000000);
+        nv_icmd(priv, 0x00000423, 0x00000000);
+        nv_icmd(priv, 0x00000424, 0x00000000);
+        nv_icmd(priv, 0x00000425, 0x00000000);
+        nv_icmd(priv, 0x00000426, 0x00000000);
+        nv_icmd(priv, 0x00000427, 0x00000000);
+        nv_icmd(priv, 0x00000428, 0x00000000);
+        nv_icmd(priv, 0x00000429, 0x00000000);
+        nv_icmd(priv, 0x0000042a, 0x00000000);
+        nv_icmd(priv, 0x0000042b, 0x00000000);
+        nv_icmd(priv, 0x0000042c, 0x00000000);
+        nv_icmd(priv, 0x0000042d, 0x00000000);
+        nv_icmd(priv, 0x0000042e, 0x00000000);
+        nv_icmd(priv, 0x0000042f, 0x00000000);
+        nv_icmd(priv, 0x000002b0, 0x00000000);
+        nv_icmd(priv, 0x000002b1, 0x00000000);
+        nv_icmd(priv, 0x000002b2, 0x00000000);
+        nv_icmd(priv, 0x000002b3, 0x00000000);
+        nv_icmd(priv, 0x000002b4, 0x00000000);
+        nv_icmd(priv, 0x000002b5, 0x00000000);
+        nv_icmd(priv, 0x000002b6, 0x00000000);
+        nv_icmd(priv, 0x000002b7, 0x00000000);
+        nv_icmd(priv, 0x000002b8, 0x00000000);
+        nv_icmd(priv, 0x000002b9, 0x00000000);
+        nv_icmd(priv, 0x000002ba, 0x00000000);
+        nv_icmd(priv, 0x000002bb, 0x00000000);
+        nv_icmd(priv, 0x000002bc, 0x00000000);
+        nv_icmd(priv, 0x000002bd, 0x00000000);
+        nv_icmd(priv, 0x000002be, 0x00000000);
+        nv_icmd(priv, 0x000002bf, 0x00000000);
+        nv_icmd(priv, 0x00000430, 0x00000000);
+        nv_icmd(priv, 0x00000431, 0x00000000);
+        nv_icmd(priv, 0x00000432, 0x00000000);
+        nv_icmd(priv, 0x00000433, 0x00000000);
+        nv_icmd(priv, 0x00000434, 0x00000000);
+        nv_icmd(priv, 0x00000435, 0x00000000);
+        nv_icmd(priv, 0x00000436, 0x00000000);
+        nv_icmd(priv, 0x00000437, 0x00000000);
+        nv_icmd(priv, 0x00000438, 0x00000000);
+        nv_icmd(priv, 0x00000439, 0x00000000);
+        nv_icmd(priv, 0x0000043a, 0x00000000);
+        nv_icmd(priv, 0x0000043b, 0x00000000);
+        nv_icmd(priv, 0x0000043c, 0x00000000);
+        nv_icmd(priv, 0x0000043d, 0x00000000);
+        nv_icmd(priv, 0x0000043e, 0x00000000);
+        nv_icmd(priv, 0x0000043f, 0x00000000);
+        nv_icmd(priv, 0x000002c0, 0x00000000);
+        nv_icmd(priv, 0x000002c1, 0x00000000);
+        nv_icmd(priv, 0x000002c2, 0x00000000);
+        nv_icmd(priv, 0x000002c3, 0x00000000);
+        nv_icmd(priv, 0x000002c4, 0x00000000);
+        nv_icmd(priv, 0x000002c5, 0x00000000);
+        nv_icmd(priv, 0x000002c6, 0x00000000);
+        nv_icmd(priv, 0x000002c7, 0x00000000);
+        nv_icmd(priv, 0x000002c8, 0x00000000);
+        nv_icmd(priv, 0x000002c9, 0x00000000);
+        nv_icmd(priv, 0x000002ca, 0x00000000);
+        nv_icmd(priv, 0x000002cb, 0x00000000);
+        nv_icmd(priv, 0x000002cc, 0x00000000);
+        nv_icmd(priv, 0x000002cd, 0x00000000);
+        nv_icmd(priv, 0x000002ce, 0x00000000);
+        nv_icmd(priv, 0x000002cf, 0x00000000);
+        nv_icmd(priv, 0x000004d0, 0x00000000);
+        nv_icmd(priv, 0x000004d1, 0x00000000);
+        nv_icmd(priv, 0x000004d2, 0x00000000);
+        nv_icmd(priv, 0x000004d3, 0x00000000);
+        nv_icmd(priv, 0x000004d4, 0x00000000);
+        nv_icmd(priv, 0x000004d5, 0x00000000);
+        nv_icmd(priv, 0x000004d6, 0x00000000);
+        nv_icmd(priv, 0x000004d7, 0x00000000);
+        nv_icmd(priv, 0x000004d8, 0x00000000);
+        nv_icmd(priv, 0x000004d9, 0x00000000);
+        nv_icmd(priv, 0x000004da, 0x00000000);
+        nv_icmd(priv, 0x000004db, 0x00000000);
+        nv_icmd(priv, 0x000004dc, 0x00000000);
+        nv_icmd(priv, 0x000004dd, 0x00000000);
+        nv_icmd(priv, 0x000004de, 0x00000000);
+        nv_icmd(priv, 0x000004df, 0x00000000);
+        nv_icmd(priv, 0x00000720, 0x00000000);
+        nv_icmd(priv, 0x00000721, 0x00000000);
+        nv_icmd(priv, 0x00000722, 0x00000000);
+        nv_icmd(priv, 0x00000723, 0x00000000);
+        nv_icmd(priv, 0x00000724, 0x00000000);
+        nv_icmd(priv, 0x00000725, 0x00000000);
+        nv_icmd(priv, 0x00000726, 0x00000000);
+        nv_icmd(priv, 0x00000727, 0x00000000);
+        nv_icmd(priv, 0x00000728, 0x00000000);
+        nv_icmd(priv, 0x00000729, 0x00000000);
+        nv_icmd(priv, 0x0000072a, 0x00000000);
+        nv_icmd(priv, 0x0000072b, 0x00000000);
+        nv_icmd(priv, 0x0000072c, 0x00000000);
+        nv_icmd(priv, 0x0000072d, 0x00000000);
+        nv_icmd(priv, 0x0000072e, 0x00000000);
+        nv_icmd(priv, 0x0000072f, 0x00000000);
+        nv_icmd(priv, 0x000008c0, 0x00000000);
+        nv_icmd(priv, 0x000008c1, 0x00000000);
+        nv_icmd(priv, 0x000008c2, 0x00000000);
+        nv_icmd(priv, 0x000008c3, 0x00000000);
+        nv_icmd(priv, 0x000008c4, 0x00000000);
+        nv_icmd(priv, 0x000008c5, 0x00000000);
+        nv_icmd(priv, 0x000008c6, 0x00000000);
+        nv_icmd(priv, 0x000008c7, 0x00000000);
+        nv_icmd(priv, 0x000008c8, 0x00000000);
+        nv_icmd(priv, 0x000008c9, 0x00000000);
+        nv_icmd(priv, 0x000008ca, 0x00000000);
+        nv_icmd(priv, 0x000008cb, 0x00000000);
+        nv_icmd(priv, 0x000008cc, 0x00000000);
+        nv_icmd(priv, 0x000008cd, 0x00000000);
+        nv_icmd(priv, 0x000008ce, 0x00000000);
+        nv_icmd(priv, 0x000008cf, 0x00000000);
+        nv_icmd(priv, 0x00000890, 0x00000000);
+        nv_icmd(priv, 0x00000891, 0x00000000);
+        nv_icmd(priv, 0x00000892, 0x00000000);
+        nv_icmd(priv, 0x00000893, 0x00000000);
+        nv_icmd(priv, 0x00000894, 0x00000000);
+        nv_icmd(priv, 0x00000895, 0x00000000);
+        nv_icmd(priv, 0x00000896, 0x00000000);
+        nv_icmd(priv, 0x00000897, 0x00000000);
+        nv_icmd(priv, 0x00000898, 0x00000000);
+        nv_icmd(priv, 0x00000899, 0x00000000);
+        nv_icmd(priv, 0x0000089a, 0x00000000);
+        nv_icmd(priv, 0x0000089b, 0x00000000);
+        nv_icmd(priv, 0x0000089c, 0x00000000);
+        nv_icmd(priv, 0x0000089d, 0x00000000);
+        nv_icmd(priv, 0x0000089e, 0x00000000);
+        nv_icmd(priv, 0x0000089f, 0x00000000);
+        nv_icmd(priv, 0x000008e0, 0x00000000);
+        nv_icmd(priv, 0x000008e1, 0x00000000);
+        nv_icmd(priv, 0x000008e2, 0x00000000);
+        nv_icmd(priv, 0x000008e3, 0x00000000);
+        nv_icmd(priv, 0x000008e4, 0x00000000);
+        nv_icmd(priv, 0x000008e5, 0x00000000);
+        nv_icmd(priv, 0x000008e6, 0x00000000);
+        nv_icmd(priv, 0x000008e7, 0x00000000);
+        nv_icmd(priv, 0x000008e8, 0x00000000);
+        nv_icmd(priv, 0x000008e9, 0x00000000);
+        nv_icmd(priv, 0x000008ea, 0x00000000);
+        nv_icmd(priv, 0x000008eb, 0x00000000);
+        nv_icmd(priv, 0x000008ec, 0x00000000);
+        nv_icmd(priv, 0x000008ed, 0x00000000);
+        nv_icmd(priv, 0x000008ee, 0x00000000);
+        nv_icmd(priv, 0x000008ef, 0x00000000);
+        nv_icmd(priv, 0x000008a0, 0x00000000);
+        nv_icmd(priv, 0x000008a1, 0x00000000);
+        nv_icmd(priv, 0x000008a2, 0x00000000);
+        nv_icmd(priv, 0x000008a3, 0x00000000);
+        nv_icmd(priv, 0x000008a4, 0x00000000);
+        nv_icmd(priv, 0x000008a5, 0x00000000);
+        nv_icmd(priv, 0x000008a6, 0x00000000);
+        nv_icmd(priv, 0x000008a7, 0x00000000);
+        nv_icmd(priv, 0x000008a8, 0x00000000);
+        nv_icmd(priv, 0x000008a9, 0x00000000);
+        nv_icmd(priv, 0x000008aa, 0x00000000);
+        nv_icmd(priv, 0x000008ab, 0x00000000);
+        nv_icmd(priv, 0x000008ac, 0x00000000);
+        nv_icmd(priv, 0x000008ad, 0x00000000);
+        nv_icmd(priv, 0x000008ae, 0x00000000);
+        nv_icmd(priv, 0x000008af, 0x00000000);
+        nv_icmd(priv, 0x000008f0, 0x00000000);
+        nv_icmd(priv, 0x000008f1, 0x00000000);
+        nv_icmd(priv, 0x000008f2, 0x00000000);
+        nv_icmd(priv, 0x000008f3, 0x00000000);
+        nv_icmd(priv, 0x000008f4, 0x00000000);
+        nv_icmd(priv, 0x000008f5, 0x00000000);
+        nv_icmd(priv, 0x000008f6, 0x00000000);
+        nv_icmd(priv, 0x000008f7, 0x00000000);
+        nv_icmd(priv, 0x000008f8, 0x00000000);
+        nv_icmd(priv, 0x000008f9, 0x00000000);
+        nv_icmd(priv, 0x000008fa, 0x00000000);
+        nv_icmd(priv, 0x000008fb, 0x00000000);
+        nv_icmd(priv, 0x000008fc, 0x00000000);
+        nv_icmd(priv, 0x000008fd, 0x00000000);
+        nv_icmd(priv, 0x000008fe, 0x00000000);
+        nv_icmd(priv, 0x000008ff, 0x00000000);
+        nv_icmd(priv, 0x0000094c, 0x000000ff);
+        nv_icmd(priv, 0x0000094d, 0xffffffff);
+        nv_icmd(priv, 0x0000094e, 0x00000002);
+        nv_icmd(priv, 0x000002ec, 0x00000001);
+        nv_icmd(priv, 0x00000303, 0x00000001);
+        nv_icmd(priv, 0x000002e6, 0x00000001);
+        nv_icmd(priv, 0x00000466, 0x00000052);
+        nv_icmd(priv, 0x00000301, 0x3f800000);
+        nv_icmd(priv, 0x00000304, 0x30201000);
+        nv_icmd(priv, 0x00000305, 0x70605040);
+        nv_icmd(priv, 0x00000306, 0xb8a89888);
+        nv_icmd(priv, 0x00000307, 0xf8e8d8c8);
+        nv_icmd(priv, 0x0000030a, 0x00ffff00);
+        nv_icmd(priv, 0x0000030b, 0x0000001a);
+        nv_icmd(priv, 0x0000030c, 0x00000001);
+        nv_icmd(priv, 0x00000318, 0x00000001);
+        nv_icmd(priv, 0x00000340, 0x00000000);
+        nv_icmd(priv, 0x00000375, 0x00000001);
+        nv_icmd(priv, 0x00000351, 0x00000100);
+        nv_icmd(priv, 0x0000037d, 0x00000006);
+        nv_icmd(priv, 0x000003a0, 0x00000002);
+        nv_icmd(priv, 0x000003aa, 0x00000001);
+        nv_icmd(priv, 0x000003a9, 0x00000001);
+        nv_icmd(priv, 0x00000380, 0x00000001);
+        nv_icmd(priv, 0x00000360, 0x00000040);
+        nv_icmd(priv, 0x00000366, 0x00000000);
+        nv_icmd(priv, 0x00000367, 0x00000000);
+        nv_icmd(priv, 0x00000368, 0x00001fff);
+        nv_icmd(priv, 0x00000370, 0x00000000);
+        nv_icmd(priv, 0x00000371, 0x00000000);
+        nv_icmd(priv, 0x00000372, 0x003fffff);
+        nv_icmd(priv, 0x0000037a, 0x00000012);
+        nv_icmd(priv, 0x000005e0, 0x00000022);
+        nv_icmd(priv, 0x000005e1, 0x00000022);
+        nv_icmd(priv, 0x000005e2, 0x00000022);
+        nv_icmd(priv, 0x000005e3, 0x00000022);
+        nv_icmd(priv, 0x000005e4, 0x00000022);
+        nv_icmd(priv, 0x00000619, 0x00000003);
+        nv_icmd(priv, 0x00000811, 0x00000003);
+        nv_icmd(priv, 0x00000812, 0x00000004);
+        nv_icmd(priv, 0x00000813, 0x00000006);
+        nv_icmd(priv, 0x00000814, 0x00000008);
+        nv_icmd(priv, 0x00000815, 0x0000000b);
+        nv_icmd(priv, 0x00000800, 0x00000001);
+        nv_icmd(priv, 0x00000801, 0x00000001);
+        nv_icmd(priv, 0x00000802, 0x00000001);
+        nv_icmd(priv, 0x00000803, 0x00000001);
+        nv_icmd(priv, 0x00000804, 0x00000001);
+        nv_icmd(priv, 0x00000805, 0x00000001);
+        nv_icmd(priv, 0x00000632, 0x00000001);
+        nv_icmd(priv, 0x00000633, 0x00000002);
+        nv_icmd(priv, 0x00000634, 0x00000003);
+        nv_icmd(priv, 0x00000635, 0x00000004);
+        nv_icmd(priv, 0x00000654, 0x3f800000);
+        nv_icmd(priv, 0x00000657, 0x3f800000);
+        nv_icmd(priv, 0x00000655, 0x3f800000);
+        nv_icmd(priv, 0x00000656, 0x3f800000);
+        nv_icmd(priv, 0x000006cd, 0x3f800000);
+        nv_icmd(priv, 0x000007f5, 0x3f800000);
+        nv_icmd(priv, 0x000007dc, 0x39291909);
+        nv_icmd(priv, 0x000007dd, 0x79695949);
+        nv_icmd(priv, 0x000007de, 0xb9a99989);
+        nv_icmd(priv, 0x000007df, 0xf9e9d9c9);
+        nv_icmd(priv, 0x000007e8, 0x00003210);
+        nv_icmd(priv, 0x000007e9, 0x00007654);
+        nv_icmd(priv, 0x000007ea, 0x00000098);
+        nv_icmd(priv, 0x000007ec, 0x39291909);
+        nv_icmd(priv, 0x000007ed, 0x79695949);
+        nv_icmd(priv, 0x000007ee, 0xb9a99989);
+        nv_icmd(priv, 0x000007ef, 0xf9e9d9c9);
+        nv_icmd(priv, 0x000007f0, 0x00003210);
+        nv_icmd(priv, 0x000007f1, 0x00007654);
+        nv_icmd(priv, 0x000007f2, 0x00000098);
+        nv_icmd(priv, 0x000005a5, 0x00000001);
+        nv_icmd(priv, 0x00000980, 0x00000000);
+        nv_icmd(priv, 0x00000981, 0x00000000);
+        nv_icmd(priv, 0x00000982, 0x00000000);
+        nv_icmd(priv, 0x00000983, 0x00000000);
+        nv_icmd(priv, 0x00000984, 0x00000000);
+        nv_icmd(priv, 0x00000985, 0x00000000);
+        nv_icmd(priv, 0x00000986, 0x00000000);
+        nv_icmd(priv, 0x00000987, 0x00000000);
+        nv_icmd(priv, 0x00000988, 0x00000000);
+        nv_icmd(priv, 0x00000989, 0x00000000);
+        nv_icmd(priv, 0x0000098a, 0x00000000);
+        nv_icmd(priv, 0x0000098b, 0x00000000);
+        nv_icmd(priv, 0x0000098c, 0x00000000);
+        nv_icmd(priv, 0x0000098d, 0x00000000);
+        nv_icmd(priv, 0x0000098e, 0x00000000);
+        nv_icmd(priv, 0x0000098f, 0x00000000);
+        nv_icmd(priv, 0x00000990, 0x00000000);
+        nv_icmd(priv, 0x00000991, 0x00000000);
+        nv_icmd(priv, 0x00000992, 0x00000000);
+        nv_icmd(priv, 0x00000993, 0x00000000);
+        nv_icmd(priv, 0x00000994, 0x00000000);
+        nv_icmd(priv, 0x00000995, 0x00000000);
+        nv_icmd(priv, 0x00000996, 0x00000000);
+        nv_icmd(priv, 0x00000997, 0x00000000);
+        nv_icmd(priv, 0x00000998, 0x00000000);
+        nv_icmd(priv, 0x00000999, 0x00000000);
+        nv_icmd(priv, 0x0000099a, 0x00000000);
+        nv_icmd(priv, 0x0000099b, 0x00000000);
+        nv_icmd(priv, 0x0000099c, 0x00000000);
+        nv_icmd(priv, 0x0000099d, 0x00000000);
+        nv_icmd(priv, 0x0000099e, 0x00000000);
+        nv_icmd(priv, 0x0000099f, 0x00000000);
+        nv_icmd(priv, 0x000009a0, 0x00000000);
+        nv_icmd(priv, 0x000009a1, 0x00000000);
+        nv_icmd(priv, 0x000009a2, 0x00000000);
+        nv_icmd(priv, 0x000009a3, 0x00000000);
+        nv_icmd(priv, 0x000009a4, 0x00000000);
+        nv_icmd(priv, 0x000009a5, 0x00000000);
+        nv_icmd(priv, 0x000009a6, 0x00000000);
+        nv_icmd(priv, 0x000009a7, 0x00000000);
+        nv_icmd(priv, 0x000009a8, 0x00000000);
+        nv_icmd(priv, 0x000009a9, 0x00000000);
+        nv_icmd(priv, 0x000009aa, 0x00000000);
+        nv_icmd(priv, 0x000009ab, 0x00000000);
+        nv_icmd(priv, 0x000009ac, 0x00000000);
+        nv_icmd(priv, 0x000009ad, 0x00000000);
+        nv_icmd(priv, 0x000009ae, 0x00000000);
+        nv_icmd(priv, 0x000009af, 0x00000000);
+        nv_icmd(priv, 0x000009b0, 0x00000000);
+        nv_icmd(priv, 0x000009b1, 0x00000000);
+        nv_icmd(priv, 0x000009b2, 0x00000000);
+        nv_icmd(priv, 0x000009b3, 0x00000000);
+        nv_icmd(priv, 0x000009b4, 0x00000000);
+        nv_icmd(priv, 0x000009b5, 0x00000000);
+        nv_icmd(priv, 0x000009b6, 0x00000000);
+        nv_icmd(priv, 0x000009b7, 0x00000000);
+        nv_icmd(priv, 0x000009b8, 0x00000000);
+        nv_icmd(priv, 0x000009b9, 0x00000000);
+        nv_icmd(priv, 0x000009ba, 0x00000000);
+        nv_icmd(priv, 0x000009bb, 0x00000000);
+        nv_icmd(priv, 0x000009bc, 0x00000000);
+        nv_icmd(priv, 0x000009bd, 0x00000000);
+        nv_icmd(priv, 0x000009be, 0x00000000);
+        nv_icmd(priv, 0x000009bf, 0x00000000);
+        nv_icmd(priv, 0x000009c0, 0x00000000);
+        nv_icmd(priv, 0x000009c1, 0x00000000);
+        nv_icmd(priv, 0x000009c2, 0x00000000);
+        nv_icmd(priv, 0x000009c3, 0x00000000);
+        nv_icmd(priv, 0x000009c4, 0x00000000);
+        nv_icmd(priv, 0x000009c5, 0x00000000);
+        nv_icmd(priv, 0x000009c6, 0x00000000);
+        nv_icmd(priv, 0x000009c7, 0x00000000);
+        nv_icmd(priv, 0x000009c8, 0x00000000);
+        nv_icmd(priv, 0x000009c9, 0x00000000);
+        nv_icmd(priv, 0x000009ca, 0x00000000);
+        nv_icmd(priv, 0x000009cb, 0x00000000);
+        nv_icmd(priv, 0x000009cc, 0x00000000);
+        nv_icmd(priv, 0x000009cd, 0x00000000);
+        nv_icmd(priv, 0x000009ce, 0x00000000);
+        nv_icmd(priv, 0x000009cf, 0x00000000);
+        nv_icmd(priv, 0x000009d0, 0x00000000);
+        nv_icmd(priv, 0x000009d1, 0x00000000);
+        nv_icmd(priv, 0x000009d2, 0x00000000);
+        nv_icmd(priv, 0x000009d3, 0x00000000);
+        nv_icmd(priv, 0x000009d4, 0x00000000);
+        nv_icmd(priv, 0x000009d5, 0x00000000);
+        nv_icmd(priv, 0x000009d6, 0x00000000);
+        nv_icmd(priv, 0x000009d7, 0x00000000);
+        nv_icmd(priv, 0x000009d8, 0x00000000);
+        nv_icmd(priv, 0x000009d9, 0x00000000);
+        nv_icmd(priv, 0x000009da, 0x00000000);
+        nv_icmd(priv, 0x000009db, 0x00000000);
+        nv_icmd(priv, 0x000009dc, 0x00000000);
+        nv_icmd(priv, 0x000009dd, 0x00000000);
+        nv_icmd(priv, 0x000009de, 0x00000000);
+        nv_icmd(priv, 0x000009df, 0x00000000);
+        nv_icmd(priv, 0x000009e0, 0x00000000);
+        nv_icmd(priv, 0x000009e1, 0x00000000);
+        nv_icmd(priv, 0x000009e2, 0x00000000);
+        nv_icmd(priv, 0x000009e3, 0x00000000);
+        nv_icmd(priv, 0x000009e4, 0x00000000);
+        nv_icmd(priv, 0x000009e5, 0x00000000);
+        nv_icmd(priv, 0x000009e6, 0x00000000);
+        nv_icmd(priv, 0x000009e7, 0x00000000);
+        nv_icmd(priv, 0x000009e8, 0x00000000);
+        nv_icmd(priv, 0x000009e9, 0x00000000);
+        nv_icmd(priv, 0x000009ea, 0x00000000);
+        nv_icmd(priv, 0x000009eb, 0x00000000);
+        nv_icmd(priv, 0x000009ec, 0x00000000);
+        nv_icmd(priv, 0x000009ed, 0x00000000);
+        nv_icmd(priv, 0x000009ee, 0x00000000);
+        nv_icmd(priv, 0x000009ef, 0x00000000);
+        nv_icmd(priv, 0x000009f0, 0x00000000);
+        nv_icmd(priv, 0x000009f1, 0x00000000);
+        nv_icmd(priv, 0x000009f2, 0x00000000);
+        nv_icmd(priv, 0x000009f3, 0x00000000);
+        nv_icmd(priv, 0x000009f4, 0x00000000);
+        nv_icmd(priv, 0x000009f5, 0x00000000);
+        nv_icmd(priv, 0x000009f6, 0x00000000);
+        nv_icmd(priv, 0x000009f7, 0x00000000);
+        nv_icmd(priv, 0x000009f8, 0x00000000);
+        nv_icmd(priv, 0x000009f9, 0x00000000);
+        nv_icmd(priv, 0x000009fa, 0x00000000);
+        nv_icmd(priv, 0x000009fb, 0x00000000);
+        nv_icmd(priv, 0x000009fc, 0x00000000);
+        nv_icmd(priv, 0x000009fd, 0x00000000);
+        nv_icmd(priv, 0x000009fe, 0x00000000);
+        nv_icmd(priv, 0x000009ff, 0x00000000);
+        nv_icmd(priv, 0x00000468, 0x00000004);
+        nv_icmd(priv, 0x0000046c, 0x00000001);
+        nv_icmd(priv, 0x00000470, 0x00000000);
+        nv_icmd(priv, 0x00000471, 0x00000000);
+        nv_icmd(priv, 0x00000472, 0x00000000);
+        nv_icmd(priv, 0x00000473, 0x00000000);
+        nv_icmd(priv, 0x00000474, 0x00000000);
+        nv_icmd(priv, 0x00000475, 0x00000000);
+        nv_icmd(priv, 0x00000476, 0x00000000);
+        nv_icmd(priv, 0x00000477, 0x00000000);
+        nv_icmd(priv, 0x00000478, 0x00000000);
+        nv_icmd(priv, 0x00000479, 0x00000000);
+        nv_icmd(priv, 0x0000047a, 0x00000000);
+        nv_icmd(priv, 0x0000047b, 0x00000000);
+        nv_icmd(priv, 0x0000047c, 0x00000000);
+        nv_icmd(priv, 0x0000047d, 0x00000000);
+        nv_icmd(priv, 0x0000047e, 0x00000000);
+        nv_icmd(priv, 0x0000047f, 0x00000000);
+        nv_icmd(priv, 0x00000480, 0x00000000);
+        nv_icmd(priv, 0x00000481, 0x00000000);
+        nv_icmd(priv, 0x00000482, 0x00000000);
+        nv_icmd(priv, 0x00000483, 0x00000000);
+        nv_icmd(priv, 0x00000484, 0x00000000);
+        nv_icmd(priv, 0x00000485, 0x00000000);
+        nv_icmd(priv, 0x00000486, 0x00000000);
+        nv_icmd(priv, 0x00000487, 0x00000000);
+        nv_icmd(priv, 0x00000488, 0x00000000);
+        nv_icmd(priv, 0x00000489, 0x00000000);
+        nv_icmd(priv, 0x0000048a, 0x00000000);
+        nv_icmd(priv, 0x0000048b, 0x00000000);
+        nv_icmd(priv, 0x0000048c, 0x00000000);
+        nv_icmd(priv, 0x0000048d, 0x00000000);
+        nv_icmd(priv, 0x0000048e, 0x00000000);
+        nv_icmd(priv, 0x0000048f, 0x00000000);
+        nv_icmd(priv, 0x00000490, 0x00000000);
+        nv_icmd(priv, 0x00000491, 0x00000000);
+        nv_icmd(priv, 0x00000492, 0x00000000);
+        nv_icmd(priv, 0x00000493, 0x00000000);
+        nv_icmd(priv, 0x00000494, 0x00000000);
+        nv_icmd(priv, 0x00000495, 0x00000000);
+        nv_icmd(priv, 0x00000496, 0x00000000);
+        nv_icmd(priv, 0x00000497, 0x00000000);
+        nv_icmd(priv, 0x00000498, 0x00000000);
+        nv_icmd(priv, 0x00000499, 0x00000000);
+        nv_icmd(priv, 0x0000049a, 0x00000000);
+        nv_icmd(priv, 0x0000049b, 0x00000000);
+        nv_icmd(priv, 0x0000049c, 0x00000000);
+        nv_icmd(priv, 0x0000049d, 0x00000000);
+        nv_icmd(priv, 0x0000049e, 0x00000000);
+        nv_icmd(priv, 0x0000049f, 0x00000000);
+        nv_icmd(priv, 0x000004a0, 0x00000000);
+        nv_icmd(priv, 0x000004a1, 0x00000000);
+        nv_icmd(priv, 0x000004a2, 0x00000000);
+        nv_icmd(priv, 0x000004a3, 0x00000000);
+        nv_icmd(priv, 0x000004a4, 0x00000000);
+        nv_icmd(priv, 0x000004a5, 0x00000000);
+        nv_icmd(priv, 0x000004a6, 0x00000000);
+        nv_icmd(priv, 0x000004a7, 0x00000000);
+        nv_icmd(priv, 0x000004a8, 0x00000000);
+        nv_icmd(priv, 0x000004a9, 0x00000000);
+        nv_icmd(priv, 0x000004aa, 0x00000000);
+        nv_icmd(priv, 0x000004ab, 0x00000000);
+        nv_icmd(priv, 0x000004ac, 0x00000000);
+        nv_icmd(priv, 0x000004ad, 0x00000000);
+        nv_icmd(priv, 0x000004ae, 0x00000000);
+        nv_icmd(priv, 0x000004af, 0x00000000);
+        nv_icmd(priv, 0x000004b0, 0x00000000);
+        nv_icmd(priv, 0x000004b1, 0x00000000);
+        nv_icmd(priv, 0x000004b2, 0x00000000);
+        nv_icmd(priv, 0x000004b3, 0x00000000);
+        nv_icmd(priv, 0x000004b4, 0x00000000);
+        nv_icmd(priv, 0x000004b5, 0x00000000);
+        nv_icmd(priv, 0x000004b6, 0x00000000);
+        nv_icmd(priv, 0x000004b7, 0x00000000);
+        nv_icmd(priv, 0x000004b8, 0x00000000);
+        nv_icmd(priv, 0x000004b9, 0x00000000);
+        nv_icmd(priv, 0x000004ba, 0x00000000);
+        nv_icmd(priv, 0x000004bb, 0x00000000);
+        nv_icmd(priv, 0x000004bc, 0x00000000);
+        nv_icmd(priv, 0x000004bd, 0x00000000);
+        nv_icmd(priv, 0x000004be, 0x00000000);
+        nv_icmd(priv, 0x000004bf, 0x00000000);
+        nv_icmd(priv, 0x000004c0, 0x00000000);
+        nv_icmd(priv, 0x000004c1, 0x00000000);
+        nv_icmd(priv, 0x000004c2, 0x00000000);
+        nv_icmd(priv, 0x000004c3, 0x00000000);
+        nv_icmd(priv, 0x000004c4, 0x00000000);
+        nv_icmd(priv, 0x000004c5, 0x00000000);
+        nv_icmd(priv, 0x000004c6, 0x00000000);
+        nv_icmd(priv, 0x000004c7, 0x00000000);
+        nv_icmd(priv, 0x000004c8, 0x00000000);
+        nv_icmd(priv, 0x000004c9, 0x00000000);
+        nv_icmd(priv, 0x000004ca, 0x00000000);
+        nv_icmd(priv, 0x000004cb, 0x00000000);
+        nv_icmd(priv, 0x000004cc, 0x00000000);
+        nv_icmd(priv, 0x000004cd, 0x00000000);
+        nv_icmd(priv, 0x000004ce, 0x00000000);
+        nv_icmd(priv, 0x000004cf, 0x00000000);
+        nv_icmd(priv, 0x00000510, 0x3f800000);
+        nv_icmd(priv, 0x00000511, 0x3f800000);
+        nv_icmd(priv, 0x00000512, 0x3f800000);
+        nv_icmd(priv, 0x00000513, 0x3f800000);
+        nv_icmd(priv, 0x00000514, 0x3f800000);
+        nv_icmd(priv, 0x00000515, 0x3f800000);
+        nv_icmd(priv, 0x00000516, 0x3f800000);
+        nv_icmd(priv, 0x00000517, 0x3f800000);
+        nv_icmd(priv, 0x00000518, 0x3f800000);
+        nv_icmd(priv, 0x00000519, 0x3f800000);
+        nv_icmd(priv, 0x0000051a, 0x3f800000);
+        nv_icmd(priv, 0x0000051b, 0x3f800000);
+        nv_icmd(priv, 0x0000051c, 0x3f800000);
+        nv_icmd(priv, 0x0000051d, 0x3f800000);
+        nv_icmd(priv, 0x0000051e, 0x3f800000);
+        nv_icmd(priv, 0x0000051f, 0x3f800000);
+        nv_icmd(priv, 0x00000520, 0x000002b6);
+        nv_icmd(priv, 0x00000529, 0x00000001);
+        nv_icmd(priv, 0x00000530, 0xffff0000);
+        nv_icmd(priv, 0x00000531, 0xffff0000);
+        nv_icmd(priv, 0x00000532, 0xffff0000);
+        nv_icmd(priv, 0x00000533, 0xffff0000);
+        nv_icmd(priv, 0x00000534, 0xffff0000);
+        nv_icmd(priv, 0x00000535, 0xffff0000);
+        nv_icmd(priv, 0x00000536, 0xffff0000);
+        nv_icmd(priv, 0x00000537, 0xffff0000);
+        nv_icmd(priv, 0x00000538, 0xffff0000);
+        nv_icmd(priv, 0x00000539, 0xffff0000);
+        nv_icmd(priv, 0x0000053a, 0xffff0000);
+        nv_icmd(priv, 0x0000053b, 0xffff0000);
+        nv_icmd(priv, 0x0000053c, 0xffff0000);
+        nv_icmd(priv, 0x0000053d, 0xffff0000);
+        nv_icmd(priv, 0x0000053e, 0xffff0000);
+        nv_icmd(priv, 0x0000053f, 0xffff0000);
+        nv_icmd(priv, 0x00000585, 0x0000003f);
+        nv_icmd(priv, 0x00000576, 0x00000003);
+        if (nv_device(priv)->chipset == 0xc1 ||
+            nv_device(priv)->chipset == 0xd9)
+                nv_icmd(priv, 0x0000057b, 0x00000059);
+        nv_icmd(priv, 0x00000586, 0x00000040);
+        nv_icmd(priv, 0x00000582, 0x00000080);
+        nv_icmd(priv, 0x00000583, 0x00000080);
+        nv_icmd(priv, 0x000005c2, 0x00000001);
+        nv_icmd(priv, 0x00000638, 0x00000001);
+        nv_icmd(priv, 0x00000639, 0x00000001);
+        nv_icmd(priv, 0x0000063a, 0x00000002);
+        nv_icmd(priv, 0x0000063b, 0x00000001);
+        nv_icmd(priv, 0x0000063c, 0x00000001);
+        nv_icmd(priv, 0x0000063d, 0x00000002);
+        nv_icmd(priv, 0x0000063e, 0x00000001);
+        nv_icmd(priv, 0x000008b8, 0x00000001);
+        nv_icmd(priv, 0x000008b9, 0x00000001);
+        nv_icmd(priv, 0x000008ba, 0x00000001);
+        nv_icmd(priv, 0x000008bb, 0x00000001);
+        nv_icmd(priv, 0x000008bc, 0x00000001);
+        nv_icmd(priv, 0x000008bd, 0x00000001);
+        nv_icmd(priv, 0x000008be, 0x00000001);
+        nv_icmd(priv, 0x000008bf, 0x00000001);
+        nv_icmd(priv, 0x00000900, 0x00000001);
+        nv_icmd(priv, 0x00000901, 0x00000001);
+        nv_icmd(priv, 0x00000902, 0x00000001);
+        nv_icmd(priv, 0x00000903, 0x00000001);
+        nv_icmd(priv, 0x00000904, 0x00000001);
+        nv_icmd(priv, 0x00000905, 0x00000001);
+        nv_icmd(priv, 0x00000906, 0x00000001);
+        nv_icmd(priv, 0x00000907, 0x00000001);
+        nv_icmd(priv, 0x00000908, 0x00000002);
+        nv_icmd(priv, 0x00000909, 0x00000002);
+        nv_icmd(priv, 0x0000090a, 0x00000002);
+        nv_icmd(priv, 0x0000090b, 0x00000002);
+        nv_icmd(priv, 0x0000090c, 0x00000002);
+        nv_icmd(priv, 0x0000090d, 0x00000002);
+        nv_icmd(priv, 0x0000090e, 0x00000002);
+        nv_icmd(priv, 0x0000090f, 0x00000002);
+        nv_icmd(priv, 0x00000910, 0x00000001);
+        nv_icmd(priv, 0x00000911, 0x00000001);
+        nv_icmd(priv, 0x00000912, 0x00000001);
+        nv_icmd(priv, 0x00000913, 0x00000001);
+        nv_icmd(priv, 0x00000914, 0x00000001);
+        nv_icmd(priv, 0x00000915, 0x00000001);
+        nv_icmd(priv, 0x00000916, 0x00000001);
+        nv_icmd(priv, 0x00000917, 0x00000001);
+        nv_icmd(priv, 0x00000918, 0x00000001);
+        nv_icmd(priv, 0x00000919, 0x00000001);
+        nv_icmd(priv, 0x0000091a, 0x00000001);
+        nv_icmd(priv, 0x0000091b, 0x00000001);
+        nv_icmd(priv, 0x0000091c, 0x00000001);
+        nv_icmd(priv, 0x0000091d, 0x00000001);
+        nv_icmd(priv, 0x0000091e, 0x00000001);
+        nv_icmd(priv, 0x0000091f, 0x00000001);
+        nv_icmd(priv, 0x00000920, 0x00000002);
+        nv_icmd(priv, 0x00000921, 0x00000002);
+        nv_icmd(priv, 0x00000922, 0x00000002);
+        nv_icmd(priv, 0x00000923, 0x00000002);
+        nv_icmd(priv, 0x00000924, 0x00000002);
+        nv_icmd(priv, 0x00000925, 0x00000002);
+        nv_icmd(priv, 0x00000926, 0x00000002);
+        nv_icmd(priv, 0x00000927, 0x00000002);
+        nv_icmd(priv, 0x00000928, 0x00000001);
+        nv_icmd(priv, 0x00000929, 0x00000001);
+        nv_icmd(priv, 0x0000092a, 0x00000001);
+        nv_icmd(priv, 0x0000092b, 0x00000001);
+        nv_icmd(priv, 0x0000092c, 0x00000001);
+        nv_icmd(priv, 0x0000092d, 0x00000001);
+        nv_icmd(priv, 0x0000092e, 0x00000001);
+        nv_icmd(priv, 0x0000092f, 0x00000001);
+        nv_icmd(priv, 0x00000648, 0x00000001);
+        nv_icmd(priv, 0x00000649, 0x00000001);
+        nv_icmd(priv, 0x0000064a, 0x00000001);
+        nv_icmd(priv, 0x0000064b, 0x00000001);
+        nv_icmd(priv, 0x0000064c, 0x00000001);
+        nv_icmd(priv, 0x0000064d, 0x00000001);
+        nv_icmd(priv, 0x0000064e, 0x00000001);
+        nv_icmd(priv, 0x0000064f, 0x00000001);
+        nv_icmd(priv, 0x00000650, 0x00000001);
+        nv_icmd(priv, 0x00000658, 0x0000000f);
+        nv_icmd(priv, 0x000007ff, 0x0000000a);
+        nv_icmd(priv, 0x0000066a, 0x40000000);
+        nv_icmd(priv, 0x0000066b, 0x10000000);
+        nv_icmd(priv, 0x0000066c, 0xffff0000);
+        nv_icmd(priv, 0x0000066d, 0xffff0000);
+        nv_icmd(priv, 0x000007af, 0x00000008);
+        nv_icmd(priv, 0x000007b0, 0x00000008);
+        nv_icmd(priv, 0x000007f6, 0x00000001);
+        nv_icmd(priv, 0x000006b2, 0x00000055);
+        nv_icmd(priv, 0x000007ad, 0x00000003);
+        nv_icmd(priv, 0x00000937, 0x00000001);
+        nv_icmd(priv, 0x00000971, 0x00000008);
+        nv_icmd(priv, 0x00000972, 0x00000040);
+        nv_icmd(priv, 0x00000973, 0x0000012c);
+        nv_icmd(priv, 0x0000097c, 0x00000040);
+        nv_icmd(priv, 0x00000979, 0x00000003);
+        nv_icmd(priv, 0x00000975, 0x00000020);
+        nv_icmd(priv, 0x00000976, 0x00000001);
+        nv_icmd(priv, 0x00000977, 0x00000020);
+        nv_icmd(priv, 0x00000978, 0x00000001);
+        nv_icmd(priv, 0x00000957, 0x00000003);
+        nv_icmd(priv, 0x0000095e, 0x20164010);
+        nv_icmd(priv, 0x0000095f, 0x00000020);
+        if (nv_device(priv)->chipset == 0xd9)
+                nv_icmd(priv, 0x0000097d, 0x00000020);
+        nv_icmd(priv, 0x00000683, 0x00000006);
+        nv_icmd(priv, 0x00000685, 0x003fffff);
+        nv_icmd(priv, 0x00000687, 0x00000c48);
+        nv_icmd(priv, 0x000006a0, 0x00000005);
+        nv_icmd(priv, 0x00000840, 0x00300008);
+        nv_icmd(priv, 0x00000841, 0x04000080);
+        nv_icmd(priv, 0x00000842, 0x00300008);
+        nv_icmd(priv, 0x00000843, 0x04000080);
+        nv_icmd(priv, 0x00000818, 0x00000000);
+        nv_icmd(priv, 0x00000819, 0x00000000);
+        nv_icmd(priv, 0x0000081a, 0x00000000);
+        nv_icmd(priv, 0x0000081b, 0x00000000);
+        nv_icmd(priv, 0x0000081c, 0x00000000);
+        nv_icmd(priv, 0x0000081d, 0x00000000);
+        nv_icmd(priv, 0x0000081e, 0x00000000);
+        nv_icmd(priv, 0x0000081f, 0x00000000);
+        nv_icmd(priv, 0x00000848, 0x00000000);
+        nv_icmd(priv, 0x00000849, 0x00000000);
+        nv_icmd(priv, 0x0000084a, 0x00000000);
+        nv_icmd(priv, 0x0000084b, 0x00000000);
+        nv_icmd(priv, 0x0000084c, 0x00000000);
+        nv_icmd(priv, 0x0000084d, 0x00000000);
+        nv_icmd(priv, 0x0000084e, 0x00000000);
+        nv_icmd(priv, 0x0000084f, 0x00000000);
+        nv_icmd(priv, 0x00000850, 0x00000000);
+        nv_icmd(priv, 0x00000851, 0x00000000);
+        nv_icmd(priv, 0x00000852, 0x00000000);
+        nv_icmd(priv, 0x00000853, 0x00000000);
+        nv_icmd(priv, 0x00000854, 0x00000000);
+        nv_icmd(priv, 0x00000855, 0x00000000);
+        nv_icmd(priv, 0x00000856, 0x00000000);
+        nv_icmd(priv, 0x00000857, 0x00000000);
+        nv_icmd(priv, 0x00000738, 0x00000000);
+        nv_icmd(priv, 0x000006aa, 0x00000001);
+        nv_icmd(priv, 0x000006ab, 0x00000002);
+        nv_icmd(priv, 0x000006ac, 0x00000080);
+        nv_icmd(priv, 0x000006ad, 0x00000100);
+        nv_icmd(priv, 0x000006ae, 0x00000100);
+        nv_icmd(priv, 0x000006b1, 0x00000011);
+        nv_icmd(priv, 0x000006bb, 0x000000cf);
+        nv_icmd(priv, 0x000006ce, 0x2a712488);
+        nv_icmd(priv, 0x00000739, 0x4085c000);
+        nv_icmd(priv, 0x0000073a, 0x00000080);
+        nv_icmd(priv, 0x00000786, 0x80000100);
+        nv_icmd(priv, 0x0000073c, 0x00010100);
+        nv_icmd(priv, 0x0000073d, 0x02800000);
+        nv_icmd(priv, 0x00000787, 0x000000cf);
+        nv_icmd(priv, 0x0000078c, 0x00000008);
+        nv_icmd(priv, 0x00000792, 0x00000001);
+        nv_icmd(priv, 0x00000794, 0x00000001);
+        nv_icmd(priv, 0x00000795, 0x00000001);
+        nv_icmd(priv, 0x00000796, 0x00000001);
+        nv_icmd(priv, 0x00000797, 0x000000cf);
+        nv_icmd(priv, 0x00000836, 0x00000001);
+        nv_icmd(priv, 0x0000079a, 0x00000002);
+        nv_icmd(priv, 0x00000833, 0x04444480);
+        nv_icmd(priv, 0x000007a1, 0x00000001);
+        nv_icmd(priv, 0x000007a3, 0x00000001);
+        nv_icmd(priv, 0x000007a4, 0x00000001);
+        nv_icmd(priv, 0x000007a5, 0x00000001);
+        nv_icmd(priv, 0x00000831, 0x00000004);
+        nv_icmd(priv, 0x0000080c, 0x00000002);
+        nv_icmd(priv, 0x0000080d, 0x00000100);
+        nv_icmd(priv, 0x0000080e, 0x00000100);
+        nv_icmd(priv, 0x0000080f, 0x00000001);
+        nv_icmd(priv, 0x00000823, 0x00000002);
+        nv_icmd(priv, 0x00000824, 0x00000100);
+        nv_icmd(priv, 0x00000825, 0x00000100);
+        nv_icmd(priv, 0x00000826, 0x00000001);
+        nv_icmd(priv, 0x0000095d, 0x00000001);
+        nv_icmd(priv, 0x0000082b, 0x00000004);
+        nv_icmd(priv, 0x00000942, 0x00010001);
+        nv_icmd(priv, 0x00000943, 0x00000001);
+        nv_icmd(priv, 0x00000944, 0x00000022);
+        nv_icmd(priv, 0x000007c5, 0x00010001);
+        nv_icmd(priv, 0x00000834, 0x00000001);
+        nv_icmd(priv, 0x000007c7, 0x00000001);
+        nv_icmd(priv, 0x0000c1b0, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b1, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b2, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b3, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b4, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b5, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b6, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b7, 0x0000000f);
+        nv_icmd(priv, 0x0000c1b8, 0x0fac6881);
+        nv_icmd(priv, 0x0000c1b9, 0x00fac688);
+        nv_icmd(priv, 0x0001e100, 0x00000001);
+        nv_icmd(priv, 0x00001000, 0x00000002);
+        nv_icmd(priv, 0x000006aa, 0x00000001);
+        nv_icmd(priv, 0x000006ad, 0x00000100);
+        nv_icmd(priv, 0x000006ae, 0x00000100);
+        nv_icmd(priv, 0x000006b1, 0x00000011);
+        nv_icmd(priv, 0x0000078c, 0x00000008);
+        nv_icmd(priv, 0x00000792, 0x00000001);
+        nv_icmd(priv, 0x00000794, 0x00000001);
+        nv_icmd(priv, 0x00000795, 0x00000001);
+        nv_icmd(priv, 0x00000796, 0x00000001);
+        nv_icmd(priv, 0x00000797, 0x000000cf);
+        nv_icmd(priv, 0x0000079a, 0x00000002);
+        nv_icmd(priv, 0x00000833, 0x04444480);
+        nv_icmd(priv, 0x000007a1, 0x00000001);
+        nv_icmd(priv, 0x000007a3, 0x00000001);
+        nv_icmd(priv, 0x000007a4, 0x00000001);
+        nv_icmd(priv, 0x000007a5, 0x00000001);
+        nv_icmd(priv, 0x00000831, 0x00000004);
+        nv_icmd(priv, 0x0001e100, 0x00000001);
+        nv_icmd(priv, 0x00001000, 0x00000014);
+        nv_icmd(priv, 0x00000351, 0x00000100);
+        nv_icmd(priv, 0x00000957, 0x00000003);
+        nv_icmd(priv, 0x0000095d, 0x00000001);
+        nv_icmd(priv, 0x0000082b, 0x00000004);
+        nv_icmd(priv, 0x00000942, 0x00010001);
+        nv_icmd(priv, 0x00000943, 0x00000001);
+        nv_icmd(priv, 0x000007c5, 0x00010001);
+        nv_icmd(priv, 0x00000834, 0x00000001);
+        nv_icmd(priv, 0x000007c7, 0x00000001);
+        nv_icmd(priv, 0x0001e100, 0x00000001);
+        nv_icmd(priv, 0x00001000, 0x00000001);
+        nv_icmd(priv, 0x0000080c, 0x00000002);
+        nv_icmd(priv, 0x0000080d, 0x00000100);
+        nv_icmd(priv, 0x0000080e, 0x00000100);
+        nv_icmd(priv, 0x0000080f, 0x00000001);
+        nv_icmd(priv, 0x00000823, 0x00000002);
+        nv_icmd(priv, 0x00000824, 0x00000100);
+        nv_icmd(priv, 0x00000825, 0x00000100);
+        nv_icmd(priv, 0x00000826, 0x00000001);
+        nv_icmd(priv, 0x0001e100, 0x00000001);
+        nv_wr32(priv, 0x400208, 0x00000000);
+        nv_wr32(priv, 0x404154, 0x00000400);
+
+        nvc0_grctx_generate_9097(priv);
+        if (fermi >= 0x9197)
+                nvc0_grctx_generate_9197(priv);
+        if (fermi >= 0x9297)
+                nvc0_grctx_generate_9297(priv);
+        nvc0_grctx_generate_902d(priv);
+        nvc0_grctx_generate_9039(priv);
+        nvc0_grctx_generate_90c0(priv);
+
+        nv_wr32(priv, 0x000260, r000260);
+
+        return nvc0_grctx_fini(&info);
+}
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/ctxnve0.c b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnve0.c
new file mode 100644
index 000000000000..6d8c63931ee6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnve0.c
@@ -0,0 +1,2788 @@
+/*
+ * 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 "nvc0.h"
+
+static void
+nve0_grctx_generate_icmd(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x400208, 0x80000000);
+        nv_icmd(priv, 0x001000, 0x00000004);
+        nv_icmd(priv, 0x000039, 0x00000000);
+        nv_icmd(priv, 0x00003a, 0x00000000);
+        nv_icmd(priv, 0x00003b, 0x00000000);
+        nv_icmd(priv, 0x0000a9, 0x0000ffff);
+        nv_icmd(priv, 0x000038, 0x0fac6881);
+        nv_icmd(priv, 0x00003d, 0x00000001);
+        nv_icmd(priv, 0x0000e8, 0x00000400);
+        nv_icmd(priv, 0x0000e9, 0x00000400);
+        nv_icmd(priv, 0x0000ea, 0x00000400);
+        nv_icmd(priv, 0x0000eb, 0x00000400);
+        nv_icmd(priv, 0x0000ec, 0x00000400);
+        nv_icmd(priv, 0x0000ed, 0x00000400);
+        nv_icmd(priv, 0x0000ee, 0x00000400);
+        nv_icmd(priv, 0x0000ef, 0x00000400);
+        nv_icmd(priv, 0x000078, 0x00000300);
+        nv_icmd(priv, 0x000079, 0x00000300);
+        nv_icmd(priv, 0x00007a, 0x00000300);
+        nv_icmd(priv, 0x00007b, 0x00000300);
+        nv_icmd(priv, 0x00007c, 0x00000300);
+        nv_icmd(priv, 0x00007d, 0x00000300);
+        nv_icmd(priv, 0x00007e, 0x00000300);
+        nv_icmd(priv, 0x00007f, 0x00000300);
+        nv_icmd(priv, 0x000050, 0x00000011);
+        nv_icmd(priv, 0x000058, 0x00000008);
+        nv_icmd(priv, 0x000059, 0x00000008);
+        nv_icmd(priv, 0x00005a, 0x00000008);
+        nv_icmd(priv, 0x00005b, 0x00000008);
+        nv_icmd(priv, 0x00005c, 0x00000008);
+        nv_icmd(priv, 0x00005d, 0x00000008);
+        nv_icmd(priv, 0x00005e, 0x00000008);
+        nv_icmd(priv, 0x00005f, 0x00000008);
+        nv_icmd(priv, 0x000208, 0x00000001);
+        nv_icmd(priv, 0x000209, 0x00000001);
+        nv_icmd(priv, 0x00020a, 0x00000001);
+        nv_icmd(priv, 0x00020b, 0x00000001);
+        nv_icmd(priv, 0x00020c, 0x00000001);
+        nv_icmd(priv, 0x00020d, 0x00000001);
+        nv_icmd(priv, 0x00020e, 0x00000001);
+        nv_icmd(priv, 0x00020f, 0x00000001);
+        nv_icmd(priv, 0x000081, 0x00000001);
+        nv_icmd(priv, 0x000085, 0x00000004);
+        nv_icmd(priv, 0x000088, 0x00000400);
+        nv_icmd(priv, 0x000090, 0x00000300);
+        nv_icmd(priv, 0x000098, 0x00001001);
+        nv_icmd(priv, 0x0000e3, 0x00000001);
+        nv_icmd(priv, 0x0000da, 0x00000001);
+        nv_icmd(priv, 0x0000f8, 0x00000003);
+        nv_icmd(priv, 0x0000fa, 0x00000001);
+        nv_icmd(priv, 0x00009f, 0x0000ffff);
+        nv_icmd(priv, 0x0000a0, 0x0000ffff);
+        nv_icmd(priv, 0x0000a1, 0x0000ffff);
+        nv_icmd(priv, 0x0000a2, 0x0000ffff);
+        nv_icmd(priv, 0x0000b1, 0x00000001);
+        nv_icmd(priv, 0x0000ad, 0x0000013e);
+        nv_icmd(priv, 0x0000e1, 0x00000010);
+        nv_icmd(priv, 0x000290, 0x00000000);
+        nv_icmd(priv, 0x000291, 0x00000000);
+        nv_icmd(priv, 0x000292, 0x00000000);
+        nv_icmd(priv, 0x000293, 0x00000000);
+        nv_icmd(priv, 0x000294, 0x00000000);
+        nv_icmd(priv, 0x000295, 0x00000000);
+        nv_icmd(priv, 0x000296, 0x00000000);
+        nv_icmd(priv, 0x000297, 0x00000000);
+        nv_icmd(priv, 0x000298, 0x00000000);
+        nv_icmd(priv, 0x000299, 0x00000000);
+        nv_icmd(priv, 0x00029a, 0x00000000);
+        nv_icmd(priv, 0x00029b, 0x00000000);
+        nv_icmd(priv, 0x00029c, 0x00000000);
+        nv_icmd(priv, 0x00029d, 0x00000000);
+        nv_icmd(priv, 0x00029e, 0x00000000);
+        nv_icmd(priv, 0x00029f, 0x00000000);
+        nv_icmd(priv, 0x0003b0, 0x00000000);
+        nv_icmd(priv, 0x0003b1, 0x00000000);
+        nv_icmd(priv, 0x0003b2, 0x00000000);
+        nv_icmd(priv, 0x0003b3, 0x00000000);
+        nv_icmd(priv, 0x0003b4, 0x00000000);
+        nv_icmd(priv, 0x0003b5, 0x00000000);
+        nv_icmd(priv, 0x0003b6, 0x00000000);
+        nv_icmd(priv, 0x0003b7, 0x00000000);
+        nv_icmd(priv, 0x0003b8, 0x00000000);
+        nv_icmd(priv, 0x0003b9, 0x00000000);
+        nv_icmd(priv, 0x0003ba, 0x00000000);
+        nv_icmd(priv, 0x0003bb, 0x00000000);
+        nv_icmd(priv, 0x0003bc, 0x00000000);
+        nv_icmd(priv, 0x0003bd, 0x00000000);
+        nv_icmd(priv, 0x0003be, 0x00000000);
+        nv_icmd(priv, 0x0003bf, 0x00000000);
+        nv_icmd(priv, 0x0002a0, 0x00000000);
+        nv_icmd(priv, 0x0002a1, 0x00000000);
+        nv_icmd(priv, 0x0002a2, 0x00000000);
+        nv_icmd(priv, 0x0002a3, 0x00000000);
+        nv_icmd(priv, 0x0002a4, 0x00000000);
+        nv_icmd(priv, 0x0002a5, 0x00000000);
+        nv_icmd(priv, 0x0002a6, 0x00000000);
+        nv_icmd(priv, 0x0002a7, 0x00000000);
+        nv_icmd(priv, 0x0002a8, 0x00000000);
+        nv_icmd(priv, 0x0002a9, 0x00000000);
+        nv_icmd(priv, 0x0002aa, 0x00000000);
+        nv_icmd(priv, 0x0002ab, 0x00000000);
+        nv_icmd(priv, 0x0002ac, 0x00000000);
+        nv_icmd(priv, 0x0002ad, 0x00000000);
+        nv_icmd(priv, 0x0002ae, 0x00000000);
+        nv_icmd(priv, 0x0002af, 0x00000000);
+        nv_icmd(priv, 0x000420, 0x00000000);
+        nv_icmd(priv, 0x000421, 0x00000000);
+        nv_icmd(priv, 0x000422, 0x00000000);
+        nv_icmd(priv, 0x000423, 0x00000000);
+        nv_icmd(priv, 0x000424, 0x00000000);
+        nv_icmd(priv, 0x000425, 0x00000000);
+        nv_icmd(priv, 0x000426, 0x00000000);
+        nv_icmd(priv, 0x000427, 0x00000000);
+        nv_icmd(priv, 0x000428, 0x00000000);
+        nv_icmd(priv, 0x000429, 0x00000000);
+        nv_icmd(priv, 0x00042a, 0x00000000);
+        nv_icmd(priv, 0x00042b, 0x00000000);
+        nv_icmd(priv, 0x00042c, 0x00000000);
+        nv_icmd(priv, 0x00042d, 0x00000000);
+        nv_icmd(priv, 0x00042e, 0x00000000);
+        nv_icmd(priv, 0x00042f, 0x00000000);
+        nv_icmd(priv, 0x0002b0, 0x00000000);
+        nv_icmd(priv, 0x0002b1, 0x00000000);
+        nv_icmd(priv, 0x0002b2, 0x00000000);
+        nv_icmd(priv, 0x0002b3, 0x00000000);
+        nv_icmd(priv, 0x0002b4, 0x00000000);
+        nv_icmd(priv, 0x0002b5, 0x00000000);
+        nv_icmd(priv, 0x0002b6, 0x00000000);
+        nv_icmd(priv, 0x0002b7, 0x00000000);
+        nv_icmd(priv, 0x0002b8, 0x00000000);
+        nv_icmd(priv, 0x0002b9, 0x00000000);
+        nv_icmd(priv, 0x0002ba, 0x00000000);
+        nv_icmd(priv, 0x0002bb, 0x00000000);
+        nv_icmd(priv, 0x0002bc, 0x00000000);
+        nv_icmd(priv, 0x0002bd, 0x00000000);
+        nv_icmd(priv, 0x0002be, 0x00000000);
+        nv_icmd(priv, 0x0002bf, 0x00000000);
+        nv_icmd(priv, 0x000430, 0x00000000);
+        nv_icmd(priv, 0x000431, 0x00000000);
+        nv_icmd(priv, 0x000432, 0x00000000);
+        nv_icmd(priv, 0x000433, 0x00000000);
+        nv_icmd(priv, 0x000434, 0x00000000);
+        nv_icmd(priv, 0x000435, 0x00000000);
+        nv_icmd(priv, 0x000436, 0x00000000);
+        nv_icmd(priv, 0x000437, 0x00000000);
+        nv_icmd(priv, 0x000438, 0x00000000);
+        nv_icmd(priv, 0x000439, 0x00000000);
+        nv_icmd(priv, 0x00043a, 0x00000000);
+        nv_icmd(priv, 0x00043b, 0x00000000);
+        nv_icmd(priv, 0x00043c, 0x00000000);
+        nv_icmd(priv, 0x00043d, 0x00000000);
+        nv_icmd(priv, 0x00043e, 0x00000000);
+        nv_icmd(priv, 0x00043f, 0x00000000);
+        nv_icmd(priv, 0x0002c0, 0x00000000);
+        nv_icmd(priv, 0x0002c1, 0x00000000);
+        nv_icmd(priv, 0x0002c2, 0x00000000);
+        nv_icmd(priv, 0x0002c3, 0x00000000);
+        nv_icmd(priv, 0x0002c4, 0x00000000);
+        nv_icmd(priv, 0x0002c5, 0x00000000);
+        nv_icmd(priv, 0x0002c6, 0x00000000);
+        nv_icmd(priv, 0x0002c7, 0x00000000);
+        nv_icmd(priv, 0x0002c8, 0x00000000);
+        nv_icmd(priv, 0x0002c9, 0x00000000);
+        nv_icmd(priv, 0x0002ca, 0x00000000);
+        nv_icmd(priv, 0x0002cb, 0x00000000);
+        nv_icmd(priv, 0x0002cc, 0x00000000);
+        nv_icmd(priv, 0x0002cd, 0x00000000);
+        nv_icmd(priv, 0x0002ce, 0x00000000);
+        nv_icmd(priv, 0x0002cf, 0x00000000);
+        nv_icmd(priv, 0x0004d0, 0x00000000);
+        nv_icmd(priv, 0x0004d1, 0x00000000);
+        nv_icmd(priv, 0x0004d2, 0x00000000);
+        nv_icmd(priv, 0x0004d3, 0x00000000);
+        nv_icmd(priv, 0x0004d4, 0x00000000);
+        nv_icmd(priv, 0x0004d5, 0x00000000);
+        nv_icmd(priv, 0x0004d6, 0x00000000);
+        nv_icmd(priv, 0x0004d7, 0x00000000);
+        nv_icmd(priv, 0x0004d8, 0x00000000);
+        nv_icmd(priv, 0x0004d9, 0x00000000);
+        nv_icmd(priv, 0x0004da, 0x00000000);
+        nv_icmd(priv, 0x0004db, 0x00000000);
+        nv_icmd(priv, 0x0004dc, 0x00000000);
+        nv_icmd(priv, 0x0004dd, 0x00000000);
+        nv_icmd(priv, 0x0004de, 0x00000000);
+        nv_icmd(priv, 0x0004df, 0x00000000);
+        nv_icmd(priv, 0x000720, 0x00000000);
+        nv_icmd(priv, 0x000721, 0x00000000);
+        nv_icmd(priv, 0x000722, 0x00000000);
+        nv_icmd(priv, 0x000723, 0x00000000);
+        nv_icmd(priv, 0x000724, 0x00000000);
+        nv_icmd(priv, 0x000725, 0x00000000);
+        nv_icmd(priv, 0x000726, 0x00000000);
+        nv_icmd(priv, 0x000727, 0x00000000);
+        nv_icmd(priv, 0x000728, 0x00000000);
+        nv_icmd(priv, 0x000729, 0x00000000);
+        nv_icmd(priv, 0x00072a, 0x00000000);
+        nv_icmd(priv, 0x00072b, 0x00000000);
+        nv_icmd(priv, 0x00072c, 0x00000000);
+        nv_icmd(priv, 0x00072d, 0x00000000);
+        nv_icmd(priv, 0x00072e, 0x00000000);
+        nv_icmd(priv, 0x00072f, 0x00000000);
+        nv_icmd(priv, 0x0008c0, 0x00000000);
+        nv_icmd(priv, 0x0008c1, 0x00000000);
+        nv_icmd(priv, 0x0008c2, 0x00000000);
+        nv_icmd(priv, 0x0008c3, 0x00000000);
+        nv_icmd(priv, 0x0008c4, 0x00000000);
+        nv_icmd(priv, 0x0008c5, 0x00000000);
+        nv_icmd(priv, 0x0008c6, 0x00000000);
+        nv_icmd(priv, 0x0008c7, 0x00000000);
+        nv_icmd(priv, 0x0008c8, 0x00000000);
+        nv_icmd(priv, 0x0008c9, 0x00000000);
+        nv_icmd(priv, 0x0008ca, 0x00000000);
+        nv_icmd(priv, 0x0008cb, 0x00000000);
+        nv_icmd(priv, 0x0008cc, 0x00000000);
+        nv_icmd(priv, 0x0008cd, 0x00000000);
+        nv_icmd(priv, 0x0008ce, 0x00000000);
+        nv_icmd(priv, 0x0008cf, 0x00000000);
+        nv_icmd(priv, 0x000890, 0x00000000);
+        nv_icmd(priv, 0x000891, 0x00000000);
+        nv_icmd(priv, 0x000892, 0x00000000);
+        nv_icmd(priv, 0x000893, 0x00000000);
+        nv_icmd(priv, 0x000894, 0x00000000);
+        nv_icmd(priv, 0x000895, 0x00000000);
+        nv_icmd(priv, 0x000896, 0x00000000);
+        nv_icmd(priv, 0x000897, 0x00000000);
+        nv_icmd(priv, 0x000898, 0x00000000);
+        nv_icmd(priv, 0x000899, 0x00000000);
+        nv_icmd(priv, 0x00089a, 0x00000000);
+        nv_icmd(priv, 0x00089b, 0x00000000);
+        nv_icmd(priv, 0x00089c, 0x00000000);
+        nv_icmd(priv, 0x00089d, 0x00000000);
+        nv_icmd(priv, 0x00089e, 0x00000000);
+        nv_icmd(priv, 0x00089f, 0x00000000);
+        nv_icmd(priv, 0x0008e0, 0x00000000);
+        nv_icmd(priv, 0x0008e1, 0x00000000);
+        nv_icmd(priv, 0x0008e2, 0x00000000);
+        nv_icmd(priv, 0x0008e3, 0x00000000);
+        nv_icmd(priv, 0x0008e4, 0x00000000);
+        nv_icmd(priv, 0x0008e5, 0x00000000);
+        nv_icmd(priv, 0x0008e6, 0x00000000);
+        nv_icmd(priv, 0x0008e7, 0x00000000);
+        nv_icmd(priv, 0x0008e8, 0x00000000);
+        nv_icmd(priv, 0x0008e9, 0x00000000);
+        nv_icmd(priv, 0x0008ea, 0x00000000);
+        nv_icmd(priv, 0x0008eb, 0x00000000);
+        nv_icmd(priv, 0x0008ec, 0x00000000);
+        nv_icmd(priv, 0x0008ed, 0x00000000);
+        nv_icmd(priv, 0x0008ee, 0x00000000);
+        nv_icmd(priv, 0x0008ef, 0x00000000);
+        nv_icmd(priv, 0x0008a0, 0x00000000);
+        nv_icmd(priv, 0x0008a1, 0x00000000);
+        nv_icmd(priv, 0x0008a2, 0x00000000);
+        nv_icmd(priv, 0x0008a3, 0x00000000);
+        nv_icmd(priv, 0x0008a4, 0x00000000);
+        nv_icmd(priv, 0x0008a5, 0x00000000);
+        nv_icmd(priv, 0x0008a6, 0x00000000);
+        nv_icmd(priv, 0x0008a7, 0x00000000);
+        nv_icmd(priv, 0x0008a8, 0x00000000);
+        nv_icmd(priv, 0x0008a9, 0x00000000);
+        nv_icmd(priv, 0x0008aa, 0x00000000);
+        nv_icmd(priv, 0x0008ab, 0x00000000);
+        nv_icmd(priv, 0x0008ac, 0x00000000);
+        nv_icmd(priv, 0x0008ad, 0x00000000);
+        nv_icmd(priv, 0x0008ae, 0x00000000);
+        nv_icmd(priv, 0x0008af, 0x00000000);
+        nv_icmd(priv, 0x0008f0, 0x00000000);
+        nv_icmd(priv, 0x0008f1, 0x00000000);
+        nv_icmd(priv, 0x0008f2, 0x00000000);
+        nv_icmd(priv, 0x0008f3, 0x00000000);
+        nv_icmd(priv, 0x0008f4, 0x00000000);
+        nv_icmd(priv, 0x0008f5, 0x00000000);
+        nv_icmd(priv, 0x0008f6, 0x00000000);
+        nv_icmd(priv, 0x0008f7, 0x00000000);
+        nv_icmd(priv, 0x0008f8, 0x00000000);
+        nv_icmd(priv, 0x0008f9, 0x00000000);
+        nv_icmd(priv, 0x0008fa, 0x00000000);
+        nv_icmd(priv, 0x0008fb, 0x00000000);
+        nv_icmd(priv, 0x0008fc, 0x00000000);
+        nv_icmd(priv, 0x0008fd, 0x00000000);
+        nv_icmd(priv, 0x0008fe, 0x00000000);
+        nv_icmd(priv, 0x0008ff, 0x00000000);
+        nv_icmd(priv, 0x00094c, 0x000000ff);
+        nv_icmd(priv, 0x00094d, 0xffffffff);
+        nv_icmd(priv, 0x00094e, 0x00000002);
+        nv_icmd(priv, 0x0002ec, 0x00000001);
+        nv_icmd(priv, 0x000303, 0x00000001);
+        nv_icmd(priv, 0x0002e6, 0x00000001);
+        nv_icmd(priv, 0x000466, 0x00000052);
+        nv_icmd(priv, 0x000301, 0x3f800000);
+        nv_icmd(priv, 0x000304, 0x30201000);
+        nv_icmd(priv, 0x000305, 0x70605040);
+        nv_icmd(priv, 0x000306, 0xb8a89888);
+        nv_icmd(priv, 0x000307, 0xf8e8d8c8);
+        nv_icmd(priv, 0x00030a, 0x00ffff00);
+        nv_icmd(priv, 0x00030b, 0x0000001a);
+        nv_icmd(priv, 0x00030c, 0x00000001);
+        nv_icmd(priv, 0x000318, 0x00000001);
+        nv_icmd(priv, 0x000340, 0x00000000);
+        nv_icmd(priv, 0x000375, 0x00000001);
+        nv_icmd(priv, 0x00037d, 0x00000006);
+        nv_icmd(priv, 0x0003a0, 0x00000002);
+        nv_icmd(priv, 0x0003aa, 0x00000001);
+        nv_icmd(priv, 0x0003a9, 0x00000001);
+        nv_icmd(priv, 0x000380, 0x00000001);
+        nv_icmd(priv, 0x000383, 0x00000011);
+        nv_icmd(priv, 0x000360, 0x00000040);
+        nv_icmd(priv, 0x000366, 0x00000000);
+        nv_icmd(priv, 0x000367, 0x00000000);
+        nv_icmd(priv, 0x000368, 0x00000fff);
+        nv_icmd(priv, 0x000370, 0x00000000);
+        nv_icmd(priv, 0x000371, 0x00000000);
+        nv_icmd(priv, 0x000372, 0x000fffff);
+        nv_icmd(priv, 0x00037a, 0x00000012);
+        nv_icmd(priv, 0x000619, 0x00000003);
+        nv_icmd(priv, 0x000811, 0x00000003);
+        nv_icmd(priv, 0x000812, 0x00000004);
+        nv_icmd(priv, 0x000813, 0x00000006);
+        nv_icmd(priv, 0x000814, 0x00000008);
+        nv_icmd(priv, 0x000815, 0x0000000b);
+        nv_icmd(priv, 0x000800, 0x00000001);
+        nv_icmd(priv, 0x000801, 0x00000001);
+        nv_icmd(priv, 0x000802, 0x00000001);
+        nv_icmd(priv, 0x000803, 0x00000001);
+        nv_icmd(priv, 0x000804, 0x00000001);
+        nv_icmd(priv, 0x000805, 0x00000001);
+        nv_icmd(priv, 0x000632, 0x00000001);
+        nv_icmd(priv, 0x000633, 0x00000002);
+        nv_icmd(priv, 0x000634, 0x00000003);
+        nv_icmd(priv, 0x000635, 0x00000004);
+        nv_icmd(priv, 0x000654, 0x3f800000);
+        nv_icmd(priv, 0x000657, 0x3f800000);
+        nv_icmd(priv, 0x000655, 0x3f800000);
+        nv_icmd(priv, 0x000656, 0x3f800000);
+        nv_icmd(priv, 0x0006cd, 0x3f800000);
+        nv_icmd(priv, 0x0007f5, 0x3f800000);
+        nv_icmd(priv, 0x0007dc, 0x39291909);
+        nv_icmd(priv, 0x0007dd, 0x79695949);
+        nv_icmd(priv, 0x0007de, 0xb9a99989);
+        nv_icmd(priv, 0x0007df, 0xf9e9d9c9);
+        nv_icmd(priv, 0x0007e8, 0x00003210);
+        nv_icmd(priv, 0x0007e9, 0x00007654);
+        nv_icmd(priv, 0x0007ea, 0x00000098);
+        nv_icmd(priv, 0x0007ec, 0x39291909);
+        nv_icmd(priv, 0x0007ed, 0x79695949);
+        nv_icmd(priv, 0x0007ee, 0xb9a99989);
+        nv_icmd(priv, 0x0007ef, 0xf9e9d9c9);
+        nv_icmd(priv, 0x0007f0, 0x00003210);
+        nv_icmd(priv, 0x0007f1, 0x00007654);
+        nv_icmd(priv, 0x0007f2, 0x00000098);
+        nv_icmd(priv, 0x0005a5, 0x00000001);
+        nv_icmd(priv, 0x000980, 0x00000000);
+        nv_icmd(priv, 0x000981, 0x00000000);
+        nv_icmd(priv, 0x000982, 0x00000000);
+        nv_icmd(priv, 0x000983, 0x00000000);
+        nv_icmd(priv, 0x000984, 0x00000000);
+        nv_icmd(priv, 0x000985, 0x00000000);
+        nv_icmd(priv, 0x000986, 0x00000000);
+        nv_icmd(priv, 0x000987, 0x00000000);
+        nv_icmd(priv, 0x000988, 0x00000000);
+        nv_icmd(priv, 0x000989, 0x00000000);
+        nv_icmd(priv, 0x00098a, 0x00000000);
+        nv_icmd(priv, 0x00098b, 0x00000000);
+        nv_icmd(priv, 0x00098c, 0x00000000);
+        nv_icmd(priv, 0x00098d, 0x00000000);
+        nv_icmd(priv, 0x00098e, 0x00000000);
+        nv_icmd(priv, 0x00098f, 0x00000000);
+        nv_icmd(priv, 0x000990, 0x00000000);
+        nv_icmd(priv, 0x000991, 0x00000000);
+        nv_icmd(priv, 0x000992, 0x00000000);
+        nv_icmd(priv, 0x000993, 0x00000000);
+        nv_icmd(priv, 0x000994, 0x00000000);
+        nv_icmd(priv, 0x000995, 0x00000000);
+        nv_icmd(priv, 0x000996, 0x00000000);
+        nv_icmd(priv, 0x000997, 0x00000000);
+        nv_icmd(priv, 0x000998, 0x00000000);
+        nv_icmd(priv, 0x000999, 0x00000000);
+        nv_icmd(priv, 0x00099a, 0x00000000);
+        nv_icmd(priv, 0x00099b, 0x00000000);
+        nv_icmd(priv, 0x00099c, 0x00000000);
+        nv_icmd(priv, 0x00099d, 0x00000000);
+        nv_icmd(priv, 0x00099e, 0x00000000);
+        nv_icmd(priv, 0x00099f, 0x00000000);
+        nv_icmd(priv, 0x0009a0, 0x00000000);
+        nv_icmd(priv, 0x0009a1, 0x00000000);
+        nv_icmd(priv, 0x0009a2, 0x00000000);
+        nv_icmd(priv, 0x0009a3, 0x00000000);
+        nv_icmd(priv, 0x0009a4, 0x00000000);
+        nv_icmd(priv, 0x0009a5, 0x00000000);
+        nv_icmd(priv, 0x0009a6, 0x00000000);
+        nv_icmd(priv, 0x0009a7, 0x00000000);
+        nv_icmd(priv, 0x0009a8, 0x00000000);
+        nv_icmd(priv, 0x0009a9, 0x00000000);
+        nv_icmd(priv, 0x0009aa, 0x00000000);
+        nv_icmd(priv, 0x0009ab, 0x00000000);
+        nv_icmd(priv, 0x0009ac, 0x00000000);
+        nv_icmd(priv, 0x0009ad, 0x00000000);
+        nv_icmd(priv, 0x0009ae, 0x00000000);
+        nv_icmd(priv, 0x0009af, 0x00000000);
+        nv_icmd(priv, 0x0009b0, 0x00000000);
+        nv_icmd(priv, 0x0009b1, 0x00000000);
+        nv_icmd(priv, 0x0009b2, 0x00000000);
+        nv_icmd(priv, 0x0009b3, 0x00000000);
+        nv_icmd(priv, 0x0009b4, 0x00000000);
+        nv_icmd(priv, 0x0009b5, 0x00000000);
+        nv_icmd(priv, 0x0009b6, 0x00000000);
+        nv_icmd(priv, 0x0009b7, 0x00000000);
+        nv_icmd(priv, 0x0009b8, 0x00000000);
+        nv_icmd(priv, 0x0009b9, 0x00000000);
+        nv_icmd(priv, 0x0009ba, 0x00000000);
+        nv_icmd(priv, 0x0009bb, 0x00000000);
+        nv_icmd(priv, 0x0009bc, 0x00000000);
+        nv_icmd(priv, 0x0009bd, 0x00000000);
+        nv_icmd(priv, 0x0009be, 0x00000000);
+        nv_icmd(priv, 0x0009bf, 0x00000000);
+        nv_icmd(priv, 0x0009c0, 0x00000000);
+        nv_icmd(priv, 0x0009c1, 0x00000000);
+        nv_icmd(priv, 0x0009c2, 0x00000000);
+        nv_icmd(priv, 0x0009c3, 0x00000000);
+        nv_icmd(priv, 0x0009c4, 0x00000000);
+        nv_icmd(priv, 0x0009c5, 0x00000000);
+        nv_icmd(priv, 0x0009c6, 0x00000000);
+        nv_icmd(priv, 0x0009c7, 0x00000000);
+        nv_icmd(priv, 0x0009c8, 0x00000000);
+        nv_icmd(priv, 0x0009c9, 0x00000000);
+        nv_icmd(priv, 0x0009ca, 0x00000000);
+        nv_icmd(priv, 0x0009cb, 0x00000000);
+        nv_icmd(priv, 0x0009cc, 0x00000000);
+        nv_icmd(priv, 0x0009cd, 0x00000000);
+        nv_icmd(priv, 0x0009ce, 0x00000000);
+        nv_icmd(priv, 0x0009cf, 0x00000000);
+        nv_icmd(priv, 0x0009d0, 0x00000000);
+        nv_icmd(priv, 0x0009d1, 0x00000000);
+        nv_icmd(priv, 0x0009d2, 0x00000000);
+        nv_icmd(priv, 0x0009d3, 0x00000000);
+        nv_icmd(priv, 0x0009d4, 0x00000000);
+        nv_icmd(priv, 0x0009d5, 0x00000000);
+        nv_icmd(priv, 0x0009d6, 0x00000000);
+        nv_icmd(priv, 0x0009d7, 0x00000000);
+        nv_icmd(priv, 0x0009d8, 0x00000000);
+        nv_icmd(priv, 0x0009d9, 0x00000000);
+        nv_icmd(priv, 0x0009da, 0x00000000);
+        nv_icmd(priv, 0x0009db, 0x00000000);
+        nv_icmd(priv, 0x0009dc, 0x00000000);
+        nv_icmd(priv, 0x0009dd, 0x00000000);
+        nv_icmd(priv, 0x0009de, 0x00000000);
+        nv_icmd(priv, 0x0009df, 0x00000000);
+        nv_icmd(priv, 0x0009e0, 0x00000000);
+        nv_icmd(priv, 0x0009e1, 0x00000000);
+        nv_icmd(priv, 0x0009e2, 0x00000000);
+        nv_icmd(priv, 0x0009e3, 0x00000000);
+        nv_icmd(priv, 0x0009e4, 0x00000000);
+        nv_icmd(priv, 0x0009e5, 0x00000000);
+        nv_icmd(priv, 0x0009e6, 0x00000000);
+        nv_icmd(priv, 0x0009e7, 0x00000000);
+        nv_icmd(priv, 0x0009e8, 0x00000000);
+        nv_icmd(priv, 0x0009e9, 0x00000000);
+        nv_icmd(priv, 0x0009ea, 0x00000000);
+        nv_icmd(priv, 0x0009eb, 0x00000000);
+        nv_icmd(priv, 0x0009ec, 0x00000000);
+        nv_icmd(priv, 0x0009ed, 0x00000000);
+        nv_icmd(priv, 0x0009ee, 0x00000000);
+        nv_icmd(priv, 0x0009ef, 0x00000000);
+        nv_icmd(priv, 0x0009f0, 0x00000000);
+        nv_icmd(priv, 0x0009f1, 0x00000000);
+        nv_icmd(priv, 0x0009f2, 0x00000000);
+        nv_icmd(priv, 0x0009f3, 0x00000000);
+        nv_icmd(priv, 0x0009f4, 0x00000000);
+        nv_icmd(priv, 0x0009f5, 0x00000000);
+        nv_icmd(priv, 0x0009f6, 0x00000000);
+        nv_icmd(priv, 0x0009f7, 0x00000000);
+        nv_icmd(priv, 0x0009f8, 0x00000000);
+        nv_icmd(priv, 0x0009f9, 0x00000000);
+        nv_icmd(priv, 0x0009fa, 0x00000000);
+        nv_icmd(priv, 0x0009fb, 0x00000000);
+        nv_icmd(priv, 0x0009fc, 0x00000000);
+        nv_icmd(priv, 0x0009fd, 0x00000000);
+        nv_icmd(priv, 0x0009fe, 0x00000000);
+        nv_icmd(priv, 0x0009ff, 0x00000000);
+        nv_icmd(priv, 0x000468, 0x00000004);
+        nv_icmd(priv, 0x00046c, 0x00000001);
+        nv_icmd(priv, 0x000470, 0x00000000);
+        nv_icmd(priv, 0x000471, 0x00000000);
+        nv_icmd(priv, 0x000472, 0x00000000);
+        nv_icmd(priv, 0x000473, 0x00000000);
+        nv_icmd(priv, 0x000474, 0x00000000);
+        nv_icmd(priv, 0x000475, 0x00000000);
+        nv_icmd(priv, 0x000476, 0x00000000);
+        nv_icmd(priv, 0x000477, 0x00000000);
+        nv_icmd(priv, 0x000478, 0x00000000);
+        nv_icmd(priv, 0x000479, 0x00000000);
+        nv_icmd(priv, 0x00047a, 0x00000000);
+        nv_icmd(priv, 0x00047b, 0x00000000);
+        nv_icmd(priv, 0x00047c, 0x00000000);
+        nv_icmd(priv, 0x00047d, 0x00000000);
+        nv_icmd(priv, 0x00047e, 0x00000000);
+        nv_icmd(priv, 0x00047f, 0x00000000);
+        nv_icmd(priv, 0x000480, 0x00000000);
+        nv_icmd(priv, 0x000481, 0x00000000);
+        nv_icmd(priv, 0x000482, 0x00000000);
+        nv_icmd(priv, 0x000483, 0x00000000);
+        nv_icmd(priv, 0x000484, 0x00000000);
+        nv_icmd(priv, 0x000485, 0x00000000);
+        nv_icmd(priv, 0x000486, 0x00000000);
+        nv_icmd(priv, 0x000487, 0x00000000);
+        nv_icmd(priv, 0x000488, 0x00000000);
+        nv_icmd(priv, 0x000489, 0x00000000);
+        nv_icmd(priv, 0x00048a, 0x00000000);
+        nv_icmd(priv, 0x00048b, 0x00000000);
+        nv_icmd(priv, 0x00048c, 0x00000000);
+        nv_icmd(priv, 0x00048d, 0x00000000);
+        nv_icmd(priv, 0x00048e, 0x00000000);
+        nv_icmd(priv, 0x00048f, 0x00000000);
+        nv_icmd(priv, 0x000490, 0x00000000);
+        nv_icmd(priv, 0x000491, 0x00000000);
+        nv_icmd(priv, 0x000492, 0x00000000);
+        nv_icmd(priv, 0x000493, 0x00000000);
+        nv_icmd(priv, 0x000494, 0x00000000);
+        nv_icmd(priv, 0x000495, 0x00000000);
+        nv_icmd(priv, 0x000496, 0x00000000);
+        nv_icmd(priv, 0x000497, 0x00000000);
+        nv_icmd(priv, 0x000498, 0x00000000);
+        nv_icmd(priv, 0x000499, 0x00000000);
+        nv_icmd(priv, 0x00049a, 0x00000000);
+        nv_icmd(priv, 0x00049b, 0x00000000);
+        nv_icmd(priv, 0x00049c, 0x00000000);
+        nv_icmd(priv, 0x00049d, 0x00000000);
+        nv_icmd(priv, 0x00049e, 0x00000000);
+        nv_icmd(priv, 0x00049f, 0x00000000);
+        nv_icmd(priv, 0x0004a0, 0x00000000);
+        nv_icmd(priv, 0x0004a1, 0x00000000);
+        nv_icmd(priv, 0x0004a2, 0x00000000);
+        nv_icmd(priv, 0x0004a3, 0x00000000);
+        nv_icmd(priv, 0x0004a4, 0x00000000);
+        nv_icmd(priv, 0x0004a5, 0x00000000);
+        nv_icmd(priv, 0x0004a6, 0x00000000);
+        nv_icmd(priv, 0x0004a7, 0x00000000);
+        nv_icmd(priv, 0x0004a8, 0x00000000);
+        nv_icmd(priv, 0x0004a9, 0x00000000);
+        nv_icmd(priv, 0x0004aa, 0x00000000);
+        nv_icmd(priv, 0x0004ab, 0x00000000);
+        nv_icmd(priv, 0x0004ac, 0x00000000);
+        nv_icmd(priv, 0x0004ad, 0x00000000);
+        nv_icmd(priv, 0x0004ae, 0x00000000);
+        nv_icmd(priv, 0x0004af, 0x00000000);
+        nv_icmd(priv, 0x0004b0, 0x00000000);
+        nv_icmd(priv, 0x0004b1, 0x00000000);
+        nv_icmd(priv, 0x0004b2, 0x00000000);
+        nv_icmd(priv, 0x0004b3, 0x00000000);
+        nv_icmd(priv, 0x0004b4, 0x00000000);
+        nv_icmd(priv, 0x0004b5, 0x00000000);
+        nv_icmd(priv, 0x0004b6, 0x00000000);
+        nv_icmd(priv, 0x0004b7, 0x00000000);
+        nv_icmd(priv, 0x0004b8, 0x00000000);
+        nv_icmd(priv, 0x0004b9, 0x00000000);
+        nv_icmd(priv, 0x0004ba, 0x00000000);
+        nv_icmd(priv, 0x0004bb, 0x00000000);
+        nv_icmd(priv, 0x0004bc, 0x00000000);
+        nv_icmd(priv, 0x0004bd, 0x00000000);
+        nv_icmd(priv, 0x0004be, 0x00000000);
+        nv_icmd(priv, 0x0004bf, 0x00000000);
+        nv_icmd(priv, 0x0004c0, 0x00000000);
+        nv_icmd(priv, 0x0004c1, 0x00000000);
+        nv_icmd(priv, 0x0004c2, 0x00000000);
+        nv_icmd(priv, 0x0004c3, 0x00000000);
+        nv_icmd(priv, 0x0004c4, 0x00000000);
+        nv_icmd(priv, 0x0004c5, 0x00000000);
+        nv_icmd(priv, 0x0004c6, 0x00000000);
+        nv_icmd(priv, 0x0004c7, 0x00000000);
+        nv_icmd(priv, 0x0004c8, 0x00000000);
+        nv_icmd(priv, 0x0004c9, 0x00000000);
+        nv_icmd(priv, 0x0004ca, 0x00000000);
+        nv_icmd(priv, 0x0004cb, 0x00000000);
+        nv_icmd(priv, 0x0004cc, 0x00000000);
+        nv_icmd(priv, 0x0004cd, 0x00000000);
+        nv_icmd(priv, 0x0004ce, 0x00000000);
+        nv_icmd(priv, 0x0004cf, 0x00000000);
+        nv_icmd(priv, 0x000510, 0x3f800000);
+        nv_icmd(priv, 0x000511, 0x3f800000);
+        nv_icmd(priv, 0x000512, 0x3f800000);
+        nv_icmd(priv, 0x000513, 0x3f800000);
+        nv_icmd(priv, 0x000514, 0x3f800000);
+        nv_icmd(priv, 0x000515, 0x3f800000);
+        nv_icmd(priv, 0x000516, 0x3f800000);
+        nv_icmd(priv, 0x000517, 0x3f800000);
+        nv_icmd(priv, 0x000518, 0x3f800000);
+        nv_icmd(priv, 0x000519, 0x3f800000);
+        nv_icmd(priv, 0x00051a, 0x3f800000);
+        nv_icmd(priv, 0x00051b, 0x3f800000);
+        nv_icmd(priv, 0x00051c, 0x3f800000);
+        nv_icmd(priv, 0x00051d, 0x3f800000);
+        nv_icmd(priv, 0x00051e, 0x3f800000);
+        nv_icmd(priv, 0x00051f, 0x3f800000);
+        nv_icmd(priv, 0x000520, 0x000002b6);
+        nv_icmd(priv, 0x000529, 0x00000001);
+        nv_icmd(priv, 0x000530, 0xffff0000);
+        nv_icmd(priv, 0x000531, 0xffff0000);
+        nv_icmd(priv, 0x000532, 0xffff0000);
+        nv_icmd(priv, 0x000533, 0xffff0000);
+        nv_icmd(priv, 0x000534, 0xffff0000);
+        nv_icmd(priv, 0x000535, 0xffff0000);
+        nv_icmd(priv, 0x000536, 0xffff0000);
+        nv_icmd(priv, 0x000537, 0xffff0000);
+        nv_icmd(priv, 0x000538, 0xffff0000);
+        nv_icmd(priv, 0x000539, 0xffff0000);
+        nv_icmd(priv, 0x00053a, 0xffff0000);
+        nv_icmd(priv, 0x00053b, 0xffff0000);
+        nv_icmd(priv, 0x00053c, 0xffff0000);
+        nv_icmd(priv, 0x00053d, 0xffff0000);
+        nv_icmd(priv, 0x00053e, 0xffff0000);
+        nv_icmd(priv, 0x00053f, 0xffff0000);
+        nv_icmd(priv, 0x000585, 0x0000003f);
+        nv_icmd(priv, 0x000576, 0x00000003);
+        nv_icmd(priv, 0x00057b, 0x00000059);
+        nv_icmd(priv, 0x000586, 0x00000040);
+        nv_icmd(priv, 0x000582, 0x00000080);
+        nv_icmd(priv, 0x000583, 0x00000080);
+        nv_icmd(priv, 0x0005c2, 0x00000001);
+        nv_icmd(priv, 0x000638, 0x00000001);
+        nv_icmd(priv, 0x000639, 0x00000001);
+        nv_icmd(priv, 0x00063a, 0x00000002);
+        nv_icmd(priv, 0x00063b, 0x00000001);
+        nv_icmd(priv, 0x00063c, 0x00000001);
+        nv_icmd(priv, 0x00063d, 0x00000002);
+        nv_icmd(priv, 0x00063e, 0x00000001);
+        nv_icmd(priv, 0x0008b8, 0x00000001);
+        nv_icmd(priv, 0x0008b9, 0x00000001);
+        nv_icmd(priv, 0x0008ba, 0x00000001);
+        nv_icmd(priv, 0x0008bb, 0x00000001);
+        nv_icmd(priv, 0x0008bc, 0x00000001);
+        nv_icmd(priv, 0x0008bd, 0x00000001);
+        nv_icmd(priv, 0x0008be, 0x00000001);
+        nv_icmd(priv, 0x0008bf, 0x00000001);
+        nv_icmd(priv, 0x000900, 0x00000001);
+        nv_icmd(priv, 0x000901, 0x00000001);
+        nv_icmd(priv, 0x000902, 0x00000001);
+        nv_icmd(priv, 0x000903, 0x00000001);
+        nv_icmd(priv, 0x000904, 0x00000001);
+        nv_icmd(priv, 0x000905, 0x00000001);
+        nv_icmd(priv, 0x000906, 0x00000001);
+        nv_icmd(priv, 0x000907, 0x00000001);
+        nv_icmd(priv, 0x000908, 0x00000002);
+        nv_icmd(priv, 0x000909, 0x00000002);
+        nv_icmd(priv, 0x00090a, 0x00000002);
+        nv_icmd(priv, 0x00090b, 0x00000002);
+        nv_icmd(priv, 0x00090c, 0x00000002);
+        nv_icmd(priv, 0x00090d, 0x00000002);
+        nv_icmd(priv, 0x00090e, 0x00000002);
+        nv_icmd(priv, 0x00090f, 0x00000002);
+        nv_icmd(priv, 0x000910, 0x00000001);
+        nv_icmd(priv, 0x000911, 0x00000001);
+        nv_icmd(priv, 0x000912, 0x00000001);
+        nv_icmd(priv, 0x000913, 0x00000001);
+        nv_icmd(priv, 0x000914, 0x00000001);
+        nv_icmd(priv, 0x000915, 0x00000001);
+        nv_icmd(priv, 0x000916, 0x00000001);
+        nv_icmd(priv, 0x000917, 0x00000001);
+        nv_icmd(priv, 0x000918, 0x00000001);
+        nv_icmd(priv, 0x000919, 0x00000001);
+        nv_icmd(priv, 0x00091a, 0x00000001);
+        nv_icmd(priv, 0x00091b, 0x00000001);
+        nv_icmd(priv, 0x00091c, 0x00000001);
+        nv_icmd(priv, 0x00091d, 0x00000001);
+        nv_icmd(priv, 0x00091e, 0x00000001);
+        nv_icmd(priv, 0x00091f, 0x00000001);
+        nv_icmd(priv, 0x000920, 0x00000002);
+        nv_icmd(priv, 0x000921, 0x00000002);
+        nv_icmd(priv, 0x000922, 0x00000002);
+        nv_icmd(priv, 0x000923, 0x00000002);
+        nv_icmd(priv, 0x000924, 0x00000002);
+        nv_icmd(priv, 0x000925, 0x00000002);
+        nv_icmd(priv, 0x000926, 0x00000002);
+        nv_icmd(priv, 0x000927, 0x00000002);
+        nv_icmd(priv, 0x000928, 0x00000001);
+        nv_icmd(priv, 0x000929, 0x00000001);
+        nv_icmd(priv, 0x00092a, 0x00000001);
+        nv_icmd(priv, 0x00092b, 0x00000001);
+        nv_icmd(priv, 0x00092c, 0x00000001);
+        nv_icmd(priv, 0x00092d, 0x00000001);
+        nv_icmd(priv, 0x00092e, 0x00000001);
+        nv_icmd(priv, 0x00092f, 0x00000001);
+        nv_icmd(priv, 0x000648, 0x00000001);
+        nv_icmd(priv, 0x000649, 0x00000001);
+        nv_icmd(priv, 0x00064a, 0x00000001);
+        nv_icmd(priv, 0x00064b, 0x00000001);
+        nv_icmd(priv, 0x00064c, 0x00000001);
+        nv_icmd(priv, 0x00064d, 0x00000001);
+        nv_icmd(priv, 0x00064e, 0x00000001);
+        nv_icmd(priv, 0x00064f, 0x00000001);
+        nv_icmd(priv, 0x000650, 0x00000001);
+        nv_icmd(priv, 0x000658, 0x0000000f);
+        nv_icmd(priv, 0x0007ff, 0x0000000a);
+        nv_icmd(priv, 0x00066a, 0x40000000);
+        nv_icmd(priv, 0x00066b, 0x10000000);
+        nv_icmd(priv, 0x00066c, 0xffff0000);
+        nv_icmd(priv, 0x00066d, 0xffff0000);
+        nv_icmd(priv, 0x0007af, 0x00000008);
+        nv_icmd(priv, 0x0007b0, 0x00000008);
+        nv_icmd(priv, 0x0007f6, 0x00000001);
+        nv_icmd(priv, 0x0006b2, 0x00000055);
+        nv_icmd(priv, 0x0007ad, 0x00000003);
+        nv_icmd(priv, 0x000937, 0x00000001);
+        nv_icmd(priv, 0x000971, 0x00000008);
+        nv_icmd(priv, 0x000972, 0x00000040);
+        nv_icmd(priv, 0x000973, 0x0000012c);
+        nv_icmd(priv, 0x00097c, 0x00000040);
+        nv_icmd(priv, 0x000979, 0x00000003);
+        nv_icmd(priv, 0x000975, 0x00000020);
+        nv_icmd(priv, 0x000976, 0x00000001);
+        nv_icmd(priv, 0x000977, 0x00000020);
+        nv_icmd(priv, 0x000978, 0x00000001);
+        nv_icmd(priv, 0x000957, 0x00000003);
+        nv_icmd(priv, 0x00095e, 0x20164010);
+        nv_icmd(priv, 0x00095f, 0x00000020);
+        nv_icmd(priv, 0x00097d, 0x00000020);
+        nv_icmd(priv, 0x000683, 0x00000006);
+        nv_icmd(priv, 0x000685, 0x003fffff);
+        nv_icmd(priv, 0x000687, 0x003fffff);
+        nv_icmd(priv, 0x0006a0, 0x00000005);
+        nv_icmd(priv, 0x000840, 0x00400008);
+        nv_icmd(priv, 0x000841, 0x08000080);
+        nv_icmd(priv, 0x000842, 0x00400008);
+        nv_icmd(priv, 0x000843, 0x08000080);
+        nv_icmd(priv, 0x000818, 0x00000000);
+        nv_icmd(priv, 0x000819, 0x00000000);
+        nv_icmd(priv, 0x00081a, 0x00000000);
+        nv_icmd(priv, 0x00081b, 0x00000000);
+        nv_icmd(priv, 0x00081c, 0x00000000);
+        nv_icmd(priv, 0x00081d, 0x00000000);
+        nv_icmd(priv, 0x00081e, 0x00000000);
+        nv_icmd(priv, 0x00081f, 0x00000000);
+        nv_icmd(priv, 0x000848, 0x00000000);
+        nv_icmd(priv, 0x000849, 0x00000000);
+        nv_icmd(priv, 0x00084a, 0x00000000);
+        nv_icmd(priv, 0x00084b, 0x00000000);
+        nv_icmd(priv, 0x00084c, 0x00000000);
+        nv_icmd(priv, 0x00084d, 0x00000000);
+        nv_icmd(priv, 0x00084e, 0x00000000);
+        nv_icmd(priv, 0x00084f, 0x00000000);
+        nv_icmd(priv, 0x000850, 0x00000000);
+        nv_icmd(priv, 0x000851, 0x00000000);
+        nv_icmd(priv, 0x000852, 0x00000000);
+        nv_icmd(priv, 0x000853, 0x00000000);
+        nv_icmd(priv, 0x000854, 0x00000000);
+        nv_icmd(priv, 0x000855, 0x00000000);
+        nv_icmd(priv, 0x000856, 0x00000000);
+        nv_icmd(priv, 0x000857, 0x00000000);
+        nv_icmd(priv, 0x000738, 0x00000000);
+        nv_icmd(priv, 0x0006aa, 0x00000001);
+        nv_icmd(priv, 0x0006ab, 0x00000002);
+        nv_icmd(priv, 0x0006ac, 0x00000080);
+        nv_icmd(priv, 0x0006ad, 0x00000100);
+        nv_icmd(priv, 0x0006ae, 0x00000100);
+        nv_icmd(priv, 0x0006b1, 0x00000011);
+        nv_icmd(priv, 0x0006bb, 0x000000cf);
+        nv_icmd(priv, 0x0006ce, 0x2a712488);
+        nv_icmd(priv, 0x000739, 0x4085c000);
+        nv_icmd(priv, 0x00073a, 0x00000080);
+        nv_icmd(priv, 0x000786, 0x80000100);
+        nv_icmd(priv, 0x00073c, 0x00010100);
+        nv_icmd(priv, 0x00073d, 0x02800000);
+        nv_icmd(priv, 0x000787, 0x000000cf);
+        nv_icmd(priv, 0x00078c, 0x00000008);
+        nv_icmd(priv, 0x000792, 0x00000001);
+        nv_icmd(priv, 0x000794, 0x00000001);
+        nv_icmd(priv, 0x000795, 0x00000001);
+        nv_icmd(priv, 0x000796, 0x00000001);
+        nv_icmd(priv, 0x000797, 0x000000cf);
+        nv_icmd(priv, 0x000836, 0x00000001);
+        nv_icmd(priv, 0x00079a, 0x00000002);
+        nv_icmd(priv, 0x000833, 0x04444480);
+        nv_icmd(priv, 0x0007a1, 0x00000001);
+        nv_icmd(priv, 0x0007a3, 0x00000001);
+        nv_icmd(priv, 0x0007a4, 0x00000001);
+        nv_icmd(priv, 0x0007a5, 0x00000001);
+        nv_icmd(priv, 0x000831, 0x00000004);
+        nv_icmd(priv, 0x000b07, 0x00000002);
+        nv_icmd(priv, 0x000b08, 0x00000100);
+        nv_icmd(priv, 0x000b09, 0x00000100);
+        nv_icmd(priv, 0x000b0a, 0x00000001);
+        nv_icmd(priv, 0x000a04, 0x000000ff);
+        nv_icmd(priv, 0x000a0b, 0x00000040);
+        nv_icmd(priv, 0x00097f, 0x00000100);
+        nv_icmd(priv, 0x000a02, 0x00000001);
+        nv_icmd(priv, 0x000809, 0x00000007);
+        nv_icmd(priv, 0x00c221, 0x00000040);
+        nv_icmd(priv, 0x00c1b0, 0x0000000f);
+        nv_icmd(priv, 0x00c1b1, 0x0000000f);
+        nv_icmd(priv, 0x00c1b2, 0x0000000f);
+        nv_icmd(priv, 0x00c1b3, 0x0000000f);
+        nv_icmd(priv, 0x00c1b4, 0x0000000f);
+        nv_icmd(priv, 0x00c1b5, 0x0000000f);
+        nv_icmd(priv, 0x00c1b6, 0x0000000f);
+        nv_icmd(priv, 0x00c1b7, 0x0000000f);
+        nv_icmd(priv, 0x00c1b8, 0x0fac6881);
+        nv_icmd(priv, 0x00c1b9, 0x00fac688);
+        nv_icmd(priv, 0x00c401, 0x00000001);
+        nv_icmd(priv, 0x00c402, 0x00010001);
+        nv_icmd(priv, 0x00c403, 0x00000001);
+        nv_icmd(priv, 0x00c404, 0x00000001);
+        nv_icmd(priv, 0x00c40e, 0x00000020);
+        nv_icmd(priv, 0x00c500, 0x00000003);
+        nv_icmd(priv, 0x01e100, 0x00000001);
+        nv_icmd(priv, 0x001000, 0x00000002);
+        nv_icmd(priv, 0x0006aa, 0x00000001);
+        nv_icmd(priv, 0x0006ad, 0x00000100);
+        nv_icmd(priv, 0x0006ae, 0x00000100);
+        nv_icmd(priv, 0x0006b1, 0x00000011);
+        nv_icmd(priv, 0x00078c, 0x00000008);
+        nv_icmd(priv, 0x000792, 0x00000001);
+        nv_icmd(priv, 0x000794, 0x00000001);
+        nv_icmd(priv, 0x000795, 0x00000001);
+        nv_icmd(priv, 0x000796, 0x00000001);
+        nv_icmd(priv, 0x000797, 0x000000cf);
+        nv_icmd(priv, 0x00079a, 0x00000002);
+        nv_icmd(priv, 0x000833, 0x04444480);
+        nv_icmd(priv, 0x0007a1, 0x00000001);
+        nv_icmd(priv, 0x0007a3, 0x00000001);
+        nv_icmd(priv, 0x0007a4, 0x00000001);
+        nv_icmd(priv, 0x0007a5, 0x00000001);
+        nv_icmd(priv, 0x000831, 0x00000004);
+        nv_icmd(priv, 0x01e100, 0x00000001);
+        nv_icmd(priv, 0x001000, 0x00000008);
+        nv_icmd(priv, 0x000039, 0x00000000);
+        nv_icmd(priv, 0x00003a, 0x00000000);
+        nv_icmd(priv, 0x00003b, 0x00000000);
+        nv_icmd(priv, 0x000380, 0x00000001);
+        nv_icmd(priv, 0x000366, 0x00000000);
+        nv_icmd(priv, 0x000367, 0x00000000);
+        nv_icmd(priv, 0x000368, 0x00000fff);
+        nv_icmd(priv, 0x000370, 0x00000000);
+        nv_icmd(priv, 0x000371, 0x00000000);
+        nv_icmd(priv, 0x000372, 0x000fffff);
+        nv_icmd(priv, 0x000813, 0x00000006);
+        nv_icmd(priv, 0x000814, 0x00000008);
+        nv_icmd(priv, 0x000957, 0x00000003);
+        nv_icmd(priv, 0x000818, 0x00000000);
+        nv_icmd(priv, 0x000819, 0x00000000);
+        nv_icmd(priv, 0x00081a, 0x00000000);
+        nv_icmd(priv, 0x00081b, 0x00000000);
+        nv_icmd(priv, 0x00081c, 0x00000000);
+        nv_icmd(priv, 0x00081d, 0x00000000);
+        nv_icmd(priv, 0x00081e, 0x00000000);
+        nv_icmd(priv, 0x00081f, 0x00000000);
+        nv_icmd(priv, 0x000848, 0x00000000);
+        nv_icmd(priv, 0x000849, 0x00000000);
+        nv_icmd(priv, 0x00084a, 0x00000000);
+        nv_icmd(priv, 0x00084b, 0x00000000);
+        nv_icmd(priv, 0x00084c, 0x00000000);
+        nv_icmd(priv, 0x00084d, 0x00000000);
+        nv_icmd(priv, 0x00084e, 0x00000000);
+        nv_icmd(priv, 0x00084f, 0x00000000);
+        nv_icmd(priv, 0x000850, 0x00000000);
+        nv_icmd(priv, 0x000851, 0x00000000);
+        nv_icmd(priv, 0x000852, 0x00000000);
+        nv_icmd(priv, 0x000853, 0x00000000);
+        nv_icmd(priv, 0x000854, 0x00000000);
+        nv_icmd(priv, 0x000855, 0x00000000);
+        nv_icmd(priv, 0x000856, 0x00000000);
+        nv_icmd(priv, 0x000857, 0x00000000);
+        nv_icmd(priv, 0x000738, 0x00000000);
+        nv_icmd(priv, 0x000b07, 0x00000002);
+        nv_icmd(priv, 0x000b08, 0x00000100);
+        nv_icmd(priv, 0x000b09, 0x00000100);
+        nv_icmd(priv, 0x000b0a, 0x00000001);
+        nv_icmd(priv, 0x000a04, 0x000000ff);
+        nv_icmd(priv, 0x00097f, 0x00000100);
+        nv_icmd(priv, 0x000a02, 0x00000001);
+        nv_icmd(priv, 0x000809, 0x00000007);
+        nv_icmd(priv, 0x00c221, 0x00000040);
+        nv_icmd(priv, 0x00c401, 0x00000001);
+        nv_icmd(priv, 0x00c402, 0x00010001);
+        nv_icmd(priv, 0x00c403, 0x00000001);
+        nv_icmd(priv, 0x00c404, 0x00000001);
+        nv_icmd(priv, 0x00c40e, 0x00000020);
+        nv_icmd(priv, 0x00c500, 0x00000003);
+        nv_icmd(priv, 0x01e100, 0x00000001);
+        nv_icmd(priv, 0x001000, 0x00000001);
+        nv_icmd(priv, 0x000b07, 0x00000002);
+        nv_icmd(priv, 0x000b08, 0x00000100);
+        nv_icmd(priv, 0x000b09, 0x00000100);
+        nv_icmd(priv, 0x000b0a, 0x00000001);
+        nv_icmd(priv, 0x01e100, 0x00000001);
+        nv_wr32(priv, 0x400208, 0x00000000);
+}
+
+static void
+nve0_grctx_generate_a097(struct nvc0_graph_priv *priv)
+{
+        nv_mthd(priv, 0xa097, 0x0800, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0840, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0880, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x08c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0900, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0940, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0980, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x09c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0804, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0844, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0884, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x08c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0904, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0944, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0984, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x09c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0808, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x0848, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x0888, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x08c8, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x0908, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x0948, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x0988, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x09c8, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x080c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x084c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x088c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x08cc, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x090c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x094c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x098c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x09cc, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x0810, 0x000000cf);
+        nv_mthd(priv, 0xa097, 0x0850, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0890, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x08d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0910, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0950, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0990, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x09d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0814, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0854, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0894, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x08d4, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0914, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0954, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0994, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x09d4, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0818, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0858, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0898, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x08d8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0918, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0958, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0998, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x09d8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x081c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x085c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x089c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x08dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x091c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x095c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x099c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x09dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0820, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0860, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x08a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x08e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0920, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0960, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x09a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x09e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ca0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cb0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cc0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cd0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ce0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cf0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c24, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c34, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c64, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c94, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ca4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cb4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cc4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cd4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ce4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cf4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c18, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c28, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c38, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c58, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c68, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c78, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c98, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ca8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cb8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cc8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cd8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ce8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cf8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c0c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c1c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c2c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c3c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c4c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c5c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c6c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c7c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1c9c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cbc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ccc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cdc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1cfc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1da0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1db0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dc0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dd0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1de0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1df0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d24, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d34, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d64, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d94, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1da4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1db4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dc4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dd4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1de4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1df4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d18, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d28, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d38, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d58, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d68, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d78, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d98, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1da8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1db8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dc8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dd8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1de8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1df8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d0c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d1c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d2c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d3c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d4c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d5c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d6c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d7c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1d9c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dbc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dcc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ddc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1dfc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f18, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f28, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f38, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f58, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f68, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f78, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f0c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f1c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f24, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f2c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f34, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f3c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f4c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f5c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f64, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f6c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f7c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f98, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fa0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fa8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fb0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fb8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fc0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fc8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fd0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fd8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fe0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fe8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ff0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ff8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f94, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1f9c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fa4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fb4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fbc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fc4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fcc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fd4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fdc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fe4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1fec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ff4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1ffc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2000, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2040, 0x00000011);
+        nv_mthd(priv, 0xa097, 0x2080, 0x00000020);
+        nv_mthd(priv, 0xa097, 0x20c0, 0x00000030);
+        nv_mthd(priv, 0xa097, 0x2100, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x2140, 0x00000051);
+        nv_mthd(priv, 0xa097, 0x200c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x204c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x208c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x20cc, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x210c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x214c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x2010, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2050, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2090, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x20d0, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x2110, 0x00000003);
+        nv_mthd(priv, 0xa097, 0x2150, 0x00000004);
+        nv_mthd(priv, 0xa097, 0x0380, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0384, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0388, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x038c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x03ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0700, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0710, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0720, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0730, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0704, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0714, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0724, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0734, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0708, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0718, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0728, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0738, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2800, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2804, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2808, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x280c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2810, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2814, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2818, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x281c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2820, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2824, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2828, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x282c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2830, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2834, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2838, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x283c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2840, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2844, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2848, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x284c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2850, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2854, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2858, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x285c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2860, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2864, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2868, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x286c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2870, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2874, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2878, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x287c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2880, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2884, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2888, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x288c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2890, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2894, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2898, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x289c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28b0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28b4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28b8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28d4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28d8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28f0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x28fc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2900, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2904, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2908, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x290c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2910, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2914, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2918, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x291c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2920, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2924, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2928, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x292c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2930, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2934, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2938, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x293c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2940, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2944, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2948, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x294c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2950, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2954, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2958, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x295c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2960, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2964, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2968, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x296c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2970, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2974, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2978, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x297c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2980, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2984, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2988, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x298c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2990, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2994, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2998, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x299c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29b0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29b4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29b8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29d4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29d8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29f0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x29fc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0aa0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ac0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ae0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ba0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bc0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0be0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a24, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a64, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0aa4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ac4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ae4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b24, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b64, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ba4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bc4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0be4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a28, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a68, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0aa8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ac8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ae8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b28, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b68, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ba8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bc8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0be8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a0c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a2c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a4c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a6c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0aac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0acc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0aec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b0c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b2c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b4c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b6c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bcc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ab0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ad0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0af0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bb0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bd0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bf0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a34, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0a94, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ab4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ad4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0af4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b34, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0b94, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bb4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bd4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0bf4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ca0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cb0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cc0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cd0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ce0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cf0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c24, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c34, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c64, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c94, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ca4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cb4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cc4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cd4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ce4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cf4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c18, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c28, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c38, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c58, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c68, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c78, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c98, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ca8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cb8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cc8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cd8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ce8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0cf8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0c0c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c1c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c2c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c3c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c4c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c5c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c6c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c7c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c8c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0c9c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0cac, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0cbc, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0ccc, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0cdc, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0cec, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0cfc, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0d00, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d08, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d10, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d18, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d20, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d28, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d30, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d38, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d04, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d0c, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d14, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d1c, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d24, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d2c, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d34, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d3c, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e00, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e20, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e30, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e60, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e70, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ea0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0eb0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ec0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ed0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ee0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ef0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0e04, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e14, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e24, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e34, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e44, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e54, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e64, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e74, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e84, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e94, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ea4, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0eb4, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ec4, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ed4, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ee4, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ef4, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e08, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e18, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e28, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e38, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e48, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e58, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e68, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e78, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e88, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0e98, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ea8, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0eb8, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ec8, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ed8, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ee8, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0ef8, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d40, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d48, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d50, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d58, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d44, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d4c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d5c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1e00, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e20, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e40, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e60, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e80, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ea0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ec0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ee0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e04, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e24, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e44, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e64, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e84, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ea4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ec4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ee4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e08, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e28, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e48, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e68, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e88, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1ea8, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1ec8, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1ee8, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e0c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e2c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e4c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e6c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e8c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1eac, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ecc, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1eec, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e10, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e30, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e50, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e70, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e90, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1eb0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ed0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ef0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e14, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e34, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e54, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e74, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e94, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1eb4, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1ed4, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1ef4, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1e18, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e38, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e58, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e78, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1e98, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1eb8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ed8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1ef8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x3400, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3404, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3408, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x340c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3410, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3414, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3418, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x341c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3420, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3424, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3428, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x342c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3430, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3434, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3438, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x343c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3440, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3444, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3448, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x344c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3450, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3454, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3458, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x345c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3460, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3464, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3468, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x346c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3470, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3474, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3478, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x347c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3480, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3484, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3488, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x348c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3490, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3494, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3498, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x349c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34b0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34b4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34b8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34d4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34d8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34f0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x34fc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3500, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3504, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3508, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x350c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3510, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3514, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3518, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x351c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3520, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3524, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3528, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x352c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3530, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3534, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3538, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x353c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3540, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3544, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3548, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x354c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3550, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3554, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3558, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x355c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3560, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3564, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3568, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x356c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3570, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3574, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3578, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x357c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3580, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3584, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3588, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x358c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3590, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3594, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x3598, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x359c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35b0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35b4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35b8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35d4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35d8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35f0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x35fc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x030c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1944, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1514, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d68, 0x0000ffff);
+        nv_mthd(priv, 0xa097, 0x121c, 0x0fac6881);
+        nv_mthd(priv, 0xa097, 0x0fac, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1538, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0fe0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0fe4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0fe8, 0x00000014);
+        nv_mthd(priv, 0xa097, 0x0fec, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x0ff0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x179c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1228, 0x00000400);
+        nv_mthd(priv, 0xa097, 0x122c, 0x00000300);
+        nv_mthd(priv, 0xa097, 0x1230, 0x00010001);
+        nv_mthd(priv, 0xa097, 0x07f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x15b4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x15cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1534, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0fb0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x15d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x153c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x16b4, 0x00000003);
+        nv_mthd(priv, 0xa097, 0x0fbc, 0x0000ffff);
+        nv_mthd(priv, 0xa097, 0x0fc0, 0x0000ffff);
+        nv_mthd(priv, 0xa097, 0x0fc4, 0x0000ffff);
+        nv_mthd(priv, 0xa097, 0x0fc8, 0x0000ffff);
+        nv_mthd(priv, 0xa097, 0x0df8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0dfc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1948, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1970, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x161c, 0x000009f0);
+        nv_mthd(priv, 0xa097, 0x0dcc, 0x00000010);
+        nv_mthd(priv, 0xa097, 0x163c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x15e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1160, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1164, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1168, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x116c, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1170, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1174, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1178, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x117c, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1180, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1184, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1188, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x118c, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1190, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1194, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1198, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x119c, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11a0, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11a4, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11a8, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11ac, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11b0, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11b4, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11b8, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11bc, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11c0, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11c4, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11c8, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11cc, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11d0, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11d4, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11d8, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x11dc, 0x25e00040);
+        nv_mthd(priv, 0xa097, 0x1880, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1884, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1888, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x188c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1890, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1894, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1898, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x189c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18b0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18b4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18b8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18d0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18d4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18d8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18e0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18f0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x18fc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x17c8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x17cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x17d0, 0x000000ff);
+        nv_mthd(priv, 0xa097, 0x17d4, 0xffffffff);
+        nv_mthd(priv, 0xa097, 0x17d8, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x17dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x15f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x15f8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1434, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1438, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d74, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0dec, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x13a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1318, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1644, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0748, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0de8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1648, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x12a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1120, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1124, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1128, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x112c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1118, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x164c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1658, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1910, 0x00000290);
+        nv_mthd(priv, 0xa097, 0x1518, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x165c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1520, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1604, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1570, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x13b0, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x13b4, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x020c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1670, 0x30201000);
+        nv_mthd(priv, 0xa097, 0x1674, 0x70605040);
+        nv_mthd(priv, 0xa097, 0x1678, 0xb8a89888);
+        nv_mthd(priv, 0xa097, 0x167c, 0xf8e8d8c8);
+        nv_mthd(priv, 0xa097, 0x166c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1680, 0x00ffff00);
+        nv_mthd(priv, 0xa097, 0x12d0, 0x00000003);
+        nv_mthd(priv, 0xa097, 0x12d4, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1684, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1688, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0dac, 0x00001b02);
+        nv_mthd(priv, 0xa097, 0x0db0, 0x00001b02);
+        nv_mthd(priv, 0xa097, 0x0db4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x168c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x15bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x156c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x187c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1110, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0dc0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0dc4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0dc8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1234, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1690, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x12ac, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0790, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0794, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0798, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x079c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07a0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x077c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1000, 0x00000010);
+        nv_mthd(priv, 0xa097, 0x10fc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1290, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0218, 0x00000010);
+        nv_mthd(priv, 0xa097, 0x12d8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x12dc, 0x00000010);
+        nv_mthd(priv, 0xa097, 0x0d94, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x155c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1560, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1564, 0x00000fff);
+        nv_mthd(priv, 0xa097, 0x1574, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1578, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x157c, 0x000fffff);
+        nv_mthd(priv, 0xa097, 0x1354, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1610, 0x00000012);
+        nv_mthd(priv, 0xa097, 0x1608, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x160c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x260c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x162c, 0x00000003);
+        nv_mthd(priv, 0xa097, 0x0210, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0320, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0324, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0328, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x032c, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0330, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0334, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0338, 0x3f800000);
+        nv_mthd(priv, 0xa097, 0x0750, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0760, 0x39291909);
+        nv_mthd(priv, 0xa097, 0x0764, 0x79695949);
+        nv_mthd(priv, 0xa097, 0x0768, 0xb9a99989);
+        nv_mthd(priv, 0xa097, 0x076c, 0xf9e9d9c9);
+        nv_mthd(priv, 0xa097, 0x0770, 0x30201000);
+        nv_mthd(priv, 0xa097, 0x0774, 0x70605040);
+        nv_mthd(priv, 0xa097, 0x0778, 0x00009080);
+        nv_mthd(priv, 0xa097, 0x0780, 0x39291909);
+        nv_mthd(priv, 0xa097, 0x0784, 0x79695949);
+        nv_mthd(priv, 0xa097, 0x0788, 0xb9a99989);
+        nv_mthd(priv, 0xa097, 0x078c, 0xf9e9d9c9);
+        nv_mthd(priv, 0xa097, 0x07d0, 0x30201000);
+        nv_mthd(priv, 0xa097, 0x07d4, 0x70605040);
+        nv_mthd(priv, 0xa097, 0x07d8, 0x00009080);
+        nv_mthd(priv, 0xa097, 0x037c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0740, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0744, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x2600, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1918, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x191c, 0x00000900);
+        nv_mthd(priv, 0xa097, 0x1920, 0x00000405);
+        nv_mthd(priv, 0xa097, 0x1308, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1924, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x13ac, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x192c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x193c, 0x00002c1c);
+        nv_mthd(priv, 0xa097, 0x0d7c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x02c0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1510, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1940, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ff4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0ff8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x194c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1950, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1968, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1590, 0x0000003f);
+        nv_mthd(priv, 0xa097, 0x07e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07f0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07f4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x196c, 0x00000011);
+        nv_mthd(priv, 0xa097, 0x02e4, 0x0000b001);
+        nv_mthd(priv, 0xa097, 0x036c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0370, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x197c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0fcc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0fd0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x02d8, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x1980, 0x00000080);
+        nv_mthd(priv, 0xa097, 0x1504, 0x00000080);
+        nv_mthd(priv, 0xa097, 0x1984, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0300, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x13a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x12ec, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1310, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1314, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1380, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1384, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1388, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x138c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1390, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1394, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x139c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1398, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1594, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1598, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x159c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x15a0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x15a4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0f54, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f58, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f5c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x19bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f9c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0fa0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x12cc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x12e8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x130c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1360, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1364, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1368, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x136c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1370, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1374, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1378, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x137c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x133c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1340, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1344, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1348, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x134c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1350, 0x00000002);
+        nv_mthd(priv, 0xa097, 0x1358, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x12e4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x131c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1320, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1324, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1328, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x19c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1140, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x19c4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x19c8, 0x00001500);
+        nv_mthd(priv, 0xa097, 0x135c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x19e0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19e4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19e8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19ec, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19f0, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19f4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19f8, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19fc, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x19cc, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x15b8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a00, 0x00001111);
+        nv_mthd(priv, 0xa097, 0x1a04, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a08, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a0c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a10, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a14, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a18, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1a1c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d6c, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x0d70, 0xffff0000);
+        nv_mthd(priv, 0xa097, 0x10f8, 0x00001010);
+        nv_mthd(priv, 0xa097, 0x0d80, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d84, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d88, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d8c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0d90, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0da0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07a4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x07a8, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1508, 0x80000000);
+        nv_mthd(priv, 0xa097, 0x150c, 0x40000000);
+        nv_mthd(priv, 0xa097, 0x1668, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0318, 0x00000008);
+        nv_mthd(priv, 0xa097, 0x031c, 0x00000008);
+        nv_mthd(priv, 0xa097, 0x0d9c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x0374, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0378, 0x00000020);
+        nv_mthd(priv, 0xa097, 0x07dc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x074c, 0x00000055);
+        nv_mthd(priv, 0xa097, 0x1420, 0x00000003);
+        nv_mthd(priv, 0xa097, 0x17bc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x17c0, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x17c4, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1008, 0x00000008);
+        nv_mthd(priv, 0xa097, 0x100c, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x1010, 0x0000012c);
+        nv_mthd(priv, 0xa097, 0x0d60, 0x00000040);
+        nv_mthd(priv, 0xa097, 0x075c, 0x00000003);
+        nv_mthd(priv, 0xa097, 0x1018, 0x00000020);
+        nv_mthd(priv, 0xa097, 0x101c, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1020, 0x00000020);
+        nv_mthd(priv, 0xa097, 0x1024, 0x00000001);
+        nv_mthd(priv, 0xa097, 0x1444, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x1448, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x144c, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0360, 0x20164010);
+        nv_mthd(priv, 0xa097, 0x0364, 0x00000020);
+        nv_mthd(priv, 0xa097, 0x0368, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0de4, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0204, 0x00000006);
+        nv_mthd(priv, 0xa097, 0x0208, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x02cc, 0x003fffff);
+        nv_mthd(priv, 0xa097, 0x02d0, 0x003fffff);
+        nv_mthd(priv, 0xa097, 0x1220, 0x00000005);
+        nv_mthd(priv, 0xa097, 0x0fdc, 0x00000000);
+        nv_mthd(priv, 0xa097, 0x0f98, 0x00400008);
+        nv_mthd(priv, 0xa097, 0x1284, 0x08000080);
+        nv_mthd(priv, 0xa097, 0x1450, 0x00400008);
+        nv_mthd(priv, 0xa097, 0x1454, 0x08000080);
+        nv_mthd(priv, 0xa097, 0x0214, 0x00000000);
+}
+
+static void
+nve0_grctx_generate_902d(struct nvc0_graph_priv *priv)
+{
+        nv_mthd(priv, 0x902d, 0x0200, 0x000000cf);
+        nv_mthd(priv, 0x902d, 0x0204, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0208, 0x00000020);
+        nv_mthd(priv, 0x902d, 0x020c, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0210, 0x00000000);
+        nv_mthd(priv, 0x902d, 0x0214, 0x00000080);
+        nv_mthd(priv, 0x902d, 0x0218, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x021c, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x0220, 0x00000000);
+        nv_mthd(priv, 0x902d, 0x0224, 0x00000000);
+        nv_mthd(priv, 0x902d, 0x0230, 0x000000cf);
+        nv_mthd(priv, 0x902d, 0x0234, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0238, 0x00000020);
+        nv_mthd(priv, 0x902d, 0x023c, 0x00000001);
+        nv_mthd(priv, 0x902d, 0x0244, 0x00000080);
+        nv_mthd(priv, 0x902d, 0x0248, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x024c, 0x00000100);
+        nv_mthd(priv, 0x902d, 0x3410, 0x00000000);
+}
+
+static void
+nve0_graph_generate_unk40xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404010, 0x0);
+        nv_wr32(priv, 0x404014, 0x0);
+        nv_wr32(priv, 0x404018, 0x0);
+        nv_wr32(priv, 0x40401c, 0x0);
+        nv_wr32(priv, 0x404020, 0x0);
+        nv_wr32(priv, 0x404024, 0xe000);
+        nv_wr32(priv, 0x404028, 0x0);
+        nv_wr32(priv, 0x4040a8, 0x0);
+        nv_wr32(priv, 0x4040ac, 0x0);
+        nv_wr32(priv, 0x4040b0, 0x0);
+        nv_wr32(priv, 0x4040b4, 0x0);
+        nv_wr32(priv, 0x4040b8, 0x0);
+        nv_wr32(priv, 0x4040bc, 0x0);
+        nv_wr32(priv, 0x4040c0, 0x0);
+        nv_wr32(priv, 0x4040c4, 0x0);
+        nv_wr32(priv, 0x4040c8, 0xf800008f);
+        nv_wr32(priv, 0x4040d0, 0x0);
+        nv_wr32(priv, 0x4040d4, 0x0);
+        nv_wr32(priv, 0x4040d8, 0x0);
+        nv_wr32(priv, 0x4040dc, 0x0);
+        nv_wr32(priv, 0x4040e0, 0x0);
+        nv_wr32(priv, 0x4040e4, 0x0);
+        nv_wr32(priv, 0x4040e8, 0x1000);
+        nv_wr32(priv, 0x4040f8, 0x0);
+        nv_wr32(priv, 0x404130, 0x0);
+        nv_wr32(priv, 0x404134, 0x0);
+        nv_wr32(priv, 0x404138, 0x20000040);
+        nv_wr32(priv, 0x404150, 0x2e);
+        nv_wr32(priv, 0x404154, 0x400);
+        nv_wr32(priv, 0x404158, 0x200);
+        nv_wr32(priv, 0x404164, 0x55);
+        nv_wr32(priv, 0x4041a0, 0x0);
+        nv_wr32(priv, 0x4041a4, 0x0);
+        nv_wr32(priv, 0x4041a8, 0x0);
+        nv_wr32(priv, 0x4041ac, 0x0);
+        nv_wr32(priv, 0x404200, 0x0);
+        nv_wr32(priv, 0x404204, 0x0);
+        nv_wr32(priv, 0x404208, 0x0);
+        nv_wr32(priv, 0x40420c, 0x0);
+}
+
+static void
+nve0_graph_generate_unk44xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404404, 0x0);
+        nv_wr32(priv, 0x404408, 0x0);
+        nv_wr32(priv, 0x40440c, 0x0);
+        nv_wr32(priv, 0x404410, 0x0);
+        nv_wr32(priv, 0x404414, 0x0);
+        nv_wr32(priv, 0x404418, 0x0);
+        nv_wr32(priv, 0x40441c, 0x0);
+        nv_wr32(priv, 0x404420, 0x0);
+        nv_wr32(priv, 0x404424, 0x0);
+        nv_wr32(priv, 0x404428, 0x0);
+        nv_wr32(priv, 0x40442c, 0x0);
+        nv_wr32(priv, 0x404430, 0x0);
+        nv_wr32(priv, 0x404434, 0x0);
+        nv_wr32(priv, 0x404438, 0x0);
+        nv_wr32(priv, 0x404460, 0x0);
+        nv_wr32(priv, 0x404464, 0x0);
+        nv_wr32(priv, 0x404468, 0xffffff);
+        nv_wr32(priv, 0x40446c, 0x0);
+        nv_wr32(priv, 0x404480, 0x1);
+        nv_wr32(priv, 0x404498, 0x1);
+}
+
+static void
+nve0_graph_generate_unk46xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404604, 0x14);
+        nv_wr32(priv, 0x404608, 0x0);
+        nv_wr32(priv, 0x40460c, 0x3fff);
+        nv_wr32(priv, 0x404610, 0x100);
+        nv_wr32(priv, 0x404618, 0x0);
+        nv_wr32(priv, 0x40461c, 0x0);
+        nv_wr32(priv, 0x404620, 0x0);
+        nv_wr32(priv, 0x404624, 0x0);
+        nv_wr32(priv, 0x40462c, 0x0);
+        nv_wr32(priv, 0x404630, 0x0);
+        nv_wr32(priv, 0x404640, 0x0);
+        nv_wr32(priv, 0x404654, 0x0);
+        nv_wr32(priv, 0x404660, 0x0);
+        nv_wr32(priv, 0x404678, 0x0);
+        nv_wr32(priv, 0x40467c, 0x2);
+        nv_wr32(priv, 0x404680, 0x0);
+        nv_wr32(priv, 0x404684, 0x0);
+        nv_wr32(priv, 0x404688, 0x0);
+        nv_wr32(priv, 0x40468c, 0x0);
+        nv_wr32(priv, 0x404690, 0x0);
+        nv_wr32(priv, 0x404694, 0x0);
+        nv_wr32(priv, 0x404698, 0x0);
+        nv_wr32(priv, 0x40469c, 0x0);
+        nv_wr32(priv, 0x4046a0, 0x7f0080);
+        nv_wr32(priv, 0x4046a4, 0x0);
+        nv_wr32(priv, 0x4046a8, 0x0);
+        nv_wr32(priv, 0x4046ac, 0x0);
+        nv_wr32(priv, 0x4046b0, 0x0);
+        nv_wr32(priv, 0x4046b4, 0x0);
+        nv_wr32(priv, 0x4046b8, 0x0);
+        nv_wr32(priv, 0x4046bc, 0x0);
+        nv_wr32(priv, 0x4046c0, 0x0);
+        nv_wr32(priv, 0x4046c8, 0x0);
+        nv_wr32(priv, 0x4046cc, 0x0);
+        nv_wr32(priv, 0x4046d0, 0x0);
+}
+
+static void
+nve0_graph_generate_unk47xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x404700, 0x0);
+        nv_wr32(priv, 0x404704, 0x0);
+        nv_wr32(priv, 0x404708, 0x0);
+        nv_wr32(priv, 0x404718, 0x0);
+        nv_wr32(priv, 0x40471c, 0x0);
+        nv_wr32(priv, 0x404720, 0x0);
+        nv_wr32(priv, 0x404724, 0x0);
+        nv_wr32(priv, 0x404728, 0x0);
+        nv_wr32(priv, 0x40472c, 0x0);
+        nv_wr32(priv, 0x404730, 0x0);
+        nv_wr32(priv, 0x404734, 0x100);
+        nv_wr32(priv, 0x404738, 0x0);
+        nv_wr32(priv, 0x40473c, 0x0);
+        nv_wr32(priv, 0x404744, 0x0);
+        nv_wr32(priv, 0x404748, 0x0);
+        nv_wr32(priv, 0x404754, 0x0);
+}
+
+static void
+nve0_graph_generate_unk58xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x405800, 0xf8000bf);
+        nv_wr32(priv, 0x405830, 0x2180648);
+        nv_wr32(priv, 0x405834, 0x8000000);
+        nv_wr32(priv, 0x405838, 0x0);
+        nv_wr32(priv, 0x405854, 0x0);
+        nv_wr32(priv, 0x405870, 0x1);
+        nv_wr32(priv, 0x405874, 0x1);
+        nv_wr32(priv, 0x405878, 0x1);
+        nv_wr32(priv, 0x40587c, 0x1);
+        nv_wr32(priv, 0x405a00, 0x0);
+        nv_wr32(priv, 0x405a04, 0x0);
+        nv_wr32(priv, 0x405a18, 0x0);
+        nv_wr32(priv, 0x405b00, 0x0);
+        nv_wr32(priv, 0x405b10, 0x1000);
+}
+
+static void
+nve0_graph_generate_unk60xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x406020, 0x4103c1);
+        nv_wr32(priv, 0x406028, 0x1);
+        nv_wr32(priv, 0x40602c, 0x1);
+        nv_wr32(priv, 0x406030, 0x1);
+        nv_wr32(priv, 0x406034, 0x1);
+}
+
+static void
+nve0_graph_generate_unk64xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x4064a8, 0x0);
+        nv_wr32(priv, 0x4064ac, 0x3fff);
+        nv_wr32(priv, 0x4064b4, 0x0);
+        nv_wr32(priv, 0x4064b8, 0x0);
+        nv_wr32(priv, 0x4064c0, 0x801a00f0);
+        nv_wr32(priv, 0x4064c4, 0x192ffff);
+        nv_wr32(priv, 0x4064c8, 0x1800600);
+        nv_wr32(priv, 0x4064cc, 0x0);
+        nv_wr32(priv, 0x4064d0, 0x0);
+        nv_wr32(priv, 0x4064d4, 0x0);
+        nv_wr32(priv, 0x4064d8, 0x0);
+        nv_wr32(priv, 0x4064dc, 0x0);
+        nv_wr32(priv, 0x4064e0, 0x0);
+        nv_wr32(priv, 0x4064e4, 0x0);
+        nv_wr32(priv, 0x4064e8, 0x0);
+        nv_wr32(priv, 0x4064ec, 0x0);
+        nv_wr32(priv, 0x4064fc, 0x22a);
+}
+
+static void
+nve0_graph_generate_unk70xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x407040, 0x0);
+}
+
+static void
+nve0_graph_generate_unk78xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x407804, 0x23);
+        nv_wr32(priv, 0x40780c, 0xa418820);
+        nv_wr32(priv, 0x407810, 0x62080e6);
+        nv_wr32(priv, 0x407814, 0x20398a4);
+        nv_wr32(priv, 0x407818, 0xe629062);
+        nv_wr32(priv, 0x40781c, 0xa418820);
+        nv_wr32(priv, 0x407820, 0xe6);
+        nv_wr32(priv, 0x4078bc, 0x103);
+}
+
+static void
+nve0_graph_generate_unk80xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x408000, 0x0);
+        nv_wr32(priv, 0x408004, 0x0);
+        nv_wr32(priv, 0x408008, 0x30);
+        nv_wr32(priv, 0x40800c, 0x0);
+        nv_wr32(priv, 0x408010, 0x0);
+        nv_wr32(priv, 0x408014, 0x69);
+        nv_wr32(priv, 0x408018, 0xe100e100);
+        nv_wr32(priv, 0x408064, 0x0);
+}
+
+static void
+nve0_graph_generate_unk88xx(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x408800, 0x2802a3c);
+        nv_wr32(priv, 0x408804, 0x40);
+        nv_wr32(priv, 0x408808, 0x1043e005);
+        nv_wr32(priv, 0x408840, 0xb);
+        nv_wr32(priv, 0x408900, 0x3080b801);
+        nv_wr32(priv, 0x408904, 0x62000001);
+        nv_wr32(priv, 0x408908, 0xc8102f);
+        nv_wr32(priv, 0x408980, 0x11d);
+}
+
+static void
+nve0_graph_generate_gpc(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x418380, 0x16);
+        nv_wr32(priv, 0x418400, 0x38004e00);
+        nv_wr32(priv, 0x418404, 0x71e0ffff);
+        nv_wr32(priv, 0x41840c, 0x1008);
+        nv_wr32(priv, 0x418410, 0xfff0fff);
+        nv_wr32(priv, 0x418414, 0x2200fff);
+        nv_wr32(priv, 0x418450, 0x0);
+        nv_wr32(priv, 0x418454, 0x0);
+        nv_wr32(priv, 0x418458, 0x0);
+        nv_wr32(priv, 0x41845c, 0x0);
+        nv_wr32(priv, 0x418460, 0x0);
+        nv_wr32(priv, 0x418464, 0x0);
+        nv_wr32(priv, 0x418468, 0x1);
+        nv_wr32(priv, 0x41846c, 0x0);
+        nv_wr32(priv, 0x418470, 0x0);
+        nv_wr32(priv, 0x418600, 0x1f);
+        nv_wr32(priv, 0x418684, 0xf);
+        nv_wr32(priv, 0x418700, 0x2);
+        nv_wr32(priv, 0x418704, 0x80);
+        nv_wr32(priv, 0x418708, 0x0);
+        nv_wr32(priv, 0x41870c, 0x0);
+        nv_wr32(priv, 0x418710, 0x0);
+        nv_wr32(priv, 0x418800, 0x7006860a);
+        nv_wr32(priv, 0x418808, 0x0);
+        nv_wr32(priv, 0x41880c, 0x0);
+        nv_wr32(priv, 0x418810, 0x0);
+        nv_wr32(priv, 0x418828, 0x44);
+        nv_wr32(priv, 0x418830, 0x10000001);
+        nv_wr32(priv, 0x4188d8, 0x8);
+        nv_wr32(priv, 0x4188e0, 0x1000000);
+        nv_wr32(priv, 0x4188e8, 0x0);
+        nv_wr32(priv, 0x4188ec, 0x0);
+        nv_wr32(priv, 0x4188f0, 0x0);
+        nv_wr32(priv, 0x4188f4, 0x0);
+        nv_wr32(priv, 0x4188f8, 0x0);
+        nv_wr32(priv, 0x4188fc, 0x20100018);
+        nv_wr32(priv, 0x41891c, 0xff00ff);
+        nv_wr32(priv, 0x418924, 0x0);
+        nv_wr32(priv, 0x418928, 0xffff00);
+        nv_wr32(priv, 0x41892c, 0xff00);
+        nv_wr32(priv, 0x418a00, 0x0);
+        nv_wr32(priv, 0x418a04, 0x0);
+        nv_wr32(priv, 0x418a08, 0x0);
+        nv_wr32(priv, 0x418a0c, 0x10000);
+        nv_wr32(priv, 0x418a10, 0x0);
+        nv_wr32(priv, 0x418a14, 0x0);
+        nv_wr32(priv, 0x418a18, 0x0);
+        nv_wr32(priv, 0x418a20, 0x0);
+        nv_wr32(priv, 0x418a24, 0x0);
+        nv_wr32(priv, 0x418a28, 0x0);
+        nv_wr32(priv, 0x418a2c, 0x10000);
+        nv_wr32(priv, 0x418a30, 0x0);
+        nv_wr32(priv, 0x418a34, 0x0);
+        nv_wr32(priv, 0x418a38, 0x0);
+        nv_wr32(priv, 0x418a40, 0x0);
+        nv_wr32(priv, 0x418a44, 0x0);
+        nv_wr32(priv, 0x418a48, 0x0);
+        nv_wr32(priv, 0x418a4c, 0x10000);
+        nv_wr32(priv, 0x418a50, 0x0);
+        nv_wr32(priv, 0x418a54, 0x0);
+        nv_wr32(priv, 0x418a58, 0x0);
+        nv_wr32(priv, 0x418a60, 0x0);
+        nv_wr32(priv, 0x418a64, 0x0);
+        nv_wr32(priv, 0x418a68, 0x0);
+        nv_wr32(priv, 0x418a6c, 0x10000);
+        nv_wr32(priv, 0x418a70, 0x0);
+        nv_wr32(priv, 0x418a74, 0x0);
+        nv_wr32(priv, 0x418a78, 0x0);
+        nv_wr32(priv, 0x418a80, 0x0);
+        nv_wr32(priv, 0x418a84, 0x0);
+        nv_wr32(priv, 0x418a88, 0x0);
+        nv_wr32(priv, 0x418a8c, 0x10000);
+        nv_wr32(priv, 0x418a90, 0x0);
+        nv_wr32(priv, 0x418a94, 0x0);
+        nv_wr32(priv, 0x418a98, 0x0);
+        nv_wr32(priv, 0x418aa0, 0x0);
+        nv_wr32(priv, 0x418aa4, 0x0);
+        nv_wr32(priv, 0x418aa8, 0x0);
+        nv_wr32(priv, 0x418aac, 0x10000);
+        nv_wr32(priv, 0x418ab0, 0x0);
+        nv_wr32(priv, 0x418ab4, 0x0);
+        nv_wr32(priv, 0x418ab8, 0x0);
+        nv_wr32(priv, 0x418ac0, 0x0);
+        nv_wr32(priv, 0x418ac4, 0x0);
+        nv_wr32(priv, 0x418ac8, 0x0);
+        nv_wr32(priv, 0x418acc, 0x10000);
+        nv_wr32(priv, 0x418ad0, 0x0);
+        nv_wr32(priv, 0x418ad4, 0x0);
+        nv_wr32(priv, 0x418ad8, 0x0);
+        nv_wr32(priv, 0x418ae0, 0x0);
+        nv_wr32(priv, 0x418ae4, 0x0);
+        nv_wr32(priv, 0x418ae8, 0x0);
+        nv_wr32(priv, 0x418aec, 0x10000);
+        nv_wr32(priv, 0x418af0, 0x0);
+        nv_wr32(priv, 0x418af4, 0x0);
+        nv_wr32(priv, 0x418af8, 0x0);
+        nv_wr32(priv, 0x418b00, 0x6);
+        nv_wr32(priv, 0x418b08, 0xa418820);
+        nv_wr32(priv, 0x418b0c, 0x62080e6);
+        nv_wr32(priv, 0x418b10, 0x20398a4);
+        nv_wr32(priv, 0x418b14, 0xe629062);
+        nv_wr32(priv, 0x418b18, 0xa418820);
+        nv_wr32(priv, 0x418b1c, 0xe6);
+        nv_wr32(priv, 0x418bb8, 0x103);
+        nv_wr32(priv, 0x418c08, 0x1);
+        nv_wr32(priv, 0x418c10, 0x0);
+        nv_wr32(priv, 0x418c14, 0x0);
+        nv_wr32(priv, 0x418c18, 0x0);
+        nv_wr32(priv, 0x418c1c, 0x0);
+        nv_wr32(priv, 0x418c20, 0x0);
+        nv_wr32(priv, 0x418c24, 0x0);
+        nv_wr32(priv, 0x418c28, 0x0);
+        nv_wr32(priv, 0x418c2c, 0x0);
+        nv_wr32(priv, 0x418c40, 0xffffffff);
+        nv_wr32(priv, 0x418c6c, 0x1);
+        nv_wr32(priv, 0x418c80, 0x20200004);
+        nv_wr32(priv, 0x418c8c, 0x1);
+        nv_wr32(priv, 0x419000, 0x780);
+        nv_wr32(priv, 0x419004, 0x0);
+        nv_wr32(priv, 0x419008, 0x0);
+        nv_wr32(priv, 0x419014, 0x4);
+}
+
+static void
+nve0_graph_generate_tpc(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x419848, 0x0);
+        nv_wr32(priv, 0x419864, 0x129);
+        nv_wr32(priv, 0x419888, 0x0);
+        nv_wr32(priv, 0x419a00, 0xf0);
+        nv_wr32(priv, 0x419a04, 0x1);
+        nv_wr32(priv, 0x419a08, 0x21);
+        nv_wr32(priv, 0x419a0c, 0x20000);
+        nv_wr32(priv, 0x419a10, 0x0);
+        nv_wr32(priv, 0x419a14, 0x200);
+        nv_wr32(priv, 0x419a1c, 0xc000);
+        nv_wr32(priv, 0x419a20, 0x800);
+        nv_wr32(priv, 0x419a30, 0x1);
+        nv_wr32(priv, 0x419ac4, 0x37f440);
+        nv_wr32(priv, 0x419c00, 0xa);
+        nv_wr32(priv, 0x419c04, 0x80000006);
+        nv_wr32(priv, 0x419c08, 0x2);
+        nv_wr32(priv, 0x419c20, 0x0);
+        nv_wr32(priv, 0x419c24, 0x84210);
+        nv_wr32(priv, 0x419c28, 0x3efbefbe);
+        nv_wr32(priv, 0x419ce8, 0x0);
+        nv_wr32(priv, 0x419cf4, 0x3203);
+        nv_wr32(priv, 0x419e04, 0x0);
+        nv_wr32(priv, 0x419e08, 0x0);
+        nv_wr32(priv, 0x419e0c, 0x0);
+        nv_wr32(priv, 0x419e10, 0x402);
+        nv_wr32(priv, 0x419e44, 0x13eff2);
+        nv_wr32(priv, 0x419e48, 0x0);
+        nv_wr32(priv, 0x419e4c, 0x7f);
+        nv_wr32(priv, 0x419e50, 0x0);
+        nv_wr32(priv, 0x419e54, 0x0);
+        nv_wr32(priv, 0x419e58, 0x0);
+        nv_wr32(priv, 0x419e5c, 0x0);
+        nv_wr32(priv, 0x419e60, 0x0);
+        nv_wr32(priv, 0x419e64, 0x0);
+        nv_wr32(priv, 0x419e68, 0x0);
+        nv_wr32(priv, 0x419e6c, 0x0);
+        nv_wr32(priv, 0x419e70, 0x0);
+        nv_wr32(priv, 0x419e74, 0x0);
+        nv_wr32(priv, 0x419e78, 0x0);
+        nv_wr32(priv, 0x419e7c, 0x0);
+        nv_wr32(priv, 0x419e80, 0x0);
+        nv_wr32(priv, 0x419e84, 0x0);
+        nv_wr32(priv, 0x419e88, 0x0);
+        nv_wr32(priv, 0x419e8c, 0x0);
+        nv_wr32(priv, 0x419e90, 0x0);
+        nv_wr32(priv, 0x419e94, 0x0);
+        nv_wr32(priv, 0x419e98, 0x0);
+        nv_wr32(priv, 0x419eac, 0x1fcf);
+        nv_wr32(priv, 0x419eb0, 0xd3f);
+        nv_wr32(priv, 0x419ec8, 0x1304f);
+        nv_wr32(priv, 0x419f30, 0x0);
+        nv_wr32(priv, 0x419f34, 0x0);
+        nv_wr32(priv, 0x419f38, 0x0);
+        nv_wr32(priv, 0x419f3c, 0x0);
+        nv_wr32(priv, 0x419f40, 0x0);
+        nv_wr32(priv, 0x419f44, 0x0);
+        nv_wr32(priv, 0x419f48, 0x0);
+        nv_wr32(priv, 0x419f4c, 0x0);
+        nv_wr32(priv, 0x419f58, 0x0);
+        nv_wr32(priv, 0x419f78, 0xb);
+}
+
+static void
+nve0_graph_generate_tpcunk(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x41be24, 0x6);
+        nv_wr32(priv, 0x41bec0, 0x12180000);
+        nv_wr32(priv, 0x41bec4, 0x37f7f);
+        nv_wr32(priv, 0x41bee4, 0x6480430);
+        nv_wr32(priv, 0x41bf00, 0xa418820);
+        nv_wr32(priv, 0x41bf04, 0x62080e6);
+        nv_wr32(priv, 0x41bf08, 0x20398a4);
+        nv_wr32(priv, 0x41bf0c, 0xe629062);
+        nv_wr32(priv, 0x41bf10, 0xa418820);
+        nv_wr32(priv, 0x41bf14, 0xe6);
+        nv_wr32(priv, 0x41bfd0, 0x900103);
+        nv_wr32(priv, 0x41bfe0, 0x400001);
+        nv_wr32(priv, 0x41bfe4, 0x0);
+}
+
+int
+nve0_grctx_generate(struct nvc0_graph_priv *priv)
+{
+        struct nvc0_grctx info;
+        int ret, i, gpc, tpc, id;
+        u32 data[6] = {}, data2[2] = {}, tmp;
+        u32 tpc_set = 0, tpc_mask = 0;
+        u32 magic[GPC_MAX][2], offset;
+        u8 tpcnr[GPC_MAX], a, b;
+        u8 shift, ntpcv;
+
+        ret = nvc0_grctx_init(priv, &info);
+        if (ret)
+                return ret;
+
+        nv_mask(priv, 0x000260, 0x00000001, 0x00000000);
+        nv_wr32(priv, 0x400204, 0x00000000);
+        nv_wr32(priv, 0x400208, 0x00000000);
+
+        nve0_graph_generate_unk40xx(priv);
+        nve0_graph_generate_unk44xx(priv);
+        nve0_graph_generate_unk46xx(priv);
+        nve0_graph_generate_unk47xx(priv);
+        nve0_graph_generate_unk58xx(priv);
+        nve0_graph_generate_unk60xx(priv);
+        nve0_graph_generate_unk64xx(priv);
+        nve0_graph_generate_unk70xx(priv);
+        nve0_graph_generate_unk78xx(priv);
+        nve0_graph_generate_unk80xx(priv);
+        nve0_graph_generate_unk88xx(priv);
+        nve0_graph_generate_gpc(priv);
+        nve0_graph_generate_tpc(priv);
+        nve0_graph_generate_tpcunk(priv);
+
+        nv_wr32(priv, 0x404154, 0x0);
+
+        mmio_data(0x003000, 0x0100, NV_MEM_ACCESS_RW | NV_MEM_ACCESS_SYS);
+        mmio_data(0x008000, 0x0100, NV_MEM_ACCESS_RW | NV_MEM_ACCESS_SYS);
+        mmio_data(0x060000, 0x1000, NV_MEM_ACCESS_RW);
+        mmio_list(0x40800c, 0x00000000,  8, 1);
+        mmio_list(0x408010, 0x80000000,  0, 0);
+        mmio_list(0x419004, 0x00000000,  8, 1);
+        mmio_list(0x419008, 0x00000000,  0, 0);
+        mmio_list(0x4064cc, 0x80000000,  0, 0);
+        mmio_list(0x408004, 0x00000000,  8, 0);
+        mmio_list(0x408008, 0x80000030,  0, 0);
+        mmio_list(0x418808, 0x00000000,  8, 0);
+        mmio_list(0x41880c, 0x80000030,  0, 0);
+        mmio_list(0x4064c8, 0x01800600,  0, 0);
+        mmio_list(0x418810, 0x80000000, 12, 2);
+        mmio_list(0x419848, 0x10000000, 12, 2);
+        mmio_list(0x405830, 0x02180648,  0, 0);
+        mmio_list(0x4064c4, 0x0192ffff,  0, 0);
+        for (gpc = 0, offset = 0; gpc < priv->gpc_nr; gpc++) {
+                u16 magic0 = 0x0218 * priv->tpc_nr[gpc];
+                u16 magic1 = 0x0648 * priv->tpc_nr[gpc];
+                magic[gpc][0]  = 0x10000000 | (magic0 << 16) | offset;
+                magic[gpc][1]  = 0x00000000 | (magic1 << 16);
+                offset += 0x0324 * priv->tpc_nr[gpc];
+        }
+        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                mmio_list(GPC_UNIT(gpc, 0x30c0), magic[gpc][0], 0, 0);
+                mmio_list(GPC_UNIT(gpc, 0x30e4), magic[gpc][1] | offset, 0, 0);
+                offset += 0x07ff * priv->tpc_nr[gpc];
+        }
+        mmio_list(0x17e91c, 0x06060609, 0, 0);
+        mmio_list(0x17e920, 0x00090a05, 0, 0);
+
+        nv_wr32(priv, 0x418c6c, 0x1);
+        nv_wr32(priv, 0x41980c, 0x10);
+        nv_wr32(priv, 0x41be08, 0x4);
+        nv_wr32(priv, 0x4064c0, 0x801a00f0);
+        nv_wr32(priv, 0x405800, 0xf8000bf);
+        nv_wr32(priv, 0x419c00, 0xa);
+
+        for (tpc = 0, id = 0; tpc < 4; tpc++) {
+                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                        if (tpc < priv->tpc_nr[gpc]) {
+                                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0698), id);
+                                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x04e8), id);
+                                nv_wr32(priv, GPC_UNIT(gpc, 0x0c10 + tpc * 4), id);
+                                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0088), id++);
+                        }
+
+                        nv_wr32(priv, GPC_UNIT(gpc, 0x0c08), priv->tpc_nr[gpc]);
+                        nv_wr32(priv, GPC_UNIT(gpc, 0x0c8c), priv->tpc_nr[gpc]);
+                }
+        }
+
+        tmp = 0;
+        for (i = 0; i < priv->gpc_nr; i++)
+                tmp |= priv->tpc_nr[i] << (i * 4);
+        nv_wr32(priv, 0x406028, tmp);
+        nv_wr32(priv, 0x405870, tmp);
+
+        nv_wr32(priv, 0x40602c, 0x0);
+        nv_wr32(priv, 0x405874, 0x0);
+        nv_wr32(priv, 0x406030, 0x0);
+        nv_wr32(priv, 0x405878, 0x0);
+        nv_wr32(priv, 0x406034, 0x0);
+        nv_wr32(priv, 0x40587c, 0x0);
+
+        /* calculate first set of magics */
+        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+
+        gpc = -1;
+        for (tpc = 0; tpc < priv->tpc_total; tpc++) {
+                do {
+                        gpc = (gpc + 1) % priv->gpc_nr;
+                } while (!tpcnr[gpc]);
+                tpcnr[gpc]--;
+
+                data[tpc / 6] |= gpc << ((tpc % 6) * 5);
+        }
+
+        for (; tpc < 32; tpc++)
+                data[tpc / 6] |= 7 << ((tpc % 6) * 5);
+
+        /* and the second... */
+        shift = 0;
+        ntpcv = priv->tpc_total;
+        while (!(ntpcv & (1 << 4))) {
+                ntpcv <<= 1;
+                shift++;
+        }
+
+        data2[0]  = ntpcv << 16;
+        data2[0] |= shift << 21;
+        data2[0] |= (((1 << (0 + 5)) % ntpcv) << 24);
+        data2[0] |= priv->tpc_total << 8;
+        data2[0] |= priv->magic_not_rop_nr;
+        for (i = 1; i < 7; i++)
+                data2[1] |= ((1 << (i + 5)) % ntpcv) << ((i - 1) * 5);
+
+        /* and write it all the various parts of PGRAPH */
+        nv_wr32(priv, 0x418bb8, (priv->tpc_total << 8) | priv->magic_not_rop_nr);
+        for (i = 0; i < 6; i++)
+                nv_wr32(priv, 0x418b08 + (i * 4), data[i]);
+
+        nv_wr32(priv, 0x41bfd0, data2[0]);
+        nv_wr32(priv, 0x41bfe4, data2[1]);
+        for (i = 0; i < 6; i++)
+                nv_wr32(priv, 0x41bf00 + (i * 4), data[i]);
+
+        nv_wr32(priv, 0x4078bc, (priv->tpc_total << 8) | priv->magic_not_rop_nr);
+        for (i = 0; i < 6; i++)
+                nv_wr32(priv, 0x40780c + (i * 4), data[i]);
+
+
+        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+        for (gpc = 0; gpc < priv->gpc_nr; gpc++)
+                tpc_mask |= ((1 << priv->tpc_nr[gpc]) - 1) << (gpc * 8);
+
+        for (i = 0, gpc = -1, b = -1; i < 32; i++) {
+                a = (i * (priv->tpc_total - 1)) / 32;
+                if (a != b) {
+                        b = a;
+                        do {
+                                gpc = (gpc + 1) % priv->gpc_nr;
+                        } while (!tpcnr[gpc]);
+                        tpc = priv->tpc_nr[gpc] - tpcnr[gpc]--;
+
+                        tpc_set |= 1 << ((gpc * 8) + tpc);
+                }
+
+                nv_wr32(priv, 0x406800 + (i * 0x20), tpc_set);
+                nv_wr32(priv, 0x406c00 + (i * 0x20), tpc_set ^ tpc_mask);
+        }
+
+        for (i = 0; i < 8; i++)
+                nv_wr32(priv, 0x4064d0 + (i * 0x04), 0x00000000);
+
+        nv_wr32(priv, 0x405b00, 0x201);
+        nv_wr32(priv, 0x408850, 0x2);
+        nv_wr32(priv, 0x408958, 0x2);
+        nv_wr32(priv, 0x419f78, 0xa);
+
+        nve0_grctx_generate_icmd(priv);
+        nve0_grctx_generate_a097(priv);
+        nve0_grctx_generate_902d(priv);
+
+        nv_mask(priv, 0x000260, 0x00000001, 0x00000001);
+        nv_wr32(priv, 0x418800, 0x7026860a); //XXX
+        nv_wr32(priv, 0x41be10, 0x00bb8bc7); //XXX
+        return nvc0_grctx_fini(&info);
+}
diff --git a/drivers/gpu/drm/nouveau/nvc0_grgpc.fuc b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnvc0.fuc
index 15272be33b66..b86cc60dcd56 100644
--- a/drivers/gpu/drm/nouveau/nvc0_grgpc.fuc
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnvc0.fuc
@@ -24,7 +24,7 @@
  */
 
 /* To build:
- *    m4 nvc0_grgpc.fuc | envyas -a -w -m fuc -V nva3 -o nvc0_grgpc.fuc.h
+ *    m4 gpcnvc0.fuc | envyas -a -w -m fuc -V fuc3 -o gpcnvc0.fuc.h
  */
 
 /* TODO
@@ -33,7 +33,7 @@
  */
 
 .section #nvc0_grgpc_data
-include(`nvc0_graph.fuc')
+include(`nvc0.fuc')
 gpc_id:                 .b32 0
 gpc_mmio_list_head:     .b32 0
 gpc_mmio_list_tail:     .b32 0
@@ -209,11 +209,11 @@ nvd9_tpc_mmio_tail:
 .section #nvc0_grgpc_code
 bra #init
 define(`include_code')
-include(`nvc0_graph.fuc')
+include(`nvc0.fuc')
 
 // reports an exception to the host
 //
-// In: $r15 error code (see nvc0_graph.fuc)
+// In: $r15 error code (see nvc0.fuc)
 //
 error:
         push $r14
diff --git a/drivers/gpu/drm/nouveau/nvc0_grgpc.fuc.h b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnvc0.fuc.h
index a988b8ad00ac..96050ddb22ca 100644
--- a/drivers/gpu/drm/nouveau/nvc0_grgpc.fuc.h
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnvc0.fuc.h
@@ -1,11 +1,19 @@
 uint32_t nvc0_grgpc_data[] = {
+/* 0x0000: gpc_id */
         0x00000000,
+/* 0x0004: gpc_mmio_list_head */
         0x00000000,
+/* 0x0008: gpc_mmio_list_tail */
         0x00000000,
+/* 0x000c: tpc_count */
         0x00000000,
+/* 0x0010: tpc_mask */
         0x00000000,
+/* 0x0014: tpc_mmio_list_head */
         0x00000000,
+/* 0x0018: tpc_mmio_list_tail */
         0x00000000,
+/* 0x001c: cmd_queue */
         0x00000000,
         0x00000000,
         0x00000000,
@@ -24,6 +32,7 @@ uint32_t nvc0_grgpc_data[] = {
         0x00000000,
         0x00000000,
         0x00000000,
+/* 0x0064: chipsets */
         0x000000c0,
         0x012800c8,
         0x01e40194,
@@ -49,6 +58,7 @@ uint32_t nvc0_grgpc_data[] = {
         0x0194012c,
         0x025401f8,
         0x00000000,
+/* 0x00c8: nvc0_gpc_mmio_head */
         0x00000380,
         0x14000400,
         0x20000450,
@@ -73,7 +83,10 @@ uint32_t nvc0_grgpc_data[] = {
         0x00000c8c,
         0x08001000,
         0x00001014,
+/* 0x0128: nvc0_gpc_mmio_tail */
         0x00000c6c,
+/* 0x012c: nvc1_gpc_mmio_tail */
+/* 0x012c: nvd9_gpc_mmio_head */
         0x00000380,
         0x04000400,
         0x0800040c,
@@ -100,6 +113,8 @@ uint32_t nvc0_grgpc_data[] = {
         0x00000c8c,
         0x08001000,
         0x00001014,
+/* 0x0194: nvd9_gpc_mmio_tail */
+/* 0x0194: nvc0_tpc_mmio_head */
         0x00000018,
         0x0000003c,
         0x00000048,
@@ -120,11 +135,16 @@ uint32_t nvc0_grgpc_data[] = {
         0x4c000644,
         0x00000698,
         0x04000750,
+/* 0x01e4: nvc0_tpc_mmio_tail */
         0x00000758,
         0x000002c4,
         0x000006e0,
+/* 0x01f0: nvcf_tpc_mmio_tail */
         0x000004bc,
+/* 0x01f4: nvc3_tpc_mmio_tail */
         0x00000544,
+/* 0x01f8: nvc1_tpc_mmio_tail */
+/* 0x01f8: nvd9_tpc_mmio_head */
         0x00000018,
         0x0000003c,
         0x00000048,
@@ -152,12 +172,14 @@ uint32_t nvc0_grgpc_data[] = {
 
 uint32_t nvc0_grgpc_code[] = {
         0x03060ef5,
+/* 0x0004: queue_put */
         0x9800d898,
         0x86f001d9,
         0x0489b808,
         0xf00c1bf4,
         0x21f502f7,
         0x00f802ec,
+/* 0x001c: queue_put_next */
         0xb60798c4,
         0x8dbb0384,
         0x0880b600,
@@ -165,6 +187,7 @@ uint32_t nvc0_grgpc_code[] = {
         0x90b6018f,
         0x0f94f001,
         0xf801d980,
+/* 0x0039: queue_get */
         0x0131f400,
         0x9800d898,
         0x89b801d9,
@@ -176,37 +199,46 @@ uint32_t nvc0_grgpc_code[] = {
         0x80b6019f,
         0x0f84f001,
         0xf400d880,
+/* 0x0066: queue_get_done */
         0x00f80132,
+/* 0x0068: nv_rd32 */
         0x0728b7f1,
         0xb906b4b6,
         0xc9f002ec,
         0x00bcd01f,
+/* 0x0078: nv_rd32_wait */
         0xc800bccf,
         0x1bf41fcc,
         0x06a7f0fa,
         0x010321f5,
         0xf840bfcf,
+/* 0x008d: nv_wr32 */
         0x28b7f100,
         0x06b4b607,
         0xb980bfd0,
         0xc9f002ec,
         0x1ec9f01f,
+/* 0x00a3: nv_wr32_wait */
         0xcf00bcd0,
         0xccc800bc,
         0xfa1bf41f,
+/* 0x00ae: watchdog_reset */
         0x87f100f8,
         0x84b60430,
         0x1ff9f006,
         0xf8008fd0,
+/* 0x00bd: watchdog_clear */
         0x3087f100,
         0x0684b604,
         0xf80080d0,
+/* 0x00c9: wait_donez */
         0x3c87f100,
         0x0684b608,
         0x99f094bd,
         0x0089d000,
         0x081887f1,
         0xd00684b6,
+/* 0x00e2: wait_done_wait_donez */
         0x87f1008a,
         0x84b60400,
         0x0088cf06,
@@ -215,6 +247,7 @@ uint32_t nvc0_grgpc_code[] = {
         0x84b6085c,
         0xf094bd06,
         0x89d00099,
+/* 0x0103: wait_doneo */
         0xf100f800,
         0xb6083c87,
         0x94bd0684,
@@ -222,6 +255,7 @@ uint32_t nvc0_grgpc_code[] = {
         0x87f10089,
         0x84b60818,
         0x008ad006,
+/* 0x011c: wait_done_wait_doneo */
         0x040087f1,
         0xcf0684b6,
         0x8aff0088,
@@ -230,6 +264,8 @@ uint32_t nvc0_grgpc_code[] = {
         0xbd0684b6,
         0x0099f094,
         0xf80089d0,
+/* 0x013d: mmctx_size */
+/* 0x013f: nv_mmctx_size_loop */
         0x9894bd00,
         0x85b600e8,
         0x0180b61a,
@@ -238,6 +274,7 @@ uint32_t nvc0_grgpc_code[] = {
         0x04efb804,
         0xb9eb1bf4,
         0x00f8029f,
+/* 0x015c: mmctx_xfer */
         0x083c87f1,
         0xbd0684b6,
         0x0199f094,
@@ -247,9 +284,11 @@ uint32_t nvc0_grgpc_code[] = {
         0xf405bbfd,
         0x8bd0090b,
         0x0099f000,
+/* 0x0180: mmctx_base_disabled */
         0xf405eefd,
         0x8ed00c0b,
         0xc08fd080,
+/* 0x018f: mmctx_multi_disabled */
         0xb70199f0,
         0xc8010080,
         0xb4b600ab,
@@ -257,6 +296,8 @@ uint32_t nvc0_grgpc_code[] = {
         0xb601aec8,
         0xbefd11e4,
         0x008bd005,
+/* 0x01a8: mmctx_exec_loop */
+/* 0x01a8: mmctx_wait_free */
         0xf0008ecf,
         0x0bf41fe4,
         0x00ce98fa,
@@ -265,34 +306,42 @@ uint32_t nvc0_grgpc_code[] = {
         0x04cdb804,
         0xc8e81bf4,
         0x1bf402ab,
+/* 0x01c9: mmctx_fini_wait */
         0x008bcf18,
         0xb01fb4f0,
         0x1bf410b4,
         0x02a7f0f7,
         0xf4c921f4,
+/* 0x01de: mmctx_stop */
         0xabc81b0e,
         0x10b4b600,
         0xf00cb9f0,
         0x8bd012b9,
+/* 0x01ed: mmctx_stop_wait */
         0x008bcf00,
         0xf412bbc8,
+/* 0x01f6: mmctx_done */
         0x87f1fa1b,
         0x84b6085c,
         0xf094bd06,
         0x89d00199,
+/* 0x0207: strand_wait */
         0xf900f800,
         0x02a7f0a0,
         0xfcc921f4,
+/* 0x0213: strand_pre */
         0xf100f8a0,
         0xf04afc87,
         0x97f00283,
         0x0089d00c,
         0x020721f5,
+/* 0x0226: strand_post */
         0x87f100f8,
         0x83f04afc,
         0x0d97f002,
         0xf50089d0,
         0xf8020721,
+/* 0x0239: strand_set */
         0xfca7f100,
         0x02a3f04f,
         0x0500aba2,
@@ -303,6 +352,7 @@ uint32_t nvc0_grgpc_code[] = {
         0xf000aed0,
         0xbcd00ac7,
         0x0721f500,
+/* 0x0263: strand_ctx_init */
         0xf100f802,
         0xb6083c87,
         0x94bd0684,
@@ -325,6 +375,7 @@ uint32_t nvc0_grgpc_code[] = {
         0x0684b608,
         0xb70089cf,
         0x95220080,
+/* 0x02ba: ctx_init_strand_loop */
         0x8ed008fe,
         0x408ed000,
         0xb6808acf,
@@ -338,12 +389,14 @@ uint32_t nvc0_grgpc_code[] = {
         0x94bd0684,
         0xd00399f0,
         0x00f80089,
+/* 0x02ec: error */
         0xe7f1e0f9,
         0xe3f09814,
         0x8d21f440,
         0x041ce0b7,
         0xf401f7f0,
         0xe0fc8d21,
+/* 0x0306: init */
         0x04bd00f8,
         0xf10004fe,
         0xf0120017,
@@ -366,11 +419,13 @@ uint32_t nvc0_grgpc_code[] = {
         0x27f10002,
         0x24b60800,
         0x0022cf06,
+/* 0x035f: init_find_chipset */
         0xb65817f0,
         0x13980c10,
         0x0432b800,
         0xb00b0bf4,
         0x1bf40034,
+/* 0x0373: init_context */
         0xf100f8f1,
         0xb6080027,
         0x22cf0624,
@@ -407,6 +462,7 @@ uint32_t nvc0_grgpc_code[] = {
         0x0010b740,
         0xf024bd08,
         0x12d01f29,
+/* 0x0401: main */
         0x0031f400,
         0xf00028f4,
         0x21f41cd7,
@@ -419,9 +475,11 @@ uint32_t nvc0_grgpc_code[] = {
         0xfe051efd,
         0x21f50018,
         0x0ef404c3,
+/* 0x0431: main_not_ctx_xfer */
         0x10ef94d3,
         0xf501f5f0,
         0xf402ec21,
+/* 0x043e: ih */
         0x80f9c60e,
         0xf90188fe,
         0xf990f980,
@@ -436,30 +494,36 @@ uint32_t nvc0_grgpc_code[] = {
         0xb0b70421,
         0xe7f00400,
         0x00bed001,
+/* 0x0474: ih_no_fifo */
         0xfc400ad0,
         0xfce0fcf0,
         0xfcb0fcd0,
         0xfc90fca0,
         0x0088fe80,
         0x32f480fc,
+/* 0x048f: hub_barrier_done */
         0xf001f800,
         0x0e9801f7,
         0x04febb00,
         0x9418e7f1,
         0xf440e3f0,
         0x00f88d21,
+/* 0x04a4: ctx_redswitch */
         0x0614e7f1,
         0xf006e4b6,
         0xefd020f7,
         0x08f7f000,
+/* 0x04b4: ctx_redswitch_delay */
         0xf401f2b6,
         0xf7f1fd1b,
         0xefd00a20,
+/* 0x04c3: ctx_xfer */
         0xf100f800,
         0xb60a0417,
         0x1fd00614,
         0x0711f400,
         0x04a421f5,
+/* 0x04d4: ctx_xfer_not_load */
         0x4afc17f1,
         0xf00213f0,
         0x12d00c27,
@@ -489,11 +553,13 @@ uint32_t nvc0_grgpc_code[] = {
         0x5c21f508,
         0x0721f501,
         0x0601f402,
+/* 0x054b: ctx_xfer_post */
         0xf11412f4,
         0xf04afc17,
         0x27f00213,
         0x0012d00d,
         0x020721f5,
+/* 0x055c: ctx_xfer_done */
         0x048f21f5,
         0x000000f8,
         0x00000000,
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnve0.fuc b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnve0.fuc
new file mode 100644
index 000000000000..7b715fda2763
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnve0.fuc
@@ -0,0 +1,451 @@
+/* fuc microcode for nve0 PGRAPH/GPC
+ *
+ * Copyright 2011 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
+ */
+
+/* To build:
+ *    m4 nve0_grgpc.fuc | envyas -a -w -m fuc -V nva3 -o nve0_grgpc.fuc.h
+ */
+
+/* TODO
+ * - bracket certain functions with scratch writes, useful for debugging
+ * - watchdog timer around ctx operations
+ */
+
+.section #nve0_grgpc_data
+include(`nve0.fuc')
+gpc_id:                 .b32 0
+gpc_mmio_list_head:     .b32 0
+gpc_mmio_list_tail:     .b32 0
+
+tpc_count:              .b32 0
+tpc_mask:               .b32 0
+tpc_mmio_list_head:     .b32 0
+tpc_mmio_list_tail:     .b32 0
+
+cmd_queue:              queue_init
+
+// chipset descriptions
+chipsets:
+.b8  0xe4 0 0 0
+.b16 #nve4_gpc_mmio_head
+.b16 #nve4_gpc_mmio_tail
+.b16 #nve4_tpc_mmio_head
+.b16 #nve4_tpc_mmio_tail
+.b8  0xe7 0 0 0
+.b16 #nve4_gpc_mmio_head
+.b16 #nve4_gpc_mmio_tail
+.b16 #nve4_tpc_mmio_head
+.b16 #nve4_tpc_mmio_tail
+.b8  0 0 0 0
+
+// GPC mmio lists
+nve4_gpc_mmio_head:
+mmctx_data(0x000380, 1)
+mmctx_data(0x000400, 2)
+mmctx_data(0x00040c, 3)
+mmctx_data(0x000450, 9)
+mmctx_data(0x000600, 1)
+mmctx_data(0x000684, 1)
+mmctx_data(0x000700, 5)
+mmctx_data(0x000800, 1)
+mmctx_data(0x000808, 3)
+mmctx_data(0x000828, 1)
+mmctx_data(0x000830, 1)
+mmctx_data(0x0008d8, 1)
+mmctx_data(0x0008e0, 1)
+mmctx_data(0x0008e8, 6)
+mmctx_data(0x00091c, 1)
+mmctx_data(0x000924, 3)
+mmctx_data(0x000b00, 1)
+mmctx_data(0x000b08, 6)
+mmctx_data(0x000bb8, 1)
+mmctx_data(0x000c08, 1)
+mmctx_data(0x000c10, 8)
+mmctx_data(0x000c40, 1)
+mmctx_data(0x000c6c, 1)
+mmctx_data(0x000c80, 1)
+mmctx_data(0x000c8c, 1)
+mmctx_data(0x001000, 3)
+mmctx_data(0x001014, 1)
+mmctx_data(0x003024, 1)
+mmctx_data(0x0030c0, 2)
+mmctx_data(0x0030e4, 1)
+mmctx_data(0x003100, 6)
+mmctx_data(0x0031d0, 1)
+mmctx_data(0x0031e0, 2)
+nve4_gpc_mmio_tail:
+
+// TPC mmio lists
+nve4_tpc_mmio_head:
+mmctx_data(0x000048, 1)
+mmctx_data(0x000064, 1)
+mmctx_data(0x000088, 1)
+mmctx_data(0x000200, 6)
+mmctx_data(0x00021c, 2)
+mmctx_data(0x000230, 1)
+mmctx_data(0x0002c4, 1)
+mmctx_data(0x000400, 3)
+mmctx_data(0x000420, 3)
+mmctx_data(0x0004e8, 1)
+mmctx_data(0x0004f4, 1)
+mmctx_data(0x000604, 4)
+mmctx_data(0x000644, 22)
+mmctx_data(0x0006ac, 2)
+mmctx_data(0x0006c8, 1)
+mmctx_data(0x000730, 8)
+mmctx_data(0x000758, 1)
+mmctx_data(0x000778, 1)
+nve4_tpc_mmio_tail:
+
+.section #nve0_grgpc_code
+bra #init
+define(`include_code')
+include(`nve0.fuc')
+
+// reports an exception to the host
+//
+// In: $r15 error code (see nve0.fuc)
+//
+error:
+        push $r14
+        mov $r14 -0x67ec        // 0x9814
+        sethi $r14 0x400000
+        call #nv_wr32           // HUB_CTXCTL_CC_SCRATCH[5] = error code
+        add b32 $r14 0x41c
+        mov $r15 1
+        call #nv_wr32           // HUB_CTXCTL_INTR_UP_SET
+        pop $r14
+        ret
+
+// GPC fuc initialisation, executed by triggering ucode start, will
+// fall through to main loop after completion.
+//
+// Input:
+//   CC_SCRATCH[0]: chipset (PMC_BOOT_0 read returns 0x0bad0bad... sigh)
+//   CC_SCRATCH[1]: context base
+//
+// Output:
+//   CC_SCRATCH[0]:
+//           31:31: set to signal completion
+//   CC_SCRATCH[1]:
+//            31:0: GPC context size
+//
+init:
+        clear b32 $r0
+        mov $sp $r0
+
+        // enable fifo access
+        mov $r1 0x1200
+        mov $r2 2
+        iowr I[$r1 + 0x000] $r2         // FIFO_ENABLE
+
+        // setup i0 handler, and route all interrupts to it
+        mov $r1 #ih
+        mov $iv0 $r1
+        mov $r1 0x400
+        iowr I[$r1 + 0x300] $r0         // INTR_DISPATCH
+
+        // enable fifo interrupt
+        mov $r2 4
+        iowr I[$r1 + 0x000] $r2         // INTR_EN_SET
+
+        // enable interrupts
+        bset $flags ie0
+
+        // figure out which GPC we are, and how many TPCs we have
+        mov $r1 0x608
+        shl b32 $r1 6
+        iord $r2 I[$r1 + 0x000]         // UNITS
+        mov $r3 1
+        and $r2 0x1f
+        shl b32 $r3 $r2
+        sub b32 $r3 1
+        st b32 D[$r0 + #tpc_count] $r2
+        st b32 D[$r0 + #tpc_mask] $r3
+        add b32 $r1 0x400
+        iord $r2 I[$r1 + 0x000]         // MYINDEX
+        st b32 D[$r0 + #gpc_id] $r2
+
+        // find context data for this chipset
+        mov $r2 0x800
+        shl b32 $r2 6
+        iord $r2 I[$r2 + 0x000]         // CC_SCRATCH[0]
+        mov $r1 #chipsets - 12
+        init_find_chipset:
+                add b32 $r1 12
+                ld b32 $r3 D[$r1 + 0x00]
+                cmpu b32 $r3 $r2
+                bra e #init_context
+                cmpu b32 $r3 0
+                bra ne #init_find_chipset
+                // unknown chipset
+                ret
+
+        // initialise context base, and size tracking
+        init_context:
+        mov $r2 0x800
+        shl b32 $r2 6
+        iord $r2 I[$r2 + 0x100] // CC_SCRATCH[1], initial base
+        clear b32 $r3           // track GPC context size here
+
+        // set mmctx base addresses now so we don't have to do it later,
+        // they don't currently ever change
+        mov $r4 0x700
+        shl b32 $r4 6
+        shr b32 $r5 $r2 8
+        iowr I[$r4 + 0x000] $r5         // MMCTX_SAVE_SWBASE
+        iowr I[$r4 + 0x100] $r5         // MMCTX_LOAD_SWBASE
+
+        // calculate GPC mmio context size, store the chipset-specific
+        // mmio list pointers somewhere we can get at them later without
+        // re-parsing the chipset list
+        clear b32 $r14
+        clear b32 $r15
+        ld b16 $r14 D[$r1 + 4]
+        ld b16 $r15 D[$r1 + 6]
+        st b16 D[$r0 + #gpc_mmio_list_head] $r14
+        st b16 D[$r0 + #gpc_mmio_list_tail] $r15
+        call #mmctx_size
+        add b32 $r2 $r15
+        add b32 $r3 $r15
+
+        // calculate per-TPC mmio context size, store the list pointers
+        ld b16 $r14 D[$r1 + 8]
+        ld b16 $r15 D[$r1 + 10]
+        st b16 D[$r0 + #tpc_mmio_list_head] $r14
+        st b16 D[$r0 + #tpc_mmio_list_tail] $r15
+        call #mmctx_size
+        ld b32 $r14 D[$r0 + #tpc_count]
+        mulu $r14 $r15
+        add b32 $r2 $r14
+        add b32 $r3 $r14
+
+        // round up base/size to 256 byte boundary (for strand SWBASE)
+        add b32 $r4 0x1300
+        shr b32 $r3 2
+        iowr I[$r4 + 0x000] $r3         // MMCTX_LOAD_COUNT, wtf for?!?
+        shr b32 $r2 8
+        shr b32 $r3 6
+        add b32 $r2 1
+        add b32 $r3 1
+        shl b32 $r2 8
+        shl b32 $r3 8
+
+        // calculate size of strand context data
+        mov b32 $r15 $r2
+        call #strand_ctx_init
+        add b32 $r3 $r15
+
+        // save context size, and tell HUB we're done
+        mov $r1 0x800
+        shl b32 $r1 6
+        iowr I[$r1 + 0x100] $r3         // CC_SCRATCH[1]  = context size
+        add b32 $r1 0x800
+        clear b32 $r2
+        bset $r2 31
+        iowr I[$r1 + 0x000] $r2         // CC_SCRATCH[0] |= 0x80000000
+
+// Main program loop, very simple, sleeps until woken up by the interrupt
+// handler, pulls a command from the queue and executes its handler
+//
+main:
+        bset $flags $p0
+        sleep $p0
+        mov $r13 #cmd_queue
+        call #queue_get
+        bra $p1 #main
+
+        // 0x0000-0x0003 are all context transfers
+        cmpu b32 $r14 0x04
+        bra nc #main_not_ctx_xfer
+                // fetch $flags and mask off $p1/$p2
+                mov $r1 $flags
+                mov $r2 0x0006
+                not b32 $r2
+                and $r1 $r2
+                // set $p1/$p2 according to transfer type
+                shl b32 $r14 1
+                or $r1 $r14
+                mov $flags $r1
+                // transfer context data
+                call #ctx_xfer
+                bra #main
+
+        main_not_ctx_xfer:
+        shl b32 $r15 $r14 16
+        or $r15 E_BAD_COMMAND
+        call #error
+        bra #main
+
+// interrupt handler
+ih:
+        push $r8
+        mov $r8 $flags
+        push $r8
+        push $r9
+        push $r10
+        push $r11
+        push $r13
+        push $r14
+        push $r15
+
+        // incoming fifo command?
+        iord $r10 I[$r0 + 0x200]        // INTR
+        and $r11 $r10 0x00000004
+        bra e #ih_no_fifo
+                // queue incoming fifo command for later processing
+                mov $r11 0x1900
+                mov $r13 #cmd_queue
+                iord $r14 I[$r11 + 0x100]       // FIFO_CMD
+                iord $r15 I[$r11 + 0x000]       // FIFO_DATA
+                call #queue_put
+                add b32 $r11 0x400
+                mov $r14 1
+                iowr I[$r11 + 0x000] $r14       // FIFO_ACK
+
+        // ack, and wake up main()
+        ih_no_fifo:
+        iowr I[$r0 + 0x100] $r10        // INTR_ACK
+
+        pop $r15
+        pop $r14
+        pop $r13
+        pop $r11
+        pop $r10
+        pop $r9
+        pop $r8
+        mov $flags $r8
+        pop $r8
+        bclr $flags $p0
+        iret
+
+// Set this GPC's bit in HUB_BAR, used to signal completion of various
+// activities to the HUB fuc
+//
+hub_barrier_done:
+        mov $r15 1
+        ld b32 $r14 D[$r0 + #gpc_id]
+        shl b32 $r15 $r14
+        mov $r14 -0x6be8        // 0x409418 - HUB_BAR_SET
+        sethi $r14 0x400000
+        call #nv_wr32
+        ret
+
+// Disables various things, waits a bit, and re-enables them..
+//
+// Not sure how exactly this helps, perhaps "ENABLE" is not such a
+// good description for the bits we turn off?  Anyways, without this,
+// funny things happen.
+//
+ctx_redswitch:
+        mov $r14 0x614
+        shl b32 $r14 6
+        mov $r15 0x020
+        iowr I[$r14] $r15       // GPC_RED_SWITCH = POWER
+        mov $r15 8
+        ctx_redswitch_delay:
+                sub b32 $r15 1
+                bra ne #ctx_redswitch_delay
+        mov $r15 0xa20
+        iowr I[$r14] $r15       // GPC_RED_SWITCH = UNK11, ENABLE, POWER
+        ret
+
+// Transfer GPC context data between GPU and storage area
+//
+// In: $r15 context base address
+//     $p1 clear on save, set on load
+//     $p2 set if opposite direction done/will be done, so:
+//              on save it means: "a load will follow this save"
+//              on load it means: "a save preceeded this load"
+//
+ctx_xfer:
+        // set context base address
+        mov $r1 0xa04
+        shl b32 $r1 6
+        iowr I[$r1 + 0x000] $r15// MEM_BASE
+        bra not $p1 #ctx_xfer_not_load
+                call #ctx_redswitch
+        ctx_xfer_not_load:
+
+        // strands
+        mov $r1 0x4afc
+        sethi $r1 0x20000
+        mov $r2 0xc
+        iowr I[$r1] $r2         // STRAND_CMD(0x3f) = 0x0c
+        call #strand_wait
+        mov $r2 0x47fc
+        sethi $r2 0x20000
+        iowr I[$r2] $r0         // STRAND_FIRST_GENE(0x3f) = 0x00
+        xbit $r2 $flags $p1
+        add b32 $r2 3
+        iowr I[$r1] $r2         // STRAND_CMD(0x3f) = 0x03/0x04 (SAVE/LOAD)
+
+        // mmio context
+        xbit $r10 $flags $p1    // direction
+        or $r10 2               // first
+        mov $r11 0x0000
+        sethi $r11 0x500000
+        ld b32 $r12 D[$r0 + #gpc_id]
+        shl b32 $r12 15
+        add b32 $r11 $r12       // base = NV_PGRAPH_GPCn
+        ld b32 $r12 D[$r0 + #gpc_mmio_list_head]
+        ld b32 $r13 D[$r0 + #gpc_mmio_list_tail]
+        mov $r14 0              // not multi
+        call #mmctx_xfer
+
+        // per-TPC mmio context
+        xbit $r10 $flags $p1    // direction
+        or $r10 4               // last
+        mov $r11 0x4000
+        sethi $r11 0x500000     // base = NV_PGRAPH_GPC0_TPC0
+        ld b32 $r12 D[$r0 + #gpc_id]
+        shl b32 $r12 15
+        add b32 $r11 $r12       // base = NV_PGRAPH_GPCn_TPC0
+        ld b32 $r12 D[$r0 + #tpc_mmio_list_head]
+        ld b32 $r13 D[$r0 + #tpc_mmio_list_tail]
+        ld b32 $r15 D[$r0 + #tpc_mask]
+        mov $r14 0x800          // stride = 0x800
+        call #mmctx_xfer
+
+        // wait for strands to finish
+        call #strand_wait
+
+        // if load, or a save without a load following, do some
+        // unknown stuff that's done after finishing a block of
+        // strand commands
+        bra $p1 #ctx_xfer_post
+        bra not $p2 #ctx_xfer_done
+        ctx_xfer_post:
+                mov $r1 0x4afc
+                sethi $r1 0x20000
+                mov $r2 0xd
+                iowr I[$r1] $r2         // STRAND_CMD(0x3f) = 0x0d
+                call #strand_wait
+
+        // mark completion in HUB's barrier
+        ctx_xfer_done:
+        call #hub_barrier_done
+        ret
+
+.align 256
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnve0.fuc.h b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnve0.fuc.h
new file mode 100644
index 000000000000..26c2165bad0f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/gpcnve0.fuc.h
@@ -0,0 +1,530 @@
+uint32_t nve0_grgpc_data[] = {
+/* 0x0000: gpc_id */
+        0x00000000,
+/* 0x0004: gpc_mmio_list_head */
+        0x00000000,
+/* 0x0008: gpc_mmio_list_tail */
+        0x00000000,
+/* 0x000c: tpc_count */
+        0x00000000,
+/* 0x0010: tpc_mask */
+        0x00000000,
+/* 0x0014: tpc_mmio_list_head */
+        0x00000000,
+/* 0x0018: tpc_mmio_list_tail */
+        0x00000000,
+/* 0x001c: cmd_queue */
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+/* 0x0064: chipsets */
+        0x000000e4,
+        0x01040080,
+        0x014c0104,
+        0x000000e7,
+        0x01040080,
+        0x014c0104,
+        0x00000000,
+/* 0x0080: nve4_gpc_mmio_head */
+        0x00000380,
+        0x04000400,
+        0x0800040c,
+        0x20000450,
+        0x00000600,
+        0x00000684,
+        0x10000700,
+        0x00000800,
+        0x08000808,
+        0x00000828,
+        0x00000830,
+        0x000008d8,
+        0x000008e0,
+        0x140008e8,
+        0x0000091c,
+        0x08000924,
+        0x00000b00,
+        0x14000b08,
+        0x00000bb8,
+        0x00000c08,
+        0x1c000c10,
+        0x00000c40,
+        0x00000c6c,
+        0x00000c80,
+        0x00000c8c,
+        0x08001000,
+        0x00001014,
+        0x00003024,
+        0x040030c0,
+        0x000030e4,
+        0x14003100,
+        0x000031d0,
+        0x040031e0,
+/* 0x0104: nve4_gpc_mmio_tail */
+/* 0x0104: nve4_tpc_mmio_head */
+        0x00000048,
+        0x00000064,
+        0x00000088,
+        0x14000200,
+        0x0400021c,
+        0x00000230,
+        0x000002c4,
+        0x08000400,
+        0x08000420,
+        0x000004e8,
+        0x000004f4,
+        0x0c000604,
+        0x54000644,
+        0x040006ac,
+        0x000006c8,
+        0x1c000730,
+        0x00000758,
+        0x00000778,
+};
+
+uint32_t nve0_grgpc_code[] = {
+        0x03060ef5,
+/* 0x0004: queue_put */
+        0x9800d898,
+        0x86f001d9,
+        0x0489b808,
+        0xf00c1bf4,
+        0x21f502f7,
+        0x00f802ec,
+/* 0x001c: queue_put_next */
+        0xb60798c4,
+        0x8dbb0384,
+        0x0880b600,
+        0x80008e80,
+        0x90b6018f,
+        0x0f94f001,
+        0xf801d980,
+/* 0x0039: queue_get */
+        0x0131f400,
+        0x9800d898,
+        0x89b801d9,
+        0x210bf404,
+        0xb60789c4,
+        0x9dbb0394,
+        0x0890b600,
+        0x98009e98,
+        0x80b6019f,
+        0x0f84f001,
+        0xf400d880,
+/* 0x0066: queue_get_done */
+        0x00f80132,
+/* 0x0068: nv_rd32 */
+        0x0728b7f1,
+        0xb906b4b6,
+        0xc9f002ec,
+        0x00bcd01f,
+/* 0x0078: nv_rd32_wait */
+        0xc800bccf,
+        0x1bf41fcc,
+        0x06a7f0fa,
+        0x010321f5,
+        0xf840bfcf,
+/* 0x008d: nv_wr32 */
+        0x28b7f100,
+        0x06b4b607,
+        0xb980bfd0,
+        0xc9f002ec,
+        0x1ec9f01f,
+/* 0x00a3: nv_wr32_wait */
+        0xcf00bcd0,
+        0xccc800bc,
+        0xfa1bf41f,
+/* 0x00ae: watchdog_reset */
+        0x87f100f8,
+        0x84b60430,
+        0x1ff9f006,
+        0xf8008fd0,
+/* 0x00bd: watchdog_clear */
+        0x3087f100,
+        0x0684b604,
+        0xf80080d0,
+/* 0x00c9: wait_donez */
+        0x3c87f100,
+        0x0684b608,
+        0x99f094bd,
+        0x0089d000,
+        0x081887f1,
+        0xd00684b6,
+/* 0x00e2: wait_done_wait_donez */
+        0x87f1008a,
+        0x84b60400,
+        0x0088cf06,
+        0xf4888aff,
+        0x87f1f31b,
+        0x84b6085c,
+        0xf094bd06,
+        0x89d00099,
+/* 0x0103: wait_doneo */
+        0xf100f800,
+        0xb6083c87,
+        0x94bd0684,
+        0xd00099f0,
+        0x87f10089,
+        0x84b60818,
+        0x008ad006,
+/* 0x011c: wait_done_wait_doneo */
+        0x040087f1,
+        0xcf0684b6,
+        0x8aff0088,
+        0xf30bf488,
+        0x085c87f1,
+        0xbd0684b6,
+        0x0099f094,
+        0xf80089d0,
+/* 0x013d: mmctx_size */
+/* 0x013f: nv_mmctx_size_loop */
+        0x9894bd00,
+        0x85b600e8,
+        0x0180b61a,
+        0xbb0284b6,
+        0xe0b60098,
+        0x04efb804,
+        0xb9eb1bf4,
+        0x00f8029f,
+/* 0x015c: mmctx_xfer */
+        0x083c87f1,
+        0xbd0684b6,
+        0x0199f094,
+        0xf10089d0,
+        0xb6071087,
+        0x94bd0684,
+        0xf405bbfd,
+        0x8bd0090b,
+        0x0099f000,
+/* 0x0180: mmctx_base_disabled */
+        0xf405eefd,
+        0x8ed00c0b,
+        0xc08fd080,
+/* 0x018f: mmctx_multi_disabled */
+        0xb70199f0,
+        0xc8010080,
+        0xb4b600ab,
+        0x0cb9f010,
+        0xb601aec8,
+        0xbefd11e4,
+        0x008bd005,
+/* 0x01a8: mmctx_exec_loop */
+/* 0x01a8: mmctx_wait_free */
+        0xf0008ecf,
+        0x0bf41fe4,
+        0x00ce98fa,
+        0xd005e9fd,
+        0xc0b6c08e,
+        0x04cdb804,
+        0xc8e81bf4,
+        0x1bf402ab,
+/* 0x01c9: mmctx_fini_wait */
+        0x008bcf18,
+        0xb01fb4f0,
+        0x1bf410b4,
+        0x02a7f0f7,
+        0xf4c921f4,
+/* 0x01de: mmctx_stop */
+        0xabc81b0e,
+        0x10b4b600,
+        0xf00cb9f0,
+        0x8bd012b9,
+/* 0x01ed: mmctx_stop_wait */
+        0x008bcf00,
+        0xf412bbc8,
+/* 0x01f6: mmctx_done */
+        0x87f1fa1b,
+        0x84b6085c,
+        0xf094bd06,
+        0x89d00199,
+/* 0x0207: strand_wait */
+        0xf900f800,
+        0x02a7f0a0,
+        0xfcc921f4,
+/* 0x0213: strand_pre */
+        0xf100f8a0,
+        0xf04afc87,
+        0x97f00283,
+        0x0089d00c,
+        0x020721f5,
+/* 0x0226: strand_post */
+        0x87f100f8,
+        0x83f04afc,
+        0x0d97f002,
+        0xf50089d0,
+        0xf8020721,
+/* 0x0239: strand_set */
+        0xfca7f100,
+        0x02a3f04f,
+        0x0500aba2,
+        0xd00fc7f0,
+        0xc7f000ac,
+        0x00bcd00b,
+        0x020721f5,
+        0xf000aed0,
+        0xbcd00ac7,
+        0x0721f500,
+/* 0x0263: strand_ctx_init */
+        0xf100f802,
+        0xb6083c87,
+        0x94bd0684,
+        0xd00399f0,
+        0x21f50089,
+        0xe7f00213,
+        0x3921f503,
+        0xfca7f102,
+        0x02a3f046,
+        0x0400aba0,
+        0xf040a0d0,
+        0xbcd001c7,
+        0x0721f500,
+        0x010c9202,
+        0xf000acd0,
+        0xbcd002c7,
+        0x0721f500,
+        0x2621f502,
+        0x8087f102,
+        0x0684b608,
+        0xb70089cf,
+        0x95220080,
+/* 0x02ba: ctx_init_strand_loop */
+        0x8ed008fe,
+        0x408ed000,
+        0xb6808acf,
+        0xa0b606a5,
+        0x00eabb01,
+        0xb60480b6,
+        0x1bf40192,
+        0x08e4b6e8,
+        0xf1f2efbc,
+        0xb6085c87,
+        0x94bd0684,
+        0xd00399f0,
+        0x00f80089,
+/* 0x02ec: error */
+        0xe7f1e0f9,
+        0xe3f09814,
+        0x8d21f440,
+        0x041ce0b7,
+        0xf401f7f0,
+        0xe0fc8d21,
+/* 0x0306: init */
+        0x04bd00f8,
+        0xf10004fe,
+        0xf0120017,
+        0x12d00227,
+        0x3e17f100,
+        0x0010fe04,
+        0x040017f1,
+        0xf0c010d0,
+        0x12d00427,
+        0x1031f400,
+        0x060817f1,
+        0xcf0614b6,
+        0x37f00012,
+        0x1f24f001,
+        0xb60432bb,
+        0x02800132,
+        0x04038003,
+        0x040010b7,
+        0x800012cf,
+        0x27f10002,
+        0x24b60800,
+        0x0022cf06,
+/* 0x035f: init_find_chipset */
+        0xb65817f0,
+        0x13980c10,
+        0x0432b800,
+        0xb00b0bf4,
+        0x1bf40034,
+/* 0x0373: init_context */
+        0xf100f8f1,
+        0xb6080027,
+        0x22cf0624,
+        0xf134bd40,
+        0xb6070047,
+        0x25950644,
+        0x0045d008,
+        0xbd4045d0,
+        0x58f4bde4,
+        0x1f58021e,
+        0x020e4003,
+        0xf5040f40,
+        0xbb013d21,
+        0x3fbb002f,
+        0x041e5800,
+        0x40051f58,
+        0x0f400a0e,
+        0x3d21f50c,
+        0x030e9801,
+        0xbb00effd,
+        0x3ebb002e,
+        0x0040b700,
+        0x0235b613,
+        0xb60043d0,
+        0x35b60825,
+        0x0120b606,
+        0xb60130b6,
+        0x34b60824,
+        0x022fb908,
+        0x026321f5,
+        0xf1003fbb,
+        0xb6080017,
+        0x13d00614,
+        0x0010b740,
+        0xf024bd08,
+        0x12d01f29,
+/* 0x0401: main */
+        0x0031f400,
+        0xf00028f4,
+        0x21f41cd7,
+        0xf401f439,
+        0xf404e4b0,
+        0x81fe1e18,
+        0x0627f001,
+        0x12fd20bd,
+        0x01e4b604,
+        0xfe051efd,
+        0x21f50018,
+        0x0ef404c3,
+/* 0x0431: main_not_ctx_xfer */
+        0x10ef94d3,
+        0xf501f5f0,
+        0xf402ec21,
+/* 0x043e: ih */
+        0x80f9c60e,
+        0xf90188fe,
+        0xf990f980,
+        0xf9b0f9a0,
+        0xf9e0f9d0,
+        0x800acff0,
+        0xf404abc4,
+        0xb7f11d0b,
+        0xd7f01900,
+        0x40becf1c,
+        0xf400bfcf,
+        0xb0b70421,
+        0xe7f00400,
+        0x00bed001,
+/* 0x0474: ih_no_fifo */
+        0xfc400ad0,
+        0xfce0fcf0,
+        0xfcb0fcd0,
+        0xfc90fca0,
+        0x0088fe80,
+        0x32f480fc,
+/* 0x048f: hub_barrier_done */
+        0xf001f800,
+        0x0e9801f7,
+        0x04febb00,
+        0x9418e7f1,
+        0xf440e3f0,
+        0x00f88d21,
+/* 0x04a4: ctx_redswitch */
+        0x0614e7f1,
+        0xf006e4b6,
+        0xefd020f7,
+        0x08f7f000,
+/* 0x04b4: ctx_redswitch_delay */
+        0xf401f2b6,
+        0xf7f1fd1b,
+        0xefd00a20,
+/* 0x04c3: ctx_xfer */
+        0xf100f800,
+        0xb60a0417,
+        0x1fd00614,
+        0x0711f400,
+        0x04a421f5,
+/* 0x04d4: ctx_xfer_not_load */
+        0x4afc17f1,
+        0xf00213f0,
+        0x12d00c27,
+        0x0721f500,
+        0xfc27f102,
+        0x0223f047,
+        0xf00020d0,
+        0x20b6012c,
+        0x0012d003,
+        0xf001acf0,
+        0xb7f002a5,
+        0x50b3f000,
+        0xb6000c98,
+        0xbcbb0fc4,
+        0x010c9800,
+        0xf0020d98,
+        0x21f500e7,
+        0xacf0015c,
+        0x04a5f001,
+        0x4000b7f1,
+        0x9850b3f0,
+        0xc4b6000c,
+        0x00bcbb0f,
+        0x98050c98,
+        0x0f98060d,
+        0x00e7f104,
+        0x5c21f508,
+        0x0721f501,
+        0x0601f402,
+/* 0x054b: ctx_xfer_post */
+        0xf11412f4,
+        0xf04afc17,
+        0x27f00213,
+        0x0012d00d,
+        0x020721f5,
+/* 0x055c: ctx_xfer_done */
+        0x048f21f5,
+        0x000000f8,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+};
diff --git a/drivers/gpu/drm/nouveau/nvc0_grhub.fuc b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnvc0.fuc
index 98acddb2c5bb..acfc457654bd 100644
--- a/drivers/gpu/drm/nouveau/nvc0_grhub.fuc
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnvc0.fuc
@@ -24,11 +24,11 @@
  */
 
 /* To build:
- *    m4 nvc0_grhub.fuc | envyas -a -w -m fuc -V nva3 -o nvc0_grhub.fuc.h
+ *    m4 hubnvc0.fuc | envyas -a -w -m fuc -V fuc3 -o hubnvc0.fuc.h
  */
 
 .section #nvc0_grhub_data
-include(`nvc0_graph.fuc')
+include(`nvc0.fuc')
 gpc_count:              .b32 0
 rop_count:              .b32 0
 cmd_queue:              queue_init
@@ -161,11 +161,11 @@ xfer_data: 		.b32 0
 .section #nvc0_grhub_code
 bra #init
 define(`include_code')
-include(`nvc0_graph.fuc')
+include(`nvc0.fuc')
 
 // reports an exception to the host
 //
-// In: $r15 error code (see nvc0_graph.fuc)
+// In: $r15 error code (see nvc0.fuc)
 //
 error:
         push $r14
diff --git a/drivers/gpu/drm/nouveau/nvc0_grhub.fuc.h b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnvc0.fuc.h
index c5ed307abeb9..85a8d556f484 100644
--- a/drivers/gpu/drm/nouveau/nvc0_grhub.fuc.h
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnvc0.fuc.h
@@ -1,6 +1,9 @@
 uint32_t nvc0_grhub_data[] = {
+/* 0x0000: gpc_count */
         0x00000000,
+/* 0x0004: rop_count */
         0x00000000,
+/* 0x0008: cmd_queue */
         0x00000000,
         0x00000000,
         0x00000000,
@@ -19,9 +22,13 @@ uint32_t nvc0_grhub_data[] = {
         0x00000000,
         0x00000000,
         0x00000000,
+/* 0x0050: hub_mmio_list_head */
         0x00000000,
+/* 0x0054: hub_mmio_list_tail */
         0x00000000,
+/* 0x0058: ctx_current */
         0x00000000,
+/* 0x005c: chipsets */
         0x000000c0,
         0x013c00a0,
         0x000000c1,
@@ -39,6 +46,7 @@ uint32_t nvc0_grhub_data[] = {
         0x000000d9,
         0x01dc0140,
         0x00000000,
+/* 0x00a0: nvc0_hub_mmio_head */
         0x0417e91c,
         0x04400204,
         0x28404004,
@@ -78,7 +86,10 @@ uint32_t nvc0_grhub_data[] = {
         0x08408800,
         0x0c408900,
         0x00408980,
+/* 0x013c: nvc0_hub_mmio_tail */
         0x044064c0,
+/* 0x0140: nvc1_hub_mmio_tail */
+/* 0x0140: nvd9_hub_mmio_head */
         0x0417e91c,
         0x04400204,
         0x24404004,
@@ -118,6 +129,7 @@ uint32_t nvc0_grhub_data[] = {
         0x08408800,
         0x0c408900,
         0x00408980,
+/* 0x01dc: nvd9_hub_mmio_tail */
         0x00000000,
         0x00000000,
         0x00000000,
@@ -127,7 +139,10 @@ uint32_t nvc0_grhub_data[] = {
         0x00000000,
         0x00000000,
         0x00000000,
+/* 0x0200: chan_data */
+/* 0x0200: chan_mmio_count */
         0x00000000,
+/* 0x0204: chan_mmio_address */
         0x00000000,
         0x00000000,
         0x00000000,
@@ -191,17 +206,20 @@ uint32_t nvc0_grhub_data[] = {
         0x00000000,
         0x00000000,
         0x00000000,
+/* 0x0300: xfer_data */
         0x00000000,
 };
 
 uint32_t nvc0_grhub_code[] = {
         0x03090ef5,
+/* 0x0004: queue_put */
         0x9800d898,
         0x86f001d9,
         0x0489b808,
         0xf00c1bf4,
         0x21f502f7,
         0x00f802ec,
+/* 0x001c: queue_put_next */
         0xb60798c4,
         0x8dbb0384,
         0x0880b600,
@@ -209,6 +227,7 @@ uint32_t nvc0_grhub_code[] = {
         0x90b6018f,
         0x0f94f001,
         0xf801d980,
+/* 0x0039: queue_get */
         0x0131f400,
         0x9800d898,
         0x89b801d9,
@@ -220,37 +239,46 @@ uint32_t nvc0_grhub_code[] = {
         0x80b6019f,
         0x0f84f001,
         0xf400d880,
+/* 0x0066: queue_get_done */
         0x00f80132,
+/* 0x0068: nv_rd32 */
         0x0728b7f1,
         0xb906b4b6,
         0xc9f002ec,
         0x00bcd01f,
+/* 0x0078: nv_rd32_wait */
         0xc800bccf,
         0x1bf41fcc,
         0x06a7f0fa,
         0x010321f5,
         0xf840bfcf,
+/* 0x008d: nv_wr32 */
         0x28b7f100,
         0x06b4b607,
         0xb980bfd0,
         0xc9f002ec,
         0x1ec9f01f,
+/* 0x00a3: nv_wr32_wait */
         0xcf00bcd0,
         0xccc800bc,
         0xfa1bf41f,
+/* 0x00ae: watchdog_reset */
         0x87f100f8,
         0x84b60430,
         0x1ff9f006,
         0xf8008fd0,
+/* 0x00bd: watchdog_clear */
         0x3087f100,
         0x0684b604,
         0xf80080d0,
+/* 0x00c9: wait_donez */
         0x3c87f100,
         0x0684b608,
         0x99f094bd,
         0x0089d000,
         0x081887f1,
         0xd00684b6,
+/* 0x00e2: wait_done_wait_donez */
         0x87f1008a,
         0x84b60400,
         0x0088cf06,
@@ -259,6 +287,7 @@ uint32_t nvc0_grhub_code[] = {
         0x84b6085c,
         0xf094bd06,
         0x89d00099,
+/* 0x0103: wait_doneo */
         0xf100f800,
         0xb6083c87,
         0x94bd0684,
@@ -266,6 +295,7 @@ uint32_t nvc0_grhub_code[] = {
         0x87f10089,
         0x84b60818,
         0x008ad006,
+/* 0x011c: wait_done_wait_doneo */
         0x040087f1,
         0xcf0684b6,
         0x8aff0088,
@@ -274,6 +304,8 @@ uint32_t nvc0_grhub_code[] = {
         0xbd0684b6,
         0x0099f094,
         0xf80089d0,
+/* 0x013d: mmctx_size */
+/* 0x013f: nv_mmctx_size_loop */
         0x9894bd00,
         0x85b600e8,
         0x0180b61a,
@@ -282,6 +314,7 @@ uint32_t nvc0_grhub_code[] = {
         0x04efb804,
         0xb9eb1bf4,
         0x00f8029f,
+/* 0x015c: mmctx_xfer */
         0x083c87f1,
         0xbd0684b6,
         0x0199f094,
@@ -291,9 +324,11 @@ uint32_t nvc0_grhub_code[] = {
         0xf405bbfd,
         0x8bd0090b,
         0x0099f000,
+/* 0x0180: mmctx_base_disabled */
         0xf405eefd,
         0x8ed00c0b,
         0xc08fd080,
+/* 0x018f: mmctx_multi_disabled */
         0xb70199f0,
         0xc8010080,
         0xb4b600ab,
@@ -301,6 +336,8 @@ uint32_t nvc0_grhub_code[] = {
         0xb601aec8,
         0xbefd11e4,
         0x008bd005,
+/* 0x01a8: mmctx_exec_loop */
+/* 0x01a8: mmctx_wait_free */
         0xf0008ecf,
         0x0bf41fe4,
         0x00ce98fa,
@@ -309,34 +346,42 @@ uint32_t nvc0_grhub_code[] = {
         0x04cdb804,
         0xc8e81bf4,
         0x1bf402ab,
+/* 0x01c9: mmctx_fini_wait */
         0x008bcf18,
         0xb01fb4f0,
         0x1bf410b4,
         0x02a7f0f7,
         0xf4c921f4,
+/* 0x01de: mmctx_stop */
         0xabc81b0e,
         0x10b4b600,
         0xf00cb9f0,
         0x8bd012b9,
+/* 0x01ed: mmctx_stop_wait */
         0x008bcf00,
         0xf412bbc8,
+/* 0x01f6: mmctx_done */
         0x87f1fa1b,
         0x84b6085c,
         0xf094bd06,
         0x89d00199,
+/* 0x0207: strand_wait */
         0xf900f800,
         0x02a7f0a0,
         0xfcc921f4,
+/* 0x0213: strand_pre */
         0xf100f8a0,
         0xf04afc87,
         0x97f00283,
         0x0089d00c,
         0x020721f5,
+/* 0x0226: strand_post */
         0x87f100f8,
         0x83f04afc,
         0x0d97f002,
         0xf50089d0,
         0xf8020721,
+/* 0x0239: strand_set */
         0xfca7f100,
         0x02a3f04f,
         0x0500aba2,
@@ -347,6 +392,7 @@ uint32_t nvc0_grhub_code[] = {
         0xf000aed0,
         0xbcd00ac7,
         0x0721f500,
+/* 0x0263: strand_ctx_init */
         0xf100f802,
         0xb6083c87,
         0x94bd0684,
@@ -369,6 +415,7 @@ uint32_t nvc0_grhub_code[] = {
         0x0684b608,
         0xb70089cf,
         0x95220080,
+/* 0x02ba: ctx_init_strand_loop */
         0x8ed008fe,
         0x408ed000,
         0xb6808acf,
@@ -382,6 +429,7 @@ uint32_t nvc0_grhub_code[] = {
         0x94bd0684,
         0xd00399f0,
         0x00f80089,
+/* 0x02ec: error */
         0xe7f1e0f9,
         0xe4b60814,
         0x00efd006,
@@ -389,6 +437,7 @@ uint32_t nvc0_grhub_code[] = {
         0xf006e4b6,
         0xefd001f7,
         0xf8e0fc00,
+/* 0x0309: init */
         0xfe04bd00,
         0x07fe0004,
         0x0017f100,
@@ -429,11 +478,13 @@ uint32_t nvc0_grhub_code[] = {
         0x080027f1,
         0xcf0624b6,
         0xf7f00022,
+/* 0x03a9: init_find_chipset */
         0x08f0b654,
         0xb800f398,
         0x0bf40432,
         0x0034b00b,
         0xf8f11bf4,
+/* 0x03bd: init_context */
         0x0017f100,
         0x02fe5801,
         0xf003ff58,
@@ -454,6 +505,7 @@ uint32_t nvc0_grhub_code[] = {
         0x001fbb02,
         0xf1000398,
         0xf0200047,
+/* 0x040e: init_gpc */
         0x4ea05043,
         0x1fb90804,
         0x8d21f402,
@@ -467,6 +519,7 @@ uint32_t nvc0_grhub_code[] = {
         0xf7f00100,
         0x8d21f402,
         0x08004ea0,
+/* 0x0440: init_gpc_wait */
         0xc86821f4,
         0x0bf41fff,
         0x044ea0fa,
@@ -479,6 +532,7 @@ uint32_t nvc0_grhub_code[] = {
         0xb74021d0,
         0xbd080020,
         0x1f19f014,
+/* 0x0473: main */
         0xf40021d0,
         0x28f40031,
         0x08d7f000,
@@ -517,6 +571,7 @@ uint32_t nvc0_grhub_code[] = {
         0x94bd0684,
         0xd00699f0,
         0x0ef40089,
+/* 0x0509: chsw_prev_no_next */
         0xb920f931,
         0x32f40212,
         0x0232f401,
@@ -524,10 +579,12 @@ uint32_t nvc0_grhub_code[] = {
         0x17f120fc,
         0x14b60b00,
         0x0012d006,
+/* 0x0527: chsw_no_prev */
         0xc8130ef4,
         0x0bf41f23,
         0x0131f40d,
         0xf50232f4,
+/* 0x0537: chsw_done */
         0xf1082921,
         0xb60b0c17,
         0x27f00614,
@@ -536,10 +593,12 @@ uint32_t nvc0_grhub_code[] = {
         0xbd0684b6,
         0x0499f094,
         0xf50089d0,
+/* 0x0557: main_not_ctx_switch */
         0xb0ff200e,
         0x1bf401e4,
         0x02f2b90d,
         0x07b521f5,
+/* 0x0567: main_not_ctx_chan */
         0xb0420ef4,
         0x1bf402e4,
         0x3c87f12e,
@@ -553,14 +612,17 @@ uint32_t nvc0_grhub_code[] = {
         0xf094bd06,
         0x89d00799,
         0x110ef400,
+/* 0x0598: main_not_ctx_save */
         0xf010ef94,
         0x21f501f5,
         0x0ef502ec,
+/* 0x05a6: main_done */
         0x17f1fed1,
         0x14b60820,
         0xf024bd06,
         0x12d01f29,
         0xbe0ef500,
+/* 0x05b9: ih */
         0xfe80f9fe,
         0x80f90188,
         0xa0f990f9,
@@ -574,16 +636,19 @@ uint32_t nvc0_grhub_code[] = {
         0x21f400bf,
         0x00b0b704,
         0x01e7f004,
+/* 0x05ef: ih_no_fifo */
         0xe400bed0,
         0xf40100ab,
         0xd7f00d0b,
         0x01e7f108,
         0x0421f440,
+/* 0x0600: ih_no_ctxsw */
         0x0104b7f1,
         0xabffb0bd,
         0x0d0bf4b4,
         0x0c1ca7f1,
         0xd006a4b6,
+/* 0x0616: ih_no_other */
         0x0ad000ab,
         0xfcf0fc40,
         0xfcd0fce0,
@@ -591,32 +656,40 @@ uint32_t nvc0_grhub_code[] = {
         0xfe80fc90,
         0x80fc0088,
         0xf80032f4,
+/* 0x0631: ctx_4160s */
         0x60e7f101,
         0x40e3f041,
         0xf401f7f0,
+/* 0x063e: ctx_4160s_wait */
         0x21f48d21,
         0x04ffc868,
         0xf8fa0bf4,
+/* 0x0649: ctx_4160c */
         0x60e7f100,
         0x40e3f041,
         0x21f4f4bd,
+/* 0x0657: ctx_4170s */
         0xf100f88d,
         0xf04170e7,
         0xf5f040e3,
         0x8d21f410,
+/* 0x0666: ctx_4170w */
         0xe7f100f8,
         0xe3f04170,
         0x6821f440,
         0xf410f4f0,
         0x00f8f31b,
+/* 0x0678: ctx_redswitch */
         0x0614e7f1,
         0xf106e4b6,
         0xd00270f7,
         0xf7f000ef,
+/* 0x0689: ctx_redswitch_delay */
         0x01f2b608,
         0xf1fd1bf4,
         0xd00770f7,
         0x00f800ef,
+/* 0x0698: ctx_86c */
         0x086ce7f1,
         0xd006e4b6,
         0xe7f100ef,
@@ -625,6 +698,7 @@ uint32_t nvc0_grhub_code[] = {
         0xa86ce7f1,
         0xf441e3f0,
         0x00f88d21,
+/* 0x06b8: ctx_load */
         0x083c87f1,
         0xbd0684b6,
         0x0599f094,
@@ -639,6 +713,7 @@ uint32_t nvc0_grhub_code[] = {
         0x0614b60a,
         0xd00747f0,
         0x14d00012,
+/* 0x06f1: ctx_chan_wait_0 */
         0x4014cf40,
         0xf41f44f0,
         0x32d0fa1b,
@@ -688,6 +763,7 @@ uint32_t nvc0_grhub_code[] = {
         0xbd0684b6,
         0x0599f094,
         0xf80089d0,
+/* 0x07b5: ctx_chan */
         0x3121f500,
         0xb821f506,
         0x0ca7f006,
@@ -695,39 +771,48 @@ uint32_t nvc0_grhub_code[] = {
         0xb60a1017,
         0x27f00614,
         0x0012d005,
+/* 0x07d0: ctx_chan_wait */
         0xfd0012cf,
         0x1bf40522,
         0x4921f5fa,
+/* 0x07df: ctx_mmio_exec */
         0x9800f806,
         0x27f18103,
         0x24b60a04,
         0x0023d006,
+/* 0x07ee: ctx_mmio_loop */
         0x34c434bd,
         0x0f1bf4ff,
         0x030057f1,
         0xfa0653f0,
         0x03f80535,
+/* 0x0800: ctx_mmio_pull */
         0x98c04e98,
         0x21f4c14f,
         0x0830b68d,
         0xf40112b6,
+/* 0x0812: ctx_mmio_done */
         0x0398df1b,
         0x0023d016,
         0xf1800080,
         0xf0020017,
         0x01fa0613,
         0xf803f806,
+/* 0x0829: ctx_xfer */
         0x0611f400,
+/* 0x082f: ctx_xfer_pre */
         0xf01102f4,
         0x21f510f7,
         0x21f50698,
         0x11f40631,
+/* 0x083d: ctx_xfer_pre_load */
         0x02f7f01c,
         0x065721f5,
         0x066621f5,
         0x067821f5,
         0x21f5f4bd,
         0x21f50657,
+/* 0x0856: ctx_xfer_exec */
         0x019806b8,
         0x1427f116,
         0x0624b604,
@@ -762,9 +847,11 @@ uint32_t nvc0_grhub_code[] = {
         0x0a1017f1,
         0xf00614b6,
         0x12d00527,
+/* 0x08dd: ctx_xfer_post_save_wait */
         0x0012cf00,
         0xf40522fd,
         0x02f4fa1b,
+/* 0x08e9: ctx_xfer_post */
         0x02f7f032,
         0x065721f5,
         0x21f5f4bd,
@@ -776,7 +863,9 @@ uint32_t nvc0_grhub_code[] = {
         0x11fd8001,
         0x070bf405,
         0x07df21f5,
+/* 0x0914: ctx_xfer_no_post_mmio */
         0x064921f5,
+/* 0x0918: ctx_xfer_done */
         0x000000f8,
         0x00000000,
         0x00000000,
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnve0.fuc b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnve0.fuc
new file mode 100644
index 000000000000..138eeaa28665
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnve0.fuc
@@ -0,0 +1,780 @@
+/* fuc microcode for nve0 PGRAPH/HUB
+ *
+ * Copyright 2011 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
+ */
+
+/* To build:
+ *    m4 nve0_grhub.fuc | envyas -a -w -m fuc -V nva3 -o nve0_grhub.fuc.h
+ */
+
+.section #nve0_grhub_data
+include(`nve0.fuc')
+gpc_count:              .b32 0
+rop_count:              .b32 0
+cmd_queue:              queue_init
+hub_mmio_list_head:     .b32 0
+hub_mmio_list_tail:     .b32 0
+
+ctx_current:            .b32 0
+
+chipsets:
+.b8  0xe4 0 0 0
+.b16 #nve4_hub_mmio_head
+.b16 #nve4_hub_mmio_tail
+.b8  0xe7 0 0 0
+.b16 #nve4_hub_mmio_head
+.b16 #nve4_hub_mmio_tail
+.b8  0 0 0 0
+
+nve4_hub_mmio_head:
+mmctx_data(0x17e91c, 2)
+mmctx_data(0x400204, 2)
+mmctx_data(0x404010, 7)
+mmctx_data(0x4040a8, 9)
+mmctx_data(0x4040d0, 7)
+mmctx_data(0x4040f8, 1)
+mmctx_data(0x404130, 3)
+mmctx_data(0x404150, 3)
+mmctx_data(0x404164, 1)
+mmctx_data(0x4041a0, 4)
+mmctx_data(0x404200, 4)
+mmctx_data(0x404404, 14)
+mmctx_data(0x404460, 4)
+mmctx_data(0x404480, 1)
+mmctx_data(0x404498, 1)
+mmctx_data(0x404604, 4)
+mmctx_data(0x404618, 4)
+mmctx_data(0x40462c, 2)
+mmctx_data(0x404640, 1)
+mmctx_data(0x404654, 1)
+mmctx_data(0x404660, 1)
+mmctx_data(0x404678, 19)
+mmctx_data(0x4046c8, 3)
+mmctx_data(0x404700, 3)
+mmctx_data(0x404718, 10)
+mmctx_data(0x404744, 2)
+mmctx_data(0x404754, 1)
+mmctx_data(0x405800, 1)
+mmctx_data(0x405830, 3)
+mmctx_data(0x405854, 1)
+mmctx_data(0x405870, 4)
+mmctx_data(0x405a00, 2)
+mmctx_data(0x405a18, 1)
+mmctx_data(0x405b00, 1)
+mmctx_data(0x405b10, 1)
+mmctx_data(0x406020, 1)
+mmctx_data(0x406028, 4)
+mmctx_data(0x4064a8, 2)
+mmctx_data(0x4064b4, 2)
+mmctx_data(0x4064c0, 12)
+mmctx_data(0x4064fc, 1)
+mmctx_data(0x407040, 1)
+mmctx_data(0x407804, 1)
+mmctx_data(0x40780c, 6)
+mmctx_data(0x4078bc, 1)
+mmctx_data(0x408000, 7)
+mmctx_data(0x408064, 1)
+mmctx_data(0x408800, 3)
+mmctx_data(0x408840, 1)
+mmctx_data(0x408900, 3)
+mmctx_data(0x408980, 1)
+nve4_hub_mmio_tail:
+
+.align 256
+chan_data:
+chan_mmio_count:        .b32 0
+chan_mmio_address:      .b32 0
+
+.align 256
+xfer_data:              .b32 0
+
+.section #nve0_grhub_code
+bra #init
+define(`include_code')
+include(`nve0.fuc')
+
+// reports an exception to the host
+//
+// In: $r15 error code (see nve0.fuc)
+//
+error:
+        push $r14
+        mov $r14 0x814
+        shl b32 $r14 6
+        iowr I[$r14 + 0x000] $r15       // CC_SCRATCH[5] = error code
+        mov $r14 0xc1c
+        shl b32 $r14 6
+        mov $r15 1
+        iowr I[$r14 + 0x000] $r15       // INTR_UP_SET
+        pop $r14
+        ret
+
+// HUB fuc initialisation, executed by triggering ucode start, will
+// fall through to main loop after completion.
+//
+// Input:
+//   CC_SCRATCH[0]: chipset (PMC_BOOT_0 read returns 0x0bad0bad... sigh)
+//
+// Output:
+//   CC_SCRATCH[0]:
+//           31:31: set to signal completion
+//   CC_SCRATCH[1]:
+//            31:0: total PGRAPH context size
+//
+init:
+        clear b32 $r0
+        mov $sp $r0
+        mov $xdbase $r0
+
+        // enable fifo access
+        mov $r1 0x1200
+        mov $r2 2
+        iowr I[$r1 + 0x000] $r2 // FIFO_ENABLE
+
+        // setup i0 handler, and route all interrupts to it
+        mov $r1 #ih
+        mov $iv0 $r1
+        mov $r1 0x400
+        iowr I[$r1 + 0x300] $r0 // INTR_DISPATCH
+
+        // route HUB_CHANNEL_SWITCH to fuc interrupt 8
+        mov $r3 0x404
+        shl b32 $r3 6
+        mov $r2 0x2003          // { HUB_CHANNEL_SWITCH, ZERO } -> intr 8
+        iowr I[$r3 + 0x000] $r2
+
+        // not sure what these are, route them because NVIDIA does, and
+        // the IRQ handler will signal the host if we ever get one.. we
+        // may find out if/why we need to handle these if so..
+        //
+        mov $r2 0x2004
+        iowr I[$r3 + 0x004] $r2 // { 0x04, ZERO } -> intr 9
+        mov $r2 0x200b
+        iowr I[$r3 + 0x008] $r2 // { 0x0b, ZERO } -> intr 10
+        mov $r2 0x200c
+        iowr I[$r3 + 0x01c] $r2 // { 0x0c, ZERO } -> intr 15
+
+        // enable all INTR_UP interrupts
+        mov $r2 0xc24
+        shl b32 $r2 6
+        not b32 $r3 $r0
+        iowr I[$r2] $r3
+
+        // enable fifo, ctxsw, 9, 10, 15 interrupts
+        mov $r2 -0x78fc         // 0x8704
+        sethi $r2 0
+        iowr I[$r1 + 0x000] $r2 // INTR_EN_SET
+
+        // fifo level triggered, rest edge
+        sub b32 $r1 0x100
+        mov $r2 4
+        iowr I[$r1] $r2
+
+        // enable interrupts
+        bset $flags ie0
+
+        // fetch enabled GPC/ROP counts
+        mov $r14 -0x69fc        // 0x409604
+        sethi $r14 0x400000
+        call #nv_rd32
+        extr $r1 $r15 16:20
+        st b32 D[$r0 + #rop_count] $r1
+        and $r15 0x1f
+        st b32 D[$r0 + #gpc_count] $r15
+
+        // set BAR_REQMASK to GPC mask
+        mov $r1 1
+        shl b32 $r1 $r15
+        sub b32 $r1 1
+        mov $r2 0x40c
+        shl b32 $r2 6
+        iowr I[$r2 + 0x000] $r1
+        iowr I[$r2 + 0x100] $r1
+
+        // find context data for this chipset
+        mov $r2 0x800
+        shl b32 $r2 6
+        iord $r2 I[$r2 + 0x000]         // CC_SCRATCH[0]
+        mov $r15 #chipsets - 8
+        init_find_chipset:
+                add b32 $r15 8
+                ld b32 $r3 D[$r15 + 0x00]
+                cmpu b32 $r3 $r2
+                bra e #init_context
+                cmpu b32 $r3 0
+                bra ne #init_find_chipset
+                // unknown chipset
+                ret
+
+        // context size calculation, reserve first 256 bytes for use by fuc
+        init_context:
+        mov $r1 256
+
+        // calculate size of mmio context data
+        ld b16 $r14 D[$r15 + 4]
+        ld b16 $r15 D[$r15 + 6]
+        sethi $r14 0
+        st b32 D[$r0 + #hub_mmio_list_head] $r14
+        st b32 D[$r0 + #hub_mmio_list_tail] $r15
+        call #mmctx_size
+
+        // set mmctx base addresses now so we don't have to do it later,
+        // they don't (currently) ever change
+        mov $r3 0x700
+        shl b32 $r3 6
+        shr b32 $r4 $r1 8
+        iowr I[$r3 + 0x000] $r4         // MMCTX_SAVE_SWBASE
+        iowr I[$r3 + 0x100] $r4         // MMCTX_LOAD_SWBASE
+        add b32 $r3 0x1300
+        add b32 $r1 $r15
+        shr b32 $r15 2
+        iowr I[$r3 + 0x000] $r15        // MMCTX_LOAD_COUNT, wtf for?!?
+
+        // strands, base offset needs to be aligned to 256 bytes
+        shr b32 $r1 8
+        add b32 $r1 1
+        shl b32 $r1 8
+        mov b32 $r15 $r1
+        call #strand_ctx_init
+        add b32 $r1 $r15
+
+        // initialise each GPC in sequence by passing in the offset of its
+        // context data in GPCn_CC_SCRATCH[1], and starting its FUC (which
+        // has previously been uploaded by the host) running.
+        //
+        // the GPC fuc init sequence will set GPCn_CC_SCRATCH[0] bit 31
+        // when it has completed, and return the size of its context data
+        // in GPCn_CC_SCRATCH[1]
+        //
+        ld b32 $r3 D[$r0 + #gpc_count]
+        mov $r4 0x2000
+        sethi $r4 0x500000
+        init_gpc:
+                // setup, and start GPC ucode running
+                add b32 $r14 $r4 0x804
+                mov b32 $r15 $r1
+                call #nv_wr32                   // CC_SCRATCH[1] = ctx offset
+                add b32 $r14 $r4 0x800
+                mov b32 $r15 $r2
+                call #nv_wr32                   // CC_SCRATCH[0] = chipset
+                add b32 $r14 $r4 0x10c
+                clear b32 $r15
+                call #nv_wr32
+                add b32 $r14 $r4 0x104
+                call #nv_wr32                   // ENTRY
+                add b32 $r14 $r4 0x100
+                mov $r15 2                      // CTRL_START_TRIGGER
+                call #nv_wr32                   // CTRL
+
+                // wait for it to complete, and adjust context size
+                add b32 $r14 $r4 0x800
+                init_gpc_wait:
+                        call #nv_rd32
+                        xbit $r15 $r15 31
+                        bra e #init_gpc_wait
+                add b32 $r14 $r4 0x804
+                call #nv_rd32
+                add b32 $r1 $r15
+
+                // next!
+                add b32 $r4 0x8000
+                sub b32 $r3 1
+                bra ne #init_gpc
+
+        // save context size, and tell host we're ready
+        mov $r2 0x800
+        shl b32 $r2 6
+        iowr I[$r2 + 0x100] $r1         // CC_SCRATCH[1]  = context size
+        add b32 $r2 0x800
+        clear b32 $r1
+        bset $r1 31
+        iowr I[$r2 + 0x000] $r1         // CC_SCRATCH[0] |= 0x80000000
+
+// Main program loop, very simple, sleeps until woken up by the interrupt
+// handler, pulls a command from the queue and executes its handler
+//
+main:
+        // sleep until we have something to do
+        bset $flags $p0
+        sleep $p0
+        mov $r13 #cmd_queue
+        call #queue_get
+        bra $p1 #main
+
+        // context switch, requested by GPU?
+        cmpu b32 $r14 0x4001
+        bra ne #main_not_ctx_switch
+                trace_set(T_AUTO)
+                mov $r1 0xb00
+                shl b32 $r1 6
+                iord $r2 I[$r1 + 0x100]         // CHAN_NEXT
+                iord $r1 I[$r1 + 0x000]         // CHAN_CUR
+
+                xbit $r3 $r1 31
+                bra e #chsw_no_prev
+                        xbit $r3 $r2 31
+                        bra e #chsw_prev_no_next
+                                push $r2
+                                mov b32 $r2 $r1
+                                trace_set(T_SAVE)
+                                bclr $flags $p1
+                                bset $flags $p2
+                                call #ctx_xfer
+                                trace_clr(T_SAVE);
+                                pop $r2
+                                trace_set(T_LOAD);
+                                bset $flags $p1
+                                call #ctx_xfer
+                                trace_clr(T_LOAD);
+                                bra #chsw_done
+                        chsw_prev_no_next:
+                                push $r2
+                                mov b32 $r2 $r1
+                                bclr $flags $p1
+                                bclr $flags $p2
+                                call #ctx_xfer
+                                pop $r2
+                                mov $r1 0xb00
+                                shl b32 $r1 6
+                                iowr I[$r1] $r2
+                                bra #chsw_done
+                chsw_no_prev:
+                        xbit $r3 $r2 31
+                        bra e #chsw_done
+                                bset $flags $p1
+                                bclr $flags $p2
+                                call #ctx_xfer
+
+                // ack the context switch request
+                chsw_done:
+                mov $r1 0xb0c
+                shl b32 $r1 6
+                mov $r2 1
+                iowr I[$r1 + 0x000] $r2         // 0x409b0c
+                trace_clr(T_AUTO)
+                bra #main
+
+        // request to set current channel? (*not* a context switch)
+        main_not_ctx_switch:
+        cmpu b32 $r14 0x0001
+        bra ne #main_not_ctx_chan
+                mov b32 $r2 $r15
+                call #ctx_chan
+                bra #main_done
+
+        // request to store current channel context?
+        main_not_ctx_chan:
+        cmpu b32 $r14 0x0002
+        bra ne #main_not_ctx_save
+                trace_set(T_SAVE)
+                bclr $flags $p1
+                bclr $flags $p2
+                call #ctx_xfer
+                trace_clr(T_SAVE)
+                bra #main_done
+
+        main_not_ctx_save:
+                shl b32 $r15 $r14 16
+                or $r15 E_BAD_COMMAND
+                call #error
+                bra #main
+
+        main_done:
+        mov $r1 0x820
+        shl b32 $r1 6
+        clear b32 $r2
+        bset $r2 31
+        iowr I[$r1 + 0x000] $r2         // CC_SCRATCH[0] |= 0x80000000
+        bra #main
+
+// interrupt handler
+ih:
+        push $r8
+        mov $r8 $flags
+        push $r8
+        push $r9
+        push $r10
+        push $r11
+        push $r13
+        push $r14
+        push $r15
+
+        // incoming fifo command?
+        iord $r10 I[$r0 + 0x200]        // INTR
+        and $r11 $r10 0x00000004
+        bra e #ih_no_fifo
+                // queue incoming fifo command for later processing
+                mov $r11 0x1900
+                mov $r13 #cmd_queue
+                iord $r14 I[$r11 + 0x100]       // FIFO_CMD
+                iord $r15 I[$r11 + 0x000]       // FIFO_DATA
+                call #queue_put
+                add b32 $r11 0x400
+                mov $r14 1
+                iowr I[$r11 + 0x000] $r14       // FIFO_ACK
+
+        // context switch request?
+        ih_no_fifo:
+        and $r11 $r10 0x00000100
+        bra e #ih_no_ctxsw
+                // enqueue a context switch for later processing
+                mov $r13 #cmd_queue
+                mov $r14 0x4001
+                call #queue_put
+
+        // anything we didn't handle, bring it to the host's attention
+        ih_no_ctxsw:
+        mov $r11 0x104
+        not b32 $r11
+        and $r11 $r10 $r11
+        bra e #ih_no_other
+                mov $r10 0xc1c
+                shl b32 $r10 6
+                iowr I[$r10] $r11       // INTR_UP_SET
+
+        // ack, and wake up main()
+        ih_no_other:
+        iowr I[$r0 + 0x100] $r10        // INTR_ACK
+
+        pop $r15
+        pop $r14
+        pop $r13
+        pop $r11
+        pop $r10
+        pop $r9
+        pop $r8
+        mov $flags $r8
+        pop $r8
+        bclr $flags $p0
+        iret
+
+// Again, not real sure
+//
+// In: $r15 value to set 0x404170 to
+//
+ctx_4170s:
+        mov $r14 0x4170
+        sethi $r14 0x400000
+        or $r15 0x10
+        call #nv_wr32
+        ret
+
+// Waits for a ctx_4170s() call to complete
+//
+ctx_4170w:
+        mov $r14 0x4170
+        sethi $r14 0x400000
+        call #nv_rd32
+        and $r15 0x10
+        bra ne #ctx_4170w
+        ret
+
+// Disables various things, waits a bit, and re-enables them..
+//
+// Not sure how exactly this helps, perhaps "ENABLE" is not such a
+// good description for the bits we turn off?  Anyways, without this,
+// funny things happen.
+//
+ctx_redswitch:
+        mov $r14 0x614
+        shl b32 $r14 6
+        mov $r15 0x270
+        iowr I[$r14] $r15       // HUB_RED_SWITCH = ENABLE_GPC, POWER_ALL
+        mov $r15 8
+        ctx_redswitch_delay:
+                sub b32 $r15 1
+                bra ne #ctx_redswitch_delay
+        mov $r15 0x770
+        iowr I[$r14] $r15       // HUB_RED_SWITCH = ENABLE_ALL, POWER_ALL
+        ret
+
+// Not a clue what this is for, except that unless the value is 0x10, the
+// strand context is saved (and presumably restored) incorrectly..
+//
+// In: $r15 value to set to (0x00/0x10 are used)
+//
+ctx_86c:
+        mov $r14 0x86c
+        shl b32 $r14 6
+        iowr I[$r14] $r15       // HUB(0x86c) = val
+        mov $r14 -0x75ec
+        sethi $r14 0x400000
+        call #nv_wr32           // ROP(0xa14) = val
+        mov $r14 -0x5794
+        sethi $r14 0x410000
+        call #nv_wr32           // GPC(0x86c) = val
+        ret
+
+// ctx_load - load's a channel's ctxctl data, and selects its vm
+//
+// In: $r2 channel address
+//
+ctx_load:
+        trace_set(T_CHAN)
+
+        // switch to channel, somewhat magic in parts..
+        mov $r10 12             // DONE_UNK12
+        call #wait_donez
+        mov $r1 0xa24
+        shl b32 $r1 6
+        iowr I[$r1 + 0x000] $r0 // 0x409a24
+        mov $r3 0xb00
+        shl b32 $r3 6
+        iowr I[$r3 + 0x100] $r2 // CHAN_NEXT
+        mov $r1 0xa0c
+        shl b32 $r1 6
+        mov $r4 7
+        iowr I[$r1 + 0x000] $r2 // MEM_CHAN
+        iowr I[$r1 + 0x100] $r4 // MEM_CMD
+        ctx_chan_wait_0:
+                iord $r4 I[$r1 + 0x100]
+                and $r4 0x1f
+                bra ne #ctx_chan_wait_0
+        iowr I[$r3 + 0x000] $r2 // CHAN_CUR
+
+        // load channel header, fetch PGRAPH context pointer
+        mov $xtargets $r0
+        bclr $r2 31
+        shl b32 $r2 4
+        add b32 $r2 2
+
+        trace_set(T_LCHAN)
+        mov $r1 0xa04
+        shl b32 $r1 6
+        iowr I[$r1 + 0x000] $r2         // MEM_BASE
+        mov $r1 0xa20
+        shl b32 $r1 6
+        mov $r2 0x0002
+        sethi $r2 0x80000000
+        iowr I[$r1 + 0x000] $r2         // MEM_TARGET = vram
+        mov $r1 0x10                    // chan + 0x0210
+        mov $r2 #xfer_data
+        sethi $r2 0x00020000            // 16 bytes
+        xdld $r1 $r2
+        xdwait
+        trace_clr(T_LCHAN)
+
+        // update current context
+        ld b32 $r1 D[$r0 + #xfer_data + 4]
+        shl b32 $r1 24
+        ld b32 $r2 D[$r0 + #xfer_data + 0]
+        shr b32 $r2 8
+        or $r1 $r2
+        st b32 D[$r0 + #ctx_current] $r1
+
+        // set transfer base to start of context, and fetch context header
+        trace_set(T_LCTXH)
+        mov $r2 0xa04
+        shl b32 $r2 6
+        iowr I[$r2 + 0x000] $r1         // MEM_BASE
+        mov $r2 1
+        mov $r1 0xa20
+        shl b32 $r1 6
+        iowr I[$r1 + 0x000] $r2         // MEM_TARGET = vm
+        mov $r1 #chan_data
+        sethi $r1 0x00060000            // 256 bytes
+        xdld $r0 $r1
+        xdwait
+        trace_clr(T_LCTXH)
+
+        trace_clr(T_CHAN)
+        ret
+
+// ctx_chan - handler for HUB_SET_CHAN command, will set a channel as
+//            the active channel for ctxctl, but not actually transfer
+//            any context data.  intended for use only during initial
+//            context construction.
+//
+// In: $r2 channel address
+//
+ctx_chan:
+        call #ctx_load
+        mov $r10 12                     // DONE_UNK12
+        call #wait_donez
+        mov $r1 0xa10
+        shl b32 $r1 6
+        mov $r2 5
+        iowr I[$r1 + 0x000] $r2         // MEM_CMD = 5 (???)
+        ctx_chan_wait:
+                iord $r2 I[$r1 + 0x000]
+                or $r2 $r2
+                bra ne #ctx_chan_wait
+        ret
+
+// Execute per-context state overrides list
+//
+// Only executed on the first load of a channel.  Might want to look into
+// removing this and having the host directly modify the channel's context
+// to change this state...  The nouveau DRM already builds this list as
+// it's definitely needed for NVIDIA's, so we may as well use it for now
+//
+// Input: $r1 mmio list length
+//
+ctx_mmio_exec:
+        // set transfer base to be the mmio list
+        ld b32 $r3 D[$r0 + #chan_mmio_address]
+        mov $r2 0xa04
+        shl b32 $r2 6
+        iowr I[$r2 + 0x000] $r3         // MEM_BASE
+
+        clear b32 $r3
+        ctx_mmio_loop:
+                // fetch next 256 bytes of mmio list if necessary
+                and $r4 $r3 0xff
+                bra ne #ctx_mmio_pull
+                        mov $r5 #xfer_data
+                        sethi $r5 0x00060000    // 256 bytes
+                        xdld $r3 $r5
+                        xdwait
+
+                // execute a single list entry
+                ctx_mmio_pull:
+                ld b32 $r14 D[$r4 + #xfer_data + 0x00]
+                ld b32 $r15 D[$r4 + #xfer_data + 0x04]
+                call #nv_wr32
+
+                // next!
+                add b32 $r3 8
+                sub b32 $r1 1
+                bra ne #ctx_mmio_loop
+
+        // set transfer base back to the current context
+        ctx_mmio_done:
+        ld b32 $r3 D[$r0 + #ctx_current]
+        iowr I[$r2 + 0x000] $r3         // MEM_BASE
+
+        // disable the mmio list now, we don't need/want to execute it again
+        st b32 D[$r0 + #chan_mmio_count] $r0
+        mov $r1 #chan_data
+        sethi $r1 0x00060000            // 256 bytes
+        xdst $r0 $r1
+        xdwait
+        ret
+
+// Transfer HUB context data between GPU and storage area
+//
+// In: $r2 channel address
+//     $p1 clear on save, set on load
+//     $p2 set if opposite direction done/will be done, so:
+//              on save it means: "a load will follow this save"
+//              on load it means: "a save preceeded this load"
+//
+ctx_xfer:
+        bra not $p1 #ctx_xfer_pre
+        bra $p2 #ctx_xfer_pre_load
+        ctx_xfer_pre:
+                mov $r15 0x10
+                call #ctx_86c
+                bra not $p1 #ctx_xfer_exec
+
+        ctx_xfer_pre_load:
+                mov $r15 2
+                call #ctx_4170s
+                call #ctx_4170w
+                call #ctx_redswitch
+                clear b32 $r15
+                call #ctx_4170s
+                call #ctx_load
+
+        // fetch context pointer, and initiate xfer on all GPCs
+        ctx_xfer_exec:
+        ld b32 $r1 D[$r0 + #ctx_current]
+        mov $r2 0x414
+        shl b32 $r2 6
+        iowr I[$r2 + 0x000] $r0 // BAR_STATUS = reset
+        mov $r14 -0x5b00
+        sethi $r14 0x410000
+        mov b32 $r15 $r1
+        call #nv_wr32           // GPC_BCAST_WRCMD_DATA = ctx pointer
+        add b32 $r14 4
+        xbit $r15 $flags $p1
+        xbit $r2 $flags $p2
+        shl b32 $r2 1
+        or $r15 $r2
+        call #nv_wr32           // GPC_BCAST_WRCMD_CMD = GPC_XFER(type)
+
+        // strands
+        mov $r1 0x4afc
+        sethi $r1 0x20000
+        mov $r2 0xc
+        iowr I[$r1] $r2         // STRAND_CMD(0x3f) = 0x0c
+        call #strand_wait
+        mov $r2 0x47fc
+        sethi $r2 0x20000
+        iowr I[$r2] $r0         // STRAND_FIRST_GENE(0x3f) = 0x00
+        xbit $r2 $flags $p1
+        add b32 $r2 3
+        iowr I[$r1] $r2         // STRAND_CMD(0x3f) = 0x03/0x04 (SAVE/LOAD)
+
+        // mmio context
+        xbit $r10 $flags $p1    // direction
+        or $r10 6               // first, last
+        mov $r11 0              // base = 0
+        ld b32 $r12 D[$r0 + #hub_mmio_list_head]
+        ld b32 $r13 D[$r0 + #hub_mmio_list_tail]
+        mov $r14 0              // not multi
+        call #mmctx_xfer
+
+        // wait for GPCs to all complete
+        mov $r10 8              // DONE_BAR
+        call #wait_doneo
+
+        // wait for strand xfer to complete
+        call #strand_wait
+
+        // post-op
+        bra $p1 #ctx_xfer_post
+                mov $r10 12             // DONE_UNK12
+                call #wait_donez
+                mov $r1 0xa10
+                shl b32 $r1 6
+                mov $r2 5
+                iowr I[$r1] $r2         // MEM_CMD
+                ctx_xfer_post_save_wait:
+                        iord $r2 I[$r1]
+                        or $r2 $r2
+                        bra ne #ctx_xfer_post_save_wait
+
+        bra $p2 #ctx_xfer_done
+        ctx_xfer_post:
+                mov $r15 2
+                call #ctx_4170s
+                clear b32 $r15
+                call #ctx_86c
+                call #strand_post
+                call #ctx_4170w
+                clear b32 $r15
+                call #ctx_4170s
+
+                bra not $p1 #ctx_xfer_no_post_mmio
+                ld b32 $r1 D[$r0 + #chan_mmio_count]
+                or $r1 $r1
+                bra e #ctx_xfer_no_post_mmio
+                        call #ctx_mmio_exec
+
+                ctx_xfer_no_post_mmio:
+
+        ctx_xfer_done:
+        ret
+
+.align 256
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnve0.fuc.h b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnve0.fuc.h
new file mode 100644
index 000000000000..decf0c60ca3b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/hubnve0.fuc.h
@@ -0,0 +1,857 @@
+uint32_t nve0_grhub_data[] = {
+/* 0x0000: gpc_count */
+        0x00000000,
+/* 0x0004: rop_count */
+        0x00000000,
+/* 0x0008: cmd_queue */
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+/* 0x0050: hub_mmio_list_head */
+        0x00000000,
+/* 0x0054: hub_mmio_list_tail */
+        0x00000000,
+/* 0x0058: ctx_current */
+        0x00000000,
+/* 0x005c: chipsets */
+        0x000000e4,
+        0x013c0070,
+        0x000000e7,
+        0x013c0070,
+        0x00000000,
+/* 0x0070: nve4_hub_mmio_head */
+        0x0417e91c,
+        0x04400204,
+        0x18404010,
+        0x204040a8,
+        0x184040d0,
+        0x004040f8,
+        0x08404130,
+        0x08404150,
+        0x00404164,
+        0x0c4041a0,
+        0x0c404200,
+        0x34404404,
+        0x0c404460,
+        0x00404480,
+        0x00404498,
+        0x0c404604,
+        0x0c404618,
+        0x0440462c,
+        0x00404640,
+        0x00404654,
+        0x00404660,
+        0x48404678,
+        0x084046c8,
+        0x08404700,
+        0x24404718,
+        0x04404744,
+        0x00404754,
+        0x00405800,
+        0x08405830,
+        0x00405854,
+        0x0c405870,
+        0x04405a00,
+        0x00405a18,
+        0x00405b00,
+        0x00405b10,
+        0x00406020,
+        0x0c406028,
+        0x044064a8,
+        0x044064b4,
+        0x2c4064c0,
+        0x004064fc,
+        0x00407040,
+        0x00407804,
+        0x1440780c,
+        0x004078bc,
+        0x18408000,
+        0x00408064,
+        0x08408800,
+        0x00408840,
+        0x08408900,
+        0x00408980,
+/* 0x013c: nve4_hub_mmio_tail */
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+/* 0x0200: chan_data */
+/* 0x0200: chan_mmio_count */
+        0x00000000,
+/* 0x0204: chan_mmio_address */
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+/* 0x0300: xfer_data */
+        0x00000000,
+};
+
+uint32_t nve0_grhub_code[] = {
+        0x03090ef5,
+/* 0x0004: queue_put */
+        0x9800d898,
+        0x86f001d9,
+        0x0489b808,
+        0xf00c1bf4,
+        0x21f502f7,
+        0x00f802ec,
+/* 0x001c: queue_put_next */
+        0xb60798c4,
+        0x8dbb0384,
+        0x0880b600,
+        0x80008e80,
+        0x90b6018f,
+        0x0f94f001,
+        0xf801d980,
+/* 0x0039: queue_get */
+        0x0131f400,
+        0x9800d898,
+        0x89b801d9,
+        0x210bf404,
+        0xb60789c4,
+        0x9dbb0394,
+        0x0890b600,
+        0x98009e98,
+        0x80b6019f,
+        0x0f84f001,
+        0xf400d880,
+/* 0x0066: queue_get_done */
+        0x00f80132,
+/* 0x0068: nv_rd32 */
+        0x0728b7f1,
+        0xb906b4b6,
+        0xc9f002ec,
+        0x00bcd01f,
+/* 0x0078: nv_rd32_wait */
+        0xc800bccf,
+        0x1bf41fcc,
+        0x06a7f0fa,
+        0x010321f5,
+        0xf840bfcf,
+/* 0x008d: nv_wr32 */
+        0x28b7f100,
+        0x06b4b607,
+        0xb980bfd0,
+        0xc9f002ec,
+        0x1ec9f01f,
+/* 0x00a3: nv_wr32_wait */
+        0xcf00bcd0,
+        0xccc800bc,
+        0xfa1bf41f,
+/* 0x00ae: watchdog_reset */
+        0x87f100f8,
+        0x84b60430,
+        0x1ff9f006,
+        0xf8008fd0,
+/* 0x00bd: watchdog_clear */
+        0x3087f100,
+        0x0684b604,
+        0xf80080d0,
+/* 0x00c9: wait_donez */
+        0x3c87f100,
+        0x0684b608,
+        0x99f094bd,
+        0x0089d000,
+        0x081887f1,
+        0xd00684b6,
+/* 0x00e2: wait_done_wait_donez */
+        0x87f1008a,
+        0x84b60400,
+        0x0088cf06,
+        0xf4888aff,
+        0x87f1f31b,
+        0x84b6085c,
+        0xf094bd06,
+        0x89d00099,
+/* 0x0103: wait_doneo */
+        0xf100f800,
+        0xb6083c87,
+        0x94bd0684,
+        0xd00099f0,
+        0x87f10089,
+        0x84b60818,
+        0x008ad006,
+/* 0x011c: wait_done_wait_doneo */
+        0x040087f1,
+        0xcf0684b6,
+        0x8aff0088,
+        0xf30bf488,
+        0x085c87f1,
+        0xbd0684b6,
+        0x0099f094,
+        0xf80089d0,
+/* 0x013d: mmctx_size */
+/* 0x013f: nv_mmctx_size_loop */
+        0x9894bd00,
+        0x85b600e8,
+        0x0180b61a,
+        0xbb0284b6,
+        0xe0b60098,
+        0x04efb804,
+        0xb9eb1bf4,
+        0x00f8029f,
+/* 0x015c: mmctx_xfer */
+        0x083c87f1,
+        0xbd0684b6,
+        0x0199f094,
+        0xf10089d0,
+        0xb6071087,
+        0x94bd0684,
+        0xf405bbfd,
+        0x8bd0090b,
+        0x0099f000,
+/* 0x0180: mmctx_base_disabled */
+        0xf405eefd,
+        0x8ed00c0b,
+        0xc08fd080,
+/* 0x018f: mmctx_multi_disabled */
+        0xb70199f0,
+        0xc8010080,
+        0xb4b600ab,
+        0x0cb9f010,
+        0xb601aec8,
+        0xbefd11e4,
+        0x008bd005,
+/* 0x01a8: mmctx_exec_loop */
+/* 0x01a8: mmctx_wait_free */
+        0xf0008ecf,
+        0x0bf41fe4,
+        0x00ce98fa,
+        0xd005e9fd,
+        0xc0b6c08e,
+        0x04cdb804,
+        0xc8e81bf4,
+        0x1bf402ab,
+/* 0x01c9: mmctx_fini_wait */
+        0x008bcf18,
+        0xb01fb4f0,
+        0x1bf410b4,
+        0x02a7f0f7,
+        0xf4c921f4,
+/* 0x01de: mmctx_stop */
+        0xabc81b0e,
+        0x10b4b600,
+        0xf00cb9f0,
+        0x8bd012b9,
+/* 0x01ed: mmctx_stop_wait */
+        0x008bcf00,
+        0xf412bbc8,
+/* 0x01f6: mmctx_done */
+        0x87f1fa1b,
+        0x84b6085c,
+        0xf094bd06,
+        0x89d00199,
+/* 0x0207: strand_wait */
+        0xf900f800,
+        0x02a7f0a0,
+        0xfcc921f4,
+/* 0x0213: strand_pre */
+        0xf100f8a0,
+        0xf04afc87,
+        0x97f00283,
+        0x0089d00c,
+        0x020721f5,
+/* 0x0226: strand_post */
+        0x87f100f8,
+        0x83f04afc,
+        0x0d97f002,
+        0xf50089d0,
+        0xf8020721,
+/* 0x0239: strand_set */
+        0xfca7f100,
+        0x02a3f04f,
+        0x0500aba2,
+        0xd00fc7f0,
+        0xc7f000ac,
+        0x00bcd00b,
+        0x020721f5,
+        0xf000aed0,
+        0xbcd00ac7,
+        0x0721f500,
+/* 0x0263: strand_ctx_init */
+        0xf100f802,
+        0xb6083c87,
+        0x94bd0684,
+        0xd00399f0,
+        0x21f50089,
+        0xe7f00213,
+        0x3921f503,
+        0xfca7f102,
+        0x02a3f046,
+        0x0400aba0,
+        0xf040a0d0,
+        0xbcd001c7,
+        0x0721f500,
+        0x010c9202,
+        0xf000acd0,
+        0xbcd002c7,
+        0x0721f500,
+        0x2621f502,
+        0x8087f102,
+        0x0684b608,
+        0xb70089cf,
+        0x95220080,
+/* 0x02ba: ctx_init_strand_loop */
+        0x8ed008fe,
+        0x408ed000,
+        0xb6808acf,
+        0xa0b606a5,
+        0x00eabb01,
+        0xb60480b6,
+        0x1bf40192,
+        0x08e4b6e8,
+        0xf1f2efbc,
+        0xb6085c87,
+        0x94bd0684,
+        0xd00399f0,
+        0x00f80089,
+/* 0x02ec: error */
+        0xe7f1e0f9,
+        0xe4b60814,
+        0x00efd006,
+        0x0c1ce7f1,
+        0xf006e4b6,
+        0xefd001f7,
+        0xf8e0fc00,
+/* 0x0309: init */
+        0xfe04bd00,
+        0x07fe0004,
+        0x0017f100,
+        0x0227f012,
+        0xf10012d0,
+        0xfe05b917,
+        0x17f10010,
+        0x10d00400,
+        0x0437f1c0,
+        0x0634b604,
+        0x200327f1,
+        0xf10032d0,
+        0xd0200427,
+        0x27f10132,
+        0x32d0200b,
+        0x0c27f102,
+        0x0732d020,
+        0x0c2427f1,
+        0xb90624b6,
+        0x23d00003,
+        0x0427f100,
+        0x0023f087,
+        0xb70012d0,
+        0xf0010012,
+        0x12d00427,
+        0x1031f400,
+        0x9604e7f1,
+        0xf440e3f0,
+        0xf1c76821,
+        0x01018090,
+        0x801ff4f0,
+        0x17f0000f,
+        0x041fbb01,
+        0xf10112b6,
+        0xb6040c27,
+        0x21d00624,
+        0x4021d000,
+        0x080027f1,
+        0xcf0624b6,
+        0xf7f00022,
+/* 0x03a9: init_find_chipset */
+        0x08f0b654,
+        0xb800f398,
+        0x0bf40432,
+        0x0034b00b,
+        0xf8f11bf4,
+/* 0x03bd: init_context */
+        0x0017f100,
+        0x02fe5801,
+        0xf003ff58,
+        0x0e8000e3,
+        0x150f8014,
+        0x013d21f5,
+        0x070037f1,
+        0x950634b6,
+        0x34d00814,
+        0x4034d000,
+        0x130030b7,
+        0xb6001fbb,
+        0x3fd002f5,
+        0x0815b600,
+        0xb60110b6,
+        0x1fb90814,
+        0x6321f502,
+        0x001fbb02,
+        0xf1000398,
+        0xf0200047,
+/* 0x040e: init_gpc */
+        0x4ea05043,
+        0x1fb90804,
+        0x8d21f402,
+        0x08004ea0,
+        0xf4022fb9,
+        0x4ea08d21,
+        0xf4bd010c,
+        0xa08d21f4,
+        0xf401044e,
+        0x4ea08d21,
+        0xf7f00100,
+        0x8d21f402,
+        0x08004ea0,
+/* 0x0440: init_gpc_wait */
+        0xc86821f4,
+        0x0bf41fff,
+        0x044ea0fa,
+        0x6821f408,
+        0xb7001fbb,
+        0xb6800040,
+        0x1bf40132,
+        0x0027f1b4,
+        0x0624b608,
+        0xb74021d0,
+        0xbd080020,
+        0x1f19f014,
+/* 0x0473: main */
+        0xf40021d0,
+        0x28f40031,
+        0x08d7f000,
+        0xf43921f4,
+        0xe4b1f401,
+        0x1bf54001,
+        0x87f100d1,
+        0x84b6083c,
+        0xf094bd06,
+        0x89d00499,
+        0x0017f100,
+        0x0614b60b,
+        0xcf4012cf,
+        0x13c80011,
+        0x7e0bf41f,
+        0xf41f23c8,
+        0x20f95a0b,
+        0xf10212b9,
+        0xb6083c87,
+        0x94bd0684,
+        0xd00799f0,
+        0x32f40089,
+        0x0231f401,
+        0x07fb21f5,
+        0x085c87f1,
+        0xbd0684b6,
+        0x0799f094,
+        0xfc0089d0,
+        0x3c87f120,
+        0x0684b608,
+        0x99f094bd,
+        0x0089d006,
+        0xf50131f4,
+        0xf107fb21,
+        0xb6085c87,
+        0x94bd0684,
+        0xd00699f0,
+        0x0ef40089,
+/* 0x0509: chsw_prev_no_next */
+        0xb920f931,
+        0x32f40212,
+        0x0232f401,
+        0x07fb21f5,
+        0x17f120fc,
+        0x14b60b00,
+        0x0012d006,
+/* 0x0527: chsw_no_prev */
+        0xc8130ef4,
+        0x0bf41f23,
+        0x0131f40d,
+        0xf50232f4,
+/* 0x0537: chsw_done */
+        0xf107fb21,
+        0xb60b0c17,
+        0x27f00614,
+        0x0012d001,
+        0x085c87f1,
+        0xbd0684b6,
+        0x0499f094,
+        0xf50089d0,
+/* 0x0557: main_not_ctx_switch */
+        0xb0ff200e,
+        0x1bf401e4,
+        0x02f2b90d,
+        0x078f21f5,
+/* 0x0567: main_not_ctx_chan */
+        0xb0420ef4,
+        0x1bf402e4,
+        0x3c87f12e,
+        0x0684b608,
+        0x99f094bd,
+        0x0089d007,
+        0xf40132f4,
+        0x21f50232,
+        0x87f107fb,
+        0x84b6085c,
+        0xf094bd06,
+        0x89d00799,
+        0x110ef400,
+/* 0x0598: main_not_ctx_save */
+        0xf010ef94,
+        0x21f501f5,
+        0x0ef502ec,
+/* 0x05a6: main_done */
+        0x17f1fed1,
+        0x14b60820,
+        0xf024bd06,
+        0x12d01f29,
+        0xbe0ef500,
+/* 0x05b9: ih */
+        0xfe80f9fe,
+        0x80f90188,
+        0xa0f990f9,
+        0xd0f9b0f9,
+        0xf0f9e0f9,
+        0xc4800acf,
+        0x0bf404ab,
+        0x00b7f11d,
+        0x08d7f019,
+        0xcf40becf,
+        0x21f400bf,
+        0x00b0b704,
+        0x01e7f004,
+/* 0x05ef: ih_no_fifo */
+        0xe400bed0,
+        0xf40100ab,
+        0xd7f00d0b,
+        0x01e7f108,
+        0x0421f440,
+/* 0x0600: ih_no_ctxsw */
+        0x0104b7f1,
+        0xabffb0bd,
+        0x0d0bf4b4,
+        0x0c1ca7f1,
+        0xd006a4b6,
+/* 0x0616: ih_no_other */
+        0x0ad000ab,
+        0xfcf0fc40,
+        0xfcd0fce0,
+        0xfca0fcb0,
+        0xfe80fc90,
+        0x80fc0088,
+        0xf80032f4,
+/* 0x0631: ctx_4170s */
+        0x70e7f101,
+        0x40e3f041,
+        0xf410f5f0,
+        0x00f88d21,
+/* 0x0640: ctx_4170w */
+        0x4170e7f1,
+        0xf440e3f0,
+        0xf4f06821,
+        0xf31bf410,
+/* 0x0652: ctx_redswitch */
+        0xe7f100f8,
+        0xe4b60614,
+        0x70f7f106,
+        0x00efd002,
+/* 0x0663: ctx_redswitch_delay */
+        0xb608f7f0,
+        0x1bf401f2,
+        0x70f7f1fd,
+        0x00efd007,
+/* 0x0672: ctx_86c */
+        0xe7f100f8,
+        0xe4b6086c,
+        0x00efd006,
+        0x8a14e7f1,
+        0xf440e3f0,
+        0xe7f18d21,
+        0xe3f0a86c,
+        0x8d21f441,
+/* 0x0692: ctx_load */
+        0x87f100f8,
+        0x84b6083c,
+        0xf094bd06,
+        0x89d00599,
+        0x0ca7f000,
+        0xf1c921f4,
+        0xb60a2417,
+        0x10d00614,
+        0x0037f100,
+        0x0634b60b,
+        0xf14032d0,
+        0xb60a0c17,
+        0x47f00614,
+        0x0012d007,
+/* 0x06cb: ctx_chan_wait_0 */
+        0xcf4014d0,
+        0x44f04014,
+        0xfa1bf41f,
+        0xfe0032d0,
+        0x2af0000b,
+        0x0424b61f,
+        0xf10220b6,
+        0xb6083c87,
+        0x94bd0684,
+        0xd00899f0,
+        0x17f10089,
+        0x14b60a04,
+        0x0012d006,
+        0x0a2017f1,
+        0xf00614b6,
+        0x23f10227,
+        0x12d08000,
+        0x1017f000,
+        0x030027f1,
+        0xfa0223f0,
+        0x03f80512,
+        0x085c87f1,
+        0xbd0684b6,
+        0x0899f094,
+        0x980089d0,
+        0x14b6c101,
+        0xc0029818,
+        0xfd0825b6,
+        0x01800512,
+        0x3c87f116,
+        0x0684b608,
+        0x99f094bd,
+        0x0089d009,
+        0x0a0427f1,
+        0xd00624b6,
+        0x27f00021,
+        0x2017f101,
+        0x0614b60a,
+        0xf10012d0,
+        0xf0020017,
+        0x01fa0613,
+        0xf103f805,
+        0xb6085c87,
+        0x94bd0684,
+        0xd00999f0,
+        0x87f10089,
+        0x84b6085c,
+        0xf094bd06,
+        0x89d00599,
+/* 0x078f: ctx_chan */
+        0xf500f800,
+        0xf0069221,
+        0x21f40ca7,
+        0x1017f1c9,
+        0x0614b60a,
+        0xd00527f0,
+/* 0x07a6: ctx_chan_wait */
+        0x12cf0012,
+        0x0522fd00,
+        0xf8fa1bf4,
+/* 0x07b1: ctx_mmio_exec */
+        0x81039800,
+        0x0a0427f1,
+        0xd00624b6,
+        0x34bd0023,
+/* 0x07c0: ctx_mmio_loop */
+        0xf4ff34c4,
+        0x57f10f1b,
+        0x53f00300,
+        0x0535fa06,
+/* 0x07d2: ctx_mmio_pull */
+        0x4e9803f8,
+        0xc14f98c0,
+        0xb68d21f4,
+        0x12b60830,
+        0xdf1bf401,
+/* 0x07e4: ctx_mmio_done */
+        0xd0160398,
+        0x00800023,
+        0x0017f180,
+        0x0613f002,
+        0xf80601fa,
+/* 0x07fb: ctx_xfer */
+        0xf400f803,
+        0x02f40611,
+/* 0x0801: ctx_xfer_pre */
+        0x10f7f00d,
+        0x067221f5,
+/* 0x080b: ctx_xfer_pre_load */
+        0xf01c11f4,
+        0x21f502f7,
+        0x21f50631,
+        0x21f50640,
+        0xf4bd0652,
+        0x063121f5,
+        0x069221f5,
+/* 0x0824: ctx_xfer_exec */
+        0xf1160198,
+        0xb6041427,
+        0x20d00624,
+        0x00e7f100,
+        0x41e3f0a5,
+        0xf4021fb9,
+        0xe0b68d21,
+        0x01fcf004,
+        0xb6022cf0,
+        0xf2fd0124,
+        0x8d21f405,
+        0x4afc17f1,
+        0xf00213f0,
+        0x12d00c27,
+        0x0721f500,
+        0xfc27f102,
+        0x0223f047,
+        0xf00020d0,
+        0x20b6012c,
+        0x0012d003,
+        0xf001acf0,
+        0xb7f006a5,
+        0x140c9800,
+        0xf0150d98,
+        0x21f500e7,
+        0xa7f0015c,
+        0x0321f508,
+        0x0721f501,
+        0x2201f402,
+        0xf40ca7f0,
+        0x17f1c921,
+        0x14b60a10,
+        0x0527f006,
+/* 0x08ab: ctx_xfer_post_save_wait */
+        0xcf0012d0,
+        0x22fd0012,
+        0xfa1bf405,
+/* 0x08b7: ctx_xfer_post */
+        0xf02e02f4,
+        0x21f502f7,
+        0xf4bd0631,
+        0x067221f5,
+        0x022621f5,
+        0x064021f5,
+        0x21f5f4bd,
+        0x11f40631,
+        0x80019810,
+        0xf40511fd,
+        0x21f5070b,
+/* 0x08e2: ctx_xfer_no_post_mmio */
+/* 0x08e2: ctx_xfer_done */
+        0x00f807b1,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+        0x00000000,
+};
diff --git a/drivers/gpu/drm/nouveau/nvc0_graph.fuc b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/nvc0.fuc
index e6b228844a32..e6b228844a32 100644
--- a/drivers/gpu/drm/nouveau/nvc0_graph.fuc
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/nvc0.fuc
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/fuc/nve0.fuc b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/nve0.fuc
new file mode 100644
index 000000000000..f16a5d53319d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/fuc/nve0.fuc
@@ -0,0 +1,400 @@
+/* fuc microcode util functions for nve0 PGRAPH
+ *
+ * Copyright 2011 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
+ */
+
+define(`mmctx_data', `.b32 eval((($2 - 1) << 26) | $1)')
+define(`queue_init', `.skip eval((2 * 4) + ((8 * 4) * 2))')
+
+ifdef(`include_code', `
+// Error codes
+define(`E_BAD_COMMAND', 0x01)
+define(`E_CMD_OVERFLOW', 0x02)
+
+// Util macros to help with debugging ucode hangs etc
+define(`T_WAIT', 0)
+define(`T_MMCTX', 1)
+define(`T_STRWAIT', 2)
+define(`T_STRINIT', 3)
+define(`T_AUTO', 4)
+define(`T_CHAN', 5)
+define(`T_LOAD', 6)
+define(`T_SAVE', 7)
+define(`T_LCHAN', 8)
+define(`T_LCTXH', 9)
+
+define(`trace_set', `
+        mov $r8 0x83c
+        shl b32 $r8 6
+        clear b32 $r9
+        bset $r9 $1
+        iowr I[$r8 + 0x000] $r9         // CC_SCRATCH[7]
+')
+
+define(`trace_clr', `
+        mov $r8 0x85c
+        shl b32 $r8 6
+        clear b32 $r9
+        bset $r9 $1
+        iowr I[$r8 + 0x000] $r9         // CC_SCRATCH[7]
+')
+
+// queue_put - add request to queue
+//
+// In : $r13 queue pointer
+//      $r14 command
+//      $r15 data
+//
+queue_put:
+        // make sure we have space..
+        ld b32 $r8 D[$r13 + 0x0]        // GET
+        ld b32 $r9 D[$r13 + 0x4]        // PUT
+        xor $r8 8
+        cmpu b32 $r8 $r9
+        bra ne #queue_put_next
+                mov $r15 E_CMD_OVERFLOW
+                call #error
+                ret
+
+        // store cmd/data on queue
+        queue_put_next:
+        and $r8 $r9 7
+        shl b32 $r8 3
+        add b32 $r8 $r13
+        add b32 $r8 8
+        st b32 D[$r8 + 0x0] $r14
+        st b32 D[$r8 + 0x4] $r15
+
+        // update PUT
+        add b32 $r9 1
+        and $r9 0xf
+        st b32 D[$r13 + 0x4] $r9
+        ret
+
+// queue_get - fetch request from queue
+//
+// In : $r13 queue pointer
+//
+// Out: $p1  clear on success (data available)
+//      $r14 command
+//      $r15 data
+//
+queue_get:
+        bset $flags $p1
+        ld b32 $r8 D[$r13 + 0x0]        // GET
+        ld b32 $r9 D[$r13 + 0x4]        // PUT
+        cmpu b32 $r8 $r9
+        bra e #queue_get_done
+                // fetch first cmd/data pair
+                and $r9 $r8 7
+                shl b32 $r9 3
+                add b32 $r9 $r13
+                add b32 $r9 8
+                ld b32 $r14 D[$r9 + 0x0]
+                ld b32 $r15 D[$r9 + 0x4]
+
+                // update GET
+                add b32 $r8 1
+                and $r8 0xf
+                st b32 D[$r13 + 0x0] $r8
+                bclr $flags $p1
+queue_get_done:
+        ret
+
+// nv_rd32 - read 32-bit value from nv register
+//
+// In : $r14 register
+// Out: $r15 value
+//
+nv_rd32:
+        mov $r11 0x728
+        shl b32 $r11 6
+        mov b32 $r12 $r14
+        bset $r12 31                    // MMIO_CTRL_PENDING
+        iowr I[$r11 + 0x000] $r12       // MMIO_CTRL
+        nv_rd32_wait:
+                iord $r12 I[$r11 + 0x000]
+                xbit $r12 $r12 31
+                bra ne #nv_rd32_wait
+        mov $r10 6                      // DONE_MMIO_RD
+        call #wait_doneo
+        iord $r15 I[$r11 + 0x100]       // MMIO_RDVAL
+        ret
+
+// nv_wr32 - write 32-bit value to nv register
+//
+// In : $r14 register
+//      $r15 value
+//
+nv_wr32:
+        mov $r11 0x728
+        shl b32 $r11 6
+        iowr I[$r11 + 0x200] $r15       // MMIO_WRVAL
+        mov b32 $r12 $r14
+        bset $r12 31                    // MMIO_CTRL_PENDING
+        bset $r12 30                    // MMIO_CTRL_WRITE
+        iowr I[$r11 + 0x000] $r12       // MMIO_CTRL
+        nv_wr32_wait:
+                iord $r12 I[$r11 + 0x000]
+                xbit $r12 $r12 31
+                bra ne #nv_wr32_wait
+        ret
+
+// (re)set watchdog timer
+//
+// In : $r15 timeout
+//
+watchdog_reset:
+        mov $r8 0x430
+        shl b32 $r8 6
+        bset $r15 31
+        iowr I[$r8 + 0x000] $r15
+        ret
+
+// clear watchdog timer
+watchdog_clear:
+        mov $r8 0x430
+        shl b32 $r8 6
+        iowr I[$r8 + 0x000] $r0
+        ret
+
+// wait_done{z,o} - wait on FUC_DONE bit to become clear/set
+//
+// In : $r10 bit to wait on
+//
+define(`wait_done', `
+$1:
+        trace_set(T_WAIT);
+        mov $r8 0x818
+        shl b32 $r8 6
+        iowr I[$r8 + 0x000] $r10        // CC_SCRATCH[6] = wait bit
+        wait_done_$1:
+                mov $r8 0x400
+                shl b32 $r8 6
+                iord $r8 I[$r8 + 0x000] // DONE
+                xbit $r8 $r8 $r10
+                bra $2 #wait_done_$1
+        trace_clr(T_WAIT)
+        ret
+')
+wait_done(wait_donez, ne)
+wait_done(wait_doneo, e)
+
+// mmctx_size - determine size of a mmio list transfer
+//
+// In : $r14 mmio list head
+//      $r15 mmio list tail
+// Out: $r15 transfer size (in bytes)
+//
+mmctx_size:
+        clear b32 $r9
+        nv_mmctx_size_loop:
+                ld b32 $r8 D[$r14]
+                shr b32 $r8 26
+                add b32 $r8 1
+                shl b32 $r8 2
+                add b32 $r9 $r8
+                add b32 $r14 4
+                cmpu b32 $r14 $r15
+                bra ne #nv_mmctx_size_loop
+        mov b32 $r15 $r9
+        ret
+
+// mmctx_xfer - execute a list of mmio transfers
+//
+// In : $r10 flags
+//              bit 0: direction (0 = save, 1 = load)
+//              bit 1: set if first transfer
+//              bit 2: set if last transfer
+//      $r11 base
+//      $r12 mmio list head
+//      $r13 mmio list tail
+//      $r14 multi_stride
+//      $r15 multi_mask
+//
+mmctx_xfer:
+        trace_set(T_MMCTX)
+        mov $r8 0x710
+        shl b32 $r8 6
+        clear b32 $r9
+        or $r11 $r11
+        bra e #mmctx_base_disabled
+                iowr I[$r8 + 0x000] $r11        // MMCTX_BASE
+                bset $r9 0                      // BASE_EN
+        mmctx_base_disabled:
+        or $r14 $r14
+        bra e #mmctx_multi_disabled
+                iowr I[$r8 + 0x200] $r14        // MMCTX_MULTI_STRIDE
+                iowr I[$r8 + 0x300] $r15        // MMCTX_MULTI_MASK
+                bset $r9 1                      // MULTI_EN
+        mmctx_multi_disabled:
+        add b32 $r8 0x100
+
+        xbit $r11 $r10 0
+        shl b32 $r11 16                 // DIR
+        bset $r11 12                    // QLIMIT = 0x10
+        xbit $r14 $r10 1
+        shl b32 $r14 17
+        or $r11 $r14                    // START_TRIGGER
+        iowr I[$r8 + 0x000] $r11        // MMCTX_CTRL
+
+        // loop over the mmio list, and send requests to the hw
+        mmctx_exec_loop:
+                // wait for space in mmctx queue
+                mmctx_wait_free:
+                        iord $r14 I[$r8 + 0x000] // MMCTX_CTRL
+                        and $r14 0x1f
+                        bra e #mmctx_wait_free
+
+                // queue up an entry
+                ld b32 $r14 D[$r12]
+                or $r14 $r9
+                iowr I[$r8 + 0x300] $r14
+                add b32 $r12 4
+                cmpu b32 $r12 $r13
+                bra ne #mmctx_exec_loop
+
+        xbit $r11 $r10 2
+        bra ne #mmctx_stop
+                // wait for queue to empty
+                mmctx_fini_wait:
+                        iord $r11 I[$r8 + 0x000]        // MMCTX_CTRL
+                        and $r11 0x1f
+                        cmpu b32 $r11 0x10
+                        bra ne #mmctx_fini_wait
+                mov $r10 2                              // DONE_MMCTX
+                call #wait_donez
+                bra #mmctx_done
+        mmctx_stop:
+                xbit $r11 $r10 0
+                shl b32 $r11 16                 // DIR
+                bset $r11 12                    // QLIMIT = 0x10
+                bset $r11 18                    // STOP_TRIGGER
+                iowr I[$r8 + 0x000] $r11        // MMCTX_CTRL
+                mmctx_stop_wait:
+                        // wait for STOP_TRIGGER to clear
+                        iord $r11 I[$r8 + 0x000] // MMCTX_CTRL
+                        xbit $r11 $r11 18
+                        bra ne #mmctx_stop_wait
+        mmctx_done:
+        trace_clr(T_MMCTX)
+        ret
+
+// Wait for DONE_STRAND
+//
+strand_wait:
+        push $r10
+        mov $r10 2
+        call #wait_donez
+        pop $r10
+        ret
+
+// unknown - call before issuing strand commands
+//
+strand_pre:
+        mov $r8 0x4afc
+        sethi $r8 0x20000
+        mov $r9 0xc
+        iowr I[$r8] $r9
+        call #strand_wait
+        ret
+
+// unknown - call after issuing strand commands
+//
+strand_post:
+        mov $r8 0x4afc
+        sethi $r8 0x20000
+        mov $r9 0xd
+        iowr I[$r8] $r9
+        call #strand_wait
+        ret
+
+// Selects strand set?!
+//
+// In: $r14 id
+//
+strand_set:
+        mov $r10 0x4ffc
+        sethi $r10 0x20000
+        sub b32 $r11 $r10 0x500
+        mov $r12 0xf
+        iowr I[$r10 + 0x000] $r12               // 0x93c = 0xf
+        mov $r12 0xb
+        iowr I[$r11 + 0x000] $r12               // 0x928 = 0xb
+        call #strand_wait
+        iowr I[$r10 + 0x000] $r14               // 0x93c = <id>
+        mov $r12 0xa
+        iowr I[$r11 + 0x000] $r12               // 0x928 = 0xa
+        call #strand_wait
+        ret
+
+// Initialise strand context data
+//
+// In : $r15 context base
+// Out: $r15 context size (in bytes)
+//
+// Strandset(?) 3 hardcoded currently
+//
+strand_ctx_init:
+        trace_set(T_STRINIT)
+        call #strand_pre
+        mov $r14 3
+        call #strand_set
+        mov $r10 0x46fc
+        sethi $r10 0x20000
+        add b32 $r11 $r10 0x400
+        iowr I[$r10 + 0x100] $r0        // STRAND_FIRST_GENE = 0
+        mov $r12 1
+        iowr I[$r11 + 0x000] $r12       // STRAND_CMD = LATCH_FIRST_GENE
+        call #strand_wait
+        sub b32 $r12 $r0 1
+        iowr I[$r10 + 0x000] $r12       // STRAND_GENE_CNT = 0xffffffff
+        mov $r12 2
+        iowr I[$r11 + 0x000] $r12       // STRAND_CMD = LATCH_GENE_CNT
+        call #strand_wait
+        call #strand_post
+
+        // read the size of each strand, poke the context offset of
+        // each into STRAND_{SAVE,LOAD}_SWBASE now, no need to worry
+        // about it later then.
+        mov $r8 0x880
+        shl b32 $r8 6
+        iord $r9 I[$r8 + 0x000]         // STRANDS
+        add b32 $r8 0x2200
+        shr b32 $r14 $r15 8
+        ctx_init_strand_loop:
+                iowr I[$r8 + 0x000] $r14        // STRAND_SAVE_SWBASE
+                iowr I[$r8 + 0x100] $r14        // STRAND_LOAD_SWBASE
+                iord $r10 I[$r8 + 0x200]        // STRAND_SIZE
+                shr b32 $r10 6
+                add b32 $r10 1
+                add b32 $r14 $r10
+                add b32 $r8 4
+                sub b32 $r9 1
+                bra ne #ctx_init_strand_loop
+
+        shl b32 $r14 8
+        sub b32 $r15 $r14 $r15
+        trace_clr(T_STRINIT)
+        ret
+')
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv04.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv04.c
new file mode 100644
index 000000000000..618528248457
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv04.c
@@ -0,0 +1,1387 @@
+/*
+ * Copyright 2007 Stephane Marchesin
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <core/os.h>
+#include <core/class.h>
+#include <core/handle.h>
+#include <core/namedb.h>
+
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/timer.h>
+
+#include <engine/fifo.h>
+#include <engine/graph.h>
+
+#include "regs.h"
+
+static u32
+nv04_graph_ctx_regs[] = {
+        0x0040053c,
+        0x00400544,
+        0x00400540,
+        0x00400548,
+        NV04_PGRAPH_CTX_SWITCH1,
+        NV04_PGRAPH_CTX_SWITCH2,
+        NV04_PGRAPH_CTX_SWITCH3,
+        NV04_PGRAPH_CTX_SWITCH4,
+        NV04_PGRAPH_CTX_CACHE1,
+        NV04_PGRAPH_CTX_CACHE2,
+        NV04_PGRAPH_CTX_CACHE3,
+        NV04_PGRAPH_CTX_CACHE4,
+        0x00400184,
+        0x004001a4,
+        0x004001c4,
+        0x004001e4,
+        0x00400188,
+        0x004001a8,
+        0x004001c8,
+        0x004001e8,
+        0x0040018c,
+        0x004001ac,
+        0x004001cc,
+        0x004001ec,
+        0x00400190,
+        0x004001b0,
+        0x004001d0,
+        0x004001f0,
+        0x00400194,
+        0x004001b4,
+        0x004001d4,
+        0x004001f4,
+        0x00400198,
+        0x004001b8,
+        0x004001d8,
+        0x004001f8,
+        0x0040019c,
+        0x004001bc,
+        0x004001dc,
+        0x004001fc,
+        0x00400174,
+        NV04_PGRAPH_DMA_START_0,
+        NV04_PGRAPH_DMA_START_1,
+        NV04_PGRAPH_DMA_LENGTH,
+        NV04_PGRAPH_DMA_MISC,
+        NV04_PGRAPH_DMA_PITCH,
+        NV04_PGRAPH_BOFFSET0,
+        NV04_PGRAPH_BBASE0,
+        NV04_PGRAPH_BLIMIT0,
+        NV04_PGRAPH_BOFFSET1,
+        NV04_PGRAPH_BBASE1,
+        NV04_PGRAPH_BLIMIT1,
+        NV04_PGRAPH_BOFFSET2,
+        NV04_PGRAPH_BBASE2,
+        NV04_PGRAPH_BLIMIT2,
+        NV04_PGRAPH_BOFFSET3,
+        NV04_PGRAPH_BBASE3,
+        NV04_PGRAPH_BLIMIT3,
+        NV04_PGRAPH_BOFFSET4,
+        NV04_PGRAPH_BBASE4,
+        NV04_PGRAPH_BLIMIT4,
+        NV04_PGRAPH_BOFFSET5,
+        NV04_PGRAPH_BBASE5,
+        NV04_PGRAPH_BLIMIT5,
+        NV04_PGRAPH_BPITCH0,
+        NV04_PGRAPH_BPITCH1,
+        NV04_PGRAPH_BPITCH2,
+        NV04_PGRAPH_BPITCH3,
+        NV04_PGRAPH_BPITCH4,
+        NV04_PGRAPH_SURFACE,
+        NV04_PGRAPH_STATE,
+        NV04_PGRAPH_BSWIZZLE2,
+        NV04_PGRAPH_BSWIZZLE5,
+        NV04_PGRAPH_BPIXEL,
+        NV04_PGRAPH_NOTIFY,
+        NV04_PGRAPH_PATT_COLOR0,
+        NV04_PGRAPH_PATT_COLOR1,
+        NV04_PGRAPH_PATT_COLORRAM+0x00,
+        NV04_PGRAPH_PATT_COLORRAM+0x04,
+        NV04_PGRAPH_PATT_COLORRAM+0x08,
+        NV04_PGRAPH_PATT_COLORRAM+0x0c,
+        NV04_PGRAPH_PATT_COLORRAM+0x10,
+        NV04_PGRAPH_PATT_COLORRAM+0x14,
+        NV04_PGRAPH_PATT_COLORRAM+0x18,
+        NV04_PGRAPH_PATT_COLORRAM+0x1c,
+        NV04_PGRAPH_PATT_COLORRAM+0x20,
+        NV04_PGRAPH_PATT_COLORRAM+0x24,
+        NV04_PGRAPH_PATT_COLORRAM+0x28,
+        NV04_PGRAPH_PATT_COLORRAM+0x2c,
+        NV04_PGRAPH_PATT_COLORRAM+0x30,
+        NV04_PGRAPH_PATT_COLORRAM+0x34,
+        NV04_PGRAPH_PATT_COLORRAM+0x38,
+        NV04_PGRAPH_PATT_COLORRAM+0x3c,
+        NV04_PGRAPH_PATT_COLORRAM+0x40,
+        NV04_PGRAPH_PATT_COLORRAM+0x44,
+        NV04_PGRAPH_PATT_COLORRAM+0x48,
+        NV04_PGRAPH_PATT_COLORRAM+0x4c,
+        NV04_PGRAPH_PATT_COLORRAM+0x50,
+        NV04_PGRAPH_PATT_COLORRAM+0x54,
+        NV04_PGRAPH_PATT_COLORRAM+0x58,
+        NV04_PGRAPH_PATT_COLORRAM+0x5c,
+        NV04_PGRAPH_PATT_COLORRAM+0x60,
+        NV04_PGRAPH_PATT_COLORRAM+0x64,
+        NV04_PGRAPH_PATT_COLORRAM+0x68,
+        NV04_PGRAPH_PATT_COLORRAM+0x6c,
+        NV04_PGRAPH_PATT_COLORRAM+0x70,
+        NV04_PGRAPH_PATT_COLORRAM+0x74,
+        NV04_PGRAPH_PATT_COLORRAM+0x78,
+        NV04_PGRAPH_PATT_COLORRAM+0x7c,
+        NV04_PGRAPH_PATT_COLORRAM+0x80,
+        NV04_PGRAPH_PATT_COLORRAM+0x84,
+        NV04_PGRAPH_PATT_COLORRAM+0x88,
+        NV04_PGRAPH_PATT_COLORRAM+0x8c,
+        NV04_PGRAPH_PATT_COLORRAM+0x90,
+        NV04_PGRAPH_PATT_COLORRAM+0x94,
+        NV04_PGRAPH_PATT_COLORRAM+0x98,
+        NV04_PGRAPH_PATT_COLORRAM+0x9c,
+        NV04_PGRAPH_PATT_COLORRAM+0xa0,
+        NV04_PGRAPH_PATT_COLORRAM+0xa4,
+        NV04_PGRAPH_PATT_COLORRAM+0xa8,
+        NV04_PGRAPH_PATT_COLORRAM+0xac,
+        NV04_PGRAPH_PATT_COLORRAM+0xb0,
+        NV04_PGRAPH_PATT_COLORRAM+0xb4,
+        NV04_PGRAPH_PATT_COLORRAM+0xb8,
+        NV04_PGRAPH_PATT_COLORRAM+0xbc,
+        NV04_PGRAPH_PATT_COLORRAM+0xc0,
+        NV04_PGRAPH_PATT_COLORRAM+0xc4,
+        NV04_PGRAPH_PATT_COLORRAM+0xc8,
+        NV04_PGRAPH_PATT_COLORRAM+0xcc,
+        NV04_PGRAPH_PATT_COLORRAM+0xd0,
+        NV04_PGRAPH_PATT_COLORRAM+0xd4,
+        NV04_PGRAPH_PATT_COLORRAM+0xd8,
+        NV04_PGRAPH_PATT_COLORRAM+0xdc,
+        NV04_PGRAPH_PATT_COLORRAM+0xe0,
+        NV04_PGRAPH_PATT_COLORRAM+0xe4,
+        NV04_PGRAPH_PATT_COLORRAM+0xe8,
+        NV04_PGRAPH_PATT_COLORRAM+0xec,
+        NV04_PGRAPH_PATT_COLORRAM+0xf0,
+        NV04_PGRAPH_PATT_COLORRAM+0xf4,
+        NV04_PGRAPH_PATT_COLORRAM+0xf8,
+        NV04_PGRAPH_PATT_COLORRAM+0xfc,
+        NV04_PGRAPH_PATTERN,
+        0x0040080c,
+        NV04_PGRAPH_PATTERN_SHAPE,
+        0x00400600,
+        NV04_PGRAPH_ROP3,
+        NV04_PGRAPH_CHROMA,
+        NV04_PGRAPH_BETA_AND,
+        NV04_PGRAPH_BETA_PREMULT,
+        NV04_PGRAPH_CONTROL0,
+        NV04_PGRAPH_CONTROL1,
+        NV04_PGRAPH_CONTROL2,
+        NV04_PGRAPH_BLEND,
+        NV04_PGRAPH_STORED_FMT,
+        NV04_PGRAPH_SOURCE_COLOR,
+        0x00400560,
+        0x00400568,
+        0x00400564,
+        0x0040056c,
+        0x00400400,
+        0x00400480,
+        0x00400404,
+        0x00400484,
+        0x00400408,
+        0x00400488,
+        0x0040040c,
+        0x0040048c,
+        0x00400410,
+        0x00400490,
+        0x00400414,
+        0x00400494,
+        0x00400418,
+        0x00400498,
+        0x0040041c,
+        0x0040049c,
+        0x00400420,
+        0x004004a0,
+        0x00400424,
+        0x004004a4,
+        0x00400428,
+        0x004004a8,
+        0x0040042c,
+        0x004004ac,
+        0x00400430,
+        0x004004b0,
+        0x00400434,
+        0x004004b4,
+        0x00400438,
+        0x004004b8,
+        0x0040043c,
+        0x004004bc,
+        0x00400440,
+        0x004004c0,
+        0x00400444,
+        0x004004c4,
+        0x00400448,
+        0x004004c8,
+        0x0040044c,
+        0x004004cc,
+        0x00400450,
+        0x004004d0,
+        0x00400454,
+        0x004004d4,
+        0x00400458,
+        0x004004d8,
+        0x0040045c,
+        0x004004dc,
+        0x00400460,
+        0x004004e0,
+        0x00400464,
+        0x004004e4,
+        0x00400468,
+        0x004004e8,
+        0x0040046c,
+        0x004004ec,
+        0x00400470,
+        0x004004f0,
+        0x00400474,
+        0x004004f4,
+        0x00400478,
+        0x004004f8,
+        0x0040047c,
+        0x004004fc,
+        0x00400534,
+        0x00400538,
+        0x00400514,
+        0x00400518,
+        0x0040051c,
+        0x00400520,
+        0x00400524,
+        0x00400528,
+        0x0040052c,
+        0x00400530,
+        0x00400d00,
+        0x00400d40,
+        0x00400d80,
+        0x00400d04,
+        0x00400d44,
+        0x00400d84,
+        0x00400d08,
+        0x00400d48,
+        0x00400d88,
+        0x00400d0c,
+        0x00400d4c,
+        0x00400d8c,
+        0x00400d10,
+        0x00400d50,
+        0x00400d90,
+        0x00400d14,
+        0x00400d54,
+        0x00400d94,
+        0x00400d18,
+        0x00400d58,
+        0x00400d98,
+        0x00400d1c,
+        0x00400d5c,
+        0x00400d9c,
+        0x00400d20,
+        0x00400d60,
+        0x00400da0,
+        0x00400d24,
+        0x00400d64,
+        0x00400da4,
+        0x00400d28,
+        0x00400d68,
+        0x00400da8,
+        0x00400d2c,
+        0x00400d6c,
+        0x00400dac,
+        0x00400d30,
+        0x00400d70,
+        0x00400db0,
+        0x00400d34,
+        0x00400d74,
+        0x00400db4,
+        0x00400d38,
+        0x00400d78,
+        0x00400db8,
+        0x00400d3c,
+        0x00400d7c,
+        0x00400dbc,
+        0x00400590,
+        0x00400594,
+        0x00400598,
+        0x0040059c,
+        0x004005a8,
+        0x004005ac,
+        0x004005b0,
+        0x004005b4,
+        0x004005c0,
+        0x004005c4,
+        0x004005c8,
+        0x004005cc,
+        0x004005d0,
+        0x004005d4,
+        0x004005d8,
+        0x004005dc,
+        0x004005e0,
+        NV04_PGRAPH_PASSTHRU_0,
+        NV04_PGRAPH_PASSTHRU_1,
+        NV04_PGRAPH_PASSTHRU_2,
+        NV04_PGRAPH_DVD_COLORFMT,
+        NV04_PGRAPH_SCALED_FORMAT,
+        NV04_PGRAPH_MISC24_0,
+        NV04_PGRAPH_MISC24_1,
+        NV04_PGRAPH_MISC24_2,
+        0x00400500,
+        0x00400504,
+        NV04_PGRAPH_VALID1,
+        NV04_PGRAPH_VALID2,
+        NV04_PGRAPH_DEBUG_3
+};
+
+struct nv04_graph_priv {
+        struct nouveau_graph base;
+        struct nv04_graph_chan *chan[16];
+        spinlock_t lock;
+};
+
+struct nv04_graph_chan {
+        struct nouveau_object base;
+        int chid;
+        u32 nv04[ARRAY_SIZE(nv04_graph_ctx_regs)];
+};
+
+
+static inline struct nv04_graph_priv *
+nv04_graph_priv(struct nv04_graph_chan *chan)
+{
+        return (void *)nv_object(chan)->engine;
+}
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+/*
+ * Software methods, why they are needed, and how they all work:
+ *
+ * NV04 and NV05 keep most of the state in PGRAPH context itself, but some
+ * 2d engine settings are kept inside the grobjs themselves. The grobjs are
+ * 3 words long on both. grobj format on NV04 is:
+ *
+ * word 0:
+ *  - bits 0-7: class
+ *  - bit 12: color key active
+ *  - bit 13: clip rect active
+ *  - bit 14: if set, destination surface is swizzled and taken from buffer 5
+ *            [set by NV04_SWIZZLED_SURFACE], otherwise it's linear and taken
+ *            from buffer 0 [set by NV04_CONTEXT_SURFACES_2D or
+ *            NV03_CONTEXT_SURFACE_DST].
+ *  - bits 15-17: 2d operation [aka patch config]
+ *  - bit 24: patch valid [enables rendering using this object]
+ *  - bit 25: surf3d valid [for tex_tri and multitex_tri only]
+ * word 1:
+ *  - bits 0-1: mono format
+ *  - bits 8-13: color format
+ *  - bits 16-31: DMA_NOTIFY instance
+ * word 2:
+ *  - bits 0-15: DMA_A instance
+ *  - bits 16-31: DMA_B instance
+ *
+ * On NV05 it's:
+ *
+ * word 0:
+ *  - bits 0-7: class
+ *  - bit 12: color key active
+ *  - bit 13: clip rect active
+ *  - bit 14: if set, destination surface is swizzled and taken from buffer 5
+ *            [set by NV04_SWIZZLED_SURFACE], otherwise it's linear and taken
+ *            from buffer 0 [set by NV04_CONTEXT_SURFACES_2D or
+ *            NV03_CONTEXT_SURFACE_DST].
+ *  - bits 15-17: 2d operation [aka patch config]
+ *  - bits 20-22: dither mode
+ *  - bit 24: patch valid [enables rendering using this object]
+ *  - bit 25: surface_dst/surface_color/surf2d/surf3d valid
+ *  - bit 26: surface_src/surface_zeta valid
+ *  - bit 27: pattern valid
+ *  - bit 28: rop valid
+ *  - bit 29: beta1 valid
+ *  - bit 30: beta4 valid
+ * word 1:
+ *  - bits 0-1: mono format
+ *  - bits 8-13: color format
+ *  - bits 16-31: DMA_NOTIFY instance
+ * word 2:
+ *  - bits 0-15: DMA_A instance
+ *  - bits 16-31: DMA_B instance
+ *
+ * NV05 will set/unset the relevant valid bits when you poke the relevant
+ * object-binding methods with object of the proper type, or with the NULL
+ * type. It'll only allow rendering using the grobj if all needed objects
+ * are bound. The needed set of objects depends on selected operation: for
+ * example rop object is needed by ROP_AND, but not by SRCCOPY_AND.
+ *
+ * NV04 doesn't have these methods implemented at all, and doesn't have the
+ * relevant bits in grobj. Instead, it'll allow rendering whenever bit 24
+ * is set. So we have to emulate them in software, internally keeping the
+ * same bits as NV05 does. Since grobjs are aligned to 16 bytes on nv04,
+ * but the last word isn't actually used for anything, we abuse it for this
+ * purpose.
+ *
+ * Actually, NV05 can optionally check bit 24 too, but we disable this since
+ * there's no use for it.
+ *
+ * For unknown reasons, NV04 implements surf3d binding in hardware as an
+ * exception. Also for unknown reasons, NV04 doesn't implement the clipping
+ * methods on the surf3d object, so we have to emulate them too.
+ */
+
+static void
+nv04_graph_set_ctx1(struct nouveau_object *object, u32 mask, u32 value)
+{
+        struct nv04_graph_priv *priv = (void *)object->engine;
+        int subc = (nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR) >> 13) & 0x7;
+        u32 tmp;
+
+        tmp  = nv_ro32(object, 0x00);
+        tmp &= ~mask;
+        tmp |= value;
+        nv_wo32(object, 0x00, tmp);
+
+        nv_wr32(priv, NV04_PGRAPH_CTX_SWITCH1, tmp);
+        nv_wr32(priv, NV04_PGRAPH_CTX_CACHE1 + (subc<<2), tmp);
+}
+
+static void
+nv04_graph_set_ctx_val(struct nouveau_object *object, u32 mask, u32 value)
+{
+        int class, op, valid = 1;
+        u32 tmp, ctx1;
+
+        ctx1 = nv_ro32(object, 0x00);
+        class = ctx1 & 0xff;
+        op = (ctx1 >> 15) & 7;
+
+        tmp = nv_ro32(object, 0x0c);
+        tmp &= ~mask;
+        tmp |= value;
+        nv_wo32(object, 0x0c, tmp);
+
+        /* check for valid surf2d/surf_dst/surf_color */
+        if (!(tmp & 0x02000000))
+                valid = 0;
+        /* check for valid surf_src/surf_zeta */
+        if ((class == 0x1f || class == 0x48) && !(tmp & 0x04000000))
+                valid = 0;
+
+        switch (op) {
+        /* SRCCOPY_AND, SRCCOPY: no extra objects required */
+        case 0:
+        case 3:
+                break;
+        /* ROP_AND: requires pattern and rop */
+        case 1:
+                if (!(tmp & 0x18000000))
+                        valid = 0;
+                break;
+        /* BLEND_AND: requires beta1 */
+        case 2:
+                if (!(tmp & 0x20000000))
+                        valid = 0;
+                break;
+        /* SRCCOPY_PREMULT, BLEND_PREMULT: beta4 required */
+        case 4:
+        case 5:
+                if (!(tmp & 0x40000000))
+                        valid = 0;
+                break;
+        }
+
+        nv04_graph_set_ctx1(object, 0x01000000, valid << 24);
+}
+
+static int
+nv04_graph_mthd_set_operation(struct nouveau_object *object, u32 mthd,
+                              void *args, u32 size)
+{
+        u32 class = nv_ro32(object, 0) & 0xff;
+        u32 data = *(u32 *)args;
+        if (data > 5)
+                return 1;
+        /* Old versions of the objects only accept first three operations. */
+        if (data > 2 && class < 0x40)
+                return 1;
+        nv04_graph_set_ctx1(object, 0x00038000, data << 15);
+        /* changing operation changes set of objects needed for validation */
+        nv04_graph_set_ctx_val(object, 0, 0);
+        return 0;
+}
+
+static int
+nv04_graph_mthd_surf3d_clip_h(struct nouveau_object *object, u32 mthd,
+                              void *args, u32 size)
+{
+        struct nv04_graph_priv *priv = (void *)object->engine;
+        u32 data = *(u32 *)args;
+        u32 min = data & 0xffff, max;
+        u32 w = data >> 16;
+        if (min & 0x8000)
+                /* too large */
+                return 1;
+        if (w & 0x8000)
+                /* yes, it accepts negative for some reason. */
+                w |= 0xffff0000;
+        max = min + w;
+        max &= 0x3ffff;
+        nv_wr32(priv, 0x40053c, min);
+        nv_wr32(priv, 0x400544, max);
+        return 0;
+}
+
+static int
+nv04_graph_mthd_surf3d_clip_v(struct nouveau_object *object, u32 mthd,
+                              void *args, u32 size)
+{
+        struct nv04_graph_priv *priv = (void *)object->engine;
+        u32 data = *(u32 *)args;
+        u32 min = data & 0xffff, max;
+        u32 w = data >> 16;
+        if (min & 0x8000)
+                /* too large */
+                return 1;
+        if (w & 0x8000)
+                /* yes, it accepts negative for some reason. */
+                w |= 0xffff0000;
+        max = min + w;
+        max &= 0x3ffff;
+        nv_wr32(priv, 0x400540, min);
+        nv_wr32(priv, 0x400548, max);
+        return 0;
+}
+
+static u16
+nv04_graph_mthd_bind_class(struct nouveau_object *object, u32 *args, u32 size)
+{
+        struct nouveau_instmem *imem = nouveau_instmem(object);
+        u32 inst = *(u32 *)args << 4;
+        return nv_ro32(imem, inst);
+}
+
+static int
+nv04_graph_mthd_bind_surf2d(struct nouveau_object *object, u32 mthd,
+                            void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx1(object, 0x00004000, 0);
+                nv04_graph_set_ctx_val(object, 0x02000000, 0);
+                return 0;
+        case 0x42:
+                nv04_graph_set_ctx1(object, 0x00004000, 0);
+                nv04_graph_set_ctx_val(object, 0x02000000, 0x02000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_surf2d_swzsurf(struct nouveau_object *object, u32 mthd,
+                                    void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx1(object, 0x00004000, 0);
+                nv04_graph_set_ctx_val(object, 0x02000000, 0);
+                return 0;
+        case 0x42:
+                nv04_graph_set_ctx1(object, 0x00004000, 0);
+                nv04_graph_set_ctx_val(object, 0x02000000, 0x02000000);
+                return 0;
+        case 0x52:
+                nv04_graph_set_ctx1(object, 0x00004000, 0x00004000);
+                nv04_graph_set_ctx_val(object, 0x02000000, 0x02000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv01_graph_mthd_bind_patt(struct nouveau_object *object, u32 mthd,
+                          void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x08000000, 0);
+                return 0;
+        case 0x18:
+                nv04_graph_set_ctx_val(object, 0x08000000, 0x08000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_patt(struct nouveau_object *object, u32 mthd,
+                          void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x08000000, 0);
+                return 0;
+        case 0x44:
+                nv04_graph_set_ctx_val(object, 0x08000000, 0x08000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_rop(struct nouveau_object *object, u32 mthd,
+                         void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x10000000, 0);
+                return 0;
+        case 0x43:
+                nv04_graph_set_ctx_val(object, 0x10000000, 0x10000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_beta1(struct nouveau_object *object, u32 mthd,
+                           void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x20000000, 0);
+                return 0;
+        case 0x12:
+                nv04_graph_set_ctx_val(object, 0x20000000, 0x20000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_beta4(struct nouveau_object *object, u32 mthd,
+                           void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x40000000, 0);
+                return 0;
+        case 0x72:
+                nv04_graph_set_ctx_val(object, 0x40000000, 0x40000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_surf_dst(struct nouveau_object *object, u32 mthd,
+                              void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x02000000, 0);
+                return 0;
+        case 0x58:
+                nv04_graph_set_ctx_val(object, 0x02000000, 0x02000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_surf_src(struct nouveau_object *object, u32 mthd,
+                              void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x04000000, 0);
+                return 0;
+        case 0x59:
+                nv04_graph_set_ctx_val(object, 0x04000000, 0x04000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_surf_color(struct nouveau_object *object, u32 mthd,
+                                void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x02000000, 0);
+                return 0;
+        case 0x5a:
+                nv04_graph_set_ctx_val(object, 0x02000000, 0x02000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv04_graph_mthd_bind_surf_zeta(struct nouveau_object *object, u32 mthd,
+                               void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx_val(object, 0x04000000, 0);
+                return 0;
+        case 0x5b:
+                nv04_graph_set_ctx_val(object, 0x04000000, 0x04000000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv01_graph_mthd_bind_clip(struct nouveau_object *object, u32 mthd,
+                          void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx1(object, 0x2000, 0);
+                return 0;
+        case 0x19:
+                nv04_graph_set_ctx1(object, 0x2000, 0x2000);
+                return 0;
+        }
+        return 1;
+}
+
+static int
+nv01_graph_mthd_bind_chroma(struct nouveau_object *object, u32 mthd,
+                            void *args, u32 size)
+{
+        switch (nv04_graph_mthd_bind_class(object, args, size)) {
+        case 0x30:
+                nv04_graph_set_ctx1(object, 0x1000, 0);
+                return 0;
+        /* Yes, for some reason even the old versions of objects
+         * accept 0x57 and not 0x17. Consistency be damned.
+         */
+        case 0x57:
+                nv04_graph_set_ctx1(object, 0x1000, 0x1000);
+                return 0;
+        }
+        return 1;
+}
+
+static struct nouveau_omthds
+nv03_graph_gdi_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_patt },
+        { 0x0188, nv04_graph_mthd_bind_rop },
+        { 0x018c, nv04_graph_mthd_bind_beta1 },
+        { 0x0190, nv04_graph_mthd_bind_surf_dst },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_gdi_omthds[] = {
+        { 0x0188, nv04_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_beta4 },
+        { 0x0198, nv04_graph_mthd_bind_surf2d },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv01_graph_blit_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_chroma },
+        { 0x0188, nv01_graph_mthd_bind_clip },
+        { 0x018c, nv01_graph_mthd_bind_patt },
+        { 0x0190, nv04_graph_mthd_bind_rop },
+        { 0x0194, nv04_graph_mthd_bind_beta1 },
+        { 0x0198, nv04_graph_mthd_bind_surf_dst },
+        { 0x019c, nv04_graph_mthd_bind_surf_src },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_blit_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_chroma },
+        { 0x0188, nv01_graph_mthd_bind_clip },
+        { 0x018c, nv04_graph_mthd_bind_patt },
+        { 0x0190, nv04_graph_mthd_bind_rop },
+        { 0x0194, nv04_graph_mthd_bind_beta1 },
+        { 0x0198, nv04_graph_mthd_bind_beta4 },
+        { 0x019c, nv04_graph_mthd_bind_surf2d },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_iifc_omthds[] = {
+        { 0x0188, nv01_graph_mthd_bind_chroma },
+        { 0x018c, nv01_graph_mthd_bind_clip },
+        { 0x0190, nv04_graph_mthd_bind_patt },
+        { 0x0194, nv04_graph_mthd_bind_rop },
+        { 0x0198, nv04_graph_mthd_bind_beta1 },
+        { 0x019c, nv04_graph_mthd_bind_beta4 },
+        { 0x01a0, nv04_graph_mthd_bind_surf2d_swzsurf },
+        { 0x03e4, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv01_graph_ifc_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_chroma },
+        { 0x0188, nv01_graph_mthd_bind_clip },
+        { 0x018c, nv01_graph_mthd_bind_patt },
+        { 0x0190, nv04_graph_mthd_bind_rop },
+        { 0x0194, nv04_graph_mthd_bind_beta1 },
+        { 0x0198, nv04_graph_mthd_bind_surf_dst },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_ifc_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_chroma },
+        { 0x0188, nv01_graph_mthd_bind_clip },
+        { 0x018c, nv04_graph_mthd_bind_patt },
+        { 0x0190, nv04_graph_mthd_bind_rop },
+        { 0x0194, nv04_graph_mthd_bind_beta1 },
+        { 0x0198, nv04_graph_mthd_bind_beta4 },
+        { 0x019c, nv04_graph_mthd_bind_surf2d },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv03_graph_sifc_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_chroma },
+        { 0x0188, nv01_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_surf_dst },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_sifc_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_chroma },
+        { 0x0188, nv04_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_beta4 },
+        { 0x0198, nv04_graph_mthd_bind_surf2d },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv03_graph_sifm_omthds[] = {
+        { 0x0188, nv01_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_surf_dst },
+        { 0x0304, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_sifm_omthds[] = {
+        { 0x0188, nv04_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_beta4 },
+        { 0x0198, nv04_graph_mthd_bind_surf2d },
+        { 0x0304, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_surf3d_omthds[] = {
+        { 0x02f8, nv04_graph_mthd_surf3d_clip_h },
+        { 0x02fc, nv04_graph_mthd_surf3d_clip_v },
+        {}
+};
+
+static struct nouveau_omthds
+nv03_graph_ttri_omthds[] = {
+        { 0x0188, nv01_graph_mthd_bind_clip },
+        { 0x018c, nv04_graph_mthd_bind_surf_color },
+        { 0x0190, nv04_graph_mthd_bind_surf_zeta },
+        {}
+};
+
+static struct nouveau_omthds
+nv01_graph_prim_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_clip },
+        { 0x0188, nv01_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_surf_dst },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static struct nouveau_omthds
+nv04_graph_prim_omthds[] = {
+        { 0x0184, nv01_graph_mthd_bind_clip },
+        { 0x0188, nv04_graph_mthd_bind_patt },
+        { 0x018c, nv04_graph_mthd_bind_rop },
+        { 0x0190, nv04_graph_mthd_bind_beta1 },
+        { 0x0194, nv04_graph_mthd_bind_beta4 },
+        { 0x0198, nv04_graph_mthd_bind_surf2d },
+        { 0x02fc, nv04_graph_mthd_set_operation },
+        {}
+};
+
+static int
+nv04_graph_object_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj *obj;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, parent,
+                                    16, 16, 0, &obj);
+        *pobject = nv_object(obj);
+        if (ret)
+                return ret;
+
+        nv_wo32(obj, 0x00, nv_mclass(obj));
+#ifdef __BIG_ENDIAN
+        nv_mo32(obj, 0x00, 0x00080000, 0x00080000);
+#endif
+        nv_wo32(obj, 0x04, 0x00000000);
+        nv_wo32(obj, 0x08, 0x00000000);
+        nv_wo32(obj, 0x0c, 0x00000000);
+        return 0;
+}
+
+struct nouveau_ofuncs
+nv04_graph_ofuncs = {
+        .ctor = nv04_graph_object_ctor,
+        .dtor = _nouveau_gpuobj_dtor,
+        .init = _nouveau_gpuobj_init,
+        .fini = _nouveau_gpuobj_fini,
+        .rd32 = _nouveau_gpuobj_rd32,
+        .wr32 = _nouveau_gpuobj_wr32,
+};
+
+static struct nouveau_oclass
+nv04_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs }, /* beta1 */
+        { 0x0017, &nv04_graph_ofuncs }, /* chroma */
+        { 0x0018, &nv04_graph_ofuncs }, /* pattern (nv01) */
+        { 0x0019, &nv04_graph_ofuncs }, /* clip */
+        { 0x001c, &nv04_graph_ofuncs, nv01_graph_prim_omthds }, /* line */
+        { 0x001d, &nv04_graph_ofuncs, nv01_graph_prim_omthds }, /* tri */
+        { 0x001e, &nv04_graph_ofuncs, nv01_graph_prim_omthds }, /* rect */
+        { 0x001f, &nv04_graph_ofuncs, nv01_graph_blit_omthds },
+        { 0x0021, &nv04_graph_ofuncs, nv01_graph_ifc_omthds },
+        { 0x0030, &nv04_graph_ofuncs }, /* null */
+        { 0x0036, &nv04_graph_ofuncs, nv03_graph_sifc_omthds },
+        { 0x0037, &nv04_graph_ofuncs, nv03_graph_sifm_omthds },
+        { 0x0038, &nv04_graph_ofuncs }, /* dvd subpicture */
+        { 0x0039, &nv04_graph_ofuncs }, /* m2mf */
+        { 0x0042, &nv04_graph_ofuncs }, /* surf2d */
+        { 0x0043, &nv04_graph_ofuncs }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs }, /* pattern */
+        { 0x0048, &nv04_graph_ofuncs, nv03_graph_ttri_omthds },
+        { 0x004a, &nv04_graph_ofuncs, nv04_graph_gdi_omthds },
+        { 0x004b, &nv04_graph_ofuncs, nv03_graph_gdi_omthds },
+        { 0x0052, &nv04_graph_ofuncs }, /* swzsurf */
+        { 0x0053, &nv04_graph_ofuncs, nv04_graph_surf3d_omthds },
+        { 0x0054, &nv04_graph_ofuncs }, /* ttri */
+        { 0x0055, &nv04_graph_ofuncs }, /* mtri */
+        { 0x0057, &nv04_graph_ofuncs }, /* chroma */
+        { 0x0058, &nv04_graph_ofuncs }, /* surf_dst */
+        { 0x0059, &nv04_graph_ofuncs }, /* surf_src */
+        { 0x005a, &nv04_graph_ofuncs }, /* surf_color */
+        { 0x005b, &nv04_graph_ofuncs }, /* surf_zeta */
+        { 0x005c, &nv04_graph_ofuncs, nv04_graph_prim_omthds }, /* line */
+        { 0x005d, &nv04_graph_ofuncs, nv04_graph_prim_omthds }, /* tri */
+        { 0x005e, &nv04_graph_ofuncs, nv04_graph_prim_omthds }, /* rect */
+        { 0x005f, &nv04_graph_ofuncs, nv04_graph_blit_omthds },
+        { 0x0060, &nv04_graph_ofuncs, nv04_graph_iifc_omthds },
+        { 0x0061, &nv04_graph_ofuncs, nv04_graph_ifc_omthds },
+        { 0x0064, &nv04_graph_ofuncs }, /* iifc (nv05) */
+        { 0x0065, &nv04_graph_ofuncs }, /* ifc (nv05) */
+        { 0x0066, &nv04_graph_ofuncs }, /* sifc (nv05) */
+        { 0x0072, &nv04_graph_ofuncs }, /* beta4 */
+        { 0x0076, &nv04_graph_ofuncs, nv04_graph_sifc_omthds },
+        { 0x0077, &nv04_graph_ofuncs, nv04_graph_sifm_omthds },
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static struct nv04_graph_chan *
+nv04_graph_channel(struct nv04_graph_priv *priv)
+{
+        struct nv04_graph_chan *chan = NULL;
+        if (nv_rd32(priv, NV04_PGRAPH_CTX_CONTROL) & 0x00010000) {
+                int chid = nv_rd32(priv, NV04_PGRAPH_CTX_USER) >> 24;
+                if (chid < ARRAY_SIZE(priv->chan))
+                        chan = priv->chan[chid];
+        }
+        return chan;
+}
+
+static int
+nv04_graph_load_context(struct nv04_graph_chan *chan, int chid)
+{
+        struct nv04_graph_priv *priv = nv04_graph_priv(chan);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(nv04_graph_ctx_regs); i++)
+                nv_wr32(priv, nv04_graph_ctx_regs[i], chan->nv04[i]);
+
+        nv_wr32(priv, NV04_PGRAPH_CTX_CONTROL, 0x10010100);
+        nv_mask(priv, NV04_PGRAPH_CTX_USER, 0xff000000, chid << 24);
+        nv_mask(priv, NV04_PGRAPH_FFINTFC_ST2, 0xfff00000, 0x00000000);
+        return 0;
+}
+
+static int
+nv04_graph_unload_context(struct nv04_graph_chan *chan)
+{
+        struct nv04_graph_priv *priv = nv04_graph_priv(chan);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(nv04_graph_ctx_regs); i++)
+                chan->nv04[i] = nv_rd32(priv, nv04_graph_ctx_regs[i]);
+
+        nv_wr32(priv, NV04_PGRAPH_CTX_CONTROL, 0x10000000);
+        nv_mask(priv, NV04_PGRAPH_CTX_USER, 0xff000000, 0x0f000000);
+        return 0;
+}
+
+static void
+nv04_graph_context_switch(struct nv04_graph_priv *priv)
+{
+        struct nv04_graph_chan *prev = NULL;
+        struct nv04_graph_chan *next = NULL;
+        unsigned long flags;
+        int chid;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        nv04_graph_idle(priv);
+
+        /* If previous context is valid, we need to save it */
+        prev = nv04_graph_channel(priv);
+        if (prev)
+                nv04_graph_unload_context(prev);
+
+        /* load context for next channel */
+        chid = (nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR) >> 24) & 0x0f;
+        next = priv->chan[chid];
+        if (next)
+                nv04_graph_load_context(next, chid);
+
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static u32 *ctx_reg(struct nv04_graph_chan *chan, u32 reg)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(nv04_graph_ctx_regs); i++) {
+                if (nv04_graph_ctx_regs[i] == reg)
+                        return &chan->nv04[i];
+        }
+
+        return NULL;
+}
+
+static int
+nv04_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nouveau_fifo_chan *fifo = (void *)parent;
+        struct nv04_graph_priv *priv = (void *)engine;
+        struct nv04_graph_chan *chan;
+        unsigned long flags;
+        int ret;
+
+        ret = nouveau_object_create(parent, engine, oclass, 0, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (priv->chan[fifo->chid]) {
+                *pobject = nv_object(priv->chan[fifo->chid]);
+                atomic_inc(&(*pobject)->refcount);
+                spin_unlock_irqrestore(&priv->lock, flags);
+                nouveau_object_destroy(&chan->base);
+                return 1;
+        }
+
+        *ctx_reg(chan, NV04_PGRAPH_DEBUG_3) = 0xfad4ff31;
+
+        priv->chan[fifo->chid] = chan;
+        chan->chid = fifo->chid;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 0;
+}
+
+static void
+nv04_graph_context_dtor(struct nouveau_object *object)
+{
+        struct nv04_graph_priv *priv = (void *)object->engine;
+        struct nv04_graph_chan *chan = (void *)object;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->chan[chan->chid] = NULL;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        nouveau_object_destroy(&chan->base);
+}
+
+static int
+nv04_graph_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv04_graph_priv *priv = (void *)object->engine;
+        struct nv04_graph_chan *chan = (void *)object;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        nv_mask(priv, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
+        if (nv04_graph_channel(priv) == chan)
+                nv04_graph_unload_context(chan);
+        nv_mask(priv, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        return nouveau_object_fini(&chan->base, suspend);
+}
+
+static struct nouveau_oclass
+nv04_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_graph_context_ctor,
+                .dtor = nv04_graph_context_dtor,
+                .init = nouveau_object_init,
+                .fini = nv04_graph_context_fini,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+bool
+nv04_graph_idle(void *obj)
+{
+        struct nouveau_graph *graph = nouveau_graph(obj);
+        u32 mask = 0xffffffff;
+
+        if (nv_device(obj)->card_type == NV_40)
+                mask &= ~NV40_PGRAPH_STATUS_SYNC_STALL;
+
+        if (!nv_wait(graph, NV04_PGRAPH_STATUS, mask, 0)) {
+                nv_error(graph, "idle timed out with status 0x%08x\n",
+                         nv_rd32(graph, NV04_PGRAPH_STATUS));
+                return false;
+        }
+
+        return true;
+}
+
+static const struct nouveau_bitfield
+nv04_graph_intr_name[] = {
+        { NV_PGRAPH_INTR_NOTIFY, "NOTIFY" },
+        {}
+};
+
+static const struct nouveau_bitfield
+nv04_graph_nstatus[] = {
+        { NV04_PGRAPH_NSTATUS_STATE_IN_USE,       "STATE_IN_USE" },
+        { NV04_PGRAPH_NSTATUS_INVALID_STATE,      "INVALID_STATE" },
+        { NV04_PGRAPH_NSTATUS_BAD_ARGUMENT,       "BAD_ARGUMENT" },
+        { NV04_PGRAPH_NSTATUS_PROTECTION_FAULT,   "PROTECTION_FAULT" },
+        {}
+};
+
+const struct nouveau_bitfield
+nv04_graph_nsource[] = {
+        { NV03_PGRAPH_NSOURCE_NOTIFICATION,       "NOTIFICATION" },
+        { NV03_PGRAPH_NSOURCE_DATA_ERROR,         "DATA_ERROR" },
+        { NV03_PGRAPH_NSOURCE_PROTECTION_ERROR,   "PROTECTION_ERROR" },
+        { NV03_PGRAPH_NSOURCE_RANGE_EXCEPTION,    "RANGE_EXCEPTION" },
+        { NV03_PGRAPH_NSOURCE_LIMIT_COLOR,        "LIMIT_COLOR" },
+        { NV03_PGRAPH_NSOURCE_LIMIT_ZETA,         "LIMIT_ZETA" },
+        { NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD,       "ILLEGAL_MTHD" },
+        { NV03_PGRAPH_NSOURCE_DMA_R_PROTECTION,   "DMA_R_PROTECTION" },
+        { NV03_PGRAPH_NSOURCE_DMA_W_PROTECTION,   "DMA_W_PROTECTION" },
+        { NV03_PGRAPH_NSOURCE_FORMAT_EXCEPTION,   "FORMAT_EXCEPTION" },
+        { NV03_PGRAPH_NSOURCE_PATCH_EXCEPTION,    "PATCH_EXCEPTION" },
+        { NV03_PGRAPH_NSOURCE_STATE_INVALID,      "STATE_INVALID" },
+        { NV03_PGRAPH_NSOURCE_DOUBLE_NOTIFY,      "DOUBLE_NOTIFY" },
+        { NV03_PGRAPH_NSOURCE_NOTIFY_IN_USE,      "NOTIFY_IN_USE" },
+        { NV03_PGRAPH_NSOURCE_METHOD_CNT,         "METHOD_CNT" },
+        { NV03_PGRAPH_NSOURCE_BFR_NOTIFICATION,   "BFR_NOTIFICATION" },
+        { NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION, "DMA_VTX_PROTECTION" },
+        { NV03_PGRAPH_NSOURCE_DMA_WIDTH_A,        "DMA_WIDTH_A" },
+        { NV03_PGRAPH_NSOURCE_DMA_WIDTH_B,        "DMA_WIDTH_B" },
+        {}
+};
+
+static void
+nv04_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nv04_graph_priv *priv = (void *)subdev;
+        struct nv04_graph_chan *chan = NULL;
+        struct nouveau_namedb *namedb = NULL;
+        struct nouveau_handle *handle = NULL;
+        u32 stat = nv_rd32(priv, NV03_PGRAPH_INTR);
+        u32 nsource = nv_rd32(priv, NV03_PGRAPH_NSOURCE);
+        u32 nstatus = nv_rd32(priv, NV03_PGRAPH_NSTATUS);
+        u32 addr = nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR);
+        u32 chid = (addr & 0x0f000000) >> 24;
+        u32 subc = (addr & 0x0000e000) >> 13;
+        u32 mthd = (addr & 0x00001ffc);
+        u32 data = nv_rd32(priv, NV04_PGRAPH_TRAPPED_DATA);
+        u32 class = nv_rd32(priv, 0x400180 + subc * 4) & 0xff;
+        u32 inst = (nv_rd32(priv, 0x40016c) & 0xffff) << 4;
+        u32 show = stat;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        chan = priv->chan[chid];
+        if (chan)
+                namedb = (void *)nv_pclass(nv_object(chan), NV_NAMEDB_CLASS);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        if (stat & NV_PGRAPH_INTR_NOTIFY) {
+                if (chan && (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD)) {
+                        handle = nouveau_namedb_get_vinst(namedb, inst);
+                        if (handle && !nv_call(handle->object, mthd, data))
+                                show &= ~NV_PGRAPH_INTR_NOTIFY;
+                }
+        }
+
+        if (stat & NV_PGRAPH_INTR_CONTEXT_SWITCH) {
+                nv_wr32(priv, NV03_PGRAPH_INTR, NV_PGRAPH_INTR_CONTEXT_SWITCH);
+                stat &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
+                show &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
+                nv04_graph_context_switch(priv);
+        }
+
+        nv_wr32(priv, NV03_PGRAPH_INTR, stat);
+        nv_wr32(priv, NV04_PGRAPH_FIFO, 0x00000001);
+
+        if (show) {
+                nv_error(priv, "");
+                nouveau_bitfield_print(nv04_graph_intr_name, show);
+                printk(" nsource:");
+                nouveau_bitfield_print(nv04_graph_nsource, nsource);
+                printk(" nstatus:");
+                nouveau_bitfield_print(nv04_graph_nstatus, nstatus);
+                printk("\n");
+                nv_error(priv, "ch %d/%d class 0x%04x "
+                               "mthd 0x%04x data 0x%08x\n",
+                         chid, subc, class, mthd, data);
+        }
+
+        nouveau_namedb_put(handle);
+}
+
+static int
+nv04_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv04_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv04_graph_intr;
+        nv_engine(priv)->cclass = &nv04_graph_cclass;
+        nv_engine(priv)->sclass = nv04_graph_sclass;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+static int
+nv04_graph_init(struct nouveau_object *object)
+{
+        struct nouveau_engine *engine = nv_engine(object);
+        struct nv04_graph_priv *priv = (void *)engine;
+        int ret;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* Enable PGRAPH interrupts */
+        nv_wr32(priv, NV03_PGRAPH_INTR, 0xFFFFFFFF);
+        nv_wr32(priv, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
+
+        nv_wr32(priv, NV04_PGRAPH_VALID1, 0);
+        nv_wr32(priv, NV04_PGRAPH_VALID2, 0);
+        /*nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x000001FF);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x001FFFFF);*/
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x1231c000);
+        /*1231C000 blob, 001 haiku*/
+        /*V_WRITE(NV04_PGRAPH_DEBUG_1, 0xf2d91100);*/
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_1, 0x72111100);
+        /*0x72111100 blob , 01 haiku*/
+        /*nv_wr32(priv, NV04_PGRAPH_DEBUG_2, 0x11d5f870);*/
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_2, 0x11d5f071);
+        /*haiku same*/
+
+        /*nv_wr32(priv, NV04_PGRAPH_DEBUG_3, 0xfad4ff31);*/
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_3, 0xf0d4ff31);
+        /*haiku and blob 10d4*/
+
+        nv_wr32(priv, NV04_PGRAPH_STATE        , 0xFFFFFFFF);
+        nv_wr32(priv, NV04_PGRAPH_CTX_CONTROL  , 0x10000100);
+        nv_mask(priv, NV04_PGRAPH_CTX_USER, 0xff000000, 0x0f000000);
+
+        /* These don't belong here, they're part of a per-channel context */
+        nv_wr32(priv, NV04_PGRAPH_PATTERN_SHAPE, 0x00000000);
+        nv_wr32(priv, NV04_PGRAPH_BETA_AND     , 0xFFFFFFFF);
+        return 0;
+}
+
+struct nouveau_oclass
+nv04_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_graph_ctor,
+                .dtor = _nouveau_graph_dtor,
+                .init = nv04_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv10.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv10.c
new file mode 100644
index 000000000000..92521c89e77f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv10.c
@@ -0,0 +1,1314 @@
+/*
+ * Copyright 2007 Matthieu CASTET <castet.matthieu@free.fr>
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <core/os.h>
+#include <core/class.h>
+#include <core/handle.h>
+
+#include <subdev/fb.h>
+
+#include <engine/fifo.h>
+#include <engine/graph.h>
+
+#include "regs.h"
+
+struct pipe_state {
+        u32 pipe_0x0000[0x040/4];
+        u32 pipe_0x0040[0x010/4];
+        u32 pipe_0x0200[0x0c0/4];
+        u32 pipe_0x4400[0x080/4];
+        u32 pipe_0x6400[0x3b0/4];
+        u32 pipe_0x6800[0x2f0/4];
+        u32 pipe_0x6c00[0x030/4];
+        u32 pipe_0x7000[0x130/4];
+        u32 pipe_0x7400[0x0c0/4];
+        u32 pipe_0x7800[0x0c0/4];
+};
+
+static int nv10_graph_ctx_regs[] = {
+        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,
+        NV04_PGRAPH_DMA_LENGTH,
+        NV04_PGRAPH_DMA_MISC,
+        NV10_PGRAPH_DMA_PITCH,
+        NV04_PGRAPH_BOFFSET0,
+        NV04_PGRAPH_BBASE0,
+        NV04_PGRAPH_BLIMIT0,
+        NV04_PGRAPH_BOFFSET1,
+        NV04_PGRAPH_BBASE1,
+        NV04_PGRAPH_BLIMIT1,
+        NV04_PGRAPH_BOFFSET2,
+        NV04_PGRAPH_BBASE2,
+        NV04_PGRAPH_BLIMIT2,
+        NV04_PGRAPH_BOFFSET3,
+        NV04_PGRAPH_BBASE3,
+        NV04_PGRAPH_BLIMIT3,
+        NV04_PGRAPH_BOFFSET4,
+        NV04_PGRAPH_BBASE4,
+        NV04_PGRAPH_BLIMIT4,
+        NV04_PGRAPH_BOFFSET5,
+        NV04_PGRAPH_BBASE5,
+        NV04_PGRAPH_BLIMIT5,
+        NV04_PGRAPH_BPITCH0,
+        NV04_PGRAPH_BPITCH1,
+        NV04_PGRAPH_BPITCH2,
+        NV04_PGRAPH_BPITCH3,
+        NV04_PGRAPH_BPITCH4,
+        NV10_PGRAPH_SURFACE,
+        NV10_PGRAPH_STATE,
+        NV04_PGRAPH_BSWIZZLE2,
+        NV04_PGRAPH_BSWIZZLE5,
+        NV04_PGRAPH_BPIXEL,
+        NV10_PGRAPH_NOTIFY,
+        NV04_PGRAPH_PATT_COLOR0,
+        NV04_PGRAPH_PATT_COLOR1,
+        NV04_PGRAPH_PATT_COLORRAM, /* 64 values from 0x400900 to 0x4009fc */
+        0x00400904,
+        0x00400908,
+        0x0040090c,
+        0x00400910,
+        0x00400914,
+        0x00400918,
+        0x0040091c,
+        0x00400920,
+        0x00400924,
+        0x00400928,
+        0x0040092c,
+        0x00400930,
+        0x00400934,
+        0x00400938,
+        0x0040093c,
+        0x00400940,
+        0x00400944,
+        0x00400948,
+        0x0040094c,
+        0x00400950,
+        0x00400954,
+        0x00400958,
+        0x0040095c,
+        0x00400960,
+        0x00400964,
+        0x00400968,
+        0x0040096c,
+        0x00400970,
+        0x00400974,
+        0x00400978,
+        0x0040097c,
+        0x00400980,
+        0x00400984,
+        0x00400988,
+        0x0040098c,
+        0x00400990,
+        0x00400994,
+        0x00400998,
+        0x0040099c,
+        0x004009a0,
+        0x004009a4,
+        0x004009a8,
+        0x004009ac,
+        0x004009b0,
+        0x004009b4,
+        0x004009b8,
+        0x004009bc,
+        0x004009c0,
+        0x004009c4,
+        0x004009c8,
+        0x004009cc,
+        0x004009d0,
+        0x004009d4,
+        0x004009d8,
+        0x004009dc,
+        0x004009e0,
+        0x004009e4,
+        0x004009e8,
+        0x004009ec,
+        0x004009f0,
+        0x004009f4,
+        0x004009f8,
+        0x004009fc,
+        NV04_PGRAPH_PATTERN,    /* 2 values from 0x400808 to 0x40080c */
+        0x0040080c,
+        NV04_PGRAPH_PATTERN_SHAPE,
+        NV03_PGRAPH_MONO_COLOR0,
+        NV04_PGRAPH_ROP3,
+        NV04_PGRAPH_CHROMA,
+        NV04_PGRAPH_BETA_AND,
+        NV04_PGRAPH_BETA_PREMULT,
+        0x00400e70,
+        0x00400e74,
+        0x00400e78,
+        0x00400e7c,
+        0x00400e80,
+        0x00400e84,
+        0x00400e88,
+        0x00400e8c,
+        0x00400ea0,
+        0x00400ea4,
+        0x00400ea8,
+        0x00400e90,
+        0x00400e94,
+        0x00400e98,
+        0x00400e9c,
+        NV10_PGRAPH_WINDOWCLIP_HORIZONTAL, /* 8 values from 0x400f00-0x400f1c */
+        NV10_PGRAPH_WINDOWCLIP_VERTICAL,   /* 8 values from 0x400f20-0x400f3c */
+        0x00400f04,
+        0x00400f24,
+        0x00400f08,
+        0x00400f28,
+        0x00400f0c,
+        0x00400f2c,
+        0x00400f10,
+        0x00400f30,
+        0x00400f14,
+        0x00400f34,
+        0x00400f18,
+        0x00400f38,
+        0x00400f1c,
+        0x00400f3c,
+        NV10_PGRAPH_XFMODE0,
+        NV10_PGRAPH_XFMODE1,
+        NV10_PGRAPH_GLOBALSTATE0,
+        NV10_PGRAPH_GLOBALSTATE1,
+        NV04_PGRAPH_STORED_FMT,
+        NV04_PGRAPH_SOURCE_COLOR,
+        NV03_PGRAPH_ABS_X_RAM,  /* 32 values from 0x400400 to 0x40047c */
+        NV03_PGRAPH_ABS_Y_RAM,  /* 32 values from 0x400480 to 0x4004fc */
+        0x00400404,
+        0x00400484,
+        0x00400408,
+        0x00400488,
+        0x0040040c,
+        0x0040048c,
+        0x00400410,
+        0x00400490,
+        0x00400414,
+        0x00400494,
+        0x00400418,
+        0x00400498,
+        0x0040041c,
+        0x0040049c,
+        0x00400420,
+        0x004004a0,
+        0x00400424,
+        0x004004a4,
+        0x00400428,
+        0x004004a8,
+        0x0040042c,
+        0x004004ac,
+        0x00400430,
+        0x004004b0,
+        0x00400434,
+        0x004004b4,
+        0x00400438,
+        0x004004b8,
+        0x0040043c,
+        0x004004bc,
+        0x00400440,
+        0x004004c0,
+        0x00400444,
+        0x004004c4,
+        0x00400448,
+        0x004004c8,
+        0x0040044c,
+        0x004004cc,
+        0x00400450,
+        0x004004d0,
+        0x00400454,
+        0x004004d4,
+        0x00400458,
+        0x004004d8,
+        0x0040045c,
+        0x004004dc,
+        0x00400460,
+        0x004004e0,
+        0x00400464,
+        0x004004e4,
+        0x00400468,
+        0x004004e8,
+        0x0040046c,
+        0x004004ec,
+        0x00400470,
+        0x004004f0,
+        0x00400474,
+        0x004004f4,
+        0x00400478,
+        0x004004f8,
+        0x0040047c,
+        0x004004fc,
+        NV03_PGRAPH_ABS_UCLIP_XMIN,
+        NV03_PGRAPH_ABS_UCLIP_XMAX,
+        NV03_PGRAPH_ABS_UCLIP_YMIN,
+        NV03_PGRAPH_ABS_UCLIP_YMAX,
+        0x00400550,
+        0x00400558,
+        0x00400554,
+        0x0040055c,
+        NV03_PGRAPH_ABS_UCLIPA_XMIN,
+        NV03_PGRAPH_ABS_UCLIPA_XMAX,
+        NV03_PGRAPH_ABS_UCLIPA_YMIN,
+        NV03_PGRAPH_ABS_UCLIPA_YMAX,
+        NV03_PGRAPH_ABS_ICLIP_XMAX,
+        NV03_PGRAPH_ABS_ICLIP_YMAX,
+        NV03_PGRAPH_XY_LOGIC_MISC0,
+        NV03_PGRAPH_XY_LOGIC_MISC1,
+        NV03_PGRAPH_XY_LOGIC_MISC2,
+        NV03_PGRAPH_XY_LOGIC_MISC3,
+        NV03_PGRAPH_CLIPX_0,
+        NV03_PGRAPH_CLIPX_1,
+        NV03_PGRAPH_CLIPY_0,
+        NV03_PGRAPH_CLIPY_1,
+        NV10_PGRAPH_COMBINER0_IN_ALPHA,
+        NV10_PGRAPH_COMBINER1_IN_ALPHA,
+        NV10_PGRAPH_COMBINER0_IN_RGB,
+        NV10_PGRAPH_COMBINER1_IN_RGB,
+        NV10_PGRAPH_COMBINER_COLOR0,
+        NV10_PGRAPH_COMBINER_COLOR1,
+        NV10_PGRAPH_COMBINER0_OUT_ALPHA,
+        NV10_PGRAPH_COMBINER1_OUT_ALPHA,
+        NV10_PGRAPH_COMBINER0_OUT_RGB,
+        NV10_PGRAPH_COMBINER1_OUT_RGB,
+        NV10_PGRAPH_COMBINER_FINAL0,
+        NV10_PGRAPH_COMBINER_FINAL1,
+        0x00400e00,
+        0x00400e04,
+        0x00400e08,
+        0x00400e0c,
+        0x00400e10,
+        0x00400e14,
+        0x00400e18,
+        0x00400e1c,
+        0x00400e20,
+        0x00400e24,
+        0x00400e28,
+        0x00400e2c,
+        0x00400e30,
+        0x00400e34,
+        0x00400e38,
+        0x00400e3c,
+        NV04_PGRAPH_PASSTHRU_0,
+        NV04_PGRAPH_PASSTHRU_1,
+        NV04_PGRAPH_PASSTHRU_2,
+        NV10_PGRAPH_DIMX_TEXTURE,
+        NV10_PGRAPH_WDIMX_TEXTURE,
+        NV10_PGRAPH_DVD_COLORFMT,
+        NV10_PGRAPH_SCALED_FORMAT,
+        NV04_PGRAPH_MISC24_0,
+        NV04_PGRAPH_MISC24_1,
+        NV04_PGRAPH_MISC24_2,
+        NV03_PGRAPH_X_MISC,
+        NV03_PGRAPH_Y_MISC,
+        NV04_PGRAPH_VALID1,
+        NV04_PGRAPH_VALID2,
+};
+
+static int nv17_graph_ctx_regs[] = {
+        NV10_PGRAPH_DEBUG_4,
+        0x004006b0,
+        0x00400eac,
+        0x00400eb0,
+        0x00400eb4,
+        0x00400eb8,
+        0x00400ebc,
+        0x00400ec0,
+        0x00400ec4,
+        0x00400ec8,
+        0x00400ecc,
+        0x00400ed0,
+        0x00400ed4,
+        0x00400ed8,
+        0x00400edc,
+        0x00400ee0,
+        0x00400a00,
+        0x00400a04,
+};
+
+struct nv10_graph_priv {
+        struct nouveau_graph base;
+        struct nv10_graph_chan *chan[32];
+        spinlock_t lock;
+};
+
+struct nv10_graph_chan {
+        struct nouveau_object base;
+        int chid;
+        int nv10[ARRAY_SIZE(nv10_graph_ctx_regs)];
+        int nv17[ARRAY_SIZE(nv17_graph_ctx_regs)];
+        struct pipe_state pipe_state;
+        u32 lma_window[4];
+};
+
+
+static inline struct nv10_graph_priv *
+nv10_graph_priv(struct nv10_graph_chan *chan)
+{
+        return (void *)nv_object(chan)->engine;
+}
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+#define PIPE_SAVE(priv, state, addr)                                    \
+        do {                                                            \
+                int __i;                                                \
+                nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, addr);          \
+                for (__i = 0; __i < ARRAY_SIZE(state); __i++)           \
+                        state[__i] = nv_rd32(priv, NV10_PGRAPH_PIPE_DATA); \
+        } while (0)
+
+#define PIPE_RESTORE(priv, state, addr)                                 \
+        do {                                                            \
+                int __i;                                                \
+                nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, addr);          \
+                for (__i = 0; __i < ARRAY_SIZE(state); __i++)           \
+                        nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, state[__i]); \
+        } while (0)
+
+static struct nouveau_oclass
+nv10_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs }, /* null */
+        { 0x0039, &nv04_graph_ofuncs }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs }, /* pattern */
+        { 0x004a, &nv04_graph_ofuncs }, /* gdi */
+        { 0x0052, &nv04_graph_ofuncs }, /* swzsurf */
+        { 0x005f, &nv04_graph_ofuncs }, /* blit */
+        { 0x0062, &nv04_graph_ofuncs }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs }, /* ifc */
+        { 0x009f, &nv04_graph_ofuncs }, /* blit */
+        { 0x0093, &nv04_graph_ofuncs }, /* surf3d */
+        { 0x0094, &nv04_graph_ofuncs }, /* ttri */
+        { 0x0095, &nv04_graph_ofuncs }, /* mtri */
+        { 0x0056, &nv04_graph_ofuncs }, /* celcius */
+        {},
+};
+
+static struct nouveau_oclass
+nv15_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs }, /* null */
+        { 0x0039, &nv04_graph_ofuncs }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs }, /* pattern */
+        { 0x004a, &nv04_graph_ofuncs }, /* gdi */
+        { 0x0052, &nv04_graph_ofuncs }, /* swzsurf */
+        { 0x005f, &nv04_graph_ofuncs }, /* blit */
+        { 0x0062, &nv04_graph_ofuncs }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs }, /* ifc */
+        { 0x009f, &nv04_graph_ofuncs }, /* blit */
+        { 0x0093, &nv04_graph_ofuncs }, /* surf3d */
+        { 0x0094, &nv04_graph_ofuncs }, /* ttri */
+        { 0x0095, &nv04_graph_ofuncs }, /* mtri */
+        { 0x0096, &nv04_graph_ofuncs }, /* celcius */
+        {},
+};
+
+static int
+nv17_graph_mthd_lma_window(struct nouveau_object *object, u32 mthd,
+                           void *args, u32 size)
+{
+        struct nv10_graph_chan *chan = (void *)object->parent;
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        struct pipe_state *pipe = &chan->pipe_state;
+        u32 pipe_0x0040[1], pipe_0x64c0[8], pipe_0x6a80[3], pipe_0x6ab0[3];
+        u32 xfmode0, xfmode1;
+        u32 data = *(u32 *)args;
+        int i;
+
+        chan->lma_window[(mthd - 0x1638) / 4] = data;
+
+        if (mthd != 0x1644)
+                return 0;
+
+        nv04_graph_idle(priv);
+
+        PIPE_SAVE(priv, pipe_0x0040, 0x0040);
+        PIPE_SAVE(priv, pipe->pipe_0x0200, 0x0200);
+
+        PIPE_RESTORE(priv, chan->lma_window, 0x6790);
+
+        nv04_graph_idle(priv);
+
+        xfmode0 = nv_rd32(priv, NV10_PGRAPH_XFMODE0);
+        xfmode1 = nv_rd32(priv, NV10_PGRAPH_XFMODE1);
+
+        PIPE_SAVE(priv, pipe->pipe_0x4400, 0x4400);
+        PIPE_SAVE(priv, pipe_0x64c0, 0x64c0);
+        PIPE_SAVE(priv, pipe_0x6ab0, 0x6ab0);
+        PIPE_SAVE(priv, pipe_0x6a80, 0x6a80);
+
+        nv04_graph_idle(priv);
+
+        nv_wr32(priv, NV10_PGRAPH_XFMODE0, 0x10000000);
+        nv_wr32(priv, NV10_PGRAPH_XFMODE1, 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x000064c0);
+        for (i = 0; i < 4; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
+        for (i = 0; i < 4; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000000);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x00006ab0);
+        for (i = 0; i < 3; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x00006a80);
+        for (i = 0; i < 3; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000000);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x00000040);
+        nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000008);
+
+        PIPE_RESTORE(priv, pipe->pipe_0x0200, 0x0200);
+
+        nv04_graph_idle(priv);
+
+        PIPE_RESTORE(priv, pipe_0x0040, 0x0040);
+
+        nv_wr32(priv, NV10_PGRAPH_XFMODE0, xfmode0);
+        nv_wr32(priv, NV10_PGRAPH_XFMODE1, xfmode1);
+
+        PIPE_RESTORE(priv, pipe_0x64c0, 0x64c0);
+        PIPE_RESTORE(priv, pipe_0x6ab0, 0x6ab0);
+        PIPE_RESTORE(priv, pipe_0x6a80, 0x6a80);
+        PIPE_RESTORE(priv, pipe->pipe_0x4400, 0x4400);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x000000c0);
+        nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000000);
+
+        nv04_graph_idle(priv);
+
+        return 0;
+}
+
+static int
+nv17_graph_mthd_lma_enable(struct nouveau_object *object, u32 mthd,
+                           void *args, u32 size)
+{
+        struct nv10_graph_chan *chan = (void *)object->parent;
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+
+        nv04_graph_idle(priv);
+
+        nv_mask(priv, NV10_PGRAPH_DEBUG_4, 0x00000100, 0x00000100);
+        nv_mask(priv, 0x4006b0, 0x08000000, 0x08000000);
+        return 0;
+}
+
+static struct nouveau_omthds
+nv17_celcius_omthds[] = {
+        { 0x1638, nv17_graph_mthd_lma_window },
+        { 0x163c, nv17_graph_mthd_lma_window },
+        { 0x1640, nv17_graph_mthd_lma_window },
+        { 0x1644, nv17_graph_mthd_lma_window },
+        { 0x1658, nv17_graph_mthd_lma_enable },
+        {}
+};
+
+static struct nouveau_oclass
+nv17_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs }, /* null */
+        { 0x0039, &nv04_graph_ofuncs }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs }, /* pattern */
+        { 0x004a, &nv04_graph_ofuncs }, /* gdi */
+        { 0x0052, &nv04_graph_ofuncs }, /* swzsurf */
+        { 0x005f, &nv04_graph_ofuncs }, /* blit */
+        { 0x0062, &nv04_graph_ofuncs }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs }, /* ifc */
+        { 0x009f, &nv04_graph_ofuncs }, /* blit */
+        { 0x0093, &nv04_graph_ofuncs }, /* surf3d */
+        { 0x0094, &nv04_graph_ofuncs }, /* ttri */
+        { 0x0095, &nv04_graph_ofuncs }, /* mtri */
+        { 0x0099, &nv04_graph_ofuncs, nv17_celcius_omthds },
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static struct nv10_graph_chan *
+nv10_graph_channel(struct nv10_graph_priv *priv)
+{
+        struct nv10_graph_chan *chan = NULL;
+        if (nv_rd32(priv, 0x400144) & 0x00010000) {
+                int chid = nv_rd32(priv, 0x400148) >> 24;
+                if (chid < ARRAY_SIZE(priv->chan))
+                        chan = priv->chan[chid];
+        }
+        return chan;
+}
+
+static void
+nv10_graph_save_pipe(struct nv10_graph_chan *chan)
+{
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        struct pipe_state *pipe = &chan->pipe_state;
+
+        PIPE_SAVE(priv, pipe->pipe_0x4400, 0x4400);
+        PIPE_SAVE(priv, pipe->pipe_0x0200, 0x0200);
+        PIPE_SAVE(priv, pipe->pipe_0x6400, 0x6400);
+        PIPE_SAVE(priv, pipe->pipe_0x6800, 0x6800);
+        PIPE_SAVE(priv, pipe->pipe_0x6c00, 0x6c00);
+        PIPE_SAVE(priv, pipe->pipe_0x7000, 0x7000);
+        PIPE_SAVE(priv, pipe->pipe_0x7400, 0x7400);
+        PIPE_SAVE(priv, pipe->pipe_0x7800, 0x7800);
+        PIPE_SAVE(priv, pipe->pipe_0x0040, 0x0040);
+        PIPE_SAVE(priv, pipe->pipe_0x0000, 0x0000);
+}
+
+static void
+nv10_graph_load_pipe(struct nv10_graph_chan *chan)
+{
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        struct pipe_state *pipe = &chan->pipe_state;
+        u32 xfmode0, xfmode1;
+        int i;
+
+        nv04_graph_idle(priv);
+        /* XXX check haiku comments */
+        xfmode0 = nv_rd32(priv, NV10_PGRAPH_XFMODE0);
+        xfmode1 = nv_rd32(priv, NV10_PGRAPH_XFMODE1);
+        nv_wr32(priv, NV10_PGRAPH_XFMODE0, 0x10000000);
+        nv_wr32(priv, NV10_PGRAPH_XFMODE1, 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x000064c0);
+        for (i = 0; i < 4; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
+        for (i = 0; i < 4; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000000);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x00006ab0);
+        for (i = 0; i < 3; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x00006a80);
+        for (i = 0; i < 3; i++)
+                nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000000);
+
+        nv_wr32(priv, NV10_PGRAPH_PIPE_ADDRESS, 0x00000040);
+        nv_wr32(priv, NV10_PGRAPH_PIPE_DATA, 0x00000008);
+
+
+        PIPE_RESTORE(priv, pipe->pipe_0x0200, 0x0200);
+        nv04_graph_idle(priv);
+
+        /* restore XFMODE */
+        nv_wr32(priv, NV10_PGRAPH_XFMODE0, xfmode0);
+        nv_wr32(priv, NV10_PGRAPH_XFMODE1, xfmode1);
+        PIPE_RESTORE(priv, pipe->pipe_0x6400, 0x6400);
+        PIPE_RESTORE(priv, pipe->pipe_0x6800, 0x6800);
+        PIPE_RESTORE(priv, pipe->pipe_0x6c00, 0x6c00);
+        PIPE_RESTORE(priv, pipe->pipe_0x7000, 0x7000);
+        PIPE_RESTORE(priv, pipe->pipe_0x7400, 0x7400);
+        PIPE_RESTORE(priv, pipe->pipe_0x7800, 0x7800);
+        PIPE_RESTORE(priv, pipe->pipe_0x4400, 0x4400);
+        PIPE_RESTORE(priv, pipe->pipe_0x0000, 0x0000);
+        PIPE_RESTORE(priv, pipe->pipe_0x0040, 0x0040);
+        nv04_graph_idle(priv);
+}
+
+static void
+nv10_graph_create_pipe(struct nv10_graph_chan *chan)
+{
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        struct pipe_state *pipe_state = &chan->pipe_state;
+        u32 *pipe_state_addr;
+        int i;
+#define PIPE_INIT(addr) \
+        do { \
+                pipe_state_addr = pipe_state->pipe_##addr; \
+        } while (0)
+#define PIPE_INIT_END(addr) \
+        do { \
+                u32 *__end_addr = pipe_state->pipe_##addr + \
+                                ARRAY_SIZE(pipe_state->pipe_##addr); \
+                if (pipe_state_addr != __end_addr) \
+                        nv_error(priv, "incomplete pipe init for 0x%x :  %p/%p\n", \
+                                addr, pipe_state_addr, __end_addr); \
+        } while (0)
+#define NV_WRITE_PIPE_INIT(value) *(pipe_state_addr++) = value
+
+        PIPE_INIT(0x0200);
+        for (i = 0; i < 48; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x0200);
+
+        PIPE_INIT(0x6400);
+        for (i = 0; i < 211; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        NV_WRITE_PIPE_INIT(0x40000000);
+        NV_WRITE_PIPE_INIT(0x40000000);
+        NV_WRITE_PIPE_INIT(0x40000000);
+        NV_WRITE_PIPE_INIT(0x40000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x3f000000);
+        NV_WRITE_PIPE_INIT(0x3f000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        PIPE_INIT_END(0x6400);
+
+        PIPE_INIT(0x6800);
+        for (i = 0; i < 162; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x3f800000);
+        for (i = 0; i < 25; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x6800);
+
+        PIPE_INIT(0x6c00);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0xbf800000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x6c00);
+
+        PIPE_INIT(0x7000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x00000000);
+        NV_WRITE_PIPE_INIT(0x7149f2ca);
+        for (i = 0; i < 35; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x7000);
+
+        PIPE_INIT(0x7400);
+        for (i = 0; i < 48; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x7400);
+
+        PIPE_INIT(0x7800);
+        for (i = 0; i < 48; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x7800);
+
+        PIPE_INIT(0x4400);
+        for (i = 0; i < 32; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x4400);
+
+        PIPE_INIT(0x0000);
+        for (i = 0; i < 16; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x0000);
+
+        PIPE_INIT(0x0040);
+        for (i = 0; i < 4; i++)
+                NV_WRITE_PIPE_INIT(0x00000000);
+        PIPE_INIT_END(0x0040);
+
+#undef PIPE_INIT
+#undef PIPE_INIT_END
+#undef NV_WRITE_PIPE_INIT
+}
+
+static int
+nv10_graph_ctx_regs_find_offset(struct nv10_graph_priv *priv, int reg)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(nv10_graph_ctx_regs); i++) {
+                if (nv10_graph_ctx_regs[i] == reg)
+                        return i;
+        }
+        nv_error(priv, "unknow offset nv10_ctx_regs %d\n", reg);
+        return -1;
+}
+
+static int
+nv17_graph_ctx_regs_find_offset(struct nv10_graph_priv *priv, int reg)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(nv17_graph_ctx_regs); i++) {
+                if (nv17_graph_ctx_regs[i] == reg)
+                        return i;
+        }
+        nv_error(priv, "unknow offset nv17_ctx_regs %d\n", reg);
+        return -1;
+}
+
+static void
+nv10_graph_load_dma_vtxbuf(struct nv10_graph_chan *chan, int chid, u32 inst)
+{
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        u32 st2, st2_dl, st2_dh, fifo_ptr, fifo[0x60/4];
+        u32 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(priv, 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(priv, NV10_PGRAPH_CTX_USER);
+        for (i = 0; i < 5; i++)
+                ctx_switch[i] = nv_rd32(priv, NV10_PGRAPH_CTX_SWITCH(i));
+
+        /* Save the FIFO state */
+        st2 = nv_rd32(priv, NV10_PGRAPH_FFINTFC_ST2);
+        st2_dl = nv_rd32(priv, NV10_PGRAPH_FFINTFC_ST2_DL);
+        st2_dh = nv_rd32(priv, NV10_PGRAPH_FFINTFC_ST2_DH);
+        fifo_ptr = nv_rd32(priv, NV10_PGRAPH_FFINTFC_FIFO_PTR);
+
+        for (i = 0; i < ARRAY_SIZE(fifo); i++)
+                fifo[i] = nv_rd32(priv, 0x4007a0 + 4 * i);
+
+        /* Switch to the celsius subchannel */
+        for (i = 0; i < 5; i++)
+                nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(i),
+                        nv_rd32(priv, NV10_PGRAPH_CTX_CACHE(subchan, i)));
+        nv_mask(priv, NV10_PGRAPH_CTX_USER, 0xe000, subchan << 13);
+
+        /* Inject NV10TCL_DMA_VTXBUF */
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_FIFO_PTR, 0);
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_ST2,
+                0x2c000000 | chid << 20 | subchan << 16 | 0x18c);
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_ST2_DL, inst);
+        nv_mask(priv, NV10_PGRAPH_CTX_CONTROL, 0, 0x10000);
+        nv_mask(priv, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
+        nv_mask(priv, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
+
+        /* Restore the FIFO state */
+        for (i = 0; i < ARRAY_SIZE(fifo); i++)
+                nv_wr32(priv, 0x4007a0 + 4 * i, fifo[i]);
+
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_FIFO_PTR, fifo_ptr);
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_ST2, st2);
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_ST2_DL, st2_dl);
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_ST2_DH, st2_dh);
+
+        /* Restore the current ctx object */
+        for (i = 0; i < 5; i++)
+                nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(i), ctx_switch[i]);
+        nv_wr32(priv, NV10_PGRAPH_CTX_USER, ctx_user);
+}
+
+static int
+nv10_graph_load_context(struct nv10_graph_chan *chan, int chid)
+{
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        u32 inst;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(nv10_graph_ctx_regs); i++)
+                nv_wr32(priv, nv10_graph_ctx_regs[i], chan->nv10[i]);
+
+        if (nv_device(priv)->chipset >= 0x17) {
+                for (i = 0; i < ARRAY_SIZE(nv17_graph_ctx_regs); i++)
+                        nv_wr32(priv, nv17_graph_ctx_regs[i], chan->nv17[i]);
+        }
+
+        nv10_graph_load_pipe(chan);
+
+        inst = nv_rd32(priv, NV10_PGRAPH_GLOBALSTATE1) & 0xffff;
+        nv10_graph_load_dma_vtxbuf(chan, chid, inst);
+
+        nv_wr32(priv, NV10_PGRAPH_CTX_CONTROL, 0x10010100);
+        nv_mask(priv, NV10_PGRAPH_CTX_USER, 0xff000000, chid << 24);
+        nv_mask(priv, NV10_PGRAPH_FFINTFC_ST2, 0x30000000, 0x00000000);
+        return 0;
+}
+
+static int
+nv10_graph_unload_context(struct nv10_graph_chan *chan)
+{
+        struct nv10_graph_priv *priv = nv10_graph_priv(chan);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(nv10_graph_ctx_regs); i++)
+                chan->nv10[i] = nv_rd32(priv, nv10_graph_ctx_regs[i]);
+
+        if (nv_device(priv)->chipset >= 0x17) {
+                for (i = 0; i < ARRAY_SIZE(nv17_graph_ctx_regs); i++)
+                        chan->nv17[i] = nv_rd32(priv, nv17_graph_ctx_regs[i]);
+        }
+
+        nv10_graph_save_pipe(chan);
+
+        nv_wr32(priv, NV10_PGRAPH_CTX_CONTROL, 0x10000000);
+        nv_mask(priv, NV10_PGRAPH_CTX_USER, 0xff000000, 0x1f000000);
+        return 0;
+}
+
+static void
+nv10_graph_context_switch(struct nv10_graph_priv *priv)
+{
+        struct nv10_graph_chan *prev = NULL;
+        struct nv10_graph_chan *next = NULL;
+        unsigned long flags;
+        int chid;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        nv04_graph_idle(priv);
+
+        /* If previous context is valid, we need to save it */
+        prev = nv10_graph_channel(priv);
+        if (prev)
+                nv10_graph_unload_context(prev);
+
+        /* load context for next channel */
+        chid = (nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR) >> 20) & 0x1f;
+        next = priv->chan[chid];
+        if (next)
+                nv10_graph_load_context(next, chid);
+
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+#define NV_WRITE_CTX(reg, val) do { \
+        int offset = nv10_graph_ctx_regs_find_offset(priv, reg); \
+        if (offset > 0) \
+                chan->nv10[offset] = val; \
+        } while (0)
+
+#define NV17_WRITE_CTX(reg, val) do { \
+        int offset = nv17_graph_ctx_regs_find_offset(priv, reg); \
+        if (offset > 0) \
+                chan->nv17[offset] = val; \
+        } while (0)
+
+static int
+nv10_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nouveau_fifo_chan *fifo = (void *)parent;
+        struct nv10_graph_priv *priv = (void *)engine;
+        struct nv10_graph_chan *chan;
+        unsigned long flags;
+        int ret;
+
+        ret = nouveau_object_create(parent, engine, oclass, 0, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (priv->chan[fifo->chid]) {
+                *pobject = nv_object(priv->chan[fifo->chid]);
+                atomic_inc(&(*pobject)->refcount);
+                spin_unlock_irqrestore(&priv->lock, flags);
+                nouveau_object_destroy(&chan->base);
+                return 1;
+        }
+
+        NV_WRITE_CTX(0x00400e88, 0x08000000);
+        NV_WRITE_CTX(0x00400e9c, 0x4b7fffff);
+        NV_WRITE_CTX(NV03_PGRAPH_XY_LOGIC_MISC0, 0x0001ffff);
+        NV_WRITE_CTX(0x00400e10, 0x00001000);
+        NV_WRITE_CTX(0x00400e14, 0x00001000);
+        NV_WRITE_CTX(0x00400e30, 0x00080008);
+        NV_WRITE_CTX(0x00400e34, 0x00080008);
+        if (nv_device(priv)->chipset >= 0x17) {
+                /* is it really needed ??? */
+                NV17_WRITE_CTX(NV10_PGRAPH_DEBUG_4,
+                                        nv_rd32(priv, NV10_PGRAPH_DEBUG_4));
+                NV17_WRITE_CTX(0x004006b0, nv_rd32(priv, 0x004006b0));
+                NV17_WRITE_CTX(0x00400eac, 0x0fff0000);
+                NV17_WRITE_CTX(0x00400eb0, 0x0fff0000);
+                NV17_WRITE_CTX(0x00400ec0, 0x00000080);
+                NV17_WRITE_CTX(0x00400ed0, 0x00000080);
+        }
+        NV_WRITE_CTX(NV10_PGRAPH_CTX_USER, chan->chid << 24);
+
+        nv10_graph_create_pipe(chan);
+
+        priv->chan[fifo->chid] = chan;
+        chan->chid = fifo->chid;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 0;
+}
+
+static void
+nv10_graph_context_dtor(struct nouveau_object *object)
+{
+        struct nv10_graph_priv *priv = (void *)object->engine;
+        struct nv10_graph_chan *chan = (void *)object;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->chan[chan->chid] = NULL;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        nouveau_object_destroy(&chan->base);
+}
+
+static int
+nv10_graph_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv10_graph_priv *priv = (void *)object->engine;
+        struct nv10_graph_chan *chan = (void *)object;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        nv_mask(priv, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
+        if (nv10_graph_channel(priv) == chan)
+                nv10_graph_unload_context(chan);
+        nv_mask(priv, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        return nouveau_object_fini(&chan->base, suspend);
+}
+
+static struct nouveau_oclass
+nv10_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_graph_context_ctor,
+                .dtor = nv10_graph_context_dtor,
+                .init = nouveau_object_init,
+                .fini = nv10_graph_context_fini,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static void
+nv10_graph_tile_prog(struct nouveau_engine *engine, int i)
+{
+        struct nouveau_fb_tile *tile = &nouveau_fb(engine)->tile.region[i];
+        struct nouveau_fifo *pfifo = nouveau_fifo(engine);
+        struct nv10_graph_priv *priv = (void *)engine;
+        unsigned long flags;
+
+        pfifo->pause(pfifo, &flags);
+        nv04_graph_idle(priv);
+
+        nv_wr32(priv, NV10_PGRAPH_TLIMIT(i), tile->limit);
+        nv_wr32(priv, NV10_PGRAPH_TSIZE(i), tile->pitch);
+        nv_wr32(priv, NV10_PGRAPH_TILE(i), tile->addr);
+
+        pfifo->start(pfifo, &flags);
+}
+
+const struct nouveau_bitfield nv10_graph_intr_name[] = {
+        { NV_PGRAPH_INTR_NOTIFY, "NOTIFY" },
+        { NV_PGRAPH_INTR_ERROR,  "ERROR"  },
+        {}
+};
+
+const struct nouveau_bitfield nv10_graph_nstatus[] = {
+        { NV10_PGRAPH_NSTATUS_STATE_IN_USE,       "STATE_IN_USE" },
+        { NV10_PGRAPH_NSTATUS_INVALID_STATE,      "INVALID_STATE" },
+        { NV10_PGRAPH_NSTATUS_BAD_ARGUMENT,       "BAD_ARGUMENT" },
+        { NV10_PGRAPH_NSTATUS_PROTECTION_FAULT,   "PROTECTION_FAULT" },
+        {}
+};
+
+static void
+nv10_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nv10_graph_priv *priv = (void *)subdev;
+        struct nv10_graph_chan *chan = NULL;
+        struct nouveau_namedb *namedb = NULL;
+        struct nouveau_handle *handle = NULL;
+        u32 stat = nv_rd32(priv, NV03_PGRAPH_INTR);
+        u32 nsource = nv_rd32(priv, NV03_PGRAPH_NSOURCE);
+        u32 nstatus = nv_rd32(priv, NV03_PGRAPH_NSTATUS);
+        u32 addr = nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR);
+        u32 chid = (addr & 0x01f00000) >> 20;
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 mthd = (addr & 0x00001ffc);
+        u32 data = nv_rd32(priv, NV04_PGRAPH_TRAPPED_DATA);
+        u32 class = nv_rd32(priv, 0x400160 + subc * 4) & 0xfff;
+        u32 show = stat;
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        chan = priv->chan[chid];
+        if (chan)
+                namedb = (void *)nv_pclass(nv_object(chan), NV_NAMEDB_CLASS);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        if (stat & NV_PGRAPH_INTR_ERROR) {
+                if (chan && (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD)) {
+                        handle = nouveau_namedb_get_class(namedb, class);
+                        if (handle && !nv_call(handle->object, mthd, data))
+                                show &= ~NV_PGRAPH_INTR_ERROR;
+                }
+        }
+
+        if (stat & NV_PGRAPH_INTR_CONTEXT_SWITCH) {
+                nv_wr32(priv, NV03_PGRAPH_INTR, NV_PGRAPH_INTR_CONTEXT_SWITCH);
+                stat &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
+                show &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
+                nv10_graph_context_switch(priv);
+        }
+
+        nv_wr32(priv, NV03_PGRAPH_INTR, stat);
+        nv_wr32(priv, NV04_PGRAPH_FIFO, 0x00000001);
+
+        if (show) {
+                nv_error(priv, "");
+                nouveau_bitfield_print(nv10_graph_intr_name, show);
+                printk(" nsource:");
+                nouveau_bitfield_print(nv04_graph_nsource, nsource);
+                printk(" nstatus:");
+                nouveau_bitfield_print(nv10_graph_nstatus, nstatus);
+                printk("\n");
+                nv_error(priv, "ch %d/%d class 0x%04x "
+                               "mthd 0x%04x data 0x%08x\n",
+                         chid, subc, class, mthd, data);
+        }
+
+        nouveau_namedb_put(handle);
+}
+
+static int
+nv10_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv10_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv10_graph_intr;
+        nv_engine(priv)->cclass = &nv10_graph_cclass;
+
+        if (nv_device(priv)->chipset <= 0x10)
+                nv_engine(priv)->sclass = nv10_graph_sclass;
+        else
+        if (nv_device(priv)->chipset <  0x17 ||
+            nv_device(priv)->chipset == 0x1a)
+                nv_engine(priv)->sclass = nv15_graph_sclass;
+        else
+                nv_engine(priv)->sclass = nv17_graph_sclass;
+
+        nv_engine(priv)->tile_prog = nv10_graph_tile_prog;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+static void
+nv10_graph_dtor(struct nouveau_object *object)
+{
+        struct nv10_graph_priv *priv = (void *)object;
+        nouveau_graph_destroy(&priv->base);
+}
+
+static int
+nv10_graph_init(struct nouveau_object *object)
+{
+        struct nouveau_engine *engine = nv_engine(object);
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        struct nv10_graph_priv *priv = (void *)engine;
+        int ret, i;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
+        nv_wr32(priv, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
+
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x00000000);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_1, 0x00118700);
+        /* nv_wr32(priv, NV04_PGRAPH_DEBUG_2, 0x24E00810); */ /* 0x25f92ad9 */
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_2, 0x25f92ad9);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_3, 0x55DE0830 | (1 << 29) | (1 << 31));
+
+        if (nv_device(priv)->chipset >= 0x17) {
+                nv_wr32(priv, NV10_PGRAPH_DEBUG_4, 0x1f000000);
+                nv_wr32(priv, 0x400a10, 0x03ff3fb6);
+                nv_wr32(priv, 0x400838, 0x002f8684);
+                nv_wr32(priv, 0x40083c, 0x00115f3f);
+                nv_wr32(priv, 0x4006b0, 0x40000020);
+        } else {
+                nv_wr32(priv, NV10_PGRAPH_DEBUG_4, 0x00000000);
+        }
+
+        /* Turn all the tiling regions off. */
+        for (i = 0; i < pfb->tile.regions; i++)
+                engine->tile_prog(engine, i);
+
+        nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(0), 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(1), 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(2), 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(3), 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_CTX_SWITCH(4), 0x00000000);
+        nv_wr32(priv, NV10_PGRAPH_STATE, 0xFFFFFFFF);
+
+        nv_mask(priv, NV10_PGRAPH_CTX_USER, 0xff000000, 0x1f000000);
+        nv_wr32(priv, NV10_PGRAPH_CTX_CONTROL, 0x10000100);
+        nv_wr32(priv, NV10_PGRAPH_FFINTFC_ST2, 0x08000000);
+        return 0;
+}
+
+static int
+nv10_graph_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv10_graph_priv *priv = (void *)object;
+        return nouveau_graph_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv10_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_graph_ctor,
+                .dtor = nv10_graph_dtor,
+                .init = nv10_graph_init,
+                .fini = nv10_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv20.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv20.c
new file mode 100644
index 000000000000..8f3f619c4a78
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv20.c
@@ -0,0 +1,381 @@
+#include <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/handle.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/graph.h>
+#include <engine/fifo.h>
+
+#include "nv20.h"
+#include "regs.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv20_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv04_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv04_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv04_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs, NULL }, /* ifc */
+        { 0x0096, &nv04_graph_ofuncs, NULL }, /* celcius */
+        { 0x0097, &nv04_graph_ofuncs, NULL }, /* kelvin */
+        { 0x009e, &nv04_graph_ofuncs, NULL }, /* swzsurf */
+        { 0x009f, &nv04_graph_ofuncs, NULL }, /* imageblit */
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv20_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv20_graph_chan *chan;
+        int ret, i;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL,
+                                           0x37f0, 16, NVOBJ_FLAG_ZERO_ALLOC,
+                                           &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->chid = nouveau_fifo_chan(parent)->chid;
+
+        nv_wo32(chan, 0x0000, 0x00000001 | (chan->chid << 24));
+        nv_wo32(chan, 0x033c, 0xffff0000);
+        nv_wo32(chan, 0x03a0, 0x0fff0000);
+        nv_wo32(chan, 0x03a4, 0x0fff0000);
+        nv_wo32(chan, 0x047c, 0x00000101);
+        nv_wo32(chan, 0x0490, 0x00000111);
+        nv_wo32(chan, 0x04a8, 0x44400000);
+        for (i = 0x04d4; i <= 0x04e0; i += 4)
+                nv_wo32(chan, i, 0x00030303);
+        for (i = 0x04f4; i <= 0x0500; i += 4)
+                nv_wo32(chan, i, 0x00080000);
+        for (i = 0x050c; i <= 0x0518; i += 4)
+                nv_wo32(chan, i, 0x01012000);
+        for (i = 0x051c; i <= 0x0528; i += 4)
+                nv_wo32(chan, i, 0x000105b8);
+        for (i = 0x052c; i <= 0x0538; i += 4)
+                nv_wo32(chan, i, 0x00080008);
+        for (i = 0x055c; i <= 0x0598; i += 4)
+                nv_wo32(chan, i, 0x07ff0000);
+        nv_wo32(chan, 0x05a4, 0x4b7fffff);
+        nv_wo32(chan, 0x05fc, 0x00000001);
+        nv_wo32(chan, 0x0604, 0x00004000);
+        nv_wo32(chan, 0x0610, 0x00000001);
+        nv_wo32(chan, 0x0618, 0x00040000);
+        nv_wo32(chan, 0x061c, 0x00010000);
+        for (i = 0x1c1c; i <= 0x248c; i += 16) {
+                nv_wo32(chan, (i + 0), 0x10700ff9);
+                nv_wo32(chan, (i + 4), 0x0436086c);
+                nv_wo32(chan, (i + 8), 0x000c001b);
+        }
+        nv_wo32(chan, 0x281c, 0x3f800000);
+        nv_wo32(chan, 0x2830, 0x3f800000);
+        nv_wo32(chan, 0x285c, 0x40000000);
+        nv_wo32(chan, 0x2860, 0x3f800000);
+        nv_wo32(chan, 0x2864, 0x3f000000);
+        nv_wo32(chan, 0x286c, 0x40000000);
+        nv_wo32(chan, 0x2870, 0x3f800000);
+        nv_wo32(chan, 0x2878, 0xbf800000);
+        nv_wo32(chan, 0x2880, 0xbf800000);
+        nv_wo32(chan, 0x34a4, 0x000fe000);
+        nv_wo32(chan, 0x3530, 0x000003f8);
+        nv_wo32(chan, 0x3540, 0x002fe000);
+        for (i = 0x355c; i <= 0x3578; i += 4)
+                nv_wo32(chan, i, 0x001c527c);
+        return 0;
+}
+
+int
+nv20_graph_context_init(struct nouveau_object *object)
+{
+        struct nv20_graph_priv *priv = (void *)object->engine;
+        struct nv20_graph_chan *chan = (void *)object;
+        int ret;
+
+        ret = nouveau_graph_context_init(&chan->base);
+        if (ret)
+                return ret;
+
+        nv_wo32(priv->ctxtab, chan->chid * 4, nv_gpuobj(chan)->addr >> 4);
+        return 0;
+}
+
+int
+nv20_graph_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv20_graph_priv *priv = (void *)object->engine;
+        struct nv20_graph_chan *chan = (void *)object;
+        int chid = -1;
+
+        nv_mask(priv, 0x400720, 0x00000001, 0x00000000);
+        if (nv_rd32(priv, 0x400144) & 0x00010000)
+                chid = (nv_rd32(priv, 0x400148) & 0x1f000000) >> 24;
+        if (chan->chid == chid) {
+                nv_wr32(priv, 0x400784, nv_gpuobj(chan)->addr >> 4);
+                nv_wr32(priv, 0x400788, 0x00000002);
+                nv_wait(priv, 0x400700, 0xffffffff, 0x00000000);
+                nv_wr32(priv, 0x400144, 0x10000000);
+                nv_mask(priv, 0x400148, 0xff000000, 0x1f000000);
+        }
+        nv_mask(priv, 0x400720, 0x00000001, 0x00000001);
+
+        nv_wo32(priv->ctxtab, chan->chid * 4, 0x00000000);
+        return nouveau_graph_context_fini(&chan->base, suspend);
+}
+
+static struct nouveau_oclass
+nv20_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x20),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv20_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = nv20_graph_context_init,
+                .fini = nv20_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+void
+nv20_graph_tile_prog(struct nouveau_engine *engine, int i)
+{
+        struct nouveau_fb_tile *tile = &nouveau_fb(engine)->tile.region[i];
+        struct nouveau_fifo *pfifo = nouveau_fifo(engine);
+        struct nv20_graph_priv *priv = (void *)engine;
+        unsigned long flags;
+
+        pfifo->pause(pfifo, &flags);
+        nv04_graph_idle(priv);
+
+        nv_wr32(priv, NV20_PGRAPH_TLIMIT(i), tile->limit);
+        nv_wr32(priv, NV20_PGRAPH_TSIZE(i), tile->pitch);
+        nv_wr32(priv, NV20_PGRAPH_TILE(i), tile->addr);
+
+        nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0030 + 4 * i);
+        nv_wr32(priv, NV10_PGRAPH_RDI_DATA, tile->limit);
+        nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0050 + 4 * i);
+        nv_wr32(priv, NV10_PGRAPH_RDI_DATA, tile->pitch);
+        nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0010 + 4 * i);
+        nv_wr32(priv, NV10_PGRAPH_RDI_DATA, tile->addr);
+
+        if (nv_device(engine)->card_type == NV_20) {
+                nv_wr32(priv, NV20_PGRAPH_ZCOMP(i), tile->zcomp);
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00ea0090 + 4 * i);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA, tile->zcomp);
+        }
+
+        pfifo->start(pfifo, &flags);
+}
+
+void
+nv20_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nouveau_handle *handle;
+        struct nv20_graph_priv *priv = (void *)subdev;
+        u32 stat = nv_rd32(priv, NV03_PGRAPH_INTR);
+        u32 nsource = nv_rd32(priv, NV03_PGRAPH_NSOURCE);
+        u32 nstatus = nv_rd32(priv, NV03_PGRAPH_NSTATUS);
+        u32 addr = nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR);
+        u32 chid = (addr & 0x01f00000) >> 20;
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 mthd = (addr & 0x00001ffc);
+        u32 data = nv_rd32(priv, NV04_PGRAPH_TRAPPED_DATA);
+        u32 class = nv_rd32(priv, 0x400160 + subc * 4) & 0xfff;
+        u32 show = stat;
+
+        engctx = nouveau_engctx_get(engine, chid);
+        if (stat & NV_PGRAPH_INTR_ERROR) {
+                if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
+                        handle = nouveau_handle_get_class(engctx, class);
+                        if (handle && !nv_call(handle->object, mthd, data))
+                                show &= ~NV_PGRAPH_INTR_ERROR;
+                        nouveau_handle_put(handle);
+                }
+        }
+
+        nv_wr32(priv, NV03_PGRAPH_INTR, stat);
+        nv_wr32(priv, NV04_PGRAPH_FIFO, 0x00000001);
+
+        if (show) {
+                nv_info(priv, "");
+                nouveau_bitfield_print(nv10_graph_intr_name, show);
+                printk(" nsource:");
+                nouveau_bitfield_print(nv04_graph_nsource, nsource);
+                printk(" nstatus:");
+                nouveau_bitfield_print(nv10_graph_nstatus, nstatus);
+                printk("\n");
+                nv_info(priv, "ch %d/%d class 0x%04x mthd 0x%04x data 0x%08x\n",
+                        chid, subc, class, mthd, data);
+        }
+
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nv20_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv20_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 32 * 4, 16,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ctxtab);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv20_graph_intr;
+        nv_engine(priv)->cclass = &nv20_graph_cclass;
+        nv_engine(priv)->sclass = nv20_graph_sclass;
+        nv_engine(priv)->tile_prog = nv20_graph_tile_prog;
+        return 0;
+}
+
+void
+nv20_graph_dtor(struct nouveau_object *object)
+{
+        struct nv20_graph_priv *priv = (void *)object;
+        nouveau_gpuobj_ref(NULL, &priv->ctxtab);
+        nouveau_graph_destroy(&priv->base);
+}
+
+int
+nv20_graph_init(struct nouveau_object *object)
+{
+        struct nouveau_engine *engine = nv_engine(object);
+        struct nv20_graph_priv *priv = (void *)engine;
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        u32 tmp, vramsz;
+        int ret, i;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, NV20_PGRAPH_CHANNEL_CTX_TABLE, priv->ctxtab->addr >> 4);
+
+        if (nv_device(priv)->chipset == 0x20) {
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x003d0000);
+                for (i = 0; i < 15; i++)
+                        nv_wr32(priv, NV10_PGRAPH_RDI_DATA, 0x00000000);
+                nv_wait(priv, 0x400700, 0xffffffff, 0x00000000);
+        } else {
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x02c80000);
+                for (i = 0; i < 32; i++)
+                        nv_wr32(priv, NV10_PGRAPH_RDI_DATA, 0x00000000);
+                nv_wait(priv, 0x400700, 0xffffffff, 0x00000000);
+        }
+
+        nv_wr32(priv, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
+        nv_wr32(priv, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
+
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x00000000);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_1, 0x00118700);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_3, 0xF3CE0475); /* 0x4 = auto ctx switch */
+        nv_wr32(priv, NV10_PGRAPH_DEBUG_4, 0x00000000);
+        nv_wr32(priv, 0x40009C           , 0x00000040);
+
+        if (nv_device(priv)->chipset >= 0x25) {
+                nv_wr32(priv, 0x400890, 0x00a8cfff);
+                nv_wr32(priv, 0x400610, 0x304B1FB6);
+                nv_wr32(priv, 0x400B80, 0x1cbd3883);
+                nv_wr32(priv, 0x400B84, 0x44000000);
+                nv_wr32(priv, 0x400098, 0x40000080);
+                nv_wr32(priv, 0x400B88, 0x000000ff);
+
+        } else {
+                nv_wr32(priv, 0x400880, 0x0008c7df);
+                nv_wr32(priv, 0x400094, 0x00000005);
+                nv_wr32(priv, 0x400B80, 0x45eae20e);
+                nv_wr32(priv, 0x400B84, 0x24000000);
+                nv_wr32(priv, 0x400098, 0x00000040);
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00E00038);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA , 0x00000030);
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00E10038);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA , 0x00000030);
+        }
+
+        /* Turn all the tiling regions off. */
+        for (i = 0; i < pfb->tile.regions; i++)
+                engine->tile_prog(engine, i);
+
+        nv_wr32(priv, 0x4009a0, nv_rd32(priv, 0x100324));
+        nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA000C);
+        nv_wr32(priv, NV10_PGRAPH_RDI_DATA, nv_rd32(priv, 0x100324));
+
+        nv_wr32(priv, NV10_PGRAPH_CTX_CONTROL, 0x10000100);
+        nv_wr32(priv, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
+
+        tmp = nv_rd32(priv, NV10_PGRAPH_SURFACE) & 0x0007ff00;
+        nv_wr32(priv, NV10_PGRAPH_SURFACE, tmp);
+        tmp = nv_rd32(priv, NV10_PGRAPH_SURFACE) | 0x00020100;
+        nv_wr32(priv, NV10_PGRAPH_SURFACE, tmp);
+
+        /* begin RAM config */
+        vramsz = pci_resource_len(nv_device(priv)->pdev, 0) - 1;
+        nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
+        nv_wr32(priv, 0x4009A8, nv_rd32(priv, 0x100204));
+        nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
+        nv_wr32(priv, NV10_PGRAPH_RDI_DATA , nv_rd32(priv, 0x100200));
+        nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0004);
+        nv_wr32(priv, NV10_PGRAPH_RDI_DATA , nv_rd32(priv, 0x100204));
+        nv_wr32(priv, 0x400820, 0);
+        nv_wr32(priv, 0x400824, 0);
+        nv_wr32(priv, 0x400864, vramsz - 1);
+        nv_wr32(priv, 0x400868, vramsz - 1);
+
+        /* interesting.. the below overwrites some of the tile setup above.. */
+        nv_wr32(priv, 0x400B20, 0x00000000);
+        nv_wr32(priv, 0x400B04, 0xFFFFFFFF);
+
+        nv_wr32(priv, NV03_PGRAPH_ABS_UCLIP_XMIN, 0);
+        nv_wr32(priv, NV03_PGRAPH_ABS_UCLIP_YMIN, 0);
+        nv_wr32(priv, NV03_PGRAPH_ABS_UCLIP_XMAX, 0x7fff);
+        nv_wr32(priv, NV03_PGRAPH_ABS_UCLIP_YMAX, 0x7fff);
+        return 0;
+}
+
+struct nouveau_oclass
+nv20_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x20),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv20_graph_ctor,
+                .dtor = nv20_graph_dtor,
+                .init = nv20_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv20.h b/drivers/gpu/drm/nouveau/core/engine/graph/nv20.h
new file mode 100644
index 000000000000..2bea7313e03f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv20.h
@@ -0,0 +1,31 @@
+#ifndef __NV20_GRAPH_H__
+#define __NV20_GRAPH_H__
+
+#include <core/enum.h>
+
+#include <engine/graph.h>
+#include <engine/fifo.h>
+
+struct nv20_graph_priv {
+        struct nouveau_graph base;
+        struct nouveau_gpuobj *ctxtab;
+};
+
+struct nv20_graph_chan {
+        struct nouveau_graph_chan base;
+        int chid;
+};
+
+extern struct nouveau_oclass nv25_graph_sclass[];
+int  nv20_graph_context_init(struct nouveau_object *);
+int  nv20_graph_context_fini(struct nouveau_object *, bool);
+
+void nv20_graph_tile_prog(struct nouveau_engine *, int);
+void nv20_graph_intr(struct nouveau_subdev *);
+
+void nv20_graph_dtor(struct nouveau_object *);
+int  nv20_graph_init(struct nouveau_object *);
+
+int  nv30_graph_init(struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv25.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv25.c
new file mode 100644
index 000000000000..b2b650dd8b28
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv25.c
@@ -0,0 +1,167 @@
+#include <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/graph.h>
+
+#include "nv20.h"
+#include "regs.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+struct nouveau_oclass
+nv25_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv04_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv04_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv04_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs, NULL }, /* ifc */
+        { 0x0096, &nv04_graph_ofuncs, NULL }, /* celcius */
+        { 0x009e, &nv04_graph_ofuncs, NULL }, /* swzsurf */
+        { 0x009f, &nv04_graph_ofuncs, NULL }, /* imageblit */
+        { 0x0597, &nv04_graph_ofuncs, NULL }, /* kelvin */
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv25_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv20_graph_chan *chan;
+        int ret, i;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL, 0x3724,
+                                           16, NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->chid = nouveau_fifo_chan(parent)->chid;
+
+        nv_wo32(chan, 0x0028, 0x00000001 | (chan->chid << 24));
+        nv_wo32(chan, 0x035c, 0xffff0000);
+        nv_wo32(chan, 0x03c0, 0x0fff0000);
+        nv_wo32(chan, 0x03c4, 0x0fff0000);
+        nv_wo32(chan, 0x049c, 0x00000101);
+        nv_wo32(chan, 0x04b0, 0x00000111);
+        nv_wo32(chan, 0x04c8, 0x00000080);
+        nv_wo32(chan, 0x04cc, 0xffff0000);
+        nv_wo32(chan, 0x04d0, 0x00000001);
+        nv_wo32(chan, 0x04e4, 0x44400000);
+        nv_wo32(chan, 0x04fc, 0x4b800000);
+        for (i = 0x0510; i <= 0x051c; i += 4)
+                nv_wo32(chan, i, 0x00030303);
+        for (i = 0x0530; i <= 0x053c; i += 4)
+                nv_wo32(chan, i, 0x00080000);
+        for (i = 0x0548; i <= 0x0554; i += 4)
+                nv_wo32(chan, i, 0x01012000);
+        for (i = 0x0558; i <= 0x0564; i += 4)
+                nv_wo32(chan, i, 0x000105b8);
+        for (i = 0x0568; i <= 0x0574; i += 4)
+                nv_wo32(chan, i, 0x00080008);
+        for (i = 0x0598; i <= 0x05d4; i += 4)
+                nv_wo32(chan, i, 0x07ff0000);
+        nv_wo32(chan, 0x05e0, 0x4b7fffff);
+        nv_wo32(chan, 0x0620, 0x00000080);
+        nv_wo32(chan, 0x0624, 0x30201000);
+        nv_wo32(chan, 0x0628, 0x70605040);
+        nv_wo32(chan, 0x062c, 0xb0a09080);
+        nv_wo32(chan, 0x0630, 0xf0e0d0c0);
+        nv_wo32(chan, 0x0664, 0x00000001);
+        nv_wo32(chan, 0x066c, 0x00004000);
+        nv_wo32(chan, 0x0678, 0x00000001);
+        nv_wo32(chan, 0x0680, 0x00040000);
+        nv_wo32(chan, 0x0684, 0x00010000);
+        for (i = 0x1b04; i <= 0x2374; i += 16) {
+                nv_wo32(chan, (i + 0), 0x10700ff9);
+                nv_wo32(chan, (i + 4), 0x0436086c);
+                nv_wo32(chan, (i + 8), 0x000c001b);
+        }
+        nv_wo32(chan, 0x2704, 0x3f800000);
+        nv_wo32(chan, 0x2718, 0x3f800000);
+        nv_wo32(chan, 0x2744, 0x40000000);
+        nv_wo32(chan, 0x2748, 0x3f800000);
+        nv_wo32(chan, 0x274c, 0x3f000000);
+        nv_wo32(chan, 0x2754, 0x40000000);
+        nv_wo32(chan, 0x2758, 0x3f800000);
+        nv_wo32(chan, 0x2760, 0xbf800000);
+        nv_wo32(chan, 0x2768, 0xbf800000);
+        nv_wo32(chan, 0x308c, 0x000fe000);
+        nv_wo32(chan, 0x3108, 0x000003f8);
+        nv_wo32(chan, 0x3468, 0x002fe000);
+        for (i = 0x3484; i <= 0x34a0; i += 4)
+                nv_wo32(chan, i, 0x001c527c);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv25_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x25),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv25_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = nv20_graph_context_init,
+                .fini = nv20_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv25_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv20_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 32 * 4, 16,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ctxtab);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv20_graph_intr;
+        nv_engine(priv)->cclass = &nv25_graph_cclass;
+        nv_engine(priv)->sclass = nv25_graph_sclass;
+        nv_engine(priv)->tile_prog = nv20_graph_tile_prog;
+        return 0;
+}
+
+struct nouveau_oclass
+nv25_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x25),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv25_graph_ctor,
+                .dtor = nv20_graph_dtor,
+                .init = nv20_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv2a.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv2a.c
new file mode 100644
index 000000000000..700462fa0ae0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv2a.c
@@ -0,0 +1,134 @@
+#include <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/graph.h>
+
+#include "nv20.h"
+#include "regs.h"
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv2a_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv20_graph_chan *chan;
+        int ret, i;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL, 0x36b0,
+                                           16, NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->chid = nouveau_fifo_chan(parent)->chid;
+
+        nv_wo32(chan, 0x0000, 0x00000001 | (chan->chid << 24));
+        nv_wo32(chan, 0x033c, 0xffff0000);
+        nv_wo32(chan, 0x03a0, 0x0fff0000);
+        nv_wo32(chan, 0x03a4, 0x0fff0000);
+        nv_wo32(chan, 0x047c, 0x00000101);
+        nv_wo32(chan, 0x0490, 0x00000111);
+        nv_wo32(chan, 0x04a8, 0x44400000);
+        for (i = 0x04d4; i <= 0x04e0; i += 4)
+                nv_wo32(chan, i, 0x00030303);
+        for (i = 0x04f4; i <= 0x0500; i += 4)
+                nv_wo32(chan, i, 0x00080000);
+        for (i = 0x050c; i <= 0x0518; i += 4)
+                nv_wo32(chan, i, 0x01012000);
+        for (i = 0x051c; i <= 0x0528; i += 4)
+                nv_wo32(chan, i, 0x000105b8);
+        for (i = 0x052c; i <= 0x0538; i += 4)
+                nv_wo32(chan, i, 0x00080008);
+        for (i = 0x055c; i <= 0x0598; i += 4)
+                nv_wo32(chan, i, 0x07ff0000);
+        nv_wo32(chan, 0x05a4, 0x4b7fffff);
+        nv_wo32(chan, 0x05fc, 0x00000001);
+        nv_wo32(chan, 0x0604, 0x00004000);
+        nv_wo32(chan, 0x0610, 0x00000001);
+        nv_wo32(chan, 0x0618, 0x00040000);
+        nv_wo32(chan, 0x061c, 0x00010000);
+        for (i = 0x1a9c; i <= 0x22fc; i += 16) { /*XXX: check!! */
+                nv_wo32(chan, (i + 0), 0x10700ff9);
+                nv_wo32(chan, (i + 4), 0x0436086c);
+                nv_wo32(chan, (i + 8), 0x000c001b);
+        }
+        nv_wo32(chan, 0x269c, 0x3f800000);
+        nv_wo32(chan, 0x26b0, 0x3f800000);
+        nv_wo32(chan, 0x26dc, 0x40000000);
+        nv_wo32(chan, 0x26e0, 0x3f800000);
+        nv_wo32(chan, 0x26e4, 0x3f000000);
+        nv_wo32(chan, 0x26ec, 0x40000000);
+        nv_wo32(chan, 0x26f0, 0x3f800000);
+        nv_wo32(chan, 0x26f8, 0xbf800000);
+        nv_wo32(chan, 0x2700, 0xbf800000);
+        nv_wo32(chan, 0x3024, 0x000fe000);
+        nv_wo32(chan, 0x30a0, 0x000003f8);
+        nv_wo32(chan, 0x33fc, 0x002fe000);
+        for (i = 0x341c; i <= 0x3438; i += 4)
+                nv_wo32(chan, i, 0x001c527c);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv2a_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x2a),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv2a_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = nv20_graph_context_init,
+                .fini = nv20_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv2a_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv20_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 32 * 4, 16,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ctxtab);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv20_graph_intr;
+        nv_engine(priv)->cclass = &nv2a_graph_cclass;
+        nv_engine(priv)->sclass = nv25_graph_sclass;
+        nv_engine(priv)->tile_prog = nv20_graph_tile_prog;
+        return 0;
+}
+
+struct nouveau_oclass
+nv2a_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x2a),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv2a_graph_ctor,
+                .dtor = nv20_graph_dtor,
+                .init = nv20_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv30.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv30.c
new file mode 100644
index 000000000000..cedadaa92d3f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv30.c
@@ -0,0 +1,238 @@
+#include <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/graph.h>
+
+#include "nv20.h"
+#include "regs.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv30_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv04_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv04_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv04_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs, NULL }, /* ifc */
+        { 0x009f, &nv04_graph_ofuncs, NULL }, /* imageblit */
+        { 0x0362, &nv04_graph_ofuncs, NULL }, /* surf2d (nv30) */
+        { 0x0389, &nv04_graph_ofuncs, NULL }, /* sifm (nv30) */
+        { 0x038a, &nv04_graph_ofuncs, NULL }, /* ifc (nv30) */
+        { 0x039e, &nv04_graph_ofuncs, NULL }, /* swzsurf (nv30) */
+        { 0x0397, &nv04_graph_ofuncs, NULL }, /* rankine */
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv30_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv20_graph_chan *chan;
+        int ret, i;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL, 0x5f48,
+                                           16, NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->chid = nouveau_fifo_chan(parent)->chid;
+
+        nv_wo32(chan, 0x0028, 0x00000001 | (chan->chid << 24));
+        nv_wo32(chan, 0x0410, 0x00000101);
+        nv_wo32(chan, 0x0424, 0x00000111);
+        nv_wo32(chan, 0x0428, 0x00000060);
+        nv_wo32(chan, 0x0444, 0x00000080);
+        nv_wo32(chan, 0x0448, 0xffff0000);
+        nv_wo32(chan, 0x044c, 0x00000001);
+        nv_wo32(chan, 0x0460, 0x44400000);
+        nv_wo32(chan, 0x048c, 0xffff0000);
+        for (i = 0x04e0; i < 0x04e8; i += 4)
+                nv_wo32(chan, i, 0x0fff0000);
+        nv_wo32(chan, 0x04ec, 0x00011100);
+        for (i = 0x0508; i < 0x0548; i += 4)
+                nv_wo32(chan, i, 0x07ff0000);
+        nv_wo32(chan, 0x0550, 0x4b7fffff);
+        nv_wo32(chan, 0x058c, 0x00000080);
+        nv_wo32(chan, 0x0590, 0x30201000);
+        nv_wo32(chan, 0x0594, 0x70605040);
+        nv_wo32(chan, 0x0598, 0xb8a89888);
+        nv_wo32(chan, 0x059c, 0xf8e8d8c8);
+        nv_wo32(chan, 0x05b0, 0xb0000000);
+        for (i = 0x0600; i < 0x0640; i += 4)
+                nv_wo32(chan, i, 0x00010588);
+        for (i = 0x0640; i < 0x0680; i += 4)
+                nv_wo32(chan, i, 0x00030303);
+        for (i = 0x06c0; i < 0x0700; i += 4)
+                nv_wo32(chan, i, 0x0008aae4);
+        for (i = 0x0700; i < 0x0740; i += 4)
+                nv_wo32(chan, i, 0x01012000);
+        for (i = 0x0740; i < 0x0780; i += 4)
+                nv_wo32(chan, i, 0x00080008);
+        nv_wo32(chan, 0x085c, 0x00040000);
+        nv_wo32(chan, 0x0860, 0x00010000);
+        for (i = 0x0864; i < 0x0874; i += 4)
+                nv_wo32(chan, i, 0x00040004);
+        for (i = 0x1f18; i <= 0x3088 ; i += 16) {
+                nv_wo32(chan, i + 0, 0x10700ff9);
+                nv_wo32(chan, i + 1, 0x0436086c);
+                nv_wo32(chan, i + 2, 0x000c001b);
+        }
+        for (i = 0x30b8; i < 0x30c8; i += 4)
+                nv_wo32(chan, i, 0x0000ffff);
+        nv_wo32(chan, 0x344c, 0x3f800000);
+        nv_wo32(chan, 0x3808, 0x3f800000);
+        nv_wo32(chan, 0x381c, 0x3f800000);
+        nv_wo32(chan, 0x3848, 0x40000000);
+        nv_wo32(chan, 0x384c, 0x3f800000);
+        nv_wo32(chan, 0x3850, 0x3f000000);
+        nv_wo32(chan, 0x3858, 0x40000000);
+        nv_wo32(chan, 0x385c, 0x3f800000);
+        nv_wo32(chan, 0x3864, 0xbf800000);
+        nv_wo32(chan, 0x386c, 0xbf800000);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv30_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x30),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv30_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = nv20_graph_context_init,
+                .fini = nv20_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv30_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv20_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 32 * 4, 16,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ctxtab);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv20_graph_intr;
+        nv_engine(priv)->cclass = &nv30_graph_cclass;
+        nv_engine(priv)->sclass = nv30_graph_sclass;
+        nv_engine(priv)->tile_prog = nv20_graph_tile_prog;
+        return 0;
+}
+
+int
+nv30_graph_init(struct nouveau_object *object)
+{
+        struct nouveau_engine *engine = nv_engine(object);
+        struct nv20_graph_priv *priv = (void *)engine;
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        int ret, i;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, NV20_PGRAPH_CHANNEL_CTX_TABLE, priv->ctxtab->addr >> 4);
+
+        nv_wr32(priv, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
+        nv_wr32(priv, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
+
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x00000000);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_1, 0x401287c0);
+        nv_wr32(priv, 0x400890, 0x01b463ff);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_3, 0xf2de0475);
+        nv_wr32(priv, NV10_PGRAPH_DEBUG_4, 0x00008000);
+        nv_wr32(priv, NV04_PGRAPH_LIMIT_VIOL_PIX, 0xf04bdff6);
+        nv_wr32(priv, 0x400B80, 0x1003d888);
+        nv_wr32(priv, 0x400B84, 0x0c000000);
+        nv_wr32(priv, 0x400098, 0x00000000);
+        nv_wr32(priv, 0x40009C, 0x0005ad00);
+        nv_wr32(priv, 0x400B88, 0x62ff00ff); /* suspiciously like PGRAPH_DEBUG_2 */
+        nv_wr32(priv, 0x4000a0, 0x00000000);
+        nv_wr32(priv, 0x4000a4, 0x00000008);
+        nv_wr32(priv, 0x4008a8, 0xb784a400);
+        nv_wr32(priv, 0x400ba0, 0x002f8685);
+        nv_wr32(priv, 0x400ba4, 0x00231f3f);
+        nv_wr32(priv, 0x4008a4, 0x40000020);
+
+        if (nv_device(priv)->chipset == 0x34) {
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0004);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA , 0x00200201);
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0008);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA , 0x00000008);
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA , 0x00000032);
+                nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00E00004);
+                nv_wr32(priv, NV10_PGRAPH_RDI_DATA , 0x00000002);
+        }
+
+        nv_wr32(priv, 0x4000c0, 0x00000016);
+
+        /* Turn all the tiling regions off. */
+        for (i = 0; i < pfb->tile.regions; i++)
+                engine->tile_prog(engine, i);
+
+        nv_wr32(priv, NV10_PGRAPH_CTX_CONTROL, 0x10000100);
+        nv_wr32(priv, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
+        nv_wr32(priv, 0x0040075c             , 0x00000001);
+
+        /* begin RAM config */
+        /* vramsz = pci_resource_len(priv->dev->pdev, 0) - 1; */
+        nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
+        nv_wr32(priv, 0x4009A8, nv_rd32(priv, 0x100204));
+        if (nv_device(priv)->chipset != 0x34) {
+                nv_wr32(priv, 0x400750, 0x00EA0000);
+                nv_wr32(priv, 0x400754, nv_rd32(priv, 0x100200));
+                nv_wr32(priv, 0x400750, 0x00EA0004);
+                nv_wr32(priv, 0x400754, nv_rd32(priv, 0x100204));
+        }
+        return 0;
+}
+
+struct nouveau_oclass
+nv30_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x30),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv30_graph_ctor,
+                .dtor = nv20_graph_dtor,
+                .init = nv30_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv34.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv34.c
new file mode 100644
index 000000000000..273f6320027b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv34.c
@@ -0,0 +1,168 @@
+#include <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include <engine/graph.h>
+
+#include "nv20.h"
+#include "regs.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv34_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv04_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv04_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv04_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs, NULL }, /* ifc */
+        { 0x009f, &nv04_graph_ofuncs, NULL }, /* imageblit */
+        { 0x0362, &nv04_graph_ofuncs, NULL }, /* surf2d (nv30) */
+        { 0x0389, &nv04_graph_ofuncs, NULL }, /* sifm (nv30) */
+        { 0x038a, &nv04_graph_ofuncs, NULL }, /* ifc (nv30) */
+        { 0x039e, &nv04_graph_ofuncs, NULL }, /* swzsurf (nv30) */
+        { 0x0697, &nv04_graph_ofuncs, NULL }, /* rankine */
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv34_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv20_graph_chan *chan;
+        int ret, i;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL, 0x46dc,
+                                           16, NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->chid = nouveau_fifo_chan(parent)->chid;
+
+        nv_wo32(chan, 0x0028, 0x00000001 | (chan->chid << 24));
+        nv_wo32(chan, 0x040c, 0x01000101);
+        nv_wo32(chan, 0x0420, 0x00000111);
+        nv_wo32(chan, 0x0424, 0x00000060);
+        nv_wo32(chan, 0x0440, 0x00000080);
+        nv_wo32(chan, 0x0444, 0xffff0000);
+        nv_wo32(chan, 0x0448, 0x00000001);
+        nv_wo32(chan, 0x045c, 0x44400000);
+        nv_wo32(chan, 0x0480, 0xffff0000);
+        for (i = 0x04d4; i < 0x04dc; i += 4)
+                nv_wo32(chan, i, 0x0fff0000);
+        nv_wo32(chan, 0x04e0, 0x00011100);
+        for (i = 0x04fc; i < 0x053c; i += 4)
+                nv_wo32(chan, i, 0x07ff0000);
+        nv_wo32(chan, 0x0544, 0x4b7fffff);
+        nv_wo32(chan, 0x057c, 0x00000080);
+        nv_wo32(chan, 0x0580, 0x30201000);
+        nv_wo32(chan, 0x0584, 0x70605040);
+        nv_wo32(chan, 0x0588, 0xb8a89888);
+        nv_wo32(chan, 0x058c, 0xf8e8d8c8);
+        nv_wo32(chan, 0x05a0, 0xb0000000);
+        for (i = 0x05f0; i < 0x0630; i += 4)
+                nv_wo32(chan, i, 0x00010588);
+        for (i = 0x0630; i < 0x0670; i += 4)
+                nv_wo32(chan, i, 0x00030303);
+        for (i = 0x06b0; i < 0x06f0; i += 4)
+                nv_wo32(chan, i, 0x0008aae4);
+        for (i = 0x06f0; i < 0x0730; i += 4)
+                nv_wo32(chan, i, 0x01012000);
+        for (i = 0x0730; i < 0x0770; i += 4)
+                nv_wo32(chan, i, 0x00080008);
+        nv_wo32(chan, 0x0850, 0x00040000);
+        nv_wo32(chan, 0x0854, 0x00010000);
+        for (i = 0x0858; i < 0x0868; i += 4)
+                nv_wo32(chan, i, 0x00040004);
+        for (i = 0x15ac; i <= 0x271c ; i += 16) {
+                nv_wo32(chan, i + 0, 0x10700ff9);
+                nv_wo32(chan, i + 1, 0x0436086c);
+                nv_wo32(chan, i + 2, 0x000c001b);
+        }
+        for (i = 0x274c; i < 0x275c; i += 4)
+                nv_wo32(chan, i, 0x0000ffff);
+        nv_wo32(chan, 0x2ae0, 0x3f800000);
+        nv_wo32(chan, 0x2e9c, 0x3f800000);
+        nv_wo32(chan, 0x2eb0, 0x3f800000);
+        nv_wo32(chan, 0x2edc, 0x40000000);
+        nv_wo32(chan, 0x2ee0, 0x3f800000);
+        nv_wo32(chan, 0x2ee4, 0x3f000000);
+        nv_wo32(chan, 0x2eec, 0x40000000);
+        nv_wo32(chan, 0x2ef0, 0x3f800000);
+        nv_wo32(chan, 0x2ef8, 0xbf800000);
+        nv_wo32(chan, 0x2f00, 0xbf800000);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv34_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x34),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv34_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = nv20_graph_context_init,
+                .fini = nv20_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv34_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv20_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 32 * 4, 16,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ctxtab);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv20_graph_intr;
+        nv_engine(priv)->cclass = &nv34_graph_cclass;
+        nv_engine(priv)->sclass = nv34_graph_sclass;
+        nv_engine(priv)->tile_prog = nv20_graph_tile_prog;
+        return 0;
+}
+
+struct nouveau_oclass
+nv34_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x34),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv34_graph_ctor,
+                .dtor = nv20_graph_dtor,
+                .init = nv30_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv35.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv35.c
new file mode 100644
index 000000000000..f40ee2116ee1
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv35.c
@@ -0,0 +1,166 @@
+#include <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+#include "nv20.h"
+#include "regs.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv35_graph_sclass[] = {
+        { 0x0012, &nv04_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv04_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv04_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv04_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv04_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv04_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv04_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv04_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv04_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv04_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv04_graph_ofuncs, NULL }, /* ifc */
+        { 0x009f, &nv04_graph_ofuncs, NULL }, /* imageblit */
+        { 0x0362, &nv04_graph_ofuncs, NULL }, /* surf2d (nv30) */
+        { 0x0389, &nv04_graph_ofuncs, NULL }, /* sifm (nv30) */
+        { 0x038a, &nv04_graph_ofuncs, NULL }, /* ifc (nv30) */
+        { 0x039e, &nv04_graph_ofuncs, NULL }, /* swzsurf (nv30) */
+        { 0x0497, &nv04_graph_ofuncs, NULL }, /* rankine */
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv35_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv20_graph_chan *chan;
+        int ret, i;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL, 0x577c,
+                                           16, NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->chid = nouveau_fifo_chan(parent)->chid;
+
+        nv_wo32(chan, 0x0028, 0x00000001 | (chan->chid << 24));
+        nv_wo32(chan, 0x040c, 0x00000101);
+        nv_wo32(chan, 0x0420, 0x00000111);
+        nv_wo32(chan, 0x0424, 0x00000060);
+        nv_wo32(chan, 0x0440, 0x00000080);
+        nv_wo32(chan, 0x0444, 0xffff0000);
+        nv_wo32(chan, 0x0448, 0x00000001);
+        nv_wo32(chan, 0x045c, 0x44400000);
+        nv_wo32(chan, 0x0488, 0xffff0000);
+        for (i = 0x04dc; i < 0x04e4; i += 4)
+                nv_wo32(chan, i, 0x0fff0000);
+        nv_wo32(chan, 0x04e8, 0x00011100);
+        for (i = 0x0504; i < 0x0544; i += 4)
+                nv_wo32(chan, i, 0x07ff0000);
+        nv_wo32(chan, 0x054c, 0x4b7fffff);
+        nv_wo32(chan, 0x0588, 0x00000080);
+        nv_wo32(chan, 0x058c, 0x30201000);
+        nv_wo32(chan, 0x0590, 0x70605040);
+        nv_wo32(chan, 0x0594, 0xb8a89888);
+        nv_wo32(chan, 0x0598, 0xf8e8d8c8);
+        nv_wo32(chan, 0x05ac, 0xb0000000);
+        for (i = 0x0604; i < 0x0644; i += 4)
+                nv_wo32(chan, i, 0x00010588);
+        for (i = 0x0644; i < 0x0684; i += 4)
+                nv_wo32(chan, i, 0x00030303);
+        for (i = 0x06c4; i < 0x0704; i += 4)
+                nv_wo32(chan, i, 0x0008aae4);
+        for (i = 0x0704; i < 0x0744; i += 4)
+                nv_wo32(chan, i, 0x01012000);
+        for (i = 0x0744; i < 0x0784; i += 4)
+                nv_wo32(chan, i, 0x00080008);
+        nv_wo32(chan, 0x0860, 0x00040000);
+        nv_wo32(chan, 0x0864, 0x00010000);
+        for (i = 0x0868; i < 0x0878; i += 4)
+                nv_wo32(chan, i, 0x00040004);
+        for (i = 0x1f1c; i <= 0x308c ; i += 16) {
+                nv_wo32(chan, i + 0, 0x10700ff9);
+                nv_wo32(chan, i + 4, 0x0436086c);
+                nv_wo32(chan, i + 8, 0x000c001b);
+        }
+        for (i = 0x30bc; i < 0x30cc; i += 4)
+                nv_wo32(chan, i, 0x0000ffff);
+        nv_wo32(chan, 0x3450, 0x3f800000);
+        nv_wo32(chan, 0x380c, 0x3f800000);
+        nv_wo32(chan, 0x3820, 0x3f800000);
+        nv_wo32(chan, 0x384c, 0x40000000);
+        nv_wo32(chan, 0x3850, 0x3f800000);
+        nv_wo32(chan, 0x3854, 0x3f000000);
+        nv_wo32(chan, 0x385c, 0x40000000);
+        nv_wo32(chan, 0x3860, 0x3f800000);
+        nv_wo32(chan, 0x3868, 0xbf800000);
+        nv_wo32(chan, 0x3870, 0xbf800000);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv35_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x35),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv35_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = nv20_graph_context_init,
+                .fini = nv20_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv35_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv20_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 32 * 4, 16,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ctxtab);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv20_graph_intr;
+        nv_engine(priv)->cclass = &nv35_graph_cclass;
+        nv_engine(priv)->sclass = nv35_graph_sclass;
+        nv_engine(priv)->tile_prog = nv20_graph_tile_prog;
+        return 0;
+}
+
+struct nouveau_oclass
+nv35_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x35),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv35_graph_ctor,
+                .dtor = nv20_graph_dtor,
+                .init = nv30_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c
new file mode 100644
index 000000000000..8d0021049ec0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c
@@ -0,0 +1,495 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/handle.h>
+#include <core/engctx.h>
+
+#include <subdev/fb.h>
+#include <subdev/timer.h>
+
+#include <engine/graph.h>
+#include <engine/fifo.h>
+
+#include "nv40.h"
+#include "regs.h"
+
+struct nv40_graph_priv {
+        struct nouveau_graph base;
+        u32 size;
+};
+
+struct nv40_graph_chan {
+        struct nouveau_graph_chan base;
+};
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static int
+nv40_graph_object_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj *obj;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, parent,
+                                    20, 16, 0, &obj);
+        *pobject = nv_object(obj);
+        if (ret)
+                return ret;
+
+        nv_wo32(obj, 0x00, nv_mclass(obj));
+        nv_wo32(obj, 0x04, 0x00000000);
+        nv_wo32(obj, 0x08, 0x00000000);
+#ifdef __BIG_ENDIAN
+        nv_mo32(obj, 0x08, 0x01000000, 0x01000000);
+#endif
+        nv_wo32(obj, 0x0c, 0x00000000);
+        nv_wo32(obj, 0x10, 0x00000000);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv40_graph_ofuncs = {
+        .ctor = nv40_graph_object_ctor,
+        .dtor = _nouveau_gpuobj_dtor,
+        .init = _nouveau_gpuobj_init,
+        .fini = _nouveau_gpuobj_fini,
+        .rd32 = _nouveau_gpuobj_rd32,
+        .wr32 = _nouveau_gpuobj_wr32,
+};
+
+static struct nouveau_oclass
+nv40_graph_sclass[] = {
+        { 0x0012, &nv40_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv40_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv40_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv40_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv40_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv40_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv40_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv40_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv40_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv40_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv40_graph_ofuncs, NULL }, /* ifc */
+        { 0x009f, &nv40_graph_ofuncs, NULL }, /* imageblit */
+        { 0x3062, &nv40_graph_ofuncs, NULL }, /* surf2d (nv40) */
+        { 0x3089, &nv40_graph_ofuncs, NULL }, /* sifm (nv40) */
+        { 0x309e, &nv40_graph_ofuncs, NULL }, /* swzsurf (nv40) */
+        { 0x4097, &nv40_graph_ofuncs, NULL }, /* curie */
+        {},
+};
+
+static struct nouveau_oclass
+nv44_graph_sclass[] = {
+        { 0x0012, &nv40_graph_ofuncs, NULL }, /* beta1 */
+        { 0x0019, &nv40_graph_ofuncs, NULL }, /* clip */
+        { 0x0030, &nv40_graph_ofuncs, NULL }, /* null */
+        { 0x0039, &nv40_graph_ofuncs, NULL }, /* m2mf */
+        { 0x0043, &nv40_graph_ofuncs, NULL }, /* rop */
+        { 0x0044, &nv40_graph_ofuncs, NULL }, /* patt */
+        { 0x004a, &nv40_graph_ofuncs, NULL }, /* gdi */
+        { 0x0062, &nv40_graph_ofuncs, NULL }, /* surf2d */
+        { 0x0072, &nv40_graph_ofuncs, NULL }, /* beta4 */
+        { 0x0089, &nv40_graph_ofuncs, NULL }, /* sifm */
+        { 0x008a, &nv40_graph_ofuncs, NULL }, /* ifc */
+        { 0x009f, &nv40_graph_ofuncs, NULL }, /* imageblit */
+        { 0x3062, &nv40_graph_ofuncs, NULL }, /* surf2d (nv40) */
+        { 0x3089, &nv40_graph_ofuncs, NULL }, /* sifm (nv40) */
+        { 0x309e, &nv40_graph_ofuncs, NULL }, /* swzsurf (nv40) */
+        { 0x4497, &nv40_graph_ofuncs, NULL }, /* curie */
+        {},
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv40_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv40_graph_priv *priv = (void *)engine;
+        struct nv40_graph_chan *chan;
+        int ret;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL,
+                                           priv->size, 16,
+                                           NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv40_grctx_fill(nv_device(priv), nv_gpuobj(chan));
+        nv_wo32(chan, 0x00000, nv_gpuobj(chan)->addr >> 4);
+        return 0;
+}
+
+static int
+nv40_graph_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv04_graph_priv *priv = (void *)object->engine;
+        struct nv04_graph_chan *chan = (void *)object;
+        u32 inst = 0x01000000 | nv_gpuobj(chan)->addr >> 4;
+        int ret = 0;
+
+        nv_mask(priv, 0x400720, 0x00000001, 0x00000000);
+
+        if (nv_rd32(priv, 0x40032c) == inst) {
+                if (suspend) {
+                        nv_wr32(priv, 0x400720, 0x00000000);
+                        nv_wr32(priv, 0x400784, inst);
+                        nv_mask(priv, 0x400310, 0x00000020, 0x00000020);
+                        nv_mask(priv, 0x400304, 0x00000001, 0x00000001);
+                        if (!nv_wait(priv, 0x400300, 0x00000001, 0x00000000)) {
+                                u32 insn = nv_rd32(priv, 0x400308);
+                                nv_warn(priv, "ctxprog timeout 0x%08x\n", insn);
+                                ret = -EBUSY;
+                        }
+                }
+
+                nv_mask(priv, 0x40032c, 0x01000000, 0x00000000);
+        }
+
+        if (nv_rd32(priv, 0x400330) == inst)
+                nv_mask(priv, 0x400330, 0x01000000, 0x00000000);
+
+        nv_mask(priv, 0x400720, 0x00000001, 0x00000001);
+        return ret;
+}
+
+static struct nouveau_oclass
+nv40_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = _nouveau_graph_context_init,
+                .fini = nv40_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static void
+nv40_graph_tile_prog(struct nouveau_engine *engine, int i)
+{
+        struct nouveau_fb_tile *tile = &nouveau_fb(engine)->tile.region[i];
+        struct nouveau_fifo *pfifo = nouveau_fifo(engine);
+        struct nv40_graph_priv *priv = (void *)engine;
+        unsigned long flags;
+
+        pfifo->pause(pfifo, &flags);
+        nv04_graph_idle(priv);
+
+        switch (nv_device(priv)->chipset) {
+        case 0x40:
+        case 0x41: /* guess */
+        case 0x42:
+        case 0x43:
+        case 0x45: /* guess */
+        case 0x4e:
+                nv_wr32(priv, NV20_PGRAPH_TSIZE(i), tile->pitch);
+                nv_wr32(priv, NV20_PGRAPH_TLIMIT(i), tile->limit);
+                nv_wr32(priv, NV20_PGRAPH_TILE(i), tile->addr);
+                nv_wr32(priv, NV40_PGRAPH_TSIZE1(i), tile->pitch);
+                nv_wr32(priv, NV40_PGRAPH_TLIMIT1(i), tile->limit);
+                nv_wr32(priv, NV40_PGRAPH_TILE1(i), tile->addr);
+                break;
+        case 0x44:
+        case 0x4a:
+                nv_wr32(priv, NV20_PGRAPH_TSIZE(i), tile->pitch);
+                nv_wr32(priv, NV20_PGRAPH_TLIMIT(i), tile->limit);
+                nv_wr32(priv, NV20_PGRAPH_TILE(i), tile->addr);
+                break;
+        case 0x46:
+        case 0x47:
+        case 0x49:
+        case 0x4b:
+        case 0x4c:
+        case 0x67:
+        default:
+                nv_wr32(priv, NV47_PGRAPH_TSIZE(i), tile->pitch);
+                nv_wr32(priv, NV47_PGRAPH_TLIMIT(i), tile->limit);
+                nv_wr32(priv, NV47_PGRAPH_TILE(i), tile->addr);
+                nv_wr32(priv, NV40_PGRAPH_TSIZE1(i), tile->pitch);
+                nv_wr32(priv, NV40_PGRAPH_TLIMIT1(i), tile->limit);
+                nv_wr32(priv, NV40_PGRAPH_TILE1(i), tile->addr);
+                break;
+        }
+
+        pfifo->start(pfifo, &flags);
+}
+
+static void
+nv40_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nouveau_handle *handle = NULL;
+        struct nv40_graph_priv *priv = (void *)subdev;
+        u32 stat = nv_rd32(priv, NV03_PGRAPH_INTR);
+        u32 nsource = nv_rd32(priv, NV03_PGRAPH_NSOURCE);
+        u32 nstatus = nv_rd32(priv, NV03_PGRAPH_NSTATUS);
+        u32 inst = nv_rd32(priv, 0x40032c) & 0x000fffff;
+        u32 addr = nv_rd32(priv, NV04_PGRAPH_TRAPPED_ADDR);
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 mthd = (addr & 0x00001ffc);
+        u32 data = nv_rd32(priv, NV04_PGRAPH_TRAPPED_DATA);
+        u32 class = nv_rd32(priv, 0x400160 + subc * 4) & 0xffff;
+        u32 show = stat;
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & NV_PGRAPH_INTR_ERROR) {
+                if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
+                        handle = nouveau_handle_get_class(engctx, class);
+                        if (handle && !nv_call(handle->object, mthd, data))
+                                show &= ~NV_PGRAPH_INTR_ERROR;
+                        nouveau_handle_put(handle);
+                }
+
+                if (nsource & NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION) {
+                        nv_mask(priv, 0x402000, 0, 0);
+                }
+        }
+
+        nv_wr32(priv, NV03_PGRAPH_INTR, stat);
+        nv_wr32(priv, NV04_PGRAPH_FIFO, 0x00000001);
+
+        if (show) {
+                nv_info(priv, "");
+                nouveau_bitfield_print(nv10_graph_intr_name, show);
+                printk(" nsource:");
+                nouveau_bitfield_print(nv04_graph_nsource, nsource);
+                printk(" nstatus:");
+                nouveau_bitfield_print(nv10_graph_nstatus, nstatus);
+                printk("\n");
+                nv_error(priv, "ch %d [0x%08x] subc %d class 0x%04x "
+                               "mthd 0x%04x data 0x%08x\n",
+                         chid, inst << 4, subc, class, mthd, data);
+        }
+
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nv40_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv40_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00001000;
+        nv_subdev(priv)->intr = nv40_graph_intr;
+        nv_engine(priv)->cclass = &nv40_graph_cclass;
+        if (nv44_graph_class(priv))
+                nv_engine(priv)->sclass = nv44_graph_sclass;
+        else
+                nv_engine(priv)->sclass = nv40_graph_sclass;
+        nv_engine(priv)->tile_prog = nv40_graph_tile_prog;
+        return 0;
+}
+
+static int
+nv40_graph_init(struct nouveau_object *object)
+{
+        struct nouveau_engine *engine = nv_engine(object);
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        struct nv40_graph_priv *priv = (void *)engine;
+        int ret, i, j;
+        u32 vramsz;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* generate and upload context program */
+        nv40_grctx_init(nv_device(priv), &priv->size);
+
+        /* No context present currently */
+        nv_wr32(priv, NV40_PGRAPH_CTXCTL_CUR, 0x00000000);
+
+        nv_wr32(priv, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
+        nv_wr32(priv, NV40_PGRAPH_INTR_EN, 0xFFFFFFFF);
+
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_0, 0x00000000);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_1, 0x401287c0);
+        nv_wr32(priv, NV04_PGRAPH_DEBUG_3, 0xe0de8055);
+        nv_wr32(priv, NV10_PGRAPH_DEBUG_4, 0x00008000);
+        nv_wr32(priv, NV04_PGRAPH_LIMIT_VIOL_PIX, 0x00be3c5f);
+
+        nv_wr32(priv, NV10_PGRAPH_CTX_CONTROL, 0x10010100);
+        nv_wr32(priv, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
+
+        j = nv_rd32(priv, 0x1540) & 0xff;
+        if (j) {
+                for (i = 0; !(j & 1); j >>= 1, i++)
+                        ;
+                nv_wr32(priv, 0x405000, i);
+        }
+
+        if (nv_device(priv)->chipset == 0x40) {
+                nv_wr32(priv, 0x4009b0, 0x83280fff);
+                nv_wr32(priv, 0x4009b4, 0x000000a0);
+        } else {
+                nv_wr32(priv, 0x400820, 0x83280eff);
+                nv_wr32(priv, 0x400824, 0x000000a0);
+        }
+
+        switch (nv_device(priv)->chipset) {
+        case 0x40:
+        case 0x45:
+                nv_wr32(priv, 0x4009b8, 0x0078e366);
+                nv_wr32(priv, 0x4009bc, 0x0000014c);
+                break;
+        case 0x41:
+        case 0x42: /* pciid also 0x00Cx */
+        /* case 0x0120: XXX (pciid) */
+                nv_wr32(priv, 0x400828, 0x007596ff);
+                nv_wr32(priv, 0x40082c, 0x00000108);
+                break;
+        case 0x43:
+                nv_wr32(priv, 0x400828, 0x0072cb77);
+                nv_wr32(priv, 0x40082c, 0x00000108);
+                break;
+        case 0x44:
+        case 0x46: /* G72 */
+        case 0x4a:
+        case 0x4c: /* G7x-based C51 */
+        case 0x4e:
+                nv_wr32(priv, 0x400860, 0);
+                nv_wr32(priv, 0x400864, 0);
+                break;
+        case 0x47: /* G70 */
+        case 0x49: /* G71 */
+        case 0x4b: /* G73 */
+                nv_wr32(priv, 0x400828, 0x07830610);
+                nv_wr32(priv, 0x40082c, 0x0000016A);
+                break;
+        default:
+                break;
+        }
+
+        nv_wr32(priv, 0x400b38, 0x2ffff800);
+        nv_wr32(priv, 0x400b3c, 0x00006000);
+
+        /* Tiling related stuff. */
+        switch (nv_device(priv)->chipset) {
+        case 0x44:
+        case 0x4a:
+                nv_wr32(priv, 0x400bc4, 0x1003d888);
+                nv_wr32(priv, 0x400bbc, 0xb7a7b500);
+                break;
+        case 0x46:
+                nv_wr32(priv, 0x400bc4, 0x0000e024);
+                nv_wr32(priv, 0x400bbc, 0xb7a7b520);
+                break;
+        case 0x4c:
+        case 0x4e:
+        case 0x67:
+                nv_wr32(priv, 0x400bc4, 0x1003d888);
+                nv_wr32(priv, 0x400bbc, 0xb7a7b540);
+                break;
+        default:
+                break;
+        }
+
+        /* Turn all the tiling regions off. */
+        for (i = 0; i < pfb->tile.regions; i++)
+                engine->tile_prog(engine, i);
+
+        /* begin RAM config */
+        vramsz = pci_resource_len(nv_device(priv)->pdev, 0) - 1;
+        switch (nv_device(priv)->chipset) {
+        case 0x40:
+                nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
+                nv_wr32(priv, 0x4009A8, nv_rd32(priv, 0x100204));
+                nv_wr32(priv, 0x4069A4, nv_rd32(priv, 0x100200));
+                nv_wr32(priv, 0x4069A8, nv_rd32(priv, 0x100204));
+                nv_wr32(priv, 0x400820, 0);
+                nv_wr32(priv, 0x400824, 0);
+                nv_wr32(priv, 0x400864, vramsz);
+                nv_wr32(priv, 0x400868, vramsz);
+                break;
+        default:
+                switch (nv_device(priv)->chipset) {
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x45:
+                case 0x4e:
+                case 0x44:
+                case 0x4a:
+                        nv_wr32(priv, 0x4009F0, nv_rd32(priv, 0x100200));
+                        nv_wr32(priv, 0x4009F4, nv_rd32(priv, 0x100204));
+                        break;
+                default:
+                        nv_wr32(priv, 0x400DF0, nv_rd32(priv, 0x100200));
+                        nv_wr32(priv, 0x400DF4, nv_rd32(priv, 0x100204));
+                        break;
+                }
+                nv_wr32(priv, 0x4069F0, nv_rd32(priv, 0x100200));
+                nv_wr32(priv, 0x4069F4, nv_rd32(priv, 0x100204));
+                nv_wr32(priv, 0x400840, 0);
+                nv_wr32(priv, 0x400844, 0);
+                nv_wr32(priv, 0x4008A0, vramsz);
+                nv_wr32(priv, 0x4008A4, vramsz);
+                break;
+        }
+
+        return 0;
+}
+
+struct nouveau_oclass
+nv40_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_graph_ctor,
+                .dtor = _nouveau_graph_dtor,
+                .init = nv40_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h
new file mode 100644
index 000000000000..d2ac975afc2e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h
@@ -0,0 +1,21 @@
+#ifndef __NV40_GRAPH_H__
+#define __NV40_GRAPH_H__
+
+/* returns 1 if device is one of the nv4x using the 0x4497 object class,
+ * helpful to determine a number of other hardware features
+ */
+static inline int
+nv44_graph_class(void *priv)
+{
+        struct nouveau_device *device = nv_device(priv);
+
+        if ((device->chipset & 0xf0) == 0x60)
+                return 1;
+
+        return !(0x0baf & (1 << (device->chipset & 0x0f)));
+}
+
+void nv40_grctx_init(struct nouveau_device *, u32 *size);
+void nv40_grctx_fill(struct nouveau_device *, struct nouveau_gpuobj *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv50.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv50.c
new file mode 100644
index 000000000000..ab3b9dcaf478
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv50.c
@@ -0,0 +1,888 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/handle.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+#include <subdev/timer.h>
+
+#include <engine/fifo.h>
+#include <engine/graph.h>
+
+#include "nv50.h"
+
+struct nv50_graph_priv {
+        struct nouveau_graph base;
+        spinlock_t lock;
+        u32 size;
+};
+
+struct nv50_graph_chan {
+        struct nouveau_graph_chan base;
+};
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static int
+nv50_graph_object_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj *obj;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, parent,
+                                    16, 16, 0, &obj);
+        *pobject = nv_object(obj);
+        if (ret)
+                return ret;
+
+        nv_wo32(obj, 0x00, nv_mclass(obj));
+        nv_wo32(obj, 0x04, 0x00000000);
+        nv_wo32(obj, 0x08, 0x00000000);
+        nv_wo32(obj, 0x0c, 0x00000000);
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv50_graph_ofuncs = {
+        .ctor = nv50_graph_object_ctor,
+        .dtor = _nouveau_gpuobj_dtor,
+        .init = _nouveau_gpuobj_init,
+        .fini = _nouveau_gpuobj_fini,
+        .rd32 = _nouveau_gpuobj_rd32,
+        .wr32 = _nouveau_gpuobj_wr32,
+};
+
+static struct nouveau_oclass
+nv50_graph_sclass[] = {
+        { 0x0030, &nv50_graph_ofuncs },
+        { 0x502d, &nv50_graph_ofuncs },
+        { 0x5039, &nv50_graph_ofuncs },
+        { 0x5097, &nv50_graph_ofuncs },
+        { 0x50c0, &nv50_graph_ofuncs },
+        {}
+};
+
+static struct nouveau_oclass
+nv84_graph_sclass[] = {
+        { 0x0030, &nv50_graph_ofuncs },
+        { 0x502d, &nv50_graph_ofuncs },
+        { 0x5039, &nv50_graph_ofuncs },
+        { 0x50c0, &nv50_graph_ofuncs },
+        { 0x8297, &nv50_graph_ofuncs },
+        {}
+};
+
+static struct nouveau_oclass
+nva0_graph_sclass[] = {
+        { 0x0030, &nv50_graph_ofuncs },
+        { 0x502d, &nv50_graph_ofuncs },
+        { 0x5039, &nv50_graph_ofuncs },
+        { 0x50c0, &nv50_graph_ofuncs },
+        { 0x8397, &nv50_graph_ofuncs },
+        {}
+};
+
+static struct nouveau_oclass
+nva3_graph_sclass[] = {
+        { 0x0030, &nv50_graph_ofuncs },
+        { 0x502d, &nv50_graph_ofuncs },
+        { 0x5039, &nv50_graph_ofuncs },
+        { 0x50c0, &nv50_graph_ofuncs },
+        { 0x8597, &nv50_graph_ofuncs },
+        { 0x85c0, &nv50_graph_ofuncs },
+        {}
+};
+
+static struct nouveau_oclass
+nvaf_graph_sclass[] = {
+        { 0x0030, &nv50_graph_ofuncs },
+        { 0x502d, &nv50_graph_ofuncs },
+        { 0x5039, &nv50_graph_ofuncs },
+        { 0x50c0, &nv50_graph_ofuncs },
+        { 0x85c0, &nv50_graph_ofuncs },
+        { 0x8697, &nv50_graph_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static int
+nv50_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *data, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nv50_graph_priv *priv = (void *)engine;
+        struct nv50_graph_chan *chan;
+        int ret;
+
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL,
+                                           priv->size, 0,
+                                           NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv50_grctx_fill(nv_device(priv), nv_gpuobj(chan));
+        return 0;
+}
+
+static struct nouveau_oclass
+nv50_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_graph_context_ctor,
+                .dtor = _nouveau_graph_context_dtor,
+                .init = _nouveau_graph_context_init,
+                .fini = _nouveau_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv50_graph_tlb_flush(struct nouveau_engine *engine)
+{
+        nv50_vm_flush_engine(&engine->base, 0x00);
+        return 0;
+}
+
+static int
+nv84_graph_tlb_flush(struct nouveau_engine *engine)
+{
+        struct nouveau_timer *ptimer = nouveau_timer(engine);
+        struct nv50_graph_priv *priv = (void *)engine;
+        bool idle, timeout = false;
+        unsigned long flags;
+        u64 start;
+        u32 tmp;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        nv_mask(priv, 0x400500, 0x00000001, 0x00000000);
+
+        start = ptimer->read(ptimer);
+        do {
+                idle = true;
+
+                for (tmp = nv_rd32(priv, 0x400380); tmp && idle; tmp >>= 3) {
+                        if ((tmp & 7) == 1)
+                                idle = false;
+                }
+
+                for (tmp = nv_rd32(priv, 0x400384); tmp && idle; tmp >>= 3) {
+                        if ((tmp & 7) == 1)
+                                idle = false;
+                }
+
+                for (tmp = nv_rd32(priv, 0x400388); tmp && idle; tmp >>= 3) {
+                        if ((tmp & 7) == 1)
+                                idle = false;
+                }
+        } while (!idle &&
+                 !(timeout = ptimer->read(ptimer) - start > 2000000000));
+
+        if (timeout) {
+                nv_error(priv, "PGRAPH TLB flush idle timeout fail: "
+                              "0x%08x 0x%08x 0x%08x 0x%08x\n",
+                         nv_rd32(priv, 0x400700), nv_rd32(priv, 0x400380),
+                         nv_rd32(priv, 0x400384), nv_rd32(priv, 0x400388));
+        }
+
+        nv50_vm_flush_engine(&engine->base, 0x00);
+
+        nv_mask(priv, 0x400500, 0x00000001, 0x00000001);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return timeout ? -EBUSY : 0;
+}
+
+static const struct nouveau_enum nv50_mp_exec_error_names[] = {
+        { 3, "STACK_UNDERFLOW", NULL },
+        { 4, "QUADON_ACTIVE", NULL },
+        { 8, "TIMEOUT", NULL },
+        { 0x10, "INVALID_OPCODE", NULL },
+        { 0x40, "BREAKPOINT", NULL },
+        {}
+};
+
+static const struct nouveau_bitfield nv50_graph_trap_m2mf[] = {
+        { 0x00000001, "NOTIFY" },
+        { 0x00000002, "IN" },
+        { 0x00000004, "OUT" },
+        {}
+};
+
+static const struct nouveau_bitfield nv50_graph_trap_vfetch[] = {
+        { 0x00000001, "FAULT" },
+        {}
+};
+
+static const struct nouveau_bitfield nv50_graph_trap_strmout[] = {
+        { 0x00000001, "FAULT" },
+        {}
+};
+
+static const struct nouveau_bitfield nv50_graph_trap_ccache[] = {
+        { 0x00000001, "FAULT" },
+        {}
+};
+
+/* There must be a *lot* of these. Will take some time to gather them up. */
+const struct nouveau_enum nv50_data_error_names[] = {
+        { 0x00000003, "INVALID_OPERATION", NULL },
+        { 0x00000004, "INVALID_VALUE", NULL },
+        { 0x00000005, "INVALID_ENUM", NULL },
+        { 0x00000008, "INVALID_OBJECT", NULL },
+        { 0x00000009, "READ_ONLY_OBJECT", NULL },
+        { 0x0000000a, "SUPERVISOR_OBJECT", NULL },
+        { 0x0000000b, "INVALID_ADDRESS_ALIGNMENT", NULL },
+        { 0x0000000c, "INVALID_BITFIELD", NULL },
+        { 0x0000000d, "BEGIN_END_ACTIVE", NULL },
+        { 0x0000000e, "SEMANTIC_COLOR_BACK_OVER_LIMIT", NULL },
+        { 0x0000000f, "VIEWPORT_ID_NEEDS_GP", NULL },
+        { 0x00000010, "RT_DOUBLE_BIND", NULL },
+        { 0x00000011, "RT_TYPES_MISMATCH", NULL },
+        { 0x00000012, "RT_LINEAR_WITH_ZETA", NULL },
+        { 0x00000015, "FP_TOO_FEW_REGS", NULL },
+        { 0x00000016, "ZETA_FORMAT_CSAA_MISMATCH", NULL },
+        { 0x00000017, "RT_LINEAR_WITH_MSAA", NULL },
+        { 0x00000018, "FP_INTERPOLANT_START_OVER_LIMIT", NULL },
+        { 0x00000019, "SEMANTIC_LAYER_OVER_LIMIT", NULL },
+        { 0x0000001a, "RT_INVALID_ALIGNMENT", NULL },
+        { 0x0000001b, "SAMPLER_OVER_LIMIT", NULL },
+        { 0x0000001c, "TEXTURE_OVER_LIMIT", NULL },
+        { 0x0000001e, "GP_TOO_MANY_OUTPUTS", NULL },
+        { 0x0000001f, "RT_BPP128_WITH_MS8", NULL },
+        { 0x00000021, "Z_OUT_OF_BOUNDS", NULL },
+        { 0x00000023, "XY_OUT_OF_BOUNDS", NULL },
+        { 0x00000024, "VP_ZERO_INPUTS", NULL },
+        { 0x00000027, "CP_MORE_PARAMS_THAN_SHARED", NULL },
+        { 0x00000028, "CP_NO_REG_SPACE_STRIPED", NULL },
+        { 0x00000029, "CP_NO_REG_SPACE_PACKED", NULL },
+        { 0x0000002a, "CP_NOT_ENOUGH_WARPS", NULL },
+        { 0x0000002b, "CP_BLOCK_SIZE_MISMATCH", NULL },
+        { 0x0000002c, "CP_NOT_ENOUGH_LOCAL_WARPS", NULL },
+        { 0x0000002d, "CP_NOT_ENOUGH_STACK_WARPS", NULL },
+        { 0x0000002e, "CP_NO_BLOCKDIM_LATCH", NULL },
+        { 0x00000031, "ENG2D_FORMAT_MISMATCH", NULL },
+        { 0x0000003f, "PRIMITIVE_ID_NEEDS_GP", NULL },
+        { 0x00000044, "SEMANTIC_VIEWPORT_OVER_LIMIT", NULL },
+        { 0x00000045, "SEMANTIC_COLOR_FRONT_OVER_LIMIT", NULL },
+        { 0x00000046, "LAYER_ID_NEEDS_GP", NULL },
+        { 0x00000047, "SEMANTIC_CLIP_OVER_LIMIT", NULL },
+        { 0x00000048, "SEMANTIC_PTSZ_OVER_LIMIT", NULL },
+        {}
+};
+
+static const struct nouveau_bitfield nv50_graph_intr_name[] = {
+        { 0x00000001, "NOTIFY" },
+        { 0x00000002, "COMPUTE_QUERY" },
+        { 0x00000010, "ILLEGAL_MTHD" },
+        { 0x00000020, "ILLEGAL_CLASS" },
+        { 0x00000040, "DOUBLE_NOTIFY" },
+        { 0x00001000, "CONTEXT_SWITCH" },
+        { 0x00010000, "BUFFER_NOTIFY" },
+        { 0x00100000, "DATA_ERROR" },
+        { 0x00200000, "TRAP" },
+        { 0x01000000, "SINGLE_STEP" },
+        {}
+};
+
+static void
+nv50_priv_mp_trap(struct nv50_graph_priv *priv, int tpid, int display)
+{
+        u32 units = nv_rd32(priv, 0x1540);
+        u32 addr, mp10, status, pc, oplow, ophigh;
+        int i;
+        int mps = 0;
+        for (i = 0; i < 4; i++) {
+                if (!(units & 1 << (i+24)))
+                        continue;
+                if (nv_device(priv)->chipset < 0xa0)
+                        addr = 0x408200 + (tpid << 12) + (i << 7);
+                else
+                        addr = 0x408100 + (tpid << 11) + (i << 7);
+                mp10 = nv_rd32(priv, addr + 0x10);
+                status = nv_rd32(priv, addr + 0x14);
+                if (!status)
+                        continue;
+                if (display) {
+                        nv_rd32(priv, addr + 0x20);
+                        pc = nv_rd32(priv, addr + 0x24);
+                        oplow = nv_rd32(priv, addr + 0x70);
+                        ophigh = nv_rd32(priv, addr + 0x74);
+                        nv_error(priv, "TRAP_MP_EXEC - "
+                                        "TP %d MP %d: ", tpid, i);
+                        nouveau_enum_print(nv50_mp_exec_error_names, status);
+                        printk(" at %06x warp %d, opcode %08x %08x\n",
+                                        pc&0xffffff, pc >> 24,
+                                        oplow, ophigh);
+                }
+                nv_wr32(priv, addr + 0x10, mp10);
+                nv_wr32(priv, addr + 0x14, 0);
+                mps++;
+        }
+        if (!mps && display)
+                nv_error(priv, "TRAP_MP_EXEC - TP %d: "
+                                "No MPs claiming errors?\n", tpid);
+}
+
+static void
+nv50_priv_tp_trap(struct nv50_graph_priv *priv, int type, u32 ustatus_old,
+                u32 ustatus_new, int display, const char *name)
+{
+        int tps = 0;
+        u32 units = nv_rd32(priv, 0x1540);
+        int i, r;
+        u32 ustatus_addr, ustatus;
+        for (i = 0; i < 16; i++) {
+                if (!(units & (1 << i)))
+                        continue;
+                if (nv_device(priv)->chipset < 0xa0)
+                        ustatus_addr = ustatus_old + (i << 12);
+                else
+                        ustatus_addr = ustatus_new + (i << 11);
+                ustatus = nv_rd32(priv, ustatus_addr) & 0x7fffffff;
+                if (!ustatus)
+                        continue;
+                tps++;
+                switch (type) {
+                case 6: /* texture error... unknown for now */
+                        if (display) {
+                                nv_error(priv, "magic set %d:\n", i);
+                                for (r = ustatus_addr + 4; r <= ustatus_addr + 0x10; r += 4)
+                                        nv_error(priv, "\t0x%08x: 0x%08x\n", r,
+                                                nv_rd32(priv, r));
+                        }
+                        break;
+                case 7: /* MP error */
+                        if (ustatus & 0x04030000) {
+                                nv50_priv_mp_trap(priv, i, display);
+                                ustatus &= ~0x04030000;
+                        }
+                        break;
+                case 8: /* TPDMA error */
+                        {
+                        u32 e0c = nv_rd32(priv, ustatus_addr + 4);
+                        u32 e10 = nv_rd32(priv, ustatus_addr + 8);
+                        u32 e14 = nv_rd32(priv, ustatus_addr + 0xc);
+                        u32 e18 = nv_rd32(priv, ustatus_addr + 0x10);
+                        u32 e1c = nv_rd32(priv, ustatus_addr + 0x14);
+                        u32 e20 = nv_rd32(priv, ustatus_addr + 0x18);
+                        u32 e24 = nv_rd32(priv, ustatus_addr + 0x1c);
+                        /* 2d engine destination */
+                        if (ustatus & 0x00000010) {
+                                if (display) {
+                                        nv_error(priv, "TRAP_TPDMA_2D - TP %d - Unknown fault at address %02x%08x\n",
+                                                        i, e14, e10);
+                                        nv_error(priv, "TRAP_TPDMA_2D - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
+                                                        i, e0c, e18, e1c, e20, e24);
+                                }
+                                ustatus &= ~0x00000010;
+                        }
+                        /* Render target */
+                        if (ustatus & 0x00000040) {
+                                if (display) {
+                                        nv_error(priv, "TRAP_TPDMA_RT - TP %d - Unknown fault at address %02x%08x\n",
+                                                        i, e14, e10);
+                                        nv_error(priv, "TRAP_TPDMA_RT - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
+                                                        i, e0c, e18, e1c, e20, e24);
+                                }
+                                ustatus &= ~0x00000040;
+                        }
+                        /* CUDA memory: l[], g[] or stack. */
+                        if (ustatus & 0x00000080) {
+                                if (display) {
+                                        if (e18 & 0x80000000) {
+                                                /* g[] read fault? */
+                                                nv_error(priv, "TRAP_TPDMA - TP %d - Global read fault at address %02x%08x\n",
+                                                                i, e14, e10 | ((e18 >> 24) & 0x1f));
+                                                e18 &= ~0x1f000000;
+                                        } else if (e18 & 0xc) {
+                                                /* g[] write fault? */
+                                                nv_error(priv, "TRAP_TPDMA - TP %d - Global write fault at address %02x%08x\n",
+                                                                i, e14, e10 | ((e18 >> 7) & 0x1f));
+                                                e18 &= ~0x00000f80;
+                                        } else {
+                                                nv_error(priv, "TRAP_TPDMA - TP %d - Unknown CUDA fault at address %02x%08x\n",
+                                                                i, e14, e10);
+                                        }
+                                        nv_error(priv, "TRAP_TPDMA - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
+                                                        i, e0c, e18, e1c, e20, e24);
+                                }
+                                ustatus &= ~0x00000080;
+                        }
+                        }
+                        break;
+                }
+                if (ustatus) {
+                        if (display)
+                                nv_info(priv, "%s - TP%d: Unhandled ustatus 0x%08x\n", name, i, ustatus);
+                }
+                nv_wr32(priv, ustatus_addr, 0xc0000000);
+        }
+
+        if (!tps && display)
+                nv_info(priv, "%s - No TPs claiming errors?\n", name);
+}
+
+static int
+nv50_graph_trap_handler(struct nv50_graph_priv *priv, u32 display,
+                        int chid, u64 inst)
+{
+        u32 status = nv_rd32(priv, 0x400108);
+        u32 ustatus;
+
+        if (!status && display) {
+                nv_error(priv, "TRAP: no units reporting traps?\n");
+                return 1;
+        }
+
+        /* DISPATCH: Relays commands to other units and handles NOTIFY,
+         * COND, QUERY. If you get a trap from it, the command is still stuck
+         * in DISPATCH and you need to do something about it. */
+        if (status & 0x001) {
+                ustatus = nv_rd32(priv, 0x400804) & 0x7fffffff;
+                if (!ustatus && display) {
+                        nv_error(priv, "TRAP_DISPATCH - no ustatus?\n");
+                }
+
+                nv_wr32(priv, 0x400500, 0x00000000);
+
+                /* Known to be triggered by screwed up NOTIFY and COND... */
+                if (ustatus & 0x00000001) {
+                        u32 addr = nv_rd32(priv, 0x400808);
+                        u32 subc = (addr & 0x00070000) >> 16;
+                        u32 mthd = (addr & 0x00001ffc);
+                        u32 datal = nv_rd32(priv, 0x40080c);
+                        u32 datah = nv_rd32(priv, 0x400810);
+                        u32 class = nv_rd32(priv, 0x400814);
+                        u32 r848 = nv_rd32(priv, 0x400848);
+
+                        nv_error(priv, "TRAP DISPATCH_FAULT\n");
+                        if (display && (addr & 0x80000000)) {
+                                nv_error(priv, "ch %d [0x%010llx] "
+                                             "subc %d class 0x%04x mthd 0x%04x "
+                                             "data 0x%08x%08x "
+                                             "400808 0x%08x 400848 0x%08x\n",
+                                        chid, inst, subc, class, mthd, datah,
+                                        datal, addr, r848);
+                        } else
+                        if (display) {
+                                nv_error(priv, "no stuck command?\n");
+                        }
+
+                        nv_wr32(priv, 0x400808, 0);
+                        nv_wr32(priv, 0x4008e8, nv_rd32(priv, 0x4008e8) & 3);
+                        nv_wr32(priv, 0x400848, 0);
+                        ustatus &= ~0x00000001;
+                }
+
+                if (ustatus & 0x00000002) {
+                        u32 addr = nv_rd32(priv, 0x40084c);
+                        u32 subc = (addr & 0x00070000) >> 16;
+                        u32 mthd = (addr & 0x00001ffc);
+                        u32 data = nv_rd32(priv, 0x40085c);
+                        u32 class = nv_rd32(priv, 0x400814);
+
+                        nv_error(priv, "TRAP DISPATCH_QUERY\n");
+                        if (display && (addr & 0x80000000)) {
+                                nv_error(priv, "ch %d [0x%010llx] "
+                                             "subc %d class 0x%04x mthd 0x%04x "
+                                             "data 0x%08x 40084c 0x%08x\n",
+                                        chid, inst, subc, class, mthd,
+                                        data, addr);
+                        } else
+                        if (display) {
+                                nv_error(priv, "no stuck command?\n");
+                        }
+
+                        nv_wr32(priv, 0x40084c, 0);
+                        ustatus &= ~0x00000002;
+                }
+
+                if (ustatus && display) {
+                        nv_error(priv, "TRAP_DISPATCH (unknown "
+                                      "0x%08x)\n", ustatus);
+                }
+
+                nv_wr32(priv, 0x400804, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x001);
+                status &= ~0x001;
+                if (!status)
+                        return 0;
+        }
+
+        /* M2MF: Memory to memory copy engine. */
+        if (status & 0x002) {
+                u32 ustatus = nv_rd32(priv, 0x406800) & 0x7fffffff;
+                if (display) {
+                        nv_error(priv, "TRAP_M2MF");
+                        nouveau_bitfield_print(nv50_graph_trap_m2mf, ustatus);
+                        printk("\n");
+                        nv_error(priv, "TRAP_M2MF %08x %08x %08x %08x\n",
+                                nv_rd32(priv, 0x406804), nv_rd32(priv, 0x406808),
+                                nv_rd32(priv, 0x40680c), nv_rd32(priv, 0x406810));
+
+                }
+
+                /* No sane way found yet -- just reset the bugger. */
+                nv_wr32(priv, 0x400040, 2);
+                nv_wr32(priv, 0x400040, 0);
+                nv_wr32(priv, 0x406800, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x002);
+                status &= ~0x002;
+        }
+
+        /* VFETCH: Fetches data from vertex buffers. */
+        if (status & 0x004) {
+                u32 ustatus = nv_rd32(priv, 0x400c04) & 0x7fffffff;
+                if (display) {
+                        nv_error(priv, "TRAP_VFETCH");
+                        nouveau_bitfield_print(nv50_graph_trap_vfetch, ustatus);
+                        printk("\n");
+                        nv_error(priv, "TRAP_VFETCH %08x %08x %08x %08x\n",
+                                nv_rd32(priv, 0x400c00), nv_rd32(priv, 0x400c08),
+                                nv_rd32(priv, 0x400c0c), nv_rd32(priv, 0x400c10));
+                }
+
+                nv_wr32(priv, 0x400c04, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x004);
+                status &= ~0x004;
+        }
+
+        /* STRMOUT: DirectX streamout / OpenGL transform feedback. */
+        if (status & 0x008) {
+                ustatus = nv_rd32(priv, 0x401800) & 0x7fffffff;
+                if (display) {
+                        nv_error(priv, "TRAP_STRMOUT");
+                        nouveau_bitfield_print(nv50_graph_trap_strmout, ustatus);
+                        printk("\n");
+                        nv_error(priv, "TRAP_STRMOUT %08x %08x %08x %08x\n",
+                                nv_rd32(priv, 0x401804), nv_rd32(priv, 0x401808),
+                                nv_rd32(priv, 0x40180c), nv_rd32(priv, 0x401810));
+
+                }
+
+                /* No sane way found yet -- just reset the bugger. */
+                nv_wr32(priv, 0x400040, 0x80);
+                nv_wr32(priv, 0x400040, 0);
+                nv_wr32(priv, 0x401800, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x008);
+                status &= ~0x008;
+        }
+
+        /* CCACHE: Handles code and c[] caches and fills them. */
+        if (status & 0x010) {
+                ustatus = nv_rd32(priv, 0x405018) & 0x7fffffff;
+                if (display) {
+                        nv_error(priv, "TRAP_CCACHE");
+                        nouveau_bitfield_print(nv50_graph_trap_ccache, ustatus);
+                        printk("\n");
+                        nv_error(priv, "TRAP_CCACHE %08x %08x %08x %08x"
+                                     " %08x %08x %08x\n",
+                                nv_rd32(priv, 0x405000), nv_rd32(priv, 0x405004),
+                                nv_rd32(priv, 0x405008), nv_rd32(priv, 0x40500c),
+                                nv_rd32(priv, 0x405010), nv_rd32(priv, 0x405014),
+                                nv_rd32(priv, 0x40501c));
+
+                }
+
+                nv_wr32(priv, 0x405018, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x010);
+                status &= ~0x010;
+        }
+
+        /* Unknown, not seen yet... 0x402000 is the only trap status reg
+         * remaining, so try to handle it anyway. Perhaps related to that
+         * unknown DMA slot on tesla? */
+        if (status & 0x20) {
+                ustatus = nv_rd32(priv, 0x402000) & 0x7fffffff;
+                if (display)
+                        nv_error(priv, "TRAP_UNKC04 0x%08x\n", ustatus);
+                nv_wr32(priv, 0x402000, 0xc0000000);
+                /* no status modifiction on purpose */
+        }
+
+        /* TEXTURE: CUDA texturing units */
+        if (status & 0x040) {
+                nv50_priv_tp_trap(priv, 6, 0x408900, 0x408600, display,
+                                    "TRAP_TEXTURE");
+                nv_wr32(priv, 0x400108, 0x040);
+                status &= ~0x040;
+        }
+
+        /* MP: CUDA execution engines. */
+        if (status & 0x080) {
+                nv50_priv_tp_trap(priv, 7, 0x408314, 0x40831c, display,
+                                    "TRAP_MP");
+                nv_wr32(priv, 0x400108, 0x080);
+                status &= ~0x080;
+        }
+
+        /* TPDMA:  Handles TP-initiated uncached memory accesses:
+         * l[], g[], stack, 2d surfaces, render targets. */
+        if (status & 0x100) {
+                nv50_priv_tp_trap(priv, 8, 0x408e08, 0x408708, display,
+                                    "TRAP_TPDMA");
+                nv_wr32(priv, 0x400108, 0x100);
+                status &= ~0x100;
+        }
+
+        if (status) {
+                if (display)
+                        nv_error(priv, "TRAP: unknown 0x%08x\n", status);
+                nv_wr32(priv, 0x400108, status);
+        }
+
+        return 1;
+}
+
+static void
+nv50_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nouveau_handle *handle = NULL;
+        struct nv50_graph_priv *priv = (void *)subdev;
+        u32 stat = nv_rd32(priv, 0x400100);
+        u32 inst = nv_rd32(priv, 0x40032c) & 0x0fffffff;
+        u32 addr = nv_rd32(priv, 0x400704);
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 mthd = (addr & 0x00001ffc);
+        u32 data = nv_rd32(priv, 0x400708);
+        u32 class = nv_rd32(priv, 0x400814);
+        u32 show = stat;
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x00000010) {
+                handle = nouveau_handle_get_class(engctx, class);
+                if (handle && !nv_call(handle->object, mthd, data))
+                        show &= ~0x00000010;
+                nouveau_handle_put(handle);
+        }
+
+        if (show & 0x00100000) {
+                u32 ecode = nv_rd32(priv, 0x400110);
+                nv_error(priv, "DATA_ERROR ");
+                nouveau_enum_print(nv50_data_error_names, ecode);
+                printk("\n");
+        }
+
+        if (stat & 0x00200000) {
+                if (!nv50_graph_trap_handler(priv, show, chid, (u64)inst << 12))
+                        show &= ~0x00200000;
+        }
+
+        nv_wr32(priv, 0x400100, stat);
+        nv_wr32(priv, 0x400500, 0x00010001);
+
+        if (show) {
+                nv_info(priv, "");
+                nouveau_bitfield_print(nv50_graph_intr_name, show);
+                printk("\n");
+                nv_error(priv, "ch %d [0x%010llx] subc %d class 0x%04x "
+                               "mthd 0x%04x data 0x%08x\n",
+                         chid, (u64)inst << 12, subc, class, mthd, data);
+                nv50_fb_trap(nouveau_fb(priv), 1);
+        }
+
+        if (nv_rd32(priv, 0x400824) & (1 << 31))
+                nv_wr32(priv, 0x400824, nv_rd32(priv, 0x400824) & ~(1 << 31));
+
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nv50_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv50_graph_priv *priv;
+        int ret;
+
+        ret = nouveau_graph_create(parent, engine, oclass, true, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00201000;
+        nv_subdev(priv)->intr = nv50_graph_intr;
+        nv_engine(priv)->cclass = &nv50_graph_cclass;
+
+        switch (nv_device(priv)->chipset) {
+        case 0x50:
+                nv_engine(priv)->sclass = nv50_graph_sclass;
+                break;
+        case 0x84:
+        case 0x86:
+        case 0x92:
+        case 0x94:
+        case 0x96:
+        case 0x98:
+                nv_engine(priv)->sclass = nv84_graph_sclass;
+                break;
+        case 0xa0:
+        case 0xaa:
+        case 0xac:
+                nv_engine(priv)->sclass = nva0_graph_sclass;
+                break;
+        case 0xa3:
+        case 0xa5:
+        case 0xa8:
+                nv_engine(priv)->sclass = nva3_graph_sclass;
+                break;
+        case 0xaf:
+                nv_engine(priv)->sclass = nvaf_graph_sclass;
+                break;
+
+        };
+
+        if (nv_device(priv)->chipset == 0x50 ||
+            nv_device(priv)->chipset == 0xac)
+                nv_engine(priv)->tlb_flush = nv50_graph_tlb_flush;
+        else
+                nv_engine(priv)->tlb_flush = nv84_graph_tlb_flush;
+
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+static int
+nv50_graph_init(struct nouveau_object *object)
+{
+        struct nv50_graph_priv *priv = (void *)object;
+        int ret, units, i;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* NV_PGRAPH_DEBUG_3_HW_CTX_SWITCH_ENABLED */
+        nv_wr32(priv, 0x40008c, 0x00000004);
+
+        /* reset/enable traps and interrupts */
+        nv_wr32(priv, 0x400804, 0xc0000000);
+        nv_wr32(priv, 0x406800, 0xc0000000);
+        nv_wr32(priv, 0x400c04, 0xc0000000);
+        nv_wr32(priv, 0x401800, 0xc0000000);
+        nv_wr32(priv, 0x405018, 0xc0000000);
+        nv_wr32(priv, 0x402000, 0xc0000000);
+
+        units = nv_rd32(priv, 0x001540);
+        for (i = 0; i < 16; i++) {
+                if (!(units & (1 << i)))
+                        continue;
+
+                if (nv_device(priv)->chipset < 0xa0) {
+                        nv_wr32(priv, 0x408900 + (i << 12), 0xc0000000);
+                        nv_wr32(priv, 0x408e08 + (i << 12), 0xc0000000);
+                        nv_wr32(priv, 0x408314 + (i << 12), 0xc0000000);
+                } else {
+                        nv_wr32(priv, 0x408600 + (i << 11), 0xc0000000);
+                        nv_wr32(priv, 0x408708 + (i << 11), 0xc0000000);
+                        nv_wr32(priv, 0x40831c + (i << 11), 0xc0000000);
+                }
+        }
+
+        nv_wr32(priv, 0x400108, 0xffffffff);
+        nv_wr32(priv, 0x400138, 0xffffffff);
+        nv_wr32(priv, 0x400100, 0xffffffff);
+        nv_wr32(priv, 0x40013c, 0xffffffff);
+        nv_wr32(priv, 0x400500, 0x00010001);
+
+        /* upload context program, initialise ctxctl defaults */
+        ret = nv50_grctx_init(nv_device(priv), &priv->size);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x400824, 0x00000000);
+        nv_wr32(priv, 0x400828, 0x00000000);
+        nv_wr32(priv, 0x40082c, 0x00000000);
+        nv_wr32(priv, 0x400830, 0x00000000);
+        nv_wr32(priv, 0x400724, 0x00000000);
+        nv_wr32(priv, 0x40032c, 0x00000000);
+        nv_wr32(priv, 0x400320, 4);     /* CTXCTL_CMD = NEWCTXDMA */
+
+        /* some unknown zcull magic */
+        switch (nv_device(priv)->chipset & 0xf0) {
+        case 0x50:
+        case 0x80:
+        case 0x90:
+                nv_wr32(priv, 0x402ca8, 0x00000800);
+                break;
+        case 0xa0:
+        default:
+                nv_wr32(priv, 0x402cc0, 0x00000000);
+                if (nv_device(priv)->chipset == 0xa0 ||
+                    nv_device(priv)->chipset == 0xaa ||
+                    nv_device(priv)->chipset == 0xac) {
+                        nv_wr32(priv, 0x402ca8, 0x00000802);
+                } else {
+                        nv_wr32(priv, 0x402cc0, 0x00000000);
+                        nv_wr32(priv, 0x402ca8, 0x00000002);
+                }
+
+                break;
+        }
+
+        /* zero out zcull regions */
+        for (i = 0; i < 8; i++) {
+                nv_wr32(priv, 0x402c20 + (i * 8), 0x00000000);
+                nv_wr32(priv, 0x402c24 + (i * 8), 0x00000000);
+                nv_wr32(priv, 0x402c28 + (i * 8), 0x00000000);
+                nv_wr32(priv, 0x402c2c + (i * 8), 0x00000000);
+        }
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_graph_ctor,
+                .dtor = _nouveau_graph_dtor,
+                .init = nv50_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv50.h b/drivers/gpu/drm/nouveau/core/engine/graph/nv50.h
new file mode 100644
index 000000000000..0505fb419bde
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv50.h
@@ -0,0 +1,7 @@
+#ifndef __NV50_GRAPH_H__
+#define __NV50_GRAPH_H__
+
+int  nv50_grctx_init(struct nouveau_device *, u32 *size);
+void nv50_grctx_fill(struct nouveau_device *, struct nouveau_gpuobj *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/graph/nvc0.c
new file mode 100644
index 000000000000..c62f2d0f5f0a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nvc0.c
@@ -0,0 +1,955 @@
+/*
+ * Copyright 2012 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 "nvc0.h"
+#include "fuc/hubnvc0.fuc.h"
+#include "fuc/gpcnvc0.fuc.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nvc0_graph_sclass[] = {
+        { 0x902d, &nouveau_object_ofuncs },
+        { 0x9039, &nouveau_object_ofuncs },
+        { 0x9097, &nouveau_object_ofuncs },
+        { 0x90c0, &nouveau_object_ofuncs },
+        {}
+};
+
+static struct nouveau_oclass
+nvc1_graph_sclass[] = {
+        { 0x902d, &nouveau_object_ofuncs },
+        { 0x9039, &nouveau_object_ofuncs },
+        { 0x9097, &nouveau_object_ofuncs },
+        { 0x90c0, &nouveau_object_ofuncs },
+        { 0x9197, &nouveau_object_ofuncs },
+        {}
+};
+
+static struct nouveau_oclass
+nvc8_graph_sclass[] = {
+        { 0x902d, &nouveau_object_ofuncs },
+        { 0x9039, &nouveau_object_ofuncs },
+        { 0x9097, &nouveau_object_ofuncs },
+        { 0x90c0, &nouveau_object_ofuncs },
+        { 0x9197, &nouveau_object_ofuncs },
+        { 0x9297, &nouveau_object_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+int
+nvc0_graph_context_ctor(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass, void *args, u32 size,
+                        struct nouveau_object **pobject)
+{
+        struct nouveau_vm *vm = nouveau_client(parent)->vm;
+        struct nvc0_graph_priv *priv = (void *)engine;
+        struct nvc0_graph_data *data = priv->mmio_data;
+        struct nvc0_graph_mmio *mmio = priv->mmio_list;
+        struct nvc0_graph_chan *chan;
+        int ret, i;
+
+        /* allocate memory for context, and fill with default values */
+        ret = nouveau_graph_context_create(parent, engine, oclass, NULL,
+                                           priv->size, 0x100,
+                                           NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        /* allocate memory for a "mmio list" buffer that's used by the HUB
+         * fuc to modify some per-context register settings on first load
+         * of the context.
+         */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 0x100, 0, &chan->mmio);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_map_vm(nv_gpuobj(chan->mmio), vm,
+                                    NV_MEM_ACCESS_RW | NV_MEM_ACCESS_SYS,
+                                    &chan->mmio_vma);
+        if (ret)
+                return ret;
+
+        /* allocate buffers referenced by mmio list */
+        for (i = 0; data->size && i < ARRAY_SIZE(priv->mmio_data); i++) {
+                ret = nouveau_gpuobj_new(parent, NULL, data->size, data->align,
+                                         0, &chan->data[i].mem);
+                if (ret)
+                        return ret;
+
+                ret = nouveau_gpuobj_map_vm(chan->data[i].mem, vm, data->access,
+                                           &chan->data[i].vma);
+                if (ret)
+                        return ret;
+
+                data++;
+        }
+
+        /* finally, fill in the mmio list and point the context at it */
+        for (i = 0; mmio->addr && i < ARRAY_SIZE(priv->mmio_list); i++) {
+                u32 addr = mmio->addr;
+                u32 data = mmio->data;
+
+                if (mmio->shift) {
+                        u64 info = chan->data[mmio->buffer].vma.offset;
+                        data |= info >> mmio->shift;
+                }
+
+                nv_wo32(chan->mmio, chan->mmio_nr++ * 4, addr);
+                nv_wo32(chan->mmio, chan->mmio_nr++ * 4, data);
+                mmio++;
+        }
+
+        for (i = 0; i < priv->size; i += 4)
+                nv_wo32(chan, i, priv->data[i / 4]);
+
+        if (!priv->firmware) {
+                nv_wo32(chan, 0x00, chan->mmio_nr / 2);
+                nv_wo32(chan, 0x04, chan->mmio_vma.offset >> 8);
+        } else {
+                nv_wo32(chan, 0xf4, 0);
+                nv_wo32(chan, 0xf8, 0);
+                nv_wo32(chan, 0x10, chan->mmio_nr / 2);
+                nv_wo32(chan, 0x14, lower_32_bits(chan->mmio_vma.offset));
+                nv_wo32(chan, 0x18, upper_32_bits(chan->mmio_vma.offset));
+                nv_wo32(chan, 0x1c, 1);
+                nv_wo32(chan, 0x20, 0);
+                nv_wo32(chan, 0x28, 0);
+                nv_wo32(chan, 0x2c, 0);
+        }
+
+        return 0;
+}
+
+void
+nvc0_graph_context_dtor(struct nouveau_object *object)
+{
+        struct nvc0_graph_chan *chan = (void *)object;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(chan->data); i++) {
+                nouveau_gpuobj_unmap(&chan->data[i].vma);
+                nouveau_gpuobj_ref(NULL, &chan->data[i].mem);
+        }
+
+        nouveau_gpuobj_unmap(&chan->mmio_vma);
+        nouveau_gpuobj_ref(NULL, &chan->mmio);
+
+        nouveau_graph_context_destroy(&chan->base);
+}
+
+static struct nouveau_oclass
+nvc0_graph_cclass = {
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_graph_context_ctor,
+                .dtor = nvc0_graph_context_dtor,
+                .init = _nouveau_graph_context_init,
+                .fini = _nouveau_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static void
+nvc0_graph_ctxctl_debug_unit(struct nvc0_graph_priv *priv, u32 base)
+{
+        nv_error(priv, "%06x - done 0x%08x\n", base,
+                 nv_rd32(priv, base + 0x400));
+        nv_error(priv, "%06x - stat 0x%08x 0x%08x 0x%08x 0x%08x\n", base,
+                 nv_rd32(priv, base + 0x800), nv_rd32(priv, base + 0x804),
+                 nv_rd32(priv, base + 0x808), nv_rd32(priv, base + 0x80c));
+        nv_error(priv, "%06x - stat 0x%08x 0x%08x 0x%08x 0x%08x\n", base,
+                 nv_rd32(priv, base + 0x810), nv_rd32(priv, base + 0x814),
+                 nv_rd32(priv, base + 0x818), nv_rd32(priv, base + 0x81c));
+}
+
+void
+nvc0_graph_ctxctl_debug(struct nvc0_graph_priv *priv)
+{
+        u32 gpcnr = nv_rd32(priv, 0x409604) & 0xffff;
+        u32 gpc;
+
+        nvc0_graph_ctxctl_debug_unit(priv, 0x409000);
+        for (gpc = 0; gpc < gpcnr; gpc++)
+                nvc0_graph_ctxctl_debug_unit(priv, 0x502000 + (gpc * 0x8000));
+}
+
+static void
+nvc0_graph_ctxctl_isr(struct nvc0_graph_priv *priv)
+{
+        u32 ustat = nv_rd32(priv, 0x409c18);
+
+        if (ustat & 0x00000001)
+                nv_error(priv, "CTXCTRL ucode error\n");
+        if (ustat & 0x00080000)
+                nv_error(priv, "CTXCTRL watchdog timeout\n");
+        if (ustat & ~0x00080001)
+                nv_error(priv, "CTXCTRL 0x%08x\n", ustat);
+
+        nvc0_graph_ctxctl_debug(priv);
+        nv_wr32(priv, 0x409c20, ustat);
+}
+
+static void
+nvc0_graph_trap_tpc(struct nvc0_graph_priv *priv, int gpc, int tpc)
+{
+        u32 stat = nv_rd32(priv, TPC_UNIT(gpc, tpc, 0x0508));
+
+        if (stat & 0x00000001) {
+                u32 trap = nv_rd32(priv, TPC_UNIT(gpc, tpc, 0x0224));
+                nv_error(priv, "GPC%d/TPC%d/TEX: 0x%08x\n", gpc, tpc, trap);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0224), 0xc0000000);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0508), 0x00000001);
+                stat &= ~0x00000001;
+        }
+
+        if (stat & 0x00000002) {
+                u32 trap0 = nv_rd32(priv, TPC_UNIT(gpc, tpc, 0x0644));
+                u32 trap1 = nv_rd32(priv, TPC_UNIT(gpc, tpc, 0x064c));
+                nv_error(priv, "GPC%d/TPC%d/MP: 0x%08x 0x%08x\n",
+                               gpc, tpc, trap0, trap1);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0644), 0x001ffffe);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x064c), 0x0000000f);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0508), 0x00000002);
+                stat &= ~0x00000002;
+        }
+
+        if (stat & 0x00000004) {
+                u32 trap = nv_rd32(priv, TPC_UNIT(gpc, tpc, 0x0084));
+                nv_error(priv, "GPC%d/TPC%d/POLY: 0x%08x\n", gpc, tpc, trap);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0084), 0xc0000000);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0508), 0x00000004);
+                stat &= ~0x00000004;
+        }
+
+        if (stat & 0x00000008) {
+                u32 trap = nv_rd32(priv, TPC_UNIT(gpc, tpc, 0x048c));
+                nv_error(priv, "GPC%d/TPC%d/L1C: 0x%08x\n", gpc, tpc, trap);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x048c), 0xc0000000);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0508), 0x00000008);
+                stat &= ~0x00000008;
+        }
+
+        if (stat) {
+                nv_error(priv, "GPC%d/TPC%d/0x%08x: unknown\n", gpc, tpc, stat);
+                nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x0508), stat);
+        }
+}
+
+static void
+nvc0_graph_trap_gpc(struct nvc0_graph_priv *priv, int gpc)
+{
+        u32 stat = nv_rd32(priv, GPC_UNIT(gpc, 0x2c90));
+        int tpc;
+
+        if (stat & 0x00000001) {
+                u32 trap = nv_rd32(priv, GPC_UNIT(gpc, 0x0420));
+                nv_error(priv, "GPC%d/PROP: 0x%08x\n", gpc, trap);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0420), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), 0x00000001);
+                stat &= ~0x00000001;
+        }
+
+        if (stat & 0x00000002) {
+                u32 trap = nv_rd32(priv, GPC_UNIT(gpc, 0x0900));
+                nv_error(priv, "GPC%d/ZCULL: 0x%08x\n", gpc, trap);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0900), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), 0x00000002);
+                stat &= ~0x00000002;
+        }
+
+        if (stat & 0x00000004) {
+                u32 trap = nv_rd32(priv, GPC_UNIT(gpc, 0x1028));
+                nv_error(priv, "GPC%d/CCACHE: 0x%08x\n", gpc, trap);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x1028), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), 0x00000004);
+                stat &= ~0x00000004;
+        }
+
+        if (stat & 0x00000008) {
+                u32 trap = nv_rd32(priv, GPC_UNIT(gpc, 0x0824));
+                nv_error(priv, "GPC%d/ESETUP: 0x%08x\n", gpc, trap);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0824), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), 0x00000008);
+                stat &= ~0x00000009;
+        }
+
+        for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
+                u32 mask = 0x00010000 << tpc;
+                if (stat & mask) {
+                        nvc0_graph_trap_tpc(priv, gpc, tpc);
+                        nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), mask);
+                        stat &= ~mask;
+                }
+        }
+
+        if (stat) {
+                nv_error(priv, "GPC%d/0x%08x: unknown\n", gpc, stat);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), stat);
+        }
+}
+
+static void
+nvc0_graph_trap_intr(struct nvc0_graph_priv *priv)
+{
+        u32 trap = nv_rd32(priv, 0x400108);
+        int rop, gpc;
+
+        if (trap & 0x00000001) {
+                u32 stat = nv_rd32(priv, 0x404000);
+                nv_error(priv, "DISPATCH 0x%08x\n", stat);
+                nv_wr32(priv, 0x404000, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000001);
+                trap &= ~0x00000001;
+        }
+
+        if (trap & 0x00000002) {
+                u32 stat = nv_rd32(priv, 0x404600);
+                nv_error(priv, "M2MF 0x%08x\n", stat);
+                nv_wr32(priv, 0x404600, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000002);
+                trap &= ~0x00000002;
+        }
+
+        if (trap & 0x00000008) {
+                u32 stat = nv_rd32(priv, 0x408030);
+                nv_error(priv, "CCACHE 0x%08x\n", stat);
+                nv_wr32(priv, 0x408030, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000008);
+                trap &= ~0x00000008;
+        }
+
+        if (trap & 0x00000010) {
+                u32 stat = nv_rd32(priv, 0x405840);
+                nv_error(priv, "SHADER 0x%08x\n", stat);
+                nv_wr32(priv, 0x405840, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000010);
+                trap &= ~0x00000010;
+        }
+
+        if (trap & 0x00000040) {
+                u32 stat = nv_rd32(priv, 0x40601c);
+                nv_error(priv, "UNK6 0x%08x\n", stat);
+                nv_wr32(priv, 0x40601c, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000040);
+                trap &= ~0x00000040;
+        }
+
+        if (trap & 0x00000080) {
+                u32 stat = nv_rd32(priv, 0x404490);
+                nv_error(priv, "MACRO 0x%08x\n", stat);
+                nv_wr32(priv, 0x404490, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000080);
+                trap &= ~0x00000080;
+        }
+
+        if (trap & 0x01000000) {
+                u32 stat = nv_rd32(priv, 0x400118);
+                for (gpc = 0; stat && gpc < priv->gpc_nr; gpc++) {
+                        u32 mask = 0x00000001 << gpc;
+                        if (stat & mask) {
+                                nvc0_graph_trap_gpc(priv, gpc);
+                                nv_wr32(priv, 0x400118, mask);
+                                stat &= ~mask;
+                        }
+                }
+                nv_wr32(priv, 0x400108, 0x01000000);
+                trap &= ~0x01000000;
+        }
+
+        if (trap & 0x02000000) {
+                for (rop = 0; rop < priv->rop_nr; rop++) {
+                        u32 statz = nv_rd32(priv, ROP_UNIT(rop, 0x070));
+                        u32 statc = nv_rd32(priv, ROP_UNIT(rop, 0x144));
+                        nv_error(priv, "ROP%d 0x%08x 0x%08x\n",
+                                 rop, statz, statc);
+                        nv_wr32(priv, ROP_UNIT(rop, 0x070), 0xc0000000);
+                        nv_wr32(priv, ROP_UNIT(rop, 0x144), 0xc0000000);
+                }
+                nv_wr32(priv, 0x400108, 0x02000000);
+                trap &= ~0x02000000;
+        }
+
+        if (trap) {
+                nv_error(priv, "TRAP UNHANDLED 0x%08x\n", trap);
+                nv_wr32(priv, 0x400108, trap);
+        }
+}
+
+static void
+nvc0_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nouveau_handle *handle;
+        struct nvc0_graph_priv *priv = (void *)subdev;
+        u64 inst = nv_rd32(priv, 0x409b00) & 0x0fffffff;
+        u32 stat = nv_rd32(priv, 0x400100);
+        u32 addr = nv_rd32(priv, 0x400704);
+        u32 mthd = (addr & 0x00003ffc);
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 data = nv_rd32(priv, 0x400708);
+        u32 code = nv_rd32(priv, 0x400110);
+        u32 class = nv_rd32(priv, 0x404200 + (subc * 4));
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x00000010) {
+                handle = nouveau_handle_get_class(engctx, class);
+                if (!handle || nv_call(handle->object, mthd, data)) {
+                        nv_error(priv, "ILLEGAL_MTHD ch %d [0x%010llx] "
+                                     "subc %d class 0x%04x mthd 0x%04x "
+                                     "data 0x%08x\n",
+                                 chid, inst << 12, subc, class, mthd, data);
+                }
+                nouveau_handle_put(handle);
+                nv_wr32(priv, 0x400100, 0x00000010);
+                stat &= ~0x00000010;
+        }
+
+        if (stat & 0x00000020) {
+                nv_error(priv, "ILLEGAL_CLASS ch %d [0x%010llx] subc %d "
+                             "class 0x%04x mthd 0x%04x data 0x%08x\n",
+                        chid, inst << 12, subc, class, mthd, data);
+                nv_wr32(priv, 0x400100, 0x00000020);
+                stat &= ~0x00000020;
+        }
+
+        if (stat & 0x00100000) {
+                nv_error(priv, "DATA_ERROR [");
+                nouveau_enum_print(nv50_data_error_names, code);
+                printk("] ch %d [0x%010llx] subc %d class 0x%04x "
+                       "mthd 0x%04x data 0x%08x\n",
+                       chid, inst << 12, subc, class, mthd, data);
+                nv_wr32(priv, 0x400100, 0x00100000);
+                stat &= ~0x00100000;
+        }
+
+        if (stat & 0x00200000) {
+                nv_error(priv, "TRAP ch %d [0x%010llx]\n", chid, inst << 12);
+                nvc0_graph_trap_intr(priv);
+                nv_wr32(priv, 0x400100, 0x00200000);
+                stat &= ~0x00200000;
+        }
+
+        if (stat & 0x00080000) {
+                nvc0_graph_ctxctl_isr(priv);
+                nv_wr32(priv, 0x400100, 0x00080000);
+                stat &= ~0x00080000;
+        }
+
+        if (stat) {
+                nv_error(priv, "unknown stat 0x%08x\n", stat);
+                nv_wr32(priv, 0x400100, stat);
+        }
+
+        nv_wr32(priv, 0x400500, 0x00010001);
+        nouveau_engctx_put(engctx);
+}
+
+int
+nvc0_graph_ctor_fw(struct nvc0_graph_priv *priv, const char *fwname,
+                   struct nvc0_graph_fuc *fuc)
+{
+        struct nouveau_device *device = nv_device(priv);
+        const struct firmware *fw;
+        char f[32];
+        int ret;
+
+        snprintf(f, sizeof(f), "nouveau/nv%02x_%s", device->chipset, fwname);
+        ret = request_firmware(&fw, f, &device->pdev->dev);
+        if (ret) {
+                snprintf(f, sizeof(f), "nouveau/%s", fwname);
+                ret = request_firmware(&fw, f, &device->pdev->dev);
+                if (ret) {
+                        nv_error(priv, "failed to load %s\n", fwname);
+                        return ret;
+                }
+        }
+
+        fuc->size = fw->size;
+        fuc->data = kmemdup(fw->data, fuc->size, GFP_KERNEL);
+        release_firmware(fw);
+        return (fuc->data != NULL) ? 0 : -ENOMEM;
+}
+
+static int
+nvc0_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nvc0_graph_priv *priv;
+        bool enable = true;
+        int ret, i;
+
+        switch (device->chipset) {
+        case 0xd9: /* known broken without binary driver firmware */
+                enable = false;
+                break;
+        default:
+                break;
+        }
+
+        ret = nouveau_graph_create(parent, engine, oclass, enable, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x18001000;
+        nv_subdev(priv)->intr = nvc0_graph_intr;
+        nv_engine(priv)->cclass = &nvc0_graph_cclass;
+
+        if (nouveau_boolopt(device->cfgopt, "NvGrUseFW", false)) {
+                nv_info(priv, "using external firmware\n");
+                if (nvc0_graph_ctor_fw(priv, "fuc409c", &priv->fuc409c) ||
+                    nvc0_graph_ctor_fw(priv, "fuc409d", &priv->fuc409d) ||
+                    nvc0_graph_ctor_fw(priv, "fuc41ac", &priv->fuc41ac) ||
+                    nvc0_graph_ctor_fw(priv, "fuc41ad", &priv->fuc41ad))
+                        return -EINVAL;
+                priv->firmware = true;
+        }
+
+        switch (nvc0_graph_class(priv)) {
+        case 0x9097:
+                nv_engine(priv)->sclass = nvc0_graph_sclass;
+                break;
+        case 0x9197:
+                nv_engine(priv)->sclass = nvc1_graph_sclass;
+                break;
+        case 0x9297:
+                nv_engine(priv)->sclass = nvc8_graph_sclass;
+                break;
+        }
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 256, 0, &priv->unk4188b4);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 256, 0, &priv->unk4188b8);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < 0x1000; i += 4) {
+                nv_wo32(priv->unk4188b4, i, 0x00000010);
+                nv_wo32(priv->unk4188b8, i, 0x00000010);
+        }
+
+        priv->rop_nr = (nv_rd32(priv, 0x409604) & 0x001f0000) >> 16;
+        priv->gpc_nr =  nv_rd32(priv, 0x409604) & 0x0000001f;
+        for (i = 0; i < priv->gpc_nr; i++) {
+                priv->tpc_nr[i]  = nv_rd32(priv, GPC_UNIT(i, 0x2608));
+                priv->tpc_total += priv->tpc_nr[i];
+        }
+
+        /*XXX: these need figuring out... though it might not even matter */
+        switch (nv_device(priv)->chipset) {
+        case 0xc0:
+                if (priv->tpc_total == 11) { /* 465, 3/4/4/0, 4 */
+                        priv->magic_not_rop_nr = 0x07;
+                } else
+                if (priv->tpc_total == 14) { /* 470, 3/3/4/4, 5 */
+                        priv->magic_not_rop_nr = 0x05;
+                } else
+                if (priv->tpc_total == 15) { /* 480, 3/4/4/4, 6 */
+                        priv->magic_not_rop_nr = 0x06;
+                }
+                break;
+        case 0xc3: /* 450, 4/0/0/0, 2 */
+                priv->magic_not_rop_nr = 0x03;
+                break;
+        case 0xc4: /* 460, 3/4/0/0, 4 */
+                priv->magic_not_rop_nr = 0x01;
+                break;
+        case 0xc1: /* 2/0/0/0, 1 */
+                priv->magic_not_rop_nr = 0x01;
+                break;
+        case 0xc8: /* 4/4/3/4, 5 */
+                priv->magic_not_rop_nr = 0x06;
+                break;
+        case 0xce: /* 4/4/0/0, 4 */
+                priv->magic_not_rop_nr = 0x03;
+                break;
+        case 0xcf: /* 4/0/0/0, 3 */
+                priv->magic_not_rop_nr = 0x03;
+                break;
+        case 0xd9: /* 1/0/0/0, 1 */
+                priv->magic_not_rop_nr = 0x01;
+                break;
+        }
+
+        return 0;
+}
+
+static void
+nvc0_graph_dtor_fw(struct nvc0_graph_fuc *fuc)
+{
+        if (fuc->data) {
+                kfree(fuc->data);
+                fuc->data = NULL;
+        }
+}
+
+void
+nvc0_graph_dtor(struct nouveau_object *object)
+{
+        struct nvc0_graph_priv *priv = (void *)object;
+
+        if (priv->data)
+                kfree(priv->data);
+
+        nvc0_graph_dtor_fw(&priv->fuc409c);
+        nvc0_graph_dtor_fw(&priv->fuc409d);
+        nvc0_graph_dtor_fw(&priv->fuc41ac);
+        nvc0_graph_dtor_fw(&priv->fuc41ad);
+
+        nouveau_gpuobj_ref(NULL, &priv->unk4188b8);
+        nouveau_gpuobj_ref(NULL, &priv->unk4188b4);
+
+        nouveau_graph_destroy(&priv->base);
+}
+
+static void
+nvc0_graph_init_obj418880(struct nvc0_graph_priv *priv)
+{
+        int i;
+
+        nv_wr32(priv, GPC_BCAST(0x0880), 0x00000000);
+        nv_wr32(priv, GPC_BCAST(0x08a4), 0x00000000);
+        for (i = 0; i < 4; i++)
+                nv_wr32(priv, GPC_BCAST(0x0888) + (i * 4), 0x00000000);
+        nv_wr32(priv, GPC_BCAST(0x08b4), priv->unk4188b4->addr >> 8);
+        nv_wr32(priv, GPC_BCAST(0x08b8), priv->unk4188b8->addr >> 8);
+}
+
+static void
+nvc0_graph_init_regs(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x400080, 0x003083c2);
+        nv_wr32(priv, 0x400088, 0x00006fe7);
+        nv_wr32(priv, 0x40008c, 0x00000000);
+        nv_wr32(priv, 0x400090, 0x00000030);
+        nv_wr32(priv, 0x40013c, 0x013901f7);
+        nv_wr32(priv, 0x400140, 0x00000100);
+        nv_wr32(priv, 0x400144, 0x00000000);
+        nv_wr32(priv, 0x400148, 0x00000110);
+        nv_wr32(priv, 0x400138, 0x00000000);
+        nv_wr32(priv, 0x400130, 0x00000000);
+        nv_wr32(priv, 0x400134, 0x00000000);
+        nv_wr32(priv, 0x400124, 0x00000002);
+}
+
+static void
+nvc0_graph_init_gpc_0(struct nvc0_graph_priv *priv)
+{
+        const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, priv->tpc_total);
+        u32 data[TPC_MAX / 8];
+        u8  tpcnr[GPC_MAX];
+        int i, gpc, tpc;
+
+        nv_wr32(priv, TPC_UNIT(0, 0, 0x5c), 1); /* affects TFB offset queries */
+
+        /*
+         *      TP      ROP UNKVAL(magic_not_rop_nr)
+         * 450: 4/0/0/0 2        3
+         * 460: 3/4/0/0 4        1
+         * 465: 3/4/4/0 4        7
+         * 470: 3/3/4/4 5        5
+         * 480: 3/4/4/4 6        6
+         */
+
+        memset(data, 0x00, sizeof(data));
+        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+        for (i = 0, gpc = -1; i < priv->tpc_total; i++) {
+                do {
+                        gpc = (gpc + 1) % priv->gpc_nr;
+                } while (!tpcnr[gpc]);
+                tpc = priv->tpc_nr[gpc] - tpcnr[gpc]--;
+
+                data[i / 8] |= tpc << ((i % 8) * 4);
+        }
+
+        nv_wr32(priv, GPC_BCAST(0x0980), data[0]);
+        nv_wr32(priv, GPC_BCAST(0x0984), data[1]);
+        nv_wr32(priv, GPC_BCAST(0x0988), data[2]);
+        nv_wr32(priv, GPC_BCAST(0x098c), data[3]);
+
+        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0914), priv->magic_not_rop_nr << 8 |
+                                                  priv->tpc_nr[gpc]);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0910), 0x00040000 | priv->tpc_total);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0918), magicgpc918);
+        }
+
+        nv_wr32(priv, GPC_BCAST(0x1bd4), magicgpc918);
+        nv_wr32(priv, GPC_BCAST(0x08ac), nv_rd32(priv, 0x100800));
+}
+
+static void
+nvc0_graph_init_units(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x409c24, 0x000f0000);
+        nv_wr32(priv, 0x404000, 0xc0000000); /* DISPATCH */
+        nv_wr32(priv, 0x404600, 0xc0000000); /* M2MF */
+        nv_wr32(priv, 0x408030, 0xc0000000);
+        nv_wr32(priv, 0x40601c, 0xc0000000);
+        nv_wr32(priv, 0x404490, 0xc0000000); /* MACRO */
+        nv_wr32(priv, 0x406018, 0xc0000000);
+        nv_wr32(priv, 0x405840, 0xc0000000);
+        nv_wr32(priv, 0x405844, 0x00ffffff);
+        nv_mask(priv, 0x419cc0, 0x00000008, 0x00000008);
+        nv_mask(priv, 0x419eb4, 0x00001000, 0x00001000);
+}
+
+static void
+nvc0_graph_init_gpc_1(struct nvc0_graph_priv *priv)
+{
+        int gpc, tpc;
+
+        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0420), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0900), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x1028), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0824), 0xc0000000);
+                for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x508), 0xffffffff);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x50c), 0xffffffff);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x224), 0xc0000000);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x48c), 0xc0000000);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x084), 0xc0000000);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x644), 0x001ffffe);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x64c), 0x0000000f);
+                }
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), 0xffffffff);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c94), 0xffffffff);
+        }
+}
+
+static void
+nvc0_graph_init_rop(struct nvc0_graph_priv *priv)
+{
+        int rop;
+
+        for (rop = 0; rop < priv->rop_nr; rop++) {
+                nv_wr32(priv, ROP_UNIT(rop, 0x144), 0xc0000000);
+                nv_wr32(priv, ROP_UNIT(rop, 0x070), 0xc0000000);
+                nv_wr32(priv, ROP_UNIT(rop, 0x204), 0xffffffff);
+                nv_wr32(priv, ROP_UNIT(rop, 0x208), 0xffffffff);
+        }
+}
+
+void
+nvc0_graph_init_fw(struct nvc0_graph_priv *priv, u32 fuc_base,
+                   struct nvc0_graph_fuc *code, struct nvc0_graph_fuc *data)
+{
+        int i;
+
+        nv_wr32(priv, fuc_base + 0x01c0, 0x01000000);
+        for (i = 0; i < data->size / 4; i++)
+                nv_wr32(priv, fuc_base + 0x01c4, data->data[i]);
+
+        nv_wr32(priv, fuc_base + 0x0180, 0x01000000);
+        for (i = 0; i < code->size / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, fuc_base + 0x0188, i >> 6);
+                nv_wr32(priv, fuc_base + 0x0184, code->data[i]);
+        }
+}
+
+static int
+nvc0_graph_init_ctxctl(struct nvc0_graph_priv *priv)
+{
+        u32 r000260;
+        int i;
+
+        if (priv->firmware) {
+                /* load fuc microcode */
+                r000260 = nv_mask(priv, 0x000260, 0x00000001, 0x00000000);
+                nvc0_graph_init_fw(priv, 0x409000, &priv->fuc409c,
+                                                   &priv->fuc409d);
+                nvc0_graph_init_fw(priv, 0x41a000, &priv->fuc41ac,
+                                                   &priv->fuc41ad);
+                nv_wr32(priv, 0x000260, r000260);
+
+                /* start both of them running */
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x41a10c, 0x00000000);
+                nv_wr32(priv, 0x40910c, 0x00000000);
+                nv_wr32(priv, 0x41a100, 0x00000002);
+                nv_wr32(priv, 0x409100, 0x00000002);
+                if (!nv_wait(priv, 0x409800, 0x00000001, 0x00000001))
+                        nv_info(priv, "0x409800 wait failed\n");
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x7fffffff);
+                nv_wr32(priv, 0x409504, 0x00000021);
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x00000000);
+                nv_wr32(priv, 0x409504, 0x00000010);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x10 timeout\n");
+                        return -EBUSY;
+                }
+                priv->size = nv_rd32(priv, 0x409800);
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x00000000);
+                nv_wr32(priv, 0x409504, 0x00000016);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x16 timeout\n");
+                        return -EBUSY;
+                }
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x00000000);
+                nv_wr32(priv, 0x409504, 0x00000025);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x25 timeout\n");
+                        return -EBUSY;
+                }
+
+                if (priv->data == NULL) {
+                        int ret = nvc0_grctx_generate(priv);
+                        if (ret) {
+                                nv_error(priv, "failed to construct context\n");
+                                return ret;
+                        }
+                }
+
+                return 0;
+        }
+
+        /* load HUB microcode */
+        r000260 = nv_mask(priv, 0x000260, 0x00000001, 0x00000000);
+        nv_wr32(priv, 0x4091c0, 0x01000000);
+        for (i = 0; i < sizeof(nvc0_grhub_data) / 4; i++)
+                nv_wr32(priv, 0x4091c4, nvc0_grhub_data[i]);
+
+        nv_wr32(priv, 0x409180, 0x01000000);
+        for (i = 0; i < sizeof(nvc0_grhub_code) / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, 0x409188, i >> 6);
+                nv_wr32(priv, 0x409184, nvc0_grhub_code[i]);
+        }
+
+        /* load GPC microcode */
+        nv_wr32(priv, 0x41a1c0, 0x01000000);
+        for (i = 0; i < sizeof(nvc0_grgpc_data) / 4; i++)
+                nv_wr32(priv, 0x41a1c4, nvc0_grgpc_data[i]);
+
+        nv_wr32(priv, 0x41a180, 0x01000000);
+        for (i = 0; i < sizeof(nvc0_grgpc_code) / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, 0x41a188, i >> 6);
+                nv_wr32(priv, 0x41a184, nvc0_grgpc_code[i]);
+        }
+        nv_wr32(priv, 0x000260, r000260);
+
+        /* start HUB ucode running, it'll init the GPCs */
+        nv_wr32(priv, 0x409800, nv_device(priv)->chipset);
+        nv_wr32(priv, 0x40910c, 0x00000000);
+        nv_wr32(priv, 0x409100, 0x00000002);
+        if (!nv_wait(priv, 0x409800, 0x80000000, 0x80000000)) {
+                nv_error(priv, "HUB_INIT timed out\n");
+                nvc0_graph_ctxctl_debug(priv);
+                return -EBUSY;
+        }
+
+        priv->size = nv_rd32(priv, 0x409804);
+        if (priv->data == NULL) {
+                int ret = nvc0_grctx_generate(priv);
+                if (ret) {
+                        nv_error(priv, "failed to construct context\n");
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int
+nvc0_graph_init(struct nouveau_object *object)
+{
+        struct nvc0_graph_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nvc0_graph_init_obj418880(priv);
+        nvc0_graph_init_regs(priv);
+        /*nvc0_graph_init_unitplemented_magics(priv);*/
+        nvc0_graph_init_gpc_0(priv);
+        /*nvc0_graph_init_unitplemented_c242(priv);*/
+
+        nv_wr32(priv, 0x400500, 0x00010001);
+        nv_wr32(priv, 0x400100, 0xffffffff);
+        nv_wr32(priv, 0x40013c, 0xffffffff);
+
+        nvc0_graph_init_units(priv);
+        nvc0_graph_init_gpc_1(priv);
+        nvc0_graph_init_rop(priv);
+
+        nv_wr32(priv, 0x400108, 0xffffffff);
+        nv_wr32(priv, 0x400138, 0xffffffff);
+        nv_wr32(priv, 0x400118, 0xffffffff);
+        nv_wr32(priv, 0x400130, 0xffffffff);
+        nv_wr32(priv, 0x40011c, 0xffffffff);
+        nv_wr32(priv, 0x400134, 0xffffffff);
+        nv_wr32(priv, 0x400054, 0x34ce3464);
+
+        ret = nvc0_graph_init_ctxctl(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_graph_ctor,
+                .dtor = nvc0_graph_dtor,
+                .init = nvc0_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nvc0.h b/drivers/gpu/drm/nouveau/core/engine/graph/nvc0.h
new file mode 100644
index 000000000000..18d2210e12eb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nvc0.h
@@ -0,0 +1,171 @@
+/*
+ * 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
+ */
+
+#ifndef __NVC0_GRAPH_H__
+#define __NVC0_GRAPH_H__
+
+#include <core/client.h>
+#include <core/handle.h>
+#include <core/gpuobj.h>
+#include <core/option.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+#include <subdev/bar.h>
+#include <subdev/timer.h>
+
+#include <engine/fifo.h>
+#include <engine/graph.h>
+
+#define GPC_MAX 4
+#define TPC_MAX 32
+
+#define ROP_BCAST(r)      (0x408800 + (r))
+#define ROP_UNIT(u, r)    (0x410000 + (u) * 0x400 + (r))
+#define GPC_BCAST(r)      (0x418000 + (r))
+#define GPC_UNIT(t, r)    (0x500000 + (t) * 0x8000 + (r))
+#define TPC_UNIT(t, m, r) (0x504000 + (t) * 0x8000 + (m) * 0x800 + (r))
+
+struct nvc0_graph_data {
+        u32 size;
+        u32 align;
+        u32 access;
+};
+
+struct nvc0_graph_mmio {
+        u32 addr;
+        u32 data;
+        u32 shift;
+        u32 buffer;
+};
+
+struct nvc0_graph_fuc {
+        u32 *data;
+        u32  size;
+};
+
+struct nvc0_graph_priv {
+        struct nouveau_graph base;
+
+        struct nvc0_graph_fuc fuc409c;
+        struct nvc0_graph_fuc fuc409d;
+        struct nvc0_graph_fuc fuc41ac;
+        struct nvc0_graph_fuc fuc41ad;
+        bool firmware;
+
+        u8 rop_nr;
+        u8 gpc_nr;
+        u8 tpc_nr[GPC_MAX];
+        u8 tpc_total;
+
+        struct nouveau_gpuobj *unk4188b4;
+        struct nouveau_gpuobj *unk4188b8;
+
+        struct nvc0_graph_data mmio_data[4];
+        struct nvc0_graph_mmio mmio_list[4096/8];
+        u32  size;
+        u32 *data;
+
+        u8 magic_not_rop_nr;
+};
+
+struct nvc0_graph_chan {
+        struct nouveau_graph_chan base;
+
+        struct nouveau_gpuobj *mmio;
+        struct nouveau_vma mmio_vma;
+        int mmio_nr;
+        struct {
+                struct nouveau_gpuobj *mem;
+                struct nouveau_vma vma;
+        } data[4];
+};
+
+static inline u32
+nvc0_graph_class(void *obj)
+{
+        struct nouveau_device *device = nv_device(obj);
+
+        switch (device->chipset) {
+        case 0xc0:
+        case 0xc3:
+        case 0xc4:
+        case 0xce: /* guess, mmio trace shows only 0x9097 state */
+        case 0xcf: /* guess, mmio trace shows only 0x9097 state */
+                return 0x9097;
+        case 0xc1:
+                return 0x9197;
+        case 0xc8:
+        case 0xd9:
+                return 0x9297;
+        case 0xe4:
+        case 0xe7:
+                return 0xa097;
+        default:
+                return 0;
+        }
+}
+
+void nv_icmd(struct nvc0_graph_priv *priv, u32 icmd, u32 data);
+
+static inline void
+nv_mthd(struct nvc0_graph_priv *priv, u32 class, u32 mthd, u32 data)
+{
+        nv_wr32(priv, 0x40448c, data);
+        nv_wr32(priv, 0x404488, 0x80000000 | (mthd << 14) | class);
+}
+
+struct nvc0_grctx {
+        struct nvc0_graph_priv *priv;
+        struct nvc0_graph_data *data;
+        struct nvc0_graph_mmio *mmio;
+        struct nouveau_gpuobj *chan;
+        int buffer_nr;
+        u64 buffer[4];
+        u64 addr;
+};
+
+int  nvc0_grctx_generate(struct nvc0_graph_priv *);
+int  nvc0_grctx_init(struct nvc0_graph_priv *, struct nvc0_grctx *);
+void nvc0_grctx_data(struct nvc0_grctx *, u32, u32, u32);
+void nvc0_grctx_mmio(struct nvc0_grctx *, u32, u32, u32, u32);
+int  nvc0_grctx_fini(struct nvc0_grctx *);
+
+int  nve0_grctx_generate(struct nvc0_graph_priv *);
+
+#define mmio_data(s,a,p) nvc0_grctx_data(&info, (s), (a), (p))
+#define mmio_list(r,d,s,b) nvc0_grctx_mmio(&info, (r), (d), (s), (b))
+
+void nvc0_graph_ctxctl_debug(struct nvc0_graph_priv *);
+int  nvc0_graph_ctor_fw(struct nvc0_graph_priv *, const char *,
+                        struct nvc0_graph_fuc *);
+void nvc0_graph_dtor(struct nouveau_object *);
+void nvc0_graph_init_fw(struct nvc0_graph_priv *, u32 base,
+                        struct nvc0_graph_fuc *, struct nvc0_graph_fuc *);
+int  nvc0_graph_context_ctor(struct nouveau_object *, struct nouveau_object *,
+                             struct nouveau_oclass *, void *, u32,
+                             struct nouveau_object **);
+void nvc0_graph_context_dtor(struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nve0.c b/drivers/gpu/drm/nouveau/core/engine/graph/nve0.c
new file mode 100644
index 000000000000..539d4c72f192
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nve0.c
@@ -0,0 +1,576 @@
+/*
+ * Copyright 2012 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 "nvc0.h"
+#include "fuc/hubnve0.fuc.h"
+#include "fuc/gpcnve0.fuc.h"
+
+/*******************************************************************************
+ * Graphics object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nve0_graph_sclass[] = {
+        { 0x902d, &nouveau_object_ofuncs },
+        { 0xa040, &nouveau_object_ofuncs },
+        { 0xa097, &nouveau_object_ofuncs },
+        { 0xa0c0, &nouveau_object_ofuncs },
+        { 0xa0b5, &nouveau_object_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PGRAPH context
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nve0_graph_cclass = {
+        .handle = NV_ENGCTX(GR, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_graph_context_ctor,
+                .dtor = nvc0_graph_context_dtor,
+                .init = _nouveau_graph_context_init,
+                .fini = _nouveau_graph_context_fini,
+                .rd32 = _nouveau_graph_context_rd32,
+                .wr32 = _nouveau_graph_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PGRAPH engine/subdev functions
+ ******************************************************************************/
+
+static void
+nve0_graph_ctxctl_isr(struct nvc0_graph_priv *priv)
+{
+        u32 ustat = nv_rd32(priv, 0x409c18);
+
+        if (ustat & 0x00000001)
+                nv_error(priv, "CTXCTRL ucode error\n");
+        if (ustat & 0x00080000)
+                nv_error(priv, "CTXCTRL watchdog timeout\n");
+        if (ustat & ~0x00080001)
+                nv_error(priv, "CTXCTRL 0x%08x\n", ustat);
+
+        nvc0_graph_ctxctl_debug(priv);
+        nv_wr32(priv, 0x409c20, ustat);
+}
+
+static void
+nve0_graph_trap_isr(struct nvc0_graph_priv *priv, int chid, u64 inst)
+{
+        u32 trap = nv_rd32(priv, 0x400108);
+        int rop;
+
+        if (trap & 0x00000001) {
+                u32 stat = nv_rd32(priv, 0x404000);
+                nv_error(priv, "DISPATCH ch %d [0x%010llx] 0x%08x\n",
+                         chid, inst, stat);
+                nv_wr32(priv, 0x404000, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000001);
+                trap &= ~0x00000001;
+        }
+
+        if (trap & 0x00000010) {
+                u32 stat = nv_rd32(priv, 0x405840);
+                nv_error(priv, "SHADER ch %d [0x%010llx] 0x%08x\n",
+                         chid, inst, stat);
+                nv_wr32(priv, 0x405840, 0xc0000000);
+                nv_wr32(priv, 0x400108, 0x00000010);
+                trap &= ~0x00000010;
+        }
+
+        if (trap & 0x02000000) {
+                for (rop = 0; rop < priv->rop_nr; rop++) {
+                        u32 statz = nv_rd32(priv, ROP_UNIT(rop, 0x070));
+                        u32 statc = nv_rd32(priv, ROP_UNIT(rop, 0x144));
+                        nv_error(priv, "ROP%d ch %d [0x%010llx] 0x%08x 0x%08x\n",
+                                 rop, chid, inst, statz, statc);
+                        nv_wr32(priv, ROP_UNIT(rop, 0x070), 0xc0000000);
+                        nv_wr32(priv, ROP_UNIT(rop, 0x144), 0xc0000000);
+                }
+                nv_wr32(priv, 0x400108, 0x02000000);
+                trap &= ~0x02000000;
+        }
+
+        if (trap) {
+                nv_error(priv, "TRAP ch %d [0x%010llx] 0x%08x\n",
+                         chid, inst, trap);
+                nv_wr32(priv, 0x400108, trap);
+        }
+}
+
+static void
+nve0_graph_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nouveau_handle *handle;
+        struct nvc0_graph_priv *priv = (void *)subdev;
+        u64 inst = nv_rd32(priv, 0x409b00) & 0x0fffffff;
+        u32 stat = nv_rd32(priv, 0x400100);
+        u32 addr = nv_rd32(priv, 0x400704);
+        u32 mthd = (addr & 0x00003ffc);
+        u32 subc = (addr & 0x00070000) >> 16;
+        u32 data = nv_rd32(priv, 0x400708);
+        u32 code = nv_rd32(priv, 0x400110);
+        u32 class = nv_rd32(priv, 0x404200 + (subc * 4));
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x00000010) {
+                handle = nouveau_handle_get_class(engctx, class);
+                if (!handle || nv_call(handle->object, mthd, data)) {
+                        nv_error(priv, "ILLEGAL_MTHD ch %d [0x%010llx] "
+                                     "subc %d class 0x%04x mthd 0x%04x "
+                                     "data 0x%08x\n",
+                                 chid, inst, subc, class, mthd, data);
+                }
+                nouveau_handle_put(handle);
+                nv_wr32(priv, 0x400100, 0x00000010);
+                stat &= ~0x00000010;
+        }
+
+        if (stat & 0x00000020) {
+                nv_error(priv, "ILLEGAL_CLASS ch %d [0x%010llx] subc %d "
+                             "class 0x%04x mthd 0x%04x data 0x%08x\n",
+                         chid, inst, subc, class, mthd, data);
+                nv_wr32(priv, 0x400100, 0x00000020);
+                stat &= ~0x00000020;
+        }
+
+        if (stat & 0x00100000) {
+                nv_error(priv, "DATA_ERROR [");
+                nouveau_enum_print(nv50_data_error_names, code);
+                printk("] ch %d [0x%010llx] subc %d class 0x%04x "
+                       "mthd 0x%04x data 0x%08x\n",
+                       chid, inst, subc, class, mthd, data);
+                nv_wr32(priv, 0x400100, 0x00100000);
+                stat &= ~0x00100000;
+        }
+
+        if (stat & 0x00200000) {
+                nve0_graph_trap_isr(priv, chid, inst);
+                nv_wr32(priv, 0x400100, 0x00200000);
+                stat &= ~0x00200000;
+        }
+
+        if (stat & 0x00080000) {
+                nve0_graph_ctxctl_isr(priv);
+                nv_wr32(priv, 0x400100, 0x00080000);
+                stat &= ~0x00080000;
+        }
+
+        if (stat) {
+                nv_error(priv, "unknown stat 0x%08x\n", stat);
+                nv_wr32(priv, 0x400100, stat);
+        }
+
+        nv_wr32(priv, 0x400500, 0x00010001);
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nve0_graph_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nvc0_graph_priv *priv;
+        int ret, i;
+
+        ret = nouveau_graph_create(parent, engine, oclass, false, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x18001000;
+        nv_subdev(priv)->intr = nve0_graph_intr;
+        nv_engine(priv)->cclass = &nve0_graph_cclass;
+        nv_engine(priv)->sclass = nve0_graph_sclass;
+
+        if (nouveau_boolopt(device->cfgopt, "NvGrUseFW", false)) {
+                nv_info(priv, "using external firmware\n");
+                if (nvc0_graph_ctor_fw(priv, "fuc409c", &priv->fuc409c) ||
+                    nvc0_graph_ctor_fw(priv, "fuc409d", &priv->fuc409d) ||
+                    nvc0_graph_ctor_fw(priv, "fuc41ac", &priv->fuc41ac) ||
+                    nvc0_graph_ctor_fw(priv, "fuc41ad", &priv->fuc41ad))
+                        return -EINVAL;
+                priv->firmware = true;
+        }
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 256, 0, &priv->unk4188b4);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 256, 0, &priv->unk4188b8);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < 0x1000; i += 4) {
+                nv_wo32(priv->unk4188b4, i, 0x00000010);
+                nv_wo32(priv->unk4188b8, i, 0x00000010);
+        }
+
+        priv->gpc_nr =  nv_rd32(priv, 0x409604) & 0x0000001f;
+        priv->rop_nr = (nv_rd32(priv, 0x409604) & 0x001f0000) >> 16;
+        for (i = 0; i < priv->gpc_nr; i++) {
+                priv->tpc_nr[i] = nv_rd32(priv, GPC_UNIT(i, 0x2608));
+                priv->tpc_total += priv->tpc_nr[i];
+        }
+
+        switch (nv_device(priv)->chipset) {
+        case 0xe4:
+                if (priv->tpc_total == 8)
+                        priv->magic_not_rop_nr = 3;
+                else
+                if (priv->tpc_total == 7)
+                        priv->magic_not_rop_nr = 1;
+                break;
+        case 0xe7:
+                priv->magic_not_rop_nr = 1;
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static void
+nve0_graph_init_obj418880(struct nvc0_graph_priv *priv)
+{
+        int i;
+
+        nv_wr32(priv, GPC_BCAST(0x0880), 0x00000000);
+        nv_wr32(priv, GPC_BCAST(0x08a4), 0x00000000);
+        for (i = 0; i < 4; i++)
+                nv_wr32(priv, GPC_BCAST(0x0888) + (i * 4), 0x00000000);
+        nv_wr32(priv, GPC_BCAST(0x08b4), priv->unk4188b4->addr >> 8);
+        nv_wr32(priv, GPC_BCAST(0x08b8), priv->unk4188b8->addr >> 8);
+}
+
+static void
+nve0_graph_init_regs(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x400080, 0x003083c2);
+        nv_wr32(priv, 0x400088, 0x0001ffe7);
+        nv_wr32(priv, 0x40008c, 0x00000000);
+        nv_wr32(priv, 0x400090, 0x00000030);
+        nv_wr32(priv, 0x40013c, 0x003901f7);
+        nv_wr32(priv, 0x400140, 0x00000100);
+        nv_wr32(priv, 0x400144, 0x00000000);
+        nv_wr32(priv, 0x400148, 0x00000110);
+        nv_wr32(priv, 0x400138, 0x00000000);
+        nv_wr32(priv, 0x400130, 0x00000000);
+        nv_wr32(priv, 0x400134, 0x00000000);
+        nv_wr32(priv, 0x400124, 0x00000002);
+}
+
+static void
+nve0_graph_init_units(struct nvc0_graph_priv *priv)
+{
+        nv_wr32(priv, 0x409ffc, 0x00000000);
+        nv_wr32(priv, 0x409c14, 0x00003e3e);
+        nv_wr32(priv, 0x409c24, 0x000f0000);
+
+        nv_wr32(priv, 0x404000, 0xc0000000);
+        nv_wr32(priv, 0x404600, 0xc0000000);
+        nv_wr32(priv, 0x408030, 0xc0000000);
+        nv_wr32(priv, 0x404490, 0xc0000000);
+        nv_wr32(priv, 0x406018, 0xc0000000);
+        nv_wr32(priv, 0x407020, 0xc0000000);
+        nv_wr32(priv, 0x405840, 0xc0000000);
+        nv_wr32(priv, 0x405844, 0x00ffffff);
+
+        nv_mask(priv, 0x419cc0, 0x00000008, 0x00000008);
+        nv_mask(priv, 0x419eb4, 0x00001000, 0x00001000);
+
+}
+
+static void
+nve0_graph_init_gpc_0(struct nvc0_graph_priv *priv)
+{
+        const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, priv->tpc_total);
+        u32 data[TPC_MAX / 8];
+        u8  tpcnr[GPC_MAX];
+        int i, gpc, tpc;
+
+        nv_wr32(priv, GPC_UNIT(0, 0x3018), 0x00000001);
+
+        memset(data, 0x00, sizeof(data));
+        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
+        for (i = 0, gpc = -1; i < priv->tpc_total; i++) {
+                do {
+                        gpc = (gpc + 1) % priv->gpc_nr;
+                } while (!tpcnr[gpc]);
+                tpc = priv->tpc_nr[gpc] - tpcnr[gpc]--;
+
+                data[i / 8] |= tpc << ((i % 8) * 4);
+        }
+
+        nv_wr32(priv, GPC_BCAST(0x0980), data[0]);
+        nv_wr32(priv, GPC_BCAST(0x0984), data[1]);
+        nv_wr32(priv, GPC_BCAST(0x0988), data[2]);
+        nv_wr32(priv, GPC_BCAST(0x098c), data[3]);
+
+        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0914), priv->magic_not_rop_nr << 8 |
+                                                  priv->tpc_nr[gpc]);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0910), 0x00040000 | priv->tpc_total);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0918), magicgpc918);
+        }
+
+        nv_wr32(priv, GPC_BCAST(0x1bd4), magicgpc918);
+        nv_wr32(priv, GPC_BCAST(0x08ac), nv_rd32(priv, 0x100800));
+}
+
+static void
+nve0_graph_init_gpc_1(struct nvc0_graph_priv *priv)
+{
+        int gpc, tpc;
+
+        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
+                nv_wr32(priv, GPC_UNIT(gpc, 0x3038), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0420), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0900), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x1028), 0xc0000000);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x0824), 0xc0000000);
+                for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x508), 0xffffffff);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x50c), 0xffffffff);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x224), 0xc0000000);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x48c), 0xc0000000);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x084), 0xc0000000);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x644), 0x001ffffe);
+                        nv_wr32(priv, TPC_UNIT(gpc, tpc, 0x64c), 0x0000000f);
+                }
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c90), 0xffffffff);
+                nv_wr32(priv, GPC_UNIT(gpc, 0x2c94), 0xffffffff);
+        }
+}
+
+static void
+nve0_graph_init_rop(struct nvc0_graph_priv *priv)
+{
+        int rop;
+
+        for (rop = 0; rop < priv->rop_nr; rop++) {
+                nv_wr32(priv, ROP_UNIT(rop, 0x144), 0xc0000000);
+                nv_wr32(priv, ROP_UNIT(rop, 0x070), 0xc0000000);
+                nv_wr32(priv, ROP_UNIT(rop, 0x204), 0xffffffff);
+                nv_wr32(priv, ROP_UNIT(rop, 0x208), 0xffffffff);
+        }
+}
+
+static int
+nve0_graph_init_ctxctl(struct nvc0_graph_priv *priv)
+{
+        u32 r000260;
+        int i;
+
+        if (priv->firmware) {
+                /* load fuc microcode */
+                r000260 = nv_mask(priv, 0x000260, 0x00000001, 0x00000000);
+                nvc0_graph_init_fw(priv, 0x409000, &priv->fuc409c, &priv->fuc409d);
+                nvc0_graph_init_fw(priv, 0x41a000, &priv->fuc41ac, &priv->fuc41ad);
+                nv_wr32(priv, 0x000260, r000260);
+
+                /* start both of them running */
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x41a10c, 0x00000000);
+                nv_wr32(priv, 0x40910c, 0x00000000);
+                nv_wr32(priv, 0x41a100, 0x00000002);
+                nv_wr32(priv, 0x409100, 0x00000002);
+                if (!nv_wait(priv, 0x409800, 0x00000001, 0x00000001))
+                        nv_error(priv, "0x409800 wait failed\n");
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x7fffffff);
+                nv_wr32(priv, 0x409504, 0x00000021);
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x00000000);
+                nv_wr32(priv, 0x409504, 0x00000010);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x10 timeout\n");
+                        return -EBUSY;
+                }
+                priv->size = nv_rd32(priv, 0x409800);
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x00000000);
+                nv_wr32(priv, 0x409504, 0x00000016);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x16 timeout\n");
+                        return -EBUSY;
+                }
+
+                nv_wr32(priv, 0x409840, 0xffffffff);
+                nv_wr32(priv, 0x409500, 0x00000000);
+                nv_wr32(priv, 0x409504, 0x00000025);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x25 timeout\n");
+                        return -EBUSY;
+                }
+
+                nv_wr32(priv, 0x409800, 0x00000000);
+                nv_wr32(priv, 0x409500, 0x00000001);
+                nv_wr32(priv, 0x409504, 0x00000030);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x30 timeout\n");
+                        return -EBUSY;
+                }
+
+                nv_wr32(priv, 0x409810, 0xb00095c8);
+                nv_wr32(priv, 0x409800, 0x00000000);
+                nv_wr32(priv, 0x409500, 0x00000001);
+                nv_wr32(priv, 0x409504, 0x00000031);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x31 timeout\n");
+                        return -EBUSY;
+                }
+
+                nv_wr32(priv, 0x409810, 0x00080420);
+                nv_wr32(priv, 0x409800, 0x00000000);
+                nv_wr32(priv, 0x409500, 0x00000001);
+                nv_wr32(priv, 0x409504, 0x00000032);
+                if (!nv_wait_ne(priv, 0x409800, 0xffffffff, 0x00000000)) {
+                        nv_error(priv, "fuc09 req 0x32 timeout\n");
+                        return -EBUSY;
+                }
+
+                nv_wr32(priv, 0x409614, 0x00000070);
+                nv_wr32(priv, 0x409614, 0x00000770);
+                nv_wr32(priv, 0x40802c, 0x00000001);
+
+                if (priv->data == NULL) {
+                        int ret = nve0_grctx_generate(priv);
+                        if (ret) {
+                                nv_error(priv, "failed to construct context\n");
+                                return ret;
+                        }
+                }
+
+                return 0;
+        }
+
+        /* load HUB microcode */
+        r000260 = nv_mask(priv, 0x000260, 0x00000001, 0x00000000);
+        nv_wr32(priv, 0x4091c0, 0x01000000);
+        for (i = 0; i < sizeof(nve0_grhub_data) / 4; i++)
+                nv_wr32(priv, 0x4091c4, nve0_grhub_data[i]);
+
+        nv_wr32(priv, 0x409180, 0x01000000);
+        for (i = 0; i < sizeof(nve0_grhub_code) / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, 0x409188, i >> 6);
+                nv_wr32(priv, 0x409184, nve0_grhub_code[i]);
+        }
+
+        /* load GPC microcode */
+        nv_wr32(priv, 0x41a1c0, 0x01000000);
+        for (i = 0; i < sizeof(nve0_grgpc_data) / 4; i++)
+                nv_wr32(priv, 0x41a1c4, nve0_grgpc_data[i]);
+
+        nv_wr32(priv, 0x41a180, 0x01000000);
+        for (i = 0; i < sizeof(nve0_grgpc_code) / 4; i++) {
+                if ((i & 0x3f) == 0)
+                        nv_wr32(priv, 0x41a188, i >> 6);
+                nv_wr32(priv, 0x41a184, nve0_grgpc_code[i]);
+        }
+        nv_wr32(priv, 0x000260, r000260);
+
+        /* start HUB ucode running, it'll init the GPCs */
+        nv_wr32(priv, 0x409800, nv_device(priv)->chipset);
+        nv_wr32(priv, 0x40910c, 0x00000000);
+        nv_wr32(priv, 0x409100, 0x00000002);
+        if (!nv_wait(priv, 0x409800, 0x80000000, 0x80000000)) {
+                nv_error(priv, "HUB_INIT timed out\n");
+                nvc0_graph_ctxctl_debug(priv);
+                return -EBUSY;
+        }
+
+        priv->size = nv_rd32(priv, 0x409804);
+        if (priv->data == NULL) {
+                int ret = nve0_grctx_generate(priv);
+                if (ret) {
+                        nv_error(priv, "failed to construct context\n");
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int
+nve0_graph_init(struct nouveau_object *object)
+{
+        struct nvc0_graph_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_graph_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nve0_graph_init_obj418880(priv);
+        nve0_graph_init_regs(priv);
+        nve0_graph_init_gpc_0(priv);
+
+        nv_wr32(priv, 0x400500, 0x00010001);
+        nv_wr32(priv, 0x400100, 0xffffffff);
+        nv_wr32(priv, 0x40013c, 0xffffffff);
+
+        nve0_graph_init_units(priv);
+        nve0_graph_init_gpc_1(priv);
+        nve0_graph_init_rop(priv);
+
+        nv_wr32(priv, 0x400108, 0xffffffff);
+        nv_wr32(priv, 0x400138, 0xffffffff);
+        nv_wr32(priv, 0x400118, 0xffffffff);
+        nv_wr32(priv, 0x400130, 0xffffffff);
+        nv_wr32(priv, 0x40011c, 0xffffffff);
+        nv_wr32(priv, 0x400134, 0xffffffff);
+        nv_wr32(priv, 0x400054, 0x34ce3464);
+
+        ret = nve0_graph_init_ctxctl(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+struct nouveau_oclass
+nve0_graph_oclass = {
+        .handle = NV_ENGINE(GR, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nve0_graph_ctor,
+                .dtor = nvc0_graph_dtor,
+                .init = nve0_graph_init,
+                .fini = _nouveau_graph_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/regs.h b/drivers/gpu/drm/nouveau/core/engine/graph/regs.h
new file mode 100644
index 000000000000..9c715a25cecb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/regs.h
@@ -0,0 +1,269 @@
+#ifndef __NOUVEAU_GRAPH_REGS_H__
+#define __NOUVEAU_GRAPH_REGS_H__
+
+#define NV04_PGRAPH_DEBUG_0                                0x00400080
+#define NV04_PGRAPH_DEBUG_1                                0x00400084
+#define NV04_PGRAPH_DEBUG_2                                0x00400088
+#define NV04_PGRAPH_DEBUG_3                                0x0040008c
+#define NV10_PGRAPH_DEBUG_4                                0x00400090
+#define NV03_PGRAPH_INTR                                   0x00400100
+#define NV03_PGRAPH_NSTATUS                                0x00400104
+#    define NV04_PGRAPH_NSTATUS_STATE_IN_USE                  (1<<11)
+#    define NV04_PGRAPH_NSTATUS_INVALID_STATE                 (1<<12)
+#    define NV04_PGRAPH_NSTATUS_BAD_ARGUMENT                  (1<<13)
+#    define NV04_PGRAPH_NSTATUS_PROTECTION_FAULT              (1<<14)
+#    define NV10_PGRAPH_NSTATUS_STATE_IN_USE                  (1<<23)
+#    define NV10_PGRAPH_NSTATUS_INVALID_STATE                 (1<<24)
+#    define NV10_PGRAPH_NSTATUS_BAD_ARGUMENT                  (1<<25)
+#    define NV10_PGRAPH_NSTATUS_PROTECTION_FAULT              (1<<26)
+#define NV03_PGRAPH_NSOURCE                                0x00400108
+#    define NV03_PGRAPH_NSOURCE_NOTIFICATION                   (1<<0)
+#    define NV03_PGRAPH_NSOURCE_DATA_ERROR                     (1<<1)
+#    define NV03_PGRAPH_NSOURCE_PROTECTION_ERROR               (1<<2)
+#    define NV03_PGRAPH_NSOURCE_RANGE_EXCEPTION                (1<<3)
+#    define NV03_PGRAPH_NSOURCE_LIMIT_COLOR                    (1<<4)
+#    define NV03_PGRAPH_NSOURCE_LIMIT_ZETA                     (1<<5)
+#    define NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD                   (1<<6)
+#    define NV03_PGRAPH_NSOURCE_DMA_R_PROTECTION               (1<<7)
+#    define NV03_PGRAPH_NSOURCE_DMA_W_PROTECTION               (1<<8)
+#    define NV03_PGRAPH_NSOURCE_FORMAT_EXCEPTION               (1<<9)
+#    define NV03_PGRAPH_NSOURCE_PATCH_EXCEPTION               (1<<10)
+#    define NV03_PGRAPH_NSOURCE_STATE_INVALID                 (1<<11)
+#    define NV03_PGRAPH_NSOURCE_DOUBLE_NOTIFY                 (1<<12)
+#    define NV03_PGRAPH_NSOURCE_NOTIFY_IN_USE                 (1<<13)
+#    define NV03_PGRAPH_NSOURCE_METHOD_CNT                    (1<<14)
+#    define NV03_PGRAPH_NSOURCE_BFR_NOTIFICATION              (1<<15)
+#    define NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION            (1<<16)
+#    define NV03_PGRAPH_NSOURCE_DMA_WIDTH_A                   (1<<17)
+#    define NV03_PGRAPH_NSOURCE_DMA_WIDTH_B                   (1<<18)
+#define NV03_PGRAPH_INTR_EN                                0x00400140
+#define NV40_PGRAPH_INTR_EN                                0x0040013C
+#    define NV_PGRAPH_INTR_NOTIFY                              (1<<0)
+#    define NV_PGRAPH_INTR_MISSING_HW                          (1<<4)
+#    define NV_PGRAPH_INTR_CONTEXT_SWITCH                     (1<<12)
+#    define NV_PGRAPH_INTR_BUFFER_NOTIFY                      (1<<16)
+#    define NV_PGRAPH_INTR_ERROR                              (1<<20)
+#define NV10_PGRAPH_CTX_CONTROL                            0x00400144
+#define NV10_PGRAPH_CTX_USER                               0x00400148
+#define NV10_PGRAPH_CTX_SWITCH(i)                         (0x0040014C + 0x4*(i))
+#define NV04_PGRAPH_CTX_SWITCH1                            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 NV03_PGRAPH_CTX_CONTROL                            0x00400190
+#define NV03_PGRAPH_CTX_USER                               0x00400194
+#define NV04_PGRAPH_CTX_CACHE2                             0x004001A0
+#define NV04_PGRAPH_CTX_CACHE3                             0x004001C0
+#define NV04_PGRAPH_CTX_CACHE4                             0x004001E0
+#define NV40_PGRAPH_CTXCTL_0304                            0x00400304
+#define NV40_PGRAPH_CTXCTL_0304_XFER_CTX                   0x00000001
+#define NV40_PGRAPH_CTXCTL_UCODE_STAT                      0x00400308
+#define NV40_PGRAPH_CTXCTL_UCODE_STAT_IP_MASK              0xff000000
+#define NV40_PGRAPH_CTXCTL_UCODE_STAT_IP_SHIFT                     24
+#define NV40_PGRAPH_CTXCTL_UCODE_STAT_OP_MASK              0x00ffffff
+#define NV40_PGRAPH_CTXCTL_0310                            0x00400310
+#define NV40_PGRAPH_CTXCTL_0310_XFER_SAVE                  0x00000020
+#define NV40_PGRAPH_CTXCTL_0310_XFER_LOAD                  0x00000040
+#define NV40_PGRAPH_CTXCTL_030C                            0x0040030c
+#define NV40_PGRAPH_CTXCTL_UCODE_INDEX                     0x00400324
+#define NV40_PGRAPH_CTXCTL_UCODE_DATA                      0x00400328
+#define NV40_PGRAPH_CTXCTL_CUR                             0x0040032c
+#define NV40_PGRAPH_CTXCTL_CUR_LOADED                      0x01000000
+#define NV40_PGRAPH_CTXCTL_CUR_INSTANCE                    0x000FFFFF
+#define NV40_PGRAPH_CTXCTL_NEXT                            0x00400330
+#define NV40_PGRAPH_CTXCTL_NEXT_INSTANCE                   0x000fffff
+#define NV50_PGRAPH_CTXCTL_CUR                             0x0040032c
+#define NV50_PGRAPH_CTXCTL_CUR_LOADED                      0x80000000
+#define NV50_PGRAPH_CTXCTL_CUR_INSTANCE                    0x00ffffff
+#define NV50_PGRAPH_CTXCTL_NEXT                            0x00400330
+#define NV50_PGRAPH_CTXCTL_NEXT_INSTANCE                   0x00ffffff
+#define NV03_PGRAPH_ABS_X_RAM                              0x00400400
+#define NV03_PGRAPH_ABS_Y_RAM                              0x00400480
+#define NV03_PGRAPH_X_MISC                                 0x00400500
+#define NV03_PGRAPH_Y_MISC                                 0x00400504
+#define NV04_PGRAPH_VALID1                                 0x00400508
+#define NV04_PGRAPH_SOURCE_COLOR                           0x0040050C
+#define NV04_PGRAPH_MISC24_0                               0x00400510
+#define NV03_PGRAPH_XY_LOGIC_MISC0                         0x00400514
+#define NV03_PGRAPH_XY_LOGIC_MISC1                         0x00400518
+#define NV03_PGRAPH_XY_LOGIC_MISC2                         0x0040051C
+#define NV03_PGRAPH_XY_LOGIC_MISC3                         0x00400520
+#define NV03_PGRAPH_CLIPX_0                                0x00400524
+#define NV03_PGRAPH_CLIPX_1                                0x00400528
+#define NV03_PGRAPH_CLIPY_0                                0x0040052C
+#define NV03_PGRAPH_CLIPY_1                                0x00400530
+#define NV03_PGRAPH_ABS_ICLIP_XMAX                         0x00400534
+#define NV03_PGRAPH_ABS_ICLIP_YMAX                         0x00400538
+#define NV03_PGRAPH_ABS_UCLIP_XMIN                         0x0040053C
+#define NV03_PGRAPH_ABS_UCLIP_YMIN                         0x00400540
+#define NV03_PGRAPH_ABS_UCLIP_XMAX                         0x00400544
+#define NV03_PGRAPH_ABS_UCLIP_YMAX                         0x00400548
+#define NV03_PGRAPH_ABS_UCLIPA_XMIN                        0x00400560
+#define NV03_PGRAPH_ABS_UCLIPA_YMIN                        0x00400564
+#define NV03_PGRAPH_ABS_UCLIPA_XMAX                        0x00400568
+#define NV03_PGRAPH_ABS_UCLIPA_YMAX                        0x0040056C
+#define NV04_PGRAPH_MISC24_1                               0x00400570
+#define NV04_PGRAPH_MISC24_2                               0x00400574
+#define NV04_PGRAPH_VALID2                                 0x00400578
+#define NV04_PGRAPH_PASSTHRU_0                             0x0040057C
+#define NV04_PGRAPH_PASSTHRU_1                             0x00400580
+#define NV04_PGRAPH_PASSTHRU_2                             0x00400584
+#define NV10_PGRAPH_DIMX_TEXTURE                           0x00400588
+#define NV10_PGRAPH_WDIMX_TEXTURE                          0x0040058C
+#define NV04_PGRAPH_COMBINE_0_ALPHA                        0x00400590
+#define NV04_PGRAPH_COMBINE_0_COLOR                        0x00400594
+#define NV04_PGRAPH_COMBINE_1_ALPHA                        0x00400598
+#define NV04_PGRAPH_COMBINE_1_COLOR                        0x0040059C
+#define NV04_PGRAPH_FORMAT_0                               0x004005A8
+#define NV04_PGRAPH_FORMAT_1                               0x004005AC
+#define NV04_PGRAPH_FILTER_0                               0x004005B0
+#define NV04_PGRAPH_FILTER_1                               0x004005B4
+#define NV03_PGRAPH_MONO_COLOR0                            0x00400600
+#define NV04_PGRAPH_ROP3                                   0x00400604
+#define NV04_PGRAPH_BETA_AND                               0x00400608
+#define NV04_PGRAPH_BETA_PREMULT                           0x0040060C
+#define NV04_PGRAPH_LIMIT_VIOL_PIX                         0x00400610
+#define NV04_PGRAPH_FORMATS                                0x00400618
+#define NV10_PGRAPH_DEBUG_2                                0x00400620
+#define NV04_PGRAPH_BOFFSET0                               0x00400640
+#define NV04_PGRAPH_BOFFSET1                               0x00400644
+#define NV04_PGRAPH_BOFFSET2                               0x00400648
+#define NV04_PGRAPH_BOFFSET3                               0x0040064C
+#define NV04_PGRAPH_BOFFSET4                               0x00400650
+#define NV04_PGRAPH_BOFFSET5                               0x00400654
+#define NV04_PGRAPH_BBASE0                                 0x00400658
+#define NV04_PGRAPH_BBASE1                                 0x0040065C
+#define NV04_PGRAPH_BBASE2                                 0x00400660
+#define NV04_PGRAPH_BBASE3                                 0x00400664
+#define NV04_PGRAPH_BBASE4                                 0x00400668
+#define NV04_PGRAPH_BBASE5                                 0x0040066C
+#define NV04_PGRAPH_BPITCH0                                0x00400670
+#define NV04_PGRAPH_BPITCH1                                0x00400674
+#define NV04_PGRAPH_BPITCH2                                0x00400678
+#define NV04_PGRAPH_BPITCH3                                0x0040067C
+#define NV04_PGRAPH_BPITCH4                                0x00400680
+#define NV04_PGRAPH_BLIMIT0                                0x00400684
+#define NV04_PGRAPH_BLIMIT1                                0x00400688
+#define NV04_PGRAPH_BLIMIT2                                0x0040068C
+#define NV04_PGRAPH_BLIMIT3                                0x00400690
+#define NV04_PGRAPH_BLIMIT4                                0x00400694
+#define NV04_PGRAPH_BLIMIT5                                0x00400698
+#define NV04_PGRAPH_BSWIZZLE2                              0x0040069C
+#define NV04_PGRAPH_BSWIZZLE5                              0x004006A0
+#define NV03_PGRAPH_STATUS                                 0x004006B0
+#define NV04_PGRAPH_STATUS                                 0x00400700
+#    define NV40_PGRAPH_STATUS_SYNC_STALL                  0x00004000
+#define NV04_PGRAPH_TRAPPED_ADDR                           0x00400704
+#define NV04_PGRAPH_TRAPPED_DATA                           0x00400708
+#define NV04_PGRAPH_SURFACE                                0x0040070C
+#define NV10_PGRAPH_TRAPPED_DATA_HIGH                      0x0040070C
+#define NV04_PGRAPH_STATE                                  0x00400710
+#define NV10_PGRAPH_SURFACE                                0x00400710
+#define NV04_PGRAPH_NOTIFY                                 0x00400714
+#define NV10_PGRAPH_STATE                                  0x00400714
+#define NV10_PGRAPH_NOTIFY                                 0x00400718
+
+#define NV04_PGRAPH_FIFO                                   0x00400720
+
+#define NV04_PGRAPH_BPIXEL                                 0x00400724
+#define NV10_PGRAPH_RDI_INDEX                              0x00400750
+#define NV04_PGRAPH_FFINTFC_ST2                            0x00400754
+#define NV10_PGRAPH_RDI_DATA                               0x00400754
+#define NV04_PGRAPH_DMA_PITCH                              0x00400760
+#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
+#define NV20_PGRAPH_CHANNEL_CTX_TABLE                      0x00400780
+#define NV20_PGRAPH_CHANNEL_CTX_POINTER                    0x00400784
+#define NV20_PGRAPH_CHANNEL_CTX_XFER                       0x00400788
+#define NV20_PGRAPH_CHANNEL_CTX_XFER_LOAD                  0x00000001
+#define NV20_PGRAPH_CHANNEL_CTX_XFER_SAVE                  0x00000002
+#define NV04_PGRAPH_PATT_COLOR0                            0x00400800
+#define NV04_PGRAPH_PATT_COLOR1                            0x00400804
+#define NV04_PGRAPH_PATTERN                                0x00400808
+#define NV04_PGRAPH_PATTERN_SHAPE                          0x00400810
+#define NV04_PGRAPH_CHROMA                                 0x00400814
+#define NV04_PGRAPH_CONTROL0                               0x00400818
+#define NV04_PGRAPH_CONTROL1                               0x0040081C
+#define NV04_PGRAPH_CONTROL2                               0x00400820
+#define NV04_PGRAPH_BLEND                                  0x00400824
+#define NV04_PGRAPH_STORED_FMT                             0x00400830
+#define NV04_PGRAPH_PATT_COLORRAM                          0x00400900
+#define NV20_PGRAPH_TILE(i)                                (0x00400900 + (i*16))
+#define NV20_PGRAPH_TLIMIT(i)                              (0x00400904 + (i*16))
+#define NV20_PGRAPH_TSIZE(i)                               (0x00400908 + (i*16))
+#define NV20_PGRAPH_TSTATUS(i)                             (0x0040090C + (i*16))
+#define NV20_PGRAPH_ZCOMP(i)                               (0x00400980 + 4*(i))
+#define NV10_PGRAPH_TILE(i)                                (0x00400B00 + (i*16))
+#define NV10_PGRAPH_TLIMIT(i)                              (0x00400B04 + (i*16))
+#define NV10_PGRAPH_TSIZE(i)                               (0x00400B08 + (i*16))
+#define NV10_PGRAPH_TSTATUS(i)                             (0x00400B0C + (i*16))
+#define NV04_PGRAPH_U_RAM                                  0x00400D00
+#define NV47_PGRAPH_TILE(i)                                (0x00400D00 + (i*16))
+#define NV47_PGRAPH_TLIMIT(i)                              (0x00400D04 + (i*16))
+#define NV47_PGRAPH_TSIZE(i)                               (0x00400D08 + (i*16))
+#define NV47_PGRAPH_TSTATUS(i)                             (0x00400D0C + (i*16))
+#define NV04_PGRAPH_V_RAM                                  0x00400D40
+#define NV04_PGRAPH_W_RAM                                  0x00400D80
+#define NV10_PGRAPH_COMBINER0_IN_ALPHA                     0x00400E40
+#define NV10_PGRAPH_COMBINER1_IN_ALPHA                     0x00400E44
+#define NV10_PGRAPH_COMBINER0_IN_RGB                       0x00400E48
+#define NV10_PGRAPH_COMBINER1_IN_RGB                       0x00400E4C
+#define NV10_PGRAPH_COMBINER_COLOR0                        0x00400E50
+#define NV10_PGRAPH_COMBINER_COLOR1                        0x00400E54
+#define NV10_PGRAPH_COMBINER0_OUT_ALPHA                    0x00400E58
+#define NV10_PGRAPH_COMBINER1_OUT_ALPHA                    0x00400E5C
+#define NV10_PGRAPH_COMBINER0_OUT_RGB                      0x00400E60
+#define NV10_PGRAPH_COMBINER1_OUT_RGB                      0x00400E64
+#define NV10_PGRAPH_COMBINER_FINAL0                        0x00400E68
+#define NV10_PGRAPH_COMBINER_FINAL1                        0x00400E6C
+#define NV10_PGRAPH_WINDOWCLIP_HORIZONTAL                  0x00400F00
+#define NV10_PGRAPH_WINDOWCLIP_VERTICAL                    0x00400F20
+#define NV10_PGRAPH_XFMODE0                                0x00400F40
+#define NV10_PGRAPH_XFMODE1                                0x00400F44
+#define NV10_PGRAPH_GLOBALSTATE0                           0x00400F48
+#define NV10_PGRAPH_GLOBALSTATE1                           0x00400F4C
+#define NV10_PGRAPH_PIPE_ADDRESS                           0x00400F50
+#define NV10_PGRAPH_PIPE_DATA                              0x00400F54
+#define NV04_PGRAPH_DMA_START_0                            0x00401000
+#define NV04_PGRAPH_DMA_START_1                            0x00401004
+#define NV04_PGRAPH_DMA_LENGTH                             0x00401008
+#define NV04_PGRAPH_DMA_MISC                               0x0040100C
+#define NV04_PGRAPH_DMA_DATA_0                             0x00401020
+#define NV04_PGRAPH_DMA_DATA_1                             0x00401024
+#define NV04_PGRAPH_DMA_RM                                 0x00401030
+#define NV04_PGRAPH_DMA_A_XLATE_INST                       0x00401040
+#define NV04_PGRAPH_DMA_A_CONTROL                          0x00401044
+#define NV04_PGRAPH_DMA_A_LIMIT                            0x00401048
+#define NV04_PGRAPH_DMA_A_TLB_PTE                          0x0040104C
+#define NV04_PGRAPH_DMA_A_TLB_TAG                          0x00401050
+#define NV04_PGRAPH_DMA_A_ADJ_OFFSET                       0x00401054
+#define NV04_PGRAPH_DMA_A_OFFSET                           0x00401058
+#define NV04_PGRAPH_DMA_A_SIZE                             0x0040105C
+#define NV04_PGRAPH_DMA_A_Y_SIZE                           0x00401060
+#define NV04_PGRAPH_DMA_B_XLATE_INST                       0x00401080
+#define NV04_PGRAPH_DMA_B_CONTROL                          0x00401084
+#define NV04_PGRAPH_DMA_B_LIMIT                            0x00401088
+#define NV04_PGRAPH_DMA_B_TLB_PTE                          0x0040108C
+#define NV04_PGRAPH_DMA_B_TLB_TAG                          0x00401090
+#define NV04_PGRAPH_DMA_B_ADJ_OFFSET                       0x00401094
+#define NV04_PGRAPH_DMA_B_OFFSET                           0x00401098
+#define NV04_PGRAPH_DMA_B_SIZE                             0x0040109C
+#define NV04_PGRAPH_DMA_B_Y_SIZE                           0x004010A0
+#define NV40_PGRAPH_TILE1(i)                               (0x00406900 + (i*16))
+#define NV40_PGRAPH_TLIMIT1(i)                             (0x00406904 + (i*16))
+#define NV40_PGRAPH_TSIZE1(i)                              (0x00406908 + (i*16))
+#define NV40_PGRAPH_TSTATUS1(i)                            (0x0040690C + (i*16))
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/engine/mpeg/nv31.c b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv31.c
new file mode 100644
index 000000000000..1f394a2629e7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv31.c
@@ -0,0 +1,308 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/handle.h>
+
+#include <subdev/fb.h>
+#include <subdev/timer.h>
+#include <subdev/instmem.h>
+
+#include <engine/fifo.h>
+#include <engine/mpeg.h>
+#include <engine/graph/nv40.h>
+
+struct nv31_mpeg_priv {
+        struct nouveau_mpeg base;
+        atomic_t refcount;
+};
+
+struct nv31_mpeg_chan {
+        struct nouveau_object base;
+};
+
+/*******************************************************************************
+ * MPEG object classes
+ ******************************************************************************/
+
+static int
+nv31_mpeg_object_ctor(struct nouveau_object *parent,
+                      struct nouveau_object *engine,
+                      struct nouveau_oclass *oclass, void *data, u32 size,
+                      struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj *obj;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, parent,
+                                    20, 16, 0, &obj);
+        *pobject = nv_object(obj);
+        if (ret)
+                return ret;
+
+        nv_wo32(obj, 0x00, nv_mclass(obj));
+        nv_wo32(obj, 0x04, 0x00000000);
+        nv_wo32(obj, 0x08, 0x00000000);
+        nv_wo32(obj, 0x0c, 0x00000000);
+        return 0;
+}
+
+static int
+nv31_mpeg_mthd_dma(struct nouveau_object *object, u32 mthd, void *arg, u32 len)
+{
+        struct nouveau_instmem *imem = nouveau_instmem(object);
+        struct nv31_mpeg_priv *priv = (void *)object->engine;
+        u32 inst = *(u32 *)arg << 4;
+        u32 dma0 = nv_ro32(imem, inst + 0);
+        u32 dma1 = nv_ro32(imem, inst + 4);
+        u32 dma2 = nv_ro32(imem, inst + 8);
+        u32 base = (dma2 & 0xfffff000) | (dma0 >> 20);
+        u32 size = dma1 + 1;
+
+        /* only allow linear DMA objects */
+        if (!(dma0 & 0x00002000))
+                return -EINVAL;
+
+        if (mthd == 0x0190) {
+                /* DMA_CMD */
+                nv_mask(priv, 0x00b300, 0x00030000, (dma0 & 0x00030000));
+                nv_wr32(priv, 0x00b334, base);
+                nv_wr32(priv, 0x00b324, size);
+        } else
+        if (mthd == 0x01a0) {
+                /* DMA_DATA */
+                nv_mask(priv, 0x00b300, 0x000c0000, (dma0 & 0x00030000) << 2);
+                nv_wr32(priv, 0x00b360, base);
+                nv_wr32(priv, 0x00b364, size);
+        } else {
+                /* DMA_IMAGE, VRAM only */
+                if (dma0 & 0x000c0000)
+                        return -EINVAL;
+
+                nv_wr32(priv, 0x00b370, base);
+                nv_wr32(priv, 0x00b374, size);
+        }
+
+        return 0;
+}
+
+static struct nouveau_ofuncs
+nv31_mpeg_ofuncs = {
+        .ctor = nv31_mpeg_object_ctor,
+        .dtor = _nouveau_gpuobj_dtor,
+        .init = _nouveau_gpuobj_init,
+        .fini = _nouveau_gpuobj_fini,
+        .rd32 = _nouveau_gpuobj_rd32,
+        .wr32 = _nouveau_gpuobj_wr32,
+};
+
+static struct nouveau_omthds
+nv31_mpeg_omthds[] = {
+        { 0x0190, nv31_mpeg_mthd_dma },
+        { 0x01a0, nv31_mpeg_mthd_dma },
+        { 0x01b0, nv31_mpeg_mthd_dma },
+        {}
+};
+
+struct nouveau_oclass
+nv31_mpeg_sclass[] = {
+        { 0x3174, &nv31_mpeg_ofuncs, nv31_mpeg_omthds },
+        {}
+};
+
+/*******************************************************************************
+ * PMPEG context
+ ******************************************************************************/
+
+static int
+nv31_mpeg_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nv31_mpeg_priv *priv = (void *)engine;
+        struct nv31_mpeg_chan *chan;
+        int ret;
+
+        if (!atomic_add_unless(&priv->refcount, 1, 1))
+                return -EBUSY;
+
+        ret = nouveau_object_create(parent, engine, oclass, 0, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nv31_mpeg_context_dtor(struct nouveau_object *object)
+{
+        struct nv31_mpeg_priv *priv = (void *)object->engine;
+        struct nv31_mpeg_chan *chan = (void *)object;
+        atomic_dec(&priv->refcount);
+        nouveau_object_destroy(&chan->base);
+}
+
+static struct nouveau_oclass
+nv31_mpeg_cclass = {
+        .handle = NV_ENGCTX(MPEG, 0x31),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv31_mpeg_context_ctor,
+                .dtor = nv31_mpeg_context_dtor,
+                .init = nouveau_object_init,
+                .fini = nouveau_object_fini,
+        },
+};
+
+/*******************************************************************************
+ * PMPEG engine/subdev functions
+ ******************************************************************************/
+
+void
+nv31_mpeg_tile_prog(struct nouveau_engine *engine, int i)
+{
+        struct nouveau_fb_tile *tile = &nouveau_fb(engine)->tile.region[i];
+        struct nv31_mpeg_priv *priv = (void *)engine;
+
+        nv_wr32(priv, 0x00b008 + (i * 0x10), tile->pitch);
+        nv_wr32(priv, 0x00b004 + (i * 0x10), tile->limit);
+        nv_wr32(priv, 0x00b000 + (i * 0x10), tile->addr);
+}
+
+void
+nv31_mpeg_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_fifo *pfifo = nouveau_fifo(subdev);
+        struct nouveau_engine *engine = nv_engine(subdev);
+        struct nouveau_object *engctx;
+        struct nouveau_handle *handle;
+        struct nv31_mpeg_priv *priv = (void *)subdev;
+        u32 inst = nv_rd32(priv, 0x00b318) & 0x000fffff;
+        u32 stat = nv_rd32(priv, 0x00b100);
+        u32 type = nv_rd32(priv, 0x00b230);
+        u32 mthd = nv_rd32(priv, 0x00b234);
+        u32 data = nv_rd32(priv, 0x00b238);
+        u32 show = stat;
+        int chid;
+
+        engctx = nouveau_engctx_get(engine, inst);
+        chid   = pfifo->chid(pfifo, engctx);
+
+        if (stat & 0x01000000) {
+                /* happens on initial binding of the object */
+                if (type == 0x00000020 && mthd == 0x0000) {
+                        nv_mask(priv, 0x00b308, 0x00000000, 0x00000000);
+                        show &= ~0x01000000;
+                }
+
+                if (type == 0x00000010) {
+                        handle = nouveau_handle_get_class(engctx, 0x3174);
+                        if (handle && !nv_call(handle->object, mthd, data))
+                                show &= ~0x01000000;
+                        nouveau_handle_put(handle);
+                }
+        }
+
+        nv_wr32(priv, 0x00b100, stat);
+        nv_wr32(priv, 0x00b230, 0x00000001);
+
+        if (show) {
+                nv_error(priv, "ch %d [0x%08x] 0x%08x 0x%08x 0x%08x 0x%08x\n",
+                         chid, inst << 4, stat, type, mthd, data);
+        }
+
+        nouveau_engctx_put(engctx);
+}
+
+static int
+nv31_mpeg_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv31_mpeg_priv *priv;
+        int ret;
+
+        ret = nouveau_mpeg_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000002;
+        nv_subdev(priv)->intr = nv31_mpeg_intr;
+        nv_engine(priv)->cclass = &nv31_mpeg_cclass;
+        nv_engine(priv)->sclass = nv31_mpeg_sclass;
+        nv_engine(priv)->tile_prog = nv31_mpeg_tile_prog;
+        return 0;
+}
+
+int
+nv31_mpeg_init(struct nouveau_object *object)
+{
+        struct nouveau_engine *engine = nv_engine(object->engine);
+        struct nv31_mpeg_priv *priv = (void *)engine;
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        int ret, i;
+
+        ret = nouveau_mpeg_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* VPE init */
+        nv_wr32(priv, 0x00b0e0, 0x00000020); /* nvidia: rd 0x01, wr 0x20 */
+        nv_wr32(priv, 0x00b0e8, 0x00000020); /* nvidia: rd 0x01, wr 0x20 */
+
+        for (i = 0; i < pfb->tile.regions; i++)
+                engine->tile_prog(engine, i);
+
+        /* PMPEG init */
+        nv_wr32(priv, 0x00b32c, 0x00000000);
+        nv_wr32(priv, 0x00b314, 0x00000100);
+        nv_wr32(priv, 0x00b220, nv44_graph_class(priv) ? 0x00000044 : 0x00000031);
+        nv_wr32(priv, 0x00b300, 0x02001ec1);
+        nv_mask(priv, 0x00b32c, 0x00000001, 0x00000001);
+
+        nv_wr32(priv, 0x00b100, 0xffffffff);
+        nv_wr32(priv, 0x00b140, 0xffffffff);
+
+        if (!nv_wait(priv, 0x00b200, 0x00000001, 0x00000000)) {
+                nv_error(priv, "timeout 0x%08x\n", nv_rd32(priv, 0x00b200));
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+struct nouveau_oclass
+nv31_mpeg_oclass = {
+        .handle = NV_ENGINE(MPEG, 0x31),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv31_mpeg_ctor,
+                .dtor = _nouveau_mpeg_dtor,
+                .init = nv31_mpeg_init,
+                .fini = _nouveau_mpeg_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/mpeg/nv40.c b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv40.c
new file mode 100644
index 000000000000..12418574efea
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv40.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <subdev/fb.h>
+#include <subdev/timer.h>
+#include <subdev/instmem.h>
+
+#include <engine/mpeg.h>
+#include <engine/graph/nv40.h>
+
+struct nv40_mpeg_priv {
+        struct nouveau_mpeg base;
+};
+
+struct nv40_mpeg_chan {
+        struct nouveau_mpeg base;
+};
+
+/*******************************************************************************
+ * PMPEG context
+ ******************************************************************************/
+
+static int
+nv40_mpeg_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nv40_mpeg_chan *chan;
+        int ret;
+
+        ret = nouveau_mpeg_context_create(parent, engine, oclass, NULL,
+                                          264 * 4, 16,
+                                          NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv40_mpeg_context_fini(struct nouveau_object *object, bool suspend)
+{
+
+        struct nv40_mpeg_priv *priv = (void *)object->engine;
+        struct nv40_mpeg_chan *chan = (void *)object;
+        u32 inst = 0x80000000 | nv_gpuobj(chan)->addr >> 4;
+
+        nv_mask(priv, 0x00b32c, 0x00000001, 0x00000000);
+        if (nv_rd32(priv, 0x00b318) == inst)
+                nv_mask(priv, 0x00b318, 0x80000000, 0x00000000);
+        nv_mask(priv, 0x00b32c, 0x00000001, 0x00000001);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv40_mpeg_cclass = {
+        .handle = NV_ENGCTX(MPEG, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_mpeg_context_ctor,
+                .dtor = _nouveau_mpeg_context_dtor,
+                .init = _nouveau_mpeg_context_init,
+                .fini = nv40_mpeg_context_fini,
+                .rd32 = _nouveau_mpeg_context_rd32,
+                .wr32 = _nouveau_mpeg_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PMPEG engine/subdev functions
+ ******************************************************************************/
+
+static void
+nv40_mpeg_intr(struct nouveau_subdev *subdev)
+{
+        struct nv40_mpeg_priv *priv = (void *)subdev;
+        u32 stat;
+
+        if ((stat = nv_rd32(priv, 0x00b100)))
+                nv31_mpeg_intr(subdev);
+
+        if ((stat = nv_rd32(priv, 0x00b800))) {
+                nv_error(priv, "PMSRCH 0x%08x\n", stat);
+                nv_wr32(priv, 0x00b800, stat);
+        }
+}
+
+static int
+nv40_mpeg_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv40_mpeg_priv *priv;
+        int ret;
+
+        ret = nouveau_mpeg_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000002;
+        nv_subdev(priv)->intr = nv40_mpeg_intr;
+        nv_engine(priv)->cclass = &nv40_mpeg_cclass;
+        nv_engine(priv)->sclass = nv31_mpeg_sclass;
+        nv_engine(priv)->tile_prog = nv31_mpeg_tile_prog;
+        return 0;
+}
+
+struct nouveau_oclass
+nv40_mpeg_oclass = {
+        .handle = NV_ENGINE(MPEG, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_mpeg_ctor,
+                .dtor = _nouveau_mpeg_dtor,
+                .init = nv31_mpeg_init,
+                .fini = _nouveau_mpeg_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/mpeg/nv50.c b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv50.c
new file mode 100644
index 000000000000..8678a9996d57
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv50.c
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <subdev/vm.h>
+#include <subdev/bar.h>
+#include <subdev/timer.h>
+
+#include <engine/mpeg.h>
+
+struct nv50_mpeg_priv {
+        struct nouveau_mpeg base;
+};
+
+struct nv50_mpeg_chan {
+        struct nouveau_mpeg_chan base;
+};
+
+/*******************************************************************************
+ * MPEG object classes
+ ******************************************************************************/
+
+static int
+nv50_mpeg_object_ctor(struct nouveau_object *parent,
+                      struct nouveau_object *engine,
+                      struct nouveau_oclass *oclass, void *data, u32 size,
+                      struct nouveau_object **pobject)
+{
+        struct nouveau_gpuobj *obj;
+        int ret;
+
+        ret = nouveau_gpuobj_create(parent, engine, oclass, 0, parent,
+                                    16, 16, 0, &obj);
+        *pobject = nv_object(obj);
+        if (ret)
+                return ret;
+
+        nv_wo32(obj, 0x00, nv_mclass(obj));
+        nv_wo32(obj, 0x04, 0x00000000);
+        nv_wo32(obj, 0x08, 0x00000000);
+        nv_wo32(obj, 0x0c, 0x00000000);
+        return 0;
+}
+
+struct nouveau_ofuncs
+nv50_mpeg_ofuncs = {
+        .ctor = nv50_mpeg_object_ctor,
+        .dtor = _nouveau_gpuobj_dtor,
+        .init = _nouveau_gpuobj_init,
+        .fini = _nouveau_gpuobj_fini,
+        .rd32 = _nouveau_gpuobj_rd32,
+        .wr32 = _nouveau_gpuobj_wr32,
+};
+
+static struct nouveau_oclass
+nv50_mpeg_sclass[] = {
+        { 0x3174, &nv50_mpeg_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PMPEG context
+ ******************************************************************************/
+
+int
+nv50_mpeg_context_ctor(struct nouveau_object *parent,
+                       struct nouveau_object *engine,
+                       struct nouveau_oclass *oclass, void *data, u32 size,
+                       struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = nouveau_bar(parent);
+        struct nv50_mpeg_chan *chan;
+        int ret;
+
+        ret = nouveau_mpeg_context_create(parent, engine, oclass, NULL, 128 * 4,
+                                          0, NVOBJ_FLAG_ZERO_ALLOC, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        nv_wo32(chan, 0x0070, 0x00801ec1);
+        nv_wo32(chan, 0x007c, 0x0000037c);
+        bar->flush(bar);
+        return 0;
+}
+
+static struct nouveau_oclass
+nv50_mpeg_cclass = {
+        .handle = NV_ENGCTX(MPEG, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_mpeg_context_ctor,
+                .dtor = _nouveau_mpeg_context_dtor,
+                .init = _nouveau_mpeg_context_init,
+                .fini = _nouveau_mpeg_context_fini,
+                .rd32 = _nouveau_mpeg_context_rd32,
+                .wr32 = _nouveau_mpeg_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PMPEG engine/subdev functions
+ ******************************************************************************/
+
+int
+nv50_mpeg_tlb_flush(struct nouveau_engine *engine)
+{
+        nv50_vm_flush_engine(&engine->base, 0x08);
+        return 0;
+}
+
+void
+nv50_mpeg_intr(struct nouveau_subdev *subdev)
+{
+        struct nv50_mpeg_priv *priv = (void *)subdev;
+        u32 stat = nv_rd32(priv, 0x00b100);
+        u32 type = nv_rd32(priv, 0x00b230);
+        u32 mthd = nv_rd32(priv, 0x00b234);
+        u32 data = nv_rd32(priv, 0x00b238);
+        u32 show = stat;
+
+        if (stat & 0x01000000) {
+                /* happens on initial binding of the object */
+                if (type == 0x00000020 && mthd == 0x0000) {
+                        nv_wr32(priv, 0x00b308, 0x00000100);
+                        show &= ~0x01000000;
+                }
+        }
+
+        if (show) {
+                nv_info(priv, "0x%08x 0x%08x 0x%08x 0x%08x\n",
+                        stat, type, mthd, data);
+        }
+
+        nv_wr32(priv, 0x00b100, stat);
+        nv_wr32(priv, 0x00b230, 0x00000001);
+        nv50_fb_trap(nouveau_fb(priv), 1);
+}
+
+static void
+nv50_vpe_intr(struct nouveau_subdev *subdev)
+{
+        struct nv50_mpeg_priv *priv = (void *)subdev;
+
+        if (nv_rd32(priv, 0x00b100))
+                nv50_mpeg_intr(subdev);
+
+        if (nv_rd32(priv, 0x00b800)) {
+                u32 stat = nv_rd32(priv, 0x00b800);
+                nv_info(priv, "PMSRCH: 0x%08x\n", stat);
+                nv_wr32(priv, 0xb800, stat);
+        }
+}
+
+static int
+nv50_mpeg_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv50_mpeg_priv *priv;
+        int ret;
+
+        ret = nouveau_mpeg_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00400002;
+        nv_subdev(priv)->intr = nv50_vpe_intr;
+        nv_engine(priv)->cclass = &nv50_mpeg_cclass;
+        nv_engine(priv)->sclass = nv50_mpeg_sclass;
+        nv_engine(priv)->tlb_flush = nv50_mpeg_tlb_flush;
+        return 0;
+}
+
+int
+nv50_mpeg_init(struct nouveau_object *object)
+{
+        struct nv50_mpeg_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_mpeg_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x00b32c, 0x00000000);
+        nv_wr32(priv, 0x00b314, 0x00000100);
+        nv_wr32(priv, 0x00b0e0, 0x0000001a);
+
+        nv_wr32(priv, 0x00b220, 0x00000044);
+        nv_wr32(priv, 0x00b300, 0x00801ec1);
+        nv_wr32(priv, 0x00b390, 0x00000000);
+        nv_wr32(priv, 0x00b394, 0x00000000);
+        nv_wr32(priv, 0x00b398, 0x00000000);
+        nv_mask(priv, 0x00b32c, 0x00000001, 0x00000001);
+
+        nv_wr32(priv, 0x00b100, 0xffffffff);
+        nv_wr32(priv, 0x00b140, 0xffffffff);
+
+        if (!nv_wait(priv, 0x00b200, 0x00000001, 0x00000000)) {
+                nv_error(priv, "timeout 0x%08x\n", nv_rd32(priv, 0x00b200));
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_mpeg_oclass = {
+        .handle = NV_ENGINE(MPEG, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_mpeg_ctor,
+                .dtor = _nouveau_mpeg_dtor,
+                .init = nv50_mpeg_init,
+                .fini = _nouveau_mpeg_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/mpeg/nv84.c b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv84.c
new file mode 100644
index 000000000000..8f805b44d59e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/mpeg/nv84.c
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <subdev/vm.h>
+#include <subdev/bar.h>
+#include <subdev/timer.h>
+
+#include <engine/mpeg.h>
+
+struct nv84_mpeg_priv {
+        struct nouveau_mpeg base;
+};
+
+struct nv84_mpeg_chan {
+        struct nouveau_mpeg_chan base;
+};
+
+/*******************************************************************************
+ * MPEG object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv84_mpeg_sclass[] = {
+        { 0x8274, &nv50_mpeg_ofuncs },
+        {}
+};
+
+/*******************************************************************************
+ * PMPEG context
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv84_mpeg_cclass = {
+        .handle = NV_ENGCTX(MPEG, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_mpeg_context_ctor,
+                .dtor = _nouveau_mpeg_context_dtor,
+                .init = _nouveau_mpeg_context_init,
+                .fini = _nouveau_mpeg_context_fini,
+                .rd32 = _nouveau_mpeg_context_rd32,
+                .wr32 = _nouveau_mpeg_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PMPEG engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv84_mpeg_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv84_mpeg_priv *priv;
+        int ret;
+
+        ret = nouveau_mpeg_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00000002;
+        nv_subdev(priv)->intr = nv50_mpeg_intr;
+        nv_engine(priv)->cclass = &nv84_mpeg_cclass;
+        nv_engine(priv)->sclass = nv84_mpeg_sclass;
+        nv_engine(priv)->tlb_flush = nv50_mpeg_tlb_flush;
+        return 0;
+}
+
+struct nouveau_oclass
+nv84_mpeg_oclass = {
+        .handle = NV_ENGINE(MPEG, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_mpeg_ctor,
+                .dtor = _nouveau_mpeg_dtor,
+                .init = nv50_mpeg_init,
+                .fini = _nouveau_mpeg_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/ppp/nv98.c b/drivers/gpu/drm/nouveau/core/engine/ppp/nv98.c
new file mode 100644
index 000000000000..50e7e0da1981
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/ppp/nv98.c
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/ppp.h>
+
+struct nv98_ppp_priv {
+        struct nouveau_ppp base;
+};
+
+struct nv98_ppp_chan {
+        struct nouveau_ppp_chan base;
+};
+
+/*******************************************************************************
+ * PPP object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv98_ppp_sclass[] = {
+        {},
+};
+
+/*******************************************************************************
+ * PPPP context
+ ******************************************************************************/
+
+static int
+nv98_ppp_context_ctor(struct nouveau_object *parent,
+                      struct nouveau_object *engine,
+                      struct nouveau_oclass *oclass, void *data, u32 size,
+                      struct nouveau_object **pobject)
+{
+        struct nv98_ppp_chan *priv;
+        int ret;
+
+        ret = nouveau_ppp_context_create(parent, engine, oclass, NULL,
+                                         0, 0, 0, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nv98_ppp_context_dtor(struct nouveau_object *object)
+{
+        struct nv98_ppp_chan *priv = (void *)object;
+        nouveau_ppp_context_destroy(&priv->base);
+}
+
+static int
+nv98_ppp_context_init(struct nouveau_object *object)
+{
+        struct nv98_ppp_chan *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_ppp_context_init(&priv->base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv98_ppp_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv98_ppp_chan *priv = (void *)object;
+        return nouveau_ppp_context_fini(&priv->base, suspend);
+}
+
+static struct nouveau_oclass
+nv98_ppp_cclass = {
+        .handle = NV_ENGCTX(PPP, 0x98),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv98_ppp_context_ctor,
+                .dtor = nv98_ppp_context_dtor,
+                .init = nv98_ppp_context_init,
+                .fini = nv98_ppp_context_fini,
+                .rd32 = _nouveau_ppp_context_rd32,
+                .wr32 = _nouveau_ppp_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PPPP engine/subdev functions
+ ******************************************************************************/
+
+static void
+nv98_ppp_intr(struct nouveau_subdev *subdev)
+{
+}
+
+static int
+nv98_ppp_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nv98_ppp_priv *priv;
+        int ret;
+
+        ret = nouveau_ppp_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x00400002;
+        nv_subdev(priv)->intr = nv98_ppp_intr;
+        nv_engine(priv)->cclass = &nv98_ppp_cclass;
+        nv_engine(priv)->sclass = nv98_ppp_sclass;
+        return 0;
+}
+
+static void
+nv98_ppp_dtor(struct nouveau_object *object)
+{
+        struct nv98_ppp_priv *priv = (void *)object;
+        nouveau_ppp_destroy(&priv->base);
+}
+
+static int
+nv98_ppp_init(struct nouveau_object *object)
+{
+        struct nv98_ppp_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_ppp_init(&priv->base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv98_ppp_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv98_ppp_priv *priv = (void *)object;
+        return nouveau_ppp_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv98_ppp_oclass = {
+        .handle = NV_ENGINE(PPP, 0x98),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv98_ppp_ctor,
+                .dtor = nv98_ppp_dtor,
+                .init = nv98_ppp_init,
+                .fini = nv98_ppp_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/software/nv04.c b/drivers/gpu/drm/nouveau/core/engine/software/nv04.c
new file mode 100644
index 000000000000..3ca4c3aa90b7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/software/nv04.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/software.h>
+#include <engine/fifo.h>
+
+struct nv04_software_priv {
+        struct nouveau_software base;
+};
+
+struct nv04_software_chan {
+        struct nouveau_software_chan base;
+};
+
+/*******************************************************************************
+ * software object classes
+ ******************************************************************************/
+
+static int
+nv04_software_set_ref(struct nouveau_object *object, u32 mthd,
+                      void *data, u32 size)
+{
+        struct nouveau_object *channel = (void *)nv_engctx(object->parent);
+        struct nouveau_fifo_chan *fifo = (void *)channel->parent;
+        atomic_set(&fifo->refcnt, *(u32*)data);
+        return 0;
+}
+
+static int
+nv04_software_flip(struct nouveau_object *object, u32 mthd,
+                   void *args, u32 size)
+{
+        struct nv04_software_chan *chan = (void *)nv_engctx(object->parent);
+        if (chan->base.flip)
+                return chan->base.flip(chan->base.flip_data);
+        return -EINVAL;
+}
+
+static struct nouveau_omthds
+nv04_software_omthds[] = {
+        { 0x0150, nv04_software_set_ref },
+        { 0x0500, nv04_software_flip },
+        {}
+};
+
+static struct nouveau_oclass
+nv04_software_sclass[] = {
+        { 0x006e, &nouveau_object_ofuncs, nv04_software_omthds },
+        {}
+};
+
+/*******************************************************************************
+ * software context
+ ******************************************************************************/
+
+static int
+nv04_software_context_ctor(struct nouveau_object *parent,
+                      struct nouveau_object *engine,
+                      struct nouveau_oclass *oclass, void *data, u32 size,
+                      struct nouveau_object **pobject)
+{
+        struct nv04_software_chan *chan;
+        int ret;
+
+        ret = nouveau_software_context_create(parent, engine, oclass, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nv04_software_cclass = {
+        .handle = NV_ENGCTX(SW, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_software_context_ctor,
+                .dtor = _nouveau_software_context_dtor,
+                .init = _nouveau_software_context_init,
+                .fini = _nouveau_software_context_fini,
+        },
+};
+
+/*******************************************************************************
+ * software engine/subdev functions
+ ******************************************************************************/
+
+void
+nv04_software_intr(struct nouveau_subdev *subdev)
+{
+        nv_mask(subdev, 0x000100, 0x80000000, 0x00000000);
+}
+
+static int
+nv04_software_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nv04_software_priv *priv;
+        int ret;
+
+        ret = nouveau_software_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->cclass = &nv04_software_cclass;
+        nv_engine(priv)->sclass = nv04_software_sclass;
+        nv_subdev(priv)->intr = nv04_software_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nv04_software_oclass = {
+        .handle = NV_ENGINE(SW, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_software_ctor,
+                .dtor = _nouveau_software_dtor,
+                .init = _nouveau_software_init,
+                .fini = _nouveau_software_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/software/nv10.c b/drivers/gpu/drm/nouveau/core/engine/software/nv10.c
new file mode 100644
index 000000000000..6e699afbfdb7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/software/nv10.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/software.h>
+
+struct nv10_software_priv {
+        struct nouveau_software base;
+};
+
+struct nv10_software_chan {
+        struct nouveau_software_chan base;
+};
+
+/*******************************************************************************
+ * software object classes
+ ******************************************************************************/
+
+static int
+nv10_software_flip(struct nouveau_object *object, u32 mthd,
+                   void *args, u32 size)
+{
+        struct nv10_software_chan *chan = (void *)nv_engctx(object->parent);
+        if (chan->base.flip)
+                return chan->base.flip(chan->base.flip_data);
+        return -EINVAL;
+}
+
+static struct nouveau_omthds
+nv10_software_omthds[] = {
+        { 0x0500, nv10_software_flip },
+        {}
+};
+
+static struct nouveau_oclass
+nv10_software_sclass[] = {
+        { 0x016e, &nouveau_object_ofuncs, nv10_software_omthds },
+        {}
+};
+
+/*******************************************************************************
+ * software context
+ ******************************************************************************/
+
+static int
+nv10_software_context_ctor(struct nouveau_object *parent,
+                      struct nouveau_object *engine,
+                      struct nouveau_oclass *oclass, void *data, u32 size,
+                      struct nouveau_object **pobject)
+{
+        struct nv10_software_chan *chan;
+        int ret;
+
+        ret = nouveau_software_context_create(parent, engine, oclass, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct nouveau_oclass
+nv10_software_cclass = {
+        .handle = NV_ENGCTX(SW, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_software_context_ctor,
+                .dtor = _nouveau_software_context_dtor,
+                .init = _nouveau_software_context_init,
+                .fini = _nouveau_software_context_fini,
+        },
+};
+
+/*******************************************************************************
+ * software engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv10_software_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nv10_software_priv *priv;
+        int ret;
+
+        ret = nouveau_software_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->cclass = &nv10_software_cclass;
+        nv_engine(priv)->sclass = nv10_software_sclass;
+        nv_subdev(priv)->intr = nv04_software_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nv10_software_oclass = {
+        .handle = NV_ENGINE(SW, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_software_ctor,
+                .dtor = _nouveau_software_dtor,
+                .init = _nouveau_software_init,
+                .fini = _nouveau_software_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/software/nv50.c b/drivers/gpu/drm/nouveau/core/engine/software/nv50.c
new file mode 100644
index 000000000000..a2edcd38544a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/software/nv50.c
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+#include <core/namedb.h>
+#include <core/handle.h>
+#include <core/gpuobj.h>
+
+#include <engine/software.h>
+#include <engine/disp.h>
+
+struct nv50_software_priv {
+        struct nouveau_software base;
+};
+
+struct nv50_software_chan {
+        struct nouveau_software_chan base;
+};
+
+/*******************************************************************************
+ * software object classes
+ ******************************************************************************/
+
+static int
+nv50_software_mthd_dma_vblsem(struct nouveau_object *object, u32 mthd,
+                              void *args, u32 size)
+{
+        struct nv50_software_chan *chan = (void *)nv_engctx(object->parent);
+        struct nouveau_fifo_chan *fifo = (void *)nv_object(chan)->parent;
+        struct nouveau_handle *handle;
+        int ret = -EINVAL;
+
+        handle = nouveau_namedb_get(nv_namedb(fifo), *(u32 *)args);
+        if (!handle)
+                return -ENOENT;
+
+        if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) {
+                struct nouveau_gpuobj *gpuobj = nv_gpuobj(handle->object);
+                chan->base.vblank.ctxdma = gpuobj->node->offset >> 4;
+                ret = 0;
+        }
+        nouveau_namedb_put(handle);
+        return ret;
+}
+
+static int
+nv50_software_mthd_vblsem_offset(struct nouveau_object *object, u32 mthd,
+                                 void *args, u32 size)
+{
+        struct nv50_software_chan *chan = (void *)nv_engctx(object->parent);
+        chan->base.vblank.offset = *(u32 *)args;
+        return 0;
+}
+
+static int
+nv50_software_mthd_vblsem_value(struct nouveau_object *object, u32 mthd,
+                                void *args, u32 size)
+{
+        struct nv50_software_chan *chan = (void *)nv_engctx(object->parent);
+        chan->base.vblank.value = *(u32 *)args;
+        return 0;
+}
+
+static int
+nv50_software_mthd_vblsem_release(struct nouveau_object *object, u32 mthd,
+                                  void *args, u32 size)
+{
+        struct nv50_software_chan *chan = (void *)nv_engctx(object->parent);
+        struct nouveau_disp *disp = nouveau_disp(object);
+        unsigned long flags;
+        u32 crtc = *(u32 *)args;
+
+        if (crtc > 1)
+                return -EINVAL;
+
+        disp->vblank.get(disp->vblank.data, crtc);
+
+        spin_lock_irqsave(&disp->vblank.lock, flags);
+        list_add(&chan->base.vblank.head, &disp->vblank.list);
+        chan->base.vblank.crtc = crtc;
+        spin_unlock_irqrestore(&disp->vblank.lock, flags);
+        return 0;
+}
+
+static int
+nv50_software_mthd_flip(struct nouveau_object *object, u32 mthd,
+                        void *args, u32 size)
+{
+        struct nv50_software_chan *chan = (void *)nv_engctx(object->parent);
+        if (chan->base.flip)
+                return chan->base.flip(chan->base.flip_data);
+        return -EINVAL;
+}
+
+static struct nouveau_omthds
+nv50_software_omthds[] = {
+        { 0x018c, nv50_software_mthd_dma_vblsem },
+        { 0x0400, nv50_software_mthd_vblsem_offset },
+        { 0x0404, nv50_software_mthd_vblsem_value },
+        { 0x0408, nv50_software_mthd_vblsem_release },
+        { 0x0500, nv50_software_mthd_flip },
+        {}
+};
+
+static struct nouveau_oclass
+nv50_software_sclass[] = {
+        { 0x506e, &nouveau_object_ofuncs, nv50_software_omthds },
+        {}
+};
+
+/*******************************************************************************
+ * software context
+ ******************************************************************************/
+
+static int
+nv50_software_context_ctor(struct nouveau_object *parent,
+                           struct nouveau_object *engine,
+                           struct nouveau_oclass *oclass, void *data, u32 size,
+                           struct nouveau_object **pobject)
+{
+        struct nv50_software_chan *chan;
+        int ret;
+
+        ret = nouveau_software_context_create(parent, engine, oclass, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->base.vblank.channel = nv_gpuobj(parent->parent)->addr >> 12;
+        return 0;
+}
+
+static struct nouveau_oclass
+nv50_software_cclass = {
+        .handle = NV_ENGCTX(SW, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_software_context_ctor,
+                .dtor = _nouveau_software_context_dtor,
+                .init = _nouveau_software_context_init,
+                .fini = _nouveau_software_context_fini,
+        },
+};
+
+/*******************************************************************************
+ * software engine/subdev functions
+ ******************************************************************************/
+
+static int
+nv50_software_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nv50_software_priv *priv;
+        int ret;
+
+        ret = nouveau_software_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->cclass = &nv50_software_cclass;
+        nv_engine(priv)->sclass = nv50_software_sclass;
+        nv_subdev(priv)->intr = nv04_software_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_software_oclass = {
+        .handle = NV_ENGINE(SW, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_software_ctor,
+                .dtor = _nouveau_software_dtor,
+                .init = _nouveau_software_init,
+                .fini = _nouveau_software_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/software/nvc0.c b/drivers/gpu/drm/nouveau/core/engine/software/nvc0.c
new file mode 100644
index 000000000000..b7b0d7e330d6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/software/nvc0.c
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/software.h>
+#include <engine/disp.h>
+
+struct nvc0_software_priv {
+        struct nouveau_software base;
+};
+
+struct nvc0_software_chan {
+        struct nouveau_software_chan base;
+};
+
+/*******************************************************************************
+ * software object classes
+ ******************************************************************************/
+
+static int
+nvc0_software_mthd_vblsem_offset(struct nouveau_object *object, u32 mthd,
+                                 void *args, u32 size)
+{
+        struct nvc0_software_chan *chan = (void *)nv_engctx(object->parent);
+        u64 data = *(u32 *)args;
+        if (mthd == 0x0400) {
+                chan->base.vblank.offset &= 0x00ffffffffULL;
+                chan->base.vblank.offset |= data << 32;
+        } else {
+                chan->base.vblank.offset &= 0xff00000000ULL;
+                chan->base.vblank.offset |= data;
+        }
+        return 0;
+}
+
+static int
+nvc0_software_mthd_vblsem_value(struct nouveau_object *object, u32 mthd,
+                                void *args, u32 size)
+{
+        struct nvc0_software_chan *chan = (void *)nv_engctx(object->parent);
+        chan->base.vblank.value = *(u32 *)args;
+        return 0;
+}
+
+static int
+nvc0_software_mthd_vblsem_release(struct nouveau_object *object, u32 mthd,
+                                  void *args, u32 size)
+{
+        struct nvc0_software_chan *chan = (void *)nv_engctx(object->parent);
+        struct nouveau_disp *disp = nouveau_disp(object);
+        unsigned long flags;
+        u32 crtc = *(u32 *)args;
+
+        if ((nv_device(object)->card_type < NV_E0 && crtc > 1) || crtc > 3)
+                return -EINVAL;
+
+        disp->vblank.get(disp->vblank.data, crtc);
+
+        spin_lock_irqsave(&disp->vblank.lock, flags);
+        list_add(&chan->base.vblank.head, &disp->vblank.list);
+        chan->base.vblank.crtc = crtc;
+        spin_unlock_irqrestore(&disp->vblank.lock, flags);
+        return 0;
+}
+
+static int
+nvc0_software_mthd_flip(struct nouveau_object *object, u32 mthd,
+                        void *args, u32 size)
+{
+        struct nvc0_software_chan *chan = (void *)nv_engctx(object->parent);
+        if (chan->base.flip)
+                return chan->base.flip(chan->base.flip_data);
+        return -EINVAL;
+}
+
+static struct nouveau_omthds
+nvc0_software_omthds[] = {
+        { 0x0400, nvc0_software_mthd_vblsem_offset },
+        { 0x0404, nvc0_software_mthd_vblsem_offset },
+        { 0x0408, nvc0_software_mthd_vblsem_value },
+        { 0x040c, nvc0_software_mthd_vblsem_release },
+        { 0x0500, nvc0_software_mthd_flip },
+        {}
+};
+
+static struct nouveau_oclass
+nvc0_software_sclass[] = {
+        { 0x906e, &nouveau_object_ofuncs, nvc0_software_omthds },
+        {}
+};
+
+/*******************************************************************************
+ * software context
+ ******************************************************************************/
+
+static int
+nvc0_software_context_ctor(struct nouveau_object *parent,
+                           struct nouveau_object *engine,
+                           struct nouveau_oclass *oclass, void *data, u32 size,
+                           struct nouveau_object **pobject)
+{
+        struct nvc0_software_chan *chan;
+        int ret;
+
+        ret = nouveau_software_context_create(parent, engine, oclass, &chan);
+        *pobject = nv_object(chan);
+        if (ret)
+                return ret;
+
+        chan->base.vblank.channel = nv_gpuobj(parent->parent)->addr >> 12;
+        return 0;
+}
+
+static struct nouveau_oclass
+nvc0_software_cclass = {
+        .handle = NV_ENGCTX(SW, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_software_context_ctor,
+                .dtor = _nouveau_software_context_dtor,
+                .init = _nouveau_software_context_init,
+                .fini = _nouveau_software_context_fini,
+        },
+};
+
+/*******************************************************************************
+ * software engine/subdev functions
+ ******************************************************************************/
+
+static int
+nvc0_software_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                   struct nouveau_oclass *oclass, void *data, u32 size,
+                   struct nouveau_object **pobject)
+{
+        struct nvc0_software_priv *priv;
+        int ret;
+
+        ret = nouveau_software_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_engine(priv)->cclass = &nvc0_software_cclass;
+        nv_engine(priv)->sclass = nvc0_software_sclass;
+        nv_subdev(priv)->intr = nv04_software_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_software_oclass = {
+        .handle = NV_ENGINE(SW, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_software_ctor,
+                .dtor = _nouveau_software_dtor,
+                .init = _nouveau_software_init,
+                .fini = _nouveau_software_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/engine/vp/nv84.c b/drivers/gpu/drm/nouveau/core/engine/vp/nv84.c
new file mode 100644
index 000000000000..dd23c80e5405
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/engine/vp/nv84.c
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2012 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 <core/os.h>
+#include <core/class.h>
+#include <core/engctx.h>
+
+#include <engine/vp.h>
+
+struct nv84_vp_priv {
+        struct nouveau_vp base;
+};
+
+struct nv84_vp_chan {
+        struct nouveau_vp_chan base;
+};
+
+/*******************************************************************************
+ * VP object classes
+ ******************************************************************************/
+
+static struct nouveau_oclass
+nv84_vp_sclass[] = {
+        {},
+};
+
+/*******************************************************************************
+ * PVP context
+ ******************************************************************************/
+
+static int
+nv84_vp_context_ctor(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass, void *data, u32 size,
+                     struct nouveau_object **pobject)
+{
+        struct nv84_vp_chan *priv;
+        int ret;
+
+        ret = nouveau_vp_context_create(parent, engine, oclass, NULL,
+                                        0, 0, 0, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nv84_vp_context_dtor(struct nouveau_object *object)
+{
+        struct nv84_vp_chan *priv = (void *)object;
+        nouveau_vp_context_destroy(&priv->base);
+}
+
+static int
+nv84_vp_context_init(struct nouveau_object *object)
+{
+        struct nv84_vp_chan *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_vp_context_init(&priv->base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv84_vp_context_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv84_vp_chan *priv = (void *)object;
+        return nouveau_vp_context_fini(&priv->base, suspend);
+}
+
+static struct nouveau_oclass
+nv84_vp_cclass = {
+        .handle = NV_ENGCTX(VP, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_vp_context_ctor,
+                .dtor = nv84_vp_context_dtor,
+                .init = nv84_vp_context_init,
+                .fini = nv84_vp_context_fini,
+                .rd32 = _nouveau_vp_context_rd32,
+                .wr32 = _nouveau_vp_context_wr32,
+        },
+};
+
+/*******************************************************************************
+ * PVP engine/subdev functions
+ ******************************************************************************/
+
+static void
+nv84_vp_intr(struct nouveau_subdev *subdev)
+{
+}
+
+static int
+nv84_vp_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv84_vp_priv *priv;
+        int ret;
+
+        ret = nouveau_vp_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->unit = 0x01020000;
+        nv_subdev(priv)->intr = nv84_vp_intr;
+        nv_engine(priv)->cclass = &nv84_vp_cclass;
+        nv_engine(priv)->sclass = nv84_vp_sclass;
+        return 0;
+}
+
+static void
+nv84_vp_dtor(struct nouveau_object *object)
+{
+        struct nv84_vp_priv *priv = (void *)object;
+        nouveau_vp_destroy(&priv->base);
+}
+
+static int
+nv84_vp_init(struct nouveau_object *object)
+{
+        struct nv84_vp_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_vp_init(&priv->base);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv84_vp_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv84_vp_priv *priv = (void *)object;
+        return nouveau_vp_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv84_vp_oclass = {
+        .handle = NV_ENGINE(VP, 0x84),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv84_vp_ctor,
+                .dtor = nv84_vp_dtor,
+                .init = nv84_vp_init,
+                .fini = nv84_vp_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/include/core/class.h b/drivers/gpu/drm/nouveau/core/include/core/class.h
new file mode 100644
index 000000000000..6180ae9800fc
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/class.h
@@ -0,0 +1,118 @@
+#ifndef __NOUVEAU_CLASS_H__
+#define __NOUVEAU_CLASS_H__
+
+/* Device class
+ *
+ * 0080: NV_DEVICE
+ */
+#define NV_DEVICE_CLASS                                              0x00000080
+
+#define NV_DEVICE_DISABLE_IDENTIFY                        0x0000000000000001ULL
+#define NV_DEVICE_DISABLE_MMIO                            0x0000000000000002ULL
+#define NV_DEVICE_DISABLE_VBIOS                           0x0000000000000004ULL
+#define NV_DEVICE_DISABLE_CORE                            0x0000000000000008ULL
+#define NV_DEVICE_DISABLE_DISP                            0x0000000000010000ULL
+#define NV_DEVICE_DISABLE_FIFO                            0x0000000000020000ULL
+#define NV_DEVICE_DISABLE_GRAPH                           0x0000000100000000ULL
+#define NV_DEVICE_DISABLE_MPEG                            0x0000000200000000ULL
+#define NV_DEVICE_DISABLE_ME                              0x0000000400000000ULL
+#define NV_DEVICE_DISABLE_VP                              0x0000000800000000ULL
+#define NV_DEVICE_DISABLE_CRYPT                           0x0000001000000000ULL
+#define NV_DEVICE_DISABLE_BSP                             0x0000002000000000ULL
+#define NV_DEVICE_DISABLE_PPP                             0x0000004000000000ULL
+#define NV_DEVICE_DISABLE_COPY0                           0x0000008000000000ULL
+#define NV_DEVICE_DISABLE_COPY1                           0x0000010000000000ULL
+#define NV_DEVICE_DISABLE_UNK1C1                          0x0000020000000000ULL
+
+struct nv_device_class {
+        u64 device;     /* device identifier, ~0 for client default */
+        u64 disable;    /* disable particular subsystems */
+        u64 debug0;     /* as above, but *internal* ids, and *NOT* ABI */
+};
+
+/* DMA object classes
+ *
+ * 0002: NV_DMA_FROM_MEMORY
+ * 0003: NV_DMA_TO_MEMORY
+ * 003d: NV_DMA_IN_MEMORY
+ */
+#define NV_DMA_FROM_MEMORY_CLASS                                     0x00000002
+#define NV_DMA_TO_MEMORY_CLASS                                       0x00000003
+#define NV_DMA_IN_MEMORY_CLASS                                       0x0000003d
+
+#define NV_DMA_TARGET_MASK                                           0x000000ff
+#define NV_DMA_TARGET_VM                                             0x00000000
+#define NV_DMA_TARGET_VRAM                                           0x00000001
+#define NV_DMA_TARGET_PCI                                            0x00000002
+#define NV_DMA_TARGET_PCI_US                                         0x00000003
+#define NV_DMA_TARGET_AGP                                            0x00000004
+#define NV_DMA_ACCESS_MASK                                           0x00000f00
+#define NV_DMA_ACCESS_VM                                             0x00000000
+#define NV_DMA_ACCESS_RD                                             0x00000100
+#define NV_DMA_ACCESS_WR                                             0x00000200
+#define NV_DMA_ACCESS_RDWR                                           0x00000300
+
+struct nv_dma_class {
+        u32 flags;
+        u32 pad0;
+        u64 start;
+        u64 limit;
+};
+
+/* DMA FIFO channel classes
+ *
+ * 006b: NV03_CHANNEL_DMA
+ * 006e: NV10_CHANNEL_DMA
+ * 176e: NV17_CHANNEL_DMA
+ * 406e: NV40_CHANNEL_DMA
+ * 506e: NV50_CHANNEL_DMA
+ * 826e: NV84_CHANNEL_DMA
+ */
+#define NV03_CHANNEL_DMA_CLASS                                       0x0000006b
+#define NV10_CHANNEL_DMA_CLASS                                       0x0000006e
+#define NV17_CHANNEL_DMA_CLASS                                       0x0000176e
+#define NV40_CHANNEL_DMA_CLASS                                       0x0000406e
+#define NV50_CHANNEL_DMA_CLASS                                       0x0000506e
+#define NV84_CHANNEL_DMA_CLASS                                       0x0000826e
+
+struct nv03_channel_dma_class {
+        u32 pushbuf;
+        u32 pad0;
+        u64 offset;
+};
+
+/* Indirect FIFO channel classes
+ *
+ * 506f: NV50_CHANNEL_IND
+ * 826f: NV84_CHANNEL_IND
+ * 906f: NVC0_CHANNEL_IND
+ * a06f: NVE0_CHANNEL_IND
+ */
+
+#define NV50_CHANNEL_IND_CLASS                                       0x0000506f
+#define NV84_CHANNEL_IND_CLASS                                       0x0000826f
+#define NVC0_CHANNEL_IND_CLASS                                       0x0000906f
+#define NVE0_CHANNEL_IND_CLASS                                       0x0000a06f
+
+struct nv50_channel_ind_class {
+        u32 pushbuf;
+        u32 ilength;
+        u64 ioffset;
+};
+
+#define NVE0_CHANNEL_IND_ENGINE_GR                                   0x00000001
+#define NVE0_CHANNEL_IND_ENGINE_VP                                   0x00000002
+#define NVE0_CHANNEL_IND_ENGINE_PPP                                  0x00000004
+#define NVE0_CHANNEL_IND_ENGINE_BSP                                  0x00000008
+#define NVE0_CHANNEL_IND_ENGINE_CE0                                  0x00000010
+#define NVE0_CHANNEL_IND_ENGINE_CE1                                  0x00000020
+#define NVE0_CHANNEL_IND_ENGINE_ENC                                  0x00000040
+
+struct nve0_channel_ind_class {
+        u32 pushbuf;
+        u32 ilength;
+        u64 ioffset;
+        u32 engine;
+};
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/client.h b/drivers/gpu/drm/nouveau/core/include/core/client.h
new file mode 100644
index 000000000000..0193532ceac9
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/client.h
@@ -0,0 +1,42 @@
+#ifndef __NOUVEAU_CLIENT_H__
+#define __NOUVEAU_CLIENT_H__
+
+#include <core/namedb.h>
+
+struct nouveau_client {
+        struct nouveau_namedb base;
+        struct nouveau_handle *root;
+        struct nouveau_object *device;
+        char name[16];
+        u32 debug;
+        struct nouveau_vm *vm;
+};
+
+static inline struct nouveau_client *
+nv_client(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_CLIENT_CLASS)))
+                nv_assert("BAD CAST -> NvClient, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+static inline struct nouveau_client *
+nouveau_client(void *obj)
+{
+        struct nouveau_object *client = nv_object(obj);
+        while (client && !(nv_iclass(client, NV_CLIENT_CLASS)))
+                client = client->parent;
+        return (void *)client;
+}
+
+#define nouveau_client_create(n,c,oc,od,d)                                     \
+        nouveau_client_create_((n), (c), (oc), (od), sizeof(**d), (void **)d)
+
+int  nouveau_client_create_(const char *name, u64 device, const char *cfg,
+                            const char *dbg, int, void **);
+int  nouveau_client_init(struct nouveau_client *);
+int  nouveau_client_fini(struct nouveau_client *, bool suspend);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/debug.h b/drivers/gpu/drm/nouveau/core/include/core/debug.h
new file mode 100644
index 000000000000..9ea18dfcb4d0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/debug.h
@@ -0,0 +1,13 @@
+#ifndef __NOUVEAU_DEBUG_H__
+#define __NOUVEAU_DEBUG_H__
+
+#define NV_DBG_FATAL    0
+#define NV_DBG_ERROR    1
+#define NV_DBG_WARN     2
+#define NV_DBG_INFO     3
+#define NV_DBG_DEBUG    4
+#define NV_DBG_TRACE    5
+#define NV_DBG_PARANOIA 6
+#define NV_DBG_SPAM     7
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/device.h b/drivers/gpu/drm/nouveau/core/include/core/device.h
new file mode 100644
index 000000000000..e58b6f0984c1
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/device.h
@@ -0,0 +1,136 @@
+#ifndef __NOUVEAU_DEVICE_H__
+#define __NOUVEAU_DEVICE_H__
+
+#include <core/object.h>
+#include <core/subdev.h>
+#include <core/engine.h>
+
+enum nv_subdev_type {
+        NVDEV_SUBDEV_DEVICE,
+        NVDEV_SUBDEV_VBIOS,
+
+        /* All subdevs from DEVINIT to DEVINIT_LAST will be created before
+         * *any* of them are initialised.  This subdev category is used
+         * for any subdevs that the VBIOS init table parsing may call out
+         * to during POST.
+         */
+        NVDEV_SUBDEV_DEVINIT,
+        NVDEV_SUBDEV_GPIO,
+        NVDEV_SUBDEV_I2C,
+        NVDEV_SUBDEV_CLOCK,
+        NVDEV_SUBDEV_DEVINIT_LAST = NVDEV_SUBDEV_CLOCK,
+
+        /* This grouping of subdevs are initialised right after they've
+         * been created, and are allowed to assume any subdevs in the
+         * list above them exist and have been initialised.
+         */
+        NVDEV_SUBDEV_MXM,
+        NVDEV_SUBDEV_MC,
+        NVDEV_SUBDEV_TIMER,
+        NVDEV_SUBDEV_FB,
+        NVDEV_SUBDEV_LTCG,
+        NVDEV_SUBDEV_IBUS,
+        NVDEV_SUBDEV_INSTMEM,
+        NVDEV_SUBDEV_VM,
+        NVDEV_SUBDEV_BAR,
+        NVDEV_SUBDEV_VOLT,
+        NVDEV_SUBDEV_THERM,
+
+        NVDEV_ENGINE_DMAOBJ,
+        NVDEV_ENGINE_FIFO,
+        NVDEV_ENGINE_SW,
+        NVDEV_ENGINE_GR,
+        NVDEV_ENGINE_MPEG,
+        NVDEV_ENGINE_ME,
+        NVDEV_ENGINE_VP,
+        NVDEV_ENGINE_CRYPT,
+        NVDEV_ENGINE_BSP,
+        NVDEV_ENGINE_PPP,
+        NVDEV_ENGINE_COPY0,
+        NVDEV_ENGINE_COPY1,
+        NVDEV_ENGINE_UNK1C1,
+        NVDEV_ENGINE_VENC,
+        NVDEV_ENGINE_DISP,
+
+        NVDEV_SUBDEV_NR,
+};
+
+struct nouveau_device {
+        struct nouveau_subdev base;
+        struct list_head head;
+
+        struct pci_dev *pdev;
+        u64 handle;
+
+        const char *cfgopt;
+        const char *dbgopt;
+        const char *name;
+        const char *cname;
+
+        enum {
+                NV_04    = 0x04,
+                NV_10    = 0x10,
+                NV_20    = 0x20,
+                NV_30    = 0x30,
+                NV_40    = 0x40,
+                NV_50    = 0x50,
+                NV_C0    = 0xc0,
+                NV_D0    = 0xd0,
+                NV_E0    = 0xe0,
+        } card_type;
+        u32 chipset;
+        u32 crystal;
+
+        struct nouveau_oclass *oclass[NVDEV_SUBDEV_NR];
+        struct nouveau_object *subdev[NVDEV_SUBDEV_NR];
+};
+
+static inline struct nouveau_device *
+nv_device(void *obj)
+{
+        struct nouveau_object *object = nv_object(obj);
+        struct nouveau_object *device = object;
+
+        if (device->engine)
+                device = device->engine;
+        if (device->parent)
+                device = device->parent;
+
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(device, NV_SUBDEV_CLASS) ||
+                     (nv_hclass(device) & 0xff) != NVDEV_SUBDEV_DEVICE)) {
+                nv_assert("BAD CAST -> NvDevice, 0x%08x 0x%08x",
+                          nv_hclass(object), nv_hclass(device));
+        }
+#endif
+
+        return (void *)device;
+}
+
+static inline struct nouveau_subdev *
+nouveau_subdev(void *obj, int sub)
+{
+        if (nv_device(obj)->subdev[sub])
+                return nv_subdev(nv_device(obj)->subdev[sub]);
+        return NULL;
+}
+
+static inline struct nouveau_engine *
+nouveau_engine(void *obj, int sub)
+{
+        struct nouveau_subdev *subdev = nouveau_subdev(obj, sub);
+        if (subdev && nv_iclass(subdev, NV_ENGINE_CLASS))
+                return nv_engine(subdev);
+        return NULL;
+}
+
+static inline bool
+nv_device_match(struct nouveau_object *object, u16 dev, u16 ven, u16 sub)
+{
+        struct nouveau_device *device = nv_device(object);
+        return device->pdev->device == dev &&
+               device->pdev->subsystem_vendor == ven &&
+               device->pdev->subsystem_device == sub;
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/engctx.h b/drivers/gpu/drm/nouveau/core/include/core/engctx.h
new file mode 100644
index 000000000000..8a947b6872eb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/engctx.h
@@ -0,0 +1,51 @@
+#ifndef __NOUVEAU_ENGCTX_H__
+#define __NOUVEAU_ENGCTX_H__
+
+#include <core/object.h>
+#include <core/gpuobj.h>
+
+#include <subdev/vm.h>
+
+#define NV_ENGCTX_(eng,var) (NV_ENGCTX_CLASS | ((var) << 8) | (eng))
+#define NV_ENGCTX(name,var)  NV_ENGCTX_(NVDEV_ENGINE_##name, (var))
+
+struct nouveau_engctx {
+        struct nouveau_gpuobj base;
+        struct nouveau_vma vma;
+        struct list_head head;
+        unsigned long save;
+        u64 addr;
+};
+
+static inline struct nouveau_engctx *
+nv_engctx(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_ENGCTX_CLASS)))
+                nv_assert("BAD CAST -> NvEngCtx, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+#define nouveau_engctx_create(p,e,c,g,s,a,f,d)                                 \
+        nouveau_engctx_create_((p), (e), (c), (g), (s), (a), (f),              \
+                               sizeof(**d), (void **)d)
+
+int  nouveau_engctx_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, struct nouveau_object *,
+                            u32 size, u32 align, u32 flags,
+                            int length, void **data);
+void nouveau_engctx_destroy(struct nouveau_engctx *);
+int  nouveau_engctx_init(struct nouveau_engctx *);
+int  nouveau_engctx_fini(struct nouveau_engctx *, bool suspend);
+
+void _nouveau_engctx_dtor(struct nouveau_object *);
+int  _nouveau_engctx_init(struct nouveau_object *);
+int  _nouveau_engctx_fini(struct nouveau_object *, bool suspend);
+#define _nouveau_engctx_rd32 _nouveau_gpuobj_rd32
+#define _nouveau_engctx_wr32 _nouveau_gpuobj_wr32
+
+struct nouveau_object *nouveau_engctx_get(struct nouveau_engine *, u64 addr);
+void nouveau_engctx_put(struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/engine.h b/drivers/gpu/drm/nouveau/core/include/core/engine.h
new file mode 100644
index 000000000000..666d06de77ec
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/engine.h
@@ -0,0 +1,57 @@
+#ifndef __NOUVEAU_ENGINE_H__
+#define __NOUVEAU_ENGINE_H__
+
+#include <core/object.h>
+#include <core/subdev.h>
+
+#define NV_ENGINE_(eng,var) (NV_ENGINE_CLASS | ((var) << 8) | (eng))
+#define NV_ENGINE(name,var)  NV_ENGINE_(NVDEV_ENGINE_##name, (var))
+
+struct nouveau_engine {
+        struct nouveau_subdev base;
+        struct nouveau_oclass *cclass;
+        struct nouveau_oclass *sclass;
+
+        struct list_head contexts;
+        spinlock_t lock;
+
+        void (*tile_prog)(struct nouveau_engine *, int region);
+        int  (*tlb_flush)(struct nouveau_engine *);
+};
+
+static inline struct nouveau_engine *
+nv_engine(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_ENGINE_CLASS)))
+                nv_assert("BAD CAST -> NvEngine, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+static inline int
+nv_engidx(struct nouveau_object *object)
+{
+        return nv_subidx(object);
+}
+
+#define nouveau_engine_create(p,e,c,d,i,f,r)                                   \
+        nouveau_engine_create_((p), (e), (c), (d), (i), (f),                   \
+                               sizeof(**r),(void **)r)
+
+#define nouveau_engine_destroy(p)                                              \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_engine_init(p)                                                 \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_engine_fini(p,s)                                               \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+int nouveau_engine_create_(struct nouveau_object *, struct nouveau_object *,
+                           struct nouveau_oclass *, bool, const char *,
+                           const char *, int, void **);
+
+#define _nouveau_engine_dtor _nouveau_subdev_dtor
+#define _nouveau_engine_init _nouveau_subdev_init
+#define _nouveau_engine_fini _nouveau_subdev_fini
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/enum.h b/drivers/gpu/drm/nouveau/core/include/core/enum.h
new file mode 100644
index 000000000000..e7b1e181943b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/enum.h
@@ -0,0 +1,23 @@
+#ifndef __NOUVEAU_ENUM_H__
+#define __NOUVEAU_ENUM_H__
+
+struct nouveau_enum {
+        u32 value;
+        const char *name;
+        const void *data;
+};
+
+const struct nouveau_enum *
+nouveau_enum_find(const struct nouveau_enum *, u32 value);
+
+void
+nouveau_enum_print(const struct nouveau_enum *en, u32 value);
+
+struct nouveau_bitfield {
+        u32 mask;
+        const char *name;
+};
+
+void nouveau_bitfield_print(const struct nouveau_bitfield *, u32 value);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/gpuobj.h b/drivers/gpu/drm/nouveau/core/include/core/gpuobj.h
new file mode 100644
index 000000000000..6eaff79377ae
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/gpuobj.h
@@ -0,0 +1,71 @@
+#ifndef __NOUVEAU_GPUOBJ_H__
+#define __NOUVEAU_GPUOBJ_H__
+
+#include <core/object.h>
+#include <core/device.h>
+#include <core/parent.h>
+#include <core/mm.h>
+
+struct nouveau_vma;
+struct nouveau_vm;
+
+#define NVOBJ_FLAG_ZERO_ALLOC 0x00000001
+#define NVOBJ_FLAG_ZERO_FREE  0x00000002
+#define NVOBJ_FLAG_HEAP       0x00000004
+
+struct nouveau_gpuobj {
+        struct nouveau_object base;
+        struct nouveau_object *parent;
+        struct nouveau_mm_node *node;
+        struct nouveau_mm heap;
+
+        u32 flags;
+        u64 addr;
+        u32 size;
+};
+
+static inline struct nouveau_gpuobj *
+nv_gpuobj(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_GPUOBJ_CLASS)))
+                nv_assert("BAD CAST -> NvGpuObj, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+#define nouveau_gpuobj_create(p,e,c,v,g,s,a,f,d)                               \
+        nouveau_gpuobj_create_((p), (e), (c), (v), (g), (s), (a), (f),         \
+                               sizeof(**d), (void **)d)
+#define nouveau_gpuobj_init(p) nouveau_object_init(&(p)->base)
+#define nouveau_gpuobj_fini(p,s) nouveau_object_fini(&(p)->base, (s))
+int  nouveau_gpuobj_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, u32 pclass,
+                            struct nouveau_object *, u32 size, u32 align,
+                            u32 flags, int length, void **);
+void nouveau_gpuobj_destroy(struct nouveau_gpuobj *);
+
+int nouveau_gpuobj_new(struct nouveau_object *, struct nouveau_object *,
+                       u32 size, u32 align, u32 flags,
+                       struct nouveau_gpuobj **);
+int nouveau_gpuobj_dup(struct nouveau_object *, struct nouveau_gpuobj *,
+                       struct nouveau_gpuobj **);
+
+int nouveau_gpuobj_map(struct nouveau_gpuobj *, u32 acc, struct nouveau_vma *);
+int nouveau_gpuobj_map_vm(struct nouveau_gpuobj *, struct nouveau_vm *,
+                          u32 access, struct nouveau_vma *);
+void nouveau_gpuobj_unmap(struct nouveau_vma *);
+
+static inline void
+nouveau_gpuobj_ref(struct nouveau_gpuobj *obj, struct nouveau_gpuobj **ref)
+{
+        nouveau_object_ref(&obj->base, (struct nouveau_object **)ref);
+}
+
+void _nouveau_gpuobj_dtor(struct nouveau_object *);
+int  _nouveau_gpuobj_init(struct nouveau_object *);
+int  _nouveau_gpuobj_fini(struct nouveau_object *, bool);
+u32  _nouveau_gpuobj_rd32(struct nouveau_object *, u32);
+void _nouveau_gpuobj_wr32(struct nouveau_object *, u32, u32);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/handle.h b/drivers/gpu/drm/nouveau/core/include/core/handle.h
new file mode 100644
index 000000000000..363674cdf8ab
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/handle.h
@@ -0,0 +1,31 @@
+#ifndef __NOUVEAU_HANDLE_H__
+#define __NOUVEAU_HANDLE_H__
+
+struct nouveau_handle {
+        struct nouveau_namedb *namedb;
+        struct list_head node;
+
+        struct list_head head;
+        struct list_head tree;
+        u32 name;
+        u32 priv;
+
+        struct nouveau_handle *parent;
+        struct nouveau_object *object;
+};
+
+int  nouveau_handle_create(struct nouveau_object *, u32 parent, u32 handle,
+                           struct nouveau_object *, struct nouveau_handle **);
+void nouveau_handle_destroy(struct nouveau_handle *);
+int  nouveau_handle_init(struct nouveau_handle *);
+int  nouveau_handle_fini(struct nouveau_handle *, bool suspend);
+
+struct nouveau_object *
+nouveau_handle_ref(struct nouveau_object *, u32 name);
+
+struct nouveau_handle *nouveau_handle_get_class(struct nouveau_object *, u16);
+struct nouveau_handle *nouveau_handle_get_vinst(struct nouveau_object *, u64);
+struct nouveau_handle *nouveau_handle_get_cinst(struct nouveau_object *, u32);
+void nouveau_handle_put(struct nouveau_handle *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/math.h b/drivers/gpu/drm/nouveau/core/include/core/math.h
new file mode 100644
index 000000000000..f808131c5cd8
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/math.h
@@ -0,0 +1,16 @@
+#ifndef __NOUVEAU_MATH_H__
+#define __NOUVEAU_MATH_H__
+
+static inline int
+log2i(u64 base)
+{
+        u64 temp = base >> 1;
+        int log2;
+
+        for (log2 = 0; temp; log2++, temp >>= 1) {
+        }
+
+        return (base & (base - 1)) ? log2 + 1: log2;
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/mm.h b/drivers/gpu/drm/nouveau/core/include/core/mm.h
new file mode 100644
index 000000000000..9ee9bf4028ca
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/mm.h
@@ -0,0 +1,33 @@
+#ifndef __NOUVEAU_MM_H__
+#define __NOUVEAU_MM_H__
+
+struct nouveau_mm_node {
+        struct list_head nl_entry;
+        struct list_head fl_entry;
+        struct list_head rl_entry;
+
+        u8  type;
+        u32 offset;
+        u32 length;
+};
+
+struct nouveau_mm {
+        struct list_head nodes;
+        struct list_head free;
+
+        struct mutex mutex;
+
+        u32 block_size;
+        int heap_nodes;
+        u32 heap_size;
+};
+
+int  nouveau_mm_init(struct nouveau_mm *, u32 offset, u32 length, u32 block);
+int  nouveau_mm_fini(struct nouveau_mm *);
+int  nouveau_mm_head(struct nouveau_mm *, u8 type, u32 size_max, u32 size_min,
+                     u32 align, struct nouveau_mm_node **);
+int  nouveau_mm_tail(struct nouveau_mm *, u8 type, u32 size_max, u32 size_min,
+                     u32 align, struct nouveau_mm_node **);
+void nouveau_mm_free(struct nouveau_mm *, struct nouveau_mm_node **);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/namedb.h b/drivers/gpu/drm/nouveau/core/include/core/namedb.h
new file mode 100644
index 000000000000..8897e0886085
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/namedb.h
@@ -0,0 +1,56 @@
+#ifndef __NOUVEAU_NAMEDB_H__
+#define __NOUVEAU_NAMEDB_H__
+
+#include <core/parent.h>
+
+struct nouveau_handle;
+
+struct nouveau_namedb {
+        struct nouveau_parent base;
+        rwlock_t lock;
+        struct list_head list;
+};
+
+static inline struct nouveau_namedb *
+nv_namedb(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_NAMEDB_CLASS)))
+                nv_assert("BAD CAST -> NvNameDB, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+#define nouveau_namedb_create(p,e,c,v,s,m,d)                                   \
+        nouveau_namedb_create_((p), (e), (c), (v), (s), (m),                   \
+                               sizeof(**d), (void **)d)
+#define nouveau_namedb_init(p)                                                 \
+        nouveau_parent_init(&(p)->base)
+#define nouveau_namedb_fini(p,s)                                               \
+        nouveau_parent_fini(&(p)->base, (s))
+#define nouveau_namedb_destroy(p)                                              \
+        nouveau_parent_destroy(&(p)->base)
+
+int  nouveau_namedb_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, u32 pclass,
+                            struct nouveau_oclass *, u32 engcls,
+                            int size, void **);
+
+int  _nouveau_namedb_ctor(struct nouveau_object *, struct nouveau_object *,
+                          struct nouveau_oclass *, void *, u32,
+                          struct nouveau_object **);
+#define _nouveau_namedb_dtor _nouveau_parent_dtor
+#define _nouveau_namedb_init _nouveau_parent_init
+#define _nouveau_namedb_fini _nouveau_parent_fini
+
+int  nouveau_namedb_insert(struct nouveau_namedb *, u32 name,
+                           struct nouveau_object *, struct nouveau_handle *);
+void nouveau_namedb_remove(struct nouveau_handle *);
+
+struct nouveau_handle *nouveau_namedb_get(struct nouveau_namedb *, u32);
+struct nouveau_handle *nouveau_namedb_get_class(struct nouveau_namedb *, u16);
+struct nouveau_handle *nouveau_namedb_get_vinst(struct nouveau_namedb *, u64);
+struct nouveau_handle *nouveau_namedb_get_cinst(struct nouveau_namedb *, u32);
+void nouveau_namedb_put(struct nouveau_handle *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/object.h b/drivers/gpu/drm/nouveau/core/include/core/object.h
new file mode 100644
index 000000000000..818feabbf4a0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/object.h
@@ -0,0 +1,188 @@
+#ifndef __NOUVEAU_OBJECT_H__
+#define __NOUVEAU_OBJECT_H__
+
+#include <core/os.h>
+#include <core/printk.h>
+
+#define NV_PARENT_CLASS 0x80000000
+#define NV_NAMEDB_CLASS 0x40000000
+#define NV_CLIENT_CLASS 0x20000000
+#define NV_SUBDEV_CLASS 0x10000000
+#define NV_ENGINE_CLASS 0x08000000
+#define NV_MEMOBJ_CLASS 0x04000000
+#define NV_GPUOBJ_CLASS 0x02000000
+#define NV_ENGCTX_CLASS 0x01000000
+#define NV_OBJECT_CLASS 0x0000ffff
+
+struct nouveau_object {
+        struct nouveau_oclass *oclass;
+        struct nouveau_object *parent;
+        struct nouveau_object *engine;
+        atomic_t refcount;
+        atomic_t usecount;
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+#define NOUVEAU_OBJECT_MAGIC 0x75ef0bad
+        struct list_head list;
+        u32 _magic;
+#endif
+};
+
+static inline struct nouveau_object *
+nv_object(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (likely(obj)) {
+                struct nouveau_object *object = obj;
+                if (unlikely(object->_magic != NOUVEAU_OBJECT_MAGIC))
+                        nv_assert("BAD CAST -> NvObject, invalid magic");
+        }
+#endif
+        return obj;
+}
+
+#define nouveau_object_create(p,e,c,s,d)                                       \
+        nouveau_object_create_((p), (e), (c), (s), sizeof(**d), (void **)d)
+int  nouveau_object_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, u32, int size, void **);
+void nouveau_object_destroy(struct nouveau_object *);
+int  nouveau_object_init(struct nouveau_object *);
+int  nouveau_object_fini(struct nouveau_object *, bool suspend);
+
+extern struct nouveau_ofuncs nouveau_object_ofuncs;
+
+struct nouveau_oclass {
+        u32 handle;
+        struct nouveau_ofuncs *ofuncs;
+        struct nouveau_omthds *omthds;
+};
+
+#define nv_oclass(o)    nv_object(o)->oclass
+#define nv_hclass(o)    nv_oclass(o)->handle
+#define nv_iclass(o,i) (nv_hclass(o) & (i))
+#define nv_mclass(o)    nv_iclass(o, NV_OBJECT_CLASS)
+
+static inline struct nouveau_object *
+nv_pclass(struct nouveau_object *parent, u32 oclass)
+{
+        while (parent && !nv_iclass(parent, oclass))
+                parent = parent->parent;
+        return parent;
+}
+
+struct nouveau_omthds {
+        u32 method;
+        int (*call)(struct nouveau_object *, u32, void *, u32);
+};
+
+struct nouveau_ofuncs {
+        int  (*ctor)(struct nouveau_object *, struct nouveau_object *,
+                     struct nouveau_oclass *, void *data, u32 size,
+                     struct nouveau_object **);
+        void (*dtor)(struct nouveau_object *);
+        int  (*init)(struct nouveau_object *);
+        int  (*fini)(struct nouveau_object *, bool suspend);
+        u8   (*rd08)(struct nouveau_object *, u32 offset);
+        u16  (*rd16)(struct nouveau_object *, u32 offset);
+        u32  (*rd32)(struct nouveau_object *, u32 offset);
+        void (*wr08)(struct nouveau_object *, u32 offset, u8 data);
+        void (*wr16)(struct nouveau_object *, u32 offset, u16 data);
+        void (*wr32)(struct nouveau_object *, u32 offset, u32 data);
+};
+
+static inline struct nouveau_ofuncs *
+nv_ofuncs(void *obj)
+{
+        return nv_oclass(obj)->ofuncs;
+}
+
+int  nouveau_object_ctor(struct nouveau_object *, struct nouveau_object *,
+                         struct nouveau_oclass *, void *, u32,
+                         struct nouveau_object **);
+void nouveau_object_ref(struct nouveau_object *, struct nouveau_object **);
+int nouveau_object_inc(struct nouveau_object *);
+int nouveau_object_dec(struct nouveau_object *, bool suspend);
+
+int nouveau_object_new(struct nouveau_object *, u32 parent, u32 handle,
+                       u16 oclass, void *data, u32 size,
+                       struct nouveau_object **);
+int nouveau_object_del(struct nouveau_object *, u32 parent, u32 handle);
+void nouveau_object_debug(void);
+
+static inline int
+nv_call(void *obj, u32 mthd, u32 data)
+{
+        struct nouveau_omthds *method = nv_oclass(obj)->omthds;
+
+        while (method && method->call) {
+                if (method->method == mthd)
+                        return method->call(obj, mthd, &data, sizeof(data));
+                method++;
+        }
+
+        return -EINVAL;
+}
+
+static inline u8
+nv_ro08(void *obj, u32 addr)
+{
+        u8 data = nv_ofuncs(obj)->rd08(obj, addr);
+        nv_spam(obj, "nv_ro08 0x%08x 0x%02x\n", addr, data);
+        return data;
+}
+
+static inline u16
+nv_ro16(void *obj, u32 addr)
+{
+        u16 data = nv_ofuncs(obj)->rd16(obj, addr);
+        nv_spam(obj, "nv_ro16 0x%08x 0x%04x\n", addr, data);
+        return data;
+}
+
+static inline u32
+nv_ro32(void *obj, u32 addr)
+{
+        u32 data = nv_ofuncs(obj)->rd32(obj, addr);
+        nv_spam(obj, "nv_ro32 0x%08x 0x%08x\n", addr, data);
+        return data;
+}
+
+static inline void
+nv_wo08(void *obj, u32 addr, u8 data)
+{
+        nv_spam(obj, "nv_wo08 0x%08x 0x%02x\n", addr, data);
+        nv_ofuncs(obj)->wr08(obj, addr, data);
+}
+
+static inline void
+nv_wo16(void *obj, u32 addr, u16 data)
+{
+        nv_spam(obj, "nv_wo16 0x%08x 0x%04x\n", addr, data);
+        nv_ofuncs(obj)->wr16(obj, addr, data);
+}
+
+static inline void
+nv_wo32(void *obj, u32 addr, u32 data)
+{
+        nv_spam(obj, "nv_wo32 0x%08x 0x%08x\n", addr, data);
+        nv_ofuncs(obj)->wr32(obj, addr, data);
+}
+
+static inline u32
+nv_mo32(void *obj, u32 addr, u32 mask, u32 data)
+{
+        u32 temp = nv_ro32(obj, addr);
+        nv_wo32(obj, addr, (temp & ~mask) | data);
+        return temp;
+}
+
+static inline bool
+nv_strncmp(void *obj, u32 addr, u32 len, const char *str)
+{
+        while (len--) {
+                if (nv_ro08(obj, addr++) != *(str++))
+                        return false;
+        }
+        return true;
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/option.h b/drivers/gpu/drm/nouveau/core/include/core/option.h
new file mode 100644
index 000000000000..27074957fd21
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/option.h
@@ -0,0 +1,11 @@
+#ifndef __NOUVEAU_OPTION_H__
+#define __NOUVEAU_OPTION_H__
+
+#include <core/os.h>
+
+const char *nouveau_stropt(const char *optstr, const char *opt, int *len);
+bool nouveau_boolopt(const char *optstr, const char *opt, bool value);
+
+int nouveau_dbgopt(const char *optstr, const char *sub);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/parent.h b/drivers/gpu/drm/nouveau/core/include/core/parent.h
new file mode 100644
index 000000000000..d3aa251a5eb6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/parent.h
@@ -0,0 +1,64 @@
+#ifndef __NOUVEAU_PARENT_H__
+#define __NOUVEAU_PARENT_H__
+
+#include <core/device.h>
+#include <core/object.h>
+
+struct nouveau_sclass {
+        struct nouveau_sclass *sclass;
+        struct nouveau_engine *engine;
+        struct nouveau_oclass *oclass;
+};
+
+struct nouveau_parent {
+        struct nouveau_object base;
+
+        struct nouveau_sclass *sclass;
+        u32 engine;
+
+        int  (*context_attach)(struct nouveau_object *,
+                               struct nouveau_object *);
+        int  (*context_detach)(struct nouveau_object *, bool suspend,
+                               struct nouveau_object *);
+
+        int  (*object_attach)(struct nouveau_object *parent,
+                              struct nouveau_object *object, u32 name);
+        void (*object_detach)(struct nouveau_object *parent, int cookie);
+};
+
+static inline struct nouveau_parent *
+nv_parent(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!(nv_iclass(obj, NV_PARENT_CLASS))))
+                nv_assert("BAD CAST -> NvParent, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+#define nouveau_parent_create(p,e,c,v,s,m,d)                                   \
+        nouveau_parent_create_((p), (e), (c), (v), (s), (m),                   \
+                               sizeof(**d), (void **)d)
+#define nouveau_parent_init(p)                                                 \
+        nouveau_object_init(&(p)->base)
+#define nouveau_parent_fini(p,s)                                               \
+        nouveau_object_fini(&(p)->base, (s))
+
+int  nouveau_parent_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, u32 pclass,
+                            struct nouveau_oclass *, u64 engcls,
+                            int size, void **);
+void nouveau_parent_destroy(struct nouveau_parent *);
+
+int  _nouveau_parent_ctor(struct nouveau_object *, struct nouveau_object *,
+                          struct nouveau_oclass *, void *, u32,
+                          struct nouveau_object **);
+void _nouveau_parent_dtor(struct nouveau_object *);
+#define _nouveau_parent_init _nouveau_object_init
+#define _nouveau_parent_fini _nouveau_object_fini
+
+int nouveau_parent_sclass(struct nouveau_object *, u16 handle,
+                          struct nouveau_object **pengine,
+                          struct nouveau_oclass **poclass);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/printk.h b/drivers/gpu/drm/nouveau/core/include/core/printk.h
new file mode 100644
index 000000000000..1d629664f32d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/printk.h
@@ -0,0 +1,39 @@
+#ifndef __NOUVEAU_PRINTK_H__
+#define __NOUVEAU_PRINTK_H__
+
+#include <core/os.h>
+#include <core/debug.h>
+
+struct nouveau_object;
+
+#define NV_PRINTK_FATAL    KERN_CRIT
+#define NV_PRINTK_ERROR    KERN_ERR
+#define NV_PRINTK_WARN     KERN_WARNING
+#define NV_PRINTK_INFO     KERN_INFO
+#define NV_PRINTK_DEBUG    KERN_DEBUG
+#define NV_PRINTK_PARANOIA KERN_DEBUG
+#define NV_PRINTK_TRACE    KERN_DEBUG
+#define NV_PRINTK_SPAM     KERN_DEBUG
+
+void nv_printk_(struct nouveau_object *, const char *, int, const char *, ...);
+
+#define nv_printk(o,l,f,a...) do {                                             \
+        if (NV_DBG_##l <= CONFIG_NOUVEAU_DEBUG)                                \
+                nv_printk_(nv_object(o), NV_PRINTK_##l, NV_DBG_##l, f, ##a);   \
+} while(0)
+
+#define nv_fatal(o,f,a...) nv_printk((o), FATAL, f, ##a)
+#define nv_error(o,f,a...) nv_printk((o), ERROR, f, ##a)
+#define nv_warn(o,f,a...) nv_printk((o), WARN, f, ##a)
+#define nv_info(o,f,a...) nv_printk((o), INFO, f, ##a)
+#define nv_debug(o,f,a...) nv_printk((o), DEBUG, f, ##a)
+#define nv_trace(o,f,a...) nv_printk((o), TRACE, f, ##a)
+#define nv_spam(o,f,a...) nv_printk((o), SPAM, f, ##a)
+
+#define nv_assert(f,a...) do {                                                 \
+        if (NV_DBG_FATAL <= CONFIG_NOUVEAU_DEBUG)                              \
+                nv_printk_(NULL, NV_PRINTK_FATAL, NV_DBG_FATAL, f "\n", ##a);  \
+        BUG_ON(1);                                                             \
+} while(0)
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/ramht.h b/drivers/gpu/drm/nouveau/core/include/core/ramht.h
new file mode 100644
index 000000000000..47e4cacbca37
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/ramht.h
@@ -0,0 +1,23 @@
+#ifndef __NOUVEAU_RAMHT_H__
+#define __NOUVEAU_RAMHT_H__
+
+#include <core/gpuobj.h>
+
+struct nouveau_ramht {
+        struct nouveau_gpuobj base;
+        int bits;
+};
+
+int  nouveau_ramht_insert(struct nouveau_ramht *, int chid,
+                          u32 handle, u32 context);
+void nouveau_ramht_remove(struct nouveau_ramht *, int cookie);
+int  nouveau_ramht_new(struct nouveau_object *, struct nouveau_object *,
+                       u32 size, u32 align, struct nouveau_ramht **);
+
+static inline void
+nouveau_ramht_ref(struct nouveau_ramht *obj, struct nouveau_ramht **ref)
+{
+        nouveau_gpuobj_ref(&obj->base, (struct nouveau_gpuobj **)ref);
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/subdev.h b/drivers/gpu/drm/nouveau/core/include/core/subdev.h
new file mode 100644
index 000000000000..e9632e931616
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/core/subdev.h
@@ -0,0 +1,118 @@
+#ifndef __NOUVEAU_SUBDEV_H__
+#define __NOUVEAU_SUBDEV_H__
+
+#include <core/object.h>
+
+#define NV_SUBDEV_(sub,var) (NV_SUBDEV_CLASS | ((var) << 8) | (sub))
+#define NV_SUBDEV(name,var)  NV_SUBDEV_(NVDEV_SUBDEV_##name, (var))
+
+struct nouveau_subdev {
+        struct nouveau_object base;
+        struct mutex mutex;
+        const char *name;
+        void __iomem *mmio;
+        u32 debug;
+        u32 unit;
+
+        void (*intr)(struct nouveau_subdev *);
+};
+
+static inline struct nouveau_subdev *
+nv_subdev(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_SUBDEV_CLASS)))
+                nv_assert("BAD CAST -> NvSubDev, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+static inline int
+nv_subidx(struct nouveau_object *object)
+{
+        return nv_hclass(nv_subdev(object)) & 0xff;
+}
+
+#define nouveau_subdev_create(p,e,o,v,s,f,d)                                   \
+        nouveau_subdev_create_((p), (e), (o), (v), (s), (f),                   \
+                               sizeof(**d),(void **)d)
+
+int  nouveau_subdev_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, u32 pclass,
+                            const char *sname, const char *fname,
+                            int size, void **);
+void nouveau_subdev_destroy(struct nouveau_subdev *);
+int  nouveau_subdev_init(struct nouveau_subdev *);
+int  nouveau_subdev_fini(struct nouveau_subdev *, bool suspend);
+void nouveau_subdev_reset(struct nouveau_object *);
+
+void _nouveau_subdev_dtor(struct nouveau_object *);
+int  _nouveau_subdev_init(struct nouveau_object *);
+int  _nouveau_subdev_fini(struct nouveau_object *, bool suspend);
+
+#define s_printk(s,l,f,a...) do {                                              \
+        if ((s)->debug >= OS_DBG_##l) {                                        \
+                nv_printk((s)->base.parent, (s)->name, l, f, ##a);             \
+        }                                                                      \
+} while(0)
+
+static inline u8
+nv_rd08(void *obj, u32 addr)
+{
+        struct nouveau_subdev *subdev = nv_subdev(obj);
+        u8 data = ioread8(subdev->mmio + addr);
+        nv_spam(subdev, "nv_rd08 0x%06x 0x%02x\n", addr, data);
+        return data;
+}
+
+static inline u16
+nv_rd16(void *obj, u32 addr)
+{
+        struct nouveau_subdev *subdev = nv_subdev(obj);
+        u16 data = ioread16_native(subdev->mmio + addr);
+        nv_spam(subdev, "nv_rd16 0x%06x 0x%04x\n", addr, data);
+        return data;
+}
+
+static inline u32
+nv_rd32(void *obj, u32 addr)
+{
+        struct nouveau_subdev *subdev = nv_subdev(obj);
+        u32 data = ioread32_native(subdev->mmio + addr);
+        nv_spam(subdev, "nv_rd32 0x%06x 0x%08x\n", addr, data);
+        return data;
+}
+
+static inline void
+nv_wr08(void *obj, u32 addr, u8 data)
+{
+        struct nouveau_subdev *subdev = nv_subdev(obj);
+        nv_spam(subdev, "nv_wr08 0x%06x 0x%02x\n", addr, data);
+        iowrite8(data, subdev->mmio + addr);
+}
+
+static inline void
+nv_wr16(void *obj, u32 addr, u16 data)
+{
+        struct nouveau_subdev *subdev = nv_subdev(obj);
+        nv_spam(subdev, "nv_wr16 0x%06x 0x%04x\n", addr, data);
+        iowrite16_native(data, subdev->mmio + addr);
+}
+
+static inline void
+nv_wr32(void *obj, u32 addr, u32 data)
+{
+        struct nouveau_subdev *subdev = nv_subdev(obj);
+        nv_spam(subdev, "nv_wr32 0x%06x 0x%08x\n", addr, data);
+        iowrite32_native(data, subdev->mmio + addr);
+}
+
+static inline u32
+nv_mask(void *obj, u32 addr, u32 mask, u32 data)
+{
+        u32 temp = nv_rd32(obj, addr);
+        nv_wr32(obj, addr, (temp & ~mask) | data);
+        return temp;
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/bsp.h b/drivers/gpu/drm/nouveau/core/include/engine/bsp.h
new file mode 100644
index 000000000000..75d1ed5f85fd
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/bsp.h
@@ -0,0 +1,45 @@
+#ifndef __NOUVEAU_BSP_H__
+#define __NOUVEAU_BSP_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_bsp_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_bsp_context_create(p,e,c,g,s,a,f,d)                            \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_bsp_context_destroy(d)                                         \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_bsp_context_init(d)                                            \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_bsp_context_fini(d,s)                                          \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_bsp_context_dtor _nouveau_engctx_dtor
+#define _nouveau_bsp_context_init _nouveau_engctx_init
+#define _nouveau_bsp_context_fini _nouveau_engctx_fini
+#define _nouveau_bsp_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_bsp_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_bsp {
+        struct nouveau_engine base;
+};
+
+#define nouveau_bsp_create(p,e,c,d)                                            \
+        nouveau_engine_create((p), (e), (c), true, "PBSP", "bsp", (d))
+#define nouveau_bsp_destroy(d)                                                 \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_bsp_init(d)                                                    \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_bsp_fini(d,s)                                                  \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_bsp_dtor _nouveau_engine_dtor
+#define _nouveau_bsp_init _nouveau_engine_init
+#define _nouveau_bsp_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv84_bsp_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/copy.h b/drivers/gpu/drm/nouveau/core/include/engine/copy.h
new file mode 100644
index 000000000000..70b9d8c5fcf5
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/copy.h
@@ -0,0 +1,49 @@
+#ifndef __NOUVEAU_COPY_H__
+#define __NOUVEAU_COPY_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_copy_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_copy_context_create(p,e,c,g,s,a,f,d)                           \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_copy_context_destroy(d)                                        \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_copy_context_init(d)                                           \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_copy_context_fini(d,s)                                         \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_copy_context_dtor _nouveau_engctx_dtor
+#define _nouveau_copy_context_init _nouveau_engctx_init
+#define _nouveau_copy_context_fini _nouveau_engctx_fini
+#define _nouveau_copy_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_copy_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_copy {
+        struct nouveau_engine base;
+};
+
+#define nouveau_copy_create(p,e,c,y,i,d)                                       \
+        nouveau_engine_create((p), (e), (c), (y), "PCE"#i, "copy"#i, (d))
+#define nouveau_copy_destroy(d)                                                \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_copy_init(d)                                                   \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_copy_fini(d,s)                                                 \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_copy_dtor _nouveau_engine_dtor
+#define _nouveau_copy_init _nouveau_engine_init
+#define _nouveau_copy_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nva3_copy_oclass;
+extern struct nouveau_oclass nvc0_copy0_oclass;
+extern struct nouveau_oclass nvc0_copy1_oclass;
+extern struct nouveau_oclass nve0_copy0_oclass;
+extern struct nouveau_oclass nve0_copy1_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/crypt.h b/drivers/gpu/drm/nouveau/core/include/engine/crypt.h
new file mode 100644
index 000000000000..e3674743baaa
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/crypt.h
@@ -0,0 +1,46 @@
+#ifndef __NOUVEAU_CRYPT_H__
+#define __NOUVEAU_CRYPT_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_crypt_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_crypt_context_create(p,e,c,g,s,a,f,d)                          \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_crypt_context_destroy(d)                                       \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_crypt_context_init(d)                                          \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_crypt_context_fini(d,s)                                        \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_crypt_context_dtor _nouveau_engctx_dtor
+#define _nouveau_crypt_context_init _nouveau_engctx_init
+#define _nouveau_crypt_context_fini _nouveau_engctx_fini
+#define _nouveau_crypt_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_crypt_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_crypt {
+        struct nouveau_engine base;
+};
+
+#define nouveau_crypt_create(p,e,c,d)                                          \
+        nouveau_engine_create((p), (e), (c), true, "PCRYPT", "crypt", (d))
+#define nouveau_crypt_destroy(d)                                               \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_crypt_init(d)                                                  \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_crypt_fini(d,s)                                                \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_crypt_dtor _nouveau_engine_dtor
+#define _nouveau_crypt_init _nouveau_engine_init
+#define _nouveau_crypt_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv84_crypt_oclass;
+extern struct nouveau_oclass nv98_crypt_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/disp.h b/drivers/gpu/drm/nouveau/core/include/engine/disp.h
new file mode 100644
index 000000000000..38ec1252cbaa
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/disp.h
@@ -0,0 +1,44 @@
+#ifndef __NOUVEAU_DISP_H__
+#define __NOUVEAU_DISP_H__
+
+#include <core/object.h>
+#include <core/engine.h>
+#include <core/device.h>
+
+struct nouveau_disp {
+        struct nouveau_engine base;
+
+        struct {
+                struct list_head list;
+                spinlock_t lock;
+                void (*notify)(void *, int);
+                void (*get)(void *, int);
+                void (*put)(void *, int);
+                void *data;
+        } vblank;
+};
+
+static inline struct nouveau_disp *
+nouveau_disp(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_ENGINE_DISP];
+}
+
+#define nouveau_disp_create(p,e,c,i,x,d)                                       \
+        nouveau_engine_create((p), (e), (c), true, (i), (x), (d))
+#define nouveau_disp_destroy(d)                                                \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_disp_init(d)                                                   \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_disp_fini(d,s)                                                 \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_disp_dtor _nouveau_engine_dtor
+#define _nouveau_disp_init _nouveau_engine_init
+#define _nouveau_disp_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv04_disp_oclass;
+extern struct nouveau_oclass nv50_disp_oclass;
+extern struct nouveau_oclass nvd0_disp_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/dmaobj.h b/drivers/gpu/drm/nouveau/core/include/engine/dmaobj.h
new file mode 100644
index 000000000000..700ccbb1941f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/dmaobj.h
@@ -0,0 +1,57 @@
+#ifndef __NOUVEAU_DMAOBJ_H__
+#define __NOUVEAU_DMAOBJ_H__
+
+#include <core/object.h>
+#include <core/engine.h>
+
+struct nouveau_gpuobj;
+
+struct nouveau_dmaobj {
+        struct nouveau_object base;
+        u32 target;
+        u32 access;
+        u64 start;
+        u64 limit;
+};
+
+#define nouveau_dmaobj_create(p,e,c,a,s,d)                                     \
+        nouveau_dmaobj_create_((p), (e), (c), (a), (s), sizeof(**d), (void **)d)
+#define nouveau_dmaobj_destroy(p)                                              \
+        nouveau_object_destroy(&(p)->base)
+#define nouveau_dmaobj_init(p)                                                 \
+        nouveau_object_init(&(p)->base)
+#define nouveau_dmaobj_fini(p,s)                                               \
+        nouveau_object_fini(&(p)->base, (s))
+
+int nouveau_dmaobj_create_(struct nouveau_object *, struct nouveau_object *,
+                           struct nouveau_oclass *, void *data, u32 size,
+                           int length, void **);
+
+#define _nouveau_dmaobj_dtor nouveau_object_destroy
+#define _nouveau_dmaobj_init nouveau_object_init
+#define _nouveau_dmaobj_fini nouveau_object_fini
+
+struct nouveau_dmaeng {
+        struct nouveau_engine base;
+        int (*bind)(struct nouveau_dmaeng *, struct nouveau_object *parent,
+                    struct nouveau_dmaobj *, struct nouveau_gpuobj **);
+};
+
+#define nouveau_dmaeng_create(p,e,c,d)                                         \
+        nouveau_engine_create((p), (e), (c), true, "DMAOBJ", "dmaobj", (d))
+#define nouveau_dmaeng_destroy(p)                                              \
+        nouveau_engine_destroy(&(p)->base)
+#define nouveau_dmaeng_init(p)                                                 \
+        nouveau_engine_init(&(p)->base)
+#define nouveau_dmaeng_fini(p,s)                                               \
+        nouveau_engine_fini(&(p)->base, (s))
+
+#define _nouveau_dmaeng_dtor _nouveau_engine_dtor
+#define _nouveau_dmaeng_init _nouveau_engine_init
+#define _nouveau_dmaeng_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv04_dmaeng_oclass;
+extern struct nouveau_oclass nv50_dmaeng_oclass;
+extern struct nouveau_oclass nvc0_dmaeng_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/fifo.h b/drivers/gpu/drm/nouveau/core/include/engine/fifo.h
new file mode 100644
index 000000000000..d67fed1e3970
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/fifo.h
@@ -0,0 +1,111 @@
+#ifndef __NOUVEAU_FIFO_H__
+#define __NOUVEAU_FIFO_H__
+
+#include <core/namedb.h>
+#include <core/gpuobj.h>
+#include <core/engine.h>
+
+struct nouveau_fifo_chan {
+        struct nouveau_namedb base;
+        struct nouveau_dmaobj *pushdma;
+        struct nouveau_gpuobj *pushgpu;
+        void __iomem *user;
+        u32 size;
+        u16 chid;
+        atomic_t refcnt; /* NV04_NVSW_SET_REF */
+};
+
+static inline struct nouveau_fifo_chan *
+nouveau_fifo_chan(void *obj)
+{
+        return (void *)nv_namedb(obj);
+}
+
+#define nouveau_fifo_channel_create(p,e,c,b,a,s,n,m,d)                         \
+        nouveau_fifo_channel_create_((p), (e), (c), (b), (a), (s), (n),        \
+                                     (m), sizeof(**d), (void **)d)
+#define nouveau_fifo_channel_init(p)                                           \
+        nouveau_namedb_init(&(p)->base)
+#define nouveau_fifo_channel_fini(p,s)                                         \
+        nouveau_namedb_fini(&(p)->base, (s))
+
+int  nouveau_fifo_channel_create_(struct nouveau_object *,
+                                  struct nouveau_object *,
+                                  struct nouveau_oclass *,
+                                  int bar, u32 addr, u32 size, u32 push,
+                                  u32 engmask, int len, void **);
+void nouveau_fifo_channel_destroy(struct nouveau_fifo_chan *);
+
+#define _nouveau_fifo_channel_init _nouveau_namedb_init
+#define _nouveau_fifo_channel_fini _nouveau_namedb_fini
+
+void _nouveau_fifo_channel_dtor(struct nouveau_object *);
+u32  _nouveau_fifo_channel_rd32(struct nouveau_object *, u32);
+void _nouveau_fifo_channel_wr32(struct nouveau_object *, u32, u32);
+
+struct nouveau_fifo_base {
+        struct nouveau_gpuobj base;
+};
+
+#define nouveau_fifo_context_create(p,e,c,g,s,a,f,d)                           \
+        nouveau_gpuobj_create((p), (e), (c), 0, (g), (s), (a), (f), (d))
+#define nouveau_fifo_context_destroy(p)                                        \
+        nouveau_gpuobj_destroy(&(p)->base)
+#define nouveau_fifo_context_init(p)                                           \
+        nouveau_gpuobj_init(&(p)->base)
+#define nouveau_fifo_context_fini(p,s)                                         \
+        nouveau_gpuobj_fini(&(p)->base, (s))
+
+#define _nouveau_fifo_context_dtor _nouveau_gpuobj_dtor
+#define _nouveau_fifo_context_init _nouveau_gpuobj_init
+#define _nouveau_fifo_context_fini _nouveau_gpuobj_fini
+#define _nouveau_fifo_context_rd32 _nouveau_gpuobj_rd32
+#define _nouveau_fifo_context_wr32 _nouveau_gpuobj_wr32
+
+struct nouveau_fifo {
+        struct nouveau_engine base;
+
+        struct nouveau_object **channel;
+        spinlock_t lock;
+        u16 min;
+        u16 max;
+
+        int  (*chid)(struct nouveau_fifo *, struct nouveau_object *);
+        void (*pause)(struct nouveau_fifo *, unsigned long *);
+        void (*start)(struct nouveau_fifo *, unsigned long *);
+};
+
+static inline struct nouveau_fifo *
+nouveau_fifo(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_ENGINE_FIFO];
+}
+
+#define nouveau_fifo_create(o,e,c,fc,lc,d)                                     \
+        nouveau_fifo_create_((o), (e), (c), (fc), (lc), sizeof(**d), (void **)d)
+#define nouveau_fifo_init(p)                                                   \
+        nouveau_engine_init(&(p)->base)
+#define nouveau_fifo_fini(p,s)                                                 \
+        nouveau_engine_fini(&(p)->base, (s))
+
+int nouveau_fifo_create_(struct nouveau_object *, struct nouveau_object *,
+                         struct nouveau_oclass *, int min, int max,
+                         int size, void **);
+void nouveau_fifo_destroy(struct nouveau_fifo *);
+
+#define _nouveau_fifo_init _nouveau_engine_init
+#define _nouveau_fifo_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv04_fifo_oclass;
+extern struct nouveau_oclass nv10_fifo_oclass;
+extern struct nouveau_oclass nv17_fifo_oclass;
+extern struct nouveau_oclass nv40_fifo_oclass;
+extern struct nouveau_oclass nv50_fifo_oclass;
+extern struct nouveau_oclass nv84_fifo_oclass;
+extern struct nouveau_oclass nvc0_fifo_oclass;
+extern struct nouveau_oclass nve0_fifo_oclass;
+
+void nv04_fifo_intr(struct nouveau_subdev *);
+int  nv04_fifo_context_attach(struct nouveau_object *, struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/graph.h b/drivers/gpu/drm/nouveau/core/include/engine/graph.h
new file mode 100644
index 000000000000..6943b40d0817
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/graph.h
@@ -0,0 +1,72 @@
+#ifndef __NOUVEAU_GRAPH_H__
+#define __NOUVEAU_GRAPH_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+#include <core/enum.h>
+
+struct nouveau_graph_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_graph_context_create(p,e,c,g,s,a,f,d)                          \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_graph_context_destroy(d)                                       \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_graph_context_init(d)                                          \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_graph_context_fini(d,s)                                        \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_graph_context_dtor _nouveau_engctx_dtor
+#define _nouveau_graph_context_init _nouveau_engctx_init
+#define _nouveau_graph_context_fini _nouveau_engctx_fini
+#define _nouveau_graph_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_graph_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_graph {
+        struct nouveau_engine base;
+};
+
+static inline struct nouveau_graph *
+nouveau_graph(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_ENGINE_GR];
+}
+
+#define nouveau_graph_create(p,e,c,y,d)                                        \
+        nouveau_engine_create((p), (e), (c), (y), "PGRAPH", "graphics", (d))
+#define nouveau_graph_destroy(d)                                               \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_graph_init(d)                                                  \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_graph_fini(d,s)                                                \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_graph_dtor _nouveau_engine_dtor
+#define _nouveau_graph_init _nouveau_engine_init
+#define _nouveau_graph_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv04_graph_oclass;
+extern struct nouveau_oclass nv10_graph_oclass;
+extern struct nouveau_oclass nv20_graph_oclass;
+extern struct nouveau_oclass nv25_graph_oclass;
+extern struct nouveau_oclass nv2a_graph_oclass;
+extern struct nouveau_oclass nv30_graph_oclass;
+extern struct nouveau_oclass nv34_graph_oclass;
+extern struct nouveau_oclass nv35_graph_oclass;
+extern struct nouveau_oclass nv40_graph_oclass;
+extern struct nouveau_oclass nv50_graph_oclass;
+extern struct nouveau_oclass nvc0_graph_oclass;
+extern struct nouveau_oclass nve0_graph_oclass;
+
+extern const struct nouveau_bitfield nv04_graph_nsource[];
+extern struct nouveau_ofuncs nv04_graph_ofuncs;
+bool nv04_graph_idle(void *obj);
+
+extern const struct nouveau_bitfield nv10_graph_intr_name[];
+extern const struct nouveau_bitfield nv10_graph_nstatus[];
+
+extern const struct nouveau_enum nv50_data_error_names[];
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/mpeg.h b/drivers/gpu/drm/nouveau/core/include/engine/mpeg.h
new file mode 100644
index 000000000000..bbf0d4a5bbd7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/mpeg.h
@@ -0,0 +1,61 @@
+#ifndef __NOUVEAU_MPEG_H__
+#define __NOUVEAU_MPEG_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_mpeg_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_mpeg_context_create(p,e,c,g,s,a,f,d)                           \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_mpeg_context_destroy(d)                                        \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_mpeg_context_init(d)                                           \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_mpeg_context_fini(d,s)                                         \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_mpeg_context_dtor _nouveau_engctx_dtor
+#define _nouveau_mpeg_context_init _nouveau_engctx_init
+#define _nouveau_mpeg_context_fini _nouveau_engctx_fini
+#define _nouveau_mpeg_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_mpeg_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_mpeg {
+        struct nouveau_engine base;
+};
+
+#define nouveau_mpeg_create(p,e,c,d)                                           \
+        nouveau_engine_create((p), (e), (c), true, "PMPEG", "mpeg", (d))
+#define nouveau_mpeg_destroy(d)                                                \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_mpeg_init(d)                                                   \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_mpeg_fini(d,s)                                                 \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_mpeg_dtor _nouveau_engine_dtor
+#define _nouveau_mpeg_init _nouveau_engine_init
+#define _nouveau_mpeg_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv31_mpeg_oclass;
+extern struct nouveau_oclass nv40_mpeg_oclass;
+extern struct nouveau_oclass nv50_mpeg_oclass;
+extern struct nouveau_oclass nv84_mpeg_oclass;
+
+extern struct nouveau_oclass nv31_mpeg_sclass[];
+void nv31_mpeg_intr(struct nouveau_subdev *);
+void nv31_mpeg_tile_prog(struct nouveau_engine *, int);
+int  nv31_mpeg_init(struct nouveau_object *);
+
+extern struct nouveau_ofuncs nv50_mpeg_ofuncs;
+int  nv50_mpeg_context_ctor(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, void *, u32,
+                            struct nouveau_object **);
+int  nv50_mpeg_tlb_flush(struct nouveau_engine *);
+void nv50_mpeg_intr(struct nouveau_subdev *);
+int  nv50_mpeg_init(struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/ppp.h b/drivers/gpu/drm/nouveau/core/include/engine/ppp.h
new file mode 100644
index 000000000000..74d554fb3281
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/ppp.h
@@ -0,0 +1,45 @@
+#ifndef __NOUVEAU_PPP_H__
+#define __NOUVEAU_PPP_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_ppp_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_ppp_context_create(p,e,c,g,s,a,f,d)                            \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_ppp_context_destroy(d)                                         \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_ppp_context_init(d)                                            \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_ppp_context_fini(d,s)                                          \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_ppp_context_dtor _nouveau_engctx_dtor
+#define _nouveau_ppp_context_init _nouveau_engctx_init
+#define _nouveau_ppp_context_fini _nouveau_engctx_fini
+#define _nouveau_ppp_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_ppp_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_ppp {
+        struct nouveau_engine base;
+};
+
+#define nouveau_ppp_create(p,e,c,d)                                            \
+        nouveau_engine_create((p), (e), (c), true, "PPPP", "ppp", (d))
+#define nouveau_ppp_destroy(d)                                                 \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_ppp_init(d)                                                    \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_ppp_fini(d,s)                                                  \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_ppp_dtor _nouveau_engine_dtor
+#define _nouveau_ppp_init _nouveau_engine_init
+#define _nouveau_ppp_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv98_ppp_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/software.h b/drivers/gpu/drm/nouveau/core/include/engine/software.h
new file mode 100644
index 000000000000..c945691c8564
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/software.h
@@ -0,0 +1,60 @@
+#ifndef __NOUVEAU_SOFTWARE_H__
+#define __NOUVEAU_SOFTWARE_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_software_chan {
+        struct nouveau_engctx base;
+
+        struct {
+                struct list_head head;
+                u32 channel;
+                u32 ctxdma;
+                u64 offset;
+                u32 value;
+                u32 crtc;
+        } vblank;
+
+        int (*flip)(void *);
+        void *flip_data;
+};
+
+#define nouveau_software_context_create(p,e,c,d)                               \
+        nouveau_engctx_create((p), (e), (c), (p), 0, 0, 0, (d))
+#define nouveau_software_context_destroy(d)                                    \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_software_context_init(d)                                       \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_software_context_fini(d,s)                                     \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_software_context_dtor _nouveau_engctx_dtor
+#define _nouveau_software_context_init _nouveau_engctx_init
+#define _nouveau_software_context_fini _nouveau_engctx_fini
+
+struct nouveau_software {
+        struct nouveau_engine base;
+};
+
+#define nouveau_software_create(p,e,c,d)                                       \
+        nouveau_engine_create((p), (e), (c), true, "SW", "software", (d))
+#define nouveau_software_destroy(d)                                            \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_software_init(d)                                               \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_software_fini(d,s)                                             \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_software_dtor _nouveau_engine_dtor
+#define _nouveau_software_init _nouveau_engine_init
+#define _nouveau_software_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv04_software_oclass;
+extern struct nouveau_oclass nv10_software_oclass;
+extern struct nouveau_oclass nv50_software_oclass;
+extern struct nouveau_oclass nvc0_software_oclass;
+
+void nv04_software_intr(struct nouveau_subdev *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/engine/vp.h b/drivers/gpu/drm/nouveau/core/include/engine/vp.h
new file mode 100644
index 000000000000..05cd08fba377
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/engine/vp.h
@@ -0,0 +1,45 @@
+#ifndef __NOUVEAU_VP_H__
+#define __NOUVEAU_VP_H__
+
+#include <core/engine.h>
+#include <core/engctx.h>
+
+struct nouveau_vp_chan {
+        struct nouveau_engctx base;
+};
+
+#define nouveau_vp_context_create(p,e,c,g,s,a,f,d)                             \
+        nouveau_engctx_create((p), (e), (c), (g), (s), (a), (f), (d))
+#define nouveau_vp_context_destroy(d)                                          \
+        nouveau_engctx_destroy(&(d)->base)
+#define nouveau_vp_context_init(d)                                             \
+        nouveau_engctx_init(&(d)->base)
+#define nouveau_vp_context_fini(d,s)                                           \
+        nouveau_engctx_fini(&(d)->base, (s))
+
+#define _nouveau_vp_context_dtor _nouveau_engctx_dtor
+#define _nouveau_vp_context_init _nouveau_engctx_init
+#define _nouveau_vp_context_fini _nouveau_engctx_fini
+#define _nouveau_vp_context_rd32 _nouveau_engctx_rd32
+#define _nouveau_vp_context_wr32 _nouveau_engctx_wr32
+
+struct nouveau_vp {
+        struct nouveau_engine base;
+};
+
+#define nouveau_vp_create(p,e,c,d)                                             \
+        nouveau_engine_create((p), (e), (c), true, "PVP", "vp", (d))
+#define nouveau_vp_destroy(d)                                                  \
+        nouveau_engine_destroy(&(d)->base)
+#define nouveau_vp_init(d)                                                     \
+        nouveau_engine_init(&(d)->base)
+#define nouveau_vp_fini(d,s)                                                   \
+        nouveau_engine_fini(&(d)->base, (s))
+
+#define _nouveau_vp_dtor _nouveau_engine_dtor
+#define _nouveau_vp_init _nouveau_engine_init
+#define _nouveau_vp_fini _nouveau_engine_fini
+
+extern struct nouveau_oclass nv84_vp_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bar.h b/drivers/gpu/drm/nouveau/core/include/subdev/bar.h
new file mode 100644
index 000000000000..4f4ff4502c3d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bar.h
@@ -0,0 +1,55 @@
+#ifndef __NOUVEAU_BAR_H__
+#define __NOUVEAU_BAR_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+#include <subdev/fb.h>
+
+struct nouveau_vma;
+
+struct nouveau_bar {
+        struct nouveau_subdev base;
+
+        int (*alloc)(struct nouveau_bar *, struct nouveau_object *,
+                     struct nouveau_mem *, struct nouveau_object **);
+        void __iomem *iomem;
+
+        int (*kmap)(struct nouveau_bar *, struct nouveau_mem *,
+                    u32 flags, struct nouveau_vma *);
+        int (*umap)(struct nouveau_bar *, struct nouveau_mem *,
+                    u32 flags, struct nouveau_vma *);
+        void (*unmap)(struct nouveau_bar *, struct nouveau_vma *);
+        void (*flush)(struct nouveau_bar *);
+};
+
+static inline struct nouveau_bar *
+nouveau_bar(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_BAR];
+}
+
+#define nouveau_bar_create(p,e,o,d)                                            \
+        nouveau_bar_create_((p), (e), (o), sizeof(**d), (void **)d)
+#define nouveau_bar_init(p)                                                    \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_bar_fini(p,s)                                                  \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+int nouveau_bar_create_(struct nouveau_object *, struct nouveau_object *,
+                        struct nouveau_oclass *, int, void **);
+void nouveau_bar_destroy(struct nouveau_bar *);
+
+void _nouveau_bar_dtor(struct nouveau_object *);
+#define _nouveau_bar_init _nouveau_subdev_init
+#define _nouveau_bar_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nv50_bar_oclass;
+extern struct nouveau_oclass nvc0_bar_oclass;
+
+int nouveau_bar_alloc(struct nouveau_bar *, struct nouveau_object *,
+                      struct nouveau_mem *, struct nouveau_object **);
+
+void nv84_bar_flush(struct nouveau_bar *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios.h
new file mode 100644
index 000000000000..d145b25e6be4
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios.h
@@ -0,0 +1,34 @@
+#ifndef __NOUVEAU_BIOS_H__
+#define __NOUVEAU_BIOS_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+struct nouveau_bios {
+        struct nouveau_subdev base;
+        u32 size;
+        u8 *data;
+
+        u32 bmp_offset;
+        u32 bit_offset;
+
+        struct {
+                u8 major;
+                u8 chip;
+                u8 minor;
+                u8 micro;
+        } version;
+};
+
+static inline struct nouveau_bios *
+nouveau_bios(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_VBIOS];
+}
+
+u8  nvbios_checksum(const u8 *data, int size);
+u16 nvbios_findstr(const u8 *data, int size, const char *str, int len);
+
+extern struct nouveau_oclass nouveau_bios_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/bit.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/bit.h
new file mode 100644
index 000000000000..73f060b07981
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/bit.h
@@ -0,0 +1,13 @@
+#ifndef __NVBIOS_BIT_H__
+#define __NVBIOS_BIT_H__
+
+struct bit_entry {
+        u8  id;
+        u8  version;
+        u16 length;
+        u16 offset;
+};
+
+int bit_entry(struct nouveau_bios *, u8 id, struct bit_entry *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/bmp.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/bmp.h
new file mode 100644
index 000000000000..10e4dbca649a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/bmp.h
@@ -0,0 +1,39 @@
+#ifndef __NVBIOS_BMP_H__
+#define __NVBIOS_BMP_H__
+
+static inline u16
+bmp_version(struct nouveau_bios *bios)
+{
+        if (bios->bmp_offset) {
+                return nv_ro08(bios, bios->bmp_offset + 5) << 8 |
+                       nv_ro08(bios, bios->bmp_offset + 6);
+        }
+
+        return 0x0000;
+}
+
+static inline u16
+bmp_mem_init_table(struct nouveau_bios *bios)
+{
+        if (bmp_version(bios) >= 0x0300)
+                return nv_ro16(bios, bios->bmp_offset + 24);
+        return 0x0000;
+}
+
+static inline u16
+bmp_sdr_seq_table(struct nouveau_bios *bios)
+{
+        if (bmp_version(bios) >= 0x0300)
+                return nv_ro16(bios, bios->bmp_offset + 26);
+        return 0x0000;
+}
+
+static inline u16
+bmp_ddr_seq_table(struct nouveau_bios *bios)
+{
+        if (bmp_version(bios) >= 0x0300)
+                return nv_ro16(bios, bios->bmp_offset + 28);
+        return 0x0000;
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/conn.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/conn.h
new file mode 100644
index 000000000000..c1270548fd0d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/conn.h
@@ -0,0 +1,27 @@
+#ifndef __NVBIOS_CONN_H__
+#define __NVBIOS_CONN_H__
+
+enum dcb_connector_type {
+        DCB_CONNECTOR_VGA = 0x00,
+        DCB_CONNECTOR_TV_0 = 0x10,
+        DCB_CONNECTOR_TV_1 = 0x11,
+        DCB_CONNECTOR_TV_3 = 0x13,
+        DCB_CONNECTOR_DVI_I = 0x30,
+        DCB_CONNECTOR_DVI_D = 0x31,
+        DCB_CONNECTOR_DMS59_0 = 0x38,
+        DCB_CONNECTOR_DMS59_1 = 0x39,
+        DCB_CONNECTOR_LVDS = 0x40,
+        DCB_CONNECTOR_LVDS_SPWG = 0x41,
+        DCB_CONNECTOR_DP = 0x46,
+        DCB_CONNECTOR_eDP = 0x47,
+        DCB_CONNECTOR_HDMI_0 = 0x60,
+        DCB_CONNECTOR_HDMI_1 = 0x61,
+        DCB_CONNECTOR_DMS59_DP0 = 0x64,
+        DCB_CONNECTOR_DMS59_DP1 = 0x65,
+        DCB_CONNECTOR_NONE = 0xff
+};
+
+u16 dcb_conntab(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len);
+u16 dcb_conn(struct nouveau_bios *bios, u8 idx, u8 *ver, u8 *len);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/dcb.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/dcb.h
new file mode 100644
index 000000000000..d682fb625833
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/dcb.h
@@ -0,0 +1,90 @@
+#ifndef __NVBIOS_DCB_H__
+#define __NVBIOS_DCB_H__
+
+struct nouveau_bios;
+
+enum dcb_output_type {
+        DCB_OUTPUT_ANALOG       = 0x0,
+        DCB_OUTPUT_TV           = 0x1,
+        DCB_OUTPUT_TMDS         = 0x2,
+        DCB_OUTPUT_LVDS         = 0x3,
+        DCB_OUTPUT_DP           = 0x6,
+        DCB_OUTPUT_EOL          = 0xe,
+        DCB_OUTPUT_UNUSED       = 0xf,
+        DCB_OUTPUT_ANY = -1,
+};
+
+struct dcb_output {
+        int index;      /* may not be raw dcb index if merging has happened */
+        enum dcb_output_type type;
+        uint8_t i2c_index;
+        uint8_t heads;
+        uint8_t connector;
+        uint8_t bus;
+        uint8_t location;
+        uint8_t or;
+        bool duallink_possible;
+        union {
+                struct sor_conf {
+                        int link;
+                } sorconf;
+                struct {
+                        int maxfreq;
+                } crtconf;
+                struct {
+                        struct sor_conf sor;
+                        bool use_straps_for_mode;
+                        bool use_acpi_for_edid;
+                        bool use_power_scripts;
+                } lvdsconf;
+                struct {
+                        bool has_component_output;
+                } tvconf;
+                struct {
+                        struct sor_conf sor;
+                        int link_nr;
+                        int link_bw;
+                } dpconf;
+                struct {
+                        struct sor_conf sor;
+                        int slave_addr;
+                } tmdsconf;
+        };
+        bool i2c_upper_default;
+};
+
+u16 dcb_table(struct nouveau_bios *, u8 *ver, u8 *hdr, u8 *ent, u8 *len);
+u16 dcb_outp(struct nouveau_bios *, u8 idx, u8 *ver, u8 *len);
+int dcb_outp_foreach(struct nouveau_bios *, void *data, int (*exec)
+                     (struct nouveau_bios *, void *, int index, u16 entry));
+
+
+/* BIT 'U'/'d' table encoder subtables have hashes matching them to
+ * a particular set of encoders.
+ *
+ * This function returns true if a particular DCB entry matches.
+ */
+static inline bool
+dcb_hash_match(struct dcb_output *dcb, u32 hash)
+{
+        if ((hash & 0x000000f0) != (dcb->location << 4))
+                return false;
+        if ((hash & 0x0000000f) != dcb->type)
+                return false;
+        if (!(hash & (dcb->or << 16)))
+                return false;
+
+        switch (dcb->type) {
+        case DCB_OUTPUT_TMDS:
+        case DCB_OUTPUT_LVDS:
+        case DCB_OUTPUT_DP:
+                if (hash & 0x00c00000) {
+                        if (!(hash & (dcb->sorconf.link << 22)))
+                                return false;
+                }
+        default:
+                return true;
+        }
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/dp.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/dp.h
new file mode 100644
index 000000000000..73b5e5d3e75a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/dp.h
@@ -0,0 +1,8 @@
+#ifndef __NVBIOS_DP_H__
+#define __NVBIOS_DP_H__
+
+u16 dp_table(struct nouveau_bios *, u8 *ver, u8 *hdr, u8 *cnt, u8 *len);
+u16 dp_outp(struct nouveau_bios *, u8 idx, u8 *ver, u8 *len);
+u16 dp_outp_match(struct nouveau_bios *, struct dcb_output *, u8 *ver, u8 *len);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/extdev.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/extdev.h
new file mode 100644
index 000000000000..949fee3af8fb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/extdev.h
@@ -0,0 +1,30 @@
+#ifndef __NVBIOS_EXTDEV_H__
+#define __NVBIOS_EXTDEV_H__
+
+struct nouveau_bios;
+
+enum nvbios_extdev_type {
+        NVBIOS_EXTDEV_LM89              = 0x02,
+        NVBIOS_EXTDEV_VT1103M           = 0x40,
+        NVBIOS_EXTDEV_PX3540            = 0x41,
+        NVBIOS_EXTDEV_VT1105M           = 0x42, /* or close enough... */
+        NVBIOS_EXTDEV_ADT7473           = 0x70, /* can also be a LM64 */
+        NVBIOS_EXTDEV_HDCP_EEPROM       = 0x90,
+        NVBIOS_EXTDEV_NONE              = 0xff,
+};
+
+struct nvbios_extdev_func {
+        u8 type;
+        u8 addr;
+        u8 bus;
+};
+
+int
+nvbios_extdev_parse(struct nouveau_bios *, int, struct nvbios_extdev_func *);
+
+int
+nvbios_extdev_find(struct nouveau_bios *, enum nvbios_extdev_type,
+                   struct nvbios_extdev_func *);
+
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/gpio.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/gpio.h
new file mode 100644
index 000000000000..2bf178082a36
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/gpio.h
@@ -0,0 +1,33 @@
+#ifndef __NVBIOS_GPIO_H__
+#define __NVBIOS_GPIO_H__
+
+struct nouveau_bios;
+
+enum dcb_gpio_func_name {
+        DCB_GPIO_PANEL_POWER = 0x01,
+        DCB_GPIO_TVDAC0 = 0x0c,
+        DCB_GPIO_TVDAC1 = 0x2d,
+        DCB_GPIO_PWM_FAN = 0x09,
+        DCB_GPIO_FAN_SENSE = 0x3d,
+        DCB_GPIO_UNUSED = 0xff
+};
+
+struct dcb_gpio_func {
+        u8 func;
+        u8 line;
+        u8 log[2];
+
+        /* so far, "param" seems to only have an influence on PWM-related
+         * GPIOs such as FAN_CONTROL and PANEL_BACKLIGHT_LEVEL.
+         * if param equals 1, hardware PWM is available
+         * if param equals 0, the host should toggle the GPIO itself
+         */
+        u8 param;
+};
+
+u16 dcb_gpio_table(struct nouveau_bios *);
+u16 dcb_gpio_entry(struct nouveau_bios *, int idx, int ent, u8 *ver);
+int dcb_gpio_parse(struct nouveau_bios *, int idx, u8 func, u8 line,
+                   struct dcb_gpio_func *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/i2c.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/i2c.h
new file mode 100644
index 000000000000..5079bedfd985
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/i2c.h
@@ -0,0 +1,25 @@
+#ifndef __NVBIOS_I2C_H__
+#define __NVBIOS_I2C_H__
+
+struct nouveau_bios;
+
+enum dcb_i2c_type {
+        DCB_I2C_NV04_BIT = 0,
+        DCB_I2C_NV4E_BIT = 4,
+        DCB_I2C_NVIO_BIT = 5,
+        DCB_I2C_NVIO_AUX = 6,
+        DCB_I2C_UNUSED = 0xff
+};
+
+struct dcb_i2c_entry {
+        enum dcb_i2c_type type;
+        u8 drive;
+        u8 sense;
+        u32 data;
+};
+
+u16 dcb_i2c_table(struct nouveau_bios *, u8 *ver, u8 *hdr, u8 *cnt, u8 *len);
+u16 dcb_i2c_entry(struct nouveau_bios *, u8 index, u8 *ver, u8 *len);
+int dcb_i2c_parse(struct nouveau_bios *, u8 index, struct dcb_i2c_entry *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/init.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/init.h
new file mode 100644
index 000000000000..e69a8bdc6e97
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/init.h
@@ -0,0 +1,21 @@
+#ifndef __NVBIOS_INIT_H__
+#define __NVBIOS_INIT_H__
+
+struct nvbios_init {
+        struct nouveau_subdev *subdev;
+        struct nouveau_bios *bios;
+        u16 offset;
+        struct dcb_output *outp;
+        int crtc;
+
+        /* internal state used during parsing */
+        u8 execute;
+        u32 nested;
+        u16 repeat;
+        u16 repend;
+};
+
+int nvbios_exec(struct nvbios_init *);
+int nvbios_init(struct nouveau_subdev *, bool execute);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/mxm.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/mxm.h
new file mode 100644
index 000000000000..5572e60414e8
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/mxm.h
@@ -0,0 +1,9 @@
+#ifndef __NVBIOS_MXM_H__
+#define __NVBIOS_MXM_H__
+
+u16 mxm_table(struct nouveau_bios *, u8 *ver, u8 *hdr);
+
+u8  mxm_sor_map(struct nouveau_bios *, u8 conn);
+u8  mxm_ddc_map(struct nouveau_bios *, u8 port);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/perf.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/perf.h
new file mode 100644
index 000000000000..0b285e99be5a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/perf.h
@@ -0,0 +1,14 @@
+#ifndef __NVBIOS_PERF_H__
+#define __NVBIOS_PERF_H__
+
+struct nouveau_bios;
+
+struct nvbios_perf_fan {
+        u32 pwm_divisor;
+};
+
+int
+nvbios_perf_fan_parse(struct nouveau_bios *, struct nvbios_perf_fan *);
+
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/pll.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/pll.h
new file mode 100644
index 000000000000..c345097592f2
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/pll.h
@@ -0,0 +1,77 @@
+#ifndef __NVBIOS_PLL_H__
+#define __NVBIOS_PLL_H__
+
+/*XXX: kill me */
+struct nouveau_pll_vals {
+        union {
+                struct {
+#ifdef __BIG_ENDIAN
+                        uint8_t N1, M1, N2, M2;
+#else
+                        uint8_t M1, N1, M2, N2;
+#endif
+                };
+                struct {
+                        uint16_t NM1, NM2;
+                } __attribute__((packed));
+        };
+        int log2P;
+
+        int refclk;
+};
+
+struct nouveau_bios;
+
+/* these match types in pll limits table version 0x40,
+ * nouveau uses them on all chipsets internally where a
+ * specific pll needs to be referenced, but the exact
+ * register isn't known.
+ */
+enum nvbios_pll_type {
+        PLL_CORE   = 0x01,
+        PLL_SHADER = 0x02,
+        PLL_UNK03  = 0x03,
+        PLL_MEMORY = 0x04,
+        PLL_VDEC   = 0x05,
+        PLL_UNK40  = 0x40,
+        PLL_UNK41  = 0x41,
+        PLL_UNK42  = 0x42,
+        PLL_VPLL0  = 0x80,
+        PLL_VPLL1  = 0x81,
+        PLL_MAX    = 0xff
+};
+
+struct nvbios_pll {
+        enum nvbios_pll_type type;
+        u32 reg;
+        u32 refclk;
+
+        u8 min_p;
+        u8 max_p;
+        u8 bias_p;
+
+        /*
+         * for most pre nv50 cards setting a log2P of 7 (the common max_log2p
+         * value) is no different to 6 (at least for vplls) so allowing the MNP
+         * calc to use 7 causes the generated clock to be out by a factor of 2.
+         * however, max_log2p cannot be fixed-up during parsing as the
+         * unmodified max_log2p value is still needed for setting mplls, hence
+         * an additional max_usable_log2p member
+         */
+        u8 max_p_usable;
+
+        struct {
+                u32 min_freq;
+                u32 max_freq;
+                u32 min_inputfreq;
+                u32 max_inputfreq;
+                u8  min_m;
+                u8  max_m;
+                u8  min_n;
+                u8  max_n;
+        } vco1, vco2;
+};
+
+int nvbios_pll_parse(struct nouveau_bios *, u32 type, struct nvbios_pll *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/bios/therm.h b/drivers/gpu/drm/nouveau/core/include/subdev/bios/therm.h
new file mode 100644
index 000000000000..a2c4296fc5f6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/bios/therm.h
@@ -0,0 +1,46 @@
+#ifndef __NVBIOS_THERM_H__
+#define __NVBIOS_THERM_H__
+
+struct nouveau_bios;
+
+struct nvbios_therm_threshold {
+        u8 temp;
+        u8 hysteresis;
+};
+
+struct nvbios_therm_sensor {
+        /* diode */
+        s16 slope_mult;
+        s16 slope_div;
+        s16 offset_num;
+        s16 offset_den;
+        s8 offset_constant;
+
+        /* thresholds */
+        struct nvbios_therm_threshold thrs_fan_boost;
+        struct nvbios_therm_threshold thrs_down_clock;
+        struct nvbios_therm_threshold thrs_critical;
+        struct nvbios_therm_threshold thrs_shutdown;
+};
+
+struct nvbios_therm_fan {
+        u16 pwm_freq;
+
+        u8 min_duty;
+        u8 max_duty;
+};
+
+enum nvbios_therm_domain {
+        NVBIOS_THERM_DOMAIN_CORE,
+        NVBIOS_THERM_DOMAIN_AMBIENT,
+};
+
+int
+nvbios_therm_sensor_parse(struct nouveau_bios *, enum nvbios_therm_domain,
+                          struct nvbios_therm_sensor *);
+
+int
+nvbios_therm_fan_parse(struct nouveau_bios *, struct nvbios_therm_fan *);
+
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/clock.h b/drivers/gpu/drm/nouveau/core/include/subdev/clock.h
new file mode 100644
index 000000000000..39e73b91d360
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/clock.h
@@ -0,0 +1,59 @@
+#ifndef __NOUVEAU_CLOCK_H__
+#define __NOUVEAU_CLOCK_H__
+
+#include <core/device.h>
+#include <core/subdev.h>
+
+struct nouveau_pll_vals;
+struct nvbios_pll;
+
+struct nouveau_clock {
+        struct nouveau_subdev base;
+
+        int (*pll_set)(struct nouveau_clock *, u32 type, u32 freq);
+
+        /*XXX: die, these are here *only* to support the completely
+         *     bat-shit insane what-was-nouveau_hw.c code
+         */
+        int (*pll_calc)(struct nouveau_clock *, struct nvbios_pll *,
+                        int clk, struct nouveau_pll_vals *pv);
+        int (*pll_prog)(struct nouveau_clock *, u32 reg1,
+                        struct nouveau_pll_vals *pv);
+};
+
+static inline struct nouveau_clock *
+nouveau_clock(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_CLOCK];
+}
+
+#define nouveau_clock_create(p,e,o,d)                                          \
+        nouveau_subdev_create((p), (e), (o), 0, "CLOCK", "clock", d)
+#define nouveau_clock_destroy(p)                                               \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_clock_init(p)                                                  \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_clock_fini(p,s)                                                \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+int  nouveau_clock_create_(struct nouveau_object *, struct nouveau_object *,
+                           struct nouveau_oclass *, void *, u32, int, void **);
+
+#define _nouveau_clock_dtor _nouveau_subdev_dtor
+#define _nouveau_clock_init _nouveau_subdev_init
+#define _nouveau_clock_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nv04_clock_oclass;
+extern struct nouveau_oclass nv40_clock_oclass;
+extern struct nouveau_oclass nv50_clock_oclass;
+extern struct nouveau_oclass nva3_clock_oclass;
+extern struct nouveau_oclass nvc0_clock_oclass;
+
+int nv04_clock_pll_set(struct nouveau_clock *, u32 type, u32 freq);
+int nv04_clock_pll_calc(struct nouveau_clock *, struct nvbios_pll *,
+                        int clk, struct nouveau_pll_vals *);
+int nv04_clock_pll_prog(struct nouveau_clock *, u32 reg1,
+                        struct nouveau_pll_vals *);
+
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/device.h b/drivers/gpu/drm/nouveau/core/include/subdev/device.h
new file mode 100644
index 000000000000..c9e4c4afa50e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/device.h
@@ -0,0 +1,24 @@
+#ifndef __NOUVEAU_SUBDEV_DEVICE_H__
+#define __NOUVEAU_SUBDEV_DEVICE_H__
+
+#include <core/device.h>
+
+#define nouveau_device_create(p,n,s,c,d,u)                                     \
+        nouveau_device_create_((p), (n), (s), (c), (d), sizeof(**u), (void **)u)
+
+int  nouveau_device_create_(struct pci_dev *, u64 name, const char *sname,
+                            const char *cfg, const char *dbg, int, void **);
+
+int nv04_identify(struct nouveau_device *);
+int nv10_identify(struct nouveau_device *);
+int nv20_identify(struct nouveau_device *);
+int nv30_identify(struct nouveau_device *);
+int nv40_identify(struct nouveau_device *);
+int nv50_identify(struct nouveau_device *);
+int nvc0_identify(struct nouveau_device *);
+int nve0_identify(struct nouveau_device *);
+
+extern struct nouveau_oclass nouveau_device_sclass[];
+struct nouveau_device *nouveau_device_find(u64 name);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/devinit.h b/drivers/gpu/drm/nouveau/core/include/subdev/devinit.h
new file mode 100644
index 000000000000..29e4cc1f6cc0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/devinit.h
@@ -0,0 +1,40 @@
+#ifndef __NOUVEAU_DEVINIT_H__
+#define __NOUVEAU_DEVINIT_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+struct nouveau_devinit {
+        struct nouveau_subdev base;
+        bool post;
+        void (*meminit)(struct nouveau_devinit *);
+};
+
+static inline struct nouveau_devinit *
+nouveau_devinit(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_DEVINIT];
+}
+
+#define nouveau_devinit_create(p,e,o,d)                                        \
+        nouveau_devinit_create_((p), (e), (o), sizeof(**d), (void **)d)
+#define nouveau_devinit_destroy(p)                                             \
+        nouveau_subdev_destroy(&(p)->base)
+
+int nouveau_devinit_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, int, void **);
+int nouveau_devinit_init(struct nouveau_devinit *);
+int nouveau_devinit_fini(struct nouveau_devinit *, bool suspend);
+
+extern struct nouveau_oclass nv04_devinit_oclass;
+extern struct nouveau_oclass nv05_devinit_oclass;
+extern struct nouveau_oclass nv10_devinit_oclass;
+extern struct nouveau_oclass nv1a_devinit_oclass;
+extern struct nouveau_oclass nv20_devinit_oclass;
+extern struct nouveau_oclass nv50_devinit_oclass;
+
+void nv04_devinit_dtor(struct nouveau_object *);
+int  nv04_devinit_init(struct nouveau_object *);
+int  nv04_devinit_fini(struct nouveau_object *, bool);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/fb.h b/drivers/gpu/drm/nouveau/core/include/subdev/fb.h
new file mode 100644
index 000000000000..5c1b5e1904f9
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/fb.h
@@ -0,0 +1,134 @@
+#ifndef __NOUVEAU_FB_H__
+#define __NOUVEAU_FB_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+#include <core/mm.h>
+
+#include <subdev/vm.h>
+
+/* memory type/access flags, do not match hardware values */
+#define NV_MEM_ACCESS_RO  1
+#define NV_MEM_ACCESS_WO  2
+#define NV_MEM_ACCESS_RW (NV_MEM_ACCESS_RO | NV_MEM_ACCESS_WO)
+#define NV_MEM_ACCESS_SYS 4
+#define NV_MEM_ACCESS_VM  8
+#define NV_MEM_ACCESS_NOSNOOP 16
+
+#define NV_MEM_TARGET_VRAM        0
+#define NV_MEM_TARGET_PCI         1
+#define NV_MEM_TARGET_PCI_NOSNOOP 2
+#define NV_MEM_TARGET_VM          3
+#define NV_MEM_TARGET_GART        4
+
+#define NV_MEM_TYPE_VM 0x7f
+#define NV_MEM_COMP_VM 0x03
+
+struct nouveau_mem {
+        struct drm_device *dev;
+
+        struct nouveau_vma bar_vma;
+        struct nouveau_vma vma[2];
+        u8  page_shift;
+
+        struct nouveau_mm_node *tag;
+        struct list_head regions;
+        dma_addr_t *pages;
+        u32 memtype;
+        u64 offset;
+        u64 size;
+        struct sg_table *sg;
+};
+
+struct nouveau_fb_tile {
+        struct nouveau_mm_node *tag;
+        u32 addr;
+        u32 limit;
+        u32 pitch;
+        u32 zcomp;
+};
+
+struct nouveau_fb {
+        struct nouveau_subdev base;
+
+        bool (*memtype_valid)(struct nouveau_fb *, u32 memtype);
+
+        struct {
+                enum {
+                        NV_MEM_TYPE_UNKNOWN = 0,
+                        NV_MEM_TYPE_STOLEN,
+                        NV_MEM_TYPE_SGRAM,
+                        NV_MEM_TYPE_SDRAM,
+                        NV_MEM_TYPE_DDR1,
+                        NV_MEM_TYPE_DDR2,
+                        NV_MEM_TYPE_DDR3,
+                        NV_MEM_TYPE_GDDR2,
+                        NV_MEM_TYPE_GDDR3,
+                        NV_MEM_TYPE_GDDR4,
+                        NV_MEM_TYPE_GDDR5
+                } type;
+                u64 stolen;
+                u64 size;
+                int ranks;
+
+                int  (*get)(struct nouveau_fb *, u64 size, u32 align,
+                            u32 size_nc, u32 type, struct nouveau_mem **);
+                void (*put)(struct nouveau_fb *, struct nouveau_mem **);
+        } ram;
+
+        struct nouveau_mm vram;
+        struct nouveau_mm tags;
+
+        struct {
+                struct nouveau_fb_tile region[16];
+                int regions;
+                void (*init)(struct nouveau_fb *, int i, u32 addr, u32 size,
+                             u32 pitch, u32 flags, struct nouveau_fb_tile *);
+                void (*fini)(struct nouveau_fb *, int i,
+                             struct nouveau_fb_tile *);
+                void (*prog)(struct nouveau_fb *, int i,
+                             struct nouveau_fb_tile *);
+        } tile;
+};
+
+static inline struct nouveau_fb *
+nouveau_fb(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_FB];
+}
+
+#define nouveau_fb_create(p,e,c,d)                                             \
+        nouveau_subdev_create((p), (e), (c), 0, "PFB", "fb", (d))
+int  nouveau_fb_created(struct nouveau_fb *);
+void nouveau_fb_destroy(struct nouveau_fb *);
+int  nouveau_fb_init(struct nouveau_fb *);
+#define nouveau_fb_fini(p,s)                                                   \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+void _nouveau_fb_dtor(struct nouveau_object *);
+int  _nouveau_fb_init(struct nouveau_object *);
+#define _nouveau_fb_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nv04_fb_oclass;
+extern struct nouveau_oclass nv10_fb_oclass;
+extern struct nouveau_oclass nv20_fb_oclass;
+extern struct nouveau_oclass nv30_fb_oclass;
+extern struct nouveau_oclass nv40_fb_oclass;
+extern struct nouveau_oclass nv50_fb_oclass;
+extern struct nouveau_oclass nvc0_fb_oclass;
+
+struct nouveau_bios;
+int  nouveau_fb_bios_memtype(struct nouveau_bios *);
+
+bool nv04_fb_memtype_valid(struct nouveau_fb *, u32 memtype);
+
+void nv10_fb_tile_prog(struct nouveau_fb *, int, struct nouveau_fb_tile *);
+
+void nv30_fb_tile_init(struct nouveau_fb *, int i, u32 addr, u32 size,
+                       u32 pitch, u32 flags, struct nouveau_fb_tile *);
+void nv30_fb_tile_fini(struct nouveau_fb *, int i, struct nouveau_fb_tile *);
+
+void nv50_fb_vram_del(struct nouveau_fb *, struct nouveau_mem **);
+void nv50_fb_trap(struct nouveau_fb *, int display);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/gpio.h b/drivers/gpu/drm/nouveau/core/include/subdev/gpio.h
new file mode 100644
index 000000000000..9ea2b12cc15d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/gpio.h
@@ -0,0 +1,64 @@
+#ifndef __NOUVEAU_GPIO_H__
+#define __NOUVEAU_GPIO_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+#include <subdev/bios.h>
+#include <subdev/bios/gpio.h>
+
+struct nouveau_gpio {
+        struct nouveau_subdev base;
+
+        /* hardware interfaces */
+        void (*reset)(struct nouveau_gpio *);
+        int  (*drive)(struct nouveau_gpio *, int line, int dir, int out);
+        int  (*sense)(struct nouveau_gpio *, int line);
+        void (*irq_enable)(struct nouveau_gpio *, int line, bool);
+
+        /* software interfaces */
+        int  (*find)(struct nouveau_gpio *, int idx, u8 tag, u8 line,
+                     struct dcb_gpio_func *);
+        int  (*set)(struct nouveau_gpio *, int idx, u8 tag, u8 line, int state);
+        int  (*get)(struct nouveau_gpio *, int idx, u8 tag, u8 line);
+        int  (*irq)(struct nouveau_gpio *, int idx, u8 tag, u8 line, bool on);
+
+        /* interrupt handling */
+        struct list_head isr;
+        spinlock_t lock;
+
+        void (*isr_run)(struct nouveau_gpio *, int idx, u32 mask);
+        int  (*isr_add)(struct nouveau_gpio *, int idx, u8 tag, u8 line,
+                        void (*)(void *, int state), void *data);
+        void (*isr_del)(struct nouveau_gpio *, int idx, u8 tag, u8 line,
+                        void (*)(void *, int state), void *data);
+};
+
+static inline struct nouveau_gpio *
+nouveau_gpio(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_GPIO];
+}
+
+#define nouveau_gpio_create(p,e,o,d)                                           \
+        nouveau_gpio_create_((p), (e), (o), sizeof(**d), (void **)d)
+#define nouveau_gpio_destroy(p)                                                \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_gpio_fini(p,s)                                                 \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+int nouveau_gpio_create_(struct nouveau_object *, struct nouveau_object *,
+                         struct nouveau_oclass *, int, void **);
+int nouveau_gpio_init(struct nouveau_gpio *);
+
+extern struct nouveau_oclass nv10_gpio_oclass;
+extern struct nouveau_oclass nv50_gpio_oclass;
+extern struct nouveau_oclass nvd0_gpio_oclass;
+
+void nv50_gpio_dtor(struct nouveau_object *);
+int  nv50_gpio_init(struct nouveau_object *);
+int  nv50_gpio_fini(struct nouveau_object *, bool);
+void nv50_gpio_intr(struct nouveau_subdev *);
+void nv50_gpio_irq_enable(struct nouveau_gpio *, int line, bool);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/i2c.h b/drivers/gpu/drm/nouveau/core/include/subdev/i2c.h
new file mode 100644
index 000000000000..b93ab01e3785
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/i2c.h
@@ -0,0 +1,60 @@
+#ifndef __NOUVEAU_I2C_H__
+#define __NOUVEAU_I2C_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+#include <subdev/bios.h>
+#include <subdev/bios/i2c.h>
+
+#define NV_I2C_PORT(n)    (0x00 + (n))
+#define NV_I2C_DEFAULT(n) (0x80 + (n))
+
+struct nouveau_i2c_port {
+        struct i2c_adapter adapter;
+        struct nouveau_i2c *i2c;
+        struct i2c_algo_bit_data bit;
+        struct list_head head;
+        u8  index;
+        u8  type;
+        u32 dcb;
+        u32 drive;
+        u32 sense;
+        u32 state;
+};
+
+struct nouveau_i2c {
+        struct nouveau_subdev base;
+
+        struct nouveau_i2c_port *(*find)(struct nouveau_i2c *, u8 index);
+        int (*identify)(struct nouveau_i2c *, int index,
+                        const char *what, struct i2c_board_info *,
+                        bool (*match)(struct nouveau_i2c_port *,
+                                      struct i2c_board_info *));
+        struct list_head ports;
+};
+
+static inline struct nouveau_i2c *
+nouveau_i2c(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_I2C];
+}
+
+extern struct nouveau_oclass nouveau_i2c_oclass;
+
+void nouveau_i2c_drive_scl(void *, int);
+void nouveau_i2c_drive_sda(void *, int);
+int  nouveau_i2c_sense_scl(void *);
+int  nouveau_i2c_sense_sda(void *);
+
+int  nv_rdi2cr(struct nouveau_i2c_port *, u8 addr, u8 reg);
+int  nv_wri2cr(struct nouveau_i2c_port *, u8 addr, u8 reg, u8 val);
+bool nv_probe_i2c(struct nouveau_i2c_port *, u8 addr);
+
+int nv_rdaux(struct nouveau_i2c_port *, u32 addr, u8 *data, u8 size);
+int nv_wraux(struct nouveau_i2c_port *, u32 addr, u8 *data, u8 size);
+
+extern const struct i2c_algorithm nouveau_i2c_bit_algo;
+extern const struct i2c_algorithm nouveau_i2c_aux_algo;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/ibus.h b/drivers/gpu/drm/nouveau/core/include/subdev/ibus.h
new file mode 100644
index 000000000000..88814f159d89
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/ibus.h
@@ -0,0 +1,34 @@
+#ifndef __NOUVEAU_IBUS_H__
+#define __NOUVEAU_IBUS_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+struct nouveau_ibus {
+        struct nouveau_subdev base;
+};
+
+static inline struct nouveau_ibus *
+nouveau_ibus(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_IBUS];
+}
+
+#define nouveau_ibus_create(p,e,o,d)                                           \
+        nouveau_subdev_create_((p), (e), (o), 0, "PIBUS", "ibus",              \
+                               sizeof(**d), (void **)d)
+#define nouveau_ibus_destroy(p)                                                \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_ibus_init(p)                                                   \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_ibus_fini(p,s)                                                 \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+#define _nouveau_ibus_dtor _nouveau_subdev_dtor
+#define _nouveau_ibus_init _nouveau_subdev_init
+#define _nouveau_ibus_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nvc0_ibus_oclass;
+extern struct nouveau_oclass nve0_ibus_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/instmem.h b/drivers/gpu/drm/nouveau/core/include/subdev/instmem.h
new file mode 100644
index 000000000000..ec7a54e91a08
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/instmem.h
@@ -0,0 +1,73 @@
+#ifndef __NOUVEAU_INSTMEM_H__
+#define __NOUVEAU_INSTMEM_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+#include <core/mm.h>
+
+struct nouveau_instobj {
+        struct nouveau_object base;
+        struct list_head head;
+        u32 *suspend;
+        u64 addr;
+        u32 size;
+};
+
+static inline struct nouveau_instobj *
+nv_memobj(void *obj)
+{
+#if CONFIG_NOUVEAU_DEBUG >= NV_DBG_PARANOIA
+        if (unlikely(!nv_iclass(obj, NV_MEMOBJ_CLASS)))
+                nv_assert("BAD CAST -> NvMemObj, %08x", nv_hclass(obj));
+#endif
+        return obj;
+}
+
+#define nouveau_instobj_create(p,e,o,d)                                        \
+        nouveau_instobj_create_((p), (e), (o), sizeof(**d), (void **)d)
+#define nouveau_instobj_init(p)                                                \
+        nouveau_object_init(&(p)->base)
+#define nouveau_instobj_fini(p,s)                                              \
+        nouveau_object_fini(&(p)->base, (s))
+
+int  nouveau_instobj_create_(struct nouveau_object *, struct nouveau_object *,
+                             struct nouveau_oclass *, int, void **);
+void nouveau_instobj_destroy(struct nouveau_instobj *);
+
+void _nouveau_instobj_dtor(struct nouveau_object *);
+#define _nouveau_instobj_init nouveau_object_init
+#define _nouveau_instobj_fini nouveau_object_fini
+
+struct nouveau_instmem {
+        struct nouveau_subdev base;
+        struct list_head list;
+
+        u32 reserved;
+        int (*alloc)(struct nouveau_instmem *, struct nouveau_object *,
+                     u32 size, u32 align, struct nouveau_object **);
+};
+
+static inline struct nouveau_instmem *
+nouveau_instmem(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_INSTMEM];
+}
+
+#define nouveau_instmem_create(p,e,o,d)                                        \
+        nouveau_instmem_create_((p), (e), (o), sizeof(**d), (void **)d)
+#define nouveau_instmem_destroy(p)                                             \
+        nouveau_subdev_destroy(&(p)->base)
+int nouveau_instmem_create_(struct nouveau_object *, struct nouveau_object *,
+                            struct nouveau_oclass *, int, void **);
+int nouveau_instmem_init(struct nouveau_instmem *);
+int nouveau_instmem_fini(struct nouveau_instmem *, bool);
+
+#define _nouveau_instmem_dtor _nouveau_subdev_dtor
+int _nouveau_instmem_init(struct nouveau_object *);
+int _nouveau_instmem_fini(struct nouveau_object *, bool);
+
+extern struct nouveau_oclass nv04_instmem_oclass;
+extern struct nouveau_oclass nv40_instmem_oclass;
+extern struct nouveau_oclass nv50_instmem_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/ltcg.h b/drivers/gpu/drm/nouveau/core/include/subdev/ltcg.h
new file mode 100644
index 000000000000..f351f63bc654
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/ltcg.h
@@ -0,0 +1,33 @@
+#ifndef __NOUVEAU_LTCG_H__
+#define __NOUVEAU_LTCG_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+struct nouveau_ltcg {
+        struct nouveau_subdev base;
+};
+
+static inline struct nouveau_ltcg *
+nouveau_ltcg(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_LTCG];
+}
+
+#define nouveau_ltcg_create(p,e,o,d)                                           \
+        nouveau_subdev_create_((p), (e), (o), 0, "PLTCG", "level2",            \
+                               sizeof(**d), (void **)d)
+#define nouveau_ltcg_destroy(p)                                                \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_ltcg_init(p)                                                   \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_ltcg_fini(p,s)                                                 \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+#define _nouveau_ltcg_dtor _nouveau_subdev_dtor
+#define _nouveau_ltcg_init _nouveau_subdev_init
+#define _nouveau_ltcg_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nvc0_ltcg_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/mc.h b/drivers/gpu/drm/nouveau/core/include/subdev/mc.h
new file mode 100644
index 000000000000..fded97cea500
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/mc.h
@@ -0,0 +1,49 @@
+#ifndef __NOUVEAU_MC_H__
+#define __NOUVEAU_MC_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+struct nouveau_mc_intr {
+        u32 stat;
+        u32 unit;
+};
+
+struct nouveau_mc {
+        struct nouveau_subdev base;
+        const struct nouveau_mc_intr *intr_map;
+};
+
+static inline struct nouveau_mc *
+nouveau_mc(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_MC];
+}
+
+#define nouveau_mc_create(p,e,o,d)                                             \
+        nouveau_subdev_create_((p), (e), (o), 0, "PMC", "master",              \
+                               sizeof(**d), (void **)d)
+#define nouveau_mc_destroy(p)                                                  \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_mc_init(p)                                                     \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_mc_fini(p,s)                                                   \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+#define _nouveau_mc_dtor _nouveau_subdev_dtor
+#define _nouveau_mc_init _nouveau_subdev_init
+#define _nouveau_mc_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nv04_mc_oclass;
+extern struct nouveau_oclass nv44_mc_oclass;
+extern struct nouveau_oclass nv50_mc_oclass;
+extern struct nouveau_oclass nv98_mc_oclass;
+extern struct nouveau_oclass nvc0_mc_oclass;
+
+void nouveau_mc_intr(struct nouveau_subdev *);
+
+extern const struct nouveau_mc_intr nv04_mc_intr[];
+int nv04_mc_init(struct nouveau_object *);
+int nv50_mc_init(struct nouveau_object *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/mxm.h b/drivers/gpu/drm/nouveau/core/include/subdev/mxm.h
new file mode 100644
index 000000000000..b93b152cb566
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/mxm.h
@@ -0,0 +1,37 @@
+#ifndef __NOUVEAU_MXM_H__
+#define __NOUVEAU_MXM_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+#define MXM_SANITISE_DCB 0x00000001
+
+struct nouveau_mxm {
+        struct nouveau_subdev base;
+        u32 action;
+        u8 *mxms;
+};
+
+static inline struct nouveau_mxm *
+nouveau_mxm(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_MXM];
+}
+
+#define nouveau_mxm_create(p,e,o,d)                                            \
+        nouveau_mxm_create_((p), (e), (o), sizeof(**d), (void **)d)
+#define nouveau_mxm_init(p)                                                    \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_mxm_fini(p,s)                                                  \
+        nouveau_subdev_fini(&(p)->base, (s))
+int  nouveau_mxm_create_(struct nouveau_object *, struct nouveau_object *,
+                         struct nouveau_oclass *, int, void **);
+void nouveau_mxm_destroy(struct nouveau_mxm *);
+
+#define _nouveau_mxm_dtor _nouveau_subdev_dtor
+#define _nouveau_mxm_init _nouveau_subdev_init
+#define _nouveau_mxm_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nv50_mxm_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/therm.h b/drivers/gpu/drm/nouveau/core/include/subdev/therm.h
new file mode 100644
index 000000000000..faee569fd458
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/therm.h
@@ -0,0 +1,58 @@
+#ifndef __NOUVEAU_THERM_H__
+#define __NOUVEAU_THERM_H__
+
+#include <core/device.h>
+#include <core/subdev.h>
+
+enum nouveau_therm_fan_mode {
+        FAN_CONTROL_NONE = 0,
+        FAN_CONTROL_MANUAL = 1,
+        FAN_CONTROL_NR,
+};
+
+enum nouveau_therm_attr_type {
+        NOUVEAU_THERM_ATTR_FAN_MIN_DUTY = 0,
+        NOUVEAU_THERM_ATTR_FAN_MAX_DUTY = 1,
+        NOUVEAU_THERM_ATTR_FAN_MODE = 2,
+
+        NOUVEAU_THERM_ATTR_THRS_FAN_BOOST = 10,
+        NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST = 11,
+        NOUVEAU_THERM_ATTR_THRS_DOWN_CLK = 12,
+        NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST = 13,
+        NOUVEAU_THERM_ATTR_THRS_CRITICAL = 14,
+        NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST = 15,
+        NOUVEAU_THERM_ATTR_THRS_SHUTDOWN = 16,
+        NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST = 17,
+};
+
+struct nouveau_therm {
+        struct nouveau_subdev base;
+
+        int (*fan_get)(struct nouveau_therm *);
+        int (*fan_set)(struct nouveau_therm *, int);
+        int (*fan_sense)(struct nouveau_therm *);
+
+        int (*temp_get)(struct nouveau_therm *);
+
+        int (*attr_get)(struct nouveau_therm *, enum nouveau_therm_attr_type);
+        int (*attr_set)(struct nouveau_therm *,
+                        enum nouveau_therm_attr_type, int);
+};
+
+static inline struct nouveau_therm *
+nouveau_therm(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_THERM];
+}
+
+#define nouveau_therm_create(p,e,o,d)                                          \
+        nouveau_subdev_create((p), (e), (o), 0, "THERM", "therm", d)
+#define nouveau_therm_destroy(p)                                               \
+        nouveau_subdev_destroy(&(p)->base)
+
+#define _nouveau_therm_dtor _nouveau_subdev_dtor
+
+extern struct nouveau_oclass nv40_therm_oclass;
+extern struct nouveau_oclass nv50_therm_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/timer.h b/drivers/gpu/drm/nouveau/core/include/subdev/timer.h
new file mode 100644
index 000000000000..49bff901544c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/timer.h
@@ -0,0 +1,53 @@
+#ifndef __NOUVEAU_TIMER_H__
+#define __NOUVEAU_TIMER_H__
+
+#include <core/subdev.h>
+#include <core/device.h>
+
+struct nouveau_alarm {
+        struct list_head head;
+        u64 timestamp;
+        void (*func)(struct nouveau_alarm *);
+};
+
+bool nouveau_timer_wait_eq(void *, u64 nsec, u32 addr, u32 mask, u32 data);
+bool nouveau_timer_wait_ne(void *, u64 nsec, u32 addr, u32 mask, u32 data);
+bool nouveau_timer_wait_cb(void *, u64 nsec, bool (*func)(void *), void *data);
+void nouveau_timer_alarm(void *, u32 nsec, struct nouveau_alarm *);
+
+#define NV_WAIT_DEFAULT 2000000000ULL
+#define nv_wait(o,a,m,v)                                                       \
+        nouveau_timer_wait_eq((o), NV_WAIT_DEFAULT, (a), (m), (v))
+#define nv_wait_ne(o,a,m,v)                                                    \
+        nouveau_timer_wait_ne((o), NV_WAIT_DEFAULT, (a), (m), (v))
+#define nv_wait_cb(o,c,d)                                                      \
+        nouveau_timer_wait_cb((o), NV_WAIT_DEFAULT, (c), (d))
+
+struct nouveau_timer {
+        struct nouveau_subdev base;
+        u64  (*read)(struct nouveau_timer *);
+        void (*alarm)(struct nouveau_timer *, u32 time, struct nouveau_alarm *);
+};
+
+static inline struct nouveau_timer *
+nouveau_timer(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_TIMER];
+}
+
+#define nouveau_timer_create(p,e,o,d)                                          \
+        nouveau_subdev_create_((p), (e), (o), 0, "PTIMER", "timer",            \
+                               sizeof(**d), (void **)d)
+#define nouveau_timer_destroy(p)                                               \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_timer_init(p)                                                  \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_timer_fini(p,s)                                                \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+int nouveau_timer_create_(struct nouveau_object *, struct nouveau_engine *,
+                          struct nouveau_oclass *, int size, void **);
+
+extern struct nouveau_oclass nv04_timer_oclass;
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/vga.h b/drivers/gpu/drm/nouveau/core/include/subdev/vga.h
new file mode 100644
index 000000000000..fee09ad818e4
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/vga.h
@@ -0,0 +1,30 @@
+#ifndef __NOUVEAU_VGA_H__
+#define __NOUVEAU_VGA_H__
+
+#include <core/os.h>
+
+/* access to various legacy io ports */
+u8   nv_rdport(void *obj, int head, u16 port);
+void nv_wrport(void *obj, int head, u16 port, u8 value);
+
+/* VGA Sequencer */
+u8   nv_rdvgas(void *obj, int head, u8 index);
+void nv_wrvgas(void *obj, int head, u8 index, u8 value);
+
+/* VGA Graphics */
+u8   nv_rdvgag(void *obj, int head, u8 index);
+void nv_wrvgag(void *obj, int head, u8 index, u8 value);
+
+/* VGA CRTC */
+u8   nv_rdvgac(void *obj, int head, u8 index);
+void nv_wrvgac(void *obj, int head, u8 index, u8 value);
+
+/* VGA indexed port access dispatcher */
+u8   nv_rdvgai(void *obj, int head, u16 port, u8 index);
+void nv_wrvgai(void *obj, int head, u16 port, u8 index, u8 value);
+
+bool nv_lockvgac(void *obj, bool lock);
+u8   nv_rdvgaowner(void *obj);
+void nv_wrvgaowner(void *obj, u8);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_vm.h b/drivers/gpu/drm/nouveau/core/include/subdev/vm.h
index a8246e7e4a89..9d595efe667a 100644
--- a/drivers/gpu/drm/nouveau/nouveau_vm.h
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/vm.h
@@ -25,10 +25,10 @@
 #ifndef __NOUVEAU_VM_H__
 #define __NOUVEAU_VM_H__
 
-#include "drmP.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_mm.h"
+#include <core/object.h>
+#include <core/subdev.h>
+#include <core/device.h>
+#include <core/mm.h>
 
 struct nouveau_vm_pgt {
         struct nouveau_gpuobj *obj[2];
@@ -40,6 +40,9 @@ struct nouveau_vm_pgd {
         struct nouveau_gpuobj *obj;
 };
 
+struct nouveau_gpuobj;
+struct nouveau_mem;
+
 struct nouveau_vma {
         struct list_head head;
         int refcount;
@@ -50,21 +53,30 @@ struct nouveau_vma {
 };
 
 struct nouveau_vm {
-        struct drm_device *dev;
+        struct nouveau_vmmgr *vmm;
         struct nouveau_mm mm;
         int refcount;
 
         struct list_head pgd_list;
-        atomic_t engref[16];
+        atomic_t engref[64]; //NVDEV_SUBDEV_NR];
 
         struct nouveau_vm_pgt *pgt;
         u32 fpde;
         u32 lpde;
+};
+
+struct nouveau_vmmgr {
+        struct nouveau_subdev base;
 
+        u64 limit;
+        u8  dma_bits;
         u32 pgt_bits;
         u8  spg_shift;
         u8  lpg_shift;
 
+        int  (*create)(struct nouveau_vmmgr *, u64 offset, u64 length,
+                       u64 mm_offset, struct nouveau_vm **);
+
         void (*map_pgt)(struct nouveau_gpuobj *pgd, u32 pde,
                         struct nouveau_gpuobj *pgt[2]);
         void (*map)(struct nouveau_vma *, struct nouveau_gpuobj *,
@@ -72,16 +84,47 @@ struct nouveau_vm {
                     u64 phys, u64 delta);
         void (*map_sg)(struct nouveau_vma *, struct nouveau_gpuobj *,
                        struct nouveau_mem *, u32 pte, u32 cnt, dma_addr_t *);
-
-        void (*map_sg_table)(struct nouveau_vma *, struct nouveau_gpuobj *,
-                             struct nouveau_mem *, u32 pte, u32 cnt, dma_addr_t *);
         void (*unmap)(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt);
         void (*flush)(struct nouveau_vm *);
 };
 
-/* nouveau_vm.c */
-int  nouveau_vm_new(struct drm_device *, u64 offset, u64 length, u64 mm_offset,
+static inline struct nouveau_vmmgr *
+nouveau_vmmgr(void *obj)
+{
+        return (void *)nv_device(obj)->subdev[NVDEV_SUBDEV_VM];
+}
+
+#define nouveau_vmmgr_create(p,e,o,i,f,d)                                      \
+        nouveau_subdev_create((p), (e), (o), 0, (i), (f), (d))
+#define nouveau_vmmgr_destroy(p)                                               \
+        nouveau_subdev_destroy(&(p)->base)
+#define nouveau_vmmgr_init(p)                                                  \
+        nouveau_subdev_init(&(p)->base)
+#define nouveau_vmmgr_fini(p,s)                                                \
+        nouveau_subdev_fini(&(p)->base, (s))
+
+#define _nouveau_vmmgr_dtor _nouveau_subdev_dtor
+#define _nouveau_vmmgr_init _nouveau_subdev_init
+#define _nouveau_vmmgr_fini _nouveau_subdev_fini
+
+extern struct nouveau_oclass nv04_vmmgr_oclass;
+extern struct nouveau_oclass nv41_vmmgr_oclass;
+extern struct nouveau_oclass nv44_vmmgr_oclass;
+extern struct nouveau_oclass nv50_vmmgr_oclass;
+extern struct nouveau_oclass nvc0_vmmgr_oclass;
+
+int  nv04_vm_create(struct nouveau_vmmgr *, u64, u64, u64,
                     struct nouveau_vm **);
+void nv04_vmmgr_dtor(struct nouveau_object *);
+
+void nv50_vm_flush_engine(struct nouveau_subdev *, int engine);
+void nvc0_vm_flush_engine(struct nouveau_subdev *, u64 addr, int type);
+
+/* nouveau_vm.c */
+int  nouveau_vm_create(struct nouveau_vmmgr *, u64 offset, u64 length,
+                       u64 mm_offset, u32 block, struct nouveau_vm **);
+int  nouveau_vm_new(struct nouveau_device *, u64 offset, u64 length,
+                    u64 mm_offset, struct nouveau_vm **);
 int  nouveau_vm_ref(struct nouveau_vm *, struct nouveau_vm **,
                     struct nouveau_gpuobj *pgd);
 int  nouveau_vm_get(struct nouveau_vm *, u64 size, u32 page_shift,
@@ -94,26 +137,6 @@ void nouveau_vm_unmap_at(struct nouveau_vma *, u64 offset, u64 length);
 void nouveau_vm_map_sg(struct nouveau_vma *, u64 offset, u64 length,
                        struct nouveau_mem *);
 void nouveau_vm_map_sg_table(struct nouveau_vma *vma, u64 delta, u64 length,
-                             struct nouveau_mem *mem);
-/* nv50_vm.c */
-void nv50_vm_map_pgt(struct nouveau_gpuobj *pgd, u32 pde,
-                     struct nouveau_gpuobj *pgt[2]);
-void nv50_vm_map(struct nouveau_vma *, struct nouveau_gpuobj *,
-                 struct nouveau_mem *, u32 pte, u32 cnt, u64 phys, u64 delta);
-void nv50_vm_map_sg(struct nouveau_vma *, struct nouveau_gpuobj *,
-                    struct nouveau_mem *, u32 pte, u32 cnt, dma_addr_t *);
-void nv50_vm_unmap(struct nouveau_gpuobj *, u32 pte, u32 cnt);
-void nv50_vm_flush(struct nouveau_vm *);
-void nv50_vm_flush_engine(struct drm_device *, int engine);
-
-/* nvc0_vm.c */
-void nvc0_vm_map_pgt(struct nouveau_gpuobj *pgd, u32 pde,
-                     struct nouveau_gpuobj *pgt[2]);
-void nvc0_vm_map(struct nouveau_vma *, struct nouveau_gpuobj *,
-                 struct nouveau_mem *, u32 pte, u32 cnt, u64 phys, u64 delta);
-void nvc0_vm_map_sg(struct nouveau_vma *, struct nouveau_gpuobj *,
-                    struct nouveau_mem *, u32 pte, u32 cnt, dma_addr_t *);
-void nvc0_vm_unmap(struct nouveau_gpuobj *, u32 pte, u32 cnt);
-void nvc0_vm_flush(struct nouveau_vm *);
+                     struct nouveau_mem *mem);
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/core/os.h b/drivers/gpu/drm/nouveau/core/os.h
new file mode 100644
index 000000000000..cfe3b9cad156
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/os.h
@@ -0,0 +1,47 @@
+#ifndef __NOUVEAU_OS_H__
+#define __NOUVEAU_OS_H__
+
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/pci.h>
+#include <linux/printk.h>
+#include <linux/bitops.h>
+#include <linux/firmware.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/delay.h>
+#include <linux/io-mapping.h>
+#include <linux/vmalloc.h>
+#include <linux/acpi.h>
+#include <linux/dmi.h>
+
+#include <asm/unaligned.h>
+
+static inline int
+ffsll(u64 mask)
+{
+        int i;
+        for (i = 0; i < 64; i++) {
+                if (mask & (1ULL << i))
+                        return i + 1;
+        }
+        return 0;
+}
+
+#ifndef ioread32_native
+#ifdef __BIG_ENDIAN
+#define ioread16_native ioread16be
+#define iowrite16_native iowrite16be
+#define ioread32_native  ioread32be
+#define iowrite32_native iowrite32be
+#else /* def __BIG_ENDIAN */
+#define ioread16_native ioread16
+#define iowrite16_native iowrite16
+#define ioread32_native  ioread32
+#define iowrite32_native iowrite32
+#endif /* def __BIG_ENDIAN else */
+#endif /* !ioread32_native */
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bar/base.c b/drivers/gpu/drm/nouveau/core/subdev/bar/base.c
new file mode 100644
index 000000000000..cd01c533007a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bar/base.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <subdev/bar.h>
+
+struct nouveau_barobj {
+        struct nouveau_object base;
+        struct nouveau_vma vma;
+        void __iomem *iomem;
+};
+
+static int
+nouveau_barobj_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *mem, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nouveau_bar *bar = (void *)engine;
+        struct nouveau_barobj *barobj;
+        int ret;
+
+        ret = nouveau_object_create(parent, engine, oclass, 0, &barobj);
+        *pobject = nv_object(barobj);
+        if (ret)
+                return ret;
+
+        ret = bar->kmap(bar, mem, NV_MEM_ACCESS_RW, &barobj->vma);
+        if (ret)
+                return ret;
+
+        barobj->iomem = bar->iomem + (u32)barobj->vma.offset;
+        return 0;
+}
+
+static void
+nouveau_barobj_dtor(struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = (void *)object->engine;
+        struct nouveau_barobj *barobj = (void *)object;
+        if (barobj->vma.node)
+                bar->unmap(bar, &barobj->vma);
+        nouveau_object_destroy(&barobj->base);
+}
+
+static u32
+nouveau_barobj_rd32(struct nouveau_object *object, u32 addr)
+{
+        struct nouveau_barobj *barobj = (void *)object;
+        return ioread32_native(barobj->iomem + addr);
+}
+
+static void
+nouveau_barobj_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        struct nouveau_barobj *barobj = (void *)object;
+        iowrite32_native(data, barobj->iomem + addr);
+}
+
+static struct nouveau_oclass
+nouveau_barobj_oclass = {
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nouveau_barobj_ctor,
+                .dtor = nouveau_barobj_dtor,
+                .init = nouveau_object_init,
+                .fini = nouveau_object_fini,
+                .rd32 = nouveau_barobj_rd32,
+                .wr32 = nouveau_barobj_wr32,
+        },
+};
+
+int
+nouveau_bar_alloc(struct nouveau_bar *bar, struct nouveau_object *parent,
+                  struct nouveau_mem *mem, struct nouveau_object **pobject)
+{
+        struct nouveau_object *engine = nv_object(bar);
+        return nouveau_object_ctor(parent, engine, &nouveau_barobj_oclass,
+                                   mem, 0, pobject);
+}
+
+int
+nouveau_bar_create_(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, int length, void **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_bar *bar;
+        int ret;
+
+        ret = nouveau_subdev_create_(parent, engine, oclass, 0, "BARCTL",
+                                     "bar", length, pobject);
+        bar = *pobject;
+        if (ret)
+                return ret;
+
+        bar->iomem = ioremap(pci_resource_start(device->pdev, 3),
+                             pci_resource_len(device->pdev, 3));
+        return 0;
+}
+
+void
+nouveau_bar_destroy(struct nouveau_bar *bar)
+{
+        if (bar->iomem)
+                iounmap(bar->iomem);
+        nouveau_subdev_destroy(&bar->base);
+}
+
+void
+_nouveau_bar_dtor(struct nouveau_object *object)
+{
+        struct nouveau_bar *bar = (void *)object;
+        nouveau_bar_destroy(bar);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bar/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/bar/nv50.c
new file mode 100644
index 000000000000..c3acf5b70d9e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bar/nv50.c
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+
+struct nv50_bar_priv {
+        struct nouveau_bar base;
+        spinlock_t lock;
+        struct nouveau_gpuobj *mem;
+        struct nouveau_gpuobj *pad;
+        struct nouveau_gpuobj *pgd;
+        struct nouveau_vm *bar1_vm;
+        struct nouveau_gpuobj *bar1;
+        struct nouveau_vm *bar3_vm;
+        struct nouveau_gpuobj *bar3;
+};
+
+static int
+nv50_bar_kmap(struct nouveau_bar *bar, struct nouveau_mem *mem,
+              u32 flags, struct nouveau_vma *vma)
+{
+        struct nv50_bar_priv *priv = (void *)bar;
+        int ret;
+
+        ret = nouveau_vm_get(priv->bar3_vm, mem->size << 12, 12, flags, vma);
+        if (ret)
+                return ret;
+
+        nouveau_vm_map(vma, mem);
+        nv50_vm_flush_engine(nv_subdev(bar), 6);
+        return 0;
+}
+
+static int
+nv50_bar_umap(struct nouveau_bar *bar, struct nouveau_mem *mem,
+              u32 flags, struct nouveau_vma *vma)
+{
+        struct nv50_bar_priv *priv = (void *)bar;
+        int ret;
+
+        ret = nouveau_vm_get(priv->bar1_vm, mem->size << 12, 12, flags, vma);
+        if (ret)
+                return ret;
+
+        nouveau_vm_map(vma, mem);
+        nv50_vm_flush_engine(nv_subdev(bar), 6);
+        return 0;
+}
+
+static void
+nv50_bar_unmap(struct nouveau_bar *bar, struct nouveau_vma *vma)
+{
+        nouveau_vm_unmap(vma);
+        nv50_vm_flush_engine(nv_subdev(bar), 6);
+        nouveau_vm_put(vma);
+}
+
+static void
+nv50_bar_flush(struct nouveau_bar *bar)
+{
+        struct nv50_bar_priv *priv = (void *)bar;
+        unsigned long flags;
+        spin_lock_irqsave(&priv->lock, flags);
+        nv_wr32(priv, 0x00330c, 0x00000001);
+        if (!nv_wait(priv, 0x00330c, 0x00000002, 0x00000000))
+                nv_warn(priv, "flush timeout\n");
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+void
+nv84_bar_flush(struct nouveau_bar *bar)
+{
+        struct nv50_bar_priv *priv = (void *)bar;
+        unsigned long flags;
+        spin_lock_irqsave(&priv->lock, flags);
+        nv_wr32(bar, 0x070000, 0x00000001);
+        if (!nv_wait(priv, 0x070000, 0x00000002, 0x00000000))
+                nv_warn(priv, "flush timeout\n");
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static int
+nv50_bar_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_object *heap;
+        struct nouveau_vm *vm;
+        struct nv50_bar_priv *priv;
+        u64 start, limit;
+        int ret;
+
+        ret = nouveau_bar_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x20000, 0, NVOBJ_FLAG_HEAP,
+                                &priv->mem);
+        heap = nv_object(priv->mem);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, heap, (device->chipset == 0x50) ?
+                                 0x1400 : 0x0200, 0, 0, &priv->pad);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, heap, 0x4000, 0, 0, &priv->pgd);
+        if (ret)
+                return ret;
+
+        /* BAR3 */
+        start = 0x0100000000ULL;
+        limit = start + pci_resource_len(device->pdev, 3);
+
+        ret = nouveau_vm_new(device, start, limit, start, &vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, heap, ((limit-- - start) >> 12) * 8,
+                                 0x1000, NVOBJ_FLAG_ZERO_ALLOC,
+                                 &vm->pgt[0].obj[0]);
+        vm->pgt[0].refcount[0] = 1;
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_ref(vm, &priv->bar3_vm, priv->pgd);
+        nouveau_vm_ref(NULL, &vm, NULL);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, heap, 24, 16, 0, &priv->bar3);
+        if (ret)
+                return ret;
+
+        nv_wo32(priv->bar3, 0x00, 0x7fc00000);
+        nv_wo32(priv->bar3, 0x04, lower_32_bits(limit));
+        nv_wo32(priv->bar3, 0x08, lower_32_bits(start));
+        nv_wo32(priv->bar3, 0x0c, upper_32_bits(limit) << 24 |
+                                  upper_32_bits(start));
+        nv_wo32(priv->bar3, 0x10, 0x00000000);
+        nv_wo32(priv->bar3, 0x14, 0x00000000);
+
+        /* BAR1 */
+        start = 0x0000000000ULL;
+        limit = start + pci_resource_len(device->pdev, 1);
+
+        ret = nouveau_vm_new(device, start, limit--, start, &vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_ref(vm, &priv->bar1_vm, priv->pgd);
+        nouveau_vm_ref(NULL, &vm, NULL);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, heap, 24, 16, 0, &priv->bar1);
+        if (ret)
+                return ret;
+
+        nv_wo32(priv->bar1, 0x00, 0x7fc00000);
+        nv_wo32(priv->bar1, 0x04, lower_32_bits(limit));
+        nv_wo32(priv->bar1, 0x08, lower_32_bits(start));
+        nv_wo32(priv->bar1, 0x0c, upper_32_bits(limit) << 24 |
+                                  upper_32_bits(start));
+        nv_wo32(priv->bar1, 0x10, 0x00000000);
+        nv_wo32(priv->bar1, 0x14, 0x00000000);
+
+        priv->base.alloc = nouveau_bar_alloc;
+        priv->base.kmap = nv50_bar_kmap;
+        priv->base.umap = nv50_bar_umap;
+        priv->base.unmap = nv50_bar_unmap;
+        if (device->chipset == 0x50)
+                priv->base.flush = nv50_bar_flush;
+        else
+                priv->base.flush = nv84_bar_flush;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+static void
+nv50_bar_dtor(struct nouveau_object *object)
+{
+        struct nv50_bar_priv *priv = (void *)object;
+        nouveau_gpuobj_ref(NULL, &priv->bar1);
+        nouveau_vm_ref(NULL, &priv->bar1_vm, priv->pgd);
+        nouveau_gpuobj_ref(NULL, &priv->bar3);
+        if (priv->bar3_vm) {
+                nouveau_gpuobj_ref(NULL, &priv->bar3_vm->pgt[0].obj[0]);
+                nouveau_vm_ref(NULL, &priv->bar3_vm, priv->pgd);
+        }
+        nouveau_gpuobj_ref(NULL, &priv->pgd);
+        nouveau_gpuobj_ref(NULL, &priv->pad);
+        nouveau_gpuobj_ref(NULL, &priv->mem);
+        nouveau_bar_destroy(&priv->base);
+}
+
+static int
+nv50_bar_init(struct nouveau_object *object)
+{
+        struct nv50_bar_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_bar_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_mask(priv, 0x000200, 0x00000100, 0x00000000);
+        nv_mask(priv, 0x000200, 0x00000100, 0x00000100);
+        nv50_vm_flush_engine(nv_subdev(priv), 6);
+
+        nv_wr32(priv, 0x001704, 0x00000000 | priv->mem->addr >> 12);
+        nv_wr32(priv, 0x001704, 0x40000000 | priv->mem->addr >> 12);
+        nv_wr32(priv, 0x001708, 0x80000000 | priv->bar1->node->offset >> 4);
+        nv_wr32(priv, 0x00170c, 0x80000000 | priv->bar3->node->offset >> 4);
+        return 0;
+}
+
+static int
+nv50_bar_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv50_bar_priv *priv = (void *)object;
+        return nouveau_bar_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv50_bar_oclass = {
+        .handle = NV_SUBDEV(BAR, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_bar_ctor,
+                .dtor = nv50_bar_dtor,
+                .init = nv50_bar_init,
+                .fini = nv50_bar_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bar/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/bar/nvc0.c
new file mode 100644
index 000000000000..77a6fb725d3f
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bar/nvc0.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+
+struct nvc0_bar_priv {
+        struct nouveau_bar base;
+        spinlock_t lock;
+        struct {
+                struct nouveau_gpuobj *mem;
+                struct nouveau_gpuobj *pgd;
+                struct nouveau_vm *vm;
+        } bar[2];
+};
+
+static int
+nvc0_bar_kmap(struct nouveau_bar *bar, struct nouveau_mem *mem,
+              u32 flags, struct nouveau_vma *vma)
+{
+        struct nvc0_bar_priv *priv = (void *)bar;
+        int ret;
+
+        ret = nouveau_vm_get(priv->bar[0].vm, mem->size << 12, 12, flags, vma);
+        if (ret)
+                return ret;
+
+        nouveau_vm_map(vma, mem);
+        nvc0_vm_flush_engine(nv_subdev(bar), priv->bar[0].pgd->addr, 5);
+        return 0;
+}
+
+static int
+nvc0_bar_umap(struct nouveau_bar *bar, struct nouveau_mem *mem,
+              u32 flags, struct nouveau_vma *vma)
+{
+        struct nvc0_bar_priv *priv = (void *)bar;
+        int ret;
+
+        ret = nouveau_vm_get(priv->bar[1].vm, mem->size << 12,
+                             mem->page_shift, flags, vma);
+        if (ret)
+                return ret;
+
+        nouveau_vm_map(vma, mem);
+        nvc0_vm_flush_engine(nv_subdev(bar), priv->bar[1].pgd->addr, 5);
+        return 0;
+}
+
+static void
+nvc0_bar_unmap(struct nouveau_bar *bar, struct nouveau_vma *vma)
+{
+        struct nvc0_bar_priv *priv = (void *)bar;
+        int i = !(vma->vm == priv->bar[0].vm);
+
+        nouveau_vm_unmap(vma);
+        nvc0_vm_flush_engine(nv_subdev(bar), priv->bar[i].pgd->addr, 5);
+        nouveau_vm_put(vma);
+}
+
+static int
+nvc0_bar_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct pci_dev *pdev = device->pdev;
+        struct nvc0_bar_priv *priv;
+        struct nouveau_gpuobj *mem;
+        struct nouveau_vm *vm;
+        int ret;
+
+        ret = nouveau_bar_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        /* BAR3 */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 0, 0, &priv->bar[0].mem);
+        mem = priv->bar[0].mem;
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x8000, 0, 0, &priv->bar[0].pgd);
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_new(device, 0, pci_resource_len(pdev, 3), 0, &vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL,
+                                 (pci_resource_len(pdev, 3) >> 12) * 8,
+                                 0x1000, NVOBJ_FLAG_ZERO_ALLOC,
+                                 &vm->pgt[0].obj[0]);
+        vm->pgt[0].refcount[0] = 1;
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_ref(vm, &priv->bar[0].vm, priv->bar[0].pgd);
+        nouveau_vm_ref(NULL, &vm, NULL);
+        if (ret)
+                return ret;
+
+        nv_wo32(mem, 0x0200, lower_32_bits(priv->bar[0].pgd->addr));
+        nv_wo32(mem, 0x0204, upper_32_bits(priv->bar[0].pgd->addr));
+        nv_wo32(mem, 0x0208, lower_32_bits(pci_resource_len(pdev, 3) - 1));
+        nv_wo32(mem, 0x020c, upper_32_bits(pci_resource_len(pdev, 3) - 1));
+
+        /* BAR1 */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x1000, 0, 0, &priv->bar[1].mem);
+        mem = priv->bar[1].mem;
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL, 0x8000, 0, 0, &priv->bar[1].pgd);
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_new(device, 0, pci_resource_len(pdev, 1), 0, &vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_vm_ref(vm, &priv->bar[1].vm, priv->bar[1].pgd);
+        nouveau_vm_ref(NULL, &vm, NULL);
+        if (ret)
+                return ret;
+
+        nv_wo32(mem, 0x0200, lower_32_bits(priv->bar[1].pgd->addr));
+        nv_wo32(mem, 0x0204, upper_32_bits(priv->bar[1].pgd->addr));
+        nv_wo32(mem, 0x0208, lower_32_bits(pci_resource_len(pdev, 1) - 1));
+        nv_wo32(mem, 0x020c, upper_32_bits(pci_resource_len(pdev, 1) - 1));
+
+        priv->base.alloc = nouveau_bar_alloc;
+        priv->base.kmap = nvc0_bar_kmap;
+        priv->base.umap = nvc0_bar_umap;
+        priv->base.unmap = nvc0_bar_unmap;
+        priv->base.flush = nv84_bar_flush;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+static void
+nvc0_bar_dtor(struct nouveau_object *object)
+{
+        struct nvc0_bar_priv *priv = (void *)object;
+
+        nouveau_vm_ref(NULL, &priv->bar[1].vm, priv->bar[1].pgd);
+        nouveau_gpuobj_ref(NULL, &priv->bar[1].pgd);
+        nouveau_gpuobj_ref(NULL, &priv->bar[1].mem);
+
+        if (priv->bar[0].vm) {
+                nouveau_gpuobj_ref(NULL, &priv->bar[0].vm->pgt[0].obj[0]);
+                nouveau_vm_ref(NULL, &priv->bar[0].vm, priv->bar[0].pgd);
+        }
+        nouveau_gpuobj_ref(NULL, &priv->bar[0].pgd);
+        nouveau_gpuobj_ref(NULL, &priv->bar[0].mem);
+
+        nouveau_bar_destroy(&priv->base);
+}
+
+static int
+nvc0_bar_init(struct nouveau_object *object)
+{
+        struct nvc0_bar_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_bar_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_mask(priv, 0x000200, 0x00000100, 0x00000000);
+        nv_mask(priv, 0x000200, 0x00000100, 0x00000100);
+        nv_mask(priv, 0x100c80, 0x00000001, 0x00000000);
+
+        nv_wr32(priv, 0x001704, 0x80000000 | priv->bar[1].mem->addr >> 12);
+        nv_wr32(priv, 0x001714, 0xc0000000 | priv->bar[0].mem->addr >> 12);
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_bar_oclass = {
+        .handle = NV_SUBDEV(BAR, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_bar_ctor,
+                .dtor = nvc0_bar_dtor,
+                .init = nvc0_bar_init,
+                .fini = _nouveau_bar_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/base.c b/drivers/gpu/drm/nouveau/core/subdev/bios/base.c
new file mode 100644
index 000000000000..2fbb6df697cd
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/base.c
@@ -0,0 +1,479 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/device.h>
+#include <core/subdev.h>
+#include <core/option.h>
+
+#include <subdev/bios.h>
+#include <subdev/bios/bmp.h>
+#include <subdev/bios/bit.h>
+
+u8
+nvbios_checksum(const u8 *data, int size)
+{
+        u8 sum = 0;
+        while (size--)
+                sum += *data++;
+        return sum;
+}
+
+u16
+nvbios_findstr(const u8 *data, int size, const char *str, int len)
+{
+        int i, j;
+
+        for (i = 0; i <= (size - len); i++) {
+                for (j = 0; j < len; j++)
+                        if ((char)data[i + j] != str[j])
+                                break;
+                if (j == len)
+                        return i;
+        }
+
+        return 0;
+}
+
+#if defined(__powerpc__)
+static void
+nouveau_bios_shadow_of(struct nouveau_bios *bios)
+{
+        struct pci_dev *pdev = nv_device(bios)->pdev;
+        struct device_node *dn;
+        const u32 *data;
+        int size, i;
+
+        dn = pci_device_to_OF_node(pdev);
+        if (!dn) {
+                nv_info(bios, "Unable to get the OF node\n");
+                return;
+        }
+
+        data = of_get_property(dn, "NVDA,BMP", &size);
+        if (data) {
+                bios->size = size;
+                bios->data = kmalloc(bios->size, GFP_KERNEL);
+                if (bios->data)
+                        memcpy(bios->data, data, size);
+        }
+}
+#endif
+
+static void
+nouveau_bios_shadow_pramin(struct nouveau_bios *bios)
+{
+        struct nouveau_device *device = nv_device(bios);
+        u32 bar0 = 0;
+        int i;
+
+        if (device->card_type >= NV_50) {
+                u64 addr = (u64)(nv_rd32(bios, 0x619f04) & 0xffffff00) << 8;
+                if (!addr) {
+                        addr  = (u64)nv_rd32(bios, 0x001700) << 16;
+                        addr += 0xf0000;
+                }
+
+                bar0 = nv_mask(bios, 0x001700, 0xffffffff, addr >> 16);
+        }
+
+        /* bail if no rom signature */
+        if (nv_rd08(bios, 0x700000) != 0x55 ||
+            nv_rd08(bios, 0x700001) != 0xaa)
+                goto out;
+
+        bios->size = nv_rd08(bios, 0x700002) * 512;
+        bios->data = kmalloc(bios->size, GFP_KERNEL);
+        if (bios->data) {
+                for (i = 0; i < bios->size; i++)
+                        nv_wo08(bios, i, nv_rd08(bios, 0x700000 + i));
+        }
+
+out:
+        if (device->card_type >= NV_50)
+                nv_wr32(bios, 0x001700, bar0);
+}
+
+static void
+nouveau_bios_shadow_prom(struct nouveau_bios *bios)
+{
+        struct nouveau_device *device = nv_device(bios);
+        u32 pcireg, access;
+        u16 pcir;
+        int i;
+
+        /* enable access to rom */
+        if (device->card_type >= NV_50)
+                pcireg = 0x088050;
+        else
+                pcireg = 0x001850;
+        access = nv_mask(bios, pcireg, 0x00000001, 0x00000000);
+
+        /* bail if no rom signature, with a workaround for a PROM reading
+         * issue on some chipsets.  the first read after a period of
+         * inactivity returns the wrong result, so retry the first header
+         * byte a few times before giving up as a workaround
+         */
+        i = 16;
+        do {
+                if (nv_rd08(bios, 0x300000) == 0x55)
+                        break;
+        } while (i--);
+
+        if (!i || nv_rd08(bios, 0x300001) != 0xaa)
+                goto out;
+
+        /* additional check (see note below) - read PCI record header */
+        pcir = nv_rd08(bios, 0x300018) |
+               nv_rd08(bios, 0x300019) << 8;
+        if (nv_rd08(bios, 0x300000 + pcir) != 'P' ||
+            nv_rd08(bios, 0x300001 + pcir) != 'C' ||
+            nv_rd08(bios, 0x300002 + pcir) != 'I' ||
+            nv_rd08(bios, 0x300003 + pcir) != 'R')
+                goto out;
+
+        /* read entire bios image to system memory */
+        bios->size = nv_rd08(bios, 0x300002) * 512;
+        bios->data = kmalloc(bios->size, GFP_KERNEL);
+        if (bios->data) {
+                for (i = 0; i < bios->size; i++)
+                        nv_wo08(bios, i, nv_rd08(bios, 0x300000 + i));
+        }
+
+out:
+        /* disable access to rom */
+        nv_wr32(bios, pcireg, access);
+}
+
+#if defined(CONFIG_ACPI)
+int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len);
+bool nouveau_acpi_rom_supported(struct pci_dev *pdev);
+#else
+static inline bool
+nouveau_acpi_rom_supported(struct pci_dev *pdev) {
+        return false;
+}
+
+static inline int
+nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len) {
+        return -EINVAL;
+}
+#endif
+
+static void
+nouveau_bios_shadow_acpi(struct nouveau_bios *bios)
+{
+        struct pci_dev *pdev = nv_device(bios)->pdev;
+        int cnt = 65536 / 4096;
+        int ret;
+
+        if (!nouveau_acpi_rom_supported(pdev))
+                return;
+
+        bios->data = kmalloc(65536, GFP_KERNEL);
+        bios->size = 0;
+        if (!bios->data)
+                return;
+
+        while (cnt--) {
+                ret = nouveau_acpi_get_bios_chunk(bios->data, bios->size, 4096);
+                if (ret != 4096)
+                        return;
+
+                bios->size += 4096;
+        }
+}
+
+static void
+nouveau_bios_shadow_pci(struct nouveau_bios *bios)
+{
+        struct pci_dev *pdev = nv_device(bios)->pdev;
+        size_t size;
+
+        if (!pci_enable_rom(pdev)) {
+                void __iomem *rom = pci_map_rom(pdev, &size);
+                if (rom && size) {
+                        bios->data = kmalloc(size, GFP_KERNEL);
+                        if (bios->data) {
+                                memcpy_fromio(bios->data, rom, size);
+                                bios->size = size;
+                        }
+                }
+                if (rom)
+                        pci_unmap_rom(pdev, rom);
+
+                pci_disable_rom(pdev);
+        }
+}
+
+static int
+nouveau_bios_score(struct nouveau_bios *bios, const bool writeable)
+{
+        if (!bios->data || bios->data[0] != 0x55 || bios->data[1] != 0xAA) {
+                nv_info(bios, "... signature not found\n");
+                return 0;
+        }
+
+        if (nvbios_checksum(bios->data, bios->data[2] * 512)) {
+                nv_info(bios, "... checksum invalid\n");
+                /* if a ro image is somewhat bad, it's probably all rubbish */
+                return writeable ? 2 : 1;
+        }
+
+        nv_info(bios, "... appears to be valid\n");
+        return 3;
+}
+
+struct methods {
+        const char desc[16];
+        void (*shadow)(struct nouveau_bios *);
+        const bool rw;
+        int score;
+        u32 size;
+        u8 *data;
+};
+
+static int
+nouveau_bios_shadow(struct nouveau_bios *bios)
+{
+        struct methods shadow_methods[] = {
+#if defined(__powerpc__)
+                { "OpenFirmware", nouveau_bios_shadow_of, true, 0, 0, NULL },
+#endif
+                { "PRAMIN", nouveau_bios_shadow_pramin, true, 0, 0, NULL },
+                { "PROM", nouveau_bios_shadow_prom, false, 0, 0, NULL },
+                { "ACPI", nouveau_bios_shadow_acpi, true, 0, 0, NULL },
+                { "PCIROM", nouveau_bios_shadow_pci, true, 0, 0, NULL },
+                {}
+        };
+        struct methods *mthd, *best;
+        const struct firmware *fw;
+        const char *optarg;
+        int optlen, ret;
+        char *source;
+
+        optarg = nouveau_stropt(nv_device(bios)->cfgopt, "NvBios", &optlen);
+        source = optarg ? kstrndup(optarg, optlen, GFP_KERNEL) : NULL;
+        if (source) {
+                /* try to match one of the built-in methods */
+                mthd = shadow_methods;
+                do {
+                        if (strcasecmp(source, mthd->desc))
+                                continue;
+                        nv_info(bios, "source: %s\n", mthd->desc);
+
+                        mthd->shadow(bios);
+                        mthd->score = nouveau_bios_score(bios, mthd->rw);
+                        if (mthd->score) {
+                                kfree(source);
+                                return 0;
+                        }
+                } while ((++mthd)->shadow);
+
+                /* attempt to load firmware image */
+                ret = request_firmware(&fw, source, &nv_device(bios)->pdev->dev);
+                if (ret == 0) {
+                        bios->size = fw->size;
+                        bios->data = kmemdup(fw->data, fw->size, GFP_KERNEL);
+                        release_firmware(fw);
+
+                        nv_info(bios, "image: %s\n", source);
+                        if (nouveau_bios_score(bios, 1)) {
+                                kfree(source);
+                                return 0;
+                        }
+
+                        kfree(bios->data);
+                        bios->data = NULL;
+                }
+
+                nv_error(bios, "source \'%s\' invalid\n", source);
+                kfree(source);
+        }
+
+        mthd = shadow_methods;
+        do {
+                nv_info(bios, "checking %s for image...\n", mthd->desc);
+                mthd->shadow(bios);
+                mthd->score = nouveau_bios_score(bios, mthd->rw);
+                mthd->size = bios->size;
+                mthd->data = bios->data;
+                bios->data = NULL;
+        } while (mthd->score != 3 && (++mthd)->shadow);
+
+        mthd = shadow_methods;
+        best = mthd;
+        do {
+                if (mthd->score > best->score) {
+                        kfree(best->data);
+                        best = mthd;
+                }
+        } while ((++mthd)->shadow);
+
+        if (best->score) {
+                nv_info(bios, "using image from %s\n", best->desc);
+                bios->size = best->size;
+                bios->data = best->data;
+                return 0;
+        }
+
+        nv_error(bios, "unable to locate usable image\n");
+        return -EINVAL;
+}
+
+static u8
+nouveau_bios_rd08(struct nouveau_object *object, u32 addr)
+{
+        struct nouveau_bios *bios = (void *)object;
+        return bios->data[addr];
+}
+
+static u16
+nouveau_bios_rd16(struct nouveau_object *object, u32 addr)
+{
+        struct nouveau_bios *bios = (void *)object;
+        return get_unaligned_le16(&bios->data[addr]);
+}
+
+static u32
+nouveau_bios_rd32(struct nouveau_object *object, u32 addr)
+{
+        struct nouveau_bios *bios = (void *)object;
+        return get_unaligned_le32(&bios->data[addr]);
+}
+
+static void
+nouveau_bios_wr08(struct nouveau_object *object, u32 addr, u8 data)
+{
+        struct nouveau_bios *bios = (void *)object;
+        bios->data[addr] = data;
+}
+
+static void
+nouveau_bios_wr16(struct nouveau_object *object, u32 addr, u16 data)
+{
+        struct nouveau_bios *bios = (void *)object;
+        put_unaligned_le16(data, &bios->data[addr]);
+}
+
+static void
+nouveau_bios_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        struct nouveau_bios *bios = (void *)object;
+        put_unaligned_le32(data, &bios->data[addr]);
+}
+
+static int
+nouveau_bios_ctor(struct nouveau_object *parent,
+                  struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nouveau_bios *bios;
+        struct bit_entry bit_i;
+        int ret;
+
+        ret = nouveau_subdev_create(parent, engine, oclass, 0,
+                                    "VBIOS", "bios", &bios);
+        *pobject = nv_object(bios);
+        if (ret)
+                return ret;
+
+        ret = nouveau_bios_shadow(bios);
+        if (ret)
+                return ret;
+
+        /* detect type of vbios we're dealing with */
+        bios->bmp_offset = nvbios_findstr(bios->data, bios->size,
+                                          "\xff\x7f""NV\0", 5);
+        if (bios->bmp_offset) {
+                nv_info(bios, "BMP version %x.%x\n",
+                        bmp_version(bios) >> 8,
+                        bmp_version(bios) & 0xff);
+        }
+
+        bios->bit_offset = nvbios_findstr(bios->data, bios->size,
+                                          "\xff\xb8""BIT", 5);
+        if (bios->bit_offset)
+                nv_info(bios, "BIT signature found\n");
+
+        /* determine the vbios version number */
+        if (!bit_entry(bios, 'i', &bit_i) && bit_i.length >= 4) {
+                bios->version.major = nv_ro08(bios, bit_i.offset + 3);
+                bios->version.chip  = nv_ro08(bios, bit_i.offset + 2);
+                bios->version.minor = nv_ro08(bios, bit_i.offset + 1);
+                bios->version.micro = nv_ro08(bios, bit_i.offset + 0);
+        } else
+        if (bmp_version(bios)) {
+                bios->version.major = nv_ro08(bios, bios->bmp_offset + 13);
+                bios->version.chip  = nv_ro08(bios, bios->bmp_offset + 12);
+                bios->version.minor = nv_ro08(bios, bios->bmp_offset + 11);
+                bios->version.micro = nv_ro08(bios, bios->bmp_offset + 10);
+        }
+
+        nv_info(bios, "version %02x.%02x.%02x.%02x\n",
+                bios->version.major, bios->version.chip,
+                bios->version.minor, bios->version.micro);
+
+        return 0;
+}
+
+static void
+nouveau_bios_dtor(struct nouveau_object *object)
+{
+        struct nouveau_bios *bios = (void *)object;
+        kfree(bios->data);
+        nouveau_subdev_destroy(&bios->base);
+}
+
+static int
+nouveau_bios_init(struct nouveau_object *object)
+{
+        struct nouveau_bios *bios = (void *)object;
+        return nouveau_subdev_init(&bios->base);
+}
+
+static int
+nouveau_bios_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nouveau_bios *bios = (void *)object;
+        return nouveau_subdev_fini(&bios->base, suspend);
+}
+
+struct nouveau_oclass
+nouveau_bios_oclass = {
+        .handle = NV_SUBDEV(VBIOS, 0x00),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nouveau_bios_ctor,
+                .dtor = nouveau_bios_dtor,
+                .init = nouveau_bios_init,
+                .fini = nouveau_bios_fini,
+                .rd08 = nouveau_bios_rd08,
+                .rd16 = nouveau_bios_rd16,
+                .rd32 = nouveau_bios_rd32,
+                .wr08 = nouveau_bios_wr08,
+                .wr16 = nouveau_bios_wr16,
+                .wr32 = nouveau_bios_wr32,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/bit.c b/drivers/gpu/drm/nouveau/core/subdev/bios/bit.c
new file mode 100644
index 000000000000..1d03a3f2b2d2
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/bit.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012 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 "core/object.h"
+
+#include "subdev/bios.h"
+#include "subdev/bios/bit.h"
+
+int
+bit_entry(struct nouveau_bios *bios, u8 id, struct bit_entry *bit)
+{
+        if (likely(bios->bit_offset)) {
+                u8  entries = nv_ro08(bios, bios->bit_offset + 10);
+                u32 entry   = bios->bit_offset + 12;
+                while (entries--) {
+                        if (nv_ro08(bios, entry + 0) == id) {
+                                bit->id      = nv_ro08(bios, entry + 0);
+                                bit->version = nv_ro08(bios, entry + 1);
+                                bit->length  = nv_ro16(bios, entry + 2);
+                                bit->offset  = nv_ro16(bios, entry + 4);
+                                return 0;
+                        }
+
+                        entry += nv_ro08(bios, bios->bit_offset + 9);
+                }
+
+                return -ENOENT;
+        }
+
+        return -EINVAL;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/conn.c b/drivers/gpu/drm/nouveau/core/subdev/bios/conn.c
new file mode 100644
index 000000000000..5ac010efd959
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/conn.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2012 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 <core/device.h>
+
+#include <subdev/bios.h>
+#include <subdev/bios/dcb.h>
+#include <subdev/bios/conn.h>
+
+u16
+dcb_conntab(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
+{
+        u16 dcb = dcb_table(bios, ver, hdr, cnt, len);
+        if (dcb && *ver >= 0x30 && *hdr >= 0x16) {
+                u16 data = nv_ro16(bios, dcb + 0x14);
+                if (data) {
+                        *ver = nv_ro08(bios, data + 0);
+                        *hdr = nv_ro08(bios, data + 1);
+                        *cnt = nv_ro08(bios, data + 2);
+                        *len = nv_ro08(bios, data + 3);
+                        return data;
+                }
+        }
+        return 0x0000;
+}
+
+u16
+dcb_conn(struct nouveau_bios *bios, u8 idx, u8 *ver, u8 *len)
+{
+        u8  hdr, cnt;
+        u16 data = dcb_conntab(bios, ver, &hdr, &cnt, len);
+        if (data && idx < cnt)
+                return data + hdr + (idx * *len);
+        return 0x0000;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c b/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c
new file mode 100644
index 000000000000..9ed6e728a94c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 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 "core/device.h"
+
+#include "subdev/bios.h"
+#include "subdev/bios/dcb.h"
+
+u16
+dcb_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
+{
+        struct nouveau_device *device = nv_device(bios);
+        u16 dcb = 0x0000;
+
+        if (device->card_type > NV_04)
+                dcb = nv_ro16(bios, 0x36);
+        if (!dcb) {
+                nv_warn(bios, "DCB table not found\n");
+                return dcb;
+        }
+
+        *ver = nv_ro08(bios, dcb);
+
+        if (*ver >= 0x41) {
+                nv_warn(bios, "DCB *ver 0x%02x unknown\n", *ver);
+                return 0x0000;
+        } else
+        if (*ver >= 0x30) {
+                if (nv_ro32(bios, dcb + 6) == 0x4edcbdcb) {
+                        *hdr = nv_ro08(bios, dcb + 1);
+                        *cnt = nv_ro08(bios, dcb + 2);
+                        *len = nv_ro08(bios, dcb + 3);
+                        return dcb;
+                }
+        } else
+        if (*ver >= 0x20) {
+                if (nv_ro32(bios, dcb + 4) == 0x4edcbdcb) {
+                        u16 i2c = nv_ro16(bios, dcb + 2);
+                        *hdr = 8;
+                        *cnt = (i2c - dcb) / 8;
+                        *len = 8;
+                        return dcb;
+                }
+        } else
+        if (*ver >= 0x15) {
+                if (!nv_strncmp(bios, dcb - 7, 7, "DEV_REC")) {
+                        u16 i2c = nv_ro16(bios, dcb + 2);
+                        *hdr = 4;
+                        *cnt = (i2c - dcb) / 10;
+                        *len = 10;
+                        return dcb;
+                }
+        } else {
+                /*
+                 * v1.4 (some NV15/16, NV11+) seems the same as v1.5, but
+                 * always has the same single (crt) entry, even when tv-out
+                 * present, so the conclusion is this version cannot really
+                 * be used.
+                 *
+                 * v1.2 tables (some NV6/10, and NV15+) normally have the
+                 * same 5 entries, which are not specific to the card and so
+                 * no use.
+                 *
+                 * v1.2 does have an I2C table that read_dcb_i2c_table can
+                 * handle, but cards exist (nv11 in #14821) with a bad i2c
+                 * table pointer, so use the indices parsed in
+                 * parse_bmp_structure.
+                 *
+                 * v1.1 (NV5+, maybe some NV4) is entirely unhelpful
+                 */
+                nv_warn(bios, "DCB contains no useful data\n");
+                return 0x0000;
+        }
+
+        nv_warn(bios, "DCB header validation failed\n");
+        return 0x0000;
+}
+
+u16
+dcb_outp(struct nouveau_bios *bios, u8 idx, u8 *ver, u8 *len)
+{
+        u8  hdr, cnt;
+        u16 dcb = dcb_table(bios, ver, &hdr, &cnt, len);
+        if (dcb && idx < cnt)
+                return dcb + hdr + (idx * *len);
+        return 0x0000;
+}
+
+int
+dcb_outp_foreach(struct nouveau_bios *bios, void *data,
+                 int (*exec)(struct nouveau_bios *, void *, int, u16))
+{
+        int ret, idx = -1;
+        u8  ver, len;
+        u16 outp;
+
+        while ((outp = dcb_outp(bios, ++idx, &ver, &len))) {
+                if (nv_ro32(bios, outp) == 0x00000000)
+                        break; /* seen on an NV11 with DCB v1.5 */
+                if (nv_ro32(bios, outp) == 0xffffffff)
+                        break; /* seen on an NV17 with DCB v2.0 */
+
+                if (nv_ro08(bios, outp) == DCB_OUTPUT_UNUSED)
+                        continue;
+                if (nv_ro08(bios, outp) == DCB_OUTPUT_EOL)
+                        break;
+
+                ret = exec(bios, data, idx, outp);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/dp.c b/drivers/gpu/drm/nouveau/core/subdev/bios/dp.c
new file mode 100644
index 000000000000..3cbc0f3e8d5e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/dp.c
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012 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 "subdev/bios.h"
+#include "subdev/bios/bit.h"
+#include "subdev/bios/dcb.h"
+#include "subdev/bios/dp.h"
+
+u16
+dp_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
+{
+        struct bit_entry bit_d;
+
+        if (!bit_entry(bios, 'd', &bit_d)) {
+                if (bit_d.version == 1) {
+                        u16 data = nv_ro16(bios, bit_d.offset);
+                        if (data) {
+                                *ver = nv_ro08(bios, data + 0);
+                                *hdr = nv_ro08(bios, data + 1);
+                                *len = nv_ro08(bios, data + 2);
+                                *cnt = nv_ro08(bios, data + 3);
+                                return data;
+                        }
+                }
+        }
+
+        return 0x0000;
+}
+
+u16
+dp_outp(struct nouveau_bios *bios, u8 idx, u8 *ver, u8 *len)
+{
+        u8  hdr, cnt;
+        u16 table = dp_table(bios, ver, &hdr, &cnt, len);
+        if (table && idx < cnt)
+                return nv_ro16(bios, table + hdr + (idx * *len));
+        return 0xffff;
+}
+
+u16
+dp_outp_match(struct nouveau_bios *bios, struct dcb_output *outp,
+              u8 *ver, u8 *len)
+{
+        u8  idx = 0;
+        u16 data;
+        while ((data = dp_outp(bios, idx++, ver, len)) != 0xffff) {
+                if (data) {
+                        u32 hash = nv_ro32(bios, data);
+                        if (dcb_hash_match(outp, hash))
+                                return data;
+                }
+        }
+        return 0x0000;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/extdev.c b/drivers/gpu/drm/nouveau/core/subdev/bios/extdev.c
new file mode 100644
index 000000000000..5afb568b2d69
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/extdev.c
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2012 Nouveau Community
+ *
+ * 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: Martin Peres
+ */
+
+#include <subdev/bios.h>
+#include <subdev/bios/dcb.h>
+#include <subdev/bios/extdev.h>
+
+static u16
+extdev_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *len, u8 *cnt)
+{
+        u8  dcb_ver, dcb_hdr, dcb_cnt, dcb_len;
+        u16 dcb, extdev = 0;
+
+        dcb = dcb_table(bios, &dcb_ver, &dcb_hdr, &dcb_cnt, &dcb_len);
+        if (!dcb || (dcb_ver != 0x30 && dcb_ver != 0x40))
+                return 0x0000;
+
+        extdev = nv_ro16(bios, dcb + 18);
+        if (!extdev)
+                return 0x0000;
+
+        *ver = nv_ro08(bios, extdev + 0);
+        *hdr = nv_ro08(bios, extdev + 1);
+        *cnt = nv_ro08(bios, extdev + 2);
+        *len = nv_ro08(bios, extdev + 3);
+
+        return extdev + *hdr;
+}
+
+u16
+nvbios_extdev_entry(struct nouveau_bios *bios, int idx, u8 *ver, u8 *len)
+{
+        u8 hdr, cnt;
+        u16 extdev = extdev_table(bios, ver, &hdr, len, &cnt);
+        if (extdev && idx < cnt)
+                return extdev + idx * *len;
+        return 0x0000;
+}
+
+static void
+extdev_parse_entry(struct nouveau_bios *bios, u16 offset,
+                          struct nvbios_extdev_func *entry)
+{
+        entry->type = nv_ro08(bios, offset + 0);
+        entry->addr = nv_ro08(bios, offset + 1);
+        entry->bus = (nv_ro08(bios, offset + 2) >> 4) & 1;
+}
+
+int
+nvbios_extdev_parse(struct nouveau_bios *bios, int idx,
+                    struct nvbios_extdev_func *func)
+{
+        u8 ver, len;
+        u16 entry;
+
+        if (!(entry = nvbios_extdev_entry(bios, idx, &ver, &len)))
+                return -EINVAL;
+
+        extdev_parse_entry(bios, entry, func);
+
+        return 0;
+}
+
+int
+nvbios_extdev_find(struct nouveau_bios *bios, enum nvbios_extdev_type type,
+                   struct nvbios_extdev_func *func)
+{
+        u8 ver, len, i;
+        u16 entry;
+
+        i = 0;
+        while (!(entry = nvbios_extdev_entry(bios, i++, &ver, &len))) {
+                extdev_parse_entry(bios, entry, func);
+                if (func->type == type)
+                        return 0;
+        }
+
+        return -EINVAL;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/gpio.c b/drivers/gpu/drm/nouveau/core/subdev/bios/gpio.c
new file mode 100644
index 000000000000..4c9f1e508165
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/gpio.c
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2012 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 <subdev/bios.h>
+#include <subdev/bios/dcb.h>
+#include <subdev/bios/gpio.h>
+
+u16
+dcb_gpio_table(struct nouveau_bios *bios)
+{
+        u8  ver, hdr, cnt, len;
+        u16 dcb = dcb_table(bios, &ver, &hdr, &cnt, &len);
+        if (dcb) {
+                if (ver >= 0x30 && hdr >= 0x0c)
+                        return nv_ro16(bios, dcb + 0x0a);
+                if (ver >= 0x22 && nv_ro08(bios, dcb - 1) >= 0x13)
+                        return nv_ro16(bios, dcb - 0x0f);
+        }
+        return 0x0000;
+}
+
+u16
+dcb_gpio_entry(struct nouveau_bios *bios, int idx, int ent, u8 *ver)
+{
+        u16 gpio = dcb_gpio_table(bios);
+        if (gpio) {
+                *ver = nv_ro08(bios, gpio);
+                if (*ver < 0x30 && ent < nv_ro08(bios, gpio + 2))
+                        return gpio + 3 + (ent * nv_ro08(bios, gpio + 1));
+                else if (ent < nv_ro08(bios, gpio + 2))
+                        return gpio + nv_ro08(bios, gpio + 1) +
+                               (ent * nv_ro08(bios, gpio + 3));
+        }
+        return 0x0000;
+}
+
+int
+dcb_gpio_parse(struct nouveau_bios *bios, int idx, u8 func, u8 line,
+               struct dcb_gpio_func *gpio)
+{
+        u8  ver, hdr, cnt, len;
+        u16 entry;
+        int i = -1;
+
+        while ((entry = dcb_gpio_entry(bios, idx, ++i, &ver))) {
+                if (ver < 0x40) {
+                        u16 data = nv_ro16(bios, entry);
+                        *gpio = (struct dcb_gpio_func) {
+                                .line = (data & 0x001f) >> 0,
+                                .func = (data & 0x07e0) >> 5,
+                                .log[0] = (data & 0x1800) >> 11,
+                                .log[1] = (data & 0x6000) >> 13,
+                                .param = !!(data & 0x8000),
+                        };
+                } else
+                if (ver < 0x41) {
+                        u32 data = nv_ro32(bios, entry);
+                        *gpio = (struct dcb_gpio_func) {
+                                .line = (data & 0x0000001f) >> 0,
+                                .func = (data & 0x0000ff00) >> 8,
+                                .log[0] = (data & 0x18000000) >> 27,
+                                .log[1] = (data & 0x60000000) >> 29,
+                                .param = !!(data & 0x80000000),
+                        };
+                } else {
+                        u32 data = nv_ro32(bios, entry + 0);
+                        u8 data1 = nv_ro32(bios, entry + 4);
+                        *gpio = (struct dcb_gpio_func) {
+                                .line = (data & 0x0000003f) >> 0,
+                                .func = (data & 0x0000ff00) >> 8,
+                                .log[0] = (data1 & 0x30) >> 4,
+                                .log[1] = (data1 & 0xc0) >> 6,
+                                .param = !!(data & 0x80000000),
+                        };
+                }
+
+                if ((line == 0xff || line == gpio->line) &&
+                    (func == 0xff || func == gpio->func))
+                        return 0;
+        }
+
+        /* DCB 2.2, fixed TVDAC GPIO data */
+        if ((entry = dcb_table(bios, &ver, &hdr, &cnt, &len)) && ver >= 0x22) {
+                if (func == DCB_GPIO_TVDAC0) {
+                        u8 conf = nv_ro08(bios, entry - 5);
+                        u8 addr = nv_ro08(bios, entry - 4);
+                        if (conf & 0x01) {
+                                *gpio = (struct dcb_gpio_func) {
+                                        .func = DCB_GPIO_TVDAC0,
+                                        .line = addr >> 4,
+                                        .log[0] = !!(conf & 0x02),
+                                        .log[1] =  !(conf & 0x02),
+                                };
+                                return 0;
+                        }
+                }
+        }
+
+        return -EINVAL;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/i2c.c b/drivers/gpu/drm/nouveau/core/subdev/bios/i2c.c
new file mode 100644
index 000000000000..ad577db83766
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/i2c.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2012 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 "subdev/bios.h"
+#include "subdev/bios/dcb.h"
+#include "subdev/bios/i2c.h"
+
+u16
+dcb_i2c_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
+{
+        u16 i2c = 0x0000;
+        u16 dcb = dcb_table(bios, ver, hdr, cnt, len);
+        if (dcb) {
+                if (*ver >= 0x15)
+                        i2c = nv_ro16(bios, dcb + 2);
+                if (*ver >= 0x30)
+                        i2c = nv_ro16(bios, dcb + 4);
+        }
+
+        if (i2c && *ver >= 0x30) {
+                *ver = nv_ro08(bios, i2c + 0);
+                *hdr = nv_ro08(bios, i2c + 1);
+                *cnt = nv_ro08(bios, i2c + 2);
+                *len = nv_ro08(bios, i2c + 3);
+        } else {
+                *ver = *ver; /* use DCB version */
+                *hdr = 0;
+                *cnt = 16;
+                *len = 4;
+        }
+
+        return i2c;
+}
+
+u16
+dcb_i2c_entry(struct nouveau_bios *bios, u8 idx, u8 *ver, u8 *len)
+{
+        u8  hdr, cnt;
+        u16 i2c = dcb_i2c_table(bios, ver, &hdr, &cnt, len);
+        if (i2c && idx < cnt)
+                return i2c + hdr + (idx * *len);
+        return 0x0000;
+}
+
+int
+dcb_i2c_parse(struct nouveau_bios *bios, u8 idx, struct dcb_i2c_entry *info)
+{
+        u8  ver, len;
+        u16 ent = dcb_i2c_entry(bios, idx, &ver, &len);
+        if (ent) {
+                info->data = nv_ro32(bios, ent + 0);
+                info->type = nv_ro08(bios, ent + 3);
+                if (ver < 0x30) {
+                        info->type &= 0x07;
+                        if (info->type == 0x07)
+                                info->type = 0xff;
+                }
+
+                switch (info->type) {
+                case DCB_I2C_NV04_BIT:
+                        info->drive = nv_ro08(bios, ent + 0);
+                        info->sense = nv_ro08(bios, ent + 1);
+                        return 0;
+                case DCB_I2C_NV4E_BIT:
+                        info->drive = nv_ro08(bios, ent + 1);
+                        return 0;
+                case DCB_I2C_NVIO_BIT:
+                case DCB_I2C_NVIO_AUX:
+                        info->drive = nv_ro08(bios, ent + 0);
+                        return 0;
+                case DCB_I2C_UNUSED:
+                        return 0;
+                default:
+                        nv_warn(bios, "unknown i2c type %d\n", info->type);
+                        info->type = DCB_I2C_UNUSED;
+                        return 0;
+                }
+        }
+
+        if (bios->bmp_offset && idx < 2) {
+                /* BMP (from v4.0 has i2c info in the structure, it's in a
+                 * fixed location on earlier VBIOS
+                 */
+                if (nv_ro08(bios, bios->bmp_offset + 5) < 4)
+                        ent = 0x0048;
+                else
+                        ent = 0x0036 + bios->bmp_offset;
+
+                if (idx == 0) {
+                        info->drive = nv_ro08(bios, ent + 4);
+                        if (!info->drive) info->drive = 0x3f;
+                        info->sense = nv_ro08(bios, ent + 5);
+                        if (!info->sense) info->sense = 0x3e;
+                } else
+                if (idx == 1) {
+                        info->drive = nv_ro08(bios, ent + 6);
+                        if (!info->drive) info->drive = 0x37;
+                        info->sense = nv_ro08(bios, ent + 7);
+                        if (!info->sense) info->sense = 0x36;
+                }
+
+                info->type = DCB_I2C_NV04_BIT;
+                return 0;
+        }
+
+        return -ENOENT;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/init.c b/drivers/gpu/drm/nouveau/core/subdev/bios/init.c
new file mode 100644
index 000000000000..6be8c32f6e4c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/init.c
@@ -0,0 +1,2120 @@
+#include <core/engine.h>
+#include <core/device.h>
+
+#include <subdev/bios.h>
+#include <subdev/bios/conn.h>
+#include <subdev/bios/bmp.h>
+#include <subdev/bios/bit.h>
+#include <subdev/bios/dcb.h>
+#include <subdev/bios/dp.h>
+#include <subdev/bios/init.h>
+#include <subdev/devinit.h>
+#include <subdev/clock.h>
+#include <subdev/i2c.h>
+#include <subdev/vga.h>
+#include <subdev/gpio.h>
+
+#define bioslog(lvl, fmt, args...) do {                                        \
+        nv_printk(init->bios, lvl, "0x%04x[%c]: "fmt, init->offset,            \
+                  init_exec(init) ? '0' + (init->nested - 1) : ' ', ##args);   \
+} while(0)
+#define cont(fmt, args...) do {                                                \
+        if (nv_subdev(init->bios)->debug >= NV_DBG_TRACE)                      \
+                printk(fmt, ##args);                                           \
+} while(0)
+#define trace(fmt, args...) bioslog(TRACE, fmt, ##args)
+#define warn(fmt, args...) bioslog(WARN, fmt, ##args)
+#define error(fmt, args...) bioslog(ERROR, fmt, ##args)
+
+/******************************************************************************
+ * init parser control flow helpers
+ *****************************************************************************/
+
+static inline bool
+init_exec(struct nvbios_init *init)
+{
+        return (init->execute == 1) || ((init->execute & 5) == 5);
+}
+
+static inline void
+init_exec_set(struct nvbios_init *init, bool exec)
+{
+        if (exec) init->execute &= 0xfd;
+        else      init->execute |= 0x02;
+}
+
+static inline void
+init_exec_inv(struct nvbios_init *init)
+{
+        init->execute ^= 0x02;
+}
+
+static inline void
+init_exec_force(struct nvbios_init *init, bool exec)
+{
+        if (exec) init->execute |= 0x04;
+        else      init->execute &= 0xfb;
+}
+
+/******************************************************************************
+ * init parser wrappers for normal register/i2c/whatever accessors
+ *****************************************************************************/
+
+static inline int
+init_or(struct nvbios_init *init)
+{
+        if (init->outp)
+                return ffs(init->outp->or) - 1;
+        error("script needs OR!!\n");
+        return 0;
+}
+
+static inline int
+init_link(struct nvbios_init *init)
+{
+        if (init->outp)
+                return !(init->outp->sorconf.link & 1);
+        error("script needs OR link\n");
+        return 0;
+}
+
+static inline int
+init_crtc(struct nvbios_init *init)
+{
+        if (init->crtc >= 0)
+                return init->crtc;
+        error("script needs crtc\n");
+        return 0;
+}
+
+static u8
+init_conn(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+
+        if (init->outp) {
+                u8  ver, len;
+                u16 conn = dcb_conn(bios, init->outp->connector, &ver, &len);
+                if (conn)
+                        return nv_ro08(bios, conn);
+        }
+
+        error("script needs connector type\n");
+        return 0x00;
+}
+
+static inline u32
+init_nvreg(struct nvbios_init *init, u32 reg)
+{
+        /* C51 (at least) sometimes has the lower bits set which the VBIOS
+         * interprets to mean that access needs to go through certain IO
+         * ports instead.  The NVIDIA binary driver has been seen to access
+         * these through the NV register address, so lets assume we can
+         * do the same
+         */
+        reg &= ~0x00000003;
+
+        /* GF8+ display scripts need register addresses mangled a bit to
+         * select a specific CRTC/OR
+         */
+        if (nv_device(init->bios)->card_type >= NV_50) {
+                if (reg & 0x80000000) {
+                        reg += init_crtc(init) * 0x800;
+                        reg &= ~0x80000000;
+                }
+
+                if (reg & 0x40000000) {
+                        reg += init_or(init) * 0x800;
+                        reg &= ~0x40000000;
+                        if (reg & 0x20000000) {
+                                reg += init_link(init) * 0x80;
+                                reg &= ~0x20000000;
+                        }
+                }
+        }
+
+        if (reg & ~0x00fffffc)
+                warn("unknown bits in register 0x%08x\n", reg);
+        return reg;
+}
+
+static u32
+init_rd32(struct nvbios_init *init, u32 reg)
+{
+        reg = init_nvreg(init, reg);
+        if (init_exec(init))
+                return nv_rd32(init->subdev, reg);
+        return 0x00000000;
+}
+
+static void
+init_wr32(struct nvbios_init *init, u32 reg, u32 val)
+{
+        reg = init_nvreg(init, reg);
+        if (init_exec(init))
+                nv_wr32(init->subdev, reg, val);
+}
+
+static u32
+init_mask(struct nvbios_init *init, u32 reg, u32 mask, u32 val)
+{
+        reg = init_nvreg(init, reg);
+        if (init_exec(init)) {
+                u32 tmp = nv_rd32(init->subdev, reg);
+                nv_wr32(init->subdev, reg, (tmp & ~mask) | val);
+                return tmp;
+        }
+        return 0x00000000;
+}
+
+static u8
+init_rdport(struct nvbios_init *init, u16 port)
+{
+        if (init_exec(init))
+                return nv_rdport(init->subdev, init->crtc, port);
+        return 0x00;
+}
+
+static void
+init_wrport(struct nvbios_init *init, u16 port, u8 value)
+{
+        if (init_exec(init))
+                nv_wrport(init->subdev, init->crtc, port, value);
+}
+
+static u8
+init_rdvgai(struct nvbios_init *init, u16 port, u8 index)
+{
+        struct nouveau_subdev *subdev = init->subdev;
+        if (init_exec(init)) {
+                int head = init->crtc < 0 ? 0 : init->crtc;
+                return nv_rdvgai(subdev, head, port, index);
+        }
+        return 0x00;
+}
+
+static void
+init_wrvgai(struct nvbios_init *init, u16 port, u8 index, u8 value)
+{
+        /* force head 0 for updates to cr44, it only exists on first head */
+        if (nv_device(init->subdev)->card_type < NV_50) {
+                if (port == 0x03d4 && index == 0x44)
+                        init->crtc = 0;
+        }
+
+        if (init_exec(init)) {
+                int head = init->crtc < 0 ? 0 : init->crtc;
+                nv_wrvgai(init->subdev, head, port, index, value);
+        }
+
+        /* select head 1 if cr44 write selected it */
+        if (nv_device(init->subdev)->card_type < NV_50) {
+                if (port == 0x03d4 && index == 0x44 && value == 3)
+                        init->crtc = 1;
+        }
+}
+
+static struct nouveau_i2c_port *
+init_i2c(struct nvbios_init *init, int index)
+{
+        struct nouveau_i2c *i2c = nouveau_i2c(init->bios);
+
+        if (index == 0xff) {
+                index = NV_I2C_DEFAULT(0);
+                if (init->outp && init->outp->i2c_upper_default)
+                        index = NV_I2C_DEFAULT(1);
+        } else
+        if (index < 0) {
+                if (!init->outp) {
+                        error("script needs output for i2c\n");
+                        return NULL;
+                }
+
+                index = init->outp->i2c_index;
+        }
+
+        return i2c->find(i2c, index);
+}
+
+static int
+init_rdi2cr(struct nvbios_init *init, u8 index, u8 addr, u8 reg)
+{
+        struct nouveau_i2c_port *port = init_i2c(init, index);
+        if (port && init_exec(init))
+                return nv_rdi2cr(port, addr, reg);
+        return -ENODEV;
+}
+
+static int
+init_wri2cr(struct nvbios_init *init, u8 index, u8 addr, u8 reg, u8 val)
+{
+        struct nouveau_i2c_port *port = init_i2c(init, index);
+        if (port && init_exec(init))
+                return nv_wri2cr(port, addr, reg, val);
+        return -ENODEV;
+}
+
+static int
+init_rdauxr(struct nvbios_init *init, u32 addr)
+{
+        struct nouveau_i2c_port *port = init_i2c(init, -1);
+        u8 data;
+
+        if (port && init_exec(init)) {
+                int ret = nv_rdaux(port, addr, &data, 1);
+                if (ret)
+                        return ret;
+                return data;
+        }
+
+        return -ENODEV;
+}
+
+static int
+init_wrauxr(struct nvbios_init *init, u32 addr, u8 data)
+{
+        struct nouveau_i2c_port *port = init_i2c(init, -1);
+        if (port && init_exec(init))
+                return nv_wraux(port, addr, &data, 1);
+        return -ENODEV;
+}
+
+static void
+init_prog_pll(struct nvbios_init *init, u32 id, u32 freq)
+{
+        struct nouveau_clock *clk = nouveau_clock(init->bios);
+        if (clk && clk->pll_set && init_exec(init)) {
+                int ret = clk->pll_set(clk, id, freq);
+                if (ret)
+                        warn("failed to prog pll 0x%08x to %dkHz\n", id, freq);
+        }
+}
+
+/******************************************************************************
+ * parsing of bios structures that are required to execute init tables
+ *****************************************************************************/
+
+static u16
+init_table(struct nouveau_bios *bios, u16 *len)
+{
+        struct bit_entry bit_I;
+
+        if (!bit_entry(bios, 'I', &bit_I)) {
+                *len = bit_I.length;
+                return bit_I.offset;
+        }
+
+        if (bmp_version(bios) >= 0x0510) {
+                *len = 14;
+                return bios->bmp_offset + 75;
+        }
+
+        return 0x0000;
+}
+
+static u16
+init_table_(struct nvbios_init *init, u16 offset, const char *name)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 len, data = init_table(bios, &len);
+        if (data) {
+                if (len >= offset + 2) {
+                        data = nv_ro16(bios, data + offset);
+                        if (data)
+                                return data;
+
+                        warn("%s pointer invalid\n", name);
+                        return 0x0000;
+                }
+
+                warn("init data too short for %s pointer", name);
+                return 0x0000;
+        }
+
+        warn("init data not found\n");
+        return 0x0000;
+}
+
+#define init_script_table(b) init_table_((b), 0x00, "script table")
+#define init_macro_index_table(b) init_table_((b), 0x02, "macro index table")
+#define init_macro_table(b) init_table_((b), 0x04, "macro table")
+#define init_condition_table(b) init_table_((b), 0x06, "condition table")
+#define init_io_condition_table(b) init_table_((b), 0x08, "io condition table")
+#define init_io_flag_condition_table(b) init_table_((b), 0x0a, "io flag conditon table")
+#define init_function_table(b) init_table_((b), 0x0c, "function table")
+#define init_xlat_table(b) init_table_((b), 0x10, "xlat table");
+
+static u16
+init_script(struct nouveau_bios *bios, int index)
+{
+        struct nvbios_init init = { .bios = bios };
+        u16 data;
+
+        if (bmp_version(bios) && bmp_version(bios) < 0x0510) {
+                if (index > 1)
+                        return 0x0000;
+
+                data = bios->bmp_offset + (bios->version.major < 2 ? 14 : 18);
+                return nv_ro16(bios, data + (index * 2));
+        }
+
+        data = init_script_table(&init);
+        if (data)
+                return nv_ro16(bios, data + (index * 2));
+
+        return 0x0000;
+}
+
+static u16
+init_unknown_script(struct nouveau_bios *bios)
+{
+        u16 len, data = init_table(bios, &len);
+        if (data && len >= 16)
+                return nv_ro16(bios, data + 14);
+        return 0x0000;
+}
+
+static u16
+init_ram_restrict_table(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        struct bit_entry bit_M;
+        u16 data = 0x0000;
+
+        if (!bit_entry(bios, 'M', &bit_M)) {
+                if (bit_M.version == 1 && bit_M.length >= 5)
+                        data = nv_ro16(bios, bit_M.offset + 3);
+                if (bit_M.version == 2 && bit_M.length >= 3)
+                        data = nv_ro16(bios, bit_M.offset + 1);
+        }
+
+        if (data == 0x0000)
+                warn("ram restrict table not found\n");
+        return data;
+}
+
+static u8
+init_ram_restrict_group_count(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        struct bit_entry bit_M;
+
+        if (!bit_entry(bios, 'M', &bit_M)) {
+                if (bit_M.version == 1 && bit_M.length >= 5)
+                        return nv_ro08(bios, bit_M.offset + 2);
+                if (bit_M.version == 2 && bit_M.length >= 3)
+                        return nv_ro08(bios, bit_M.offset + 0);
+        }
+
+        return 0x00;
+}
+
+static u8
+init_ram_restrict(struct nvbios_init *init)
+{
+        u32 strap = (init_rd32(init, 0x101000) & 0x0000003c) >> 2;
+        u16 table = init_ram_restrict_table(init);
+        if (table)
+                return nv_ro08(init->bios, table + strap);
+        return 0x00;
+}
+
+static u8
+init_xlat_(struct nvbios_init *init, u8 index, u8 offset)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 table = init_xlat_table(init);
+        if (table) {
+                u16 data = nv_ro16(bios, table + (index * 2));
+                if (data)
+                        return nv_ro08(bios, data + offset);
+                warn("xlat table pointer %d invalid\n", index);
+        }
+        return 0x00;
+}
+
+/******************************************************************************
+ * utility functions used by various init opcode handlers
+ *****************************************************************************/
+
+static bool
+init_condition_met(struct nvbios_init *init, u8 cond)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 table = init_condition_table(init);
+        if (table) {
+                u32 reg = nv_ro32(bios, table + (cond * 12) + 0);
+                u32 msk = nv_ro32(bios, table + (cond * 12) + 4);
+                u32 val = nv_ro32(bios, table + (cond * 12) + 8);
+                trace("\t[0x%02x] (R[0x%06x] & 0x%08x) == 0x%08x\n",
+                      cond, reg, msk, val);
+                return (init_rd32(init, reg) & msk) == val;
+        }
+        return false;
+}
+
+static bool
+init_io_condition_met(struct nvbios_init *init, u8 cond)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 table = init_io_condition_table(init);
+        if (table) {
+                u16 port = nv_ro16(bios, table + (cond * 5) + 0);
+                u8 index = nv_ro08(bios, table + (cond * 5) + 2);
+                u8  mask = nv_ro08(bios, table + (cond * 5) + 3);
+                u8 value = nv_ro08(bios, table + (cond * 5) + 4);
+                trace("\t[0x%02x] (0x%04x[0x%02x] & 0x%02x) == 0x%02x\n",
+                      cond, port, index, mask, value);
+                return (init_rdvgai(init, port, index) & mask) == value;
+        }
+        return false;
+}
+
+static bool
+init_io_flag_condition_met(struct nvbios_init *init, u8 cond)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 table = init_io_flag_condition_table(init);
+        if (table) {
+                u16 port = nv_ro16(bios, table + (cond * 9) + 0);
+                u8 index = nv_ro08(bios, table + (cond * 9) + 2);
+                u8  mask = nv_ro08(bios, table + (cond * 9) + 3);
+                u8 shift = nv_ro08(bios, table + (cond * 9) + 4);
+                u16 data = nv_ro16(bios, table + (cond * 9) + 5);
+                u8 dmask = nv_ro08(bios, table + (cond * 9) + 7);
+                u8 value = nv_ro08(bios, table + (cond * 9) + 8);
+                u8 ioval = (init_rdvgai(init, port, index) & mask) >> shift;
+                return (nv_ro08(bios, data + ioval) & dmask) == value;
+        }
+        return false;
+}
+
+static inline u32
+init_shift(u32 data, u8 shift)
+{
+        if (shift < 0x80)
+                return data >> shift;
+        return data << (0x100 - shift);
+}
+
+static u32
+init_tmds_reg(struct nvbios_init *init, u8 tmds)
+{
+        /* For mlv < 0x80, it is an index into a table of TMDS base addresses.
+         * For mlv == 0x80 use the "or" value of the dcb_entry indexed by
+         * CR58 for CR57 = 0 to index a table of offsets to the basic
+         * 0x6808b0 address.
+         * For mlv == 0x81 use the "or" value of the dcb_entry indexed by
+         * CR58 for CR57 = 0 to index a table of offsets to the basic
+         * 0x6808b0 address, and then flip the offset by 8.
+         */
+
+        const int pramdac_offset[13] = {
+                0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000 };
+        const u32 pramdac_table[4] = {
+                0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8 };
+
+        if (tmds >= 0x80) {
+                if (init->outp) {
+                        u32 dacoffset = pramdac_offset[init->outp->or];
+                        if (tmds == 0x81)
+                                dacoffset ^= 8;
+                        return 0x6808b0 + dacoffset;
+                }
+
+                error("tmds opcodes need dcb\n");
+        } else {
+                if (tmds < ARRAY_SIZE(pramdac_table))
+                        return pramdac_table[tmds];
+
+                error("tmds selector 0x%02x unknown\n", tmds);
+        }
+
+        return 0;
+}
+
+/******************************************************************************
+ * init opcode handlers
+ *****************************************************************************/
+
+/**
+ * init_reserved - stub for various unknown/unused single-byte opcodes
+ *
+ */
+static void
+init_reserved(struct nvbios_init *init)
+{
+        u8 opcode = nv_ro08(init->bios, init->offset);
+        trace("RESERVED\t0x%02x\n", opcode);
+        init->offset += 1;
+}
+
+/**
+ * INIT_DONE - opcode 0x71
+ *
+ */
+static void
+init_done(struct nvbios_init *init)
+{
+        trace("DONE\n");
+        init->offset = 0x0000;
+}
+
+/**
+ * INIT_IO_RESTRICT_PROG - opcode 0x32
+ *
+ */
+static void
+init_io_restrict_prog(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 port = nv_ro16(bios, init->offset + 1);
+        u8 index = nv_ro08(bios, init->offset + 3);
+        u8  mask = nv_ro08(bios, init->offset + 4);
+        u8 shift = nv_ro08(bios, init->offset + 5);
+        u8 count = nv_ro08(bios, init->offset + 6);
+        u32  reg = nv_ro32(bios, init->offset + 7);
+        u8 conf, i;
+
+        trace("IO_RESTRICT_PROG\tR[0x%06x] = "
+              "((0x%04x[0x%02x] & 0x%02x) >> %d) [{\n",
+              reg, port, index, mask, shift);
+        init->offset += 11;
+
+        conf = (init_rdvgai(init, port, index) & mask) >> shift;
+        for (i = 0; i < count; i++) {
+                u32 data = nv_ro32(bios, init->offset);
+
+                if (i == conf) {
+                        trace("\t0x%08x *\n", data);
+                        init_wr32(init, reg, data);
+                } else {
+                        trace("\t0x%08x\n", data);
+                }
+
+                init->offset += 4;
+        }
+        trace("}]\n");
+}
+
+/**
+ * INIT_REPEAT - opcode 0x33
+ *
+ */
+static void
+init_repeat(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 count = nv_ro08(bios, init->offset + 1);
+        u16 repeat = init->repeat;
+
+        trace("REPEAT\t0x%02x\n", count);
+        init->offset += 2;
+
+        init->repeat = init->offset;
+        init->repend = init->offset;
+        while (count--) {
+                init->offset = init->repeat;
+                nvbios_exec(init);
+                if (count)
+                        trace("REPEAT\t0x%02x\n", count);
+        }
+        init->offset = init->repend;
+        init->repeat = repeat;
+}
+
+/**
+ * INIT_IO_RESTRICT_PLL - opcode 0x34
+ *
+ */
+static void
+init_io_restrict_pll(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 port = nv_ro16(bios, init->offset + 1);
+        u8 index = nv_ro08(bios, init->offset + 3);
+        u8  mask = nv_ro08(bios, init->offset + 4);
+        u8 shift = nv_ro08(bios, init->offset + 5);
+        s8  iofc = nv_ro08(bios, init->offset + 6);
+        u8 count = nv_ro08(bios, init->offset + 7);
+        u32  reg = nv_ro32(bios, init->offset + 8);
+        u8 conf, i;
+
+        trace("IO_RESTRICT_PLL\tR[0x%06x] =PLL= "
+              "((0x%04x[0x%02x] & 0x%02x) >> 0x%02x) IOFCOND 0x%02x [{\n",
+              reg, port, index, mask, shift, iofc);
+        init->offset += 12;
+
+        conf = (init_rdvgai(init, port, index) & mask) >> shift;
+        for (i = 0; i < count; i++) {
+                u32 freq = nv_ro16(bios, init->offset) * 10;
+
+                if (i == conf) {
+                        trace("\t%dkHz *\n", freq);
+                        if (iofc > 0 && init_io_flag_condition_met(init, iofc))
+                                freq *= 2;
+                        init_prog_pll(init, reg, freq);
+                } else {
+                        trace("\t%dkHz\n", freq);
+                }
+
+                init->offset += 2;
+        }
+        trace("}]\n");
+}
+
+/**
+ * INIT_END_REPEAT - opcode 0x36
+ *
+ */
+static void
+init_end_repeat(struct nvbios_init *init)
+{
+        trace("END_REPEAT\n");
+        init->offset += 1;
+
+        if (init->repeat) {
+                init->repend = init->offset;
+                init->offset = 0;
+        }
+}
+
+/**
+ * INIT_COPY - opcode 0x37
+ *
+ */
+static void
+init_copy(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32  reg = nv_ro32(bios, init->offset + 1);
+        u8 shift = nv_ro08(bios, init->offset + 5);
+        u8 smask = nv_ro08(bios, init->offset + 6);
+        u16 port = nv_ro16(bios, init->offset + 7);
+        u8 index = nv_ro08(bios, init->offset + 9);
+        u8  mask = nv_ro08(bios, init->offset + 10);
+        u8  data;
+
+        trace("COPY\t0x%04x[0x%02x] &= 0x%02x |= "
+              "((R[0x%06x] %s 0x%02x) & 0x%02x)\n",
+              port, index, mask, reg, (shift & 0x80) ? "<<" : ">>",
+              (shift & 0x80) ? (0x100 - shift) : shift, smask);
+        init->offset += 11;
+
+        data  = init_rdvgai(init, port, index) & mask;
+        data |= init_shift(init_rd32(init, reg), shift) & smask;
+        init_wrvgai(init, port, index, data);
+}
+
+/**
+ * INIT_NOT - opcode 0x38
+ *
+ */
+static void
+init_not(struct nvbios_init *init)
+{
+        trace("NOT\n");
+        init->offset += 1;
+        init_exec_inv(init);
+}
+
+/**
+ * INIT_IO_FLAG_CONDITION - opcode 0x39
+ *
+ */
+static void
+init_io_flag_condition(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 cond = nv_ro08(bios, init->offset + 1);
+
+        trace("IO_FLAG_CONDITION\t0x%02x\n", cond);
+        init->offset += 2;
+
+        if (!init_io_flag_condition_met(init, cond))
+                init_exec_set(init, false);
+}
+
+/**
+ * INIT_DP_CONDITION - opcode 0x3a
+ *
+ */
+static void
+init_dp_condition(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8  cond = nv_ro08(bios, init->offset + 1);
+        u8  unkn = nv_ro08(bios, init->offset + 2);
+        u8  ver, len;
+        u16 data;
+
+        trace("DP_CONDITION\t0x%02x 0x%02x\n", cond, unkn);
+        init->offset += 3;
+
+        switch (cond) {
+        case 0:
+                if (init_conn(init) != DCB_CONNECTOR_eDP)
+                        init_exec_set(init, false);
+                break;
+        case 1:
+        case 2:
+                if ( init->outp &&
+                    (data = dp_outp_match(bios, init->outp, &ver, &len))) {
+                        if (ver <= 0x40 && !(nv_ro08(bios, data + 5) & cond))
+                                init_exec_set(init, false);
+                        if (ver == 0x40 && !(nv_ro08(bios, data + 4) & cond))
+                                init_exec_set(init, false);
+                        break;
+                }
+
+                warn("script needs dp output table data\n");
+                break;
+        case 5:
+                if (!(init_rdauxr(init, 0x0d) & 1))
+                        init_exec_set(init, false);
+                break;
+        default:
+                warn("unknown dp condition 0x%02x\n", cond);
+                break;
+        }
+}
+
+/**
+ * INIT_IO_MASK_OR - opcode 0x3b
+ *
+ */
+static void
+init_io_mask_or(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8    or = init_or(init);
+        u8  data;
+
+        trace("IO_MASK_OR\t0x03d4[0x%02x] &= ~(1 << 0x%02x)", index, or);
+        init->offset += 2;
+
+        data = init_rdvgai(init, 0x03d4, index);
+        init_wrvgai(init, 0x03d4, index, data &= ~(1 << or));
+}
+
+/**
+ * INIT_IO_OR - opcode 0x3c
+ *
+ */
+static void
+init_io_or(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8    or = init_or(init);
+        u8  data;
+
+        trace("IO_OR\t0x03d4[0x%02x] |= (1 << 0x%02x)", index, or);
+        init->offset += 2;
+
+        data = init_rdvgai(init, 0x03d4, index);
+        init_wrvgai(init, 0x03d4, index, data | (1 << or));
+}
+
+/**
+ * INIT_INDEX_ADDRESS_LATCHED - opcode 0x49
+ *
+ */
+static void
+init_idx_addr_latched(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 creg = nv_ro32(bios, init->offset + 1);
+        u32 dreg = nv_ro32(bios, init->offset + 5);
+        u32 mask = nv_ro32(bios, init->offset + 9);
+        u32 data = nv_ro32(bios, init->offset + 13);
+        u8 count = nv_ro08(bios, init->offset + 17);
+
+        trace("INDEX_ADDRESS_LATCHED\t"
+              "R[0x%06x] : R[0x%06x]\n\tCTRL &= 0x%08x |= 0x%08x\n",
+              creg, dreg, mask, data);
+        init->offset += 18;
+
+        while (count--) {
+                u8 iaddr = nv_ro08(bios, init->offset + 0);
+                u8 idata = nv_ro08(bios, init->offset + 1);
+
+                trace("\t[0x%02x] = 0x%02x\n", iaddr, idata);
+                init->offset += 2;
+
+                init_wr32(init, dreg, idata);
+                init_mask(init, creg, ~mask, data | idata);
+        }
+}
+
+/**
+ * INIT_IO_RESTRICT_PLL2 - opcode 0x4a
+ *
+ */
+static void
+init_io_restrict_pll2(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 port = nv_ro16(bios, init->offset + 1);
+        u8 index = nv_ro08(bios, init->offset + 3);
+        u8  mask = nv_ro08(bios, init->offset + 4);
+        u8 shift = nv_ro08(bios, init->offset + 5);
+        u8 count = nv_ro08(bios, init->offset + 6);
+        u32  reg = nv_ro32(bios, init->offset + 7);
+        u8  conf, i;
+
+        trace("IO_RESTRICT_PLL2\t"
+              "R[0x%06x] =PLL= ((0x%04x[0x%02x] & 0x%02x) >> 0x%02x) [{\n",
+              reg, port, index, mask, shift);
+        init->offset += 11;
+
+        conf = (init_rdvgai(init, port, index) & mask) >> shift;
+        for (i = 0; i < count; i++) {
+                u32 freq = nv_ro32(bios, init->offset);
+                if (i == conf) {
+                        trace("\t%dkHz *\n", freq);
+                        init_prog_pll(init, reg, freq);
+                } else {
+                        trace("\t%dkHz\n", freq);
+                }
+                init->offset += 4;
+        }
+        trace("}]\n");
+}
+
+/**
+ * INIT_PLL2 - opcode 0x4b
+ *
+ */
+static void
+init_pll2(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32  reg = nv_ro32(bios, init->offset + 1);
+        u32 freq = nv_ro32(bios, init->offset + 5);
+
+        trace("PLL2\tR[0x%06x] =PLL= %dkHz\n", reg, freq);
+        init->offset += 9;
+
+        init_prog_pll(init, reg, freq);
+}
+
+/**
+ * INIT_I2C_BYTE - opcode 0x4c
+ *
+ */
+static void
+init_i2c_byte(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
+        u8 count = nv_ro08(bios, init->offset + 3);
+
+        trace("I2C_BYTE\tI2C[0x%02x][0x%02x]\n", index, addr);
+        init->offset += 4;
+
+        while (count--) {
+                u8  reg = nv_ro08(bios, init->offset + 0);
+                u8 mask = nv_ro08(bios, init->offset + 1);
+                u8 data = nv_ro08(bios, init->offset + 2);
+                int val;
+
+                trace("\t[0x%02x] &= 0x%02x |= 0x%02x\n", reg, mask, data);
+                init->offset += 3;
+
+                val = init_rdi2cr(init, index, addr, reg);
+                if (val < 0)
+                        continue;
+                init_wri2cr(init, index, addr, reg, (val & mask) | data);
+        }
+}
+
+/**
+ * INIT_ZM_I2C_BYTE - opcode 0x4d
+ *
+ */
+static void
+init_zm_i2c_byte(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
+        u8 count = nv_ro08(bios, init->offset + 3);
+
+        trace("ZM_I2C_BYTE\tI2C[0x%02x][0x%02x]\n", index, addr);
+        init->offset += 4;
+
+        while (count--) {
+                u8  reg = nv_ro08(bios, init->offset + 0);
+                u8 data = nv_ro08(bios, init->offset + 1);
+
+                trace("\t[0x%02x] = 0x%02x\n", reg, data);
+                init->offset += 2;
+
+                init_wri2cr(init, index, addr, reg, data);
+        }
+
+}
+
+/**
+ * INIT_ZM_I2C - opcode 0x4e
+ *
+ */
+static void
+init_zm_i2c(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
+        u8 count = nv_ro08(bios, init->offset + 3);
+        u8 data[256], i;
+
+        trace("ZM_I2C\tI2C[0x%02x][0x%02x]\n", index, addr);
+        init->offset += 4;
+
+        for (i = 0; i < count; i++) {
+                data[i] = nv_ro08(bios, init->offset);
+                trace("\t0x%02x\n", data[i]);
+                init->offset++;
+        }
+
+        if (init_exec(init)) {
+                struct nouveau_i2c_port *port = init_i2c(init, index);
+                struct i2c_msg msg = {
+                        .addr = addr, .flags = 0, .len = count, .buf = data,
+                };
+                int ret;
+
+                if (port && (ret = i2c_transfer(&port->adapter, &msg, 1)) != 1)
+                        warn("i2c wr failed, %d\n", ret);
+        }
+}
+
+/**
+ * INIT_TMDS - opcode 0x4f
+ *
+ */
+static void
+init_tmds(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 tmds = nv_ro08(bios, init->offset + 1);
+        u8 addr = nv_ro08(bios, init->offset + 2);
+        u8 mask = nv_ro08(bios, init->offset + 3);
+        u8 data = nv_ro08(bios, init->offset + 4);
+        u32 reg = init_tmds_reg(init, tmds);
+
+        trace("TMDS\tT[0x%02x][0x%02x] &= 0x%02x |= 0x%02x\n",
+              tmds, addr, mask, data);
+        init->offset += 5;
+
+        if (reg == 0)
+                return;
+
+        init_wr32(init, reg + 0, addr | 0x00010000);
+        init_wr32(init, reg + 4, data | (init_rd32(init, reg + 4) & mask));
+        init_wr32(init, reg + 0, addr);
+}
+
+/**
+ * INIT_ZM_TMDS_GROUP - opcode 0x50
+ *
+ */
+static void
+init_zm_tmds_group(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8  tmds = nv_ro08(bios, init->offset + 1);
+        u8 count = nv_ro08(bios, init->offset + 2);
+        u32  reg = init_tmds_reg(init, tmds);
+
+        trace("TMDS_ZM_GROUP\tT[0x%02x]\n", tmds);
+        init->offset += 3;
+
+        while (count--) {
+                u8 addr = nv_ro08(bios, init->offset + 0);
+                u8 data = nv_ro08(bios, init->offset + 1);
+
+                trace("\t[0x%02x] = 0x%02x\n", addr, data);
+                init->offset += 2;
+
+                init_wr32(init, reg + 4, data);
+                init_wr32(init, reg + 0, addr);
+        }
+}
+
+/**
+ * INIT_CR_INDEX_ADDRESS_LATCHED - opcode 0x51
+ *
+ */
+static void
+init_cr_idx_adr_latch(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 addr0 = nv_ro08(bios, init->offset + 1);
+        u8 addr1 = nv_ro08(bios, init->offset + 2);
+        u8  base = nv_ro08(bios, init->offset + 3);
+        u8 count = nv_ro08(bios, init->offset + 4);
+        u8 save0;
+
+        trace("CR_INDEX_ADDR C[%02x] C[%02x]\n", addr0, addr1);
+        init->offset += 5;
+
+        save0 = init_rdvgai(init, 0x03d4, addr0);
+        while (count--) {
+                u8 data = nv_ro08(bios, init->offset);
+
+                trace("\t\t[0x%02x] = 0x%02x\n", base, data);
+                init->offset += 1;
+
+                init_wrvgai(init, 0x03d4, addr0, base++);
+                init_wrvgai(init, 0x03d4, addr1, data);
+        }
+        init_wrvgai(init, 0x03d4, addr0, save0);
+}
+
+/**
+ * INIT_CR - opcode 0x52
+ *
+ */
+static void
+init_cr(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 addr = nv_ro08(bios, init->offset + 1);
+        u8 mask = nv_ro08(bios, init->offset + 2);
+        u8 data = nv_ro08(bios, init->offset + 3);
+        u8 val;
+
+        trace("CR\t\tC[0x%02x] &= 0x%02x |= 0x%02x\n", addr, mask, data);
+        init->offset += 4;
+
+        val = init_rdvgai(init, 0x03d4, addr) & mask;
+        init_wrvgai(init, 0x03d4, addr, val | data);
+}
+
+/**
+ * INIT_ZM_CR - opcode 0x53
+ *
+ */
+static void
+init_zm_cr(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 addr = nv_ro08(bios, init->offset + 1);
+        u8 data = nv_ro08(bios, init->offset + 2);
+
+        trace("ZM_CR\tC[0x%02x] = 0x%02x\n", addr,  data);
+        init->offset += 3;
+
+        init_wrvgai(init, 0x03d4, addr, data);
+}
+
+/**
+ * INIT_ZM_CR_GROUP - opcode 0x54
+ *
+ */
+static void
+init_zm_cr_group(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 count = nv_ro08(bios, init->offset + 1);
+
+        trace("ZM_CR_GROUP\n");
+        init->offset += 2;
+
+        while (count--) {
+                u8 addr = nv_ro08(bios, init->offset + 0);
+                u8 data = nv_ro08(bios, init->offset + 1);
+
+                trace("\t\tC[0x%02x] = 0x%02x\n", addr, data);
+                init->offset += 2;
+
+                init_wrvgai(init, 0x03d4, addr, data);
+        }
+}
+
+/**
+ * INIT_CONDITION_TIME - opcode 0x56
+ *
+ */
+static void
+init_condition_time(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8  cond = nv_ro08(bios, init->offset + 1);
+        u8 retry = nv_ro08(bios, init->offset + 2);
+        u8  wait = min((u16)retry * 50, 100);
+
+        trace("CONDITION_TIME\t0x%02x 0x%02x\n", cond, retry);
+        init->offset += 3;
+
+        if (!init_exec(init))
+                return;
+
+        while (wait--) {
+                if (init_condition_met(init, cond))
+                        return;
+                mdelay(20);
+        }
+
+        init_exec_set(init, false);
+}
+
+/**
+ * INIT_LTIME - opcode 0x57
+ *
+ */
+static void
+init_ltime(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 msec = nv_ro16(bios, init->offset + 1);
+
+        trace("LTIME\t0x%04x\n", msec);
+        init->offset += 3;
+
+        if (init_exec(init))
+                mdelay(msec);
+}
+
+/**
+ * INIT_ZM_REG_SEQUENCE - opcode 0x58
+ *
+ */
+static void
+init_zm_reg_sequence(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 base = nv_ro32(bios, init->offset + 1);
+        u8 count = nv_ro08(bios, init->offset + 5);
+
+        trace("ZM_REG_SEQUENCE\t0x%02x\n", count);
+        init->offset += 6;
+
+        while (count--) {
+                u32 data = nv_ro32(bios, init->offset);
+
+                trace("\t\tR[0x%06x] = 0x%08x\n", base, data);
+                init->offset += 4;
+
+                init_wr32(init, base, data);
+                base += 4;
+        }
+}
+
+/**
+ * INIT_SUB_DIRECT - opcode 0x5b
+ *
+ */
+static void
+init_sub_direct(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 addr = nv_ro16(bios, init->offset + 1);
+        u16 save;
+
+        trace("SUB_DIRECT\t0x%04x\n", addr);
+
+        if (init_exec(init)) {
+                save = init->offset;
+                init->offset = addr;
+                if (nvbios_exec(init)) {
+                        error("error parsing sub-table\n");
+                        return;
+                }
+                init->offset = save;
+        }
+
+        init->offset += 3;
+}
+
+/**
+ * INIT_JUMP - opcode 0x5c
+ *
+ */
+static void
+init_jump(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 offset = nv_ro16(bios, init->offset + 1);
+
+        trace("JUMP\t0x%04x\n", offset);
+        init->offset = offset;
+}
+
+/**
+ * INIT_I2C_IF - opcode 0x5e
+ *
+ */
+static void
+init_i2c_if(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8  addr = nv_ro08(bios, init->offset + 2);
+        u8   reg = nv_ro08(bios, init->offset + 3);
+        u8  mask = nv_ro08(bios, init->offset + 4);
+        u8  data = nv_ro08(bios, init->offset + 5);
+        u8 value;
+
+        trace("I2C_IF\tI2C[0x%02x][0x%02x][0x%02x] & 0x%02x == 0x%02x\n",
+              index, addr, reg, mask, data);
+        init->offset += 6;
+        init_exec_force(init, true);
+
+        value = init_rdi2cr(init, index, addr, reg);
+        if ((value & mask) != data)
+                init_exec_set(init, false);
+
+        init_exec_force(init, false);
+}
+
+/**
+ * INIT_COPY_NV_REG - opcode 0x5f
+ *
+ */
+static void
+init_copy_nv_reg(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32  sreg = nv_ro32(bios, init->offset + 1);
+        u8  shift = nv_ro08(bios, init->offset + 5);
+        u32 smask = nv_ro32(bios, init->offset + 6);
+        u32  sxor = nv_ro32(bios, init->offset + 10);
+        u32  dreg = nv_ro32(bios, init->offset + 14);
+        u32 dmask = nv_ro32(bios, init->offset + 18);
+        u32 data;
+
+        trace("COPY_NV_REG\tR[0x%06x] &= 0x%08x |= "
+              "((R[0x%06x] %s 0x%02x) & 0x%08x ^ 0x%08x)\n",
+              dreg, dmask, sreg, (shift & 0x80) ? "<<" : ">>",
+              (shift & 0x80) ? (0x100 - shift) : shift, smask, sxor);
+        init->offset += 22;
+
+        data = init_shift(init_rd32(init, sreg), shift);
+        init_mask(init, dreg, ~dmask, (data & smask) ^ sxor);
+}
+
+/**
+ * INIT_ZM_INDEX_IO - opcode 0x62
+ *
+ */
+static void
+init_zm_index_io(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 port = nv_ro16(bios, init->offset + 1);
+        u8 index = nv_ro08(bios, init->offset + 3);
+        u8  data = nv_ro08(bios, init->offset + 4);
+
+        trace("ZM_INDEX_IO\tI[0x%04x][0x%02x] = 0x%02x\n", port, index, data);
+        init->offset += 5;
+
+        init_wrvgai(init, port, index, data);
+}
+
+/**
+ * INIT_COMPUTE_MEM - opcode 0x63
+ *
+ */
+static void
+init_compute_mem(struct nvbios_init *init)
+{
+        struct nouveau_devinit *devinit = nouveau_devinit(init->bios);
+
+        trace("COMPUTE_MEM\n");
+        init->offset += 1;
+
+        init_exec_force(init, true);
+        if (init_exec(init) && devinit->meminit)
+                devinit->meminit(devinit);
+        init_exec_force(init, false);
+}
+
+/**
+ * INIT_RESET - opcode 0x65
+ *
+ */
+static void
+init_reset(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32   reg = nv_ro32(bios, init->offset + 1);
+        u32 data1 = nv_ro32(bios, init->offset + 5);
+        u32 data2 = nv_ro32(bios, init->offset + 9);
+        u32 savepci19;
+
+        trace("RESET\tR[0x%08x] = 0x%08x, 0x%08x", reg, data1, data2);
+        init->offset += 13;
+        init_exec_force(init, true);
+
+        savepci19 = init_mask(init, 0x00184c, 0x00000f00, 0x00000000);
+        init_wr32(init, reg, data1);
+        udelay(10);
+        init_wr32(init, reg, data2);
+        init_wr32(init, 0x00184c, savepci19);
+        init_mask(init, 0x001850, 0x00000001, 0x00000000);
+
+        init_exec_force(init, false);
+}
+
+/**
+ * INIT_CONFIGURE_MEM - opcode 0x66
+ *
+ */
+static u16
+init_configure_mem_clk(struct nvbios_init *init)
+{
+        u16 mdata = bmp_mem_init_table(init->bios);
+        if (mdata)
+                mdata += (init_rdvgai(init, 0x03d4, 0x3c) >> 4) * 66;
+        return mdata;
+}
+
+static void
+init_configure_mem(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 mdata, sdata;
+        u32 addr, data;
+
+        trace("CONFIGURE_MEM\n");
+        init->offset += 1;
+
+        if (bios->version.major > 2) {
+                init_done(init);
+                return;
+        }
+        init_exec_force(init, true);
+
+        mdata = init_configure_mem_clk(init);
+        sdata = bmp_sdr_seq_table(bios);
+        if (nv_ro08(bios, mdata) & 0x01)
+                sdata = bmp_ddr_seq_table(bios);
+        mdata += 6; /* skip to data */
+
+        data = init_rdvgai(init, 0x03c4, 0x01);
+        init_wrvgai(init, 0x03c4, 0x01, data | 0x20);
+
+        while ((addr = nv_ro32(bios, sdata)) != 0xffffffff) {
+                switch (addr) {
+                case 0x10021c: /* CKE_NORMAL */
+                case 0x1002d0: /* CMD_REFRESH */
+                case 0x1002d4: /* CMD_PRECHARGE */
+                        data = 0x00000001;
+                        break;
+                default:
+                        data = nv_ro32(bios, mdata);
+                        mdata += 4;
+                        if (data == 0xffffffff)
+                                continue;
+                        break;
+                }
+
+                init_wr32(init, addr, data);
+        }
+
+        init_exec_force(init, false);
+}
+
+/**
+ * INIT_CONFIGURE_CLK - opcode 0x67
+ *
+ */
+static void
+init_configure_clk(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 mdata, clock;
+
+        trace("CONFIGURE_CLK\n");
+        init->offset += 1;
+
+        if (bios->version.major > 2) {
+                init_done(init);
+                return;
+        }
+        init_exec_force(init, true);
+
+        mdata = init_configure_mem_clk(init);
+
+        /* NVPLL */
+        clock = nv_ro16(bios, mdata + 4) * 10;
+        init_prog_pll(init, 0x680500, clock);
+
+        /* MPLL */
+        clock = nv_ro16(bios, mdata + 2) * 10;
+        if (nv_ro08(bios, mdata) & 0x01)
+                clock *= 2;
+        init_prog_pll(init, 0x680504, clock);
+
+        init_exec_force(init, false);
+}
+
+/**
+ * INIT_CONFIGURE_PREINIT - opcode 0x68
+ *
+ */
+static void
+init_configure_preinit(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 strap;
+
+        trace("CONFIGURE_PREINIT\n");
+        init->offset += 1;
+
+        if (bios->version.major > 2) {
+                init_done(init);
+                return;
+        }
+        init_exec_force(init, true);
+
+        strap = init_rd32(init, 0x101000);
+        strap = ((strap << 2) & 0xf0) | ((strap & 0x40) >> 6);
+        init_wrvgai(init, 0x03d4, 0x3c, strap);
+
+        init_exec_force(init, false);
+}
+
+/**
+ * INIT_IO - opcode 0x69
+ *
+ */
+static void
+init_io(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 port = nv_ro16(bios, init->offset + 1);
+        u8  mask = nv_ro16(bios, init->offset + 3);
+        u8  data = nv_ro16(bios, init->offset + 4);
+        u8 value;
+
+        trace("IO\t\tI[0x%04x] &= 0x%02x |= 0x%02x\n", port, mask, data);
+        init->offset += 5;
+
+        /* ummm.. yes.. should really figure out wtf this is and why it's
+         * needed some day..  it's almost certainly wrong, but, it also
+         * somehow makes things work...
+         */
+        if (nv_device(init->bios)->card_type >= NV_50 &&
+            port == 0x03c3 && data == 0x01) {
+                init_mask(init, 0x614100, 0xf0800000, 0x00800000);
+                init_mask(init, 0x00e18c, 0x00020000, 0x00020000);
+                init_mask(init, 0x614900, 0xf0800000, 0x00800000);
+                init_mask(init, 0x000200, 0x40000000, 0x00000000);
+                mdelay(10);
+                init_mask(init, 0x00e18c, 0x00020000, 0x00000000);
+                init_mask(init, 0x000200, 0x40000000, 0x40000000);
+                init_wr32(init, 0x614100, 0x00800018);
+                init_wr32(init, 0x614900, 0x00800018);
+                mdelay(10);
+                init_wr32(init, 0x614100, 0x10000018);
+                init_wr32(init, 0x614900, 0x10000018);
+                return;
+        }
+
+        value = init_rdport(init, port) & mask;
+        init_wrport(init, port, data | value);
+}
+
+/**
+ * INIT_SUB - opcode 0x6b
+ *
+ */
+static void
+init_sub(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u16 addr, save;
+
+        trace("SUB\t0x%02x\n", index);
+
+        addr = init_script(bios, index);
+        if (addr && init_exec(init)) {
+                save = init->offset;
+                init->offset = addr;
+                if (nvbios_exec(init)) {
+                        error("error parsing sub-table\n");
+                        return;
+                }
+                init->offset = save;
+        }
+
+        init->offset += 2;
+}
+
+/**
+ * INIT_RAM_CONDITION - opcode 0x6d
+ *
+ */
+static void
+init_ram_condition(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8  mask = nv_ro08(bios, init->offset + 1);
+        u8 value = nv_ro08(bios, init->offset + 2);
+
+        trace("RAM_CONDITION\t"
+              "(R[0x100000] & 0x%02x) == 0x%02x\n", mask, value);
+        init->offset += 3;
+
+        if ((init_rd32(init, 0x100000) & mask) != value)
+                init_exec_set(init, false);
+}
+
+/**
+ * INIT_NV_REG - opcode 0x6e
+ *
+ */
+static void
+init_nv_reg(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32  reg = nv_ro32(bios, init->offset + 1);
+        u32 mask = nv_ro32(bios, init->offset + 5);
+        u32 data = nv_ro32(bios, init->offset + 9);
+
+        trace("NV_REG\tR[0x%06x] &= 0x%08x |= 0x%08x\n", reg, mask, data);
+        init->offset += 13;
+
+        init_mask(init, reg, ~mask, data);
+}
+
+/**
+ * INIT_MACRO - opcode 0x6f
+ *
+ */
+static void
+init_macro(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8  macro = nv_ro08(bios, init->offset + 1);
+        u16 table;
+
+        trace("MACRO\t0x%02x\n", macro);
+
+        table = init_macro_table(init);
+        if (table) {
+                u32 addr = nv_ro32(bios, table + (macro * 8) + 0);
+                u32 data = nv_ro32(bios, table + (macro * 8) + 4);
+                trace("\t\tR[0x%06x] = 0x%08x\n", addr, data);
+                init_wr32(init, addr, data);
+        }
+
+        init->offset += 2;
+}
+
+/**
+ * INIT_RESUME - opcode 0x72
+ *
+ */
+static void
+init_resume(struct nvbios_init *init)
+{
+        trace("RESUME\n");
+        init->offset += 1;
+        init_exec_set(init, true);
+}
+
+/**
+ * INIT_TIME - opcode 0x74
+ *
+ */
+static void
+init_time(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 usec = nv_ro16(bios, init->offset + 1);
+
+        trace("TIME\t0x%04x\n", usec);
+        init->offset += 3;
+
+        if (init_exec(init)) {
+                if (usec < 1000)
+                        udelay(usec);
+                else
+                        mdelay((usec + 900) / 1000);
+        }
+}
+
+/**
+ * INIT_CONDITION - opcode 0x75
+ *
+ */
+static void
+init_condition(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 cond = nv_ro08(bios, init->offset + 1);
+
+        trace("CONDITION\t0x%02x\n", cond);
+        init->offset += 2;
+
+        if (!init_condition_met(init, cond))
+                init_exec_set(init, false);
+}
+
+/**
+ * INIT_IO_CONDITION - opcode 0x76
+ *
+ */
+static void
+init_io_condition(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 cond = nv_ro08(bios, init->offset + 1);
+
+        trace("IO_CONDITION\t0x%02x\n", cond);
+        init->offset += 2;
+
+        if (!init_io_condition_met(init, cond))
+                init_exec_set(init, false);
+}
+
+/**
+ * INIT_INDEX_IO - opcode 0x78
+ *
+ */
+static void
+init_index_io(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u16 port = nv_ro16(bios, init->offset + 1);
+        u8 index = nv_ro16(bios, init->offset + 3);
+        u8  mask = nv_ro08(bios, init->offset + 4);
+        u8  data = nv_ro08(bios, init->offset + 5);
+        u8 value;
+
+        trace("INDEX_IO\tI[0x%04x][0x%02x] &= 0x%02x |= 0x%02x\n",
+              port, index, mask, data);
+        init->offset += 6;
+
+        value = init_rdvgai(init, port, index) & mask;
+        init_wrvgai(init, port, index, data | value);
+}
+
+/**
+ * INIT_PLL - opcode 0x79
+ *
+ */
+static void
+init_pll(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32  reg = nv_ro32(bios, init->offset + 1);
+        u32 freq = nv_ro16(bios, init->offset + 5) * 10;
+
+        trace("PLL\tR[0x%06x] =PLL= %dkHz\n", reg, freq);
+        init->offset += 7;
+
+        init_prog_pll(init, reg, freq);
+}
+
+/**
+ * INIT_ZM_REG - opcode 0x7a
+ *
+ */
+static void
+init_zm_reg(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 addr = nv_ro32(bios, init->offset + 1);
+        u32 data = nv_ro32(bios, init->offset + 5);
+
+        trace("ZM_REG\tR[0x%06x] = 0x%08x\n", addr, data);
+        init->offset += 9;
+
+        if (addr == 0x000200)
+                data |= 0x00000001;
+
+        init_wr32(init, addr, data);
+}
+
+/**
+ * INIT_RAM_RESTRICT_PLL - opcde 0x87
+ *
+ */
+static void
+init_ram_restrict_pll(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8  type = nv_ro08(bios, init->offset + 1);
+        u8 count = init_ram_restrict_group_count(init);
+        u8 strap = init_ram_restrict(init);
+        u8 cconf;
+
+        trace("RAM_RESTRICT_PLL\t0x%02x\n", type);
+        init->offset += 2;
+
+        for (cconf = 0; cconf < count; cconf++) {
+                u32 freq = nv_ro32(bios, init->offset);
+
+                if (cconf == strap) {
+                        trace("%dkHz *\n", freq);
+                        init_prog_pll(init, type, freq);
+                } else {
+                        trace("%dkHz\n", freq);
+                }
+
+                init->offset += 4;
+        }
+}
+
+/**
+ * INIT_GPIO - opcode 0x8e
+ *
+ */
+static void
+init_gpio(struct nvbios_init *init)
+{
+        struct nouveau_gpio *gpio = nouveau_gpio(init->bios);
+
+        trace("GPIO\n");
+        init->offset += 1;
+
+        if (init_exec(init) && gpio && gpio->reset)
+                gpio->reset(gpio);
+}
+
+/**
+ * INIT_RAM_RESTRICT_ZM_GROUP - opcode 0x8f
+ *
+ */
+static void
+init_ram_restrict_zm_reg_group(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 addr = nv_ro32(bios, init->offset + 1);
+        u8  incr = nv_ro08(bios, init->offset + 5);
+        u8   num = nv_ro08(bios, init->offset + 6);
+        u8 count = init_ram_restrict_group_count(init);
+        u8 index = init_ram_restrict(init);
+        u8 i, j;
+
+        trace("RAM_RESTRICT_ZM_REG_GROUP\t"
+              "R[%08x] 0x%02x 0x%02x\n", addr, incr, num);
+        init->offset += 7;
+
+        for (i = 0; i < num; i++) {
+                trace("\tR[0x%06x] = {\n", addr);
+                for (j = 0; j < count; j++) {
+                        u32 data = nv_ro32(bios, init->offset);
+
+                        if (j == index) {
+                                trace("\t\t0x%08x *\n", data);
+                                init_wr32(init, addr, data);
+                        } else {
+                                trace("\t\t0x%08x\n", data);
+                        }
+
+                        init->offset += 4;
+                }
+                trace("\t}\n");
+                addr += incr;
+        }
+}
+
+/**
+ * INIT_COPY_ZM_REG - opcode 0x90
+ *
+ */
+static void
+init_copy_zm_reg(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 sreg = nv_ro32(bios, init->offset + 1);
+        u32 dreg = nv_ro32(bios, init->offset + 5);
+
+        trace("COPY_ZM_REG\tR[0x%06x] = R[0x%06x]\n", sreg, dreg);
+        init->offset += 9;
+
+        init_wr32(init, dreg, init_rd32(init, sreg));
+}
+
+/**
+ * INIT_ZM_REG_GROUP - opcode 0x91
+ *
+ */
+static void
+init_zm_reg_group(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 addr = nv_ro32(bios, init->offset + 1);
+        u8 count = nv_ro08(bios, init->offset + 5);
+
+        trace("ZM_REG_GROUP\tR[0x%06x] =\n");
+        init->offset += 6;
+
+        while (count--) {
+                u32 data = nv_ro32(bios, init->offset);
+                trace("\t0x%08x\n", data);
+                init_wr32(init, addr, data);
+                init->offset += 4;
+        }
+}
+
+/**
+ * INIT_XLAT - opcode 0x96
+ *
+ */
+static void
+init_xlat(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 saddr = nv_ro32(bios, init->offset + 1);
+        u8 sshift = nv_ro08(bios, init->offset + 5);
+        u8  smask = nv_ro08(bios, init->offset + 6);
+        u8  index = nv_ro08(bios, init->offset + 7);
+        u32 daddr = nv_ro32(bios, init->offset + 8);
+        u32 dmask = nv_ro32(bios, init->offset + 12);
+        u8  shift = nv_ro08(bios, init->offset + 16);
+        u32 data;
+
+        trace("INIT_XLAT\tR[0x%06x] &= 0x%08x |= "
+              "(X%02x((R[0x%06x] %s 0x%02x) & 0x%02x) << 0x%02x)\n",
+              daddr, dmask, index, saddr, (sshift & 0x80) ? "<<" : ">>",
+              (sshift & 0x80) ? (0x100 - sshift) : sshift, smask, shift);
+        init->offset += 17;
+
+        data = init_shift(init_rd32(init, saddr), sshift) & smask;
+        data = init_xlat_(init, index, data) << shift;
+        init_mask(init, daddr, ~dmask, data);
+}
+
+/**
+ * INIT_ZM_MASK_ADD - opcode 0x97
+ *
+ */
+static void
+init_zm_mask_add(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 addr = nv_ro32(bios, init->offset + 1);
+        u32 mask = nv_ro32(bios, init->offset + 5);
+        u32  add = nv_ro32(bios, init->offset + 9);
+        u32 data;
+
+        trace("ZM_MASK_ADD\tR[0x%06x] &= 0x%08x += 0x%08x\n", addr, mask, add);
+        init->offset += 13;
+
+        data  =  init_rd32(init, addr) & mask;
+        data |= ((data + add) & ~mask);
+        init_wr32(init, addr, data);
+}
+
+/**
+ * INIT_AUXCH - opcode 0x98
+ *
+ */
+static void
+init_auxch(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 addr = nv_ro32(bios, init->offset + 1);
+        u8 count = nv_ro08(bios, init->offset + 5);
+
+        trace("AUXCH\tAUX[0x%08x] 0x%02x\n", addr, count);
+        init->offset += 6;
+
+        while (count--) {
+                u8 mask = nv_ro08(bios, init->offset + 0);
+                u8 data = nv_ro08(bios, init->offset + 1);
+                trace("\tAUX[0x%08x] &= 0x%02x |= 0x%02x\n", addr, mask, data);
+                mask = init_rdauxr(init, addr) & mask;
+                init_wrauxr(init, addr, mask | data);
+                init->offset += 2;
+        }
+}
+
+/**
+ * INIT_AUXCH - opcode 0x99
+ *
+ */
+static void
+init_zm_auxch(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u32 addr = nv_ro32(bios, init->offset + 1);
+        u8 count = nv_ro08(bios, init->offset + 5);
+
+        trace("ZM_AUXCH\tAUX[0x%08x] 0x%02x\n", addr, count);
+        init->offset += 6;
+
+        while (count--) {
+                u8 data = nv_ro08(bios, init->offset + 0);
+                trace("\tAUX[0x%08x] = 0x%02x\n", addr, data);
+                init_wrauxr(init, addr, data);
+                init->offset += 1;
+        }
+}
+
+/**
+ * INIT_I2C_LONG_IF - opcode 0x9a
+ *
+ */
+static void
+init_i2c_long_if(struct nvbios_init *init)
+{
+        struct nouveau_bios *bios = init->bios;
+        u8 index = nv_ro08(bios, init->offset + 1);
+        u8  addr = nv_ro08(bios, init->offset + 2) >> 1;
+        u8 reglo = nv_ro08(bios, init->offset + 3);
+        u8 reghi = nv_ro08(bios, init->offset + 4);
+        u8  mask = nv_ro08(bios, init->offset + 5);
+        u8  data = nv_ro08(bios, init->offset + 6);
+        struct nouveau_i2c_port *port;
+
+        trace("I2C_LONG_IF\t"
+              "I2C[0x%02x][0x%02x][0x%02x%02x] & 0x%02x == 0x%02x\n",
+              index, addr, reglo, reghi, mask, data);
+        init->offset += 7;
+
+        port = init_i2c(init, index);
+        if (port) {
+                u8 i[2] = { reghi, reglo };
+                u8 o[1] = {};
+                struct i2c_msg msg[] = {
+                        { .addr = addr, .flags = 0, .len = 2, .buf = i },
+                        { .addr = addr, .flags = I2C_M_RD, .len = 1, .buf = o }
+                };
+                int ret;
+
+                ret = i2c_transfer(&port->adapter, msg, 2);
+                if (ret == 2 && ((o[0] & mask) == data))
+                        return;
+        }
+
+        init_exec_set(init, false);
+}
+
+static struct nvbios_init_opcode {
+        void (*exec)(struct nvbios_init *);
+} init_opcode[] = {
+        [0x32] = { init_io_restrict_prog },
+        [0x33] = { init_repeat },
+        [0x34] = { init_io_restrict_pll },
+        [0x36] = { init_end_repeat },
+        [0x37] = { init_copy },
+        [0x38] = { init_not },
+        [0x39] = { init_io_flag_condition },
+        [0x3a] = { init_dp_condition },
+        [0x3b] = { init_io_mask_or },
+        [0x3c] = { init_io_or },
+        [0x49] = { init_idx_addr_latched },
+        [0x4a] = { init_io_restrict_pll2 },
+        [0x4b] = { init_pll2 },
+        [0x4c] = { init_i2c_byte },
+        [0x4d] = { init_zm_i2c_byte },
+        [0x4e] = { init_zm_i2c },
+        [0x4f] = { init_tmds },
+        [0x50] = { init_zm_tmds_group },
+        [0x51] = { init_cr_idx_adr_latch },
+        [0x52] = { init_cr },
+        [0x53] = { init_zm_cr },
+        [0x54] = { init_zm_cr_group },
+        [0x56] = { init_condition_time },
+        [0x57] = { init_ltime },
+        [0x58] = { init_zm_reg_sequence },
+        [0x5b] = { init_sub_direct },
+        [0x5c] = { init_jump },
+        [0x5e] = { init_i2c_if },
+        [0x5f] = { init_copy_nv_reg },
+        [0x62] = { init_zm_index_io },
+        [0x63] = { init_compute_mem },
+        [0x65] = { init_reset },
+        [0x66] = { init_configure_mem },
+        [0x67] = { init_configure_clk },
+        [0x68] = { init_configure_preinit },
+        [0x69] = { init_io },
+        [0x6b] = { init_sub },
+        [0x6d] = { init_ram_condition },
+        [0x6e] = { init_nv_reg },
+        [0x6f] = { init_macro },
+        [0x71] = { init_done },
+        [0x72] = { init_resume },
+        [0x74] = { init_time },
+        [0x75] = { init_condition },
+        [0x76] = { init_io_condition },
+        [0x78] = { init_index_io },
+        [0x79] = { init_pll },
+        [0x7a] = { init_zm_reg },
+        [0x87] = { init_ram_restrict_pll },
+        [0x8c] = { init_reserved },
+        [0x8d] = { init_reserved },
+        [0x8e] = { init_gpio },
+        [0x8f] = { init_ram_restrict_zm_reg_group },
+        [0x90] = { init_copy_zm_reg },
+        [0x91] = { init_zm_reg_group },
+        [0x92] = { init_reserved },
+        [0x96] = { init_xlat },
+        [0x97] = { init_zm_mask_add },
+        [0x98] = { init_auxch },
+        [0x99] = { init_zm_auxch },
+        [0x9a] = { init_i2c_long_if },
+};
+
+#define init_opcode_nr (sizeof(init_opcode) / sizeof(init_opcode[0]))
+
+int
+nvbios_exec(struct nvbios_init *init)
+{
+        init->nested++;
+        while (init->offset) {
+                u8 opcode = nv_ro08(init->bios, init->offset);
+                if (opcode >= init_opcode_nr || !init_opcode[opcode].exec) {
+                        error("unknown opcode 0x%02x\n", opcode);
+                        return -EINVAL;
+                }
+
+                init_opcode[opcode].exec(init);
+        }
+        init->nested--;
+        return 0;
+}
+
+int
+nvbios_init(struct nouveau_subdev *subdev, bool execute)
+{
+        struct nouveau_bios *bios = nouveau_bios(subdev);
+        int ret = 0;
+        int i = -1;
+        u16 data;
+
+        if (execute)
+                nv_info(bios, "running init tables\n");
+        while (!ret && (data = (init_script(bios, ++i)))) {
+                struct nvbios_init init = {
+                        .subdev = subdev,
+                        .bios = bios,
+                        .offset = data,
+                        .outp = NULL,
+                        .crtc = -1,
+                        .execute = execute ? 1 : 0,
+                };
+
+                ret = nvbios_exec(&init);
+        }
+
+        /* the vbios parser will run this right after the normal init
+         * tables, whereas the binary driver appears to run it later.
+         */
+        if (!ret && (data = init_unknown_script(bios))) {
+                struct nvbios_init init = {
+                        .subdev = subdev,
+                        .bios = bios,
+                        .offset = data,
+                        .outp = NULL,
+                        .crtc = -1,
+                        .execute = execute ? 1 : 0,
+                };
+
+                ret = nvbios_exec(&init);
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/mxm.c b/drivers/gpu/drm/nouveau/core/subdev/bios/mxm.c
new file mode 100644
index 000000000000..2610b11a99b3
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/mxm.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 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 <subdev/bios.h>
+#include <subdev/bios/bit.h>
+#include <subdev/bios/mxm.h>
+
+u16
+mxm_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr)
+{
+        struct bit_entry x;
+
+        if (bit_entry(bios, 'x', &x)) {
+                nv_debug(bios, "BIT 'x' table not present\n");
+                return 0x0000;
+        }
+
+        *ver = x.version;
+        *hdr = x.length;
+        if (*ver != 1 || *hdr < 3) {
+                nv_warn(bios, "BIT 'x' table %d/%d unknown\n", *ver, *hdr);
+                return 0x0000;
+        }
+
+        return x.offset;
+}
+
+/* These map MXM v2.x digital connection values to the appropriate SOR/link,
+ * hopefully they're correct for all boards within the same chipset...
+ *
+ * MXM v3.x VBIOS are nicer and provide pointers to these tables.
+ */
+static u8 nv84_sor_map[16] = {
+        0x00, 0x12, 0x22, 0x11, 0x32, 0x31, 0x11, 0x31,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 nv92_sor_map[16] = {
+        0x00, 0x12, 0x22, 0x11, 0x32, 0x31, 0x11, 0x31,
+        0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 nv94_sor_map[16] = {
+        0x00, 0x14, 0x24, 0x11, 0x34, 0x31, 0x11, 0x31,
+        0x11, 0x31, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 nv98_sor_map[16] = {
+        0x00, 0x14, 0x12, 0x11, 0x00, 0x31, 0x11, 0x31,
+        0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+u8
+mxm_sor_map(struct nouveau_bios *bios, u8 conn)
+{
+        u8  ver, hdr;
+        u16 mxm = mxm_table(bios, &ver, &hdr);
+        if (mxm && hdr >= 6) {
+                u16 map = nv_ro16(bios, mxm + 4);
+                if (map) {
+                        ver = nv_ro08(bios, map);
+                        if (ver == 0x10) {
+                                if (conn < nv_ro08(bios, map + 3)) {
+                                        map += nv_ro08(bios, map + 1);
+                                        map += conn;
+                                        return nv_ro08(bios, map);
+                                }
+
+                                return 0x00;
+                        }
+
+                        nv_warn(bios, "unknown sor map v%02x\n", ver);
+                }
+        }
+
+        if (bios->version.chip == 0x84 || bios->version.chip == 0x86)
+                return nv84_sor_map[conn];
+        if (bios->version.chip == 0x92)
+                return nv92_sor_map[conn];
+        if (bios->version.chip == 0x94 || bios->version.chip == 0x96)
+                return nv94_sor_map[conn];
+        if (bios->version.chip == 0x98)
+                return nv98_sor_map[conn];
+
+        nv_warn(bios, "missing sor map\n");
+        return 0x00;
+}
+
+u8
+mxm_ddc_map(struct nouveau_bios *bios, u8 port)
+{
+        u8  ver, hdr;
+        u16 mxm = mxm_table(bios, &ver, &hdr);
+        if (mxm && hdr >= 8) {
+                u16 map = nv_ro16(bios, mxm + 6);
+                if (map) {
+                        ver = nv_ro08(bios, map);
+                        if (ver == 0x10) {
+                                if (port < nv_ro08(bios, map + 3)) {
+                                        map += nv_ro08(bios, map + 1);
+                                        map += port;
+                                        return nv_ro08(bios, map);
+                                }
+
+                                return 0x00;
+                        }
+
+                        nv_warn(bios, "unknown ddc map v%02x\n", ver);
+                }
+        }
+
+        /* v2.x: directly write port as dcb i2cidx */
+        return (port << 4) | port;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/perf.c b/drivers/gpu/drm/nouveau/core/subdev/bios/perf.c
new file mode 100644
index 000000000000..bcbb056c2887
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/perf.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2012 Nouveau Community
+ *
+ * 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: Martin Peres
+ */
+
+#include <subdev/bios.h>
+#include <subdev/bios/bit.h>
+#include <subdev/bios/perf.h>
+
+static u16
+perf_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
+{
+        struct bit_entry bit_P;
+        u16 perf = 0x0000;
+
+        if (!bit_entry(bios, 'P', &bit_P)) {
+                if (bit_P.version <= 2) {
+                        perf = nv_ro16(bios, bit_P.offset + 0);
+                        if (perf) {
+                                *ver = nv_ro08(bios, perf + 0);
+                                *hdr = nv_ro08(bios, perf + 1);
+                        }
+                } else
+                        nv_error(bios, "unknown offset for perf in BIT P %d\n",
+                                bit_P.version);
+        }
+
+        if (bios->bmp_offset) {
+                if (nv_ro08(bios, bios->bmp_offset + 6) >= 0x25) {
+                        perf = nv_ro16(bios, bios->bmp_offset + 0x94);
+                        if (perf) {
+                                *hdr = nv_ro08(bios, perf + 0);
+                                *ver = nv_ro08(bios, perf + 1);
+                        }
+                }
+        }
+
+        return perf;
+}
+
+int
+nvbios_perf_fan_parse(struct nouveau_bios *bios,
+                      struct nvbios_perf_fan *fan)
+{
+        u8 ver = 0, hdr = 0, cnt = 0, len = 0;
+        u16 perf = perf_table(bios, &ver, &hdr, &cnt, &len);
+        if (!perf)
+                return -ENODEV;
+
+        if (ver >= 0x20 && ver < 0x40 && hdr > 6)
+                fan->pwm_divisor = nv_ro16(bios, perf + 6);
+        else
+                fan->pwm_divisor = 0;
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/pll.c b/drivers/gpu/drm/nouveau/core/subdev/bios/pll.c
new file mode 100644
index 000000000000..5e5f4cddae3c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/pll.c
@@ -0,0 +1,417 @@
+/*
+ * Copyright 2005-2006 Erik Waling
+ * Copyright 2006 Stephane Marchesin
+ * Copyright 2007-2009 Stuart Bennett
+ *
+ * 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 AUTHORS 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 <subdev/vga.h>
+#include <subdev/bios.h>
+#include <subdev/bios/bit.h>
+#include <subdev/bios/bmp.h>
+#include <subdev/bios/pll.h>
+
+struct pll_mapping {
+        u8  type;
+        u32 reg;
+};
+
+static struct pll_mapping
+nv04_pll_mapping[] = {
+        { PLL_CORE  , 0x680500 },
+        { PLL_MEMORY, 0x680504 },
+        { PLL_VPLL0 , 0x680508 },
+        { PLL_VPLL1 , 0x680520 },
+        {}
+};
+
+static struct pll_mapping
+nv40_pll_mapping[] = {
+        { PLL_CORE  , 0x004000 },
+        { PLL_MEMORY, 0x004020 },
+        { PLL_VPLL0 , 0x680508 },
+        { PLL_VPLL1 , 0x680520 },
+        {}
+};
+
+static struct pll_mapping
+nv50_pll_mapping[] = {
+        { PLL_CORE  , 0x004028 },
+        { PLL_SHADER, 0x004020 },
+        { PLL_UNK03 , 0x004000 },
+        { PLL_MEMORY, 0x004008 },
+        { PLL_UNK40 , 0x00e810 },
+        { PLL_UNK41 , 0x00e818 },
+        { PLL_UNK42 , 0x00e824 },
+        { PLL_VPLL0 , 0x614100 },
+        { PLL_VPLL1 , 0x614900 },
+        {}
+};
+
+static struct pll_mapping
+nv84_pll_mapping[] = {
+        { PLL_CORE  , 0x004028 },
+        { PLL_SHADER, 0x004020 },
+        { PLL_MEMORY, 0x004008 },
+        { PLL_VDEC  , 0x004030 },
+        { PLL_UNK41 , 0x00e818 },
+        { PLL_VPLL0 , 0x614100 },
+        { PLL_VPLL1 , 0x614900 },
+        {}
+};
+
+static u16
+pll_limits_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
+{
+        struct bit_entry bit_C;
+
+        if (!bit_entry(bios, 'C', &bit_C) && bit_C.length >= 10) {
+                u16 data = nv_ro16(bios, bit_C.offset + 8);
+                if (data) {
+                        *ver = nv_ro08(bios, data + 0);
+                        *hdr = nv_ro08(bios, data + 1);
+                        *len = nv_ro08(bios, data + 2);
+                        *cnt = nv_ro08(bios, data + 3);
+                        return data;
+                }
+        }
+
+        if (bmp_version(bios) >= 0x0524) {
+                u16 data = nv_ro16(bios, bios->bmp_offset + 142);
+                if (data) {
+                        *ver = nv_ro08(bios, data + 0);
+                        *hdr = 1;
+                        *cnt = 1;
+                        *len = 0x18;
+                        return data;
+                }
+        }
+
+        *ver = 0x00;
+        return 0x0000;
+}
+
+static struct pll_mapping *
+pll_map(struct nouveau_bios *bios)
+{
+        switch (nv_device(bios)->card_type) {
+        case NV_04:
+        case NV_10:
+        case NV_20:
+        case NV_30:
+                return nv04_pll_mapping;
+                break;
+        case NV_40:
+                return nv40_pll_mapping;
+        case NV_50:
+                if (nv_device(bios)->chipset == 0x50)
+                        return nv50_pll_mapping;
+                else
+                if (nv_device(bios)->chipset <  0xa3 ||
+                    nv_device(bios)->chipset == 0xaa ||
+                    nv_device(bios)->chipset == 0xac)
+                        return nv84_pll_mapping;
+        default:
+                return NULL;
+        }
+}
+
+static u16
+pll_map_reg(struct nouveau_bios *bios, u32 reg, u32 *type, u8 *ver, u8 *len)
+{
+        struct pll_mapping *map;
+        u8  hdr, cnt;
+        u16 data;
+
+        data = pll_limits_table(bios, ver, &hdr, &cnt, len);
+        if (data && *ver >= 0x30) {
+                data += hdr;
+                while (cnt--) {
+                        if (nv_ro32(bios, data + 3) == reg) {
+                                *type = nv_ro08(bios, data + 0);
+                                return data;
+                        }
+                        data += *len;
+                }
+                return 0x0000;
+        }
+
+        map = pll_map(bios);
+        while (map->reg) {
+                if (map->reg == reg && *ver >= 0x20) {
+                        u16 addr = (data += hdr);
+                        while (cnt--) {
+                                if (nv_ro32(bios, data) == map->reg) {
+                                        *type = map->type;
+                                        return data;
+                                }
+                                data += *len;
+                        }
+                        return addr;
+                } else
+                if (map->reg == reg) {
+                        *type = map->type;
+                        return data + 1;
+                }
+                map++;
+        }
+
+        return 0x0000;
+}
+
+static u16
+pll_map_type(struct nouveau_bios *bios, u8 type, u32 *reg, u8 *ver, u8 *len)
+{
+        struct pll_mapping *map;
+        u8  hdr, cnt;
+        u16 data;
+
+        data = pll_limits_table(bios, ver, &hdr, &cnt, len);
+        if (data && *ver >= 0x30) {
+                data += hdr;
+                while (cnt--) {
+                        if (nv_ro08(bios, data + 0) == type) {
+                                *reg = nv_ro32(bios, data + 3);
+                                return data;
+                        }
+                        data += *len;
+                }
+                return 0x0000;
+        }
+
+        map = pll_map(bios);
+        while (map->reg) {
+                if (map->type == type && *ver >= 0x20) {
+                        u16 addr = (data += hdr);
+                        while (cnt--) {
+                                if (nv_ro32(bios, data) == map->reg) {
+                                        *reg = map->reg;
+                                        return data;
+                                }
+                                data += *len;
+                        }
+                        return addr;
+                } else
+                if (map->type == type) {
+                        *reg = map->reg;
+                        return data + 1;
+                }
+                map++;
+        }
+
+        return 0x0000;
+}
+
+int
+nvbios_pll_parse(struct nouveau_bios *bios, u32 type, struct nvbios_pll *info)
+{
+        u8  ver, len;
+        u32 reg = type;
+        u16 data;
+
+        if (type > PLL_MAX) {
+                reg  = type;
+                data = pll_map_reg(bios, reg, &type, &ver, &len);
+        } else {
+                data = pll_map_type(bios, type, &reg, &ver, &len);
+        }
+
+        if (ver && !data)
+                return -ENOENT;
+
+        memset(info, 0, sizeof(*info));
+        info->type = type;
+        info->reg = reg;
+
+        switch (ver) {
+        case 0x00:
+                break;
+        case 0x10:
+        case 0x11:
+                info->vco1.min_freq = nv_ro32(bios, data + 0);
+                info->vco1.max_freq = nv_ro32(bios, data + 4);
+                info->vco2.min_freq = nv_ro32(bios, data + 8);
+                info->vco2.max_freq = nv_ro32(bios, data + 12);
+                info->vco1.min_inputfreq = nv_ro32(bios, data + 16);
+                info->vco2.min_inputfreq = nv_ro32(bios, data + 20);
+                info->vco1.max_inputfreq = INT_MAX;
+                info->vco2.max_inputfreq = INT_MAX;
+
+                info->max_p = 0x7;
+                info->max_p_usable = 0x6;
+
+                /* these values taken from nv30/31/36 */
+                switch (bios->version.chip) {
+                case 0x36:
+                        info->vco1.min_n = 0x5;
+                        break;
+                default:
+                        info->vco1.min_n = 0x1;
+                        break;
+                }
+                info->vco1.max_n = 0xff;
+                info->vco1.min_m = 0x1;
+                info->vco1.max_m = 0xd;
+
+                /*
+                 * On nv30, 31, 36 (i.e. all cards with two stage PLLs with this
+                 * table version (apart from nv35)), N2 is compared to
+                 * maxN2 (0x46) and 10 * maxM2 (0x4), so set maxN2 to 0x28 and
+                 * save a comparison
+                 */
+                info->vco2.min_n = 0x4;
+                switch (bios->version.chip) {
+                case 0x30:
+                case 0x35:
+                        info->vco2.max_n = 0x1f;
+                        break;
+                default:
+                        info->vco2.max_n = 0x28;
+                        break;
+                }
+                info->vco2.min_m = 0x1;
+                info->vco2.max_m = 0x4;
+                break;
+        case 0x20:
+        case 0x21:
+                info->vco1.min_freq = nv_ro16(bios, data + 4) * 1000;
+                info->vco1.max_freq = nv_ro16(bios, data + 6) * 1000;
+                info->vco2.min_freq = nv_ro16(bios, data + 8) * 1000;
+                info->vco2.max_freq = nv_ro16(bios, data + 10) * 1000;
+                info->vco1.min_inputfreq = nv_ro16(bios, data + 12) * 1000;
+                info->vco2.min_inputfreq = nv_ro16(bios, data + 14) * 1000;
+                info->vco1.max_inputfreq = nv_ro16(bios, data + 16) * 1000;
+                info->vco2.max_inputfreq = nv_ro16(bios, data + 18) * 1000;
+                info->vco1.min_n = nv_ro08(bios, data + 20);
+                info->vco1.max_n = nv_ro08(bios, data + 21);
+                info->vco1.min_m = nv_ro08(bios, data + 22);
+                info->vco1.max_m = nv_ro08(bios, data + 23);
+                info->vco2.min_n = nv_ro08(bios, data + 24);
+                info->vco2.max_n = nv_ro08(bios, data + 25);
+                info->vco2.min_m = nv_ro08(bios, data + 26);
+                info->vco2.max_m = nv_ro08(bios, data + 27);
+
+                info->max_p = nv_ro08(bios, data + 29);
+                info->max_p_usable = info->max_p;
+                if (bios->version.chip < 0x60)
+                        info->max_p_usable = 0x6;
+                info->bias_p = nv_ro08(bios, data + 30);
+
+                if (len > 0x22)
+                        info->refclk = nv_ro32(bios, data + 31);
+                break;
+        case 0x30:
+                data = nv_ro16(bios, data + 1);
+
+                info->vco1.min_freq = nv_ro16(bios, data + 0) * 1000;
+                info->vco1.max_freq = nv_ro16(bios, data + 2) * 1000;
+                info->vco2.min_freq = nv_ro16(bios, data + 4) * 1000;
+                info->vco2.max_freq = nv_ro16(bios, data + 6) * 1000;
+                info->vco1.min_inputfreq = nv_ro16(bios, data + 8) * 1000;
+                info->vco2.min_inputfreq = nv_ro16(bios, data + 10) * 1000;
+                info->vco1.max_inputfreq = nv_ro16(bios, data + 12) * 1000;
+                info->vco2.max_inputfreq = nv_ro16(bios, data + 14) * 1000;
+                info->vco1.min_n = nv_ro08(bios, data + 16);
+                info->vco1.max_n = nv_ro08(bios, data + 17);
+                info->vco1.min_m = nv_ro08(bios, data + 18);
+                info->vco1.max_m = nv_ro08(bios, data + 19);
+                info->vco2.min_n = nv_ro08(bios, data + 20);
+                info->vco2.max_n = nv_ro08(bios, data + 21);
+                info->vco2.min_m = nv_ro08(bios, data + 22);
+                info->vco2.max_m = nv_ro08(bios, data + 23);
+                info->max_p_usable = info->max_p = nv_ro08(bios, data + 25);
+                info->bias_p = nv_ro08(bios, data + 27);
+                info->refclk = nv_ro32(bios, data + 28);
+                break;
+        case 0x40:
+                info->refclk = nv_ro16(bios, data + 9) * 1000;
+                data = nv_ro16(bios, data + 1);
+
+                info->vco1.min_freq = nv_ro16(bios, data + 0) * 1000;
+                info->vco1.max_freq = nv_ro16(bios, data + 2) * 1000;
+                info->vco1.min_inputfreq = nv_ro16(bios, data + 4) * 1000;
+                info->vco1.max_inputfreq = nv_ro16(bios, data + 6) * 1000;
+                info->vco1.min_m = nv_ro08(bios, data + 8);
+                info->vco1.max_m = nv_ro08(bios, data + 9);
+                info->vco1.min_n = nv_ro08(bios, data + 10);
+                info->vco1.max_n = nv_ro08(bios, data + 11);
+                info->min_p = nv_ro08(bios, data + 12);
+                info->max_p = nv_ro08(bios, data + 13);
+                break;
+        default:
+                nv_error(bios, "unknown pll limits version 0x%02x\n", ver);
+                return -EINVAL;
+        }
+
+        if (!info->refclk) {
+                info->refclk = nv_device(bios)->crystal;
+                if (bios->version.chip == 0x51) {
+                        u32 sel_clk = nv_rd32(bios, 0x680524);
+                        if ((info->reg == 0x680508 && sel_clk & 0x20) ||
+                            (info->reg == 0x680520 && sel_clk & 0x80)) {
+                                if (nv_rdvgac(bios, 0, 0x27) < 0xa3)
+                                        info->refclk = 200000;
+                                else
+                                        info->refclk = 25000;
+                        }
+                }
+        }
+
+        /*
+         * By now any valid limit table ought to have set a max frequency for
+         * vco1, so if it's zero it's either a pre limit table bios, or one
+         * with an empty limit table (seen on nv18)
+         */
+        if (!info->vco1.max_freq) {
+                info->vco1.max_freq = nv_ro32(bios, bios->bmp_offset + 67);
+                info->vco1.min_freq = nv_ro32(bios, bios->bmp_offset + 71);
+                if (bmp_version(bios) < 0x0506) {
+                        info->vco1.max_freq = 256000;
+                        info->vco1.min_freq = 128000;
+                }
+
+                info->vco1.min_inputfreq = 0;
+                info->vco1.max_inputfreq = INT_MAX;
+                info->vco1.min_n = 0x1;
+                info->vco1.max_n = 0xff;
+                info->vco1.min_m = 0x1;
+
+                if (nv_device(bios)->crystal == 13500) {
+                        /* nv05 does this, nv11 doesn't, nv10 unknown */
+                        if (bios->version.chip < 0x11)
+                                info->vco1.min_m = 0x7;
+                        info->vco1.max_m = 0xd;
+                } else {
+                        if (bios->version.chip < 0x11)
+                                info->vco1.min_m = 0x8;
+                        info->vco1.max_m = 0xe;
+                }
+
+                if (bios->version.chip <  0x17 ||
+                    bios->version.chip == 0x1a ||
+                    bios->version.chip == 0x20)
+                        info->max_p = 4;
+                else
+                        info->max_p = 5;
+                info->max_p_usable = info->max_p;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/therm.c b/drivers/gpu/drm/nouveau/core/subdev/bios/therm.c
new file mode 100644
index 000000000000..862a08a2ae27
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/therm.c
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2012 Nouveau Community
+ *
+ * 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: Martin Peres
+ */
+
+#include <subdev/bios.h>
+#include <subdev/bios/bit.h>
+#include <subdev/bios/therm.h>
+
+static u16
+therm_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *len, u8 *cnt)
+{
+        struct bit_entry bit_P;
+        u16 therm = 0;
+
+        if (!bit_entry(bios, 'P', &bit_P)) {
+                if (bit_P.version == 1)
+                        therm = nv_ro16(bios, bit_P.offset + 12);
+                else if (bit_P.version == 2)
+                        therm = nv_ro16(bios, bit_P.offset + 16);
+                else
+                        nv_error(bios,
+                                "unknown offset for thermal in BIT P %d\n",
+                                bit_P.version);
+        }
+
+        /* exit now if we haven't found the thermal table */
+        if (!therm)
+                return 0x0000;
+
+        *ver = nv_ro08(bios, therm + 0);
+        *hdr = nv_ro08(bios, therm + 1);
+        *len = nv_ro08(bios, therm + 2);
+        *cnt = nv_ro08(bios, therm + 3);
+
+        return therm + nv_ro08(bios, therm + 1);
+}
+
+u16
+nvbios_therm_entry(struct nouveau_bios *bios, int idx, u8 *ver, u8 *len)
+{
+        u8 hdr, cnt;
+        u16 therm = therm_table(bios, ver, &hdr, len, &cnt);
+        if (therm && idx < cnt)
+                return therm + idx * *len;
+        return 0x0000;
+}
+
+int
+nvbios_therm_sensor_parse(struct nouveau_bios *bios,
+                          enum nvbios_therm_domain domain,
+                          struct nvbios_therm_sensor *sensor)
+{
+        s8 thrs_section, sensor_section, offset;
+        u8 ver, len, i;
+        u16 entry;
+
+        /* we only support the core domain for now */
+        if (domain != NVBIOS_THERM_DOMAIN_CORE)
+                return -EINVAL;
+
+        /* Read the entries from the table */
+        thrs_section = 0;
+        sensor_section = -1;
+        i = 0;
+        while ((entry = nvbios_therm_entry(bios, i++, &ver, &len))) {
+                s16 value = nv_ro16(bios, entry + 1);
+
+                switch (nv_ro08(bios, entry + 0)) {
+                case 0x0:
+                        thrs_section = value;
+                        if (value > 0)
+                                return 0; /* we do not try to support ambient */
+                        break;
+                case 0x01:
+                        sensor_section++;
+                        if (sensor_section == 0) {
+                                offset = ((s8) nv_ro08(bios, entry + 2)) / 2;
+                                sensor->offset_constant = offset;
+                        }
+                        break;
+
+                case 0x04:
+                        if (thrs_section == 0) {
+                                sensor->thrs_critical.temp = (value & 0xff0) >> 4;
+                                sensor->thrs_critical.hysteresis = value & 0xf;
+                        }
+                        break;
+
+                case 0x07:
+                        if (thrs_section == 0) {
+                                sensor->thrs_down_clock.temp = (value & 0xff0) >> 4;
+                                sensor->thrs_down_clock.hysteresis = value & 0xf;
+                        }
+                        break;
+
+                case 0x08:
+                        if (thrs_section == 0) {
+                                sensor->thrs_fan_boost.temp = (value & 0xff0) >> 4;
+                                sensor->thrs_fan_boost.hysteresis = value & 0xf;
+                        }
+                        break;
+
+                case 0x10:
+                        if (sensor_section == 0)
+                                sensor->offset_num = value;
+                        break;
+
+                case 0x11:
+                        if (sensor_section == 0)
+                                sensor->offset_den = value;
+                        break;
+
+                case 0x12:
+                        if (sensor_section == 0)
+                                sensor->slope_mult = value;
+                        break;
+
+                case 0x13:
+                        if (sensor_section == 0)
+                                sensor->slope_div = value;
+                        break;
+                case 0x32:
+                        if (thrs_section == 0) {
+                                sensor->thrs_shutdown.temp = (value & 0xff0) >> 4;
+                                sensor->thrs_shutdown.hysteresis = value & 0xf;
+                        }
+                        break;
+                }
+        }
+
+        return 0;
+}
+
+int
+nvbios_therm_fan_parse(struct nouveau_bios *bios,
+                          struct nvbios_therm_fan *fan)
+{
+        u8 ver, len, i;
+        u16 entry;
+
+        i = 0;
+        while ((entry = nvbios_therm_entry(bios, i++, &ver, &len))) {
+                s16 value = nv_ro16(bios, entry + 1);
+
+                switch (nv_ro08(bios, entry + 0)) {
+                case 0x22:
+                        fan->min_duty = value & 0xff;
+                        fan->max_duty = (value & 0xff00) >> 8;
+                        break;
+                case 0x26:
+                        fan->pwm_freq = value;
+                        break;
+                }
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/clock/nv04.c
new file mode 100644
index 000000000000..b7fd1151166e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nv04.c
@@ -0,0 +1,359 @@
+/*
+ * Copyright 2012 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 <subdev/clock.h>
+#include <subdev/bios.h>
+#include <subdev/bios/pll.h>
+
+#include "pll.h"
+
+struct nv04_clock_priv {
+        struct nouveau_clock base;
+};
+
+static int
+powerctrl_1_shift(int chip_version, int reg)
+{
+        int shift = -4;
+
+        if (chip_version < 0x17 || chip_version == 0x1a || chip_version == 0x20)
+                return shift;
+
+        switch (reg) {
+        case 0x680520:
+                shift += 4;
+        case 0x680508:
+                shift += 4;
+        case 0x680504:
+                shift += 4;
+        case 0x680500:
+                shift += 4;
+        }
+
+        /*
+         * the shift for vpll regs is only used for nv3x chips with a single
+         * stage pll
+         */
+        if (shift > 4 && (chip_version < 0x32 || chip_version == 0x35 ||
+                          chip_version == 0x36 || chip_version >= 0x40))
+                shift = -4;
+
+        return shift;
+}
+
+static void
+setPLL_single(struct nv04_clock_priv *priv, u32 reg,
+              struct nouveau_pll_vals *pv)
+{
+        int chip_version = nouveau_bios(priv)->version.chip;
+        uint32_t oldpll = nv_rd32(priv, reg);
+        int oldN = (oldpll >> 8) & 0xff, oldM = oldpll & 0xff;
+        uint32_t pll = (oldpll & 0xfff80000) | pv->log2P << 16 | pv->NM1;
+        uint32_t saved_powerctrl_1 = 0;
+        int shift_powerctrl_1 = powerctrl_1_shift(chip_version, reg);
+
+        if (oldpll == pll)
+                return; /* already set */
+
+        if (shift_powerctrl_1 >= 0) {
+                saved_powerctrl_1 = nv_rd32(priv, 0x001584);
+                nv_wr32(priv, 0x001584,
+                        (saved_powerctrl_1 & ~(0xf << shift_powerctrl_1)) |
+                        1 << shift_powerctrl_1);
+        }
+
+        if (oldM && pv->M1 && (oldN / oldM < pv->N1 / pv->M1))
+                /* upclock -- write new post divider first */
+                nv_wr32(priv, reg, pv->log2P << 16 | (oldpll & 0xffff));
+        else
+                /* downclock -- write new NM first */
+                nv_wr32(priv, reg, (oldpll & 0xffff0000) | pv->NM1);
+
+        if (chip_version < 0x17 && chip_version != 0x11)
+                /* wait a bit on older chips */
+                msleep(64);
+        nv_rd32(priv, reg);
+
+        /* then write the other half as well */
+        nv_wr32(priv, reg, pll);
+
+        if (shift_powerctrl_1 >= 0)
+                nv_wr32(priv, 0x001584, saved_powerctrl_1);
+}
+
+static uint32_t
+new_ramdac580(uint32_t reg1, bool ss, uint32_t ramdac580)
+{
+        bool head_a = (reg1 == 0x680508);
+
+        if (ss) /* single stage pll mode */
+                ramdac580 |= head_a ? 0x00000100 : 0x10000000;
+        else
+                ramdac580 &= head_a ? 0xfffffeff : 0xefffffff;
+
+        return ramdac580;
+}
+
+static void
+setPLL_double_highregs(struct nv04_clock_priv *priv, u32 reg1,
+                       struct nouveau_pll_vals *pv)
+{
+        int chip_version = nouveau_bios(priv)->version.chip;
+        bool nv3035 = chip_version == 0x30 || chip_version == 0x35;
+        uint32_t reg2 = reg1 + ((reg1 == 0x680520) ? 0x5c : 0x70);
+        uint32_t oldpll1 = nv_rd32(priv, reg1);
+        uint32_t oldpll2 = !nv3035 ? nv_rd32(priv, reg2) : 0;
+        uint32_t pll1 = (oldpll1 & 0xfff80000) | pv->log2P << 16 | pv->NM1;
+        uint32_t pll2 = (oldpll2 & 0x7fff0000) | 1 << 31 | pv->NM2;
+        uint32_t oldramdac580 = 0, ramdac580 = 0;
+        bool single_stage = !pv->NM2 || pv->N2 == pv->M2;       /* nv41+ only */
+        uint32_t saved_powerctrl_1 = 0, savedc040 = 0;
+        int shift_powerctrl_1 = powerctrl_1_shift(chip_version, reg1);
+
+        /* model specific additions to generic pll1 and pll2 set up above */
+        if (nv3035) {
+                pll1 = (pll1 & 0xfcc7ffff) | (pv->N2 & 0x18) << 21 |
+                       (pv->N2 & 0x7) << 19 | 8 << 4 | (pv->M2 & 7) << 4;
+                pll2 = 0;
+        }
+        if (chip_version > 0x40 && reg1 >= 0x680508) { /* !nv40 */
+                oldramdac580 = nv_rd32(priv, 0x680580);
+                ramdac580 = new_ramdac580(reg1, single_stage, oldramdac580);
+                if (oldramdac580 != ramdac580)
+                        oldpll1 = ~0;   /* force mismatch */
+                if (single_stage)
+                        /* magic value used by nvidia in single stage mode */
+                        pll2 |= 0x011f;
+        }
+        if (chip_version > 0x70)
+                /* magic bits set by the blob (but not the bios) on g71-73 */
+                pll1 = (pll1 & 0x7fffffff) | (single_stage ? 0x4 : 0xc) << 28;
+
+        if (oldpll1 == pll1 && oldpll2 == pll2)
+                return; /* already set */
+
+        if (shift_powerctrl_1 >= 0) {
+                saved_powerctrl_1 = nv_rd32(priv, 0x001584);
+                nv_wr32(priv, 0x001584,
+                        (saved_powerctrl_1 & ~(0xf << shift_powerctrl_1)) |
+                        1 << shift_powerctrl_1);
+        }
+
+        if (chip_version >= 0x40) {
+                int shift_c040 = 14;
+
+                switch (reg1) {
+                case 0x680504:
+                        shift_c040 += 2;
+                case 0x680500:
+                        shift_c040 += 2;
+                case 0x680520:
+                        shift_c040 += 2;
+                case 0x680508:
+                        shift_c040 += 2;
+                }
+
+                savedc040 = nv_rd32(priv, 0xc040);
+                if (shift_c040 != 14)
+                        nv_wr32(priv, 0xc040, savedc040 & ~(3 << shift_c040));
+        }
+
+        if (oldramdac580 != ramdac580)
+                nv_wr32(priv, 0x680580, ramdac580);
+
+        if (!nv3035)
+                nv_wr32(priv, reg2, pll2);
+        nv_wr32(priv, reg1, pll1);
+
+        if (shift_powerctrl_1 >= 0)
+                nv_wr32(priv, 0x001584, saved_powerctrl_1);
+        if (chip_version >= 0x40)
+                nv_wr32(priv, 0xc040, savedc040);
+}
+
+static void
+setPLL_double_lowregs(struct nv04_clock_priv *priv, u32 NMNMreg,
+                      struct nouveau_pll_vals *pv)
+{
+        /* When setting PLLs, there is a merry game of disabling and enabling
+         * various bits of hardware during the process. This function is a
+         * synthesis of six nv4x traces, nearly each card doing a subtly
+         * different thing. With luck all the necessary bits for each card are
+         * combined herein. Without luck it deviates from each card's formula
+         * so as to not work on any :)
+         */
+
+        uint32_t Preg = NMNMreg - 4;
+        bool mpll = Preg == 0x4020;
+        uint32_t oldPval = nv_rd32(priv, Preg);
+        uint32_t NMNM = pv->NM2 << 16 | pv->NM1;
+        uint32_t Pval = (oldPval & (mpll ? ~(0x77 << 16) : ~(7 << 16))) |
+                        0xc << 28 | pv->log2P << 16;
+        uint32_t saved4600 = 0;
+        /* some cards have different maskc040s */
+        uint32_t maskc040 = ~(3 << 14), savedc040;
+        bool single_stage = !pv->NM2 || pv->N2 == pv->M2;
+
+        if (nv_rd32(priv, NMNMreg) == NMNM && (oldPval & 0xc0070000) == Pval)
+                return;
+
+        if (Preg == 0x4000)
+                maskc040 = ~0x333;
+        if (Preg == 0x4058)
+                maskc040 = ~(0xc << 24);
+
+        if (mpll) {
+                struct nvbios_pll info;
+                uint8_t Pval2;
+
+                if (nvbios_pll_parse(nouveau_bios(priv), Preg, &info))
+                        return;
+
+                Pval2 = pv->log2P + info.bias_p;
+                if (Pval2 > info.max_p)
+                        Pval2 = info.max_p;
+                Pval |= 1 << 28 | Pval2 << 20;
+
+                saved4600 = nv_rd32(priv, 0x4600);
+                nv_wr32(priv, 0x4600, saved4600 | 8 << 28);
+        }
+        if (single_stage)
+                Pval |= mpll ? 1 << 12 : 1 << 8;
+
+        nv_wr32(priv, Preg, oldPval | 1 << 28);
+        nv_wr32(priv, Preg, Pval & ~(4 << 28));
+        if (mpll) {
+                Pval |= 8 << 20;
+                nv_wr32(priv, 0x4020, Pval & ~(0xc << 28));
+                nv_wr32(priv, 0x4038, Pval & ~(0xc << 28));
+        }
+
+        savedc040 = nv_rd32(priv, 0xc040);
+        nv_wr32(priv, 0xc040, savedc040 & maskc040);
+
+        nv_wr32(priv, NMNMreg, NMNM);
+        if (NMNMreg == 0x4024)
+                nv_wr32(priv, 0x403c, NMNM);
+
+        nv_wr32(priv, Preg, Pval);
+        if (mpll) {
+                Pval &= ~(8 << 20);
+                nv_wr32(priv, 0x4020, Pval);
+                nv_wr32(priv, 0x4038, Pval);
+                nv_wr32(priv, 0x4600, saved4600);
+        }
+
+        nv_wr32(priv, 0xc040, savedc040);
+
+        if (mpll) {
+                nv_wr32(priv, 0x4020, Pval & ~(1 << 28));
+                nv_wr32(priv, 0x4038, Pval & ~(1 << 28));
+        }
+}
+
+int
+nv04_clock_pll_set(struct nouveau_clock *clk, u32 type, u32 freq)
+{
+        struct nv04_clock_priv *priv = (void *)clk;
+        struct nouveau_pll_vals pv;
+        struct nvbios_pll info;
+        int ret;
+
+        ret = nvbios_pll_parse(nouveau_bios(priv), type > 0x405c ?
+                               type : type - 4, &info);
+        if (ret)
+                return ret;
+
+        ret = clk->pll_calc(clk, &info, freq, &pv);
+        if (!ret)
+                return ret;
+
+        return clk->pll_prog(clk, type, &pv);
+}
+
+int
+nv04_clock_pll_calc(struct nouveau_clock *clock, struct nvbios_pll *info,
+                    int clk, struct nouveau_pll_vals *pv)
+{
+        int N1, M1, N2, M2, P;
+        int ret = nv04_pll_calc(clock, info, clk, &N1, &M1, &N2, &M2, &P);
+        if (ret) {
+                pv->refclk = info->refclk;
+                pv->N1 = N1;
+                pv->M1 = M1;
+                pv->N2 = N2;
+                pv->M2 = M2;
+                pv->log2P = P;
+        }
+        return ret;
+}
+
+int
+nv04_clock_pll_prog(struct nouveau_clock *clk, u32 reg1,
+                    struct nouveau_pll_vals *pv)
+{
+        struct nv04_clock_priv *priv = (void *)clk;
+        int cv = nouveau_bios(clk)->version.chip;
+
+        if (cv == 0x30 || cv == 0x31 || cv == 0x35 || cv == 0x36 ||
+            cv >= 0x40) {
+                if (reg1 > 0x405c)
+                        setPLL_double_highregs(priv, reg1, pv);
+                else
+                        setPLL_double_lowregs(priv, reg1, pv);
+        } else
+                setPLL_single(priv, reg1, pv);
+
+        return 0;
+}
+
+static int
+nv04_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv04_clock_priv *priv;
+        int ret;
+
+        ret = nouveau_clock_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.pll_set = nv04_clock_pll_set;
+        priv->base.pll_calc = nv04_clock_pll_calc;
+        priv->base.pll_prog = nv04_clock_pll_prog;
+        return 0;
+}
+
+struct nouveau_oclass
+nv04_clock_oclass = {
+        .handle = NV_SUBDEV(CLOCK, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_clock_ctor,
+                .dtor = _nouveau_clock_dtor,
+                .init = _nouveau_clock_init,
+                .fini = _nouveau_clock_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_ramht.h b/drivers/gpu/drm/nouveau/core/subdev/clock/nv40.c
index c82de98fee0e..a4b2b7ebf9af 100644
--- a/drivers/gpu/drm/nouveau/nouveau_ramht.h
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nv40.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010 Red Hat Inc.
+ * Copyright 2012 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"),
@@ -22,34 +22,38 @@
  * Authors: Ben Skeggs
  */
 
-#ifndef __NOUVEAU_RAMHT_H__
-#define __NOUVEAU_RAMHT_H__
+#include <subdev/clock.h>
 
-struct nouveau_ramht_entry {
-        struct list_head head;
-        struct nouveau_channel *channel;
-        struct nouveau_gpuobj *gpuobj;
-        u32 handle;
+struct nv40_clock_priv {
+        struct nouveau_clock base;
 };
 
-struct nouveau_ramht {
-        struct drm_device *dev;
-        struct kref refcount;
-        spinlock_t lock;
-        struct nouveau_gpuobj *gpuobj;
-        struct list_head entries;
-        int bits;
-};
+static int
+nv40_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv40_clock_priv *priv;
+        int ret;
 
-extern int  nouveau_ramht_new(struct drm_device *, struct nouveau_gpuobj *,
-                              struct nouveau_ramht **);
-extern void nouveau_ramht_ref(struct nouveau_ramht *, struct nouveau_ramht **,
-                              struct nouveau_channel *unref_channel);
+        ret = nouveau_clock_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
 
-extern int  nouveau_ramht_insert(struct nouveau_channel *, u32 handle,
-                                 struct nouveau_gpuobj *);
-extern int  nouveau_ramht_remove(struct nouveau_channel *, u32 handle);
-extern struct nouveau_gpuobj *
-nouveau_ramht_find(struct nouveau_channel *chan, u32 handle);
+        priv->base.pll_set = nv04_clock_pll_set;
+        priv->base.pll_calc = nv04_clock_pll_calc;
+        priv->base.pll_prog = nv04_clock_pll_prog;
+        return 0;
+}
 
-#endif
+struct nouveau_oclass
+nv40_clock_oclass = {
+        .handle = NV_SUBDEV(CLOCK, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_clock_ctor,
+                .dtor = _nouveau_clock_dtor,
+                .init = _nouveau_clock_init,
+                .fini = _nouveau_clock_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/clock/nv50.c
new file mode 100644
index 000000000000..fd181fbceddb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nv50.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2012 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 <subdev/clock.h>
+#include <subdev/bios.h>
+#include <subdev/bios/pll.h>
+
+#include "pll.h"
+
+struct nv50_clock_priv {
+        struct nouveau_clock base;
+};
+
+static int
+nv50_clock_pll_set(struct nouveau_clock *clk, u32 type, u32 freq)
+{
+        struct nv50_clock_priv *priv = (void *)clk;
+        struct nouveau_bios *bios = nouveau_bios(priv);
+        struct nvbios_pll info;
+        int N1, M1, N2, M2, P;
+        int ret;
+
+        ret = nvbios_pll_parse(bios, type, &info);
+        if (ret) {
+                nv_error(clk, "failed to retrieve pll data, %d\n", ret);
+                return ret;
+        }
+
+        ret = nv04_pll_calc(clk, &info, freq, &N1, &M1, &N2, &M2, &P);
+        if (!ret) {
+                nv_error(clk, "failed pll calculation\n");
+                return ret;
+        }
+
+        switch (info.type) {
+        case PLL_VPLL0:
+        case PLL_VPLL1:
+                nv_wr32(priv, info.reg + 0, 0x10000611);
+                nv_mask(priv, info.reg + 4, 0x00ff00ff, (M1 << 16) | N1);
+                nv_mask(priv, info.reg + 8, 0x7fff00ff, (P  << 28) |
+                                                        (M2 << 16) | N2);
+                break;
+        case PLL_MEMORY:
+                nv_mask(priv, info.reg + 0, 0x01ff0000, (P << 22) |
+                                                        (info.bias_p << 19) |
+                                                        (P << 16));
+                nv_wr32(priv, info.reg + 4, (N1 << 8) | M1);
+                break;
+        default:
+                nv_mask(priv, info.reg + 0, 0x00070000, (P << 16));
+                nv_wr32(priv, info.reg + 4, (N1 << 8) | M1);
+                break;
+        }
+
+        return 0;
+}
+
+static int
+nv50_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv50_clock_priv *priv;
+        int ret;
+
+        ret = nouveau_clock_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.pll_set = nv50_clock_pll_set;
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_clock_oclass = {
+        .handle = NV_SUBDEV(CLOCK, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_clock_ctor,
+                .dtor = _nouveau_clock_dtor,
+                .init = _nouveau_clock_init,
+                .fini = _nouveau_clock_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c b/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c
new file mode 100644
index 000000000000..cc8d7d162d7c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2012 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 <subdev/clock.h>
+#include <subdev/bios.h>
+#include <subdev/bios/pll.h>
+
+#include "pll.h"
+
+struct nva3_clock_priv {
+        struct nouveau_clock base;
+};
+
+static int
+nva3_clock_pll_set(struct nouveau_clock *clk, u32 type, u32 freq)
+{
+        struct nva3_clock_priv *priv = (void *)clk;
+        struct nouveau_bios *bios = nouveau_bios(priv);
+        struct nvbios_pll info;
+        int N, fN, M, P;
+        int ret;
+
+        ret = nvbios_pll_parse(bios, type, &info);
+        if (ret)
+                return ret;
+
+        ret = nva3_pll_calc(clk, &info, freq, &N, &fN, &M, &P);
+        if (ret < 0)
+                return ret;
+
+        switch (info.type) {
+        case PLL_VPLL0:
+        case PLL_VPLL1:
+                nv_wr32(priv, info.reg + 0, 0x50000610);
+                nv_mask(priv, info.reg + 4, 0x003fffff,
+                                            (P << 16) | (M << 8) | N);
+                nv_wr32(priv, info.reg + 8, fN);
+                break;
+        default:
+                nv_warn(priv, "0x%08x/%dKhz unimplemented\n", type, freq);
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+static int
+nva3_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nva3_clock_priv *priv;
+        int ret;
+
+        ret = nouveau_clock_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.pll_set = nva3_clock_pll_set;
+        return 0;
+}
+
+struct nouveau_oclass
+nva3_clock_oclass = {
+        .handle = NV_SUBDEV(CLOCK, 0xa3),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nva3_clock_ctor,
+                .dtor = _nouveau_clock_dtor,
+                .init = _nouveau_clock_init,
+                .fini = _nouveau_clock_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c
new file mode 100644
index 000000000000..5ccce0b17bf3
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2012 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 <subdev/clock.h>
+#include <subdev/bios.h>
+#include <subdev/bios/pll.h>
+
+#include "pll.h"
+
+struct nvc0_clock_priv {
+        struct nouveau_clock base;
+};
+
+static int
+nvc0_clock_pll_set(struct nouveau_clock *clk, u32 type, u32 freq)
+{
+        struct nvc0_clock_priv *priv = (void *)clk;
+        struct nouveau_bios *bios = nouveau_bios(priv);
+        struct nvbios_pll info;
+        int N, fN, M, P;
+        int ret;
+
+        ret = nvbios_pll_parse(bios, type, &info);
+        if (ret)
+                return ret;
+
+        ret = nva3_pll_calc(clk, &info, freq, &N, &fN, &M, &P);
+        if (ret < 0)
+                return ret;
+
+        switch (info.type) {
+        case PLL_VPLL0:
+        case PLL_VPLL1:
+                nv_mask(priv, info.reg + 0x0c, 0x00000000, 0x00000100);
+                nv_wr32(priv, info.reg + 0x04, (P << 16) | (N << 8) | M);
+                nv_wr32(priv, info.reg + 0x10, fN << 16);
+                break;
+        default:
+                nv_warn(priv, "0x%08x/%dKhz unimplemented\n", type, freq);
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+static int
+nvc0_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nvc0_clock_priv *priv;
+        int ret;
+
+        ret = nouveau_clock_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.pll_set = nvc0_clock_pll_set;
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_clock_oclass = {
+        .handle = NV_SUBDEV(CLOCK, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_clock_ctor,
+                .dtor = _nouveau_clock_dtor,
+                .init = _nouveau_clock_init,
+                .fini = _nouveau_clock_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/pll.h b/drivers/gpu/drm/nouveau/core/subdev/clock/pll.h
new file mode 100644
index 000000000000..ef2c0078f337
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/pll.h
@@ -0,0 +1,9 @@
+#ifndef __NOUVEAU_PLL_H__
+#define __NOUVEAU_PLL_H__
+
+int nv04_pll_calc(struct nouveau_clock *, struct nvbios_pll *, u32 freq,
+                  int *N1, int *M1, int *N2, int *M2, int *P);
+int nva3_pll_calc(struct nouveau_clock *, struct nvbios_pll *, u32 freq,
+                  int *N, int *fN, int *M, int *P);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/pllnv04.c b/drivers/gpu/drm/nouveau/core/subdev/clock/pllnv04.c
new file mode 100644
index 000000000000..a2ab6d051ba8
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/pllnv04.c
@@ -0,0 +1,242 @@
+/*
+ * Copyright 1993-2003 NVIDIA, Corporation
+ * Copyright 2007-2009 Stuart Bennett
+ *
+ * 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 AUTHORS 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 <subdev/clock.h>
+#include <subdev/bios.h>
+#include <subdev/bios/pll.h>
+
+#include "pll.h"
+
+static int
+getMNP_single(struct nouveau_clock *clock, struct nvbios_pll *info, int clk,
+              int *pN, int *pM, int *pP)
+{
+        /* Find M, N and P for a single stage PLL
+         *
+         * Note that some bioses (NV3x) have lookup tables of precomputed MNP
+         * values, but we're too lazy to use those atm
+         *
+         * "clk" parameter in kHz
+         * returns calculated clock
+         */
+        int cv = nouveau_bios(clock)->version.chip;
+        int minvco = info->vco1.min_freq, maxvco = info->vco1.max_freq;
+        int minM = info->vco1.min_m, maxM = info->vco1.max_m;
+        int minN = info->vco1.min_n, maxN = info->vco1.max_n;
+        int minU = info->vco1.min_inputfreq;
+        int maxU = info->vco1.max_inputfreq;
+        int minP = info->min_p;
+        int maxP = info->max_p_usable;
+        int crystal = info->refclk;
+        int M, N, thisP, P;
+        int clkP, calcclk;
+        int delta, bestdelta = INT_MAX;
+        int bestclk = 0;
+
+        /* this division verified for nv20, nv18, nv28 (Haiku), and nv34 */
+        /* possibly correlated with introduction of 27MHz crystal */
+        if (cv < 0x17 || cv == 0x1a || cv == 0x20) {
+                if (clk > 250000)
+                        maxM = 6;
+                if (clk > 340000)
+                        maxM = 2;
+        } else if (cv < 0x40) {
+                if (clk > 150000)
+                        maxM = 6;
+                if (clk > 200000)
+                        maxM = 4;
+                if (clk > 340000)
+                        maxM = 2;
+        }
+
+        P = 1 << maxP;
+        if ((clk * P) < minvco) {
+                minvco = clk * maxP;
+                maxvco = minvco * 2;
+        }
+
+        if (clk + clk/200 > maxvco)     /* +0.5% */
+                maxvco = clk + clk/200;
+
+        /* NV34 goes maxlog2P->0, NV20 goes 0->maxlog2P */
+        for (thisP = minP; thisP <= maxP; thisP++) {
+                P = 1 << thisP;
+                clkP = clk * P;
+
+                if (clkP < minvco)
+                        continue;
+                if (clkP > maxvco)
+                        return bestclk;
+
+                for (M = minM; M <= maxM; M++) {
+                        if (crystal/M < minU)
+                                return bestclk;
+                        if (crystal/M > maxU)
+                                continue;
+
+                        /* add crystal/2 to round better */
+                        N = (clkP * M + crystal/2) / crystal;
+
+                        if (N < minN)
+                                continue;
+                        if (N > maxN)
+                                break;
+
+                        /* more rounding additions */
+                        calcclk = ((N * crystal + P/2) / P + M/2) / M;
+                        delta = abs(calcclk - clk);
+                        /* we do an exhaustive search rather than terminating
+                         * on an optimality condition...
+                         */
+                        if (delta < bestdelta) {
+                                bestdelta = delta;
+                                bestclk = calcclk;
+                                *pN = N;
+                                *pM = M;
+                                *pP = thisP;
+                                if (delta == 0) /* except this one */
+                                        return bestclk;
+                        }
+                }
+        }
+
+        return bestclk;
+}
+
+static int
+getMNP_double(struct nouveau_clock *clock, struct nvbios_pll *info, int clk,
+              int *pN1, int *pM1, int *pN2, int *pM2, int *pP)
+{
+        /* Find M, N and P for a two stage PLL
+         *
+         * Note that some bioses (NV30+) have lookup tables of precomputed MNP
+         * values, but we're too lazy to use those atm
+         *
+         * "clk" parameter in kHz
+         * returns calculated clock
+         */
+        int chip_version = nouveau_bios(clock)->version.chip;
+        int minvco1 = info->vco1.min_freq, maxvco1 = info->vco1.max_freq;
+        int minvco2 = info->vco2.min_freq, maxvco2 = info->vco2.max_freq;
+        int minU1 = info->vco1.min_inputfreq, minU2 = info->vco2.min_inputfreq;
+        int maxU1 = info->vco1.max_inputfreq, maxU2 = info->vco2.max_inputfreq;
+        int minM1 = info->vco1.min_m, maxM1 = info->vco1.max_m;
+        int minN1 = info->vco1.min_n, maxN1 = info->vco1.max_n;
+        int minM2 = info->vco2.min_m, maxM2 = info->vco2.max_m;
+        int minN2 = info->vco2.min_n, maxN2 = info->vco2.max_n;
+        int maxlog2P = info->max_p_usable;
+        int crystal = info->refclk;
+        bool fixedgain2 = (minM2 == maxM2 && minN2 == maxN2);
+        int M1, N1, M2, N2, log2P;
+        int clkP, calcclk1, calcclk2, calcclkout;
+        int delta, bestdelta = INT_MAX;
+        int bestclk = 0;
+
+        int vco2 = (maxvco2 - maxvco2/200) / 2;
+        for (log2P = 0; clk && log2P < maxlog2P && clk <= (vco2 >> log2P); log2P++)
+                ;
+        clkP = clk << log2P;
+
+        if (maxvco2 < clk + clk/200)    /* +0.5% */
+                maxvco2 = clk + clk/200;
+
+        for (M1 = minM1; M1 <= maxM1; M1++) {
+                if (crystal/M1 < minU1)
+                        return bestclk;
+                if (crystal/M1 > maxU1)
+                        continue;
+
+                for (N1 = minN1; N1 <= maxN1; N1++) {
+                        calcclk1 = crystal * N1 / M1;
+                        if (calcclk1 < minvco1)
+                                continue;
+                        if (calcclk1 > maxvco1)
+                                break;
+
+                        for (M2 = minM2; M2 <= maxM2; M2++) {
+                                if (calcclk1/M2 < minU2)
+                                        break;
+                                if (calcclk1/M2 > maxU2)
+                                        continue;
+
+                                /* add calcclk1/2 to round better */
+                                N2 = (clkP * M2 + calcclk1/2) / calcclk1;
+                                if (N2 < minN2)
+                                        continue;
+                                if (N2 > maxN2)
+                                        break;
+
+                                if (!fixedgain2) {
+                                        if (chip_version < 0x60)
+                                                if (N2/M2 < 4 || N2/M2 > 10)
+                                                        continue;
+
+                                        calcclk2 = calcclk1 * N2 / M2;
+                                        if (calcclk2 < minvco2)
+                                                break;
+                                        if (calcclk2 > maxvco2)
+                                                continue;
+                                } else
+                                        calcclk2 = calcclk1;
+
+                                calcclkout = calcclk2 >> log2P;
+                                delta = abs(calcclkout - clk);
+                                /* we do an exhaustive search rather than terminating
+                                 * on an optimality condition...
+                                 */
+                                if (delta < bestdelta) {
+                                        bestdelta = delta;
+                                        bestclk = calcclkout;
+                                        *pN1 = N1;
+                                        *pM1 = M1;
+                                        *pN2 = N2;
+                                        *pM2 = M2;
+                                        *pP = log2P;
+                                        if (delta == 0) /* except this one */
+                                                return bestclk;
+                                }
+                        }
+                }
+        }
+
+        return bestclk;
+}
+
+int
+nv04_pll_calc(struct nouveau_clock *clk, struct nvbios_pll *info, u32 freq,
+              int *N1, int *M1, int *N2, int *M2, int *P)
+{
+        int ret;
+
+        if (!info->vco2.max_freq) {
+                ret = getMNP_single(clk, info, freq, N1, M1, P);
+                *N2 = 1;
+                *M2 = 1;
+        } else {
+                ret = getMNP_double(clk, info, freq, N1, M1, N2, M2, P);
+        }
+
+        if (!ret)
+                nv_error(clk, "unable to compute acceptable pll values\n");
+        return ret;
+}
diff --git a/drivers/gpu/drm/nouveau/nv50_calc.c b/drivers/gpu/drm/nouveau/core/subdev/clock/pllnva3.c
index 8cf63a8b30cd..eed5c16cf610 100644
--- a/drivers/gpu/drm/nouveau/nv50_calc.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/pllnva3.c
@@ -22,60 +22,43 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_hw.h"
+#include <subdev/clock.h>
+#include <subdev/bios.h>
+#include <subdev/bios/pll.h>
 
-int
-nv50_calc_pll(struct drm_device *dev, struct pll_lims *pll, int clk,
-              int *N1, int *M1, int *N2, int *M2, int *P)
-{
-        struct nouveau_pll_vals pll_vals;
-        int ret;
-
-        ret = nouveau_calc_pll_mnp(dev, pll, clk, &pll_vals);
-        if (ret <= 0)
-                return ret;
-
-        *N1 = pll_vals.N1;
-        *M1 = pll_vals.M1;
-        *N2 = pll_vals.N2;
-        *M2 = pll_vals.M2;
-        *P = pll_vals.log2P;
-        return ret;
-}
+#include "pll.h"
 
 int
-nva3_calc_pll(struct drm_device *dev, struct pll_lims *pll, int clk,
-              int *pN, int *pfN, int *pM, int *P)
+nva3_pll_calc(struct nouveau_clock *clock, struct nvbios_pll *info,
+              u32 freq, int *pN, int *pfN, int *pM, int *P)
 {
         u32 best_err = ~0, err;
         int M, lM, hM, N, fN;
 
-        *P = pll->vco1.maxfreq / clk;
-        if (*P > pll->max_p)
-                *P = pll->max_p;
-        if (*P < pll->min_p)
-                *P = pll->min_p;
+        *P = info->vco1.max_freq / freq;
+        if (*P > info->max_p)
+                *P = info->max_p;
+        if (*P < info->min_p)
+                *P = info->min_p;
 
-        lM = (pll->refclk + pll->vco1.max_inputfreq) / pll->vco1.max_inputfreq;
-        lM = max(lM, (int)pll->vco1.min_m);
-        hM = (pll->refclk + pll->vco1.min_inputfreq) / pll->vco1.min_inputfreq;
-        hM = min(hM, (int)pll->vco1.max_m);
+        lM = (info->refclk + info->vco1.max_inputfreq) / info->vco1.max_inputfreq;
+        lM = max(lM, (int)info->vco1.min_m);
+        hM = (info->refclk + info->vco1.min_inputfreq) / info->vco1.min_inputfreq;
+        hM = min(hM, (int)info->vco1.max_m);
 
         for (M = lM; M <= hM; M++) {
-                u32 tmp = clk * *P * M;
-                N  = tmp / pll->refclk;
-                fN = tmp % pll->refclk;
-                if (!pfN && fN >= pll->refclk / 2)
+                u32 tmp = freq * *P * M;
+                N  = tmp / info->refclk;
+                fN = tmp % info->refclk;
+                if (!pfN && fN >= info->refclk / 2)
                         N++;
 
-                if (N < pll->vco1.min_n)
+                if (N < info->vco1.min_n)
                         continue;
-                if (N > pll->vco1.max_n)
+                if (N > info->vco1.max_n)
                         break;
 
-                err = abs(clk - (pll->refclk * N / M / *P));
+                err = abs(freq - (info->refclk * N / M / *P));
                 if (err < best_err) {
                         best_err = err;
                         *pN = N;
@@ -83,15 +66,15 @@ nva3_calc_pll(struct drm_device *dev, struct pll_lims *pll, int clk,
                 }
 
                 if (pfN) {
-                        *pfN = (((fN << 13) / pll->refclk) - 4096) & 0xffff;
-                        return clk;
+                        *pfN = (((fN << 13) / info->refclk) - 4096) & 0xffff;
+                        return freq;
                 }
         }
 
         if (unlikely(best_err == ~0)) {
-                NV_ERROR(dev, "unable to find matching pll values\n");
+                nv_error(clock, "unable to find matching pll values\n");
                 return -EINVAL;
         }
 
-        return pll->refclk * *pN / *pM / *P;
+        return info->refclk * *pN / *pM / *P;
 }
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/base.c b/drivers/gpu/drm/nouveau/core/subdev/device/base.c
new file mode 100644
index 000000000000..ca9a4648bd8a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/base.c
@@ -0,0 +1,472 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/device.h>
+#include <core/client.h>
+#include <core/device.h>
+#include <core/option.h>
+
+#include <core/class.h>
+
+#include <subdev/device.h>
+
+static DEFINE_MUTEX(nv_devices_mutex);
+static LIST_HEAD(nv_devices);
+
+struct nouveau_device *
+nouveau_device_find(u64 name)
+{
+        struct nouveau_device *device, *match = NULL;
+        mutex_lock(&nv_devices_mutex);
+        list_for_each_entry(device, &nv_devices, head) {
+                if (device->handle == name) {
+                        match = device;
+                        break;
+                }
+        }
+        mutex_unlock(&nv_devices_mutex);
+        return match;
+}
+
+/******************************************************************************
+ * nouveau_devobj (0x0080): class implementation
+ *****************************************************************************/
+struct nouveau_devobj {
+        struct nouveau_parent base;
+        struct nouveau_object *subdev[NVDEV_SUBDEV_NR];
+        bool created;
+};
+
+static const u64 disable_map[] = {
+        [NVDEV_SUBDEV_VBIOS]    = NV_DEVICE_DISABLE_VBIOS,
+        [NVDEV_SUBDEV_GPIO]     = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_I2C]      = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_DEVINIT]  = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_MC]       = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_TIMER]    = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_FB]       = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_VM]       = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_INSTMEM]  = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_BAR]      = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_VOLT]     = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_CLOCK]    = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_SUBDEV_THERM]    = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_ENGINE_DMAOBJ]   = NV_DEVICE_DISABLE_CORE,
+        [NVDEV_ENGINE_GR]       = NV_DEVICE_DISABLE_GRAPH,
+        [NVDEV_ENGINE_MPEG]     = NV_DEVICE_DISABLE_MPEG,
+        [NVDEV_ENGINE_ME]       = NV_DEVICE_DISABLE_ME,
+        [NVDEV_ENGINE_VP]       = NV_DEVICE_DISABLE_VP,
+        [NVDEV_ENGINE_CRYPT]    = NV_DEVICE_DISABLE_CRYPT,
+        [NVDEV_ENGINE_BSP]      = NV_DEVICE_DISABLE_BSP,
+        [NVDEV_ENGINE_PPP]      = NV_DEVICE_DISABLE_PPP,
+        [NVDEV_ENGINE_COPY0]    = NV_DEVICE_DISABLE_COPY0,
+        [NVDEV_ENGINE_COPY1]    = NV_DEVICE_DISABLE_COPY1,
+        [NVDEV_ENGINE_UNK1C1]   = NV_DEVICE_DISABLE_UNK1C1,
+        [NVDEV_ENGINE_FIFO]     = NV_DEVICE_DISABLE_FIFO,
+        [NVDEV_ENGINE_DISP]     = NV_DEVICE_DISABLE_DISP,
+        [NVDEV_SUBDEV_NR]       = 0,
+};
+
+static int
+nouveau_devobj_ctor(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, void *data, u32 size,
+                    struct nouveau_object **pobject)
+{
+        struct nouveau_client *client = nv_client(parent);
+        struct nouveau_device *device;
+        struct nouveau_devobj *devobj;
+        struct nv_device_class *args = data;
+        u64 disable, boot0, strap;
+        u64 mmio_base, mmio_size;
+        void __iomem *map;
+        int ret, i, c;
+
+        if (size < sizeof(struct nv_device_class))
+                return -EINVAL;
+
+        /* find the device subdev that matches what the client requested */
+        device = nv_device(client->device);
+        if (args->device != ~0) {
+                device = nouveau_device_find(args->device);
+                if (!device)
+                        return -ENODEV;
+        }
+
+        ret = nouveau_parent_create(parent, nv_object(device), oclass, 0, NULL,
+                                    (1ULL << NVDEV_ENGINE_DMAOBJ) |
+                                    (1ULL << NVDEV_ENGINE_FIFO) |
+                                    (1ULL << NVDEV_ENGINE_DISP), &devobj);
+        *pobject = nv_object(devobj);
+        if (ret)
+                return ret;
+
+        mmio_base = pci_resource_start(device->pdev, 0);
+        mmio_size = pci_resource_len(device->pdev, 0);
+
+        /* translate api disable mask into internal mapping */
+        disable = args->debug0;
+        for (i = 0; i < NVDEV_SUBDEV_NR; i++) {
+                if (args->disable & disable_map[i])
+                        disable |= (1ULL << i);
+        }
+
+        /* identify the chipset, and determine classes of subdev/engines */
+        if (!(args->disable & NV_DEVICE_DISABLE_IDENTIFY) &&
+            !device->card_type) {
+                map = ioremap(mmio_base, 0x102000);
+                if (map == NULL)
+                        return -ENOMEM;
+
+                /* switch mmio to cpu's native endianness */
+#ifndef __BIG_ENDIAN
+                if (ioread32_native(map + 0x000004) != 0x00000000)
+#else
+                if (ioread32_native(map + 0x000004) == 0x00000000)
+#endif
+                        iowrite32_native(0x01000001, map + 0x000004);
+
+                /* read boot0 and strapping information */
+                boot0 = ioread32_native(map + 0x000000);
+                strap = ioread32_native(map + 0x101000);
+                iounmap(map);
+
+                /* determine chipset and derive architecture from it */
+                if ((boot0 & 0x0f000000) > 0) {
+                        device->chipset = (boot0 & 0xff00000) >> 20;
+                        switch (device->chipset & 0xf0) {
+                        case 0x10: device->card_type = NV_10; break;
+                        case 0x20: device->card_type = NV_20; break;
+                        case 0x30: device->card_type = NV_30; break;
+                        case 0x40:
+                        case 0x60: device->card_type = NV_40; break;
+                        case 0x50:
+                        case 0x80:
+                        case 0x90:
+                        case 0xa0: device->card_type = NV_50; break;
+                        case 0xc0: device->card_type = NV_C0; break;
+                        case 0xd0: device->card_type = NV_D0; break;
+                        case 0xe0: device->card_type = NV_E0; break;
+                        default:
+                                break;
+                        }
+                } else
+                if ((boot0 & 0xff00fff0) == 0x20004000) {
+                        if (boot0 & 0x00f00000)
+                                device->chipset = 0x05;
+                        else
+                                device->chipset = 0x04;
+                        device->card_type = NV_04;
+                }
+
+                switch (device->card_type) {
+                case NV_04: ret = nv04_identify(device); break;
+                case NV_10: ret = nv10_identify(device); break;
+                case NV_20: ret = nv20_identify(device); break;
+                case NV_30: ret = nv30_identify(device); break;
+                case NV_40: ret = nv40_identify(device); break;
+                case NV_50: ret = nv50_identify(device); break;
+                case NV_C0:
+                case NV_D0: ret = nvc0_identify(device); break;
+                case NV_E0: ret = nve0_identify(device); break;
+                default:
+                        ret = -EINVAL;
+                        break;
+                }
+
+                if (ret) {
+                        nv_error(device, "unknown chipset, 0x%08x\n", boot0);
+                        return ret;
+                }
+
+                nv_info(device, "BOOT0  : 0x%08x\n", boot0);
+                nv_info(device, "Chipset: %s (NV%02X)\n",
+                        device->cname, device->chipset);
+                nv_info(device, "Family : NV%02X\n", device->card_type);
+
+                /* determine frequency of timing crystal */
+                if ( device->chipset < 0x17 ||
+                    (device->chipset >= 0x20 && device->chipset <= 0x25))
+                        strap &= 0x00000040;
+                else
+                        strap &= 0x00400040;
+
+                switch (strap) {
+                case 0x00000000: device->crystal = 13500; break;
+                case 0x00000040: device->crystal = 14318; break;
+                case 0x00400000: device->crystal = 27000; break;
+                case 0x00400040: device->crystal = 25000; break;
+                }
+
+                nv_debug(device, "crystal freq: %dKHz\n", device->crystal);
+        }
+
+        if (!(args->disable & NV_DEVICE_DISABLE_MMIO) &&
+            !nv_subdev(device)->mmio) {
+                nv_subdev(device)->mmio  = ioremap(mmio_base, mmio_size);
+                if (!nv_subdev(device)->mmio) {
+                        nv_error(device, "unable to map device registers\n");
+                        return -ENOMEM;
+                }
+        }
+
+        /* ensure requested subsystems are available for use */
+        for (i = 0, c = 0; i < NVDEV_SUBDEV_NR; i++) {
+                if (!(oclass = device->oclass[i]) || (disable & (1ULL << i)))
+                        continue;
+
+                if (!device->subdev[i]) {
+                        ret = nouveau_object_ctor(nv_object(device), NULL,
+                                                  oclass, NULL, i,
+                                                  &devobj->subdev[i]);
+                        if (ret == -ENODEV)
+                                continue;
+                        if (ret)
+                                return ret;
+
+                        if (nv_iclass(devobj->subdev[i], NV_ENGINE_CLASS))
+                                nouveau_subdev_reset(devobj->subdev[i]);
+                } else {
+                        nouveau_object_ref(device->subdev[i],
+                                          &devobj->subdev[i]);
+                }
+
+                /* note: can't init *any* subdevs until devinit has been run
+                 * due to not knowing exactly what the vbios init tables will
+                 * mess with.  devinit also can't be run until all of its
+                 * dependencies have been created.
+                 *
+                 * this code delays init of any subdev until all of devinit's
+                 * dependencies have been created, and then initialises each
+                 * subdev in turn as they're created.
+                 */
+                while (i >= NVDEV_SUBDEV_DEVINIT_LAST && c <= i) {
+                        struct nouveau_object *subdev = devobj->subdev[c++];
+                        if (subdev && !nv_iclass(subdev, NV_ENGINE_CLASS)) {
+                                ret = nouveau_object_inc(subdev);
+                                if (ret)
+                                        return ret;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+static void
+nouveau_devobj_dtor(struct nouveau_object *object)
+{
+        struct nouveau_devobj *devobj = (void *)object;
+        int i;
+
+        for (i = NVDEV_SUBDEV_NR - 1; i >= 0; i--)
+                nouveau_object_ref(NULL, &devobj->subdev[i]);
+
+        nouveau_parent_destroy(&devobj->base);
+}
+
+static int
+nouveau_devobj_init(struct nouveau_object *object)
+{
+        struct nouveau_devobj *devobj = (void *)object;
+        struct nouveau_object *subdev;
+        int ret, i;
+
+        ret = nouveau_parent_init(&devobj->base);
+        if (ret)
+                return ret;
+
+        for (i = 0; devobj->created && i < NVDEV_SUBDEV_NR; i++) {
+                if ((subdev = devobj->subdev[i])) {
+                        if (!nv_iclass(subdev, NV_ENGINE_CLASS)) {
+                                ret = nouveau_object_inc(subdev);
+                                if (ret)
+                                        goto fail;
+                        }
+                }
+        }
+
+        devobj->created = true;
+        return 0;
+
+fail:
+        for (--i; i >= 0; i--) {
+                if ((subdev = devobj->subdev[i])) {
+                        if (!nv_iclass(subdev, NV_ENGINE_CLASS))
+                                nouveau_object_dec(subdev, false);
+                }
+        }
+
+        return ret;
+}
+
+static int
+nouveau_devobj_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nouveau_devobj *devobj = (void *)object;
+        struct nouveau_object *subdev;
+        int ret, i;
+
+        for (i = NVDEV_SUBDEV_NR - 1; i >= 0; i--) {
+                if ((subdev = devobj->subdev[i])) {
+                        if (!nv_iclass(subdev, NV_ENGINE_CLASS)) {
+                                ret = nouveau_object_dec(subdev, suspend);
+                                if (ret && suspend)
+                                        goto fail;
+                        }
+                }
+        }
+
+        ret = nouveau_parent_fini(&devobj->base, suspend);
+fail:
+        for (; ret && suspend && i < NVDEV_SUBDEV_NR; i++) {
+                if ((subdev = devobj->subdev[i])) {
+                        if (!nv_iclass(subdev, NV_ENGINE_CLASS)) {
+                                ret = nouveau_object_inc(subdev);
+                                if (ret) {
+                                        /* XXX */
+                                }
+                        }
+                }
+        }
+
+        return ret;
+}
+
+static u8
+nouveau_devobj_rd08(struct nouveau_object *object, u32 addr)
+{
+        return nv_rd08(object->engine, addr);
+}
+
+static u16
+nouveau_devobj_rd16(struct nouveau_object *object, u32 addr)
+{
+        return nv_rd16(object->engine, addr);
+}
+
+static u32
+nouveau_devobj_rd32(struct nouveau_object *object, u32 addr)
+{
+        return nv_rd32(object->engine, addr);
+}
+
+static void
+nouveau_devobj_wr08(struct nouveau_object *object, u32 addr, u8 data)
+{
+        nv_wr08(object->engine, addr, data);
+}
+
+static void
+nouveau_devobj_wr16(struct nouveau_object *object, u32 addr, u16 data)
+{
+        nv_wr16(object->engine, addr, data);
+}
+
+static void
+nouveau_devobj_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        nv_wr32(object->engine, addr, data);
+}
+
+static struct nouveau_ofuncs
+nouveau_devobj_ofuncs = {
+        .ctor = nouveau_devobj_ctor,
+        .dtor = nouveau_devobj_dtor,
+        .init = nouveau_devobj_init,
+        .fini = nouveau_devobj_fini,
+        .rd08 = nouveau_devobj_rd08,
+        .rd16 = nouveau_devobj_rd16,
+        .rd32 = nouveau_devobj_rd32,
+        .wr08 = nouveau_devobj_wr08,
+        .wr16 = nouveau_devobj_wr16,
+        .wr32 = nouveau_devobj_wr32,
+};
+
+/******************************************************************************
+ * nouveau_device: engine functions
+ *****************************************************************************/
+struct nouveau_oclass
+nouveau_device_sclass[] = {
+        { 0x0080, &nouveau_devobj_ofuncs },
+        {}
+};
+
+static void
+nouveau_device_dtor(struct nouveau_object *object)
+{
+        struct nouveau_device *device = (void *)object;
+
+        mutex_lock(&nv_devices_mutex);
+        list_del(&device->head);
+        mutex_unlock(&nv_devices_mutex);
+
+        if (device->base.mmio)
+                iounmap(device->base.mmio);
+
+        nouveau_subdev_destroy(&device->base);
+}
+
+static struct nouveau_oclass
+nouveau_device_oclass = {
+        .handle = NV_SUBDEV(DEVICE, 0x00),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .dtor = nouveau_device_dtor,
+        },
+};
+
+int
+nouveau_device_create_(struct pci_dev *pdev, u64 name, const char *sname,
+                       const char *cfg, const char *dbg,
+                       int length, void **pobject)
+{
+        struct nouveau_device *device;
+        int ret = -EEXIST;
+
+        mutex_lock(&nv_devices_mutex);
+        list_for_each_entry(device, &nv_devices, head) {
+                if (device->handle == name)
+                        goto done;
+        }
+
+        ret = nouveau_subdev_create_(NULL, NULL, &nouveau_device_oclass, 0,
+                                     "DEVICE", "device", length, pobject);
+        device = *pobject;
+        if (ret)
+                goto done;
+
+        atomic_set(&nv_object(device)->usecount, 2);
+        device->pdev = pdev;
+        device->handle = name;
+        device->cfgopt = cfg;
+        device->dbgopt = dbg;
+        device->name = sname;
+
+        nv_subdev(device)->debug = nouveau_dbgopt(device->dbgopt, "DEVICE");
+        list_add(&device->head, &nv_devices);
+done:
+        mutex_unlock(&nv_devices_mutex);
+        return ret;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/device/nv04.c
new file mode 100644
index 000000000000..8626d0d6cbbc
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nv04.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/disp.h>
+
+int
+nv04_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0x04:
+                device->cname = "NV04";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv04_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv04_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv04_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv04_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv04_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x05:
+                device->cname = "NV05";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv05_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv04_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv04_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv04_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv04_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown RIVA chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nv10.c b/drivers/gpu/drm/nouveau/core/subdev/device/nv10.c
new file mode 100644
index 000000000000..f09accfd0e31
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nv10.c
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/disp.h>
+
+int
+nv10_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0x10:
+                device->cname = "NV10";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x15:
+                device->cname = "NV15";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv10_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x16:
+                device->cname = "NV16";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv10_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x1a:
+                device->cname = "nForce";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv10_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x11:
+                device->cname = "NV11";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv10_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x17:
+                device->cname = "NV17";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x1f:
+                device->cname = "nForce2";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x18:
+                device->cname = "NV18";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv10_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv10_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Celsius chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nv20.c b/drivers/gpu/drm/nouveau/core/subdev/device/nv20.c
new file mode 100644
index 000000000000..5fa58b7369b5
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nv20.c
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/therm.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/disp.h>
+
+int
+nv20_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0x20:
+                device->cname = "NV20";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv20_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv20_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x25:
+                device->cname = "NV25";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv20_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv25_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x28:
+                device->cname = "NV28";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv20_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv25_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x2a:
+                device->cname = "NV2A";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv20_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv2a_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Kelvin chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nv30.c b/drivers/gpu/drm/nouveau/core/subdev/device/nv30.c
new file mode 100644
index 000000000000..7f4b8fe6cccc
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nv30.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/mpeg.h>
+#include <engine/disp.h>
+
+int
+nv30_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0x30:
+                device->cname = "NV30";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv30_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv30_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x35:
+                device->cname = "NV35";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv30_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv35_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x31:
+                device->cname = "NV31";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv30_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv30_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv31_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x36:
+                device->cname = "NV36";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv20_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv30_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv35_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv31_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x34:
+                device->cname = "NV34";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv04_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv10_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv30_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv04_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv17_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv34_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv31_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Rankine chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nv40.c b/drivers/gpu/drm/nouveau/core/subdev/device/nv40.c
new file mode 100644
index 000000000000..42deadca0f0a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nv40.c
@@ -0,0 +1,375 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/therm.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/mpeg.h>
+#include <engine/disp.h>
+
+int
+nv40_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0x40:
+                device->cname = "NV40";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x41:
+                device->cname = "NV41";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv41_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x42:
+                device->cname = "NV42";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv41_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x43:
+                device->cname = "NV43";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv41_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x45:
+                device->cname = "NV45";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv04_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x47:
+                device->cname = "G70";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv41_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x49:
+                device->cname = "G71";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv41_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x4b:
+                device->cname = "G73";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv04_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv41_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x44:
+                device->cname = "NV44";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x46:
+                device->cname = "G72";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x4a:
+                device->cname = "NV44A";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x4c:
+                device->cname = "C61";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x4e:
+                device->cname = "C51";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x63:
+                device->cname = "C73";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x67:
+                device->cname = "C67";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        case 0x68:
+                device->cname = "C68";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv10_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv40_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv40_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv1a_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv44_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv40_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv40_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv44_vmmgr_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv04_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv40_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv10_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv40_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv40_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv04_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Curie chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/device/nv50.c
new file mode 100644
index 000000000000..fec3bcc9a6fc
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nv50.c
@@ -0,0 +1,410 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/therm.h>
+#include <subdev/mxm.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+#include <subdev/bar.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/mpeg.h>
+#include <engine/vp.h>
+#include <engine/crypt.h>
+#include <engine/bsp.h>
+#include <engine/ppp.h>
+#include <engine/copy.h>
+#include <engine/disp.h>
+
+int
+nv50_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0x50:
+                device->cname = "G80";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv50_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv50_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv50_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0x84:
+                device->cname = "G84";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv50_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv84_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0x86:
+                device->cname = "G86";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv50_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv84_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0x92:
+                device->cname = "G92";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv50_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv84_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0x94:
+                device->cname = "G94";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv50_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv84_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0x96:
+                device->cname = "G96";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv50_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv84_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0x98:
+                device->cname = "G98";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv98_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xa0:
+                device->cname = "G200";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv84_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xaa:
+                device->cname = "MCP77/MCP78";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv98_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xac:
+                device->cname = "MCP79/MCP7A";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nv50_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_CRYPT  ] = &nv98_crypt_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xa3:
+                device->cname = "GT215";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nva3_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_MPEG   ] = &nv84_mpeg_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nva3_copy_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xa5:
+                device->cname = "GT216";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nva3_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nva3_copy_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xa8:
+                device->cname = "GT218";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nva3_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nva3_copy_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xaf:
+                device->cname = "MCP89";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nva3_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nv98_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nv50_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nv50_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nv50_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nv50_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nv84_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nv50_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nv50_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nva3_copy_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Tesla chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/device/nvc0.c
new file mode 100644
index 000000000000..6697f0f9c293
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nvc0.c
@@ -0,0 +1,285 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/therm.h>
+#include <subdev/mxm.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/ltcg.h>
+#include <subdev/ibus.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+#include <subdev/bar.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/vp.h>
+#include <engine/bsp.h>
+#include <engine/ppp.h>
+#include <engine/copy.h>
+#include <engine/disp.h>
+
+int
+nvc0_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0xc0:
+                device->cname = "GF100";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xc4:
+                device->cname = "GF104";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xc3:
+                device->cname = "GF106";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xce:
+                device->cname = "GF114";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xcf:
+                device->cname = "GF116";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xc1:
+                device->cname = "GF108";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xc8:
+                device->cname = "GF110";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nv50_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nvc0_copy1_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nv50_disp_oclass;
+                break;
+        case 0xd9:
+                device->cname = "GF119";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nvd0_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nvc0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nvc0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nvc0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_VP     ] = &nv84_vp_oclass;
+                device->oclass[NVDEV_ENGINE_BSP    ] = &nv84_bsp_oclass;
+                device->oclass[NVDEV_ENGINE_PPP    ] = &nv98_ppp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nvc0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nvd0_disp_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Fermi chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/device/nve0.c b/drivers/gpu/drm/nouveau/core/subdev/device/nve0.c
new file mode 100644
index 000000000000..4a280b7ab853
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/device/nve0.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2012 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 <subdev/device.h>
+#include <subdev/bios.h>
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+#include <subdev/clock.h>
+#include <subdev/therm.h>
+#include <subdev/mxm.h>
+#include <subdev/devinit.h>
+#include <subdev/mc.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/ltcg.h>
+#include <subdev/ibus.h>
+#include <subdev/instmem.h>
+#include <subdev/vm.h>
+#include <subdev/bar.h>
+
+#include <engine/dmaobj.h>
+#include <engine/fifo.h>
+#include <engine/software.h>
+#include <engine/graph.h>
+#include <engine/disp.h>
+#include <engine/copy.h>
+
+int
+nve0_identify(struct nouveau_device *device)
+{
+        switch (device->chipset) {
+        case 0xe4:
+                device->cname = "GK104";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nvd0_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nve0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nve0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nve0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nvd0_disp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nve0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nve0_copy1_oclass;
+                break;
+        case 0xe7:
+                device->cname = "GK107";
+                device->oclass[NVDEV_SUBDEV_VBIOS  ] = &nouveau_bios_oclass;
+                device->oclass[NVDEV_SUBDEV_GPIO   ] = &nvd0_gpio_oclass;
+                device->oclass[NVDEV_SUBDEV_I2C    ] = &nouveau_i2c_oclass;
+                device->oclass[NVDEV_SUBDEV_CLOCK  ] = &nvc0_clock_oclass;
+                device->oclass[NVDEV_SUBDEV_THERM  ] = &nv50_therm_oclass;
+                device->oclass[NVDEV_SUBDEV_MXM    ] = &nv50_mxm_oclass;
+                device->oclass[NVDEV_SUBDEV_DEVINIT] = &nv50_devinit_oclass;
+                device->oclass[NVDEV_SUBDEV_MC     ] = &nvc0_mc_oclass;
+                device->oclass[NVDEV_SUBDEV_TIMER  ] = &nv04_timer_oclass;
+                device->oclass[NVDEV_SUBDEV_FB     ] = &nvc0_fb_oclass;
+                device->oclass[NVDEV_SUBDEV_LTCG   ] = &nvc0_ltcg_oclass;
+                device->oclass[NVDEV_SUBDEV_IBUS   ] = &nve0_ibus_oclass;
+                device->oclass[NVDEV_SUBDEV_INSTMEM] = &nv50_instmem_oclass;
+                device->oclass[NVDEV_SUBDEV_VM     ] = &nvc0_vmmgr_oclass;
+                device->oclass[NVDEV_SUBDEV_BAR    ] = &nvc0_bar_oclass;
+                device->oclass[NVDEV_ENGINE_DMAOBJ ] = &nvc0_dmaeng_oclass;
+                device->oclass[NVDEV_ENGINE_FIFO   ] = &nve0_fifo_oclass;
+                device->oclass[NVDEV_ENGINE_SW     ] = &nvc0_software_oclass;
+                device->oclass[NVDEV_ENGINE_GR     ] = &nve0_graph_oclass;
+                device->oclass[NVDEV_ENGINE_DISP   ] = &nvd0_disp_oclass;
+                device->oclass[NVDEV_ENGINE_COPY0  ] = &nve0_copy0_oclass;
+                device->oclass[NVDEV_ENGINE_COPY1  ] = &nve0_copy1_oclass;
+                break;
+        default:
+                nv_fatal(device, "unknown Kepler chipset\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/nv98_ppp.c b/drivers/gpu/drm/nouveau/core/subdev/devinit/base.c
index a987dd6e0036..5a07a39c1735 100644
--- a/drivers/gpu/drm/nouveau/nv98_ppp.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/base.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 Red Hat Inc.
+ * Copyright 2012 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"),
@@ -22,57 +22,48 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
+#include <core/option.h>
 
-struct nv98_ppp_engine {
-        struct nouveau_exec_engine base;
-};
+#include <subdev/devinit.h>
+#include <subdev/bios.h>
+#include <subdev/bios/init.h>
 
-static int
-nv98_ppp_fini(struct drm_device *dev, int engine, bool suspend)
+int
+nouveau_devinit_init(struct nouveau_devinit *devinit)
 {
-        if (!(nv_rd32(dev, 0x000200) & 0x00000002))
-                return 0;
+        int ret = nouveau_subdev_init(&devinit->base);
+        if (ret)
+                return ret;
 
-        nv_mask(dev, 0x000200, 0x00000002, 0x00000000);
-        return 0;
+        return nvbios_init(&devinit->base, devinit->post);
 }
 
-static int
-nv98_ppp_init(struct drm_device *dev, int engine)
-{
-        nv_mask(dev, 0x000200, 0x00000002, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00000002, 0x00000002);
-        return 0;
-}
-
-static void
-nv98_ppp_destroy(struct drm_device *dev, int engine)
+int
+nouveau_devinit_fini(struct nouveau_devinit *devinit, bool suspend)
 {
-        struct nv98_ppp_engine *pppp = nv_engine(dev, engine);
+        /* force full reinit on resume */
+        if (suspend)
+                devinit->post = true;
 
-        NVOBJ_ENGINE_DEL(dev, PPP);
-
-        kfree(pppp);
+        return nouveau_subdev_fini(&devinit->base, suspend);
 }
 
 int
-nv98_ppp_create(struct drm_device *dev)
+nouveau_devinit_create_(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass,
+                        int size, void **pobject)
 {
-        struct nv98_ppp_engine *pppp;
-
-        pppp = kzalloc(sizeof(*pppp), GFP_KERNEL);
-        if (!pppp)
-                return -ENOMEM;
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_devinit *devinit;
+        int ret;
 
-        pppp->base.destroy = nv98_ppp_destroy;
-        pppp->base.init = nv98_ppp_init;
-        pppp->base.fini = nv98_ppp_fini;
+        ret = nouveau_subdev_create_(parent, engine, oclass, 0, "DEVINIT",
+                                     "init", size, pobject);
+        devinit = *pobject;
+        if (ret)
+                return ret;
 
-        NVOBJ_ENGINE_ADD(dev, PPP, &pppp->base);
+        devinit->post = nouveau_boolopt(device->cfgopt, "NvForcePost", false);
         return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/core/subdev/devinit/fbmem.h b/drivers/gpu/drm/nouveau/core/subdev/devinit/fbmem.h
new file mode 100644
index 000000000000..6b56a0f4cb40
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/fbmem.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#define NV04_PFB_BOOT_0                                         0x00100000
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT                       0x00000003
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_32MB                  0x00000000
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_4MB                   0x00000001
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_8MB                   0x00000002
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_16MB                  0x00000003
+#       define NV04_PFB_BOOT_0_RAM_WIDTH_128                    0x00000004
+#       define NV04_PFB_BOOT_0_RAM_TYPE                         0x00000028
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_8MBIT             0x00000000
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT            0x00000008
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT_4BANK      0x00000010
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_16MBIT            0x00000018
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_64MBIT            0x00000020
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_64MBITX16         0x00000028
+#       define NV04_PFB_BOOT_0_UMA_ENABLE                       0x00000100
+#       define NV04_PFB_BOOT_0_UMA_SIZE                         0x0000f000
+#define NV04_PFB_DEBUG_0                                        0x00100080
+#       define NV04_PFB_DEBUG_0_PAGE_MODE                       0x00000001
+#       define NV04_PFB_DEBUG_0_REFRESH_OFF                     0x00000010
+#       define NV04_PFB_DEBUG_0_REFRESH_COUNTX64                0x00003f00
+#       define NV04_PFB_DEBUG_0_REFRESH_SLOW_CLK                0x00004000
+#       define NV04_PFB_DEBUG_0_SAFE_MODE                       0x00008000
+#       define NV04_PFB_DEBUG_0_ALOM_ENABLE                     0x00010000
+#       define NV04_PFB_DEBUG_0_CASOE                           0x00100000
+#       define NV04_PFB_DEBUG_0_CKE_INVERT                      0x10000000
+#       define NV04_PFB_DEBUG_0_REFINC                          0x20000000
+#       define NV04_PFB_DEBUG_0_SAVE_POWER_OFF                  0x40000000
+#define NV04_PFB_CFG0                                           0x00100200
+#       define NV04_PFB_CFG0_SCRAMBLE                           0x20000000
+#define NV04_PFB_CFG1                                           0x00100204
+#define NV04_PFB_SCRAMBLE(i)                         (0x00100400 + 4 * (i))
+
+#define NV10_PFB_REFCTRL                                        0x00100210
+#       define NV10_PFB_REFCTRL_VALID_1                         (1 << 31)
+
+static inline struct io_mapping *
+fbmem_init(struct pci_dev *pdev)
+{
+        return io_mapping_create_wc(pci_resource_start(pdev, 1),
+                                    pci_resource_len(pdev, 1));
+}
+
+static inline void
+fbmem_fini(struct io_mapping *fb)
+{
+        io_mapping_free(fb);
+}
+
+static inline u32
+fbmem_peek(struct io_mapping *fb, u32 off)
+{
+        u8 __iomem *p = io_mapping_map_atomic_wc(fb, off & PAGE_MASK);
+        u32 val = ioread32(p + (off & ~PAGE_MASK));
+        io_mapping_unmap_atomic(p);
+        return val;
+}
+
+static inline void
+fbmem_poke(struct io_mapping *fb, u32 off, u32 val)
+{
+        u8 __iomem *p = io_mapping_map_atomic_wc(fb, off & PAGE_MASK);
+        iowrite32(val, p + (off & ~PAGE_MASK));
+        wmb();
+        io_mapping_unmap_atomic(p);
+}
+
+static inline bool
+fbmem_readback(struct io_mapping *fb, u32 off, u32 val)
+{
+        fbmem_poke(fb, off, val);
+        return val == fbmem_peek(fb, off);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/devinit/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv04.c
new file mode 100644
index 000000000000..7a72d9394340
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv04.c
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/devinit.h>
+#include <subdev/vga.h>
+
+#include "fbmem.h"
+
+struct nv04_devinit_priv {
+        struct nouveau_devinit base;
+        int owner;
+};
+
+static void
+nv04_devinit_meminit(struct nouveau_devinit *devinit)
+{
+        struct nv04_devinit_priv *priv = (void *)devinit;
+        u32 patt = 0xdeadbeef;
+        struct io_mapping *fb;
+        int i;
+
+        /* Map the framebuffer aperture */
+        fb = fbmem_init(nv_device(priv)->pdev);
+        if (!fb) {
+                nv_error(priv, "failed to map fb\n");
+                return;
+        }
+
+        /* Sequencer and refresh off */
+        nv_wrvgas(priv, 0, 1, nv_rdvgas(priv, 0, 1) | 0x20);
+        nv_mask(priv, NV04_PFB_DEBUG_0, 0, NV04_PFB_DEBUG_0_REFRESH_OFF);
+
+        nv_mask(priv, NV04_PFB_BOOT_0, ~0,
+                      NV04_PFB_BOOT_0_RAM_AMOUNT_16MB |
+                      NV04_PFB_BOOT_0_RAM_WIDTH_128 |
+                      NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT);
+
+        for (i = 0; i < 4; i++)
+                fbmem_poke(fb, 4 * i, patt);
+
+        fbmem_poke(fb, 0x400000, patt + 1);
+
+        if (fbmem_peek(fb, 0) == patt + 1) {
+                nv_mask(priv, NV04_PFB_BOOT_0,
+                              NV04_PFB_BOOT_0_RAM_TYPE,
+                              NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_16MBIT);
+                nv_mask(priv, NV04_PFB_DEBUG_0,
+                              NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
+
+                for (i = 0; i < 4; i++)
+                        fbmem_poke(fb, 4 * i, patt);
+
+                if ((fbmem_peek(fb, 0xc) & 0xffff) != (patt & 0xffff))
+                        nv_mask(priv, NV04_PFB_BOOT_0,
+                                      NV04_PFB_BOOT_0_RAM_WIDTH_128 |
+                                      NV04_PFB_BOOT_0_RAM_AMOUNT,
+                                      NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
+        } else
+        if ((fbmem_peek(fb, 0xc) & 0xffff0000) != (patt & 0xffff0000)) {
+                nv_mask(priv, NV04_PFB_BOOT_0,
+                              NV04_PFB_BOOT_0_RAM_WIDTH_128 |
+                              NV04_PFB_BOOT_0_RAM_AMOUNT,
+                              NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
+        } else
+        if (fbmem_peek(fb, 0) != patt) {
+                if (fbmem_readback(fb, 0x800000, patt))
+                        nv_mask(priv, NV04_PFB_BOOT_0,
+                                      NV04_PFB_BOOT_0_RAM_AMOUNT,
+                                      NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
+                else
+                        nv_mask(priv, NV04_PFB_BOOT_0,
+                                      NV04_PFB_BOOT_0_RAM_AMOUNT,
+                                      NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
+
+                nv_mask(priv, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_TYPE,
+                              NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_8MBIT);
+        } else
+        if (!fbmem_readback(fb, 0x800000, patt)) {
+                nv_mask(priv, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
+                              NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
+
+        }
+
+        /* Refresh on, sequencer on */
+        nv_mask(priv, NV04_PFB_DEBUG_0, NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
+        nv_wrvgas(priv, 0, 1, nv_rdvgas(priv, 0, 1) & ~0x20);
+        fbmem_fini(fb);
+}
+
+static int
+nv04_devinit_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv04_devinit_priv *priv;
+        int ret;
+
+        ret = nouveau_devinit_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.meminit = nv04_devinit_meminit;
+        priv->owner = -1;
+        return 0;
+}
+
+void
+nv04_devinit_dtor(struct nouveau_object *object)
+{
+        struct nv04_devinit_priv *priv = (void *)object;
+
+        /* restore vga owner saved at first init, and lock crtc regs  */
+        nv_wrvgaowner(priv, priv->owner);
+        nv_lockvgac(priv, true);
+
+        nouveau_devinit_destroy(&priv->base);
+}
+
+int
+nv04_devinit_init(struct nouveau_object *object)
+{
+        struct nv04_devinit_priv *priv = (void *)object;
+
+        if (!priv->base.post) {
+                u32 htotal = nv_rdvgac(priv, 0, 0x06);
+                htotal |= (nv_rdvgac(priv, 0, 0x07) & 0x01) << 8;
+                htotal |= (nv_rdvgac(priv, 0, 0x07) & 0x20) << 4;
+                htotal |= (nv_rdvgac(priv, 0, 0x25) & 0x01) << 10;
+                htotal |= (nv_rdvgac(priv, 0, 0x41) & 0x01) << 11;
+                if (!htotal) {
+                        nv_info(priv, "adaptor not initialised\n");
+                        priv->base.post = true;
+                }
+        }
+
+        return nouveau_devinit_init(&priv->base);
+}
+
+int
+nv04_devinit_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv04_devinit_priv *priv = (void *)object;
+
+        /* make i2c busses accessible */
+        nv_mask(priv, 0x000200, 0x00000001, 0x00000001);
+
+        /* unlock extended vga crtc regs, and unslave crtcs */
+        nv_lockvgac(priv, false);
+        if (priv->owner < 0)
+                priv->owner = nv_rdvgaowner(priv);
+        nv_wrvgaowner(priv, 0);
+
+        return nouveau_devinit_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv04_devinit_oclass = {
+        .handle = NV_SUBDEV(DEVINIT, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_devinit_ctor,
+                .dtor = nv04_devinit_dtor,
+                .init = nv04_devinit_init,
+                .fini = nv04_devinit_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/devinit/nv05.c b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv05.c
new file mode 100644
index 000000000000..191447d0d252
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv05.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/devinit.h>
+#include <subdev/bios.h>
+#include <subdev/bios/bmp.h>
+#include <subdev/vga.h>
+
+#include "fbmem.h"
+
+struct nv05_devinit_priv {
+        struct nouveau_devinit base;
+        u8 owner;
+};
+
+static void
+nv05_devinit_meminit(struct nouveau_devinit *devinit)
+{
+        static const u8 default_config_tab[][2] = {
+                { 0x24, 0x00 },
+                { 0x28, 0x00 },
+                { 0x24, 0x01 },
+                { 0x1f, 0x00 },
+                { 0x0f, 0x00 },
+                { 0x17, 0x00 },
+                { 0x06, 0x00 },
+                { 0x00, 0x00 }
+        };
+        struct nv05_devinit_priv *priv = (void *)devinit;
+        struct nouveau_bios *bios = nouveau_bios(priv);
+        struct io_mapping *fb;
+        u32 patt = 0xdeadbeef;
+        u16 data;
+        u8 strap, ramcfg[2];
+        int i, v;
+
+        /* Map the framebuffer aperture */
+        fb = fbmem_init(nv_device(priv)->pdev);
+        if (!fb) {
+                nv_error(priv, "failed to map fb\n");
+                return;
+        }
+
+        strap = (nv_rd32(priv, 0x101000) & 0x0000003c) >> 2;
+        if ((data = bmp_mem_init_table(bios))) {
+                ramcfg[0] = nv_ro08(bios, data + 2 * strap + 0);
+                ramcfg[1] = nv_ro08(bios, data + 2 * strap + 1);
+        } else {
+                ramcfg[0] = default_config_tab[strap][0];
+                ramcfg[1] = default_config_tab[strap][1];
+        }
+
+        /* Sequencer off */
+        nv_wrvgas(priv, 0, 1, nv_rdvgas(priv, 0, 1) | 0x20);
+
+        if (nv_rd32(priv, NV04_PFB_BOOT_0) & NV04_PFB_BOOT_0_UMA_ENABLE)
+                goto out;
+
+        nv_mask(priv, NV04_PFB_DEBUG_0, NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
+
+        /* If present load the hardcoded scrambling table */
+        if (data) {
+                for (i = 0, data += 0x10; i < 8; i++, data += 4) {
+                        u32 scramble = nv_ro32(bios, data);
+                        nv_wr32(priv, NV04_PFB_SCRAMBLE(i), scramble);
+                }
+        }
+
+        /* Set memory type/width/length defaults depending on the straps */
+        nv_mask(priv, NV04_PFB_BOOT_0, 0x3f, ramcfg[0]);
+
+        if (ramcfg[1] & 0x80)
+                nv_mask(priv, NV04_PFB_CFG0, 0, NV04_PFB_CFG0_SCRAMBLE);
+
+        nv_mask(priv, NV04_PFB_CFG1, 0x700001, (ramcfg[1] & 1) << 20);
+        nv_mask(priv, NV04_PFB_CFG1, 0, 1);
+
+        /* Probe memory bus width */
+        for (i = 0; i < 4; i++)
+                fbmem_poke(fb, 4 * i, patt);
+
+        if (fbmem_peek(fb, 0xc) != patt)
+                nv_mask(priv, NV04_PFB_BOOT_0,
+                          NV04_PFB_BOOT_0_RAM_WIDTH_128, 0);
+
+        /* Probe memory length */
+        v = nv_rd32(priv, NV04_PFB_BOOT_0) & NV04_PFB_BOOT_0_RAM_AMOUNT;
+
+        if (v == NV04_PFB_BOOT_0_RAM_AMOUNT_32MB &&
+            (!fbmem_readback(fb, 0x1000000, ++patt) ||
+             !fbmem_readback(fb, 0, ++patt)))
+                nv_mask(priv, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
+                          NV04_PFB_BOOT_0_RAM_AMOUNT_16MB);
+
+        if (v == NV04_PFB_BOOT_0_RAM_AMOUNT_16MB &&
+            !fbmem_readback(fb, 0x800000, ++patt))
+                nv_mask(priv, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
+                          NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
+
+        if (!fbmem_readback(fb, 0x400000, ++patt))
+                nv_mask(priv, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
+                          NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
+
+out:
+        /* Sequencer on */
+        nv_wrvgas(priv, 0, 1, nv_rdvgas(priv, 0, 1) & ~0x20);
+        fbmem_fini(fb);
+}
+
+static int
+nv05_devinit_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv05_devinit_priv *priv;
+        int ret;
+
+        ret = nouveau_devinit_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.meminit = nv05_devinit_meminit;
+        return 0;
+}
+
+struct nouveau_oclass
+nv05_devinit_oclass = {
+        .handle = NV_SUBDEV(DEVINIT, 0x05),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv05_devinit_ctor,
+                .dtor = nv04_devinit_dtor,
+                .init = nv04_devinit_init,
+                .fini = nv04_devinit_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/devinit/nv10.c b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv10.c
new file mode 100644
index 000000000000..eb76ffab6b0c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv10.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/devinit.h>
+#include <subdev/vga.h>
+
+#include "fbmem.h"
+
+struct nv10_devinit_priv {
+        struct nouveau_devinit base;
+        u8 owner;
+};
+
+static void
+nv10_devinit_meminit(struct nouveau_devinit *devinit)
+{
+        struct nv10_devinit_priv *priv = (void *)devinit;
+        const int mem_width[] = { 0x10, 0x00, 0x20 };
+        const int mem_width_count = nv_device(priv)->chipset >= 0x17 ? 3 : 2;
+        uint32_t patt = 0xdeadbeef;
+        struct io_mapping *fb;
+        int i, j, k;
+
+        /* Map the framebuffer aperture */
+        fb = fbmem_init(nv_device(priv)->pdev);
+        if (!fb) {
+                nv_error(priv, "failed to map fb\n");
+                return;
+        }
+
+        nv_wr32(priv, NV10_PFB_REFCTRL, NV10_PFB_REFCTRL_VALID_1);
+
+        /* Probe memory bus width */
+        for (i = 0; i < mem_width_count; i++) {
+                nv_mask(priv, NV04_PFB_CFG0, 0x30, mem_width[i]);
+
+                for (j = 0; j < 4; j++) {
+                        for (k = 0; k < 4; k++)
+                                fbmem_poke(fb, 0x1c, 0);
+
+                        fbmem_poke(fb, 0x1c, patt);
+                        fbmem_poke(fb, 0x3c, 0);
+
+                        if (fbmem_peek(fb, 0x1c) == patt)
+                                goto mem_width_found;
+                }
+        }
+
+mem_width_found:
+        patt <<= 1;
+
+        /* Probe amount of installed memory */
+        for (i = 0; i < 4; i++) {
+                int off = nv_rd32(priv, 0x10020c) - 0x100000;
+
+                fbmem_poke(fb, off, patt);
+                fbmem_poke(fb, 0, 0);
+
+                fbmem_peek(fb, 0);
+                fbmem_peek(fb, 0);
+                fbmem_peek(fb, 0);
+                fbmem_peek(fb, 0);
+
+                if (fbmem_peek(fb, off) == patt)
+                        goto amount_found;
+        }
+
+        /* IC missing - disable the upper half memory space. */
+        nv_mask(priv, NV04_PFB_CFG0, 0x1000, 0);
+
+amount_found:
+        fbmem_fini(fb);
+}
+
+static int
+nv10_devinit_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv10_devinit_priv *priv;
+        int ret;
+
+        ret = nouveau_devinit_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.meminit = nv10_devinit_meminit;
+        return 0;
+}
+
+struct nouveau_oclass
+nv10_devinit_oclass = {
+        .handle = NV_SUBDEV(DEVINIT, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_devinit_ctor,
+                .dtor = nv04_devinit_dtor,
+                .init = nv04_devinit_init,
+                .fini = nv04_devinit_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.h b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv1a.c
index 1d083893a4d7..5b2ba630d913 100644
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.h
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv1a.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2009 Red Hat Inc.
+ * Copyright 2012 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"),
@@ -18,42 +18,41 @@
  * 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
  */
 
-#ifndef __NOUVEAU_I2C_H__
-#define __NOUVEAU_I2C_H__
-
-#include <linux/i2c.h>
-#include <linux/i2c-algo-bit.h>
-#include "drm_dp_helper.h"
-
-#define NV_I2C_PORT(n)    (0x00 + (n))
-#define NV_I2C_PORT_NUM    0x10
-#define NV_I2C_DEFAULT(n) (0x80 + (n))
+#include <subdev/devinit.h>
+#include <subdev/vga.h>
 
-struct nouveau_i2c_chan {
-        struct i2c_adapter adapter;
-        struct drm_device *dev;
-        struct i2c_algo_bit_data bit;
-        struct list_head head;
-        u8  index;
-        u8  type;
-        u32 dcb;
-        u32 drive;
-        u32 sense;
-        u32 state;
+struct nv1a_devinit_priv {
+        struct nouveau_devinit base;
+        u8 owner;
 };
 
-int  nouveau_i2c_init(struct drm_device *);
-void nouveau_i2c_fini(struct drm_device *);
-struct nouveau_i2c_chan *nouveau_i2c_find(struct drm_device *, u8 index);
-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,
-                         bool (*match)(struct nouveau_i2c_chan *,
-                                       struct i2c_board_info *),
-                         int index);
+static int
+nv1a_devinit_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv1a_devinit_priv *priv;
+        int ret;
 
-extern const struct i2c_algorithm nouveau_dp_i2c_algo;
+        ret = nouveau_devinit_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
 
-#endif /* __NOUVEAU_I2C_H__ */
+        return 0;
+}
+
+struct nouveau_oclass
+nv1a_devinit_oclass = {
+        .handle = NV_SUBDEV(DEVINIT, 0x1a),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv1a_devinit_ctor,
+                .dtor = nv04_devinit_dtor,
+                .init = nv04_devinit_init,
+                .fini = nv04_devinit_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/devinit/nv20.c b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv20.c
new file mode 100644
index 000000000000..eb32e99005e4
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv20.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/devinit.h>
+#include <subdev/vga.h>
+
+#include "fbmem.h"
+
+struct nv20_devinit_priv {
+        struct nouveau_devinit base;
+        u8 owner;
+};
+
+static void
+nv20_devinit_meminit(struct nouveau_devinit *devinit)
+{
+        struct nv20_devinit_priv *priv = (void *)devinit;
+        struct nouveau_device *device = nv_device(priv);
+        uint32_t mask = (device->chipset >= 0x25 ? 0x300 : 0x900);
+        uint32_t amount, off;
+        struct io_mapping *fb;
+
+        /* Map the framebuffer aperture */
+        fb = fbmem_init(nv_device(priv)->pdev);
+        if (!fb) {
+                nv_error(priv, "failed to map fb\n");
+                return;
+        }
+
+        nv_wr32(priv, NV10_PFB_REFCTRL, NV10_PFB_REFCTRL_VALID_1);
+
+        /* Allow full addressing */
+        nv_mask(priv, NV04_PFB_CFG0, 0, mask);
+
+        amount = nv_rd32(priv, 0x10020c);
+        for (off = amount; off > 0x2000000; off -= 0x2000000)
+                fbmem_poke(fb, off - 4, off);
+
+        amount = nv_rd32(priv, 0x10020c);
+        if (amount != fbmem_peek(fb, amount - 4))
+                /* IC missing - disable the upper half memory space. */
+                nv_mask(priv, NV04_PFB_CFG0, mask, 0);
+
+        fbmem_fini(fb);
+}
+
+static int
+nv20_devinit_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv20_devinit_priv *priv;
+        int ret;
+
+        ret = nouveau_devinit_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.meminit = nv20_devinit_meminit;
+        return 0;
+}
+
+struct nouveau_oclass
+nv20_devinit_oclass = {
+        .handle = NV_SUBDEV(DEVINIT, 0x20),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv20_devinit_ctor,
+                .dtor = nv04_devinit_dtor,
+                .init = nv04_devinit_init,
+                .fini = nv04_devinit_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/devinit/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv50.c
new file mode 100644
index 000000000000..61becfa732e9
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/devinit/nv50.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2012 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 <subdev/devinit.h>
+#include <subdev/vga.h>
+
+struct nv50_devinit_priv {
+        struct nouveau_devinit base;
+};
+
+static int
+nv50_devinit_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv50_devinit_priv *priv;
+        int ret;
+
+        ret = nouveau_devinit_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static void
+nv50_devinit_dtor(struct nouveau_object *object)
+{
+        struct nv50_devinit_priv *priv = (void *)object;
+        nouveau_devinit_destroy(&priv->base);
+}
+
+static int
+nv50_devinit_init(struct nouveau_object *object)
+{
+        struct nv50_devinit_priv *priv = (void *)object;
+
+        if (!priv->base.post) {
+                if (!nv_rdvgac(priv, 0, 0x00) &&
+                    !nv_rdvgac(priv, 0, 0x1a)) {
+                        nv_info(priv, "adaptor not initialised\n");
+                        priv->base.post = true;
+                }
+        }
+
+        return nouveau_devinit_init(&priv->base);
+}
+
+static int
+nv50_devinit_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv50_devinit_priv *priv = (void *)object;
+        return nouveau_devinit_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv50_devinit_oclass = {
+        .handle = NV_SUBDEV(DEVINIT, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_devinit_ctor,
+                .dtor = nv50_devinit_dtor,
+                .init = nv50_devinit_init,
+                .fini = nv50_devinit_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/base.c b/drivers/gpu/drm/nouveau/core/subdev/fb/base.c
new file mode 100644
index 000000000000..f0086de8af31
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/base.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2012 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 "subdev/fb.h"
+#include "subdev/bios.h"
+#include "subdev/bios/bit.h"
+
+int
+nouveau_fb_bios_memtype(struct nouveau_bios *bios)
+{
+        struct bit_entry M;
+        u8 ramcfg;
+
+        ramcfg = (nv_rd32(bios, 0x101000) & 0x0000003c) >> 2;
+        if (!bit_entry(bios, 'M', &M) && M.version == 2 && M.length >= 5) {
+                u16 table   = nv_ro16(bios, M.offset + 3);
+                u8  version = nv_ro08(bios, table + 0);
+                u8  header  = nv_ro08(bios, table + 1);
+                u8  record  = nv_ro08(bios, table + 2);
+                u8  entries = nv_ro08(bios, table + 3);
+                if (table && version == 0x10 && ramcfg < entries) {
+                        u16 entry = table + header + (ramcfg * record);
+                        switch (nv_ro08(bios, entry) & 0x0f) {
+                        case 0: return NV_MEM_TYPE_DDR2;
+                        case 1: return NV_MEM_TYPE_DDR3;
+                        case 2: return NV_MEM_TYPE_GDDR3;
+                        case 3: return NV_MEM_TYPE_GDDR5;
+                        default:
+                                break;
+                        }
+
+                }
+        }
+
+        return NV_MEM_TYPE_UNKNOWN;
+}
+
+int
+nouveau_fb_init(struct nouveau_fb *pfb)
+{
+        int ret, i;
+
+        ret = nouveau_subdev_init(&pfb->base);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < pfb->tile.regions; i++)
+                pfb->tile.prog(pfb, i, &pfb->tile.region[i]);
+
+        return 0;
+}
+
+int
+_nouveau_fb_init(struct nouveau_object *object)
+{
+        struct nouveau_fb *pfb = (void *)object;
+        return nouveau_fb_init(pfb);
+}
+
+void
+nouveau_fb_destroy(struct nouveau_fb *pfb)
+{
+        int i;
+
+        for (i = 0; i < pfb->tile.regions; i++)
+                pfb->tile.fini(pfb, i, &pfb->tile.region[i]);
+
+        if (pfb->tags.block_size)
+                nouveau_mm_fini(&pfb->tags);
+
+        if (pfb->vram.block_size)
+                nouveau_mm_fini(&pfb->vram);
+
+        nouveau_subdev_destroy(&pfb->base);
+}
+
+void
+_nouveau_fb_dtor(struct nouveau_object *object)
+{
+        struct nouveau_fb *pfb = (void *)object;
+        nouveau_fb_destroy(pfb);
+}
+
+int
+nouveau_fb_created(struct nouveau_fb *pfb)
+{
+        static const char *name[] = {
+                [NV_MEM_TYPE_UNKNOWN] = "unknown",
+                [NV_MEM_TYPE_STOLEN ] = "stolen system memory",
+                [NV_MEM_TYPE_SGRAM  ] = "SGRAM",
+                [NV_MEM_TYPE_SDRAM  ] = "SDRAM",
+                [NV_MEM_TYPE_DDR1   ] = "DDR1",
+                [NV_MEM_TYPE_DDR2   ] = "DDR2",
+                [NV_MEM_TYPE_DDR3   ] = "DDR3",
+                [NV_MEM_TYPE_GDDR2  ] = "GDDR2",
+                [NV_MEM_TYPE_GDDR3  ] = "GDDR3",
+                [NV_MEM_TYPE_GDDR4  ] = "GDDR4",
+                [NV_MEM_TYPE_GDDR5  ] = "GDDR5",
+        };
+
+        if (pfb->ram.size == 0) {
+                nv_fatal(pfb, "no vram detected!!\n");
+                return -ERANGE;
+        }
+
+        nv_info(pfb, "RAM type: %s\n", name[pfb->ram.type]);
+        nv_info(pfb, "RAM size: %d MiB\n", (int)(pfb->ram.size >> 20));
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nv04.c
new file mode 100644
index 000000000000..eb06836b69f7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nv04.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2012 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 <subdev/fb.h>
+
+#define NV04_PFB_BOOT_0                                         0x00100000
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT                       0x00000003
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_32MB                  0x00000000
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_4MB                   0x00000001
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_8MB                   0x00000002
+#       define NV04_PFB_BOOT_0_RAM_AMOUNT_16MB                  0x00000003
+#       define NV04_PFB_BOOT_0_RAM_WIDTH_128                    0x00000004
+#       define NV04_PFB_BOOT_0_RAM_TYPE                         0x00000028
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_8MBIT             0x00000000
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT            0x00000008
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT_4BANK      0x00000010
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_16MBIT            0x00000018
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_64MBIT            0x00000020
+#       define NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_64MBITX16         0x00000028
+#       define NV04_PFB_BOOT_0_UMA_ENABLE                       0x00000100
+#       define NV04_PFB_BOOT_0_UMA_SIZE                         0x0000f000
+#define NV04_PFB_CFG0                                           0x00100200
+
+struct nv04_fb_priv {
+        struct nouveau_fb base;
+};
+
+bool
+nv04_fb_memtype_valid(struct nouveau_fb *pfb, u32 tile_flags)
+{
+        if (!(tile_flags & 0xff00))
+                return true;
+
+        return false;
+}
+
+static int
+nv04_fb_init(struct nouveau_object *object)
+{
+        struct nv04_fb_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_fb_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* This is what the DDX did for NV_ARCH_04, but a mmio-trace shows
+         * nvidia reading PFB_CFG_0, then writing back its original value.
+         * (which was 0x701114 in this case)
+         */
+        nv_wr32(priv, NV04_PFB_CFG0, 0x1114);
+        return 0;
+}
+
+static int
+nv04_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv04_fb_priv *priv;
+        u32 boot0;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        boot0 = nv_rd32(priv, NV04_PFB_BOOT_0);
+        if (boot0 & 0x00000100) {
+                priv->base.ram.size  = ((boot0 >> 12) & 0xf) * 2 + 2;
+                priv->base.ram.size *= 1024 * 1024;
+        } else {
+                switch (boot0 & NV04_PFB_BOOT_0_RAM_AMOUNT) {
+                case NV04_PFB_BOOT_0_RAM_AMOUNT_32MB:
+                        priv->base.ram.size = 32 * 1024 * 1024;
+                        break;
+                case NV04_PFB_BOOT_0_RAM_AMOUNT_16MB:
+                        priv->base.ram.size = 16 * 1024 * 1024;
+                        break;
+                case NV04_PFB_BOOT_0_RAM_AMOUNT_8MB:
+                        priv->base.ram.size = 8 * 1024 * 1024;
+                        break;
+                case NV04_PFB_BOOT_0_RAM_AMOUNT_4MB:
+                        priv->base.ram.size = 4 * 1024 * 1024;
+                        break;
+                }
+        }
+
+        if ((boot0 & 0x00000038) <= 0x10)
+                priv->base.ram.type = NV_MEM_TYPE_SGRAM;
+        else
+                priv->base.ram.type = NV_MEM_TYPE_SDRAM;
+
+
+        priv->base.memtype_valid = nv04_fb_memtype_valid;
+        return nouveau_fb_created(&priv->base);
+}
+
+struct nouveau_oclass
+nv04_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_fb_ctor,
+                .dtor = _nouveau_fb_dtor,
+                .init = nv04_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nv10.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nv10.c
new file mode 100644
index 000000000000..f037a422d2f4
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nv10.c
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/fb.h>
+
+struct nv10_fb_priv {
+        struct nouveau_fb base;
+};
+
+static void
+nv10_fb_tile_init(struct nouveau_fb *pfb, int i, u32 addr, u32 size, u32 pitch,
+                  u32 flags, struct nouveau_fb_tile *tile)
+{
+        tile->addr  = 0x80000000 | addr;
+        tile->limit = max(1u, addr + size) - 1;
+        tile->pitch = pitch;
+}
+
+static void
+nv10_fb_tile_fini(struct nouveau_fb *pfb, int i, struct nouveau_fb_tile *tile)
+{
+        tile->addr  = 0;
+        tile->limit = 0;
+        tile->pitch = 0;
+        tile->zcomp = 0;
+}
+
+void
+nv10_fb_tile_prog(struct nouveau_fb *pfb, int i, struct nouveau_fb_tile *tile)
+{
+        nv_wr32(pfb, 0x100244 + (i * 0x10), tile->limit);
+        nv_wr32(pfb, 0x100248 + (i * 0x10), tile->pitch);
+        nv_wr32(pfb, 0x100240 + (i * 0x10), tile->addr);
+}
+
+static int
+nv10_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nv10_fb_priv *priv;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        if (device->chipset == 0x1a ||  device->chipset == 0x1f) {
+                struct pci_dev *bridge;
+                u32 mem, mib;
+
+                bridge = pci_get_bus_and_slot(0, PCI_DEVFN(0, 1));
+                if (!bridge) {
+                        nv_fatal(device, "no bridge device\n");
+                        return 0;
+                }
+
+                if (device->chipset == 0x1a) {
+                        pci_read_config_dword(bridge, 0x7c, &mem);
+                        mib = ((mem >> 6) & 31) + 1;
+                } else {
+                        pci_read_config_dword(bridge, 0x84, &mem);
+                        mib = ((mem >> 4) & 127) + 1;
+                }
+
+                priv->base.ram.type = NV_MEM_TYPE_STOLEN;
+                priv->base.ram.size = mib * 1024 * 1024;
+        } else {
+                u32 cfg0 = nv_rd32(priv, 0x100200);
+                if (cfg0 & 0x00000001)
+                        priv->base.ram.type = NV_MEM_TYPE_DDR1;
+                else
+                        priv->base.ram.type = NV_MEM_TYPE_SDRAM;
+
+                priv->base.ram.size = nv_rd32(priv, 0x10020c) & 0xff000000;
+        }
+
+        priv->base.memtype_valid = nv04_fb_memtype_valid;
+        priv->base.tile.regions = 8;
+        priv->base.tile.init = nv10_fb_tile_init;
+        priv->base.tile.fini = nv10_fb_tile_fini;
+        priv->base.tile.prog = nv10_fb_tile_prog;
+        return nouveau_fb_created(&priv->base);
+}
+
+struct nouveau_oclass
+nv10_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_fb_ctor,
+                .dtor = _nouveau_fb_dtor,
+                .init = _nouveau_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nv20.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nv20.c
new file mode 100644
index 000000000000..4b3578fcb7fb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nv20.c
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/fb.h>
+
+struct nv20_fb_priv {
+        struct nouveau_fb base;
+};
+
+static void
+nv20_fb_tile_init(struct nouveau_fb *pfb, int i, u32 addr, u32 size, u32 pitch,
+                  u32 flags, struct nouveau_fb_tile *tile)
+{
+        struct nouveau_device *device = nv_device(pfb);
+        int bpp = (flags & 2) ? 32 : 16;
+
+        tile->addr  = 0x00000001 | addr;
+        tile->limit = max(1u, addr + size) - 1;
+        tile->pitch = pitch;
+
+        /* Allocate some of the on-die tag memory, used to store Z
+         * compression meta-data (most likely just a bitmap determining
+         * if a given tile is compressed or not).
+         */
+        size /= 256;
+        if (flags & 4) {
+                if (!nouveau_mm_head(&pfb->tags, 1, size, size, 1, &tile->tag)) {
+                        /* Enable Z compression */
+                        tile->zcomp = tile->tag->offset;
+                        if (device->chipset >= 0x25) {
+                                if (bpp == 16)
+                                        tile->zcomp |= 0x00100000;
+                                else
+                                        tile->zcomp |= 0x00200000;
+                        } else {
+                                tile->zcomp |= 0x80000000;
+                                if (bpp != 16)
+                                        tile->zcomp |= 0x04000000;
+                        }
+                }
+
+                tile->addr |= 2;
+        }
+}
+
+static void
+nv20_fb_tile_fini(struct nouveau_fb *pfb, int i, struct nouveau_fb_tile *tile)
+{
+        tile->addr  = 0;
+        tile->limit = 0;
+        tile->pitch = 0;
+        tile->zcomp = 0;
+        nouveau_mm_free(&pfb->tags, &tile->tag);
+}
+
+static void
+nv20_fb_tile_prog(struct nouveau_fb *pfb, int i, struct nouveau_fb_tile *tile)
+{
+        nv_wr32(pfb, 0x100244 + (i * 0x10), tile->limit);
+        nv_wr32(pfb, 0x100248 + (i * 0x10), tile->pitch);
+        nv_wr32(pfb, 0x100240 + (i * 0x10), tile->addr);
+        nv_wr32(pfb, 0x100300 + (i * 0x04), tile->zcomp);
+}
+
+static int
+nv20_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nv20_fb_priv *priv;
+        u32 pbus1218;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        pbus1218 = nv_rd32(priv, 0x001218);
+        switch (pbus1218 & 0x00000300) {
+        case 0x00000000: priv->base.ram.type = NV_MEM_TYPE_SDRAM; break;
+        case 0x00000100: priv->base.ram.type = NV_MEM_TYPE_DDR1; break;
+        case 0x00000200: priv->base.ram.type = NV_MEM_TYPE_GDDR3; break;
+        case 0x00000300: priv->base.ram.type = NV_MEM_TYPE_GDDR2; break;
+        }
+        priv->base.ram.size = nv_rd32(priv, 0x10020c) & 0xff000000;
+
+        if (device->chipset >= 0x25)
+                ret = nouveau_mm_init(&priv->base.tags, 0, 64 * 1024, 1);
+        else
+                ret = nouveau_mm_init(&priv->base.tags, 0, 32 * 1024, 1);
+        if (ret)
+                return ret;
+
+        priv->base.memtype_valid = nv04_fb_memtype_valid;
+        priv->base.tile.regions = 8;
+        priv->base.tile.init = nv20_fb_tile_init;
+        priv->base.tile.fini = nv20_fb_tile_fini;
+        priv->base.tile.prog = nv20_fb_tile_prog;
+        return nouveau_fb_created(&priv->base);
+}
+
+struct nouveau_oclass
+nv20_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0x20),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv20_fb_ctor,
+                .dtor = _nouveau_fb_dtor,
+                .init = _nouveau_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nv30.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nv30.c
new file mode 100644
index 000000000000..cba67bc91390
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nv30.c
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/fb.h>
+
+struct nv30_fb_priv {
+        struct nouveau_fb base;
+};
+
+void
+nv30_fb_tile_init(struct nouveau_fb *pfb, int i, u32 addr, u32 size, u32 pitch,
+                  u32 flags, struct nouveau_fb_tile *tile)
+{
+        tile->addr = addr | 1;
+        tile->limit = max(1u, addr + size) - 1;
+        tile->pitch = pitch;
+}
+
+void
+nv30_fb_tile_fini(struct nouveau_fb *pfb, int i, struct nouveau_fb_tile *tile)
+{
+        tile->addr  = 0;
+        tile->limit = 0;
+        tile->pitch = 0;
+}
+
+static int
+calc_bias(struct nv30_fb_priv *priv, int k, int i, int j)
+{
+        struct nouveau_device *device = nv_device(priv);
+        int b = (device->chipset > 0x30 ?
+                 nv_rd32(priv, 0x122c + 0x10 * k + 0x4 * j) >> (4 * (i ^ 1)) :
+                 0) & 0xf;
+
+        return 2 * (b & 0x8 ? b - 0x10 : b);
+}
+
+static int
+calc_ref(struct nv30_fb_priv *priv, int l, int k, int i)
+{
+        int j, x = 0;
+
+        for (j = 0; j < 4; j++) {
+                int m = (l >> (8 * i) & 0xff) + calc_bias(priv, k, i, j);
+
+                x |= (0x80 | clamp(m, 0, 0x1f)) << (8 * j);
+        }
+
+        return x;
+}
+
+static int
+nv30_fb_init(struct nouveau_object *object)
+{
+        struct nouveau_device *device = nv_device(object);
+        struct nv30_fb_priv *priv = (void *)object;
+        int ret, i, j;
+
+        ret = nouveau_fb_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* Init the memory timing regs at 0x10037c/0x1003ac */
+        if (device->chipset == 0x30 ||
+            device->chipset == 0x31 ||
+            device->chipset == 0x35) {
+                /* Related to ROP count */
+                int n = (device->chipset == 0x31 ? 2 : 4);
+                int l = nv_rd32(priv, 0x1003d0);
+
+                for (i = 0; i < n; i++) {
+                        for (j = 0; j < 3; j++)
+                                nv_wr32(priv, 0x10037c + 0xc * i + 0x4 * j,
+                                        calc_ref(priv, l, 0, j));
+
+                        for (j = 0; j < 2; j++)
+                                nv_wr32(priv, 0x1003ac + 0x8 * i + 0x4 * j,
+                                        calc_ref(priv, l, 1, j));
+                }
+        }
+
+        return 0;
+}
+
+static int
+nv30_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv30_fb_priv *priv;
+        u32 pbus1218;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        pbus1218 = nv_rd32(priv, 0x001218);
+        switch (pbus1218 & 0x00000300) {
+        case 0x00000000: priv->base.ram.type = NV_MEM_TYPE_SDRAM; break;
+        case 0x00000100: priv->base.ram.type = NV_MEM_TYPE_DDR1; break;
+        case 0x00000200: priv->base.ram.type = NV_MEM_TYPE_GDDR3; break;
+        case 0x00000300: priv->base.ram.type = NV_MEM_TYPE_GDDR2; break;
+        }
+        priv->base.ram.size = nv_rd32(priv, 0x10020c) & 0xff000000;
+
+        priv->base.memtype_valid = nv04_fb_memtype_valid;
+        priv->base.tile.regions = 8;
+        priv->base.tile.init = nv30_fb_tile_init;
+        priv->base.tile.fini = nv30_fb_tile_fini;
+        priv->base.tile.prog = nv10_fb_tile_prog;
+        return nouveau_fb_created(&priv->base);
+}
+
+struct nouveau_oclass
+nv30_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0x30),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv30_fb_ctor,
+                .dtor = _nouveau_fb_dtor,
+                .init = nv30_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nv40.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nv40.c
new file mode 100644
index 000000000000..347a496fcad8
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nv40.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/fb.h>
+
+struct nv40_fb_priv {
+        struct nouveau_fb base;
+};
+
+static inline int
+nv44_graph_class(struct nouveau_device *device)
+{
+        if ((device->chipset & 0xf0) == 0x60)
+                return 1;
+
+        return !(0x0baf & (1 << (device->chipset & 0x0f)));
+}
+
+static void
+nv40_fb_tile_prog(struct nouveau_fb *pfb, int i, struct nouveau_fb_tile *tile)
+{
+        nv_wr32(pfb, 0x100604 + (i * 0x10), tile->limit);
+        nv_wr32(pfb, 0x100608 + (i * 0x10), tile->pitch);
+        nv_wr32(pfb, 0x100600 + (i * 0x10), tile->addr);
+}
+
+static void
+nv40_fb_init_gart(struct nv40_fb_priv *priv)
+{
+        nv_wr32(priv, 0x100800, 0x00000001);
+}
+
+static void
+nv44_fb_init_gart(struct nv40_fb_priv *priv)
+{
+        nv_wr32(priv, 0x100850, 0x80000000);
+        nv_wr32(priv, 0x100800, 0x00000001);
+}
+
+static int
+nv40_fb_init(struct nouveau_object *object)
+{
+        struct nv40_fb_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_fb_init(&priv->base);
+        if (ret)
+                return ret;
+
+        switch (nv_device(priv)->chipset) {
+        case 0x40:
+        case 0x45:
+                nv_mask(priv, 0x10033c, 0x00008000, 0x00000000);
+                break;
+        default:
+                if (nv44_graph_class(nv_device(priv)))
+                        nv44_fb_init_gart(priv);
+                else
+                        nv40_fb_init_gart(priv);
+                break;
+        }
+
+        return 0;
+}
+
+static int
+nv40_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nv40_fb_priv *priv;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        /* 0x001218 is actually present on a few other NV4X I looked at,
+         * and even contains sane values matching 0x100474.  From looking
+         * at various vbios images however, this isn't the case everywhere.
+         * So, I chose to use the same regs I've seen NVIDIA reading around
+         * the memory detection, hopefully that'll get us the right numbers
+         */
+        if (device->chipset == 0x40) {
+                u32 pbus1218 = nv_rd32(priv, 0x001218);
+                switch (pbus1218 & 0x00000300) {
+                case 0x00000000: priv->base.ram.type = NV_MEM_TYPE_SDRAM; break;
+                case 0x00000100: priv->base.ram.type = NV_MEM_TYPE_DDR1; break;
+                case 0x00000200: priv->base.ram.type = NV_MEM_TYPE_GDDR3; break;
+                case 0x00000300: priv->base.ram.type = NV_MEM_TYPE_DDR2; break;
+                }
+        } else
+        if (device->chipset == 0x49 || device->chipset == 0x4b) {
+                u32 pfb914 = nv_rd32(priv, 0x100914);
+                switch (pfb914 & 0x00000003) {
+                case 0x00000000: priv->base.ram.type = NV_MEM_TYPE_DDR1; break;
+                case 0x00000001: priv->base.ram.type = NV_MEM_TYPE_DDR2; break;
+                case 0x00000002: priv->base.ram.type = NV_MEM_TYPE_GDDR3; break;
+                case 0x00000003: break;
+                }
+        } else
+        if (device->chipset != 0x4e) {
+                u32 pfb474 = nv_rd32(priv, 0x100474);
+                if (pfb474 & 0x00000004)
+                        priv->base.ram.type = NV_MEM_TYPE_GDDR3;
+                if (pfb474 & 0x00000002)
+                        priv->base.ram.type = NV_MEM_TYPE_DDR2;
+                if (pfb474 & 0x00000001)
+                        priv->base.ram.type = NV_MEM_TYPE_DDR1;
+        } else {
+                priv->base.ram.type = NV_MEM_TYPE_STOLEN;
+        }
+
+        priv->base.ram.size = nv_rd32(priv, 0x10020c) & 0xff000000;
+
+        priv->base.memtype_valid = nv04_fb_memtype_valid;
+        switch (device->chipset) {
+        case 0x40:
+        case 0x45:
+                priv->base.tile.regions = 8;
+                break;
+        case 0x46:
+        case 0x47:
+        case 0x49:
+        case 0x4b:
+        case 0x4c:
+                priv->base.tile.regions = 15;
+                break;
+        default:
+                priv->base.tile.regions = 12;
+                break;
+        }
+        priv->base.tile.init = nv30_fb_tile_init;
+        priv->base.tile.fini = nv30_fb_tile_fini;
+        if (device->chipset == 0x40)
+                priv->base.tile.prog = nv10_fb_tile_prog;
+        else
+                priv->base.tile.prog = nv40_fb_tile_prog;
+
+        return nouveau_fb_created(&priv->base);
+}
+
+
+struct nouveau_oclass
+nv40_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_fb_ctor,
+                .dtor = _nouveau_fb_dtor,
+                .init = nv40_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nv50.c
new file mode 100644
index 000000000000..436e9efe7ef5
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nv50.c
@@ -0,0 +1,498 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/enum.h>
+
+#include <subdev/fb.h>
+#include <subdev/bios.h>
+
+struct nv50_fb_priv {
+        struct nouveau_fb base;
+        struct page *r100c08_page;
+        dma_addr_t r100c08;
+};
+
+static int types[0x80] = {
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 0, 0,
+        0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        1, 0, 2, 0, 1, 0, 2, 0, 1, 1, 2, 2, 1, 1, 0, 0
+};
+
+static bool
+nv50_fb_memtype_valid(struct nouveau_fb *pfb, u32 memtype)
+{
+        return types[(memtype & 0xff00) >> 8] != 0;
+}
+
+static int
+nv50_fb_vram_new(struct nouveau_fb *pfb, u64 size, u32 align, u32 ncmin,
+                 u32 memtype, struct nouveau_mem **pmem)
+{
+        struct nv50_fb_priv *priv = (void *)pfb;
+        struct nouveau_mm *heap = &priv->base.vram;
+        struct nouveau_mm *tags = &priv->base.tags;
+        struct nouveau_mm_node *r;
+        struct nouveau_mem *mem;
+        int comp = (memtype & 0x300) >> 8;
+        int type = (memtype & 0x07f);
+        int back = (memtype & 0x800);
+        int min, max, ret;
+
+        max = (size >> 12);
+        min = ncmin ? (ncmin >> 12) : max;
+        align >>= 12;
+
+        mem = kzalloc(sizeof(*mem), GFP_KERNEL);
+        if (!mem)
+                return -ENOMEM;
+
+        mutex_lock(&pfb->base.mutex);
+        if (comp) {
+                if (align == 16) {
+                        int n = (max >> 4) * comp;
+
+                        ret = nouveau_mm_head(tags, 1, n, n, 1, &mem->tag);
+                        if (ret)
+                                mem->tag = NULL;
+                }
+
+                if (unlikely(!mem->tag))
+                        comp = 0;
+        }
+
+        INIT_LIST_HEAD(&mem->regions);
+        mem->memtype = (comp << 7) | type;
+        mem->size = max;
+
+        type = types[type];
+        do {
+                if (back)
+                        ret = nouveau_mm_tail(heap, type, max, min, align, &r);
+                else
+                        ret = nouveau_mm_head(heap, type, max, min, align, &r);
+                if (ret) {
+                        mutex_unlock(&pfb->base.mutex);
+                        pfb->ram.put(pfb, &mem);
+                        return ret;
+                }
+
+                list_add_tail(&r->rl_entry, &mem->regions);
+                max -= r->length;
+        } while (max);
+        mutex_unlock(&pfb->base.mutex);
+
+        r = list_first_entry(&mem->regions, struct nouveau_mm_node, rl_entry);
+        mem->offset = (u64)r->offset << 12;
+        *pmem = mem;
+        return 0;
+}
+
+void
+nv50_fb_vram_del(struct nouveau_fb *pfb, struct nouveau_mem **pmem)
+{
+        struct nv50_fb_priv *priv = (void *)pfb;
+        struct nouveau_mm_node *this;
+        struct nouveau_mem *mem;
+
+        mem = *pmem;
+        *pmem = NULL;
+        if (unlikely(mem == NULL))
+                return;
+
+        mutex_lock(&pfb->base.mutex);
+        while (!list_empty(&mem->regions)) {
+                this = list_first_entry(&mem->regions, typeof(*this), rl_entry);
+
+                list_del(&this->rl_entry);
+                nouveau_mm_free(&priv->base.vram, &this);
+        }
+
+        nouveau_mm_free(&priv->base.tags, &mem->tag);
+        mutex_unlock(&pfb->base.mutex);
+
+        kfree(mem);
+}
+
+static u32
+nv50_vram_rblock(struct nv50_fb_priv *priv)
+{
+        int i, parts, colbits, rowbitsa, rowbitsb, banks;
+        u64 rowsize, predicted;
+        u32 r0, r4, rt, ru, rblock_size;
+
+        r0 = nv_rd32(priv, 0x100200);
+        r4 = nv_rd32(priv, 0x100204);
+        rt = nv_rd32(priv, 0x100250);
+        ru = nv_rd32(priv, 0x001540);
+        nv_debug(priv, "memcfg 0x%08x 0x%08x 0x%08x 0x%08x\n", r0, r4, rt, ru);
+
+        for (i = 0, parts = 0; i < 8; i++) {
+                if (ru & (0x00010000 << i))
+                        parts++;
+        }
+
+        colbits  =  (r4 & 0x0000f000) >> 12;
+        rowbitsa = ((r4 & 0x000f0000) >> 16) + 8;
+        rowbitsb = ((r4 & 0x00f00000) >> 20) + 8;
+        banks    = 1 << (((r4 & 0x03000000) >> 24) + 2);
+
+        rowsize = parts * banks * (1 << colbits) * 8;
+        predicted = rowsize << rowbitsa;
+        if (r0 & 0x00000004)
+                predicted += rowsize << rowbitsb;
+
+        if (predicted != priv->base.ram.size) {
+                nv_warn(priv, "memory controller reports %d MiB VRAM\n",
+                        (u32)(priv->base.ram.size >> 20));
+        }
+
+        rblock_size = rowsize;
+        if (rt & 1)
+                rblock_size *= 3;
+
+        nv_debug(priv, "rblock %d bytes\n", rblock_size);
+        return rblock_size;
+}
+
+static int
+nv50_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        const u32 rsvd_head = ( 256 * 1024) >> 12; /* vga memory */
+        const u32 rsvd_tail = (1024 * 1024) >> 12; /* vbios etc */
+        struct nv50_fb_priv *priv;
+        u32 tags;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        switch (nv_rd32(priv, 0x100714) & 0x00000007) {
+        case 0: priv->base.ram.type = NV_MEM_TYPE_DDR1; break;
+        case 1:
+                if (nouveau_fb_bios_memtype(bios) == NV_MEM_TYPE_DDR3)
+                        priv->base.ram.type = NV_MEM_TYPE_DDR3;
+                else
+                        priv->base.ram.type = NV_MEM_TYPE_DDR2;
+                break;
+        case 2: priv->base.ram.type = NV_MEM_TYPE_GDDR3; break;
+        case 3: priv->base.ram.type = NV_MEM_TYPE_GDDR4; break;
+        case 4: priv->base.ram.type = NV_MEM_TYPE_GDDR5; break;
+        default:
+                break;
+        }
+
+        priv->base.ram.size = nv_rd32(priv, 0x10020c);
+        priv->base.ram.size = (priv->base.ram.size & 0xffffff00) |
+                             ((priv->base.ram.size & 0x000000ff) << 32);
+
+        tags = nv_rd32(priv, 0x100320);
+        if (tags) {
+                ret = nouveau_mm_init(&priv->base.tags, 0, tags, 1);
+                if (ret)
+                        return ret;
+
+                nv_debug(priv, "%d compression tags\n", tags);
+        }
+
+        size = (priv->base.ram.size >> 12) - rsvd_head - rsvd_tail;
+        switch (device->chipset) {
+        case 0xaa:
+        case 0xac:
+        case 0xaf: /* IGPs, no reordering, no real VRAM */
+                ret = nouveau_mm_init(&priv->base.vram, rsvd_head, size, 1);
+                if (ret)
+                        return ret;
+
+                priv->base.ram.stolen = (u64)nv_rd32(priv, 0x100e10) << 12;
+                break;
+        default:
+                ret = nouveau_mm_init(&priv->base.vram, rsvd_head, size,
+                                      nv50_vram_rblock(priv) >> 12);
+                if (ret)
+                        return ret;
+
+                priv->base.ram.ranks = (nv_rd32(priv, 0x100200) & 0x4) ? 2 : 1;
+                break;
+        }
+
+        priv->r100c08_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+        if (priv->r100c08_page) {
+                priv->r100c08 = pci_map_page(device->pdev, priv->r100c08_page,
+                                             0, PAGE_SIZE,
+                                             PCI_DMA_BIDIRECTIONAL);
+                if (pci_dma_mapping_error(device->pdev, priv->r100c08))
+                        nv_warn(priv, "failed 0x100c08 page map\n");
+        } else {
+                nv_warn(priv, "failed 0x100c08 page alloc\n");
+        }
+
+        priv->base.memtype_valid = nv50_fb_memtype_valid;
+        priv->base.ram.get = nv50_fb_vram_new;
+        priv->base.ram.put = nv50_fb_vram_del;
+        return nouveau_fb_created(&priv->base);
+}
+
+static void
+nv50_fb_dtor(struct nouveau_object *object)
+{
+        struct nouveau_device *device = nv_device(object);
+        struct nv50_fb_priv *priv = (void *)object;
+
+        if (priv->r100c08_page) {
+                pci_unmap_page(device->pdev, priv->r100c08, PAGE_SIZE,
+                               PCI_DMA_BIDIRECTIONAL);
+                __free_page(priv->r100c08_page);
+        }
+
+        nouveau_mm_fini(&priv->base.vram);
+        nouveau_fb_destroy(&priv->base);
+}
+
+static int
+nv50_fb_init(struct nouveau_object *object)
+{
+        struct nouveau_device *device = nv_device(object);
+        struct nv50_fb_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_fb_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* Not a clue what this is exactly.  Without pointing it at a
+         * scratch page, VRAM->GART blits with M2MF (as in DDX DFS)
+         * cause IOMMU "read from address 0" errors (rh#561267)
+         */
+        nv_wr32(priv, 0x100c08, priv->r100c08 >> 8);
+
+        /* This is needed to get meaningful information from 100c90
+         * on traps. No idea what these values mean exactly. */
+        switch (device->chipset) {
+        case 0x50:
+                nv_wr32(priv, 0x100c90, 0x000707ff);
+                break;
+        case 0xa3:
+        case 0xa5:
+        case 0xa8:
+                nv_wr32(priv, 0x100c90, 0x000d0fff);
+                break;
+        case 0xaf:
+                nv_wr32(priv, 0x100c90, 0x089d1fff);
+                break;
+        default:
+                nv_wr32(priv, 0x100c90, 0x001d07ff);
+                break;
+        }
+
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_fb_ctor,
+                .dtor = nv50_fb_dtor,
+                .init = nv50_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
+
+static const struct nouveau_enum vm_dispatch_subclients[] = {
+        { 0x00000000, "GRCTX", NULL },
+        { 0x00000001, "NOTIFY", NULL },
+        { 0x00000002, "QUERY", NULL },
+        { 0x00000003, "COND", NULL },
+        { 0x00000004, "M2M_IN", NULL },
+        { 0x00000005, "M2M_OUT", NULL },
+        { 0x00000006, "M2M_NOTIFY", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_ccache_subclients[] = {
+        { 0x00000000, "CB", NULL },
+        { 0x00000001, "TIC", NULL },
+        { 0x00000002, "TSC", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_prop_subclients[] = {
+        { 0x00000000, "RT0", NULL },
+        { 0x00000001, "RT1", NULL },
+        { 0x00000002, "RT2", NULL },
+        { 0x00000003, "RT3", NULL },
+        { 0x00000004, "RT4", NULL },
+        { 0x00000005, "RT5", NULL },
+        { 0x00000006, "RT6", NULL },
+        { 0x00000007, "RT7", NULL },
+        { 0x00000008, "ZETA", NULL },
+        { 0x00000009, "LOCAL", NULL },
+        { 0x0000000a, "GLOBAL", NULL },
+        { 0x0000000b, "STACK", NULL },
+        { 0x0000000c, "DST2D", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_pfifo_subclients[] = {
+        { 0x00000000, "PUSHBUF", NULL },
+        { 0x00000001, "SEMAPHORE", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_bar_subclients[] = {
+        { 0x00000000, "FB", NULL },
+        { 0x00000001, "IN", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_client[] = {
+        { 0x00000000, "STRMOUT", NULL },
+        { 0x00000003, "DISPATCH", vm_dispatch_subclients },
+        { 0x00000004, "PFIFO_WRITE", NULL },
+        { 0x00000005, "CCACHE", vm_ccache_subclients },
+        { 0x00000006, "PPPP", NULL },
+        { 0x00000007, "CLIPID", NULL },
+        { 0x00000008, "PFIFO_READ", NULL },
+        { 0x00000009, "VFETCH", NULL },
+        { 0x0000000a, "TEXTURE", NULL },
+        { 0x0000000b, "PROP", vm_prop_subclients },
+        { 0x0000000c, "PVP", NULL },
+        { 0x0000000d, "PBSP", NULL },
+        { 0x0000000e, "PCRYPT", NULL },
+        { 0x0000000f, "PCOUNTER", NULL },
+        { 0x00000011, "PDAEMON", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_engine[] = {
+        { 0x00000000, "PGRAPH", NULL },
+        { 0x00000001, "PVP", NULL },
+        { 0x00000004, "PEEPHOLE", NULL },
+        { 0x00000005, "PFIFO", vm_pfifo_subclients },
+        { 0x00000006, "BAR", vm_bar_subclients },
+        { 0x00000008, "PPPP", NULL },
+        { 0x00000009, "PBSP", NULL },
+        { 0x0000000a, "PCRYPT", NULL },
+        { 0x0000000b, "PCOUNTER", NULL },
+        { 0x0000000c, "SEMAPHORE_BG", NULL },
+        { 0x0000000d, "PCOPY", NULL },
+        { 0x0000000e, "PDAEMON", NULL },
+        {}
+};
+
+static const struct nouveau_enum vm_fault[] = {
+        { 0x00000000, "PT_NOT_PRESENT", NULL },
+        { 0x00000001, "PT_TOO_SHORT", NULL },
+        { 0x00000002, "PAGE_NOT_PRESENT", NULL },
+        { 0x00000003, "PAGE_SYSTEM_ONLY", NULL },
+        { 0x00000004, "PAGE_READ_ONLY", NULL },
+        { 0x00000006, "NULL_DMAOBJ", NULL },
+        { 0x00000007, "WRONG_MEMTYPE", NULL },
+        { 0x0000000b, "VRAM_LIMIT", NULL },
+        { 0x0000000f, "DMAOBJ_LIMIT", NULL },
+        {}
+};
+
+void
+nv50_fb_trap(struct nouveau_fb *pfb, int display)
+{
+        struct nouveau_device *device = nv_device(pfb);
+        struct nv50_fb_priv *priv = (void *)pfb;
+        const struct nouveau_enum *en, *cl;
+        u32 trap[6], idx, chan;
+        u8 st0, st1, st2, st3;
+        int i;
+
+        idx = nv_rd32(priv, 0x100c90);
+        if (!(idx & 0x80000000))
+                return;
+        idx &= 0x00ffffff;
+
+        for (i = 0; i < 6; i++) {
+                nv_wr32(priv, 0x100c90, idx | i << 24);
+                trap[i] = nv_rd32(priv, 0x100c94);
+        }
+        nv_wr32(priv, 0x100c90, idx | 0x80000000);
+
+        if (!display)
+                return;
+
+        /* decode status bits into something more useful */
+        if (device->chipset  < 0xa3 ||
+            device->chipset == 0xaa || device->chipset == 0xac) {
+                st0 = (trap[0] & 0x0000000f) >> 0;
+                st1 = (trap[0] & 0x000000f0) >> 4;
+                st2 = (trap[0] & 0x00000f00) >> 8;
+                st3 = (trap[0] & 0x0000f000) >> 12;
+        } else {
+                st0 = (trap[0] & 0x000000ff) >> 0;
+                st1 = (trap[0] & 0x0000ff00) >> 8;
+                st2 = (trap[0] & 0x00ff0000) >> 16;
+                st3 = (trap[0] & 0xff000000) >> 24;
+        }
+        chan = (trap[2] << 16) | trap[1];
+
+        nv_error(priv, "trapped %s at 0x%02x%04x%04x on channel 0x%08x ",
+                 (trap[5] & 0x00000100) ? "read" : "write",
+                 trap[5] & 0xff, trap[4] & 0xffff, trap[3] & 0xffff, chan);
+
+        en = nouveau_enum_find(vm_engine, st0);
+        if (en)
+                printk("%s/", en->name);
+        else
+                printk("%02x/", st0);
+
+        cl = nouveau_enum_find(vm_client, st2);
+        if (cl)
+                printk("%s/", cl->name);
+        else
+                printk("%02x/", st2);
+
+        if      (cl && cl->data) cl = nouveau_enum_find(cl->data, st3);
+        else if (en && en->data) cl = nouveau_enum_find(en->data, st3);
+        else                     cl = NULL;
+        if (cl)
+                printk("%s", cl->name);
+        else
+                printk("%02x", st3);
+
+        printk(" reason: ");
+        en = nouveau_enum_find(vm_fault, st1);
+        if (en)
+                printk("%s\n", en->name);
+        else
+                printk("0x%08x\n", st1);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/fb/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/fb/nvc0.c
new file mode 100644
index 000000000000..9f59f2bf0079
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/fb/nvc0.c
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2012 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 <subdev/fb.h>
+#include <subdev/bios.h>
+
+struct nvc0_fb_priv {
+        struct nouveau_fb base;
+        struct page *r100c10_page;
+        dma_addr_t r100c10;
+};
+
+/* 0 = unsupported
+ * 1 = non-compressed
+ * 3 = compressed
+ */
+static const u8 types[256] = {
+        1, 1, 3, 3, 3, 3, 0, 3, 3, 3, 3, 0, 0, 0, 0, 0,
+        0, 1, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
+        3, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 1, 1, 1, 1, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 3, 3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
+        3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3,
+        3, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 3, 0, 3,
+        3, 0, 3, 3, 3, 3, 3, 0, 0, 3, 0, 3, 0, 3, 3, 0,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 1, 1, 0
+};
+
+static bool
+nvc0_fb_memtype_valid(struct nouveau_fb *pfb, u32 tile_flags)
+{
+        u8 memtype = (tile_flags & 0x0000ff00) >> 8;
+        return likely((types[memtype] == 1));
+}
+
+static int
+nvc0_fb_vram_new(struct nouveau_fb *pfb, u64 size, u32 align, u32 ncmin,
+                 u32 memtype, struct nouveau_mem **pmem)
+{
+        struct nouveau_mm *mm = &pfb->vram;
+        struct nouveau_mm_node *r;
+        struct nouveau_mem *mem;
+        int type = (memtype & 0x0ff);
+        int back = (memtype & 0x800);
+        int ret;
+
+        size  >>= 12;
+        align >>= 12;
+        ncmin >>= 12;
+        if (!ncmin)
+                ncmin = size;
+
+        mem = kzalloc(sizeof(*mem), GFP_KERNEL);
+        if (!mem)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&mem->regions);
+        mem->memtype = type;
+        mem->size = size;
+
+        mutex_lock(&mm->mutex);
+        do {
+                if (back)
+                        ret = nouveau_mm_tail(mm, 1, size, ncmin, align, &r);
+                else
+                        ret = nouveau_mm_head(mm, 1, size, ncmin, align, &r);
+                if (ret) {
+                        mutex_unlock(&mm->mutex);
+                        pfb->ram.put(pfb, &mem);
+                        return ret;
+                }
+
+                list_add_tail(&r->rl_entry, &mem->regions);
+                size -= r->length;
+        } while (size);
+        mutex_unlock(&mm->mutex);
+
+        r = list_first_entry(&mem->regions, struct nouveau_mm_node, rl_entry);
+        mem->offset = (u64)r->offset << 12;
+        *pmem = mem;
+        return 0;
+}
+
+static int
+nvc0_fb_init(struct nouveau_object *object)
+{
+        struct nvc0_fb_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_fb_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x100c10, priv->r100c10 >> 8);
+        return 0;
+}
+
+static void
+nvc0_fb_dtor(struct nouveau_object *object)
+{
+        struct nouveau_device *device = nv_device(object);
+        struct nvc0_fb_priv *priv = (void *)object;
+
+        if (priv->r100c10_page) {
+                pci_unmap_page(device->pdev, priv->r100c10, PAGE_SIZE,
+                               PCI_DMA_BIDIRECTIONAL);
+                __free_page(priv->r100c10_page);
+        }
+
+        nouveau_fb_destroy(&priv->base);
+}
+
+static int
+nvc0_vram_detect(struct nvc0_fb_priv *priv)
+{
+        struct nouveau_bios *bios = nouveau_bios(priv);
+        struct nouveau_fb *pfb = &priv->base;
+        const u32 rsvd_head = ( 256 * 1024) >> 12; /* vga memory */
+        const u32 rsvd_tail = (1024 * 1024) >> 12; /* vbios etc */
+        u32 parts = nv_rd32(priv, 0x022438);
+        u32 pmask = nv_rd32(priv, 0x022554);
+        u32 bsize = nv_rd32(priv, 0x10f20c);
+        u32 offset, length;
+        bool uniform = true;
+        int ret, part;
+
+        nv_debug(priv, "0x100800: 0x%08x\n", nv_rd32(priv, 0x100800));
+        nv_debug(priv, "parts 0x%08x mask 0x%08x\n", parts, pmask);
+
+        priv->base.ram.type = nouveau_fb_bios_memtype(bios);
+        priv->base.ram.ranks = (nv_rd32(priv, 0x10f200) & 0x00000004) ? 2 : 1;
+
+        /* read amount of vram attached to each memory controller */
+        for (part = 0; part < parts; part++) {
+                if (!(pmask & (1 << part))) {
+                        u32 psize = nv_rd32(priv, 0x11020c + (part * 0x1000));
+                        if (psize != bsize) {
+                                if (psize < bsize)
+                                        bsize = psize;
+                                uniform = false;
+                        }
+
+                        nv_debug(priv, "%d: mem_amount 0x%08x\n", part, psize);
+                        priv->base.ram.size += (u64)psize << 20;
+                }
+        }
+
+        /* if all controllers have the same amount attached, there's no holes */
+        if (uniform) {
+                offset = rsvd_head;
+                length = (priv->base.ram.size >> 12) - rsvd_head - rsvd_tail;
+                return nouveau_mm_init(&pfb->vram, offset, length, 1);
+        }
+
+        /* otherwise, address lowest common amount from 0GiB */
+        ret = nouveau_mm_init(&pfb->vram, rsvd_head, (bsize << 8) * parts, 1);
+        if (ret)
+                return ret;
+
+        /* and the rest starting from (8GiB + common_size) */
+        offset = (0x0200000000ULL >> 12) + (bsize << 8);
+        length = (priv->base.ram.size >> 12) - (bsize << 8) - rsvd_tail;
+
+        ret = nouveau_mm_init(&pfb->vram, offset, length, 0);
+        if (ret) {
+                nouveau_mm_fini(&pfb->vram);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int
+nvc0_fb_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nvc0_fb_priv *priv;
+        int ret;
+
+        ret = nouveau_fb_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.memtype_valid = nvc0_fb_memtype_valid;
+        priv->base.ram.get = nvc0_fb_vram_new;
+        priv->base.ram.put = nv50_fb_vram_del;
+
+        ret = nvc0_vram_detect(priv);
+        if (ret)
+                return ret;
+
+        priv->r100c10_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+        if (!priv->r100c10_page)
+                return -ENOMEM;
+
+        priv->r100c10 = pci_map_page(device->pdev, priv->r100c10_page, 0,
+                                     PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
+        if (pci_dma_mapping_error(device->pdev, priv->r100c10))
+                return -EFAULT;
+
+        return nouveau_fb_created(&priv->base);
+}
+
+
+struct nouveau_oclass
+nvc0_fb_oclass = {
+        .handle = NV_SUBDEV(FB, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_fb_ctor,
+                .dtor = nvc0_fb_dtor,
+                .init = nvc0_fb_init,
+                .fini = _nouveau_fb_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/gpio/base.c b/drivers/gpu/drm/nouveau/core/subdev/gpio/base.c
new file mode 100644
index 000000000000..abb135f74953
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/gpio/base.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2011 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 <subdev/gpio.h>
+#include <subdev/bios.h>
+#include <subdev/bios/gpio.h>
+
+static int
+nouveau_gpio_drive(struct nouveau_gpio *gpio,
+                   int idx, int line, int dir, int out)
+{
+        return gpio->drive ? gpio->drive(gpio, line, dir, out) : -ENODEV;
+}
+
+static int
+nouveau_gpio_sense(struct nouveau_gpio *gpio, int idx, int line)
+{
+        return gpio->sense ? gpio->sense(gpio, line) : -ENODEV;
+}
+
+static int
+nouveau_gpio_find(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line,
+                  struct dcb_gpio_func *func)
+{
+        if (line == 0xff && tag == 0xff)
+                return -EINVAL;
+
+        if (!dcb_gpio_parse(nouveau_bios(gpio), idx, tag, line, func))
+                return 0;
+
+        /* Apple iMac G4 NV18 */
+        if (nv_device_match(nv_object(gpio), 0x0189, 0x10de, 0x0010)) {
+                if (tag == DCB_GPIO_TVDAC0) {
+                        *func = (struct dcb_gpio_func) {
+                                .func = DCB_GPIO_TVDAC0,
+                                .line = 4,
+                                .log[0] = 0,
+                                .log[1] = 1,
+                        };
+                        return 0;
+                }
+        }
+
+        return -EINVAL;
+}
+
+static int
+nouveau_gpio_set(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line, int state)
+{
+        struct dcb_gpio_func func;
+        int ret;
+
+        ret = nouveau_gpio_find(gpio, idx, tag, line, &func);
+        if (ret == 0) {
+                int dir = !!(func.log[state] & 0x02);
+                int out = !!(func.log[state] & 0x01);
+                ret = nouveau_gpio_drive(gpio, idx, func.line, dir, out);
+        }
+
+        return ret;
+}
+
+static int
+nouveau_gpio_get(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line)
+{
+        struct dcb_gpio_func func;
+        int ret;
+
+        ret = nouveau_gpio_find(gpio, idx, tag, line, &func);
+        if (ret == 0) {
+                ret = nouveau_gpio_sense(gpio, idx, func.line);
+                if (ret >= 0)
+                        ret = (ret == (func.log[1] & 1));
+        }
+
+        return ret;
+}
+
+static int
+nouveau_gpio_irq(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line, bool on)
+{
+        struct dcb_gpio_func func;
+        int ret;
+
+        ret = nouveau_gpio_find(gpio, idx, tag, line, &func);
+        if (ret == 0) {
+                if (idx == 0 && gpio->irq_enable)
+                        gpio->irq_enable(gpio, func.line, on);
+                else
+                        ret = -ENODEV;
+        }
+
+        return ret;
+}
+
+struct gpio_isr {
+        struct nouveau_gpio *gpio;
+        struct list_head head;
+        struct work_struct work;
+        int idx;
+        struct dcb_gpio_func func;
+        void (*handler)(void *, int);
+        void *data;
+        bool inhibit;
+};
+
+static void
+nouveau_gpio_isr_bh(struct work_struct *work)
+{
+        struct gpio_isr *isr = container_of(work, struct gpio_isr, work);
+        struct nouveau_gpio *gpio = isr->gpio;
+        unsigned long flags;
+        int state;
+
+        state = nouveau_gpio_get(gpio, isr->idx, isr->func.func,
+                                                 isr->func.line);
+        if (state >= 0)
+                isr->handler(isr->data, state);
+
+        spin_lock_irqsave(&gpio->lock, flags);
+        isr->inhibit = false;
+        spin_unlock_irqrestore(&gpio->lock, flags);
+}
+
+static void
+nouveau_gpio_isr_run(struct nouveau_gpio *gpio, int idx, u32 line_mask)
+{
+        struct gpio_isr *isr;
+
+        if (idx != 0)
+                return;
+
+        spin_lock(&gpio->lock);
+        list_for_each_entry(isr, &gpio->isr, head) {
+                if (line_mask & (1 << isr->func.line)) {
+                        if (isr->inhibit)
+                                continue;
+                        isr->inhibit = true;
+                        schedule_work(&isr->work);
+                }
+        }
+        spin_unlock(&gpio->lock);
+}
+
+static int
+nouveau_gpio_isr_add(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line,
+                     void (*handler)(void *, int), void *data)
+{
+        struct gpio_isr *isr;
+        unsigned long flags;
+        int ret;
+
+        isr = kzalloc(sizeof(*isr), GFP_KERNEL);
+        if (!isr)
+                return -ENOMEM;
+
+        ret = nouveau_gpio_find(gpio, idx, tag, line, &isr->func);
+        if (ret) {
+                kfree(isr);
+                return ret;
+        }
+
+        INIT_WORK(&isr->work, nouveau_gpio_isr_bh);
+        isr->gpio = gpio;
+        isr->handler = handler;
+        isr->data = data;
+        isr->idx = idx;
+
+        spin_lock_irqsave(&gpio->lock, flags);
+        list_add(&isr->head, &gpio->isr);
+        spin_unlock_irqrestore(&gpio->lock, flags);
+        return 0;
+}
+
+static void
+nouveau_gpio_isr_del(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line,
+                     void (*handler)(void *, int), void *data)
+{
+        struct gpio_isr *isr, *tmp;
+        struct dcb_gpio_func func;
+        unsigned long flags;
+        LIST_HEAD(tofree);
+        int ret;
+
+        ret = nouveau_gpio_find(gpio, idx, tag, line, &func);
+        if (ret == 0) {
+                spin_lock_irqsave(&gpio->lock, flags);
+                list_for_each_entry_safe(isr, tmp, &gpio->isr, head) {
+                        if (memcmp(&isr->func, &func, sizeof(func)) ||
+                            isr->idx != idx ||
+                            isr->handler != handler || isr->data != data)
+                                continue;
+                        list_move_tail(&isr->head, &tofree);
+                }
+                spin_unlock_irqrestore(&gpio->lock, flags);
+
+                list_for_each_entry_safe(isr, tmp, &tofree, head) {
+                        flush_work_sync(&isr->work);
+                        kfree(isr);
+                }
+        }
+}
+
+int
+nouveau_gpio_create_(struct nouveau_object *parent,
+                     struct nouveau_object *engine,
+                     struct nouveau_oclass *oclass, int length, void **pobject)
+{
+        struct nouveau_gpio *gpio;
+        int ret;
+
+        ret = nouveau_subdev_create_(parent, engine, oclass, 0, "GPIO", "gpio",
+                                     length, pobject);
+        gpio = *pobject;
+        if (ret)
+                return ret;
+
+        gpio->find = nouveau_gpio_find;
+        gpio->set  = nouveau_gpio_set;
+        gpio->get  = nouveau_gpio_get;
+        gpio->irq  = nouveau_gpio_irq;
+        gpio->isr_run = nouveau_gpio_isr_run;
+        gpio->isr_add = nouveau_gpio_isr_add;
+        gpio->isr_del = nouveau_gpio_isr_del;
+        INIT_LIST_HEAD(&gpio->isr);
+        spin_lock_init(&gpio->lock);
+        return 0;
+}
+
+static struct dmi_system_id gpio_reset_ids[] = {
+        {
+                .ident = "Apple Macbook 10,1",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro10,1"),
+                }
+        },
+        { }
+};
+
+int
+nouveau_gpio_init(struct nouveau_gpio *gpio)
+{
+        int ret = nouveau_subdev_init(&gpio->base);
+        if (ret == 0 && gpio->reset) {
+                if (dmi_check_system(gpio_reset_ids))
+                        gpio->reset(gpio);
+        }
+        return ret;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/gpio/nv10.c b/drivers/gpu/drm/nouveau/core/subdev/gpio/nv10.c
new file mode 100644
index 000000000000..168d16a9a8e9
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/gpio/nv10.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2009 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <subdev/gpio.h>
+
+struct nv10_gpio_priv {
+        struct nouveau_gpio base;
+};
+
+static int
+nv10_gpio_sense(struct nouveau_gpio *gpio, int line)
+{
+        if (line < 2) {
+                line = line * 16;
+                line = nv_rd32(gpio, 0x600818) >> line;
+                return !!(line & 0x0100);
+        } else
+        if (line < 10) {
+                line = (line - 2) * 4;
+                line = nv_rd32(gpio, 0x60081c) >> line;
+                return !!(line & 0x04);
+        } else
+        if (line < 14) {
+                line = (line - 10) * 4;
+                line = nv_rd32(gpio, 0x600850) >> line;
+                return !!(line & 0x04);
+        }
+
+        return -EINVAL;
+}
+
+static int
+nv10_gpio_drive(struct nouveau_gpio *gpio, int line, int dir, int out)
+{
+        u32 reg, mask, data;
+
+        if (line < 2) {
+                line = line * 16;
+                reg  = 0x600818;
+                mask = 0x00000011;
+                data = (dir << 4) | out;
+        } else
+        if (line < 10) {
+                line = (line - 2) * 4;
+                reg  = 0x60081c;
+                mask = 0x00000003;
+                data = (dir << 1) | out;
+        } else
+        if (line < 14) {
+                line = (line - 10) * 4;
+                reg  = 0x600850;
+                mask = 0x00000003;
+                data = (dir << 1) | out;
+        } else {
+                return -EINVAL;
+        }
+
+        nv_mask(gpio, reg, mask << line, data << line);
+        return 0;
+}
+
+static void
+nv10_gpio_irq_enable(struct nouveau_gpio *gpio, int line, bool on)
+{
+        u32 mask = 0x00010001 << line;
+
+        nv_wr32(gpio, 0x001104, mask);
+        nv_mask(gpio, 0x001144, mask, on ? mask : 0);
+}
+
+static void
+nv10_gpio_intr(struct nouveau_subdev *subdev)
+{
+        struct nv10_gpio_priv *priv = (void *)subdev;
+        u32 intr = nv_rd32(priv, 0x001104);
+        u32 hi = (intr & 0x0000ffff) >> 0;
+        u32 lo = (intr & 0xffff0000) >> 16;
+
+        priv->base.isr_run(&priv->base, 0, hi | lo);
+
+        nv_wr32(priv, 0x001104, intr);
+}
+
+static int
+nv10_gpio_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv10_gpio_priv *priv;
+        int ret;
+
+        ret = nouveau_gpio_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.drive = nv10_gpio_drive;
+        priv->base.sense = nv10_gpio_sense;
+        priv->base.irq_enable = nv10_gpio_irq_enable;
+        nv_subdev(priv)->intr = nv10_gpio_intr;
+        return 0;
+}
+
+static void
+nv10_gpio_dtor(struct nouveau_object *object)
+{
+        struct nv10_gpio_priv *priv = (void *)object;
+        nouveau_gpio_destroy(&priv->base);
+}
+
+static int
+nv10_gpio_init(struct nouveau_object *object)
+{
+        struct nv10_gpio_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_gpio_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x001140, 0x00000000);
+        nv_wr32(priv, 0x001100, 0xffffffff);
+        nv_wr32(priv, 0x001144, 0x00000000);
+        nv_wr32(priv, 0x001104, 0xffffffff);
+        return 0;
+}
+
+static int
+nv10_gpio_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv10_gpio_priv *priv = (void *)object;
+        nv_wr32(priv, 0x001140, 0x00000000);
+        nv_wr32(priv, 0x001144, 0x00000000);
+        return nouveau_gpio_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv10_gpio_oclass = {
+        .handle = NV_SUBDEV(GPIO, 0x10),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv10_gpio_ctor,
+                .dtor = nv10_gpio_dtor,
+                .init = nv10_gpio_init,
+                .fini = nv10_gpio_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/gpio/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/gpio/nv50.c
new file mode 100644
index 000000000000..f3502c961cd9
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/gpio/nv50.c
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2012 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 <subdev/gpio.h>
+
+struct nv50_gpio_priv {
+        struct nouveau_gpio base;
+};
+
+static void
+nv50_gpio_reset(struct nouveau_gpio *gpio)
+{
+        struct nouveau_bios *bios = nouveau_bios(gpio);
+        struct nv50_gpio_priv *priv = (void *)gpio;
+        u16 entry;
+        u8 ver;
+        int ent = -1;
+
+        while ((entry = dcb_gpio_entry(bios, 0, ++ent, &ver))) {
+                static const u32 regs[] = { 0xe100, 0xe28c };
+                u32 data = nv_ro32(bios, entry);
+                u8  line =   (data & 0x0000001f);
+                u8  func =   (data & 0x0000ff00) >> 8;
+                u8  defs = !!(data & 0x01000000);
+                u8  unk0 = !!(data & 0x02000000);
+                u8  unk1 = !!(data & 0x04000000);
+                u32 val = (unk1 << 16) | unk0;
+                u32 reg = regs[line >> 4]; line &= 0x0f;
+
+                if (func == 0xff)
+                        continue;
+
+                gpio->set(gpio, 0, func, line, defs);
+
+                nv_mask(priv, reg, 0x00010001 << line, val << line);
+        }
+}
+
+static int
+nv50_gpio_location(int line, u32 *reg, u32 *shift)
+{
+        const u32 nv50_gpio_reg[4] = { 0xe104, 0xe108, 0xe280, 0xe284 };
+
+        if (line >= 32)
+                return -EINVAL;
+
+        *reg = nv50_gpio_reg[line >> 3];
+        *shift = (line & 7) << 2;
+        return 0;
+}
+
+static int
+nv50_gpio_drive(struct nouveau_gpio *gpio, int line, int dir, int out)
+{
+        u32 reg, shift;
+
+        if (nv50_gpio_location(line, &reg, &shift))
+                return -EINVAL;
+
+        nv_mask(gpio, reg, 7 << shift, (((dir ^ 1) << 1) | out) << shift);
+        return 0;
+}
+
+static int
+nv50_gpio_sense(struct nouveau_gpio *gpio, int line)
+{
+        u32 reg, shift;
+
+        if (nv50_gpio_location(line, &reg, &shift))
+                return -EINVAL;
+
+        return !!(nv_rd32(gpio, reg) & (4 << shift));
+}
+
+void
+nv50_gpio_irq_enable(struct nouveau_gpio *gpio, int line, bool on)
+{
+        u32 reg  = line < 16 ? 0xe050 : 0xe070;
+        u32 mask = 0x00010001 << (line & 0xf);
+
+        nv_wr32(gpio, reg + 4, mask);
+        nv_mask(gpio, reg + 0, mask, on ? mask : 0);
+}
+
+void
+nv50_gpio_intr(struct nouveau_subdev *subdev)
+{
+        struct nv50_gpio_priv *priv = (void *)subdev;
+        u32 intr0, intr1 = 0;
+        u32 hi, lo;
+
+        intr0 = nv_rd32(priv, 0xe054) & nv_rd32(priv, 0xe050);
+        if (nv_device(priv)->chipset >= 0x90)
+                intr1 = nv_rd32(priv, 0xe074) & nv_rd32(priv, 0xe070);
+
+        hi = (intr0 & 0x0000ffff) | (intr1 << 16);
+        lo = (intr0 >> 16) | (intr1 & 0xffff0000);
+        priv->base.isr_run(&priv->base, 0, hi | lo);
+
+        nv_wr32(priv, 0xe054, intr0);
+        if (nv_device(priv)->chipset >= 0x90)
+                nv_wr32(priv, 0xe074, intr1);
+}
+
+static int
+nv50_gpio_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nv50_gpio_priv *priv;
+        int ret;
+
+        ret = nouveau_gpio_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.reset = nv50_gpio_reset;
+        priv->base.drive = nv50_gpio_drive;
+        priv->base.sense = nv50_gpio_sense;
+        priv->base.irq_enable = nv50_gpio_irq_enable;
+        nv_subdev(priv)->intr = nv50_gpio_intr;
+        return 0;
+}
+
+void
+nv50_gpio_dtor(struct nouveau_object *object)
+{
+        struct nv50_gpio_priv *priv = (void *)object;
+        nouveau_gpio_destroy(&priv->base);
+}
+
+int
+nv50_gpio_init(struct nouveau_object *object)
+{
+        struct nv50_gpio_priv *priv = (void *)object;
+        int ret;
+
+        ret = nouveau_gpio_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* disable, and ack any pending gpio interrupts */
+        nv_wr32(priv, 0xe050, 0x00000000);
+        nv_wr32(priv, 0xe054, 0xffffffff);
+        if (nv_device(priv)->chipset >= 0x90) {
+                nv_wr32(priv, 0xe070, 0x00000000);
+                nv_wr32(priv, 0xe074, 0xffffffff);
+        }
+
+        return 0;
+}
+
+int
+nv50_gpio_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv50_gpio_priv *priv = (void *)object;
+        nv_wr32(priv, 0xe050, 0x00000000);
+        if (nv_device(priv)->chipset >= 0x90)
+                nv_wr32(priv, 0xe070, 0x00000000);
+        return nouveau_gpio_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv50_gpio_oclass = {
+        .handle = NV_SUBDEV(GPIO, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_gpio_ctor,
+                .dtor = nv50_gpio_dtor,
+                .init = nv50_gpio_init,
+                .fini = nv50_gpio_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/gpio/nvd0.c b/drivers/gpu/drm/nouveau/core/subdev/gpio/nvd0.c
new file mode 100644
index 000000000000..8d18fcad26e0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/gpio/nvd0.c
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2012 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 <subdev/gpio.h>
+
+struct nvd0_gpio_priv {
+        struct nouveau_gpio base;
+};
+
+static void
+nvd0_gpio_reset(struct nouveau_gpio *gpio)
+{
+        struct nouveau_bios *bios = nouveau_bios(gpio);
+        struct nvd0_gpio_priv *priv = (void *)gpio;
+        u16 entry;
+        u8 ver;
+        int ent = -1;
+
+        while ((entry = dcb_gpio_entry(bios, 0, ++ent, &ver))) {
+                u32 data = nv_ro32(bios, entry);
+                u8  line =   (data & 0x0000003f);
+                u8  defs = !!(data & 0x00000080);
+                u8  func =   (data & 0x0000ff00) >> 8;
+                u8  unk0 =   (data & 0x00ff0000) >> 16;
+                u8  unk1 =   (data & 0x1f000000) >> 24;
+
+                if (func == 0xff)
+                        continue;
+
+                gpio->set(gpio, 0, func, line, defs);
+
+                nv_mask(priv, 0x00d610 + (line * 4), 0xff, unk0);
+                if (unk1--)
+                        nv_mask(priv, 0x00d740 + (unk1 * 4), 0xff, line);
+        }
+}
+
+static int
+nvd0_gpio_drive(struct nouveau_gpio *gpio, int line, int dir, int out)
+{
+        u32 data = ((dir ^ 1) << 13) | (out << 12);
+        nv_mask(gpio, 0x00d610 + (line * 4), 0x00003000, data);
+        nv_mask(gpio, 0x00d604, 0x00000001, 0x00000001); /* update? */
+        return 0;
+}
+
+static int
+nvd0_gpio_sense(struct nouveau_gpio *gpio, int line)
+{
+        return !!(nv_rd32(gpio, 0x00d610 + (line * 4)) & 0x00004000);
+}
+
+static int
+nvd0_gpio_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nvd0_gpio_priv *priv;
+        int ret;
+
+        ret = nouveau_gpio_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.reset = nvd0_gpio_reset;
+        priv->base.drive = nvd0_gpio_drive;
+        priv->base.sense = nvd0_gpio_sense;
+        priv->base.irq_enable = nv50_gpio_irq_enable;
+        nv_subdev(priv)->intr = nv50_gpio_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nvd0_gpio_oclass = {
+        .handle = NV_SUBDEV(GPIO, 0xd0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvd0_gpio_ctor,
+                .dtor = nv50_gpio_dtor,
+                .init = nv50_gpio_init,
+                .fini = nv50_gpio_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/i2c/aux.c b/drivers/gpu/drm/nouveau/core/subdev/i2c/aux.c
new file mode 100644
index 000000000000..fe1ebf199ba9
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/i2c/aux.c
@@ -0,0 +1,212 @@
+/*
+ * Copyright 2009 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 <subdev/i2c.h>
+
+/******************************************************************************
+ * aux channel util functions
+ *****************************************************************************/
+#define AUX_DBG(fmt, args...) nv_debug(aux, "AUXCH(%d): " fmt, ch, ##args)
+#define AUX_ERR(fmt, args...) nv_error(aux, "AUXCH(%d): " fmt, ch, ##args)
+
+static void
+auxch_fini(struct nouveau_i2c *aux, int ch)
+{
+        nv_mask(aux, 0x00e4e4 + (ch * 0x50), 0x00310000, 0x00000000);
+}
+
+static int
+auxch_init(struct nouveau_i2c *aux, int ch)
+{
+        const u32 unksel = 1; /* nfi which to use, or if it matters.. */
+        const u32 ureq = unksel ? 0x00100000 : 0x00200000;
+        const u32 urep = unksel ? 0x01000000 : 0x02000000;
+        u32 ctrl, timeout;
+
+        /* wait up to 1ms for any previous transaction to be done... */
+        timeout = 1000;
+        do {
+                ctrl = nv_rd32(aux, 0x00e4e4 + (ch * 0x50));
+                udelay(1);
+                if (!timeout--) {
+                        AUX_ERR("begin idle timeout 0x%08x", ctrl);
+                        return -EBUSY;
+                }
+        } while (ctrl & 0x03010000);
+
+        /* set some magic, and wait up to 1ms for it to appear */
+        nv_mask(aux, 0x00e4e4 + (ch * 0x50), 0x00300000, ureq);
+        timeout = 1000;
+        do {
+                ctrl = nv_rd32(aux, 0x00e4e4 + (ch * 0x50));
+                udelay(1);
+                if (!timeout--) {
+                        AUX_ERR("magic wait 0x%08x\n", ctrl);
+                        auxch_fini(aux, ch);
+                        return -EBUSY;
+                }
+        } while ((ctrl & 0x03000000) != urep);
+
+        return 0;
+}
+
+static int
+auxch_tx(struct nouveau_i2c *aux, int ch, u8 type, u32 addr, u8 *data, u8 size)
+{
+        u32 ctrl, stat, timeout, retries;
+        u32 xbuf[4] = {};
+        int ret, i;
+
+        AUX_DBG("%d: 0x%08x %d\n", type, addr, size);
+
+        ret = auxch_init(aux, ch);
+        if (ret)
+                goto out;
+
+        stat = nv_rd32(aux, 0x00e4e8 + (ch * 0x50));
+        if (!(stat & 0x10000000)) {
+                AUX_DBG("sink not detected\n");
+                ret = -ENXIO;
+                goto out;
+        }
+
+        if (!(type & 1)) {
+                memcpy(xbuf, data, size);
+                for (i = 0; i < 16; i += 4) {
+                        AUX_DBG("wr 0x%08x\n", xbuf[i / 4]);
+                        nv_wr32(aux, 0x00e4c0 + (ch * 0x50) + i, xbuf[i / 4]);
+                }
+        }
+
+        ctrl  = nv_rd32(aux, 0x00e4e4 + (ch * 0x50));
+        ctrl &= ~0x0001f0ff;
+        ctrl |= type << 12;
+        ctrl |= size - 1;
+        nv_wr32(aux, 0x00e4e0 + (ch * 0x50), addr);
+
+        /* retry transaction a number of times on failure... */
+        ret = -EREMOTEIO;
+        for (retries = 0; retries < 32; retries++) {
+                /* reset, and delay a while if this is a retry */
+                nv_wr32(aux, 0x00e4e4 + (ch * 0x50), 0x80000000 | ctrl);
+                nv_wr32(aux, 0x00e4e4 + (ch * 0x50), 0x00000000 | ctrl);
+                if (retries)
+                        udelay(400);
+
+                /* transaction request, wait up to 1ms for it to complete */
+                nv_wr32(aux, 0x00e4e4 + (ch * 0x50), 0x00010000 | ctrl);
+
+                timeout = 1000;
+                do {
+                        ctrl = nv_rd32(aux, 0x00e4e4 + (ch * 0x50));
+                        udelay(1);
+                        if (!timeout--) {
+                                AUX_ERR("tx req timeout 0x%08x\n", ctrl);
+                                goto out;
+                        }
+                } while (ctrl & 0x00010000);
+
+                /* read status, and check if transaction completed ok */
+                stat = nv_mask(aux, 0x00e4e8 + (ch * 0x50), 0, 0);
+                if (!(stat & 0x000f0f00)) {
+                        ret = 0;
+                        break;
+                }
+
+                AUX_DBG("%02d 0x%08x 0x%08x\n", retries, ctrl, stat);
+        }
+
+        if (type & 1) {
+                for (i = 0; i < 16; i += 4) {
+                        xbuf[i / 4] = nv_rd32(aux, 0x00e4d0 + (ch * 0x50) + i);
+                        AUX_DBG("rd 0x%08x\n", xbuf[i / 4]);
+                }
+                memcpy(data, xbuf, size);
+        }
+
+out:
+        auxch_fini(aux, ch);
+        return ret;
+}
+
+int
+nv_rdaux(struct nouveau_i2c_port *auxch, u32 addr, u8 *data, u8 size)
+{
+        return auxch_tx(auxch->i2c, auxch->drive, 9, addr, data, size);
+}
+
+int
+nv_wraux(struct nouveau_i2c_port *auxch, u32 addr, u8 *data, u8 size)
+{
+        return auxch_tx(auxch->i2c, auxch->drive, 8, addr, data, size);
+}
+
+static int
+aux_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
+{
+        struct nouveau_i2c_port *auxch = (struct nouveau_i2c_port *)adap;
+        struct i2c_msg *msg = msgs;
+        int ret, mcnt = num;
+
+        while (mcnt--) {
+                u8 remaining = msg->len;
+                u8 *ptr = msg->buf;
+
+                while (remaining) {
+                        u8 cnt = (remaining > 16) ? 16 : remaining;
+                        u8 cmd;
+
+                        if (msg->flags & I2C_M_RD)
+                                cmd = 1;
+                        else
+                                cmd = 0;
+
+                        if (mcnt || remaining > 16)
+                                cmd |= 4; /* MOT */
+
+                        ret = auxch_tx(auxch->i2c, auxch->drive, cmd,
+                                       msg->addr, ptr, cnt);
+                        if (ret < 0)
+                                return ret;
+
+                        ptr += cnt;
+                        remaining -= cnt;
+                }
+
+                msg++;
+        }
+
+        return num;
+}
+
+static u32
+aux_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+}
+
+const struct i2c_algorithm nouveau_i2c_aux_algo = {
+        .master_xfer = aux_xfer,
+        .functionality = aux_func
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/i2c/base.c b/drivers/gpu/drm/nouveau/core/subdev/i2c/base.c
new file mode 100644
index 000000000000..3d2c88310f98
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/i2c/base.c
@@ -0,0 +1,407 @@
+/*
+ * Copyright 2012 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 "core/option.h"
+
+#include "subdev/i2c.h"
+#include "subdev/vga.h"
+
+int
+nv_rdi2cr(struct nouveau_i2c_port *port, u8 addr, u8 reg)
+{
+        u8 val;
+        struct i2c_msg msgs[] = {
+                { .addr = addr, .flags = 0, .len = 1, .buf = &reg },
+                { .addr = addr, .flags = I2C_M_RD, .len = 1, .buf = &val },
+        };
+
+        int ret = i2c_transfer(&port->adapter, msgs, 2);
+        if (ret != 2)
+                return -EIO;
+
+        return val;
+}
+
+int
+nv_wri2cr(struct nouveau_i2c_port *port, u8 addr, u8 reg, u8 val)
+{
+        struct i2c_msg msgs[] = {
+                { .addr = addr, .flags = 0, .len = 1, .buf = &reg },
+                { .addr = addr, .flags = 0, .len = 1, .buf = &val },
+        };
+
+        int ret = i2c_transfer(&port->adapter, msgs, 2);
+        if (ret != 2)
+                return -EIO;
+
+        return 0;
+}
+
+bool
+nv_probe_i2c(struct nouveau_i2c_port *port, u8 addr)
+{
+        u8 buf[] = { 0 };
+        struct i2c_msg msgs[] = {
+                {
+                        .addr = addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = buf,
+                },
+                {
+                        .addr = addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = buf,
+                }
+        };
+
+        return i2c_transfer(&port->adapter, msgs, 2) == 2;
+}
+
+static struct nouveau_i2c_port *
+nouveau_i2c_find(struct nouveau_i2c *i2c, u8 index)
+{
+        struct nouveau_bios *bios = nouveau_bios(i2c);
+        struct nouveau_i2c_port *port;
+
+        if (index == NV_I2C_DEFAULT(0) ||
+            index == NV_I2C_DEFAULT(1)) {
+                u8  ver, hdr, cnt, len;
+                u16 i2c = dcb_i2c_table(bios, &ver, &hdr, &cnt, &len);
+                if (i2c && ver >= 0x30) {
+                        u8 auxidx = nv_ro08(bios, i2c + 4);
+                        if (index == NV_I2C_DEFAULT(0))
+                                index = (auxidx & 0x0f) >> 0;
+                        else
+                                index = (auxidx & 0xf0) >> 4;
+                } else {
+                        index = 2;
+                }
+        }
+
+        list_for_each_entry(port, &i2c->ports, head) {
+                if (port->index == index)
+                        break;
+        }
+
+        if (&port->head == &i2c->ports)
+                return NULL;
+
+        if (nv_device(i2c)->card_type >= NV_50 && (port->dcb & 0x00000100)) {
+                u32 reg = 0x00e500, val;
+                if (port->type == 6) {
+                        reg += port->drive * 0x50;
+                        val  = 0x2002;
+                } else {
+                        reg += ((port->dcb & 0x1e00) >> 9) * 0x50;
+                        val  = 0xe001;
+                }
+
+                /* nfi, but neither auxch or i2c work if it's 1 */
+                nv_mask(i2c, reg + 0x0c, 0x00000001, 0x00000000);
+                /* nfi, but switches auxch vs normal i2c */
+                nv_mask(i2c, reg + 0x00, 0x0000f003, val);
+        }
+
+        return port;
+}
+
+static int
+nouveau_i2c_identify(struct nouveau_i2c *i2c, int index, const char *what,
+                     struct i2c_board_info *info,
+                     bool (*match)(struct nouveau_i2c_port *,
+                                   struct i2c_board_info *))
+{
+        struct nouveau_i2c_port *port = nouveau_i2c_find(i2c, index);
+        int i;
+
+        if (!port) {
+                nv_debug(i2c, "no bus when probing %s on %d\n", what, index);
+                return -ENODEV;
+        }
+
+        nv_debug(i2c, "probing %ss on bus: %d\n", what, port->index);
+        for (i = 0; info[i].addr; i++) {
+                if (nv_probe_i2c(port, info[i].addr) &&
+                    (!match || match(port, &info[i]))) {
+                        nv_info(i2c, "detected %s: %s\n", what, info[i].type);
+                        return i;
+                }
+        }
+
+        nv_debug(i2c, "no devices found.\n");
+        return -ENODEV;
+}
+
+void
+nouveau_i2c_drive_scl(void *data, int state)
+{
+        struct nouveau_i2c_port *port = data;
+
+        if (port->type == DCB_I2C_NV04_BIT) {
+                u8 val = nv_rdvgac(port->i2c, 0, port->drive);
+                if (state) val |= 0x20;
+                else       val &= 0xdf;
+                nv_wrvgac(port->i2c, 0, port->drive, val | 0x01);
+        } else
+        if (port->type == DCB_I2C_NV4E_BIT) {
+                nv_mask(port->i2c, port->drive, 0x2f, state ? 0x21 : 0x01);
+        } else
+        if (port->type == DCB_I2C_NVIO_BIT) {
+                if (state) port->state |= 0x01;
+                else       port->state &= 0xfe;
+                nv_wr32(port->i2c, port->drive, 4 | port->state);
+        }
+}
+
+void
+nouveau_i2c_drive_sda(void *data, int state)
+{
+        struct nouveau_i2c_port *port = data;
+
+        if (port->type == DCB_I2C_NV04_BIT) {
+                u8 val = nv_rdvgac(port->i2c, 0, port->drive);
+                if (state) val |= 0x10;
+                else       val &= 0xef;
+                nv_wrvgac(port->i2c, 0, port->drive, val | 0x01);
+        } else
+        if (port->type == DCB_I2C_NV4E_BIT) {
+                nv_mask(port->i2c, port->drive, 0x1f, state ? 0x11 : 0x01);
+        } else
+        if (port->type == DCB_I2C_NVIO_BIT) {
+                if (state) port->state |= 0x02;
+                else       port->state &= 0xfd;
+                nv_wr32(port->i2c, port->drive, 4 | port->state);
+        }
+}
+
+int
+nouveau_i2c_sense_scl(void *data)
+{
+        struct nouveau_i2c_port *port = data;
+        struct nouveau_device *device = nv_device(port->i2c);
+
+        if (port->type == DCB_I2C_NV04_BIT) {
+                return !!(nv_rdvgac(port->i2c, 0, port->sense) & 0x04);
+        } else
+        if (port->type == DCB_I2C_NV4E_BIT) {
+                return !!(nv_rd32(port->i2c, port->sense) & 0x00040000);
+        } else
+        if (port->type == DCB_I2C_NVIO_BIT) {
+                if (device->card_type < NV_D0)
+                        return !!(nv_rd32(port->i2c, port->sense) & 0x01);
+                else
+                        return !!(nv_rd32(port->i2c, port->sense) & 0x10);
+        }
+
+        return 0;
+}
+
+int
+nouveau_i2c_sense_sda(void *data)
+{
+        struct nouveau_i2c_port *port = data;
+        struct nouveau_device *device = nv_device(port->i2c);
+
+        if (port->type == DCB_I2C_NV04_BIT) {
+                return !!(nv_rdvgac(port->i2c, 0, port->sense) & 0x08);
+        } else
+        if (port->type == DCB_I2C_NV4E_BIT) {
+                return !!(nv_rd32(port->i2c, port->sense) & 0x00080000);
+        } else
+        if (port->type == DCB_I2C_NVIO_BIT) {
+                if (device->card_type < NV_D0)
+                        return !!(nv_rd32(port->i2c, port->sense) & 0x02);
+                else
+                        return !!(nv_rd32(port->i2c, port->sense) & 0x20);
+        }
+
+        return 0;
+}
+
+static const u32 nv50_i2c_port[] = {
+        0x00e138, 0x00e150, 0x00e168, 0x00e180,
+        0x00e254, 0x00e274, 0x00e764, 0x00e780,
+        0x00e79c, 0x00e7b8
+};
+
+static int
+nouveau_i2c_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                 struct nouveau_oclass *oclass, void *data, u32 size,
+                 struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_bios *bios = nouveau_bios(parent);
+        struct nouveau_i2c_port *port;
+        struct nouveau_i2c *i2c;
+        struct dcb_i2c_entry info;
+        int ret, i = -1;
+
+        ret = nouveau_subdev_create(parent, engine, oclass, 0,
+                                    "I2C", "i2c", &i2c);
+        *pobject = nv_object(i2c);
+        if (ret)
+                return ret;
+
+        i2c->find = nouveau_i2c_find;
+        i2c->identify = nouveau_i2c_identify;
+        INIT_LIST_HEAD(&i2c->ports);
+
+        while (!dcb_i2c_parse(bios, ++i, &info)) {
+                if (info.type == DCB_I2C_UNUSED)
+                        continue;
+
+                port = kzalloc(sizeof(*port), GFP_KERNEL);
+                if (!port) {
+                        nv_error(i2c, "failed port memory alloc at %d\n", i);
+                        break;
+                }
+
+                port->type = info.type;
+                switch (port->type) {
+                case DCB_I2C_NV04_BIT:
+                        port->drive = info.drive;
+                        port->sense = info.sense;
+                        break;
+                case DCB_I2C_NV4E_BIT:
+                        port->drive = 0x600800 + info.drive;
+                        port->sense = port->drive;
+                        break;
+                case DCB_I2C_NVIO_BIT:
+                        port->drive = info.drive & 0x0f;
+                        if (device->card_type < NV_D0) {
+                                if (info.drive >= ARRAY_SIZE(nv50_i2c_port))
+                                        break;
+                                port->drive = nv50_i2c_port[port->drive];
+                                port->sense = port->drive;
+                        } else {
+                                port->drive = 0x00d014 + (port->drive * 0x20);
+                                port->sense = port->drive;
+                        }
+                        break;
+                case DCB_I2C_NVIO_AUX:
+                        port->drive = info.drive & 0x0f;
+                        port->sense = port->drive;
+                        port->adapter.algo = &nouveau_i2c_aux_algo;
+                        break;
+                default:
+                        break;
+                }
+
+                if (!port->adapter.algo && !port->drive) {
+                        nv_error(i2c, "I2C%d: type %d index %x/%x unknown\n",
+                                 i, port->type, port->drive, port->sense);
+                        kfree(port);
+                        continue;
+                }
+
+                snprintf(port->adapter.name, sizeof(port->adapter.name),
+                         "nouveau-%s-%d", device->name, i);
+                port->adapter.owner = THIS_MODULE;
+                port->adapter.dev.parent = &device->pdev->dev;
+                port->i2c = i2c;
+                port->index = i;
+                port->dcb = info.data;
+                i2c_set_adapdata(&port->adapter, i2c);
+
+                if (port->adapter.algo != &nouveau_i2c_aux_algo) {
+                        nouveau_i2c_drive_scl(port, 0);
+                        nouveau_i2c_drive_sda(port, 1);
+                        nouveau_i2c_drive_scl(port, 1);
+
+#ifdef CONFIG_NOUVEAU_I2C_INTERNAL_DEFAULT
+                        if (nouveau_boolopt(device->cfgopt, "NvI2C", true)) {
+#else
+                        if (nouveau_boolopt(device->cfgopt, "NvI2C", false)) {
+#endif
+                                port->adapter.algo = &nouveau_i2c_bit_algo;
+                                ret = i2c_add_adapter(&port->adapter);
+                        } else {
+                                port->adapter.algo_data = &port->bit;
+                                port->bit.udelay = 10;
+                                port->bit.timeout = usecs_to_jiffies(2200);
+                                port->bit.data = port;
+                                port->bit.setsda = nouveau_i2c_drive_sda;
+                                port->bit.setscl = nouveau_i2c_drive_scl;
+                                port->bit.getsda = nouveau_i2c_sense_sda;
+                                port->bit.getscl = nouveau_i2c_sense_scl;
+                                ret = i2c_bit_add_bus(&port->adapter);
+                        }
+                } else {
+                        port->adapter.algo = &nouveau_i2c_aux_algo;
+                        ret = i2c_add_adapter(&port->adapter);
+                }
+
+                if (ret) {
+                        nv_error(i2c, "I2C%d: failed register: %d\n", i, ret);
+                        kfree(port);
+                        continue;
+                }
+
+                list_add_tail(&port->head, &i2c->ports);
+        }
+
+        return 0;
+}
+
+static void
+nouveau_i2c_dtor(struct nouveau_object *object)
+{
+        struct nouveau_i2c *i2c = (void *)object;
+        struct nouveau_i2c_port *port, *temp;
+
+        list_for_each_entry_safe(port, temp, &i2c->ports, head) {
+                i2c_del_adapter(&port->adapter);
+                list_del(&port->head);
+                kfree(port);
+        }
+
+        nouveau_subdev_destroy(&i2c->base);
+}
+
+static int
+nouveau_i2c_init(struct nouveau_object *object)
+{
+        struct nouveau_i2c *i2c = (void *)object;
+        return nouveau_subdev_init(&i2c->base);
+}
+
+static int
+nouveau_i2c_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nouveau_i2c *i2c = (void *)object;
+        return nouveau_subdev_fini(&i2c->base, suspend);
+}
+
+struct nouveau_oclass
+nouveau_i2c_oclass = {
+        .handle = NV_SUBDEV(I2C, 0x00),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nouveau_i2c_ctor,
+                .dtor = nouveau_i2c_dtor,
+                .init = nouveau_i2c_init,
+                .fini = nouveau_i2c_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/i2c/bit.c b/drivers/gpu/drm/nouveau/core/subdev/i2c/bit.c
new file mode 100644
index 000000000000..1c4c9a5c8e2e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/i2c/bit.c
@@ -0,0 +1,230 @@
+/*
+ * Copyright 2012 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 "subdev/i2c.h"
+
+#ifdef CONFIG_NOUVEAU_I2C_INTERNAL
+#define T_TIMEOUT  2200000
+#define T_RISEFALL 1000
+#define T_HOLD     5000
+
+static inline void
+i2c_drive_scl(struct nouveau_i2c_port *port, int state)
+{
+        nouveau_i2c_drive_scl(port, state);
+}
+
+static inline void
+i2c_drive_sda(struct nouveau_i2c_port *port, int state)
+{
+        nouveau_i2c_drive_sda(port, state);
+}
+
+static inline int
+i2c_sense_scl(struct nouveau_i2c_port *port)
+{
+        return nouveau_i2c_sense_scl(port);
+}
+
+static inline int
+i2c_sense_sda(struct nouveau_i2c_port *port)
+{
+        return nouveau_i2c_sense_sda(port);
+}
+
+static void
+i2c_delay(struct nouveau_i2c_port *port, u32 nsec)
+{
+        udelay((nsec + 500) / 1000);
+}
+
+static bool
+i2c_raise_scl(struct nouveau_i2c_port *port)
+{
+        u32 timeout = T_TIMEOUT / T_RISEFALL;
+
+        i2c_drive_scl(port, 1);
+        do {
+                i2c_delay(port, T_RISEFALL);
+        } while (!i2c_sense_scl(port) && --timeout);
+
+        return timeout != 0;
+}
+
+static int
+i2c_start(struct nouveau_i2c_port *port)
+{
+        int ret = 0;
+
+        port->state  = i2c_sense_scl(port);
+        port->state |= i2c_sense_sda(port) << 1;
+        if (port->state != 3) {
+                i2c_drive_scl(port, 0);
+                i2c_drive_sda(port, 1);
+                if (!i2c_raise_scl(port))
+                        ret = -EBUSY;
+        }
+
+        i2c_drive_sda(port, 0);
+        i2c_delay(port, T_HOLD);
+        i2c_drive_scl(port, 0);
+        i2c_delay(port, T_HOLD);
+        return ret;
+}
+
+static void
+i2c_stop(struct nouveau_i2c_port *port)
+{
+        i2c_drive_scl(port, 0);
+        i2c_drive_sda(port, 0);
+        i2c_delay(port, T_RISEFALL);
+
+        i2c_drive_scl(port, 1);
+        i2c_delay(port, T_HOLD);
+        i2c_drive_sda(port, 1);
+        i2c_delay(port, T_HOLD);
+}
+
+static int
+i2c_bitw(struct nouveau_i2c_port *port, int sda)
+{
+        i2c_drive_sda(port, sda);
+        i2c_delay(port, T_RISEFALL);
+
+        if (!i2c_raise_scl(port))
+                return -ETIMEDOUT;
+        i2c_delay(port, T_HOLD);
+
+        i2c_drive_scl(port, 0);
+        i2c_delay(port, T_HOLD);
+        return 0;
+}
+
+static int
+i2c_bitr(struct nouveau_i2c_port *port)
+{
+        int sda;
+
+        i2c_drive_sda(port, 1);
+        i2c_delay(port, T_RISEFALL);
+
+        if (!i2c_raise_scl(port))
+                return -ETIMEDOUT;
+        i2c_delay(port, T_HOLD);
+
+        sda = i2c_sense_sda(port);
+
+        i2c_drive_scl(port, 0);
+        i2c_delay(port, T_HOLD);
+        return sda;
+}
+
+static int
+i2c_get_byte(struct nouveau_i2c_port *port, u8 *byte, bool last)
+{
+        int i, bit;
+
+        *byte = 0;
+        for (i = 7; i >= 0; i--) {
+                bit = i2c_bitr(port);
+                if (bit < 0)
+                        return bit;
+                *byte |= bit << i;
+        }
+
+        return i2c_bitw(port, last ? 1 : 0);
+}
+
+static int
+i2c_put_byte(struct nouveau_i2c_port *port, u8 byte)
+{
+        int i, ret;
+        for (i = 7; i >= 0; i--) {
+                ret = i2c_bitw(port, !!(byte & (1 << i)));
+                if (ret < 0)
+                        return ret;
+        }
+
+        ret = i2c_bitr(port);
+        if (ret == 1) /* nack */
+                ret = -EIO;
+        return ret;
+}
+
+static int
+i2c_addr(struct nouveau_i2c_port *port, struct i2c_msg *msg)
+{
+        u32 addr = msg->addr << 1;
+        if (msg->flags & I2C_M_RD)
+                addr |= 1;
+        return i2c_put_byte(port, addr);
+}
+
+static int
+i2c_bit_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
+{
+        struct nouveau_i2c_port *port = (struct nouveau_i2c_port *)adap;
+        struct i2c_msg *msg = msgs;
+        int ret = 0, mcnt = num;
+
+        while (!ret && mcnt--) {
+                u8 remaining = msg->len;
+                u8 *ptr = msg->buf;
+
+                ret = i2c_start(port);
+                if (ret == 0)
+                        ret = i2c_addr(port, msg);
+
+                if (msg->flags & I2C_M_RD) {
+                        while (!ret && remaining--)
+                                ret = i2c_get_byte(port, ptr++, !remaining);
+                } else {
+                        while (!ret && remaining--)
+                                ret = i2c_put_byte(port, *ptr++);
+                }
+
+                msg++;
+        }
+
+        i2c_stop(port);
+        return (ret < 0) ? ret : num;
+}
+#else
+static int
+i2c_bit_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
+{
+        return -ENODEV;
+}
+#endif
+
+static u32
+i2c_bit_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+}
+
+const struct i2c_algorithm nouveau_i2c_bit_algo = {
+        .master_xfer = i2c_bit_xfer,
+        .functionality = i2c_bit_func
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/ibus/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/ibus/nvc0.c
new file mode 100644
index 000000000000..4e977ff27e44
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/ibus/nvc0.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2012 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 <subdev/ibus.h>
+
+struct nvc0_ibus_priv {
+        struct nouveau_ibus base;
+};
+
+static void
+nvc0_ibus_intr_hub(struct nvc0_ibus_priv *priv, int i)
+{
+        u32 addr = nv_rd32(priv, 0x122120 + (i * 0x0400));
+        u32 data = nv_rd32(priv, 0x122124 + (i * 0x0400));
+        u32 stat = nv_rd32(priv, 0x122128 + (i * 0x0400));
+        nv_error(priv, "HUB%d: 0x%06x 0x%08x (0x%08x)\n", i, addr, data, stat);
+        nv_mask(priv, 0x122128 + (i * 0x0400), 0x00000200, 0x00000000);
+}
+
+static void
+nvc0_ibus_intr_rop(struct nvc0_ibus_priv *priv, int i)
+{
+        u32 addr = nv_rd32(priv, 0x124120 + (i * 0x0400));
+        u32 data = nv_rd32(priv, 0x124124 + (i * 0x0400));
+        u32 stat = nv_rd32(priv, 0x124128 + (i * 0x0400));
+        nv_error(priv, "ROP%d: 0x%06x 0x%08x (0x%08x)\n", i, addr, data, stat);
+        nv_mask(priv, 0x124128 + (i * 0x0400), 0x00000200, 0x00000000);
+}
+
+static void
+nvc0_ibus_intr_gpc(struct nvc0_ibus_priv *priv, int i)
+{
+        u32 addr = nv_rd32(priv, 0x128120 + (i * 0x0400));
+        u32 data = nv_rd32(priv, 0x128124 + (i * 0x0400));
+        u32 stat = nv_rd32(priv, 0x128128 + (i * 0x0400));
+        nv_error(priv, "GPC%d: 0x%06x 0x%08x (0x%08x)\n", i, addr, data, stat);
+        nv_mask(priv, 0x128128 + (i * 0x0400), 0x00000200, 0x00000000);
+}
+
+static void
+nvc0_ibus_intr(struct nouveau_subdev *subdev)
+{
+        struct nvc0_ibus_priv *priv = (void *)subdev;
+        u32 intr0 = nv_rd32(priv, 0x121c58);
+        u32 intr1 = nv_rd32(priv, 0x121c5c);
+        u32 hubnr = nv_rd32(priv, 0x121c70);
+        u32 ropnr = nv_rd32(priv, 0x121c74);
+        u32 gpcnr = nv_rd32(priv, 0x121c78);
+        u32 i;
+
+        for (i = 0; (intr0 & 0x0000ff00) && i < hubnr; i++) {
+                u32 stat = 0x00000100 << i;
+                if (intr0 & stat) {
+                        nvc0_ibus_intr_hub(priv, i);
+                        intr0 &= ~stat;
+                }
+        }
+
+        for (i = 0; (intr0 & 0xffff0000) && i < ropnr; i++) {
+                u32 stat = 0x00010000 << i;
+                if (intr0 & stat) {
+                        nvc0_ibus_intr_rop(priv, i);
+                        intr0 &= ~stat;
+                }
+        }
+
+        for (i = 0; intr1 && i < gpcnr; i++) {
+                u32 stat = 0x00000001 << i;
+                if (intr1 & stat) {
+                        nvc0_ibus_intr_gpc(priv, i);
+                        intr1 &= ~stat;
+                }
+        }
+}
+
+static int
+nvc0_ibus_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nvc0_ibus_priv *priv;
+        int ret;
+
+        ret = nouveau_ibus_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nvc0_ibus_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_ibus_oclass = {
+        .handle = NV_SUBDEV(IBUS, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_ibus_ctor,
+                .dtor = _nouveau_ibus_dtor,
+                .init = _nouveau_ibus_init,
+                .fini = _nouveau_ibus_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/ibus/nve0.c b/drivers/gpu/drm/nouveau/core/subdev/ibus/nve0.c
new file mode 100644
index 000000000000..7120124dceac
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/ibus/nve0.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2012 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 <subdev/ibus.h>
+
+struct nve0_ibus_priv {
+        struct nouveau_ibus base;
+};
+
+static void
+nve0_ibus_intr_hub(struct nve0_ibus_priv *priv, int i)
+{
+        u32 addr = nv_rd32(priv, 0x122120 + (i * 0x0800));
+        u32 data = nv_rd32(priv, 0x122124 + (i * 0x0800));
+        u32 stat = nv_rd32(priv, 0x122128 + (i * 0x0800));
+        nv_error(priv, "HUB%d: 0x%06x 0x%08x (0x%08x)\n", i, addr, data, stat);
+        nv_mask(priv, 0x122128 + (i * 0x0800), 0x00000200, 0x00000000);
+}
+
+static void
+nve0_ibus_intr_rop(struct nve0_ibus_priv *priv, int i)
+{
+        u32 addr = nv_rd32(priv, 0x124120 + (i * 0x0800));
+        u32 data = nv_rd32(priv, 0x124124 + (i * 0x0800));
+        u32 stat = nv_rd32(priv, 0x124128 + (i * 0x0800));
+        nv_error(priv, "ROP%d: 0x%06x 0x%08x (0x%08x)\n", i, addr, data, stat);
+        nv_mask(priv, 0x124128 + (i * 0x0800), 0x00000200, 0x00000000);
+}
+
+static void
+nve0_ibus_intr_gpc(struct nve0_ibus_priv *priv, int i)
+{
+        u32 addr = nv_rd32(priv, 0x128120 + (i * 0x0800));
+        u32 data = nv_rd32(priv, 0x128124 + (i * 0x0800));
+        u32 stat = nv_rd32(priv, 0x128128 + (i * 0x0800));
+        nv_error(priv, "GPC%d: 0x%06x 0x%08x (0x%08x)\n", i, addr, data, stat);
+        nv_mask(priv, 0x128128 + (i * 0x0800), 0x00000200, 0x00000000);
+}
+
+static void
+nve0_ibus_intr(struct nouveau_subdev *subdev)
+{
+        struct nve0_ibus_priv *priv = (void *)subdev;
+        u32 intr0 = nv_rd32(priv, 0x120058);
+        u32 intr1 = nv_rd32(priv, 0x12005c);
+        u32 hubnr = nv_rd32(priv, 0x120070);
+        u32 ropnr = nv_rd32(priv, 0x120074);
+        u32 gpcnr = nv_rd32(priv, 0x120078);
+        u32 i;
+
+        for (i = 0; (intr0 & 0x0000ff00) && i < hubnr; i++) {
+                u32 stat = 0x00000100 << i;
+                if (intr0 & stat) {
+                        nve0_ibus_intr_hub(priv, i);
+                        intr0 &= ~stat;
+                }
+        }
+
+        for (i = 0; (intr0 & 0xffff0000) && i < ropnr; i++) {
+                u32 stat = 0x00010000 << i;
+                if (intr0 & stat) {
+                        nve0_ibus_intr_rop(priv, i);
+                        intr0 &= ~stat;
+                }
+        }
+
+        for (i = 0; intr1 && i < gpcnr; i++) {
+                u32 stat = 0x00000001 << i;
+                if (intr1 & stat) {
+                        nve0_ibus_intr_gpc(priv, i);
+                        intr1 &= ~stat;
+                }
+        }
+}
+
+static int
+nve0_ibus_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nve0_ibus_priv *priv;
+        int ret;
+
+        ret = nouveau_ibus_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nve0_ibus_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nve0_ibus_oclass = {
+        .handle = NV_SUBDEV(IBUS, 0xe0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nve0_ibus_ctor,
+                .dtor = _nouveau_ibus_dtor,
+                .init = _nouveau_ibus_init,
+                .fini = _nouveau_ibus_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/instmem/base.c b/drivers/gpu/drm/nouveau/core/subdev/instmem/base.c
new file mode 100644
index 000000000000..1188227ca6aa
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/instmem/base.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 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 <subdev/instmem.h>
+
+int
+nouveau_instobj_create_(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass,
+                        int length, void **pobject)
+{
+        struct nouveau_instmem *imem = (void *)engine;
+        struct nouveau_instobj *iobj;
+        int ret;
+
+        ret = nouveau_object_create_(parent, engine, oclass, NV_MEMOBJ_CLASS,
+                                     length, pobject);
+        iobj = *pobject;
+        if (ret)
+                return ret;
+
+        list_add(&iobj->head, &imem->list);
+        return 0;
+}
+
+void
+nouveau_instobj_destroy(struct nouveau_instobj *iobj)
+{
+        if (iobj->head.prev)
+                list_del(&iobj->head);
+        return nouveau_object_destroy(&iobj->base);
+}
+
+void
+_nouveau_instobj_dtor(struct nouveau_object *object)
+{
+        struct nouveau_instobj *iobj = (void *)object;
+        return nouveau_instobj_destroy(iobj);
+}
+
+int
+nouveau_instmem_create_(struct nouveau_object *parent,
+                        struct nouveau_object *engine,
+                        struct nouveau_oclass *oclass,
+                        int length, void **pobject)
+{
+        struct nouveau_instmem *imem;
+        int ret;
+
+        ret = nouveau_subdev_create_(parent, engine, oclass, 0,
+                                     "INSTMEM", "instmem", length, pobject);
+        imem = *pobject;
+        if (ret)
+                return ret;
+
+        INIT_LIST_HEAD(&imem->list);
+        return 0;
+}
+
+int
+nouveau_instmem_init(struct nouveau_instmem *imem)
+{
+        struct nouveau_instobj *iobj;
+        int ret, i;
+
+        ret = nouveau_subdev_init(&imem->base);
+        if (ret)
+                return ret;
+
+        list_for_each_entry(iobj, &imem->list, head) {
+                if (iobj->suspend) {
+                        for (i = 0; i < iobj->size; i += 4)
+                                nv_wo32(iobj, i, iobj->suspend[i / 4]);
+                        vfree(iobj->suspend);
+                        iobj->suspend = NULL;
+                }
+        }
+
+        return 0;
+}
+
+int
+nouveau_instmem_fini(struct nouveau_instmem *imem, bool suspend)
+{
+        struct nouveau_instobj *iobj;
+        int i;
+
+        if (suspend) {
+                list_for_each_entry(iobj, &imem->list, head) {
+                        iobj->suspend = vmalloc(iobj->size);
+                        if (iobj->suspend) {
+                                for (i = 0; i < iobj->size; i += 4)
+                                        iobj->suspend[i / 4] = nv_ro32(iobj, i);
+                        } else
+                                return -ENOMEM;
+                }
+        }
+
+        return nouveau_subdev_fini(&imem->base, suspend);
+}
+
+int
+_nouveau_instmem_init(struct nouveau_object *object)
+{
+        struct nouveau_instmem *imem = (void *)object;
+        return nouveau_instmem_init(imem);
+}
+
+int
+_nouveau_instmem_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nouveau_instmem *imem = (void *)object;
+        return nouveau_instmem_fini(imem, suspend);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/instmem/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv04.c
new file mode 100644
index 000000000000..ba4d28b50368
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv04.c
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2012 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 <subdev/fb.h>
+
+#include "nv04.h"
+
+static int
+nv04_instobj_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv04_instmem_priv *priv = (void *)engine;
+        struct nv04_instobj_priv *node;
+        int ret, align;
+
+        align = (unsigned long)data;
+        if (!align)
+                align = 1;
+
+        ret = nouveau_instobj_create(parent, engine, oclass, &node);
+        *pobject = nv_object(node);
+        if (ret)
+                return ret;
+
+        ret = nouveau_mm_head(&priv->heap, 1, size, size, align, &node->mem);
+        if (ret)
+                return ret;
+
+        node->base.addr = node->mem->offset;
+        node->base.size = node->mem->length;
+        return 0;
+}
+
+static void
+nv04_instobj_dtor(struct nouveau_object *object)
+{
+        struct nv04_instmem_priv *priv = (void *)object->engine;
+        struct nv04_instobj_priv *node = (void *)object;
+        nouveau_mm_free(&priv->heap, &node->mem);
+        nouveau_instobj_destroy(&node->base);
+}
+
+static u32
+nv04_instobj_rd32(struct nouveau_object *object, u32 addr)
+{
+        struct nv04_instobj_priv *node = (void *)object;
+        return nv_ro32(object->engine, node->mem->offset + addr);
+}
+
+static void
+nv04_instobj_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        struct nv04_instobj_priv *node = (void *)object;
+        nv_wo32(object->engine, node->mem->offset + addr, data);
+}
+
+static struct nouveau_oclass
+nv04_instobj_oclass = {
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_instobj_ctor,
+                .dtor = nv04_instobj_dtor,
+                .init = _nouveau_instobj_init,
+                .fini = _nouveau_instobj_fini,
+                .rd32 = nv04_instobj_rd32,
+                .wr32 = nv04_instobj_wr32,
+        },
+};
+
+int
+nv04_instmem_alloc(struct nouveau_instmem *imem, struct nouveau_object *parent,
+                   u32 size, u32 align, struct nouveau_object **pobject)
+{
+        struct nouveau_object *engine = nv_object(imem);
+        struct nv04_instmem_priv *priv = (void *)(imem);
+        int ret;
+
+        ret = nouveau_object_ctor(parent, engine, &nv04_instobj_oclass,
+                                  (void *)(unsigned long)align, size, pobject);
+        if (ret)
+                return ret;
+
+        /* INSTMEM itself creates objects to reserve (and preserve across
+         * suspend/resume) various fixed data locations, each one of these
+         * takes a reference on INSTMEM itself, causing it to never be
+         * freed.  We drop all the self-references here to avoid this.
+         */
+        if (unlikely(!priv->created))
+                atomic_dec(&engine->refcount);
+
+        return 0;
+}
+
+static int
+nv04_instmem_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv04_instmem_priv *priv;
+        int ret;
+
+        ret = nouveau_instmem_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        /* PRAMIN aperture maps over the end of VRAM, reserve it */
+        priv->base.reserved = 512 * 1024;
+        priv->base.alloc    = nv04_instmem_alloc;
+
+        ret = nouveau_mm_init(&priv->heap, 0, priv->base.reserved, 1);
+        if (ret)
+                return ret;
+
+        /* 0x00000-0x10000: reserve for probable vbios image */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x10000, 0, 0, &priv->vbios);
+        if (ret)
+                return ret;
+
+        /* 0x10000-0x18000: reserve for RAMHT */
+        ret = nouveau_ramht_new(parent, NULL, 0x08000, 0, &priv->ramht);
+        if (ret)
+                return ret;
+
+        /* 0x18000-0x18800: reserve for RAMFC (enough for 32 nv30 channels) */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x00800, 0,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ramfc);
+        if (ret)
+                return ret;
+
+        /* 0x18800-0x18a00: reserve for RAMRO */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x00200, 0, 0, &priv->ramro);
+        if (ret)
+                return ret;
+
+        priv->created = true;
+        return 0;
+}
+
+void
+nv04_instmem_dtor(struct nouveau_object *object)
+{
+        struct nv04_instmem_priv *priv = (void *)object;
+        nouveau_gpuobj_ref(NULL, &priv->ramfc);
+        nouveau_gpuobj_ref(NULL, &priv->ramro);
+        nouveau_ramht_ref(NULL, &priv->ramht);
+        nouveau_gpuobj_ref(NULL, &priv->vbios);
+        nouveau_mm_fini(&priv->heap);
+        if (priv->iomem)
+                iounmap(priv->iomem);
+        nouveau_instmem_destroy(&priv->base);
+}
+
+static u32
+nv04_instmem_rd32(struct nouveau_object *object, u32 addr)
+{
+        return nv_rd32(object, 0x700000 + addr);
+}
+
+static void
+nv04_instmem_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        return nv_wr32(object, 0x700000 + addr, data);
+}
+
+struct nouveau_oclass
+nv04_instmem_oclass = {
+        .handle = NV_SUBDEV(INSTMEM, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_instmem_ctor,
+                .dtor = nv04_instmem_dtor,
+                .init = _nouveau_instmem_init,
+                .fini = _nouveau_instmem_fini,
+                .rd32 = nv04_instmem_rd32,
+                .wr32 = nv04_instmem_wr32,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/instmem/nv04.h b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv04.h
new file mode 100644
index 000000000000..7983d8d9b358
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv04.h
@@ -0,0 +1,39 @@
+#ifndef __NV04_INSTMEM_H__
+#define __NV04_INSTMEM_H__
+
+#include <core/gpuobj.h>
+#include <core/ramht.h>
+#include <core/mm.h>
+
+#include <subdev/instmem.h>
+
+struct nv04_instmem_priv {
+        struct nouveau_instmem base;
+        bool created;
+
+        void __iomem *iomem;
+        struct nouveau_mm heap;
+
+        struct nouveau_gpuobj *vbios;
+        struct nouveau_ramht  *ramht;
+        struct nouveau_gpuobj *ramro;
+        struct nouveau_gpuobj *ramfc;
+};
+
+static inline struct nv04_instmem_priv *
+nv04_instmem(void *obj)
+{
+        return (void *)nouveau_instmem(obj);
+}
+
+struct nv04_instobj_priv {
+        struct nouveau_instobj base;
+        struct nouveau_mm_node *mem;
+};
+
+void nv04_instmem_dtor(struct nouveau_object *);
+
+int nv04_instmem_alloc(struct nouveau_instmem *, struct nouveau_object *,
+                       u32 size, u32 align, struct nouveau_object **pobject);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/subdev/instmem/nv40.c b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv40.c
new file mode 100644
index 000000000000..73c52ebd5932
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv40.c
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2012 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 "nv04.h"
+
+static inline int
+nv44_graph_class(struct nv04_instmem_priv *priv)
+{
+        if ((nv_device(priv)->chipset & 0xf0) == 0x60)
+                return 1;
+        return !(0x0baf & (1 << (nv_device(priv)->chipset & 0x0f)));
+}
+
+static int
+nv40_instmem_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct pci_dev *pdev = device->pdev;
+        struct nv04_instmem_priv *priv;
+        int ret, bar, vs;
+
+        ret = nouveau_instmem_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        /* map bar */
+        if (pci_resource_len(pdev, 2))
+                bar = 2;
+        else
+                bar = 3;
+
+        priv->iomem = ioremap(pci_resource_start(pdev, bar),
+                              pci_resource_len(pdev, bar));
+        if (!priv->iomem) {
+                nv_error(priv, "unable to map PRAMIN BAR\n");
+                return -EFAULT;
+        }
+
+        /* PRAMIN aperture maps over the end of vram, reserve enough space
+         * to fit graphics contexts for every channel, the magics come
+         * from engine/graph/nv40.c
+         */
+        vs = hweight8((nv_rd32(priv, 0x001540) & 0x0000ff00) >> 8);
+        if      (device->chipset == 0x40) priv->base.reserved = 0x6aa0 * vs;
+        else if (device->chipset  < 0x43) priv->base.reserved = 0x4f00 * vs;
+        else if (nv44_graph_class(priv))  priv->base.reserved = 0x4980 * vs;
+        else                              priv->base.reserved = 0x4a40 * vs;
+        priv->base.reserved += 16 * 1024;
+        priv->base.reserved *= 32;              /* per-channel */
+        priv->base.reserved += 512 * 1024;      /* pci(e)gart table */
+        priv->base.reserved += 512 * 1024;      /* object storage */
+
+        priv->base.reserved = round_up(priv->base.reserved, 4096);
+        priv->base.alloc    = nv04_instmem_alloc;
+
+        ret = nouveau_mm_init(&priv->heap, 0, priv->base.reserved, 1);
+        if (ret)
+                return ret;
+
+        /* 0x00000-0x10000: reserve for probable vbios image */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x10000, 0, 0, &priv->vbios);
+        if (ret)
+                return ret;
+
+        /* 0x10000-0x18000: reserve for RAMHT */
+        ret = nouveau_ramht_new(parent, NULL, 0x08000, 0, &priv->ramht);
+        if (ret)
+                return ret;
+
+        /* 0x18000-0x18200: reserve for RAMRO
+         * 0x18200-0x20000: padding
+         */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x08000, 0, 0, &priv->ramro);
+        if (ret)
+                return ret;
+
+        /* 0x20000-0x21000: reserve for RAMFC
+         * 0x21000-0x40000: padding and some unknown crap
+         */
+        ret = nouveau_gpuobj_new(parent, NULL, 0x20000, 0,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->ramfc);
+        if (ret)
+                return ret;
+
+        priv->created = true;
+        return 0;
+}
+
+static u32
+nv40_instmem_rd32(struct nouveau_object *object, u32 addr)
+{
+        struct nv04_instmem_priv *priv = (void *)object;
+        return ioread32_native(priv->iomem + addr);
+}
+
+static void
+nv40_instmem_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        struct nv04_instmem_priv *priv = (void *)object;
+        iowrite32_native(data, priv->iomem + addr);
+}
+
+struct nouveau_oclass
+nv40_instmem_oclass = {
+        .handle = NV_SUBDEV(INSTMEM, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_instmem_ctor,
+                .dtor = nv04_instmem_dtor,
+                .init = _nouveau_instmem_init,
+                .fini = _nouveau_instmem_fini,
+                .rd32 = nv40_instmem_rd32,
+                .wr32 = nv40_instmem_wr32,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/instmem/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv50.c
new file mode 100644
index 000000000000..27ef0891d10b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/instmem/nv50.c
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2012 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 <subdev/instmem.h>
+#include <subdev/fb.h>
+
+#include <core/mm.h>
+
+struct nv50_instmem_priv {
+        struct nouveau_instmem base;
+        spinlock_t lock;
+        u64 addr;
+};
+
+struct nv50_instobj_priv {
+        struct nouveau_instobj base;
+        struct nouveau_mem *mem;
+};
+
+static int
+nv50_instobj_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nouveau_fb *pfb = nouveau_fb(parent);
+        struct nv50_instobj_priv *node;
+        u32 align = (unsigned long)data;
+        int ret;
+
+        size  = max((size  + 4095) & ~4095, (u32)4096);
+        align = max((align + 4095) & ~4095, (u32)4096);
+
+        ret = nouveau_instobj_create(parent, engine, oclass, &node);
+        *pobject = nv_object(node);
+        if (ret)
+                return ret;
+
+        ret = pfb->ram.get(pfb, size, align, 0, 0x800, &node->mem);
+        if (ret)
+                return ret;
+
+        node->base.addr = node->mem->offset;
+        node->base.size = node->mem->size << 12;
+        node->mem->page_shift = 12;
+        return 0;
+}
+
+static void
+nv50_instobj_dtor(struct nouveau_object *object)
+{
+        struct nv50_instobj_priv *node = (void *)object;
+        struct nouveau_fb *pfb = nouveau_fb(object);
+        pfb->ram.put(pfb, &node->mem);
+        nouveau_instobj_destroy(&node->base);
+}
+
+static u32
+nv50_instobj_rd32(struct nouveau_object *object, u32 offset)
+{
+        struct nv50_instmem_priv *priv = (void *)object->engine;
+        struct nv50_instobj_priv *node = (void *)object;
+        unsigned long flags;
+        u64 base = (node->mem->offset + offset) & 0xffffff00000ULL;
+        u64 addr = (node->mem->offset + offset) & 0x000000fffffULL;
+        u32 data;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (unlikely(priv->addr != base)) {
+                nv_wr32(priv, 0x001700, base >> 16);
+                priv->addr = base;
+        }
+        data = nv_rd32(priv, 0x700000 + addr);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return data;
+}
+
+static void
+nv50_instobj_wr32(struct nouveau_object *object, u32 offset, u32 data)
+{
+        struct nv50_instmem_priv *priv = (void *)object->engine;
+        struct nv50_instobj_priv *node = (void *)object;
+        unsigned long flags;
+        u64 base = (node->mem->offset + offset) & 0xffffff00000ULL;
+        u64 addr = (node->mem->offset + offset) & 0x000000fffffULL;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (unlikely(priv->addr != base)) {
+                nv_wr32(priv, 0x001700, base >> 16);
+                priv->addr = base;
+        }
+        nv_wr32(priv, 0x700000 + addr, data);
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static struct nouveau_oclass
+nv50_instobj_oclass = {
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_instobj_ctor,
+                .dtor = nv50_instobj_dtor,
+                .init = _nouveau_instobj_init,
+                .fini = _nouveau_instobj_fini,
+                .rd32 = nv50_instobj_rd32,
+                .wr32 = nv50_instobj_wr32,
+        },
+};
+
+static int
+nv50_instmem_alloc(struct nouveau_instmem *imem, struct nouveau_object *parent,
+                   u32 size, u32 align, struct nouveau_object **pobject)
+{
+        struct nouveau_object *engine = nv_object(imem);
+        return nouveau_object_ctor(parent, engine, &nv50_instobj_oclass,
+                                   (void *)(unsigned long)align, size, pobject);
+}
+
+static int
+nv50_instmem_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                  struct nouveau_oclass *oclass, void *data, u32 size,
+                  struct nouveau_object **pobject)
+{
+        struct nv50_instmem_priv *priv;
+        int ret;
+
+        ret = nouveau_instmem_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        spin_lock_init(&priv->lock);
+        priv->base.alloc = nv50_instmem_alloc;
+        return 0;
+}
+
+static int
+nv50_instmem_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv50_instmem_priv *priv = (void *)object;
+        priv->addr = ~0ULL;
+        return nouveau_instmem_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv50_instmem_oclass = {
+        .handle = NV_SUBDEV(INSTMEM, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_instmem_ctor,
+                .dtor = _nouveau_instmem_dtor,
+                .init = _nouveau_instmem_init,
+                .fini = nv50_instmem_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/ltcg/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/ltcg/nvc0.c
new file mode 100644
index 000000000000..078a2b9d6bd6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/ltcg/nvc0.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2012 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 <subdev/ltcg.h>
+
+struct nvc0_ltcg_priv {
+        struct nouveau_ltcg base;
+        u32 subp_nr;
+};
+
+static void
+nvc0_ltcg_subp_isr(struct nvc0_ltcg_priv *priv, int unit, int subp)
+{
+        u32 subp_base = 0x141000 + (unit * 0x2000) + (subp * 0x400);
+        u32 stat = nv_rd32(priv, subp_base + 0x020);
+
+        if (stat) {
+                nv_info(priv, "LTC%d_LTS%d: 0x%08x\n", unit, subp, stat);
+                nv_wr32(priv, subp_base + 0x020, stat);
+        }
+}
+
+static void
+nvc0_ltcg_intr(struct nouveau_subdev *subdev)
+{
+        struct nvc0_ltcg_priv *priv = (void *)subdev;
+        u32 units;
+
+        units = nv_rd32(priv, 0x00017c);
+        while (units) {
+                u32 subp, unit = ffs(units) - 1;
+                for (subp = 0; subp < priv->subp_nr; subp++)
+                        nvc0_ltcg_subp_isr(priv, unit, subp);
+                units &= ~(1 << unit);
+        }
+
+        /* we do something horribly wrong and upset PMFB a lot, so mask off
+         * interrupts from it after the first one until it's fixed
+         */
+        nv_mask(priv, 0x000640, 0x02000000, 0x00000000);
+}
+
+static int
+nvc0_ltcg_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+               struct nouveau_oclass *oclass, void *data, u32 size,
+               struct nouveau_object **pobject)
+{
+        struct nvc0_ltcg_priv *priv;
+        int ret;
+
+        ret = nouveau_ltcg_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->subp_nr = nv_rd32(priv, 0x17e8dc) >> 24;
+        nv_mask(priv, 0x17e820, 0x00100000, 0x00000000); /* INTR_EN &= ~0x10 */
+
+        nv_subdev(priv)->intr = nvc0_ltcg_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_ltcg_oclass = {
+        .handle = NV_SUBDEV(LTCG, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_ltcg_ctor,
+                .dtor = _nouveau_ltcg_dtor,
+                .init = _nouveau_ltcg_init,
+                .fini = _nouveau_ltcg_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mc/base.c b/drivers/gpu/drm/nouveau/core/subdev/mc/base.c
new file mode 100644
index 000000000000..de5721cfc4c2
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mc/base.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2012 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 <subdev/mc.h>
+
+void
+nouveau_mc_intr(struct nouveau_subdev *subdev)
+{
+        struct nouveau_mc *pmc = nouveau_mc(subdev);
+        const struct nouveau_mc_intr *map = pmc->intr_map;
+        struct nouveau_subdev *unit;
+        u32 stat;
+
+        stat = nv_rd32(pmc, 0x000100);
+        while (stat && map->stat) {
+                if (stat & map->stat) {
+                        unit = nouveau_subdev(subdev, map->unit);
+                        if (unit && unit->intr)
+                                unit->intr(unit);
+                        stat &= ~map->stat;
+                }
+                map++;
+        }
+
+        if (stat) {
+                nv_error(pmc, "unknown intr 0x%08x\n", stat);
+        }
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mc/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/mc/nv04.c
new file mode 100644
index 000000000000..23ebe477a6f0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mc/nv04.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2012 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 <subdev/mc.h>
+
+struct nv04_mc_priv {
+        struct nouveau_mc base;
+};
+
+const struct nouveau_mc_intr
+nv04_mc_intr[] = {
+        { 0x00000001, NVDEV_ENGINE_MPEG },      /* NV17- MPEG/ME */
+        { 0x00000100, NVDEV_ENGINE_FIFO },
+        { 0x00001000, NVDEV_ENGINE_GR },
+        { 0x00020000, NVDEV_ENGINE_VP },        /* NV40- */
+        { 0x00100000, NVDEV_SUBDEV_TIMER },
+        { 0x01000000, NVDEV_ENGINE_DISP },      /* NV04- PCRTC0 */
+        { 0x02000000, NVDEV_ENGINE_DISP },      /* NV11- PCRTC1 */
+        { 0x10000000, NVDEV_SUBDEV_GPIO },      /* PBUS */
+        { 0x80000000, NVDEV_ENGINE_SW },
+        {}
+};
+
+static int
+nv04_mc_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv04_mc_priv *priv;
+        int ret;
+
+        ret = nouveau_mc_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nouveau_mc_intr;
+        priv->base.intr_map = nv04_mc_intr;
+        return 0;
+}
+
+int
+nv04_mc_init(struct nouveau_object *object)
+{
+        struct nv04_mc_priv *priv = (void *)object;
+
+        nv_wr32(priv, 0x000200, 0xffffffff); /* everything enabled */
+        nv_wr32(priv, 0x001850, 0x00000001); /* disable rom access */
+
+        return nouveau_mc_init(&priv->base);
+}
+
+struct nouveau_oclass
+nv04_mc_oclass = {
+        .handle = NV_SUBDEV(MC, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_mc_ctor,
+                .dtor = _nouveau_mc_dtor,
+                .init = nv04_mc_init,
+                .fini = _nouveau_mc_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mc/nv44.c b/drivers/gpu/drm/nouveau/core/subdev/mc/nv44.c
new file mode 100644
index 000000000000..397d868359ad
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mc/nv44.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2012 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 <subdev/mc.h>
+
+struct nv44_mc_priv {
+        struct nouveau_mc base;
+};
+
+static int
+nv44_mc_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv44_mc_priv *priv;
+        int ret;
+
+        ret = nouveau_mc_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nouveau_mc_intr;
+        priv->base.intr_map = nv04_mc_intr;
+        return 0;
+}
+
+static int
+nv44_mc_init(struct nouveau_object *object)
+{
+        struct nv44_mc_priv *priv = (void *)object;
+        u32 tmp = nv_rd32(priv, 0x10020c);
+
+        nv_wr32(priv, 0x000200, 0xffffffff); /* everything enabled */
+
+        nv_wr32(priv, 0x001700, tmp);
+        nv_wr32(priv, 0x001704, 0);
+        nv_wr32(priv, 0x001708, 0);
+        nv_wr32(priv, 0x00170c, tmp);
+
+        return nouveau_mc_init(&priv->base);
+}
+
+struct nouveau_oclass
+nv44_mc_oclass = {
+        .handle = NV_SUBDEV(MC, 0x44),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv44_mc_ctor,
+                .dtor = _nouveau_mc_dtor,
+                .init = nv44_mc_init,
+                .fini = _nouveau_mc_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mc/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/mc/nv50.c
new file mode 100644
index 000000000000..cedf33b02977
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mc/nv50.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2012 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 <subdev/mc.h>
+
+struct nv50_mc_priv {
+        struct nouveau_mc base;
+};
+
+static const struct nouveau_mc_intr
+nv50_mc_intr[] = {
+        { 0x00000001, NVDEV_ENGINE_MPEG },
+        { 0x00000100, NVDEV_ENGINE_FIFO },
+        { 0x00001000, NVDEV_ENGINE_GR },
+        { 0x00004000, NVDEV_ENGINE_CRYPT },     /* NV84- */
+        { 0x00008000, NVDEV_ENGINE_BSP },       /* NV84- */
+        { 0x00100000, NVDEV_SUBDEV_TIMER },
+        { 0x00200000, NVDEV_SUBDEV_GPIO },
+        { 0x04000000, NVDEV_ENGINE_DISP },
+        { 0x80000000, NVDEV_ENGINE_SW },
+        {},
+};
+
+static int
+nv50_mc_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv50_mc_priv *priv;
+        int ret;
+
+        ret = nouveau_mc_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nouveau_mc_intr;
+        priv->base.intr_map = nv50_mc_intr;
+        return 0;
+}
+
+int
+nv50_mc_init(struct nouveau_object *object)
+{
+        struct nv50_mc_priv *priv = (void *)object;
+        nv_wr32(priv, 0x000200, 0xffffffff); /* everything on */
+        return nouveau_mc_init(&priv->base);
+}
+
+struct nouveau_oclass
+nv50_mc_oclass = {
+        .handle = NV_SUBDEV(MC, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_mc_ctor,
+                .dtor = _nouveau_mc_dtor,
+                .init = nv50_mc_init,
+                .fini = _nouveau_mc_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mc/nv98.c b/drivers/gpu/drm/nouveau/core/subdev/mc/nv98.c
new file mode 100644
index 000000000000..a001e4c4d38d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mc/nv98.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2012 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 <subdev/mc.h>
+
+struct nv98_mc_priv {
+        struct nouveau_mc base;
+};
+
+static const struct nouveau_mc_intr
+nv98_mc_intr[] = {
+        { 0x00000001, NVDEV_ENGINE_PPP },
+        { 0x00000100, NVDEV_ENGINE_FIFO },
+        { 0x00001000, NVDEV_ENGINE_GR },
+        { 0x00004000, NVDEV_ENGINE_CRYPT },     /* NV84:NVA3 */
+        { 0x00008000, NVDEV_ENGINE_BSP },
+        { 0x00100000, NVDEV_SUBDEV_TIMER },
+        { 0x00200000, NVDEV_SUBDEV_GPIO },
+        { 0x00400000, NVDEV_ENGINE_COPY0 },     /* NVA3-     */
+        { 0x04000000, NVDEV_ENGINE_DISP },
+        { 0x80000000, NVDEV_ENGINE_SW },
+        {},
+};
+
+static int
+nv98_mc_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nv98_mc_priv *priv;
+        int ret;
+
+        ret = nouveau_mc_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nouveau_mc_intr;
+        priv->base.intr_map = nv98_mc_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nv98_mc_oclass = {
+        .handle = NV_SUBDEV(MC, 0x98),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv98_mc_ctor,
+                .dtor = _nouveau_mc_dtor,
+                .init = nv50_mc_init,
+                .fini = _nouveau_mc_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mc/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/mc/nvc0.c
new file mode 100644
index 000000000000..c2b81e30a17d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mc/nvc0.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2012 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 <subdev/mc.h>
+
+struct nvc0_mc_priv {
+        struct nouveau_mc base;
+};
+
+static const struct nouveau_mc_intr
+nvc0_mc_intr[] = {
+        { 0x00000001, NVDEV_ENGINE_PPP },
+        { 0x00000020, NVDEV_ENGINE_COPY0 },
+        { 0x00000040, NVDEV_ENGINE_COPY1 },
+        { 0x00000100, NVDEV_ENGINE_FIFO },
+        { 0x00001000, NVDEV_ENGINE_GR },
+        { 0x00008000, NVDEV_ENGINE_BSP },
+        { 0x00100000, NVDEV_SUBDEV_TIMER },
+        { 0x00200000, NVDEV_SUBDEV_GPIO },
+        { 0x02000000, NVDEV_SUBDEV_LTCG },
+        { 0x04000000, NVDEV_ENGINE_DISP },
+        { 0x40000000, NVDEV_SUBDEV_IBUS },
+        { 0x80000000, NVDEV_ENGINE_SW },
+        {},
+};
+
+static int
+nvc0_mc_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+             struct nouveau_oclass *oclass, void *data, u32 size,
+             struct nouveau_object **pobject)
+{
+        struct nvc0_mc_priv *priv;
+        int ret;
+
+        ret = nouveau_mc_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        nv_subdev(priv)->intr = nouveau_mc_intr;
+        priv->base.intr_map = nvc0_mc_intr;
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_mc_oclass = {
+        .handle = NV_SUBDEV(MC, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_mc_ctor,
+                .dtor = _nouveau_mc_dtor,
+                .init = nv50_mc_init,
+                .fini = _nouveau_mc_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mxm/base.c b/drivers/gpu/drm/nouveau/core/subdev/mxm/base.c
new file mode 100644
index 000000000000..93e3ddf7303a
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mxm/base.c
@@ -0,0 +1,290 @@
+/*
+ * Copyright 2011 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 <core/option.h>
+
+#include <subdev/i2c.h>
+#include <subdev/mxm.h>
+#include <subdev/bios.h>
+#include <subdev/bios/mxm.h>
+
+#include "mxms.h"
+
+static bool
+mxm_shadow_rom_fetch(struct nouveau_i2c_port *i2c, u8 addr,
+                     u8 offset, u8 size, u8 *data)
+{
+        struct i2c_msg msgs[] = {
+                { .addr = addr, .flags = 0, .len = 1, .buf = &offset },
+                { .addr = addr, .flags = I2C_M_RD, .len = size, .buf = data, },
+        };
+
+        return i2c_transfer(&i2c->adapter, msgs, 2) == 2;
+}
+
+static bool
+mxm_shadow_rom(struct nouveau_mxm *mxm, u8 version)
+{
+        struct nouveau_bios *bios = nouveau_bios(mxm);
+        struct nouveau_i2c *i2c = nouveau_i2c(mxm);
+        struct nouveau_i2c_port *port = NULL;
+        u8 i2cidx, mxms[6], addr, size;
+
+        i2cidx = mxm_ddc_map(bios, 1 /* LVDS_DDC */) & 0x0f;
+        if (i2cidx < 0x0f)
+                port = i2c->find(i2c, i2cidx);
+        if (!port)
+                return false;
+
+        addr = 0x54;
+        if (!mxm_shadow_rom_fetch(port, addr, 0, 6, mxms)) {
+                addr = 0x56;
+                if (!mxm_shadow_rom_fetch(port, addr, 0, 6, mxms))
+                        return false;
+        }
+
+        mxm->mxms = mxms;
+        size = mxms_headerlen(mxm) + mxms_structlen(mxm);
+        mxm->mxms = kmalloc(size, GFP_KERNEL);
+
+        if (mxm->mxms &&
+            mxm_shadow_rom_fetch(port, addr, 0, size, mxm->mxms))
+                return true;
+
+        kfree(mxm->mxms);
+        mxm->mxms = NULL;
+        return false;
+}
+
+#if defined(CONFIG_ACPI)
+static bool
+mxm_shadow_dsm(struct nouveau_mxm *mxm, u8 version)
+{
+        struct nouveau_device *device = nv_device(mxm);
+        static char muid[] = {
+                0x00, 0xA4, 0x04, 0x40, 0x7D, 0x91, 0xF2, 0x4C,
+                0xB8, 0x9C, 0x79, 0xB6, 0x2F, 0xD5, 0x56, 0x65
+        };
+        u32 mxms_args[] = { 0x00000000 };
+        union acpi_object args[4] = {
+                /* _DSM MUID */
+                { .buffer.type = 3,
+                  .buffer.length = sizeof(muid),
+                  .buffer.pointer = muid,
+                },
+                /* spec says this can be zero to mean "highest revision", but
+                 * of course there's at least one bios out there which fails
+                 * unless you pass in exactly the version it supports..
+                 */
+                { .integer.type = ACPI_TYPE_INTEGER,
+                  .integer.value = (version & 0xf0) << 4 | (version & 0x0f),
+                },
+                /* MXMS function */
+                { .integer.type = ACPI_TYPE_INTEGER,
+                  .integer.value = 0x00000010,
+                },
+                /* Pointer to MXMS arguments */
+                { .buffer.type = ACPI_TYPE_BUFFER,
+                  .buffer.length = sizeof(mxms_args),
+                  .buffer.pointer = (char *)mxms_args,
+                },
+        };
+        struct acpi_object_list list = { ARRAY_SIZE(args), args };
+        struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_handle handle;
+        int ret;
+
+        handle = DEVICE_ACPI_HANDLE(&device->pdev->dev);
+        if (!handle)
+                return false;
+
+        ret = acpi_evaluate_object(handle, "_DSM", &list, &retn);
+        if (ret) {
+                nv_debug(mxm, "DSM MXMS failed: %d\n", ret);
+                return false;
+        }
+
+        obj = retn.pointer;
+        if (obj->type == ACPI_TYPE_BUFFER) {
+                mxm->mxms = kmemdup(obj->buffer.pointer,
+                                         obj->buffer.length, GFP_KERNEL);
+        } else
+        if (obj->type == ACPI_TYPE_INTEGER) {
+                nv_debug(mxm, "DSM MXMS returned 0x%llx\n", obj->integer.value);
+        }
+
+        kfree(obj);
+        return mxm->mxms != NULL;
+}
+#endif
+
+#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
+
+#define WMI_WMMX_GUID "F6CB5C3C-9CAE-4EBD-B577-931EA32A2CC0"
+
+static u8
+wmi_wmmx_mxmi(struct nouveau_mxm *mxm, u8 version)
+{
+        u32 mxmi_args[] = { 0x494D584D /* MXMI */, version, 0 };
+        struct acpi_buffer args = { sizeof(mxmi_args), mxmi_args };
+        struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_evaluate_method(WMI_WMMX_GUID, 0, 0, &args, &retn);
+        if (ACPI_FAILURE(status)) {
+                nv_debug(mxm, "WMMX MXMI returned %d\n", status);
+                return 0x00;
+        }
+
+        obj = retn.pointer;
+        if (obj->type == ACPI_TYPE_INTEGER) {
+                version = obj->integer.value;
+                nv_debug(mxm, "WMMX MXMI version %d.%d\n",
+                             (version >> 4), version & 0x0f);
+        } else {
+                version = 0;
+                nv_debug(mxm, "WMMX MXMI returned non-integer\n");
+        }
+
+        kfree(obj);
+        return version;
+}
+
+static bool
+mxm_shadow_wmi(struct nouveau_mxm *mxm, u8 version)
+{
+        u32 mxms_args[] = { 0x534D584D /* MXMS */, version, 0 };
+        struct acpi_buffer args = { sizeof(mxms_args), mxms_args };
+        struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        if (!wmi_has_guid(WMI_WMMX_GUID)) {
+                nv_debug(mxm, "WMMX GUID not found\n");
+                return false;
+        }
+
+        mxms_args[1] = wmi_wmmx_mxmi(mxm, 0x00);
+        if (!mxms_args[1])
+                mxms_args[1] = wmi_wmmx_mxmi(mxm, version);
+        if (!mxms_args[1])
+                return false;
+
+        status = wmi_evaluate_method(WMI_WMMX_GUID, 0, 0, &args, &retn);
+        if (ACPI_FAILURE(status)) {
+                nv_debug(mxm, "WMMX MXMS returned %d\n", status);
+                return false;
+        }
+
+        obj = retn.pointer;
+        if (obj->type == ACPI_TYPE_BUFFER) {
+                mxm->mxms = kmemdup(obj->buffer.pointer,
+                                         obj->buffer.length, GFP_KERNEL);
+        }
+
+        kfree(obj);
+        return mxm->mxms != NULL;
+}
+#endif
+
+static struct mxm_shadow_h {
+        const char *name;
+        bool (*exec)(struct nouveau_mxm *, u8 version);
+} _mxm_shadow[] = {
+        { "ROM", mxm_shadow_rom },
+#if defined(CONFIG_ACPI)
+        { "DSM", mxm_shadow_dsm },
+#endif
+#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
+        { "WMI", mxm_shadow_wmi },
+#endif
+        {}
+};
+
+static int
+mxm_shadow(struct nouveau_mxm *mxm, u8 version)
+{
+        struct mxm_shadow_h *shadow = _mxm_shadow;
+        do {
+                nv_debug(mxm, "checking %s\n", shadow->name);
+                if (shadow->exec(mxm, version)) {
+                        if (mxms_valid(mxm))
+                                return 0;
+                        kfree(mxm->mxms);
+                        mxm->mxms = NULL;
+                }
+        } while ((++shadow)->name);
+        return -ENOENT;
+}
+
+int
+nouveau_mxm_create_(struct nouveau_object *parent,
+                    struct nouveau_object *engine,
+                    struct nouveau_oclass *oclass, int length, void **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nouveau_mxm *mxm;
+        u8  ver, len;
+        u16 data;
+        int ret;
+
+        ret = nouveau_subdev_create_(parent, engine, oclass, 0, "MXM", "mxm",
+                                     length, pobject);
+        mxm = *pobject;
+        if (ret)
+                return ret;
+
+        data = mxm_table(bios, &ver, &len);
+        if (!data || !(ver = nv_ro08(bios, data))) {
+                nv_info(mxm, "no VBIOS data, nothing to do\n");
+                return 0;
+        }
+
+        nv_info(mxm, "BIOS version %d.%d\n", ver >> 4, ver & 0x0f);
+
+        if (mxm_shadow(mxm, ver)) {
+                nv_info(mxm, "failed to locate valid SIS\n");
+#if 0
+                /* we should, perhaps, fall back to some kind of limited
+                 * mode here if the x86 vbios hasn't already done the
+                 * work for us (so we prevent loading with completely
+                 * whacked vbios tables).
+                 */
+                return -EINVAL;
+#else
+                return 0;
+#endif
+        }
+
+        nv_info(mxm, "MXMS Version %d.%d\n",
+                mxms_version(mxm) >> 8, mxms_version(mxm) & 0xff);
+        mxms_foreach(mxm, 0, NULL, NULL);
+
+        if (nouveau_boolopt(device->cfgopt, "NvMXMDCB", true))
+                mxm->action |= MXM_SANITISE_DCB;
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mxm/mxms.c b/drivers/gpu/drm/nouveau/core/subdev/mxm/mxms.c
new file mode 100644
index 000000000000..839ca1edc132
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mxm/mxms.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2012 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 <subdev/mxm.h>
+#include "mxms.h"
+
+#define ROM16(x) le16_to_cpu(*(u16 *)&(x))
+#define ROM32(x) le32_to_cpu(*(u32 *)&(x))
+
+static u8 *
+mxms_data(struct nouveau_mxm *mxm)
+{
+        return mxm->mxms;
+
+}
+
+u16
+mxms_version(struct nouveau_mxm *mxm)
+{
+        u8 *mxms = mxms_data(mxm);
+        u16 version = (mxms[4] << 8) | mxms[5];
+        switch (version ) {
+        case 0x0200:
+        case 0x0201:
+        case 0x0300:
+                return version;
+        default:
+                break;
+        }
+
+        nv_debug(mxm, "unknown version %d.%d\n", mxms[4], mxms[5]);
+        return 0x0000;
+}
+
+u16
+mxms_headerlen(struct nouveau_mxm *mxm)
+{
+        return 8;
+}
+
+u16
+mxms_structlen(struct nouveau_mxm *mxm)
+{
+        return *(u16 *)&mxms_data(mxm)[6];
+}
+
+bool
+mxms_checksum(struct nouveau_mxm *mxm)
+{
+        u16 size = mxms_headerlen(mxm) + mxms_structlen(mxm);
+        u8 *mxms = mxms_data(mxm), sum = 0;
+        while (size--)
+                sum += *mxms++;
+        if (sum) {
+                nv_debug(mxm, "checksum invalid\n");
+                return false;
+        }
+        return true;
+}
+
+bool
+mxms_valid(struct nouveau_mxm *mxm)
+{
+        u8 *mxms = mxms_data(mxm);
+        if (*(u32 *)mxms != 0x5f4d584d) {
+                nv_debug(mxm, "signature invalid\n");
+                return false;
+        }
+
+        if (!mxms_version(mxm) || !mxms_checksum(mxm))
+                return false;
+
+        return true;
+}
+
+bool
+mxms_foreach(struct nouveau_mxm *mxm, u8 types,
+             bool (*exec)(struct nouveau_mxm *, u8 *, void *), void *info)
+{
+        u8 *mxms = mxms_data(mxm);
+        u8 *desc = mxms + mxms_headerlen(mxm);
+        u8 *fini = desc + mxms_structlen(mxm) - 1;
+        while (desc < fini) {
+                u8 type = desc[0] & 0x0f;
+                u8 headerlen = 0;
+                u8 recordlen = 0;
+                u8 entries = 0;
+
+                switch (type) {
+                case 0: /* Output Device Structure */
+                        if (mxms_version(mxm) >= 0x0300)
+                                headerlen = 8;
+                        else
+                                headerlen = 6;
+                        break;
+                case 1: /* System Cooling Capability Structure */
+                case 2: /* Thermal Structure */
+                case 3: /* Input Power Structure */
+                        headerlen = 4;
+                        break;
+                case 4: /* GPIO Device Structure */
+                        headerlen = 4;
+                        recordlen = 2;
+                        entries   = (ROM32(desc[0]) & 0x01f00000) >> 20;
+                        break;
+                case 5: /* Vendor Specific Structure */
+                        headerlen = 8;
+                        break;
+                case 6: /* Backlight Control Structure */
+                        if (mxms_version(mxm) >= 0x0300) {
+                                headerlen = 4;
+                                recordlen = 8;
+                                entries   = (desc[1] & 0xf0) >> 4;
+                        } else {
+                                headerlen = 8;
+                        }
+                        break;
+                case 7: /* Fan Control Structure */
+                        headerlen = 8;
+                        recordlen = 4;
+                        entries   = desc[1] & 0x07;
+                        break;
+                default:
+                        nv_debug(mxm, "unknown descriptor type %d\n", type);
+                        return false;
+                }
+
+                if (nv_subdev(mxm)->debug >= NV_DBG_DEBUG && (exec == NULL)) {
+                        static const char * mxms_desc_name[] = {
+                                "ODS", "SCCS", "TS", "IPS",
+                                "GSD", "VSS", "BCS", "FCS",
+                        };
+                        u8 *dump = desc;
+                        int i, j;
+
+                        nv_debug(mxm, "%4s: ", mxms_desc_name[type]);
+                        for (j = headerlen - 1; j >= 0; j--)
+                                printk("%02x", dump[j]);
+                        printk("\n");
+                        dump += headerlen;
+
+                        for (i = 0; i < entries; i++, dump += recordlen) {
+                                nv_debug(mxm, "      ");
+                                for (j = recordlen - 1; j >= 0; j--)
+                                        printk("%02x", dump[j]);
+                                printk("\n");
+                        }
+                }
+
+                if (types & (1 << type)) {
+                        if (!exec(mxm, desc, info))
+                                return false;
+                }
+
+                desc += headerlen + (entries * recordlen);
+        }
+
+        return true;
+}
+
+void
+mxms_output_device(struct nouveau_mxm *mxm, u8 *pdata, struct mxms_odev *desc)
+{
+        u64 data = ROM32(pdata[0]);
+        if (mxms_version(mxm) >= 0x0300)
+                data |= (u64)ROM16(pdata[4]) << 32;
+
+        desc->outp_type = (data & 0x00000000000000f0ULL) >> 4;
+        desc->ddc_port  = (data & 0x0000000000000f00ULL) >> 8;
+        desc->conn_type = (data & 0x000000000001f000ULL) >> 12;
+        desc->dig_conn  = (data & 0x0000000000780000ULL) >> 19;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mxm/mxms.h b/drivers/gpu/drm/nouveau/core/subdev/mxm/mxms.h
new file mode 100644
index 000000000000..5e0be0c591ca
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mxm/mxms.h
@@ -0,0 +1,22 @@
+#ifndef __NVMXM_MXMS_H__
+#define __NVMXM_MXMS_H__
+
+struct mxms_odev {
+        u8 outp_type;
+        u8 conn_type;
+        u8 ddc_port;
+        u8 dig_conn;
+};
+
+void mxms_output_device(struct nouveau_mxm *, u8 *, struct mxms_odev *);
+
+u16  mxms_version(struct nouveau_mxm *);
+u16  mxms_headerlen(struct nouveau_mxm *);
+u16  mxms_structlen(struct nouveau_mxm *);
+bool mxms_checksum(struct nouveau_mxm *);
+bool mxms_valid(struct nouveau_mxm *);
+
+bool mxms_foreach(struct nouveau_mxm *, u8,
+                  bool (*)(struct nouveau_mxm *, u8 *, void *), void *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/subdev/mxm/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/mxm/nv50.c
new file mode 100644
index 000000000000..af129c2e8113
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/mxm/nv50.c
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2011 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 <subdev/mxm.h>
+#include <subdev/bios.h>
+#include <subdev/bios/conn.h>
+#include <subdev/bios/dcb.h>
+#include <subdev/bios/mxm.h>
+
+#include "mxms.h"
+
+struct nv50_mxm_priv {
+        struct nouveau_mxm base;
+};
+
+struct context {
+        u32 *outp;
+        struct mxms_odev desc;
+};
+
+static bool
+mxm_match_tmds_partner(struct nouveau_mxm *mxm, u8 *data, void *info)
+{
+        struct context *ctx = info;
+        struct mxms_odev desc;
+
+        mxms_output_device(mxm, data, &desc);
+        if (desc.outp_type == 2 &&
+            desc.dig_conn == ctx->desc.dig_conn)
+                return false;
+        return true;
+}
+
+static bool
+mxm_match_dcb(struct nouveau_mxm *mxm, u8 *data, void *info)
+{
+        struct nouveau_bios *bios = nouveau_bios(mxm);
+        struct context *ctx = info;
+        u64 desc = *(u64 *)data;
+
+        mxms_output_device(mxm, data, &ctx->desc);
+
+        /* match dcb encoder type to mxm-ods device type */
+        if ((ctx->outp[0] & 0x0000000f) != ctx->desc.outp_type)
+                return true;
+
+        /* digital output, have some extra stuff to match here, there's a
+         * table in the vbios that provides a mapping from the mxm digital
+         * connection enum values to SOR/link
+         */
+        if ((desc & 0x00000000000000f0) >= 0x20) {
+                /* check against sor index */
+                u8 link = mxm_sor_map(bios, ctx->desc.dig_conn);
+                if ((ctx->outp[0] & 0x0f000000) != (link & 0x0f) << 24)
+                        return true;
+
+                /* check dcb entry has a compatible link field */
+                link = (link & 0x30) >> 4;
+                if ((link & ((ctx->outp[1] & 0x00000030) >> 4)) != link)
+                        return true;
+        }
+
+        /* mark this descriptor accounted for by setting invalid device type,
+         * except of course some manufactures don't follow specs properly and
+         * we need to avoid killing off the TMDS function on DP connectors
+         * if MXM-SIS is missing an entry for it.
+         */
+        data[0] &= ~0xf0;
+        if (ctx->desc.outp_type == 6 && ctx->desc.conn_type == 6 &&
+            mxms_foreach(mxm, 0x01, mxm_match_tmds_partner, ctx)) {
+                data[0] |= 0x20; /* modify descriptor to match TMDS now */
+        } else {
+                data[0] |= 0xf0;
+        }
+
+        return false;
+}
+
+static int
+mxm_dcb_sanitise_entry(struct nouveau_bios *bios, void *data, int idx, u16 pdcb)
+{
+        struct nouveau_mxm *mxm = nouveau_mxm(bios);
+        struct context ctx = { .outp = (u32 *)(bios->data + pdcb) };
+        u8 type, i2cidx, link, ver, len;
+        u8 *conn;
+
+        /* look for an output device structure that matches this dcb entry.
+         * if one isn't found, disable it.
+         */
+        if (mxms_foreach(mxm, 0x01, mxm_match_dcb, &ctx)) {
+                nv_debug(mxm, "disable %d: 0x%08x 0x%08x\n",
+                        idx, ctx.outp[0], ctx.outp[1]);
+                ctx.outp[0] |= 0x0000000f;
+                return 0;
+        }
+
+        /* modify the output's ddc/aux port, there's a pointer to a table
+         * with the mapping from mxm ddc/aux port to dcb i2c_index in the
+         * vbios mxm table
+         */
+        i2cidx = mxm_ddc_map(bios, ctx.desc.ddc_port);
+        if ((ctx.outp[0] & 0x0000000f) != DCB_OUTPUT_DP)
+                i2cidx = (i2cidx & 0x0f) << 4;
+        else
+                i2cidx = (i2cidx & 0xf0);
+
+        if (i2cidx != 0xf0) {
+                ctx.outp[0] &= ~0x000000f0;
+                ctx.outp[0] |= i2cidx;
+        }
+
+        /* override dcb sorconf.link, based on what mxm data says */
+        switch (ctx.desc.outp_type) {
+        case 0x00: /* Analog CRT */
+        case 0x01: /* Analog TV/HDTV */
+                break;
+        default:
+                link = mxm_sor_map(bios, ctx.desc.dig_conn) & 0x30;
+                ctx.outp[1] &= ~0x00000030;
+                ctx.outp[1] |= link;
+                break;
+        }
+
+        /* we may need to fixup various other vbios tables based on what
+         * the descriptor says the connector type should be.
+         *
+         * in a lot of cases, the vbios tables will claim DVI-I is possible,
+         * and the mxm data says the connector is really HDMI.  another
+         * common example is DP->eDP.
+         */
+        conn  = bios->data;
+        conn += dcb_conn(bios, (ctx.outp[0] & 0x0000f000) >> 12, &ver, &len);
+        type  = conn[0];
+        switch (ctx.desc.conn_type) {
+        case 0x01: /* LVDS */
+                ctx.outp[1] |= 0x00000004; /* use_power_scripts */
+                /* XXX: modify default link width in LVDS table */
+                break;
+        case 0x02: /* HDMI */
+                type = DCB_CONNECTOR_HDMI_1;
+                break;
+        case 0x03: /* DVI-D */
+                type = DCB_CONNECTOR_DVI_D;
+                break;
+        case 0x0e: /* eDP, falls through to DPint */
+                ctx.outp[1] |= 0x00010000;
+        case 0x07: /* DP internal, wtf is this?? HP8670w */
+                ctx.outp[1] |= 0x00000004; /* use_power_scripts? */
+                type = DCB_CONNECTOR_eDP;
+                break;
+        default:
+                break;
+        }
+
+        if (mxms_version(mxm) >= 0x0300)
+                conn[0] = type;
+
+        return 0;
+}
+
+static bool
+mxm_show_unmatched(struct nouveau_mxm *mxm, u8 *data, void *info)
+{
+        u64 desc = *(u64 *)data;
+        if ((desc & 0xf0) != 0xf0)
+        nv_info(mxm, "unmatched output device 0x%016llx\n", desc);
+        return true;
+}
+
+static void
+mxm_dcb_sanitise(struct nouveau_mxm *mxm)
+{
+        struct nouveau_bios *bios = nouveau_bios(mxm);
+        u8  ver, hdr, cnt, len;
+        u16 dcb = dcb_table(bios, &ver, &hdr, &cnt, &len);
+        if (dcb == 0x0000 || ver != 0x40) {
+                nv_debug(mxm, "unsupported DCB version\n");
+                return;
+        }
+
+        dcb_outp_foreach(bios, NULL, mxm_dcb_sanitise_entry);
+        mxms_foreach(mxm, 0x01, mxm_show_unmatched, NULL);
+}
+
+static int
+nv50_mxm_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+              struct nouveau_oclass *oclass, void *data, u32 size,
+              struct nouveau_object **pobject)
+{
+        struct nv50_mxm_priv *priv;
+        int ret;
+
+        ret = nouveau_mxm_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        if (priv->base.action & MXM_SANITISE_DCB)
+                mxm_dcb_sanitise(&priv->base);
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_mxm_oclass = {
+        .handle = NV_SUBDEV(MXM, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_mxm_ctor,
+                .dtor = _nouveau_mxm_dtor,
+                .init = _nouveau_mxm_init,
+                .fini = _nouveau_mxm_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/base.c b/drivers/gpu/drm/nouveau/core/subdev/therm/base.c
new file mode 100644
index 000000000000..1674c74a76c8
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/base.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2012 The Nouveau community
+ *
+ * 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: Martin Peres
+ */
+
+#include <core/object.h>
+#include <core/device.h>
+
+#include <subdev/bios.h>
+
+#include "priv.h"
+
+int
+nouveau_therm_attr_get(struct nouveau_therm *therm,
+                       enum nouveau_therm_attr_type type)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        switch (type) {
+        case NOUVEAU_THERM_ATTR_FAN_MIN_DUTY:
+                return priv->bios_fan.min_duty;
+        case NOUVEAU_THERM_ATTR_FAN_MAX_DUTY:
+                return priv->bios_fan.max_duty;
+        case NOUVEAU_THERM_ATTR_FAN_MODE:
+                return priv->fan.mode;
+        case NOUVEAU_THERM_ATTR_THRS_FAN_BOOST:
+                return priv->bios_sensor.thrs_fan_boost.temp;
+        case NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST:
+                return priv->bios_sensor.thrs_fan_boost.hysteresis;
+        case NOUVEAU_THERM_ATTR_THRS_DOWN_CLK:
+                return priv->bios_sensor.thrs_down_clock.temp;
+        case NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST:
+                return priv->bios_sensor.thrs_down_clock.hysteresis;
+        case NOUVEAU_THERM_ATTR_THRS_CRITICAL:
+                return priv->bios_sensor.thrs_critical.temp;
+        case NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST:
+                return priv->bios_sensor.thrs_critical.hysteresis;
+        case NOUVEAU_THERM_ATTR_THRS_SHUTDOWN:
+                return priv->bios_sensor.thrs_shutdown.temp;
+        case NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST:
+                return priv->bios_sensor.thrs_shutdown.hysteresis;
+        }
+
+        return -EINVAL;
+}
+
+int
+nouveau_therm_attr_set(struct nouveau_therm *therm,
+                       enum nouveau_therm_attr_type type, int value)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        switch (type) {
+        case NOUVEAU_THERM_ATTR_FAN_MIN_DUTY:
+                if (value < 0)
+                        value = 0;
+                if (value > priv->bios_fan.max_duty)
+                        value = priv->bios_fan.max_duty;
+                priv->bios_fan.min_duty = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_FAN_MAX_DUTY:
+                if (value < 0)
+                        value = 0;
+                if (value < priv->bios_fan.min_duty)
+                        value = priv->bios_fan.min_duty;
+                priv->bios_fan.max_duty = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_FAN_MODE:
+                return nouveau_therm_fan_set_mode(therm, value);
+        case NOUVEAU_THERM_ATTR_THRS_FAN_BOOST:
+                priv->bios_sensor.thrs_fan_boost.temp = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST:
+                priv->bios_sensor.thrs_fan_boost.hysteresis = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_DOWN_CLK:
+                priv->bios_sensor.thrs_down_clock.temp = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST:
+                priv->bios_sensor.thrs_down_clock.hysteresis = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_CRITICAL:
+                priv->bios_sensor.thrs_critical.temp = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST:
+                priv->bios_sensor.thrs_critical.hysteresis = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_SHUTDOWN:
+                priv->bios_sensor.thrs_shutdown.temp = value;
+                return 0;
+        case NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST:
+                priv->bios_sensor.thrs_shutdown.hysteresis = value;
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+int
+nouveau_therm_init(struct nouveau_object *object)
+{
+        struct nouveau_therm *therm = (void *)object;
+        struct nouveau_therm_priv *priv = (void *)therm;
+        int ret;
+
+        ret = nouveau_subdev_init(&therm->base);
+        if (ret)
+                return ret;
+
+        if (priv->fan.percent >= 0)
+                therm->fan_set(therm, priv->fan.percent);
+
+        return 0;
+}
+
+int
+nouveau_therm_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nouveau_therm *therm = (void *)object;
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        priv->fan.percent = therm->fan_get(therm);
+
+        return nouveau_subdev_fini(&therm->base, suspend);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/fan.c b/drivers/gpu/drm/nouveau/core/subdev/therm/fan.c
new file mode 100644
index 000000000000..b29237970fa0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/fan.c
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2012 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
+ *          Martin Peres
+ */
+
+#include "priv.h"
+
+#include <core/object.h>
+#include <core/device.h>
+#include <subdev/gpio.h>
+#include <subdev/timer.h>
+
+int
+nouveau_therm_fan_get(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+        struct nouveau_gpio *gpio = nouveau_gpio(therm);
+        struct dcb_gpio_func func;
+        int card_type = nv_device(therm)->card_type;
+        u32 divs, duty;
+        int ret;
+
+        if (!priv->fan.pwm_get)
+                return -ENODEV;
+
+        ret = gpio->find(gpio, 0, DCB_GPIO_PWM_FAN, 0xff, &func);
+        if (ret == 0) {
+                ret = priv->fan.pwm_get(therm, func.line, &divs, &duty);
+                if (ret == 0 && divs) {
+                        divs = max(divs, duty);
+                        if (card_type <= NV_40 || (func.log[0] & 1))
+                                duty = divs - duty;
+                        return (duty * 100) / divs;
+                }
+
+                return gpio->get(gpio, 0, func.func, func.line) * 100;
+        }
+
+        return -ENODEV;
+}
+
+int
+nouveau_therm_fan_set(struct nouveau_therm *therm, int percent)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+        struct nouveau_gpio *gpio = nouveau_gpio(therm);
+        struct dcb_gpio_func func;
+        int card_type = nv_device(therm)->card_type;
+        u32 divs, duty;
+        int ret;
+
+        if (priv->fan.mode == FAN_CONTROL_NONE)
+                return -EINVAL;
+
+        if (!priv->fan.pwm_set)
+                return -ENODEV;
+
+        if (percent < priv->bios_fan.min_duty)
+                percent = priv->bios_fan.min_duty;
+        if (percent > priv->bios_fan.max_duty)
+                percent = priv->bios_fan.max_duty;
+
+        ret = gpio->find(gpio, 0, DCB_GPIO_PWM_FAN, 0xff, &func);
+        if (ret == 0) {
+                divs = priv->bios_perf_fan.pwm_divisor;
+                if (priv->bios_fan.pwm_freq) {
+                        divs = 1;
+                        if (priv->fan.pwm_clock)
+                                divs = priv->fan.pwm_clock(therm);
+                        divs /= priv->bios_fan.pwm_freq;
+                }
+
+                duty = ((divs * percent) + 99) / 100;
+                if (card_type <= NV_40 || (func.log[0] & 1))
+                        duty = divs - duty;
+
+                ret = priv->fan.pwm_set(therm, func.line, divs, duty);
+                return ret;
+        }
+
+        return -ENODEV;
+}
+
+int
+nouveau_therm_fan_sense(struct nouveau_therm *therm)
+{
+        struct nouveau_timer *ptimer = nouveau_timer(therm);
+        struct nouveau_gpio *gpio = nouveau_gpio(therm);
+        struct dcb_gpio_func func;
+        u32 cycles, cur, prev;
+        u64 start, end, tach;
+
+        if (gpio->find(gpio, 0, DCB_GPIO_FAN_SENSE, 0xff, &func))
+                return -ENODEV;
+
+        /* Time a complete rotation and extrapolate to RPM:
+         * When the fan spins, it changes the value of GPIO FAN_SENSE.
+         * We get 4 changes (0 -> 1 -> 0 -> 1) per complete rotation.
+         */
+        start = ptimer->read(ptimer);
+        prev = gpio->get(gpio, 0, func.func, func.line);
+        cycles = 0;
+        do {
+                usleep_range(500, 1000); /* supports 0 < rpm < 7500 */
+
+                cur = gpio->get(gpio, 0, func.func, func.line);
+                if (prev != cur) {
+                        if (!start)
+                                start = ptimer->read(ptimer);
+                        cycles++;
+                        prev = cur;
+                }
+        } while (cycles < 5 && ptimer->read(ptimer) - start < 250000000);
+        end = ptimer->read(ptimer);
+
+        if (cycles == 5) {
+                tach = (u64)60000000000;
+                do_div(tach, (end - start));
+                return tach;
+        } else
+                return 0;
+}
+
+int
+nouveau_therm_fan_set_mode(struct nouveau_therm *therm,
+                           enum nouveau_therm_fan_mode mode)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        if (priv->fan.mode == mode)
+                return 0;
+
+        if (mode < FAN_CONTROL_NONE || mode >= FAN_CONTROL_NR)
+                return -EINVAL;
+
+        switch (mode)
+        {
+        case FAN_CONTROL_NONE:
+                nv_info(therm, "switch fan to no-control mode\n");
+                break;
+        case FAN_CONTROL_MANUAL:
+                nv_info(therm, "switch fan to manual mode\n");
+                break;
+        case FAN_CONTROL_NR:
+                break;
+        }
+
+        priv->fan.mode = mode;
+        return 0;
+}
+
+int
+nouveau_therm_fan_user_get(struct nouveau_therm *therm)
+{
+        return nouveau_therm_fan_get(therm);
+}
+
+int
+nouveau_therm_fan_user_set(struct nouveau_therm *therm, int percent)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        if (priv->fan.mode != FAN_CONTROL_MANUAL)
+                return -EINVAL;
+
+        return nouveau_therm_fan_set(therm, percent);
+}
+
+void
+nouveau_therm_fan_set_defaults(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        priv->bios_fan.pwm_freq = 0;
+        priv->bios_fan.min_duty = 0;
+        priv->bios_fan.max_duty = 100;
+}
+
+
+static void
+nouveau_therm_fan_safety_checks(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        if (priv->bios_fan.min_duty > 100)
+                priv->bios_fan.min_duty = 100;
+        if (priv->bios_fan.max_duty > 100)
+                priv->bios_fan.max_duty = 100;
+
+        if (priv->bios_fan.min_duty > priv->bios_fan.max_duty)
+                priv->bios_fan.min_duty = priv->bios_fan.max_duty;
+}
+
+int nouveau_fan_pwm_clock_dummy(struct nouveau_therm *therm)
+{
+        return 1;
+}
+
+int
+nouveau_therm_fan_ctor(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+        struct nouveau_bios *bios = nouveau_bios(therm);
+
+        nouveau_therm_fan_set_defaults(therm);
+        nvbios_perf_fan_parse(bios, &priv->bios_perf_fan);
+        if (nvbios_therm_fan_parse(bios, &priv->bios_fan))
+                nv_error(therm, "parsing the thermal table failed\n");
+        nouveau_therm_fan_safety_checks(therm);
+
+        nouveau_therm_fan_set_mode(therm, FAN_CONTROL_NONE);
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/ic.c b/drivers/gpu/drm/nouveau/core/subdev/therm/ic.c
new file mode 100644
index 000000000000..e512ff0aae60
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/ic.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2012 Nouveau community
+ *
+ * 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: Martin Peres
+ */
+
+#include "priv.h"
+
+#include <subdev/i2c.h>
+#include <subdev/bios/extdev.h>
+
+static bool
+probe_monitoring_device(struct nouveau_i2c_port *i2c,
+                        struct i2c_board_info *info)
+{
+        struct nouveau_therm_priv *priv = (void *)nouveau_therm(i2c->i2c);
+        struct i2c_client *client;
+
+        request_module("%s%s", I2C_MODULE_PREFIX, info->type);
+
+        client = i2c_new_device(&i2c->adapter, info);
+        if (!client)
+                return false;
+
+        if (!client->driver || client->driver->detect(client, info)) {
+                i2c_unregister_device(client);
+                return false;
+        }
+
+        nv_info(priv,
+                "Found an %s at address 0x%x (controlled by lm_sensors)\n",
+                info->type, info->addr);
+        priv->ic = client;
+
+        return true;
+}
+
+void
+nouveau_therm_ic_ctor(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+        struct nouveau_bios *bios = nouveau_bios(therm);
+        struct nouveau_i2c *i2c = nouveau_i2c(therm);
+        struct nvbios_extdev_func extdev_entry;
+        struct i2c_board_info info[] = {
+                { I2C_BOARD_INFO("w83l785ts", 0x2d) },
+                { I2C_BOARD_INFO("w83781d", 0x2d) },
+                { I2C_BOARD_INFO("adt7473", 0x2e) },
+                { I2C_BOARD_INFO("adt7473", 0x2d) },
+                { I2C_BOARD_INFO("adt7473", 0x2c) },
+                { I2C_BOARD_INFO("f75375", 0x2e) },
+                { I2C_BOARD_INFO("lm99", 0x4c) },
+                { I2C_BOARD_INFO("lm90", 0x4c) },
+                { I2C_BOARD_INFO("lm90", 0x4d) },
+                { I2C_BOARD_INFO("adm1021", 0x18) },
+                { I2C_BOARD_INFO("adm1021", 0x19) },
+                { I2C_BOARD_INFO("adm1021", 0x1a) },
+                { I2C_BOARD_INFO("adm1021", 0x29) },
+                { I2C_BOARD_INFO("adm1021", 0x2a) },
+                { I2C_BOARD_INFO("adm1021", 0x2b) },
+                { I2C_BOARD_INFO("adm1021", 0x4c) },
+                { I2C_BOARD_INFO("adm1021", 0x4d) },
+                { I2C_BOARD_INFO("adm1021", 0x4e) },
+                { I2C_BOARD_INFO("lm63", 0x18) },
+                { I2C_BOARD_INFO("lm63", 0x4e) },
+                { }
+        };
+
+        if (!nvbios_extdev_find(bios, NVBIOS_EXTDEV_LM89, &extdev_entry)) {
+                struct i2c_board_info board[] = {
+                        { I2C_BOARD_INFO("lm90", extdev_entry.addr >> 1) },
+                        { }
+                };
+
+                i2c->identify(i2c, NV_I2C_DEFAULT(0), "monitoring device",
+                                  board, probe_monitoring_device);
+                if (priv->ic)
+                        return;
+        }
+
+        if (!nvbios_extdev_find(bios, NVBIOS_EXTDEV_ADT7473, &extdev_entry)) {
+                struct i2c_board_info board[] = {
+                        { I2C_BOARD_INFO("adt7473", extdev_entry.addr >> 1) },
+                        { }
+                };
+
+                i2c->identify(i2c, NV_I2C_DEFAULT(0), "monitoring device",
+                                  board, probe_monitoring_device);
+                if (priv->ic)
+                        return;
+        }
+
+        /* The vbios doesn't provide the address of an exisiting monitoring
+           device. Let's try our static list.
+         */
+        i2c->identify(i2c, NV_I2C_DEFAULT(0), "monitoring device", info,
+                      probe_monitoring_device);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/nv40.c b/drivers/gpu/drm/nouveau/core/subdev/therm/nv40.c
new file mode 100644
index 000000000000..fcf2cfe731d6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/nv40.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2012 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
+ *          Martin Peres
+ */
+
+#include "priv.h"
+
+static int
+nv40_sensor_setup(struct nouveau_therm *therm)
+{
+        struct nouveau_device *device = nv_device(therm);
+
+        /* enable ADC readout and disable the ALARM threshold */
+        if (device->chipset >= 0x46) {
+                nv_mask(therm, 0x15b8, 0x80000000, 0);
+                nv_wr32(therm, 0x15b0, 0x80003fff);
+                return nv_rd32(therm, 0x15b4) & 0x3fff;
+        } else {
+                nv_wr32(therm, 0x15b0, 0xff);
+                return nv_rd32(therm, 0x15b4) & 0xff;
+        }
+}
+
+static int
+nv40_temp_get(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+        struct nouveau_device *device = nv_device(therm);
+        struct nvbios_therm_sensor *sensor = &priv->bios_sensor;
+        int core_temp;
+
+        if (device->chipset >= 0x46) {
+                nv_wr32(therm, 0x15b0, 0x80003fff);
+                core_temp = nv_rd32(therm, 0x15b4) & 0x3fff;
+        } else {
+                nv_wr32(therm, 0x15b0, 0xff);
+                core_temp = nv_rd32(therm, 0x15b4) & 0xff;
+        }
+
+        /* Setup the sensor if the temperature is 0 */
+        if (core_temp == 0)
+                core_temp = nv40_sensor_setup(therm);
+
+        if (sensor->slope_div == 0)
+                sensor->slope_div = 1;
+        if (sensor->offset_den == 0)
+                sensor->offset_den = 1;
+        if (sensor->slope_mult < 1)
+                sensor->slope_mult = 1;
+
+        core_temp = core_temp * sensor->slope_mult / sensor->slope_div;
+        core_temp = core_temp + sensor->offset_num / sensor->offset_den;
+        core_temp = core_temp + sensor->offset_constant - 8;
+
+        return core_temp;
+}
+
+int
+nv40_fan_pwm_get(struct nouveau_therm *therm, int line, u32 *divs, u32 *duty)
+{
+        if (line == 2) {
+                u32 reg = nv_rd32(therm, 0x0010f0);
+                if (reg & 0x80000000) {
+                        *duty = (reg & 0x7fff0000) >> 16;
+                        *divs = (reg & 0x00007fff);
+                        return 0;
+                }
+        } else
+        if (line == 9) {
+                u32 reg = nv_rd32(therm, 0x0015f4);
+                if (reg & 0x80000000) {
+                        *divs = nv_rd32(therm, 0x0015f8);
+                        *duty = (reg & 0x7fffffff);
+                        return 0;
+                }
+        } else {
+                nv_error(therm, "unknown pwm ctrl for gpio %d\n", line);
+                return -ENODEV;
+        }
+
+        return -EINVAL;
+}
+
+int
+nv40_fan_pwm_set(struct nouveau_therm *therm, int line, u32 divs, u32 duty)
+{
+        if (line == 2) {
+                nv_wr32(therm, 0x0010f0, 0x80000000 | (duty << 16) | divs);
+        } else
+        if (line == 9) {
+                nv_wr32(therm, 0x0015f8, divs);
+                nv_wr32(therm, 0x0015f4, duty | 0x80000000);
+        } else {
+                nv_error(therm, "unknown pwm ctrl for gpio %d\n", line);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int
+nv40_therm_ctor(struct nouveau_object *parent,
+                   struct nouveau_object *engine,
+                   struct nouveau_oclass *oclass, void *data, u32 size,
+                   struct nouveau_object **pobject)
+{
+        struct nouveau_therm_priv *priv;
+        struct nouveau_therm *therm;
+        int ret;
+
+        ret = nouveau_therm_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        therm = (void *) priv;
+        if (ret)
+                return ret;
+
+        nouveau_therm_ic_ctor(therm);
+        nouveau_therm_sensor_ctor(therm);
+        nouveau_therm_fan_ctor(therm);
+
+        priv->fan.pwm_get = nv40_fan_pwm_get;
+        priv->fan.pwm_set = nv40_fan_pwm_set;
+
+        therm->temp_get = nv40_temp_get;
+        therm->fan_get = nouveau_therm_fan_user_get;
+        therm->fan_set = nouveau_therm_fan_user_set;
+        therm->fan_sense = nouveau_therm_fan_sense;
+        therm->attr_get = nouveau_therm_attr_get;
+        therm->attr_set = nouveau_therm_attr_set;
+
+        return 0;
+}
+
+struct nouveau_oclass
+nv40_therm_oclass = {
+        .handle = NV_SUBDEV(THERM, 0x40),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv40_therm_ctor,
+                .dtor = _nouveau_therm_dtor,
+                .init = nouveau_therm_init,
+                .fini = nouveau_therm_fini,
+        },
+};
\ No newline at end of file
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/nv50.c b/drivers/gpu/drm/nouveau/core/subdev/therm/nv50.c
new file mode 100644
index 000000000000..f87a7a3eb4e7
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/nv50.c
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2012 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
+ *          Martin Peres
+ */
+
+#include "priv.h"
+
+static int
+pwm_info(struct nouveau_therm *therm, int *line, int *ctrl, int *indx)
+{
+        if (*line == 0x04) {
+                *ctrl = 0x00e100;
+                *line = 4;
+                *indx = 0;
+        } else
+        if (*line == 0x09) {
+                *ctrl = 0x00e100;
+                *line = 9;
+                *indx = 1;
+        } else
+        if (*line == 0x10) {
+                *ctrl = 0x00e28c;
+                *line = 0;
+                *indx = 0;
+        } else {
+                nv_error(therm, "unknown pwm ctrl for gpio %d\n", *line);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+int
+nv50_fan_pwm_get(struct nouveau_therm *therm, int line, u32 *divs, u32 *duty)
+{
+        int ctrl, id, ret = pwm_info(therm, &line, &ctrl, &id);
+        if (ret)
+                return ret;
+
+        if (nv_rd32(therm, ctrl) & (1 << line)) {
+                *divs = nv_rd32(therm, 0x00e114 + (id * 8));
+                *duty = nv_rd32(therm, 0x00e118 + (id * 8));
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+int
+nv50_fan_pwm_set(struct nouveau_therm *therm, int line, u32 divs, u32 duty)
+{
+        int ctrl, id, ret = pwm_info(therm, &line, &ctrl, &id);
+        if (ret)
+                return ret;
+
+        nv_mask(therm, ctrl, 0x00010001 << line, 0x00000001 << line);
+        nv_wr32(therm, 0x00e114 + (id * 8), divs);
+        nv_wr32(therm, 0x00e118 + (id * 8), duty | 0x80000000);
+        return 0;
+}
+
+int
+nv50_fan_pwm_clock(struct nouveau_therm *therm)
+{
+        int chipset = nv_device(therm)->chipset;
+        int crystal = nv_device(therm)->crystal;
+        int pwm_clock;
+
+        /* determine the PWM source clock */
+        if (chipset > 0x50 && chipset < 0x94) {
+                u8 pwm_div = nv_rd32(therm, 0x410c);
+                if (nv_rd32(therm, 0xc040) & 0x800000) {
+                        /* Use the HOST clock (100 MHz)
+                        * Where does this constant(2.4) comes from? */
+                        pwm_clock = (100000000 >> pwm_div) / 10 / 24;
+                } else {
+                        /* Where does this constant(20) comes from? */
+                        pwm_clock = (crystal * 1000) >> pwm_div;
+                        pwm_clock /= 20;
+                }
+        } else {
+                pwm_clock = (crystal * 1000) / 20;
+        }
+
+        return pwm_clock;
+}
+
+int
+nv50_temp_get(struct nouveau_therm *therm)
+{
+        return nv_rd32(therm, 0x20400);
+}
+
+static int
+nv50_therm_ctor(struct nouveau_object *parent,
+                   struct nouveau_object *engine,
+                   struct nouveau_oclass *oclass, void *data, u32 size,
+                   struct nouveau_object **pobject)
+{
+        struct nouveau_therm_priv *priv;
+        struct nouveau_therm *therm;
+        int ret;
+
+        ret = nouveau_therm_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        therm = (void *) priv;
+        if (ret)
+                return ret;
+
+        nouveau_therm_ic_ctor(therm);
+        nouveau_therm_sensor_ctor(therm);
+        nouveau_therm_fan_ctor(therm);
+
+        priv->fan.pwm_get = nv50_fan_pwm_get;
+        priv->fan.pwm_set = nv50_fan_pwm_set;
+        priv->fan.pwm_clock = nv50_fan_pwm_clock;
+
+        therm->temp_get = nv50_temp_get;
+        therm->fan_get = nouveau_therm_fan_user_get;
+        therm->fan_set = nouveau_therm_fan_user_set;
+        therm->fan_sense = nouveau_therm_fan_sense;
+        therm->attr_get = nouveau_therm_attr_get;
+        therm->attr_set = nouveau_therm_attr_set;
+
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_therm_oclass = {
+        .handle = NV_SUBDEV(THERM, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_therm_ctor,
+                .dtor = _nouveau_therm_dtor,
+                .init = nouveau_therm_init,
+                .fini = nouveau_therm_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/priv.h b/drivers/gpu/drm/nouveau/core/subdev/therm/priv.h
new file mode 100644
index 000000000000..1c3cd6abc36e
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/priv.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2012 The Nouveau community
+ *
+ * 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: Martin Peres
+ */
+
+#include <subdev/therm.h>
+
+#include <subdev/bios/extdev.h>
+#include <subdev/bios/perf.h>
+#include <subdev/bios/therm.h>
+
+struct nouveau_therm_priv {
+        struct nouveau_therm base;
+
+        /* bios */
+        struct nvbios_therm_sensor bios_sensor;
+        struct nvbios_therm_fan bios_fan;
+        struct nvbios_perf_fan bios_perf_fan;
+
+        /* fan priv */
+        struct {
+                enum nouveau_therm_fan_mode mode;
+                int percent;
+
+                int (*pwm_get)(struct nouveau_therm *, int line, u32*, u32*);
+                int (*pwm_set)(struct nouveau_therm *, int line, u32, u32);
+                int (*pwm_clock)(struct nouveau_therm *);
+        } fan;
+
+        /* ic */
+        struct i2c_client *ic;
+};
+
+int nouveau_therm_init(struct nouveau_object *object);
+int nouveau_therm_fini(struct nouveau_object *object, bool suspend);
+int nouveau_therm_attr_get(struct nouveau_therm *therm,
+                       enum nouveau_therm_attr_type type);
+int nouveau_therm_attr_set(struct nouveau_therm *therm,
+                       enum nouveau_therm_attr_type type, int value);
+
+void nouveau_therm_ic_ctor(struct nouveau_therm *therm);
+
+int nouveau_therm_sensor_ctor(struct nouveau_therm *therm);
+
+int nouveau_therm_fan_ctor(struct nouveau_therm *therm);
+int nouveau_therm_fan_get(struct nouveau_therm *therm);
+int nouveau_therm_fan_set(struct nouveau_therm *therm, int percent);
+int nouveau_therm_fan_user_get(struct nouveau_therm *therm);
+int nouveau_therm_fan_user_set(struct nouveau_therm *therm, int percent);
+int nouveau_therm_fan_set_mode(struct nouveau_therm *therm,
+                           enum nouveau_therm_fan_mode mode);
+
+
+int nouveau_therm_fan_sense(struct nouveau_therm *therm);
diff --git a/drivers/gpu/drm/nouveau/core/subdev/therm/temp.c b/drivers/gpu/drm/nouveau/core/subdev/therm/temp.c
new file mode 100644
index 000000000000..204282301fb1
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/therm/temp.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2012 The Nouveau community
+ *
+ * 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: Martin Peres
+ */
+
+#include "priv.h"
+
+#include <core/object.h>
+#include <core/device.h>
+
+#include <subdev/bios.h>
+
+static void
+nouveau_therm_temp_set_defaults(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        priv->bios_sensor.slope_mult = 1;
+        priv->bios_sensor.slope_div = 1;
+        priv->bios_sensor.offset_num = 0;
+        priv->bios_sensor.offset_den = 1;
+        priv->bios_sensor.offset_constant = 0;
+
+        priv->bios_sensor.thrs_fan_boost.temp = 90;
+        priv->bios_sensor.thrs_fan_boost.hysteresis = 3;
+
+        priv->bios_sensor.thrs_down_clock.temp = 95;
+        priv->bios_sensor.thrs_down_clock.hysteresis = 3;
+
+        priv->bios_sensor.thrs_critical.temp = 105;
+        priv->bios_sensor.thrs_critical.hysteresis = 5;
+
+        priv->bios_sensor.thrs_shutdown.temp = 135;
+        priv->bios_sensor.thrs_shutdown.hysteresis = 5; /*not that it matters */
+}
+
+
+static void
+nouveau_therm_temp_safety_checks(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+
+        if (!priv->bios_sensor.slope_div)
+                priv->bios_sensor.slope_div = 1;
+        if (!priv->bios_sensor.offset_den)
+                priv->bios_sensor.offset_den = 1;
+}
+
+int
+nouveau_therm_sensor_ctor(struct nouveau_therm *therm)
+{
+        struct nouveau_therm_priv *priv = (void *)therm;
+        struct nouveau_bios *bios = nouveau_bios(therm);
+
+        nouveau_therm_temp_set_defaults(therm);
+        if (nvbios_therm_sensor_parse(bios, NVBIOS_THERM_DOMAIN_CORE,
+                                      &priv->bios_sensor))
+                nv_error(therm, "nvbios_therm_sensor_parse failed\n");
+        nouveau_therm_temp_safety_checks(therm);
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/timer/base.c b/drivers/gpu/drm/nouveau/core/subdev/timer/base.c
new file mode 100644
index 000000000000..5d417cc9949b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/timer/base.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2012 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 "subdev/timer.h"
+
+bool
+nouveau_timer_wait_eq(void *obj, u64 nsec, u32 addr, u32 mask, u32 data)
+{
+        struct nouveau_timer *ptimer = nouveau_timer(obj);
+        u64 time0;
+
+        time0 = ptimer->read(ptimer);
+        do {
+                if (nv_iclass(obj, NV_SUBDEV_CLASS)) {
+                        if ((nv_rd32(obj, addr) & mask) == data)
+                                return true;
+                } else {
+                        if ((nv_ro32(obj, addr) & mask) == data)
+                                return true;
+                }
+        } while (ptimer->read(ptimer) - time0 < nsec);
+
+        return false;
+}
+
+bool
+nouveau_timer_wait_ne(void *obj, u64 nsec, u32 addr, u32 mask, u32 data)
+{
+        struct nouveau_timer *ptimer = nouveau_timer(obj);
+        u64 time0;
+
+        time0 = ptimer->read(ptimer);
+        do {
+                if (nv_iclass(obj, NV_SUBDEV_CLASS)) {
+                        if ((nv_rd32(obj, addr) & mask) != data)
+                                return true;
+                } else {
+                        if ((nv_ro32(obj, addr) & mask) != data)
+                                return true;
+                }
+        } while (ptimer->read(ptimer) - time0 < nsec);
+
+        return false;
+}
+
+bool
+nouveau_timer_wait_cb(void *obj, u64 nsec, bool (*func)(void *), void *data)
+{
+        struct nouveau_timer *ptimer = nouveau_timer(obj);
+        u64 time0;
+
+        time0 = ptimer->read(ptimer);
+        do {
+                if (func(data) == true)
+                        return true;
+        } while (ptimer->read(ptimer) - time0 < nsec);
+
+        return false;
+}
+
+void
+nouveau_timer_alarm(void *obj, u32 nsec, struct nouveau_alarm *alarm)
+{
+        struct nouveau_timer *ptimer = nouveau_timer(obj);
+        ptimer->alarm(ptimer, nsec, alarm);
+}
diff --git a/drivers/gpu/drm/nouveau/core/subdev/timer/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/timer/nv04.c
new file mode 100644
index 000000000000..49976be4d73b
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/timer/nv04.c
@@ -0,0 +1,249 @@
+/*
+ * Copyright 2012 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 <subdev/timer.h>
+
+#define NV04_PTIMER_INTR_0      0x009100
+#define NV04_PTIMER_INTR_EN_0   0x009140
+#define NV04_PTIMER_NUMERATOR   0x009200
+#define NV04_PTIMER_DENOMINATOR 0x009210
+#define NV04_PTIMER_TIME_0      0x009400
+#define NV04_PTIMER_TIME_1      0x009410
+#define NV04_PTIMER_ALARM_0     0x009420
+
+struct nv04_timer_priv {
+        struct nouveau_timer base;
+        struct list_head alarms;
+        spinlock_t lock;
+};
+
+static u64
+nv04_timer_read(struct nouveau_timer *ptimer)
+{
+        struct nv04_timer_priv *priv = (void *)ptimer;
+        u32 hi, lo;
+
+        do {
+                hi = nv_rd32(priv, NV04_PTIMER_TIME_1);
+                lo = nv_rd32(priv, NV04_PTIMER_TIME_0);
+        } while (hi != nv_rd32(priv, NV04_PTIMER_TIME_1));
+
+        return ((u64)hi << 32 | lo);
+}
+
+static void
+nv04_timer_alarm_trigger(struct nouveau_timer *ptimer)
+{
+        struct nv04_timer_priv *priv = (void *)ptimer;
+        struct nouveau_alarm *alarm, *atemp;
+        unsigned long flags;
+        LIST_HEAD(exec);
+
+        /* move any due alarms off the pending list */
+        spin_lock_irqsave(&priv->lock, flags);
+        list_for_each_entry_safe(alarm, atemp, &priv->alarms, head) {
+                if (alarm->timestamp <= ptimer->read(ptimer))
+                        list_move_tail(&alarm->head, &exec);
+        }
+
+        /* reschedule interrupt for next alarm time */
+        if (!list_empty(&priv->alarms)) {
+                alarm = list_first_entry(&priv->alarms, typeof(*alarm), head);
+                nv_wr32(priv, NV04_PTIMER_ALARM_0, alarm->timestamp);
+                nv_wr32(priv, NV04_PTIMER_INTR_EN_0, 0x00000001);
+        } else {
+                nv_wr32(priv, NV04_PTIMER_INTR_EN_0, 0x00000000);
+        }
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        /* execute any pending alarm handlers */
+        list_for_each_entry_safe(alarm, atemp, &exec, head) {
+                list_del(&alarm->head);
+                alarm->func(alarm);
+        }
+}
+
+static void
+nv04_timer_alarm(struct nouveau_timer *ptimer, u32 time,
+                 struct nouveau_alarm *alarm)
+{
+        struct nv04_timer_priv *priv = (void *)ptimer;
+        struct nouveau_alarm *list;
+        unsigned long flags;
+
+        alarm->timestamp = ptimer->read(ptimer) + time;
+
+        /* append new alarm to list, in soonest-alarm-first order */
+        spin_lock_irqsave(&priv->lock, flags);
+        list_for_each_entry(list, &priv->alarms, head) {
+                if (list->timestamp > alarm->timestamp)
+                        break;
+        }
+        list_add_tail(&alarm->head, &list->head);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        /* process pending alarms */
+        nv04_timer_alarm_trigger(ptimer);
+}
+
+static void
+nv04_timer_intr(struct nouveau_subdev *subdev)
+{
+        struct nv04_timer_priv *priv = (void *)subdev;
+        u32 stat = nv_rd32(priv, NV04_PTIMER_INTR_0);
+
+        if (stat & 0x00000001) {
+                nv04_timer_alarm_trigger(&priv->base);
+                nv_wr32(priv, NV04_PTIMER_INTR_0, 0x00000001);
+                stat &= ~0x00000001;
+        }
+
+        if (stat) {
+                nv_error(priv, "unknown stat 0x%08x\n", stat);
+                nv_wr32(priv, NV04_PTIMER_INTR_0, stat);
+        }
+}
+
+static int
+nv04_timer_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv04_timer_priv *priv;
+        int ret;
+
+        ret = nouveau_timer_create(parent, engine, oclass, &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.base.intr = nv04_timer_intr;
+        priv->base.read = nv04_timer_read;
+        priv->base.alarm = nv04_timer_alarm;
+
+        INIT_LIST_HEAD(&priv->alarms);
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+static void
+nv04_timer_dtor(struct nouveau_object *object)
+{
+        struct nv04_timer_priv *priv = (void *)object;
+        return nouveau_timer_destroy(&priv->base);
+}
+
+static int
+nv04_timer_init(struct nouveau_object *object)
+{
+        struct nouveau_device *device = nv_device(object);
+        struct nv04_timer_priv *priv = (void *)object;
+        u32 m = 1, f, n, d;
+        int ret;
+
+        ret = nouveau_timer_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* aim for 31.25MHz, which gives us nanosecond timestamps */
+        d = 1000000 / 32;
+
+        /* determine base clock for timer source */
+#if 0 /*XXX*/
+        if (device->chipset < 0x40) {
+                n = nouveau_hw_get_clock(device, PLL_CORE);
+        } else
+#endif
+        if (device->chipset <= 0x40) {
+                /*XXX: figure this out */
+                f = -1;
+                n = 0;
+        } else {
+                f = device->crystal;
+                n = f;
+                while (n < (d * 2)) {
+                        n += (n / m);
+                        m++;
+                }
+
+                nv_wr32(priv, 0x009220, m - 1);
+        }
+
+        if (!n) {
+                nv_warn(priv, "unknown input clock freq\n");
+                if (!nv_rd32(priv, NV04_PTIMER_NUMERATOR) ||
+                    !nv_rd32(priv, NV04_PTIMER_DENOMINATOR)) {
+                        nv_wr32(priv, NV04_PTIMER_NUMERATOR, 1);
+                        nv_wr32(priv, NV04_PTIMER_DENOMINATOR, 1);
+                }
+                return 0;
+        }
+
+        /* reduce ratio to acceptable values */
+        while (((n % 5) == 0) && ((d % 5) == 0)) {
+                n /= 5;
+                d /= 5;
+        }
+
+        while (((n % 2) == 0) && ((d % 2) == 0)) {
+                n /= 2;
+                d /= 2;
+        }
+
+        while (n > 0xffff || d > 0xffff) {
+                n >>= 1;
+                d >>= 1;
+        }
+
+        nv_debug(priv, "input frequency : %dHz\n", f);
+        nv_debug(priv, "input multiplier: %d\n", m);
+        nv_debug(priv, "numerator       : 0x%08x\n", n);
+        nv_debug(priv, "denominator     : 0x%08x\n", d);
+        nv_debug(priv, "timer frequency : %dHz\n", (f * m) * d / n);
+
+        nv_wr32(priv, NV04_PTIMER_NUMERATOR, n);
+        nv_wr32(priv, NV04_PTIMER_DENOMINATOR, d);
+        nv_wr32(priv, NV04_PTIMER_INTR_0, 0xffffffff);
+        nv_wr32(priv, NV04_PTIMER_INTR_EN_0, 0x00000000);
+        return 0;
+}
+
+static int
+nv04_timer_fini(struct nouveau_object *object, bool suspend)
+{
+        struct nv04_timer_priv *priv = (void *)object;
+        nv_wr32(priv, NV04_PTIMER_INTR_EN_0, 0x00000000);
+        return nouveau_timer_fini(&priv->base, suspend);
+}
+
+struct nouveau_oclass
+nv04_timer_oclass = {
+        .handle = NV_SUBDEV(TIMER, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_timer_ctor,
+                .dtor = nv04_timer_dtor,
+                .init = nv04_timer_init,
+                .fini = nv04_timer_fini,
+        }
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_vm.c b/drivers/gpu/drm/nouveau/core/subdev/vm/base.c
index 11edd5e91a0a..082c11b75acb 100644
--- a/drivers/gpu/drm/nouveau/nouveau_vm.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/base.c
@@ -22,22 +22,24 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_mm.h"
-#include "nouveau_vm.h"
+#include <core/gpuobj.h>
+#include <core/mm.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm.h>
 
 void
 nouveau_vm_map_at(struct nouveau_vma *vma, u64 delta, struct nouveau_mem *node)
 {
         struct nouveau_vm *vm = vma->vm;
+        struct nouveau_vmmgr *vmm = vm->vmm;
         struct nouveau_mm_node *r;
-        int big = vma->node->type != vm->spg_shift;
+        int big = vma->node->type != vmm->spg_shift;
         u32 offset = vma->node->offset + (delta >> 12);
         u32 bits = vma->node->type - 12;
-        u32 pde  = (offset >> vm->pgt_bits) - vm->fpde;
-        u32 pte  = (offset & ((1 << vm->pgt_bits) - 1)) >> bits;
-        u32 max  = 1 << (vm->pgt_bits - bits);
+        u32 pde  = (offset >> vmm->pgt_bits) - vm->fpde;
+        u32 pte  = (offset & ((1 << vmm->pgt_bits) - 1)) >> bits;
+        u32 max  = 1 << (vmm->pgt_bits - bits);
         u32 end, len;
 
         delta = 0;
@@ -53,7 +55,7 @@ nouveau_vm_map_at(struct nouveau_vma *vma, u64 delta, struct nouveau_mem *node)
                                 end = max;
                         len = end - pte;
 
-                        vm->map(vma, pgt, node, pte, len, phys, delta);
+                        vmm->map(vma, pgt, node, pte, len, phys, delta);
 
                         num -= len;
                         pte += len;
@@ -67,7 +69,7 @@ nouveau_vm_map_at(struct nouveau_vma *vma, u64 delta, struct nouveau_mem *node)
                 }
         }
 
-        vm->flush(vm);
+        vmm->flush(vm);
 }
 
 void
@@ -81,13 +83,14 @@ nouveau_vm_map_sg_table(struct nouveau_vma *vma, u64 delta, u64 length,
                         struct nouveau_mem *mem)
 {
         struct nouveau_vm *vm = vma->vm;
-        int big = vma->node->type != vm->spg_shift;
+        struct nouveau_vmmgr *vmm = vm->vmm;
+        int big = vma->node->type != vmm->spg_shift;
         u32 offset = vma->node->offset + (delta >> 12);
         u32 bits = vma->node->type - 12;
         u32 num  = length >> vma->node->type;
-        u32 pde  = (offset >> vm->pgt_bits) - vm->fpde;
-        u32 pte  = (offset & ((1 << vm->pgt_bits) - 1)) >> bits;
-        u32 max  = 1 << (vm->pgt_bits - bits);
+        u32 pde  = (offset >> vmm->pgt_bits) - vm->fpde;
+        u32 pte  = (offset & ((1 << vmm->pgt_bits) - 1)) >> bits;
+        u32 max  = 1 << (vmm->pgt_bits - bits);
         unsigned m, sglen;
         u32 end, len;
         int i;
@@ -105,7 +108,7 @@ nouveau_vm_map_sg_table(struct nouveau_vma *vma, u64 delta, u64 length,
                 for (m = 0; m < len; m++) {
                         dma_addr_t addr = sg_dma_address(sg) + (m << PAGE_SHIFT);
 
-                        vm->map_sg(vma, pgt, mem, pte, 1, &addr);
+                        vmm->map_sg(vma, pgt, mem, pte, 1, &addr);
                         num--;
                         pte++;
 
@@ -120,7 +123,7 @@ nouveau_vm_map_sg_table(struct nouveau_vma *vma, u64 delta, u64 length,
                         for (; m < sglen; m++) {
                                 dma_addr_t addr = sg_dma_address(sg) + (m << PAGE_SHIFT);
 
-                                vm->map_sg(vma, pgt, mem, pte, 1, &addr);
+                                vmm->map_sg(vma, pgt, mem, pte, 1, &addr);
                                 num--;
                                 pte++;
                                 if (num == 0)
@@ -130,7 +133,7 @@ nouveau_vm_map_sg_table(struct nouveau_vma *vma, u64 delta, u64 length,
 
         }
 finish:
-        vm->flush(vm);
+        vmm->flush(vm);
 }
 
 void
@@ -138,14 +141,15 @@ nouveau_vm_map_sg(struct nouveau_vma *vma, u64 delta, u64 length,
                   struct nouveau_mem *mem)
 {
         struct nouveau_vm *vm = vma->vm;
+        struct nouveau_vmmgr *vmm = vm->vmm;
         dma_addr_t *list = mem->pages;
-        int big = vma->node->type != vm->spg_shift;
+        int big = vma->node->type != vmm->spg_shift;
         u32 offset = vma->node->offset + (delta >> 12);
         u32 bits = vma->node->type - 12;
         u32 num  = length >> vma->node->type;
-        u32 pde  = (offset >> vm->pgt_bits) - vm->fpde;
-        u32 pte  = (offset & ((1 << vm->pgt_bits) - 1)) >> bits;
-        u32 max  = 1 << (vm->pgt_bits - bits);
+        u32 pde  = (offset >> vmm->pgt_bits) - vm->fpde;
+        u32 pte  = (offset & ((1 << vmm->pgt_bits) - 1)) >> bits;
+        u32 max  = 1 << (vmm->pgt_bits - bits);
         u32 end, len;
 
         while (num) {
@@ -156,7 +160,7 @@ nouveau_vm_map_sg(struct nouveau_vma *vma, u64 delta, u64 length,
                         end = max;
                 len = end - pte;
 
-                vm->map_sg(vma, pgt, mem, pte, len, list);
+                vmm->map_sg(vma, pgt, mem, pte, len, list);
 
                 num  -= len;
                 pte  += len;
@@ -167,20 +171,21 @@ nouveau_vm_map_sg(struct nouveau_vma *vma, u64 delta, u64 length,
                 }
         }
 
-        vm->flush(vm);
+        vmm->flush(vm);
 }
 
 void
 nouveau_vm_unmap_at(struct nouveau_vma *vma, u64 delta, u64 length)
 {
         struct nouveau_vm *vm = vma->vm;
-        int big = vma->node->type != vm->spg_shift;
+        struct nouveau_vmmgr *vmm = vm->vmm;
+        int big = vma->node->type != vmm->spg_shift;
         u32 offset = vma->node->offset + (delta >> 12);
         u32 bits = vma->node->type - 12;
         u32 num  = length >> vma->node->type;
-        u32 pde  = (offset >> vm->pgt_bits) - vm->fpde;
-        u32 pte  = (offset & ((1 << vm->pgt_bits) - 1)) >> bits;
-        u32 max  = 1 << (vm->pgt_bits - bits);
+        u32 pde  = (offset >> vmm->pgt_bits) - vm->fpde;
+        u32 pte  = (offset & ((1 << vmm->pgt_bits) - 1)) >> bits;
+        u32 max  = 1 << (vmm->pgt_bits - bits);
         u32 end, len;
 
         while (num) {
@@ -191,7 +196,7 @@ nouveau_vm_unmap_at(struct nouveau_vma *vma, u64 delta, u64 length)
                         end = max;
                 len = end - pte;
 
-                vm->unmap(pgt, pte, len);
+                vmm->unmap(pgt, pte, len);
 
                 num -= len;
                 pte += len;
@@ -201,7 +206,7 @@ nouveau_vm_unmap_at(struct nouveau_vma *vma, u64 delta, u64 length)
                 }
         }
 
-        vm->flush(vm);
+        vmm->flush(vm);
 }
 
 void
@@ -213,6 +218,7 @@ nouveau_vm_unmap(struct nouveau_vma *vma)
 static void
 nouveau_vm_unmap_pgt(struct nouveau_vm *vm, int big, u32 fpde, u32 lpde)
 {
+        struct nouveau_vmmgr *vmm = vm->vmm;
         struct nouveau_vm_pgd *vpgd;
         struct nouveau_vm_pgt *vpgt;
         struct nouveau_gpuobj *pgt;
@@ -227,7 +233,7 @@ nouveau_vm_unmap_pgt(struct nouveau_vm *vm, int big, u32 fpde, u32 lpde)
                 vpgt->obj[big] = NULL;
 
                 list_for_each_entry(vpgd, &vm->pgd_list, head) {
-                        vm->map_pgt(vpgd->obj, pde, vpgt->obj);
+                        vmm->map_pgt(vpgd->obj, pde, vpgt->obj);
                 }
 
                 mutex_unlock(&vm->mm.mutex);
@@ -239,18 +245,19 @@ nouveau_vm_unmap_pgt(struct nouveau_vm *vm, int big, u32 fpde, u32 lpde)
 static int
 nouveau_vm_map_pgt(struct nouveau_vm *vm, u32 pde, u32 type)
 {
+        struct nouveau_vmmgr *vmm = vm->vmm;
         struct nouveau_vm_pgt *vpgt = &vm->pgt[pde - vm->fpde];
         struct nouveau_vm_pgd *vpgd;
         struct nouveau_gpuobj *pgt;
-        int big = (type != vm->spg_shift);
+        int big = (type != vmm->spg_shift);
         u32 pgt_size;
         int ret;
 
-        pgt_size  = (1 << (vm->pgt_bits + 12)) >> type;
+        pgt_size  = (1 << (vmm->pgt_bits + 12)) >> type;
         pgt_size *= 8;
 
         mutex_unlock(&vm->mm.mutex);
-        ret = nouveau_gpuobj_new(vm->dev, NULL, pgt_size, 0x1000,
+        ret = nouveau_gpuobj_new(nv_object(vm->vmm), NULL, pgt_size, 0x1000,
                                  NVOBJ_FLAG_ZERO_ALLOC, &pgt);
         mutex_lock(&vm->mm.mutex);
         if (unlikely(ret))
@@ -266,7 +273,7 @@ nouveau_vm_map_pgt(struct nouveau_vm *vm, u32 pde, u32 type)
 
         vpgt->obj[big] = pgt;
         list_for_each_entry(vpgd, &vm->pgd_list, head) {
-                vm->map_pgt(vpgd->obj, pde, vpgt->obj);
+                vmm->map_pgt(vpgd->obj, pde, vpgt->obj);
         }
 
         return 0;
@@ -276,23 +283,26 @@ int
 nouveau_vm_get(struct nouveau_vm *vm, u64 size, u32 page_shift,
                u32 access, struct nouveau_vma *vma)
 {
+        struct nouveau_vmmgr *vmm = vm->vmm;
         u32 align = (1 << page_shift) >> 12;
         u32 msize = size >> 12;
         u32 fpde, lpde, pde;
         int ret;
 
         mutex_lock(&vm->mm.mutex);
-        ret = nouveau_mm_get(&vm->mm, page_shift, msize, 0, align, &vma->node);
+        ret = nouveau_mm_head(&vm->mm, page_shift, msize, msize, align,
+                             &vma->node);
         if (unlikely(ret != 0)) {
                 mutex_unlock(&vm->mm.mutex);
                 return ret;
         }
 
-        fpde = (vma->node->offset >> vm->pgt_bits);
-        lpde = (vma->node->offset + vma->node->length - 1) >> vm->pgt_bits;
+        fpde = (vma->node->offset >> vmm->pgt_bits);
+        lpde = (vma->node->offset + vma->node->length - 1) >> vmm->pgt_bits;
+
         for (pde = fpde; pde <= lpde; pde++) {
                 struct nouveau_vm_pgt *vpgt = &vm->pgt[pde - vm->fpde];
-                int big = (vma->node->type != vm->spg_shift);
+                int big = (vma->node->type != vmm->spg_shift);
 
                 if (likely(vpgt->refcount[big])) {
                         vpgt->refcount[big]++;
@@ -303,9 +313,8 @@ nouveau_vm_get(struct nouveau_vm *vm, u64 size, u32 page_shift,
                 if (ret) {
                         if (pde != fpde)
                                 nouveau_vm_unmap_pgt(vm, big, fpde, pde - 1);
-                        nouveau_mm_put(&vm->mm, vma->node);
+                        nouveau_mm_free(&vm->mm, &vma->node);
                         mutex_unlock(&vm->mm.mutex);
-                        vma->node = NULL;
                         return ret;
                 }
         }
@@ -321,91 +330,67 @@ void
 nouveau_vm_put(struct nouveau_vma *vma)
 {
         struct nouveau_vm *vm = vma->vm;
+        struct nouveau_vmmgr *vmm = vm->vmm;
         u32 fpde, lpde;
 
         if (unlikely(vma->node == NULL))
                 return;
-        fpde = (vma->node->offset >> vm->pgt_bits);
-        lpde = (vma->node->offset + vma->node->length - 1) >> vm->pgt_bits;
+        fpde = (vma->node->offset >> vmm->pgt_bits);
+        lpde = (vma->node->offset + vma->node->length - 1) >> vmm->pgt_bits;
 
         mutex_lock(&vm->mm.mutex);
-        nouveau_vm_unmap_pgt(vm, vma->node->type != vm->spg_shift, fpde, lpde);
-        nouveau_mm_put(&vm->mm, vma->node);
-        vma->node = NULL;
+        nouveau_vm_unmap_pgt(vm, vma->node->type != vmm->spg_shift, fpde, lpde);
+        nouveau_mm_free(&vm->mm, &vma->node);
         mutex_unlock(&vm->mm.mutex);
 }
 
 int
-nouveau_vm_new(struct drm_device *dev, u64 offset, u64 length, u64 mm_offset,
-               struct nouveau_vm **pvm)
+nouveau_vm_create(struct nouveau_vmmgr *vmm, u64 offset, u64 length,
+                  u64 mm_offset, u32 block, struct nouveau_vm **pvm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nouveau_vm *vm;
         u64 mm_length = (offset + length) - mm_offset;
-        u32 block, pgt_bits;
         int ret;
 
-        vm = kzalloc(sizeof(*vm), GFP_KERNEL);
+        vm = *pvm = kzalloc(sizeof(*vm), GFP_KERNEL);
         if (!vm)
                 return -ENOMEM;
 
-        if (dev_priv->card_type == NV_50) {
-                vm->map_pgt = nv50_vm_map_pgt;
-                vm->map = nv50_vm_map;
-                vm->map_sg = nv50_vm_map_sg;
-                vm->unmap = nv50_vm_unmap;
-                vm->flush = nv50_vm_flush;
-                vm->spg_shift = 12;
-                vm->lpg_shift = 16;
-
-                pgt_bits = 29;
-                block = (1 << pgt_bits);
-                if (length < block)
-                        block = length;
-
-        } else
-        if (dev_priv->card_type >= NV_C0) {
-                vm->map_pgt = nvc0_vm_map_pgt;
-                vm->map = nvc0_vm_map;
-                vm->map_sg = nvc0_vm_map_sg;
-                vm->unmap = nvc0_vm_unmap;
-                vm->flush = nvc0_vm_flush;
-                vm->spg_shift = 12;
-                vm->lpg_shift = 17;
-                pgt_bits = 27;
-                block = 4096;
-        } else {
-                kfree(vm);
-                return -ENOSYS;
-        }
+        INIT_LIST_HEAD(&vm->pgd_list);
+        vm->vmm = vmm;
+        vm->refcount = 1;
+        vm->fpde = offset >> (vmm->pgt_bits + 12);
+        vm->lpde = (offset + length - 1) >> (vmm->pgt_bits + 12);
 
-        vm->fpde   = offset >> pgt_bits;
-        vm->lpde   = (offset + length - 1) >> pgt_bits;
-        vm->pgt = kcalloc(vm->lpde - vm->fpde + 1, sizeof(*vm->pgt), GFP_KERNEL);
+        vm->pgt  = kcalloc(vm->lpde - vm->fpde + 1, sizeof(*vm->pgt), GFP_KERNEL);
         if (!vm->pgt) {
                 kfree(vm);
                 return -ENOMEM;
         }
 
-        INIT_LIST_HEAD(&vm->pgd_list);
-        vm->dev = dev;
-        vm->refcount = 1;
-        vm->pgt_bits = pgt_bits - 12;
-
         ret = nouveau_mm_init(&vm->mm, mm_offset >> 12, mm_length >> 12,
                               block >> 12);
         if (ret) {
+                kfree(vm->pgt);
                 kfree(vm);
                 return ret;
         }
 
-        *pvm = vm;
         return 0;
 }
 
+int
+nouveau_vm_new(struct nouveau_device *device, u64 offset, u64 length,
+               u64 mm_offset, struct nouveau_vm **pvm)
+{
+        struct nouveau_vmmgr *vmm = nouveau_vmmgr(device);
+        return vmm->create(vmm, offset, length, mm_offset, pvm);
+}
+
 static int
 nouveau_vm_link(struct nouveau_vm *vm, struct nouveau_gpuobj *pgd)
 {
+        struct nouveau_vmmgr *vmm = vm->vmm;
         struct nouveau_vm_pgd *vpgd;
         int i;
 
@@ -420,7 +405,7 @@ nouveau_vm_link(struct nouveau_vm *vm, struct nouveau_gpuobj *pgd)
 
         mutex_lock(&vm->mm.mutex);
         for (i = vm->fpde; i <= vm->lpde; i++)
-                vm->map_pgt(pgd, i, vm->pgt[i - vm->fpde].obj);
+                vmm->map_pgt(pgd, i, vm->pgt[i - vm->fpde].obj);
         list_add(&vpgd->head, &vm->pgd_list);
         mutex_unlock(&vm->mm.mutex);
         return 0;
diff --git a/drivers/gpu/drm/nouveau/core/subdev/vm/nv04.c b/drivers/gpu/drm/nouveau/core/subdev/vm/nv04.c
new file mode 100644
index 000000000000..6adbbc9cc361
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/nv04.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+
+#include "nv04.h"
+
+#define NV04_PDMA_SIZE (128 * 1024 * 1024)
+#define NV04_PDMA_PAGE (  4 * 1024)
+
+/*******************************************************************************
+ * VM map/unmap callbacks
+ ******************************************************************************/
+
+static void
+nv04_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
+               struct nouveau_mem *mem, u32 pte, u32 cnt, dma_addr_t *list)
+{
+        pte = 0x00008 + (pte * 4);
+        while (cnt) {
+                u32 page = PAGE_SIZE / NV04_PDMA_PAGE;
+                u32 phys = (u32)*list++;
+                while (cnt && page--) {
+                        nv_wo32(pgt, pte, phys | 3);
+                        phys += NV04_PDMA_PAGE;
+                        pte += 4;
+                        cnt -= 1;
+                }
+        }
+}
+
+static void
+nv04_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
+{
+        pte = 0x00008 + (pte * 4);
+        while (cnt--) {
+                nv_wo32(pgt, pte, 0x00000000);
+                pte += 4;
+        }
+}
+
+static void
+nv04_vm_flush(struct nouveau_vm *vm)
+{
+}
+
+/*******************************************************************************
+ * VM object
+ ******************************************************************************/
+
+int
+nv04_vm_create(struct nouveau_vmmgr *vmm, u64 offset, u64 length, u64 mmstart,
+               struct nouveau_vm **pvm)
+{
+        return -EINVAL;
+}
+
+/*******************************************************************************
+ * VMMGR subdev
+ ******************************************************************************/
+
+static int
+nv04_vmmgr_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv04_vmmgr_priv *priv;
+        struct nouveau_gpuobj *dma;
+        int ret;
+
+        ret = nouveau_vmmgr_create(parent, engine, oclass, "PCIGART",
+                                   "pcigart", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.create = nv04_vm_create;
+        priv->base.limit = NV04_PDMA_SIZE;
+        priv->base.dma_bits = 32;
+        priv->base.pgt_bits = 32 - 12;
+        priv->base.spg_shift = 12;
+        priv->base.lpg_shift = 12;
+        priv->base.map_sg = nv04_vm_map_sg;
+        priv->base.unmap = nv04_vm_unmap;
+        priv->base.flush = nv04_vm_flush;
+
+        ret = nouveau_vm_create(&priv->base, 0, NV04_PDMA_SIZE, 0, 4096,
+                                &priv->vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL,
+                                 (NV04_PDMA_SIZE / NV04_PDMA_PAGE) * 4 +
+                                 8, 16, NVOBJ_FLAG_ZERO_ALLOC,
+                                 &priv->vm->pgt[0].obj[0]);
+        dma = priv->vm->pgt[0].obj[0];
+        priv->vm->pgt[0].refcount[0] = 1;
+        if (ret)
+                return ret;
+
+        nv_wo32(dma, 0x00000, 0x0002103d); /* PCI, RW, PT, !LN */
+        nv_wo32(dma, 0x00004, NV04_PDMA_SIZE - 1);
+        return 0;
+}
+
+void
+nv04_vmmgr_dtor(struct nouveau_object *object)
+{
+        struct nv04_vmmgr_priv *priv = (void *)object;
+        if (priv->vm) {
+                nouveau_gpuobj_ref(NULL, &priv->vm->pgt[0].obj[0]);
+                nouveau_vm_ref(NULL, &priv->vm, NULL);
+        }
+        if (priv->nullp) {
+                pci_free_consistent(nv_device(priv)->pdev, 16 * 1024,
+                                    priv->nullp, priv->null);
+        }
+        nouveau_vmmgr_destroy(&priv->base);
+}
+
+struct nouveau_oclass
+nv04_vmmgr_oclass = {
+        .handle = NV_SUBDEV(VM, 0x04),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv04_vmmgr_ctor,
+                .dtor = nv04_vmmgr_dtor,
+                .init = _nouveau_vmmgr_init,
+                .fini = _nouveau_vmmgr_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/vm/nv04.h b/drivers/gpu/drm/nouveau/core/subdev/vm/nv04.h
new file mode 100644
index 000000000000..ec42d4bc86a6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/nv04.h
@@ -0,0 +1,19 @@
+#ifndef __NV04_VMMGR_PRIV__
+#define __NV04_VMMGR_PRIV__
+
+#include <subdev/vm.h>
+
+struct nv04_vmmgr_priv {
+        struct nouveau_vmmgr base;
+        struct nouveau_vm *vm;
+        dma_addr_t null;
+        void *nullp;
+};
+
+static inline struct nv04_vmmgr_priv *
+nv04_vmmgr(void *obj)
+{
+        return (void *)nouveau_vmmgr(obj);
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/core/subdev/vm/nv41.c b/drivers/gpu/drm/nouveau/core/subdev/vm/nv41.c
new file mode 100644
index 000000000000..0203e1e12caa
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/nv41.c
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+#include <core/option.h>
+
+#include <subdev/timer.h>
+#include <subdev/vm.h>
+
+#include "nv04.h"
+
+#define NV41_GART_SIZE (512 * 1024 * 1024)
+#define NV41_GART_PAGE (  4 * 1024)
+
+/*******************************************************************************
+ * VM map/unmap callbacks
+ ******************************************************************************/
+
+static void
+nv41_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
+               struct nouveau_mem *mem, u32 pte, u32 cnt, dma_addr_t *list)
+{
+        pte = pte * 4;
+        while (cnt) {
+                u32 page = PAGE_SIZE / NV41_GART_PAGE;
+                u64 phys = (u64)*list++;
+                while (cnt && page--) {
+                        nv_wo32(pgt, pte, (phys >> 7) | 1);
+                        phys += NV41_GART_PAGE;
+                        pte += 4;
+                        cnt -= 1;
+                }
+        }
+}
+
+static void
+nv41_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
+{
+        pte = pte * 4;
+        while (cnt--) {
+                nv_wo32(pgt, pte, 0x00000000);
+                pte += 4;
+        }
+}
+
+static void
+nv41_vm_flush(struct nouveau_vm *vm)
+{
+        struct nv04_vm_priv *priv = (void *)vm->vmm;
+
+        mutex_lock(&nv_subdev(priv)->mutex);
+        nv_wr32(priv, 0x100810, 0x00000022);
+        if (!nv_wait(priv, 0x100810, 0x00000020, 0x00000020)) {
+                nv_warn(priv, "flush timeout, 0x%08x\n",
+                        nv_rd32(priv, 0x100810));
+        }
+        nv_wr32(priv, 0x100810, 0x00000000);
+        mutex_unlock(&nv_subdev(priv)->mutex);
+}
+
+/*******************************************************************************
+ * VMMGR subdev
+ ******************************************************************************/
+
+static int
+nv41_vmmgr_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nv04_vmmgr_priv *priv;
+        int ret;
+
+        if (!nouveau_boolopt(device->cfgopt, "NvPCIE", true)) {
+                return nouveau_object_ctor(parent, engine, &nv04_vmmgr_oclass,
+                                           data, size, pobject);
+        }
+
+        ret = nouveau_vmmgr_create(parent, engine, oclass, "PCIEGART",
+                                   "pciegart", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.create = nv04_vm_create;
+        priv->base.limit = NV41_GART_SIZE;
+        priv->base.dma_bits = 39;
+        priv->base.pgt_bits = 32 - 12;
+        priv->base.spg_shift = 12;
+        priv->base.lpg_shift = 12;
+        priv->base.map_sg = nv41_vm_map_sg;
+        priv->base.unmap = nv41_vm_unmap;
+        priv->base.flush = nv41_vm_flush;
+
+        ret = nouveau_vm_create(&priv->base, 0, NV41_GART_SIZE, 0, 4096,
+                                &priv->vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL,
+                                (NV41_GART_SIZE / NV41_GART_PAGE) * 4,
+                                 16, NVOBJ_FLAG_ZERO_ALLOC,
+                                 &priv->vm->pgt[0].obj[0]);
+        priv->vm->pgt[0].refcount[0] = 1;
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv41_vmmgr_init(struct nouveau_object *object)
+{
+        struct nv04_vmmgr_priv *priv = (void *)object;
+        struct nouveau_gpuobj *dma = priv->vm->pgt[0].obj[0];
+        int ret;
+
+        ret = nouveau_vmmgr_init(&priv->base);
+        if (ret)
+                return ret;
+
+        nv_wr32(priv, 0x100800, dma->addr | 0x00000002);
+        nv_mask(priv, 0x10008c, 0x00000100, 0x00000100);
+        nv_wr32(priv, 0x100820, 0x00000000);
+        return 0;
+}
+
+struct nouveau_oclass
+nv41_vmmgr_oclass = {
+        .handle = NV_SUBDEV(VM, 0x41),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv41_vmmgr_ctor,
+                .dtor = nv04_vmmgr_dtor,
+                .init = nv41_vmmgr_init,
+                .fini = _nouveau_vmmgr_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/core/subdev/vm/nv44.c b/drivers/gpu/drm/nouveau/core/subdev/vm/nv44.c
new file mode 100644
index 000000000000..0ac18d05a146
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/nv44.c
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2012 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 <core/gpuobj.h>
+#include <core/option.h>
+
+#include <subdev/timer.h>
+#include <subdev/vm.h>
+
+#include "nv04.h"
+
+#define NV44_GART_SIZE (512 * 1024 * 1024)
+#define NV44_GART_PAGE (  4 * 1024)
+
+/*******************************************************************************
+ * VM map/unmap callbacks
+ ******************************************************************************/
+
+static void
+nv44_vm_fill(struct nouveau_gpuobj *pgt, dma_addr_t null,
+             dma_addr_t *list, u32 pte, u32 cnt)
+{
+        u32 base = (pte << 2) & ~0x0000000f;
+        u32 tmp[4];
+
+        tmp[0] = nv_ro32(pgt, base + 0x0);
+        tmp[1] = nv_ro32(pgt, base + 0x4);
+        tmp[2] = nv_ro32(pgt, base + 0x8);
+        tmp[3] = nv_ro32(pgt, base + 0xc);
+
+        while (cnt--) {
+                u32 addr = list ? (*list++ >> 12) : (null >> 12);
+                switch (pte++ & 0x3) {
+                case 0:
+                        tmp[0] &= ~0x07ffffff;
+                        tmp[0] |= addr;
+                        break;
+                case 1:
+                        tmp[0] &= ~0xf8000000;
+                        tmp[0] |= addr << 27;
+                        tmp[1] &= ~0x003fffff;
+                        tmp[1] |= addr >> 5;
+                        break;
+                case 2:
+                        tmp[1] &= ~0xffc00000;
+                        tmp[1] |= addr << 22;
+                        tmp[2] &= ~0x0001ffff;
+                        tmp[2] |= addr >> 10;
+                        break;
+                case 3:
+                        tmp[2] &= ~0xfffe0000;
+                        tmp[2] |= addr << 17;
+                        tmp[3] &= ~0x00000fff;
+                        tmp[3] |= addr >> 15;
+                        break;
+                }
+        }
+
+        nv_wo32(pgt, base + 0x0, tmp[0]);
+        nv_wo32(pgt, base + 0x4, tmp[1]);
+        nv_wo32(pgt, base + 0x8, tmp[2]);
+        nv_wo32(pgt, base + 0xc, tmp[3] | 0x40000000);
+}
+
+static void
+nv44_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
+               struct nouveau_mem *mem, u32 pte, u32 cnt, dma_addr_t *list)
+{
+        struct nv04_vmmgr_priv *priv = (void *)vma->vm->vmm;
+        u32 tmp[4];
+        int i;
+
+        if (pte & 3) {
+                u32  max = 4 - (pte & 3);
+                u32 part = (cnt > max) ? max : cnt;
+                nv44_vm_fill(pgt, priv->null, list, pte, part);
+                pte  += part;
+                list += part;
+                cnt  -= part;
+        }
+
+        while (cnt >= 4) {
+                for (i = 0; i < 4; i++)
+                        tmp[i] = *list++ >> 12;
+                nv_wo32(pgt, pte++ * 4, tmp[0] >>  0 | tmp[1] << 27);
+                nv_wo32(pgt, pte++ * 4, tmp[1] >>  5 | tmp[2] << 22);
+                nv_wo32(pgt, pte++ * 4, tmp[2] >> 10 | tmp[3] << 17);
+                nv_wo32(pgt, pte++ * 4, tmp[3] >> 15 | 0x40000000);
+                cnt -= 4;
+        }
+
+        if (cnt)
+                nv44_vm_fill(pgt, priv->null, list, pte, cnt);
+}
+
+static void
+nv44_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
+{
+        struct nv04_vmmgr_priv *priv = (void *)nouveau_vmmgr(pgt);
+
+        if (pte & 3) {
+                u32  max = 4 - (pte & 3);
+                u32 part = (cnt > max) ? max : cnt;
+                nv44_vm_fill(pgt, priv->null, NULL, pte, part);
+                pte  += part;
+                cnt  -= part;
+        }
+
+        while (cnt >= 4) {
+                nv_wo32(pgt, pte++ * 4, 0x00000000);
+                nv_wo32(pgt, pte++ * 4, 0x00000000);
+                nv_wo32(pgt, pte++ * 4, 0x00000000);
+                nv_wo32(pgt, pte++ * 4, 0x00000000);
+                cnt -= 4;
+        }
+
+        if (cnt)
+                nv44_vm_fill(pgt, priv->null, NULL, pte, cnt);
+}
+
+static void
+nv44_vm_flush(struct nouveau_vm *vm)
+{
+        struct nv04_vmmgr_priv *priv = (void *)vm->vmm;
+        nv_wr32(priv, 0x100814, priv->base.limit - NV44_GART_PAGE);
+        nv_wr32(priv, 0x100808, 0x00000020);
+        if (!nv_wait(priv, 0x100808, 0x00000001, 0x00000001))
+                nv_error(priv, "timeout: 0x%08x\n", nv_rd32(priv, 0x100808));
+        nv_wr32(priv, 0x100808, 0x00000000);
+}
+
+/*******************************************************************************
+ * VMMGR subdev
+ ******************************************************************************/
+
+static int
+nv44_vmmgr_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nouveau_device *device = nv_device(parent);
+        struct nv04_vmmgr_priv *priv;
+        int ret;
+
+        if (!nouveau_boolopt(device->cfgopt, "NvPCIE", true)) {
+                return nouveau_object_ctor(parent, engine, &nv04_vmmgr_oclass,
+                                           data, size, pobject);
+        }
+
+        ret = nouveau_vmmgr_create(parent, engine, oclass, "PCIEGART",
+                                   "pciegart", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.create = nv04_vm_create;
+        priv->base.limit = NV44_GART_SIZE;
+        priv->base.dma_bits = 39;
+        priv->base.pgt_bits = 32 - 12;
+        priv->base.spg_shift = 12;
+        priv->base.lpg_shift = 12;
+        priv->base.map_sg = nv44_vm_map_sg;
+        priv->base.unmap = nv44_vm_unmap;
+        priv->base.flush = nv44_vm_flush;
+
+        priv->nullp = pci_alloc_consistent(device->pdev, 16 * 1024, &priv->null);
+        if (!priv->nullp) {
+                nv_error(priv, "unable to allocate dummy pages\n");
+                return -ENOMEM;
+        }
+
+        ret = nouveau_vm_create(&priv->base, 0, NV44_GART_SIZE, 0, 4096,
+                                &priv->vm);
+        if (ret)
+                return ret;
+
+        ret = nouveau_gpuobj_new(parent, NULL,
+                                (NV44_GART_SIZE / NV44_GART_PAGE) * 4,
+                                 512 * 1024, NVOBJ_FLAG_ZERO_ALLOC,
+                                 &priv->vm->pgt[0].obj[0]);
+        priv->vm->pgt[0].refcount[0] = 1;
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int
+nv44_vmmgr_init(struct nouveau_object *object)
+{
+        struct nv04_vmmgr_priv *priv = (void *)object;
+        struct nouveau_gpuobj *gart = priv->vm->pgt[0].obj[0];
+        u32 addr;
+        int ret;
+
+        ret = nouveau_vmmgr_init(&priv->base);
+        if (ret)
+                return ret;
+
+        /* calculate vram address of this PRAMIN block, object must be
+         * allocated on 512KiB alignment, and not exceed a total size
+         * of 512KiB for this to work correctly
+         */
+        addr  = nv_rd32(priv, 0x10020c);
+        addr -= ((gart->addr >> 19) + 1) << 19;
+
+        nv_wr32(priv, 0x100850, 0x80000000);
+        nv_wr32(priv, 0x100818, priv->null);
+        nv_wr32(priv, 0x100804, NV44_GART_SIZE);
+        nv_wr32(priv, 0x100850, 0x00008000);
+        nv_mask(priv, 0x10008c, 0x00000200, 0x00000200);
+        nv_wr32(priv, 0x100820, 0x00000000);
+        nv_wr32(priv, 0x10082c, 0x00000001);
+        nv_wr32(priv, 0x100800, addr | 0x00000010);
+        return 0;
+}
+
+struct nouveau_oclass
+nv44_vmmgr_oclass = {
+        .handle = NV_SUBDEV(VM, 0x44),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv44_vmmgr_ctor,
+                .dtor = nv04_vmmgr_dtor,
+                .init = nv44_vmmgr_init,
+                .fini = _nouveau_vmmgr_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nv50_vm.c b/drivers/gpu/drm/nouveau/core/subdev/vm/nv50.c
index 179bb42a635c..e067f81c97b3 100644
--- a/drivers/gpu/drm/nouveau/nv50_vm.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/nv50.c
@@ -22,12 +22,19 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
+#include <core/device.h>
+#include <core/gpuobj.h>
 
-#include "nouveau_drv.h"
-#include "nouveau_vm.h"
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/vm.h>
 
-void
+struct nv50_vmmgr_priv {
+        struct nouveau_vmmgr base;
+        spinlock_t lock;
+};
+
+static void
 nv50_vm_map_pgt(struct nouveau_gpuobj *pgd, u32 pde,
                 struct nouveau_gpuobj *pgt[2])
 {
@@ -35,11 +42,11 @@ nv50_vm_map_pgt(struct nouveau_gpuobj *pgd, u32 pde,
         u32 coverage = 0;
 
         if (pgt[0]) {
-                phys = 0x00000003 | pgt[0]->vinst; /* present, 4KiB pages */
+                phys = 0x00000003 | pgt[0]->addr; /* present, 4KiB pages */
                 coverage = (pgt[0]->size >> 3) << 12;
         } else
         if (pgt[1]) {
-                phys = 0x00000001 | pgt[1]->vinst; /* present */
+                phys = 0x00000001 | pgt[1]->addr; /* present */
                 coverage = (pgt[1]->size >> 3) << 16;
         }
 
@@ -69,19 +76,18 @@ vm_addr(struct nouveau_vma *vma, u64 phys, u32 memtype, u32 target)
         return phys;
 }
 
-void
+static void
 nv50_vm_map(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
             struct nouveau_mem *mem, u32 pte, u32 cnt, u64 phys, u64 delta)
 {
-        struct drm_nouveau_private *dev_priv = vma->vm->dev->dev_private;
         u32 comp = (mem->memtype & 0x180) >> 7;
         u32 block, target;
         int i;
 
         /* IGPs don't have real VRAM, re-target to stolen system memory */
         target = 0;
-        if (dev_priv->vram_sys_base) {
-                phys += dev_priv->vram_sys_base;
+        if (nouveau_fb(vma->vm->vmm)->ram.stolen) {
+                phys += nouveau_fb(vma->vm->vmm)->ram.stolen;
                 target = 3;
         }
 
@@ -103,7 +109,7 @@ nv50_vm_map(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
                 phys += block << (vma->node->type - 3);
                 cnt  -= block;
                 if (comp) {
-                        u32 tag = mem->tag->start + ((delta >> 16) * comp);
+                        u32 tag = mem->tag->offset + ((delta >> 16) * comp);
                         offset_h |= (tag << 17);
                         delta    += block << (vma->node->type - 3);
                 }
@@ -117,7 +123,7 @@ nv50_vm_map(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
         }
 }
 
-void
+static void
 nv50_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
                struct nouveau_mem *mem, u32 pte, u32 cnt, dma_addr_t *list)
 {
@@ -131,7 +137,7 @@ nv50_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
         }
 }
 
-void
+static void
 nv50_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
 {
         pte <<= 3;
@@ -142,36 +148,80 @@ nv50_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
         }
 }
 
-void
+static void
 nv50_vm_flush(struct nouveau_vm *vm)
 {
-        struct drm_nouveau_private *dev_priv = vm->dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
+        struct nouveau_engine *engine;
         int i;
 
-        pinstmem->flush(vm->dev);
-
-        /* BAR */
-        if (vm == dev_priv->bar1_vm || vm == dev_priv->bar3_vm) {
-                nv50_vm_flush_engine(vm->dev, 6);
-                return;
-        }
-
-        for (i = 0; i < NVOBJ_ENGINE_NR; i++) {
-                if (atomic_read(&vm->engref[i]))
-                        dev_priv->eng[i]->tlb_flush(vm->dev, i);
+        for (i = 0; i < NVDEV_SUBDEV_NR; i++) {
+                if (atomic_read(&vm->engref[i])) {
+                        engine = nouveau_engine(vm->vmm, i);
+                        if (engine && engine->tlb_flush)
+                                engine->tlb_flush(engine);
+                }
         }
 }
 
 void
-nv50_vm_flush_engine(struct drm_device *dev, int engine)
+nv50_vm_flush_engine(struct nouveau_subdev *subdev, int engine)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nv50_vmmgr_priv *priv = (void *)nouveau_vmmgr(subdev);
         unsigned long flags;
 
-        spin_lock_irqsave(&dev_priv->vm_lock, flags);
-        nv_wr32(dev, 0x100c80, (engine << 16) | 1);
-        if (!nv_wait(dev, 0x100c80, 0x00000001, 0x00000000))
-                NV_ERROR(dev, "vm flush timeout: engine %d\n", engine);
-        spin_unlock_irqrestore(&dev_priv->vm_lock, flags);
+        spin_lock_irqsave(&priv->lock, flags);
+        nv_wr32(subdev, 0x100c80, (engine << 16) | 1);
+        if (!nv_wait(subdev, 0x100c80, 0x00000001, 0x00000000))
+                nv_error(subdev, "vm flush timeout: engine %d\n", engine);
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static int
+nv50_vm_create(struct nouveau_vmmgr *vmm, u64 offset, u64 length,
+               u64 mm_offset, struct nouveau_vm **pvm)
+{
+        u32 block = (1 << (vmm->pgt_bits + 12));
+        if (block > length)
+                block = length;
+
+        return nouveau_vm_create(vmm, offset, length, mm_offset, block, pvm);
 }
+
+static int
+nv50_vmmgr_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nv50_vmmgr_priv *priv;
+        int ret;
+
+        ret = nouveau_vmmgr_create(parent, engine, oclass, "VM", "vm", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.limit = 1ULL << 40;
+        priv->base.dma_bits = 40;
+        priv->base.pgt_bits  = 29 - 12;
+        priv->base.spg_shift = 12;
+        priv->base.lpg_shift = 16;
+        priv->base.create = nv50_vm_create;
+        priv->base.map_pgt = nv50_vm_map_pgt;
+        priv->base.map = nv50_vm_map;
+        priv->base.map_sg = nv50_vm_map_sg;
+        priv->base.unmap = nv50_vm_unmap;
+        priv->base.flush = nv50_vm_flush;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+struct nouveau_oclass
+nv50_vmmgr_oclass = {
+        .handle = NV_SUBDEV(VM, 0x50),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nv50_vmmgr_ctor,
+                .dtor = _nouveau_vmmgr_dtor,
+                .init = _nouveau_vmmgr_init,
+                .fini = _nouveau_vmmgr_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nvc0_vm.c b/drivers/gpu/drm/nouveau/core/subdev/vm/nvc0.c
index 30d2bd58828f..30c61e6c2017 100644
--- a/drivers/gpu/drm/nouveau/nvc0_vm.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/vm/nvc0.c
@@ -22,21 +22,28 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
+#include <core/device.h>
+#include <core/gpuobj.h>
 
-#include "nouveau_drv.h"
-#include "nouveau_vm.h"
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+#include <subdev/vm.h>
 
-void
+struct nvc0_vmmgr_priv {
+        struct nouveau_vmmgr base;
+        spinlock_t lock;
+};
+
+static void
 nvc0_vm_map_pgt(struct nouveau_gpuobj *pgd, u32 index,
                 struct nouveau_gpuobj *pgt[2])
 {
         u32 pde[2] = { 0, 0 };
 
         if (pgt[0])
-                pde[1] = 0x00000001 | (pgt[0]->vinst >> 8);
+                pde[1] = 0x00000001 | (pgt[0]->addr >> 8);
         if (pgt[1])
-                pde[0] = 0x00000001 | (pgt[1]->vinst >> 8);
+                pde[0] = 0x00000001 | (pgt[1]->addr >> 8);
 
         nv_wo32(pgd, (index * 8) + 0, pde[0]);
         nv_wo32(pgd, (index * 8) + 4, pde[1]);
@@ -57,7 +64,7 @@ nvc0_vm_addr(struct nouveau_vma *vma, u64 phys, u32 memtype, u32 target)
         return phys;
 }
 
-void
+static void
 nvc0_vm_map(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
             struct nouveau_mem *mem, u32 pte, u32 cnt, u64 phys, u64 delta)
 {
@@ -73,7 +80,7 @@ nvc0_vm_map(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
         }
 }
 
-void
+static void
 nvc0_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
                struct nouveau_mem *mem, u32 pte, u32 cnt, dma_addr_t *list)
 {
@@ -88,7 +95,7 @@ nvc0_vm_map_sg(struct nouveau_vma *vma, struct nouveau_gpuobj *pgt,
         }
 }
 
-void
+static void
 nvc0_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
 {
         pte <<= 3;
@@ -100,37 +107,83 @@ nvc0_vm_unmap(struct nouveau_gpuobj *pgt, u32 pte, u32 cnt)
 }
 
 void
-nvc0_vm_flush(struct nouveau_vm *vm)
+nvc0_vm_flush_engine(struct nouveau_subdev *subdev, u64 addr, int type)
 {
-        struct drm_nouveau_private *dev_priv = vm->dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct drm_device *dev = vm->dev;
-        struct nouveau_vm_pgd *vpgd;
+        struct nvc0_vmmgr_priv *priv = (void *)nouveau_vmmgr(subdev);
         unsigned long flags;
-        u32 engine;
 
-        engine = 1;
-        if (vm == dev_priv->bar1_vm || vm == dev_priv->bar3_vm)
-                engine |= 4;
+        /* looks like maybe a "free flush slots" counter, the
+         * faster you write to 0x100cbc to more it decreases
+         */
+        spin_lock_irqsave(&priv->lock, flags);
+        if (!nv_wait_ne(subdev, 0x100c80, 0x00ff0000, 0x00000000)) {
+                nv_error(subdev, "vm timeout 0: 0x%08x %d\n",
+                         nv_rd32(subdev, 0x100c80), type);
+        }
+
+        nv_wr32(subdev, 0x100cb8, addr >> 8);
+        nv_wr32(subdev, 0x100cbc, 0x80000000 | type);
+
+        /* wait for flush to be queued? */
+        if (!nv_wait(subdev, 0x100c80, 0x00008000, 0x00008000)) {
+                nv_error(subdev, "vm timeout 1: 0x%08x %d\n",
+                         nv_rd32(subdev, 0x100c80), type);
+        }
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
 
-        pinstmem->flush(vm->dev);
+static void
+nvc0_vm_flush(struct nouveau_vm *vm)
+{
+        struct nouveau_vm_pgd *vpgd;
 
-        spin_lock_irqsave(&dev_priv->vm_lock, flags);
         list_for_each_entry(vpgd, &vm->pgd_list, head) {
-                /* looks like maybe a "free flush slots" counter, the
-                 * faster you write to 0x100cbc to more it decreases
-                 */
-                if (!nv_wait_ne(dev, 0x100c80, 0x00ff0000, 0x00000000)) {
-                        NV_ERROR(dev, "vm timeout 0: 0x%08x %d\n",
-                                 nv_rd32(dev, 0x100c80), engine);
-                }
-                nv_wr32(dev, 0x100cb8, vpgd->obj->vinst >> 8);
-                nv_wr32(dev, 0x100cbc, 0x80000000 | engine);
-                /* wait for flush to be queued? */
-                if (!nv_wait(dev, 0x100c80, 0x00008000, 0x00008000)) {
-                        NV_ERROR(dev, "vm timeout 1: 0x%08x %d\n",
-                                 nv_rd32(dev, 0x100c80), engine);
-                }
+                nvc0_vm_flush_engine(nv_subdev(vm->vmm), vpgd->obj->addr, 1);
         }
-        spin_unlock_irqrestore(&dev_priv->vm_lock, flags);
 }
+
+static int
+nvc0_vm_create(struct nouveau_vmmgr *vmm, u64 offset, u64 length,
+               u64 mm_offset, struct nouveau_vm **pvm)
+{
+        return nouveau_vm_create(vmm, offset, length, mm_offset, 4096, pvm);
+}
+
+static int
+nvc0_vmmgr_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
+                struct nouveau_oclass *oclass, void *data, u32 size,
+                struct nouveau_object **pobject)
+{
+        struct nvc0_vmmgr_priv *priv;
+        int ret;
+
+        ret = nouveau_vmmgr_create(parent, engine, oclass, "VM", "vm", &priv);
+        *pobject = nv_object(priv);
+        if (ret)
+                return ret;
+
+        priv->base.limit = 1ULL << 40;
+        priv->base.dma_bits = 40;
+        priv->base.pgt_bits  = 27 - 12;
+        priv->base.spg_shift = 12;
+        priv->base.lpg_shift = 17;
+        priv->base.create = nvc0_vm_create;
+        priv->base.map_pgt = nvc0_vm_map_pgt;
+        priv->base.map = nvc0_vm_map;
+        priv->base.map_sg = nvc0_vm_map_sg;
+        priv->base.unmap = nvc0_vm_unmap;
+        priv->base.flush = nvc0_vm_flush;
+        spin_lock_init(&priv->lock);
+        return 0;
+}
+
+struct nouveau_oclass
+nvc0_vmmgr_oclass = {
+        .handle = NV_SUBDEV(VM, 0xc0),
+        .ofuncs = &(struct nouveau_ofuncs) {
+                .ctor = nvc0_vmmgr_ctor,
+                .dtor = _nouveau_vmmgr_dtor,
+                .init = _nouveau_vmmgr_init,
+                .fini = _nouveau_vmmgr_fini,
+        },
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_abi16.c b/drivers/gpu/drm/nouveau/nouveau_abi16.c
index ff23d88880e5..cc79c796afee 100644
--- a/drivers/gpu/drm/nouveau/nouveau_abi16.c
+++ b/drivers/gpu/drm/nouveau/nouveau_abi16.c
@@ -21,23 +21,153 @@
  *
  */
 
-#include "drmP.h"
+#include <core/object.h>
+#include <core/client.h>
+#include <core/device.h>
+#include <core/class.h>
+#include <core/mm.h>
 
-#include "nouveau_drv.h"
+#include <subdev/fb.h>
+#include <subdev/timer.h>
+#include <subdev/instmem.h>
+
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
+#include "nouveau_gem.h"
+#include "nouveau_chan.h"
 #include "nouveau_abi16.h"
-#include "nouveau_ramht.h"
-#include "nouveau_software.h"
+
+struct nouveau_abi16 *
+nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev)
+{
+        struct nouveau_cli *cli = nouveau_cli(file_priv);
+        mutex_lock(&cli->mutex);
+        if (!cli->abi16) {
+                struct nouveau_abi16 *abi16;
+                cli->abi16 = abi16 = kzalloc(sizeof(*abi16), GFP_KERNEL);
+                if (cli->abi16) {
+                        INIT_LIST_HEAD(&abi16->channels);
+                        abi16->client = nv_object(cli);
+
+                        /* allocate device object targeting client's default
+                         * device (ie. the one that belongs to the fd it
+                         * opened)
+                         */
+                        if (nouveau_object_new(abi16->client, NVDRM_CLIENT,
+                                               NVDRM_DEVICE, 0x0080,
+                                               &(struct nv_device_class) {
+                                                .device = ~0ULL,
+                                               },
+                                               sizeof(struct nv_device_class),
+                                               &abi16->device) == 0)
+                                return cli->abi16;
+
+                        kfree(cli->abi16);
+                        cli->abi16 = NULL;
+                }
+
+                mutex_unlock(&cli->mutex);
+        }
+        return cli->abi16;
+}
+
+int
+nouveau_abi16_put(struct nouveau_abi16 *abi16, int ret)
+{
+        struct nouveau_cli *cli = (void *)abi16->client;
+        mutex_unlock(&cli->mutex);
+        return ret;
+}
+
+u16
+nouveau_abi16_swclass(struct nouveau_drm *drm)
+{
+        switch (nv_device(drm->device)->card_type) {
+        case NV_04:
+                return 0x006e;
+        case NV_10:
+        case NV_20:
+        case NV_30:
+        case NV_40:
+                return 0x016e;
+        case NV_50:
+                return 0x506e;
+        case NV_C0:
+        case NV_D0:
+        case NV_E0:
+                return 0x906e;
+        }
+
+        return 0x0000;
+}
+
+static void
+nouveau_abi16_ntfy_fini(struct nouveau_abi16_chan *chan,
+                        struct nouveau_abi16_ntfy *ntfy)
+{
+        nouveau_mm_free(&chan->heap, &ntfy->node);
+        list_del(&ntfy->head);
+        kfree(ntfy);
+}
+
+static void
+nouveau_abi16_chan_fini(struct nouveau_abi16 *abi16,
+                        struct nouveau_abi16_chan *chan)
+{
+        struct nouveau_abi16_ntfy *ntfy, *temp;
+
+        /* cleanup notifier state */
+        list_for_each_entry_safe(ntfy, temp, &chan->notifiers, head) {
+                nouveau_abi16_ntfy_fini(chan, ntfy);
+        }
+
+        if (chan->ntfy) {
+                nouveau_bo_vma_del(chan->ntfy, &chan->ntfy_vma);
+                drm_gem_object_unreference_unlocked(chan->ntfy->gem);
+        }
+
+        if (chan->heap.block_size)
+                nouveau_mm_fini(&chan->heap);
+
+        /* destroy channel object, all children will be killed too */
+        if (chan->chan) {
+                abi16->handles &= ~(1 << (chan->chan->handle & 0xffff));
+                nouveau_channel_del(&chan->chan);
+        }
+
+        list_del(&chan->head);
+        kfree(chan);
+}
+
+void
+nouveau_abi16_fini(struct nouveau_abi16 *abi16)
+{
+        struct nouveau_cli *cli = (void *)abi16->client;
+        struct nouveau_abi16_chan *chan, *temp;
+
+        /* cleanup channels */
+        list_for_each_entry_safe(chan, temp, &abi16->channels, head) {
+                nouveau_abi16_chan_fini(abi16, chan);
+        }
+
+        /* destroy the device object */
+        nouveau_object_del(abi16->client, NVDRM_CLIENT, NVDRM_DEVICE);
+
+        kfree(cli->abi16);
+        cli->abi16 = NULL;
+}
 
 int
 nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_timer *ptimer = nouveau_timer(device);
         struct drm_nouveau_getparam *getparam = data;
 
         switch (getparam->param) {
         case NOUVEAU_GETPARAM_CHIPSET_ID:
-                getparam->value = dev_priv->chipset;
+                getparam->value = device->chipset;
                 break;
         case NOUVEAU_GETPARAM_PCI_VENDOR:
                 getparam->value = dev->pci_vendor;
@@ -55,16 +185,16 @@ nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
                         getparam->value = 2;
                 break;
         case NOUVEAU_GETPARAM_FB_SIZE:
-                getparam->value = dev_priv->fb_available_size;
+                getparam->value = drm->gem.vram_available;
                 break;
         case NOUVEAU_GETPARAM_AGP_SIZE:
-                getparam->value = dev_priv->gart_info.aper_size;
+                getparam->value = drm->gem.gart_available;
                 break;
         case NOUVEAU_GETPARAM_VM_VRAM_BASE:
                 getparam->value = 0; /* deprecated */
                 break;
         case NOUVEAU_GETPARAM_PTIMER_TIME:
-                getparam->value = dev_priv->engine.timer.read(dev);
+                getparam->value = ptimer->read(ptimer);
                 break;
         case NOUVEAU_GETPARAM_HAS_BO_USAGE:
                 getparam->value = 1;
@@ -76,13 +206,13 @@ nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
                 /* NV40 and NV50 versions are quite different, but register
                  * address is the same. User is supposed to know the card
                  * family anyway... */
-                if (dev_priv->chipset >= 0x40) {
-                        getparam->value = nv_rd32(dev, NV40_PMC_GRAPH_UNITS);
+                if (device->chipset >= 0x40) {
+                        getparam->value = nv_rd32(device, 0x001540);
                         break;
                 }
                 /* FALLTHRU */
         default:
-                NV_DEBUG(dev, "unknown parameter %lld\n", getparam->param);
+                nv_debug(device, "unknown parameter %lld\n", getparam->param);
                 return -EINVAL;
         }
 
@@ -98,148 +228,252 @@ nouveau_abi16_ioctl_setparam(ABI16_IOCTL_ARGS)
 int
 nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct drm_nouveau_channel_alloc *init = data;
-        struct nouveau_channel *chan;
+        struct nouveau_cli *cli = nouveau_cli(file_priv);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
+        struct nouveau_abi16_chan *chan;
+        struct nouveau_client *client;
+        struct nouveau_device *device;
+        struct nouveau_instmem *imem;
+        struct nouveau_fb *pfb;
         int ret;
 
-        if (!dev_priv->eng[NVOBJ_ENGINE_GR])
-                return -ENODEV;
+        if (unlikely(!abi16))
+                return -ENOMEM;
+        client = nv_client(abi16->client);
 
         if (init->fb_ctxdma_handle == ~0 || init->tt_ctxdma_handle == ~0)
-                return -EINVAL;
+                return nouveau_abi16_put(abi16, -EINVAL);
+
+        device = nv_device(abi16->device);
+        imem   = nouveau_instmem(device);
+        pfb    = nouveau_fb(device);
+
+        /* allocate "abi16 channel" data and make up a handle for it */
+        init->channel = ffsll(~abi16->handles);
+        if (!init->channel--)
+                return nouveau_abi16_put(abi16, -ENOSPC);
+
+        chan = kzalloc(sizeof(*chan), GFP_KERNEL);
+        if (!chan)
+                return nouveau_abi16_put(abi16, -ENOMEM);
+
+        INIT_LIST_HEAD(&chan->notifiers);
+        list_add(&chan->head, &abi16->channels);
+        abi16->handles |= (1 << init->channel);
+
+        /* create channel object and initialise dma and fence management */
+        if (device->card_type >= NV_E0) {
+                init->fb_ctxdma_handle = NVE0_CHANNEL_IND_ENGINE_GR;
+                init->tt_ctxdma_handle = 0;
+        }
 
-        ret = nouveau_channel_alloc(dev, &chan, file_priv,
-                                    init->fb_ctxdma_handle,
-                                    init->tt_ctxdma_handle);
+        ret = nouveau_channel_new(drm, cli, NVDRM_DEVICE, NVDRM_CHAN |
+                                  init->channel, init->fb_ctxdma_handle,
+                                  init->tt_ctxdma_handle, &chan->chan);
         if (ret)
-                return ret;
-        init->channel  = chan->id;
-
-        if (nouveau_vram_pushbuf == 0) {
-                if (chan->dma.ib_max)
-                        init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM |
-                                                NOUVEAU_GEM_DOMAIN_GART;
-                else if (chan->pushbuf_bo->bo.mem.mem_type == TTM_PL_VRAM)
-                        init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM;
-                else
-                        init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_GART;
-        } else {
+                goto done;
+
+        if (device->card_type >= NV_50)
+                init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM |
+                                        NOUVEAU_GEM_DOMAIN_GART;
+        else
+        if (chan->chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM)
                 init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM;
-        }
+        else
+                init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_GART;
 
-        if (dev_priv->card_type < NV_C0) {
+        if (device->card_type < NV_C0) {
                 init->subchan[0].handle = 0x00000000;
                 init->subchan[0].grclass = 0x0000;
                 init->subchan[1].handle = NvSw;
-                init->subchan[1].grclass = NV_SW;
+                init->subchan[1].grclass = 0x506e;
                 init->nr_subchan = 2;
         }
 
         /* Named memory object area */
-        ret = drm_gem_handle_create(file_priv, chan->notifier_bo->gem,
+        ret = nouveau_gem_new(dev, PAGE_SIZE, 0, NOUVEAU_GEM_DOMAIN_GART,
+                              0, 0, &chan->ntfy);
+        if (ret == 0)
+                ret = nouveau_bo_pin(chan->ntfy, TTM_PL_FLAG_TT);
+        if (ret)
+                goto done;
+
+        if (device->card_type >= NV_50) {
+                ret = nouveau_bo_vma_add(chan->ntfy, client->vm,
+                                        &chan->ntfy_vma);
+                if (ret)
+                        goto done;
+        }
+
+        ret = drm_gem_handle_create(file_priv, chan->ntfy->gem,
                                     &init->notifier_handle);
+        if (ret)
+                goto done;
 
-        if (ret == 0)
-                atomic_inc(&chan->users); /* userspace reference */
-        nouveau_channel_put(&chan);
-        return ret;
+        ret = nouveau_mm_init(&chan->heap, 0, PAGE_SIZE, 1);
+done:
+        if (ret)
+                nouveau_abi16_chan_fini(abi16, chan);
+        return nouveau_abi16_put(abi16, ret);
 }
 
+
 int
 nouveau_abi16_ioctl_channel_free(ABI16_IOCTL_ARGS)
 {
         struct drm_nouveau_channel_free *req = data;
-        struct nouveau_channel *chan;
+        struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
+        struct nouveau_abi16_chan *chan;
+        int ret = -ENOENT;
 
-        chan = nouveau_channel_get(file_priv, req->channel);
-        if (IS_ERR(chan))
-                return PTR_ERR(chan);
+        if (unlikely(!abi16))
+                return -ENOMEM;
 
-        list_del(&chan->list);
-        atomic_dec(&chan->users);
-        nouveau_channel_put(&chan);
-        return 0;
+        list_for_each_entry(chan, &abi16->channels, head) {
+                if (chan->chan->handle == (NVDRM_CHAN | req->channel)) {
+                        nouveau_abi16_chan_fini(abi16, chan);
+                        return nouveau_abi16_put(abi16, 0);
+                }
+        }
+
+        return nouveau_abi16_put(abi16, ret);
 }
 
 int
 nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS)
 {
         struct drm_nouveau_grobj_alloc *init = data;
-        struct nouveau_channel *chan;
+        struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_object *object;
         int ret;
 
+        if (unlikely(!abi16))
+                return -ENOMEM;
+
         if (init->handle == ~0)
-                return -EINVAL;
+                return nouveau_abi16_put(abi16, -EINVAL);
 
         /* compatibility with userspace that assumes 506e for all chipsets */
         if (init->class == 0x506e) {
-                init->class = nouveau_software_class(dev);
+                init->class = nouveau_abi16_swclass(drm);
                 if (init->class == 0x906e)
-                        return 0;
-        } else
-        if (init->class == 0x906e) {
-                NV_ERROR(dev, "906e not supported yet\n");
-                return -EINVAL;
-        }
-
-        chan = nouveau_channel_get(file_priv, init->channel);
-        if (IS_ERR(chan))
-                return PTR_ERR(chan);
-
-        if (nouveau_ramht_find(chan, init->handle)) {
-                ret = -EEXIST;
-                goto out;
-        }
-
-        ret = nouveau_gpuobj_gr_new(chan, init->handle, init->class);
-        if (ret) {
-                NV_ERROR(dev, "Error creating object: %d (%d/0x%08x)\n",
-                         ret, init->channel, init->handle);
+                        return nouveau_abi16_put(abi16, 0);
         }
 
-out:
-        nouveau_channel_put(&chan);
-        return ret;
+        ret = nouveau_object_new(abi16->client, NVDRM_CHAN | init->channel,
+                                  init->handle, init->class, NULL, 0, &object);
+        return nouveau_abi16_put(abi16, ret);
 }
 
 int
 nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct drm_nouveau_notifierobj_alloc *na = data;
-        struct nouveau_channel *chan;
+        struct drm_nouveau_notifierobj_alloc *info = data;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
+        struct nouveau_abi16_chan *chan, *temp;
+        struct nouveau_abi16_ntfy *ntfy;
+        struct nouveau_object *object;
+        struct nv_dma_class args;
         int ret;
 
+        if (unlikely(!abi16))
+                return -ENOMEM;
+
         /* completely unnecessary for these chipsets... */
-        if (unlikely(dev_priv->card_type >= NV_C0))
-                return -EINVAL;
+        if (unlikely(nv_device(abi16->device)->card_type >= NV_C0))
+                return nouveau_abi16_put(abi16, -EINVAL);
 
-        chan = nouveau_channel_get(file_priv, na->channel);
-        if (IS_ERR(chan))
-                return PTR_ERR(chan);
+        list_for_each_entry_safe(chan, temp, &abi16->channels, head) {
+                if (chan->chan->handle == (NVDRM_CHAN | info->channel))
+                        break;
+                chan = NULL;
+        }
 
-        ret = nouveau_notifier_alloc(chan, na->handle, na->size, 0, 0x1000,
-                                     &na->offset);
-        nouveau_channel_put(&chan);
-        return ret;
+        if (!chan)
+                return nouveau_abi16_put(abi16, -ENOENT);
+
+        ntfy = kzalloc(sizeof(*ntfy), GFP_KERNEL);
+        if (!ntfy)
+                return nouveau_abi16_put(abi16, -ENOMEM);
+
+        list_add(&ntfy->head, &chan->notifiers);
+        ntfy->handle = info->handle;
+
+        ret = nouveau_mm_head(&chan->heap, 1, info->size, info->size, 1,
+                              &ntfy->node);
+        if (ret)
+                goto done;
+
+        args.start = ntfy->node->offset;
+        args.limit = ntfy->node->offset + ntfy->node->length - 1;
+        if (device->card_type >= NV_50) {
+                args.flags  = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
+                args.start += chan->ntfy_vma.offset;
+                args.limit += chan->ntfy_vma.offset;
+        } else
+        if (drm->agp.stat == ENABLED) {
+                args.flags  = NV_DMA_TARGET_AGP | NV_DMA_ACCESS_RDWR;
+                args.start += drm->agp.base + chan->ntfy->bo.offset;
+                args.limit += drm->agp.base + chan->ntfy->bo.offset;
+        } else {
+                args.flags  = NV_DMA_TARGET_VM | NV_DMA_ACCESS_RDWR;
+                args.start += chan->ntfy->bo.offset;
+                args.limit += chan->ntfy->bo.offset;
+        }
+
+        ret = nouveau_object_new(abi16->client, chan->chan->handle,
+                                 ntfy->handle, 0x003d, &args,
+                                 sizeof(args), &object);
+        if (ret)
+                goto done;
+
+done:
+        if (ret)
+                nouveau_abi16_ntfy_fini(chan, ntfy);
+        return nouveau_abi16_put(abi16, ret);
 }
 
 int
 nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS)
 {
-        struct drm_nouveau_gpuobj_free *objfree = data;
-        struct nouveau_channel *chan;
+        struct drm_nouveau_gpuobj_free *fini = data;
+        struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
+        struct nouveau_abi16_chan *chan, *temp;
+        struct nouveau_abi16_ntfy *ntfy;
         int ret;
 
-        chan = nouveau_channel_get(file_priv, objfree->channel);
-        if (IS_ERR(chan))
-                return PTR_ERR(chan);
+        if (unlikely(!abi16))
+                return -ENOMEM;
+
+        list_for_each_entry_safe(chan, temp, &abi16->channels, head) {
+                if (chan->chan->handle == (NVDRM_CHAN | fini->channel))
+                        break;
+                chan = NULL;
+        }
+
+        if (!chan)
+                return nouveau_abi16_put(abi16, -ENOENT);
 
-        /* Synchronize with the user channel */
-        nouveau_channel_idle(chan);
+        /* synchronize with the user channel and destroy the gpu object */
+        nouveau_channel_idle(chan->chan);
 
-        ret = nouveau_ramht_remove(chan, objfree->handle);
-        nouveau_channel_put(&chan);
-        return ret;
+        ret = nouveau_object_del(abi16->client, chan->chan->handle, fini->handle);
+        if (ret)
+                return nouveau_abi16_put(abi16, ret);
+
+        /* cleanup extra state if this object was a notifier */
+        list_for_each_entry(ntfy, &chan->notifiers, head) {
+                if (ntfy->handle == fini->handle) {
+                        nouveau_mm_free(&chan->heap, &ntfy->node);
+                        list_del(&ntfy->head);
+                        break;
+                }
+        }
+
+        return nouveau_abi16_put(abi16, 0);
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_abi16.h b/drivers/gpu/drm/nouveau/nouveau_abi16.h
index e6328b008a8c..90004081a501 100644
--- a/drivers/gpu/drm/nouveau/nouveau_abi16.h
+++ b/drivers/gpu/drm/nouveau/nouveau_abi16.h
@@ -3,6 +3,7 @@
 
 #define ABI16_IOCTL_ARGS                                                       \
         struct drm_device *dev, void *data, struct drm_file *file_priv
+
 int nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS);
 int nouveau_abi16_ioctl_setparam(ABI16_IOCTL_ARGS);
 int nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS);
@@ -11,6 +12,37 @@ int nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS);
 int nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS);
 int nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS);
 
+struct nouveau_abi16_ntfy {
+        struct list_head head;
+        struct nouveau_mm_node *node;
+        u32 handle;
+};
+
+struct nouveau_abi16_chan {
+        struct list_head head;
+        struct nouveau_channel *chan;
+        struct list_head notifiers;
+        struct nouveau_bo *ntfy;
+        struct nouveau_vma ntfy_vma;
+        struct nouveau_mm  heap;
+};
+
+struct nouveau_abi16 {
+        struct nouveau_object *client;
+        struct nouveau_object *device;
+        struct list_head channels;
+        u64 handles;
+};
+
+struct nouveau_drm;
+struct nouveau_abi16 *nouveau_abi16_get(struct drm_file *, struct drm_device *);
+int  nouveau_abi16_put(struct nouveau_abi16 *, int);
+void nouveau_abi16_fini(struct nouveau_abi16 *);
+u16  nouveau_abi16_swclass(struct nouveau_drm *);
+
+#define NOUVEAU_GEM_DOMAIN_VRAM      (1 << 1)
+#define NOUVEAU_GEM_DOMAIN_GART      (1 << 2)
+
 struct drm_nouveau_channel_alloc {
         uint32_t     fb_ctxdma_handle;
         uint32_t     tt_ctxdma_handle;
diff --git a/drivers/gpu/drm/nouveau/nouveau_acpi.c b/drivers/gpu/drm/nouveau/nouveau_acpi.c
index 26ebffebe710..e7369c8239d3 100644
--- a/drivers/gpu/drm/nouveau/nouveau_acpi.c
+++ b/drivers/gpu/drm/nouveau/nouveau_acpi.c
@@ -7,17 +7,13 @@
 #include <acpi/acpi.h>
 #include <linux/mxm-wmi.h>
 
-#include "drmP.h"
-#include "drm.h"
-#include "drm_sarea.h"
-#include "drm_crtc_helper.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-#include "nv50_display.h"
-#include "nouveau_connector.h"
-
 #include <linux/vga_switcheroo.h>
 
+#include "drm_edid.h"
+
+#include "nouveau_drm.h"
+#include "nouveau_acpi.h"
+
 #define NOUVEAU_DSM_LED 0x02
 #define NOUVEAU_DSM_LED_STATE 0x00
 #define NOUVEAU_DSM_LED_OFF 0x10
@@ -390,10 +386,9 @@ int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len)
         return nouveau_rom_call(nouveau_dsm_priv.rom_handle, bios, offset, len);
 }
 
-int
+void *
 nouveau_acpi_edid(struct drm_device *dev, struct drm_connector *connector)
 {
-        struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct acpi_device *acpidev;
         acpi_handle handle;
         int type, ret;
@@ -405,21 +400,20 @@ nouveau_acpi_edid(struct drm_device *dev, struct drm_connector *connector)
                 type = ACPI_VIDEO_DISPLAY_LCD;
                 break;
         default:
-                return -EINVAL;
+                return NULL;
         }
 
         handle = DEVICE_ACPI_HANDLE(&dev->pdev->dev);
         if (!handle)
-                return -ENODEV;
+                return NULL;
 
         ret = acpi_bus_get_device(handle, &acpidev);
         if (ret)
-                return -ENODEV;
+                return NULL;
 
         ret = acpi_video_get_edid(acpidev, type, -1, &edid);
         if (ret < 0)
-                return ret;
+                return NULL;
 
-        nv_connector->edid = kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
-        return 0;
+        return kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_acpi.h b/drivers/gpu/drm/nouveau/nouveau_acpi.h
new file mode 100644
index 000000000000..08af67722b57
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_acpi.h
@@ -0,0 +1,22 @@
+#ifndef __NOUVEAU_ACPI_H__
+#define __NOUVEAU_ACPI_H__
+
+#define ROM_BIOS_PAGE 4096
+
+#if defined(CONFIG_ACPI)
+void nouveau_register_dsm_handler(void);
+void nouveau_unregister_dsm_handler(void);
+void nouveau_switcheroo_optimus_dsm(void);
+int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len);
+bool nouveau_acpi_rom_supported(struct pci_dev *pdev);
+void *nouveau_acpi_edid(struct drm_device *, struct drm_connector *);
+#else
+static inline void nouveau_register_dsm_handler(void) {}
+static inline void nouveau_unregister_dsm_handler(void) {}
+static inline void nouveau_switcheroo_optimus_dsm(void) {}
+static inline bool nouveau_acpi_rom_supported(struct pci_dev *pdev) { return false; }
+static inline int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len) { return -EINVAL; }
+static inline void *nouveau_acpi_edid(struct drm_device *dev, struct drm_connector *connector) { return NULL; }
+#endif
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_agp.c b/drivers/gpu/drm/nouveau/nouveau_agp.c
new file mode 100644
index 000000000000..d28430cd2ba6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_agp.c
@@ -0,0 +1,152 @@
+#include <linux/module.h>
+
+#include <core/device.h>
+
+#include "nouveau_drm.h"
+#include "nouveau_agp.h"
+#include "nouveau_reg.h"
+
+#if __OS_HAS_AGP
+MODULE_PARM_DESC(agpmode, "AGP mode (0 to disable AGP)");
+static int nouveau_agpmode = -1;
+module_param_named(agpmode, nouveau_agpmode, int, 0400);
+
+static unsigned long
+get_agp_mode(struct nouveau_drm *drm, unsigned long mode)
+{
+        struct nouveau_device *device = nv_device(drm->device);
+
+        /*
+         * FW seems to be broken on nv18, it makes the card lock up
+         * randomly.
+         */
+        if (device->chipset == 0x18)
+                mode &= ~PCI_AGP_COMMAND_FW;
+
+        /*
+         * AGP mode set in the command line.
+         */
+        if (nouveau_agpmode > 0) {
+                bool agpv3 = mode & 0x8;
+                int rate = agpv3 ? nouveau_agpmode / 4 : nouveau_agpmode;
+
+                mode = (mode & ~0x7) | (rate & 0x7);
+        }
+
+        return mode;
+}
+
+static bool
+nouveau_agp_enabled(struct nouveau_drm *drm)
+{
+        struct drm_device *dev = drm->dev;
+
+        if (!drm_pci_device_is_agp(dev) || !dev->agp)
+                return false;
+
+        if (drm->agp.stat == UNKNOWN) {
+                if (!nouveau_agpmode)
+                        return false;
+                return true;
+        }
+
+        return (drm->agp.stat == ENABLED);
+}
+#endif
+
+void
+nouveau_agp_reset(struct nouveau_drm *drm)
+{
+#if __OS_HAS_AGP
+        struct nouveau_device *device = nv_device(drm->device);
+        struct drm_device *dev = drm->dev;
+        u32 save[2];
+        int ret;
+
+        if (!nouveau_agp_enabled(drm))
+                return;
+
+        /* 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 ((nv_rd32(device, NV04_PBUS_PCI_NV_19) |
+             dev->agp->mode) & PCI_AGP_COMMAND_FW) {
+                struct drm_agp_info info;
+                struct drm_agp_mode mode;
+
+                ret = drm_agp_info(dev, &info);
+                if (ret)
+                        return;
+
+                mode.mode  = get_agp_mode(drm, info.mode);
+                mode.mode &= ~PCI_AGP_COMMAND_FW;
+
+                ret = drm_agp_enable(dev, mode);
+                if (ret)
+                        return;
+        }
+
+
+        /* clear busmaster bit, and disable AGP */
+        save[0] = nv_mask(device, NV04_PBUS_PCI_NV_1, 0x00000004, 0x00000000);
+        nv_wr32(device, NV04_PBUS_PCI_NV_19, 0);
+
+        /* reset PGRAPH, PFIFO and PTIMER */
+        save[1] = nv_mask(device, 0x000200, 0x00011100, 0x00000000);
+        nv_mask(device, 0x000200, 0x00011100, save[1]);
+
+        /* and restore bustmaster bit (gives effect of resetting AGP) */
+        nv_wr32(device, NV04_PBUS_PCI_NV_1, save[0]);
+#endif
+}
+
+void
+nouveau_agp_init(struct nouveau_drm *drm)
+{
+#if __OS_HAS_AGP
+        struct nouveau_device *device = nv_device(drm->device);
+        struct drm_device *dev = drm->dev;
+        struct drm_agp_info info;
+        struct drm_agp_mode mode;
+        int ret;
+
+        if (!nouveau_agp_enabled(drm))
+                return;
+        drm->agp.stat = DISABLE;
+
+        ret = drm_agp_acquire(dev);
+        if (ret) {
+                nv_error(device, "unable to acquire AGP: %d\n", ret);
+                return;
+        }
+
+        ret = drm_agp_info(dev, &info);
+        if (ret) {
+                nv_error(device, "unable to get AGP info: %d\n", ret);
+                return;
+        }
+
+        /* see agp.h for the AGPSTAT_* modes available */
+        mode.mode = get_agp_mode(drm, info.mode);
+
+        ret = drm_agp_enable(dev, mode);
+        if (ret) {
+                nv_error(device, "unable to enable AGP: %d\n", ret);
+                return;
+        }
+
+        drm->agp.stat = ENABLED;
+        drm->agp.base = info.aperture_base;
+        drm->agp.size = info.aperture_size;
+#endif
+}
+
+void
+nouveau_agp_fini(struct nouveau_drm *drm)
+{
+#if __OS_HAS_AGP
+        struct drm_device *dev = drm->dev;
+        if (dev->agp && dev->agp->acquired)
+                drm_agp_release(dev);
+#endif
+}
diff --git a/drivers/gpu/drm/nouveau/nouveau_agp.h b/drivers/gpu/drm/nouveau/nouveau_agp.h
new file mode 100644
index 000000000000..b55c08652963
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_agp.h
@@ -0,0 +1,10 @@
+#ifndef __NOUVEAU_AGP_H__
+#define __NOUVEAU_AGP_H__
+
+struct nouveau_drm;
+
+void nouveau_agp_reset(struct nouveau_drm *);
+void nouveau_agp_init(struct nouveau_drm *);
+void nouveau_agp_fini(struct nouveau_drm *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_backlight.c b/drivers/gpu/drm/nouveau/nouveau_backlight.c
index fa22b28e8777..f65b20a375f6 100644
--- a/drivers/gpu/drm/nouveau/nouveau_backlight.c
+++ b/drivers/gpu/drm/nouveau/nouveau_backlight.c
@@ -33,8 +33,6 @@
 #include <linux/backlight.h>
 #include <linux/acpi.h>
 
-#include "drmP.h"
-#include "nouveau_drv.h"
 #include "nouveau_drm.h"
 #include "nouveau_reg.h"
 #include "nouveau_encoder.h"
@@ -42,9 +40,10 @@
 static int
 nv40_get_intensity(struct backlight_device *bd)
 {
-        struct drm_device *dev = bl_get_data(bd);
-        int val = (nv_rd32(dev, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK)
-                                                                        >> 16;
+        struct nouveau_drm *drm = bl_get_data(bd);
+        struct nouveau_device *device = nv_device(drm->device);
+        int val = (nv_rd32(device, NV40_PMC_BACKLIGHT) &
+                                   NV40_PMC_BACKLIGHT_MASK) >> 16;
 
         return val;
 }
@@ -52,11 +51,12 @@ nv40_get_intensity(struct backlight_device *bd)
 static int
 nv40_set_intensity(struct backlight_device *bd)
 {
-        struct drm_device *dev = bl_get_data(bd);
+        struct nouveau_drm *drm = bl_get_data(bd);
+        struct nouveau_device *device = nv_device(drm->device);
         int val = bd->props.brightness;
-        int reg = nv_rd32(dev, NV40_PMC_BACKLIGHT);
+        int reg = nv_rd32(device, NV40_PMC_BACKLIGHT);
 
-        nv_wr32(dev, NV40_PMC_BACKLIGHT,
+        nv_wr32(device, NV40_PMC_BACKLIGHT,
                  (val << 16) | (reg & ~NV40_PMC_BACKLIGHT_MASK));
 
         return 0;
@@ -71,23 +71,20 @@ static const struct backlight_ops nv40_bl_ops = {
 static int
 nv40_backlight_init(struct drm_connector *connector)
 {
-        struct drm_device *dev = connector->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
+        struct nouveau_device *device = nv_device(drm->device);
         struct backlight_properties props;
         struct backlight_device *bd;
 
-        if (!(nv_rd32(dev, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
+        if (!(nv_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
                 return 0;
 
         memset(&props, 0, sizeof(struct backlight_properties));
         props.type = BACKLIGHT_RAW;
         props.max_brightness = 31;
-        bd = backlight_device_register("nv_backlight", &connector->kdev, dev,
+        bd = backlight_device_register("nv_backlight", &connector->kdev, drm,
                                        &nv40_bl_ops, &props);
-        if (IS_ERR(bd))
-                return PTR_ERR(bd);
-
-        dev_priv->backlight = bd;
+        drm->backlight = bd;
         bd->props.brightness = nv40_get_intensity(bd);
         backlight_update_status(bd);
 
@@ -98,12 +95,13 @@ static int
 nv50_get_intensity(struct backlight_device *bd)
 {
         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
-        struct drm_device *dev = nv_encoder->base.base.dev;
+        struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int or = nv_encoder->or;
         u32 div = 1025;
         u32 val;
 
-        val  = nv_rd32(dev, NV50_PDISP_SOR_PWM_CTL(or));
+        val  = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
         val &= NV50_PDISP_SOR_PWM_CTL_VAL;
         return ((val * 100) + (div / 2)) / div;
 }
@@ -112,13 +110,14 @@ static int
 nv50_set_intensity(struct backlight_device *bd)
 {
         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
-        struct drm_device *dev = nv_encoder->base.base.dev;
+        struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int or = nv_encoder->or;
         u32 div = 1025;
         u32 val = (bd->props.brightness * div) / 100;
 
-        nv_wr32(dev, NV50_PDISP_SOR_PWM_CTL(or),
-                     NV50_PDISP_SOR_PWM_CTL_NEW | val);
+        nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
+                        NV50_PDISP_SOR_PWM_CTL_NEW | val);
         return 0;
 }
 
@@ -132,12 +131,13 @@ static int
 nva3_get_intensity(struct backlight_device *bd)
 {
         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
-        struct drm_device *dev = nv_encoder->base.base.dev;
+        struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int or = nv_encoder->or;
         u32 div, val;
 
-        div  = nv_rd32(dev, NV50_PDISP_SOR_PWM_DIV(or));
-        val  = nv_rd32(dev, NV50_PDISP_SOR_PWM_CTL(or));
+        div  = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
+        val  = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
         val &= NVA3_PDISP_SOR_PWM_CTL_VAL;
         if (div && div >= val)
                 return ((val * 100) + (div / 2)) / div;
@@ -149,16 +149,17 @@ static int
 nva3_set_intensity(struct backlight_device *bd)
 {
         struct nouveau_encoder *nv_encoder = bl_get_data(bd);
-        struct drm_device *dev = nv_encoder->base.base.dev;
+        struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int or = nv_encoder->or;
         u32 div, val;
 
-        div = nv_rd32(dev, NV50_PDISP_SOR_PWM_DIV(or));
+        div = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
         val = (bd->props.brightness * div) / 100;
         if (div) {
-                nv_wr32(dev, NV50_PDISP_SOR_PWM_CTL(or), val |
-                             NV50_PDISP_SOR_PWM_CTL_NEW |
-                             NVA3_PDISP_SOR_PWM_CTL_UNK);
+                nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val |
+                                NV50_PDISP_SOR_PWM_CTL_NEW |
+                                NVA3_PDISP_SOR_PWM_CTL_UNK);
                 return 0;
         }
 
@@ -174,26 +175,26 @@ static const struct backlight_ops nva3_bl_ops = {
 static int
 nv50_backlight_init(struct drm_connector *connector)
 {
-        struct drm_device *dev = connector->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
+        struct nouveau_device *device = nv_device(drm->device);
         struct nouveau_encoder *nv_encoder;
         struct backlight_properties props;
         struct backlight_device *bd;
         const struct backlight_ops *ops;
 
-        nv_encoder = find_encoder(connector, OUTPUT_LVDS);
+        nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
         if (!nv_encoder) {
-                nv_encoder = find_encoder(connector, OUTPUT_DP);
+                nv_encoder = find_encoder(connector, DCB_OUTPUT_DP);
                 if (!nv_encoder)
                         return -ENODEV;
         }
 
-        if (!nv_rd32(dev, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
+        if (!nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
                 return 0;
 
-        if (dev_priv->chipset <= 0xa0 ||
-            dev_priv->chipset == 0xaa ||
-            dev_priv->chipset == 0xac)
+        if (device->chipset <= 0xa0 ||
+            device->chipset == 0xaa ||
+            device->chipset == 0xac)
                 ops = &nv50_bl_ops;
         else
                 ops = &nva3_bl_ops;
@@ -206,7 +207,7 @@ nv50_backlight_init(struct drm_connector *connector)
         if (IS_ERR(bd))
                 return PTR_ERR(bd);
 
-        dev_priv->backlight = bd;
+        drm->backlight = bd;
         bd->props.brightness = bd->ops->get_brightness(bd);
         backlight_update_status(bd);
         return 0;
@@ -215,12 +216,13 @@ nv50_backlight_init(struct drm_connector *connector)
 int
 nouveau_backlight_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
         struct drm_connector *connector;
 
 #ifdef CONFIG_ACPI
         if (acpi_video_backlight_support()) {
-                NV_INFO(dev, "ACPI backlight interface available, "
+                NV_INFO(drm, "ACPI backlight interface available, "
                              "not registering our own\n");
                 return 0;
         }
@@ -231,7 +233,7 @@ nouveau_backlight_init(struct drm_device *dev)
                     connector->connector_type != DRM_MODE_CONNECTOR_eDP)
                         continue;
 
-                switch (dev_priv->card_type) {
+                switch (device->card_type) {
                 case NV_40:
                         return nv40_backlight_init(connector);
                 case NV_50:
@@ -248,10 +250,10 @@ nouveau_backlight_init(struct drm_device *dev)
 void
 nouveau_backlight_exit(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        if (dev_priv->backlight) {
-                backlight_device_unregister(dev_priv->backlight);
-                dev_priv->backlight = NULL;
+        if (drm->backlight) {
+                backlight_device_unregister(drm->backlight);
+                drm->backlight = NULL;
         }
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.c b/drivers/gpu/drm/nouveau/nouveau_bios.c
index a0a3fe3c016b..f6b7fa39d312 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.c
@@ -22,12 +22,13 @@
  * SOFTWARE.
  */
 
+#include <subdev/bios.h>
+
 #include "drmP.h"
-#define NV_DEBUG_NOTRACE
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_hw.h"
 #include "nouveau_encoder.h"
-#include "nouveau_gpio.h"
 
 #include <linux/io-mapping.h>
 #include <linux/firmware.h>
@@ -65,3677 +66,6 @@ static bool nv_cksum(const uint8_t *data, unsigned int length)
         return false;
 }
 
-static int
-score_vbios(struct nvbios *bios, const bool writeable)
-{
-        if (!bios->data || bios->data[0] != 0x55 || bios->data[1] != 0xAA) {
-                NV_TRACEWARN(bios->dev, "... BIOS signature not found\n");
-                return 0;
-        }
-
-        if (nv_cksum(bios->data, bios->data[2] * 512)) {
-                NV_TRACEWARN(bios->dev, "... BIOS checksum invalid\n");
-                /* if a ro image is somewhat bad, it's probably all rubbish */
-                return writeable ? 2 : 1;
-        }
-
-        NV_TRACE(bios->dev, "... appears to be valid\n");
-        return 3;
-}
-
-static void
-bios_shadow_prom(struct nvbios *bios)
-{
-        struct drm_device *dev = bios->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 pcireg, access;
-        u16 pcir;
-        int i;
-
-        /* enable access to rom */
-        if (dev_priv->card_type >= NV_50)
-                pcireg = 0x088050;
-        else
-                pcireg = NV_PBUS_PCI_NV_20;
-        access = nv_mask(dev, pcireg, 0x00000001, 0x00000000);
-
-        /* bail if no rom signature, with a workaround for a PROM reading
-         * issue on some chipsets.  the first read after a period of
-         * inactivity returns the wrong result, so retry the first header
-         * byte a few times before giving up as a workaround
-         */
-        i = 16;
-        do {
-                if (nv_rd08(dev, NV_PROM_OFFSET + 0) == 0x55)
-                        break;
-        } while (i--);
-
-        if (!i || nv_rd08(dev, NV_PROM_OFFSET + 1) != 0xaa)
-                goto out;
-
-        /* additional check (see note below) - read PCI record header */
-        pcir = nv_rd08(dev, NV_PROM_OFFSET + 0x18) |
-               nv_rd08(dev, NV_PROM_OFFSET + 0x19) << 8;
-        if (nv_rd08(dev, NV_PROM_OFFSET + pcir + 0) != 'P' ||
-            nv_rd08(dev, NV_PROM_OFFSET + pcir + 1) != 'C' ||
-            nv_rd08(dev, NV_PROM_OFFSET + pcir + 2) != 'I' ||
-            nv_rd08(dev, NV_PROM_OFFSET + pcir + 3) != 'R')
-                goto out;
-
-        /* read entire bios image to system memory */
-        bios->length = nv_rd08(dev, NV_PROM_OFFSET + 2) * 512;
-        bios->data = kmalloc(bios->length, GFP_KERNEL);
-        if (bios->data) {
-                for (i = 0; i < bios->length; i++)
-                        bios->data[i] = nv_rd08(dev, NV_PROM_OFFSET + i);
-        }
-
-out:
-        /* disable access to rom */
-        nv_wr32(dev, pcireg, access);
-}
-
-static void
-bios_shadow_pramin(struct nvbios *bios)
-{
-        struct drm_device *dev = bios->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 bar0 = 0;
-        int i;
-
-        if (dev_priv->card_type >= NV_50) {
-                u64 addr = (u64)(nv_rd32(dev, 0x619f04) & 0xffffff00) << 8;
-                if (!addr) {
-                        addr  = (u64)nv_rd32(dev, 0x001700) << 16;
-                        addr += 0xf0000;
-                }
-
-                bar0 = nv_mask(dev, 0x001700, 0xffffffff, addr >> 16);
-        }
-
-        /* bail if no rom signature */
-        if (nv_rd08(dev, NV_PRAMIN_OFFSET + 0) != 0x55 ||
-            nv_rd08(dev, NV_PRAMIN_OFFSET + 1) != 0xaa)
-                goto out;
-
-        bios->length = nv_rd08(dev, NV_PRAMIN_OFFSET + 2) * 512;
-        bios->data = kmalloc(bios->length, GFP_KERNEL);
-        if (bios->data) {
-                for (i = 0; i < bios->length; i++)
-                        bios->data[i] = nv_rd08(dev, NV_PRAMIN_OFFSET + i);
-        }
-
-out:
-        if (dev_priv->card_type >= NV_50)
-                nv_wr32(dev, 0x001700, bar0);
-}
-
-static void
-bios_shadow_pci(struct nvbios *bios)
-{
-        struct pci_dev *pdev = bios->dev->pdev;
-        size_t length;
-
-        if (!pci_enable_rom(pdev)) {
-                void __iomem *rom = pci_map_rom(pdev, &length);
-                if (rom && length) {
-                        bios->data = kmalloc(length, GFP_KERNEL);
-                        if (bios->data) {
-                                memcpy_fromio(bios->data, rom, length);
-                                bios->length = length;
-                        }
-                }
-                if (rom)
-                        pci_unmap_rom(pdev, rom);
-
-                pci_disable_rom(pdev);
-        }
-}
-
-static void
-bios_shadow_acpi(struct nvbios *bios)
-{
-        struct pci_dev *pdev = bios->dev->pdev;
-        int cnt = 65536 / ROM_BIOS_PAGE;
-        int ret;
-
-        if (!nouveau_acpi_rom_supported(pdev))
-                return;
-
-        bios->data = kmalloc(cnt * ROM_BIOS_PAGE, GFP_KERNEL);
-        if (!bios->data)
-                return;
-
-        bios->length = 0;
-        while (cnt--) {
-                ret = nouveau_acpi_get_bios_chunk(bios->data, bios->length,
-                                                  ROM_BIOS_PAGE);
-                if (ret != ROM_BIOS_PAGE)
-                        return;
-
-                bios->length += ROM_BIOS_PAGE;
-        }
-}
-
-struct methods {
-        const char desc[8];
-        void (*shadow)(struct nvbios *);
-        const bool rw;
-        int score;
-        u32 size;
-        u8 *data;
-};
-
-static bool
-bios_shadow(struct drm_device *dev)
-{
-        struct methods shadow_methods[] = {
-                { "PRAMIN", bios_shadow_pramin, true, 0, 0, NULL },
-                { "PROM", bios_shadow_prom, false, 0, 0, NULL },
-                { "ACPI", bios_shadow_acpi, true, 0, 0, NULL },
-                { "PCIROM", bios_shadow_pci, true, 0, 0, NULL },
-                {}
-        };
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct methods *mthd, *best;
-        const struct firmware *fw;
-        char fname[32];
-        int ret;
-
-        if (nouveau_vbios) {
-                /* try to match one of the built-in methods */
-                mthd = shadow_methods;
-                do {
-                        if (strcasecmp(nouveau_vbios, mthd->desc))
-                                continue;
-                        NV_INFO(dev, "VBIOS source: %s\n", mthd->desc);
-
-                        mthd->shadow(bios);
-                        mthd->score = score_vbios(bios, mthd->rw);
-                        if (mthd->score)
-                                return true;
-                } while ((++mthd)->shadow);
-
-                /* attempt to load firmware image */
-                snprintf(fname, sizeof(fname), "nouveau/%s", nouveau_vbios);
-                ret = request_firmware(&fw, fname, &dev->pdev->dev);
-                if (ret == 0) {
-                        bios->length = fw->size;
-                        bios->data   = kmemdup(fw->data, fw->size, GFP_KERNEL);
-                        release_firmware(fw);
-
-                        NV_INFO(dev, "VBIOS image: %s\n", nouveau_vbios);
-                        if (score_vbios(bios, 1))
-                                return true;
-
-                        kfree(bios->data);
-                        bios->data = NULL;
-                }
-
-                NV_ERROR(dev, "VBIOS source \'%s\' invalid\n", nouveau_vbios);
-        }
-
-        mthd = shadow_methods;
-        do {
-                NV_TRACE(dev, "Checking %s for VBIOS\n", mthd->desc);
-                mthd->shadow(bios);
-                mthd->score = score_vbios(bios, mthd->rw);
-                mthd->size = bios->length;
-                mthd->data = bios->data;
-                bios->data = NULL;
-        } while (mthd->score != 3 && (++mthd)->shadow);
-
-        mthd = shadow_methods;
-        best = mthd;
-        do {
-                if (mthd->score > best->score) {
-                        kfree(best->data);
-                        best = mthd;
-                }
-        } while ((++mthd)->shadow);
-
-        if (best->score) {
-                NV_TRACE(dev, "Using VBIOS from %s\n", best->desc);
-                bios->length = best->size;
-                bios->data = best->data;
-                return true;
-        }
-
-        NV_ERROR(dev, "No valid VBIOS image found\n");
-        return false;
-}
-
-struct init_tbl_entry {
-        char *name;
-        uint8_t id;
-        /* Return:
-         *  > 0: success, length of opcode
-         *    0: success, but abort further parsing of table (INIT_DONE etc)
-         *  < 0: failure, table parsing will be aborted
-         */
-        int (*handler)(struct nvbios *, uint16_t, struct init_exec *);
-};
-
-static int parse_init_table(struct nvbios *, uint16_t, struct init_exec *);
-
-#define MACRO_INDEX_SIZE        2
-#define MACRO_SIZE              8
-#define CONDITION_SIZE          12
-#define IO_FLAG_CONDITION_SIZE  9
-#define IO_CONDITION_SIZE       5
-#define MEM_INIT_SIZE           66
-
-static void still_alive(void)
-{
-#if 0
-        sync();
-        mdelay(2);
-#endif
-}
-
-static uint32_t
-munge_reg(struct nvbios *bios, uint32_t reg)
-{
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        struct dcb_entry *dcbent = bios->display.output;
-
-        if (dev_priv->card_type < NV_50)
-                return reg;
-
-        if (reg & 0x80000000) {
-                BUG_ON(bios->display.crtc < 0);
-                reg += bios->display.crtc * 0x800;
-        }
-
-        if (reg & 0x40000000) {
-                BUG_ON(!dcbent);
-
-                reg += (ffs(dcbent->or) - 1) * 0x800;
-                if ((reg & 0x20000000) && !(dcbent->sorconf.link & 1))
-                        reg += 0x00000080;
-        }
-
-        reg &= ~0xe0000000;
-        return reg;
-}
-
-static int
-valid_reg(struct nvbios *bios, uint32_t reg)
-{
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        struct drm_device *dev = bios->dev;
-
-        /* C51 has misaligned regs on purpose. Marvellous */
-        if (reg & 0x2 ||
-            (reg & 0x1 && dev_priv->vbios.chip_version != 0x51))
-                NV_ERROR(dev, "======= misaligned reg 0x%08X =======\n", reg);
-
-        /* warn on C51 regs that haven't been verified accessible in tracing */
-        if (reg & 0x1 && dev_priv->vbios.chip_version == 0x51 &&
-            reg != 0x130d && reg != 0x1311 && reg != 0x60081d)
-                NV_WARN(dev, "=== C51 misaligned reg 0x%08X not verified ===\n",
-                        reg);
-
-        if (reg >= (8*1024*1024)) {
-                NV_ERROR(dev, "=== reg 0x%08x out of mapped bounds ===\n", reg);
-                return 0;
-        }
-
-        return 1;
-}
-
-static bool
-valid_idx_port(struct nvbios *bios, uint16_t port)
-{
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        struct drm_device *dev = bios->dev;
-
-        /*
-         * If adding more ports here, the read/write functions below will need
-         * updating so that the correct mmio range (PRMCIO, PRMDIO, PRMVIO) is
-         * used for the port in question
-         */
-        if (dev_priv->card_type < NV_50) {
-                if (port == NV_CIO_CRX__COLOR)
-                        return true;
-                if (port == NV_VIO_SRX)
-                        return true;
-        } else {
-                if (port == NV_CIO_CRX__COLOR)
-                        return true;
-        }
-
-        NV_ERROR(dev, "========== unknown indexed io port 0x%04X ==========\n",
-                 port);
-
-        return false;
-}
-
-static bool
-valid_port(struct nvbios *bios, uint16_t port)
-{
-        struct drm_device *dev = bios->dev;
-
-        /*
-         * If adding more ports here, the read/write functions below will need
-         * updating so that the correct mmio range (PRMCIO, PRMDIO, PRMVIO) is
-         * used for the port in question
-         */
-        if (port == NV_VIO_VSE2)
-                return true;
-
-        NV_ERROR(dev, "========== unknown io port 0x%04X ==========\n", port);
-
-        return false;
-}
-
-static uint32_t
-bios_rd32(struct nvbios *bios, uint32_t reg)
-{
-        uint32_t data;
-
-        reg = munge_reg(bios, reg);
-        if (!valid_reg(bios, reg))
-                return 0;
-
-        /*
-         * C51 sometimes uses regs with bit0 set in the address. For these
-         * cases there should exist a translation in a BIOS table to an IO
-         * port address which the BIOS uses for accessing the reg
-         *
-         * These only seem to appear for the power control regs to a flat panel,
-         * and the GPIO regs at 0x60081*.  In C51 mmio traces the normal regs
-         * for 0x1308 and 0x1310 are used - hence the mask below.  An S3
-         * suspend-resume mmio trace from a C51 will be required to see if this
-         * is true for the power microcode in 0x14.., or whether the direct IO
-         * port access method is needed
-         */
-        if (reg & 0x1)
-                reg &= ~0x1;
-
-        data = nv_rd32(bios->dev, reg);
-
-        BIOSLOG(bios, " Read:  Reg: 0x%08X, Data: 0x%08X\n", reg, data);
-
-        return data;
-}
-
-static void
-bios_wr32(struct nvbios *bios, uint32_t reg, uint32_t data)
-{
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-
-        reg = munge_reg(bios, reg);
-        if (!valid_reg(bios, reg))
-                return;
-
-        /* see note in bios_rd32 */
-        if (reg & 0x1)
-                reg &= 0xfffffffe;
-
-        LOG_OLD_VALUE(bios_rd32(bios, reg));
-        BIOSLOG(bios, " Write: Reg: 0x%08X, Data: 0x%08X\n", reg, data);
-
-        if (dev_priv->vbios.execute) {
-                still_alive();
-                nv_wr32(bios->dev, reg, data);
-        }
-}
-
-static uint8_t
-bios_idxprt_rd(struct nvbios *bios, uint16_t port, uint8_t index)
-{
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        struct drm_device *dev = bios->dev;
-        uint8_t data;
-
-        if (!valid_idx_port(bios, port))
-                return 0;
-
-        if (dev_priv->card_type < NV_50) {
-                if (port == NV_VIO_SRX)
-                        data = NVReadVgaSeq(dev, bios->state.crtchead, index);
-                else    /* assume NV_CIO_CRX__COLOR */
-                        data = NVReadVgaCrtc(dev, bios->state.crtchead, index);
-        } else {
-                uint32_t data32;
-
-                data32 = bios_rd32(bios, NV50_PDISPLAY_VGACRTC(index & ~3));
-                data = (data32 >> ((index & 3) << 3)) & 0xff;
-        }
-
-        BIOSLOG(bios, " Indexed IO read:  Port: 0x%04X, Index: 0x%02X, "
-                      "Head: 0x%02X, Data: 0x%02X\n",
-                port, index, bios->state.crtchead, data);
-        return data;
-}
-
-static void
-bios_idxprt_wr(struct nvbios *bios, uint16_t port, uint8_t index, uint8_t data)
-{
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        struct drm_device *dev = bios->dev;
-
-        if (!valid_idx_port(bios, port))
-                return;
-
-        /*
-         * The current head is maintained in the nvbios member  state.crtchead.
-         * We trap changes to CR44 and update the head variable and hence the
-         * register set written.
-         * As CR44 only exists on CRTC0, we update crtchead to head0 in advance
-         * of the write, and to head1 after the write
-         */
-        if (port == NV_CIO_CRX__COLOR && index == NV_CIO_CRE_44 &&
-            data != NV_CIO_CRE_44_HEADB)
-                bios->state.crtchead = 0;
-
-        LOG_OLD_VALUE(bios_idxprt_rd(bios, port, index));
-        BIOSLOG(bios, " Indexed IO write: Port: 0x%04X, Index: 0x%02X, "
-                      "Head: 0x%02X, Data: 0x%02X\n",
-                port, index, bios->state.crtchead, data);
-
-        if (bios->execute && dev_priv->card_type < NV_50) {
-                still_alive();
-                if (port == NV_VIO_SRX)
-                        NVWriteVgaSeq(dev, bios->state.crtchead, index, data);
-                else    /* assume NV_CIO_CRX__COLOR */
-                        NVWriteVgaCrtc(dev, bios->state.crtchead, index, data);
-        } else
-        if (bios->execute) {
-                uint32_t data32, shift = (index & 3) << 3;
-
-                still_alive();
-
-                data32  = bios_rd32(bios, NV50_PDISPLAY_VGACRTC(index & ~3));
-                data32 &= ~(0xff << shift);
-                data32 |= (data << shift);
-                bios_wr32(bios, NV50_PDISPLAY_VGACRTC(index & ~3), data32);
-        }
-
-        if (port == NV_CIO_CRX__COLOR &&
-            index == NV_CIO_CRE_44 && data == NV_CIO_CRE_44_HEADB)
-                bios->state.crtchead = 1;
-}
-
-static uint8_t
-bios_port_rd(struct nvbios *bios, uint16_t port)
-{
-        uint8_t data, head = bios->state.crtchead;
-
-        if (!valid_port(bios, port))
-                return 0;
-
-        data = NVReadPRMVIO(bios->dev, head, NV_PRMVIO0_OFFSET + port);
-
-        BIOSLOG(bios, " IO read:  Port: 0x%04X, Head: 0x%02X, Data: 0x%02X\n",
-                port, head, data);
-
-        return data;
-}
-
-static void
-bios_port_wr(struct nvbios *bios, uint16_t port, uint8_t data)
-{
-        int head = bios->state.crtchead;
-
-        if (!valid_port(bios, port))
-                return;
-
-        LOG_OLD_VALUE(bios_port_rd(bios, port));
-        BIOSLOG(bios, " IO write: Port: 0x%04X, Head: 0x%02X, Data: 0x%02X\n",
-                port, head, data);
-
-        if (!bios->execute)
-                return;
-
-        still_alive();
-        NVWritePRMVIO(bios->dev, head, NV_PRMVIO0_OFFSET + port, data);
-}
-
-static bool
-io_flag_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond)
-{
-        /*
-         * The IO flag condition entry has 2 bytes for the CRTC port; 1 byte
-         * for the CRTC index; 1 byte for the mask to apply to the value
-         * retrieved from the CRTC; 1 byte for the shift right to apply to the
-         * masked CRTC value; 2 bytes for the offset to the flag array, to
-         * which the shifted value is added; 1 byte for the mask applied to the
-         * value read from the flag array; and 1 byte for the value to compare
-         * against the masked byte from the flag table.
-         */
-
-        uint16_t condptr = bios->io_flag_condition_tbl_ptr + cond * IO_FLAG_CONDITION_SIZE;
-        uint16_t crtcport = ROM16(bios->data[condptr]);
-        uint8_t crtcindex = bios->data[condptr + 2];
-        uint8_t mask = bios->data[condptr + 3];
-        uint8_t shift = bios->data[condptr + 4];
-        uint16_t flagarray = ROM16(bios->data[condptr + 5]);
-        uint8_t flagarraymask = bios->data[condptr + 7];
-        uint8_t cmpval = bios->data[condptr + 8];
-        uint8_t data;
-
-        BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
-                      "Shift: 0x%02X, FlagArray: 0x%04X, FAMask: 0x%02X, "
-                      "Cmpval: 0x%02X\n",
-                offset, crtcport, crtcindex, mask, shift, flagarray, flagarraymask, cmpval);
-
-        data = bios_idxprt_rd(bios, crtcport, crtcindex);
-
-        data = bios->data[flagarray + ((data & mask) >> shift)];
-        data &= flagarraymask;
-
-        BIOSLOG(bios, "0x%04X: Checking if 0x%02X equals 0x%02X\n",
-                offset, data, cmpval);
-
-        return (data == cmpval);
-}
-
-static bool
-bios_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond)
-{
-        /*
-         * The condition table entry has 4 bytes for the address of the
-         * register to check, 4 bytes for a mask to apply to the register and
-         * 4 for a test comparison value
-         */
-
-        uint16_t condptr = bios->condition_tbl_ptr + cond * CONDITION_SIZE;
-        uint32_t reg = ROM32(bios->data[condptr]);
-        uint32_t mask = ROM32(bios->data[condptr + 4]);
-        uint32_t cmpval = ROM32(bios->data[condptr + 8]);
-        uint32_t data;
-
-        BIOSLOG(bios, "0x%04X: Cond: 0x%02X, Reg: 0x%08X, Mask: 0x%08X\n",
-                offset, cond, reg, mask);
-
-        data = bios_rd32(bios, reg) & mask;
-
-        BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n",
-                offset, data, cmpval);
-
-        return (data == cmpval);
-}
-
-static bool
-io_condition_met(struct nvbios *bios, uint16_t offset, uint8_t cond)
-{
-        /*
-         * The IO condition entry has 2 bytes for the IO port address; 1 byte
-         * for the index to write to io_port; 1 byte for the mask to apply to
-         * the byte read from io_port+1; and 1 byte for the value to compare
-         * against the masked byte.
-         */
-
-        uint16_t condptr = bios->io_condition_tbl_ptr + cond * IO_CONDITION_SIZE;
-        uint16_t io_port = ROM16(bios->data[condptr]);
-        uint8_t port_index = bios->data[condptr + 2];
-        uint8_t mask = bios->data[condptr + 3];
-        uint8_t cmpval = bios->data[condptr + 4];
-
-        uint8_t data = bios_idxprt_rd(bios, io_port, port_index) & mask;
-
-        BIOSLOG(bios, "0x%04X: Checking if 0x%02X equals 0x%02X\n",
-                offset, data, cmpval);
-
-        return (data == cmpval);
-}
-
-static int
-nv50_pll_set(struct drm_device *dev, uint32_t reg, uint32_t clk)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pll_vals pll;
-        struct pll_lims pll_limits;
-        u32 ctrl, mask, coef;
-        int ret;
-
-        ret = get_pll_limits(dev, reg, &pll_limits);
-        if (ret)
-                return ret;
-
-        clk = nouveau_calc_pll_mnp(dev, &pll_limits, clk, &pll);
-        if (!clk)
-                return -ERANGE;
-
-        coef = pll.N1 << 8 | pll.M1;
-        ctrl = pll.log2P << 16;
-        mask = 0x00070000;
-        if (reg == 0x004008) {
-                mask |= 0x01f80000;
-                ctrl |= (pll_limits.log2p_bias << 19);
-                ctrl |= (pll.log2P << 22);
-        }
-
-        if (!dev_priv->vbios.execute)
-                return 0;
-
-        nv_mask(dev, reg + 0, mask, ctrl);
-        nv_wr32(dev, reg + 4, coef);
-        return 0;
-}
-
-static int
-setPLL(struct nvbios *bios, uint32_t reg, uint32_t clk)
-{
-        struct drm_device *dev = bios->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        /* clk in kHz */
-        struct pll_lims pll_lim;
-        struct nouveau_pll_vals pllvals;
-        int ret;
-
-        if (dev_priv->card_type >= NV_50)
-                return nv50_pll_set(dev, reg, clk);
-
-        /* high regs (such as in the mac g5 table) are not -= 4 */
-        ret = get_pll_limits(dev, reg > 0x405c ? reg : reg - 4, &pll_lim);
-        if (ret)
-                return ret;
-
-        clk = nouveau_calc_pll_mnp(dev, &pll_lim, clk, &pllvals);
-        if (!clk)
-                return -ERANGE;
-
-        if (bios->execute) {
-                still_alive();
-                nouveau_hw_setpll(dev, reg, &pllvals);
-        }
-
-        return 0;
-}
-
-static int dcb_entry_idx_from_crtchead(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-
-        /*
-         * For the results of this function to be correct, CR44 must have been
-         * set (using bios_idxprt_wr to set crtchead), CR58 set for CR57 = 0,
-         * and the DCB table parsed, before the script calling the function is
-         * run.  run_digital_op_script is example of how to do such setup
-         */
-
-        uint8_t dcb_entry = NVReadVgaCrtc5758(dev, bios->state.crtchead, 0);
-
-        if (dcb_entry > bios->dcb.entries) {
-                NV_ERROR(dev, "CR58 doesn't have a valid DCB entry currently "
-                                "(%02X)\n", dcb_entry);
-                dcb_entry = 0x7f;       /* unused / invalid marker */
-        }
-
-        return dcb_entry;
-}
-
-static struct nouveau_i2c_chan *
-init_i2c_device_find(struct drm_device *dev, int i2c_index)
-{
-        if (i2c_index == 0xff) {
-                struct drm_nouveau_private *dev_priv = dev->dev_private;
-                struct dcb_table *dcb = &dev_priv->vbios.dcb;
-                /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */
-                int idx = dcb_entry_idx_from_crtchead(dev);
-
-                i2c_index = NV_I2C_DEFAULT(0);
-                if (idx != 0x7f && dcb->entry[idx].i2c_upper_default)
-                        i2c_index = NV_I2C_DEFAULT(1);
-        }
-
-        return nouveau_i2c_find(dev, i2c_index);
-}
-
-static uint32_t
-get_tmds_index_reg(struct drm_device *dev, uint8_t mlv)
-{
-        /*
-         * For mlv < 0x80, it is an index into a table of TMDS base addresses.
-         * For mlv == 0x80 use the "or" value of the dcb_entry indexed by
-         * CR58 for CR57 = 0 to index a table of offsets to the basic
-         * 0x6808b0 address.
-         * For mlv == 0x81 use the "or" value of the dcb_entry indexed by
-         * CR58 for CR57 = 0 to index a table of offsets to the basic
-         * 0x6808b0 address, and then flip the offset by 8.
-         */
-
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        const int pramdac_offset[13] = {
-                0, 0, 0x8, 0, 0x2000, 0, 0, 0, 0x2008, 0, 0, 0, 0x2000 };
-        const uint32_t pramdac_table[4] = {
-                0x6808b0, 0x6808b8, 0x6828b0, 0x6828b8 };
-
-        if (mlv >= 0x80) {
-                int dcb_entry, dacoffset;
-
-                /* note: dcb_entry_idx_from_crtchead needs pre-script set-up */
-                dcb_entry = dcb_entry_idx_from_crtchead(dev);
-                if (dcb_entry == 0x7f)
-                        return 0;
-                dacoffset = pramdac_offset[bios->dcb.entry[dcb_entry].or];
-                if (mlv == 0x81)
-                        dacoffset ^= 8;
-                return 0x6808b0 + dacoffset;
-        } else {
-                if (mlv >= ARRAY_SIZE(pramdac_table)) {
-                        NV_ERROR(dev, "Magic Lookup Value too big (%02X)\n",
-                                                                        mlv);
-                        return 0;
-                }
-                return pramdac_table[mlv];
-        }
-}
-
-static int
-init_io_restrict_prog(struct nvbios *bios, uint16_t offset,
-                      struct init_exec *iexec)
-{
-        /*
-         * INIT_IO_RESTRICT_PROG   opcode: 0x32 ('2')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): CRTC port
-         * offset + 3  (8  bit): CRTC index
-         * offset + 4  (8  bit): mask
-         * offset + 5  (8  bit): shift
-         * offset + 6  (8  bit): count
-         * offset + 7  (32 bit): register
-         * offset + 11 (32 bit): configuration 1
-         * ...
-         *
-         * Starting at offset + 11 there are "count" 32 bit values.
-         * To find out which value to use read index "CRTC index" on "CRTC
-         * port", AND this value with "mask" and then bit shift right "shift"
-         * bits.  Read the appropriate value using this index and write to
-         * "register"
-         */
-
-        uint16_t crtcport = ROM16(bios->data[offset + 1]);
-        uint8_t crtcindex = bios->data[offset + 3];
-        uint8_t mask = bios->data[offset + 4];
-        uint8_t shift = bios->data[offset + 5];
-        uint8_t count = bios->data[offset + 6];
-        uint32_t reg = ROM32(bios->data[offset + 7]);
-        uint8_t config;
-        uint32_t configval;
-        int len = 11 + count * 4;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
-                      "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
-                offset, crtcport, crtcindex, mask, shift, count, reg);
-
-        config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
-        if (config > count) {
-                NV_ERROR(bios->dev,
-                         "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
-                         offset, config, count);
-                return len;
-        }
-
-        configval = ROM32(bios->data[offset + 11 + config * 4]);
-
-        BIOSLOG(bios, "0x%04X: Writing config %02X\n", offset, config);
-
-        bios_wr32(bios, reg, configval);
-
-        return len;
-}
-
-static int
-init_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_REPEAT   opcode: 0x33 ('3')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): count
-         *
-         * Execute script following this opcode up to INIT_REPEAT_END
-         * "count" times
-         */
-
-        uint8_t count = bios->data[offset + 1];
-        uint8_t i;
-
-        /* no iexec->execute check by design */
-
-        BIOSLOG(bios, "0x%04X: Repeating following segment %d times\n",
-                offset, count);
-
-        iexec->repeat = true;
-
-        /*
-         * count - 1, as the script block will execute once when we leave this
-         * opcode -- this is compatible with bios behaviour as:
-         * a) the block is always executed at least once, even if count == 0
-         * b) the bios interpreter skips to the op following INIT_END_REPEAT,
-         * while we don't
-         */
-        for (i = 0; i < count - 1; i++)
-                parse_init_table(bios, offset + 2, iexec);
-
-        iexec->repeat = false;
-
-        return 2;
-}
-
-static int
-init_io_restrict_pll(struct nvbios *bios, uint16_t offset,
-                     struct init_exec *iexec)
-{
-        /*
-         * INIT_IO_RESTRICT_PLL   opcode: 0x34 ('4')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): CRTC port
-         * offset + 3  (8  bit): CRTC index
-         * offset + 4  (8  bit): mask
-         * offset + 5  (8  bit): shift
-         * offset + 6  (8  bit): IO flag condition index
-         * offset + 7  (8  bit): count
-         * offset + 8  (32 bit): register
-         * offset + 12 (16 bit): frequency 1
-         * ...
-         *
-         * Starting at offset + 12 there are "count" 16 bit frequencies (10kHz).
-         * Set PLL register "register" to coefficients for frequency n,
-         * selected by reading index "CRTC index" of "CRTC port" ANDed with
-         * "mask" and shifted right by "shift".
-         *
-         * If "IO flag condition index" > 0, and condition met, double
-         * frequency before setting it.
-         */
-
-        uint16_t crtcport = ROM16(bios->data[offset + 1]);
-        uint8_t crtcindex = bios->data[offset + 3];
-        uint8_t mask = bios->data[offset + 4];
-        uint8_t shift = bios->data[offset + 5];
-        int8_t io_flag_condition_idx = bios->data[offset + 6];
-        uint8_t count = bios->data[offset + 7];
-        uint32_t reg = ROM32(bios->data[offset + 8]);
-        uint8_t config;
-        uint16_t freq;
-        int len = 12 + count * 2;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
-                      "Shift: 0x%02X, IO Flag Condition: 0x%02X, "
-                      "Count: 0x%02X, Reg: 0x%08X\n",
-                offset, crtcport, crtcindex, mask, shift,
-                io_flag_condition_idx, count, reg);
-
-        config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
-        if (config > count) {
-                NV_ERROR(bios->dev,
-                         "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
-                         offset, config, count);
-                return len;
-        }
-
-        freq = ROM16(bios->data[offset + 12 + config * 2]);
-
-        if (io_flag_condition_idx > 0) {
-                if (io_flag_condition_met(bios, offset, io_flag_condition_idx)) {
-                        BIOSLOG(bios, "0x%04X: Condition fulfilled -- "
-                                      "frequency doubled\n", offset);
-                        freq *= 2;
-                } else
-                        BIOSLOG(bios, "0x%04X: Condition not fulfilled -- "
-                                      "frequency unchanged\n", offset);
-        }
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %d0kHz\n",
-                offset, reg, config, freq);
-
-        setPLL(bios, reg, freq * 10);
-
-        return len;
-}
-
-static int
-init_end_repeat(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_END_REPEAT   opcode: 0x36 ('6')
-         *
-         * offset      (8 bit): opcode
-         *
-         * Marks the end of the block for INIT_REPEAT to repeat
-         */
-
-        /* no iexec->execute check by design */
-
-        /*
-         * iexec->repeat flag necessary to go past INIT_END_REPEAT opcode when
-         * we're not in repeat mode
-         */
-        if (iexec->repeat)
-                return 0;
-
-        return 1;
-}
-
-static int
-init_copy(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_COPY   opcode: 0x37 ('7')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (8  bit): shift
-         * offset + 6  (8  bit): srcmask
-         * offset + 7  (16 bit): CRTC port
-         * offset + 9  (8 bit): CRTC index
-         * offset + 10  (8 bit): mask
-         *
-         * Read index "CRTC index" on "CRTC port", AND with "mask", OR with
-         * (REGVAL("register") >> "shift" & "srcmask") and write-back to CRTC
-         * port
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint8_t shift = bios->data[offset + 5];
-        uint8_t srcmask = bios->data[offset + 6];
-        uint16_t crtcport = ROM16(bios->data[offset + 7]);
-        uint8_t crtcindex = bios->data[offset + 9];
-        uint8_t mask = bios->data[offset + 10];
-        uint32_t data;
-        uint8_t crtcdata;
-
-        if (!iexec->execute)
-                return 11;
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%02X, "
-                      "Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X\n",
-                offset, reg, shift, srcmask, crtcport, crtcindex, mask);
-
-        data = bios_rd32(bios, reg);
-
-        if (shift < 0x80)
-                data >>= shift;
-        else
-                data <<= (0x100 - shift);
-
-        data &= srcmask;
-
-        crtcdata  = bios_idxprt_rd(bios, crtcport, crtcindex) & mask;
-        crtcdata |= (uint8_t)data;
-        bios_idxprt_wr(bios, crtcport, crtcindex, crtcdata);
-
-        return 11;
-}
-
-static int
-init_not(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_NOT   opcode: 0x38 ('8')
-         *
-         * offset      (8  bit): opcode
-         *
-         * Invert the current execute / no-execute condition (i.e. "else")
-         */
-        if (iexec->execute)
-                BIOSLOG(bios, "0x%04X: ------ Skipping following commands  ------\n", offset);
-        else
-                BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", offset);
-
-        iexec->execute = !iexec->execute;
-        return 1;
-}
-
-static int
-init_io_flag_condition(struct nvbios *bios, uint16_t offset,
-                       struct init_exec *iexec)
-{
-        /*
-         * INIT_IO_FLAG_CONDITION   opcode: 0x39 ('9')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): condition number
-         *
-         * Check condition "condition number" in the IO flag condition table.
-         * If condition not met skip subsequent opcodes until condition is
-         * inverted (INIT_NOT), or we hit INIT_RESUME
-         */
-
-        uint8_t cond = bios->data[offset + 1];
-
-        if (!iexec->execute)
-                return 2;
-
-        if (io_flag_condition_met(bios, offset, cond))
-                BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
-        else {
-                BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
-                iexec->execute = false;
-        }
-
-        return 2;
-}
-
-static int
-init_dp_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_DP_CONDITION   opcode: 0x3A ('')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): "sub" opcode
-         * offset + 2  (8 bit): unknown
-         *
-         */
-
-        struct dcb_entry *dcb = bios->display.output;
-        struct drm_device *dev = bios->dev;
-        uint8_t cond = bios->data[offset + 1];
-        uint8_t *table, *entry;
-
-        BIOSLOG(bios, "0x%04X: subop 0x%02X\n", offset, cond);
-
-        if (!iexec->execute)
-                return 3;
-
-        table = nouveau_dp_bios_data(dev, dcb, &entry);
-        if (!table)
-                return 3;
-
-        switch (cond) {
-        case 0:
-                entry = dcb_conn(dev, dcb->connector);
-                if (!entry || entry[0] != DCB_CONNECTOR_eDP)
-                        iexec->execute = false;
-                break;
-        case 1:
-        case 2:
-                if ((table[0]  < 0x40 && !(entry[5] & cond)) ||
-                    (table[0] == 0x40 && !(entry[4] & cond)))
-                        iexec->execute = false;
-                break;
-        case 5:
-        {
-                struct nouveau_i2c_chan *auxch;
-                int ret;
-
-                auxch = nouveau_i2c_find(dev, bios->display.output->i2c_index);
-                if (!auxch) {
-                        NV_ERROR(dev, "0x%04X: couldn't get auxch\n", offset);
-                        return 3;
-                }
-
-                ret = nouveau_dp_auxch(auxch, 9, 0xd, &cond, 1);
-                if (ret) {
-                        NV_ERROR(dev, "0x%04X: auxch rd fail: %d\n", offset, ret);
-                        return 3;
-                }
-
-                if (!(cond & 1))
-                        iexec->execute = false;
-        }
-                break;
-        default:
-                NV_WARN(dev, "0x%04X: unknown INIT_3A op: %d\n", offset, cond);
-                break;
-        }
-
-        if (iexec->execute)
-                BIOSLOG(bios, "0x%04X: continuing to execute\n", offset);
-        else
-                BIOSLOG(bios, "0x%04X: skipping following commands\n", offset);
-
-        return 3;
-}
-
-static int
-init_op_3b(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_3B   opcode: 0x3B ('')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): crtc index
-         *
-         */
-
-        uint8_t or = ffs(bios->display.output->or) - 1;
-        uint8_t index = bios->data[offset + 1];
-        uint8_t data;
-
-        if (!iexec->execute)
-                return 2;
-
-        data = bios_idxprt_rd(bios, 0x3d4, index);
-        bios_idxprt_wr(bios, 0x3d4, index, data & ~(1 << or));
-        return 2;
-}
-
-static int
-init_op_3c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_3C   opcode: 0x3C ('')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): crtc index
-         *
-         */
-
-        uint8_t or = ffs(bios->display.output->or) - 1;
-        uint8_t index = bios->data[offset + 1];
-        uint8_t data;
-
-        if (!iexec->execute)
-                return 2;
-
-        data = bios_idxprt_rd(bios, 0x3d4, index);
-        bios_idxprt_wr(bios, 0x3d4, index, data | (1 << or));
-        return 2;
-}
-
-static int
-init_idx_addr_latched(struct nvbios *bios, uint16_t offset,
-                      struct init_exec *iexec)
-{
-        /*
-         * INIT_INDEX_ADDRESS_LATCHED   opcode: 0x49 ('I')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): control register
-         * offset + 5  (32 bit): data register
-         * offset + 9  (32 bit): mask
-         * offset + 13 (32 bit): data
-         * offset + 17 (8  bit): count
-         * offset + 18 (8  bit): address 1
-         * offset + 19 (8  bit): data 1
-         * ...
-         *
-         * For each of "count" address and data pairs, write "data n" to
-         * "data register", read the current value of "control register",
-         * and write it back once ANDed with "mask", ORed with "data",
-         * and ORed with "address n"
-         */
-
-        uint32_t controlreg = ROM32(bios->data[offset + 1]);
-        uint32_t datareg = ROM32(bios->data[offset + 5]);
-        uint32_t mask = ROM32(bios->data[offset + 9]);
-        uint32_t data = ROM32(bios->data[offset + 13]);
-        uint8_t count = bios->data[offset + 17];
-        int len = 18 + count * 2;
-        uint32_t value;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: ControlReg: 0x%08X, DataReg: 0x%08X, "
-                      "Mask: 0x%08X, Data: 0x%08X, Count: 0x%02X\n",
-                offset, controlreg, datareg, mask, data, count);
-
-        for (i = 0; i < count; i++) {
-                uint8_t instaddress = bios->data[offset + 18 + i * 2];
-                uint8_t instdata = bios->data[offset + 19 + i * 2];
-
-                BIOSLOG(bios, "0x%04X: Address: 0x%02X, Data: 0x%02X\n",
-                        offset, instaddress, instdata);
-
-                bios_wr32(bios, datareg, instdata);
-                value  = bios_rd32(bios, controlreg) & mask;
-                value |= data;
-                value |= instaddress;
-                bios_wr32(bios, controlreg, value);
-        }
-
-        return len;
-}
-
-static int
-init_io_restrict_pll2(struct nvbios *bios, uint16_t offset,
-                      struct init_exec *iexec)
-{
-        /*
-         * INIT_IO_RESTRICT_PLL2   opcode: 0x4A ('J')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): CRTC port
-         * offset + 3  (8  bit): CRTC index
-         * offset + 4  (8  bit): mask
-         * offset + 5  (8  bit): shift
-         * offset + 6  (8  bit): count
-         * offset + 7  (32 bit): register
-         * offset + 11 (32 bit): frequency 1
-         * ...
-         *
-         * Starting at offset + 11 there are "count" 32 bit frequencies (kHz).
-         * Set PLL register "register" to coefficients for frequency n,
-         * selected by reading index "CRTC index" of "CRTC port" ANDed with
-         * "mask" and shifted right by "shift".
-         */
-
-        uint16_t crtcport = ROM16(bios->data[offset + 1]);
-        uint8_t crtcindex = bios->data[offset + 3];
-        uint8_t mask = bios->data[offset + 4];
-        uint8_t shift = bios->data[offset + 5];
-        uint8_t count = bios->data[offset + 6];
-        uint32_t reg = ROM32(bios->data[offset + 7]);
-        int len = 11 + count * 4;
-        uint8_t config;
-        uint32_t freq;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
-                      "Shift: 0x%02X, Count: 0x%02X, Reg: 0x%08X\n",
-                offset, crtcport, crtcindex, mask, shift, count, reg);
-
-        if (!reg)
-                return len;
-
-        config = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) >> shift;
-        if (config > count) {
-                NV_ERROR(bios->dev,
-                         "0x%04X: Config 0x%02X exceeds maximal bound 0x%02X\n",
-                         offset, config, count);
-                return len;
-        }
-
-        freq = ROM32(bios->data[offset + 11 + config * 4]);
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Config: 0x%02X, Freq: %dkHz\n",
-                offset, reg, config, freq);
-
-        setPLL(bios, reg, freq);
-
-        return len;
-}
-
-static int
-init_pll2(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_PLL2   opcode: 0x4B ('K')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (32 bit): freq
-         *
-         * Set PLL register "register" to coefficients for frequency "freq"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint32_t freq = ROM32(bios->data[offset + 5]);
-
-        if (!iexec->execute)
-                return 9;
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%04X, Freq: %dkHz\n",
-                offset, reg, freq);
-
-        setPLL(bios, reg, freq);
-        return 9;
-}
-
-static int
-init_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_I2C_BYTE   opcode: 0x4C ('L')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): DCB I2C table entry index
-         * offset + 2  (8 bit): I2C slave address
-         * offset + 3  (8 bit): count
-         * offset + 4  (8 bit): I2C register 1
-         * offset + 5  (8 bit): mask 1
-         * offset + 6  (8 bit): data 1
-         * ...
-         *
-         * For each of "count" registers given by "I2C register n" on the device
-         * addressed by "I2C slave address" on the I2C bus given by
-         * "DCB I2C table entry index", read the register, AND the result with
-         * "mask n" and OR it with "data n" before writing it back to the device
-         */
-
-        struct drm_device *dev = bios->dev;
-        uint8_t i2c_index = bios->data[offset + 1];
-        uint8_t i2c_address = bios->data[offset + 2] >> 1;
-        uint8_t count = bios->data[offset + 3];
-        struct nouveau_i2c_chan *chan;
-        int len = 4 + count * 3;
-        int ret, i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
-                      "Count: 0x%02X\n",
-                offset, i2c_index, i2c_address, count);
-
-        chan = init_i2c_device_find(dev, i2c_index);
-        if (!chan) {
-                NV_ERROR(dev, "0x%04X: i2c bus not found\n", offset);
-                return len;
-        }
-
-        for (i = 0; i < count; i++) {
-                uint8_t reg = bios->data[offset + 4 + i * 3];
-                uint8_t mask = bios->data[offset + 5 + i * 3];
-                uint8_t data = bios->data[offset + 6 + i * 3];
-                union i2c_smbus_data val;
-
-                ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
-                                     I2C_SMBUS_READ, reg,
-                                     I2C_SMBUS_BYTE_DATA, &val);
-                if (ret < 0) {
-                        NV_ERROR(dev, "0x%04X: i2c rd fail: %d\n", offset, ret);
-                        return len;
-                }
-
-                BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Value: 0x%02X, "
-                              "Mask: 0x%02X, Data: 0x%02X\n",
-                        offset, reg, val.byte, mask, data);
-
-                if (!bios->execute)
-                        continue;
-
-                val.byte &= mask;
-                val.byte |= data;
-                ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
-                                     I2C_SMBUS_WRITE, reg,
-                                     I2C_SMBUS_BYTE_DATA, &val);
-                if (ret < 0) {
-                        NV_ERROR(dev, "0x%04X: i2c wr fail: %d\n", offset, ret);
-                        return len;
-                }
-        }
-
-        return len;
-}
-
-static int
-init_zm_i2c_byte(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_I2C_BYTE   opcode: 0x4D ('M')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): DCB I2C table entry index
-         * offset + 2  (8 bit): I2C slave address
-         * offset + 3  (8 bit): count
-         * offset + 4  (8 bit): I2C register 1
-         * offset + 5  (8 bit): data 1
-         * ...
-         *
-         * For each of "count" registers given by "I2C register n" on the device
-         * addressed by "I2C slave address" on the I2C bus given by
-         * "DCB I2C table entry index", set the register to "data n"
-         */
-
-        struct drm_device *dev = bios->dev;
-        uint8_t i2c_index = bios->data[offset + 1];
-        uint8_t i2c_address = bios->data[offset + 2] >> 1;
-        uint8_t count = bios->data[offset + 3];
-        struct nouveau_i2c_chan *chan;
-        int len = 4 + count * 2;
-        int ret, i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
-                      "Count: 0x%02X\n",
-                offset, i2c_index, i2c_address, count);
-
-        chan = init_i2c_device_find(dev, i2c_index);
-        if (!chan) {
-                NV_ERROR(dev, "0x%04X: i2c bus not found\n", offset);
-                return len;
-        }
-
-        for (i = 0; i < count; i++) {
-                uint8_t reg = bios->data[offset + 4 + i * 2];
-                union i2c_smbus_data val;
-
-                val.byte = bios->data[offset + 5 + i * 2];
-
-                BIOSLOG(bios, "0x%04X: I2CReg: 0x%02X, Data: 0x%02X\n",
-                        offset, reg, val.byte);
-
-                if (!bios->execute)
-                        continue;
-
-                ret = i2c_smbus_xfer(&chan->adapter, i2c_address, 0,
-                                     I2C_SMBUS_WRITE, reg,
-                                     I2C_SMBUS_BYTE_DATA, &val);
-                if (ret < 0) {
-                        NV_ERROR(dev, "0x%04X: i2c wr fail: %d\n", offset, ret);
-                        return len;
-                }
-        }
-
-        return len;
-}
-
-static int
-init_zm_i2c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_I2C   opcode: 0x4E ('N')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): DCB I2C table entry index
-         * offset + 2  (8 bit): I2C slave address
-         * offset + 3  (8 bit): count
-         * offset + 4  (8 bit): data 1
-         * ...
-         *
-         * Send "count" bytes ("data n") to the device addressed by "I2C slave
-         * address" on the I2C bus given by "DCB I2C table entry index"
-         */
-
-        struct drm_device *dev = bios->dev;
-        uint8_t i2c_index = bios->data[offset + 1];
-        uint8_t i2c_address = bios->data[offset + 2] >> 1;
-        uint8_t count = bios->data[offset + 3];
-        int len = 4 + count;
-        struct nouveau_i2c_chan *chan;
-        struct i2c_msg msg;
-        uint8_t data[256];
-        int ret, i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: DCBI2CIndex: 0x%02X, I2CAddress: 0x%02X, "
-                      "Count: 0x%02X\n",
-                offset, i2c_index, i2c_address, count);
-
-        chan = init_i2c_device_find(dev, i2c_index);
-        if (!chan) {
-                NV_ERROR(dev, "0x%04X: i2c bus not found\n", offset);
-                return len;
-        }
-
-        for (i = 0; i < count; i++) {
-                data[i] = bios->data[offset + 4 + i];
-
-                BIOSLOG(bios, "0x%04X: Data: 0x%02X\n", offset, data[i]);
-        }
-
-        if (bios->execute) {
-                msg.addr = i2c_address;
-                msg.flags = 0;
-                msg.len = count;
-                msg.buf = data;
-                ret = i2c_transfer(&chan->adapter, &msg, 1);
-                if (ret != 1) {
-                        NV_ERROR(dev, "0x%04X: i2c wr fail: %d\n", offset, ret);
-                        return len;
-                }
-        }
-
-        return len;
-}
-
-static int
-init_tmds(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_TMDS   opcode: 0x4F ('O')       (non-canon name)
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): magic lookup value
-         * offset + 2  (8 bit): TMDS address
-         * offset + 3  (8 bit): mask
-         * offset + 4  (8 bit): data
-         *
-         * Read the data reg for TMDS address "TMDS address", AND it with mask
-         * and OR it with data, then write it back
-         * "magic lookup value" determines which TMDS base address register is
-         * used -- see get_tmds_index_reg()
-         */
-
-        struct drm_device *dev = bios->dev;
-        uint8_t mlv = bios->data[offset + 1];
-        uint32_t tmdsaddr = bios->data[offset + 2];
-        uint8_t mask = bios->data[offset + 3];
-        uint8_t data = bios->data[offset + 4];
-        uint32_t reg, value;
-
-        if (!iexec->execute)
-                return 5;
-
-        BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, TMDSAddr: 0x%02X, "
-                      "Mask: 0x%02X, Data: 0x%02X\n",
-                offset, mlv, tmdsaddr, mask, data);
-
-        reg = get_tmds_index_reg(bios->dev, mlv);
-        if (!reg) {
-                NV_ERROR(dev, "0x%04X: no tmds_index_reg\n", offset);
-                return 5;
-        }
-
-        bios_wr32(bios, reg,
-                  tmdsaddr | NV_PRAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE);
-        value = (bios_rd32(bios, reg + 4) & mask) | data;
-        bios_wr32(bios, reg + 4, value);
-        bios_wr32(bios, reg, tmdsaddr);
-
-        return 5;
-}
-
-static int
-init_zm_tmds_group(struct nvbios *bios, uint16_t offset,
-                   struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_TMDS_GROUP   opcode: 0x50 ('P')      (non-canon name)
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): magic lookup value
-         * offset + 2  (8 bit): count
-         * offset + 3  (8 bit): addr 1
-         * offset + 4  (8 bit): data 1
-         * ...
-         *
-         * For each of "count" TMDS address and data pairs write "data n" to
-         * "addr n".  "magic lookup value" determines which TMDS base address
-         * register is used -- see get_tmds_index_reg()
-         */
-
-        struct drm_device *dev = bios->dev;
-        uint8_t mlv = bios->data[offset + 1];
-        uint8_t count = bios->data[offset + 2];
-        int len = 3 + count * 2;
-        uint32_t reg;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: MagicLookupValue: 0x%02X, Count: 0x%02X\n",
-                offset, mlv, count);
-
-        reg = get_tmds_index_reg(bios->dev, mlv);
-        if (!reg) {
-                NV_ERROR(dev, "0x%04X: no tmds_index_reg\n", offset);
-                return len;
-        }
-
-        for (i = 0; i < count; i++) {
-                uint8_t tmdsaddr = bios->data[offset + 3 + i * 2];
-                uint8_t tmdsdata = bios->data[offset + 4 + i * 2];
-
-                bios_wr32(bios, reg + 4, tmdsdata);
-                bios_wr32(bios, reg, tmdsaddr);
-        }
-
-        return len;
-}
-
-static int
-init_cr_idx_adr_latch(struct nvbios *bios, uint16_t offset,
-                      struct init_exec *iexec)
-{
-        /*
-         * INIT_CR_INDEX_ADDRESS_LATCHED   opcode: 0x51 ('Q')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): CRTC index1
-         * offset + 2  (8 bit): CRTC index2
-         * offset + 3  (8 bit): baseaddr
-         * offset + 4  (8 bit): count
-         * offset + 5  (8 bit): data 1
-         * ...
-         *
-         * For each of "count" address and data pairs, write "baseaddr + n" to
-         * "CRTC index1" and "data n" to "CRTC index2"
-         * Once complete, restore initial value read from "CRTC index1"
-         */
-        uint8_t crtcindex1 = bios->data[offset + 1];
-        uint8_t crtcindex2 = bios->data[offset + 2];
-        uint8_t baseaddr = bios->data[offset + 3];
-        uint8_t count = bios->data[offset + 4];
-        int len = 5 + count;
-        uint8_t oldaddr, data;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: Index1: 0x%02X, Index2: 0x%02X, "
-                      "BaseAddr: 0x%02X, Count: 0x%02X\n",
-                offset, crtcindex1, crtcindex2, baseaddr, count);
-
-        oldaddr = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex1);
-
-        for (i = 0; i < count; i++) {
-                bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1,
-                                     baseaddr + i);
-                data = bios->data[offset + 5 + i];
-                bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex2, data);
-        }
-
-        bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex1, oldaddr);
-
-        return len;
-}
-
-static int
-init_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_CR   opcode: 0x52 ('R')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (8  bit): CRTC index
-         * offset + 2  (8  bit): mask
-         * offset + 3  (8  bit): data
-         *
-         * Assign the value of at "CRTC index" ANDed with mask and ORed with
-         * data back to "CRTC index"
-         */
-
-        uint8_t crtcindex = bios->data[offset + 1];
-        uint8_t mask = bios->data[offset + 2];
-        uint8_t data = bios->data[offset + 3];
-        uint8_t value;
-
-        if (!iexec->execute)
-                return 4;
-
-        BIOSLOG(bios, "0x%04X: Index: 0x%02X, Mask: 0x%02X, Data: 0x%02X\n",
-                offset, crtcindex, mask, data);
-
-        value  = bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, crtcindex) & mask;
-        value |= data;
-        bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, value);
-
-        return 4;
-}
-
-static int
-init_zm_cr(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_CR   opcode: 0x53 ('S')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): CRTC index
-         * offset + 2  (8 bit): value
-         *
-         * Assign "value" to CRTC register with index "CRTC index".
-         */
-
-        uint8_t crtcindex = ROM32(bios->data[offset + 1]);
-        uint8_t data = bios->data[offset + 2];
-
-        if (!iexec->execute)
-                return 3;
-
-        bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, crtcindex, data);
-
-        return 3;
-}
-
-static int
-init_zm_cr_group(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_CR_GROUP   opcode: 0x54 ('T')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): count
-         * offset + 2  (8 bit): CRTC index 1
-         * offset + 3  (8 bit): value 1
-         * ...
-         *
-         * For "count", assign "value n" to CRTC register with index
-         * "CRTC index n".
-         */
-
-        uint8_t count = bios->data[offset + 1];
-        int len = 2 + count * 2;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        for (i = 0; i < count; i++)
-                init_zm_cr(bios, offset + 2 + 2 * i - 1, iexec);
-
-        return len;
-}
-
-static int
-init_condition_time(struct nvbios *bios, uint16_t offset,
-                    struct init_exec *iexec)
-{
-        /*
-         * INIT_CONDITION_TIME   opcode: 0x56 ('V')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): condition number
-         * offset + 2  (8 bit): retries / 50
-         *
-         * Check condition "condition number" in the condition table.
-         * Bios code then sleeps for 2ms if the condition is not met, and
-         * repeats up to "retries" times, but on one C51 this has proved
-         * insufficient.  In mmiotraces the driver sleeps for 20ms, so we do
-         * this, and bail after "retries" times, or 2s, whichever is less.
-         * If still not met after retries, clear execution flag for this table.
-         */
-
-        uint8_t cond = bios->data[offset + 1];
-        uint16_t retries = bios->data[offset + 2] * 50;
-        unsigned cnt;
-
-        if (!iexec->execute)
-                return 3;
-
-        if (retries > 100)
-                retries = 100;
-
-        BIOSLOG(bios, "0x%04X: Condition: 0x%02X, Retries: 0x%02X\n",
-                offset, cond, retries);
-
-        if (!bios->execute) /* avoid 2s delays when "faking" execution */
-                retries = 1;
-
-        for (cnt = 0; cnt < retries; cnt++) {
-                if (bios_condition_met(bios, offset, cond)) {
-                        BIOSLOG(bios, "0x%04X: Condition met, continuing\n",
-                                                                offset);
-                        break;
-                } else {
-                        BIOSLOG(bios, "0x%04X: "
-                                "Condition not met, sleeping for 20ms\n",
-                                                                offset);
-                        mdelay(20);
-                }
-        }
-
-        if (!bios_condition_met(bios, offset, cond)) {
-                NV_WARN(bios->dev,
-                        "0x%04X: Condition still not met after %dms, "
-                        "skipping following opcodes\n", offset, 20 * retries);
-                iexec->execute = false;
-        }
-
-        return 3;
-}
-
-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" milliseconds.
-         */
-
-        unsigned time = ROM16(bios->data[offset + 1]);
-
-        if (!iexec->execute)
-                return 3;
-
-        BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X milliseconds\n",
-                offset, time);
-
-        mdelay(time);
-
-        return 3;
-}
-
-static int
-init_zm_reg_sequence(struct nvbios *bios, uint16_t offset,
-                     struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_REG_SEQUENCE   opcode: 0x58 ('X')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): base register
-         * offset + 5  (8  bit): count
-         * offset + 6  (32 bit): value 1
-         * ...
-         *
-         * Starting at offset + 6 there are "count" 32 bit values.
-         * For "count" iterations set "base register" + 4 * current_iteration
-         * to "value current_iteration"
-         */
-
-        uint32_t basereg = ROM32(bios->data[offset + 1]);
-        uint32_t count = bios->data[offset + 5];
-        int len = 6 + count * 4;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        BIOSLOG(bios, "0x%04X: BaseReg: 0x%08X, Count: 0x%02X\n",
-                offset, basereg, count);
-
-        for (i = 0; i < count; i++) {
-                uint32_t reg = basereg + i * 4;
-                uint32_t data = ROM32(bios->data[offset + 6 + i * 4]);
-
-                bios_wr32(bios, reg, data);
-        }
-
-        return len;
-}
-
-static int
-init_sub_direct(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_SUB_DIRECT   opcode: 0x5B ('[')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): subroutine offset (in bios)
-         *
-         * Calls a subroutine that will execute commands until INIT_DONE
-         * is found.
-         */
-
-        uint16_t sub_offset = ROM16(bios->data[offset + 1]);
-
-        if (!iexec->execute)
-                return 3;
-
-        BIOSLOG(bios, "0x%04X: Executing subroutine at 0x%04X\n",
-                offset, sub_offset);
-
-        parse_init_table(bios, sub_offset, iexec);
-
-        BIOSLOG(bios, "0x%04X: End of 0x%04X subroutine\n", offset, sub_offset);
-
-        return 3;
-}
-
-static int
-init_jump(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_JUMP   opcode: 0x5C ('\')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): offset (in bios)
-         *
-         * Continue execution of init table from 'offset'
-         */
-
-        uint16_t jmp_offset = ROM16(bios->data[offset + 1]);
-
-        if (!iexec->execute)
-                return 3;
-
-        BIOSLOG(bios, "0x%04X: Jump to 0x%04X\n", offset, jmp_offset);
-        return jmp_offset - offset;
-}
-
-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)
-{
-        /*
-         * INIT_COPY_NV_REG   opcode: 0x5F ('_')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): src reg
-         * offset + 5  (8  bit): shift
-         * offset + 6  (32 bit): src mask
-         * offset + 10 (32 bit): xor
-         * offset + 14 (32 bit): dst reg
-         * offset + 18 (32 bit): dst mask
-         *
-         * Shift REGVAL("src reg") right by (signed) "shift", AND result with
-         * "src mask", then XOR with "xor". Write this OR'd with
-         * (REGVAL("dst reg") AND'd with "dst mask") to "dst reg"
-         */
-
-        uint32_t srcreg = *((uint32_t *)(&bios->data[offset + 1]));
-        uint8_t shift = bios->data[offset + 5];
-        uint32_t srcmask = *((uint32_t *)(&bios->data[offset + 6]));
-        uint32_t xor = *((uint32_t *)(&bios->data[offset + 10]));
-        uint32_t dstreg = *((uint32_t *)(&bios->data[offset + 14]));
-        uint32_t dstmask = *((uint32_t *)(&bios->data[offset + 18]));
-        uint32_t srcvalue, dstvalue;
-
-        if (!iexec->execute)
-                return 22;
-
-        BIOSLOG(bios, "0x%04X: SrcReg: 0x%08X, Shift: 0x%02X, SrcMask: 0x%08X, "
-                      "Xor: 0x%08X, DstReg: 0x%08X, DstMask: 0x%08X\n",
-                offset, srcreg, shift, srcmask, xor, dstreg, dstmask);
-
-        srcvalue = bios_rd32(bios, srcreg);
-
-        if (shift < 0x80)
-                srcvalue >>= shift;
-        else
-                srcvalue <<= (0x100 - shift);
-
-        srcvalue = (srcvalue & srcmask) ^ xor;
-
-        dstvalue = bios_rd32(bios, dstreg) & dstmask;
-
-        bios_wr32(bios, dstreg, dstvalue | srcvalue);
-
-        return 22;
-}
-
-static int
-init_zm_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_INDEX_IO   opcode: 0x62 ('b')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): CRTC port
-         * offset + 3  (8  bit): CRTC index
-         * offset + 4  (8  bit): data
-         *
-         * Write "data" to index "CRTC index" of "CRTC port"
-         */
-        uint16_t crtcport = ROM16(bios->data[offset + 1]);
-        uint8_t crtcindex = bios->data[offset + 3];
-        uint8_t data = bios->data[offset + 4];
-
-        if (!iexec->execute)
-                return 5;
-
-        bios_idxprt_wr(bios, crtcport, crtcindex, data);
-
-        return 5;
-}
-
-static inline void
-bios_md32(struct nvbios *bios, uint32_t reg,
-          uint32_t mask, uint32_t val)
-{
-        bios_wr32(bios, reg, (bios_rd32(bios, reg) & ~mask) | val);
-}
-
-static uint32_t
-peek_fb(struct drm_device *dev, struct io_mapping *fb,
-        uint32_t off)
-{
-        uint32_t val = 0;
-
-        if (off < pci_resource_len(dev->pdev, 1)) {
-                uint8_t __iomem *p =
-                        io_mapping_map_atomic_wc(fb, off & PAGE_MASK);
-
-                val = ioread32(p + (off & ~PAGE_MASK));
-
-                io_mapping_unmap_atomic(p);
-        }
-
-        return val;
-}
-
-static void
-poke_fb(struct drm_device *dev, struct io_mapping *fb,
-        uint32_t off, uint32_t val)
-{
-        if (off < pci_resource_len(dev->pdev, 1)) {
-                uint8_t __iomem *p =
-                        io_mapping_map_atomic_wc(fb, off & PAGE_MASK);
-
-                iowrite32(val, p + (off & ~PAGE_MASK));
-                wmb();
-
-                io_mapping_unmap_atomic(p);
-        }
-}
-
-static inline bool
-read_back_fb(struct drm_device *dev, struct io_mapping *fb,
-             uint32_t off, uint32_t val)
-{
-        poke_fb(dev, fb, off, val);
-        return val == peek_fb(dev, fb, off);
-}
-
-static int
-nv04_init_compute_mem(struct nvbios *bios)
-{
-        struct drm_device *dev = bios->dev;
-        uint32_t patt = 0xdeadbeef;
-        struct io_mapping *fb;
-        int i;
-
-        /* Map the framebuffer aperture */
-        fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
-                                  pci_resource_len(dev->pdev, 1));
-        if (!fb)
-                return -ENOMEM;
-
-        /* Sequencer and refresh off */
-        NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) | 0x20);
-        bios_md32(bios, NV04_PFB_DEBUG_0, 0, NV04_PFB_DEBUG_0_REFRESH_OFF);
-
-        bios_md32(bios, NV04_PFB_BOOT_0, ~0,
-                  NV04_PFB_BOOT_0_RAM_AMOUNT_16MB |
-                  NV04_PFB_BOOT_0_RAM_WIDTH_128 |
-                  NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_16MBIT);
-
-        for (i = 0; i < 4; i++)
-                poke_fb(dev, fb, 4 * i, patt);
-
-        poke_fb(dev, fb, 0x400000, patt + 1);
-
-        if (peek_fb(dev, fb, 0) == patt + 1) {
-                bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_TYPE,
-                          NV04_PFB_BOOT_0_RAM_TYPE_SDRAM_16MBIT);
-                bios_md32(bios, NV04_PFB_DEBUG_0,
-                          NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
-
-                for (i = 0; i < 4; i++)
-                        poke_fb(dev, fb, 4 * i, patt);
-
-                if ((peek_fb(dev, fb, 0xc) & 0xffff) != (patt & 0xffff))
-                        bios_md32(bios, NV04_PFB_BOOT_0,
-                                  NV04_PFB_BOOT_0_RAM_WIDTH_128 |
-                                  NV04_PFB_BOOT_0_RAM_AMOUNT,
-                                  NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
-
-        } else if ((peek_fb(dev, fb, 0xc) & 0xffff0000) !=
-                   (patt & 0xffff0000)) {
-                bios_md32(bios, NV04_PFB_BOOT_0,
-                          NV04_PFB_BOOT_0_RAM_WIDTH_128 |
-                          NV04_PFB_BOOT_0_RAM_AMOUNT,
-                          NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
-
-        } 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,
-                                  NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
-                else
-                        bios_md32(bios, NV04_PFB_BOOT_0,
-                                  NV04_PFB_BOOT_0_RAM_AMOUNT,
-                                  NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
-
-                bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_TYPE,
-                          NV04_PFB_BOOT_0_RAM_TYPE_SGRAM_8MBIT);
-
-        } else if (!read_back_fb(dev, fb, 0x800000, patt)) {
-                bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
-                          NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
-
-        }
-
-        /* Refresh on, sequencer on */
-        bios_md32(bios, NV04_PFB_DEBUG_0, NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
-        NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) & ~0x20);
-
-        io_mapping_free(fb);
-        return 0;
-}
-
-static const uint8_t *
-nv05_memory_config(struct nvbios *bios)
-{
-        /* Defaults for BIOSes lacking a memory config table */
-        static const uint8_t default_config_tab[][2] = {
-                { 0x24, 0x00 },
-                { 0x28, 0x00 },
-                { 0x24, 0x01 },
-                { 0x1f, 0x00 },
-                { 0x0f, 0x00 },
-                { 0x17, 0x00 },
-                { 0x06, 0x00 },
-                { 0x00, 0x00 }
-        };
-        int i = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) &
-                 NV_PEXTDEV_BOOT_0_RAMCFG) >> 2;
-
-        if (bios->legacy.mem_init_tbl_ptr)
-                return &bios->data[bios->legacy.mem_init_tbl_ptr + 2 * i];
-        else
-                return default_config_tab[i];
-}
-
-static int
-nv05_init_compute_mem(struct nvbios *bios)
-{
-        struct drm_device *dev = bios->dev;
-        const uint8_t *ramcfg = nv05_memory_config(bios);
-        uint32_t patt = 0xdeadbeef;
-        struct io_mapping *fb;
-        int i, v;
-
-        /* Map the framebuffer aperture */
-        fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
-                                  pci_resource_len(dev->pdev, 1));
-        if (!fb)
-                return -ENOMEM;
-
-        /* Sequencer off */
-        NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) | 0x20);
-
-        if (bios_rd32(bios, NV04_PFB_BOOT_0) & NV04_PFB_BOOT_0_UMA_ENABLE)
-                goto out;
-
-        bios_md32(bios, NV04_PFB_DEBUG_0, NV04_PFB_DEBUG_0_REFRESH_OFF, 0);
-
-        /* If present load the hardcoded scrambling table */
-        if (bios->legacy.mem_init_tbl_ptr) {
-                uint32_t *scramble_tab = (uint32_t *)&bios->data[
-                        bios->legacy.mem_init_tbl_ptr + 0x10];
-
-                for (i = 0; i < 8; i++)
-                        bios_wr32(bios, NV04_PFB_SCRAMBLE(i),
-                                  ROM32(scramble_tab[i]));
-        }
-
-        /* Set memory type/width/length defaults depending on the straps */
-        bios_md32(bios, NV04_PFB_BOOT_0, 0x3f, ramcfg[0]);
-
-        if (ramcfg[1] & 0x80)
-                bios_md32(bios, NV04_PFB_CFG0, 0, NV04_PFB_CFG0_SCRAMBLE);
-
-        bios_md32(bios, NV04_PFB_CFG1, 0x700001, (ramcfg[1] & 1) << 20);
-        bios_md32(bios, NV04_PFB_CFG1, 0, 1);
-
-        /* Probe memory bus width */
-        for (i = 0; i < 4; i++)
-                poke_fb(dev, fb, 4 * i, patt);
-
-        if (peek_fb(dev, fb, 0xc) != patt)
-                bios_md32(bios, NV04_PFB_BOOT_0,
-                          NV04_PFB_BOOT_0_RAM_WIDTH_128, 0);
-
-        /* Probe memory length */
-        v = bios_rd32(bios, NV04_PFB_BOOT_0) & NV04_PFB_BOOT_0_RAM_AMOUNT;
-
-        if (v == NV04_PFB_BOOT_0_RAM_AMOUNT_32MB &&
-            (!read_back_fb(dev, fb, 0x1000000, ++patt) ||
-             !read_back_fb(dev, fb, 0, ++patt)))
-                bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
-                          NV04_PFB_BOOT_0_RAM_AMOUNT_16MB);
-
-        if (v == NV04_PFB_BOOT_0_RAM_AMOUNT_16MB &&
-            !read_back_fb(dev, fb, 0x800000, ++patt))
-                bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
-                          NV04_PFB_BOOT_0_RAM_AMOUNT_8MB);
-
-        if (!read_back_fb(dev, fb, 0x400000, ++patt))
-                bios_md32(bios, NV04_PFB_BOOT_0, NV04_PFB_BOOT_0_RAM_AMOUNT,
-                          NV04_PFB_BOOT_0_RAM_AMOUNT_4MB);
-
-out:
-        /* Sequencer on */
-        NVWriteVgaSeq(dev, 0, 1, NVReadVgaSeq(dev, 0, 1) & ~0x20);
-
-        io_mapping_free(fb);
-        return 0;
-}
-
-static int
-nv10_init_compute_mem(struct nvbios *bios)
-{
-        struct drm_device *dev = bios->dev;
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        const int mem_width[] = { 0x10, 0x00, 0x20 };
-        const int mem_width_count = (dev_priv->chipset >= 0x17 ? 3 : 2);
-        uint32_t patt = 0xdeadbeef;
-        struct io_mapping *fb;
-        int i, j, k;
-
-        /* Map the framebuffer aperture */
-        fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
-                                  pci_resource_len(dev->pdev, 1));
-        if (!fb)
-                return -ENOMEM;
-
-        bios_wr32(bios, NV10_PFB_REFCTRL, NV10_PFB_REFCTRL_VALID_1);
-
-        /* Probe memory bus width */
-        for (i = 0; i < mem_width_count; i++) {
-                bios_md32(bios, NV04_PFB_CFG0, 0x30, mem_width[i]);
-
-                for (j = 0; j < 4; j++) {
-                        for (k = 0; k < 4; k++)
-                                poke_fb(dev, fb, 0x1c, 0);
-
-                        poke_fb(dev, fb, 0x1c, patt);
-                        poke_fb(dev, fb, 0x3c, 0);
-
-                        if (peek_fb(dev, fb, 0x1c) == patt)
-                                goto mem_width_found;
-                }
-        }
-
-mem_width_found:
-        patt <<= 1;
-
-        /* Probe amount of installed memory */
-        for (i = 0; i < 4; i++) {
-                int off = bios_rd32(bios, NV04_PFB_FIFO_DATA) - 0x100000;
-
-                poke_fb(dev, fb, off, patt);
-                poke_fb(dev, fb, 0, 0);
-
-                peek_fb(dev, fb, 0);
-                peek_fb(dev, fb, 0);
-                peek_fb(dev, fb, 0);
-                peek_fb(dev, fb, 0);
-
-                if (peek_fb(dev, fb, off) == patt)
-                        goto amount_found;
-        }
-
-        /* IC missing - disable the upper half memory space. */
-        bios_md32(bios, NV04_PFB_CFG0, 0x1000, 0);
-
-amount_found:
-        io_mapping_free(fb);
-        return 0;
-}
-
-static int
-nv20_init_compute_mem(struct nvbios *bios)
-{
-        struct drm_device *dev = bios->dev;
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        uint32_t mask = (dev_priv->chipset >= 0x25 ? 0x300 : 0x900);
-        uint32_t amount, off;
-        struct io_mapping *fb;
-
-        /* Map the framebuffer aperture */
-        fb = io_mapping_create_wc(pci_resource_start(dev->pdev, 1),
-                                  pci_resource_len(dev->pdev, 1));
-        if (!fb)
-                return -ENOMEM;
-
-        bios_wr32(bios, NV10_PFB_REFCTRL, NV10_PFB_REFCTRL_VALID_1);
-
-        /* Allow full addressing */
-        bios_md32(bios, NV04_PFB_CFG0, 0, mask);
-
-        amount = bios_rd32(bios, NV04_PFB_FIFO_DATA);
-        for (off = amount; off > 0x2000000; off -= 0x2000000)
-                poke_fb(dev, fb, off - 4, off);
-
-        amount = bios_rd32(bios, NV04_PFB_FIFO_DATA);
-        if (amount != peek_fb(dev, fb, amount - 4))
-                /* IC missing - disable the upper half memory space. */
-                bios_md32(bios, NV04_PFB_CFG0, mask, 0);
-
-        io_mapping_free(fb);
-        return 0;
-}
-
-static int
-init_compute_mem(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_COMPUTE_MEM   opcode: 0x63 ('c')
-         *
-         * offset      (8 bit): opcode
-         *
-         * This opcode is meant to set the PFB memory config registers
-         * appropriately so that we can correctly calculate how much VRAM it
-         * has (on nv10 and better chipsets the amount of installed VRAM is
-         * subsequently reported in NV_PFB_CSTATUS (0x10020C)).
-         *
-         * The implementation of this opcode in general consists of several
-         * parts:
-         *
-         * 1) Determination of memory type and density. Only necessary for
-         *    really old chipsets, the memory type reported by the strap bits
-         *    (0x101000) is assumed to be accurate on nv05 and newer.
-         *
-         * 2) Determination of the memory bus width. Usually done by a cunning
-         *    combination of writes to offsets 0x1c and 0x3c in the fb, and
-         *    seeing whether the written values are read back correctly.
-         *
-         *    Only necessary on nv0x-nv1x and nv34, on the other cards we can
-         *    trust the straps.
-         *
-         * 3) Determination of how many of the card's RAM pads have ICs
-         *    attached, usually done by a cunning combination of writes to an
-         *    offset slightly less than the maximum memory reported by
-         *    NV_PFB_CSTATUS, then seeing if the test pattern can be read back.
-         *
-         * This appears to be a NOP on IGPs and NV4x or newer chipsets, both io
-         * logs of the VBIOS and kmmio traces of the binary driver POSTing the
-         * card show nothing being done for this opcode. Why is it still listed
-         * in the table?!
-         */
-
-        /* no iexec->execute check by design */
-
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        int ret;
-
-        if (dev_priv->chipset >= 0x40 ||
-            dev_priv->chipset == 0x1a ||
-            dev_priv->chipset == 0x1f)
-                ret = 0;
-        else if (dev_priv->chipset >= 0x20 &&
-                 dev_priv->chipset != 0x34)
-                ret = nv20_init_compute_mem(bios);
-        else if (dev_priv->chipset >= 0x10)
-                ret = nv10_init_compute_mem(bios);
-        else if (dev_priv->chipset >= 0x5)
-                ret = nv05_init_compute_mem(bios);
-        else
-                ret = nv04_init_compute_mem(bios);
-
-        if (ret)
-                return ret;
-
-        return 1;
-}
-
-static int
-init_reset(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_RESET   opcode: 0x65 ('e')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (32 bit): value1
-         * offset + 9  (32 bit): value2
-         *
-         * Assign "value1" to "register", then assign "value2" to "register"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint32_t value1 = ROM32(bios->data[offset + 5]);
-        uint32_t value2 = ROM32(bios->data[offset + 9]);
-        uint32_t pci_nv_19, pci_nv_20;
-
-        /* no iexec->execute check by design */
-
-        pci_nv_19 = bios_rd32(bios, NV_PBUS_PCI_NV_19);
-        bios_wr32(bios, NV_PBUS_PCI_NV_19, pci_nv_19 & ~0xf00);
-
-        bios_wr32(bios, reg, value1);
-
-        udelay(10);
-
-        bios_wr32(bios, reg, value2);
-        bios_wr32(bios, NV_PBUS_PCI_NV_19, pci_nv_19);
-
-        pci_nv_20 = bios_rd32(bios, NV_PBUS_PCI_NV_20);
-        pci_nv_20 &= ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED;     /* 0xfffffffe */
-        bios_wr32(bios, NV_PBUS_PCI_NV_20, pci_nv_20);
-
-        return 13;
-}
-
-static int
-init_configure_mem(struct nvbios *bios, uint16_t offset,
-                   struct init_exec *iexec)
-{
-        /*
-         * INIT_CONFIGURE_MEM   opcode: 0x66 ('f')
-         *
-         * offset      (8 bit): opcode
-         *
-         * Equivalent to INIT_DONE on bios version 3 or greater.
-         * For early bios versions, sets up the memory registers, using values
-         * taken from the memory init table
-         */
-
-        /* no iexec->execute check by design */
-
-        uint16_t meminitoffs = bios->legacy.mem_init_tbl_ptr + MEM_INIT_SIZE * (bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_SCRATCH4__INDEX) >> 4);
-        uint16_t seqtbloffs = bios->legacy.sdr_seq_tbl_ptr, meminitdata = meminitoffs + 6;
-        uint32_t reg, data;
-
-        if (bios->major_version > 2)
-                return 0;
-
-        bios_idxprt_wr(bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX, bios_idxprt_rd(
-                       bios, NV_VIO_SRX, NV_VIO_SR_CLOCK_INDEX) | 0x20);
-
-        if (bios->data[meminitoffs] & 1)
-                seqtbloffs = bios->legacy.ddr_seq_tbl_ptr;
-
-        for (reg = ROM32(bios->data[seqtbloffs]);
-             reg != 0xffffffff;
-             reg = ROM32(bios->data[seqtbloffs += 4])) {
-
-                switch (reg) {
-                case NV04_PFB_PRE:
-                        data = NV04_PFB_PRE_CMD_PRECHARGE;
-                        break;
-                case NV04_PFB_PAD:
-                        data = NV04_PFB_PAD_CKE_NORMAL;
-                        break;
-                case NV04_PFB_REF:
-                        data = NV04_PFB_REF_CMD_REFRESH;
-                        break;
-                default:
-                        data = ROM32(bios->data[meminitdata]);
-                        meminitdata += 4;
-                        if (data == 0xffffffff)
-                                continue;
-                }
-
-                bios_wr32(bios, reg, data);
-        }
-
-        return 1;
-}
-
-static int
-init_configure_clk(struct nvbios *bios, uint16_t offset,
-                   struct init_exec *iexec)
-{
-        /*
-         * INIT_CONFIGURE_CLK   opcode: 0x67 ('g')
-         *
-         * offset      (8 bit): opcode
-         *
-         * Equivalent to INIT_DONE on bios version 3 or greater.
-         * For early bios versions, sets up the NVClk and MClk PLLs, using
-         * values taken from the memory init table
-         */
-
-        /* no iexec->execute check by design */
-
-        uint16_t meminitoffs = bios->legacy.mem_init_tbl_ptr + MEM_INIT_SIZE * (bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_SCRATCH4__INDEX) >> 4);
-        int clock;
-
-        if (bios->major_version > 2)
-                return 0;
-
-        clock = ROM16(bios->data[meminitoffs + 4]) * 10;
-        setPLL(bios, NV_PRAMDAC_NVPLL_COEFF, clock);
-
-        clock = ROM16(bios->data[meminitoffs + 2]) * 10;
-        if (bios->data[meminitoffs] & 1) /* DDR */
-                clock *= 2;
-        setPLL(bios, NV_PRAMDAC_MPLL_COEFF, clock);
-
-        return 1;
-}
-
-static int
-init_configure_preinit(struct nvbios *bios, uint16_t offset,
-                       struct init_exec *iexec)
-{
-        /*
-         * INIT_CONFIGURE_PREINIT   opcode: 0x68 ('h')
-         *
-         * offset      (8 bit): opcode
-         *
-         * Equivalent to INIT_DONE on bios version 3 or greater.
-         * For early bios versions, does early init, loading ram and crystal
-         * configuration from straps into CR3C
-         */
-
-        /* no iexec->execute check by design */
-
-        uint32_t straps = bios_rd32(bios, NV_PEXTDEV_BOOT_0);
-        uint8_t cr3c = ((straps << 2) & 0xf0) | (straps & 0x40) >> 6;
-
-        if (bios->major_version > 2)
-                return 0;
-
-        bios_idxprt_wr(bios, NV_CIO_CRX__COLOR,
-                             NV_CIO_CRE_SCRATCH4__INDEX, cr3c);
-
-        return 1;
-}
-
-static int
-init_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_IO   opcode: 0x69 ('i')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): CRTC port
-         * offset + 3  (8  bit): mask
-         * offset + 4  (8  bit): data
-         *
-         * Assign ((IOVAL("crtc port") & "mask") | "data") to "crtc port"
-         */
-
-        struct drm_nouveau_private *dev_priv = bios->dev->dev_private;
-        uint16_t crtcport = ROM16(bios->data[offset + 1]);
-        uint8_t mask = bios->data[offset + 3];
-        uint8_t data = bios->data[offset + 4];
-
-        if (!iexec->execute)
-                return 5;
-
-        BIOSLOG(bios, "0x%04X: Port: 0x%04X, Mask: 0x%02X, Data: 0x%02X\n",
-                offset, crtcport, mask, data);
-
-        /*
-         * I have no idea what this does, but NVIDIA do this magic sequence
-         * in the places where this INIT_IO happens..
-         */
-        if (dev_priv->card_type >= NV_50 && crtcport == 0x3c3 && data == 1) {
-                int i;
-
-                bios_wr32(bios, 0x614100, (bios_rd32(
-                          bios, 0x614100) & 0x0fffffff) | 0x00800000);
-
-                bios_wr32(bios, 0x00e18c, bios_rd32(
-                          bios, 0x00e18c) | 0x00020000);
-
-                bios_wr32(bios, 0x614900, (bios_rd32(
-                          bios, 0x614900) & 0x0fffffff) | 0x00800000);
-
-                bios_wr32(bios, 0x000200, bios_rd32(
-                          bios, 0x000200) & ~0x40000000);
-
-                mdelay(10);
-
-                bios_wr32(bios, 0x00e18c, bios_rd32(
-                          bios, 0x00e18c) & ~0x00020000);
-
-                bios_wr32(bios, 0x000200, bios_rd32(
-                          bios, 0x000200) | 0x40000000);
-
-                bios_wr32(bios, 0x614100, 0x00800018);
-                bios_wr32(bios, 0x614900, 0x00800018);
-
-                mdelay(10);
-
-                bios_wr32(bios, 0x614100, 0x10000018);
-                bios_wr32(bios, 0x614900, 0x10000018);
-
-                for (i = 0; i < 3; i++)
-                        bios_wr32(bios, 0x614280 + (i*0x800), bios_rd32(
-                                  bios, 0x614280 + (i*0x800)) & 0xf0f0f0f0);
-
-                for (i = 0; i < 2; i++)
-                        bios_wr32(bios, 0x614300 + (i*0x800), bios_rd32(
-                                  bios, 0x614300 + (i*0x800)) & 0xfffff0f0);
-
-                for (i = 0; i < 3; i++)
-                        bios_wr32(bios, 0x614380 + (i*0x800), bios_rd32(
-                                  bios, 0x614380 + (i*0x800)) & 0xfffff0f0);
-
-                for (i = 0; i < 2; i++)
-                        bios_wr32(bios, 0x614200 + (i*0x800), bios_rd32(
-                                  bios, 0x614200 + (i*0x800)) & 0xfffffff0);
-
-                for (i = 0; i < 2; i++)
-                        bios_wr32(bios, 0x614108 + (i*0x800), bios_rd32(
-                                  bios, 0x614108 + (i*0x800)) & 0x0fffffff);
-                return 5;
-        }
-
-        bios_port_wr(bios, crtcport, (bios_port_rd(bios, crtcport) & mask) |
-                                                                        data);
-        return 5;
-}
-
-static int
-init_sub(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_SUB   opcode: 0x6B ('k')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): script number
-         *
-         * Execute script number "script number", as a subroutine
-         */
-
-        uint8_t sub = bios->data[offset + 1];
-
-        if (!iexec->execute)
-                return 2;
-
-        BIOSLOG(bios, "0x%04X: Calling script %d\n", offset, sub);
-
-        parse_init_table(bios,
-                         ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]),
-                         iexec);
-
-        BIOSLOG(bios, "0x%04X: End of script %d\n", offset, sub);
-
-        return 2;
-}
-
-static int
-init_ram_condition(struct nvbios *bios, uint16_t offset,
-                   struct init_exec *iexec)
-{
-        /*
-         * INIT_RAM_CONDITION   opcode: 0x6D ('m')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): mask
-         * offset + 2  (8 bit): cmpval
-         *
-         * Test if (NV04_PFB_BOOT_0 & "mask") equals "cmpval".
-         * If condition not met skip subsequent opcodes until condition is
-         * inverted (INIT_NOT), or we hit INIT_RESUME
-         */
-
-        uint8_t mask = bios->data[offset + 1];
-        uint8_t cmpval = bios->data[offset + 2];
-        uint8_t data;
-
-        if (!iexec->execute)
-                return 3;
-
-        data = bios_rd32(bios, NV04_PFB_BOOT_0) & mask;
-
-        BIOSLOG(bios, "0x%04X: Checking if 0x%08X equals 0x%08X\n",
-                offset, data, cmpval);
-
-        if (data == cmpval)
-                BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
-        else {
-                BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
-                iexec->execute = false;
-        }
-
-        return 3;
-}
-
-static int
-init_nv_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_NV_REG   opcode: 0x6E ('n')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (32 bit): mask
-         * offset + 9  (32 bit): data
-         *
-         * Assign ((REGVAL("register") & "mask") | "data") to "register"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint32_t mask = ROM32(bios->data[offset + 5]);
-        uint32_t data = ROM32(bios->data[offset + 9]);
-
-        if (!iexec->execute)
-                return 13;
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Mask: 0x%08X, Data: 0x%08X\n",
-                offset, reg, mask, data);
-
-        bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | data);
-
-        return 13;
-}
-
-static int
-init_macro(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_MACRO   opcode: 0x6F ('o')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): macro number
-         *
-         * Look up macro index "macro number" in the macro index table.
-         * The macro index table entry has 1 byte for the index in the macro
-         * table, and 1 byte for the number of times to repeat the macro.
-         * The macro table entry has 4 bytes for the register address and
-         * 4 bytes for the value to write to that register
-         */
-
-        uint8_t macro_index_tbl_idx = bios->data[offset + 1];
-        uint16_t tmp = bios->macro_index_tbl_ptr + (macro_index_tbl_idx * MACRO_INDEX_SIZE);
-        uint8_t macro_tbl_idx = bios->data[tmp];
-        uint8_t count = bios->data[tmp + 1];
-        uint32_t reg, data;
-        int i;
-
-        if (!iexec->execute)
-                return 2;
-
-        BIOSLOG(bios, "0x%04X: Macro: 0x%02X, MacroTableIndex: 0x%02X, "
-                      "Count: 0x%02X\n",
-                offset, macro_index_tbl_idx, macro_tbl_idx, count);
-
-        for (i = 0; i < count; i++) {
-                uint16_t macroentryptr = bios->macro_tbl_ptr + (macro_tbl_idx + i) * MACRO_SIZE;
-
-                reg = ROM32(bios->data[macroentryptr]);
-                data = ROM32(bios->data[macroentryptr + 4]);
-
-                bios_wr32(bios, reg, data);
-        }
-
-        return 2;
-}
-
-static int
-init_done(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_DONE   opcode: 0x71 ('q')
-         *
-         * offset      (8  bit): opcode
-         *
-         * End the current script
-         */
-
-        /* mild retval abuse to stop parsing this table */
-        return 0;
-}
-
-static int
-init_resume(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_RESUME   opcode: 0x72 ('r')
-         *
-         * offset      (8  bit): opcode
-         *
-         * End the current execute / no-execute condition
-         */
-
-        if (iexec->execute)
-                return 1;
-
-        iexec->execute = true;
-        BIOSLOG(bios, "0x%04X: ---- Executing following commands ----\n", offset);
-
-        return 1;
-}
-
-static int
-init_time(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_TIME   opcode: 0x74 ('t')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): time
-         *
-         * Sleep for "time" microseconds.
-         */
-
-        unsigned time = ROM16(bios->data[offset + 1]);
-
-        if (!iexec->execute)
-                return 3;
-
-        BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X microseconds\n",
-                offset, time);
-
-        if (time < 1000)
-                udelay(time);
-        else
-                mdelay((time + 900) / 1000);
-
-        return 3;
-}
-
-static int
-init_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_CONDITION   opcode: 0x75 ('u')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): condition number
-         *
-         * Check condition "condition number" in the condition table.
-         * If condition not met skip subsequent opcodes until condition is
-         * inverted (INIT_NOT), or we hit INIT_RESUME
-         */
-
-        uint8_t cond = bios->data[offset + 1];
-
-        if (!iexec->execute)
-                return 2;
-
-        BIOSLOG(bios, "0x%04X: Condition: 0x%02X\n", offset, cond);
-
-        if (bios_condition_met(bios, offset, cond))
-                BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
-        else {
-                BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
-                iexec->execute = false;
-        }
-
-        return 2;
-}
-
-static int
-init_io_condition(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_IO_CONDITION  opcode: 0x76
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): condition number
-         *
-         * Check condition "condition number" in the io condition table.
-         * If condition not met skip subsequent opcodes until condition is
-         * inverted (INIT_NOT), or we hit INIT_RESUME
-         */
-
-        uint8_t cond = bios->data[offset + 1];
-
-        if (!iexec->execute)
-                return 2;
-
-        BIOSLOG(bios, "0x%04X: IO condition: 0x%02X\n", offset, cond);
-
-        if (io_condition_met(bios, offset, cond))
-                BIOSLOG(bios, "0x%04X: Condition fulfilled -- continuing to execute\n", offset);
-        else {
-                BIOSLOG(bios, "0x%04X: Condition not fulfilled -- skipping following commands\n", offset);
-                iexec->execute = false;
-        }
-
-        return 2;
-}
-
-static int
-init_index_io(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_INDEX_IO   opcode: 0x78 ('x')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (16 bit): CRTC port
-         * offset + 3  (8  bit): CRTC index
-         * offset + 4  (8  bit): mask
-         * offset + 5  (8  bit): data
-         *
-         * Read value at index "CRTC index" on "CRTC port", AND with "mask",
-         * OR with "data", write-back
-         */
-
-        uint16_t crtcport = ROM16(bios->data[offset + 1]);
-        uint8_t crtcindex = bios->data[offset + 3];
-        uint8_t mask = bios->data[offset + 4];
-        uint8_t data = bios->data[offset + 5];
-        uint8_t value;
-
-        if (!iexec->execute)
-                return 6;
-
-        BIOSLOG(bios, "0x%04X: Port: 0x%04X, Index: 0x%02X, Mask: 0x%02X, "
-                      "Data: 0x%02X\n",
-                offset, crtcport, crtcindex, mask, data);
-
-        value = (bios_idxprt_rd(bios, crtcport, crtcindex) & mask) | data;
-        bios_idxprt_wr(bios, crtcport, crtcindex, value);
-
-        return 6;
-}
-
-static int
-init_pll(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_PLL   opcode: 0x79 ('y')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (16 bit): freq
-         *
-         * Set PLL register "register" to coefficients for frequency (10kHz)
-         * "freq"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint16_t freq = ROM16(bios->data[offset + 5]);
-
-        if (!iexec->execute)
-                return 7;
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%08X, Freq: %d0kHz\n", offset, reg, freq);
-
-        setPLL(bios, reg, freq * 10);
-
-        return 7;
-}
-
-static int
-init_zm_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_REG   opcode: 0x7A ('z')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (32 bit): value
-         *
-         * Assign "value" to "register"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint32_t value = ROM32(bios->data[offset + 5]);
-
-        if (!iexec->execute)
-                return 9;
-
-        if (reg == 0x000200)
-                value |= 1;
-
-        bios_wr32(bios, reg, value);
-
-        return 9;
-}
-
-static int
-init_ram_restrict_pll(struct nvbios *bios, uint16_t offset,
-                      struct init_exec *iexec)
-{
-        /*
-         * INIT_RAM_RESTRICT_PLL   opcode: 0x87 ('')
-         *
-         * offset      (8 bit): opcode
-         * offset + 1  (8 bit): PLL type
-         * offset + 2 (32 bit): frequency 0
-         *
-         * Uses the RAMCFG strap of PEXTDEV_BOOT as an index into the table at
-         * ram_restrict_table_ptr.  The value read from there is used to select
-         * a frequency from the table starting at 'frequency 0' to be
-         * programmed into the PLL corresponding to 'type'.
-         *
-         * The PLL limits table on cards using this opcode has a mapping of
-         * 'type' to the relevant registers.
-         */
-
-        struct drm_device *dev = bios->dev;
-        uint32_t strap = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) & 0x0000003c) >> 2;
-        uint8_t index = bios->data[bios->ram_restrict_tbl_ptr + strap];
-        uint8_t type = bios->data[offset + 1];
-        uint32_t freq = ROM32(bios->data[offset + 2 + (index * 4)]);
-        uint8_t *pll_limits = &bios->data[bios->pll_limit_tbl_ptr], *entry;
-        int len = 2 + bios->ram_restrict_group_count * 4;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        if (!bios->pll_limit_tbl_ptr || (pll_limits[0] & 0xf0) != 0x30) {
-                NV_ERROR(dev, "PLL limits table not version 3.x\n");
-                return len; /* deliberate, allow default clocks to remain */
-        }
-
-        entry = pll_limits + pll_limits[1];
-        for (i = 0; i < pll_limits[3]; i++, entry += pll_limits[2]) {
-                if (entry[0] == type) {
-                        uint32_t reg = ROM32(entry[3]);
-
-                        BIOSLOG(bios, "0x%04X: "
-                                      "Type %02x Reg 0x%08x Freq %dKHz\n",
-                                offset, type, reg, freq);
-
-                        setPLL(bios, reg, freq);
-                        return len;
-                }
-        }
-
-        NV_ERROR(dev, "PLL type 0x%02x not found in PLL limits table", type);
-        return len;
-}
-
-static int
-init_8c(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_8C   opcode: 0x8C ('')
-         *
-         * NOP so far....
-         *
-         */
-
-        return 1;
-}
-
-static int
-init_8d(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_8D   opcode: 0x8D ('')
-         *
-         * NOP so far....
-         *
-         */
-
-        return 1;
-}
-
-static int
-init_gpio(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_GPIO   opcode: 0x8E ('')
-         *
-         * offset      (8 bit): opcode
-         *
-         * Loop over all entries in the DCB GPIO table, and initialise
-         * each GPIO according to various values listed in each entry
-         */
-
-        if (iexec->execute && bios->execute)
-                nouveau_gpio_reset(bios->dev);
-
-        return 1;
-}
-
-static int
-init_ram_restrict_zm_reg_group(struct nvbios *bios, uint16_t offset,
-                               struct init_exec *iexec)
-{
-        /*
-         * INIT_RAM_RESTRICT_ZM_REG_GROUP   opcode: 0x8F ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): reg
-         * offset + 5  (8  bit): regincrement
-         * offset + 6  (8  bit): count
-         * offset + 7  (32 bit): value 1,1
-         * ...
-         *
-         * Use the RAMCFG strap of PEXTDEV_BOOT as an index into the table at
-         * ram_restrict_table_ptr. The value read from here is 'n', and
-         * "value 1,n" gets written to "reg". This repeats "count" times and on
-         * each iteration 'm', "reg" increases by "regincrement" and
-         * "value m,n" is used. The extent of n is limited by a number read
-         * from the 'M' BIT table, herein called "blocklen"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint8_t regincrement = bios->data[offset + 5];
-        uint8_t count = bios->data[offset + 6];
-        uint32_t strap_ramcfg, data;
-        /* previously set by 'M' BIT table */
-        uint16_t blocklen = bios->ram_restrict_group_count * 4;
-        int len = 7 + count * blocklen;
-        uint8_t index;
-        int i;
-
-        /* critical! to know the length of the opcode */;
-        if (!blocklen) {
-                NV_ERROR(bios->dev,
-                         "0x%04X: Zero block length - has the M table "
-                         "been parsed?\n", offset);
-                return -EINVAL;
-        }
-
-        if (!iexec->execute)
-                return len;
-
-        strap_ramcfg = (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 2) & 0xf;
-        index = bios->data[bios->ram_restrict_tbl_ptr + strap_ramcfg];
-
-        BIOSLOG(bios, "0x%04X: Reg: 0x%08X, RegIncrement: 0x%02X, "
-                      "Count: 0x%02X, StrapRamCfg: 0x%02X, Index: 0x%02X\n",
-                offset, reg, regincrement, count, strap_ramcfg, index);
-
-        for (i = 0; i < count; i++) {
-                data = ROM32(bios->data[offset + 7 + index * 4 + blocklen * i]);
-
-                bios_wr32(bios, reg, data);
-
-                reg += regincrement;
-        }
-
-        return len;
-}
-
-static int
-init_copy_zm_reg(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_COPY_ZM_REG   opcode: 0x90 ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): src reg
-         * offset + 5  (32 bit): dst reg
-         *
-         * Put contents of "src reg" into "dst reg"
-         */
-
-        uint32_t srcreg = ROM32(bios->data[offset + 1]);
-        uint32_t dstreg = ROM32(bios->data[offset + 5]);
-
-        if (!iexec->execute)
-                return 9;
-
-        bios_wr32(bios, dstreg, bios_rd32(bios, srcreg));
-
-        return 9;
-}
-
-static int
-init_zm_reg_group_addr_latched(struct nvbios *bios, uint16_t offset,
-                               struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_REG_GROUP_ADDRESS_LATCHED   opcode: 0x91 ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): dst reg
-         * offset + 5  (8  bit): count
-         * offset + 6  (32 bit): data 1
-         * ...
-         *
-         * For each of "count" values write "data n" to "dst reg"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint8_t count = bios->data[offset + 5];
-        int len = 6 + count * 4;
-        int i;
-
-        if (!iexec->execute)
-                return len;
-
-        for (i = 0; i < count; i++) {
-                uint32_t data = ROM32(bios->data[offset + 6 + 4 * i]);
-                bios_wr32(bios, reg, data);
-        }
-
-        return len;
-}
-
-static int
-init_reserved(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_RESERVED   opcode: 0x92 ('')
-         *
-         * offset      (8 bit): opcode
-         *
-         * Seemingly does nothing
-         */
-
-        return 1;
-}
-
-static int
-init_96(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_96   opcode: 0x96 ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): sreg
-         * offset + 5  (8  bit): sshift
-         * offset + 6  (8  bit): smask
-         * offset + 7  (8  bit): index
-         * offset + 8  (32 bit): reg
-         * offset + 12 (32 bit): mask
-         * offset + 16 (8  bit): shift
-         *
-         */
-
-        uint16_t xlatptr = bios->init96_tbl_ptr + (bios->data[offset + 7] * 2);
-        uint32_t reg = ROM32(bios->data[offset + 8]);
-        uint32_t mask = ROM32(bios->data[offset + 12]);
-        uint32_t val;
-
-        val = bios_rd32(bios, ROM32(bios->data[offset + 1]));
-        if (bios->data[offset + 5] < 0x80)
-                val >>= bios->data[offset + 5];
-        else
-                val <<= (0x100 - bios->data[offset + 5]);
-        val &= bios->data[offset + 6];
-
-        val   = bios->data[ROM16(bios->data[xlatptr]) + val];
-        val <<= bios->data[offset + 16];
-
-        if (!iexec->execute)
-                return 17;
-
-        bios_wr32(bios, reg, (bios_rd32(bios, reg) & mask) | val);
-        return 17;
-}
-
-static int
-init_97(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_97   opcode: 0x97 ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): register
-         * offset + 5  (32 bit): mask
-         * offset + 9  (32 bit): value
-         *
-         * Adds "value" to "register" preserving the fields specified
-         * by "mask"
-         */
-
-        uint32_t reg = ROM32(bios->data[offset + 1]);
-        uint32_t mask = ROM32(bios->data[offset + 5]);
-        uint32_t add = ROM32(bios->data[offset + 9]);
-        uint32_t val;
-
-        val = bios_rd32(bios, reg);
-        val = (val & mask) | ((val + add) & ~mask);
-
-        if (!iexec->execute)
-                return 13;
-
-        bios_wr32(bios, reg, val);
-        return 13;
-}
-
-static int
-init_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_AUXCH   opcode: 0x98 ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): address
-         * offset + 5  (8  bit): count
-         * offset + 6  (8  bit): mask 0
-         * offset + 7  (8  bit): data 0
-         *  ...
-         *
-         */
-
-        struct drm_device *dev = bios->dev;
-        struct nouveau_i2c_chan *auxch;
-        uint32_t addr = ROM32(bios->data[offset + 1]);
-        uint8_t count = bios->data[offset + 5];
-        int len = 6 + count * 2;
-        int ret, i;
-
-        if (!bios->display.output) {
-                NV_ERROR(dev, "INIT_AUXCH: no active output\n");
-                return len;
-        }
-
-        auxch = init_i2c_device_find(dev, bios->display.output->i2c_index);
-        if (!auxch) {
-                NV_ERROR(dev, "INIT_AUXCH: couldn't get auxch %d\n",
-                         bios->display.output->i2c_index);
-                return len;
-        }
-
-        if (!iexec->execute)
-                return len;
-
-        offset += 6;
-        for (i = 0; i < count; i++, offset += 2) {
-                uint8_t data;
-
-                ret = nouveau_dp_auxch(auxch, 9, addr, &data, 1);
-                if (ret) {
-                        NV_ERROR(dev, "INIT_AUXCH: rd auxch fail %d\n", ret);
-                        return len;
-                }
-
-                data &= bios->data[offset + 0];
-                data |= bios->data[offset + 1];
-
-                ret = nouveau_dp_auxch(auxch, 8, addr, &data, 1);
-                if (ret) {
-                        NV_ERROR(dev, "INIT_AUXCH: wr auxch fail %d\n", ret);
-                        return len;
-                }
-        }
-
-        return len;
-}
-
-static int
-init_zm_auxch(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * INIT_ZM_AUXCH   opcode: 0x99 ('')
-         *
-         * offset      (8  bit): opcode
-         * offset + 1  (32 bit): address
-         * offset + 5  (8  bit): count
-         * offset + 6  (8  bit): data 0
-         *  ...
-         *
-         */
-
-        struct drm_device *dev = bios->dev;
-        struct nouveau_i2c_chan *auxch;
-        uint32_t addr = ROM32(bios->data[offset + 1]);
-        uint8_t count = bios->data[offset + 5];
-        int len = 6 + count;
-        int ret, i;
-
-        if (!bios->display.output) {
-                NV_ERROR(dev, "INIT_ZM_AUXCH: no active output\n");
-                return len;
-        }
-
-        auxch = init_i2c_device_find(dev, bios->display.output->i2c_index);
-        if (!auxch) {
-                NV_ERROR(dev, "INIT_ZM_AUXCH: couldn't get auxch %d\n",
-                         bios->display.output->i2c_index);
-                return len;
-        }
-
-        if (!iexec->execute)
-                return len;
-
-        offset += 6;
-        for (i = 0; i < count; i++, offset++) {
-                ret = nouveau_dp_auxch(auxch, 8, addr, &bios->data[offset], 1);
-                if (ret) {
-                        NV_ERROR(dev, "INIT_ZM_AUXCH: wr auxch fail %d\n", ret);
-                        return len;
-                }
-        }
-
-        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 */
-        { "INIT_IO_RESTRICT_PROG"             , 0x32, init_io_restrict_prog           },
-        { "INIT_REPEAT"                       , 0x33, init_repeat                     },
-        { "INIT_IO_RESTRICT_PLL"              , 0x34, init_io_restrict_pll            },
-        { "INIT_END_REPEAT"                   , 0x36, init_end_repeat                 },
-        { "INIT_COPY"                         , 0x37, init_copy                       },
-        { "INIT_NOT"                          , 0x38, init_not                        },
-        { "INIT_IO_FLAG_CONDITION"            , 0x39, init_io_flag_condition          },
-        { "INIT_DP_CONDITION"                 , 0x3A, init_dp_condition               },
-        { "INIT_OP_3B"                        , 0x3B, init_op_3b                      },
-        { "INIT_OP_3C"                        , 0x3C, init_op_3c                      },
-        { "INIT_INDEX_ADDRESS_LATCHED"        , 0x49, init_idx_addr_latched           },
-        { "INIT_IO_RESTRICT_PLL2"             , 0x4A, init_io_restrict_pll2           },
-        { "INIT_PLL2"                         , 0x4B, init_pll2                       },
-        { "INIT_I2C_BYTE"                     , 0x4C, init_i2c_byte                   },
-        { "INIT_ZM_I2C_BYTE"                  , 0x4D, init_zm_i2c_byte                },
-        { "INIT_ZM_I2C"                       , 0x4E, init_zm_i2c                     },
-        { "INIT_TMDS"                         , 0x4F, init_tmds                       },
-        { "INIT_ZM_TMDS_GROUP"                , 0x50, init_zm_tmds_group              },
-        { "INIT_CR_INDEX_ADDRESS_LATCHED"     , 0x51, init_cr_idx_adr_latch           },
-        { "INIT_CR"                           , 0x52, init_cr                         },
-        { "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_JUMP"                         , 0x5C, init_jump                       },
-        { "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                },
-        { "INIT_RESET"                        , 0x65, init_reset                      },
-        { "INIT_CONFIGURE_MEM"                , 0x66, init_configure_mem              },
-        { "INIT_CONFIGURE_CLK"                , 0x67, init_configure_clk              },
-        { "INIT_CONFIGURE_PREINIT"            , 0x68, init_configure_preinit          },
-        { "INIT_IO"                           , 0x69, init_io                         },
-        { "INIT_SUB"                          , 0x6B, init_sub                        },
-        { "INIT_RAM_CONDITION"                , 0x6D, init_ram_condition              },
-        { "INIT_NV_REG"                       , 0x6E, init_nv_reg                     },
-        { "INIT_MACRO"                        , 0x6F, init_macro                      },
-        { "INIT_DONE"                         , 0x71, init_done                       },
-        { "INIT_RESUME"                       , 0x72, init_resume                     },
-        /* INIT_RAM_CONDITION2 (0x73, 9, 0, 0) removed due to no example of use */
-        { "INIT_TIME"                         , 0x74, init_time                       },
-        { "INIT_CONDITION"                    , 0x75, init_condition                  },
-        { "INIT_IO_CONDITION"                 , 0x76, init_io_condition               },
-        { "INIT_INDEX_IO"                     , 0x78, init_index_io                   },
-        { "INIT_PLL"                          , 0x79, init_pll                        },
-        { "INIT_ZM_REG"                       , 0x7A, init_zm_reg                     },
-        { "INIT_RAM_RESTRICT_PLL"             , 0x87, init_ram_restrict_pll           },
-        { "INIT_8C"                           , 0x8C, init_8c                         },
-        { "INIT_8D"                           , 0x8D, init_8d                         },
-        { "INIT_GPIO"                         , 0x8E, init_gpio                       },
-        { "INIT_RAM_RESTRICT_ZM_REG_GROUP"    , 0x8F, init_ram_restrict_zm_reg_group  },
-        { "INIT_COPY_ZM_REG"                  , 0x90, init_copy_zm_reg                },
-        { "INIT_ZM_REG_GROUP_ADDRESS_LATCHED" , 0x91, init_zm_reg_group_addr_latched  },
-        { "INIT_RESERVED"                     , 0x92, init_reserved                   },
-        { "INIT_96"                           , 0x96, init_96                         },
-        { "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                            }
-};
-
-#define MAX_TABLE_OPS 1000
-
-static int
-parse_init_table(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
-{
-        /*
-         * Parses all commands in an init table.
-         *
-         * We start out executing all commands found in the init table. Some
-         * opcodes may change the status of iexec->execute to SKIP, which will
-         * cause the following opcodes to perform no operation until the value
-         * is changed back to EXECUTE.
-         */
-
-        int count = 0, i, ret;
-        uint8_t id;
-
-        /* catch NULL script pointers */
-        if (offset == 0)
-                return 0;
-
-        /*
-         * Loop until INIT_DONE causes us to break out of the loop
-         * (or until offset > bios length just in case... )
-         * (and no more than MAX_TABLE_OPS iterations, just in case... )
-         */
-        while ((offset < bios->length) && (count++ < MAX_TABLE_OPS)) {
-                id = bios->data[offset];
-
-                /* Find matching id in itbl_entry */
-                for (i = 0; itbl_entry[i].name && (itbl_entry[i].id != id); i++)
-                        ;
-
-                if (!itbl_entry[i].name) {
-                        NV_ERROR(bios->dev,
-                                 "0x%04X: Init table command not found: "
-                                 "0x%02X\n", offset, id);
-                        return -ENOENT;
-                }
-
-                BIOSLOG(bios, "0x%04X: [ (0x%02X) - %s ]\n", offset,
-                        itbl_entry[i].id, itbl_entry[i].name);
-
-                /* execute eventual command handler */
-                ret = (*itbl_entry[i].handler)(bios, offset, iexec);
-                if (ret < 0) {
-                        NV_ERROR(bios->dev, "0x%04X: Failed parsing init "
-                                 "table opcode: %s %d\n", offset,
-                                 itbl_entry[i].name, ret);
-                }
-
-                if (ret <= 0)
-                        break;
-
-                /*
-                 * Add the offset of the current command including all data
-                 * of that command. The offset will then be pointing on the
-                 * next op code.
-                 */
-                offset += ret;
-        }
-
-        if (offset >= bios->length)
-                NV_WARN(bios->dev,
-                        "Offset 0x%04X greater than known bios image length.  "
-                        "Corrupt image?\n", offset);
-        if (count >= MAX_TABLE_OPS)
-                NV_WARN(bios->dev,
-                        "More than %d opcodes to a table is unlikely, "
-                        "is the bios image corrupt?\n", MAX_TABLE_OPS);
-
-        return 0;
-}
-
-static void
-parse_init_tables(struct nvbios *bios)
-{
-        /* Loops and calls parse_init_table() for each present table. */
-
-        int i = 0;
-        uint16_t table;
-        struct init_exec iexec = {true, false};
-
-        if (bios->old_style_init) {
-                if (bios->init_script_tbls_ptr)
-                        parse_init_table(bios, bios->init_script_tbls_ptr, &iexec);
-                if (bios->extra_init_script_tbl_ptr)
-                        parse_init_table(bios, bios->extra_init_script_tbl_ptr, &iexec);
-
-                return;
-        }
-
-        while ((table = ROM16(bios->data[bios->init_script_tbls_ptr + i]))) {
-                NV_INFO(bios->dev,
-                        "Parsing VBIOS init table %d at offset 0x%04X\n",
-                        i / 2, table);
-                BIOSLOG(bios, "0x%04X: ------ Executing following commands ------\n", table);
-
-                parse_init_table(bios, table, &iexec);
-                i += 2;
-        }
-}
-
 static uint16_t clkcmptable(struct nvbios *bios, uint16_t clktable, int pxclk)
 {
         int compare_record_len, i = 0;
@@ -3764,28 +94,24 @@ static uint16_t clkcmptable(struct nvbios *bios, uint16_t clktable, int pxclk)
 
 static void
 run_digital_op_script(struct drm_device *dev, uint16_t scriptptr,
-                      struct dcb_entry *dcbent, int head, bool dl)
+                      struct dcb_output *dcbent, int head, bool dl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct init_exec iexec = {true, false};
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        NV_TRACE(dev, "0x%04X: Parsing digital output script table\n",
+        NV_INFO(drm, "0x%04X: Parsing digital output script table\n",
                  scriptptr);
-        bios_idxprt_wr(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_44,
-                       head ? NV_CIO_CRE_44_HEADB : NV_CIO_CRE_44_HEADA);
-        /* note: if dcb entries have been merged, index may be misleading */
-        NVWriteVgaCrtc5758(dev, head, 0, dcbent->index);
-        parse_init_table(bios, scriptptr, &iexec);
+        NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_44, head ? NV_CIO_CRE_44_HEADB :
+                                                 NV_CIO_CRE_44_HEADA);
+        nouveau_bios_run_init_table(dev, scriptptr, dcbent, head);
 
         nv04_dfp_bind_head(dev, dcbent, head, dl);
 }
 
-static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script)
+static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_output *dcbent, int head, enum LVDS_script script)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        uint8_t sub = bios->data[bios->fp.xlated_entry + script] + (bios->fp.link_c_increment && dcbent->or & OUTPUT_C ? 1 : 0);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
+        uint8_t sub = bios->data[bios->fp.xlated_entry + script] + (bios->fp.link_c_increment && dcbent->or & DCB_OUTPUT_C ? 1 : 0);
         uint16_t scriptofs = ROM16(bios->data[bios->init_script_tbls_ptr + sub * 2]);
 
         if (!bios->fp.xlated_entry || !sub || !scriptofs)
@@ -3808,7 +134,7 @@ static int call_lvds_manufacturer_script(struct drm_device *dev, struct dcb_entr
         return 0;
 }
 
-static int run_lvds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script, int pxclk)
+static int run_lvds_table(struct drm_device *dev, struct dcb_output *dcbent, int head, enum LVDS_script script, int pxclk)
 {
         /*
          * The BIT LVDS table's header has the information to setup the
@@ -3820,8 +146,8 @@ static int run_lvds_table(struct drm_device *dev, struct dcb_entry *dcbent, int
          * conf byte. These tables are similar to the TMDS tables, consisting
          * of a list of pxclks and script pointers.
          */
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         unsigned int outputset = (dcbent->or == 4) ? 1 : 0;
         uint16_t scriptptr = 0, clktable;
 
@@ -3866,14 +192,14 @@ static int run_lvds_table(struct drm_device *dev, struct dcb_entry *dcbent, int
 
                 clktable = ROM16(bios->data[clktable]);
                 if (!clktable) {
-                        NV_ERROR(dev, "Pixel clock comparison table not found\n");
+                        NV_ERROR(drm, "Pixel clock comparison table not found\n");
                         return -ENOENT;
                 }
                 scriptptr = clkcmptable(bios, clktable, pxclk);
         }
 
         if (!scriptptr) {
-                NV_ERROR(dev, "LVDS output init script not found\n");
+                NV_ERROR(drm, "LVDS output init script not found\n");
                 return -ENOENT;
         }
         run_digital_op_script(dev, scriptptr, dcbent, head, bios->fp.dual_link);
@@ -3881,7 +207,7 @@ static int run_lvds_table(struct drm_device *dev, struct dcb_entry *dcbent, int
         return 0;
 }
 
-int call_lvds_script(struct drm_device *dev, struct dcb_entry *dcbent, int head, enum LVDS_script script, int pxclk)
+int call_lvds_script(struct drm_device *dev, struct dcb_output *dcbent, int head, enum LVDS_script script, int pxclk)
 {
         /*
          * LVDS operations are multiplexed in an effort to present a single API
@@ -3889,8 +215,9 @@ int call_lvds_script(struct drm_device *dev, struct dcb_entry *dcbent, int head,
          * This acts as the demux
          */
 
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nvbios *bios = &drm->vbios;
         uint8_t lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer];
         uint32_t sel_clk_binding, sel_clk;
         int ret;
@@ -3909,10 +236,10 @@ int call_lvds_script(struct drm_device *dev, struct dcb_entry *dcbent, int head,
         if (script == LVDS_RESET && bios->fp.power_off_for_reset)
                 call_lvds_script(dev, dcbent, head, LVDS_PANEL_OFF, pxclk);
 
-        NV_TRACE(dev, "Calling LVDS script %d:\n", script);
+        NV_INFO(drm, "Calling LVDS script %d:\n", script);
 
         /* don't let script change pll->head binding */
-        sel_clk_binding = bios_rd32(bios, NV_PRAMDAC_SEL_CLK) & 0x50000;
+        sel_clk_binding = nv_rd32(device, NV_PRAMDAC_SEL_CLK) & 0x50000;
 
         if (lvds_ver < 0x30)
                 ret = call_lvds_manufacturer_script(dev, dcbent, head, script);
@@ -3924,7 +251,7 @@ int call_lvds_script(struct drm_device *dev, struct dcb_entry *dcbent, int head,
         sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK) & ~0x50000;
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, sel_clk | sel_clk_binding);
         /* some scripts set a value in NV_PBUS_POWERCTRL_2 and break video overlay */
-        nvWriteMC(dev, NV_PBUS_POWERCTRL_2, 0);
+        nv_wr32(device, NV_PBUS_POWERCTRL_2, 0);
 
         return ret;
 }
@@ -3942,12 +269,13 @@ static int parse_lvds_manufacturer_table_header(struct drm_device *dev, struct n
          * the maximum number of records that can be held in the table.
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t lvds_ver, headerlen, recordlen;
 
         memset(lth, 0, sizeof(struct lvdstableheader));
 
         if (bios->fp.lvdsmanufacturerpointer == 0x0) {
-                NV_ERROR(dev, "Pointer to LVDS manufacturer table invalid\n");
+                NV_ERROR(drm, "Pointer to LVDS manufacturer table invalid\n");
                 return -EINVAL;
         }
 
@@ -3961,7 +289,7 @@ static int parse_lvds_manufacturer_table_header(struct drm_device *dev, struct n
         case 0x30:      /* NV4x */
                 headerlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1];
                 if (headerlen < 0x1f) {
-                        NV_ERROR(dev, "LVDS table header not understood\n");
+                        NV_ERROR(drm, "LVDS table header not understood\n");
                         return -EINVAL;
                 }
                 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 2];
@@ -3969,13 +297,13 @@ static int parse_lvds_manufacturer_table_header(struct drm_device *dev, struct n
         case 0x40:      /* G80/G90 */
                 headerlen = bios->data[bios->fp.lvdsmanufacturerpointer + 1];
                 if (headerlen < 0x7) {
-                        NV_ERROR(dev, "LVDS table header not understood\n");
+                        NV_ERROR(drm, "LVDS table header not understood\n");
                         return -EINVAL;
                 }
                 recordlen = bios->data[bios->fp.lvdsmanufacturerpointer + 2];
                 break;
         default:
-                NV_ERROR(dev,
+                NV_ERROR(drm,
                          "LVDS table revision %d.%d not currently supported\n",
                          lvds_ver >> 4, lvds_ver & 0xf);
                 return -ENOSYS;
@@ -3991,7 +319,7 @@ static int parse_lvds_manufacturer_table_header(struct drm_device *dev, struct n
 static int
 get_fp_strap(struct drm_device *dev, struct nvbios *bios)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
 
         /*
          * The fp strap is normally dictated by the "User Strap" in
@@ -4005,14 +333,15 @@ get_fp_strap(struct drm_device *dev, struct nvbios *bios)
         if (bios->major_version < 5 && bios->data[0x48] & 0x4)
                 return NVReadVgaCrtc5758(dev, 0, 0xf) & 0xf;
 
-        if (dev_priv->card_type >= NV_50)
-                return (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 24) & 0xf;
+        if (device->card_type >= NV_50)
+                return (nv_rd32(device, NV_PEXTDEV_BOOT_0) >> 24) & 0xf;
         else
-                return (bios_rd32(bios, NV_PEXTDEV_BOOT_0) >> 16) & 0xf;
+                return (nv_rd32(device, NV_PEXTDEV_BOOT_0) >> 16) & 0xf;
 }
 
 static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t *fptable;
         uint8_t fptable_ver, headerlen = 0, recordlen, fpentries = 0xf, fpindex;
         int ret, ofs, fpstrapping;
@@ -4022,7 +351,7 @@ static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
                 /* Apple cards don't have the fp table; the laptops use DDC */
                 /* The table is also missing on some x86 IGPs */
 #ifndef __powerpc__
-                NV_ERROR(dev, "Pointer to flat panel table invalid\n");
+                NV_ERROR(drm, "Pointer to flat panel table invalid\n");
 #endif
                 bios->digital_min_front_porch = 0x4b;
                 return 0;
@@ -4061,7 +390,7 @@ static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
                 ofs = -7;
                 break;
         default:
-                NV_ERROR(dev,
+                NV_ERROR(drm,
                          "FP table revision %d.%d not currently supported\n",
                          fptable_ver >> 4, fptable_ver & 0xf);
                 return -ENOSYS;
@@ -4080,7 +409,7 @@ static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
                 bios->fp.xlatwidth = lth.recordlen;
         }
         if (bios->fp.fpxlatetableptr == 0x0) {
-                NV_ERROR(dev, "Pointer to flat panel xlat table invalid\n");
+                NV_ERROR(drm, "Pointer to flat panel xlat table invalid\n");
                 return -EINVAL;
         }
 
@@ -4090,7 +419,7 @@ static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
                                         fpstrapping * bios->fp.xlatwidth];
 
         if (fpindex > fpentries) {
-                NV_ERROR(dev, "Bad flat panel table index\n");
+                NV_ERROR(drm, "Bad flat panel table index\n");
                 return -ENOENT;
         }
 
@@ -4109,7 +438,7 @@ static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
         bios->fp.mode_ptr = bios->fp.fptablepointer + headerlen +
                             recordlen * fpindex + ofs;
 
-        NV_TRACE(dev, "BIOS FP mode: %dx%d (%dkHz pixel clock)\n",
+        NV_INFO(drm, "BIOS FP mode: %dx%d (%dkHz pixel clock)\n",
                  ROM16(bios->data[bios->fp.mode_ptr + 11]) + 1,
                  ROM16(bios->data[bios->fp.mode_ptr + 25]) + 1,
                  ROM16(bios->data[bios->fp.mode_ptr + 7]) * 10);
@@ -4119,8 +448,8 @@ static int parse_fp_mode_table(struct drm_device *dev, struct nvbios *bios)
 
 bool nouveau_bios_fp_mode(struct drm_device *dev, struct drm_display_mode *mode)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         uint8_t *mode_entry = &bios->data[bios->fp.mode_ptr];
 
         if (!mode)      /* just checking whether we can produce a mode */
@@ -4190,8 +519,8 @@ int nouveau_bios_parse_lvds_table(struct drm_device *dev, int pxclk, bool *dl, b
          * requiring tests against the native-mode pixel clock, cannot be done
          * until later, when this function should be called with non-zero pxclk
          */
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         int fpstrapping = get_fp_strap(dev, bios), lvdsmanufacturerindex = 0;
         struct lvdstableheader lth;
         uint16_t lvdsofs;
@@ -4252,7 +581,7 @@ int nouveau_bios_parse_lvds_table(struct drm_device *dev, int pxclk, bool *dl, b
                 lvdsmanufacturerindex = fpstrapping;
                 break;
         default:
-                NV_ERROR(dev, "LVDS table revision not currently supported\n");
+                NV_ERROR(drm, "LVDS table revision not currently supported\n");
                 return -ENOSYS;
         }
 
@@ -4300,7 +629,7 @@ int nouveau_bios_parse_lvds_table(struct drm_device *dev, int pxclk, bool *dl, b
  * This function returns true if a particular DCB entry matches.
  */
 bool
-bios_encoder_match(struct dcb_entry *dcb, u32 hash)
+bios_encoder_match(struct dcb_output *dcb, u32 hash)
 {
         if ((hash & 0x000000f0) != (dcb->location << 4))
                 return false;
@@ -4310,9 +639,9 @@ bios_encoder_match(struct dcb_entry *dcb, u32 hash)
                 return false;
 
         switch (dcb->type) {
-        case OUTPUT_TMDS:
-        case OUTPUT_LVDS:
-        case OUTPUT_DP:
+        case DCB_OUTPUT_TMDS:
+        case DCB_OUTPUT_LVDS:
+        case DCB_OUTPUT_DP:
                 if (hash & 0x00c00000) {
                         if (!(hash & (dcb->sorconf.link << 22)))
                                 return false;
@@ -4324,7 +653,7 @@ bios_encoder_match(struct dcb_entry *dcb, u32 hash)
 
 int
 nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
-                               struct dcb_entry *dcbent, int crtc)
+                               struct dcb_output *dcbent, int crtc)
 {
         /*
          * The display script table is located by the BIT 'U' table.
@@ -4349,15 +678,15 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
          * offset + 5   (16 bits): pointer to first output script table
          */
 
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         uint8_t *table = &bios->data[bios->display.script_table_ptr];
         uint8_t *otable = NULL;
         uint16_t script;
         int i;
 
         if (!bios->display.script_table_ptr) {
-                NV_ERROR(dev, "No pointer to output script table\n");
+                NV_ERROR(drm, "No pointer to output script table\n");
                 return 1;
         }
 
@@ -4369,7 +698,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
                 return 1;
 
         if (table[0] != 0x20 && table[0] != 0x21) {
-                NV_ERROR(dev, "Output script table version 0x%02x unknown\n",
+                NV_ERROR(drm, "Output script table version 0x%02x unknown\n",
                          table[0]);
                 return 1;
         }
@@ -4404,7 +733,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
          * script tables is a pointer to the script to execute.
          */
 
-        NV_DEBUG_KMS(dev, "Searching for output entry for %d %d %d\n",
+        NV_DEBUG(drm, "Searching for output entry for %d %d %d\n",
                         dcbent->type, dcbent->location, dcbent->or);
         for (i = 0; i < table[3]; i++) {
                 otable = ROMPTR(dev, table[table[1] + (i * table[2])]);
@@ -4413,7 +742,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
         }
 
         if (!otable) {
-                NV_DEBUG_KMS(dev, "failed to match any output table\n");
+                NV_DEBUG(drm, "failed to match any output table\n");
                 return 1;
         }
 
@@ -4425,7 +754,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
                 }
 
                 if (i == otable[5]) {
-                        NV_ERROR(dev, "Table 0x%04x not found for %d/%d, "
+                        NV_ERROR(drm, "Table 0x%04x not found for %d/%d, "
                                       "using first\n",
                                  type, dcbent->type, dcbent->or);
                         i = 0;
@@ -4435,21 +764,21 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
         if (pclk == 0) {
                 script = ROM16(otable[6]);
                 if (!script) {
-                        NV_DEBUG_KMS(dev, "output script 0 not found\n");
+                        NV_DEBUG(drm, "output script 0 not found\n");
                         return 1;
                 }
 
-                NV_DEBUG_KMS(dev, "0x%04X: parsing output script 0\n", script);
+                NV_DEBUG(drm, "0x%04X: parsing output script 0\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent, crtc);
         } else
         if (pclk == -1) {
                 script = ROM16(otable[8]);
                 if (!script) {
-                        NV_DEBUG_KMS(dev, "output script 1 not found\n");
+                        NV_DEBUG(drm, "output script 1 not found\n");
                         return 1;
                 }
 
-                NV_DEBUG_KMS(dev, "0x%04X: parsing output script 1\n", script);
+                NV_DEBUG(drm, "0x%04X: parsing output script 1\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent, crtc);
         } else
         if (pclk == -2) {
@@ -4458,11 +787,11 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
                 else
                         script = 0;
                 if (!script) {
-                        NV_DEBUG_KMS(dev, "output script 2 not found\n");
+                        NV_DEBUG(drm, "output script 2 not found\n");
                         return 1;
                 }
 
-                NV_DEBUG_KMS(dev, "0x%04X: parsing output script 2\n", script);
+                NV_DEBUG(drm, "0x%04X: parsing output script 2\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent, crtc);
         } else
         if (pclk > 0) {
@@ -4470,11 +799,11 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
                 if (script)
                         script = clkcmptable(bios, script, pclk);
                 if (!script) {
-                        NV_DEBUG_KMS(dev, "clock script 0 not found\n");
+                        NV_DEBUG(drm, "clock script 0 not found\n");
                         return 1;
                 }
 
-                NV_DEBUG_KMS(dev, "0x%04X: parsing clock script 0\n", script);
+                NV_DEBUG(drm, "0x%04X: parsing clock script 0\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent, crtc);
         } else
         if (pclk < 0) {
@@ -4482,11 +811,11 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
                 if (script)
                         script = clkcmptable(bios, script, -pclk);
                 if (!script) {
-                        NV_DEBUG_KMS(dev, "clock script 1 not found\n");
+                        NV_DEBUG(drm, "clock script 1 not found\n");
                         return 1;
                 }
 
-                NV_DEBUG_KMS(dev, "0x%04X: parsing clock script 1\n", script);
+                NV_DEBUG(drm, "0x%04X: parsing clock script 1\n", script);
                 nouveau_bios_run_init_table(dev, script, dcbent, crtc);
         }
 
@@ -4494,7 +823,7 @@ nouveau_bios_run_display_table(struct drm_device *dev, u16 type, int pclk,
 }
 
 
-int run_tmds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, int pxclk)
+int run_tmds_table(struct drm_device *dev, struct dcb_output *dcbent, int head, int pxclk)
 {
         /*
          * the pxclk parameter is in kHz
@@ -4505,8 +834,9 @@ int run_tmds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, i
          * ffs(or) == 3, use the second.
          */
 
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nvbios *bios = &drm->vbios;
         int cv = bios->chip_version;
         uint16_t clktable = 0, scriptptr;
         uint32_t sel_clk_binding, sel_clk;
@@ -4527,19 +857,19 @@ int run_tmds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, i
         }
 
         if (!clktable) {
-                NV_ERROR(dev, "Pixel clock comparison table not found\n");
+                NV_ERROR(drm, "Pixel clock comparison table not found\n");
                 return -EINVAL;
         }
 
         scriptptr = clkcmptable(bios, clktable, pxclk);
 
         if (!scriptptr) {
-                NV_ERROR(dev, "TMDS output init script not found\n");
+                NV_ERROR(drm, "TMDS output init script not found\n");
                 return -ENOENT;
         }
 
         /* don't let script change pll->head binding */
-        sel_clk_binding = bios_rd32(bios, NV_PRAMDAC_SEL_CLK) & 0x50000;
+        sel_clk_binding = nv_rd32(device, NV_PRAMDAC_SEL_CLK) & 0x50000;
         run_digital_op_script(dev, scriptptr, dcbent, head, pxclk >= 165000);
         sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK) & ~0x50000;
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, sel_clk | sel_clk_binding);
@@ -4547,447 +877,6 @@ int run_tmds_table(struct drm_device *dev, struct dcb_entry *dcbent, int head, i
         return 0;
 }
 
-struct pll_mapping {
-        u8  type;
-        u32 reg;
-};
-
-static struct pll_mapping nv04_pll_mapping[] = {
-        { PLL_CORE  , NV_PRAMDAC_NVPLL_COEFF },
-        { PLL_MEMORY, NV_PRAMDAC_MPLL_COEFF },
-        { PLL_VPLL0 , NV_PRAMDAC_VPLL_COEFF },
-        { PLL_VPLL1 , NV_RAMDAC_VPLL2 },
-        {}
-};
-
-static struct pll_mapping nv40_pll_mapping[] = {
-        { PLL_CORE  , 0x004000 },
-        { PLL_MEMORY, 0x004020 },
-        { PLL_VPLL0 , NV_PRAMDAC_VPLL_COEFF },
-        { PLL_VPLL1 , NV_RAMDAC_VPLL2 },
-        {}
-};
-
-static struct pll_mapping nv50_pll_mapping[] = {
-        { PLL_CORE  , 0x004028 },
-        { PLL_SHADER, 0x004020 },
-        { PLL_UNK03 , 0x004000 },
-        { PLL_MEMORY, 0x004008 },
-        { PLL_UNK40 , 0x00e810 },
-        { PLL_UNK41 , 0x00e818 },
-        { PLL_UNK42 , 0x00e824 },
-        { PLL_VPLL0 , 0x614100 },
-        { PLL_VPLL1 , 0x614900 },
-        {}
-};
-
-static struct pll_mapping nv84_pll_mapping[] = {
-        { PLL_CORE  , 0x004028 },
-        { PLL_SHADER, 0x004020 },
-        { PLL_MEMORY, 0x004008 },
-        { PLL_VDEC  , 0x004030 },
-        { PLL_UNK41 , 0x00e818 },
-        { PLL_VPLL0 , 0x614100 },
-        { PLL_VPLL1 , 0x614900 },
-        {}
-};
-
-u32
-get_pll_register(struct drm_device *dev, enum pll_types type)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct pll_mapping *map;
-        int i;
-
-        if (dev_priv->card_type < NV_40)
-                map = nv04_pll_mapping;
-        else
-        if (dev_priv->card_type < NV_50)
-                map = nv40_pll_mapping;
-        else {
-                u8 *plim = &bios->data[bios->pll_limit_tbl_ptr];
-
-                if (plim[0] >= 0x30) {
-                        u8 *entry = plim + plim[1];
-                        for (i = 0; i < plim[3]; i++, entry += plim[2]) {
-                                if (entry[0] == type)
-                                        return ROM32(entry[3]);
-                        }
-
-                        return 0;
-                }
-
-                if (dev_priv->chipset == 0x50)
-                        map = nv50_pll_mapping;
-                else
-                        map = nv84_pll_mapping;
-        }
-
-        while (map->reg) {
-                if (map->type == type)
-                        return map->reg;
-                map++;
-        }
-
-        return 0;
-}
-
-int get_pll_limits(struct drm_device *dev, uint32_t limit_match, struct pll_lims *pll_lim)
-{
-        /*
-         * PLL limits table
-         *
-         * Version 0x10: NV30, NV31
-         * One byte header (version), one record of 24 bytes
-         * Version 0x11: NV36 - Not implemented
-         * Seems to have same record style as 0x10, but 3 records rather than 1
-         * Version 0x20: Found on Geforce 6 cards
-         * Trivial 4 byte BIT header. 31 (0x1f) byte record length
-         * Version 0x21: Found on Geforce 7, 8 and some Geforce 6 cards
-         * 5 byte header, fifth byte of unknown purpose. 35 (0x23) byte record
-         * length in general, some (integrated) have an extra configuration byte
-         * Version 0x30: Found on Geforce 8, separates the register mapping
-         * from the limits tables.
-         */
-
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        int cv = bios->chip_version, pllindex = 0;
-        uint8_t pll_lim_ver = 0, headerlen = 0, recordlen = 0, entries = 0;
-        uint32_t crystal_strap_mask, crystal_straps;
-
-        if (!bios->pll_limit_tbl_ptr) {
-                if (cv == 0x30 || cv == 0x31 || cv == 0x35 || cv == 0x36 ||
-                    cv >= 0x40) {
-                        NV_ERROR(dev, "Pointer to PLL limits table invalid\n");
-                        return -EINVAL;
-                }
-        } else
-                pll_lim_ver = bios->data[bios->pll_limit_tbl_ptr];
-
-        crystal_strap_mask = 1 << 6;
-        /* open coded dev->twoHeads test */
-        if (cv > 0x10 && cv != 0x15 && cv != 0x1a && cv != 0x20)
-                crystal_strap_mask |= 1 << 22;
-        crystal_straps = nvReadEXTDEV(dev, NV_PEXTDEV_BOOT_0) &
-                                                        crystal_strap_mask;
-
-        switch (pll_lim_ver) {
-        /*
-         * We use version 0 to indicate a pre limit table bios (single stage
-         * pll) and load the hard coded limits instead.
-         */
-        case 0:
-                break;
-        case 0x10:
-        case 0x11:
-                /*
-                 * Strictly v0x11 has 3 entries, but the last two don't seem
-                 * to get used.
-                 */
-                headerlen = 1;
-                recordlen = 0x18;
-                entries = 1;
-                pllindex = 0;
-                break;
-        case 0x20:
-        case 0x21:
-        case 0x30:
-        case 0x40:
-                headerlen = bios->data[bios->pll_limit_tbl_ptr + 1];
-                recordlen = bios->data[bios->pll_limit_tbl_ptr + 2];
-                entries = bios->data[bios->pll_limit_tbl_ptr + 3];
-                break;
-        default:
-                NV_ERROR(dev, "PLL limits table revision 0x%X not currently "
-                                "supported\n", pll_lim_ver);
-                return -ENOSYS;
-        }
-
-        /* initialize all members to zero */
-        memset(pll_lim, 0, sizeof(struct pll_lims));
-
-        /* if we were passed a type rather than a register, figure
-         * out the register and store it
-         */
-        if (limit_match > PLL_MAX)
-                pll_lim->reg = limit_match;
-        else {
-                pll_lim->reg = get_pll_register(dev, limit_match);
-                if (!pll_lim->reg)
-                        return -ENOENT;
-        }
-
-        if (pll_lim_ver == 0x10 || pll_lim_ver == 0x11) {
-                uint8_t *pll_rec = &bios->data[bios->pll_limit_tbl_ptr + headerlen + recordlen * pllindex];
-
-                pll_lim->vco1.minfreq = ROM32(pll_rec[0]);
-                pll_lim->vco1.maxfreq = ROM32(pll_rec[4]);
-                pll_lim->vco2.minfreq = ROM32(pll_rec[8]);
-                pll_lim->vco2.maxfreq = ROM32(pll_rec[12]);
-                pll_lim->vco1.min_inputfreq = ROM32(pll_rec[16]);
-                pll_lim->vco2.min_inputfreq = ROM32(pll_rec[20]);
-                pll_lim->vco1.max_inputfreq = pll_lim->vco2.max_inputfreq = INT_MAX;
-
-                /* these values taken from nv30/31/36 */
-                pll_lim->vco1.min_n = 0x1;
-                if (cv == 0x36)
-                        pll_lim->vco1.min_n = 0x5;
-                pll_lim->vco1.max_n = 0xff;
-                pll_lim->vco1.min_m = 0x1;
-                pll_lim->vco1.max_m = 0xd;
-                pll_lim->vco2.min_n = 0x4;
-                /*
-                 * On nv30, 31, 36 (i.e. all cards with two stage PLLs with this
-                 * table version (apart from nv35)), N2 is compared to
-                 * maxN2 (0x46) and 10 * maxM2 (0x4), so set maxN2 to 0x28 and
-                 * save a comparison
-                 */
-                pll_lim->vco2.max_n = 0x28;
-                if (cv == 0x30 || cv == 0x35)
-                        /* only 5 bits available for N2 on nv30/35 */
-                        pll_lim->vco2.max_n = 0x1f;
-                pll_lim->vco2.min_m = 0x1;
-                pll_lim->vco2.max_m = 0x4;
-                pll_lim->max_log2p = 0x7;
-                pll_lim->max_usable_log2p = 0x6;
-        } else if (pll_lim_ver == 0x20 || pll_lim_ver == 0x21) {
-                uint16_t plloffs = bios->pll_limit_tbl_ptr + headerlen;
-                uint8_t *pll_rec;
-                int i;
-
-                /*
-                 * First entry is default match, if nothing better. warn if
-                 * reg field nonzero
-                 */
-                if (ROM32(bios->data[plloffs]))
-                        NV_WARN(dev, "Default PLL limit entry has non-zero "
-                                       "register field\n");
-
-                for (i = 1; i < entries; i++)
-                        if (ROM32(bios->data[plloffs + recordlen * i]) == pll_lim->reg) {
-                                pllindex = i;
-                                break;
-                        }
-
-                if ((dev_priv->card_type >= NV_50) && (pllindex == 0)) {
-                        NV_ERROR(dev, "Register 0x%08x not found in PLL "
-                                 "limits table", pll_lim->reg);
-                        return -ENOENT;
-                }
-
-                pll_rec = &bios->data[plloffs + recordlen * pllindex];
-
-                BIOSLOG(bios, "Loading PLL limits for reg 0x%08x\n",
-                        pllindex ? pll_lim->reg : 0);
-
-                /*
-                 * Frequencies are stored in tables in MHz, kHz are more
-                 * useful, so we convert.
-                 */
-
-                /* What output frequencies can each VCO generate? */
-                pll_lim->vco1.minfreq = ROM16(pll_rec[4]) * 1000;
-                pll_lim->vco1.maxfreq = ROM16(pll_rec[6]) * 1000;
-                pll_lim->vco2.minfreq = ROM16(pll_rec[8]) * 1000;
-                pll_lim->vco2.maxfreq = ROM16(pll_rec[10]) * 1000;
-
-                /* What input frequencies they accept (past the m-divider)? */
-                pll_lim->vco1.min_inputfreq = ROM16(pll_rec[12]) * 1000;
-                pll_lim->vco2.min_inputfreq = ROM16(pll_rec[14]) * 1000;
-                pll_lim->vco1.max_inputfreq = ROM16(pll_rec[16]) * 1000;
-                pll_lim->vco2.max_inputfreq = ROM16(pll_rec[18]) * 1000;
-
-                /* What values are accepted as multiplier and divider? */
-                pll_lim->vco1.min_n = pll_rec[20];
-                pll_lim->vco1.max_n = pll_rec[21];
-                pll_lim->vco1.min_m = pll_rec[22];
-                pll_lim->vco1.max_m = pll_rec[23];
-                pll_lim->vco2.min_n = pll_rec[24];
-                pll_lim->vco2.max_n = pll_rec[25];
-                pll_lim->vco2.min_m = pll_rec[26];
-                pll_lim->vco2.max_m = pll_rec[27];
-
-                pll_lim->max_usable_log2p = pll_lim->max_log2p = pll_rec[29];
-                if (pll_lim->max_log2p > 0x7)
-                        /* pll decoding in nv_hw.c assumes never > 7 */
-                        NV_WARN(dev, "Max log2 P value greater than 7 (%d)\n",
-                                pll_lim->max_log2p);
-                if (cv < 0x60)
-                        pll_lim->max_usable_log2p = 0x6;
-                pll_lim->log2p_bias = pll_rec[30];
-
-                if (recordlen > 0x22)
-                        pll_lim->refclk = ROM32(pll_rec[31]);
-
-                if (recordlen > 0x23 && pll_rec[35])
-                        NV_WARN(dev,
-                                "Bits set in PLL configuration byte (%x)\n",
-                                pll_rec[35]);
-
-                /* C51 special not seen elsewhere */
-                if (cv == 0x51 && !pll_lim->refclk) {
-                        uint32_t sel_clk = bios_rd32(bios, NV_PRAMDAC_SEL_CLK);
-
-                        if ((pll_lim->reg == NV_PRAMDAC_VPLL_COEFF && sel_clk & 0x20) ||
-                            (pll_lim->reg == NV_RAMDAC_VPLL2 && sel_clk & 0x80)) {
-                                if (bios_idxprt_rd(bios, NV_CIO_CRX__COLOR, NV_CIO_CRE_CHIP_ID_INDEX) < 0xa3)
-                                        pll_lim->refclk = 200000;
-                                else
-                                        pll_lim->refclk = 25000;
-                        }
-                }
-        } else if (pll_lim_ver == 0x30) { /* ver 0x30 */
-                uint8_t *entry = &bios->data[bios->pll_limit_tbl_ptr + headerlen];
-                uint8_t *record = NULL;
-                int i;
-
-                BIOSLOG(bios, "Loading PLL limits for register 0x%08x\n",
-                        pll_lim->reg);
-
-                for (i = 0; i < entries; i++, entry += recordlen) {
-                        if (ROM32(entry[3]) == pll_lim->reg) {
-                                record = &bios->data[ROM16(entry[1])];
-                                break;
-                        }
-                }
-
-                if (!record) {
-                        NV_ERROR(dev, "Register 0x%08x not found in PLL "
-                                 "limits table", pll_lim->reg);
-                        return -ENOENT;
-                }
-
-                pll_lim->vco1.minfreq = ROM16(record[0]) * 1000;
-                pll_lim->vco1.maxfreq = ROM16(record[2]) * 1000;
-                pll_lim->vco2.minfreq = ROM16(record[4]) * 1000;
-                pll_lim->vco2.maxfreq = ROM16(record[6]) * 1000;
-                pll_lim->vco1.min_inputfreq = ROM16(record[8]) * 1000;
-                pll_lim->vco2.min_inputfreq = ROM16(record[10]) * 1000;
-                pll_lim->vco1.max_inputfreq = ROM16(record[12]) * 1000;
-                pll_lim->vco2.max_inputfreq = ROM16(record[14]) * 1000;
-                pll_lim->vco1.min_n = record[16];
-                pll_lim->vco1.max_n = record[17];
-                pll_lim->vco1.min_m = record[18];
-                pll_lim->vco1.max_m = record[19];
-                pll_lim->vco2.min_n = record[20];
-                pll_lim->vco2.max_n = record[21];
-                pll_lim->vco2.min_m = record[22];
-                pll_lim->vco2.max_m = record[23];
-                pll_lim->max_usable_log2p = pll_lim->max_log2p = record[25];
-                pll_lim->log2p_bias = record[27];
-                pll_lim->refclk = ROM32(record[28]);
-        } else if (pll_lim_ver) { /* ver 0x40 */
-                uint8_t *entry = &bios->data[bios->pll_limit_tbl_ptr + headerlen];
-                uint8_t *record = NULL;
-                int i;
-
-                BIOSLOG(bios, "Loading PLL limits for register 0x%08x\n",
-                        pll_lim->reg);
-
-                for (i = 0; i < entries; i++, entry += recordlen) {
-                        if (ROM32(entry[3]) == pll_lim->reg) {
-                                record = &bios->data[ROM16(entry[1])];
-                                break;
-                        }
-                }
-
-                if (!record) {
-                        NV_ERROR(dev, "Register 0x%08x not found in PLL "
-                                 "limits table", pll_lim->reg);
-                        return -ENOENT;
-                }
-
-                pll_lim->vco1.minfreq = ROM16(record[0]) * 1000;
-                pll_lim->vco1.maxfreq = ROM16(record[2]) * 1000;
-                pll_lim->vco1.min_inputfreq = ROM16(record[4]) * 1000;
-                pll_lim->vco1.max_inputfreq = ROM16(record[6]) * 1000;
-                pll_lim->vco1.min_m = record[8];
-                pll_lim->vco1.max_m = record[9];
-                pll_lim->vco1.min_n = record[10];
-                pll_lim->vco1.max_n = record[11];
-                pll_lim->min_p = record[12];
-                pll_lim->max_p = record[13];
-                pll_lim->refclk = ROM16(entry[9]) * 1000;
-        }
-
-        /*
-         * By now any valid limit table ought to have set a max frequency for
-         * vco1, so if it's zero it's either a pre limit table bios, or one
-         * with an empty limit table (seen on nv18)
-         */
-        if (!pll_lim->vco1.maxfreq) {
-                pll_lim->vco1.minfreq = bios->fminvco;
-                pll_lim->vco1.maxfreq = bios->fmaxvco;
-                pll_lim->vco1.min_inputfreq = 0;
-                pll_lim->vco1.max_inputfreq = INT_MAX;
-                pll_lim->vco1.min_n = 0x1;
-                pll_lim->vco1.max_n = 0xff;
-                pll_lim->vco1.min_m = 0x1;
-                if (crystal_straps == 0) {
-                        /* nv05 does this, nv11 doesn't, nv10 unknown */
-                        if (cv < 0x11)
-                                pll_lim->vco1.min_m = 0x7;
-                        pll_lim->vco1.max_m = 0xd;
-                } else {
-                        if (cv < 0x11)
-                                pll_lim->vco1.min_m = 0x8;
-                        pll_lim->vco1.max_m = 0xe;
-                }
-                if (cv < 0x17 || cv == 0x1a || cv == 0x20)
-                        pll_lim->max_log2p = 4;
-                else
-                        pll_lim->max_log2p = 5;
-                pll_lim->max_usable_log2p = pll_lim->max_log2p;
-        }
-
-        if (!pll_lim->refclk)
-                switch (crystal_straps) {
-                case 0:
-                        pll_lim->refclk = 13500;
-                        break;
-                case (1 << 6):
-                        pll_lim->refclk = 14318;
-                        break;
-                case (1 << 22):
-                        pll_lim->refclk = 27000;
-                        break;
-                case (1 << 22 | 1 << 6):
-                        pll_lim->refclk = 25000;
-                        break;
-                }
-
-        NV_DEBUG(dev, "pll.vco1.minfreq: %d\n", pll_lim->vco1.minfreq);
-        NV_DEBUG(dev, "pll.vco1.maxfreq: %d\n", pll_lim->vco1.maxfreq);
-        NV_DEBUG(dev, "pll.vco1.min_inputfreq: %d\n", pll_lim->vco1.min_inputfreq);
-        NV_DEBUG(dev, "pll.vco1.max_inputfreq: %d\n", pll_lim->vco1.max_inputfreq);
-        NV_DEBUG(dev, "pll.vco1.min_n: %d\n", pll_lim->vco1.min_n);
-        NV_DEBUG(dev, "pll.vco1.max_n: %d\n", pll_lim->vco1.max_n);
-        NV_DEBUG(dev, "pll.vco1.min_m: %d\n", pll_lim->vco1.min_m);
-        NV_DEBUG(dev, "pll.vco1.max_m: %d\n", pll_lim->vco1.max_m);
-        if (pll_lim->vco2.maxfreq) {
-                NV_DEBUG(dev, "pll.vco2.minfreq: %d\n", pll_lim->vco2.minfreq);
-                NV_DEBUG(dev, "pll.vco2.maxfreq: %d\n", pll_lim->vco2.maxfreq);
-                NV_DEBUG(dev, "pll.vco2.min_inputfreq: %d\n", pll_lim->vco2.min_inputfreq);
-                NV_DEBUG(dev, "pll.vco2.max_inputfreq: %d\n", pll_lim->vco2.max_inputfreq);
-                NV_DEBUG(dev, "pll.vco2.min_n: %d\n", pll_lim->vco2.min_n);
-                NV_DEBUG(dev, "pll.vco2.max_n: %d\n", pll_lim->vco2.max_n);
-                NV_DEBUG(dev, "pll.vco2.min_m: %d\n", pll_lim->vco2.min_m);
-                NV_DEBUG(dev, "pll.vco2.max_m: %d\n", pll_lim->vco2.max_m);
-        }
-        if (!pll_lim->max_p) {
-                NV_DEBUG(dev, "pll.max_log2p: %d\n", pll_lim->max_log2p);
-                NV_DEBUG(dev, "pll.log2p_bias: %d\n", pll_lim->log2p_bias);
-        } else {
-                NV_DEBUG(dev, "pll.min_p: %d\n", pll_lim->min_p);
-                NV_DEBUG(dev, "pll.max_p: %d\n", pll_lim->max_p);
-        }
-        NV_DEBUG(dev, "pll.refclk: %d\n", pll_lim->refclk);
-
-        return 0;
-}
-
 static void parse_bios_version(struct drm_device *dev, struct nvbios *bios, uint16_t offset)
 {
         /*
@@ -4996,10 +885,11 @@ static void parse_bios_version(struct drm_device *dev, struct nvbios *bios, uint
          * offset + 2  (8 bits): Chip version
          * offset + 3  (8 bits): Major version
          */
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         bios->major_version = bios->data[offset + 3];
         bios->chip_version = bios->data[offset + 2];
-        NV_TRACE(dev, "Bios version %02x.%02x.%02x.%02x\n",
+        NV_INFO(drm, "Bios version %02x.%02x.%02x.%02x\n",
                  bios->data[offset + 3], bios->data[offset + 2],
                  bios->data[offset + 1], bios->data[offset]);
 }
@@ -5035,25 +925,26 @@ static int parse_bit_A_tbl_entry(struct drm_device *dev, struct nvbios *bios, st
          * offset + 0 (16 bits): loadval table pointer
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint16_t load_table_ptr;
         uint8_t version, headerlen, entrylen, num_entries;
 
         if (bitentry->length != 3) {
-                NV_ERROR(dev, "Do not understand BIT A table\n");
+                NV_ERROR(drm, "Do not understand BIT A table\n");
                 return -EINVAL;
         }
 
         load_table_ptr = ROM16(bios->data[bitentry->offset]);
 
         if (load_table_ptr == 0x0) {
-                NV_DEBUG(dev, "Pointer to BIT loadval table invalid\n");
+                NV_DEBUG(drm, "Pointer to BIT loadval table invalid\n");
                 return -EINVAL;
         }
 
         version = bios->data[load_table_ptr];
 
         if (version != 0x10) {
-                NV_ERROR(dev, "BIT loadval table version %d.%d not supported\n",
+                NV_ERROR(drm, "BIT loadval table version %d.%d not supported\n",
                          version >> 4, version & 0xF);
                 return -ENOSYS;
         }
@@ -5063,7 +954,7 @@ static int parse_bit_A_tbl_entry(struct drm_device *dev, struct nvbios *bios, st
         num_entries = bios->data[load_table_ptr + 3];
 
         if (headerlen != 4 || entrylen != 4 || num_entries != 2) {
-                NV_ERROR(dev, "Do not understand BIT loadval table\n");
+                NV_ERROR(drm, "Do not understand BIT loadval table\n");
                 return -EINVAL;
         }
 
@@ -5080,9 +971,10 @@ static int parse_bit_C_tbl_entry(struct drm_device *dev, struct nvbios *bios, st
          *
          * There's more in here, but that's unknown.
          */
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         if (bitentry->length < 10) {
-                NV_ERROR(dev, "Do not understand BIT C table\n");
+                NV_ERROR(drm, "Do not understand BIT C table\n");
                 return -EINVAL;
         }
 
@@ -5101,9 +993,10 @@ static int parse_bit_display_tbl_entry(struct drm_device *dev, struct nvbios *bi
          * records beginning with a freq.
          * offset + 2  (16 bits): mode table pointer
          */
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         if (bitentry->length != 4) {
-                NV_ERROR(dev, "Do not understand BIT display table\n");
+                NV_ERROR(drm, "Do not understand BIT display table\n");
                 return -EINVAL;
         }
 
@@ -5119,9 +1012,10 @@ static int parse_bit_init_tbl_entry(struct drm_device *dev, struct nvbios *bios,
          *
          * See parse_script_table_pointers for layout
          */
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         if (bitentry->length < 14) {
-                NV_ERROR(dev, "Do not understand init table\n");
+                NV_ERROR(drm, "Do not understand init table\n");
                 return -EINVAL;
         }
 
@@ -5148,11 +1042,12 @@ static int parse_bit_i_tbl_entry(struct drm_device *dev, struct nvbios *bios, st
          * There's other things in the table, purpose unknown
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint16_t daccmpoffset;
         uint8_t dacver, dacheaderlen;
 
         if (bitentry->length < 6) {
-                NV_ERROR(dev, "BIT i table too short for needed information\n");
+                NV_ERROR(drm, "BIT i table too short for needed information\n");
                 return -EINVAL;
         }
 
@@ -5166,7 +1061,7 @@ static int parse_bit_i_tbl_entry(struct drm_device *dev, struct nvbios *bios, st
         bios->is_mobile = bios->feature_byte & FEATURE_MOBILE;
 
         if (bitentry->length < 15) {
-                NV_WARN(dev, "BIT i table not long enough for DAC load "
+                NV_WARN(drm, "BIT i table not long enough for DAC load "
                                "detection comparison table\n");
                 return -EINVAL;
         }
@@ -5187,7 +1082,7 @@ static int parse_bit_i_tbl_entry(struct drm_device *dev, struct nvbios *bios, st
         dacheaderlen = bios->data[daccmpoffset + 1];
 
         if (dacver != 0x00 && dacver != 0x10) {
-                NV_WARN(dev, "DAC load detection comparison table version "
+                NV_WARN(drm, "DAC load detection comparison table version "
                                "%d.%d not known\n", dacver >> 4, dacver & 0xf);
                 return -ENOSYS;
         }
@@ -5207,8 +1102,10 @@ static int parse_bit_lvds_tbl_entry(struct drm_device *dev, struct nvbios *bios,
          * offset + 0  (16 bits): LVDS strap xlate table pointer
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         if (bitentry->length != 2) {
-                NV_ERROR(dev, "Do not understand BIT LVDS table\n");
+                NV_ERROR(drm, "Do not understand BIT LVDS table\n");
                 return -EINVAL;
         }
 
@@ -5278,20 +1175,21 @@ static int parse_bit_tmds_tbl_entry(struct drm_device *dev, struct nvbios *bios,
          * "or" from the DCB.
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint16_t tmdstableptr, script1, script2;
 
         if (bitentry->length != 2) {
-                NV_ERROR(dev, "Do not understand BIT TMDS table\n");
+                NV_ERROR(drm, "Do not understand BIT TMDS table\n");
                 return -EINVAL;
         }
 
         tmdstableptr = ROM16(bios->data[bitentry->offset]);
         if (!tmdstableptr) {
-                NV_ERROR(dev, "Pointer to TMDS table invalid\n");
+                NV_ERROR(drm, "Pointer to TMDS table invalid\n");
                 return -EINVAL;
         }
 
-        NV_INFO(dev, "TMDS table version %d.%d\n",
+        NV_INFO(drm, "TMDS table version %d.%d\n",
                 bios->data[tmdstableptr] >> 4, bios->data[tmdstableptr] & 0xf);
 
         /* nv50+ has v2.0, but we don't parse it atm */
@@ -5305,7 +1203,7 @@ static int parse_bit_tmds_tbl_entry(struct drm_device *dev, struct nvbios *bios,
         script1 = ROM16(bios->data[tmdstableptr + 7]);
         script2 = ROM16(bios->data[tmdstableptr + 9]);
         if (bios->data[script1] != 'q' || bios->data[script2] != 'q')
-                NV_WARN(dev, "TMDS table script pointers not stubbed\n");
+                NV_WARN(drm, "TMDS table script pointers not stubbed\n");
 
         bios->tmds.output0_script_ptr = ROM16(bios->data[tmdstableptr + 11]);
         bios->tmds.output1_script_ptr = ROM16(bios->data[tmdstableptr + 13]);
@@ -5325,10 +1223,11 @@ parse_bit_U_tbl_entry(struct drm_device *dev, struct nvbios *bios,
          * offset + 0  (16 bits): output script table pointer
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint16_t outputscripttableptr;
 
         if (bitentry->length != 3) {
-                NV_ERROR(dev, "Do not understand BIT U table\n");
+                NV_ERROR(drm, "Do not understand BIT U table\n");
                 return -EINVAL;
         }
 
@@ -5347,8 +1246,8 @@ struct bit_table {
 int
 bit_table(struct drm_device *dev, u8 id, struct bit_entry *bit)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         u8 entries, *entry;
 
         if (bios->type != NVBIOS_BIT)
@@ -5377,12 +1276,13 @@ parse_bit_table(struct nvbios *bios, const uint16_t bitoffset,
                 struct bit_table *table)
 {
         struct drm_device *dev = bios->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct bit_entry bitentry;
 
         if (bit_table(dev, table->id, &bitentry) == 0)
                 return table->parse_fn(dev, bios, &bitentry);
 
-        NV_INFO(dev, "BIT table '%c' not found\n", table->id);
+        NV_INFO(drm, "BIT table '%c' not found\n", table->id);
         return -ENOSYS;
 }
 
@@ -5462,6 +1362,7 @@ static int parse_bmp_structure(struct drm_device *dev, struct nvbios *bios, unsi
          * offset + 156: minimum pixel clock for LVDS dual link
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t *bmp = &bios->data[offset], bmp_version_major, bmp_version_minor;
         uint16_t bmplength;
         uint16_t legacy_scripts_offset, legacy_i2c_offset;
@@ -5475,7 +1376,7 @@ static int parse_bmp_structure(struct drm_device *dev, struct nvbios *bios, unsi
         bmp_version_major = bmp[5];
         bmp_version_minor = bmp[6];
 
-        NV_TRACE(dev, "BMP version %d.%d\n",
+        NV_INFO(drm, "BMP version %d.%d\n",
                  bmp_version_major, bmp_version_minor);
 
         /*
@@ -5491,7 +1392,7 @@ static int parse_bmp_structure(struct drm_device *dev, struct nvbios *bios, unsi
          * happened instead.
          */
         if ((bmp_version_major < 5 && bmp_version_minor != 1) || bmp_version_major > 5) {
-                NV_ERROR(dev, "You have an unsupported BMP version. "
+                NV_ERROR(drm, "You have an unsupported BMP version. "
                                 "Please send in your bios\n");
                 return -ENOSYS;
         }
@@ -5540,7 +1441,7 @@ static int parse_bmp_structure(struct drm_device *dev, struct nvbios *bios, unsi
 
         /* checksum */
         if (nv_cksum(bmp, 8)) {
-                NV_ERROR(dev, "Bad BMP checksum\n");
+                NV_ERROR(drm, "Bad BMP checksum\n");
                 return -EINVAL;
         }
 
@@ -5625,20 +1526,20 @@ static uint16_t findstr(uint8_t *data, int n, const uint8_t *str, int len)
 }
 
 void *
-dcb_table(struct drm_device *dev)
+olddcb_table(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 *dcb = NULL;
 
-        if (dev_priv->card_type > NV_04)
-                dcb = ROMPTR(dev, dev_priv->vbios.data[0x36]);
+        if (nv_device(drm->device)->card_type > NV_04)
+                dcb = ROMPTR(dev, drm->vbios.data[0x36]);
         if (!dcb) {
-                NV_WARNONCE(dev, "No DCB data found in VBIOS\n");
+                NV_WARN(drm, "No DCB data found in VBIOS\n");
                 return NULL;
         }
 
         if (dcb[0] >= 0x41) {
-                NV_WARNONCE(dev, "DCB version 0x%02x unknown\n", dcb[0]);
+                NV_WARN(drm, "DCB version 0x%02x unknown\n", dcb[0]);
                 return NULL;
         } else
         if (dcb[0] >= 0x30) {
@@ -5670,18 +1571,18 @@ dcb_table(struct drm_device *dev)
                  *
                  * v1.1 (NV5+, maybe some NV4) is entirely unhelpful
                  */
-                NV_WARNONCE(dev, "No useful DCB data in VBIOS\n");
+                NV_WARN(drm, "No useful DCB data in VBIOS\n");
                 return NULL;
         }
 
-        NV_WARNONCE(dev, "DCB header validation failed\n");
+        NV_WARN(drm, "DCB header validation failed\n");
         return NULL;
 }
 
 void *
-dcb_outp(struct drm_device *dev, u8 idx)
+olddcb_outp(struct drm_device *dev, u8 idx)
 {
-        u8 *dcb = dcb_table(dev);
+        u8 *dcb = olddcb_table(dev);
         if (dcb && dcb[0] >= 0x30) {
                 if (idx < dcb[2])
                         return dcb + dcb[1] + (idx * dcb[3]);
@@ -5703,20 +1604,20 @@ dcb_outp(struct drm_device *dev, u8 idx)
 }
 
 int
-dcb_outp_foreach(struct drm_device *dev, void *data,
+olddcb_outp_foreach(struct drm_device *dev, void *data,
                  int (*exec)(struct drm_device *, void *, int idx, u8 *outp))
 {
         int ret, idx = -1;
         u8 *outp = NULL;
-        while ((outp = dcb_outp(dev, ++idx))) {
+        while ((outp = olddcb_outp(dev, ++idx))) {
                 if (ROM32(outp[0]) == 0x00000000)
                         break; /* seen on an NV11 with DCB v1.5 */
                 if (ROM32(outp[0]) == 0xffffffff)
                         break; /* seen on an NV17 with DCB v2.0 */
 
-                if ((outp[0] & 0x0f) == OUTPUT_UNUSED)
+                if ((outp[0] & 0x0f) == DCB_OUTPUT_UNUSED)
                         continue;
-                if ((outp[0] & 0x0f) == OUTPUT_EOL)
+                if ((outp[0] & 0x0f) == DCB_OUTPUT_EOL)
                         break;
 
                 ret = exec(dev, data, idx, outp);
@@ -5728,9 +1629,9 @@ dcb_outp_foreach(struct drm_device *dev, void *data,
 }
 
 u8 *
-dcb_conntab(struct drm_device *dev)
+olddcb_conntab(struct drm_device *dev)
 {
-        u8 *dcb = dcb_table(dev);
+        u8 *dcb = olddcb_table(dev);
         if (dcb && dcb[0] >= 0x30 && dcb[1] >= 0x16) {
                 u8 *conntab = ROMPTR(dev, dcb[0x14]);
                 if (conntab && conntab[0] >= 0x30 && conntab[0] <= 0x40)
@@ -5740,19 +1641,19 @@ dcb_conntab(struct drm_device *dev)
 }
 
 u8 *
-dcb_conn(struct drm_device *dev, u8 idx)
+olddcb_conn(struct drm_device *dev, u8 idx)
 {
-        u8 *conntab = dcb_conntab(dev);
+        u8 *conntab = olddcb_conntab(dev);
         if (conntab && idx < conntab[2])
                 return conntab + conntab[1] + (idx * conntab[3]);
         return NULL;
 }
 
-static struct dcb_entry *new_dcb_entry(struct dcb_table *dcb)
+static struct dcb_output *new_dcb_entry(struct dcb_table *dcb)
 {
-        struct dcb_entry *entry = &dcb->entry[dcb->entries];
+        struct dcb_output *entry = &dcb->entry[dcb->entries];
 
-        memset(entry, 0, sizeof(struct dcb_entry));
+        memset(entry, 0, sizeof(struct dcb_output));
         entry->index = dcb->entries++;
 
         return entry;
@@ -5761,20 +1662,22 @@ static struct dcb_entry *new_dcb_entry(struct dcb_table *dcb)
 static void fabricate_dcb_output(struct dcb_table *dcb, int type, int i2c,
                                  int heads, int or)
 {
-        struct dcb_entry *entry = new_dcb_entry(dcb);
+        struct dcb_output *entry = new_dcb_entry(dcb);
 
         entry->type = type;
         entry->i2c_index = i2c;
         entry->heads = heads;
-        if (type != OUTPUT_ANALOG)
+        if (type != DCB_OUTPUT_ANALOG)
                 entry->location = !DCB_LOC_ON_CHIP; /* ie OFF CHIP */
         entry->or = or;
 }
 
 static bool
 parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
-                  uint32_t conn, uint32_t conf, struct dcb_entry *entry)
+                  uint32_t conn, uint32_t conf, struct dcb_output *entry)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         entry->type = conn & 0xf;
         entry->i2c_index = (conn >> 4) & 0xf;
         entry->heads = (conn >> 8) & 0xf;
@@ -5784,7 +1687,7 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
         entry->or = (conn >> 24) & 0xf;
 
         switch (entry->type) {
-        case OUTPUT_ANALOG:
+        case DCB_OUTPUT_ANALOG:
                 /*
                  * Although the rest of a CRT conf dword is usually
                  * zeros, mac biosen have stuff there so we must mask
@@ -5793,7 +1696,7 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
                                          (conf & 0xffff) * 10 :
                                          (conf & 0xff) * 10000;
                 break;
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 {
                 uint32_t mask;
                 if (conf & 0x1)
@@ -5828,12 +1731,12 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
                         if (dcb->version >= 0x40)
                                 break;
 
-                        NV_ERROR(dev, "Unknown LVDS configuration bits, "
+                        NV_ERROR(drm, "Unknown LVDS configuration bits, "
                                       "please report\n");
                 }
                 break;
                 }
-        case OUTPUT_TV:
+        case DCB_OUTPUT_TV:
         {
                 if (dcb->version >= 0x30)
                         entry->tvconf.has_component_output = conf & (0x8 << 4);
@@ -5842,7 +1745,7 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
 
                 break;
         }
-        case OUTPUT_DP:
+        case DCB_OUTPUT_DP:
                 entry->dpconf.sor.link = (conf & 0x00000030) >> 4;
                 switch ((conf & 0x00e00000) >> 21) {
                 case 0:
@@ -5864,7 +1767,7 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
                         break;
                 }
                 break;
-        case OUTPUT_TMDS:
+        case DCB_OUTPUT_TMDS:
                 if (dcb->version >= 0x40)
                         entry->tmdsconf.sor.link = (conf & 0x00000030) >> 4;
                 else if (dcb->version >= 0x30)
@@ -5873,7 +1776,7 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
                         entry->tmdsconf.slave_addr = (conf & 0x00000070) >> 4;
 
                 break;
-        case OUTPUT_EOL:
+        case DCB_OUTPUT_EOL:
                 /* weird g80 mobile type that "nv" treats as a terminator */
                 dcb->entries--;
                 return false;
@@ -5900,27 +1803,29 @@ parse_dcb20_entry(struct drm_device *dev, struct dcb_table *dcb,
 
 static bool
 parse_dcb15_entry(struct drm_device *dev, struct dcb_table *dcb,
-                  uint32_t conn, uint32_t conf, struct dcb_entry *entry)
+                  uint32_t conn, uint32_t conf, struct dcb_output *entry)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         switch (conn & 0x0000000f) {
         case 0:
-                entry->type = OUTPUT_ANALOG;
+                entry->type = DCB_OUTPUT_ANALOG;
                 break;
         case 1:
-                entry->type = OUTPUT_TV;
+                entry->type = DCB_OUTPUT_TV;
                 break;
         case 2:
         case 4:
                 if (conn & 0x10)
-                        entry->type = OUTPUT_LVDS;
+                        entry->type = DCB_OUTPUT_LVDS;
                 else
-                        entry->type = OUTPUT_TMDS;
+                        entry->type = DCB_OUTPUT_TMDS;
                 break;
         case 3:
-                entry->type = OUTPUT_LVDS;
+                entry->type = DCB_OUTPUT_LVDS;
                 break;
         default:
-                NV_ERROR(dev, "Unknown DCB type %d\n", conn & 0x0000000f);
+                NV_ERROR(drm, "Unknown DCB type %d\n", conn & 0x0000000f);
                 return false;
         }
 
@@ -5932,13 +1837,13 @@ parse_dcb15_entry(struct drm_device *dev, struct dcb_table *dcb,
         entry->duallink_possible = false;
 
         switch (entry->type) {
-        case OUTPUT_ANALOG:
+        case DCB_OUTPUT_ANALOG:
                 entry->crtconf.maxfreq = (conf & 0xffff) * 10;
                 break;
-        case OUTPUT_TV:
+        case DCB_OUTPUT_TV:
                 entry->tvconf.has_component_output = false;
                 break;
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 if ((conn & 0x00003f00) >> 8 != 0x10)
                         entry->lvdsconf.use_straps_for_mode = true;
                 entry->lvdsconf.use_power_scripts = true;
@@ -5959,14 +1864,15 @@ void merge_like_dcb_entries(struct drm_device *dev, struct dcb_table *dcb)
          * more options
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int i, newentries = 0;
 
         for (i = 0; i < dcb->entries; i++) {
-                struct dcb_entry *ient = &dcb->entry[i];
+                struct dcb_output *ient = &dcb->entry[i];
                 int j;
 
                 for (j = i + 1; j < dcb->entries; j++) {
-                        struct dcb_entry *jent = &dcb->entry[j];
+                        struct dcb_output *jent = &dcb->entry[j];
 
                         if (jent->type == 100) /* already merged entry */
                                 continue;
@@ -5976,7 +1882,7 @@ void merge_like_dcb_entries(struct drm_device *dev, struct dcb_table *dcb)
                             jent->type == ient->type &&
                             jent->location == ient->location &&
                             jent->or == ient->or) {
-                                NV_TRACE(dev, "Merging DCB entries %d and %d\n",
+                                NV_INFO(drm, "Merging DCB entries %d and %d\n",
                                          i, j);
                                 ient->heads |= jent->heads;
                                 jent->type = 100; /* dummy value */
@@ -6002,8 +1908,8 @@ void merge_like_dcb_entries(struct drm_device *dev, struct dcb_table *dcb)
 static bool
 apply_dcb_encoder_quirks(struct drm_device *dev, int idx, u32 *conn, u32 *conf)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct dcb_table *dcb = &dev_priv->vbios.dcb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct dcb_table *dcb = &drm->vbios.dcb;
 
         /* Dell Precision M6300
          *   DCB entry 2: 02025312 00000010
@@ -6029,7 +1935,7 @@ apply_dcb_encoder_quirks(struct drm_device *dev, int idx, u32 *conn, u32 *conf)
          */
         if (nv_match_device(dev, 0x0201, 0x1462, 0x8851)) {
                 if (*conn == 0xf2005014 && *conf == 0xffffffff) {
-                        fabricate_dcb_output(dcb, OUTPUT_TMDS, 1, 1, 1);
+                        fabricate_dcb_output(dcb, DCB_OUTPUT_TMDS, 1, 1, 1);
                         return false;
                 }
         }
@@ -6115,24 +2021,24 @@ fabricate_dcb_encoder_table(struct drm_device *dev, struct nvbios *bios)
 #ifdef __powerpc__
         /* Apple iMac G4 NV17 */
         if (of_machine_is_compatible("PowerMac4,5")) {
-                fabricate_dcb_output(dcb, OUTPUT_TMDS, 0, all_heads, 1);
-                fabricate_dcb_output(dcb, OUTPUT_ANALOG, 1, all_heads, 2);
+                fabricate_dcb_output(dcb, DCB_OUTPUT_TMDS, 0, all_heads, 1);
+                fabricate_dcb_output(dcb, DCB_OUTPUT_ANALOG, 1, all_heads, 2);
                 return;
         }
 #endif
 
         /* Make up some sane defaults */
-        fabricate_dcb_output(dcb, OUTPUT_ANALOG,
+        fabricate_dcb_output(dcb, DCB_OUTPUT_ANALOG,
                              bios->legacy.i2c_indices.crt, 1, 1);
 
         if (nv04_tv_identify(dev, bios->legacy.i2c_indices.tv) >= 0)
-                fabricate_dcb_output(dcb, OUTPUT_TV,
+                fabricate_dcb_output(dcb, DCB_OUTPUT_TV,
                                      bios->legacy.i2c_indices.tv,
                                      all_heads, 0);
 
         else if (bios->tmds.output0_script_ptr ||
                  bios->tmds.output1_script_ptr)
-                fabricate_dcb_output(dcb, OUTPUT_TMDS,
+                fabricate_dcb_output(dcb, DCB_OUTPUT_TMDS,
                                      bios->legacy.i2c_indices.panel,
                                      all_heads, 1);
 }
@@ -6140,16 +2046,16 @@ fabricate_dcb_encoder_table(struct drm_device *dev, struct nvbios *bios)
 static int
 parse_dcb_entry(struct drm_device *dev, void *data, int idx, u8 *outp)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct dcb_table *dcb = &dev_priv->vbios.dcb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct dcb_table *dcb = &drm->vbios.dcb;
         u32 conf = (dcb->version >= 0x20) ? ROM32(outp[4]) : ROM32(outp[6]);
         u32 conn = ROM32(outp[0]);
         bool ret;
 
         if (apply_dcb_encoder_quirks(dev, idx, &conn, &conf)) {
-                struct dcb_entry *entry = new_dcb_entry(dcb);
+                struct dcb_output *entry = new_dcb_entry(dcb);
 
-                NV_TRACEWARN(dev, "DCB outp %02d: %08x %08x\n", idx, conn, conf);
+                NV_INFO(drm, "DCB outp %02d: %08x %08x\n", idx, conn, conf);
 
                 if (dcb->version >= 0x20)
                         ret = parse_dcb20_entry(dev, dcb, conn, conf, entry);
@@ -6162,7 +2068,7 @@ parse_dcb_entry(struct drm_device *dev, void *data, int idx, u8 *outp)
                  * are cards with bogus values (nv31m in bug 23212),
                  * and it's otherwise useless.
                  */
-                if (entry->type == OUTPUT_TV &&
+                if (entry->type == DCB_OUTPUT_TV &&
                     entry->location == DCB_LOC_ON_CHIP)
                         entry->i2c_index = 0x0f;
         }
@@ -6210,7 +2116,7 @@ dcb_fake_connectors(struct nvbios *bios)
          * table - just in case it has random, rather than stub, entries.
          */
         if (i > 1) {
-                u8 *conntab = dcb_conntab(bios->dev);
+                u8 *conntab = olddcb_conntab(bios->dev);
                 if (conntab)
                         conntab[0] = 0x00;
         }
@@ -6219,11 +2125,12 @@ dcb_fake_connectors(struct nvbios *bios)
 static int
 parse_dcb_table(struct drm_device *dev, struct nvbios *bios)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct dcb_table *dcb = &bios->dcb;
         u8 *dcbt, *conn;
         int idx;
 
-        dcbt = dcb_table(dev);
+        dcbt = olddcb_table(dev);
         if (!dcbt) {
                 /* handle pre-DCB boards */
                 if (bios->type == NVBIOS_BMP) {
@@ -6234,10 +2141,10 @@ parse_dcb_table(struct drm_device *dev, struct nvbios *bios)
                 return -EINVAL;
         }
 
-        NV_TRACE(dev, "DCB version %d.%d\n", dcbt[0] >> 4, dcbt[0] & 0xf);
+        NV_INFO(drm, "DCB version %d.%d\n", dcbt[0] >> 4, dcbt[0] & 0xf);
 
         dcb->version = dcbt[0];
-        dcb_outp_foreach(dev, NULL, parse_dcb_entry);
+        olddcb_outp_foreach(dev, NULL, parse_dcb_entry);
 
         /*
          * apart for v2.1+ not being known for requiring merging, this
@@ -6251,10 +2158,10 @@ parse_dcb_table(struct drm_device *dev, struct nvbios *bios)
 
         /* dump connector table entries to log, if any exist */
         idx = -1;
-        while ((conn = dcb_conn(dev, ++idx))) {
+        while ((conn = olddcb_conn(dev, ++idx))) {
                 if (conn[0] != 0xff) {
-                        NV_TRACE(dev, "DCB conn %02d: ", idx);
-                        if (dcb_conntab(dev)[3] < 4)
+                        NV_INFO(drm, "DCB conn %02d: ", idx);
+                        if (olddcb_conntab(dev)[3] < 4)
                                 printk("%04x\n", ROM16(conn[0]));
                         else
                                 printk("%08x\n", ROM32(conn[0]));
@@ -6275,12 +2182,14 @@ static int load_nv17_hwsq_ucode_entry(struct drm_device *dev, struct nvbios *bio
          * starting at reg 0x00001400
          */
 
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
         uint8_t bytes_to_write;
         uint16_t hwsq_entry_offset;
         int i;
 
         if (bios->data[hwsq_offset] <= entry) {
-                NV_ERROR(dev, "Too few entries in HW sequencer table for "
+                NV_ERROR(drm, "Too few entries in HW sequencer table for "
                                 "requested entry\n");
                 return -ENOENT;
         }
@@ -6288,24 +2197,24 @@ static int load_nv17_hwsq_ucode_entry(struct drm_device *dev, struct nvbios *bio
         bytes_to_write = bios->data[hwsq_offset + 1];
 
         if (bytes_to_write != 36) {
-                NV_ERROR(dev, "Unknown HW sequencer entry size\n");
+                NV_ERROR(drm, "Unknown HW sequencer entry size\n");
                 return -EINVAL;
         }
 
-        NV_TRACE(dev, "Loading NV17 power sequencing microcode\n");
+        NV_INFO(drm, "Loading NV17 power sequencing microcode\n");
 
         hwsq_entry_offset = hwsq_offset + 2 + entry * bytes_to_write;
 
         /* set sequencer control */
-        bios_wr32(bios, 0x00001304, ROM32(bios->data[hwsq_entry_offset]));
+        nv_wr32(device, 0x00001304, ROM32(bios->data[hwsq_entry_offset]));
         bytes_to_write -= 4;
 
         /* write ucode */
         for (i = 0; i < bytes_to_write; i += 4)
-                bios_wr32(bios, 0x00001400 + i, ROM32(bios->data[hwsq_entry_offset + i + 4]));
+                nv_wr32(device, 0x00001400 + i, ROM32(bios->data[hwsq_entry_offset + i + 4]));
 
         /* twiddle NV_PBUS_DEBUG_4 */
-        bios_wr32(bios, NV_PBUS_DEBUG_4, bios_rd32(bios, NV_PBUS_DEBUG_4) | 0x18);
+        nv_wr32(device, NV_PBUS_DEBUG_4, nv_rd32(device, NV_PBUS_DEBUG_4) | 0x18);
 
         return 0;
 }
@@ -6336,8 +2245,8 @@ static int load_nv17_hw_sequencer_ucode(struct drm_device *dev,
 
 uint8_t *nouveau_bios_embedded_edid(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         const uint8_t edid_sig[] = {
                         0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
         uint16_t offset = 0;
@@ -6360,53 +2269,29 @@ uint8_t *nouveau_bios_embedded_edid(struct drm_device *dev)
                 offset++;
         }
 
-        NV_TRACE(dev, "Found EDID in BIOS\n");
+        NV_INFO(drm, "Found EDID in BIOS\n");
 
         return bios->fp.edid = &bios->data[offset];
 }
 
-void
-nouveau_bios_run_init_table(struct drm_device *dev, uint16_t table,
-                            struct dcb_entry *dcbent, int crtc)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct init_exec iexec = { true, false };
-
-        spin_lock_bh(&bios->lock);
-        bios->display.output = dcbent;
-        bios->display.crtc = crtc;
-        parse_init_table(bios, table, &iexec);
-        bios->display.output = NULL;
-        spin_unlock_bh(&bios->lock);
-}
-
-void
-nouveau_bios_init_exec(struct drm_device *dev, uint16_t table)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct init_exec iexec = { true, false };
-
-        parse_init_table(bios, table, &iexec);
-}
-
 static bool NVInitVBIOS(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
 
         memset(bios, 0, sizeof(struct nvbios));
         spin_lock_init(&bios->lock);
         bios->dev = dev;
 
-        return bios_shadow(dev);
+        bios->data = nouveau_bios(drm->device)->data;
+        bios->length = nouveau_bios(drm->device)->size;
+        return true;
 }
 
 static int nouveau_parse_vbios_struct(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         const uint8_t bit_signature[] = { 0xff, 0xb8, 'B', 'I', 'T' };
         const uint8_t bmp_signature[] = { 0xff, 0x7f, 'N', 'V', 0x0 };
         int offset;
@@ -6414,7 +2299,7 @@ static int nouveau_parse_vbios_struct(struct drm_device *dev)
         offset = findstr(bios->data, bios->length,
                                         bit_signature, sizeof(bit_signature));
         if (offset) {
-                NV_TRACE(dev, "BIT BIOS found\n");
+                NV_INFO(drm, "BIT BIOS found\n");
                 bios->type = NVBIOS_BIT;
                 bios->offset = offset;
                 return parse_bit_structure(bios, offset + 6);
@@ -6423,21 +2308,21 @@ static int nouveau_parse_vbios_struct(struct drm_device *dev)
         offset = findstr(bios->data, bios->length,
                                         bmp_signature, sizeof(bmp_signature));
         if (offset) {
-                NV_TRACE(dev, "BMP BIOS found\n");
+                NV_INFO(drm, "BMP BIOS found\n");
                 bios->type = NVBIOS_BMP;
                 bios->offset = offset;
                 return parse_bmp_structure(dev, bios, offset);
         }
 
-        NV_ERROR(dev, "No known BIOS signature found\n");
+        NV_ERROR(drm, "No known BIOS signature found\n");
         return -ENODEV;
 }
 
 int
 nouveau_run_vbios_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         int i, ret = 0;
 
         /* Reset the BIOS head to 0. */
@@ -6451,23 +2336,8 @@ nouveau_run_vbios_init(struct drm_device *dev)
                 bios->fp.lvds_init_run = false;
         }
 
-        parse_init_tables(bios);
-
-        /*
-         * Runs some additional script seen on G8x VBIOSen.  The VBIOS'
-         * parser will run this right after the init tables, the binary
-         * driver appears to run it at some point later.
-         */
-        if (bios->some_script_ptr) {
-                struct init_exec iexec = {true, false};
-
-                NV_INFO(dev, "Parsing VBIOS init table at offset 0x%04X\n",
-                        bios->some_script_ptr);
-                parse_init_table(bios, bios->some_script_ptr, &iexec);
-        }
-
-        if (dev_priv->card_type >= NV_50) {
-                for (i = 0; i < bios->dcb.entries; i++) {
+        if (nv_device(drm->device)->card_type >= NV_50) {
+                for (i = 0; bios->execute && i < bios->dcb.entries; i++) {
                         nouveau_bios_run_display_table(dev, 0, 0,
                                                        &bios->dcb.entry[i], -1);
                 }
@@ -6479,10 +2349,10 @@ nouveau_run_vbios_init(struct drm_device *dev)
 static bool
 nouveau_bios_posted(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         unsigned htotal;
 
-        if (dev_priv->card_type >= NV_50) {
+        if (nv_device(drm->device)->card_type >= NV_50) {
                 if (NVReadVgaCrtc(dev, 0, 0x00) == 0 &&
                     NVReadVgaCrtc(dev, 0, 0x1a) == 0)
                         return false;
@@ -6501,8 +2371,8 @@ nouveau_bios_posted(struct drm_device *dev)
 int
 nouveau_bios_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         int ret;
 
         if (!NVInitVBIOS(dev))
@@ -6512,14 +2382,6 @@ nouveau_bios_init(struct drm_device *dev)
         if (ret)
                 return ret;
 
-        ret = nouveau_i2c_init(dev);
-        if (ret)
-                return ret;
-
-        ret = nouveau_mxm_init(dev);
-        if (ret)
-                return ret;
-
         ret = parse_dcb_table(dev, bios);
         if (ret)
                 return ret;
@@ -6532,12 +2394,10 @@ nouveau_bios_init(struct drm_device *dev)
 
         /* ... unless card isn't POSTed already */
         if (!nouveau_bios_posted(dev)) {
-                NV_INFO(dev, "Adaptor not initialised, "
+                NV_INFO(drm, "Adaptor not initialised, "
                         "running VBIOS init tables.\n");
                 bios->execute = true;
         }
-        if (nouveau_force_post)
-                bios->execute = true;
 
         ret = nouveau_run_vbios_init(dev);
         if (ret)
@@ -6560,10 +2420,4 @@ nouveau_bios_init(struct drm_device *dev)
 void
 nouveau_bios_takedown(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nouveau_mxm_fini(dev);
-        nouveau_i2c_fini(dev);
-
-        kfree(dev_priv->vbios.data);
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.h b/drivers/gpu/drm/nouveau/nouveau_bios.h
index 298a3af48d14..3befbb821a56 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.h
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.h
@@ -21,11 +21,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef __NOUVEAU_BIOS_H__
-#define __NOUVEAU_BIOS_H__
+#ifndef __NOUVEAU_DISPBIOS_H__
+#define __NOUVEAU_DISPBIOS_H__
 
 #include "nvreg.h"
-#include "nouveau_i2c.h"
 
 #define DCB_MAX_NUM_ENTRIES 16
 #define DCB_MAX_NUM_I2C_ENTRIES 16
@@ -39,8 +38,8 @@
 #define ROM48(x) ({ u8 *p = &(x); (u64)ROM16(p[4]) << 32 | ROM32(p[0]); })
 #define ROM64(x) le64_to_cpu(*(u64 *)&(x))
 #define ROMPTR(d,x) ({            \
-        struct drm_nouveau_private *dev_priv = (d)->dev_private; \
-        ROM16(x) ? &dev_priv->vbios.data[ROM16(x)] : NULL; \
+        struct nouveau_drm *drm = nouveau_drm((d)); \
+        ROM16(x) ? &drm->vbios.data[ROM16(x)] : NULL; \
 })
 
 struct bit_entry {
@@ -53,95 +52,19 @@ struct bit_entry {
 
 int bit_table(struct drm_device *, u8 id, struct bit_entry *);
 
-enum dcb_gpio_tag {
-        DCB_GPIO_PANEL_POWER = 0x01,
-        DCB_GPIO_TVDAC0 = 0x0c,
-        DCB_GPIO_TVDAC1 = 0x2d,
-        DCB_GPIO_PWM_FAN = 0x09,
-        DCB_GPIO_FAN_SENSE = 0x3d,
-        DCB_GPIO_UNUSED = 0xff
-};
-
-enum dcb_connector_type {
-        DCB_CONNECTOR_VGA = 0x00,
-        DCB_CONNECTOR_TV_0 = 0x10,
-        DCB_CONNECTOR_TV_1 = 0x11,
-        DCB_CONNECTOR_TV_3 = 0x13,
-        DCB_CONNECTOR_DVI_I = 0x30,
-        DCB_CONNECTOR_DVI_D = 0x31,
-        DCB_CONNECTOR_DMS59_0 = 0x38,
-        DCB_CONNECTOR_DMS59_1 = 0x39,
-        DCB_CONNECTOR_LVDS = 0x40,
-        DCB_CONNECTOR_LVDS_SPWG = 0x41,
-        DCB_CONNECTOR_DP = 0x46,
-        DCB_CONNECTOR_eDP = 0x47,
-        DCB_CONNECTOR_HDMI_0 = 0x60,
-        DCB_CONNECTOR_HDMI_1 = 0x61,
-        DCB_CONNECTOR_DMS59_DP0 = 0x64,
-        DCB_CONNECTOR_DMS59_DP1 = 0x65,
-        DCB_CONNECTOR_NONE = 0xff
-};
-
-enum dcb_type {
-        OUTPUT_ANALOG = 0,
-        OUTPUT_TV = 1,
-        OUTPUT_TMDS = 2,
-        OUTPUT_LVDS = 3,
-        OUTPUT_DP = 6,
-        OUTPUT_EOL = 14, /* DCB 4.0+, appears to be end-of-list */
-        OUTPUT_UNUSED = 15,
-        OUTPUT_ANY = -1
-};
-
-struct dcb_entry {
-        int index;      /* may not be raw dcb index if merging has happened */
-        enum dcb_type type;
-        uint8_t i2c_index;
-        uint8_t heads;
-        uint8_t connector;
-        uint8_t bus;
-        uint8_t location;
-        uint8_t or;
-        bool duallink_possible;
-        union {
-                struct sor_conf {
-                        int link;
-                } sorconf;
-                struct {
-                        int maxfreq;
-                } crtconf;
-                struct {
-                        struct sor_conf sor;
-                        bool use_straps_for_mode;
-                        bool use_acpi_for_edid;
-                        bool use_power_scripts;
-                } lvdsconf;
-                struct {
-                        bool has_component_output;
-                } tvconf;
-                struct {
-                        struct sor_conf sor;
-                        int link_nr;
-                        int link_bw;
-                } dpconf;
-                struct {
-                        struct sor_conf sor;
-                        int slave_addr;
-                } tmdsconf;
-        };
-        bool i2c_upper_default;
-};
+#include <subdev/bios/dcb.h>
+#include <subdev/bios/conn.h>
 
 struct dcb_table {
         uint8_t version;
         int entries;
-        struct dcb_entry entry[DCB_MAX_NUM_ENTRIES];
+        struct dcb_output entry[DCB_MAX_NUM_ENTRIES];
 };
 
 enum nouveau_or {
-        OUTPUT_A = (1 << 0),
-        OUTPUT_B = (1 << 1),
-        OUTPUT_C = (1 << 2)
+        DCB_OUTPUT_A = (1 << 0),
+        DCB_OUTPUT_B = (1 << 1),
+        DCB_OUTPUT_C = (1 << 2)
 };
 
 enum LVDS_script {
@@ -154,58 +77,6 @@ enum LVDS_script {
         LVDS_PANEL_OFF
 };
 
-/* these match types in pll limits table version 0x40,
- * nouveau uses them on all chipsets internally where a
- * specific pll needs to be referenced, but the exact
- * register isn't known.
- */
-enum pll_types {
-        PLL_CORE   = 0x01,
-        PLL_SHADER = 0x02,
-        PLL_UNK03  = 0x03,
-        PLL_MEMORY = 0x04,
-        PLL_VDEC   = 0x05,
-        PLL_UNK40  = 0x40,
-        PLL_UNK41  = 0x41,
-        PLL_UNK42  = 0x42,
-        PLL_VPLL0  = 0x80,
-        PLL_VPLL1  = 0x81,
-        PLL_MAX    = 0xff
-};
-
-struct pll_lims {
-        u32 reg;
-
-        struct {
-                int minfreq;
-                int maxfreq;
-                int min_inputfreq;
-                int max_inputfreq;
-
-                uint8_t min_m;
-                uint8_t max_m;
-                uint8_t min_n;
-                uint8_t max_n;
-        } vco1, vco2;
-
-        uint8_t max_log2p;
-        /*
-         * for most pre nv50 cards setting a log2P of 7 (the common max_log2p
-         * value) is no different to 6 (at least for vplls) so allowing the MNP
-         * calc to use 7 causes the generated clock to be out by a factor of 2.
-         * however, max_log2p cannot be fixed-up during parsing as the
-         * unmodified max_log2p value is still needed for setting mplls, hence
-         * an additional max_usable_log2p member
-         */
-        uint8_t max_usable_log2p;
-        uint8_t log2p_bias;
-
-        uint8_t min_p;
-        uint8_t max_p;
-
-        int refclk;
-};
-
 struct nvbios {
         struct drm_device *dev;
         enum {
@@ -257,7 +128,7 @@ struct nvbios {
         } state;
 
         struct {
-                struct dcb_entry *output;
+                struct dcb_output *output;
                 int crtc;
                 uint16_t script_table_ptr;
         } display;
@@ -302,11 +173,28 @@ struct nvbios {
         } legacy;
 };
 
-void *dcb_table(struct drm_device *);
-void *dcb_outp(struct drm_device *, u8 idx);
-int dcb_outp_foreach(struct drm_device *, void *data,
+void *olddcb_table(struct drm_device *);
+void *olddcb_outp(struct drm_device *, u8 idx);
+int olddcb_outp_foreach(struct drm_device *, void *data,
                      int (*)(struct drm_device *, void *, int idx, u8 *outp));
-u8 *dcb_conntab(struct drm_device *);
-u8 *dcb_conn(struct drm_device *, u8 idx);
+u8 *olddcb_conntab(struct drm_device *);
+u8 *olddcb_conn(struct drm_device *, u8 idx);
+
+int nouveau_bios_init(struct drm_device *);
+void nouveau_bios_takedown(struct drm_device *dev);
+int nouveau_run_vbios_init(struct drm_device *);
+struct dcb_connector_table_entry *
+nouveau_bios_connector_entry(struct drm_device *, int index);
+int nouveau_bios_run_display_table(struct drm_device *, u16 id, int clk,
+                                          struct dcb_output *, int crtc);
+bool nouveau_bios_fp_mode(struct drm_device *, struct drm_display_mode *);
+uint8_t *nouveau_bios_embedded_edid(struct drm_device *);
+int nouveau_bios_parse_lvds_table(struct drm_device *, int pxclk,
+                                         bool *dl, bool *if_is_24bit);
+int run_tmds_table(struct drm_device *, struct dcb_output *,
+                          int head, int pxclk);
+int call_lvds_script(struct drm_device *, struct dcb_output *, int head,
+                            enum LVDS_script, int pxclk);
+bool bios_encoder_match(struct dcb_output *, u32 hash);
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.c b/drivers/gpu/drm/nouveau/nouveau_bo.c
index 7f80ed523562..259e5f1adf47 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bo.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bo.c
@@ -27,31 +27,127 @@
  *          Jeremy Kolb  <jkolb@brandeis.edu>
  */
 
-#include "drmP.h"
-#include "ttm/ttm_page_alloc.h"
+#include <core/engine.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+#include <subdev/bar.h>
 
 #include "nouveau_drm.h"
-#include "nouveau_drv.h"
 #include "nouveau_dma.h"
-#include "nouveau_mm.h"
-#include "nouveau_vm.h"
 #include "nouveau_fence.h"
-#include "nouveau_ramht.h"
 
-#include <linux/log2.h>
-#include <linux/slab.h>
+#include "nouveau_bo.h"
+#include "nouveau_ttm.h"
+#include "nouveau_gem.h"
+
+/*
+ * NV10-NV40 tiling helpers
+ */
+
+static void
+nv10_bo_update_tile_region(struct drm_device *dev, struct nouveau_drm_tile *reg,
+                           u32 addr, u32 size, u32 pitch, u32 flags)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        int i = reg - drm->tile.reg;
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
+        struct nouveau_fb_tile *tile = &pfb->tile.region[i];
+        struct nouveau_engine *engine;
+
+        nouveau_fence_unref(&reg->fence);
+
+        if (tile->pitch)
+                pfb->tile.fini(pfb, i, tile);
+
+        if (pitch)
+                pfb->tile.init(pfb, i, addr, size, pitch, flags, tile);
+
+        pfb->tile.prog(pfb, i, tile);
+
+        if ((engine = nouveau_engine(pfb, NVDEV_ENGINE_GR)))
+                engine->tile_prog(engine, i);
+        if ((engine = nouveau_engine(pfb, NVDEV_ENGINE_MPEG)))
+                engine->tile_prog(engine, i);
+}
+
+static struct nouveau_drm_tile *
+nv10_bo_get_tile_region(struct drm_device *dev, int i)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_drm_tile *tile = &drm->tile.reg[i];
+
+        spin_lock(&drm->tile.lock);
+
+        if (!tile->used &&
+            (!tile->fence || nouveau_fence_done(tile->fence)))
+                tile->used = true;
+        else
+                tile = NULL;
+
+        spin_unlock(&drm->tile.lock);
+        return tile;
+}
+
+static void
+nv10_bo_put_tile_region(struct drm_device *dev, struct nouveau_drm_tile *tile,
+                        struct nouveau_fence *fence)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
+        if (tile) {
+                spin_lock(&drm->tile.lock);
+                if (fence) {
+                        /* Mark it as pending. */
+                        tile->fence = fence;
+                        nouveau_fence_ref(fence);
+                }
+
+                tile->used = false;
+                spin_unlock(&drm->tile.lock);
+        }
+}
+
+static struct nouveau_drm_tile *
+nv10_bo_set_tiling(struct drm_device *dev, u32 addr,
+                   u32 size, u32 pitch, u32 flags)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
+        struct nouveau_drm_tile *tile, *found = NULL;
+        int i;
+
+        for (i = 0; i < pfb->tile.regions; i++) {
+                tile = nv10_bo_get_tile_region(dev, i);
+
+                if (pitch && !found) {
+                        found = tile;
+                        continue;
+
+                } else if (tile && pfb->tile.region[i].pitch) {
+                        /* Kill an unused tile region. */
+                        nv10_bo_update_tile_region(dev, tile, 0, 0, 0, 0);
+                }
+
+                nv10_bo_put_tile_region(dev, tile, NULL);
+        }
+
+        if (found)
+                nv10_bo_update_tile_region(dev, found, addr, size,
+                                            pitch, flags);
+        return found;
+}
 
 static void
 nouveau_bo_del_ttm(struct ttm_buffer_object *bo)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
+        struct drm_device *dev = drm->dev;
         struct nouveau_bo *nvbo = nouveau_bo(bo);
 
         if (unlikely(nvbo->gem))
                 DRM_ERROR("bo %p still attached to GEM object\n", bo);
-
-        nv10_mem_put_tile_region(dev, nvbo->tile, NULL);
+        nv10_bo_put_tile_region(dev, nvbo->tile, NULL);
         kfree(nvbo);
 }
 
@@ -59,23 +155,24 @@ static void
 nouveau_bo_fixup_align(struct nouveau_bo *nvbo, u32 flags,
                        int *align, int *size)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(nvbo->bo.bdev);
+        struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
+        struct nouveau_device *device = nv_device(drm->device);
 
-        if (dev_priv->card_type < NV_50) {
+        if (device->card_type < NV_50) {
                 if (nvbo->tile_mode) {
-                        if (dev_priv->chipset >= 0x40) {
+                        if (device->chipset >= 0x40) {
                                 *align = 65536;
                                 *size = roundup(*size, 64 * nvbo->tile_mode);
 
-                        } else if (dev_priv->chipset >= 0x30) {
+                        } else if (device->chipset >= 0x30) {
                                 *align = 32768;
                                 *size = roundup(*size, 64 * nvbo->tile_mode);
 
-                        } else if (dev_priv->chipset >= 0x20) {
+                        } else if (device->chipset >= 0x20) {
                                 *align = 16384;
                                 *size = roundup(*size, 64 * nvbo->tile_mode);
 
-                        } else if (dev_priv->chipset >= 0x10) {
+                        } else if (device->chipset >= 0x10) {
                                 *align = 16384;
                                 *size = roundup(*size, 32 * nvbo->tile_mode);
                         }
@@ -94,7 +191,7 @@ nouveau_bo_new(struct drm_device *dev, int size, int align,
                struct sg_table *sg,
                struct nouveau_bo **pnvbo)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_bo *nvbo;
         size_t acc_size;
         int ret;
@@ -111,22 +208,22 @@ nouveau_bo_new(struct drm_device *dev, int size, int align,
         INIT_LIST_HEAD(&nvbo->vma_list);
         nvbo->tile_mode = tile_mode;
         nvbo->tile_flags = tile_flags;
-        nvbo->bo.bdev = &dev_priv->ttm.bdev;
+        nvbo->bo.bdev = &drm->ttm.bdev;
 
         nvbo->page_shift = 12;
-        if (dev_priv->bar1_vm) {
+        if (drm->client.base.vm) {
                 if (!(flags & TTM_PL_FLAG_TT) && size > 256 * 1024)
-                        nvbo->page_shift = dev_priv->bar1_vm->lpg_shift;
+                        nvbo->page_shift = drm->client.base.vm->vmm->lpg_shift;
         }
 
         nouveau_bo_fixup_align(nvbo, flags, &align, &size);
         nvbo->bo.mem.num_pages = size >> PAGE_SHIFT;
         nouveau_bo_placement_set(nvbo, flags, 0);
 
-        acc_size = ttm_bo_dma_acc_size(&dev_priv->ttm.bdev, size,
+        acc_size = ttm_bo_dma_acc_size(&drm->ttm.bdev, size,
                                        sizeof(struct nouveau_bo));
 
-        ret = ttm_bo_init(&dev_priv->ttm.bdev, &nvbo->bo, size,
+        ret = ttm_bo_init(&drm->ttm.bdev, &nvbo->bo, size,
                           type, &nvbo->placement,
                           align >> PAGE_SHIFT, 0, false, NULL, acc_size, sg,
                           nouveau_bo_del_ttm);
@@ -155,10 +252,11 @@ set_placement_list(uint32_t *pl, unsigned *n, uint32_t type, uint32_t flags)
 static void
 set_placement_range(struct nouveau_bo *nvbo, uint32_t type)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(nvbo->bo.bdev);
-        int vram_pages = dev_priv->vram_size >> PAGE_SHIFT;
+        struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
+        u32 vram_pages = pfb->ram.size >> PAGE_SHIFT;
 
-        if (dev_priv->card_type == NV_10 &&
+        if (nv_device(drm->device)->card_type == NV_10 &&
             nvbo->tile_mode && (type & TTM_PL_FLAG_VRAM) &&
             nvbo->bo.mem.num_pages < vram_pages / 4) {
                 /*
@@ -198,13 +296,12 @@ nouveau_bo_placement_set(struct nouveau_bo *nvbo, uint32_t type, uint32_t busy)
 int
 nouveau_bo_pin(struct nouveau_bo *nvbo, uint32_t memtype)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(nvbo->bo.bdev);
+        struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
         struct ttm_buffer_object *bo = &nvbo->bo;
         int ret;
 
         if (nvbo->pin_refcnt && !(memtype & (1 << bo->mem.mem_type))) {
-                NV_ERROR(nouveau_bdev(bo->bdev)->dev,
-                         "bo %p pinned elsewhere: 0x%08x vs 0x%08x\n", bo,
+                NV_ERROR(drm, "bo %p pinned elsewhere: 0x%08x vs 0x%08x\n", bo,
                          1 << bo->mem.mem_type, memtype);
                 return -EINVAL;
         }
@@ -222,10 +319,10 @@ nouveau_bo_pin(struct nouveau_bo *nvbo, uint32_t memtype)
         if (ret == 0) {
                 switch (bo->mem.mem_type) {
                 case TTM_PL_VRAM:
-                        dev_priv->fb_aper_free -= bo->mem.size;
+                        drm->gem.vram_available -= bo->mem.size;
                         break;
                 case TTM_PL_TT:
-                        dev_priv->gart_info.aper_free -= bo->mem.size;
+                        drm->gem.gart_available -= bo->mem.size;
                         break;
                 default:
                         break;
@@ -241,7 +338,7 @@ out:
 int
 nouveau_bo_unpin(struct nouveau_bo *nvbo)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(nvbo->bo.bdev);
+        struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
         struct ttm_buffer_object *bo = &nvbo->bo;
         int ret;
 
@@ -258,10 +355,10 @@ nouveau_bo_unpin(struct nouveau_bo *nvbo)
         if (ret == 0) {
                 switch (bo->mem.mem_type) {
                 case TTM_PL_VRAM:
-                        dev_priv->fb_aper_free += bo->mem.size;
+                        drm->gem.vram_available += bo->mem.size;
                         break;
                 case TTM_PL_TT:
-                        dev_priv->gart_info.aper_free += bo->mem.size;
+                        drm->gem.gart_available += bo->mem.size;
                         break;
                 default:
                         break;
@@ -356,30 +453,18 @@ nouveau_bo_wr32(struct nouveau_bo *nvbo, unsigned index, u32 val)
 }
 
 static struct ttm_tt *
-nouveau_ttm_tt_create(struct ttm_bo_device *bdev,
-                      unsigned long size, uint32_t page_flags,
-                      struct page *dummy_read_page)
+nouveau_ttm_tt_create(struct ttm_bo_device *bdev, unsigned long size,
+                      uint32_t page_flags, struct page *dummy_read)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bdev);
+        struct drm_device *dev = drm->dev;
 
-        switch (dev_priv->gart_info.type) {
-#if __OS_HAS_AGP
-        case NOUVEAU_GART_AGP:
-                return ttm_agp_tt_create(bdev, dev->agp->bridge,
-                                         size, page_flags, dummy_read_page);
-#endif
-        case NOUVEAU_GART_PDMA:
-        case NOUVEAU_GART_HW:
-                return nouveau_sgdma_create_ttm(bdev, size, page_flags,
-                                                dummy_read_page);
-        default:
-                NV_ERROR(dev, "Unknown GART type %d\n",
-                         dev_priv->gart_info.type);
-                break;
+        if (drm->agp.stat == ENABLED) {
+                return ttm_agp_tt_create(bdev, dev->agp->bridge, size,
+                                         page_flags, dummy_read);
         }
 
-        return NULL;
+        return nouveau_sgdma_create_ttm(bdev, size, page_flags, dummy_read);
 }
 
 static int
@@ -393,8 +478,7 @@ static int
 nouveau_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
                          struct ttm_mem_type_manager *man)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bdev);
 
         switch (type) {
         case TTM_PL_SYSTEM:
@@ -403,7 +487,7 @@ nouveau_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
                 man->default_caching = TTM_PL_FLAG_CACHED;
                 break;
         case TTM_PL_VRAM:
-                if (dev_priv->card_type >= NV_50) {
+                if (nv_device(drm->device)->card_type >= NV_50) {
                         man->func = &nouveau_vram_manager;
                         man->io_reserve_fastpath = false;
                         man->use_io_reserve_lru = true;
@@ -417,32 +501,28 @@ nouveau_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
                 man->default_caching = TTM_PL_FLAG_WC;
                 break;
         case TTM_PL_TT:
-                if (dev_priv->card_type >= NV_50)
+                if (nv_device(drm->device)->card_type >= NV_50)
                         man->func = &nouveau_gart_manager;
                 else
+                if (drm->agp.stat != ENABLED)
+                        man->func = &nv04_gart_manager;
+                else
                         man->func = &ttm_bo_manager_func;
-                switch (dev_priv->gart_info.type) {
-                case NOUVEAU_GART_AGP:
+
+                if (drm->agp.stat == ENABLED) {
                         man->flags = TTM_MEMTYPE_FLAG_MAPPABLE;
                         man->available_caching = TTM_PL_FLAG_UNCACHED |
                                 TTM_PL_FLAG_WC;
                         man->default_caching = TTM_PL_FLAG_WC;
-                        break;
-                case NOUVEAU_GART_PDMA:
-                case NOUVEAU_GART_HW:
+                } else {
                         man->flags = TTM_MEMTYPE_FLAG_MAPPABLE |
                                      TTM_MEMTYPE_FLAG_CMA;
                         man->available_caching = TTM_PL_MASK_CACHING;
                         man->default_caching = TTM_PL_FLAG_CACHED;
-                        break;
-                default:
-                        NV_ERROR(dev, "Unknown GART type: %d\n",
-                                 dev_priv->gart_info.type);
-                        return -EINVAL;
                 }
+
                 break;
         default:
-                NV_ERROR(dev, "Unsupported memory type %u\n", (unsigned)type);
                 return -EINVAL;
         }
         return 0;
@@ -491,6 +571,18 @@ nouveau_bo_move_accel_cleanup(struct nouveau_channel *chan,
 }
 
 static int
+nve0_bo_move_init(struct nouveau_channel *chan, u32 handle)
+{
+        int ret = RING_SPACE(chan, 2);
+        if (ret == 0) {
+                BEGIN_NVC0(chan, NvSubCopy, 0x0000, 1);
+                OUT_RING  (chan, handle);
+                FIRE_RING (chan);
+        }
+        return ret;
+}
+
+static int
 nve0_bo_move_copy(struct nouveau_channel *chan, struct ttm_buffer_object *bo,
                   struct ttm_mem_reg *old_mem, struct ttm_mem_reg *new_mem)
 {
@@ -676,20 +768,14 @@ nv84_bo_move_exec(struct nouveau_channel *chan, struct ttm_buffer_object *bo,
 static int
 nv50_bo_move_init(struct nouveau_channel *chan, u32 handle)
 {
-        int ret = nouveau_notifier_alloc(chan, NvNotify0, 32, 0xfe0, 0x1000,
-                                         &chan->m2mf_ntfy);
+        int ret = RING_SPACE(chan, 6);
         if (ret == 0) {
-                ret = RING_SPACE(chan, 6);
-                if (ret == 0) {
-                        BEGIN_NV04(chan, NvSubCopy, 0x0000, 1);
-                        OUT_RING  (chan, handle);
-                        BEGIN_NV04(chan, NvSubCopy, 0x0180, 3);
-                        OUT_RING  (chan, NvNotify0);
-                        OUT_RING  (chan, NvDmaFB);
-                        OUT_RING  (chan, NvDmaFB);
-                } else {
-                        nouveau_ramht_remove(chan, NvNotify0);
-                }
+                BEGIN_NV04(chan, NvSubCopy, 0x0000, 1);
+                OUT_RING  (chan, handle);
+                BEGIN_NV04(chan, NvSubCopy, 0x0180, 3);
+                OUT_RING  (chan, NvNotify0);
+                OUT_RING  (chan, NvDmaFB);
+                OUT_RING  (chan, NvDmaFB);
         }
 
         return ret;
@@ -788,16 +874,12 @@ nv50_bo_move_m2mf(struct nouveau_channel *chan, struct ttm_buffer_object *bo,
 static int
 nv04_bo_move_init(struct nouveau_channel *chan, u32 handle)
 {
-        int ret = nouveau_notifier_alloc(chan, NvNotify0, 32, 0xfe0, 0x1000,
-                                         &chan->m2mf_ntfy);
+        int ret = RING_SPACE(chan, 4);
         if (ret == 0) {
-                ret = RING_SPACE(chan, 4);
-                if (ret == 0) {
-                        BEGIN_NV04(chan, NvSubCopy, 0x0000, 1);
-                        OUT_RING  (chan, handle);
-                        BEGIN_NV04(chan, NvSubCopy, 0x0180, 1);
-                        OUT_RING  (chan, NvNotify0);
-                }
+                BEGIN_NV04(chan, NvSubCopy, 0x0000, 1);
+                OUT_RING  (chan, handle);
+                BEGIN_NV04(chan, NvSubCopy, 0x0180, 1);
+                OUT_RING  (chan, NvNotify0);
         }
 
         return ret;
@@ -808,8 +890,8 @@ nouveau_bo_mem_ctxdma(struct ttm_buffer_object *bo,
                       struct nouveau_channel *chan, struct ttm_mem_reg *mem)
 {
         if (mem->mem_type == TTM_PL_TT)
-                return chan->gart_handle;
-        return chan->vram_handle;
+                return NvDmaTT;
+        return NvDmaFB;
 }
 
 static int
@@ -865,8 +947,9 @@ nouveau_vma_getmap(struct nouveau_channel *chan, struct nouveau_bo *nvbo,
         struct nouveau_mem *node = mem->mm_node;
         int ret;
 
-        ret = nouveau_vm_get(chan->vm, mem->num_pages << PAGE_SHIFT,
-                             node->page_shift, NV_MEM_ACCESS_RO, vma);
+        ret = nouveau_vm_get(nv_client(chan->cli)->vm, mem->num_pages <<
+                             PAGE_SHIFT, node->page_shift,
+                             NV_MEM_ACCESS_RW, vma);
         if (ret)
                 return ret;
 
@@ -883,19 +966,19 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr,
                      bool no_wait_reserve, bool no_wait_gpu,
                      struct ttm_mem_reg *new_mem)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
-        struct nouveau_channel *chan = chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
+        struct nouveau_channel *chan = chan = drm->channel;
         struct nouveau_bo *nvbo = nouveau_bo(bo);
         struct ttm_mem_reg *old_mem = &bo->mem;
         int ret;
 
-        mutex_lock_nested(&chan->mutex, NOUVEAU_KCHANNEL_MUTEX);
+        mutex_lock(&chan->cli->mutex);
 
         /* create temporary vmas for the transfer and attach them to the
          * old nouveau_mem node, these will get cleaned up after ttm has
          * destroyed the ttm_mem_reg
          */
-        if (dev_priv->card_type >= NV_50) {
+        if (nv_device(drm->device)->card_type >= NV_50) {
                 struct nouveau_mem *node = old_mem->mm_node;
 
                 ret = nouveau_vma_getmap(chan, nvbo, old_mem, &node->vma[0]);
@@ -907,7 +990,7 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr,
                         goto out;
         }
 
-        ret = dev_priv->ttm.move(chan, bo, &bo->mem, new_mem);
+        ret = drm->ttm.move(chan, bo, &bo->mem, new_mem);
         if (ret == 0) {
                 ret = nouveau_bo_move_accel_cleanup(chan, nvbo, evict,
                                                     no_wait_reserve,
@@ -915,14 +998,13 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr,
         }
 
 out:
-        mutex_unlock(&chan->mutex);
+        mutex_unlock(&chan->cli->mutex);
         return ret;
 }
 
 void
-nouveau_bo_move_init(struct nouveau_channel *chan)
+nouveau_bo_move_init(struct nouveau_drm *drm)
 {
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
         static const struct {
                 const char *name;
                 int engine;
@@ -932,7 +1014,8 @@ nouveau_bo_move_init(struct nouveau_channel *chan)
                             struct ttm_mem_reg *, struct ttm_mem_reg *);
                 int (*init)(struct nouveau_channel *, u32 handle);
         } _methods[] = {
-                {  "COPY", 0, 0xa0b5, nve0_bo_move_copy, nvc0_bo_move_init },
+                {  "COPY", 0, 0xa0b5, nve0_bo_move_copy, nve0_bo_move_init },
+                {  "GRCE", 0, 0xa0b5, nve0_bo_move_copy, nvc0_bo_move_init },
                 { "COPY1", 5, 0x90b8, nvc0_bo_move_copy, nvc0_bo_move_init },
                 { "COPY0", 4, 0x90b5, nvc0_bo_move_copy, nvc0_bo_move_init },
                 {  "COPY", 0, 0x85b5, nva3_bo_move_copy, nv50_bo_move_init },
@@ -947,19 +1030,34 @@ nouveau_bo_move_init(struct nouveau_channel *chan)
         int ret;
 
         do {
+                struct nouveau_object *object;
+                struct nouveau_channel *chan;
                 u32 handle = (mthd->engine << 16) | mthd->oclass;
-                ret = nouveau_gpuobj_gr_new(chan, handle, mthd->oclass);
+
+                if (mthd->init == nve0_bo_move_init)
+                        chan = drm->cechan;
+                else
+                        chan = drm->channel;
+                if (chan == NULL)
+                        continue;
+
+                ret = nouveau_object_new(nv_object(drm), chan->handle, handle,
+                                         mthd->oclass, NULL, 0, &object);
                 if (ret == 0) {
                         ret = mthd->init(chan, handle);
-                        if (ret == 0) {
-                                dev_priv->ttm.move = mthd->exec;
-                                name = mthd->name;
-                                break;
+                        if (ret) {
+                                nouveau_object_del(nv_object(drm),
+                                                   chan->handle, handle);
+                                continue;
                         }
+
+                        drm->ttm.move = mthd->exec;
+                        name = mthd->name;
+                        break;
                 }
         } while ((++mthd)->exec);
 
-        NV_INFO(chan->dev, "MM: using %s for buffer copies\n", name);
+        NV_INFO(drm, "MM: using %s for buffer copies\n", name);
 }
 
 static int
@@ -1044,7 +1142,7 @@ nouveau_bo_move_ntfy(struct ttm_buffer_object *bo, struct ttm_mem_reg *new_mem)
                         nouveau_vm_map(vma, new_mem->mm_node);
                 } else
                 if (new_mem && new_mem->mem_type == TTM_PL_TT &&
-                    nvbo->page_shift == vma->vm->spg_shift) {
+                    nvbo->page_shift == vma->vm->vmm->spg_shift) {
                         if (((struct nouveau_mem *)new_mem->mm_node)->sg)
                                 nouveau_vm_map_sg_table(vma, 0, new_mem->
                                                   num_pages << PAGE_SHIFT,
@@ -1061,10 +1159,10 @@ nouveau_bo_move_ntfy(struct ttm_buffer_object *bo, struct ttm_mem_reg *new_mem)
 
 static int
 nouveau_bo_vm_bind(struct ttm_buffer_object *bo, struct ttm_mem_reg *new_mem,
-                   struct nouveau_tile_reg **new_tile)
+                   struct nouveau_drm_tile **new_tile)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
+        struct drm_device *dev = drm->dev;
         struct nouveau_bo *nvbo = nouveau_bo(bo);
         u64 offset = new_mem->start << PAGE_SHIFT;
 
@@ -1072,8 +1170,8 @@ nouveau_bo_vm_bind(struct ttm_buffer_object *bo, struct ttm_mem_reg *new_mem,
         if (new_mem->mem_type != TTM_PL_VRAM)
                 return 0;
 
-        if (dev_priv->card_type >= NV_10) {
-                *new_tile = nv10_mem_set_tiling(dev, offset, new_mem->size,
+        if (nv_device(drm->device)->card_type >= NV_10) {
+                *new_tile = nv10_bo_set_tiling(dev, offset, new_mem->size,
                                                 nvbo->tile_mode,
                                                 nvbo->tile_flags);
         }
@@ -1083,13 +1181,13 @@ nouveau_bo_vm_bind(struct ttm_buffer_object *bo, struct ttm_mem_reg *new_mem,
 
 static void
 nouveau_bo_vm_cleanup(struct ttm_buffer_object *bo,
-                      struct nouveau_tile_reg *new_tile,
-                      struct nouveau_tile_reg **old_tile)
+                      struct nouveau_drm_tile *new_tile,
+                      struct nouveau_drm_tile **old_tile)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
+        struct drm_device *dev = drm->dev;
 
-        nv10_mem_put_tile_region(dev, *old_tile, bo->sync_obj);
+        nv10_bo_put_tile_region(dev, *old_tile, bo->sync_obj);
         *old_tile = new_tile;
 }
 
@@ -1098,13 +1196,13 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr,
                 bool no_wait_reserve, bool no_wait_gpu,
                 struct ttm_mem_reg *new_mem)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
+        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
         struct nouveau_bo *nvbo = nouveau_bo(bo);
         struct ttm_mem_reg *old_mem = &bo->mem;
-        struct nouveau_tile_reg *new_tile = NULL;
+        struct nouveau_drm_tile *new_tile = NULL;
         int ret = 0;
 
-        if (dev_priv->card_type < NV_50) {
+        if (nv_device(drm->device)->card_type < NV_50) {
                 ret = nouveau_bo_vm_bind(bo, new_mem, &new_tile);
                 if (ret)
                         return ret;
@@ -1119,7 +1217,7 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr,
         }
 
         /* CPU copy if we have no accelerated method available */
-        if (!dev_priv->ttm.move) {
+        if (!drm->ttm.move) {
                 ret = ttm_bo_move_memcpy(bo, evict, no_wait_reserve, no_wait_gpu, new_mem);
                 goto out;
         }
@@ -1139,7 +1237,7 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr,
         ret = ttm_bo_move_memcpy(bo, evict, no_wait_reserve, no_wait_gpu, new_mem);
 
 out:
-        if (dev_priv->card_type < NV_50) {
+        if (nv_device(drm->device)->card_type < NV_50) {
                 if (ret)
                         nouveau_bo_vm_cleanup(bo, NULL, &new_tile);
                 else
@@ -1159,8 +1257,8 @@ static int
 nouveau_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
 {
         struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bdev);
+        struct drm_device *dev = drm->dev;
         int ret;
 
         mem->bus.addr = NULL;
@@ -1176,48 +1274,28 @@ nouveau_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
                 return 0;
         case TTM_PL_TT:
 #if __OS_HAS_AGP
-                if (dev_priv->gart_info.type == NOUVEAU_GART_AGP) {
+                if (drm->agp.stat == ENABLED) {
                         mem->bus.offset = mem->start << PAGE_SHIFT;
-                        mem->bus.base = dev_priv->gart_info.aper_base;
+                        mem->bus.base = drm->agp.base;
                         mem->bus.is_iomem = true;
                 }
 #endif
                 break;
         case TTM_PL_VRAM:
-        {
-                struct nouveau_mem *node = mem->mm_node;
-                u8 page_shift;
-
-                if (!dev_priv->bar1_vm) {
-                        mem->bus.offset = mem->start << PAGE_SHIFT;
-                        mem->bus.base = pci_resource_start(dev->pdev, 1);
-                        mem->bus.is_iomem = true;
-                        break;
-                }
-
-                if (dev_priv->card_type >= NV_C0)
-                        page_shift = node->page_shift;
-                else
-                        page_shift = 12;
+                mem->bus.offset = mem->start << PAGE_SHIFT;
+                mem->bus.base = pci_resource_start(dev->pdev, 1);
+                mem->bus.is_iomem = true;
+                if (nv_device(drm->device)->card_type >= NV_50) {
+                        struct nouveau_bar *bar = nouveau_bar(drm->device);
+                        struct nouveau_mem *node = mem->mm_node;
 
-                ret = nouveau_vm_get(dev_priv->bar1_vm, mem->bus.size,
-                                     page_shift, NV_MEM_ACCESS_RW,
-                                     &node->bar_vma);
-                if (ret)
-                        return ret;
+                        ret = bar->umap(bar, node, NV_MEM_ACCESS_RW,
+                                        &node->bar_vma);
+                        if (ret)
+                                return ret;
 
-                nouveau_vm_map(&node->bar_vma, node);
-                if (ret) {
-                        nouveau_vm_put(&node->bar_vma);
-                        return ret;
+                        mem->bus.offset = node->bar_vma.offset;
                 }
-
-                mem->bus.offset = node->bar_vma.offset;
-                if (dev_priv->card_type == NV_50) /*XXX*/
-                        mem->bus.offset -= 0x0020000000ULL;
-                mem->bus.base = pci_resource_start(dev->pdev, 1);
-                mem->bus.is_iomem = true;
-        }
                 break;
         default:
                 return -EINVAL;
@@ -1228,41 +1306,40 @@ nouveau_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
 static void
 nouveau_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bdev);
+        struct nouveau_drm *drm = nouveau_bdev(bdev);
+        struct nouveau_bar *bar = nouveau_bar(drm->device);
         struct nouveau_mem *node = mem->mm_node;
 
-        if (!dev_priv->bar1_vm || mem->mem_type != TTM_PL_VRAM)
-                return;
-
         if (!node->bar_vma.node)
                 return;
 
-        nouveau_vm_unmap(&node->bar_vma);
-        nouveau_vm_put(&node->bar_vma);
+        bar->unmap(bar, &node->bar_vma);
 }
 
 static int
 nouveau_ttm_fault_reserve_notify(struct ttm_buffer_object *bo)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
+        struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
         struct nouveau_bo *nvbo = nouveau_bo(bo);
+        struct nouveau_device *device = nv_device(drm->device);
+        u32 mappable = pci_resource_len(device->pdev, 1) >> PAGE_SHIFT;
 
         /* as long as the bo isn't in vram, and isn't tiled, we've got
          * nothing to do here.
          */
         if (bo->mem.mem_type != TTM_PL_VRAM) {
-                if (dev_priv->card_type < NV_50 ||
+                if (nv_device(drm->device)->card_type < NV_50 ||
                     !nouveau_bo_tile_layout(nvbo))
                         return 0;
         }
 
         /* make sure bo is in mappable vram */
-        if (bo->mem.start + bo->mem.num_pages < dev_priv->fb_mappable_pages)
+        if (bo->mem.start + bo->mem.num_pages < mappable)
                 return 0;
 
 
         nvbo->placement.fpfn = 0;
-        nvbo->placement.lpfn = dev_priv->fb_mappable_pages;
+        nvbo->placement.lpfn = mappable;
         nouveau_bo_placement_set(nvbo, TTM_PL_FLAG_VRAM, 0);
         return nouveau_bo_validate(nvbo, false, true, false);
 }
@@ -1271,7 +1348,7 @@ static int
 nouveau_ttm_tt_populate(struct ttm_tt *ttm)
 {
         struct ttm_dma_tt *ttm_dma = (void *)ttm;
-        struct drm_nouveau_private *dev_priv;
+        struct nouveau_drm *drm;
         struct drm_device *dev;
         unsigned i;
         int r;
@@ -1288,11 +1365,11 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm)
                 return 0;
         }
 
-        dev_priv = nouveau_bdev(ttm->bdev);
-        dev = dev_priv->dev;
+        drm = nouveau_bdev(ttm->bdev);
+        dev = drm->dev;
 
 #if __OS_HAS_AGP
-        if (dev_priv->gart_info.type == NOUVEAU_GART_AGP) {
+        if (drm->agp.stat == ENABLED) {
                 return ttm_agp_tt_populate(ttm);
         }
 #endif
@@ -1329,7 +1406,7 @@ static void
 nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
 {
         struct ttm_dma_tt *ttm_dma = (void *)ttm;
-        struct drm_nouveau_private *dev_priv;
+        struct nouveau_drm *drm;
         struct drm_device *dev;
         unsigned i;
         bool slave = !!(ttm->page_flags & TTM_PAGE_FLAG_SG);
@@ -1337,11 +1414,11 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
         if (slave)
                 return;
 
-        dev_priv = nouveau_bdev(ttm->bdev);
-        dev = dev_priv->dev;
+        drm = nouveau_bdev(ttm->bdev);
+        dev = drm->dev;
 
 #if __OS_HAS_AGP
-        if (dev_priv->gart_info.type == NOUVEAU_GART_AGP) {
+        if (drm->agp.stat == ENABLED) {
                 ttm_agp_tt_unpopulate(ttm);
                 return;
         }
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.h b/drivers/gpu/drm/nouveau/nouveau_bo.h
new file mode 100644
index 000000000000..dec51b1098fe
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_bo.h
@@ -0,0 +1,99 @@
+#ifndef __NOUVEAU_BO_H__
+#define __NOUVEAU_BO_H__
+
+struct nouveau_channel;
+struct nouveau_fence;
+struct nouveau_vma;
+
+struct nouveau_bo {
+        struct ttm_buffer_object bo;
+        struct ttm_placement placement;
+        u32 valid_domains;
+        u32 placements[3];
+        u32 busy_placements[3];
+        struct ttm_bo_kmap_obj kmap;
+        struct list_head head;
+
+        /* protected by ttm_bo_reserve() */
+        struct drm_file *reserved_by;
+        struct list_head entry;
+        int pbbo_index;
+        bool validate_mapped;
+
+        struct list_head vma_list;
+        unsigned page_shift;
+
+        u32 tile_mode;
+        u32 tile_flags;
+        struct nouveau_drm_tile *tile;
+
+        struct drm_gem_object *gem;
+        int pin_refcnt;
+
+        struct ttm_bo_kmap_obj dma_buf_vmap;
+        int vmapping_count;
+};
+
+static inline struct nouveau_bo *
+nouveau_bo(struct ttm_buffer_object *bo)
+{
+        return container_of(bo, struct nouveau_bo, bo);
+}
+
+static inline int
+nouveau_bo_ref(struct nouveau_bo *ref, struct nouveau_bo **pnvbo)
+{
+        struct nouveau_bo *prev;
+
+        if (!pnvbo)
+                return -EINVAL;
+        prev = *pnvbo;
+
+        *pnvbo = ref ? nouveau_bo(ttm_bo_reference(&ref->bo)) : NULL;
+        if (prev) {
+                struct ttm_buffer_object *bo = &prev->bo;
+
+                ttm_bo_unref(&bo);
+        }
+
+        return 0;
+}
+
+extern struct ttm_bo_driver nouveau_bo_driver;
+
+void nouveau_bo_move_init(struct nouveau_drm *);
+int  nouveau_bo_new(struct drm_device *, int size, int align, u32 flags,
+                    u32 tile_mode, u32 tile_flags, struct sg_table *sg,
+                    struct nouveau_bo **);
+int  nouveau_bo_pin(struct nouveau_bo *, u32 flags);
+int  nouveau_bo_unpin(struct nouveau_bo *);
+int  nouveau_bo_map(struct nouveau_bo *);
+void nouveau_bo_unmap(struct nouveau_bo *);
+void nouveau_bo_placement_set(struct nouveau_bo *, u32 type, u32 busy);
+u16  nouveau_bo_rd16(struct nouveau_bo *, unsigned index);
+void nouveau_bo_wr16(struct nouveau_bo *, unsigned index, u16 val);
+u32  nouveau_bo_rd32(struct nouveau_bo *, unsigned index);
+void nouveau_bo_wr32(struct nouveau_bo *, unsigned index, u32 val);
+void nouveau_bo_fence(struct nouveau_bo *, struct nouveau_fence *);
+int  nouveau_bo_validate(struct nouveau_bo *, bool interruptible,
+                         bool no_wait_reserve, bool no_wait_gpu);
+
+struct nouveau_vma *
+nouveau_bo_vma_find(struct nouveau_bo *, struct nouveau_vm *);
+
+int  nouveau_bo_vma_add(struct nouveau_bo *, struct nouveau_vm *,
+                        struct nouveau_vma *);
+void nouveau_bo_vma_del(struct nouveau_bo *, struct nouveau_vma *);
+
+/* TODO: submit equivalent to TTM generic API upstream? */
+static inline void __iomem *
+nvbo_kmap_obj_iovirtual(struct nouveau_bo *nvbo)
+{
+        bool is_iomem;
+        void __iomem *ioptr = (void __force __iomem *)ttm_kmap_obj_virtual(
+                                                &nvbo->kmap, &is_iomem);
+        WARN_ON_ONCE(ioptr && !is_iomem);
+        return ioptr;
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_calc.c b/drivers/gpu/drm/nouveau/nouveau_calc.c
index dad96cce5e39..77959526b5f3 100644
--- a/drivers/gpu/drm/nouveau/nouveau_calc.c
+++ b/drivers/gpu/drm/nouveau/nouveau_calc.c
@@ -22,7 +22,8 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_hw.h"
 
 /****************************************************************************\
@@ -195,12 +196,13 @@ static void
 nv04_update_arb(struct drm_device *dev, int VClk, int bpp,
                 int *burst, int *lwm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nv_fifo_info fifo_data;
         struct nv_sim_state sim_data;
         int MClk = nouveau_hw_get_clock(dev, PLL_MEMORY);
         int NVClk = nouveau_hw_get_clock(dev, PLL_CORE);
-        uint32_t cfg1 = nvReadFB(dev, NV04_PFB_CFG1);
+        uint32_t cfg1 = nv_rd32(device, NV04_PFB_CFG1);
 
         sim_data.pclk_khz = VClk;
         sim_data.mclk_khz = MClk;
@@ -218,13 +220,13 @@ nv04_update_arb(struct drm_device *dev, int VClk, int bpp,
                 sim_data.mem_latency = 3;
                 sim_data.mem_page_miss = 10;
         } else {
-                sim_data.memory_type = nvReadFB(dev, NV04_PFB_CFG0) & 0x1;
-                sim_data.memory_width = (nvReadEXTDEV(dev, NV_PEXTDEV_BOOT_0) & 0x10) ? 128 : 64;
+                sim_data.memory_type = nv_rd32(device, NV04_PFB_CFG0) & 0x1;
+                sim_data.memory_width = (nv_rd32(device, NV_PEXTDEV_BOOT_0) & 0x10) ? 128 : 64;
                 sim_data.mem_latency = cfg1 & 0xf;
                 sim_data.mem_page_miss = ((cfg1 >> 4) & 0xf) + ((cfg1 >> 31) & 0x1);
         }
 
-        if (dev_priv->card_type == NV_04)
+        if (nv_device(drm->device)->card_type == NV_04)
                 nv04_calc_arb(&fifo_data, &sim_data);
         else
                 nv10_calc_arb(&fifo_data, &sim_data);
@@ -249,9 +251,9 @@ nv20_update_arb(int *burst, int *lwm)
 void
 nouveau_calc_arb(struct drm_device *dev, int vclk, int bpp, int *burst, int *lwm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        if (dev_priv->card_type < NV_20)
+        if (nv_device(drm->device)->card_type < NV_20)
                 nv04_update_arb(dev, vclk, bpp, burst, lwm);
         else if ((dev->pci_device & 0xfff0) == 0x0240 /*CHIPSET_C51*/ ||
                  (dev->pci_device & 0xfff0) == 0x03d0 /*CHIPSET_C512*/) {
@@ -260,219 +262,3 @@ nouveau_calc_arb(struct drm_device *dev, int vclk, int bpp, int *burst, int *lwm
         } else
                 nv20_update_arb(burst, lwm);
 }
-
-static int
-getMNP_single(struct drm_device *dev, struct pll_lims *pll_lim, int clk,
-              struct nouveau_pll_vals *bestpv)
-{
-        /* Find M, N and P for a single stage PLL
-         *
-         * Note that some bioses (NV3x) have lookup tables of precomputed MNP
-         * values, but we're too lazy to use those atm
-         *
-         * "clk" parameter in kHz
-         * returns calculated clock
-         */
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int cv = dev_priv->vbios.chip_version;
-        int minvco = pll_lim->vco1.minfreq, maxvco = pll_lim->vco1.maxfreq;
-        int minM = pll_lim->vco1.min_m, maxM = pll_lim->vco1.max_m;
-        int minN = pll_lim->vco1.min_n, maxN = pll_lim->vco1.max_n;
-        int minU = pll_lim->vco1.min_inputfreq;
-        int maxU = pll_lim->vco1.max_inputfreq;
-        int minP = pll_lim->max_p ? pll_lim->min_p : 0;
-        int maxP = pll_lim->max_p ? pll_lim->max_p : pll_lim->max_usable_log2p;
-        int crystal = pll_lim->refclk;
-        int M, N, thisP, P;
-        int clkP, calcclk;
-        int delta, bestdelta = INT_MAX;
-        int bestclk = 0;
-
-        /* this division verified for nv20, nv18, nv28 (Haiku), and nv34 */
-        /* possibly correlated with introduction of 27MHz crystal */
-        if (dev_priv->card_type < NV_50) {
-                if (cv < 0x17 || cv == 0x1a || cv == 0x20) {
-                        if (clk > 250000)
-                                maxM = 6;
-                        if (clk > 340000)
-                                maxM = 2;
-                } else if (cv < 0x40) {
-                        if (clk > 150000)
-                                maxM = 6;
-                        if (clk > 200000)
-                                maxM = 4;
-                        if (clk > 340000)
-                                maxM = 2;
-                }
-        }
-
-        P = pll_lim->max_p ? maxP : (1 << maxP);
-        if ((clk * P) < minvco) {
-                minvco = clk * maxP;
-                maxvco = minvco * 2;
-        }
-
-        if (clk + clk/200 > maxvco)     /* +0.5% */
-                maxvco = clk + clk/200;
-
-        /* NV34 goes maxlog2P->0, NV20 goes 0->maxlog2P */
-        for (thisP = minP; thisP <= maxP; thisP++) {
-                P = pll_lim->max_p ? thisP : (1 << thisP);
-                clkP = clk * P;
-
-                if (clkP < minvco)
-                        continue;
-                if (clkP > maxvco)
-                        return bestclk;
-
-                for (M = minM; M <= maxM; M++) {
-                        if (crystal/M < minU)
-                                return bestclk;
-                        if (crystal/M > maxU)
-                                continue;
-
-                        /* add crystal/2 to round better */
-                        N = (clkP * M + crystal/2) / crystal;
-
-                        if (N < minN)
-                                continue;
-                        if (N > maxN)
-                                break;
-
-                        /* more rounding additions */
-                        calcclk = ((N * crystal + P/2) / P + M/2) / M;
-                        delta = abs(calcclk - clk);
-                        /* we do an exhaustive search rather than terminating
-                         * on an optimality condition...
-                         */
-                        if (delta < bestdelta) {
-                                bestdelta = delta;
-                                bestclk = calcclk;
-                                bestpv->N1 = N;
-                                bestpv->M1 = M;
-                                bestpv->log2P = thisP;
-                                if (delta == 0) /* except this one */
-                                        return bestclk;
-                        }
-                }
-        }
-
-        return bestclk;
-}
-
-static int
-getMNP_double(struct drm_device *dev, struct pll_lims *pll_lim, int clk,
-              struct nouveau_pll_vals *bestpv)
-{
-        /* Find M, N and P for a two stage PLL
-         *
-         * Note that some bioses (NV30+) have lookup tables of precomputed MNP
-         * values, but we're too lazy to use those atm
-         *
-         * "clk" parameter in kHz
-         * returns calculated clock
-         */
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chip_version = dev_priv->vbios.chip_version;
-        int minvco1 = pll_lim->vco1.minfreq, maxvco1 = pll_lim->vco1.maxfreq;
-        int minvco2 = pll_lim->vco2.minfreq, maxvco2 = pll_lim->vco2.maxfreq;
-        int minU1 = pll_lim->vco1.min_inputfreq, minU2 = pll_lim->vco2.min_inputfreq;
-        int maxU1 = pll_lim->vco1.max_inputfreq, maxU2 = pll_lim->vco2.max_inputfreq;
-        int minM1 = pll_lim->vco1.min_m, maxM1 = pll_lim->vco1.max_m;
-        int minN1 = pll_lim->vco1.min_n, maxN1 = pll_lim->vco1.max_n;
-        int minM2 = pll_lim->vco2.min_m, maxM2 = pll_lim->vco2.max_m;
-        int minN2 = pll_lim->vco2.min_n, maxN2 = pll_lim->vco2.max_n;
-        int maxlog2P = pll_lim->max_usable_log2p;
-        int crystal = pll_lim->refclk;
-        bool fixedgain2 = (minM2 == maxM2 && minN2 == maxN2);
-        int M1, N1, M2, N2, log2P;
-        int clkP, calcclk1, calcclk2, calcclkout;
-        int delta, bestdelta = INT_MAX;
-        int bestclk = 0;
-
-        int vco2 = (maxvco2 - maxvco2/200) / 2;
-        for (log2P = 0; clk && log2P < maxlog2P && clk <= (vco2 >> log2P); log2P++)
-                ;
-        clkP = clk << log2P;
-
-        if (maxvco2 < clk + clk/200)    /* +0.5% */
-                maxvco2 = clk + clk/200;
-
-        for (M1 = minM1; M1 <= maxM1; M1++) {
-                if (crystal/M1 < minU1)
-                        return bestclk;
-                if (crystal/M1 > maxU1)
-                        continue;
-
-                for (N1 = minN1; N1 <= maxN1; N1++) {
-                        calcclk1 = crystal * N1 / M1;
-                        if (calcclk1 < minvco1)
-                                continue;
-                        if (calcclk1 > maxvco1)
-                                break;
-
-                        for (M2 = minM2; M2 <= maxM2; M2++) {
-                                if (calcclk1/M2 < minU2)
-                                        break;
-                                if (calcclk1/M2 > maxU2)
-                                        continue;
-
-                                /* add calcclk1/2 to round better */
-                                N2 = (clkP * M2 + calcclk1/2) / calcclk1;
-                                if (N2 < minN2)
-                                        continue;
-                                if (N2 > maxN2)
-                                        break;
-
-                                if (!fixedgain2) {
-                                        if (chip_version < 0x60)
-                                                if (N2/M2 < 4 || N2/M2 > 10)
-                                                        continue;
-
-                                        calcclk2 = calcclk1 * N2 / M2;
-                                        if (calcclk2 < minvco2)
-                                                break;
-                                        if (calcclk2 > maxvco2)
-                                                continue;
-                                } else
-                                        calcclk2 = calcclk1;
-
-                                calcclkout = calcclk2 >> log2P;
-                                delta = abs(calcclkout - clk);
-                                /* we do an exhaustive search rather than terminating
-                                 * on an optimality condition...
-                                 */
-                                if (delta < bestdelta) {
-                                        bestdelta = delta;
-                                        bestclk = calcclkout;
-                                        bestpv->N1 = N1;
-                                        bestpv->M1 = M1;
-                                        bestpv->N2 = N2;
-                                        bestpv->M2 = M2;
-                                        bestpv->log2P = log2P;
-                                        if (delta == 0) /* except this one */
-                                                return bestclk;
-                                }
-                        }
-                }
-        }
-
-        return bestclk;
-}
-
-int
-nouveau_calc_pll_mnp(struct drm_device *dev, struct pll_lims *pll_lim, int clk,
-                     struct nouveau_pll_vals *pv)
-{
-        int outclk;
-
-        if (!pll_lim->vco2.maxfreq)
-                outclk = getMNP_single(dev, pll_lim, clk, pv);
-        else
-                outclk = getMNP_double(dev, pll_lim, clk, pv);
-
-        if (!outclk)
-                NV_ERROR(dev, "Could not find a compatible set of PLL values\n");
-
-        return outclk;
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_chan.c b/drivers/gpu/drm/nouveau/nouveau_chan.c
new file mode 100644
index 000000000000..c1d7301c0e9c
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_chan.c
@@ -0,0 +1,400 @@
+/*
+ * Copyright 2012 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 <core/object.h>
+#include <core/client.h>
+#include <core/device.h>
+#include <core/class.h>
+
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+#include <subdev/instmem.h>
+
+#include <engine/software.h>
+
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
+#include "nouveau_bo.h"
+#include "nouveau_chan.h"
+#include "nouveau_fence.h"
+#include "nouveau_abi16.h"
+
+MODULE_PARM_DESC(vram_pushbuf, "Create DMA push buffers in VRAM");
+static int nouveau_vram_pushbuf;
+module_param_named(vram_pushbuf, nouveau_vram_pushbuf, int, 0400);
+
+int
+nouveau_channel_idle(struct nouveau_channel *chan)
+{
+        struct nouveau_cli *cli = chan->cli;
+        struct nouveau_fence *fence = NULL;
+        int ret;
+
+        ret = nouveau_fence_new(chan, &fence);
+        if (!ret) {
+                ret = nouveau_fence_wait(fence, false, false);
+                nouveau_fence_unref(&fence);
+        }
+
+        if (ret)
+                NV_ERROR(cli, "failed to idle channel 0x%08x\n", chan->handle);
+        return ret;
+}
+
+void
+nouveau_channel_del(struct nouveau_channel **pchan)
+{
+        struct nouveau_channel *chan = *pchan;
+        if (chan) {
+                struct nouveau_object *client = nv_object(chan->cli);
+                if (chan->fence) {
+                        nouveau_channel_idle(chan);
+                        nouveau_fence(chan->drm)->context_del(chan);
+                }
+                nouveau_object_del(client, NVDRM_DEVICE, chan->handle);
+                nouveau_object_del(client, NVDRM_DEVICE, chan->push.handle);
+                nouveau_bo_vma_del(chan->push.buffer, &chan->push.vma);
+                nouveau_bo_unmap(chan->push.buffer);
+                nouveau_bo_ref(NULL, &chan->push.buffer);
+                kfree(chan);
+        }
+        *pchan = NULL;
+}
+
+static int
+nouveau_channel_prep(struct nouveau_drm *drm, struct nouveau_cli *cli,
+                     u32 parent, u32 handle, u32 size,
+                     struct nouveau_channel **pchan)
+{
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_instmem *imem = nouveau_instmem(device);
+        struct nouveau_vmmgr *vmm = nouveau_vmmgr(device);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        struct nouveau_client *client = &cli->base;
+        struct nv_dma_class args = {};
+        struct nouveau_channel *chan;
+        struct nouveau_object *push;
+        u32 target;
+        int ret;
+
+        chan = *pchan = kzalloc(sizeof(*chan), GFP_KERNEL);
+        if (!chan)
+                return -ENOMEM;
+
+        chan->cli = cli;
+        chan->drm = drm;
+        chan->handle = handle;
+
+        /* allocate memory for dma push buffer */
+        target = TTM_PL_FLAG_TT;
+        if (nouveau_vram_pushbuf)
+                target = TTM_PL_FLAG_VRAM;
+
+        ret = nouveau_bo_new(drm->dev, size, 0, target, 0, 0, NULL,
+                            &chan->push.buffer);
+        if (ret == 0) {
+                ret = nouveau_bo_pin(chan->push.buffer, target);
+                if (ret == 0)
+                        ret = nouveau_bo_map(chan->push.buffer);
+        }
+
+        if (ret) {
+                nouveau_channel_del(pchan);
+                return ret;
+        }
+
+        /* create dma object covering the *entire* memory space that the
+         * pushbuf lives in, this is because the GEM code requires that
+         * we be able to call out to other (indirect) push buffers
+         */
+        chan->push.vma.offset = chan->push.buffer->bo.offset;
+        chan->push.handle = NVDRM_PUSH | (handle & 0xffff);
+
+        if (device->card_type >= NV_50) {
+                ret = nouveau_bo_vma_add(chan->push.buffer, client->vm,
+                                        &chan->push.vma);
+                if (ret) {
+                        nouveau_channel_del(pchan);
+                        return ret;
+                }
+
+                args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
+                args.start = 0;
+                args.limit = client->vm->vmm->limit - 1;
+        } else
+        if (chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM) {
+                u64 limit = pfb->ram.size - imem->reserved - 1;
+                if (device->card_type == NV_04) {
+                        /* nv04 vram pushbuf hack, retarget to its location in
+                         * the framebuffer bar rather than direct vram access..
+                         * nfi why this exists, it came from the -nv ddx.
+                         */
+                        args.flags = NV_DMA_TARGET_PCI | NV_DMA_ACCESS_RDWR;
+                        args.start = pci_resource_start(device->pdev, 1);
+                        args.limit = args.start + limit;
+                } else {
+                        args.flags = NV_DMA_TARGET_VRAM | NV_DMA_ACCESS_RDWR;
+                        args.start = 0;
+                        args.limit = limit;
+                }
+        } else {
+                if (chan->drm->agp.stat == ENABLED) {
+                        args.flags = NV_DMA_TARGET_AGP | NV_DMA_ACCESS_RDWR;
+                        args.start = chan->drm->agp.base;
+                        args.limit = chan->drm->agp.base +
+                                     chan->drm->agp.size - 1;
+                } else {
+                        args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_RDWR;
+                        args.start = 0;
+                        args.limit = vmm->limit - 1;
+                }
+        }
+
+        ret = nouveau_object_new(nv_object(chan->cli), parent,
+                                 chan->push.handle, 0x0002,
+                                 &args, sizeof(args), &push);
+        if (ret) {
+                nouveau_channel_del(pchan);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int
+nouveau_channel_ind(struct nouveau_drm *drm, struct nouveau_cli *cli,
+                    u32 parent, u32 handle, u32 engine,
+                    struct nouveau_channel **pchan)
+{
+        static const u16 oclasses[] = { NVE0_CHANNEL_IND_CLASS,
+                                        NVC0_CHANNEL_IND_CLASS,
+                                        NV84_CHANNEL_IND_CLASS,
+                                        NV50_CHANNEL_IND_CLASS,
+                                        0 };
+        const u16 *oclass = oclasses;
+        struct nve0_channel_ind_class args;
+        struct nouveau_channel *chan;
+        int ret;
+
+        /* allocate dma push buffer */
+        ret = nouveau_channel_prep(drm, cli, parent, handle, 0x12000, &chan);
+        *pchan = chan;
+        if (ret)
+                return ret;
+
+        /* create channel object */
+        args.pushbuf = chan->push.handle;
+        args.ioffset = 0x10000 + chan->push.vma.offset;
+        args.ilength = 0x02000;
+        args.engine  = engine;
+
+        do {
+                ret = nouveau_object_new(nv_object(cli), parent, handle,
+                                         *oclass++, &args, sizeof(args),
+                                         &chan->object);
+                if (ret == 0)
+                        return ret;
+        } while (*oclass);
+
+        nouveau_channel_del(pchan);
+        return ret;
+}
+
+static int
+nouveau_channel_dma(struct nouveau_drm *drm, struct nouveau_cli *cli,
+                    u32 parent, u32 handle, struct nouveau_channel **pchan)
+{
+        static const u16 oclasses[] = { NV40_CHANNEL_DMA_CLASS,
+                                        NV17_CHANNEL_DMA_CLASS,
+                                        NV10_CHANNEL_DMA_CLASS,
+                                        NV03_CHANNEL_DMA_CLASS,
+                                        0 };
+        const u16 *oclass = oclasses;
+        struct nv03_channel_dma_class args;
+        struct nouveau_channel *chan;
+        int ret;
+
+        /* allocate dma push buffer */
+        ret = nouveau_channel_prep(drm, cli, parent, handle, 0x10000, &chan);
+        *pchan = chan;
+        if (ret)
+                return ret;
+
+        /* create channel object */
+        args.pushbuf = chan->push.handle;
+        args.offset = chan->push.vma.offset;
+
+        do {
+                ret = nouveau_object_new(nv_object(cli), parent, handle,
+                                         *oclass++, &args, sizeof(args),
+                                         &chan->object);
+                if (ret == 0)
+                        return ret;
+        } while (ret && *oclass);
+
+        nouveau_channel_del(pchan);
+        return ret;
+}
+
+static int
+nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
+{
+        struct nouveau_client *client = nv_client(chan->cli);
+        struct nouveau_device *device = nv_device(chan->drm->device);
+        struct nouveau_instmem *imem = nouveau_instmem(device);
+        struct nouveau_vmmgr *vmm = nouveau_vmmgr(device);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        struct nouveau_software_chan *swch;
+        struct nouveau_object *object;
+        struct nv_dma_class args;
+        int ret, i;
+
+        /* allocate dma objects to cover all allowed vram, and gart */
+        if (device->card_type < NV_C0) {
+                if (device->card_type >= NV_50) {
+                        args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
+                        args.start = 0;
+                        args.limit = client->vm->vmm->limit - 1;
+                } else {
+                        args.flags = NV_DMA_TARGET_VRAM | NV_DMA_ACCESS_RDWR;
+                        args.start = 0;
+                        args.limit = pfb->ram.size - imem->reserved - 1;
+                }
+
+                ret = nouveau_object_new(nv_object(client), chan->handle, vram,
+                                         0x003d, &args, sizeof(args), &object);
+                if (ret)
+                        return ret;
+
+                if (device->card_type >= NV_50) {
+                        args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
+                        args.start = 0;
+                        args.limit = client->vm->vmm->limit - 1;
+                } else
+                if (chan->drm->agp.stat == ENABLED) {
+                        args.flags = NV_DMA_TARGET_AGP | NV_DMA_ACCESS_RDWR;
+                        args.start = chan->drm->agp.base;
+                        args.limit = chan->drm->agp.base +
+                                     chan->drm->agp.size - 1;
+                } else {
+                        args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_RDWR;
+                        args.start = 0;
+                        args.limit = vmm->limit - 1;
+                }
+
+                ret = nouveau_object_new(nv_object(client), chan->handle, gart,
+                                         0x003d, &args, sizeof(args), &object);
+                if (ret)
+                        return ret;
+
+                chan->vram = vram;
+                chan->gart = gart;
+        }
+
+        /* initialise dma tracking parameters */
+        switch (nv_hclass(chan->object) & 0x00ff) {
+        case 0x006b:
+        case 0x006e:
+                chan->user_put = 0x40;
+                chan->user_get = 0x44;
+                chan->dma.max = (0x10000 / 4) - 2;
+                break;
+        default:
+                chan->user_put = 0x40;
+                chan->user_get = 0x44;
+                chan->user_get_hi = 0x60;
+                chan->dma.ib_base =  0x10000 / 4;
+                chan->dma.ib_max  = (0x02000 / 8) - 1;
+                chan->dma.ib_put  = 0;
+                chan->dma.ib_free = chan->dma.ib_max - chan->dma.ib_put;
+                chan->dma.max = chan->dma.ib_base;
+                break;
+        }
+
+        chan->dma.put = 0;
+        chan->dma.cur = chan->dma.put;
+        chan->dma.free = chan->dma.max - chan->dma.cur;
+
+        ret = RING_SPACE(chan, NOUVEAU_DMA_SKIPS);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < NOUVEAU_DMA_SKIPS; i++)
+                OUT_RING(chan, 0x00000000);
+
+        /* allocate software object class (used for fences on <= nv05, and
+         * to signal flip completion), bind it to a subchannel.
+         */
+        if (chan != chan->drm->cechan) {
+                ret = nouveau_object_new(nv_object(client), chan->handle,
+                                         NvSw, nouveau_abi16_swclass(chan->drm),
+                                         NULL, 0, &object);
+                if (ret)
+                        return ret;
+
+                swch = (void *)object->parent;
+                swch->flip = nouveau_flip_complete;
+                swch->flip_data = chan;
+        }
+
+        if (device->card_type < NV_C0) {
+                ret = RING_SPACE(chan, 2);
+                if (ret)
+                        return ret;
+
+                BEGIN_NV04(chan, NvSubSw, 0x0000, 1);
+                OUT_RING  (chan, NvSw);
+                FIRE_RING (chan);
+        }
+
+        /* initialise synchronisation */
+        return nouveau_fence(chan->drm)->context_new(chan);
+}
+
+int
+nouveau_channel_new(struct nouveau_drm *drm, struct nouveau_cli *cli,
+                    u32 parent, u32 handle, u32 arg0, u32 arg1,
+                    struct nouveau_channel **pchan)
+{
+        int ret;
+
+        ret = nouveau_channel_ind(drm, cli, parent, handle, arg0, pchan);
+        if (ret) {
+                NV_DEBUG(cli, "ib channel create, %d\n", ret);
+                ret = nouveau_channel_dma(drm, cli, parent, handle, pchan);
+                if (ret) {
+                        NV_DEBUG(cli, "dma channel create, %d\n", ret);
+                        return ret;
+                }
+        }
+
+        ret = nouveau_channel_init(*pchan, arg0, arg1);
+        if (ret) {
+                NV_ERROR(cli, "channel failed to initialise, %d\n", ret);
+                nouveau_channel_del(pchan);
+                return ret;
+        }
+
+        return 0;
+}
diff --git a/drivers/gpu/drm/nouveau/nouveau_chan.h b/drivers/gpu/drm/nouveau/nouveau_chan.h
new file mode 100644
index 000000000000..40f97e2c47b6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_chan.h
@@ -0,0 +1,47 @@
+#ifndef __NOUVEAU_CHAN_H__
+#define __NOUVEAU_CHAN_H__
+
+struct nouveau_cli;
+
+struct nouveau_channel {
+        struct nouveau_cli *cli;
+        struct nouveau_drm *drm;
+
+        u32 handle;
+        u32 vram;
+        u32 gart;
+
+        struct {
+                struct nouveau_bo *buffer;
+                struct nouveau_vma vma;
+                u32 handle;
+        } push;
+
+        /* TODO: this will be reworked in the near future */
+        bool accel_done;
+        void *fence;
+        struct {
+                int max;
+                int free;
+                int cur;
+                int put;
+                int ib_base;
+                int ib_max;
+                int ib_free;
+                int ib_put;
+        } dma;
+        u32 user_get_hi;
+        u32 user_get;
+        u32 user_put;
+
+        struct nouveau_object *object;
+};
+
+
+int  nouveau_channel_new(struct nouveau_drm *, struct nouveau_cli *,
+                         u32 parent, u32 handle, u32 arg0, u32 arg1,
+                         struct nouveau_channel **);
+void nouveau_channel_del(struct nouveau_channel **);
+int  nouveau_channel_idle(struct nouveau_channel *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_channel.c b/drivers/gpu/drm/nouveau/nouveau_channel.c
deleted file mode 100644
index debd90225a88..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_channel.c
+++ /dev/null
@@ -1,397 +0,0 @@
-/*
- * Copyright 2005-2006 Stephane Marchesin
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-#include "nouveau_dma.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-#include "nouveau_fence.h"
-#include "nouveau_software.h"
-
-static int
-nouveau_channel_pushbuf_init(struct nouveau_channel *chan)
-{
-        u32 mem = nouveau_vram_pushbuf ? TTM_PL_FLAG_VRAM : TTM_PL_FLAG_TT;
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int ret;
-
-        /* allocate buffer object */
-        ret = nouveau_bo_new(dev, 65536, 0, mem, 0, 0, NULL, &chan->pushbuf_bo);
-        if (ret)
-                goto out;
-
-        ret = nouveau_bo_pin(chan->pushbuf_bo, mem);
-        if (ret)
-                goto out;
-
-        ret = nouveau_bo_map(chan->pushbuf_bo);
-        if (ret)
-                goto out;
-
-        /* create DMA object covering the entire memtype where the push
-         * buffer resides, userspace can submit its own push buffers from
-         * anywhere within the same memtype.
-         */
-        chan->pushbuf_base = chan->pushbuf_bo->bo.offset;
-        if (dev_priv->card_type >= NV_50) {
-                ret = nouveau_bo_vma_add(chan->pushbuf_bo, chan->vm,
-                                         &chan->pushbuf_vma);
-                if (ret)
-                        goto out;
-
-                if (dev_priv->card_type < NV_C0) {
-                        ret = nouveau_gpuobj_dma_new(chan,
-                                                     NV_CLASS_DMA_IN_MEMORY, 0,
-                                                     (1ULL << 40),
-                                                     NV_MEM_ACCESS_RO,
-                                                     NV_MEM_TARGET_VM,
-                                                     &chan->pushbuf);
-                }
-                chan->pushbuf_base = chan->pushbuf_vma.offset;
-        } else
-        if (chan->pushbuf_bo->bo.mem.mem_type == TTM_PL_TT) {
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, 0,
-                                             dev_priv->gart_info.aper_size,
-                                             NV_MEM_ACCESS_RO,
-                                             NV_MEM_TARGET_GART,
-                                             &chan->pushbuf);
-        } else
-        if (dev_priv->card_type != NV_04) {
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, 0,
-                                             dev_priv->fb_available_size,
-                                             NV_MEM_ACCESS_RO,
-                                             NV_MEM_TARGET_VRAM,
-                                             &chan->pushbuf);
-        } else {
-                /* NV04 cmdbuf hack, from original ddx.. not sure of it's
-                 * exact reason for existing :)  PCI access to cmdbuf in
-                 * VRAM.
-                 */
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
-                                             pci_resource_start(dev->pdev, 1),
-                                             dev_priv->fb_available_size,
-                                             NV_MEM_ACCESS_RO,
-                                             NV_MEM_TARGET_PCI,
-                                             &chan->pushbuf);
-        }
-
-out:
-        if (ret) {
-                NV_ERROR(dev, "error initialising pushbuf: %d\n", ret);
-                nouveau_bo_vma_del(chan->pushbuf_bo, &chan->pushbuf_vma);
-                nouveau_gpuobj_ref(NULL, &chan->pushbuf);
-                if (chan->pushbuf_bo) {
-                        nouveau_bo_unmap(chan->pushbuf_bo);
-                        nouveau_bo_ref(NULL, &chan->pushbuf_bo);
-                }
-        }
-
-        return 0;
-}
-
-/* allocates and initializes a fifo for user space consumption */
-int
-nouveau_channel_alloc(struct drm_device *dev, struct nouveau_channel **chan_ret,
-                      struct drm_file *file_priv,
-                      uint32_t vram_handle, uint32_t gart_handle)
-{
-        struct nouveau_exec_engine *fence = nv_engine(dev, NVOBJ_ENGINE_FENCE);
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
-        struct nouveau_channel *chan;
-        unsigned long flags;
-        int ret, i;
-
-        /* allocate and lock channel structure */
-        chan = kzalloc(sizeof(*chan), GFP_KERNEL);
-        if (!chan)
-                return -ENOMEM;
-        chan->dev = dev;
-        chan->file_priv = file_priv;
-        chan->vram_handle = vram_handle;
-        chan->gart_handle = gart_handle;
-
-        kref_init(&chan->ref);
-        atomic_set(&chan->users, 1);
-        mutex_init(&chan->mutex);
-        mutex_lock(&chan->mutex);
-
-        /* allocate hw channel id */
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (chan->id = 0; chan->id < pfifo->channels; chan->id++) {
-                if (!dev_priv->channels.ptr[chan->id]) {
-                        nouveau_channel_ref(chan, &dev_priv->channels.ptr[chan->id]);
-                        break;
-                }
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-
-        if (chan->id == pfifo->channels) {
-                mutex_unlock(&chan->mutex);
-                kfree(chan);
-                return -ENODEV;
-        }
-
-        NV_DEBUG(dev, "initialising channel %d\n", chan->id);
-
-        /* setup channel's memory and vm */
-        ret = nouveau_gpuobj_channel_init(chan, vram_handle, gart_handle);
-        if (ret) {
-                NV_ERROR(dev, "gpuobj %d\n", ret);
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        /* Allocate space for per-channel fixed notifier memory */
-        ret = nouveau_notifier_init_channel(chan);
-        if (ret) {
-                NV_ERROR(dev, "ntfy %d\n", ret);
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        /* Allocate DMA push buffer */
-        ret = nouveau_channel_pushbuf_init(chan);
-        if (ret) {
-                NV_ERROR(dev, "pushbuf %d\n", ret);
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        nouveau_dma_init(chan);
-        chan->user_put = 0x40;
-        chan->user_get = 0x44;
-        if (dev_priv->card_type >= NV_50)
-                chan->user_get_hi = 0x60;
-
-        /* create fifo context */
-        ret = pfifo->base.context_new(chan, NVOBJ_ENGINE_FIFO);
-        if (ret) {
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        /* Insert NOPs for NOUVEAU_DMA_SKIPS */
-        ret = RING_SPACE(chan, NOUVEAU_DMA_SKIPS);
-        if (ret) {
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        for (i = 0; i < NOUVEAU_DMA_SKIPS; i++)
-                OUT_RING  (chan, 0x00000000);
-
-        ret = nouveau_gpuobj_gr_new(chan, NvSw, nouveau_software_class(dev));
-        if (ret) {
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        if (dev_priv->card_type < NV_C0) {
-                ret = RING_SPACE(chan, 2);
-                if (ret) {
-                        nouveau_channel_put(&chan);
-                        return ret;
-                }
-
-                BEGIN_NV04(chan, NvSubSw, NV01_SUBCHAN_OBJECT, 1);
-                OUT_RING  (chan, NvSw);
-                FIRE_RING (chan);
-        }
-
-        FIRE_RING(chan);
-
-        ret = fence->context_new(chan, NVOBJ_ENGINE_FENCE);
-        if (ret) {
-                nouveau_channel_put(&chan);
-                return ret;
-        }
-
-        nouveau_debugfs_channel_init(chan);
-
-        NV_DEBUG(dev, "channel %d initialised\n", chan->id);
-        if (fpriv) {
-                spin_lock(&fpriv->lock);
-                list_add(&chan->list, &fpriv->channels);
-                spin_unlock(&fpriv->lock);
-        }
-        *chan_ret = chan;
-        return 0;
-}
-
-struct nouveau_channel *
-nouveau_channel_get_unlocked(struct nouveau_channel *ref)
-{
-        struct nouveau_channel *chan = NULL;
-
-        if (likely(ref && atomic_inc_not_zero(&ref->users)))
-                nouveau_channel_ref(ref, &chan);
-
-        return chan;
-}
-
-struct nouveau_channel *
-nouveau_channel_get(struct drm_file *file_priv, int id)
-{
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
-        struct nouveau_channel *chan;
-
-        spin_lock(&fpriv->lock);
-        list_for_each_entry(chan, &fpriv->channels, list) {
-                if (chan->id == id) {
-                        chan = nouveau_channel_get_unlocked(chan);
-                        spin_unlock(&fpriv->lock);
-                        mutex_lock(&chan->mutex);
-                        return chan;
-                }
-        }
-        spin_unlock(&fpriv->lock);
-
-        return ERR_PTR(-EINVAL);
-}
-
-void
-nouveau_channel_put_unlocked(struct nouveau_channel **pchan)
-{
-        struct nouveau_channel *chan = *pchan;
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-        int i;
-
-        /* decrement the refcount, and we're done if there's still refs */
-        if (likely(!atomic_dec_and_test(&chan->users))) {
-                nouveau_channel_ref(NULL, pchan);
-                return;
-        }
-
-        /* no one wants the channel anymore */
-        NV_DEBUG(dev, "freeing channel %d\n", chan->id);
-        nouveau_debugfs_channel_fini(chan);
-
-        /* give it chance to idle */
-        nouveau_channel_idle(chan);
-
-        /* destroy the engine specific contexts */
-        for (i = NVOBJ_ENGINE_NR - 1; i >= 0; i--) {
-                if (chan->engctx[i])
-                        dev_priv->eng[i]->context_del(chan, i);
-        }
-
-        /* aside from its resources, the channel should now be dead,
-         * remove it from the channel list
-         */
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        nouveau_channel_ref(NULL, &dev_priv->channels.ptr[chan->id]);
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-
-        /* destroy any resources the channel owned */
-        nouveau_gpuobj_ref(NULL, &chan->pushbuf);
-        if (chan->pushbuf_bo) {
-                nouveau_bo_vma_del(chan->pushbuf_bo, &chan->pushbuf_vma);
-                nouveau_bo_unmap(chan->pushbuf_bo);
-                nouveau_bo_unpin(chan->pushbuf_bo);
-                nouveau_bo_ref(NULL, &chan->pushbuf_bo);
-        }
-        nouveau_ramht_ref(NULL, &chan->ramht, chan);
-        nouveau_notifier_takedown_channel(chan);
-        nouveau_gpuobj_channel_takedown(chan);
-
-        nouveau_channel_ref(NULL, pchan);
-}
-
-void
-nouveau_channel_put(struct nouveau_channel **pchan)
-{
-        mutex_unlock(&(*pchan)->mutex);
-        nouveau_channel_put_unlocked(pchan);
-}
-
-static void
-nouveau_channel_del(struct kref *ref)
-{
-        struct nouveau_channel *chan =
-                container_of(ref, struct nouveau_channel, ref);
-
-        kfree(chan);
-}
-
-void
-nouveau_channel_ref(struct nouveau_channel *chan,
-                    struct nouveau_channel **pchan)
-{
-        if (chan)
-                kref_get(&chan->ref);
-
-        if (*pchan)
-                kref_put(&(*pchan)->ref, nouveau_channel_del);
-
-        *pchan = chan;
-}
-
-int
-nouveau_channel_idle(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_fence *fence = NULL;
-        int ret;
-
-        ret = nouveau_fence_new(chan, &fence);
-        if (!ret) {
-                ret = nouveau_fence_wait(fence, false, false);
-                nouveau_fence_unref(&fence);
-        }
-
-        if (ret)
-                NV_ERROR(dev, "Failed to idle channel %d.\n", chan->id);
-        return ret;
-}
-
-/* cleans up all the fifos from file_priv */
-void
-nouveau_channel_cleanup(struct drm_device *dev, struct drm_file *file_priv)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct nouveau_channel *chan;
-        int i;
-
-        if (!pfifo)
-                return;
-
-        NV_DEBUG(dev, "clearing FIFO enables from file_priv\n");
-        for (i = 0; i < pfifo->channels; i++) {
-                chan = nouveau_channel_get(file_priv, i);
-                if (IS_ERR(chan))
-                        continue;
-
-                list_del(&chan->list);
-                atomic_dec(&chan->users);
-                nouveau_channel_put(&chan);
-        }
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index 7b11edb077d0..702e2a74d2d1 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
@@ -31,12 +31,29 @@
 #include "drm_crtc_helper.h"
 
 #include "nouveau_reg.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_hw.h"
+#include "nouveau_acpi.h"
+
+#include "nouveau_display.h"
+#include "nouveau_connector.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
-#include "nouveau_connector.h"
-#include "nouveau_gpio.h"
-#include "nouveau_hw.h"
+
+#include <subdev/i2c.h>
+#include <subdev/gpio.h>
+
+MODULE_PARM_DESC(tv_disable, "Disable TV-out detection");
+static int nouveau_tv_disable = 0;
+module_param_named(tv_disable, nouveau_tv_disable, int, 0400);
+
+MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
+static int nouveau_ignorelid = 0;
+module_param_named(ignorelid, nouveau_ignorelid, int, 0400);
+
+MODULE_PARM_DESC(duallink, "Allow dual-link TMDS (default: enabled)");
+static int nouveau_duallink = 1;
+module_param_named(duallink, nouveau_duallink, int, 0400);
 
 static void nouveau_connector_hotplug(void *, int);
 
@@ -58,7 +75,7 @@ find_encoder(struct drm_connector *connector, int type)
                         continue;
                 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
 
-                if (type == OUTPUT_ANY || nv_encoder->dcb->type == type)
+                if (type == DCB_OUTPUT_ANY || nv_encoder->dcb->type == type)
                         return nv_encoder;
         }
 
@@ -83,19 +100,21 @@ static void
 nouveau_connector_destroy(struct drm_connector *connector)
 {
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
-        struct drm_nouveau_private *dev_priv;
+        struct nouveau_gpio *gpio;
+        struct nouveau_drm *drm;
         struct drm_device *dev;
 
         if (!nv_connector)
                 return;
 
-        dev = nv_connector->base.dev;
-        dev_priv = dev->dev_private;
-        NV_DEBUG_KMS(dev, "\n");
+        dev  = nv_connector->base.dev;
+        drm  = nouveau_drm(dev);
+        gpio = nouveau_gpio(drm->device);
+        NV_DEBUG(drm, "\n");
 
-        if (nv_connector->hpd != DCB_GPIO_UNUSED) {
-                nouveau_gpio_isr_del(dev, 0, nv_connector->hpd, 0xff,
-                                     nouveau_connector_hotplug, connector);
+        if (gpio && nv_connector->hpd != DCB_GPIO_UNUSED) {
+                gpio->isr_del(gpio, 0, nv_connector->hpd, 0xff,
+                              nouveau_connector_hotplug, connector);
         }
 
         kfree(nv_connector->edid);
@@ -104,15 +123,17 @@ nouveau_connector_destroy(struct drm_connector *connector)
         kfree(connector);
 }
 
-static struct nouveau_i2c_chan *
+static struct nouveau_i2c_port *
 nouveau_connector_ddc_detect(struct drm_connector *connector,
                              struct nouveau_encoder **pnv_encoder)
 {
         struct drm_device *dev = connector->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
         int i;
 
         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
-                struct nouveau_i2c_chan *i2c = NULL;
+                struct nouveau_i2c_port *port = NULL;
                 struct nouveau_encoder *nv_encoder;
                 struct drm_mode_object *obj;
                 int id;
@@ -127,11 +148,10 @@ nouveau_connector_ddc_detect(struct drm_connector *connector,
                 nv_encoder = nouveau_encoder(obj_to_encoder(obj));
 
                 if (nv_encoder->dcb->i2c_index < 0xf)
-                        i2c = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
-
-                if (i2c && nouveau_probe_i2c_addr(i2c, 0x50)) {
+                        port = i2c->find(i2c, nv_encoder->dcb->i2c_index);
+                if (port && nv_probe_i2c(port, 0x50)) {
                         *pnv_encoder = nv_encoder;
-                        return i2c;
+                        return port;
                 }
         }
 
@@ -148,8 +168,8 @@ nouveau_connector_of_detect(struct drm_connector *connector)
         struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev);
 
         if (!dn ||
-            !((nv_encoder = find_encoder(connector, OUTPUT_TMDS)) ||
-              (nv_encoder = find_encoder(connector, OUTPUT_ANALOG))))
+            !((nv_encoder = find_encoder(connector, DCB_OUTPUT_TMDS)) ||
+              (nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG))))
                 return NULL;
 
         for_each_child_of_node(dn, cn) {
@@ -173,25 +193,25 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
                               struct nouveau_encoder *nv_encoder)
 {
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
-        struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
         struct drm_device *dev = connector->dev;
 
         if (nv_connector->detected_encoder == nv_encoder)
                 return;
         nv_connector->detected_encoder = nv_encoder;
 
-        if (dev_priv->card_type >= NV_50) {
+        if (nv_device(drm->device)->card_type >= NV_50) {
                 connector->interlace_allowed = true;
                 connector->doublescan_allowed = true;
         } else
-        if (nv_encoder->dcb->type == OUTPUT_LVDS ||
-            nv_encoder->dcb->type == OUTPUT_TMDS) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
+            nv_encoder->dcb->type == DCB_OUTPUT_TMDS) {
                 connector->doublescan_allowed = false;
                 connector->interlace_allowed = false;
         } else {
                 connector->doublescan_allowed = true;
-                if (dev_priv->card_type == NV_20 ||
-                   (dev_priv->card_type == NV_10 &&
+                if (nv_device(drm->device)->card_type == NV_20 ||
+                   (nv_device(drm->device)->card_type == NV_10 &&
                     (dev->pci_device & 0x0ff0) != 0x0100 &&
                     (dev->pci_device & 0x0ff0) != 0x0150))
                         /* HW is broken */
@@ -203,7 +223,7 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
         if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
                 drm_connector_property_set_value(connector,
                         dev->mode_config.dvi_i_subconnector_property,
-                        nv_encoder->dcb->type == OUTPUT_TMDS ?
+                        nv_encoder->dcb->type == DCB_OUTPUT_TMDS ?
                         DRM_MODE_SUBCONNECTOR_DVID :
                         DRM_MODE_SUBCONNECTOR_DVIA);
         }
@@ -213,10 +233,11 @@ static enum drm_connector_status
 nouveau_connector_detect(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder = NULL;
         struct nouveau_encoder *nv_partner;
-        struct nouveau_i2c_chan *i2c;
+        struct nouveau_i2c_port *i2c;
         int type;
 
         /* Cleanup the previous EDID block. */
@@ -232,14 +253,14 @@ nouveau_connector_detect(struct drm_connector *connector, bool force)
                 drm_mode_connector_update_edid_property(connector,
                                                         nv_connector->edid);
                 if (!nv_connector->edid) {
-                        NV_ERROR(dev, "DDC responded, but no EDID for %s\n",
+                        NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
                                  drm_get_connector_name(connector));
                         goto detect_analog;
                 }
 
-                if (nv_encoder->dcb->type == OUTPUT_DP &&
+                if (nv_encoder->dcb->type == DCB_OUTPUT_DP &&
                     !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
-                        NV_ERROR(dev, "Detected %s, but failed init\n",
+                        NV_ERROR(drm, "Detected %s, but failed init\n",
                                  drm_get_connector_name(connector));
                         return connector_status_disconnected;
                 }
@@ -250,19 +271,19 @@ nouveau_connector_detect(struct drm_connector *connector, bool force)
                  * isn't necessarily correct.
                  */
                 nv_partner = NULL;
-                if (nv_encoder->dcb->type == OUTPUT_TMDS)
-                        nv_partner = find_encoder(connector, OUTPUT_ANALOG);
-                if (nv_encoder->dcb->type == OUTPUT_ANALOG)
-                        nv_partner = find_encoder(connector, OUTPUT_TMDS);
-
-                if (nv_partner && ((nv_encoder->dcb->type == OUTPUT_ANALOG &&
-                                    nv_partner->dcb->type == OUTPUT_TMDS) ||
-                                   (nv_encoder->dcb->type == OUTPUT_TMDS &&
-                                    nv_partner->dcb->type == OUTPUT_ANALOG))) {
+                if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS)
+                        nv_partner = find_encoder(connector, DCB_OUTPUT_ANALOG);
+                if (nv_encoder->dcb->type == DCB_OUTPUT_ANALOG)
+                        nv_partner = find_encoder(connector, DCB_OUTPUT_TMDS);
+
+                if (nv_partner && ((nv_encoder->dcb->type == DCB_OUTPUT_ANALOG &&
+                                    nv_partner->dcb->type == DCB_OUTPUT_TMDS) ||
+                                   (nv_encoder->dcb->type == DCB_OUTPUT_TMDS &&
+                                    nv_partner->dcb->type == DCB_OUTPUT_ANALOG))) {
                         if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
-                                type = OUTPUT_TMDS;
+                                type = DCB_OUTPUT_TMDS;
                         else
-                                type = OUTPUT_ANALOG;
+                                type = DCB_OUTPUT_ANALOG;
 
                         nv_encoder = find_encoder(connector, type);
                 }
@@ -278,9 +299,9 @@ nouveau_connector_detect(struct drm_connector *connector, bool force)
         }
 
 detect_analog:
-        nv_encoder = find_encoder(connector, OUTPUT_ANALOG);
+        nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG);
         if (!nv_encoder && !nouveau_tv_disable)
-                nv_encoder = find_encoder(connector, OUTPUT_TV);
+                nv_encoder = find_encoder(connector, DCB_OUTPUT_TV);
         if (nv_encoder && force) {
                 struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
                 struct drm_encoder_helper_funcs *helper =
@@ -301,7 +322,7 @@ static enum drm_connector_status
 nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
 {
         struct drm_device *dev = connector->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder = NULL;
         enum drm_connector_status status = connector_status_disconnected;
@@ -313,12 +334,12 @@ nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
                 nv_connector->edid = NULL;
         }
 
-        nv_encoder = find_encoder(connector, OUTPUT_LVDS);
+        nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
         if (!nv_encoder)
                 return connector_status_disconnected;
 
         /* Try retrieving EDID via DDC */
-        if (!dev_priv->vbios.fp_no_ddc) {
+        if (!drm->vbios.fp_no_ddc) {
                 status = nouveau_connector_detect(connector, force);
                 if (status == connector_status_connected)
                         goto out;
@@ -334,7 +355,7 @@ nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
          * valid - it's not (rh#613284)
          */
         if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) {
-                if (!nouveau_acpi_edid(dev, connector)) {
+                if (!(nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
                         status = connector_status_connected;
                         goto out;
                 }
@@ -344,7 +365,7 @@ nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
          * modeline is avalilable for the panel, set it as the panel's
          * native mode and exit.
          */
-        if (nouveau_bios_fp_mode(dev, NULL) && (dev_priv->vbios.fp_no_ddc ||
+        if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc ||
             nv_encoder->dcb->lvdsconf.use_straps_for_mode)) {
                 status = connector_status_connected;
                 goto out;
@@ -353,7 +374,7 @@ nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
         /* Still nothing, some VBIOS images have a hardcoded EDID block
          * stored for the panel stored in them.
          */
-        if (!dev_priv->vbios.fp_no_ddc) {
+        if (!drm->vbios.fp_no_ddc) {
                 struct edid *edid =
                         (struct edid *)nouveau_bios_embedded_edid(dev);
                 if (edid) {
@@ -379,21 +400,22 @@ out:
 static void
 nouveau_connector_force(struct drm_connector *connector)
 {
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder;
         int type;
 
         if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
                 if (connector->force == DRM_FORCE_ON_DIGITAL)
-                        type = OUTPUT_TMDS;
+                        type = DCB_OUTPUT_TMDS;
                 else
-                        type = OUTPUT_ANALOG;
+                        type = DCB_OUTPUT_ANALOG;
         } else
-                type = OUTPUT_ANY;
+                type = DCB_OUTPUT_ANY;
 
         nv_encoder = find_encoder(connector, type);
         if (!nv_encoder) {
-                NV_ERROR(connector->dev, "can't find encoder to force %s on!\n",
+                NV_ERROR(drm, "can't find encoder to force %s on!\n",
                          drm_get_connector_name(connector));
                 connector->status = connector_status_disconnected;
                 return;
@@ -406,8 +428,7 @@ static int
 nouveau_connector_set_property(struct drm_connector *connector,
                                struct drm_property *property, uint64_t value)
 {
-        struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
-        struct nouveau_display_engine *disp = &dev_priv->engine.display;
+        struct nouveau_display *disp = nouveau_display(connector->dev);
         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);
@@ -532,7 +553,7 @@ nouveau_connector_set_property(struct drm_connector *connector,
                 }
         }
 
-        if (nv_encoder && nv_encoder->dcb->type == OUTPUT_TV)
+        if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV)
                 return get_slave_funcs(encoder)->set_property(
                         encoder, connector, property, value);
 
@@ -543,6 +564,7 @@ static struct drm_display_mode *
 nouveau_connector_native_mode(struct drm_connector *connector)
 {
         struct drm_connector_helper_funcs *helper = connector->helper_private;
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct drm_device *dev = connector->dev;
         struct drm_display_mode *mode, *largest = NULL;
@@ -556,7 +578,7 @@ nouveau_connector_native_mode(struct drm_connector *connector)
 
                 /* Use preferred mode if there is one.. */
                 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
-                        NV_DEBUG_KMS(dev, "native mode from preferred\n");
+                        NV_DEBUG(drm, "native mode from preferred\n");
                         return drm_mode_duplicate(dev, mode);
                 }
 
@@ -579,7 +601,7 @@ nouveau_connector_native_mode(struct drm_connector *connector)
                 largest = mode;
         }
 
-        NV_DEBUG_KMS(dev, "native mode from largest: %dx%d@%d\n",
+        NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
                       high_w, high_h, high_v);
         return largest ? drm_mode_duplicate(dev, largest) : NULL;
 }
@@ -643,10 +665,10 @@ nouveau_connector_scaler_modes_add(struct drm_connector *connector)
 static void
 nouveau_connector_detect_depth(struct drm_connector *connector)
 {
-        struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
         struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nvbios *bios = &drm->vbios;
         struct drm_display_mode *mode = nv_connector->native_mode;
         bool duallink;
 
@@ -661,7 +683,7 @@ nouveau_connector_detect_depth(struct drm_connector *connector)
         }
 
         /* we're out of options unless we're LVDS, default to 8bpc */
-        if (nv_encoder->dcb->type != OUTPUT_LVDS) {
+        if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
                 connector->display_info.bpc = 8;
                 return;
         }
@@ -693,7 +715,7 @@ static int
 nouveau_connector_get_modes(struct drm_connector *connector)
 {
         struct drm_device *dev = connector->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         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);
@@ -709,9 +731,9 @@ nouveau_connector_get_modes(struct drm_connector *connector)
         if (nv_connector->edid)
                 ret = drm_add_edid_modes(connector, nv_connector->edid);
         else
-        if (nv_encoder->dcb->type == OUTPUT_LVDS &&
+        if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
             (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
-             dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
+             drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
                 struct drm_display_mode mode;
 
                 nouveau_bios_fp_mode(dev, &mode);
@@ -746,7 +768,7 @@ nouveau_connector_get_modes(struct drm_connector *connector)
         if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
                 nouveau_connector_detect_depth(connector);
 
-        if (nv_encoder->dcb->type == OUTPUT_TV)
+        if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
                 ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
 
         if (nv_connector->type == DCB_CONNECTOR_LVDS ||
@@ -761,15 +783,15 @@ static unsigned
 get_tmds_link_bandwidth(struct drm_connector *connector)
 {
         struct nouveau_connector *nv_connector = nouveau_connector(connector);
-        struct drm_nouveau_private *dev_priv = connector->dev->dev_private;
-        struct dcb_entry *dcb = nv_connector->detected_encoder->dcb;
+        struct nouveau_drm *drm = nouveau_drm(connector->dev);
+        struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
 
         if (dcb->location != DCB_LOC_ON_CHIP ||
-            dev_priv->chipset >= 0x46)
+            nv_device(drm->device)->chipset >= 0x46)
                 return 165000;
-        else if (dev_priv->chipset >= 0x40)
+        else if (nv_device(drm->device)->chipset >= 0x40)
                 return 155000;
-        else if (dev_priv->chipset >= 0x18)
+        else if (nv_device(drm->device)->chipset >= 0x18)
                 return 135000;
         else
                 return 112000;
@@ -786,7 +808,7 @@ nouveau_connector_mode_valid(struct drm_connector *connector,
         unsigned clock = mode->clock;
 
         switch (nv_encoder->dcb->type) {
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 if (nv_connector->native_mode &&
                     (mode->hdisplay > nv_connector->native_mode->hdisplay ||
                      mode->vdisplay > nv_connector->native_mode->vdisplay))
@@ -795,19 +817,19 @@ nouveau_connector_mode_valid(struct drm_connector *connector,
                 min_clock = 0;
                 max_clock = 400000;
                 break;
-        case OUTPUT_TMDS:
+        case DCB_OUTPUT_TMDS:
                 max_clock = get_tmds_link_bandwidth(connector);
                 if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
                         max_clock *= 2;
                 break;
-        case OUTPUT_ANALOG:
+        case DCB_OUTPUT_ANALOG:
                 max_clock = nv_encoder->dcb->crtconf.maxfreq;
                 if (!max_clock)
                         max_clock = 350000;
                 break;
-        case OUTPUT_TV:
+        case DCB_OUTPUT_TV:
                 return get_slave_funcs(encoder)->mode_valid(encoder, mode);
-        case OUTPUT_DP:
+        case DCB_OUTPUT_DP:
                 max_clock  = nv_encoder->dp.link_nr;
                 max_clock *= nv_encoder->dp.link_bw;
                 clock = clock * (connector->display_info.bpc * 3) / 10;
@@ -899,14 +921,15 @@ struct drm_connector *
 nouveau_connector_create(struct drm_device *dev, int index)
 {
         const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_display_engine *disp = &dev_priv->engine.display;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
+        struct nouveau_display *disp = nouveau_display(dev);
         struct nouveau_connector *nv_connector = NULL;
         struct drm_connector *connector;
         int type, ret = 0;
         bool dummy;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 nv_connector = nouveau_connector(connector);
@@ -922,7 +945,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
         nv_connector->index = index;
 
         /* attempt to parse vbios connector type and hotplug gpio */
-        nv_connector->dcb = dcb_conn(dev, index);
+        nv_connector->dcb = olddcb_conn(dev, index);
         if (nv_connector->dcb) {
                 static const u8 hpd[16] = {
                         0xff, 0x07, 0x08, 0xff, 0xff, 0x51, 0x52, 0xff,
@@ -930,7 +953,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
                 };
 
                 u32 entry = ROM16(nv_connector->dcb[0]);
-                if (dcb_conntab(dev)[3] >= 4)
+                if (olddcb_conntab(dev)[3] >= 4)
                         entry |= (u32)ROM16(nv_connector->dcb[2]) << 16;
 
                 nv_connector->hpd = ffs((entry & 0x07033000) >> 12);
@@ -939,7 +962,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
                 nv_connector->type = nv_connector->dcb[0];
                 if (drm_conntype_from_dcb(nv_connector->type) ==
                                           DRM_MODE_CONNECTOR_Unknown) {
-                        NV_WARN(dev, "unknown connector type %02x\n",
+                        NV_WARN(drm, "unknown connector type %02x\n",
                                 nv_connector->type);
                         nv_connector->type = DCB_CONNECTOR_NONE;
                 }
@@ -964,8 +987,8 @@ nouveau_connector_create(struct drm_device *dev, int index)
          * figure out something suitable ourselves
          */
         if (nv_connector->type == DCB_CONNECTOR_NONE) {
-                struct drm_nouveau_private *dev_priv = dev->dev_private;
-                struct dcb_table *dcbt = &dev_priv->vbios.dcb;
+                struct nouveau_drm *drm = nouveau_drm(dev);
+                struct dcb_table *dcbt = &drm->vbios.dcb;
                 u32 encoders = 0;
                 int i;
 
@@ -974,25 +997,25 @@ nouveau_connector_create(struct drm_device *dev, int index)
                                 encoders |= (1 << dcbt->entry[i].type);
                 }
 
-                if (encoders & (1 << OUTPUT_DP)) {
-                        if (encoders & (1 << OUTPUT_TMDS))
+                if (encoders & (1 << DCB_OUTPUT_DP)) {
+                        if (encoders & (1 << DCB_OUTPUT_TMDS))
                                 nv_connector->type = DCB_CONNECTOR_DP;
                         else
                                 nv_connector->type = DCB_CONNECTOR_eDP;
                 } else
-                if (encoders & (1 << OUTPUT_TMDS)) {
-                        if (encoders & (1 << OUTPUT_ANALOG))
+                if (encoders & (1 << DCB_OUTPUT_TMDS)) {
+                        if (encoders & (1 << DCB_OUTPUT_ANALOG))
                                 nv_connector->type = DCB_CONNECTOR_DVI_I;
                         else
                                 nv_connector->type = DCB_CONNECTOR_DVI_D;
                 } else
-                if (encoders & (1 << OUTPUT_ANALOG)) {
+                if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
                         nv_connector->type = DCB_CONNECTOR_VGA;
                 } else
-                if (encoders & (1 << OUTPUT_LVDS)) {
+                if (encoders & (1 << DCB_OUTPUT_LVDS)) {
                         nv_connector->type = DCB_CONNECTOR_LVDS;
                 } else
-                if (encoders & (1 << OUTPUT_TV)) {
+                if (encoders & (1 << DCB_OUTPUT_TV)) {
                         nv_connector->type = DCB_CONNECTOR_TV_0;
                 }
         }
@@ -1001,7 +1024,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
         if (type == DRM_MODE_CONNECTOR_LVDS) {
                 ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
                 if (ret) {
-                        NV_ERROR(dev, "Error parsing LVDS table, disabling\n");
+                        NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
                         kfree(nv_connector);
                         return ERR_PTR(ret);
                 }
@@ -1051,7 +1074,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
 
         switch (nv_connector->type) {
         case DCB_CONNECTOR_VGA:
-                if (dev_priv->card_type >= NV_50) {
+                if (nv_device(drm->device)->card_type >= NV_50) {
                         drm_connector_attach_property(connector,
                                         dev->mode_config.scaling_mode_property,
                                         nv_connector->scaling_mode);
@@ -1084,10 +1107,9 @@ nouveau_connector_create(struct drm_device *dev, int index)
         }
 
         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
-        if (nv_connector->hpd != DCB_GPIO_UNUSED) {
-                ret = nouveau_gpio_isr_add(dev, 0, nv_connector->hpd, 0xff,
-                                           nouveau_connector_hotplug,
-                                           connector);
+        if (gpio && nv_connector->hpd != DCB_GPIO_UNUSED) {
+                ret = gpio->isr_add(gpio, 0, nv_connector->hpd, 0xff,
+                                    nouveau_connector_hotplug, connector);
                 if (ret == 0)
                         connector->polled = DRM_CONNECTOR_POLL_HPD;
         }
@@ -1101,8 +1123,9 @@ nouveau_connector_hotplug(void *data, int plugged)
 {
         struct drm_connector *connector = data;
         struct drm_device *dev = connector->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        NV_DEBUG(dev, "%splugged %s\n", plugged ? "" : "un",
+        NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un",
                  drm_get_connector_name(connector));
 
         if (plugged)
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.h b/drivers/gpu/drm/nouveau/nouveau_connector.h
index e4857021304c..9503cfa0492c 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.h
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.h
@@ -28,7 +28,8 @@
 #define __NOUVEAU_CONNECTOR_H__
 
 #include "drm_edid.h"
-#include "nouveau_i2c.h"
+
+struct nouveau_i2c_port;
 
 enum nouveau_underscan_type {
         UNDERSCAN_OFF,
diff --git a/drivers/gpu/drm/nouveau/nouveau_debugfs.c b/drivers/gpu/drm/nouveau/nouveau_debugfs.c
deleted file mode 100644
index 188c92b327e2..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_debugfs.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * Copyright (C) 2009 Red Hat <bskeggs@redhat.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-/*
- * Authors:
- *  Ben Skeggs <bskeggs@redhat.com>
- */
-
-#include <linux/debugfs.h>
-
-#include "drmP.h"
-#include "nouveau_drv.h"
-
-#include <ttm/ttm_page_alloc.h>
-
-static int
-nouveau_debugfs_channel_info(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct nouveau_channel *chan = node->info_ent->data;
-
-        seq_printf(m, "channel id    : %d\n", chan->id);
-
-        seq_printf(m, "cpu fifo state:\n");
-        seq_printf(m, "          base: 0x%10llx\n", chan->pushbuf_base);
-        seq_printf(m, "           max: 0x%08x\n", chan->dma.max << 2);
-        seq_printf(m, "           cur: 0x%08x\n", chan->dma.cur << 2);
-        seq_printf(m, "           put: 0x%08x\n", chan->dma.put << 2);
-        seq_printf(m, "          free: 0x%08x\n", chan->dma.free << 2);
-        if (chan->dma.ib_max) {
-                seq_printf(m, "        ib max: 0x%08x\n", chan->dma.ib_max);
-                seq_printf(m, "        ib put: 0x%08x\n", chan->dma.ib_put);
-                seq_printf(m, "       ib free: 0x%08x\n", chan->dma.ib_free);
-        }
-
-        seq_printf(m, "gpu fifo state:\n");
-        seq_printf(m, "           get: 0x%08x\n",
-                                        nvchan_rd32(chan, chan->user_get));
-        seq_printf(m, "           put: 0x%08x\n",
-                                        nvchan_rd32(chan, chan->user_put));
-        if (chan->dma.ib_max) {
-                seq_printf(m, "        ib get: 0x%08x\n",
-                           nvchan_rd32(chan, 0x88));
-                seq_printf(m, "        ib put: 0x%08x\n",
-                           nvchan_rd32(chan, 0x8c));
-        }
-
-        return 0;
-}
-
-int
-nouveau_debugfs_channel_init(struct nouveau_channel *chan)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct drm_minor *minor = chan->dev->primary;
-        int ret;
-
-        if (!dev_priv->debugfs.channel_root) {
-                dev_priv->debugfs.channel_root =
-                        debugfs_create_dir("channel", minor->debugfs_root);
-                if (!dev_priv->debugfs.channel_root)
-                        return -ENOENT;
-        }
-
-        snprintf(chan->debugfs.name, 32, "%d", chan->id);
-        chan->debugfs.info.name = chan->debugfs.name;
-        chan->debugfs.info.show = nouveau_debugfs_channel_info;
-        chan->debugfs.info.driver_features = 0;
-        chan->debugfs.info.data = chan;
-
-        ret = drm_debugfs_create_files(&chan->debugfs.info, 1,
-                                       dev_priv->debugfs.channel_root,
-                                       chan->dev->primary);
-        if (ret == 0)
-                chan->debugfs.active = true;
-        return ret;
-}
-
-void
-nouveau_debugfs_channel_fini(struct nouveau_channel *chan)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-
-        if (!chan->debugfs.active)
-                return;
-
-        drm_debugfs_remove_files(&chan->debugfs.info, 1, chan->dev->primary);
-        chan->debugfs.active = false;
-
-        if (chan == dev_priv->channel) {
-                debugfs_remove(dev_priv->debugfs.channel_root);
-                dev_priv->debugfs.channel_root = NULL;
-        }
-}
-
-static int
-nouveau_debugfs_chipset_info(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_minor *minor = node->minor;
-        struct drm_device *dev = minor->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t ppci_0;
-
-        ppci_0 = nv_rd32(dev, dev_priv->chipset >= 0x40 ? 0x88000 : 0x1800);
-
-        seq_printf(m, "PMC_BOOT_0: 0x%08x\n", nv_rd32(dev, NV03_PMC_BOOT_0));
-        seq_printf(m, "PCI ID    : 0x%04x:0x%04x\n",
-                   ppci_0 & 0xffff, ppci_0 >> 16);
-        return 0;
-}
-
-static int
-nouveau_debugfs_memory_info(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_minor *minor = node->minor;
-        struct drm_nouveau_private *dev_priv = minor->dev->dev_private;
-
-        seq_printf(m, "VRAM total: %dKiB\n", (int)(dev_priv->vram_size >> 10));
-        return 0;
-}
-
-static int
-nouveau_debugfs_vbios_image(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_nouveau_private *dev_priv = node->minor->dev->dev_private;
-        int i;
-
-        for (i = 0; i < dev_priv->vbios.length; i++)
-                seq_printf(m, "%c", dev_priv->vbios.data[i]);
-        return 0;
-}
-
-static int
-nouveau_debugfs_evict_vram(struct seq_file *m, void *data)
-{
-        struct drm_info_node *node = (struct drm_info_node *) m->private;
-        struct drm_nouveau_private *dev_priv = node->minor->dev->dev_private;
-        int ret;
-
-        ret = ttm_bo_evict_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
-        if (ret)
-                seq_printf(m, "failed: %d", ret);
-        else
-                seq_printf(m, "succeeded\n");
-        return 0;
-}
-
-static struct drm_info_list nouveau_debugfs_list[] = {
-        { "evict_vram", nouveau_debugfs_evict_vram, 0, NULL },
-        { "chipset", nouveau_debugfs_chipset_info, 0, NULL },
-        { "memory", nouveau_debugfs_memory_info, 0, NULL },
-        { "vbios.rom", nouveau_debugfs_vbios_image, 0, NULL },
-        { "ttm_page_pool", ttm_page_alloc_debugfs, 0, NULL },
-        { "ttm_dma_page_pool", ttm_dma_page_alloc_debugfs, 0, NULL },
-};
-#define NOUVEAU_DEBUGFS_ENTRIES ARRAY_SIZE(nouveau_debugfs_list)
-
-int
-nouveau_debugfs_init(struct drm_minor *minor)
-{
-        drm_debugfs_create_files(nouveau_debugfs_list, NOUVEAU_DEBUGFS_ENTRIES,
-                                 minor->debugfs_root, minor);
-        return 0;
-}
-
-void
-nouveau_debugfs_takedown(struct drm_minor *minor)
-{
-        drm_debugfs_remove_files(nouveau_debugfs_list, NOUVEAU_DEBUGFS_ENTRIES,
-                                 minor);
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_display.c b/drivers/gpu/drm/nouveau/nouveau_display.c
index 7e16dc5e6467..61f370d000e9 100644
--- a/drivers/gpu/drm/nouveau/nouveau_display.c
+++ b/drivers/gpu/drm/nouveau/nouveau_display.c
@@ -26,18 +26,21 @@
 
 #include "drmP.h"
 #include "drm_crtc_helper.h"
-#include "nouveau_drv.h"
-#include "nouveau_fb.h"
+
 #include "nouveau_fbcon.h"
 #include "nouveau_hw.h"
 #include "nouveau_crtc.h"
 #include "nouveau_dma.h"
+#include "nouveau_gem.h"
 #include "nouveau_connector.h"
-#include "nouveau_software.h"
-#include "nouveau_gpio.h"
-#include "nouveau_fence.h"
 #include "nv50_display.h"
 
+#include "nouveau_fence.h"
+
+#include <subdev/bios/gpio.h>
+#include <subdev/gpio.h>
+#include <engine/disp.h>
+
 static void
 nouveau_user_framebuffer_destroy(struct drm_framebuffer *drm_fb)
 {
@@ -71,7 +74,7 @@ nouveau_framebuffer_init(struct drm_device *dev,
                          struct drm_mode_fb_cmd2 *mode_cmd,
                          struct nouveau_bo *nvbo)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_framebuffer *fb = &nv_fb->base;
         int ret;
 
@@ -83,7 +86,7 @@ nouveau_framebuffer_init(struct drm_device *dev,
         drm_helper_mode_fill_fb_struct(fb, mode_cmd);
         nv_fb->nvbo = nvbo;
 
-        if (dev_priv->card_type >= NV_50) {
+        if (nv_device(drm->device)->card_type >= NV_50) {
                 u32 tile_flags = nouveau_bo_tile_layout(nvbo);
                 if (tile_flags == 0x7a00 ||
                     tile_flags == 0xfe00)
@@ -102,21 +105,21 @@ nouveau_framebuffer_init(struct drm_device *dev,
                 case 32: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_24; break;
                 case 30: nv_fb->r_format = NV50_EVO_CRTC_FB_DEPTH_30; break;
                 default:
-                         NV_ERROR(dev, "unknown depth %d\n", fb->depth);
+                         NV_ERROR(drm, "unknown depth %d\n", fb->depth);
                          return -EINVAL;
                 }
 
-                if (dev_priv->chipset == 0x50)
+                if (nv_device(drm->device)->chipset == 0x50)
                         nv_fb->r_format |= (tile_flags << 8);
 
                 if (!tile_flags) {
-                        if (dev_priv->card_type < NV_D0)
+                        if (nv_device(drm->device)->card_type < NV_D0)
                                 nv_fb->r_pitch = 0x00100000 | fb->pitches[0];
                         else
                                 nv_fb->r_pitch = 0x01000000 | fb->pitches[0];
                 } else {
                         u32 mode = nvbo->tile_mode;
-                        if (dev_priv->card_type >= NV_C0)
+                        if (nv_device(drm->device)->card_type >= NV_C0)
                                 mode >>= 4;
                         nv_fb->r_pitch = ((fb->pitches[0] / 4) << 4) | mode;
                 }
@@ -212,8 +215,9 @@ static struct nouveau_drm_prop_enum_list dither_depth[] = {
 int
 nouveau_display_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_display_engine *disp = &dev_priv->engine.display;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_display *disp = nouveau_display(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
         struct drm_connector *connector;
         int ret;
 
@@ -225,8 +229,8 @@ nouveau_display_init(struct drm_device *dev)
          * some vbios default this to off for some reason, causing the
          * panel to not work after resume
          */
-        if (nouveau_gpio_func_get(dev, DCB_GPIO_PANEL_POWER) == 0) {
-                nouveau_gpio_func_set(dev, DCB_GPIO_PANEL_POWER, true);
+        if (gpio && gpio->get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff) == 0) {
+                gpio->set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
                 msleep(300);
         }
 
@@ -236,7 +240,8 @@ nouveau_display_init(struct drm_device *dev)
         /* enable hotplug interrupts */
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 struct nouveau_connector *conn = nouveau_connector(connector);
-                nouveau_gpio_irq(dev, 0, conn->hpd, 0xff, true);
+                if (gpio)
+                        gpio->irq(gpio, 0, conn->hpd, 0xff, true);
         }
 
         return ret;
@@ -245,35 +250,65 @@ nouveau_display_init(struct drm_device *dev)
 void
 nouveau_display_fini(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_display_engine *disp = &dev_priv->engine.display;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_display *disp = nouveau_display(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
         struct drm_connector *connector;
 
         /* disable hotplug interrupts */
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 struct nouveau_connector *conn = nouveau_connector(connector);
-                nouveau_gpio_irq(dev, 0, conn->hpd, 0xff, false);
+                if (gpio)
+                        gpio->irq(gpio, 0, conn->hpd, 0xff, false);
         }
 
         drm_kms_helper_poll_disable(dev);
         disp->fini(dev);
 }
 
+static void
+nouveau_display_vblank_notify(void *data, int crtc)
+{
+        drm_handle_vblank(data, crtc);
+}
+
+static void
+nouveau_display_vblank_get(void *data, int crtc)
+{
+        drm_vblank_get(data, crtc);
+}
+
+static void
+nouveau_display_vblank_put(void *data, int crtc)
+{
+        drm_vblank_put(data, crtc);
+}
+
 int
 nouveau_display_create(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_display_engine *disp = &dev_priv->engine.display;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_disp *pdisp = nouveau_disp(drm->device);
+        struct nouveau_display *disp;
         int ret, gen;
 
+        disp = drm->display = kzalloc(sizeof(*disp), GFP_KERNEL);
+        if (!disp)
+                return -ENOMEM;
+
+        pdisp->vblank.data = dev;
+        pdisp->vblank.notify = nouveau_display_vblank_notify;
+        pdisp->vblank.get = nouveau_display_vblank_get;
+        pdisp->vblank.put = nouveau_display_vblank_put;
+
         drm_mode_config_init(dev);
         drm_mode_create_scaling_mode_property(dev);
         drm_mode_create_dvi_i_properties(dev);
 
-        if (dev_priv->card_type < NV_50)
+        if (nv_device(drm->device)->card_type < NV_50)
                 gen = 0;
         else
-        if (dev_priv->card_type < NV_D0)
+        if (nv_device(drm->device)->card_type < NV_D0)
                 gen = 1;
         else
                 gen = 2;
@@ -307,11 +342,11 @@ nouveau_display_create(struct drm_device *dev)
 
         dev->mode_config.min_width = 0;
         dev->mode_config.min_height = 0;
-        if (dev_priv->card_type < NV_10) {
+        if (nv_device(drm->device)->card_type < NV_10) {
                 dev->mode_config.max_width = 2048;
                 dev->mode_config.max_height = 2048;
         } else
-        if (dev_priv->card_type < NV_50) {
+        if (nv_device(drm->device)->card_type < NV_50) {
                 dev->mode_config.max_width = 4096;
                 dev->mode_config.max_height = 4096;
         } else {
@@ -325,7 +360,13 @@ nouveau_display_create(struct drm_device *dev)
         drm_kms_helper_poll_init(dev);
         drm_kms_helper_poll_disable(dev);
 
-        ret = disp->create(dev);
+        if (nv_device(drm->device)->card_type < NV_50)
+                ret = nv04_display_create(dev);
+        else
+        if (nv_device(drm->device)->card_type < NV_D0)
+                ret = nv50_display_create(dev);
+        else
+                ret = nvd0_display_create(dev);
         if (ret)
                 goto disp_create_err;
 
@@ -335,10 +376,11 @@ nouveau_display_create(struct drm_device *dev)
                         goto vblank_err;
         }
 
+        nouveau_backlight_init(dev);
         return 0;
 
 vblank_err:
-        disp->destroy(dev);
+        disp->dtor(dev);
 disp_create_err:
         drm_kms_helper_poll_fini(dev);
         drm_mode_config_cleanup(dev);
@@ -348,24 +390,109 @@ disp_create_err:
 void
 nouveau_display_destroy(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_display_engine *disp = &dev_priv->engine.display;
+        struct nouveau_display *disp = nouveau_display(dev);
 
+        nouveau_backlight_exit(dev);
         drm_vblank_cleanup(dev);
 
-        disp->destroy(dev);
+        disp->dtor(dev);
 
         drm_kms_helper_poll_fini(dev);
         drm_mode_config_cleanup(dev);
+        nouveau_drm(dev)->display = NULL;
+        kfree(disp);
+}
+
+int
+nouveau_display_suspend(struct drm_device *dev)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct drm_crtc *crtc;
+
+        nouveau_display_fini(dev);
+
+        NV_INFO(drm, "unpinning framebuffer(s)...\n");
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                struct nouveau_framebuffer *nouveau_fb;
+
+                nouveau_fb = nouveau_framebuffer(crtc->fb);
+                if (!nouveau_fb || !nouveau_fb->nvbo)
+                        continue;
+
+                nouveau_bo_unpin(nouveau_fb->nvbo);
+        }
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+
+                nouveau_bo_unmap(nv_crtc->cursor.nvbo);
+                nouveau_bo_unpin(nv_crtc->cursor.nvbo);
+        }
+
+        return 0;
+}
+
+void
+nouveau_display_resume(struct drm_device *dev)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct drm_crtc *crtc;
+        int ret;
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                struct nouveau_framebuffer *nouveau_fb;
+
+                nouveau_fb = nouveau_framebuffer(crtc->fb);
+                if (!nouveau_fb || !nouveau_fb->nvbo)
+                        continue;
+
+                nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM);
+        }
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+
+                ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM);
+                if (!ret)
+                        ret = nouveau_bo_map(nv_crtc->cursor.nvbo);
+                if (ret)
+                        NV_ERROR(drm, "Could not pin/map cursor.\n");
+        }
+
+        nouveau_fbcon_set_suspend(dev, 0);
+        nouveau_fbcon_zfill_all(dev);
+
+        nouveau_display_init(dev);
+
+        /* Force CLUT to get re-loaded during modeset */
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+
+                nv_crtc->lut.depth = 0;
+        }
+
+        drm_helper_resume_force_mode(dev);
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+                u32 offset = nv_crtc->cursor.nvbo->bo.offset;
+
+                nv_crtc->cursor.set_offset(nv_crtc, offset);
+                nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,
+                                                 nv_crtc->cursor_saved_y);
+        }
 }
 
 int
 nouveau_vblank_enable(struct drm_device *dev, int crtc)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
 
-        if (dev_priv->card_type >= NV_50)
-                nv_mask(dev, NV50_PDISPLAY_INTR_EN_1, 0,
+        if (device->card_type >= NV_D0)
+                nv_mask(device, 0x6100c0 + (crtc * 0x800), 1, 1);
+        else
+        if (device->card_type >= NV_50)
+                nv_mask(device, NV50_PDISPLAY_INTR_EN_1, 0,
                         NV50_PDISPLAY_INTR_EN_1_VBLANK_CRTC_(crtc));
         else
                 NVWriteCRTC(dev, crtc, NV_PCRTC_INTR_EN_0,
@@ -377,10 +504,13 @@ nouveau_vblank_enable(struct drm_device *dev, int crtc)
 void
 nouveau_vblank_disable(struct drm_device *dev, int crtc)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
 
-        if (dev_priv->card_type >= NV_50)
-                nv_mask(dev, NV50_PDISPLAY_INTR_EN_1,
+        if (device->card_type >= NV_D0)
+                nv_mask(device, 0x6100c0 + (crtc * 0x800), 1, 0);
+        else
+        if (device->card_type >= NV_50)
+                nv_mask(device, NV50_PDISPLAY_INTR_EN_1,
                         NV50_PDISPLAY_INTR_EN_1_VBLANK_CRTC_(crtc), 0);
         else
                 NVWriteCRTC(dev, crtc, NV_PCRTC_INTR_EN_0, 0);
@@ -434,15 +564,15 @@ nouveau_page_flip_emit(struct nouveau_channel *chan,
                        struct nouveau_page_flip_state *s,
                        struct nouveau_fence **pfence)
 {
-        struct nouveau_software_chan *swch = chan->engctx[NVOBJ_ENGINE_SW];
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct drm_device *dev = chan->dev;
+        struct nouveau_fence_chan *fctx = chan->fence;
+        struct nouveau_drm *drm = chan->drm;
+        struct drm_device *dev = drm->dev;
         unsigned long flags;
         int ret;
 
         /* Queue it to the pending list */
         spin_lock_irqsave(&dev->event_lock, flags);
-        list_add_tail(&s->head, &swch->flip);
+        list_add_tail(&s->head, &fctx->flip);
         spin_unlock_irqrestore(&dev->event_lock, flags);
 
         /* Synchronize with the old framebuffer */
@@ -455,7 +585,7 @@ nouveau_page_flip_emit(struct nouveau_channel *chan,
         if (ret)
                 goto fail;
 
-        if (dev_priv->card_type < NV_C0) {
+        if (nv_device(drm->device)->card_type < NV_C0) {
                 BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);
                 OUT_RING  (chan, 0x00000000);
                 OUT_RING  (chan, 0x00000000);
@@ -483,7 +613,7 @@ nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                        struct drm_pending_vblank_event *event)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_bo *old_bo = nouveau_framebuffer(crtc->fb)->nvbo;
         struct nouveau_bo *new_bo = nouveau_framebuffer(fb)->nvbo;
         struct nouveau_page_flip_state *s;
@@ -491,7 +621,7 @@ nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
         struct nouveau_fence *fence;
         int ret;
 
-        if (!dev_priv->channel)
+        if (!drm->channel)
                 return -ENODEV;
 
         s = kzalloc(sizeof(*s), GFP_KERNEL);
@@ -512,25 +642,25 @@ nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
         /* Choose the channel the flip will be handled in */
         fence = new_bo->bo.sync_obj;
         if (fence)
-                chan = nouveau_channel_get_unlocked(fence->channel);
+                chan = fence->channel;
         if (!chan)
-                chan = nouveau_channel_get_unlocked(dev_priv->channel);
-        mutex_lock(&chan->mutex);
+                chan = drm->channel;
+        mutex_lock(&chan->cli->mutex);
 
         /* Emit a page flip */
-        if (dev_priv->card_type >= NV_50) {
-                if (dev_priv->card_type >= NV_D0)
+        if (nv_device(drm->device)->card_type >= NV_50) {
+                if (nv_device(drm->device)->card_type >= NV_D0)
                         ret = nvd0_display_flip_next(crtc, fb, chan, 0);
                 else
                         ret = nv50_display_flip_next(crtc, fb, chan);
                 if (ret) {
-                        nouveau_channel_put(&chan);
+                        mutex_unlock(&chan->cli->mutex);
                         goto fail_unreserve;
                 }
         }
 
         ret = nouveau_page_flip_emit(chan, old_bo, new_bo, s, &fence);
-        nouveau_channel_put(&chan);
+        mutex_unlock(&chan->cli->mutex);
         if (ret)
                 goto fail_unreserve;
 
@@ -552,20 +682,21 @@ int
 nouveau_finish_page_flip(struct nouveau_channel *chan,
                          struct nouveau_page_flip_state *ps)
 {
-        struct nouveau_software_chan *swch = chan->engctx[NVOBJ_ENGINE_SW];
-        struct drm_device *dev = chan->dev;
+        struct nouveau_fence_chan *fctx = chan->fence;
+        struct nouveau_drm *drm = chan->drm;
+        struct drm_device *dev = drm->dev;
         struct nouveau_page_flip_state *s;
         unsigned long flags;
 
         spin_lock_irqsave(&dev->event_lock, flags);
 
-        if (list_empty(&swch->flip)) {
-                NV_ERROR(dev, "Unexpected pageflip in channel %d.\n", chan->id);
+        if (list_empty(&fctx->flip)) {
+                NV_ERROR(drm, "unexpected pageflip\n");
                 spin_unlock_irqrestore(&dev->event_lock, flags);
                 return -EINVAL;
         }
 
-        s = list_first_entry(&swch->flip, struct nouveau_page_flip_state, head);
+        s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head);
         if (s->event) {
                 struct drm_pending_vblank_event *e = s->event;
                 struct timeval now;
@@ -588,6 +719,24 @@ nouveau_finish_page_flip(struct nouveau_channel *chan,
 }
 
 int
+nouveau_flip_complete(void *data)
+{
+        struct nouveau_channel *chan = data;
+        struct nouveau_drm *drm = chan->drm;
+        struct nouveau_page_flip_state state;
+
+        if (!nouveau_finish_page_flip(chan, &state)) {
+                if (nv_device(drm->device)->card_type < NV_50) {
+                        nv_set_crtc_base(drm->dev, state.crtc, state.offset +
+                                         state.y * state.pitch +
+                                         state.x * state.bpp / 8);
+                }
+        }
+
+        return 0;
+}
+
+int
 nouveau_display_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
                             struct drm_mode_create_dumb *args)
 {
diff --git a/drivers/gpu/drm/nouveau/nouveau_display.h b/drivers/gpu/drm/nouveau/nouveau_display.h
new file mode 100644
index 000000000000..722548bb3bd3
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_display.h
@@ -0,0 +1,94 @@
+#ifndef __NOUVEAU_DISPLAY_H__
+#define __NOUVEAU_DISPLAY_H__
+
+#include <subdev/vm.h>
+
+#include "nouveau_drm.h"
+
+struct nouveau_framebuffer {
+        struct drm_framebuffer base;
+        struct nouveau_bo *nvbo;
+        struct nouveau_vma vma;
+        u32 r_dma;
+        u32 r_format;
+        u32 r_pitch;
+};
+
+static inline struct nouveau_framebuffer *
+nouveau_framebuffer(struct drm_framebuffer *fb)
+{
+        return container_of(fb, struct nouveau_framebuffer, base);
+}
+
+int nouveau_framebuffer_init(struct drm_device *, struct nouveau_framebuffer *,
+                             struct drm_mode_fb_cmd2 *, struct nouveau_bo *);
+
+struct nouveau_page_flip_state {
+        struct list_head head;
+        struct drm_pending_vblank_event *event;
+        int crtc, bpp, pitch, x, y;
+        u64 offset;
+};
+
+struct nouveau_display {
+        void *priv;
+        void (*dtor)(struct drm_device *);
+        int  (*init)(struct drm_device *);
+        void (*fini)(struct drm_device *);
+
+        struct drm_property *dithering_mode;
+        struct drm_property *dithering_depth;
+        struct drm_property *underscan_property;
+        struct drm_property *underscan_hborder_property;
+        struct drm_property *underscan_vborder_property;
+        /* not really hue and saturation: */
+        struct drm_property *vibrant_hue_property;
+        struct drm_property *color_vibrance_property;
+};
+
+static inline struct nouveau_display *
+nouveau_display(struct drm_device *dev)
+{
+        return nouveau_drm(dev)->display;
+}
+
+int  nouveau_display_create(struct drm_device *dev);
+void nouveau_display_destroy(struct drm_device *dev);
+int  nouveau_display_init(struct drm_device *dev);
+void nouveau_display_fini(struct drm_device *dev);
+int  nouveau_display_suspend(struct drm_device *dev);
+void nouveau_display_resume(struct drm_device *dev);
+
+int  nouveau_vblank_enable(struct drm_device *dev, int crtc);
+void nouveau_vblank_disable(struct drm_device *dev, int crtc);
+
+int  nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
+                            struct drm_pending_vblank_event *event);
+int  nouveau_finish_page_flip(struct nouveau_channel *,
+                              struct nouveau_page_flip_state *);
+
+int  nouveau_display_dumb_create(struct drm_file *, struct drm_device *,
+                                 struct drm_mode_create_dumb *args);
+int  nouveau_display_dumb_map_offset(struct drm_file *, struct drm_device *,
+                                     u32 handle, u64 *offset);
+int  nouveau_display_dumb_destroy(struct drm_file *, struct drm_device *,
+                                  u32 handle);
+
+void nouveau_hdmi_mode_set(struct drm_encoder *, struct drm_display_mode *);
+
+#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
+extern int nouveau_backlight_init(struct drm_device *);
+extern void nouveau_backlight_exit(struct drm_device *);
+#else
+static inline int
+nouveau_backlight_init(struct drm_device *dev)
+{
+        return 0;
+}
+
+static inline void
+nouveau_backlight_exit(struct drm_device *dev) {
+}
+#endif
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_dma.c b/drivers/gpu/drm/nouveau/nouveau_dma.c
index 295932e66ac5..40f91e1e5842 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dma.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dma.c
@@ -24,41 +24,16 @@
  *
  */
 
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_dma.h"
-#include "nouveau_ramht.h"
-
-void
-nouveau_dma_init(struct nouveau_channel *chan)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct nouveau_bo *pushbuf = chan->pushbuf_bo;
-
-        if (dev_priv->card_type >= NV_50) {
-                const int ib_size = pushbuf->bo.mem.size / 2;
-
-                chan->dma.ib_base = (pushbuf->bo.mem.size - ib_size) >> 2;
-                chan->dma.ib_max = (ib_size / 8) - 1;
-                chan->dma.ib_put = 0;
-                chan->dma.ib_free = chan->dma.ib_max - chan->dma.ib_put;
+#include <core/client.h>
 
-                chan->dma.max = (pushbuf->bo.mem.size - ib_size) >> 2;
-        } else {
-                chan->dma.max  = (pushbuf->bo.mem.size >> 2) - 2;
-        }
-
-        chan->dma.put  = 0;
-        chan->dma.cur  = chan->dma.put;
-        chan->dma.free = chan->dma.max - chan->dma.cur;
-}
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
 
 void
 OUT_RINGp(struct nouveau_channel *chan, const void *data, unsigned nr_dwords)
 {
         bool is_iomem;
-        u32 *mem = ttm_kmap_obj_virtual(&chan->pushbuf_bo->kmap, &is_iomem);
+        u32 *mem = ttm_kmap_obj_virtual(&chan->push.buffer->kmap, &is_iomem);
         mem = &mem[chan->dma.cur];
         if (is_iomem)
                 memcpy_toio((void __force __iomem *)mem, data, nr_dwords * 4);
@@ -79,9 +54,9 @@ READ_GET(struct nouveau_channel *chan, uint64_t *prev_get, int *timeout)
 {
         uint64_t val;
 
-        val = nvchan_rd32(chan, chan->user_get);
+        val = nv_ro32(chan->object, chan->user_get);
         if (chan->user_get_hi)
-                val |= (uint64_t)nvchan_rd32(chan, chan->user_get_hi) << 32;
+                val |= (uint64_t)nv_ro32(chan->object, chan->user_get_hi) << 32;
 
         /* reset counter as long as GET is still advancing, this is
          * to avoid misdetecting a GPU lockup if the GPU happens to
@@ -93,32 +68,33 @@ READ_GET(struct nouveau_channel *chan, uint64_t *prev_get, int *timeout)
         }
 
         if ((++*timeout & 0xff) == 0) {
-                DRM_UDELAY(1);
+                udelay(1);
                 if (*timeout > 100000)
                         return -EBUSY;
         }
 
-        if (val < chan->pushbuf_base ||
-            val > chan->pushbuf_base + (chan->dma.max << 2))
+        if (val < chan->push.vma.offset ||
+            val > chan->push.vma.offset + (chan->dma.max << 2))
                 return -EINVAL;
 
-        return (val - chan->pushbuf_base) >> 2;
+        return (val - chan->push.vma.offset) >> 2;
 }
 
 void
 nv50_dma_push(struct nouveau_channel *chan, struct nouveau_bo *bo,
               int delta, int length)
 {
-        struct nouveau_bo *pb = chan->pushbuf_bo;
+        struct nouveau_bo *pb = chan->push.buffer;
         struct nouveau_vma *vma;
         int ip = (chan->dma.ib_put * 2) + chan->dma.ib_base;
         u64 offset;
 
-        vma = nouveau_bo_vma_find(bo, chan->vm);
+        vma = nouveau_bo_vma_find(bo, nv_client(chan->cli)->vm);
         BUG_ON(!vma);
         offset = vma->offset + delta;
 
         BUG_ON(chan->dma.ib_free < 1);
+
         nouveau_bo_wr32(pb, ip++, lower_32_bits(offset));
         nouveau_bo_wr32(pb, ip++, upper_32_bits(offset) | length << 8);
 
@@ -128,7 +104,7 @@ nv50_dma_push(struct nouveau_channel *chan, struct nouveau_bo *bo,
         /* Flush writes. */
         nouveau_bo_rd32(pb, 0);
 
-        nvchan_wr32(chan, 0x8c, chan->dma.ib_put);
+        nv_wo32(chan->object, 0x8c, chan->dma.ib_put);
         chan->dma.ib_free--;
 }
 
@@ -138,7 +114,7 @@ nv50_dma_push_wait(struct nouveau_channel *chan, int count)
         uint32_t cnt = 0, prev_get = 0;
 
         while (chan->dma.ib_free < count) {
-                uint32_t get = nvchan_rd32(chan, 0x88);
+                uint32_t get = nv_ro32(chan->object, 0x88);
                 if (get != prev_get) {
                         prev_get = get;
                         cnt = 0;
@@ -249,7 +225,7 @@ nouveau_dma_wait(struct nouveau_channel *chan, int slots, int size)
                          * instruct the GPU to jump back to the start right
                          * after processing the currently pending commands.
                          */
-                        OUT_RING(chan, chan->pushbuf_base | 0x20000000);
+                        OUT_RING(chan, chan->push.vma.offset | 0x20000000);
 
                         /* wait for GET to depart from the skips area.
                          * prevents writing GET==PUT and causing a race
diff --git a/drivers/gpu/drm/nouveau/nouveau_dma.h b/drivers/gpu/drm/nouveau/nouveau_dma.h
index 8db68be9544f..5c2e22932d1c 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dma.h
+++ b/drivers/gpu/drm/nouveau/nouveau_dma.h
@@ -27,10 +27,10 @@
 #ifndef __NOUVEAU_DMA_H__
 #define __NOUVEAU_DMA_H__
 
-#ifndef NOUVEAU_DMA_DEBUG
-#define NOUVEAU_DMA_DEBUG 0
-#endif
+#include "nouveau_bo.h"
+#include "nouveau_chan.h"
 
+int nouveau_dma_wait(struct nouveau_channel *, int slots, int size);
 void nv50_dma_push(struct nouveau_channel *, struct nouveau_bo *,
                    int delta, int length);
 
@@ -116,12 +116,7 @@ RING_SPACE(struct nouveau_channel *chan, int size)
 static inline void
 OUT_RING(struct nouveau_channel *chan, int data)
 {
-        if (NOUVEAU_DMA_DEBUG) {
-                NV_INFO(chan->dev, "Ch%d/0x%08x: 0x%08x\n",
-                        chan->id, chan->dma.cur << 2, data);
-        }
-
-        nouveau_bo_wr32(chan->pushbuf_bo, chan->dma.cur++, data);
+        nouveau_bo_wr32(chan->push.buffer, chan->dma.cur++, data);
 }
 
 extern void
@@ -159,24 +154,19 @@ BEGIN_IMC0(struct nouveau_channel *chan, int subc, int mthd, u16 data)
 
 #define WRITE_PUT(val) do {                                                    \
         DRM_MEMORYBARRIER();                                                   \
-        nouveau_bo_rd32(chan->pushbuf_bo, 0);                                  \
-        nvchan_wr32(chan, chan->user_put, ((val) << 2) + chan->pushbuf_base);  \
+        nouveau_bo_rd32(chan->push.buffer, 0);                                 \
+        nv_wo32(chan->object, chan->user_put, ((val) << 2) + chan->push.vma.offset);  \
 } while (0)
 
 static inline void
 FIRE_RING(struct nouveau_channel *chan)
 {
-        if (NOUVEAU_DMA_DEBUG) {
-                NV_INFO(chan->dev, "Ch%d/0x%08x: PUSH!\n",
-                        chan->id, chan->dma.cur << 2);
-        }
-
         if (chan->dma.cur == chan->dma.put)
                 return;
         chan->accel_done = true;
 
         if (chan->dma.ib_max) {
-                nv50_dma_push(chan, chan->pushbuf_bo, chan->dma.put << 2,
+                nv50_dma_push(chan, chan->push.buffer, chan->dma.put << 2,
                               (chan->dma.cur - chan->dma.put) << 2);
         } else {
                 WRITE_PUT(chan->dma.cur);
@@ -191,4 +181,31 @@ WIND_RING(struct nouveau_channel *chan)
         chan->dma.cur = chan->dma.put;
 }
 
+/* FIFO methods */
+#define NV01_SUBCHAN_OBJECT                                          0x00000000
+#define NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH                          0x00000010
+#define NV84_SUBCHAN_SEMAPHORE_ADDRESS_LOW                           0x00000014
+#define NV84_SUBCHAN_SEMAPHORE_SEQUENCE                              0x00000018
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER                               0x0000001c
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_EQUAL                 0x00000001
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_WRITE_LONG                    0x00000002
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_GEQUAL                0x00000004
+#define NVC0_SUBCHAN_SEMAPHORE_TRIGGER_YIELD                         0x00001000
+#define NV84_SUBCHAN_NOTIFY_INTR                                     0x00000020
+#define NV84_SUBCHAN_WRCACHE_FLUSH                                   0x00000024
+#define NV10_SUBCHAN_REF_CNT                                         0x00000050
+#define NVSW_SUBCHAN_PAGE_FLIP                                       0x00000054
+#define NV11_SUBCHAN_DMA_SEMAPHORE                                   0x00000060
+#define NV11_SUBCHAN_SEMAPHORE_OFFSET                                0x00000064
+#define NV11_SUBCHAN_SEMAPHORE_ACQUIRE                               0x00000068
+#define NV11_SUBCHAN_SEMAPHORE_RELEASE                               0x0000006c
+#define NV40_SUBCHAN_YIELD                                           0x00000080
+
+/* NV_SW object class */
+#define NV_SW_DMA_VBLSEM                                             0x0000018c
+#define NV_SW_VBLSEM_OFFSET                                          0x00000400
+#define NV_SW_VBLSEM_RELEASE_VALUE                                   0x00000404
+#define NV_SW_VBLSEM_RELEASE                                         0x00000408
+#define NV_SW_PAGE_FLIP                                              0x00000500
+
 #endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index e754aa32edf1..72266ae91fa1 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dp.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dp.c
@@ -23,164 +23,37 @@
  */
 
 #include "drmP.h"
+#include "drm_dp_helper.h"
 
-#include "nouveau_drv.h"
-#include "nouveau_i2c.h"
+#include "nouveau_drm.h"
 #include "nouveau_connector.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
-#include "nouveau_gpio.h"
 
-/******************************************************************************
- * aux channel util functions
- *****************************************************************************/
-#define AUX_DBG(fmt, args...) do {                                             \
-        if (nouveau_reg_debug & NOUVEAU_REG_DEBUG_AUXCH) {                     \
-                NV_PRINTK(KERN_DEBUG, dev, "AUXCH(%d): " fmt, ch, ##args);     \
-        }                                                                      \
-} while (0)
-#define AUX_ERR(fmt, args...) NV_ERROR(dev, "AUXCH(%d): " fmt, ch, ##args)
-
-static void
-auxch_fini(struct drm_device *dev, int ch)
-{
-        nv_mask(dev, 0x00e4e4 + (ch * 0x50), 0x00310000, 0x00000000);
-}
-
-static int
-auxch_init(struct drm_device *dev, int ch)
-{
-        const u32 unksel = 1; /* nfi which to use, or if it matters.. */
-        const u32 ureq = unksel ? 0x00100000 : 0x00200000;
-        const u32 urep = unksel ? 0x01000000 : 0x02000000;
-        u32 ctrl, timeout;
-
-        /* wait up to 1ms for any previous transaction to be done... */
-        timeout = 1000;
-        do {
-                ctrl = nv_rd32(dev, 0x00e4e4 + (ch * 0x50));
-                udelay(1);
-                if (!timeout--) {
-                        AUX_ERR("begin idle timeout 0x%08x", ctrl);
-                        return -EBUSY;
-                }
-        } while (ctrl & 0x03010000);
-
-        /* set some magic, and wait up to 1ms for it to appear */
-        nv_mask(dev, 0x00e4e4 + (ch * 0x50), 0x00300000, ureq);
-        timeout = 1000;
-        do {
-                ctrl = nv_rd32(dev, 0x00e4e4 + (ch * 0x50));
-                udelay(1);
-                if (!timeout--) {
-                        AUX_ERR("magic wait 0x%08x\n", ctrl);
-                        auxch_fini(dev, ch);
-                        return -EBUSY;
-                }
-        } while ((ctrl & 0x03000000) != urep);
-
-        return 0;
-}
-
-static int
-auxch_tx(struct drm_device *dev, int ch, u8 type, u32 addr, u8 *data, u8 size)
-{
-        u32 ctrl, stat, timeout, retries;
-        u32 xbuf[4] = {};
-        int ret, i;
-
-        AUX_DBG("%d: 0x%08x %d\n", type, addr, size);
-
-        ret = auxch_init(dev, ch);
-        if (ret)
-                goto out;
-
-        stat = nv_rd32(dev, 0x00e4e8 + (ch * 0x50));
-        if (!(stat & 0x10000000)) {
-                AUX_DBG("sink not detected\n");
-                ret = -ENXIO;
-                goto out;
-        }
-
-        if (!(type & 1)) {
-                memcpy(xbuf, data, size);
-                for (i = 0; i < 16; i += 4) {
-                        AUX_DBG("wr 0x%08x\n", xbuf[i / 4]);
-                        nv_wr32(dev, 0x00e4c0 + (ch * 0x50) + i, xbuf[i / 4]);
-                }
-        }
-
-        ctrl  = nv_rd32(dev, 0x00e4e4 + (ch * 0x50));
-        ctrl &= ~0x0001f0ff;
-        ctrl |= type << 12;
-        ctrl |= size - 1;
-        nv_wr32(dev, 0x00e4e0 + (ch * 0x50), addr);
-
-        /* retry transaction a number of times on failure... */
-        ret = -EREMOTEIO;
-        for (retries = 0; retries < 32; retries++) {
-                /* reset, and delay a while if this is a retry */
-                nv_wr32(dev, 0x00e4e4 + (ch * 0x50), 0x80000000 | ctrl);
-                nv_wr32(dev, 0x00e4e4 + (ch * 0x50), 0x00000000 | ctrl);
-                if (retries)
-                        udelay(400);
-
-                /* transaction request, wait up to 1ms for it to complete */
-                nv_wr32(dev, 0x00e4e4 + (ch * 0x50), 0x00010000 | ctrl);
-
-                timeout = 1000;
-                do {
-                        ctrl = nv_rd32(dev, 0x00e4e4 + (ch * 0x50));
-                        udelay(1);
-                        if (!timeout--) {
-                                AUX_ERR("tx req timeout 0x%08x\n", ctrl);
-                                goto out;
-                        }
-                } while (ctrl & 0x00010000);
-
-                /* read status, and check if transaction completed ok */
-                stat = nv_mask(dev, 0x00e4e8 + (ch * 0x50), 0, 0);
-                if (!(stat & 0x000f0f00)) {
-                        ret = 0;
-                        break;
-                }
-
-                AUX_DBG("%02d 0x%08x 0x%08x\n", retries, ctrl, stat);
-        }
-
-        if (type & 1) {
-                for (i = 0; i < 16; i += 4) {
-                        xbuf[i / 4] = nv_rd32(dev, 0x00e4d0 + (ch * 0x50) + i);
-                        AUX_DBG("rd 0x%08x\n", xbuf[i / 4]);
-                }
-                memcpy(data, xbuf, size);
-        }
-
-out:
-        auxch_fini(dev, ch);
-        return ret;
-}
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
 
 u8 *
-nouveau_dp_bios_data(struct drm_device *dev, struct dcb_entry *dcb, u8 **entry)
+nouveau_dp_bios_data(struct drm_device *dev, struct dcb_output *dcb, u8 **entry)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct bit_entry d;
         u8 *table;
         int i;
 
         if (bit_table(dev, 'd', &d)) {
-                NV_ERROR(dev, "BIT 'd' table not found\n");
+                NV_ERROR(drm, "BIT 'd' table not found\n");
                 return NULL;
         }
 
         if (d.version != 1) {
-                NV_ERROR(dev, "BIT 'd' table version %d unknown\n", d.version);
+                NV_ERROR(drm, "BIT 'd' table version %d unknown\n", d.version);
                 return NULL;
         }
 
         table = ROMPTR(dev, d.data[0]);
         if (!table) {
-                NV_ERROR(dev, "displayport table pointer invalid\n");
+                NV_ERROR(drm, "displayport table pointer invalid\n");
                 return NULL;
         }
 
@@ -191,7 +64,7 @@ nouveau_dp_bios_data(struct drm_device *dev, struct dcb_entry *dcb, u8 **entry)
         case 0x40:
                 break;
         default:
-                NV_ERROR(dev, "displayport table 0x%02x unknown\n", table[0]);
+                NV_ERROR(drm, "displayport table 0x%02x unknown\n", table[0]);
                 return NULL;
         }
 
@@ -201,7 +74,7 @@ nouveau_dp_bios_data(struct drm_device *dev, struct dcb_entry *dcb, u8 **entry)
                         return table;
         }
 
-        NV_ERROR(dev, "displayport encoder table not found\n");
+        NV_ERROR(drm, "displayport encoder table not found\n");
         return NULL;
 }
 
@@ -209,9 +82,9 @@ nouveau_dp_bios_data(struct drm_device *dev, struct dcb_entry *dcb, u8 **entry)
  * link training
  *****************************************************************************/
 struct dp_state {
+        struct nouveau_i2c_port *auxch;
         struct dp_train_func *func;
-        struct dcb_entry *dcb;
-        int auxch;
+        struct dcb_output *dcb;
         int crtc;
         u8 *dpcd;
         int link_nr;
@@ -223,9 +96,10 @@ struct dp_state {
 static void
 dp_set_link_config(struct drm_device *dev, struct dp_state *dp)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 sink[2];
 
-        NV_DEBUG_KMS(dev, "%d lanes at %d KB/s\n", dp->link_nr, dp->link_bw);
+        NV_DEBUG(drm, "%d lanes at %d KB/s\n", dp->link_nr, dp->link_bw);
 
         /* set desired link configuration on the source */
         dp->func->link_set(dev, dp->dcb, dp->crtc, dp->link_nr, dp->link_bw,
@@ -237,27 +111,29 @@ dp_set_link_config(struct drm_device *dev, struct dp_state *dp)
         if (dp->dpcd[2] & DP_ENHANCED_FRAME_CAP)
                 sink[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
 
-        auxch_tx(dev, dp->auxch, 8, DP_LINK_BW_SET, sink, 2);
+        nv_wraux(dp->auxch, DP_LINK_BW_SET, sink, 2);
 }
 
 static void
 dp_set_training_pattern(struct drm_device *dev, struct dp_state *dp, u8 pattern)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 sink_tp;
 
-        NV_DEBUG_KMS(dev, "training pattern %d\n", pattern);
+        NV_DEBUG(drm, "training pattern %d\n", pattern);
 
         dp->func->train_set(dev, dp->dcb, pattern);
 
-        auxch_tx(dev, dp->auxch, 9, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
+        nv_rdaux(dp->auxch, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
         sink_tp &= ~DP_TRAINING_PATTERN_MASK;
         sink_tp |= pattern;
-        auxch_tx(dev, dp->auxch, 8, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
+        nv_wraux(dp->auxch, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
 }
 
 static int
 dp_link_train_commit(struct drm_device *dev, struct dp_state *dp)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int i;
 
         for (i = 0; i < dp->link_nr; i++) {
@@ -271,25 +147,26 @@ dp_link_train_commit(struct drm_device *dev, struct dp_state *dp)
                 if ((lpre << 3) == DP_TRAIN_PRE_EMPHASIS_9_5)
                         dp->conf[i] |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
 
-                NV_DEBUG_KMS(dev, "config lane %d %02x\n", i, dp->conf[i]);
+                NV_DEBUG(drm, "config lane %d %02x\n", i, dp->conf[i]);
                 dp->func->train_adj(dev, dp->dcb, i, lvsw, lpre);
         }
 
-        return auxch_tx(dev, dp->auxch, 8, DP_TRAINING_LANE0_SET, dp->conf, 4);
+        return nv_wraux(dp->auxch, DP_TRAINING_LANE0_SET, dp->conf, 4);
 }
 
 static int
 dp_link_train_update(struct drm_device *dev, struct dp_state *dp, u32 delay)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int ret;
 
         udelay(delay);
 
-        ret = auxch_tx(dev, dp->auxch, 9, DP_LANE0_1_STATUS, dp->stat, 6);
+        ret = nv_rdaux(dp->auxch, DP_LANE0_1_STATUS, dp->stat, 6);
         if (ret)
                 return ret;
 
-        NV_DEBUG_KMS(dev, "status %*ph\n", 6, dp->stat);
+        NV_DEBUG(drm, "status %*ph\n", 6, dp->stat);
         return 0;
 }
 
@@ -407,7 +284,7 @@ dp_link_train_fini(struct drm_device *dev, struct dp_state *dp)
         nouveau_bios_run_init_table(dev, script, dp->dcb, dp->crtc);
 }
 
-bool
+static bool
 nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
                       struct dp_train_func *func)
 {
@@ -416,19 +293,20 @@ nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
         struct nouveau_connector *nv_connector =
                 nouveau_encoder_connector_get(nv_encoder);
         struct drm_device *dev = encoder->dev;
-        struct nouveau_i2c_chan *auxch;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
         const u32 bw_list[] = { 270000, 162000, 0 };
         const u32 *link_bw = bw_list;
         struct dp_state dp;
 
-        auxch = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
-        if (!auxch)
+        dp.auxch = i2c->find(i2c, nv_encoder->dcb->i2c_index);
+        if (!dp.auxch)
                 return false;
 
         dp.func = func;
         dp.dcb = nv_encoder->dcb;
         dp.crtc = nv_crtc->index;
-        dp.auxch = auxch->drive;
         dp.dpcd = nv_encoder->dp.dpcd;
 
         /* adjust required bandwidth for 8B/10B coding overhead */
@@ -438,7 +316,7 @@ nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
          * we take during link training (DP_SET_POWER is one), we need
          * to ignore them for the moment to avoid races.
          */
-        nouveau_gpio_irq(dev, 0, nv_connector->hpd, 0xff, false);
+        gpio->irq(gpio, 0, nv_connector->hpd, 0xff, false);
 
         /* enable down-spreading, if possible */
         dp_set_downspread(dev, &dp, nv_encoder->dp.dpcd[3] & 1);
@@ -481,7 +359,7 @@ nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
         dp_link_train_fini(dev, &dp);
 
         /* re-enable hotplug detect */
-        nouveau_gpio_irq(dev, 0, nv_connector->hpd, 0xff, true);
+        gpio->irq(gpio, 0, nv_connector->hpd, 0xff, true);
         return true;
 }
 
@@ -490,10 +368,12 @@ nouveau_dp_dpms(struct drm_encoder *encoder, int mode, u32 datarate,
                 struct dp_train_func *func)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct nouveau_i2c_chan *auxch;
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+        struct nouveau_i2c_port *auxch;
         u8 status;
 
-        auxch = nouveau_i2c_find(encoder->dev, nv_encoder->dcb->i2c_index);
+        auxch = i2c->find(i2c, nv_encoder->dcb->i2c_index);
         if (!auxch)
                 return;
 
@@ -502,27 +382,28 @@ nouveau_dp_dpms(struct drm_encoder *encoder, int mode, u32 datarate,
         else
                 status = DP_SET_POWER_D3;
 
-        nouveau_dp_auxch(auxch, 8, DP_SET_POWER, &status, 1);
+        nv_wraux(auxch, DP_SET_POWER, &status, 1);
 
         if (mode == DRM_MODE_DPMS_ON)
                 nouveau_dp_link_train(encoder, datarate, func);
 }
 
 static void
-nouveau_dp_probe_oui(struct drm_device *dev, struct nouveau_i2c_chan *auxch,
+nouveau_dp_probe_oui(struct drm_device *dev, struct nouveau_i2c_port *auxch,
                      u8 *dpcd)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 buf[3];
 
         if (!(dpcd[DP_DOWN_STREAM_PORT_COUNT] & DP_OUI_SUPPORT))
                 return;
 
-        if (!auxch_tx(dev, auxch->drive, 9, DP_SINK_OUI, buf, 3))
-                NV_DEBUG_KMS(dev, "Sink OUI: %02hx%02hx%02hx\n",
+        if (!nv_rdaux(auxch, DP_SINK_OUI, buf, 3))
+                NV_DEBUG(drm, "Sink OUI: %02hx%02hx%02hx\n",
                              buf[0], buf[1], buf[2]);
 
-        if (!auxch_tx(dev, auxch->drive, 9, DP_BRANCH_OUI, buf, 3))
-                NV_DEBUG_KMS(dev, "Branch OUI: %02hx%02hx%02hx\n",
+        if (!nv_rdaux(auxch, DP_BRANCH_OUI, buf, 3))
+                NV_DEBUG(drm, "Branch OUI: %02hx%02hx%02hx\n",
                              buf[0], buf[1], buf[2]);
 
 }
@@ -532,24 +413,26 @@ nouveau_dp_detect(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
-        struct nouveau_i2c_chan *auxch;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+        struct nouveau_i2c_port *auxch;
         u8 *dpcd = nv_encoder->dp.dpcd;
         int ret;
 
-        auxch = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
+        auxch = i2c->find(i2c, nv_encoder->dcb->i2c_index);
         if (!auxch)
                 return false;
 
-        ret = auxch_tx(dev, auxch->drive, 9, DP_DPCD_REV, dpcd, 8);
+        ret = nv_rdaux(auxch, DP_DPCD_REV, dpcd, 8);
         if (ret)
                 return false;
 
         nv_encoder->dp.link_bw = 27000 * dpcd[1];
         nv_encoder->dp.link_nr = dpcd[2] & DP_MAX_LANE_COUNT_MASK;
 
-        NV_DEBUG_KMS(dev, "display: %dx%d dpcd 0x%02x\n",
+        NV_DEBUG(drm, "display: %dx%d dpcd 0x%02x\n",
                      nv_encoder->dp.link_nr, nv_encoder->dp.link_bw, dpcd[0]);
-        NV_DEBUG_KMS(dev, "encoder: %dx%d\n",
+        NV_DEBUG(drm, "encoder: %dx%d\n",
                      nv_encoder->dcb->dpconf.link_nr,
                      nv_encoder->dcb->dpconf.link_bw);
 
@@ -558,65 +441,10 @@ nouveau_dp_detect(struct drm_encoder *encoder)
         if (nv_encoder->dcb->dpconf.link_bw < nv_encoder->dp.link_bw)
                 nv_encoder->dp.link_bw = nv_encoder->dcb->dpconf.link_bw;
 
-        NV_DEBUG_KMS(dev, "maximum: %dx%d\n",
+        NV_DEBUG(drm, "maximum: %dx%d\n",
                      nv_encoder->dp.link_nr, nv_encoder->dp.link_bw);
 
         nouveau_dp_probe_oui(dev, auxch, dpcd);
 
         return true;
 }
-
-int
-nouveau_dp_auxch(struct nouveau_i2c_chan *auxch, int cmd, int addr,
-                 uint8_t *data, int data_nr)
-{
-        return auxch_tx(auxch->dev, auxch->drive, cmd, addr, data, data_nr);
-}
-
-static int
-nouveau_dp_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
-{
-        struct nouveau_i2c_chan *auxch = (struct nouveau_i2c_chan *)adap;
-        struct i2c_msg *msg = msgs;
-        int ret, mcnt = num;
-
-        while (mcnt--) {
-                u8 remaining = msg->len;
-                u8 *ptr = msg->buf;
-
-                while (remaining) {
-                        u8 cnt = (remaining > 16) ? 16 : remaining;
-                        u8 cmd;
-
-                        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;
-
-                        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_drm.c b/drivers/gpu/drm/nouveau/nouveau_drm.c
new file mode 100644
index 000000000000..e96507e11488
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_drm.c
@@ -0,0 +1,693 @@
+/*
+ * Copyright 2012 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 <linux/console.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+
+#include <core/device.h>
+#include <core/client.h>
+#include <core/gpuobj.h>
+#include <core/class.h>
+
+#include <subdev/device.h>
+#include <subdev/vm.h>
+
+#include "nouveau_drm.h"
+#include "nouveau_irq.h"
+#include "nouveau_dma.h"
+#include "nouveau_ttm.h"
+#include "nouveau_gem.h"
+#include "nouveau_agp.h"
+#include "nouveau_vga.h"
+#include "nouveau_pm.h"
+#include "nouveau_acpi.h"
+#include "nouveau_bios.h"
+#include "nouveau_ioctl.h"
+#include "nouveau_abi16.h"
+#include "nouveau_fbcon.h"
+#include "nouveau_fence.h"
+
+#include "nouveau_ttm.h"
+
+MODULE_PARM_DESC(config, "option string to pass to driver core");
+static char *nouveau_config;
+module_param_named(config, nouveau_config, charp, 0400);
+
+MODULE_PARM_DESC(debug, "debug string to pass to driver core");
+static char *nouveau_debug;
+module_param_named(debug, nouveau_debug, charp, 0400);
+
+MODULE_PARM_DESC(noaccel, "disable kernel/abi16 acceleration");
+static int nouveau_noaccel = 0;
+module_param_named(noaccel, nouveau_noaccel, int, 0400);
+
+MODULE_PARM_DESC(modeset, "enable driver");
+static int nouveau_modeset = -1;
+module_param_named(modeset, nouveau_modeset, int, 0400);
+
+static struct drm_driver driver;
+
+static u64
+nouveau_name(struct pci_dev *pdev)
+{
+        u64 name = (u64)pci_domain_nr(pdev->bus) << 32;
+        name |= pdev->bus->number << 16;
+        name |= PCI_SLOT(pdev->devfn) << 8;
+        return name | PCI_FUNC(pdev->devfn);
+}
+
+static int
+nouveau_cli_create(struct pci_dev *pdev, const char *name,
+                   int size, void **pcli)
+{
+        struct nouveau_cli *cli;
+        int ret;
+
+        ret = nouveau_client_create_(name, nouveau_name(pdev), nouveau_config,
+                                     nouveau_debug, size, pcli);
+        cli = *pcli;
+        if (ret)
+                return ret;
+
+        mutex_init(&cli->mutex);
+        return 0;
+}
+
+static void
+nouveau_cli_destroy(struct nouveau_cli *cli)
+{
+        struct nouveau_object *client = nv_object(cli);
+        nouveau_vm_ref(NULL, &cli->base.vm, NULL);
+        nouveau_client_fini(&cli->base, false);
+        atomic_set(&client->refcount, 1);
+        nouveau_object_ref(NULL, &client);
+}
+
+static void
+nouveau_accel_fini(struct nouveau_drm *drm)
+{
+        nouveau_gpuobj_ref(NULL, &drm->notify);
+        nouveau_channel_del(&drm->channel);
+        nouveau_channel_del(&drm->cechan);
+        if (drm->fence)
+                nouveau_fence(drm)->dtor(drm);
+}
+
+static void
+nouveau_accel_init(struct nouveau_drm *drm)
+{
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_object *object;
+        u32 arg0, arg1;
+        int ret;
+
+        if (nouveau_noaccel)
+                return;
+
+        /* initialise synchronisation routines */
+        if      (device->card_type < NV_10) ret = nv04_fence_create(drm);
+        else if (device->chipset   <  0x84) ret = nv10_fence_create(drm);
+        else if (device->card_type < NV_C0) ret = nv84_fence_create(drm);
+        else                                ret = nvc0_fence_create(drm);
+        if (ret) {
+                NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret);
+                nouveau_accel_fini(drm);
+                return;
+        }
+
+        if (device->card_type >= NV_E0) {
+                ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE,
+                                          NVDRM_CHAN + 1,
+                                          NVE0_CHANNEL_IND_ENGINE_CE0 |
+                                          NVE0_CHANNEL_IND_ENGINE_CE1, 0,
+                                          &drm->cechan);
+                if (ret)
+                        NV_ERROR(drm, "failed to create ce channel, %d\n", ret);
+
+                arg0 = NVE0_CHANNEL_IND_ENGINE_GR;
+                arg1 = 0;
+        } else {
+                arg0 = NvDmaFB;
+                arg1 = NvDmaTT;
+        }
+
+        ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE, NVDRM_CHAN,
+                                  arg0, arg1, &drm->channel);
+        if (ret) {
+                NV_ERROR(drm, "failed to create kernel channel, %d\n", ret);
+                nouveau_accel_fini(drm);
+                return;
+        }
+
+        if (device->card_type < NV_C0) {
+                ret = nouveau_gpuobj_new(drm->device, NULL, 32, 0, 0,
+                                        &drm->notify);
+                if (ret) {
+                        NV_ERROR(drm, "failed to allocate notifier, %d\n", ret);
+                        nouveau_accel_fini(drm);
+                        return;
+                }
+
+                ret = nouveau_object_new(nv_object(drm),
+                                         drm->channel->handle, NvNotify0,
+                                         0x003d, &(struct nv_dma_class) {
+                                                .flags = NV_DMA_TARGET_VRAM |
+                                                         NV_DMA_ACCESS_RDWR,
+                                                .start = drm->notify->addr,
+                                                .limit = drm->notify->addr + 31
+                                                }, sizeof(struct nv_dma_class),
+                                         &object);
+                if (ret) {
+                        nouveau_accel_fini(drm);
+                        return;
+                }
+        }
+
+
+        nouveau_bo_move_init(drm);
+}
+
+static int __devinit
+nouveau_drm_probe(struct pci_dev *pdev, const struct pci_device_id *pent)
+{
+        struct nouveau_device *device;
+        struct apertures_struct *aper;
+        bool boot = false;
+        int ret;
+
+        /* remove conflicting drivers (vesafb, efifb etc) */
+        aper = alloc_apertures(3);
+        if (!aper)
+                return -ENOMEM;
+
+        aper->ranges[0].base = pci_resource_start(pdev, 1);
+        aper->ranges[0].size = pci_resource_len(pdev, 1);
+        aper->count = 1;
+
+        if (pci_resource_len(pdev, 2)) {
+                aper->ranges[aper->count].base = pci_resource_start(pdev, 2);
+                aper->ranges[aper->count].size = pci_resource_len(pdev, 2);
+                aper->count++;
+        }
+
+        if (pci_resource_len(pdev, 3)) {
+                aper->ranges[aper->count].base = pci_resource_start(pdev, 3);
+                aper->ranges[aper->count].size = pci_resource_len(pdev, 3);
+                aper->count++;
+        }
+
+#ifdef CONFIG_X86
+        boot = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
+#endif
+        remove_conflicting_framebuffers(aper, "nouveaufb", boot);
+
+        ret = nouveau_device_create(pdev, nouveau_name(pdev), pci_name(pdev),
+                                    nouveau_config, nouveau_debug, &device);
+        if (ret)
+                return ret;
+
+        pci_set_master(pdev);
+
+        ret = drm_get_pci_dev(pdev, pent, &driver);
+        if (ret) {
+                nouveau_object_ref(NULL, (struct nouveau_object **)&device);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int
+nouveau_drm_load(struct drm_device *dev, unsigned long flags)
+{
+        struct pci_dev *pdev = dev->pdev;
+        struct nouveau_device *device;
+        struct nouveau_drm *drm;
+        int ret;
+
+        ret = nouveau_cli_create(pdev, "DRM", sizeof(*drm), (void**)&drm);
+        if (ret)
+                return ret;
+
+        dev->dev_private = drm;
+        drm->dev = dev;
+
+        INIT_LIST_HEAD(&drm->clients);
+        spin_lock_init(&drm->tile.lock);
+
+        /* make sure AGP controller is in a consistent state before we
+         * (possibly) execute vbios init tables (see nouveau_agp.h)
+         */
+        if (drm_pci_device_is_agp(dev) && dev->agp) {
+                /* dummy device object, doesn't init anything, but allows
+                 * agp code access to registers
+                 */
+                ret = nouveau_object_new(nv_object(drm), NVDRM_CLIENT,
+                                         NVDRM_DEVICE, 0x0080,
+                                         &(struct nv_device_class) {
+                                                .device = ~0,
+                                                .disable =
+                                                 ~(NV_DEVICE_DISABLE_MMIO |
+                                                   NV_DEVICE_DISABLE_IDENTIFY),
+                                                .debug0 = ~0,
+                                         }, sizeof(struct nv_device_class),
+                                         &drm->device);
+                if (ret)
+                        goto fail_device;
+
+                nouveau_agp_reset(drm);
+                nouveau_object_del(nv_object(drm), NVDRM_CLIENT, NVDRM_DEVICE);
+        }
+
+        ret = nouveau_object_new(nv_object(drm), NVDRM_CLIENT, NVDRM_DEVICE,
+                                 0x0080, &(struct nv_device_class) {
+                                        .device = ~0,
+                                        .disable = 0,
+                                        .debug0 = 0,
+                                 }, sizeof(struct nv_device_class),
+                                 &drm->device);
+        if (ret)
+                goto fail_device;
+
+        /* workaround an odd issue on nvc1 by disabling the device's
+         * nosnoop capability.  hopefully won't cause issues until a
+         * better fix is found - assuming there is one...
+         */
+        device = nv_device(drm->device);
+        if (nv_device(drm->device)->chipset == 0xc1)
+                nv_mask(device, 0x00088080, 0x00000800, 0x00000000);
+
+        nouveau_vga_init(drm);
+        nouveau_agp_init(drm);
+
+        if (device->card_type >= NV_50) {
+                ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40),
+                                     0x1000, &drm->client.base.vm);
+                if (ret)
+                        goto fail_device;
+        }
+
+        ret = nouveau_ttm_init(drm);
+        if (ret)
+                goto fail_ttm;
+
+        ret = nouveau_bios_init(dev);
+        if (ret)
+                goto fail_bios;
+
+        ret = nouveau_irq_init(dev);
+        if (ret)
+                goto fail_irq;
+
+        ret = nouveau_display_create(dev);
+        if (ret)
+                goto fail_dispctor;
+
+        if (dev->mode_config.num_crtc) {
+                ret = nouveau_display_init(dev);
+                if (ret)
+                        goto fail_dispinit;
+        }
+
+        nouveau_pm_init(dev);
+
+        nouveau_accel_init(drm);
+        nouveau_fbcon_init(dev);
+        return 0;
+
+fail_dispinit:
+        nouveau_display_destroy(dev);
+fail_dispctor:
+        nouveau_irq_fini(dev);
+fail_irq:
+        nouveau_bios_takedown(dev);
+fail_bios:
+        nouveau_ttm_fini(drm);
+fail_ttm:
+        nouveau_agp_fini(drm);
+        nouveau_vga_fini(drm);
+fail_device:
+        nouveau_cli_destroy(&drm->client);
+        return ret;
+}
+
+static int
+nouveau_drm_unload(struct drm_device *dev)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
+        nouveau_fbcon_fini(dev);
+        nouveau_accel_fini(drm);
+
+        nouveau_pm_fini(dev);
+
+        nouveau_display_fini(dev);
+        nouveau_display_destroy(dev);
+
+        nouveau_irq_fini(dev);
+        nouveau_bios_takedown(dev);
+
+        nouveau_ttm_fini(drm);
+        nouveau_agp_fini(drm);
+        nouveau_vga_fini(drm);
+
+        nouveau_cli_destroy(&drm->client);
+        return 0;
+}
+
+static void
+nouveau_drm_remove(struct pci_dev *pdev)
+{
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_object *device;
+
+        device = drm->client.base.device;
+        drm_put_dev(dev);
+
+        nouveau_object_ref(NULL, &device);
+        nouveau_object_debug();
+}
+
+int
+nouveau_drm_suspend(struct pci_dev *pdev, pm_message_t pm_state)
+{
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_cli *cli;
+        int ret;
+
+        if (dev->switch_power_state == DRM_SWITCH_POWER_OFF ||
+            pm_state.event == PM_EVENT_PRETHAW)
+                return 0;
+
+        NV_INFO(drm, "suspending fbcon...\n");
+        nouveau_fbcon_set_suspend(dev, 1);
+
+        NV_INFO(drm, "suspending display...\n");
+        ret = nouveau_display_suspend(dev);
+        if (ret)
+                return ret;
+
+        NV_INFO(drm, "evicting buffers...\n");
+        ttm_bo_evict_mm(&drm->ttm.bdev, TTM_PL_VRAM);
+
+        if (drm->fence && nouveau_fence(drm)->suspend) {
+                if (!nouveau_fence(drm)->suspend(drm))
+                        return -ENOMEM;
+        }
+
+        NV_INFO(drm, "suspending client object trees...\n");
+        list_for_each_entry(cli, &drm->clients, head) {
+                ret = nouveau_client_fini(&cli->base, true);
+                if (ret)
+                        goto fail_client;
+        }
+
+        ret = nouveau_client_fini(&drm->client.base, true);
+        if (ret)
+                goto fail_client;
+
+        nouveau_agp_fini(drm);
+
+        pci_save_state(pdev);
+        if (pm_state.event == PM_EVENT_SUSPEND) {
+                pci_disable_device(pdev);
+                pci_set_power_state(pdev, PCI_D3hot);
+        }
+
+        return 0;
+
+fail_client:
+        list_for_each_entry_continue_reverse(cli, &drm->clients, head) {
+                nouveau_client_init(&cli->base);
+        }
+
+        NV_INFO(drm, "resuming display...\n");
+        nouveau_display_resume(dev);
+        return ret;
+}
+
+int
+nouveau_drm_resume(struct pci_dev *pdev)
+{
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_cli *cli;
+        int ret;
+
+        if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
+                return 0;
+
+        NV_INFO(drm, "re-enabling device...\n");
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
+        pci_set_master(pdev);
+
+        nouveau_agp_reset(drm);
+
+        NV_INFO(drm, "resuming client object trees...\n");
+        nouveau_client_init(&drm->client.base);
+        nouveau_agp_init(drm);
+
+        list_for_each_entry(cli, &drm->clients, head) {
+                nouveau_client_init(&cli->base);
+        }
+
+        if (drm->fence && nouveau_fence(drm)->resume)
+                nouveau_fence(drm)->resume(drm);
+
+        nouveau_run_vbios_init(dev);
+        nouveau_irq_postinstall(dev);
+        nouveau_pm_resume(dev);
+
+        NV_INFO(drm, "resuming display...\n");
+        nouveau_display_resume(dev);
+        return 0;
+}
+
+static int
+nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv)
+{
+        struct pci_dev *pdev = dev->pdev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_cli *cli;
+        char name[16];
+        int ret;
+
+        snprintf(name, sizeof(name), "%d", fpriv->pid);
+
+        ret = nouveau_cli_create(pdev, name, sizeof(*cli), (void **)&cli);
+        if (ret)
+                return ret;
+
+        if (nv_device(drm->device)->card_type >= NV_50) {
+                ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40),
+                                     0x1000, &cli->base.vm);
+                if (ret) {
+                        nouveau_cli_destroy(cli);
+                        return ret;
+                }
+        }
+
+        fpriv->driver_priv = cli;
+
+        mutex_lock(&drm->client.mutex);
+        list_add(&cli->head, &drm->clients);
+        mutex_unlock(&drm->client.mutex);
+        return 0;
+}
+
+static void
+nouveau_drm_preclose(struct drm_device *dev, struct drm_file *fpriv)
+{
+        struct nouveau_cli *cli = nouveau_cli(fpriv);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
+        if (cli->abi16)
+                nouveau_abi16_fini(cli->abi16);
+
+        mutex_lock(&drm->client.mutex);
+        list_del(&cli->head);
+        mutex_unlock(&drm->client.mutex);
+}
+
+static void
+nouveau_drm_postclose(struct drm_device *dev, struct drm_file *fpriv)
+{
+        struct nouveau_cli *cli = nouveau_cli(fpriv);
+        nouveau_cli_destroy(cli);
+}
+
+static struct drm_ioctl_desc
+nouveau_ioctls[] = {
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GETPARAM, nouveau_abi16_ioctl_getparam, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_SETPARAM, nouveau_abi16_ioctl_setparam, DRM_UNLOCKED|DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_ALLOC, nouveau_abi16_ioctl_channel_alloc, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_FREE, nouveau_abi16_ioctl_channel_free, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GROBJ_ALLOC, nouveau_abi16_ioctl_grobj_alloc, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_NOTIFIEROBJ_ALLOC, nouveau_abi16_ioctl_notifierobj_alloc, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GPUOBJ_FREE, nouveau_abi16_ioctl_gpuobj_free, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_NEW, nouveau_gem_ioctl_new, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_PUSHBUF, nouveau_gem_ioctl_pushbuf, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_PREP, nouveau_gem_ioctl_cpu_prep, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_FINI, nouveau_gem_ioctl_cpu_fini, DRM_UNLOCKED|DRM_AUTH),
+        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_INFO, nouveau_gem_ioctl_info, DRM_UNLOCKED|DRM_AUTH),
+};
+
+static const struct file_operations
+nouveau_driver_fops = {
+        .owner = THIS_MODULE,
+        .open = drm_open,
+        .release = drm_release,
+        .unlocked_ioctl = drm_ioctl,
+        .mmap = nouveau_ttm_mmap,
+        .poll = drm_poll,
+        .fasync = drm_fasync,
+        .read = drm_read,
+#if defined(CONFIG_COMPAT)
+        .compat_ioctl = nouveau_compat_ioctl,
+#endif
+        .llseek = noop_llseek,
+};
+
+static struct drm_driver
+driver = {
+        .driver_features =
+                DRIVER_USE_AGP | DRIVER_PCI_DMA | DRIVER_SG |
+                DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM |
+                DRIVER_MODESET | DRIVER_PRIME,
+
+        .load = nouveau_drm_load,
+        .unload = nouveau_drm_unload,
+        .open = nouveau_drm_open,
+        .preclose = nouveau_drm_preclose,
+        .postclose = nouveau_drm_postclose,
+        .lastclose = nouveau_vga_lastclose,
+
+        .irq_preinstall = nouveau_irq_preinstall,
+        .irq_postinstall = nouveau_irq_postinstall,
+        .irq_uninstall = nouveau_irq_uninstall,
+        .irq_handler = nouveau_irq_handler,
+
+        .get_vblank_counter = drm_vblank_count,
+        .enable_vblank = nouveau_vblank_enable,
+        .disable_vblank = nouveau_vblank_disable,
+
+        .ioctls = nouveau_ioctls,
+        .fops = &nouveau_driver_fops,
+
+        .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
+        .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
+        .gem_prime_export = nouveau_gem_prime_export,
+        .gem_prime_import = nouveau_gem_prime_import,
+
+        .gem_init_object = nouveau_gem_object_new,
+        .gem_free_object = nouveau_gem_object_del,
+        .gem_open_object = nouveau_gem_object_open,
+        .gem_close_object = nouveau_gem_object_close,
+
+        .dumb_create = nouveau_display_dumb_create,
+        .dumb_map_offset = nouveau_display_dumb_map_offset,
+        .dumb_destroy = nouveau_display_dumb_destroy,
+
+        .name = DRIVER_NAME,
+        .desc = DRIVER_DESC,
+#ifdef GIT_REVISION
+        .date = GIT_REVISION,
+#else
+        .date = DRIVER_DATE,
+#endif
+        .major = DRIVER_MAJOR,
+        .minor = DRIVER_MINOR,
+        .patchlevel = DRIVER_PATCHLEVEL,
+};
+
+static struct pci_device_id
+nouveau_drm_pci_table[] = {
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
+                .class = PCI_BASE_CLASS_DISPLAY << 16,
+                .class_mask  = 0xff << 16,
+        },
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID),
+                .class = PCI_BASE_CLASS_DISPLAY << 16,
+                .class_mask  = 0xff << 16,
+        },
+        {}
+};
+
+static struct pci_driver
+nouveau_drm_pci_driver = {
+        .name = "nouveau",
+        .id_table = nouveau_drm_pci_table,
+        .probe = nouveau_drm_probe,
+        .remove = nouveau_drm_remove,
+        .suspend = nouveau_drm_suspend,
+        .resume = nouveau_drm_resume,
+};
+
+static int __init
+nouveau_drm_init(void)
+{
+        driver.num_ioctls = ARRAY_SIZE(nouveau_ioctls);
+
+        if (nouveau_modeset == -1) {
+#ifdef CONFIG_VGA_CONSOLE
+                if (vgacon_text_force())
+                        nouveau_modeset = 0;
+                else
+#endif
+                        nouveau_modeset = 1;
+        }
+
+        if (!nouveau_modeset)
+                return 0;
+
+        nouveau_register_dsm_handler();
+        return drm_pci_init(&driver, &nouveau_drm_pci_driver);
+}
+
+static void __exit
+nouveau_drm_exit(void)
+{
+        if (!nouveau_modeset)
+                return;
+
+        drm_pci_exit(&driver, &nouveau_drm_pci_driver);
+        nouveau_unregister_dsm_handler();
+}
+
+module_init(nouveau_drm_init);
+module_exit(nouveau_drm_exit);
+
+MODULE_DEVICE_TABLE(pci, nouveau_drm_pci_table);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL and additional rights");
diff --git a/drivers/gpu/drm/nouveau/nouveau_drm.h b/drivers/gpu/drm/nouveau/nouveau_drm.h
new file mode 100644
index 000000000000..3c12e9862e37
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_drm.h
@@ -0,0 +1,144 @@
+#ifndef __NOUVEAU_DRMCLI_H__
+#define __NOUVEAU_DRMCLI_H__
+
+#define DRIVER_AUTHOR           "Nouveau Project"
+#define DRIVER_EMAIL            "nouveau@lists.freedesktop.org"
+
+#define DRIVER_NAME             "nouveau"
+#define DRIVER_DESC             "nVidia Riva/TNT/GeForce/Quadro/Tesla"
+#define DRIVER_DATE             "20120801"
+
+#define DRIVER_MAJOR            1
+#define DRIVER_MINOR            1
+#define DRIVER_PATCHLEVEL       0
+
+#include <core/client.h>
+
+#include <subdev/vm.h>
+
+#include <drmP.h>
+#include <drm/nouveau_drm.h>
+
+#include "ttm/ttm_bo_api.h"
+#include "ttm/ttm_bo_driver.h"
+#include "ttm/ttm_placement.h"
+#include "ttm/ttm_memory.h"
+#include "ttm/ttm_module.h"
+#include "ttm/ttm_page_alloc.h"
+
+struct nouveau_channel;
+
+#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT)
+
+#include "nouveau_fence.h"
+#include "nouveau_bios.h"
+
+struct nouveau_drm_tile {
+        struct nouveau_fence *fence;
+        bool used;
+};
+
+enum nouveau_drm_handle {
+        NVDRM_CLIENT = 0xffffffff,
+        NVDRM_DEVICE = 0xdddddddd,
+        NVDRM_PUSH   = 0xbbbb0000, /* |= client chid */
+        NVDRM_CHAN   = 0xcccc0000, /* |= client chid */
+};
+
+struct nouveau_cli {
+        struct nouveau_client base;
+        struct list_head head;
+        struct mutex mutex;
+        void *abi16;
+};
+
+static inline struct nouveau_cli *
+nouveau_cli(struct drm_file *fpriv)
+{
+        return fpriv ? fpriv->driver_priv : NULL;
+}
+
+struct nouveau_drm {
+        struct nouveau_cli client;
+        struct drm_device *dev;
+
+        struct nouveau_object *device;
+        struct list_head clients;
+
+        struct {
+                enum {
+                        UNKNOWN = 0,
+                        DISABLE = 1,
+                        ENABLED = 2
+                } stat;
+                u32 base;
+                u32 size;
+        } agp;
+
+        /* TTM interface support */
+        struct {
+                struct drm_global_reference mem_global_ref;
+                struct ttm_bo_global_ref bo_global_ref;
+                struct ttm_bo_device bdev;
+                atomic_t validate_sequence;
+                int (*move)(struct nouveau_channel *,
+                            struct ttm_buffer_object *,
+                            struct ttm_mem_reg *, struct ttm_mem_reg *);
+                int mtrr;
+        } ttm;
+
+        /* GEM interface support */
+        struct {
+                u64 vram_available;
+                u64 gart_available;
+        } gem;
+
+        /* synchronisation */
+        void *fence;
+
+        /* context for accelerated drm-internal operations */
+        struct nouveau_channel *cechan;
+        struct nouveau_channel *channel;
+        struct nouveau_gpuobj *notify;
+        struct nouveau_fbdev *fbcon;
+
+        /* nv10-nv40 tiling regions */
+        struct {
+                struct nouveau_drm_tile reg[15];
+                spinlock_t lock;
+        } tile;
+
+        /* modesetting */
+        struct nvbios vbios;
+        struct nouveau_display *display;
+        struct backlight_device *backlight;
+
+        /* power management */
+        struct nouveau_pm *pm;
+};
+
+static inline struct nouveau_drm *
+nouveau_drm(struct drm_device *dev)
+{
+        return dev->dev_private;
+}
+
+static inline struct nouveau_device *
+nouveau_dev(struct drm_device *dev)
+{
+        return nv_device(nouveau_drm(dev)->device);
+}
+
+int nouveau_drm_suspend(struct pci_dev *, pm_message_t);
+int nouveau_drm_resume(struct pci_dev *);
+
+#define NV_FATAL(cli, fmt, args...) nv_fatal((cli), fmt, ##args)
+#define NV_ERROR(cli, fmt, args...) nv_error((cli), fmt, ##args)
+#define NV_WARN(cli, fmt, args...) nv_warn((cli), fmt, ##args)
+#define NV_INFO(cli, fmt, args...) nv_info((cli), fmt, ##args)
+#define NV_DEBUG(cli, fmt, args...) do {                                       \
+        if (drm_debug & DRM_UT_DRIVER)                                         \
+                nv_info((cli), fmt, ##args);                                   \
+} while (0)
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.c b/drivers/gpu/drm/nouveau/nouveau_drv.c
deleted file mode 100644
index 9a36f5f39b06..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_drv.c
+++ /dev/null
@@ -1,513 +0,0 @@
-/*
- * Copyright 2005 Stephane Marchesin.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <linux/console.h>
-#include <linux/module.h>
-
-#include "drmP.h"
-#include "drm.h"
-#include "drm_crtc_helper.h"
-#include "nouveau_drv.h"
-#include "nouveau_abi16.h"
-#include "nouveau_hw.h"
-#include "nouveau_fb.h"
-#include "nouveau_fbcon.h"
-#include "nouveau_pm.h"
-#include "nouveau_fifo.h"
-#include "nv50_display.h"
-
-#include "drm_pciids.h"
-
-MODULE_PARM_DESC(agpmode, "AGP mode (0 to disable AGP)");
-int nouveau_agpmode = -1;
-module_param_named(agpmode, nouveau_agpmode, int, 0400);
-
-MODULE_PARM_DESC(modeset, "Enable kernel modesetting");
-int nouveau_modeset = -1;
-module_param_named(modeset, nouveau_modeset, int, 0400);
-
-MODULE_PARM_DESC(vbios, "Override default VBIOS location");
-char *nouveau_vbios;
-module_param_named(vbios, nouveau_vbios, charp, 0400);
-
-MODULE_PARM_DESC(vram_pushbuf, "Force DMA push buffers to be in VRAM");
-int nouveau_vram_pushbuf;
-module_param_named(vram_pushbuf, nouveau_vram_pushbuf, int, 0400);
-
-MODULE_PARM_DESC(vram_notify, "Force DMA notifiers to be in VRAM");
-int nouveau_vram_notify = 0;
-module_param_named(vram_notify, nouveau_vram_notify, int, 0400);
-
-MODULE_PARM_DESC(vram_type, "Override detected VRAM type");
-char *nouveau_vram_type;
-module_param_named(vram_type, nouveau_vram_type, charp, 0400);
-
-MODULE_PARM_DESC(duallink, "Allow dual-link TMDS (>=GeForce 8)");
-int nouveau_duallink = 1;
-module_param_named(duallink, nouveau_duallink, int, 0400);
-
-MODULE_PARM_DESC(uscript_lvds, "LVDS output script table ID (>=GeForce 8)");
-int nouveau_uscript_lvds = -1;
-module_param_named(uscript_lvds, nouveau_uscript_lvds, int, 0400);
-
-MODULE_PARM_DESC(uscript_tmds, "TMDS output script table ID (>=GeForce 8)");
-int nouveau_uscript_tmds = -1;
-module_param_named(uscript_tmds, nouveau_uscript_tmds, int, 0400);
-
-MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
-int nouveau_ignorelid = 0;
-module_param_named(ignorelid, nouveau_ignorelid, int, 0400);
-
-MODULE_PARM_DESC(noaccel, "Disable all acceleration");
-int nouveau_noaccel = -1;
-module_param_named(noaccel, nouveau_noaccel, int, 0400);
-
-MODULE_PARM_DESC(nofbaccel, "Disable fbcon acceleration");
-int nouveau_nofbaccel = 0;
-module_param_named(nofbaccel, nouveau_nofbaccel, int, 0400);
-
-MODULE_PARM_DESC(force_post, "Force POST");
-int nouveau_force_post = 0;
-module_param_named(force_post, nouveau_force_post, int, 0400);
-
-MODULE_PARM_DESC(override_conntype, "Ignore DCB connector type");
-int nouveau_override_conntype = 0;
-module_param_named(override_conntype, nouveau_override_conntype, int, 0400);
-
-MODULE_PARM_DESC(tv_disable, "Disable TV-out detection");
-int nouveau_tv_disable = 0;
-module_param_named(tv_disable, nouveau_tv_disable, int, 0400);
-
-MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
-                 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, NTSC-M, NTSC-J,\n"
-                 "\t\t\thd480i, hd480p, hd576i, hd576p, hd720p, hd1080i.\n"
-                 "\t\tDefault: PAL\n"
-                 "\t\t*NOTE* Ignored for cards with external TV encoders.");
-char *nouveau_tv_norm;
-module_param_named(tv_norm, nouveau_tv_norm, charp, 0400);
-
-MODULE_PARM_DESC(reg_debug, "Register access debug bitmask:\n"
-                "\t\t0x1 mc, 0x2 video, 0x4 fb, 0x8 extdev,\n"
-                "\t\t0x10 crtc, 0x20 ramdac, 0x40 vgacrtc, 0x80 rmvio,\n"
-                "\t\t0x100 vgaattr, 0x200 EVO (G80+)");
-int nouveau_reg_debug;
-module_param_named(reg_debug, nouveau_reg_debug, int, 0600);
-
-MODULE_PARM_DESC(perflvl, "Performance level (default: boot)");
-char *nouveau_perflvl;
-module_param_named(perflvl, nouveau_perflvl, charp, 0400);
-
-MODULE_PARM_DESC(perflvl_wr, "Allow perflvl changes (warning: dangerous!)");
-int nouveau_perflvl_wr;
-module_param_named(perflvl_wr, nouveau_perflvl_wr, int, 0400);
-
-MODULE_PARM_DESC(msi, "Enable MSI (default: off)");
-int nouveau_msi;
-module_param_named(msi, nouveau_msi, int, 0400);
-
-MODULE_PARM_DESC(ctxfw, "Use external HUB/GPC ucode (fermi)");
-int nouveau_ctxfw;
-module_param_named(ctxfw, nouveau_ctxfw, int, 0400);
-
-MODULE_PARM_DESC(mxmdcb, "Santise DCB table according to MXM-SIS");
-int nouveau_mxmdcb = 1;
-module_param_named(mxmdcb, nouveau_mxmdcb, int, 0400);
-
-int nouveau_fbpercrtc;
-#if 0
-module_param_named(fbpercrtc, nouveau_fbpercrtc, int, 0400);
-#endif
-
-static struct pci_device_id pciidlist[] = {
-        {
-                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
-                .class = PCI_BASE_CLASS_DISPLAY << 16,
-                .class_mask  = 0xff << 16,
-        },
-        {
-                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID),
-                .class = PCI_BASE_CLASS_DISPLAY << 16,
-                .class_mask  = 0xff << 16,
-        },
-        {}
-};
-
-MODULE_DEVICE_TABLE(pci, pciidlist);
-
-static struct drm_driver driver;
-
-static int __devinit
-nouveau_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
-{
-        return drm_get_pci_dev(pdev, ent, &driver);
-}
-
-static void
-nouveau_pci_remove(struct pci_dev *pdev)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-
-        drm_put_dev(dev);
-}
-
-int
-nouveau_pci_suspend(struct pci_dev *pdev, pm_message_t pm_state)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct nouveau_channel *chan;
-        struct drm_crtc *crtc;
-        int ret, i, e;
-
-        if (pm_state.event == PM_EVENT_PRETHAW)
-                return 0;
-
-        if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
-                return 0;
-
-        NV_INFO(dev, "Disabling display...\n");
-        nouveau_display_fini(dev);
-
-        NV_INFO(dev, "Disabling fbcon...\n");
-        nouveau_fbcon_set_suspend(dev, 1);
-
-        NV_INFO(dev, "Unpinning framebuffer(s)...\n");
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                struct nouveau_framebuffer *nouveau_fb;
-
-                nouveau_fb = nouveau_framebuffer(crtc->fb);
-                if (!nouveau_fb || !nouveau_fb->nvbo)
-                        continue;
-
-                nouveau_bo_unpin(nouveau_fb->nvbo);
-        }
-
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-
-                nouveau_bo_unmap(nv_crtc->cursor.nvbo);
-                nouveau_bo_unpin(nv_crtc->cursor.nvbo);
-        }
-
-        NV_INFO(dev, "Evicting buffers...\n");
-        ttm_bo_evict_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
-
-        NV_INFO(dev, "Idling channels...\n");
-        for (i = 0; i < (pfifo ? pfifo->channels : 0); i++) {
-                chan = dev_priv->channels.ptr[i];
-
-                if (chan && chan->pushbuf_bo)
-                        nouveau_channel_idle(chan);
-        }
-
-        for (e = NVOBJ_ENGINE_NR - 1; e >= 0; e--) {
-                if (!dev_priv->eng[e])
-                        continue;
-
-                ret = dev_priv->eng[e]->fini(dev, e, true);
-                if (ret) {
-                        NV_ERROR(dev, "... engine %d failed: %d\n", e, ret);
-                        goto out_abort;
-                }
-        }
-
-        ret = pinstmem->suspend(dev);
-        if (ret) {
-                NV_ERROR(dev, "... failed: %d\n", ret);
-                goto out_abort;
-        }
-
-        NV_INFO(dev, "Suspending GPU objects...\n");
-        ret = nouveau_gpuobj_suspend(dev);
-        if (ret) {
-                NV_ERROR(dev, "... failed: %d\n", ret);
-                pinstmem->resume(dev);
-                goto out_abort;
-        }
-
-        NV_INFO(dev, "And we're gone!\n");
-        pci_save_state(pdev);
-        if (pm_state.event == PM_EVENT_SUSPEND) {
-                pci_disable_device(pdev);
-                pci_set_power_state(pdev, PCI_D3hot);
-        }
-
-        return 0;
-
-out_abort:
-        NV_INFO(dev, "Re-enabling acceleration..\n");
-        for (e = e + 1; e < NVOBJ_ENGINE_NR; e++) {
-                if (dev_priv->eng[e])
-                        dev_priv->eng[e]->init(dev, e);
-        }
-        return ret;
-}
-
-int
-nouveau_pci_resume(struct pci_dev *pdev)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_engine *engine = &dev_priv->engine;
-        struct drm_crtc *crtc;
-        int ret, i;
-
-        if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
-                return 0;
-
-        NV_INFO(dev, "We're back, enabling device...\n");
-        pci_set_power_state(pdev, PCI_D0);
-        pci_restore_state(pdev);
-        if (pci_enable_device(pdev))
-                return -1;
-        pci_set_master(dev->pdev);
-
-        /* Make sure the AGP controller is in a consistent state */
-        if (dev_priv->gart_info.type == NOUVEAU_GART_AGP)
-                nouveau_mem_reset_agp(dev);
-
-        /* Make the CRTCs accessible */
-        engine->display.early_init(dev);
-
-        NV_INFO(dev, "POSTing device...\n");
-        ret = nouveau_run_vbios_init(dev);
-        if (ret)
-                return ret;
-
-        if (dev_priv->gart_info.type == NOUVEAU_GART_AGP) {
-                ret = nouveau_mem_init_agp(dev);
-                if (ret) {
-                        NV_ERROR(dev, "error reinitialising AGP: %d\n", ret);
-                        return ret;
-                }
-        }
-
-        NV_INFO(dev, "Restoring GPU objects...\n");
-        nouveau_gpuobj_resume(dev);
-
-        NV_INFO(dev, "Reinitialising engines...\n");
-        engine->instmem.resume(dev);
-        engine->mc.init(dev);
-        engine->timer.init(dev);
-        engine->fb.init(dev);
-        for (i = 0; i < NVOBJ_ENGINE_NR; i++) {
-                if (dev_priv->eng[i])
-                        dev_priv->eng[i]->init(dev, i);
-        }
-
-        nouveau_irq_postinstall(dev);
-
-        /* Re-write SKIPS, they'll have been lost over the suspend */
-        if (nouveau_vram_pushbuf) {
-                struct nouveau_channel *chan;
-                int j;
-
-                for (i = 0; i < (pfifo ? pfifo->channels : 0); i++) {
-                        chan = dev_priv->channels.ptr[i];
-                        if (!chan || !chan->pushbuf_bo)
-                                continue;
-
-                        for (j = 0; j < NOUVEAU_DMA_SKIPS; j++)
-                                nouveau_bo_wr32(chan->pushbuf_bo, i, 0);
-                }
-        }
-
-        nouveau_pm_resume(dev);
-
-        NV_INFO(dev, "Restoring mode...\n");
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                struct nouveau_framebuffer *nouveau_fb;
-
-                nouveau_fb = nouveau_framebuffer(crtc->fb);
-                if (!nouveau_fb || !nouveau_fb->nvbo)
-                        continue;
-
-                nouveau_bo_pin(nouveau_fb->nvbo, TTM_PL_FLAG_VRAM);
-        }
-
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-
-                ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM);
-                if (!ret)
-                        ret = nouveau_bo_map(nv_crtc->cursor.nvbo);
-                if (ret)
-                        NV_ERROR(dev, "Could not pin/map cursor.\n");
-        }
-
-        nouveau_fbcon_set_suspend(dev, 0);
-        nouveau_fbcon_zfill_all(dev);
-
-        nouveau_display_init(dev);
-
-        /* Force CLUT to get re-loaded during modeset */
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-
-                nv_crtc->lut.depth = 0;
-        }
-
-        drm_helper_resume_force_mode(dev);
-
-        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-                struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-                u32 offset = nv_crtc->cursor.nvbo->bo.offset;
-
-                nv_crtc->cursor.set_offset(nv_crtc, offset);
-                nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,
-                                                 nv_crtc->cursor_saved_y);
-        }
-
-        return 0;
-}
-
-static struct drm_ioctl_desc nouveau_ioctls[] = {
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GETPARAM, nouveau_abi16_ioctl_getparam, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_SETPARAM, nouveau_abi16_ioctl_setparam, DRM_UNLOCKED|DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_ALLOC, nouveau_abi16_ioctl_channel_alloc, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_FREE, nouveau_abi16_ioctl_channel_free, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GROBJ_ALLOC, nouveau_abi16_ioctl_grobj_alloc, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_NOTIFIEROBJ_ALLOC, nouveau_abi16_ioctl_notifierobj_alloc, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GPUOBJ_FREE, nouveau_abi16_ioctl_gpuobj_free, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_NEW, nouveau_gem_ioctl_new, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_PUSHBUF, nouveau_gem_ioctl_pushbuf, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_PREP, nouveau_gem_ioctl_cpu_prep, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_FINI, nouveau_gem_ioctl_cpu_fini, DRM_UNLOCKED|DRM_AUTH),
-        DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_INFO, nouveau_gem_ioctl_info, DRM_UNLOCKED|DRM_AUTH),
-};
-
-static const struct file_operations nouveau_driver_fops = {
-        .owner = THIS_MODULE,
-        .open = drm_open,
-        .release = drm_release,
-        .unlocked_ioctl = drm_ioctl,
-        .mmap = nouveau_ttm_mmap,
-        .poll = drm_poll,
-        .fasync = drm_fasync,
-        .read = drm_read,
-#if defined(CONFIG_COMPAT)
-        .compat_ioctl = nouveau_compat_ioctl,
-#endif
-        .llseek = noop_llseek,
-};
-
-static struct drm_driver driver = {
-        .driver_features =
-                DRIVER_USE_AGP | DRIVER_PCI_DMA | DRIVER_SG |
-                DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM |
-                DRIVER_MODESET | DRIVER_PRIME,
-        .load = nouveau_load,
-        .firstopen = nouveau_firstopen,
-        .lastclose = nouveau_lastclose,
-        .unload = nouveau_unload,
-        .open = nouveau_open,
-        .preclose = nouveau_preclose,
-        .postclose = nouveau_postclose,
-#if defined(CONFIG_DRM_NOUVEAU_DEBUG)
-        .debugfs_init = nouveau_debugfs_init,
-        .debugfs_cleanup = nouveau_debugfs_takedown,
-#endif
-        .irq_preinstall = nouveau_irq_preinstall,
-        .irq_postinstall = nouveau_irq_postinstall,
-        .irq_uninstall = nouveau_irq_uninstall,
-        .irq_handler = nouveau_irq_handler,
-        .get_vblank_counter = drm_vblank_count,
-        .enable_vblank = nouveau_vblank_enable,
-        .disable_vblank = nouveau_vblank_disable,
-        .ioctls = nouveau_ioctls,
-        .fops = &nouveau_driver_fops,
-
-        .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
-        .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
-        .gem_prime_export = nouveau_gem_prime_export,
-        .gem_prime_import = nouveau_gem_prime_import,
-
-        .gem_init_object = nouveau_gem_object_new,
-        .gem_free_object = nouveau_gem_object_del,
-        .gem_open_object = nouveau_gem_object_open,
-        .gem_close_object = nouveau_gem_object_close,
-
-        .dumb_create = nouveau_display_dumb_create,
-        .dumb_map_offset = nouveau_display_dumb_map_offset,
-        .dumb_destroy = nouveau_display_dumb_destroy,
-
-        .name = DRIVER_NAME,
-        .desc = DRIVER_DESC,
-#ifdef GIT_REVISION
-        .date = GIT_REVISION,
-#else
-        .date = DRIVER_DATE,
-#endif
-        .major = DRIVER_MAJOR,
-        .minor = DRIVER_MINOR,
-        .patchlevel = DRIVER_PATCHLEVEL,
-};
-
-static struct pci_driver nouveau_pci_driver = {
-                .name = DRIVER_NAME,
-                .id_table = pciidlist,
-                .probe = nouveau_pci_probe,
-                .remove = nouveau_pci_remove,
-                .suspend = nouveau_pci_suspend,
-                .resume = nouveau_pci_resume
-};
-
-static int __init nouveau_init(void)
-{
-        driver.num_ioctls = ARRAY_SIZE(nouveau_ioctls);
-
-        if (nouveau_modeset == -1) {
-#ifdef CONFIG_VGA_CONSOLE
-                if (vgacon_text_force())
-                        nouveau_modeset = 0;
-                else
-#endif
-                        nouveau_modeset = 1;
-        }
-
-        if (!nouveau_modeset)
-                return 0;
-
-        nouveau_register_dsm_handler();
-        return drm_pci_init(&driver, &nouveau_pci_driver);
-}
-
-static void __exit nouveau_exit(void)
-{
-        if (!nouveau_modeset)
-                return;
-
-        drm_pci_exit(&driver, &nouveau_pci_driver);
-        nouveau_unregister_dsm_handler();
-}
-
-module_init(nouveau_init);
-module_exit(nouveau_exit);
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL and additional rights");
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h
deleted file mode 100644
index 4f2cc95ce264..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_drv.h
+++ /dev/null
@@ -1,1655 +0,0 @@
-/*
- * Copyright 2005 Stephane Marchesin.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef __NOUVEAU_DRV_H__
-#define __NOUVEAU_DRV_H__
-
-#define DRIVER_AUTHOR           "Stephane Marchesin"
-#define DRIVER_EMAIL            "nouveau@lists.freedesktop.org"
-
-#define DRIVER_NAME             "nouveau"
-#define DRIVER_DESC             "nVidia Riva/TNT/GeForce"
-#define DRIVER_DATE             "20120316"
-
-#define DRIVER_MAJOR            1
-#define DRIVER_MINOR            0
-#define DRIVER_PATCHLEVEL       0
-
-#define NOUVEAU_FAMILY   0x0000FFFF
-#define NOUVEAU_FLAGS    0xFFFF0000
-
-#include "ttm/ttm_bo_api.h"
-#include "ttm/ttm_bo_driver.h"
-#include "ttm/ttm_placement.h"
-#include "ttm/ttm_memory.h"
-#include "ttm/ttm_module.h"
-
-struct nouveau_fpriv {
-        spinlock_t lock;
-        struct list_head channels;
-        struct nouveau_vm *vm;
-};
-
-static inline struct nouveau_fpriv *
-nouveau_fpriv(struct drm_file *file_priv)
-{
-        return file_priv ? file_priv->driver_priv : NULL;
-}
-
-#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT)
-
-#include "nouveau_drm.h"
-#include "nouveau_reg.h"
-#include "nouveau_bios.h"
-#include "nouveau_util.h"
-
-struct nouveau_grctx;
-struct nouveau_mem;
-#include "nouveau_vm.h"
-
-#define MAX_NUM_DCB_ENTRIES 16
-
-#define NOUVEAU_MAX_CHANNEL_NR 4096
-#define NOUVEAU_MAX_TILE_NR 15
-
-struct nouveau_mem {
-        struct drm_device *dev;
-
-        struct nouveau_vma bar_vma;
-        struct nouveau_vma vma[2];
-        u8  page_shift;
-
-        struct drm_mm_node *tag;
-        struct list_head regions;
-        dma_addr_t *pages;
-        u32 memtype;
-        u64 offset;
-        u64 size;
-        struct sg_table *sg;
-};
-
-struct nouveau_tile_reg {
-        bool used;
-        uint32_t addr;
-        uint32_t limit;
-        uint32_t pitch;
-        uint32_t zcomp;
-        struct drm_mm_node *tag_mem;
-        struct nouveau_fence *fence;
-};
-
-struct nouveau_bo {
-        struct ttm_buffer_object bo;
-        struct ttm_placement placement;
-        u32 valid_domains;
-        u32 placements[3];
-        u32 busy_placements[3];
-        struct ttm_bo_kmap_obj kmap;
-        struct list_head head;
-
-        /* protected by ttm_bo_reserve() */
-        struct drm_file *reserved_by;
-        struct list_head entry;
-        int pbbo_index;
-        bool validate_mapped;
-
-        struct list_head vma_list;
-        unsigned page_shift;
-
-        uint32_t tile_mode;
-        uint32_t tile_flags;
-        struct nouveau_tile_reg *tile;
-
-        struct drm_gem_object *gem;
-        int pin_refcnt;
-
-        struct ttm_bo_kmap_obj dma_buf_vmap;
-        int vmapping_count;
-};
-
-#define nouveau_bo_tile_layout(nvbo)                            \
-        ((nvbo)->tile_flags & NOUVEAU_GEM_TILE_LAYOUT_MASK)
-
-static inline struct nouveau_bo *
-nouveau_bo(struct ttm_buffer_object *bo)
-{
-        return container_of(bo, struct nouveau_bo, bo);
-}
-
-static inline struct nouveau_bo *
-nouveau_gem_object(struct drm_gem_object *gem)
-{
-        return gem ? gem->driver_private : NULL;
-}
-
-/* TODO: submit equivalent to TTM generic API upstream? */
-static inline void __iomem *
-nvbo_kmap_obj_iovirtual(struct nouveau_bo *nvbo)
-{
-        bool is_iomem;
-        void __iomem *ioptr = (void __force __iomem *)ttm_kmap_obj_virtual(
-                                                &nvbo->kmap, &is_iomem);
-        WARN_ON_ONCE(ioptr && !is_iomem);
-        return ioptr;
-}
-
-enum nouveau_flags {
-        NV_NFORCE   = 0x10000000,
-        NV_NFORCE2  = 0x20000000
-};
-
-#define NVOBJ_ENGINE_SW         0
-#define NVOBJ_ENGINE_GR         1
-#define NVOBJ_ENGINE_CRYPT      2
-#define NVOBJ_ENGINE_COPY0      3
-#define NVOBJ_ENGINE_COPY1      4
-#define NVOBJ_ENGINE_MPEG       5
-#define NVOBJ_ENGINE_PPP        NVOBJ_ENGINE_MPEG
-#define NVOBJ_ENGINE_BSP        6
-#define NVOBJ_ENGINE_VP         7
-#define NVOBJ_ENGINE_FIFO       14
-#define NVOBJ_ENGINE_FENCE      15
-#define NVOBJ_ENGINE_NR         16
-#define NVOBJ_ENGINE_DISPLAY    (NVOBJ_ENGINE_NR + 0) /*XXX*/
-
-#define NVOBJ_FLAG_DONT_MAP             (1 << 0)
-#define NVOBJ_FLAG_ZERO_ALLOC           (1 << 1)
-#define NVOBJ_FLAG_ZERO_FREE            (1 << 2)
-#define NVOBJ_FLAG_VM                   (1 << 3)
-#define NVOBJ_FLAG_VM_USER              (1 << 4)
-
-#define NVOBJ_CINST_GLOBAL      0xdeadbeef
-
-struct nouveau_gpuobj {
-        struct drm_device *dev;
-        struct kref refcount;
-        struct list_head list;
-
-        void *node;
-        u32 *suspend;
-
-        uint32_t flags;
-
-        u32 size;
-        u32 pinst;      /* PRAMIN BAR offset */
-        u32 cinst;      /* Channel offset */
-        u64 vinst;      /* VRAM address */
-        u64 linst;      /* VM address */
-
-        uint32_t engine;
-        uint32_t class;
-
-        void (*dtor)(struct drm_device *, struct nouveau_gpuobj *);
-        void *priv;
-};
-
-struct nouveau_page_flip_state {
-        struct list_head head;
-        struct drm_pending_vblank_event *event;
-        int crtc, bpp, pitch, x, y;
-        uint64_t offset;
-};
-
-enum nouveau_channel_mutex_class {
-        NOUVEAU_UCHANNEL_MUTEX,
-        NOUVEAU_KCHANNEL_MUTEX
-};
-
-struct nouveau_channel {
-        struct drm_device *dev;
-        struct list_head list;
-        int id;
-
-        /* references to the channel data structure */
-        struct kref ref;
-        /* users of the hardware channel resources, the hardware
-         * context will be kicked off when it reaches zero. */
-        atomic_t users;
-        struct mutex mutex;
-
-        /* owner of this fifo */
-        struct drm_file *file_priv;
-        /* mapping of the fifo itself */
-        struct drm_local_map *map;
-
-        /* mapping of the regs controlling the fifo */
-        void __iomem *user;
-        uint32_t user_get;
-        uint32_t user_get_hi;
-        uint32_t user_put;
-
-        /* DMA push buffer */
-        struct nouveau_gpuobj *pushbuf;
-        struct nouveau_bo     *pushbuf_bo;
-        struct nouveau_vma     pushbuf_vma;
-        uint64_t               pushbuf_base;
-
-        /* Notifier memory */
-        struct nouveau_bo *notifier_bo;
-        struct nouveau_vma notifier_vma;
-        struct drm_mm notifier_heap;
-
-        /* PFIFO context */
-        struct nouveau_gpuobj *ramfc;
-
-        /* Execution engine contexts */
-        void *engctx[NVOBJ_ENGINE_NR];
-
-        /* NV50 VM */
-        struct nouveau_vm     *vm;
-        struct nouveau_gpuobj *vm_pd;
-
-        /* Objects */
-        struct nouveau_gpuobj *ramin; /* Private instmem */
-        struct drm_mm          ramin_heap; /* Private PRAMIN heap */
-        struct nouveau_ramht  *ramht; /* Hash table */
-
-        /* GPU object info for stuff used in-kernel (mm_enabled) */
-        uint32_t m2mf_ntfy;
-        uint32_t vram_handle;
-        uint32_t gart_handle;
-        bool accel_done;
-
-        /* Push buffer state (only for drm's channel on !mm_enabled) */
-        struct {
-                int max;
-                int free;
-                int cur;
-                int put;
-                /* access via pushbuf_bo */
-
-                int ib_base;
-                int ib_max;
-                int ib_free;
-                int ib_put;
-        } dma;
-
-        struct {
-                bool active;
-                char name[32];
-                struct drm_info_list info;
-        } debugfs;
-};
-
-struct nouveau_exec_engine {
-        void (*destroy)(struct drm_device *, int engine);
-        int  (*init)(struct drm_device *, int engine);
-        int  (*fini)(struct drm_device *, int engine, bool suspend);
-        int  (*context_new)(struct nouveau_channel *, int engine);
-        void (*context_del)(struct nouveau_channel *, int engine);
-        int  (*object_new)(struct nouveau_channel *, int engine,
-                           u32 handle, u16 class);
-        void (*set_tile_region)(struct drm_device *dev, int i);
-        void (*tlb_flush)(struct drm_device *, int engine);
-};
-
-struct nouveau_instmem_engine {
-        void    *priv;
-
-        int     (*init)(struct drm_device *dev);
-        void    (*takedown)(struct drm_device *dev);
-        int     (*suspend)(struct drm_device *dev);
-        void    (*resume)(struct drm_device *dev);
-
-        int     (*get)(struct nouveau_gpuobj *, struct nouveau_channel *,
-                       u32 size, u32 align);
-        void    (*put)(struct nouveau_gpuobj *);
-        int     (*map)(struct nouveau_gpuobj *);
-        void    (*unmap)(struct nouveau_gpuobj *);
-
-        void    (*flush)(struct drm_device *);
-};
-
-struct nouveau_mc_engine {
-        int  (*init)(struct drm_device *dev);
-        void (*takedown)(struct drm_device *dev);
-};
-
-struct nouveau_timer_engine {
-        int      (*init)(struct drm_device *dev);
-        void     (*takedown)(struct drm_device *dev);
-        uint64_t (*read)(struct drm_device *dev);
-};
-
-struct nouveau_fb_engine {
-        int num_tiles;
-        struct drm_mm tag_heap;
-        void *priv;
-
-        int  (*init)(struct drm_device *dev);
-        void (*takedown)(struct drm_device *dev);
-
-        void (*init_tile_region)(struct drm_device *dev, int i,
-                                 uint32_t addr, uint32_t size,
-                                 uint32_t pitch, uint32_t flags);
-        void (*set_tile_region)(struct drm_device *dev, int i);
-        void (*free_tile_region)(struct drm_device *dev, int i);
-};
-
-struct nouveau_display_engine {
-        void *priv;
-        int (*early_init)(struct drm_device *);
-        void (*late_takedown)(struct drm_device *);
-        int (*create)(struct drm_device *);
-        void (*destroy)(struct drm_device *);
-        int (*init)(struct drm_device *);
-        void (*fini)(struct drm_device *);
-
-        struct drm_property *dithering_mode;
-        struct drm_property *dithering_depth;
-        struct drm_property *underscan_property;
-        struct drm_property *underscan_hborder_property;
-        struct drm_property *underscan_vborder_property;
-        /* not really hue and saturation: */
-        struct drm_property *vibrant_hue_property;
-        struct drm_property *color_vibrance_property;
-};
-
-struct nouveau_gpio_engine {
-        spinlock_t lock;
-        struct list_head isr;
-        int (*init)(struct drm_device *);
-        void (*fini)(struct drm_device *);
-        int (*drive)(struct drm_device *, int line, int dir, int out);
-        int (*sense)(struct drm_device *, int line);
-        void (*irq_enable)(struct drm_device *, int line, bool);
-};
-
-struct nouveau_pm_voltage_level {
-        u32 voltage; /* microvolts */
-        u8  vid;
-};
-
-struct nouveau_pm_voltage {
-        bool supported;
-        u8 version;
-        u8 vid_mask;
-
-        struct nouveau_pm_voltage_level *level;
-        int nr_level;
-};
-
-/* Exclusive upper limits */
-#define NV_MEM_CL_DDR2_MAX 8
-#define NV_MEM_WR_DDR2_MAX 9
-#define NV_MEM_CL_DDR3_MAX 17
-#define NV_MEM_WR_DDR3_MAX 17
-#define NV_MEM_CL_GDDR3_MAX 16
-#define NV_MEM_WR_GDDR3_MAX 18
-#define NV_MEM_CL_GDDR5_MAX 21
-#define NV_MEM_WR_GDDR5_MAX 20
-
-struct nouveau_pm_memtiming {
-        int id;
-
-        u32 reg[9];
-        u32 mr[4];
-
-        u8 tCWL;
-
-        u8 odt;
-        u8 drive_strength;
-};
-
-struct nouveau_pm_tbl_header {
-        u8 version;
-        u8 header_len;
-        u8 entry_cnt;
-        u8 entry_len;
-};
-
-struct nouveau_pm_tbl_entry {
-        u8 tWR;
-        u8 tWTR;
-        u8 tCL;
-        u8 tRC;
-        u8 empty_4;
-        u8 tRFC;        /* Byte 5 */
-        u8 empty_6;
-        u8 tRAS;        /* Byte 7 */
-        u8 empty_8;
-        u8 tRP;         /* Byte 9 */
-        u8 tRCDRD;
-        u8 tRCDWR;
-        u8 tRRD;
-        u8 tUNK_13;
-        u8 RAM_FT1;             /* 14, a bitmask of random RAM features */
-        u8 empty_15;
-        u8 tUNK_16;
-        u8 empty_17;
-        u8 tUNK_18;
-        u8 tCWL;
-        u8 tUNK_20, tUNK_21;
-};
-
-struct nouveau_pm_profile;
-struct nouveau_pm_profile_func {
-        void (*destroy)(struct nouveau_pm_profile *);
-        void (*init)(struct nouveau_pm_profile *);
-        void (*fini)(struct nouveau_pm_profile *);
-        struct nouveau_pm_level *(*select)(struct nouveau_pm_profile *);
-};
-
-struct nouveau_pm_profile {
-        const struct nouveau_pm_profile_func *func;
-        struct list_head head;
-        char name[8];
-};
-
-#define NOUVEAU_PM_MAX_LEVEL 8
-struct nouveau_pm_level {
-        struct nouveau_pm_profile profile;
-        struct device_attribute dev_attr;
-        char name[32];
-        int id;
-
-        struct nouveau_pm_memtiming timing;
-        u32 memory;
-        u16 memscript;
-
-        u32 core;
-        u32 shader;
-        u32 rop;
-        u32 copy;
-        u32 daemon;
-        u32 vdec;
-        u32 dom6;
-        u32 unka0;      /* nva3:nvc0 */
-        u32 hub01;      /* nvc0- */
-        u32 hub06;      /* nvc0- */
-        u32 hub07;      /* nvc0- */
-
-        u32 volt_min; /* microvolts */
-        u32 volt_max;
-        u8  fanspeed;
-};
-
-struct nouveau_pm_temp_sensor_constants {
-        u16 offset_constant;
-        s16 offset_mult;
-        s16 offset_div;
-        s16 slope_mult;
-        s16 slope_div;
-};
-
-struct nouveau_pm_threshold_temp {
-        s16 critical;
-        s16 down_clock;
-        s16 fan_boost;
-};
-
-struct nouveau_pm_fan {
-        u32 percent;
-        u32 min_duty;
-        u32 max_duty;
-        u32 pwm_freq;
-        u32 pwm_divisor;
-};
-
-struct nouveau_pm_engine {
-        struct nouveau_pm_voltage voltage;
-        struct nouveau_pm_level perflvl[NOUVEAU_PM_MAX_LEVEL];
-        int nr_perflvl;
-        struct nouveau_pm_temp_sensor_constants sensor_constants;
-        struct nouveau_pm_threshold_temp threshold_temp;
-        struct nouveau_pm_fan fan;
-
-        struct nouveau_pm_profile *profile_ac;
-        struct nouveau_pm_profile *profile_dc;
-        struct nouveau_pm_profile *profile;
-        struct list_head profiles;
-
-        struct nouveau_pm_level boot;
-        struct nouveau_pm_level *cur;
-
-        struct device *hwmon;
-        struct notifier_block acpi_nb;
-
-        int  (*clocks_get)(struct drm_device *, struct nouveau_pm_level *);
-        void *(*clocks_pre)(struct drm_device *, struct nouveau_pm_level *);
-        int (*clocks_set)(struct drm_device *, void *);
-
-        int (*voltage_get)(struct drm_device *);
-        int (*voltage_set)(struct drm_device *, int voltage);
-        int (*pwm_get)(struct drm_device *, int line, u32*, u32*);
-        int (*pwm_set)(struct drm_device *, int line, u32, u32);
-        int (*temp_get)(struct drm_device *);
-};
-
-struct nouveau_vram_engine {
-        struct nouveau_mm mm;
-
-        int  (*init)(struct drm_device *);
-        void (*takedown)(struct drm_device *dev);
-        int  (*get)(struct drm_device *, u64, u32 align, u32 size_nc,
-                    u32 type, struct nouveau_mem **);
-        void (*put)(struct drm_device *, struct nouveau_mem **);
-
-        bool (*flags_valid)(struct drm_device *, u32 tile_flags);
-};
-
-struct nouveau_engine {
-        struct nouveau_instmem_engine instmem;
-        struct nouveau_mc_engine      mc;
-        struct nouveau_timer_engine   timer;
-        struct nouveau_fb_engine      fb;
-        struct nouveau_display_engine display;
-        struct nouveau_gpio_engine    gpio;
-        struct nouveau_pm_engine      pm;
-        struct nouveau_vram_engine    vram;
-};
-
-struct nouveau_pll_vals {
-        union {
-                struct {
-#ifdef __BIG_ENDIAN
-                        uint8_t N1, M1, N2, M2;
-#else
-                        uint8_t M1, N1, M2, N2;
-#endif
-                };
-                struct {
-                        uint16_t NM1, NM2;
-                } __attribute__((packed));
-        };
-        int log2P;
-
-        int refclk;
-};
-
-enum nv04_fp_display_regs {
-        FP_DISPLAY_END,
-        FP_TOTAL,
-        FP_CRTC,
-        FP_SYNC_START,
-        FP_SYNC_END,
-        FP_VALID_START,
-        FP_VALID_END
-};
-
-struct nv04_crtc_reg {
-        unsigned char MiscOutReg;
-        uint8_t CRTC[0xa0];
-        uint8_t CR58[0x10];
-        uint8_t Sequencer[5];
-        uint8_t Graphics[9];
-        uint8_t Attribute[21];
-        unsigned char DAC[768];
-
-        /* PCRTC regs */
-        uint32_t fb_start;
-        uint32_t crtc_cfg;
-        uint32_t cursor_cfg;
-        uint32_t gpio_ext;
-        uint32_t crtc_830;
-        uint32_t crtc_834;
-        uint32_t crtc_850;
-        uint32_t crtc_eng_ctrl;
-
-        /* PRAMDAC regs */
-        uint32_t nv10_cursync;
-        struct nouveau_pll_vals pllvals;
-        uint32_t ramdac_gen_ctrl;
-        uint32_t ramdac_630;
-        uint32_t ramdac_634;
-        uint32_t tv_setup;
-        uint32_t tv_vtotal;
-        uint32_t tv_vskew;
-        uint32_t tv_vsync_delay;
-        uint32_t tv_htotal;
-        uint32_t tv_hskew;
-        uint32_t tv_hsync_delay;
-        uint32_t tv_hsync_delay2;
-        uint32_t fp_horiz_regs[7];
-        uint32_t fp_vert_regs[7];
-        uint32_t dither;
-        uint32_t fp_control;
-        uint32_t dither_regs[6];
-        uint32_t fp_debug_0;
-        uint32_t fp_debug_1;
-        uint32_t fp_debug_2;
-        uint32_t fp_margin_color;
-        uint32_t ramdac_8c0;
-        uint32_t ramdac_a20;
-        uint32_t ramdac_a24;
-        uint32_t ramdac_a34;
-        uint32_t ctv_regs[38];
-};
-
-struct nv04_output_reg {
-        uint32_t output;
-        int head;
-};
-
-struct nv04_mode_state {
-        struct nv04_crtc_reg crtc_reg[2];
-        uint32_t pllsel;
-        uint32_t sel_clk;
-};
-
-enum nouveau_card_type {
-        NV_04      = 0x04,
-        NV_10      = 0x10,
-        NV_20      = 0x20,
-        NV_30      = 0x30,
-        NV_40      = 0x40,
-        NV_50      = 0x50,
-        NV_C0      = 0xc0,
-        NV_D0      = 0xd0,
-        NV_E0      = 0xe0,
-};
-
-struct drm_nouveau_private {
-        struct drm_device *dev;
-        bool noaccel;
-
-        /* the card type, takes NV_* as values */
-        enum nouveau_card_type card_type;
-        /* exact chipset, derived from NV_PMC_BOOT_0 */
-        int chipset;
-        int flags;
-        u32 crystal;
-
-        void __iomem *mmio;
-
-        spinlock_t ramin_lock;
-        void __iomem *ramin;
-        u32 ramin_size;
-        u32 ramin_base;
-        bool ramin_available;
-        struct drm_mm ramin_heap;
-        struct nouveau_exec_engine *eng[NVOBJ_ENGINE_NR];
-        struct list_head gpuobj_list;
-        struct list_head classes;
-
-        struct nouveau_bo *vga_ram;
-
-        /* interrupt handling */
-        void (*irq_handler[32])(struct drm_device *);
-        bool msi_enabled;
-
-        struct {
-                struct drm_global_reference mem_global_ref;
-                struct ttm_bo_global_ref bo_global_ref;
-                struct ttm_bo_device bdev;
-                atomic_t validate_sequence;
-                int (*move)(struct nouveau_channel *,
-                            struct ttm_buffer_object *,
-                            struct ttm_mem_reg *, struct ttm_mem_reg *);
-        } ttm;
-
-        struct {
-                spinlock_t lock;
-                struct drm_mm heap;
-                struct nouveau_bo *bo;
-        } fence;
-
-        struct {
-                spinlock_t lock;
-                struct nouveau_channel *ptr[NOUVEAU_MAX_CHANNEL_NR];
-        } channels;
-
-        struct nouveau_engine engine;
-        struct nouveau_channel *channel;
-
-        /* For PFIFO and PGRAPH. */
-        spinlock_t context_switch_lock;
-
-        /* VM/PRAMIN flush, legacy PRAMIN aperture */
-        spinlock_t vm_lock;
-
-        /* RAMIN configuration, RAMFC, RAMHT and RAMRO offsets */
-        struct nouveau_ramht  *ramht;
-        struct nouveau_gpuobj *ramfc;
-        struct nouveau_gpuobj *ramro;
-
-        uint32_t ramin_rsvd_vram;
-
-        struct {
-                enum {
-                        NOUVEAU_GART_NONE = 0,
-                        NOUVEAU_GART_AGP,       /* AGP */
-                        NOUVEAU_GART_PDMA,      /* paged dma object */
-                        NOUVEAU_GART_HW         /* on-chip gart/vm */
-                } type;
-                uint64_t aper_base;
-                uint64_t aper_size;
-                uint64_t aper_free;
-
-                struct ttm_backend_func *func;
-
-                struct {
-                        struct page *page;
-                        dma_addr_t   addr;
-                } dummy;
-
-                struct nouveau_gpuobj *sg_ctxdma;
-        } gart_info;
-
-        /* nv10-nv40 tiling regions */
-        struct {
-                struct nouveau_tile_reg reg[NOUVEAU_MAX_TILE_NR];
-                spinlock_t lock;
-        } tile;
-
-        /* VRAM/fb configuration */
-        enum {
-                NV_MEM_TYPE_UNKNOWN = 0,
-                NV_MEM_TYPE_STOLEN,
-                NV_MEM_TYPE_SGRAM,
-                NV_MEM_TYPE_SDRAM,
-                NV_MEM_TYPE_DDR1,
-                NV_MEM_TYPE_DDR2,
-                NV_MEM_TYPE_DDR3,
-                NV_MEM_TYPE_GDDR2,
-                NV_MEM_TYPE_GDDR3,
-                NV_MEM_TYPE_GDDR4,
-                NV_MEM_TYPE_GDDR5
-        } vram_type;
-        uint64_t vram_size;
-        uint64_t vram_sys_base;
-        bool vram_rank_B;
-
-        uint64_t fb_available_size;
-        uint64_t fb_mappable_pages;
-        uint64_t fb_aper_free;
-        int fb_mtrr;
-
-        /* BAR control (NV50-) */
-        struct nouveau_vm *bar1_vm;
-        struct nouveau_vm *bar3_vm;
-
-        /* G8x/G9x virtual address space */
-        struct nouveau_vm *chan_vm;
-
-        struct nvbios vbios;
-        u8 *mxms;
-        struct list_head i2c_ports;
-
-        struct nv04_mode_state mode_reg;
-        struct nv04_mode_state saved_reg;
-        uint32_t saved_vga_font[4][16384];
-        uint32_t crtc_owner;
-        uint32_t dac_users[4];
-
-        struct backlight_device *backlight;
-
-        struct {
-                struct dentry *channel_root;
-        } debugfs;
-
-        struct nouveau_fbdev *nfbdev;
-        struct apertures_struct *apertures;
-};
-
-static inline struct drm_nouveau_private *
-nouveau_private(struct drm_device *dev)
-{
-        return dev->dev_private;
-}
-
-static inline struct drm_nouveau_private *
-nouveau_bdev(struct ttm_bo_device *bd)
-{
-        return container_of(bd, struct drm_nouveau_private, ttm.bdev);
-}
-
-static inline int
-nouveau_bo_ref(struct nouveau_bo *ref, struct nouveau_bo **pnvbo)
-{
-        struct nouveau_bo *prev;
-
-        if (!pnvbo)
-                return -EINVAL;
-        prev = *pnvbo;
-
-        *pnvbo = ref ? nouveau_bo(ttm_bo_reference(&ref->bo)) : NULL;
-        if (prev) {
-                struct ttm_buffer_object *bo = &prev->bo;
-
-                ttm_bo_unref(&bo);
-        }
-
-        return 0;
-}
-
-/* nouveau_drv.c */
-extern int nouveau_modeset;
-extern int nouveau_agpmode;
-extern int nouveau_duallink;
-extern int nouveau_uscript_lvds;
-extern int nouveau_uscript_tmds;
-extern int nouveau_vram_pushbuf;
-extern int nouveau_vram_notify;
-extern char *nouveau_vram_type;
-extern int nouveau_fbpercrtc;
-extern int nouveau_tv_disable;
-extern char *nouveau_tv_norm;
-extern int nouveau_reg_debug;
-extern char *nouveau_vbios;
-extern int nouveau_ignorelid;
-extern int nouveau_nofbaccel;
-extern int nouveau_noaccel;
-extern int nouveau_force_post;
-extern int nouveau_override_conntype;
-extern char *nouveau_perflvl;
-extern int nouveau_perflvl_wr;
-extern int nouveau_msi;
-extern int nouveau_ctxfw;
-extern int nouveau_mxmdcb;
-
-extern int nouveau_pci_suspend(struct pci_dev *pdev, pm_message_t pm_state);
-extern int nouveau_pci_resume(struct pci_dev *pdev);
-
-/* nouveau_state.c */
-extern int  nouveau_open(struct drm_device *, struct drm_file *);
-extern void nouveau_preclose(struct drm_device *dev, struct drm_file *);
-extern void nouveau_postclose(struct drm_device *, struct drm_file *);
-extern int  nouveau_load(struct drm_device *, unsigned long flags);
-extern int  nouveau_firstopen(struct drm_device *);
-extern void nouveau_lastclose(struct drm_device *);
-extern int  nouveau_unload(struct drm_device *);
-extern bool nouveau_wait_eq(struct drm_device *, uint64_t timeout,
-                            uint32_t reg, uint32_t mask, uint32_t val);
-extern bool nouveau_wait_ne(struct drm_device *, uint64_t timeout,
-                            uint32_t reg, uint32_t mask, uint32_t val);
-extern bool nouveau_wait_cb(struct drm_device *, u64 timeout,
-                            bool (*cond)(void *), void *);
-extern bool nouveau_wait_for_idle(struct drm_device *);
-extern int  nouveau_card_init(struct drm_device *);
-
-/* nouveau_mem.c */
-extern int  nouveau_mem_vram_init(struct drm_device *);
-extern void nouveau_mem_vram_fini(struct drm_device *);
-extern int  nouveau_mem_gart_init(struct drm_device *);
-extern void nouveau_mem_gart_fini(struct drm_device *);
-extern int  nouveau_mem_init_agp(struct drm_device *);
-extern int  nouveau_mem_reset_agp(struct drm_device *);
-extern void nouveau_mem_close(struct drm_device *);
-extern bool nouveau_mem_flags_valid(struct drm_device *, u32 tile_flags);
-extern int  nouveau_mem_timing_calc(struct drm_device *, u32 freq,
-                                    struct nouveau_pm_memtiming *);
-extern void nouveau_mem_timing_read(struct drm_device *,
-                                    struct nouveau_pm_memtiming *);
-extern int nouveau_mem_vbios_type(struct drm_device *);
-extern struct nouveau_tile_reg *nv10_mem_set_tiling(
-        struct drm_device *dev, uint32_t addr, uint32_t size,
-        uint32_t pitch, uint32_t flags);
-extern void nv10_mem_put_tile_region(struct drm_device *dev,
-                                     struct nouveau_tile_reg *tile,
-                                     struct nouveau_fence *fence);
-extern const struct ttm_mem_type_manager_func nouveau_vram_manager;
-extern const struct ttm_mem_type_manager_func nouveau_gart_manager;
-
-/* nouveau_notifier.c */
-extern int  nouveau_notifier_init_channel(struct nouveau_channel *);
-extern void nouveau_notifier_takedown_channel(struct nouveau_channel *);
-extern int  nouveau_notifier_alloc(struct nouveau_channel *, uint32_t handle,
-                                   int cout, uint32_t start, uint32_t end,
-                                   uint32_t *offset);
-
-/* nouveau_channel.c */
-extern void nouveau_channel_cleanup(struct drm_device *, struct drm_file *);
-extern int  nouveau_channel_alloc(struct drm_device *dev,
-                                  struct nouveau_channel **chan,
-                                  struct drm_file *file_priv,
-                                  uint32_t fb_ctxdma, uint32_t tt_ctxdma);
-extern struct nouveau_channel *
-nouveau_channel_get_unlocked(struct nouveau_channel *);
-extern struct nouveau_channel *
-nouveau_channel_get(struct drm_file *, int id);
-extern void nouveau_channel_put_unlocked(struct nouveau_channel **);
-extern void nouveau_channel_put(struct nouveau_channel **);
-extern void nouveau_channel_ref(struct nouveau_channel *chan,
-                                struct nouveau_channel **pchan);
-extern int  nouveau_channel_idle(struct nouveau_channel *chan);
-
-/* nouveau_gpuobj.c */
-#define NVOBJ_ENGINE_ADD(d, e, p) do {                                         \
-        struct drm_nouveau_private *dev_priv = (d)->dev_private;               \
-        dev_priv->eng[NVOBJ_ENGINE_##e] = (p);                                 \
-} while (0)
-
-#define NVOBJ_ENGINE_DEL(d, e) do {                                            \
-        struct drm_nouveau_private *dev_priv = (d)->dev_private;               \
-        dev_priv->eng[NVOBJ_ENGINE_##e] = NULL;                                \
-} while (0)
-
-#define NVOBJ_CLASS(d, c, e) do {                                              \
-        int ret = nouveau_gpuobj_class_new((d), (c), NVOBJ_ENGINE_##e);        \
-        if (ret)                                                               \
-                return ret;                                                    \
-} while (0)
-
-#define NVOBJ_MTHD(d, c, m, e) do {                                            \
-        int ret = nouveau_gpuobj_mthd_new((d), (c), (m), (e));                 \
-        if (ret)                                                               \
-                return ret;                                                    \
-} while (0)
-
-extern int  nouveau_gpuobj_early_init(struct drm_device *);
-extern int  nouveau_gpuobj_init(struct drm_device *);
-extern void nouveau_gpuobj_takedown(struct drm_device *);
-extern int  nouveau_gpuobj_suspend(struct drm_device *dev);
-extern void nouveau_gpuobj_resume(struct drm_device *dev);
-extern int  nouveau_gpuobj_class_new(struct drm_device *, u32 class, u32 eng);
-extern int  nouveau_gpuobj_mthd_new(struct drm_device *, u32 class, u32 mthd,
-                                    int (*exec)(struct nouveau_channel *,
-                                                u32 class, u32 mthd, u32 data));
-extern int  nouveau_gpuobj_mthd_call(struct nouveau_channel *, u32, u32, u32);
-extern int  nouveau_gpuobj_mthd_call2(struct drm_device *, int, u32, u32, u32);
-extern int nouveau_gpuobj_channel_init(struct nouveau_channel *,
-                                       uint32_t vram_h, uint32_t tt_h);
-extern void nouveau_gpuobj_channel_takedown(struct nouveau_channel *);
-extern int nouveau_gpuobj_new(struct drm_device *, struct nouveau_channel *,
-                              uint32_t size, int align, uint32_t flags,
-                              struct nouveau_gpuobj **);
-extern void nouveau_gpuobj_ref(struct nouveau_gpuobj *,
-                               struct nouveau_gpuobj **);
-extern int nouveau_gpuobj_new_fake(struct drm_device *, u32 pinst, u64 vinst,
-                                   u32 size, u32 flags,
-                                   struct nouveau_gpuobj **);
-extern int nouveau_gpuobj_dma_new(struct nouveau_channel *, int class,
-                                  uint64_t offset, uint64_t size, int access,
-                                  int target, struct nouveau_gpuobj **);
-extern int nouveau_gpuobj_gr_new(struct nouveau_channel *, u32 handle, int class);
-extern int nv50_gpuobj_dma_new(struct nouveau_channel *, int class, u64 base,
-                               u64 size, int target, int access, u32 type,
-                               u32 comp, struct nouveau_gpuobj **pobj);
-extern void nv50_gpuobj_dma_init(struct nouveau_gpuobj *, u32 offset,
-                                 int class, u64 base, u64 size, int target,
-                                 int access, u32 type, u32 comp);
-
-/* nouveau_irq.c */
-extern int         nouveau_irq_init(struct drm_device *);
-extern void        nouveau_irq_fini(struct drm_device *);
-extern irqreturn_t nouveau_irq_handler(DRM_IRQ_ARGS);
-extern void        nouveau_irq_register(struct drm_device *, int status_bit,
-                                        void (*)(struct drm_device *));
-extern void        nouveau_irq_unregister(struct drm_device *, int status_bit);
-extern void        nouveau_irq_preinstall(struct drm_device *);
-extern int         nouveau_irq_postinstall(struct drm_device *);
-extern void        nouveau_irq_uninstall(struct drm_device *);
-
-/* nouveau_sgdma.c */
-extern int nouveau_sgdma_init(struct drm_device *);
-extern void nouveau_sgdma_takedown(struct drm_device *);
-extern uint32_t nouveau_sgdma_get_physical(struct drm_device *,
-                                           uint32_t offset);
-extern struct ttm_tt *nouveau_sgdma_create_ttm(struct ttm_bo_device *bdev,
-                                               unsigned long size,
-                                               uint32_t page_flags,
-                                               struct page *dummy_read_page);
-
-/* nouveau_debugfs.c */
-#if defined(CONFIG_DRM_NOUVEAU_DEBUG)
-extern int  nouveau_debugfs_init(struct drm_minor *);
-extern void nouveau_debugfs_takedown(struct drm_minor *);
-extern int  nouveau_debugfs_channel_init(struct nouveau_channel *);
-extern void nouveau_debugfs_channel_fini(struct nouveau_channel *);
-#else
-static inline int
-nouveau_debugfs_init(struct drm_minor *minor)
-{
-        return 0;
-}
-
-static inline void nouveau_debugfs_takedown(struct drm_minor *minor)
-{
-}
-
-static inline int
-nouveau_debugfs_channel_init(struct nouveau_channel *chan)
-{
-        return 0;
-}
-
-static inline void
-nouveau_debugfs_channel_fini(struct nouveau_channel *chan)
-{
-}
-#endif
-
-/* nouveau_dma.c */
-extern void nouveau_dma_init(struct nouveau_channel *);
-extern int  nouveau_dma_wait(struct nouveau_channel *, int slots, int size);
-
-/* nouveau_acpi.c */
-#define ROM_BIOS_PAGE 4096
-#if defined(CONFIG_ACPI)
-void nouveau_register_dsm_handler(void);
-void nouveau_unregister_dsm_handler(void);
-void nouveau_switcheroo_optimus_dsm(void);
-int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len);
-bool nouveau_acpi_rom_supported(struct pci_dev *pdev);
-int nouveau_acpi_edid(struct drm_device *, struct drm_connector *);
-#else
-static inline void nouveau_register_dsm_handler(void) {}
-static inline void nouveau_unregister_dsm_handler(void) {}
-static inline void nouveau_switcheroo_optimus_dsm(void) {}
-static inline bool nouveau_acpi_rom_supported(struct pci_dev *pdev) { return false; }
-static inline int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len) { return -EINVAL; }
-static inline int nouveau_acpi_edid(struct drm_device *dev, struct drm_connector *connector) { return -EINVAL; }
-#endif
-
-/* nouveau_backlight.c */
-#ifdef CONFIG_DRM_NOUVEAU_BACKLIGHT
-extern int nouveau_backlight_init(struct drm_device *);
-extern void nouveau_backlight_exit(struct drm_device *);
-#else
-static inline int nouveau_backlight_init(struct drm_device *dev)
-{
-        return 0;
-}
-
-static inline void nouveau_backlight_exit(struct drm_device *dev) { }
-#endif
-
-/* nouveau_bios.c */
-extern int nouveau_bios_init(struct drm_device *);
-extern void nouveau_bios_takedown(struct drm_device *dev);
-extern int nouveau_run_vbios_init(struct drm_device *);
-extern void nouveau_bios_run_init_table(struct drm_device *, uint16_t table,
-                                        struct dcb_entry *, int crtc);
-extern void nouveau_bios_init_exec(struct drm_device *, uint16_t table);
-extern struct dcb_connector_table_entry *
-nouveau_bios_connector_entry(struct drm_device *, int index);
-extern u32 get_pll_register(struct drm_device *, enum pll_types);
-extern int get_pll_limits(struct drm_device *, uint32_t limit_match,
-                          struct pll_lims *);
-extern int nouveau_bios_run_display_table(struct drm_device *, u16 id, int clk,
-                                          struct dcb_entry *, int crtc);
-extern bool nouveau_bios_fp_mode(struct drm_device *, struct drm_display_mode *);
-extern uint8_t *nouveau_bios_embedded_edid(struct drm_device *);
-extern int nouveau_bios_parse_lvds_table(struct drm_device *, int pxclk,
-                                         bool *dl, bool *if_is_24bit);
-extern int run_tmds_table(struct drm_device *, struct dcb_entry *,
-                          int head, int pxclk);
-extern int call_lvds_script(struct drm_device *, struct dcb_entry *, int head,
-                            enum LVDS_script, int pxclk);
-bool bios_encoder_match(struct dcb_entry *, u32 hash);
-
-/* nouveau_mxm.c */
-int  nouveau_mxm_init(struct drm_device *dev);
-void nouveau_mxm_fini(struct drm_device *dev);
-
-/* nouveau_ttm.c */
-int nouveau_ttm_global_init(struct drm_nouveau_private *);
-void nouveau_ttm_global_release(struct drm_nouveau_private *);
-int nouveau_ttm_mmap(struct file *, struct vm_area_struct *);
-
-/* nouveau_hdmi.c */
-void nouveau_hdmi_mode_set(struct drm_encoder *, struct drm_display_mode *);
-
-/* nv04_fb.c */
-extern int  nv04_fb_vram_init(struct drm_device *);
-extern int  nv04_fb_init(struct drm_device *);
-extern void nv04_fb_takedown(struct drm_device *);
-
-/* nv10_fb.c */
-extern int  nv10_fb_vram_init(struct drm_device *dev);
-extern int  nv1a_fb_vram_init(struct drm_device *dev);
-extern int  nv10_fb_init(struct drm_device *);
-extern void nv10_fb_takedown(struct drm_device *);
-extern void nv10_fb_init_tile_region(struct drm_device *dev, int i,
-                                     uint32_t addr, uint32_t size,
-                                     uint32_t pitch, uint32_t flags);
-extern void nv10_fb_set_tile_region(struct drm_device *dev, int i);
-extern void nv10_fb_free_tile_region(struct drm_device *dev, int i);
-
-/* nv20_fb.c */
-extern int  nv20_fb_vram_init(struct drm_device *dev);
-extern int  nv20_fb_init(struct drm_device *);
-extern void nv20_fb_takedown(struct drm_device *);
-extern void nv20_fb_init_tile_region(struct drm_device *dev, int i,
-                                     uint32_t addr, uint32_t size,
-                                     uint32_t pitch, uint32_t flags);
-extern void nv20_fb_set_tile_region(struct drm_device *dev, int i);
-extern void nv20_fb_free_tile_region(struct drm_device *dev, int i);
-
-/* nv30_fb.c */
-extern int  nv30_fb_init(struct drm_device *);
-extern void nv30_fb_takedown(struct drm_device *);
-extern void nv30_fb_init_tile_region(struct drm_device *dev, int i,
-                                     uint32_t addr, uint32_t size,
-                                     uint32_t pitch, uint32_t flags);
-extern void nv30_fb_free_tile_region(struct drm_device *dev, int i);
-
-/* nv40_fb.c */
-extern int  nv40_fb_vram_init(struct drm_device *dev);
-extern int  nv40_fb_init(struct drm_device *);
-extern void nv40_fb_takedown(struct drm_device *);
-extern void nv40_fb_set_tile_region(struct drm_device *dev, int i);
-
-/* nv50_fb.c */
-extern int  nv50_fb_init(struct drm_device *);
-extern void nv50_fb_takedown(struct drm_device *);
-extern void nv50_fb_vm_trap(struct drm_device *, int display);
-
-/* nvc0_fb.c */
-extern int  nvc0_fb_init(struct drm_device *);
-extern void nvc0_fb_takedown(struct drm_device *);
-
-/* nv04_graph.c */
-extern int  nv04_graph_create(struct drm_device *);
-extern int  nv04_graph_object_new(struct nouveau_channel *, int, u32, u16);
-extern int  nv04_graph_mthd_page_flip(struct nouveau_channel *chan,
-                                      u32 class, u32 mthd, u32 data);
-extern struct nouveau_bitfield nv04_graph_nsource[];
-
-/* nv10_graph.c */
-extern int  nv10_graph_create(struct drm_device *);
-extern struct nouveau_channel *nv10_graph_channel(struct drm_device *);
-extern struct nouveau_bitfield nv10_graph_intr[];
-extern struct nouveau_bitfield nv10_graph_nstatus[];
-
-/* nv20_graph.c */
-extern int  nv20_graph_create(struct drm_device *);
-
-/* nv40_graph.c */
-extern int  nv40_graph_create(struct drm_device *);
-extern void nv40_grctx_init(struct drm_device *, u32 *size);
-extern void nv40_grctx_fill(struct drm_device *, struct nouveau_gpuobj *);
-
-/* nv50_graph.c */
-extern int  nv50_graph_create(struct drm_device *);
-extern struct nouveau_enum nv50_data_error_names[];
-extern int  nv50_graph_isr_chid(struct drm_device *dev, u64 inst);
-extern int  nv50_grctx_init(struct drm_device *, u32 *, u32, u32 *, u32 *);
-extern void nv50_grctx_fill(struct drm_device *, struct nouveau_gpuobj *);
-
-/* nvc0_graph.c */
-extern int  nvc0_graph_create(struct drm_device *);
-extern int  nvc0_graph_isr_chid(struct drm_device *dev, u64 inst);
-
-/* nve0_graph.c */
-extern int  nve0_graph_create(struct drm_device *);
-
-/* nv84_crypt.c */
-extern int  nv84_crypt_create(struct drm_device *);
-
-/* nv98_crypt.c */
-extern int  nv98_crypt_create(struct drm_device *dev);
-
-/* nva3_copy.c */
-extern int  nva3_copy_create(struct drm_device *dev);
-
-/* nvc0_copy.c */
-extern int  nvc0_copy_create(struct drm_device *dev, int engine);
-
-/* nv31_mpeg.c */
-extern int  nv31_mpeg_create(struct drm_device *dev);
-
-/* nv50_mpeg.c */
-extern int  nv50_mpeg_create(struct drm_device *dev);
-
-/* nv84_bsp.c */
-/* nv98_bsp.c */
-extern int  nv84_bsp_create(struct drm_device *dev);
-
-/* nv84_vp.c */
-/* nv98_vp.c */
-extern int  nv84_vp_create(struct drm_device *dev);
-
-/* nv98_ppp.c */
-extern int  nv98_ppp_create(struct drm_device *dev);
-
-/* nv04_instmem.c */
-extern int  nv04_instmem_init(struct drm_device *);
-extern void nv04_instmem_takedown(struct drm_device *);
-extern int  nv04_instmem_suspend(struct drm_device *);
-extern void nv04_instmem_resume(struct drm_device *);
-extern int  nv04_instmem_get(struct nouveau_gpuobj *, struct nouveau_channel *,
-                             u32 size, u32 align);
-extern void nv04_instmem_put(struct nouveau_gpuobj *);
-extern int  nv04_instmem_map(struct nouveau_gpuobj *);
-extern void nv04_instmem_unmap(struct nouveau_gpuobj *);
-extern void nv04_instmem_flush(struct drm_device *);
-
-/* nv50_instmem.c */
-extern int  nv50_instmem_init(struct drm_device *);
-extern void nv50_instmem_takedown(struct drm_device *);
-extern int  nv50_instmem_suspend(struct drm_device *);
-extern void nv50_instmem_resume(struct drm_device *);
-extern int  nv50_instmem_get(struct nouveau_gpuobj *, struct nouveau_channel *,
-                             u32 size, u32 align);
-extern void nv50_instmem_put(struct nouveau_gpuobj *);
-extern int  nv50_instmem_map(struct nouveau_gpuobj *);
-extern void nv50_instmem_unmap(struct nouveau_gpuobj *);
-extern void nv50_instmem_flush(struct drm_device *);
-extern void nv84_instmem_flush(struct drm_device *);
-
-/* 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 *);
-
-/* nv04_mc.c */
-extern int  nv04_mc_init(struct drm_device *);
-extern void nv04_mc_takedown(struct drm_device *);
-
-/* nv40_mc.c */
-extern int  nv40_mc_init(struct drm_device *);
-extern void nv40_mc_takedown(struct drm_device *);
-
-/* nv50_mc.c */
-extern int  nv50_mc_init(struct drm_device *);
-extern void nv50_mc_takedown(struct drm_device *);
-
-/* nv04_timer.c */
-extern int  nv04_timer_init(struct drm_device *);
-extern uint64_t nv04_timer_read(struct drm_device *);
-extern void nv04_timer_takedown(struct drm_device *);
-
-extern long nouveau_compat_ioctl(struct file *file, unsigned int cmd,
-                                 unsigned long arg);
-
-/* nv04_dac.c */
-extern int nv04_dac_create(struct drm_connector *, struct dcb_entry *);
-extern uint32_t nv17_dac_sample_load(struct drm_encoder *encoder);
-extern int nv04_dac_output_offset(struct drm_encoder *encoder);
-extern void nv04_dac_update_dacclk(struct drm_encoder *encoder, bool enable);
-extern bool nv04_dac_in_use(struct drm_encoder *encoder);
-
-/* nv04_dfp.c */
-extern int nv04_dfp_create(struct drm_connector *, struct dcb_entry *);
-extern int nv04_dfp_get_bound_head(struct drm_device *dev, struct dcb_entry *dcbent);
-extern void nv04_dfp_bind_head(struct drm_device *dev, struct dcb_entry *dcbent,
-                               int head, bool dl);
-extern void nv04_dfp_disable(struct drm_device *dev, int head);
-extern void nv04_dfp_update_fp_control(struct drm_encoder *encoder, int mode);
-
-/* nv04_tv.c */
-extern int nv04_tv_identify(struct drm_device *dev, int i2c_index);
-extern int nv04_tv_create(struct drm_connector *, struct dcb_entry *);
-
-/* nv17_tv.c */
-extern int nv17_tv_create(struct drm_connector *, struct dcb_entry *);
-
-/* nv04_display.c */
-extern int nv04_display_early_init(struct drm_device *);
-extern void nv04_display_late_takedown(struct drm_device *);
-extern int nv04_display_create(struct drm_device *);
-extern void nv04_display_destroy(struct drm_device *);
-extern int nv04_display_init(struct drm_device *);
-extern void nv04_display_fini(struct drm_device *);
-
-/* nvd0_display.c */
-extern int nvd0_display_create(struct drm_device *);
-extern void nvd0_display_destroy(struct drm_device *);
-extern int nvd0_display_init(struct drm_device *);
-extern void nvd0_display_fini(struct drm_device *);
-struct nouveau_bo *nvd0_display_crtc_sema(struct drm_device *, int crtc);
-void nvd0_display_flip_stop(struct drm_crtc *);
-int nvd0_display_flip_next(struct drm_crtc *, struct drm_framebuffer *,
-                           struct nouveau_channel *, u32 swap_interval);
-
-/* nv04_crtc.c */
-extern int nv04_crtc_create(struct drm_device *, int index);
-
-/* nouveau_bo.c */
-extern struct ttm_bo_driver nouveau_bo_driver;
-extern void nouveau_bo_move_init(struct nouveau_channel *);
-extern int nouveau_bo_new(struct drm_device *, int size, int align,
-                          uint32_t flags, uint32_t tile_mode,
-                          uint32_t tile_flags,
-                          struct sg_table *sg,
-                          struct nouveau_bo **);
-extern int nouveau_bo_pin(struct nouveau_bo *, uint32_t flags);
-extern int nouveau_bo_unpin(struct nouveau_bo *);
-extern int nouveau_bo_map(struct nouveau_bo *);
-extern void nouveau_bo_unmap(struct nouveau_bo *);
-extern void nouveau_bo_placement_set(struct nouveau_bo *, uint32_t type,
-                                     uint32_t busy);
-extern u16 nouveau_bo_rd16(struct nouveau_bo *nvbo, unsigned index);
-extern void nouveau_bo_wr16(struct nouveau_bo *nvbo, unsigned index, u16 val);
-extern u32 nouveau_bo_rd32(struct nouveau_bo *nvbo, unsigned index);
-extern void nouveau_bo_wr32(struct nouveau_bo *nvbo, unsigned index, u32 val);
-extern void nouveau_bo_fence(struct nouveau_bo *, struct nouveau_fence *);
-extern int nouveau_bo_validate(struct nouveau_bo *, bool interruptible,
-                               bool no_wait_reserve, bool no_wait_gpu);
-
-extern struct nouveau_vma *
-nouveau_bo_vma_find(struct nouveau_bo *, struct nouveau_vm *);
-extern int  nouveau_bo_vma_add(struct nouveau_bo *, struct nouveau_vm *,
-                               struct nouveau_vma *);
-extern void nouveau_bo_vma_del(struct nouveau_bo *, struct nouveau_vma *);
-
-/* nouveau_gem.c */
-extern int nouveau_gem_new(struct drm_device *, int size, int align,
-                           uint32_t domain, uint32_t tile_mode,
-                           uint32_t tile_flags, struct nouveau_bo **);
-extern int nouveau_gem_object_new(struct drm_gem_object *);
-extern void nouveau_gem_object_del(struct drm_gem_object *);
-extern int nouveau_gem_object_open(struct drm_gem_object *, struct drm_file *);
-extern void nouveau_gem_object_close(struct drm_gem_object *,
-                                     struct drm_file *);
-extern int nouveau_gem_ioctl_new(struct drm_device *, void *,
-                                 struct drm_file *);
-extern int nouveau_gem_ioctl_pushbuf(struct drm_device *, void *,
-                                     struct drm_file *);
-extern int nouveau_gem_ioctl_cpu_prep(struct drm_device *, void *,
-                                      struct drm_file *);
-extern int nouveau_gem_ioctl_cpu_fini(struct drm_device *, void *,
-                                      struct drm_file *);
-extern int nouveau_gem_ioctl_info(struct drm_device *, void *,
-                                  struct drm_file *);
-
-extern struct dma_buf *nouveau_gem_prime_export(struct drm_device *dev,
-                                struct drm_gem_object *obj, int flags);
-extern struct drm_gem_object *nouveau_gem_prime_import(struct drm_device *dev,
-                                struct dma_buf *dma_buf);
-
-/* nouveau_display.c */
-int nouveau_display_create(struct drm_device *dev);
-void nouveau_display_destroy(struct drm_device *dev);
-int nouveau_display_init(struct drm_device *dev);
-void nouveau_display_fini(struct drm_device *dev);
-int nouveau_vblank_enable(struct drm_device *dev, int crtc);
-void nouveau_vblank_disable(struct drm_device *dev, int crtc);
-int nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
-                           struct drm_pending_vblank_event *event);
-int nouveau_finish_page_flip(struct nouveau_channel *,
-                             struct nouveau_page_flip_state *);
-int nouveau_display_dumb_create(struct drm_file *, struct drm_device *,
-                                struct drm_mode_create_dumb *args);
-int nouveau_display_dumb_map_offset(struct drm_file *, struct drm_device *,
-                                    uint32_t handle, uint64_t *offset);
-int nouveau_display_dumb_destroy(struct drm_file *, struct drm_device *,
-                                 uint32_t handle);
-
-/* nv10_gpio.c */
-int nv10_gpio_init(struct drm_device *dev);
-void nv10_gpio_fini(struct drm_device *dev);
-int nv10_gpio_drive(struct drm_device *dev, int line, int dir, int out);
-int nv10_gpio_sense(struct drm_device *dev, int line);
-void nv10_gpio_irq_enable(struct drm_device *, int line, bool on);
-
-/* nv50_gpio.c */
-int nv50_gpio_init(struct drm_device *dev);
-void nv50_gpio_fini(struct drm_device *dev);
-int nv50_gpio_drive(struct drm_device *dev, int line, int dir, int out);
-int nv50_gpio_sense(struct drm_device *dev, int line);
-void nv50_gpio_irq_enable(struct drm_device *, int line, bool on);
-int nvd0_gpio_drive(struct drm_device *dev, int line, int dir, int out);
-int nvd0_gpio_sense(struct drm_device *dev, int line);
-
-/* nv50_calc.c */
-int nv50_calc_pll(struct drm_device *, struct pll_lims *, int clk,
-                  int *N1, int *M1, int *N2, int *M2, int *P);
-int nva3_calc_pll(struct drm_device *, struct pll_lims *,
-                  int clk, int *N, int *fN, int *M, int *P);
-
-#ifndef ioread32_native
-#ifdef __BIG_ENDIAN
-#define ioread16_native ioread16be
-#define iowrite16_native iowrite16be
-#define ioread32_native  ioread32be
-#define iowrite32_native iowrite32be
-#else /* def __BIG_ENDIAN */
-#define ioread16_native ioread16
-#define iowrite16_native iowrite16
-#define ioread32_native  ioread32
-#define iowrite32_native iowrite32
-#endif /* def __BIG_ENDIAN else */
-#endif /* !ioread32_native */
-
-/* channel control reg access */
-static inline u32 nvchan_rd32(struct nouveau_channel *chan, unsigned reg)
-{
-        return ioread32_native(chan->user + reg);
-}
-
-static inline void nvchan_wr32(struct nouveau_channel *chan,
-                                                        unsigned reg, u32 val)
-{
-        iowrite32_native(val, chan->user + reg);
-}
-
-/* register access */
-static inline u32 nv_rd32(struct drm_device *dev, unsigned reg)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return ioread32_native(dev_priv->mmio + reg);
-}
-
-static inline void nv_wr32(struct drm_device *dev, unsigned reg, u32 val)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        iowrite32_native(val, dev_priv->mmio + reg);
-}
-
-static inline u32 nv_mask(struct drm_device *dev, u32 reg, u32 mask, u32 val)
-{
-        u32 tmp = nv_rd32(dev, reg);
-        nv_wr32(dev, reg, (tmp & ~mask) | val);
-        return tmp;
-}
-
-static inline u8 nv_rd08(struct drm_device *dev, unsigned reg)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return ioread8(dev_priv->mmio + reg);
-}
-
-static inline void nv_wr08(struct drm_device *dev, unsigned reg, u8 val)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        iowrite8(val, dev_priv->mmio + reg);
-}
-
-#define nv_wait(dev, reg, mask, val) \
-        nouveau_wait_eq(dev, 2000000000ULL, (reg), (mask), (val))
-#define nv_wait_ne(dev, reg, mask, val) \
-        nouveau_wait_ne(dev, 2000000000ULL, (reg), (mask), (val))
-#define nv_wait_cb(dev, func, data) \
-        nouveau_wait_cb(dev, 2000000000ULL, (func), (data))
-
-/* PRAMIN access */
-static inline u32 nv_ri32(struct drm_device *dev, unsigned offset)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return ioread32_native(dev_priv->ramin + offset);
-}
-
-static inline void nv_wi32(struct drm_device *dev, unsigned offset, u32 val)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        iowrite32_native(val, dev_priv->ramin + offset);
-}
-
-/* object access */
-extern u32 nv_ro32(struct nouveau_gpuobj *, u32 offset);
-extern void nv_wo32(struct nouveau_gpuobj *, u32 offset, u32 val);
-
-/*
- * Logging
- * Argument d is (struct drm_device *).
- */
-#define NV_PRINTK(level, d, fmt, arg...) \
-        printk(level "[" DRM_NAME "] " DRIVER_NAME " %s: " fmt, \
-                                        pci_name(d->pdev), ##arg)
-#ifndef NV_DEBUG_NOTRACE
-#define NV_DEBUG(d, fmt, arg...) do {                                          \
-        if (drm_debug & DRM_UT_DRIVER) {                                       \
-                NV_PRINTK(KERN_DEBUG, d, "%s:%d - " fmt, __func__,             \
-                          __LINE__, ##arg);                                    \
-        }                                                                      \
-} while (0)
-#define NV_DEBUG_KMS(d, fmt, arg...) do {                                      \
-        if (drm_debug & DRM_UT_KMS) {                                          \
-                NV_PRINTK(KERN_DEBUG, d, "%s:%d - " fmt, __func__,             \
-                          __LINE__, ##arg);                                    \
-        }                                                                      \
-} while (0)
-#else
-#define NV_DEBUG(d, fmt, arg...) do {                                          \
-        if (drm_debug & DRM_UT_DRIVER)                                         \
-                NV_PRINTK(KERN_DEBUG, d, fmt, ##arg);                          \
-} while (0)
-#define NV_DEBUG_KMS(d, fmt, arg...) do {                                      \
-        if (drm_debug & DRM_UT_KMS)                                            \
-                NV_PRINTK(KERN_DEBUG, d, fmt, ##arg);                          \
-} while (0)
-#endif
-#define NV_ERROR(d, fmt, arg...) NV_PRINTK(KERN_ERR, d, fmt, ##arg)
-#define NV_INFO(d, fmt, arg...) NV_PRINTK(KERN_INFO, d, fmt, ##arg)
-#define NV_TRACEWARN(d, fmt, arg...) NV_PRINTK(KERN_NOTICE, d, fmt, ##arg)
-#define NV_TRACE(d, fmt, arg...) NV_PRINTK(KERN_INFO, d, fmt, ##arg)
-#define NV_WARN(d, fmt, arg...) NV_PRINTK(KERN_WARNING, d, fmt, ##arg)
-#define NV_WARNONCE(d, fmt, arg...) do {                                       \
-        static int _warned = 0;                                                \
-        if (!_warned) {                                                        \
-                NV_WARN(d, fmt, ##arg);                                        \
-                _warned = 1;                                                   \
-        }                                                                      \
-} while(0)
-
-/* nouveau_reg_debug bitmask */
-enum {
-        NOUVEAU_REG_DEBUG_MC             = 0x1,
-        NOUVEAU_REG_DEBUG_VIDEO          = 0x2,
-        NOUVEAU_REG_DEBUG_FB             = 0x4,
-        NOUVEAU_REG_DEBUG_EXTDEV         = 0x8,
-        NOUVEAU_REG_DEBUG_CRTC           = 0x10,
-        NOUVEAU_REG_DEBUG_RAMDAC         = 0x20,
-        NOUVEAU_REG_DEBUG_VGACRTC        = 0x40,
-        NOUVEAU_REG_DEBUG_RMVIO          = 0x80,
-        NOUVEAU_REG_DEBUG_VGAATTR        = 0x100,
-        NOUVEAU_REG_DEBUG_EVO            = 0x200,
-        NOUVEAU_REG_DEBUG_AUXCH          = 0x400
-};
-
-#define NV_REG_DEBUG(type, dev, fmt, arg...) do { \
-        if (nouveau_reg_debug & NOUVEAU_REG_DEBUG_##type) \
-                NV_PRINTK(KERN_DEBUG, dev, "%s: " fmt, __func__, ##arg); \
-} while (0)
-
-static inline bool
-nv_two_heads(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        const int impl = dev->pci_device & 0x0ff0;
-
-        if (dev_priv->card_type >= NV_10 && impl != 0x0100 &&
-            impl != 0x0150 && impl != 0x01a0 && impl != 0x0200)
-                return true;
-
-        return false;
-}
-
-static inline bool
-nv_gf4_disp_arch(struct drm_device *dev)
-{
-        return nv_two_heads(dev) && (dev->pci_device & 0x0ff0) != 0x0110;
-}
-
-static inline bool
-nv_two_reg_pll(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        const int impl = dev->pci_device & 0x0ff0;
-
-        if (impl == 0x0310 || impl == 0x0340 || dev_priv->card_type >= NV_40)
-                return true;
-        return false;
-}
-
-static inline bool
-nv_match_device(struct drm_device *dev, unsigned device,
-                unsigned sub_vendor, unsigned sub_device)
-{
-        return dev->pdev->device == device &&
-                dev->pdev->subsystem_vendor == sub_vendor &&
-                dev->pdev->subsystem_device == sub_device;
-}
-
-static inline void *
-nv_engine(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return (void *)dev_priv->eng[engine];
-}
-
-/* returns 1 if device is one of the nv4x using the 0x4497 object class,
- * helpful to determine a number of other hardware features
- */
-static inline int
-nv44_graph_class(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if ((dev_priv->chipset & 0xf0) == 0x60)
-                return 1;
-
-        return !(0x0baf & (1 << (dev_priv->chipset & 0x0f)));
-}
-
-/* memory type/access flags, do not match hardware values */
-#define NV_MEM_ACCESS_RO  1
-#define NV_MEM_ACCESS_WO  2
-#define NV_MEM_ACCESS_RW (NV_MEM_ACCESS_RO | NV_MEM_ACCESS_WO)
-#define NV_MEM_ACCESS_SYS 4
-#define NV_MEM_ACCESS_VM  8
-#define NV_MEM_ACCESS_NOSNOOP 16
-
-#define NV_MEM_TARGET_VRAM        0
-#define NV_MEM_TARGET_PCI         1
-#define NV_MEM_TARGET_PCI_NOSNOOP 2
-#define NV_MEM_TARGET_VM          3
-#define NV_MEM_TARGET_GART        4
-
-#define NV_MEM_TYPE_VM 0x7f
-#define NV_MEM_COMP_VM 0x03
-
-/* FIFO methods */
-#define NV01_SUBCHAN_OBJECT                                          0x00000000
-#define NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH                          0x00000010
-#define NV84_SUBCHAN_SEMAPHORE_ADDRESS_LOW                           0x00000014
-#define NV84_SUBCHAN_SEMAPHORE_SEQUENCE                              0x00000018
-#define NV84_SUBCHAN_SEMAPHORE_TRIGGER                               0x0000001c
-#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_EQUAL                 0x00000001
-#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_WRITE_LONG                    0x00000002
-#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_GEQUAL                0x00000004
-#define NVC0_SUBCHAN_SEMAPHORE_TRIGGER_YIELD                         0x00001000
-#define NV84_SUBCHAN_NOTIFY_INTR                                     0x00000020
-#define NV84_SUBCHAN_WRCACHE_FLUSH                                   0x00000024
-#define NV10_SUBCHAN_REF_CNT                                         0x00000050
-#define NVSW_SUBCHAN_PAGE_FLIP                                       0x00000054
-#define NV11_SUBCHAN_DMA_SEMAPHORE                                   0x00000060
-#define NV11_SUBCHAN_SEMAPHORE_OFFSET                                0x00000064
-#define NV11_SUBCHAN_SEMAPHORE_ACQUIRE                               0x00000068
-#define NV11_SUBCHAN_SEMAPHORE_RELEASE                               0x0000006c
-#define NV40_SUBCHAN_YIELD                                           0x00000080
-
-/* NV_SW object class */
-#define NV_SW                                                        0x0000506e
-#define NV_SW_DMA_VBLSEM                                             0x0000018c
-#define NV_SW_VBLSEM_OFFSET                                          0x00000400
-#define NV_SW_VBLSEM_RELEASE_VALUE                                   0x00000404
-#define NV_SW_VBLSEM_RELEASE                                         0x00000408
-#define NV_SW_PAGE_FLIP                                              0x00000500
-
-#endif /* __NOUVEAU_DRV_H__ */
diff --git a/drivers/gpu/drm/nouveau/nouveau_encoder.h b/drivers/gpu/drm/nouveau/nouveau_encoder.h
index 3dc14a3dcc4c..5b5d0148f8bf 100644
--- a/drivers/gpu/drm/nouveau/nouveau_encoder.h
+++ b/drivers/gpu/drm/nouveau/nouveau_encoder.h
@@ -27,23 +27,27 @@
 #ifndef __NOUVEAU_ENCODER_H__
 #define __NOUVEAU_ENCODER_H__
 
+#include <subdev/bios/dcb.h>
+
 #include "drm_encoder_slave.h"
-#include "nouveau_drv.h"
+#include "nv04_display.h"
 
 #define NV_DPMS_CLEARED 0x80
 
+struct nouveau_i2c_port;
+
 struct dp_train_func {
-        void (*link_set)(struct drm_device *, struct dcb_entry *, int crtc,
+        void (*link_set)(struct drm_device *, struct dcb_output *, int crtc,
                          int nr, u32 bw, bool enhframe);
-        void (*train_set)(struct drm_device *, struct dcb_entry *, u8 pattern);
-        void (*train_adj)(struct drm_device *, struct dcb_entry *,
+        void (*train_set)(struct drm_device *, struct dcb_output *, u8 pattern);
+        void (*train_adj)(struct drm_device *, struct dcb_output *,
                           u8 lane, u8 swing, u8 preem);
 };
 
 struct nouveau_encoder {
         struct drm_encoder_slave base;
 
-        struct dcb_entry *dcb;
+        struct dcb_output *dcb;
         int or;
 
         /* different to drm_encoder.crtc, this reflects what's
@@ -87,18 +91,16 @@ get_slave_funcs(struct drm_encoder *enc)
 }
 
 /* nouveau_dp.c */
-int nouveau_dp_auxch(struct nouveau_i2c_chan *auxch, int cmd, int addr,
-                     uint8_t *data, int data_nr);
 bool nouveau_dp_detect(struct drm_encoder *);
 void nouveau_dp_dpms(struct drm_encoder *, int mode, u32 datarate,
                      struct dp_train_func *);
-u8 *nouveau_dp_bios_data(struct drm_device *, struct dcb_entry *, u8 **);
+u8 *nouveau_dp_bios_data(struct drm_device *, struct dcb_output *, u8 **);
 
 struct nouveau_connector *
 nouveau_encoder_connector_get(struct nouveau_encoder *encoder);
-int nv50_sor_create(struct drm_connector *, struct dcb_entry *);
+int nv50_sor_create(struct drm_connector *, struct dcb_output *);
 void nv50_sor_dp_calc_tu(struct drm_device *, int, int, u32, u32);
-int nv50_dac_create(struct drm_connector *, struct dcb_entry *);
+int nv50_dac_create(struct drm_connector *, struct dcb_output *);
 
 
 #endif /* __NOUVEAU_ENCODER_H__ */
diff --git a/drivers/gpu/drm/nouveau/nouveau_fb.h b/drivers/gpu/drm/nouveau/nouveau_fb.h
deleted file mode 100644
index f3fb649fe454..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_fb.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2008 Maarten Maathuis.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#ifndef __NOUVEAU_FB_H__
-#define __NOUVEAU_FB_H__
-
-struct nouveau_framebuffer {
-        struct drm_framebuffer base;
-        struct nouveau_bo *nvbo;
-        struct nouveau_vma vma;
-        u32 r_dma;
-        u32 r_format;
-        u32 r_pitch;
-};
-
-static inline struct nouveau_framebuffer *
-nouveau_framebuffer(struct drm_framebuffer *fb)
-{
-        return container_of(fb, struct nouveau_framebuffer, base);
-}
-
-int nouveau_framebuffer_init(struct drm_device *dev, struct nouveau_framebuffer *nouveau_fb,
-                             struct drm_mode_fb_cmd2 *mode_cmd, struct nouveau_bo *nvbo);
-#endif /* __NOUVEAU_FB_H__ */
diff --git a/drivers/gpu/drm/nouveau/nouveau_fbcon.c b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
index 1074bc5dd418..e75e071845b7 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fbcon.c
@@ -43,19 +43,30 @@
 #include "drm_crtc.h"
 #include "drm_crtc_helper.h"
 #include "drm_fb_helper.h"
-#include "nouveau_drv.h"
+
 #include "nouveau_drm.h"
-#include "nouveau_crtc.h"
-#include "nouveau_fb.h"
+#include "nouveau_gem.h"
+#include "nouveau_bo.h"
 #include "nouveau_fbcon.h"
-#include "nouveau_dma.h"
+#include "nouveau_chan.h"
+
+#include "nouveau_crtc.h"
+
+#include <core/client.h>
+#include <core/device.h>
+
+#include <subdev/fb.h>
+
+MODULE_PARM_DESC(nofbaccel, "Disable fbcon acceleration");
+static int nouveau_nofbaccel = 0;
+module_param_named(nofbaccel, nouveau_nofbaccel, int, 0400);
 
 static void
 nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
-        struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_fbdev *fbcon = info->par;
+        struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int ret;
 
         if (info->state != FBINFO_STATE_RUNNING)
@@ -63,15 +74,15 @@ nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 
         ret = -ENODEV;
         if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
-            mutex_trylock(&dev_priv->channel->mutex)) {
-                if (dev_priv->card_type < NV_50)
+            mutex_trylock(&drm->client.mutex)) {
+                if (device->card_type < NV_50)
                         ret = nv04_fbcon_fillrect(info, rect);
                 else
-                if (dev_priv->card_type < NV_C0)
+                if (device->card_type < NV_C0)
                         ret = nv50_fbcon_fillrect(info, rect);
                 else
                         ret = nvc0_fbcon_fillrect(info, rect);
-                mutex_unlock(&dev_priv->channel->mutex);
+                mutex_unlock(&drm->client.mutex);
         }
 
         if (ret == 0)
@@ -85,9 +96,9 @@ nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 static void
 nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
 {
-        struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_fbdev *fbcon = info->par;
+        struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int ret;
 
         if (info->state != FBINFO_STATE_RUNNING)
@@ -95,15 +106,15 @@ nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
 
         ret = -ENODEV;
         if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
-            mutex_trylock(&dev_priv->channel->mutex)) {
-                if (dev_priv->card_type < NV_50)
+            mutex_trylock(&drm->client.mutex)) {
+                if (device->card_type < NV_50)
                         ret = nv04_fbcon_copyarea(info, image);
                 else
-                if (dev_priv->card_type < NV_C0)
+                if (device->card_type < NV_C0)
                         ret = nv50_fbcon_copyarea(info, image);
                 else
                         ret = nvc0_fbcon_copyarea(info, image);
-                mutex_unlock(&dev_priv->channel->mutex);
+                mutex_unlock(&drm->client.mutex);
         }
 
         if (ret == 0)
@@ -117,9 +128,9 @@ nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
 static void
 nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
 {
-        struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_fbdev *fbcon = info->par;
+        struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
+        struct nouveau_device *device = nv_device(drm->device);
         int ret;
 
         if (info->state != FBINFO_STATE_RUNNING)
@@ -127,15 +138,15 @@ nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
 
         ret = -ENODEV;
         if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
-            mutex_trylock(&dev_priv->channel->mutex)) {
-                if (dev_priv->card_type < NV_50)
+            mutex_trylock(&drm->client.mutex)) {
+                if (device->card_type < NV_50)
                         ret = nv04_fbcon_imageblit(info, image);
                 else
-                if (dev_priv->card_type < NV_C0)
+                if (device->card_type < NV_C0)
                         ret = nv50_fbcon_imageblit(info, image);
                 else
                         ret = nvc0_fbcon_imageblit(info, image);
-                mutex_unlock(&dev_priv->channel->mutex);
+                mutex_unlock(&drm->client.mutex);
         }
 
         if (ret == 0)
@@ -149,10 +160,9 @@ nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
 static int
 nouveau_fbcon_sync(struct fb_info *info)
 {
-        struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_fbdev *fbcon = info->par;
+        struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         if (!chan || !chan->accel_done || in_interrupt() ||
@@ -160,11 +170,11 @@ nouveau_fbcon_sync(struct fb_info *info)
             info->flags & FBINFO_HWACCEL_DISABLED)
                 return 0;
 
-        if (!mutex_trylock(&chan->mutex))
+        if (!mutex_trylock(&drm->client.mutex))
                 return 0;
 
         ret = nouveau_channel_idle(chan);
-        mutex_unlock(&chan->mutex);
+        mutex_unlock(&drm->client.mutex);
         if (ret) {
                 nouveau_fbcon_gpu_lockup(info);
                 return 0;
@@ -224,9 +234,9 @@ static void nouveau_fbcon_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
 }
 
 static void
-nouveau_fbcon_zfill(struct drm_device *dev, struct nouveau_fbdev *nfbdev)
+nouveau_fbcon_zfill(struct drm_device *dev, struct nouveau_fbdev *fbcon)
 {
-        struct fb_info *info = nfbdev->helper.fbdev;
+        struct fb_info *info = fbcon->helper.fbdev;
         struct fb_fillrect rect;
 
         /* Clear the entire fbcon.  The drm will program every connector
@@ -242,11 +252,12 @@ nouveau_fbcon_zfill(struct drm_device *dev, struct nouveau_fbdev *nfbdev)
 }
 
 static int
-nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
+nouveau_fbcon_create(struct nouveau_fbdev *fbcon,
                      struct drm_fb_helper_surface_size *sizes)
 {
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct drm_device *dev = fbcon->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
         struct fb_info *info;
         struct drm_framebuffer *fb;
         struct nouveau_framebuffer *nouveau_fb;
@@ -254,7 +265,6 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
         struct nouveau_bo *nvbo;
         struct drm_mode_fb_cmd2 mode_cmd;
         struct pci_dev *pdev = dev->pdev;
-        struct device *device = &pdev->dev;
         int size, ret;
 
         mode_cmd.width = sizes->surface_width;
@@ -272,37 +282,38 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
         ret = nouveau_gem_new(dev, size, 0, NOUVEAU_GEM_DOMAIN_VRAM,
                               0, 0x0000, &nvbo);
         if (ret) {
-                NV_ERROR(dev, "failed to allocate framebuffer\n");
+                NV_ERROR(drm, "failed to allocate framebuffer\n");
                 goto out;
         }
 
         ret = nouveau_bo_pin(nvbo, TTM_PL_FLAG_VRAM);
         if (ret) {
-                NV_ERROR(dev, "failed to pin fb: %d\n", ret);
+                NV_ERROR(drm, "failed to pin fb: %d\n", ret);
                 nouveau_bo_ref(NULL, &nvbo);
                 goto out;
         }
 
         ret = nouveau_bo_map(nvbo);
         if (ret) {
-                NV_ERROR(dev, "failed to map fb: %d\n", ret);
+                NV_ERROR(drm, "failed to map fb: %d\n", ret);
                 nouveau_bo_unpin(nvbo);
                 nouveau_bo_ref(NULL, &nvbo);
                 goto out;
         }
 
-        chan = nouveau_nofbaccel ? NULL : dev_priv->channel;
-        if (chan && dev_priv->card_type >= NV_50) {
-                ret = nouveau_bo_vma_add(nvbo, chan->vm, &nfbdev->nouveau_fb.vma);
+        chan = nouveau_nofbaccel ? NULL : drm->channel;
+        if (chan && device->card_type >= NV_50) {
+                ret = nouveau_bo_vma_add(nvbo, nv_client(chan->cli)->vm,
+                                        &fbcon->nouveau_fb.vma);
                 if (ret) {
-                        NV_ERROR(dev, "failed to map fb into chan: %d\n", ret);
+                        NV_ERROR(drm, "failed to map fb into chan: %d\n", ret);
                         chan = NULL;
                 }
         }
 
         mutex_lock(&dev->struct_mutex);
 
-        info = framebuffer_alloc(0, device);
+        info = framebuffer_alloc(0, &pdev->dev);
         if (!info) {
                 ret = -ENOMEM;
                 goto out_unref;
@@ -314,16 +325,16 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
                 goto out_unref;
         }
 
-        info->par = nfbdev;
+        info->par = fbcon;
 
-        nouveau_framebuffer_init(dev, &nfbdev->nouveau_fb, &mode_cmd, nvbo);
+        nouveau_framebuffer_init(dev, &fbcon->nouveau_fb, &mode_cmd, nvbo);
 
-        nouveau_fb = &nfbdev->nouveau_fb;
+        nouveau_fb = &fbcon->nouveau_fb;
         fb = &nouveau_fb->base;
 
         /* setup helper */
-        nfbdev->helper.fb = fb;
-        nfbdev->helper.fbdev = info;
+        fbcon->helper.fb = fb;
+        fbcon->helper.fbdev = info;
 
         strcpy(info->fix.id, "nouveaufb");
         if (nouveau_nofbaccel)
@@ -342,25 +353,18 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
         info->screen_size = size;
 
         drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
-        drm_fb_helper_fill_var(info, &nfbdev->helper, sizes->fb_width, sizes->fb_height);
-
-        /* Set aperture base/size for vesafb takeover */
-        info->apertures = dev_priv->apertures;
-        if (!info->apertures) {
-                ret = -ENOMEM;
-                goto out_unref;
-        }
+        drm_fb_helper_fill_var(info, &fbcon->helper, sizes->fb_width, sizes->fb_height);
 
         /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
 
         mutex_unlock(&dev->struct_mutex);
 
-        if (dev_priv->channel && !nouveau_nofbaccel) {
+        if (chan) {
                 ret = -ENODEV;
-                if (dev_priv->card_type < NV_50)
+                if (device->card_type < NV_50)
                         ret = nv04_fbcon_accel_init(info);
                 else
-                if (dev_priv->card_type < NV_C0)
+                if (device->card_type < NV_C0)
                         ret = nv50_fbcon_accel_init(info);
                 else
                         ret = nvc0_fbcon_accel_init(info);
@@ -369,13 +373,12 @@ nouveau_fbcon_create(struct nouveau_fbdev *nfbdev,
                         info->fbops = &nouveau_fbcon_ops;
         }
 
-        nouveau_fbcon_zfill(dev, nfbdev);
+        nouveau_fbcon_zfill(dev, fbcon);
 
         /* To allow resizeing without swapping buffers */
-        NV_INFO(dev, "allocated %dx%d fb: 0x%lx, bo %p\n",
-                                                nouveau_fb->base.width,
-                                                nouveau_fb->base.height,
-                                                nvbo->bo.offset, nvbo);
+        NV_INFO(drm, "allocated %dx%d fb: 0x%lx, bo %p\n",
+                nouveau_fb->base.width, nouveau_fb->base.height,
+                nvbo->bo.offset, nvbo);
 
         vga_switcheroo_client_fb_set(dev->pdev, info);
         return 0;
@@ -390,12 +393,12 @@ static int
 nouveau_fbcon_find_or_create_single(struct drm_fb_helper *helper,
                                     struct drm_fb_helper_surface_size *sizes)
 {
-        struct nouveau_fbdev *nfbdev = (struct nouveau_fbdev *)helper;
+        struct nouveau_fbdev *fbcon = (struct nouveau_fbdev *)helper;
         int new_fb = 0;
         int ret;
 
         if (!helper->fb) {
-                ret = nouveau_fbcon_create(nfbdev, sizes);
+                ret = nouveau_fbcon_create(fbcon, sizes);
                 if (ret)
                         return ret;
                 new_fb = 1;
@@ -406,18 +409,18 @@ nouveau_fbcon_find_or_create_single(struct drm_fb_helper *helper,
 void
 nouveau_fbcon_output_poll_changed(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        drm_fb_helper_hotplug_event(&dev_priv->nfbdev->helper);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        drm_fb_helper_hotplug_event(&drm->fbcon->helper);
 }
 
 static int
-nouveau_fbcon_destroy(struct drm_device *dev, struct nouveau_fbdev *nfbdev)
+nouveau_fbcon_destroy(struct drm_device *dev, struct nouveau_fbdev *fbcon)
 {
-        struct nouveau_framebuffer *nouveau_fb = &nfbdev->nouveau_fb;
+        struct nouveau_framebuffer *nouveau_fb = &fbcon->nouveau_fb;
         struct fb_info *info;
 
-        if (nfbdev->helper.fbdev) {
-                info = nfbdev->helper.fbdev;
+        if (fbcon->helper.fbdev) {
+                info = fbcon->helper.fbdev;
                 unregister_framebuffer(info);
                 if (info->cmap.len)
                         fb_dealloc_cmap(&info->cmap);
@@ -430,17 +433,17 @@ nouveau_fbcon_destroy(struct drm_device *dev, struct nouveau_fbdev *nfbdev)
                 drm_gem_object_unreference_unlocked(nouveau_fb->nvbo->gem);
                 nouveau_fb->nvbo = NULL;
         }
-        drm_fb_helper_fini(&nfbdev->helper);
+        drm_fb_helper_fini(&fbcon->helper);
         drm_framebuffer_cleanup(&nouveau_fb->base);
         return 0;
 }
 
 void nouveau_fbcon_gpu_lockup(struct fb_info *info)
 {
-        struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
+        struct nouveau_fbdev *fbcon = info->par;
+        struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
 
-        NV_ERROR(dev, "GPU lockup - switching to software fbcon\n");
+        NV_ERROR(drm, "GPU lockup - switching to software fbcon\n");
         info->flags |= FBINFO_HWACCEL_DISABLED;
 }
 
@@ -451,74 +454,81 @@ static struct drm_fb_helper_funcs nouveau_fbcon_helper_funcs = {
 };
 
 
-int nouveau_fbcon_init(struct drm_device *dev)
+int
+nouveau_fbcon_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fbdev *nfbdev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
+        struct nouveau_fbdev *fbcon;
         int preferred_bpp;
         int ret;
 
-        nfbdev = kzalloc(sizeof(struct nouveau_fbdev), GFP_KERNEL);
-        if (!nfbdev)
+        if (!dev->mode_config.num_crtc)
+                return 0;
+
+        fbcon = kzalloc(sizeof(struct nouveau_fbdev), GFP_KERNEL);
+        if (!fbcon)
                 return -ENOMEM;
 
-        nfbdev->dev = dev;
-        dev_priv->nfbdev = nfbdev;
-        nfbdev->helper.funcs = &nouveau_fbcon_helper_funcs;
+        fbcon->dev = dev;
+        drm->fbcon = fbcon;
+        fbcon->helper.funcs = &nouveau_fbcon_helper_funcs;
 
-        ret = drm_fb_helper_init(dev, &nfbdev->helper,
+        ret = drm_fb_helper_init(dev, &fbcon->helper,
                                  dev->mode_config.num_crtc, 4);
         if (ret) {
-                kfree(nfbdev);
+                kfree(fbcon);
                 return ret;
         }
 
-        drm_fb_helper_single_add_all_connectors(&nfbdev->helper);
+        drm_fb_helper_single_add_all_connectors(&fbcon->helper);
 
-        if (dev_priv->vram_size <= 32 * 1024 * 1024)
+        if (pfb->ram.size <= 32 * 1024 * 1024)
                 preferred_bpp = 8;
-        else if (dev_priv->vram_size <= 64 * 1024 * 1024)
+        else
+        if (pfb->ram.size <= 64 * 1024 * 1024)
                 preferred_bpp = 16;
         else
                 preferred_bpp = 32;
 
-        drm_fb_helper_initial_config(&nfbdev->helper, preferred_bpp);
+        drm_fb_helper_initial_config(&fbcon->helper, preferred_bpp);
         return 0;
 }
 
-void nouveau_fbcon_fini(struct drm_device *dev)
+void
+nouveau_fbcon_fini(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        if (!dev_priv->nfbdev)
+        if (!drm->fbcon)
                 return;
 
-        nouveau_fbcon_destroy(dev, dev_priv->nfbdev);
-        kfree(dev_priv->nfbdev);
-        dev_priv->nfbdev = NULL;
+        nouveau_fbcon_destroy(dev, drm->fbcon);
+        kfree(drm->fbcon);
+        drm->fbcon = NULL;
 }
 
 void nouveau_fbcon_save_disable_accel(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        dev_priv->nfbdev->saved_flags = dev_priv->nfbdev->helper.fbdev->flags;
-        dev_priv->nfbdev->helper.fbdev->flags |= FBINFO_HWACCEL_DISABLED;
+        drm->fbcon->saved_flags = drm->fbcon->helper.fbdev->flags;
+        drm->fbcon->helper.fbdev->flags |= FBINFO_HWACCEL_DISABLED;
 }
 
 void nouveau_fbcon_restore_accel(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        dev_priv->nfbdev->helper.fbdev->flags = dev_priv->nfbdev->saved_flags;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        drm->fbcon->helper.fbdev->flags = drm->fbcon->saved_flags;
 }
 
 void nouveau_fbcon_set_suspend(struct drm_device *dev, int state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         console_lock();
         if (state == 0)
                 nouveau_fbcon_save_disable_accel(dev);
-        fb_set_suspend(dev_priv->nfbdev->helper.fbdev, state);
+        fb_set_suspend(drm->fbcon->helper.fbdev, state);
         if (state == 1)
                 nouveau_fbcon_restore_accel(dev);
         console_unlock();
@@ -526,6 +536,6 @@ void nouveau_fbcon_set_suspend(struct drm_device *dev, int state)
 
 void nouveau_fbcon_zfill_all(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        nouveau_fbcon_zfill(dev, dev_priv->nfbdev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        nouveau_fbcon_zfill(dev, drm->fbcon);
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_fbcon.h b/drivers/gpu/drm/nouveau/nouveau_fbcon.h
index b73c29f87fc3..18e028008225 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fbcon.h
+++ b/drivers/gpu/drm/nouveau/nouveau_fbcon.h
@@ -29,7 +29,8 @@
 
 #include "drm_fb_helper.h"
 
-#include "nouveau_fb.h"
+#include "nouveau_display.h"
+
 struct nouveau_fbdev {
         struct drm_fb_helper helper;
         struct nouveau_framebuffer nouveau_fb;
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c
index 3c180493dab8..5b5471ba6eda 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.c
@@ -30,11 +30,9 @@
 #include <linux/ktime.h>
 #include <linux/hrtimer.h>
 
-#include "nouveau_drv.h"
-#include "nouveau_ramht.h"
-#include "nouveau_fence.h"
-#include "nouveau_software.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
+#include "nouveau_fence.h"
 
 void
 nouveau_fence_context_del(struct nouveau_fence_chan *fctx)
@@ -54,16 +52,16 @@ nouveau_fence_context_del(struct nouveau_fence_chan *fctx)
 void
 nouveau_fence_context_new(struct nouveau_fence_chan *fctx)
 {
+        INIT_LIST_HEAD(&fctx->flip);
         INIT_LIST_HEAD(&fctx->pending);
         spin_lock_init(&fctx->lock);
 }
 
-void
+static void
 nouveau_fence_update(struct nouveau_channel *chan)
 {
-        struct drm_device *dev = chan->dev;
-        struct nouveau_fence_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FENCE);
-        struct nouveau_fence_chan *fctx = chan->engctx[NVOBJ_ENGINE_FENCE];
+        struct nouveau_fence_priv *priv = chan->drm->fence;
+        struct nouveau_fence_chan *fctx = chan->fence;
         struct nouveau_fence *fence, *fnext;
 
         spin_lock(&fctx->lock);
@@ -83,9 +81,8 @@ nouveau_fence_update(struct nouveau_channel *chan)
 int
 nouveau_fence_emit(struct nouveau_fence *fence, struct nouveau_channel *chan)
 {
-        struct drm_device *dev = chan->dev;
-        struct nouveau_fence_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FENCE);
-        struct nouveau_fence_chan *fctx = chan->engctx[NVOBJ_ENGINE_FENCE];
+        struct nouveau_fence_priv *priv = chan->drm->fence;
+        struct nouveau_fence_chan *fctx = chan->fence;
         int ret;
 
         fence->channel  = chan;
@@ -147,19 +144,17 @@ nouveau_fence_wait(struct nouveau_fence *fence, bool lazy, bool intr)
 int
 nouveau_fence_sync(struct nouveau_fence *fence, struct nouveau_channel *chan)
 {
-        struct drm_device *dev = chan->dev;
-        struct nouveau_fence_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FENCE);
+        struct nouveau_fence_priv *priv = chan->drm->fence;
         struct nouveau_channel *prev;
         int ret = 0;
 
-        prev = fence ? nouveau_channel_get_unlocked(fence->channel) : NULL;
+        prev = fence ? fence->channel : NULL;
         if (prev) {
                 if (unlikely(prev != chan && !nouveau_fence_done(fence))) {
                         ret = priv->sync(fence, prev, chan);
                         if (unlikely(ret))
                                 ret = nouveau_fence_wait(fence, true, false);
                 }
-                nouveau_channel_put_unlocked(&prev);
         }
 
         return ret;
@@ -193,7 +188,7 @@ nouveau_fence_new(struct nouveau_channel *chan, struct nouveau_fence **pfence)
         struct nouveau_fence *fence;
         int ret = 0;
 
-        if (unlikely(!chan->engctx[NVOBJ_ENGINE_FENCE]))
+        if (unlikely(!chan->fence))
                 return -ENODEV;
 
         fence = kzalloc(sizeof(*fence), GFP_KERNEL);
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.h b/drivers/gpu/drm/nouveau/nouveau_fence.h
index 82ba733393ae..bedafd1c9539 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.h
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.h
@@ -1,6 +1,8 @@
 #ifndef __NOUVEAU_FENCE_H__
 #define __NOUVEAU_FENCE_H__
 
+struct nouveau_drm;
+
 struct nouveau_fence {
         struct list_head head;
         struct kref kref;
@@ -22,31 +24,48 @@ int  nouveau_fence_emit(struct nouveau_fence *, struct nouveau_channel *);
 bool nouveau_fence_done(struct nouveau_fence *);
 int  nouveau_fence_wait(struct nouveau_fence *, bool lazy, bool intr);
 int  nouveau_fence_sync(struct nouveau_fence *, struct nouveau_channel *);
-void nouveau_fence_idle(struct nouveau_channel *);
-void nouveau_fence_update(struct nouveau_channel *);
 
 struct nouveau_fence_chan {
         struct list_head pending;
+        struct list_head flip;
+
         spinlock_t lock;
         u32 sequence;
 };
 
 struct nouveau_fence_priv {
-        struct nouveau_exec_engine engine;
-        int (*emit)(struct nouveau_fence *);
-        int (*sync)(struct nouveau_fence *, struct nouveau_channel *,
-                    struct nouveau_channel *);
-        u32 (*read)(struct nouveau_channel *);
+        void (*dtor)(struct nouveau_drm *);
+        bool (*suspend)(struct nouveau_drm *);
+        void (*resume)(struct nouveau_drm *);
+        int  (*context_new)(struct nouveau_channel *);
+        void (*context_del)(struct nouveau_channel *);
+        int  (*emit)(struct nouveau_fence *);
+        int  (*sync)(struct nouveau_fence *, struct nouveau_channel *,
+                     struct nouveau_channel *);
+        u32  (*read)(struct nouveau_channel *);
 };
 
+#define nouveau_fence(drm) ((struct nouveau_fence_priv *)(drm)->fence)
+
 void nouveau_fence_context_new(struct nouveau_fence_chan *);
 void nouveau_fence_context_del(struct nouveau_fence_chan *);
 
-int nv04_fence_create(struct drm_device *dev);
+int nv04_fence_create(struct nouveau_drm *);
 int nv04_fence_mthd(struct nouveau_channel *, u32, u32, u32);
 
-int nv10_fence_create(struct drm_device *dev);
-int nv84_fence_create(struct drm_device *dev);
-int nvc0_fence_create(struct drm_device *dev);
+int  nv10_fence_emit(struct nouveau_fence *);
+int  nv17_fence_sync(struct nouveau_fence *, struct nouveau_channel *,
+                     struct nouveau_channel *);
+u32  nv10_fence_read(struct nouveau_channel *);
+void nv10_fence_context_del(struct nouveau_channel *);
+void nv10_fence_destroy(struct nouveau_drm *);
+int  nv10_fence_create(struct nouveau_drm *);
+
+int nv50_fence_create(struct nouveau_drm *);
+int nv84_fence_create(struct nouveau_drm *);
+int nvc0_fence_create(struct nouveau_drm *);
+u64 nvc0_fence_crtc(struct nouveau_channel *, int crtc);
+
+int nouveau_flip_complete(void *chan);
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_fifo.h b/drivers/gpu/drm/nouveau/nouveau_fifo.h
deleted file mode 100644
index ce99cab2f257..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_fifo.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef __NOUVEAU_FIFO_H__
-#define __NOUVEAU_FIFO_H__
-
-struct nouveau_fifo_priv {
-        struct nouveau_exec_engine base;
-        u32 channels;
-};
-
-struct nouveau_fifo_chan {
-};
-
-bool nv04_fifo_cache_pull(struct drm_device *, bool);
-void nv04_fifo_context_del(struct nouveau_channel *, int);
-int  nv04_fifo_fini(struct drm_device *, int, bool);
-int  nv04_fifo_init(struct drm_device *, int);
-void nv04_fifo_isr(struct drm_device *);
-void nv04_fifo_destroy(struct drm_device *, int);
-
-void nv50_fifo_playlist_update(struct drm_device *);
-void nv50_fifo_destroy(struct drm_device *, int);
-void nv50_fifo_tlb_flush(struct drm_device *, int);
-
-int  nv04_fifo_create(struct drm_device *);
-int  nv10_fifo_create(struct drm_device *);
-int  nv17_fifo_create(struct drm_device *);
-int  nv40_fifo_create(struct drm_device *);
-int  nv50_fifo_create(struct drm_device *);
-int  nv84_fifo_create(struct drm_device *);
-int  nvc0_fifo_create(struct drm_device *);
-int  nve0_fifo_create(struct drm_device *);
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c
index af7cfb825716..6454370e78cf 100644
--- a/drivers/gpu/drm/nouveau/nouveau_gem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_gem.c
@@ -23,16 +23,19 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  */
+
 #include <linux/dma-buf.h>
-#include "drmP.h"
-#include "drm.h"
+#include <nouveau_drm.h>
+
+#include <subdev/fb.h>
 
-#include "nouveau_drv.h"
 #include "nouveau_drm.h"
 #include "nouveau_dma.h"
 #include "nouveau_fence.h"
+#include "nouveau_abi16.h"
 
-#define nouveau_gem_pushbuf_sync(chan) 0
+#include "nouveau_ttm.h"
+#include "nouveau_gem.h"
 
 int
 nouveau_gem_object_new(struct drm_gem_object *gem)
@@ -67,19 +70,19 @@ nouveau_gem_object_del(struct drm_gem_object *gem)
 int
 nouveau_gem_object_open(struct drm_gem_object *gem, struct drm_file *file_priv)
 {
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
+        struct nouveau_cli *cli = nouveau_cli(file_priv);
         struct nouveau_bo *nvbo = nouveau_gem_object(gem);
         struct nouveau_vma *vma;
         int ret;
 
-        if (!fpriv->vm)
+        if (!cli->base.vm)
                 return 0;
 
         ret = ttm_bo_reserve(&nvbo->bo, false, false, false, 0);
         if (ret)
                 return ret;
 
-        vma = nouveau_bo_vma_find(nvbo, fpriv->vm);
+        vma = nouveau_bo_vma_find(nvbo, cli->base.vm);
         if (!vma) {
                 vma = kzalloc(sizeof(*vma), GFP_KERNEL);
                 if (!vma) {
@@ -87,7 +90,7 @@ nouveau_gem_object_open(struct drm_gem_object *gem, struct drm_file *file_priv)
                         goto out;
                 }
 
-                ret = nouveau_bo_vma_add(nvbo, fpriv->vm, vma);
+                ret = nouveau_bo_vma_add(nvbo, cli->base.vm, vma);
                 if (ret) {
                         kfree(vma);
                         goto out;
@@ -104,19 +107,19 @@ out:
 void
 nouveau_gem_object_close(struct drm_gem_object *gem, struct drm_file *file_priv)
 {
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
+        struct nouveau_cli *cli = nouveau_cli(file_priv);
         struct nouveau_bo *nvbo = nouveau_gem_object(gem);
         struct nouveau_vma *vma;
         int ret;
 
-        if (!fpriv->vm)
+        if (!cli->base.vm)
                 return;
 
         ret = ttm_bo_reserve(&nvbo->bo, false, false, false, 0);
         if (ret)
                 return;
 
-        vma = nouveau_bo_vma_find(nvbo, fpriv->vm);
+        vma = nouveau_bo_vma_find(nvbo, cli->base.vm);
         if (vma) {
                 if (--vma->refcount == 0) {
                         nouveau_bo_vma_del(nvbo, vma);
@@ -131,7 +134,7 @@ nouveau_gem_new(struct drm_device *dev, int size, int align, uint32_t domain,
                 uint32_t tile_mode, uint32_t tile_flags,
                 struct nouveau_bo **pnvbo)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_bo *nvbo;
         u32 flags = 0;
         int ret;
@@ -155,7 +158,7 @@ nouveau_gem_new(struct drm_device *dev, int size, int align, uint32_t domain,
          */
         nvbo->valid_domains = NOUVEAU_GEM_DOMAIN_VRAM |
                               NOUVEAU_GEM_DOMAIN_GART;
-        if (dev_priv->card_type >= NV_50)
+        if (nv_device(drm->device)->card_type >= NV_50)
                 nvbo->valid_domains &= domain;
 
         nvbo->gem = drm_gem_object_alloc(dev, nvbo->bo.mem.size);
@@ -173,7 +176,7 @@ static int
 nouveau_gem_info(struct drm_file *file_priv, struct drm_gem_object *gem,
                  struct drm_nouveau_gem_info *rep)
 {
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
+        struct nouveau_cli *cli = nouveau_cli(file_priv);
         struct nouveau_bo *nvbo = nouveau_gem_object(gem);
         struct nouveau_vma *vma;
 
@@ -183,8 +186,8 @@ nouveau_gem_info(struct drm_file *file_priv, struct drm_gem_object *gem,
                 rep->domain = NOUVEAU_GEM_DOMAIN_VRAM;
 
         rep->offset = nvbo->bo.offset;
-        if (fpriv->vm) {
-                vma = nouveau_bo_vma_find(nvbo, fpriv->vm);
+        if (cli->base.vm) {
+                vma = nouveau_bo_vma_find(nvbo, cli->base.vm);
                 if (!vma)
                         return -EINVAL;
 
@@ -202,15 +205,16 @@ int
 nouveau_gem_ioctl_new(struct drm_device *dev, void *data,
                       struct drm_file *file_priv)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
         struct drm_nouveau_gem_new *req = data;
         struct nouveau_bo *nvbo = NULL;
         int ret = 0;
 
-        dev_priv->ttm.bdev.dev_mapping = dev->dev_mapping;
+        drm->ttm.bdev.dev_mapping = drm->dev->dev_mapping;
 
-        if (!dev_priv->engine.vram.flags_valid(dev, req->info.tile_flags)) {
-                NV_ERROR(dev, "bad page flags: 0x%08x\n", req->info.tile_flags);
+        if (!pfb->memtype_valid(pfb, req->info.tile_flags)) {
+                NV_ERROR(drm, "bad page flags: 0x%08x\n", req->info.tile_flags);
                 return -EINVAL;
         }
 
@@ -312,16 +316,16 @@ validate_init(struct nouveau_channel *chan, struct drm_file *file_priv,
               struct drm_nouveau_gem_pushbuf_bo *pbbo,
               int nr_buffers, struct validate_op *op)
 {
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct drm_device *dev = chan->drm->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint32_t sequence;
         int trycnt = 0;
         int ret, i;
 
-        sequence = atomic_add_return(1, &dev_priv->ttm.validate_sequence);
+        sequence = atomic_add_return(1, &drm->ttm.validate_sequence);
 retry:
         if (++trycnt > 100000) {
-                NV_ERROR(dev, "%s failed and gave up.\n", __func__);
+                NV_ERROR(drm, "%s failed and gave up.\n", __func__);
                 return -EINVAL;
         }
 
@@ -332,14 +336,14 @@ retry:
 
                 gem = drm_gem_object_lookup(dev, file_priv, b->handle);
                 if (!gem) {
-                        NV_ERROR(dev, "Unknown handle 0x%08x\n", b->handle);
+                        NV_ERROR(drm, "Unknown handle 0x%08x\n", b->handle);
                         validate_fini(op, NULL);
                         return -ENOENT;
                 }
                 nvbo = gem->driver_private;
 
                 if (nvbo->reserved_by && nvbo->reserved_by == file_priv) {
-                        NV_ERROR(dev, "multiple instances of buffer %d on "
+                        NV_ERROR(drm, "multiple instances of buffer %d on "
                                       "validation list\n", b->handle);
                         drm_gem_object_unreference_unlocked(gem);
                         validate_fini(op, NULL);
@@ -354,7 +358,7 @@ retry:
                         drm_gem_object_unreference_unlocked(gem);
                         if (unlikely(ret)) {
                                 if (ret != -ERESTARTSYS)
-                                        NV_ERROR(dev, "fail reserve\n");
+                                        NV_ERROR(drm, "fail reserve\n");
                                 return ret;
                         }
                         goto retry;
@@ -373,7 +377,7 @@ retry:
                 if (b->valid_domains & NOUVEAU_GEM_DOMAIN_GART)
                         list_add_tail(&nvbo->entry, &op->gart_list);
                 else {
-                        NV_ERROR(dev, "invalid valid domains: 0x%08x\n",
+                        NV_ERROR(drm, "invalid valid domains: 0x%08x\n",
                                  b->valid_domains);
                         list_add_tail(&nvbo->entry, &op->both_list);
                         validate_fini(op, NULL);
@@ -407,10 +411,9 @@ static int
 validate_list(struct nouveau_channel *chan, struct list_head *list,
               struct drm_nouveau_gem_pushbuf_bo *pbbo, uint64_t user_pbbo_ptr)
 {
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
+        struct nouveau_drm *drm = chan->drm;
         struct drm_nouveau_gem_pushbuf_bo __user *upbbo =
                                 (void __force __user *)(uintptr_t)user_pbbo_ptr;
-        struct drm_device *dev = chan->dev;
         struct nouveau_bo *nvbo;
         int ret, relocs = 0;
 
@@ -419,7 +422,7 @@ validate_list(struct nouveau_channel *chan, struct list_head *list,
 
                 ret = validate_sync(chan, nvbo);
                 if (unlikely(ret)) {
-                        NV_ERROR(dev, "fail pre-validate sync\n");
+                        NV_ERROR(drm, "fail pre-validate sync\n");
                         return ret;
                 }
 
@@ -427,24 +430,24 @@ validate_list(struct nouveau_channel *chan, struct list_head *list,
                                              b->write_domains,
                                              b->valid_domains);
                 if (unlikely(ret)) {
-                        NV_ERROR(dev, "fail set_domain\n");
+                        NV_ERROR(drm, "fail set_domain\n");
                         return ret;
                 }
 
                 ret = nouveau_bo_validate(nvbo, true, false, false);
                 if (unlikely(ret)) {
                         if (ret != -ERESTARTSYS)
-                                NV_ERROR(dev, "fail ttm_validate\n");
+                                NV_ERROR(drm, "fail ttm_validate\n");
                         return ret;
                 }
 
                 ret = validate_sync(chan, nvbo);
                 if (unlikely(ret)) {
-                        NV_ERROR(dev, "fail post-validate sync\n");
+                        NV_ERROR(drm, "fail post-validate sync\n");
                         return ret;
                 }
 
-                if (dev_priv->card_type < NV_50) {
+                if (nv_device(drm->device)->card_type < NV_50) {
                         if (nvbo->bo.offset == b->presumed.offset &&
                             ((nvbo->bo.mem.mem_type == TTM_PL_VRAM &&
                               b->presumed.domain & NOUVEAU_GEM_DOMAIN_VRAM) ||
@@ -476,7 +479,7 @@ nouveau_gem_pushbuf_validate(struct nouveau_channel *chan,
                              uint64_t user_buffers, int nr_buffers,
                              struct validate_op *op, int *apply_relocs)
 {
-        struct drm_device *dev = chan->dev;
+        struct nouveau_drm *drm = chan->drm;
         int ret, relocs = 0;
 
         INIT_LIST_HEAD(&op->vram_list);
@@ -489,14 +492,14 @@ nouveau_gem_pushbuf_validate(struct nouveau_channel *chan,
         ret = validate_init(chan, file_priv, pbbo, nr_buffers, op);
         if (unlikely(ret)) {
                 if (ret != -ERESTARTSYS)
-                        NV_ERROR(dev, "validate_init\n");
+                        NV_ERROR(drm, "validate_init\n");
                 return ret;
         }
 
         ret = validate_list(chan, &op->vram_list, pbbo, user_buffers);
         if (unlikely(ret < 0)) {
                 if (ret != -ERESTARTSYS)
-                        NV_ERROR(dev, "validate vram_list\n");
+                        NV_ERROR(drm, "validate vram_list\n");
                 validate_fini(op, NULL);
                 return ret;
         }
@@ -505,7 +508,7 @@ nouveau_gem_pushbuf_validate(struct nouveau_channel *chan,
         ret = validate_list(chan, &op->gart_list, pbbo, user_buffers);
         if (unlikely(ret < 0)) {
                 if (ret != -ERESTARTSYS)
-                        NV_ERROR(dev, "validate gart_list\n");
+                        NV_ERROR(drm, "validate gart_list\n");
                 validate_fini(op, NULL);
                 return ret;
         }
@@ -514,7 +517,7 @@ nouveau_gem_pushbuf_validate(struct nouveau_channel *chan,
         ret = validate_list(chan, &op->both_list, pbbo, user_buffers);
         if (unlikely(ret < 0)) {
                 if (ret != -ERESTARTSYS)
-                        NV_ERROR(dev, "validate both_list\n");
+                        NV_ERROR(drm, "validate both_list\n");
                 validate_fini(op, NULL);
                 return ret;
         }
@@ -547,6 +550,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
                                 struct drm_nouveau_gem_pushbuf *req,
                                 struct drm_nouveau_gem_pushbuf_bo *bo)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_nouveau_gem_pushbuf_reloc *reloc = NULL;
         int ret = 0;
         unsigned i;
@@ -562,7 +566,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
                 uint32_t data;
 
                 if (unlikely(r->bo_index > req->nr_buffers)) {
-                        NV_ERROR(dev, "reloc bo index invalid\n");
+                        NV_ERROR(drm, "reloc bo index invalid\n");
                         ret = -EINVAL;
                         break;
                 }
@@ -572,7 +576,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
                         continue;
 
                 if (unlikely(r->reloc_bo_index > req->nr_buffers)) {
-                        NV_ERROR(dev, "reloc container bo index invalid\n");
+                        NV_ERROR(drm, "reloc container bo index invalid\n");
                         ret = -EINVAL;
                         break;
                 }
@@ -580,7 +584,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
 
                 if (unlikely(r->reloc_bo_offset + 4 >
                              nvbo->bo.mem.num_pages << PAGE_SHIFT)) {
-                        NV_ERROR(dev, "reloc outside of bo\n");
+                        NV_ERROR(drm, "reloc outside of bo\n");
                         ret = -EINVAL;
                         break;
                 }
@@ -589,7 +593,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
                         ret = ttm_bo_kmap(&nvbo->bo, 0, nvbo->bo.mem.num_pages,
                                           &nvbo->kmap);
                         if (ret) {
-                                NV_ERROR(dev, "failed kmap for reloc\n");
+                                NV_ERROR(drm, "failed kmap for reloc\n");
                                 break;
                         }
                         nvbo->validate_mapped = true;
@@ -614,7 +618,7 @@ nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
                 ret = ttm_bo_wait(&nvbo->bo, false, false, false);
                 spin_unlock(&nvbo->bo.bdev->fence_lock);
                 if (ret) {
-                        NV_ERROR(dev, "reloc wait_idle failed: %d\n", ret);
+                        NV_ERROR(drm, "reloc wait_idle failed: %d\n", ret);
                         break;
                 }
 
@@ -629,62 +633,67 @@ int
 nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
                           struct drm_file *file_priv)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
+        struct nouveau_abi16_chan *temp;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_nouveau_gem_pushbuf *req = data;
         struct drm_nouveau_gem_pushbuf_push *push;
         struct drm_nouveau_gem_pushbuf_bo *bo;
-        struct nouveau_channel *chan;
+        struct nouveau_channel *chan = NULL;
         struct validate_op op;
         struct nouveau_fence *fence = NULL;
         int i, j, ret = 0, do_reloc = 0;
 
-        chan = nouveau_channel_get(file_priv, req->channel);
-        if (IS_ERR(chan))
-                return PTR_ERR(chan);
+        if (unlikely(!abi16))
+                return -ENOMEM;
+
+        list_for_each_entry(temp, &abi16->channels, head) {
+                if (temp->chan->handle == (NVDRM_CHAN | req->channel)) {
+                        chan = temp->chan;
+                        break;
+                }
+        }
 
-        req->vram_available = dev_priv->fb_aper_free;
-        req->gart_available = dev_priv->gart_info.aper_free;
+        if (!chan)
+                return nouveau_abi16_put(abi16, -ENOENT);
+
+        req->vram_available = drm->gem.vram_available;
+        req->gart_available = drm->gem.gart_available;
         if (unlikely(req->nr_push == 0))
                 goto out_next;
 
         if (unlikely(req->nr_push > NOUVEAU_GEM_MAX_PUSH)) {
-                NV_ERROR(dev, "pushbuf push count exceeds limit: %d max %d\n",
+                NV_ERROR(drm, "pushbuf push count exceeds limit: %d max %d\n",
                          req->nr_push, NOUVEAU_GEM_MAX_PUSH);
-                nouveau_channel_put(&chan);
-                return -EINVAL;
+                return nouveau_abi16_put(abi16, -EINVAL);
         }
 
         if (unlikely(req->nr_buffers > NOUVEAU_GEM_MAX_BUFFERS)) {
-                NV_ERROR(dev, "pushbuf bo count exceeds limit: %d max %d\n",
+                NV_ERROR(drm, "pushbuf bo count exceeds limit: %d max %d\n",
                          req->nr_buffers, NOUVEAU_GEM_MAX_BUFFERS);
-                nouveau_channel_put(&chan);
-                return -EINVAL;
+                return nouveau_abi16_put(abi16, -EINVAL);
         }
 
         if (unlikely(req->nr_relocs > NOUVEAU_GEM_MAX_RELOCS)) {
-                NV_ERROR(dev, "pushbuf reloc count exceeds limit: %d max %d\n",
+                NV_ERROR(drm, "pushbuf reloc count exceeds limit: %d max %d\n",
                          req->nr_relocs, NOUVEAU_GEM_MAX_RELOCS);
-                nouveau_channel_put(&chan);
-                return -EINVAL;
+                return nouveau_abi16_put(abi16, -EINVAL);
         }
 
         push = u_memcpya(req->push, req->nr_push, sizeof(*push));
-        if (IS_ERR(push)) {
-                nouveau_channel_put(&chan);
-                return PTR_ERR(push);
-        }
+        if (IS_ERR(push))
+                return nouveau_abi16_put(abi16, PTR_ERR(push));
 
         bo = u_memcpya(req->buffers, req->nr_buffers, sizeof(*bo));
         if (IS_ERR(bo)) {
                 kfree(push);
-                nouveau_channel_put(&chan);
-                return PTR_ERR(bo);
+                return nouveau_abi16_put(abi16, PTR_ERR(bo));
         }
 
         /* Ensure all push buffers are on validate list */
         for (i = 0; i < req->nr_push; i++) {
                 if (push[i].bo_index >= req->nr_buffers) {
-                        NV_ERROR(dev, "push %d buffer not in list\n", i);
+                        NV_ERROR(drm, "push %d buffer not in list\n", i);
                         ret = -EINVAL;
                         goto out_prevalid;
                 }
@@ -695,7 +704,7 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
                                            req->nr_buffers, &op, &do_reloc);
         if (ret) {
                 if (ret != -ERESTARTSYS)
-                        NV_ERROR(dev, "validate: %d\n", ret);
+                        NV_ERROR(drm, "validate: %d\n", ret);
                 goto out_prevalid;
         }
 
@@ -703,7 +712,7 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
         if (do_reloc) {
                 ret = nouveau_gem_pushbuf_reloc_apply(dev, req, bo);
                 if (ret) {
-                        NV_ERROR(dev, "reloc apply: %d\n", ret);
+                        NV_ERROR(drm, "reloc apply: %d\n", ret);
                         goto out;
                 }
         }
@@ -711,7 +720,7 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
         if (chan->dma.ib_max) {
                 ret = nouveau_dma_wait(chan, req->nr_push + 1, 16);
                 if (ret) {
-                        NV_INFO(dev, "nv50cal_space: %d\n", ret);
+                        NV_ERROR(drm, "nv50cal_space: %d\n", ret);
                         goto out;
                 }
 
@@ -723,36 +732,33 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
                                       push[i].length);
                 }
         } else
-        if (dev_priv->chipset >= 0x25) {
+        if (nv_device(drm->device)->chipset >= 0x25) {
                 ret = RING_SPACE(chan, req->nr_push * 2);
                 if (ret) {
-                        NV_ERROR(dev, "cal_space: %d\n", ret);
+                        NV_ERROR(drm, "cal_space: %d\n", ret);
                         goto out;
                 }
 
                 for (i = 0; i < req->nr_push; i++) {
                         struct nouveau_bo *nvbo = (void *)(unsigned long)
                                 bo[push[i].bo_index].user_priv;
-                        struct drm_mm_node *mem = nvbo->bo.mem.mm_node;
 
-                        OUT_RING(chan, ((mem->start << PAGE_SHIFT) +
-                                        push[i].offset) | 2);
+                        OUT_RING(chan, (nvbo->bo.offset + push[i].offset) | 2);
                         OUT_RING(chan, 0);
                 }
         } else {
                 ret = RING_SPACE(chan, req->nr_push * (2 + NOUVEAU_DMA_SKIPS));
                 if (ret) {
-                        NV_ERROR(dev, "jmp_space: %d\n", ret);
+                        NV_ERROR(drm, "jmp_space: %d\n", ret);
                         goto out;
                 }
 
                 for (i = 0; i < req->nr_push; i++) {
                         struct nouveau_bo *nvbo = (void *)(unsigned long)
                                 bo[push[i].bo_index].user_priv;
-                        struct drm_mm_node *mem = nvbo->bo.mem.mm_node;
                         uint32_t cmd;
 
-                        cmd = chan->pushbuf_base + ((chan->dma.cur + 2) << 2);
+                        cmd = chan->push.vma.offset + ((chan->dma.cur + 2) << 2);
                         cmd |= 0x20000000;
                         if (unlikely(cmd != req->suffix0)) {
                                 if (!nvbo->kmap.virtual) {
@@ -771,8 +777,8 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
                                                 push[i].length - 8) / 4, cmd);
                         }
 
-                        OUT_RING(chan, ((mem->start << PAGE_SHIFT) +
-                                        push[i].offset) | 0x20000000);
+                        OUT_RING(chan, 0x20000000 |
+                                      (nvbo->bo.offset + push[i].offset));
                         OUT_RING(chan, 0);
                         for (j = 0; j < NOUVEAU_DMA_SKIPS; j++)
                                 OUT_RING(chan, 0);
@@ -781,7 +787,7 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
 
         ret = nouveau_fence_new(chan, &fence);
         if (ret) {
-                NV_ERROR(dev, "error fencing pushbuf: %d\n", ret);
+                NV_ERROR(drm, "error fencing pushbuf: %d\n", ret);
                 WIND_RING(chan);
                 goto out;
         }
@@ -799,17 +805,16 @@ out_next:
                 req->suffix0 = 0x00000000;
                 req->suffix1 = 0x00000000;
         } else
-        if (dev_priv->chipset >= 0x25) {
+        if (nv_device(drm->device)->chipset >= 0x25) {
                 req->suffix0 = 0x00020000;
                 req->suffix1 = 0x00000000;
         } else {
                 req->suffix0 = 0x20000000 |
-                              (chan->pushbuf_base + ((chan->dma.cur + 2) << 2));
+                              (chan->push.vma.offset + ((chan->dma.cur + 2) << 2));
                 req->suffix1 = 0x00000000;
         }
 
-        nouveau_channel_put(&chan);
-        return ret;
+        return nouveau_abi16_put(abi16, ret);
 }
 
 static inline uint32_t
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.h b/drivers/gpu/drm/nouveau/nouveau_gem.h
new file mode 100644
index 000000000000..085ece91c395
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_gem.h
@@ -0,0 +1,43 @@
+#ifndef __NOUVEAU_GEM_H__
+#define __NOUVEAU_GEM_H__
+
+#include "drmP.h"
+
+#include <nouveau_drm.h>
+#include "nouveau_bo.h"
+
+#define nouveau_bo_tile_layout(nvbo)                            \
+        ((nvbo)->tile_flags & NOUVEAU_GEM_TILE_LAYOUT_MASK)
+
+static inline struct nouveau_bo *
+nouveau_gem_object(struct drm_gem_object *gem)
+{
+        return gem ? gem->driver_private : NULL;
+}
+
+/* nouveau_gem.c */
+extern int nouveau_gem_new(struct drm_device *, int size, int align,
+                           uint32_t domain, uint32_t tile_mode,
+                           uint32_t tile_flags, struct nouveau_bo **);
+extern int nouveau_gem_object_new(struct drm_gem_object *);
+extern void nouveau_gem_object_del(struct drm_gem_object *);
+extern int nouveau_gem_object_open(struct drm_gem_object *, struct drm_file *);
+extern void nouveau_gem_object_close(struct drm_gem_object *,
+                                     struct drm_file *);
+extern int nouveau_gem_ioctl_new(struct drm_device *, void *,
+                                 struct drm_file *);
+extern int nouveau_gem_ioctl_pushbuf(struct drm_device *, void *,
+                                     struct drm_file *);
+extern int nouveau_gem_ioctl_cpu_prep(struct drm_device *, void *,
+                                      struct drm_file *);
+extern int nouveau_gem_ioctl_cpu_fini(struct drm_device *, void *,
+                                      struct drm_file *);
+extern int nouveau_gem_ioctl_info(struct drm_device *, void *,
+                                  struct drm_file *);
+
+extern struct dma_buf *nouveau_gem_prime_export(struct drm_device *dev,
+                                struct drm_gem_object *obj, int flags);
+extern struct drm_gem_object *nouveau_gem_prime_import(struct drm_device *dev,
+                                struct dma_buf *dma_buf);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_gpio.c b/drivers/gpu/drm/nouveau/nouveau_gpio.c
deleted file mode 100644
index 82c19e82ff02..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_gpio.c
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- * Copyright 2011 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"
-#include "nouveau_i2c.h"
-#include "nouveau_gpio.h"
-
-static u8 *
-dcb_gpio_table(struct drm_device *dev)
-{
-        u8 *dcb = dcb_table(dev);
-        if (dcb) {
-                if (dcb[0] >= 0x30 && dcb[1] >= 0x0c)
-                        return ROMPTR(dev, dcb[0x0a]);
-                if (dcb[0] >= 0x22 && dcb[-1] >= 0x13)
-                        return ROMPTR(dev, dcb[-15]);
-        }
-        return NULL;
-}
-
-static u8 *
-dcb_gpio_entry(struct drm_device *dev, int idx, int ent, u8 *version)
-{
-        u8 *table = dcb_gpio_table(dev);
-        if (table) {
-                *version = table[0];
-                if (*version < 0x30 && ent < table[2])
-                        return table + 3 + (ent * table[1]);
-                else if (ent < table[2])
-                        return table + table[1] + (ent * table[3]);
-        }
-        return NULL;
-}
-
-int
-nouveau_gpio_drive(struct drm_device *dev, int idx, int line, int dir, int out)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-
-        return pgpio->drive ? pgpio->drive(dev, line, dir, out) : -ENODEV;
-}
-
-int
-nouveau_gpio_sense(struct drm_device *dev, int idx, int line)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-
-        return pgpio->sense ? pgpio->sense(dev, line) : -ENODEV;
-}
-
-int
-nouveau_gpio_find(struct drm_device *dev, int idx, u8 func, u8 line,
-                  struct gpio_func *gpio)
-{
-        u8 *table, *entry, version;
-        int i = -1;
-
-        if (line == 0xff && func == 0xff)
-                return -EINVAL;
-
-        while ((entry = dcb_gpio_entry(dev, idx, ++i, &version))) {
-                if (version < 0x40) {
-                        u16 data = ROM16(entry[0]);
-                        *gpio = (struct gpio_func) {
-                                .line = (data & 0x001f) >> 0,
-                                .func = (data & 0x07e0) >> 5,
-                                .log[0] = (data & 0x1800) >> 11,
-                                .log[1] = (data & 0x6000) >> 13,
-                        };
-                } else
-                if (version < 0x41) {
-                        *gpio = (struct gpio_func) {
-                                .line = entry[0] & 0x1f,
-                                .func = entry[1],
-                                .log[0] = (entry[3] & 0x18) >> 3,
-                                .log[1] = (entry[3] & 0x60) >> 5,
-                        };
-                } else {
-                        *gpio = (struct gpio_func) {
-                                .line = entry[0] & 0x3f,
-                                .func = entry[1],
-                                .log[0] = (entry[4] & 0x30) >> 4,
-                                .log[1] = (entry[4] & 0xc0) >> 6,
-                        };
-                }
-
-                if ((line == 0xff || line == gpio->line) &&
-                    (func == 0xff || func == gpio->func))
-                        return 0;
-        }
-
-        /* DCB 2.2, fixed TVDAC GPIO data */
-        if ((table = dcb_table(dev)) && table[0] >= 0x22) {
-                if (func == DCB_GPIO_TVDAC0) {
-                        *gpio = (struct gpio_func) {
-                                .func = DCB_GPIO_TVDAC0,
-                                .line = table[-4] >> 4,
-                                .log[0] = !!(table[-5] & 2),
-                                .log[1] =  !(table[-5] & 2),
-                        };
-                        return 0;
-                }
-        }
-
-        /* Apple iMac G4 NV18 */
-        if (nv_match_device(dev, 0x0189, 0x10de, 0x0010)) {
-                if (func == DCB_GPIO_TVDAC0) {
-                        *gpio = (struct gpio_func) {
-                                .func = DCB_GPIO_TVDAC0,
-                                .line = 4,
-                                .log[0] = 0,
-                                .log[1] = 1,
-                        };
-                        return 0;
-                }
-        }
-
-        return -EINVAL;
-}
-
-int
-nouveau_gpio_set(struct drm_device *dev, int idx, u8 tag, u8 line, int state)
-{
-        struct gpio_func gpio;
-        int ret;
-
-        ret = nouveau_gpio_find(dev, idx, tag, line, &gpio);
-        if (ret == 0) {
-                int dir = !!(gpio.log[state] & 0x02);
-                int out = !!(gpio.log[state] & 0x01);
-                ret = nouveau_gpio_drive(dev, idx, gpio.line, dir, out);
-        }
-
-        return ret;
-}
-
-int
-nouveau_gpio_get(struct drm_device *dev, int idx, u8 tag, u8 line)
-{
-        struct gpio_func gpio;
-        int ret;
-
-        ret = nouveau_gpio_find(dev, idx, tag, line, &gpio);
-        if (ret == 0) {
-                ret = nouveau_gpio_sense(dev, idx, gpio.line);
-                if (ret >= 0)
-                        ret = (ret == (gpio.log[1] & 1));
-        }
-
-        return ret;
-}
-
-int
-nouveau_gpio_irq(struct drm_device *dev, int idx, u8 tag, u8 line, bool on)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-        struct gpio_func gpio;
-        int ret;
-
-        ret = nouveau_gpio_find(dev, idx, tag, line, &gpio);
-        if (ret == 0) {
-                if (idx == 0 && pgpio->irq_enable)
-                        pgpio->irq_enable(dev, gpio.line, on);
-                else
-                        ret = -ENODEV;
-        }
-
-        return ret;
-}
-
-struct gpio_isr {
-        struct drm_device *dev;
-        struct list_head head;
-        struct work_struct work;
-        int idx;
-        struct gpio_func func;
-        void (*handler)(void *, int);
-        void *data;
-        bool inhibit;
-};
-
-static void
-nouveau_gpio_isr_bh(struct work_struct *work)
-{
-        struct gpio_isr *isr = container_of(work, struct gpio_isr, work);
-        struct drm_device *dev = isr->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-        unsigned long flags;
-        int state;
-
-        state = nouveau_gpio_get(dev, isr->idx, isr->func.func, isr->func.line);
-        if (state >= 0)
-                isr->handler(isr->data, state);
-
-        spin_lock_irqsave(&pgpio->lock, flags);
-        isr->inhibit = false;
-        spin_unlock_irqrestore(&pgpio->lock, flags);
-}
-
-void
-nouveau_gpio_isr(struct drm_device *dev, int idx, u32 line_mask)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-        struct gpio_isr *isr;
-
-        if (idx != 0)
-                return;
-
-        spin_lock(&pgpio->lock);
-        list_for_each_entry(isr, &pgpio->isr, head) {
-                if (line_mask & (1 << isr->func.line)) {
-                        if (isr->inhibit)
-                                continue;
-                        isr->inhibit = true;
-                        schedule_work(&isr->work);
-                }
-        }
-        spin_unlock(&pgpio->lock);
-}
-
-int
-nouveau_gpio_isr_add(struct drm_device *dev, int idx, u8 tag, u8 line,
-                     void (*handler)(void *, int), void *data)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-        struct gpio_isr *isr;
-        unsigned long flags;
-        int ret;
-
-        isr = kzalloc(sizeof(*isr), GFP_KERNEL);
-        if (!isr)
-                return -ENOMEM;
-
-        ret = nouveau_gpio_find(dev, idx, tag, line, &isr->func);
-        if (ret) {
-                kfree(isr);
-                return ret;
-        }
-
-        INIT_WORK(&isr->work, nouveau_gpio_isr_bh);
-        isr->dev = dev;
-        isr->handler = handler;
-        isr->data = data;
-        isr->idx = idx;
-
-        spin_lock_irqsave(&pgpio->lock, flags);
-        list_add(&isr->head, &pgpio->isr);
-        spin_unlock_irqrestore(&pgpio->lock, flags);
-        return 0;
-}
-
-void
-nouveau_gpio_isr_del(struct drm_device *dev, int idx, u8 tag, u8 line,
-                     void (*handler)(void *, int), void *data)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-        struct gpio_isr *isr, *tmp;
-        struct gpio_func func;
-        unsigned long flags;
-        LIST_HEAD(tofree);
-        int ret;
-
-        ret = nouveau_gpio_find(dev, idx, tag, line, &func);
-        if (ret == 0) {
-                spin_lock_irqsave(&pgpio->lock, flags);
-                list_for_each_entry_safe(isr, tmp, &pgpio->isr, head) {
-                        if (memcmp(&isr->func, &func, sizeof(func)) ||
-                            isr->idx != idx ||
-                            isr->handler != handler || isr->data != data)
-                                continue;
-                        list_move(&isr->head, &tofree);
-                }
-                spin_unlock_irqrestore(&pgpio->lock, flags);
-
-                list_for_each_entry_safe(isr, tmp, &tofree, head) {
-                        flush_work_sync(&isr->work);
-                        kfree(isr);
-                }
-        }
-}
-
-int
-nouveau_gpio_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-
-        INIT_LIST_HEAD(&pgpio->isr);
-        spin_lock_init(&pgpio->lock);
-
-        return nouveau_gpio_init(dev);
-}
-
-void
-nouveau_gpio_destroy(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-
-        nouveau_gpio_fini(dev);
-        BUG_ON(!list_empty(&pgpio->isr));
-}
-
-int
-nouveau_gpio_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-        int ret = 0;
-
-        if (pgpio->init)
-                ret = pgpio->init(dev);
-
-        return ret;
-}
-
-void
-nouveau_gpio_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio;
-
-        if (pgpio->fini)
-                pgpio->fini(dev);
-}
-
-void
-nouveau_gpio_reset(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u8 *entry, version;
-        int ent = -1;
-
-        while ((entry = dcb_gpio_entry(dev, 0, ++ent, &version))) {
-                u8 func = 0xff, line, defs, unk0, unk1;
-                if (version >= 0x41) {
-                        defs = !!(entry[0] & 0x80);
-                        line = entry[0] & 0x3f;
-                        func = entry[1];
-                        unk0 = entry[2];
-                        unk1 = entry[3] & 0x1f;
-                } else
-                if (version >= 0x40) {
-                        line = entry[0] & 0x1f;
-                        func = entry[1];
-                        defs = !!(entry[3] & 0x01);
-                        unk0 = !!(entry[3] & 0x02);
-                        unk1 = !!(entry[3] & 0x04);
-                } else {
-                        break;
-                }
-
-                if (func == 0xff)
-                        continue;
-
-                nouveau_gpio_func_set(dev, func, defs);
-
-                if (dev_priv->card_type >= NV_D0) {
-                        nv_mask(dev, 0x00d610 + (line * 4), 0xff, unk0);
-                        if (unk1--)
-                                nv_mask(dev, 0x00d740 + (unk1 * 4), 0xff, line);
-                } else
-                if (dev_priv->card_type >= NV_50) {
-                        static const u32 regs[] = { 0xe100, 0xe28c };
-                        u32 val = (unk1 << 16) | unk0;
-                        u32 reg = regs[line >> 4]; line &= 0x0f;
-
-                        nv_mask(dev, reg, 0x00010001 << line, val << line);
-                }
-        }
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_gpio.h b/drivers/gpu/drm/nouveau/nouveau_gpio.h
deleted file mode 100644
index 64c5cb077ace..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_gpio.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2011 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.
- */
-
-#ifndef __NOUVEAU_GPIO_H__
-#define __NOUVEAU_GPIO_H__
-
-struct gpio_func {
-        u8 func;
-        u8 line;
-        u8 log[2];
-};
-
-/* nouveau_gpio.c */
-int  nouveau_gpio_create(struct drm_device *);
-void nouveau_gpio_destroy(struct drm_device *);
-int  nouveau_gpio_init(struct drm_device *);
-void nouveau_gpio_fini(struct drm_device *);
-void nouveau_gpio_reset(struct drm_device *);
-int  nouveau_gpio_drive(struct drm_device *, int idx, int line,
-                        int dir, int out);
-int  nouveau_gpio_sense(struct drm_device *, int idx, int line);
-int  nouveau_gpio_find(struct drm_device *, int idx, u8 tag, u8 line,
-                       struct gpio_func *);
-int  nouveau_gpio_set(struct drm_device *, int idx, u8 tag, u8 line, int state);
-int  nouveau_gpio_get(struct drm_device *, int idx, u8 tag, u8 line);
-int  nouveau_gpio_irq(struct drm_device *, int idx, u8 tag, u8 line, bool on);
-void nouveau_gpio_isr(struct drm_device *, int idx, u32 mask);
-int  nouveau_gpio_isr_add(struct drm_device *, int idx, u8 tag, u8 line,
-                          void (*)(void *, int state), void *data);
-void nouveau_gpio_isr_del(struct drm_device *, int idx, u8 tag, u8 line,
-                          void (*)(void *, int state), void *data);
-
-static inline bool
-nouveau_gpio_func_valid(struct drm_device *dev, u8 tag)
-{
-        struct gpio_func func;
-        return (nouveau_gpio_find(dev, 0, tag, 0xff, &func)) == 0;
-}
-
-static inline int
-nouveau_gpio_func_set(struct drm_device *dev, u8 tag, int state)
-{
-        return nouveau_gpio_set(dev, 0, tag, 0xff, state);
-}
-
-static inline int
-nouveau_gpio_func_get(struct drm_device *dev, u8 tag)
-{
-        return nouveau_gpio_get(dev, 0, tag, 0xff);
-}
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_gpuobj.c b/drivers/gpu/drm/nouveau/nouveau_gpuobj.c
deleted file mode 100644
index bd79fedb7054..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_gpuobj.c
+++ /dev/null
@@ -1,808 +0,0 @@
-/*
- * Copyright (C) 2006 Ben Skeggs.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-/*
- * Authors:
- *   Ben Skeggs <darktama@iinet.net.au>
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-#include "nouveau_software.h"
-#include "nouveau_vm.h"
-
-struct nouveau_gpuobj_method {
-        struct list_head head;
-        u32 mthd;
-        int (*exec)(struct nouveau_channel *, u32 class, u32 mthd, u32 data);
-};
-
-struct nouveau_gpuobj_class {
-        struct list_head head;
-        struct list_head methods;
-        u32 id;
-        u32 engine;
-};
-
-int
-nouveau_gpuobj_class_new(struct drm_device *dev, u32 class, u32 engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj_class *oc;
-
-        oc = kzalloc(sizeof(*oc), GFP_KERNEL);
-        if (!oc)
-                return -ENOMEM;
-
-        INIT_LIST_HEAD(&oc->methods);
-        oc->id = class;
-        oc->engine = engine;
-        list_add(&oc->head, &dev_priv->classes);
-        return 0;
-}
-
-int
-nouveau_gpuobj_mthd_new(struct drm_device *dev, u32 class, u32 mthd,
-                        int (*exec)(struct nouveau_channel *, u32, u32, u32))
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj_method *om;
-        struct nouveau_gpuobj_class *oc;
-
-        list_for_each_entry(oc, &dev_priv->classes, head) {
-                if (oc->id == class)
-                        goto found;
-        }
-
-        return -EINVAL;
-
-found:
-        om = kzalloc(sizeof(*om), GFP_KERNEL);
-        if (!om)
-                return -ENOMEM;
-
-        om->mthd = mthd;
-        om->exec = exec;
-        list_add(&om->head, &oc->methods);
-        return 0;
-}
-
-int
-nouveau_gpuobj_mthd_call(struct nouveau_channel *chan,
-                         u32 class, u32 mthd, u32 data)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct nouveau_gpuobj_method *om;
-        struct nouveau_gpuobj_class *oc;
-
-        list_for_each_entry(oc, &dev_priv->classes, head) {
-                if (oc->id != class)
-                        continue;
-
-                list_for_each_entry(om, &oc->methods, head) {
-                        if (om->mthd == mthd)
-                                return om->exec(chan, class, mthd, data);
-                }
-        }
-
-        return -ENOENT;
-}
-
-int
-nouveau_gpuobj_mthd_call2(struct drm_device *dev, int chid,
-                          u32 class, u32 mthd, u32 data)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct nouveau_channel *chan = NULL;
-        unsigned long flags;
-        int ret = -EINVAL;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        if (chid >= 0 && chid < pfifo->channels)
-                chan = dev_priv->channels.ptr[chid];
-        if (chan)
-                ret = nouveau_gpuobj_mthd_call(chan, class, mthd, data);
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return ret;
-}
-
-int
-nouveau_gpuobj_new(struct drm_device *dev, struct nouveau_channel *chan,
-                   uint32_t size, int align, uint32_t flags,
-                   struct nouveau_gpuobj **gpuobj_ret)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *instmem = &dev_priv->engine.instmem;
-        struct nouveau_gpuobj *gpuobj;
-        struct drm_mm_node *ramin = NULL;
-        int ret, i;
-
-        NV_DEBUG(dev, "ch%d size=%u align=%d flags=0x%08x\n",
-                 chan ? chan->id : -1, size, align, flags);
-
-        gpuobj = kzalloc(sizeof(*gpuobj), GFP_KERNEL);
-        if (!gpuobj)
-                return -ENOMEM;
-        NV_DEBUG(dev, "gpuobj %p\n", gpuobj);
-        gpuobj->dev = dev;
-        gpuobj->flags = flags;
-        kref_init(&gpuobj->refcount);
-        gpuobj->size = size;
-
-        spin_lock(&dev_priv->ramin_lock);
-        list_add_tail(&gpuobj->list, &dev_priv->gpuobj_list);
-        spin_unlock(&dev_priv->ramin_lock);
-
-        if (!(flags & NVOBJ_FLAG_VM) && chan) {
-                ramin = drm_mm_search_free(&chan->ramin_heap, size, align, 0);
-                if (ramin)
-                        ramin = drm_mm_get_block(ramin, size, align);
-                if (!ramin) {
-                        nouveau_gpuobj_ref(NULL, &gpuobj);
-                        return -ENOMEM;
-                }
-
-                gpuobj->pinst = chan->ramin->pinst;
-                if (gpuobj->pinst != ~0)
-                        gpuobj->pinst += ramin->start;
-
-                gpuobj->cinst = ramin->start;
-                gpuobj->vinst = ramin->start + chan->ramin->vinst;
-                gpuobj->node  = ramin;
-        } else {
-                ret = instmem->get(gpuobj, chan, size, align);
-                if (ret) {
-                        nouveau_gpuobj_ref(NULL, &gpuobj);
-                        return ret;
-                }
-
-                ret = -ENOSYS;
-                if (!(flags & NVOBJ_FLAG_DONT_MAP))
-                        ret = instmem->map(gpuobj);
-                if (ret)
-                        gpuobj->pinst = ~0;
-
-                gpuobj->cinst = NVOBJ_CINST_GLOBAL;
-        }
-
-        if (gpuobj->flags & NVOBJ_FLAG_ZERO_ALLOC) {
-                for (i = 0; i < gpuobj->size; i += 4)
-                        nv_wo32(gpuobj, i, 0);
-                instmem->flush(dev);
-        }
-
-
-        *gpuobj_ret = gpuobj;
-        return 0;
-}
-
-int
-nouveau_gpuobj_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        NV_DEBUG(dev, "\n");
-
-        INIT_LIST_HEAD(&dev_priv->gpuobj_list);
-        INIT_LIST_HEAD(&dev_priv->classes);
-        spin_lock_init(&dev_priv->ramin_lock);
-        dev_priv->ramin_base = ~0;
-
-        return 0;
-}
-
-void
-nouveau_gpuobj_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj_method *om, *tm;
-        struct nouveau_gpuobj_class *oc, *tc;
-
-        NV_DEBUG(dev, "\n");
-
-        list_for_each_entry_safe(oc, tc, &dev_priv->classes, head) {
-                list_for_each_entry_safe(om, tm, &oc->methods, head) {
-                        list_del(&om->head);
-                        kfree(om);
-                }
-                list_del(&oc->head);
-                kfree(oc);
-        }
-
-        WARN_ON(!list_empty(&dev_priv->gpuobj_list));
-}
-
-
-static void
-nouveau_gpuobj_del(struct kref *ref)
-{
-        struct nouveau_gpuobj *gpuobj =
-                container_of(ref, struct nouveau_gpuobj, refcount);
-        struct drm_device *dev = gpuobj->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *instmem = &dev_priv->engine.instmem;
-        int i;
-
-        NV_DEBUG(dev, "gpuobj %p\n", gpuobj);
-
-        if (gpuobj->node && (gpuobj->flags & NVOBJ_FLAG_ZERO_FREE)) {
-                for (i = 0; i < gpuobj->size; i += 4)
-                        nv_wo32(gpuobj, i, 0);
-                instmem->flush(dev);
-        }
-
-        if (gpuobj->dtor)
-                gpuobj->dtor(dev, gpuobj);
-
-        if (gpuobj->cinst == NVOBJ_CINST_GLOBAL) {
-                if (gpuobj->node) {
-                        instmem->unmap(gpuobj);
-                        instmem->put(gpuobj);
-                }
-        } else {
-                if (gpuobj->node) {
-                        spin_lock(&dev_priv->ramin_lock);
-                        drm_mm_put_block(gpuobj->node);
-                        spin_unlock(&dev_priv->ramin_lock);
-                }
-        }
-
-        spin_lock(&dev_priv->ramin_lock);
-        list_del(&gpuobj->list);
-        spin_unlock(&dev_priv->ramin_lock);
-
-        kfree(gpuobj);
-}
-
-void
-nouveau_gpuobj_ref(struct nouveau_gpuobj *ref, struct nouveau_gpuobj **ptr)
-{
-        if (ref)
-                kref_get(&ref->refcount);
-
-        if (*ptr)
-                kref_put(&(*ptr)->refcount, nouveau_gpuobj_del);
-
-        *ptr = ref;
-}
-
-int
-nouveau_gpuobj_new_fake(struct drm_device *dev, u32 pinst, u64 vinst,
-                        u32 size, u32 flags, struct nouveau_gpuobj **pgpuobj)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj = NULL;
-        int i;
-
-        NV_DEBUG(dev,
-                 "pinst=0x%08x vinst=0x%010llx size=0x%08x flags=0x%08x\n",
-                 pinst, vinst, size, flags);
-
-        gpuobj = kzalloc(sizeof(*gpuobj), GFP_KERNEL);
-        if (!gpuobj)
-                return -ENOMEM;
-        NV_DEBUG(dev, "gpuobj %p\n", gpuobj);
-        gpuobj->dev = dev;
-        gpuobj->flags = flags;
-        kref_init(&gpuobj->refcount);
-        gpuobj->size  = size;
-        gpuobj->pinst = pinst;
-        gpuobj->cinst = NVOBJ_CINST_GLOBAL;
-        gpuobj->vinst = vinst;
-
-        if (gpuobj->flags & NVOBJ_FLAG_ZERO_ALLOC) {
-                for (i = 0; i < gpuobj->size; i += 4)
-                        nv_wo32(gpuobj, i, 0);
-                dev_priv->engine.instmem.flush(dev);
-        }
-
-        spin_lock(&dev_priv->ramin_lock);
-        list_add_tail(&gpuobj->list, &dev_priv->gpuobj_list);
-        spin_unlock(&dev_priv->ramin_lock);
-        *pgpuobj = gpuobj;
-        return 0;
-}
-
-void
-nv50_gpuobj_dma_init(struct nouveau_gpuobj *obj, u32 offset, int class,
-                     u64 base, u64 size, int target, int access,
-                     u32 type, u32 comp)
-{
-        struct drm_nouveau_private *dev_priv = obj->dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        u32 flags0;
-
-        flags0  = (comp << 29) | (type << 22) | class;
-        flags0 |= 0x00100000;
-
-        switch (access) {
-        case NV_MEM_ACCESS_RO: flags0 |= 0x00040000; break;
-        case NV_MEM_ACCESS_RW:
-        case NV_MEM_ACCESS_WO: flags0 |= 0x00080000; break;
-        default:
-                break;
-        }
-
-        switch (target) {
-        case NV_MEM_TARGET_VRAM:
-                flags0 |= 0x00010000;
-                break;
-        case NV_MEM_TARGET_PCI:
-                flags0 |= 0x00020000;
-                break;
-        case NV_MEM_TARGET_PCI_NOSNOOP:
-                flags0 |= 0x00030000;
-                break;
-        case NV_MEM_TARGET_GART:
-                base += dev_priv->gart_info.aper_base;
-        default:
-                flags0 &= ~0x00100000;
-                break;
-        }
-
-        /* convert to base + limit */
-        size = (base + size) - 1;
-
-        nv_wo32(obj, offset + 0x00, flags0);
-        nv_wo32(obj, offset + 0x04, lower_32_bits(size));
-        nv_wo32(obj, offset + 0x08, lower_32_bits(base));
-        nv_wo32(obj, offset + 0x0c, upper_32_bits(size) << 24 |
-                                    upper_32_bits(base));
-        nv_wo32(obj, offset + 0x10, 0x00000000);
-        nv_wo32(obj, offset + 0x14, 0x00000000);
-
-        pinstmem->flush(obj->dev);
-}
-
-int
-nv50_gpuobj_dma_new(struct nouveau_channel *chan, int class, u64 base, u64 size,
-                    int target, int access, u32 type, u32 comp,
-                    struct nouveau_gpuobj **pobj)
-{
-        struct drm_device *dev = chan->dev;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 24, 16, NVOBJ_FLAG_ZERO_FREE, pobj);
-        if (ret)
-                return ret;
-
-        nv50_gpuobj_dma_init(*pobj, 0, class, base, size, target,
-                             access, type, comp);
-        return 0;
-}
-
-int
-nouveau_gpuobj_dma_new(struct nouveau_channel *chan, int class, u64 base,
-                       u64 size, int access, int target,
-                       struct nouveau_gpuobj **pobj)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *obj;
-        u32 flags0, flags2;
-        int ret;
-
-        if (dev_priv->card_type >= NV_50) {
-                u32 comp = (target == NV_MEM_TARGET_VM) ? NV_MEM_COMP_VM : 0;
-                u32 type = (target == NV_MEM_TARGET_VM) ? NV_MEM_TYPE_VM : 0;
-
-                return nv50_gpuobj_dma_new(chan, class, base, size,
-                                           target, access, type, comp, pobj);
-        }
-
-        if (target == NV_MEM_TARGET_GART) {
-                struct nouveau_gpuobj *gart = dev_priv->gart_info.sg_ctxdma;
-
-                if (dev_priv->gart_info.type == NOUVEAU_GART_PDMA) {
-                        if (base == 0) {
-                                nouveau_gpuobj_ref(gart, pobj);
-                                return 0;
-                        }
-
-                        base   = nouveau_sgdma_get_physical(dev, base);
-                        target = NV_MEM_TARGET_PCI;
-                } else {
-                        base += dev_priv->gart_info.aper_base;
-                        if (dev_priv->gart_info.type == NOUVEAU_GART_AGP)
-                                target = NV_MEM_TARGET_PCI_NOSNOOP;
-                        else
-                                target = NV_MEM_TARGET_PCI;
-                }
-        }
-
-        flags0  = class;
-        flags0 |= 0x00003000; /* PT present, PT linear */
-        flags2  = 0;
-
-        switch (target) {
-        case NV_MEM_TARGET_PCI:
-                flags0 |= 0x00020000;
-                break;
-        case NV_MEM_TARGET_PCI_NOSNOOP:
-                flags0 |= 0x00030000;
-                break;
-        default:
-                break;
-        }
-
-        switch (access) {
-        case NV_MEM_ACCESS_RO:
-                flags0 |= 0x00004000;
-                break;
-        case NV_MEM_ACCESS_WO:
-                flags0 |= 0x00008000;
-        default:
-                flags2 |= 0x00000002;
-                break;
-        }
-
-        flags0 |= (base & 0x00000fff) << 20;
-        flags2 |= (base & 0xfffff000);
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-
-        nv_wo32(obj, 0x00, flags0);
-        nv_wo32(obj, 0x04, size - 1);
-        nv_wo32(obj, 0x08, flags2);
-        nv_wo32(obj, 0x0c, flags2);
-
-        obj->engine = NVOBJ_ENGINE_SW;
-        obj->class  = class;
-        *pobj = obj;
-        return 0;
-}
-
-int
-nouveau_gpuobj_gr_new(struct nouveau_channel *chan, u32 handle, int class)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj_class *oc;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d class=0x%04x\n", chan->id, class);
-
-        list_for_each_entry(oc, &dev_priv->classes, head) {
-                struct nouveau_exec_engine *eng = dev_priv->eng[oc->engine];
-
-                if (oc->id != class)
-                        continue;
-
-                if (!chan->engctx[oc->engine]) {
-                        ret = eng->context_new(chan, oc->engine);
-                        if (ret)
-                                return ret;
-                }
-
-                return eng->object_new(chan, oc->engine, handle, class);
-        }
-
-        return -EINVAL;
-}
-
-static int
-nouveau_gpuobj_channel_init_pramin(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t size;
-        uint32_t base;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d\n", chan->id);
-
-        /* Base amount for object storage (4KiB enough?) */
-        size = 0x2000;
-        base = 0;
-
-        if (dev_priv->card_type == NV_50) {
-                /* Various fixed table thingos */
-                size += 0x1400; /* mostly unknown stuff */
-                size += 0x4000; /* vm pd */
-                base  = 0x6000;
-                /* RAMHT, not sure about setting size yet, 32KiB to be safe */
-                size += 0x8000;
-                /* RAMFC */
-                size += 0x1000;
-        }
-
-        ret = nouveau_gpuobj_new(dev, NULL, size, 0x1000, 0, &chan->ramin);
-        if (ret) {
-                NV_ERROR(dev, "Error allocating channel PRAMIN: %d\n", ret);
-                return ret;
-        }
-
-        ret = drm_mm_init(&chan->ramin_heap, base, size - base);
-        if (ret) {
-                NV_ERROR(dev, "Error creating PRAMIN heap: %d\n", ret);
-                nouveau_gpuobj_ref(NULL, &chan->ramin);
-                return ret;
-        }
-
-        return 0;
-}
-
-static int
-nvc0_gpuobj_channel_init(struct nouveau_channel *chan, struct nouveau_vm *vm)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *pgd = NULL;
-        struct nouveau_vm_pgd *vpgd;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 4096, 0x1000, 0, &chan->ramin);
-        if (ret)
-                return ret;
-
-        /* create page directory for this vm if none currently exists,
-         * will be destroyed automagically when last reference to the
-         * vm is removed
-         */
-        if (list_empty(&vm->pgd_list)) {
-                ret = nouveau_gpuobj_new(dev, NULL, 65536, 0x1000, 0, &pgd);
-                if (ret)
-                        return ret;
-        }
-        nouveau_vm_ref(vm, &chan->vm, pgd);
-        nouveau_gpuobj_ref(NULL, &pgd);
-
-        /* point channel at vm's page directory */
-        vpgd = list_first_entry(&vm->pgd_list, struct nouveau_vm_pgd, head);
-        nv_wo32(chan->ramin, 0x0200, lower_32_bits(vpgd->obj->vinst));
-        nv_wo32(chan->ramin, 0x0204, upper_32_bits(vpgd->obj->vinst));
-        nv_wo32(chan->ramin, 0x0208, 0xffffffff);
-        nv_wo32(chan->ramin, 0x020c, 0x000000ff);
-
-        return 0;
-}
-
-int
-nouveau_gpuobj_channel_init(struct nouveau_channel *chan,
-                            uint32_t vram_h, uint32_t tt_h)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(chan->file_priv);
-        struct nouveau_vm *vm = fpriv ? fpriv->vm : dev_priv->chan_vm;
-        struct nouveau_gpuobj *vram = NULL, *tt = NULL;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d vram=0x%08x tt=0x%08x\n", chan->id, vram_h, tt_h);
-        if (dev_priv->card_type >= NV_C0)
-                return nvc0_gpuobj_channel_init(chan, vm);
-
-        /* Allocate a chunk of memory for per-channel object storage */
-        ret = nouveau_gpuobj_channel_init_pramin(chan);
-        if (ret) {
-                NV_ERROR(dev, "init pramin\n");
-                return ret;
-        }
-
-        /* NV50 VM
-         *  - Allocate per-channel page-directory
-         *  - Link with shared channel VM
-         */
-        if (vm) {
-                u32 pgd_offs = (dev_priv->chipset == 0x50) ? 0x1400 : 0x0200;
-                u64 vm_vinst = chan->ramin->vinst + pgd_offs;
-                u32 vm_pinst = chan->ramin->pinst;
-
-                if (vm_pinst != ~0)
-                        vm_pinst += pgd_offs;
-
-                ret = nouveau_gpuobj_new_fake(dev, vm_pinst, vm_vinst, 0x4000,
-                                              0, &chan->vm_pd);
-                if (ret)
-                        return ret;
-
-                nouveau_vm_ref(vm, &chan->vm, chan->vm_pd);
-        }
-
-        /* RAMHT */
-        if (dev_priv->card_type < NV_50) {
-                nouveau_ramht_ref(dev_priv->ramht, &chan->ramht, NULL);
-        } else {
-                struct nouveau_gpuobj *ramht = NULL;
-
-                ret = nouveau_gpuobj_new(dev, chan, 0x8000, 16,
-                                         NVOBJ_FLAG_ZERO_ALLOC, &ramht);
-                if (ret)
-                        return ret;
-
-                ret = nouveau_ramht_new(dev, ramht, &chan->ramht);
-                nouveau_gpuobj_ref(NULL, &ramht);
-                if (ret)
-                        return ret;
-        }
-
-        /* VRAM ctxdma */
-        if (dev_priv->card_type >= NV_50) {
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
-                                             0, (1ULL << 40), NV_MEM_ACCESS_RW,
-                                             NV_MEM_TARGET_VM, &vram);
-                if (ret) {
-                        NV_ERROR(dev, "Error creating VRAM ctxdma: %d\n", ret);
-                        return ret;
-                }
-        } else {
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
-                                             0, dev_priv->fb_available_size,
-                                             NV_MEM_ACCESS_RW,
-                                             NV_MEM_TARGET_VRAM, &vram);
-                if (ret) {
-                        NV_ERROR(dev, "Error creating VRAM ctxdma: %d\n", ret);
-                        return ret;
-                }
-        }
-
-        ret = nouveau_ramht_insert(chan, vram_h, vram);
-        nouveau_gpuobj_ref(NULL, &vram);
-        if (ret) {
-                NV_ERROR(dev, "Error adding VRAM ctxdma to RAMHT: %d\n", ret);
-                return ret;
-        }
-
-        /* TT memory ctxdma */
-        if (dev_priv->card_type >= NV_50) {
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
-                                             0, (1ULL << 40), NV_MEM_ACCESS_RW,
-                                             NV_MEM_TARGET_VM, &tt);
-        } else {
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
-                                             0, dev_priv->gart_info.aper_size,
-                                             NV_MEM_ACCESS_RW,
-                                             NV_MEM_TARGET_GART, &tt);
-        }
-
-        if (ret) {
-                NV_ERROR(dev, "Error creating TT ctxdma: %d\n", ret);
-                return ret;
-        }
-
-        ret = nouveau_ramht_insert(chan, tt_h, tt);
-        nouveau_gpuobj_ref(NULL, &tt);
-        if (ret) {
-                NV_ERROR(dev, "Error adding TT ctxdma to RAMHT: %d\n", ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-void
-nouveau_gpuobj_channel_takedown(struct nouveau_channel *chan)
-{
-        NV_DEBUG(chan->dev, "ch%d\n", chan->id);
-
-        nouveau_vm_ref(NULL, &chan->vm, chan->vm_pd);
-        nouveau_gpuobj_ref(NULL, &chan->vm_pd);
-
-        if (drm_mm_initialized(&chan->ramin_heap))
-                drm_mm_takedown(&chan->ramin_heap);
-        nouveau_gpuobj_ref(NULL, &chan->ramin);
-}
-
-int
-nouveau_gpuobj_suspend(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj;
-        int i;
-
-        list_for_each_entry(gpuobj, &dev_priv->gpuobj_list, list) {
-                if (gpuobj->cinst != NVOBJ_CINST_GLOBAL)
-                        continue;
-
-                gpuobj->suspend = vmalloc(gpuobj->size);
-                if (!gpuobj->suspend) {
-                        nouveau_gpuobj_resume(dev);
-                        return -ENOMEM;
-                }
-
-                for (i = 0; i < gpuobj->size; i += 4)
-                        gpuobj->suspend[i/4] = nv_ro32(gpuobj, i);
-        }
-
-        return 0;
-}
-
-void
-nouveau_gpuobj_resume(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj;
-        int i;
-
-        list_for_each_entry(gpuobj, &dev_priv->gpuobj_list, list) {
-                if (!gpuobj->suspend)
-                        continue;
-
-                for (i = 0; i < gpuobj->size; i += 4)
-                        nv_wo32(gpuobj, i, gpuobj->suspend[i/4]);
-
-                vfree(gpuobj->suspend);
-                gpuobj->suspend = NULL;
-        }
-
-        dev_priv->engine.instmem.flush(dev);
-}
-
-u32
-nv_ro32(struct nouveau_gpuobj *gpuobj, u32 offset)
-{
-        struct drm_nouveau_private *dev_priv = gpuobj->dev->dev_private;
-        struct drm_device *dev = gpuobj->dev;
-        unsigned long flags;
-
-        if (gpuobj->pinst == ~0 || !dev_priv->ramin_available) {
-                u64  ptr = gpuobj->vinst + offset;
-                u32 base = ptr >> 16;
-                u32  val;
-
-                spin_lock_irqsave(&dev_priv->vm_lock, flags);
-                if (dev_priv->ramin_base != base) {
-                        dev_priv->ramin_base = base;
-                        nv_wr32(dev, 0x001700, dev_priv->ramin_base);
-                }
-                val = nv_rd32(dev, 0x700000 + (ptr & 0xffff));
-                spin_unlock_irqrestore(&dev_priv->vm_lock, flags);
-                return val;
-        }
-
-        return nv_ri32(dev, gpuobj->pinst + offset);
-}
-
-void
-nv_wo32(struct nouveau_gpuobj *gpuobj, u32 offset, u32 val)
-{
-        struct drm_nouveau_private *dev_priv = gpuobj->dev->dev_private;
-        struct drm_device *dev = gpuobj->dev;
-        unsigned long flags;
-
-        if (gpuobj->pinst == ~0 || !dev_priv->ramin_available) {
-                u64  ptr = gpuobj->vinst + offset;
-                u32 base = ptr >> 16;
-
-                spin_lock_irqsave(&dev_priv->vm_lock, flags);
-                if (dev_priv->ramin_base != base) {
-                        dev_priv->ramin_base = base;
-                        nv_wr32(dev, 0x001700, dev_priv->ramin_base);
-                }
-                nv_wr32(dev, 0x700000 + (ptr & 0xffff), val);
-                spin_unlock_irqrestore(&dev_priv->vm_lock, flags);
-                return;
-        }
-
-        nv_wi32(dev, gpuobj->pinst + offset, val);
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_hdmi.c b/drivers/gpu/drm/nouveau/nouveau_hdmi.c
index c3de36384522..ea712b5762e7 100644
--- a/drivers/gpu/drm/nouveau/nouveau_hdmi.c
+++ b/drivers/gpu/drm/nouveau/nouveau_hdmi.c
@@ -23,7 +23,7 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_connector.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
@@ -31,10 +31,10 @@
 static bool
 hdmi_sor(struct drm_encoder *encoder)
 {
-        struct drm_nouveau_private *dev_priv = encoder->dev->dev_private;
-        if (dev_priv->chipset <  0xa3 ||
-            dev_priv->chipset == 0xaa ||
-            dev_priv->chipset == 0xac)
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        if (nv_device(drm->device)->chipset <  0xa3 ||
+            nv_device(drm->device)->chipset == 0xaa ||
+            nv_device(drm->device)->chipset == 0xac)
                 return false;
         return true;
 }
@@ -52,13 +52,15 @@ hdmi_base(struct drm_encoder *encoder)
 static void
 hdmi_wr32(struct drm_encoder *encoder, u32 reg, u32 val)
 {
-        nv_wr32(encoder->dev, hdmi_base(encoder) + reg, val);
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
+        nv_wr32(device, hdmi_base(encoder) + reg, val);
 }
 
 static u32
 hdmi_rd32(struct drm_encoder *encoder, u32 reg)
 {
-        return nv_rd32(encoder->dev, hdmi_base(encoder) + reg);
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
+        return nv_rd32(device, hdmi_base(encoder) + reg);
 }
 
 static u32
@@ -73,12 +75,11 @@ static void
 nouveau_audio_disconnect(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
         u32 or = nv_encoder->or * 0x800;
 
-        if (hdmi_sor(encoder)) {
-                nv_mask(dev, 0x61c448 + or, 0x00000003, 0x00000000);
-        }
+        if (hdmi_sor(encoder))
+                nv_mask(device, 0x61c448 + or, 0x00000003, 0x00000000);
 }
 
 static void
@@ -86,8 +87,8 @@ nouveau_audio_mode_set(struct drm_encoder *encoder,
                        struct drm_display_mode *mode)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
         struct nouveau_connector *nv_connector;
-        struct drm_device *dev = encoder->dev;
         u32 or = nv_encoder->or * 0x800;
         int i;
 
@@ -98,16 +99,16 @@ nouveau_audio_mode_set(struct drm_encoder *encoder,
         }
 
         if (hdmi_sor(encoder)) {
-                nv_mask(dev, 0x61c448 + or, 0x00000001, 0x00000001);
+                nv_mask(device, 0x61c448 + or, 0x00000001, 0x00000001);
 
                 drm_edid_to_eld(&nv_connector->base, nv_connector->edid);
                 if (nv_connector->base.eld[0]) {
                         u8 *eld = nv_connector->base.eld;
                         for (i = 0; i < eld[2] * 4; i++)
-                                nv_wr32(dev, 0x61c440 + or, (i << 8) | eld[i]);
+                                nv_wr32(device, 0x61c440 + or, (i << 8) | eld[i]);
                         for (i = eld[2] * 4; i < 0x60; i++)
-                                nv_wr32(dev, 0x61c440 + or, (i << 8) | 0x00);
-                        nv_mask(dev, 0x61c448 + or, 0x00000002, 0x00000002);
+                                nv_wr32(device, 0x61c440 + or, (i << 8) | 0x00);
+                        nv_mask(device, 0x61c448 + or, 0x00000002, 0x00000002);
                 }
         }
 }
@@ -219,9 +220,9 @@ void
 nouveau_hdmi_mode_set(struct drm_encoder *encoder,
                       struct drm_display_mode *mode)
 {
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct nouveau_connector *nv_connector;
-        struct drm_device *dev = encoder->dev;
         u32 max_ac_packet, rekey;
 
         nv_connector = nouveau_encoder_connector_get(nv_encoder);
@@ -238,9 +239,9 @@ nouveau_hdmi_mode_set(struct drm_encoder *encoder,
         hdmi_mask(encoder, 0x068, 0x00010101, 0x00000000); /* ACR_CTRL, ?? */
         hdmi_mask(encoder, 0x078, 0x80000000, 0x80000000); /* ACR_0441_ENABLE */
 
-        nv_mask(dev, 0x61733c, 0x00100000, 0x00100000); /* RESETF */
-        nv_mask(dev, 0x61733c, 0x10000000, 0x10000000); /* LOOKUP_EN */
-        nv_mask(dev, 0x61733c, 0x00100000, 0x00000000); /* !RESETF */
+        nv_mask(device, 0x61733c, 0x00100000, 0x00100000); /* RESETF */
+        nv_mask(device, 0x61733c, 0x10000000, 0x10000000); /* LOOKUP_EN */
+        nv_mask(device, 0x61733c, 0x00100000, 0x00000000); /* !RESETF */
 
         /* value matches nvidia binary driver, and tegra constant */
         rekey = 56;
diff --git a/drivers/gpu/drm/nouveau/nouveau_hw.c b/drivers/gpu/drm/nouveau/nouveau_hw.c
index b87ad3bd7739..a78b24704794 100644
--- a/drivers/gpu/drm/nouveau/nouveau_hw.c
+++ b/drivers/gpu/drm/nouveau/nouveau_hw.c
@@ -23,9 +23,13 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_hw.h"
 
+#include <subdev/bios/pll.h>
+#include <subdev/clock.h>
+#include <subdev/timer.h>
+
 #define CHIPSET_NFORCE 0x01a0
 #define CHIPSET_NFORCE2 0x01f0
 
@@ -82,12 +86,12 @@ NVReadVgaGr(struct drm_device *dev, int head, uint8_t index)
 void
 NVSetOwner(struct drm_device *dev, int owner)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         if (owner == 1)
                 owner *= 3;
 
-        if (dev_priv->chipset == 0x11) {
+        if (nv_device(drm->device)->chipset == 0x11) {
                 /* This might seem stupid, but the blob does it and
                  * omitting it often locks the system up.
                  */
@@ -98,7 +102,7 @@ NVSetOwner(struct drm_device *dev, int owner)
         /* CR44 is always changed on CRTC0 */
         NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_44, owner);
 
-        if (dev_priv->chipset == 0x11) {        /* set me harder */
+        if (nv_device(drm->device)->chipset == 0x11) {  /* set me harder */
                 NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_2E, owner);
                 NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_2E, owner);
         }
@@ -123,270 +127,6 @@ NVBlankScreen(struct drm_device *dev, int head, bool blank)
 }
 
 /*
- * PLL setting
- */
-
-static int
-powerctrl_1_shift(int chip_version, int reg)
-{
-        int shift = -4;
-
-        if (chip_version < 0x17 || chip_version == 0x1a || chip_version == 0x20)
-                return shift;
-
-        switch (reg) {
-        case NV_RAMDAC_VPLL2:
-                shift += 4;
-        case NV_PRAMDAC_VPLL_COEFF:
-                shift += 4;
-        case NV_PRAMDAC_MPLL_COEFF:
-                shift += 4;
-        case NV_PRAMDAC_NVPLL_COEFF:
-                shift += 4;
-        }
-
-        /*
-         * the shift for vpll regs is only used for nv3x chips with a single
-         * stage pll
-         */
-        if (shift > 4 && (chip_version < 0x32 || chip_version == 0x35 ||
-                          chip_version == 0x36 || chip_version >= 0x40))
-                shift = -4;
-
-        return shift;
-}
-
-static void
-setPLL_single(struct drm_device *dev, uint32_t reg, struct nouveau_pll_vals *pv)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chip_version = dev_priv->vbios.chip_version;
-        uint32_t oldpll = NVReadRAMDAC(dev, 0, reg);
-        int oldN = (oldpll >> 8) & 0xff, oldM = oldpll & 0xff;
-        uint32_t pll = (oldpll & 0xfff80000) | pv->log2P << 16 | pv->NM1;
-        uint32_t saved_powerctrl_1 = 0;
-        int shift_powerctrl_1 = powerctrl_1_shift(chip_version, reg);
-
-        if (oldpll == pll)
-                return; /* already set */
-
-        if (shift_powerctrl_1 >= 0) {
-                saved_powerctrl_1 = nvReadMC(dev, NV_PBUS_POWERCTRL_1);
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_1,
-                        (saved_powerctrl_1 & ~(0xf << shift_powerctrl_1)) |
-                        1 << shift_powerctrl_1);
-        }
-
-        if (oldM && pv->M1 && (oldN / oldM < pv->N1 / pv->M1))
-                /* upclock -- write new post divider first */
-                NVWriteRAMDAC(dev, 0, reg, pv->log2P << 16 | (oldpll & 0xffff));
-        else
-                /* downclock -- write new NM first */
-                NVWriteRAMDAC(dev, 0, reg, (oldpll & 0xffff0000) | pv->NM1);
-
-        if (chip_version < 0x17 && chip_version != 0x11)
-                /* wait a bit on older chips */
-                msleep(64);
-        NVReadRAMDAC(dev, 0, reg);
-
-        /* then write the other half as well */
-        NVWriteRAMDAC(dev, 0, reg, pll);
-
-        if (shift_powerctrl_1 >= 0)
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_1, saved_powerctrl_1);
-}
-
-static uint32_t
-new_ramdac580(uint32_t reg1, bool ss, uint32_t ramdac580)
-{
-        bool head_a = (reg1 == NV_PRAMDAC_VPLL_COEFF);
-
-        if (ss) /* single stage pll mode */
-                ramdac580 |= head_a ? NV_RAMDAC_580_VPLL1_ACTIVE :
-                                      NV_RAMDAC_580_VPLL2_ACTIVE;
-        else
-                ramdac580 &= head_a ? ~NV_RAMDAC_580_VPLL1_ACTIVE :
-                                      ~NV_RAMDAC_580_VPLL2_ACTIVE;
-
-        return ramdac580;
-}
-
-static void
-setPLL_double_highregs(struct drm_device *dev, uint32_t reg1,
-                       struct nouveau_pll_vals *pv)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chip_version = dev_priv->vbios.chip_version;
-        bool nv3035 = chip_version == 0x30 || chip_version == 0x35;
-        uint32_t reg2 = reg1 + ((reg1 == NV_RAMDAC_VPLL2) ? 0x5c : 0x70);
-        uint32_t oldpll1 = NVReadRAMDAC(dev, 0, reg1);
-        uint32_t oldpll2 = !nv3035 ? NVReadRAMDAC(dev, 0, reg2) : 0;
-        uint32_t pll1 = (oldpll1 & 0xfff80000) | pv->log2P << 16 | pv->NM1;
-        uint32_t pll2 = (oldpll2 & 0x7fff0000) | 1 << 31 | pv->NM2;
-        uint32_t oldramdac580 = 0, ramdac580 = 0;
-        bool single_stage = !pv->NM2 || pv->N2 == pv->M2;       /* nv41+ only */
-        uint32_t saved_powerctrl_1 = 0, savedc040 = 0;
-        int shift_powerctrl_1 = powerctrl_1_shift(chip_version, reg1);
-
-        /* model specific additions to generic pll1 and pll2 set up above */
-        if (nv3035) {
-                pll1 = (pll1 & 0xfcc7ffff) | (pv->N2 & 0x18) << 21 |
-                       (pv->N2 & 0x7) << 19 | 8 << 4 | (pv->M2 & 7) << 4;
-                pll2 = 0;
-        }
-        if (chip_version > 0x40 && reg1 >= NV_PRAMDAC_VPLL_COEFF) { /* !nv40 */
-                oldramdac580 = NVReadRAMDAC(dev, 0, NV_PRAMDAC_580);
-                ramdac580 = new_ramdac580(reg1, single_stage, oldramdac580);
-                if (oldramdac580 != ramdac580)
-                        oldpll1 = ~0;   /* force mismatch */
-                if (single_stage)
-                        /* magic value used by nvidia in single stage mode */
-                        pll2 |= 0x011f;
-        }
-        if (chip_version > 0x70)
-                /* magic bits set by the blob (but not the bios) on g71-73 */
-                pll1 = (pll1 & 0x7fffffff) | (single_stage ? 0x4 : 0xc) << 28;
-
-        if (oldpll1 == pll1 && oldpll2 == pll2)
-                return; /* already set */
-
-        if (shift_powerctrl_1 >= 0) {
-                saved_powerctrl_1 = nvReadMC(dev, NV_PBUS_POWERCTRL_1);
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_1,
-                        (saved_powerctrl_1 & ~(0xf << shift_powerctrl_1)) |
-                        1 << shift_powerctrl_1);
-        }
-
-        if (chip_version >= 0x40) {
-                int shift_c040 = 14;
-
-                switch (reg1) {
-                case NV_PRAMDAC_MPLL_COEFF:
-                        shift_c040 += 2;
-                case NV_PRAMDAC_NVPLL_COEFF:
-                        shift_c040 += 2;
-                case NV_RAMDAC_VPLL2:
-                        shift_c040 += 2;
-                case NV_PRAMDAC_VPLL_COEFF:
-                        shift_c040 += 2;
-                }
-
-                savedc040 = nvReadMC(dev, 0xc040);
-                if (shift_c040 != 14)
-                        nvWriteMC(dev, 0xc040, savedc040 & ~(3 << shift_c040));
-        }
-
-        if (oldramdac580 != ramdac580)
-                NVWriteRAMDAC(dev, 0, NV_PRAMDAC_580, ramdac580);
-
-        if (!nv3035)
-                NVWriteRAMDAC(dev, 0, reg2, pll2);
-        NVWriteRAMDAC(dev, 0, reg1, pll1);
-
-        if (shift_powerctrl_1 >= 0)
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_1, saved_powerctrl_1);
-        if (chip_version >= 0x40)
-                nvWriteMC(dev, 0xc040, savedc040);
-}
-
-static void
-setPLL_double_lowregs(struct drm_device *dev, uint32_t NMNMreg,
-                      struct nouveau_pll_vals *pv)
-{
-        /* When setting PLLs, there is a merry game of disabling and enabling
-         * various bits of hardware during the process. This function is a
-         * synthesis of six nv4x traces, nearly each card doing a subtly
-         * different thing. With luck all the necessary bits for each card are
-         * combined herein. Without luck it deviates from each card's formula
-         * so as to not work on any :)
-         */
-
-        uint32_t Preg = NMNMreg - 4;
-        bool mpll = Preg == 0x4020;
-        uint32_t oldPval = nvReadMC(dev, Preg);
-        uint32_t NMNM = pv->NM2 << 16 | pv->NM1;
-        uint32_t Pval = (oldPval & (mpll ? ~(0x77 << 16) : ~(7 << 16))) |
-                        0xc << 28 | pv->log2P << 16;
-        uint32_t saved4600 = 0;
-        /* some cards have different maskc040s */
-        uint32_t maskc040 = ~(3 << 14), savedc040;
-        bool single_stage = !pv->NM2 || pv->N2 == pv->M2;
-
-        if (nvReadMC(dev, NMNMreg) == NMNM && (oldPval & 0xc0070000) == Pval)
-                return;
-
-        if (Preg == 0x4000)
-                maskc040 = ~0x333;
-        if (Preg == 0x4058)
-                maskc040 = ~(0xc << 24);
-
-        if (mpll) {
-                struct pll_lims pll_lim;
-                uint8_t Pval2;
-
-                if (get_pll_limits(dev, Preg, &pll_lim))
-                        return;
-
-                Pval2 = pv->log2P + pll_lim.log2p_bias;
-                if (Pval2 > pll_lim.max_log2p)
-                        Pval2 = pll_lim.max_log2p;
-                Pval |= 1 << 28 | Pval2 << 20;
-
-                saved4600 = nvReadMC(dev, 0x4600);
-                nvWriteMC(dev, 0x4600, saved4600 | 8 << 28);
-        }
-        if (single_stage)
-                Pval |= mpll ? 1 << 12 : 1 << 8;
-
-        nvWriteMC(dev, Preg, oldPval | 1 << 28);
-        nvWriteMC(dev, Preg, Pval & ~(4 << 28));
-        if (mpll) {
-                Pval |= 8 << 20;
-                nvWriteMC(dev, 0x4020, Pval & ~(0xc << 28));
-                nvWriteMC(dev, 0x4038, Pval & ~(0xc << 28));
-        }
-
-        savedc040 = nvReadMC(dev, 0xc040);
-        nvWriteMC(dev, 0xc040, savedc040 & maskc040);
-
-        nvWriteMC(dev, NMNMreg, NMNM);
-        if (NMNMreg == 0x4024)
-                nvWriteMC(dev, 0x403c, NMNM);
-
-        nvWriteMC(dev, Preg, Pval);
-        if (mpll) {
-                Pval &= ~(8 << 20);
-                nvWriteMC(dev, 0x4020, Pval);
-                nvWriteMC(dev, 0x4038, Pval);
-                nvWriteMC(dev, 0x4600, saved4600);
-        }
-
-        nvWriteMC(dev, 0xc040, savedc040);
-
-        if (mpll) {
-                nvWriteMC(dev, 0x4020, Pval & ~(1 << 28));
-                nvWriteMC(dev, 0x4038, Pval & ~(1 << 28));
-        }
-}
-
-void
-nouveau_hw_setpll(struct drm_device *dev, uint32_t reg1,
-                  struct nouveau_pll_vals *pv)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int cv = dev_priv->vbios.chip_version;
-
-        if (cv == 0x30 || cv == 0x31 || cv == 0x35 || cv == 0x36 ||
-            cv >= 0x40) {
-                if (reg1 > 0x405c)
-                        setPLL_double_highregs(dev, reg1, pv);
-                else
-                        setPLL_double_lowregs(dev, reg1, pv);
-        } else
-                setPLL_single(dev, reg1, pv);
-}
-
-/*
  * PLL getting
  */
 
@@ -394,7 +134,7 @@ static void
 nouveau_hw_decode_pll(struct drm_device *dev, uint32_t reg1, uint32_t pll1,
                       uint32_t pll2, struct nouveau_pll_vals *pllvals)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         /* to force parsing as single stage (i.e. nv40 vplls) pass pll2 as 0 */
 
@@ -411,7 +151,7 @@ nouveau_hw_decode_pll(struct drm_device *dev, uint32_t reg1, uint32_t pll1,
                 pllvals->NM1 = pll1 & 0xffff;
                 if (nv_two_reg_pll(dev) && pll2 & NV31_RAMDAC_ENABLE_VCO2)
                         pllvals->NM2 = pll2 & 0xffff;
-                else if (dev_priv->chipset == 0x30 || dev_priv->chipset == 0x35) {
+                else if (nv_device(drm->device)->chipset == 0x30 || nv_device(drm->device)->chipset == 0x35) {
                         pllvals->M1 &= 0xf; /* only 4 bits */
                         if (pll1 & NV30_RAMDAC_ENABLE_VCO2) {
                                 pllvals->M2 = (pll1 >> 4) & 0x7;
@@ -423,28 +163,30 @@ nouveau_hw_decode_pll(struct drm_device *dev, uint32_t reg1, uint32_t pll1,
 }
 
 int
-nouveau_hw_get_pllvals(struct drm_device *dev, enum pll_types plltype,
+nouveau_hw_get_pllvals(struct drm_device *dev, enum nvbios_pll_type plltype,
                        struct nouveau_pll_vals *pllvals)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t reg1 = get_pll_register(dev, plltype), pll1, pll2 = 0;
-        struct pll_lims pll_lim;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        uint32_t reg1, pll1, pll2 = 0;
+        struct nvbios_pll pll_lim;
         int ret;
 
-        if (reg1 == 0)
+        ret = nvbios_pll_parse(bios, plltype, &pll_lim);
+        if (ret || !(reg1 = pll_lim.reg))
                 return -ENOENT;
 
-        pll1 = nvReadMC(dev, reg1);
-
+        pll1 = nv_rd32(device, reg1);
         if (reg1 <= 0x405c)
-                pll2 = nvReadMC(dev, reg1 + 4);
+                pll2 = nv_rd32(device, reg1 + 4);
         else if (nv_two_reg_pll(dev)) {
                 uint32_t reg2 = reg1 + (reg1 == NV_RAMDAC_VPLL2 ? 0x5c : 0x70);
 
-                pll2 = nvReadMC(dev, reg2);
+                pll2 = nv_rd32(device, reg2);
         }
 
-        if (dev_priv->card_type == 0x40 && reg1 >= NV_PRAMDAC_VPLL_COEFF) {
+        if (nv_device(drm->device)->card_type == 0x40 && reg1 >= NV_PRAMDAC_VPLL_COEFF) {
                 uint32_t ramdac580 = NVReadRAMDAC(dev, 0, NV_PRAMDAC_580);
 
                 /* check whether vpll has been forced into single stage mode */
@@ -457,13 +199,7 @@ nouveau_hw_get_pllvals(struct drm_device *dev, enum pll_types plltype,
         }
 
         nouveau_hw_decode_pll(dev, reg1, pll1, pll2, pllvals);
-
-        ret = get_pll_limits(dev, plltype, &pll_lim);
-        if (ret)
-                return ret;
-
         pllvals->refclk = pll_lim.refclk;
-
         return 0;
 }
 
@@ -478,7 +214,7 @@ nouveau_hw_pllvals_to_clk(struct nouveau_pll_vals *pv)
 }
 
 int
-nouveau_hw_get_clock(struct drm_device *dev, enum pll_types plltype)
+nouveau_hw_get_clock(struct drm_device *dev, enum nvbios_pll_type plltype)
 {
         struct nouveau_pll_vals pllvals;
         int ret;
@@ -517,26 +253,30 @@ nouveau_hw_fix_bad_vpll(struct drm_device *dev, int head)
          * when such a condition detected.  only seen on nv11 to date
          */
 
-        struct pll_lims pll_lim;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_clock *clk = nouveau_clock(device);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nvbios_pll pll_lim;
         struct nouveau_pll_vals pv;
-        enum pll_types pll = head ? PLL_VPLL1 : PLL_VPLL0;
+        enum nvbios_pll_type pll = head ? PLL_VPLL1 : PLL_VPLL0;
 
-        if (get_pll_limits(dev, pll, &pll_lim))
+        if (nvbios_pll_parse(bios, pll, &pll_lim))
                 return;
         nouveau_hw_get_pllvals(dev, pll, &pv);
 
         if (pv.M1 >= pll_lim.vco1.min_m && pv.M1 <= pll_lim.vco1.max_m &&
             pv.N1 >= pll_lim.vco1.min_n && pv.N1 <= pll_lim.vco1.max_n &&
-            pv.log2P <= pll_lim.max_log2p)
+            pv.log2P <= pll_lim.max_p)
                 return;
 
-        NV_WARN(dev, "VPLL %d outwith limits, attempting to fix\n", head + 1);
+        NV_WARN(drm, "VPLL %d outwith limits, attempting to fix\n", head + 1);
 
         /* set lowest clock within static limits */
         pv.M1 = pll_lim.vco1.max_m;
         pv.N1 = pll_lim.vco1.min_n;
-        pv.log2P = pll_lim.max_usable_log2p;
-        nouveau_hw_setpll(dev, pll_lim.reg, &pv);
+        pv.log2P = pll_lim.max_p_usable;
+        clk->pll_prog(clk, pll_lim.reg, &pv);
 }
 
 /*
@@ -547,17 +287,16 @@ static void nouveau_vga_font_io(struct drm_device *dev,
                                 void __iomem *iovram,
                                 bool save, unsigned plane)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         unsigned i;
 
         NVWriteVgaSeq(dev, 0, NV_VIO_SR_PLANE_MASK_INDEX, 1 << plane);
         NVWriteVgaGr(dev, 0, NV_VIO_GX_READ_MAP_INDEX, plane);
         for (i = 0; i < 16384; i++) {
                 if (save) {
-                        dev_priv->saved_vga_font[plane][i] =
+                        nv04_display(dev)->saved_vga_font[plane][i] =
                                         ioread32_native(iovram + i * 4);
                 } else {
-                        iowrite32_native(dev_priv->saved_vga_font[plane][i],
+                        iowrite32_native(nv04_display(dev)->saved_vga_font[plane][i],
                                                         iovram + i * 4);
                 }
         }
@@ -566,6 +305,7 @@ static void nouveau_vga_font_io(struct drm_device *dev,
 void
 nouveau_hw_save_vga_fonts(struct drm_device *dev, bool save)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t misc, gr4, gr5, gr6, seq2, seq4;
         bool graphicsmode;
         unsigned plane;
@@ -581,12 +321,12 @@ nouveau_hw_save_vga_fonts(struct drm_device *dev, bool save)
         if (graphicsmode) /* graphics mode => framebuffer => no need to save */
                 return;
 
-        NV_INFO(dev, "%sing VGA fonts\n", save ? "Sav" : "Restor");
+        NV_INFO(drm, "%sing VGA fonts\n", save ? "Sav" : "Restor");
 
         /* map first 64KiB of VRAM, holds VGA fonts etc */
         iovram = ioremap(pci_resource_start(dev->pdev, 1), 65536);
         if (!iovram) {
-                NV_ERROR(dev, "Failed to map VRAM, "
+                NV_ERROR(drm, "Failed to map VRAM, "
                                         "cannot save/restore VGA fonts.\n");
                 return;
         }
@@ -649,25 +389,25 @@ static void
 nv_save_state_ramdac(struct drm_device *dev, int head,
                      struct nv04_mode_state *state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv04_crtc_reg *regp = &state->crtc_reg[head];
         int i;
 
-        if (dev_priv->card_type >= NV_10)
+        if (nv_device(drm->device)->card_type >= NV_10)
                 regp->nv10_cursync = NVReadRAMDAC(dev, head, NV_RAMDAC_NV10_CURSYNC);
 
         nouveau_hw_get_pllvals(dev, head ? PLL_VPLL1 : PLL_VPLL0, &regp->pllvals);
         state->pllsel = NVReadRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT);
         if (nv_two_heads(dev))
                 state->sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK);
-        if (dev_priv->chipset == 0x11)
+        if (nv_device(drm->device)->chipset == 0x11)
                 regp->dither = NVReadRAMDAC(dev, head, NV_RAMDAC_DITHER_NV11);
 
         regp->ramdac_gen_ctrl = NVReadRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL);
 
         if (nv_gf4_disp_arch(dev))
                 regp->ramdac_630 = NVReadRAMDAC(dev, head, NV_PRAMDAC_630);
-        if (dev_priv->chipset >= 0x30)
+        if (nv_device(drm->device)->chipset >= 0x30)
                 regp->ramdac_634 = NVReadRAMDAC(dev, head, NV_PRAMDAC_634);
 
         regp->tv_setup = NVReadRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP);
@@ -709,7 +449,7 @@ nv_save_state_ramdac(struct drm_device *dev, int head,
         if (nv_gf4_disp_arch(dev))
                 regp->ramdac_8c0 = NVReadRAMDAC(dev, head, NV_PRAMDAC_8C0);
 
-        if (dev_priv->card_type == NV_40) {
+        if (nv_device(drm->device)->card_type == NV_40) {
                 regp->ramdac_a20 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A20);
                 regp->ramdac_a24 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A24);
                 regp->ramdac_a34 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A34);
@@ -724,26 +464,27 @@ static void
 nv_load_state_ramdac(struct drm_device *dev, int head,
                      struct nv04_mode_state *state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_clock *clk = nouveau_clock(drm->device);
         struct nv04_crtc_reg *regp = &state->crtc_reg[head];
         uint32_t pllreg = head ? NV_RAMDAC_VPLL2 : NV_PRAMDAC_VPLL_COEFF;
         int i;
 
-        if (dev_priv->card_type >= NV_10)
+        if (nv_device(drm->device)->card_type >= NV_10)
                 NVWriteRAMDAC(dev, head, NV_RAMDAC_NV10_CURSYNC, regp->nv10_cursync);
 
-        nouveau_hw_setpll(dev, pllreg, &regp->pllvals);
+        clk->pll_prog(clk, pllreg, &regp->pllvals);
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT, state->pllsel);
         if (nv_two_heads(dev))
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, state->sel_clk);
-        if (dev_priv->chipset == 0x11)
+        if (nv_device(drm->device)->chipset == 0x11)
                 NVWriteRAMDAC(dev, head, NV_RAMDAC_DITHER_NV11, regp->dither);
 
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL, regp->ramdac_gen_ctrl);
 
         if (nv_gf4_disp_arch(dev))
                 NVWriteRAMDAC(dev, head, NV_PRAMDAC_630, regp->ramdac_630);
-        if (dev_priv->chipset >= 0x30)
+        if (nv_device(drm->device)->chipset >= 0x30)
                 NVWriteRAMDAC(dev, head, NV_PRAMDAC_634, regp->ramdac_634);
 
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP, regp->tv_setup);
@@ -780,7 +521,7 @@ nv_load_state_ramdac(struct drm_device *dev, int head,
         if (nv_gf4_disp_arch(dev))
                 NVWriteRAMDAC(dev, head, NV_PRAMDAC_8C0, regp->ramdac_8c0);
 
-        if (dev_priv->card_type == NV_40) {
+        if (nv_device(drm->device)->card_type == NV_40) {
                 NVWriteRAMDAC(dev, head, NV_PRAMDAC_A20, regp->ramdac_a20);
                 NVWriteRAMDAC(dev, head, NV_PRAMDAC_A24, regp->ramdac_a24);
                 NVWriteRAMDAC(dev, head, NV_PRAMDAC_A34, regp->ramdac_a34);
@@ -845,7 +586,7 @@ static void
 nv_save_state_ext(struct drm_device *dev, int head,
                   struct nv04_mode_state *state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv04_crtc_reg *regp = &state->crtc_reg[head];
         int i;
 
@@ -861,10 +602,10 @@ nv_save_state_ext(struct drm_device *dev, int head,
         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_20)
+        if (nv_device(drm->device)->card_type >= NV_20)
                 rd_cio_state(dev, head, regp, NV_CIO_CRE_47);
 
-        if (dev_priv->card_type >= NV_30)
+        if (nv_device(drm->device)->card_type >= NV_30)
                 rd_cio_state(dev, head, regp, 0x9f);
 
         rd_cio_state(dev, head, regp, NV_CIO_CRE_49);
@@ -873,14 +614,14 @@ nv_save_state_ext(struct drm_device *dev, int head,
         rd_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX);
         rd_cio_state(dev, head, regp, NV_CIO_CRE_ILACE__INDEX);
 
-        if (dev_priv->card_type >= NV_10) {
+        if (nv_device(drm->device)->card_type >= NV_10) {
                 regp->crtc_830 = NVReadCRTC(dev, head, NV_PCRTC_830);
                 regp->crtc_834 = NVReadCRTC(dev, head, NV_PCRTC_834);
 
-                if (dev_priv->card_type >= NV_30)
+                if (nv_device(drm->device)->card_type >= NV_30)
                         regp->gpio_ext = NVReadCRTC(dev, head, NV_PCRTC_GPIO_EXT);
 
-                if (dev_priv->card_type == NV_40)
+                if (nv_device(drm->device)->card_type == NV_40)
                         regp->crtc_850 = NVReadCRTC(dev, head, NV_PCRTC_850);
 
                 if (nv_two_heads(dev))
@@ -892,7 +633,7 @@ nv_save_state_ext(struct drm_device *dev, int head,
 
         rd_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH3__INDEX);
         rd_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH4__INDEX);
-        if (dev_priv->card_type >= NV_10) {
+        if (nv_device(drm->device)->card_type >= NV_10) {
                 rd_cio_state(dev, head, regp, NV_CIO_CRE_EBR_INDEX);
                 rd_cio_state(dev, head, regp, NV_CIO_CRE_CSB);
                 rd_cio_state(dev, head, regp, NV_CIO_CRE_4B);
@@ -920,12 +661,14 @@ static void
 nv_load_state_ext(struct drm_device *dev, int head,
                   struct nv04_mode_state *state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_timer *ptimer = nouveau_timer(device);
         struct nv04_crtc_reg *regp = &state->crtc_reg[head];
         uint32_t reg900;
         int i;
 
-        if (dev_priv->card_type >= NV_10) {
+        if (nv_device(drm->device)->card_type >= NV_10) {
                 if (nv_two_heads(dev))
                         /* setting ENGINE_CTRL (EC) *must* come before
                          * CIO_CRE_LCD, as writing CRE_LCD sets bits 16 & 17 in
@@ -933,24 +676,24 @@ nv_load_state_ext(struct drm_device *dev, int head,
                          */
                         NVWriteCRTC(dev, head, NV_PCRTC_ENGINE_CTRL, regp->crtc_eng_ctrl);
 
-                nvWriteVIDEO(dev, NV_PVIDEO_STOP, 1);
-                nvWriteVIDEO(dev, NV_PVIDEO_INTR_EN, 0);
-                nvWriteVIDEO(dev, NV_PVIDEO_OFFSET_BUFF(0), 0);
-                nvWriteVIDEO(dev, NV_PVIDEO_OFFSET_BUFF(1), 0);
-                nvWriteVIDEO(dev, NV_PVIDEO_LIMIT(0), dev_priv->fb_available_size - 1);
-                nvWriteVIDEO(dev, NV_PVIDEO_LIMIT(1), dev_priv->fb_available_size - 1);
-                nvWriteVIDEO(dev, NV_PVIDEO_UVPLANE_LIMIT(0), dev_priv->fb_available_size - 1);
-                nvWriteVIDEO(dev, NV_PVIDEO_UVPLANE_LIMIT(1), dev_priv->fb_available_size - 1);
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_2, 0);
+                nv_wr32(device, NV_PVIDEO_STOP, 1);
+                nv_wr32(device, NV_PVIDEO_INTR_EN, 0);
+                nv_wr32(device, NV_PVIDEO_OFFSET_BUFF(0), 0);
+                nv_wr32(device, NV_PVIDEO_OFFSET_BUFF(1), 0);
+                nv_wr32(device, NV_PVIDEO_LIMIT(0), 0); //drm->fb_available_size - 1);
+                nv_wr32(device, NV_PVIDEO_LIMIT(1), 0); //drm->fb_available_size - 1);
+                nv_wr32(device, NV_PVIDEO_UVPLANE_LIMIT(0), 0); //drm->fb_available_size - 1);
+                nv_wr32(device, NV_PVIDEO_UVPLANE_LIMIT(1), 0); //drm->fb_available_size - 1);
+                nv_wr32(device, NV_PBUS_POWERCTRL_2, 0);
 
                 NVWriteCRTC(dev, head, NV_PCRTC_CURSOR_CONFIG, regp->cursor_cfg);
                 NVWriteCRTC(dev, head, NV_PCRTC_830, regp->crtc_830);
                 NVWriteCRTC(dev, head, NV_PCRTC_834, regp->crtc_834);
 
-                if (dev_priv->card_type >= NV_30)
+                if (nv_device(drm->device)->card_type >= NV_30)
                         NVWriteCRTC(dev, head, NV_PCRTC_GPIO_EXT, regp->gpio_ext);
 
-                if (dev_priv->card_type == NV_40) {
+                if (nv_device(drm->device)->card_type == NV_40) {
                         NVWriteCRTC(dev, head, NV_PCRTC_850, regp->crtc_850);
 
                         reg900 = NVReadRAMDAC(dev, head, NV_PRAMDAC_900);
@@ -973,23 +716,23 @@ nv_load_state_ext(struct drm_device *dev, int head,
         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_20)
+        if (nv_device(drm->device)->card_type >= NV_20)
                 wr_cio_state(dev, head, regp, NV_CIO_CRE_47);
 
-        if (dev_priv->card_type >= NV_30)
+        if (nv_device(drm->device)->card_type >= NV_30)
                 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);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX);
-        if (dev_priv->card_type == NV_40)
+        if (nv_device(drm->device)->card_type == NV_40)
                 nv_fix_nv40_hw_cursor(dev, head);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_ILACE__INDEX);
 
         wr_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH3__INDEX);
         wr_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH4__INDEX);
-        if (dev_priv->card_type >= NV_10) {
+        if (nv_device(drm->device)->card_type >= NV_10) {
                 wr_cio_state(dev, head, regp, NV_CIO_CRE_EBR_INDEX);
                 wr_cio_state(dev, head, regp, NV_CIO_CRE_CSB);
                 wr_cio_state(dev, head, regp, NV_CIO_CRE_4B);
@@ -997,11 +740,11 @@ nv_load_state_ext(struct drm_device *dev, int head,
         }
         /* NV11 and NV20 stop at 0x52. */
         if (nv_gf4_disp_arch(dev)) {
-                if (dev_priv->card_type == NV_10) {
+                if (nv_device(drm->device)->card_type == NV_10) {
                         /* Not waiting for vertical retrace before modifying
                            CRE_53/CRE_54 causes lockups. */
-                        nouveau_wait_eq(dev, 650000000, NV_PRMCIO_INP0__COLOR, 0x8, 0x8);
-                        nouveau_wait_eq(dev, 650000000, NV_PRMCIO_INP0__COLOR, 0x8, 0x0);
+                        nouveau_timer_wait_eq(ptimer, 650000000, NV_PRMCIO_INP0__COLOR, 0x8, 0x8);
+                        nouveau_timer_wait_eq(ptimer, 650000000, NV_PRMCIO_INP0__COLOR, 0x8, 0x0);
                 }
 
                 wr_cio_state(dev, head, regp, NV_CIO_CRE_42);
@@ -1024,14 +767,15 @@ static void
 nv_save_state_palette(struct drm_device *dev, int head,
                       struct nv04_mode_state *state)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         int head_offset = head * NV_PRMDIO_SIZE, i;
 
-        nv_wr08(dev, NV_PRMDIO_PIXEL_MASK + head_offset,
+        nv_wr08(device, NV_PRMDIO_PIXEL_MASK + head_offset,
                                 NV_PRMDIO_PIXEL_MASK_MASK);
-        nv_wr08(dev, NV_PRMDIO_READ_MODE_ADDRESS + head_offset, 0x0);
+        nv_wr08(device, NV_PRMDIO_READ_MODE_ADDRESS + head_offset, 0x0);
 
         for (i = 0; i < 768; i++) {
-                state->crtc_reg[head].DAC[i] = nv_rd08(dev,
+                state->crtc_reg[head].DAC[i] = nv_rd08(device,
                                 NV_PRMDIO_PALETTE_DATA + head_offset);
         }
 
@@ -1042,14 +786,15 @@ void
 nouveau_hw_load_state_palette(struct drm_device *dev, int head,
                               struct nv04_mode_state *state)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         int head_offset = head * NV_PRMDIO_SIZE, i;
 
-        nv_wr08(dev, NV_PRMDIO_PIXEL_MASK + head_offset,
+        nv_wr08(device, NV_PRMDIO_PIXEL_MASK + head_offset,
                                 NV_PRMDIO_PIXEL_MASK_MASK);
-        nv_wr08(dev, NV_PRMDIO_WRITE_MODE_ADDRESS + head_offset, 0x0);
+        nv_wr08(device, NV_PRMDIO_WRITE_MODE_ADDRESS + head_offset, 0x0);
 
         for (i = 0; i < 768; i++) {
-                nv_wr08(dev, NV_PRMDIO_PALETTE_DATA + head_offset,
+                nv_wr08(device, NV_PRMDIO_PALETTE_DATA + head_offset,
                                 state->crtc_reg[head].DAC[i]);
         }
 
@@ -1059,9 +804,9 @@ nouveau_hw_load_state_palette(struct drm_device *dev, int head,
 void nouveau_hw_save_state(struct drm_device *dev, int head,
                            struct nv04_mode_state *state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        if (dev_priv->chipset == 0x11)
+        if (nv_device(drm->device)->chipset == 0x11)
                 /* NB: no attempt is made to restore the bad pll later on */
                 nouveau_hw_fix_bad_vpll(dev, head);
         nv_save_state_ramdac(dev, head, state);
diff --git a/drivers/gpu/drm/nouveau/nouveau_hw.h b/drivers/gpu/drm/nouveau/nouveau_hw.h
index 2989090b9434..ba8fc0f9e0db 100644
--- a/drivers/gpu/drm/nouveau/nouveau_hw.h
+++ b/drivers/gpu/drm/nouveau/nouveau_hw.h
@@ -24,7 +24,9 @@
 #define __NOUVEAU_HW_H__
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nv04_display.h"
+
+#include <subdev/bios/pll.h>
 
 #define MASK(field) ( \
         (0xffffffff >> (31 - ((1 ? field) - (0 ? field)))) << (0 ? field))
@@ -38,12 +40,10 @@ void NVWriteVgaGr(struct drm_device *, int head, uint8_t index, uint8_t value);
 uint8_t NVReadVgaGr(struct drm_device *, int head, uint8_t index);
 void NVSetOwner(struct drm_device *, int owner);
 void NVBlankScreen(struct drm_device *, int head, bool blank);
-void nouveau_hw_setpll(struct drm_device *, uint32_t reg1,
-                       struct nouveau_pll_vals *pv);
-int nouveau_hw_get_pllvals(struct drm_device *, enum pll_types plltype,
+int nouveau_hw_get_pllvals(struct drm_device *, enum nvbios_pll_type plltype,
                            struct nouveau_pll_vals *pllvals);
 int nouveau_hw_pllvals_to_clk(struct nouveau_pll_vals *pllvals);
-int nouveau_hw_get_clock(struct drm_device *, enum pll_types plltype);
+int nouveau_hw_get_clock(struct drm_device *, enum nvbios_pll_type plltype);
 void nouveau_hw_save_vga_fonts(struct drm_device *, bool save);
 void nouveau_hw_save_state(struct drm_device *, int head,
                            struct nv04_mode_state *state);
@@ -55,115 +55,51 @@ void nouveau_hw_load_state_palette(struct drm_device *, int head,
 /* nouveau_calc.c */
 extern void nouveau_calc_arb(struct drm_device *, int vclk, int bpp,
                              int *burst, int *lwm);
-extern int nouveau_calc_pll_mnp(struct drm_device *, struct pll_lims *pll_lim,
-                                int clk, struct nouveau_pll_vals *pv);
-
-static inline uint32_t
-nvReadMC(struct drm_device *dev, uint32_t reg)
-{
-        uint32_t val = nv_rd32(dev, reg);
-        NV_REG_DEBUG(MC, dev, "reg %08x val %08x\n", reg, val);
-        return val;
-}
-
-static inline void
-nvWriteMC(struct drm_device *dev, uint32_t reg, uint32_t val)
-{
-        NV_REG_DEBUG(MC, dev, "reg %08x val %08x\n", reg, val);
-        nv_wr32(dev, reg, val);
-}
-
-static inline uint32_t
-nvReadVIDEO(struct drm_device *dev, uint32_t reg)
-{
-        uint32_t val = nv_rd32(dev, reg);
-        NV_REG_DEBUG(VIDEO, dev, "reg %08x val %08x\n", reg, val);
-        return val;
-}
-
-static inline void
-nvWriteVIDEO(struct drm_device *dev, uint32_t reg, uint32_t val)
-{
-        NV_REG_DEBUG(VIDEO, dev, "reg %08x val %08x\n", reg, val);
-        nv_wr32(dev, reg, val);
-}
-
-static inline uint32_t
-nvReadFB(struct drm_device *dev, uint32_t reg)
-{
-        uint32_t val = nv_rd32(dev, reg);
-        NV_REG_DEBUG(FB, dev, "reg %08x val %08x\n", reg, val);
-        return val;
-}
-
-static inline void
-nvWriteFB(struct drm_device *dev, uint32_t reg, uint32_t val)
-{
-        NV_REG_DEBUG(FB, dev, "reg %08x val %08x\n", reg, val);
-        nv_wr32(dev, reg, val);
-}
-
-static inline uint32_t
-nvReadEXTDEV(struct drm_device *dev, uint32_t reg)
-{
-        uint32_t val = nv_rd32(dev, reg);
-        NV_REG_DEBUG(EXTDEV, dev, "reg %08x val %08x\n", reg, val);
-        return val;
-}
-
-static inline void
-nvWriteEXTDEV(struct drm_device *dev, uint32_t reg, uint32_t val)
-{
-        NV_REG_DEBUG(EXTDEV, dev, "reg %08x val %08x\n", reg, val);
-        nv_wr32(dev, reg, val);
-}
 
 static inline uint32_t NVReadCRTC(struct drm_device *dev,
                                         int head, uint32_t reg)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         uint32_t val;
         if (head)
                 reg += NV_PCRTC0_SIZE;
-        val = nv_rd32(dev, reg);
-        NV_REG_DEBUG(CRTC, dev, "head %d reg %08x val %08x\n", head, reg, val);
+        val = nv_rd32(device, reg);
         return val;
 }
 
 static inline void NVWriteCRTC(struct drm_device *dev,
                                         int head, uint32_t reg, uint32_t val)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         if (head)
                 reg += NV_PCRTC0_SIZE;
-        NV_REG_DEBUG(CRTC, dev, "head %d reg %08x val %08x\n", head, reg, val);
-        nv_wr32(dev, reg, val);
+        nv_wr32(device, reg, val);
 }
 
 static inline uint32_t NVReadRAMDAC(struct drm_device *dev,
                                         int head, uint32_t reg)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         uint32_t val;
         if (head)
                 reg += NV_PRAMDAC0_SIZE;
-        val = nv_rd32(dev, reg);
-        NV_REG_DEBUG(RAMDAC, dev, "head %d reg %08x val %08x\n",
-                                                        head, reg, val);
+        val = nv_rd32(device, reg);
         return val;
 }
 
 static inline void NVWriteRAMDAC(struct drm_device *dev,
                                         int head, uint32_t reg, uint32_t val)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         if (head)
                 reg += NV_PRAMDAC0_SIZE;
-        NV_REG_DEBUG(RAMDAC, dev, "head %d reg %08x val %08x\n",
-                                                        head, reg, val);
-        nv_wr32(dev, reg, val);
+        nv_wr32(device, reg, val);
 }
 
 static inline uint8_t nv_read_tmds(struct drm_device *dev,
                                         int or, int dl, uint8_t address)
 {
-        int ramdac = (or & OUTPUT_C) >> 2;
+        int ramdac = (or & DCB_OUTPUT_C) >> 2;
 
         NVWriteRAMDAC(dev, ramdac, NV_PRAMDAC_FP_TMDS_CONTROL + dl * 8,
         NV_PRAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE | address);
@@ -174,7 +110,7 @@ static inline void nv_write_tmds(struct drm_device *dev,
                                         int or, int dl, uint8_t address,
                                         uint8_t data)
 {
-        int ramdac = (or & OUTPUT_C) >> 2;
+        int ramdac = (or & DCB_OUTPUT_C) >> 2;
 
         NVWriteRAMDAC(dev, ramdac, NV_PRAMDAC_FP_TMDS_DATA + dl * 8, data);
         NVWriteRAMDAC(dev, ramdac, NV_PRAMDAC_FP_TMDS_CONTROL + dl * 8, address);
@@ -183,20 +119,18 @@ static inline void nv_write_tmds(struct drm_device *dev,
 static inline void NVWriteVgaCrtc(struct drm_device *dev,
                                         int head, uint8_t index, uint8_t value)
 {
-        NV_REG_DEBUG(VGACRTC, dev, "head %d index 0x%02x data 0x%02x\n",
-                                                        head, index, value);
-        nv_wr08(dev, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
-        nv_wr08(dev, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE, value);
+        struct nouveau_device *device = nouveau_dev(dev);
+        nv_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
+        nv_wr08(device, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE, value);
 }
 
 static inline uint8_t NVReadVgaCrtc(struct drm_device *dev,
                                         int head, uint8_t index)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         uint8_t val;
-        nv_wr08(dev, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
-        val = nv_rd08(dev, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE);
-        NV_REG_DEBUG(VGACRTC, dev, "head %d index 0x%02x data 0x%02x\n",
-                                                        head, index, val);
+        nv_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
+        val = nv_rd08(device, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE);
         return val;
 }
 
@@ -230,75 +164,74 @@ static inline uint8_t NVReadVgaCrtc5758(struct drm_device *dev, int head, uint8_
 static inline uint8_t NVReadPRMVIO(struct drm_device *dev,
                                         int head, uint32_t reg)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t val;
 
         /* Only NV4x have two pvio ranges; other twoHeads cards MUST call
          * NVSetOwner for the relevant head to be programmed */
-        if (head && dev_priv->card_type == NV_40)
+        if (head && nv_device(drm->device)->card_type == NV_40)
                 reg += NV_PRMVIO_SIZE;
 
-        val = nv_rd08(dev, reg);
-        NV_REG_DEBUG(RMVIO, dev, "head %d reg %08x val %02x\n", head, reg, val);
+        val = nv_rd08(device, reg);
         return val;
 }
 
 static inline void NVWritePRMVIO(struct drm_device *dev,
                                         int head, uint32_t reg, uint8_t value)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         /* Only NV4x have two pvio ranges; other twoHeads cards MUST call
          * NVSetOwner for the relevant head to be programmed */
-        if (head && dev_priv->card_type == NV_40)
+        if (head && nv_device(drm->device)->card_type == NV_40)
                 reg += NV_PRMVIO_SIZE;
 
-        NV_REG_DEBUG(RMVIO, dev, "head %d reg %08x val %02x\n",
-                                                head, reg, value);
-        nv_wr08(dev, reg, value);
+        nv_wr08(device, reg, value);
 }
 
 static inline void NVSetEnablePalette(struct drm_device *dev, int head, bool enable)
 {
-        nv_rd08(dev, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
-        nv_wr08(dev, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, enable ? 0 : 0x20);
+        struct nouveau_device *device = nouveau_dev(dev);
+        nv_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
+        nv_wr08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, enable ? 0 : 0x20);
 }
 
 static inline bool NVGetEnablePalette(struct drm_device *dev, int head)
 {
-        nv_rd08(dev, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
-        return !(nv_rd08(dev, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE) & 0x20);
+        struct nouveau_device *device = nouveau_dev(dev);
+        nv_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
+        return !(nv_rd08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE) & 0x20);
 }
 
 static inline void NVWriteVgaAttr(struct drm_device *dev,
                                         int head, uint8_t index, uint8_t value)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         if (NVGetEnablePalette(dev, head))
                 index &= ~0x20;
         else
                 index |= 0x20;
 
-        nv_rd08(dev, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
-        NV_REG_DEBUG(VGAATTR, dev, "head %d index 0x%02x data 0x%02x\n",
-                                                        head, index, value);
-        nv_wr08(dev, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, index);
-        nv_wr08(dev, NV_PRMCIO_AR__WRITE + head * NV_PRMCIO_SIZE, value);
+        nv_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
+        nv_wr08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, index);
+        nv_wr08(device, NV_PRMCIO_AR__WRITE + head * NV_PRMCIO_SIZE, value);
 }
 
 static inline uint8_t NVReadVgaAttr(struct drm_device *dev,
                                         int head, uint8_t index)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         uint8_t val;
         if (NVGetEnablePalette(dev, head))
                 index &= ~0x20;
         else
                 index |= 0x20;
 
-        nv_rd08(dev, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
-        nv_wr08(dev, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, index);
-        val = nv_rd08(dev, NV_PRMCIO_AR__READ + head * NV_PRMCIO_SIZE);
-        NV_REG_DEBUG(VGAATTR, dev, "head %d index 0x%02x data 0x%02x\n",
-                                                        head, index, val);
+        nv_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
+        nv_wr08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, index);
+        val = nv_rd08(device, NV_PRMCIO_AR__READ + head * NV_PRMCIO_SIZE);
         return val;
 }
 
@@ -325,10 +258,11 @@ static inline void NVVgaProtect(struct drm_device *dev, int head, bool protect)
 static inline bool
 nv_heads_tied(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        if (dev_priv->chipset == 0x11)
-                return !!(nvReadMC(dev, NV_PBUS_DEBUG_1) & (1 << 28));
+        if (nv_device(drm->device)->chipset == 0x11)
+                return !!(nv_rd32(device, NV_PBUS_DEBUG_1) & (1 << 28));
 
         return NVReadVgaCrtc(dev, 0, NV_CIO_CRE_44) & 0x4;
 }
@@ -377,13 +311,13 @@ nv_lock_vga_crtc_shadow(struct drm_device *dev, int head, int lock)
 static inline bool
 NVLockVgaCrtcs(struct drm_device *dev, bool lock)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         bool waslocked = !NVReadVgaCrtc(dev, 0, NV_CIO_SR_LOCK_INDEX);
 
         NVWriteVgaCrtc(dev, 0, NV_CIO_SR_LOCK_INDEX,
                        lock ? NV_CIO_SR_LOCK_VALUE : NV_CIO_SR_UNLOCK_RW_VALUE);
         /* NV11 has independently lockable extended crtcs, except when tied */
-        if (dev_priv->chipset == 0x11 && !nv_heads_tied(dev))
+        if (nv_device(drm->device)->chipset == 0x11 && !nv_heads_tied(dev))
                 NVWriteVgaCrtc(dev, 1, NV_CIO_SR_LOCK_INDEX,
                                lock ? NV_CIO_SR_LOCK_VALUE :
                                       NV_CIO_SR_UNLOCK_RW_VALUE);
@@ -398,9 +332,9 @@ NVLockVgaCrtcs(struct drm_device *dev, bool lock)
 
 static inline int nv_cursor_width(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        return dev_priv->card_type >= NV_10 ? NV10_CURSOR_SIZE : NV04_CURSOR_SIZE;
+        return nv_device(drm->device)->card_type >= NV_10 ? NV10_CURSOR_SIZE : NV04_CURSOR_SIZE;
 }
 
 static inline void
@@ -418,11 +352,11 @@ nv_fix_nv40_hw_cursor(struct drm_device *dev, int head)
 static inline void
 nv_set_crtc_base(struct drm_device *dev, int head, uint32_t offset)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         NVWriteCRTC(dev, head, NV_PCRTC_START, offset);
 
-        if (dev_priv->card_type == NV_04) {
+        if (nv_device(drm->device)->card_type == NV_04) {
                 /*
                  * Hilarious, the 24th bit doesn't want to stick to
                  * PCRTC_START...
@@ -437,9 +371,9 @@ nv_set_crtc_base(struct drm_device *dev, int head, uint32_t offset)
 static inline void
 nv_show_cursor(struct drm_device *dev, int head, bool show)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t *curctl1 =
-                &dev_priv->mode_reg.crtc_reg[head].CRTC[NV_CIO_CRE_HCUR_ADDR1_INDEX];
+                &nv04_display(dev)->mode_reg.crtc_reg[head].CRTC[NV_CIO_CRE_HCUR_ADDR1_INDEX];
 
         if (show)
                 *curctl1 |= MASK(NV_CIO_CRE_HCUR_ADDR1_ENABLE);
@@ -447,14 +381,14 @@ nv_show_cursor(struct drm_device *dev, int head, bool show)
                 *curctl1 &= ~MASK(NV_CIO_CRE_HCUR_ADDR1_ENABLE);
         NVWriteVgaCrtc(dev, head, NV_CIO_CRE_HCUR_ADDR1_INDEX, *curctl1);
 
-        if (dev_priv->card_type == NV_40)
+        if (nv_device(drm->device)->card_type == NV_40)
                 nv_fix_nv40_hw_cursor(dev, head);
 }
 
 static inline uint32_t
 nv_pitch_align(struct drm_device *dev, uint32_t width, int bpp)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int mask;
 
         if (bpp == 15)
@@ -463,7 +397,7 @@ nv_pitch_align(struct drm_device *dev, uint32_t width, int bpp)
                 bpp = 8;
 
         /* Alignment requirements taken from the Haiku driver */
-        if (dev_priv->card_type == NV_04)
+        if (nv_device(drm->device)->card_type == NV_04)
                 mask = 128 / bpp - 1;
         else
                 mask = 512 / bpp - 1;
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.c b/drivers/gpu/drm/nouveau/nouveau_i2c.c
deleted file mode 100644
index 240cf962c999..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.c
+++ /dev/null
@@ -1,394 +0,0 @@
-/*
- * Copyright 2009 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 <linux/module.h>
-
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_i2c.h"
-#include "nouveau_hw.h"
-
-static void
-i2c_drive_scl(void *data, int state)
-{
-        struct nouveau_i2c_chan *port = data;
-        if (port->type == 0) {
-                u8 val = NVReadVgaCrtc(port->dev, 0, port->drive);
-                if (state) val |= 0x20;
-                else       val &= 0xdf;
-                NVWriteVgaCrtc(port->dev, 0, port->drive, val | 0x01);
-        } else
-        if (port->type == 4) {
-                nv_mask(port->dev, port->drive, 0x2f, state ? 0x21 : 0x01);
-        } else
-        if (port->type == 5) {
-                if (state) port->state |= 0x01;
-                else       port->state &= 0xfe;
-                nv_wr32(port->dev, port->drive, 4 | port->state);
-        }
-}
-
-static void
-i2c_drive_sda(void *data, int state)
-{
-        struct nouveau_i2c_chan *port = data;
-        if (port->type == 0) {
-                u8 val = NVReadVgaCrtc(port->dev, 0, port->drive);
-                if (state) val |= 0x10;
-                else       val &= 0xef;
-                NVWriteVgaCrtc(port->dev, 0, port->drive, val | 0x01);
-        } else
-        if (port->type == 4) {
-                nv_mask(port->dev, port->drive, 0x1f, state ? 0x11 : 0x01);
-        } else
-        if (port->type == 5) {
-                if (state) port->state |= 0x02;
-                else       port->state &= 0xfd;
-                nv_wr32(port->dev, port->drive, 4 | port->state);
-        }
-}
-
-static int
-i2c_sense_scl(void *data)
-{
-        struct nouveau_i2c_chan *port = data;
-        struct drm_nouveau_private *dev_priv = port->dev->dev_private;
-        if (port->type == 0) {
-                return !!(NVReadVgaCrtc(port->dev, 0, port->sense) & 0x04);
-        } else
-        if (port->type == 4) {
-                return !!(nv_rd32(port->dev, port->sense) & 0x00040000);
-        } else
-        if (port->type == 5) {
-                if (dev_priv->card_type < NV_D0)
-                        return !!(nv_rd32(port->dev, port->sense) & 0x01);
-                else
-                        return !!(nv_rd32(port->dev, port->sense) & 0x10);
-        }
-        return 0;
-}
-
-static int
-i2c_sense_sda(void *data)
-{
-        struct nouveau_i2c_chan *port = data;
-        struct drm_nouveau_private *dev_priv = port->dev->dev_private;
-        if (port->type == 0) {
-                return !!(NVReadVgaCrtc(port->dev, 0, port->sense) & 0x08);
-        } else
-        if (port->type == 4) {
-                return !!(nv_rd32(port->dev, port->sense) & 0x00080000);
-        } else
-        if (port->type == 5) {
-                if (dev_priv->card_type < NV_D0)
-                        return !!(nv_rd32(port->dev, port->sense) & 0x02);
-                else
-                        return !!(nv_rd32(port->dev, port->sense) & 0x20);
-        }
-        return 0;
-}
-
-static const uint32_t nv50_i2c_port[] = {
-        0x00e138, 0x00e150, 0x00e168, 0x00e180,
-        0x00e254, 0x00e274, 0x00e764, 0x00e780,
-        0x00e79c, 0x00e7b8
-};
-
-static u8 *
-i2c_table(struct drm_device *dev, u8 *version)
-{
-        u8 *dcb = dcb_table(dev), *i2c = NULL;
-        if (dcb) {
-                if (dcb[0] >= 0x15)
-                        i2c = ROMPTR(dev, dcb[2]);
-                if (dcb[0] >= 0x30)
-                        i2c = ROMPTR(dev, dcb[4]);
-        }
-
-        /* early revisions had no version number, use dcb version */
-        if (i2c) {
-                *version = dcb[0];
-                if (*version >= 0x30)
-                        *version = i2c[0];
-        }
-
-        return i2c;
-}
-
-int
-nouveau_i2c_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct nouveau_i2c_chan *port;
-        u8 version = 0x00, entries, recordlen;
-        u8 *i2c, *entry, legacy[2][4] = {};
-        int ret, i;
-
-        INIT_LIST_HEAD(&dev_priv->i2c_ports);
-
-        i2c = i2c_table(dev, &version);
-        if (!i2c) {
-                u8 *bmp = &bios->data[bios->offset];
-                if (bios->type != NVBIOS_BMP)
-                        return -ENODEV;
-
-                legacy[0][0] = NV_CIO_CRE_DDC_WR__INDEX;
-                legacy[0][1] = NV_CIO_CRE_DDC_STATUS__INDEX;
-                legacy[1][0] = NV_CIO_CRE_DDC0_WR__INDEX;
-                legacy[1][1] = NV_CIO_CRE_DDC0_STATUS__INDEX;
-
-                /* BMP (from v4.0) has i2c info in the structure, it's in a
-                 * fixed location on earlier VBIOS
-                 */
-                if (bmp[5] < 4)
-                        i2c = &bios->data[0x48];
-                else
-                        i2c = &bmp[0x36];
-
-                if (i2c[4]) legacy[0][0] = i2c[4];
-                if (i2c[5]) legacy[0][1] = i2c[5];
-                if (i2c[6]) legacy[1][0] = i2c[6];
-                if (i2c[7]) legacy[1][1] = i2c[7];
-        }
-
-        if (version >= 0x30) {
-                entry     = i2c[1] + i2c;
-                entries   = i2c[2];
-                recordlen = i2c[3];
-        } else
-        if (version) {
-                entry     = i2c;
-                entries   = 16;
-                recordlen = 4;
-        } else {
-                entry     = legacy[0];
-                entries   = 2;
-                recordlen = 4;
-        }
-
-        for (i = 0; i < entries; i++, entry += recordlen) {
-                port = kzalloc(sizeof(*port), GFP_KERNEL);
-                if (port == NULL) {
-                        nouveau_i2c_fini(dev);
-                        return -ENOMEM;
-                }
-
-                port->type = entry[3];
-                if (version < 0x30) {
-                        port->type &= 0x07;
-                        if (port->type == 0x07)
-                                port->type = 0xff;
-                }
-
-                if (port->type == 0xff) {
-                        kfree(port);
-                        continue;
-                }
-
-                switch (port->type) {
-                case 0: /* NV04:NV50 */
-                        port->drive = entry[0];
-                        port->sense = entry[1];
-                        break;
-                case 4: /* NV4E */
-                        port->drive = 0x600800 + entry[1];
-                        port->sense = port->drive;
-                        break;
-                case 5: /* NV50- */
-                        port->drive = entry[0] & 0x0f;
-                        if (dev_priv->card_type < NV_D0) {
-                                if (port->drive >= ARRAY_SIZE(nv50_i2c_port))
-                                        break;
-                                port->drive = nv50_i2c_port[port->drive];
-                                port->sense = port->drive;
-                        } else {
-                                port->drive = 0x00d014 + (port->drive * 0x20);
-                                port->sense = port->drive;
-                        }
-                        break;
-                case 6: /* NV50- DP AUX */
-                        port->drive = entry[0] & 0x0f;
-                        port->sense = port->drive;
-                        port->adapter.algo = &nouveau_dp_i2c_algo;
-                        break;
-                default:
-                        break;
-                }
-
-                if (!port->adapter.algo && !port->drive) {
-                        NV_ERROR(dev, "I2C%d: type %d index %x/%x unknown\n",
-                                 i, port->type, port->drive, port->sense);
-                        kfree(port);
-                        continue;
-                }
-
-                snprintf(port->adapter.name, sizeof(port->adapter.name),
-                         "nouveau-%s-%d", pci_name(dev->pdev), i);
-                port->adapter.owner = THIS_MODULE;
-                port->adapter.dev.parent = &dev->pdev->dev;
-                port->dev = dev;
-                port->index = i;
-                port->dcb = ROM32(entry[0]);
-                i2c_set_adapdata(&port->adapter, i2c);
-
-                if (port->adapter.algo != &nouveau_dp_i2c_algo) {
-                        port->adapter.algo_data = &port->bit;
-                        port->bit.udelay = 10;
-                        port->bit.timeout = usecs_to_jiffies(2200);
-                        port->bit.data = port;
-                        port->bit.setsda = i2c_drive_sda;
-                        port->bit.setscl = i2c_drive_scl;
-                        port->bit.getsda = i2c_sense_sda;
-                        port->bit.getscl = i2c_sense_scl;
-
-                        i2c_drive_scl(port, 0);
-                        i2c_drive_sda(port, 1);
-                        i2c_drive_scl(port, 1);
-
-                        ret = i2c_bit_add_bus(&port->adapter);
-                } else {
-                        port->adapter.algo = &nouveau_dp_i2c_algo;
-                        ret = i2c_add_adapter(&port->adapter);
-                }
-
-                if (ret) {
-                        NV_ERROR(dev, "I2C%d: failed register: %d\n", i, ret);
-                        kfree(port);
-                        continue;
-                }
-
-                list_add_tail(&port->head, &dev_priv->i2c_ports);
-        }
-
-        return 0;
-}
-
-void
-nouveau_i2c_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_i2c_chan *port, *tmp;
-
-        list_for_each_entry_safe(port, tmp, &dev_priv->i2c_ports, head) {
-                i2c_del_adapter(&port->adapter);
-                kfree(port);
-        }
-}
-
-struct nouveau_i2c_chan *
-nouveau_i2c_find(struct drm_device *dev, u8 index)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_i2c_chan *port;
-
-        if (index == NV_I2C_DEFAULT(0) ||
-            index == NV_I2C_DEFAULT(1)) {
-                u8 version, *i2c = i2c_table(dev, &version);
-                if (i2c && version >= 0x30) {
-                        if (index == NV_I2C_DEFAULT(0))
-                                index = (i2c[4] & 0x0f);
-                        else
-                                index = (i2c[4] & 0xf0) >> 4;
-                } else {
-                        index = 2;
-                }
-        }
-
-        list_for_each_entry(port, &dev_priv->i2c_ports, head) {
-                if (port->index == index)
-                        break;
-        }
-
-        if (&port->head == &dev_priv->i2c_ports)
-                return NULL;
-
-        if (dev_priv->card_type >= NV_50 && (port->dcb & 0x00000100)) {
-                u32 reg = 0x00e500, val;
-                if (port->type == 6) {
-                        reg += port->drive * 0x50;
-                        val  = 0x2002;
-                } else {
-                        reg += ((port->dcb & 0x1e00) >> 9) * 0x50;
-                        val  = 0xe001;
-                }
-
-                /* nfi, but neither auxch or i2c work if it's 1 */
-                nv_mask(dev, reg + 0x0c, 0x00000001, 0x00000000);
-                /* nfi, but switches auxch vs normal i2c */
-                nv_mask(dev, reg + 0x00, 0x0000f003, val);
-        }
-
-        return port;
-}
-
-bool
-nouveau_probe_i2c_addr(struct nouveau_i2c_chan *i2c, int addr)
-{
-        uint8_t buf[] = { 0 };
-        struct i2c_msg msgs[] = {
-                {
-                        .addr = addr,
-                        .flags = 0,
-                        .len = 1,
-                        .buf = buf,
-                },
-                {
-                        .addr = addr,
-                        .flags = I2C_M_RD,
-                        .len = 1,
-                        .buf = buf,
-                }
-        };
-
-        return i2c_transfer(&i2c->adapter, msgs, 2) == 2;
-}
-
-int
-nouveau_i2c_identify(struct drm_device *dev, const char *what,
-                     struct i2c_board_info *info,
-                     bool (*match)(struct nouveau_i2c_chan *,
-                                   struct i2c_board_info *),
-                     int index)
-{
-        struct nouveau_i2c_chan *i2c = nouveau_i2c_find(dev, index);
-        int i;
-
-        if (!i2c) {
-                NV_DEBUG(dev, "No bus when probing %s on %d\n", what, index);
-                return -ENODEV;
-        }
-
-        NV_DEBUG(dev, "Probing %ss on I2C bus: %d\n", what, i2c->index);
-        for (i = 0; info[i].addr; i++) {
-                if (nouveau_probe_i2c_addr(i2c, info[i].addr) &&
-                    (!match || match(i2c, &info[i]))) {
-                        NV_INFO(dev, "Detected %s: %s\n", what, info[i].type);
-                        return i;
-                }
-        }
-
-        NV_DEBUG(dev, "No devices found.\n");
-        return -ENODEV;
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_ioc32.c b/drivers/gpu/drm/nouveau/nouveau_ioc32.c
index 475ba810bba3..6ac560ee478c 100644
--- a/drivers/gpu/drm/nouveau/nouveau_ioc32.c
+++ b/drivers/gpu/drm/nouveau/nouveau_ioc32.c
@@ -36,7 +36,7 @@
 #include "drmP.h"
 #include "drm.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_ioctl.h"
 
 /**
  * Called whenever a 32-bit process running under a 64-bit kernel
diff --git a/drivers/gpu/drm/nouveau/nouveau_ioctl.h b/drivers/gpu/drm/nouveau/nouveau_ioctl.h
new file mode 100644
index 000000000000..ef2b2906d9e6
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_ioctl.h
@@ -0,0 +1,6 @@
+#ifndef __NOUVEAU_IOCTL_H__
+#define __NOUVEAU_IOCTL_H__
+
+long nouveau_compat_ioctl(struct file *, unsigned int cmd, unsigned long arg);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_irq.c b/drivers/gpu/drm/nouveau/nouveau_irq.c
index b2c2937531a8..9ca8afdb5549 100644
--- a/drivers/gpu/drm/nouveau/nouveau_irq.c
+++ b/drivers/gpu/drm/nouveau/nouveau_irq.c
@@ -1,147 +1,86 @@
 /*
- * Copyright (C) 2006 Ben Skeggs.
+ * Copyright 2012 Red Hat Inc.
  *
- * All Rights Reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
  *
- * 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 above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 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
  */
 
-/*
- * Authors:
- *   Ben Skeggs <darktama@iinet.net.au>
- */
+#include <subdev/mc.h>
 
-#include "drmP.h"
-#include "drm.h"
 #include "nouveau_drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_reg.h"
-#include "nouveau_ramht.h"
-#include "nouveau_util.h"
+#include "nouveau_irq.h"
+#include "nv50_display.h"
 
 void
 nouveau_irq_preinstall(struct drm_device *dev)
 {
-        /* Master disable */
-        nv_wr32(dev, NV03_PMC_INTR_EN_0, 0);
+        nv_wr32(nouveau_dev(dev), 0x000140, 0x00000000);
 }
 
 int
 nouveau_irq_postinstall(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        /* Master enable */
-        nv_wr32(dev, NV03_PMC_INTR_EN_0, NV_PMC_INTR_EN_0_MASTER_ENABLE);
-        if (dev_priv->msi_enabled)
-                nv_wr08(dev, 0x00088068, 0xff);
-
+        nv_wr32(nouveau_dev(dev), 0x000140, 0x00000001);
         return 0;
 }
 
 void
 nouveau_irq_uninstall(struct drm_device *dev)
 {
-        /* Master disable */
-        nv_wr32(dev, NV03_PMC_INTR_EN_0, 0);
+        nv_wr32(nouveau_dev(dev), 0x000140, 0x00000000);
 }
 
 irqreturn_t
 nouveau_irq_handler(DRM_IRQ_ARGS)
 {
-        struct drm_device *dev = (struct drm_device *)arg;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
+        struct drm_device *dev = arg;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_mc *pmc = nouveau_mc(device);
         u32 stat;
-        int i;
 
-        stat = nv_rd32(dev, NV03_PMC_INTR_0);
+        stat = nv_rd32(device, 0x000100);
         if (stat == 0 || stat == ~0)
                 return IRQ_NONE;
 
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        for (i = 0; i < 32 && stat; i++) {
-                if (!(stat & (1 << i)) || !dev_priv->irq_handler[i])
-                        continue;
+        nv_subdev(pmc)->intr(nv_subdev(pmc));
 
-                dev_priv->irq_handler[i](dev);
-                stat &= ~(1 << i);
+        if (device->card_type >= NV_D0) {
+                if (nv_rd32(device, 0x000100) & 0x04000000)
+                        nvd0_display_intr(dev);
+        } else
+        if (device->card_type >= NV_50) {
+                if (nv_rd32(device, 0x000100) & 0x04000000)
+                        nv50_display_intr(dev);
         }
 
-        if (dev_priv->msi_enabled)
-                nv_wr08(dev, 0x00088068, 0xff);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        if (stat && nouveau_ratelimit())
-                NV_ERROR(dev, "PMC - unhandled INTR 0x%08x\n", stat);
         return IRQ_HANDLED;
 }
 
 int
 nouveau_irq_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int ret;
-
-        if (nouveau_msi != 0 && dev_priv->card_type >= NV_50) {
-                ret = pci_enable_msi(dev->pdev);
-                if (ret == 0) {
-                        NV_INFO(dev, "enabled MSI\n");
-                        dev_priv->msi_enabled = true;
-                }
-        }
-
         return drm_irq_install(dev);
 }
 
 void
 nouveau_irq_fini(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
         drm_irq_uninstall(dev);
-        if (dev_priv->msi_enabled)
-                pci_disable_msi(dev->pdev);
-}
-
-void
-nouveau_irq_register(struct drm_device *dev, int status_bit,
-                     void (*handler)(struct drm_device *))
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        dev_priv->irq_handler[status_bit] = handler;
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-}
-
-void
-nouveau_irq_unregister(struct drm_device *dev, int status_bit)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        dev_priv->irq_handler[status_bit] = NULL;
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_irq.h b/drivers/gpu/drm/nouveau/nouveau_irq.h
new file mode 100644
index 000000000000..06714ad857bb
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_irq.h
@@ -0,0 +1,11 @@
+#ifndef __NOUVEAU_IRQ_H__
+#define __NOUVEAU_IRQ_H__
+
+extern int         nouveau_irq_init(struct drm_device *);
+extern void        nouveau_irq_fini(struct drm_device *);
+extern irqreturn_t nouveau_irq_handler(DRM_IRQ_ARGS);
+extern void        nouveau_irq_preinstall(struct drm_device *);
+extern int         nouveau_irq_postinstall(struct drm_device *);
+extern void        nouveau_irq_uninstall(struct drm_device *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_mem.c b/drivers/gpu/drm/nouveau/nouveau_mem.c
index 5b498ea32e14..7e0ff10a2759 100644
--- a/drivers/gpu/drm/nouveau/nouveau_mem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_mem.c
@@ -30,448 +30,10 @@
  *    Roy Spliet <r.spliet@student.tudelft.nl>
  */
 
-
-#include "drmP.h"
-#include "drm.h"
-#include "drm_sarea.h"
-
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_pm.h"
-#include "nouveau_mm.h"
-#include "nouveau_vm.h"
-#include "nouveau_fifo.h"
-#include "nouveau_fence.h"
-
-/*
- * NV10-NV40 tiling helpers
- */
-
-static void
-nv10_mem_update_tile_region(struct drm_device *dev,
-                            struct nouveau_tile_reg *tile, uint32_t addr,
-                            uint32_t size, uint32_t pitch, uint32_t flags)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        int i = tile - dev_priv->tile.reg, j;
-        unsigned long save;
-
-        nouveau_fence_unref(&tile->fence);
-
-        if (tile->pitch)
-                pfb->free_tile_region(dev, i);
-
-        if (pitch)
-                pfb->init_tile_region(dev, i, addr, size, pitch, flags);
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, save);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 0);
-        nv04_fifo_cache_pull(dev, false);
-
-        nouveau_wait_for_idle(dev);
-
-        pfb->set_tile_region(dev, i);
-        for (j = 0; j < NVOBJ_ENGINE_NR; j++) {
-                if (dev_priv->eng[j] && dev_priv->eng[j]->set_tile_region)
-                        dev_priv->eng[j]->set_tile_region(dev, i);
-        }
-
-        nv04_fifo_cache_pull(dev, true);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 1);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, save);
-}
-
-static struct nouveau_tile_reg *
-nv10_mem_get_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        spin_lock(&dev_priv->tile.lock);
-
-        if (!tile->used &&
-            (!tile->fence || nouveau_fence_done(tile->fence)))
-                tile->used = true;
-        else
-                tile = NULL;
-
-        spin_unlock(&dev_priv->tile.lock);
-        return tile;
-}
-
-void
-nv10_mem_put_tile_region(struct drm_device *dev, struct nouveau_tile_reg *tile,
-                         struct nouveau_fence *fence)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (tile) {
-                spin_lock(&dev_priv->tile.lock);
-                if (fence) {
-                        /* Mark it as pending. */
-                        tile->fence = fence;
-                        nouveau_fence_ref(fence);
-                }
-
-                tile->used = false;
-                spin_unlock(&dev_priv->tile.lock);
-        }
-}
-
-struct nouveau_tile_reg *
-nv10_mem_set_tiling(struct drm_device *dev, uint32_t addr, uint32_t size,
-                    uint32_t pitch, uint32_t flags)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        struct nouveau_tile_reg *tile, *found = NULL;
-        int i;
-
-        for (i = 0; i < pfb->num_tiles; i++) {
-                tile = nv10_mem_get_tile_region(dev, i);
-
-                if (pitch && !found) {
-                        found = tile;
-                        continue;
-
-                } else if (tile && tile->pitch) {
-                        /* Kill an unused tile region. */
-                        nv10_mem_update_tile_region(dev, tile, 0, 0, 0, 0);
-                }
-
-                nv10_mem_put_tile_region(dev, tile, NULL);
-        }
-
-        if (found)
-                nv10_mem_update_tile_region(dev, found, addr, size,
-                                            pitch, flags);
-        return found;
-}
-
-/*
- * Cleanup everything
- */
-void
-nouveau_mem_vram_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        ttm_bo_device_release(&dev_priv->ttm.bdev);
-
-        nouveau_ttm_global_release(dev_priv);
-
-        if (dev_priv->fb_mtrr >= 0) {
-                drm_mtrr_del(dev_priv->fb_mtrr,
-                             pci_resource_start(dev->pdev, 1),
-                             pci_resource_len(dev->pdev, 1), DRM_MTRR_WC);
-                dev_priv->fb_mtrr = -1;
-        }
-}
-
-void
-nouveau_mem_gart_fini(struct drm_device *dev)
-{
-        nouveau_sgdma_takedown(dev);
-
-        if (drm_core_has_AGP(dev) && dev->agp) {
-                struct drm_agp_mem *entry, *tempe;
-
-                /* Remove AGP resources, but leave dev->agp
-                   intact until drv_cleanup is called. */
-                list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) {
-                        if (entry->bound)
-                                drm_unbind_agp(entry->memory);
-                        drm_free_agp(entry->memory, entry->pages);
-                        kfree(entry);
-                }
-                INIT_LIST_HEAD(&dev->agp->memory);
 
-                if (dev->agp->acquired)
-                        drm_agp_release(dev);
-
-                dev->agp->acquired = 0;
-                dev->agp->enabled = 0;
-        }
-}
-
-bool
-nouveau_mem_flags_valid(struct drm_device *dev, u32 tile_flags)
-{
-        if (!(tile_flags & NOUVEAU_GEM_TILE_LAYOUT_MASK))
-                return true;
-
-        return false;
-}
-
-#if __OS_HAS_AGP
-static unsigned long
-get_agp_mode(struct drm_device *dev, unsigned long mode)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        /*
-         * FW seems to be broken on nv18, it makes the card lock up
-         * randomly.
-         */
-        if (dev_priv->chipset == 0x18)
-                mode &= ~PCI_AGP_COMMAND_FW;
-
-        /*
-         * AGP mode set in the command line.
-         */
-        if (nouveau_agpmode > 0) {
-                bool agpv3 = mode & 0x8;
-                int rate = agpv3 ? nouveau_agpmode / 4 : nouveau_agpmode;
-
-                mode = (mode & ~0x7) | (rate & 0x7);
-        }
-
-        return mode;
-}
-#endif
-
-int
-nouveau_mem_reset_agp(struct drm_device *dev)
-{
-#if __OS_HAS_AGP
-        uint32_t saved_pci_nv_1, pmc_enable;
-        int ret;
-
-        /* 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 ((nv_rd32(dev, NV04_PBUS_PCI_NV_19) |
-             dev->agp->mode) & PCI_AGP_COMMAND_FW) {
-                struct drm_agp_info info;
-                struct drm_agp_mode mode;
-
-                ret = drm_agp_info(dev, &info);
-                if (ret)
-                        return ret;
-
-                mode.mode = get_agp_mode(dev, info.mode) & ~PCI_AGP_COMMAND_FW;
-                ret = drm_agp_enable(dev, mode);
-                if (ret)
-                        return ret;
-        }
-
-        saved_pci_nv_1 = nv_rd32(dev, NV04_PBUS_PCI_NV_1);
-
-        /* clear busmaster bit */
-        nv_wr32(dev, NV04_PBUS_PCI_NV_1, saved_pci_nv_1 & ~0x4);
-        /* disable AGP */
-        nv_wr32(dev, NV04_PBUS_PCI_NV_19, 0);
-
-        /* power cycle pgraph, if enabled */
-        pmc_enable = nv_rd32(dev, NV03_PMC_ENABLE);
-        if (pmc_enable & NV_PMC_ENABLE_PGRAPH) {
-                nv_wr32(dev, NV03_PMC_ENABLE,
-                                pmc_enable & ~NV_PMC_ENABLE_PGRAPH);
-                nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) |
-                                NV_PMC_ENABLE_PGRAPH);
-        }
-
-        /* and restore (gives effect of resetting AGP) */
-        nv_wr32(dev, NV04_PBUS_PCI_NV_1, saved_pci_nv_1);
-#endif
-
-        return 0;
-}
-
-int
-nouveau_mem_init_agp(struct drm_device *dev)
-{
-#if __OS_HAS_AGP
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct drm_agp_info info;
-        struct drm_agp_mode mode;
-        int ret;
-
-        if (!dev->agp->acquired) {
-                ret = drm_agp_acquire(dev);
-                if (ret) {
-                        NV_ERROR(dev, "Unable to acquire AGP: %d\n", ret);
-                        return ret;
-                }
-        }
-
-        nouveau_mem_reset_agp(dev);
-
-        ret = drm_agp_info(dev, &info);
-        if (ret) {
-                NV_ERROR(dev, "Unable to get AGP info: %d\n", ret);
-                return ret;
-        }
-
-        /* see agp.h for the AGPSTAT_* modes available */
-        mode.mode = get_agp_mode(dev, info.mode);
-        ret = drm_agp_enable(dev, mode);
-        if (ret) {
-                NV_ERROR(dev, "Unable to enable AGP: %d\n", ret);
-                return ret;
-        }
-
-        dev_priv->gart_info.type        = NOUVEAU_GART_AGP;
-        dev_priv->gart_info.aper_base   = info.aperture_base;
-        dev_priv->gart_info.aper_size   = info.aperture_size;
-#endif
-        return 0;
-}
-
-static const struct vram_types {
-        int value;
-        const char *name;
-} vram_type_map[] = {
-        { NV_MEM_TYPE_STOLEN , "stolen system memory" },
-        { NV_MEM_TYPE_SGRAM  , "SGRAM" },
-        { NV_MEM_TYPE_SDRAM  , "SDRAM" },
-        { NV_MEM_TYPE_DDR1   , "DDR1" },
-        { NV_MEM_TYPE_DDR2   , "DDR2" },
-        { NV_MEM_TYPE_DDR3   , "DDR3" },
-        { NV_MEM_TYPE_GDDR2  , "GDDR2" },
-        { NV_MEM_TYPE_GDDR3  , "GDDR3" },
-        { NV_MEM_TYPE_GDDR4  , "GDDR4" },
-        { NV_MEM_TYPE_GDDR5  , "GDDR5" },
-        { NV_MEM_TYPE_UNKNOWN, "unknown type" }
-};
-
-int
-nouveau_mem_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct ttm_bo_device *bdev = &dev_priv->ttm.bdev;
-        const struct vram_types *vram_type;
-        int ret, dma_bits;
-
-        dma_bits = 32;
-        if (dev_priv->card_type >= NV_50) {
-                if (pci_dma_supported(dev->pdev, DMA_BIT_MASK(40)))
-                        dma_bits = 40;
-        } else
-        if (0 && pci_is_pcie(dev->pdev) &&
-            dev_priv->chipset  > 0x40 &&
-            dev_priv->chipset != 0x45) {
-                if (pci_dma_supported(dev->pdev, DMA_BIT_MASK(39)))
-                        dma_bits = 39;
-        }
-
-        ret = pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(dma_bits));
-        if (ret)
-                return ret;
-        ret = pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(dma_bits));
-        if (ret) {
-                /* Reset to default value. */
-                pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32));
-        }
-
-
-        ret = nouveau_ttm_global_init(dev_priv);
-        if (ret)
-                return ret;
-
-        ret = ttm_bo_device_init(&dev_priv->ttm.bdev,
-                                 dev_priv->ttm.bo_global_ref.ref.object,
-                                 &nouveau_bo_driver, DRM_FILE_PAGE_OFFSET,
-                                 dma_bits <= 32 ? true : false);
-        if (ret) {
-                NV_ERROR(dev, "Error initialising bo driver: %d\n", ret);
-                return ret;
-        }
-
-        vram_type = vram_type_map;
-        while (vram_type->value != NV_MEM_TYPE_UNKNOWN) {
-                if (nouveau_vram_type) {
-                        if (!strcasecmp(nouveau_vram_type, vram_type->name))
-                                break;
-                        dev_priv->vram_type = vram_type->value;
-                } else {
-                        if (vram_type->value == dev_priv->vram_type)
-                                break;
-                }
-                vram_type++;
-        }
-
-        NV_INFO(dev, "Detected %dMiB VRAM (%s)\n",
-                (int)(dev_priv->vram_size >> 20), vram_type->name);
-        if (dev_priv->vram_sys_base) {
-                NV_INFO(dev, "Stolen system memory at: 0x%010llx\n",
-                        dev_priv->vram_sys_base);
-        }
-
-        dev_priv->fb_available_size = dev_priv->vram_size;
-        dev_priv->fb_mappable_pages = dev_priv->fb_available_size;
-        if (dev_priv->fb_mappable_pages > pci_resource_len(dev->pdev, 1))
-                dev_priv->fb_mappable_pages = pci_resource_len(dev->pdev, 1);
-        dev_priv->fb_mappable_pages >>= PAGE_SHIFT;
-
-        dev_priv->fb_available_size -= dev_priv->ramin_rsvd_vram;
-        dev_priv->fb_aper_free = dev_priv->fb_available_size;
-
-        /* mappable vram */
-        ret = ttm_bo_init_mm(bdev, TTM_PL_VRAM,
-                             dev_priv->fb_available_size >> PAGE_SHIFT);
-        if (ret) {
-                NV_ERROR(dev, "Failed VRAM mm init: %d\n", ret);
-                return ret;
-        }
-
-        if (dev_priv->card_type < NV_50) {
-                ret = nouveau_bo_new(dev, 256*1024, 0, TTM_PL_FLAG_VRAM,
-                                     0, 0, NULL, &dev_priv->vga_ram);
-                if (ret == 0)
-                        ret = nouveau_bo_pin(dev_priv->vga_ram,
-                                             TTM_PL_FLAG_VRAM);
-
-                if (ret) {
-                        NV_WARN(dev, "failed to reserve VGA memory\n");
-                        nouveau_bo_ref(NULL, &dev_priv->vga_ram);
-                }
-        }
-
-        dev_priv->fb_mtrr = drm_mtrr_add(pci_resource_start(dev->pdev, 1),
-                                         pci_resource_len(dev->pdev, 1),
-                                         DRM_MTRR_WC);
-        return 0;
-}
-
-int
-nouveau_mem_gart_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct ttm_bo_device *bdev = &dev_priv->ttm.bdev;
-        int ret;
-
-        dev_priv->gart_info.type = NOUVEAU_GART_NONE;
-
-#if !defined(__powerpc__) && !defined(__ia64__)
-        if (drm_pci_device_is_agp(dev) && dev->agp && nouveau_agpmode) {
-                ret = nouveau_mem_init_agp(dev);
-                if (ret)
-                        NV_ERROR(dev, "Error initialising AGP: %d\n", ret);
-        }
-#endif
-
-        if (dev_priv->gart_info.type == NOUVEAU_GART_NONE) {
-                ret = nouveau_sgdma_init(dev);
-                if (ret) {
-                        NV_ERROR(dev, "Error initialising PCI(E): %d\n", ret);
-                        return ret;
-                }
-        }
-
-        NV_INFO(dev, "%d MiB GART (aperture)\n",
-                (int)(dev_priv->gart_info.aper_size >> 20));
-        dev_priv->gart_info.aper_free = dev_priv->gart_info.aper_size;
-
-        ret = ttm_bo_init_mm(bdev, TTM_PL_TT,
-                             dev_priv->gart_info.aper_size >> PAGE_SHIFT);
-        if (ret) {
-                NV_ERROR(dev, "Failed TT mm init: %d\n", ret);
-                return ret;
-        }
-
-        return 0;
-}
+#include <subdev/fb.h>
 
 static int
 nv40_mem_timing_calc(struct drm_device *dev, u32 freq,
@@ -479,6 +41,8 @@ nv40_mem_timing_calc(struct drm_device *dev, u32 freq,
                      struct nouveau_pm_memtiming *boot,
                      struct nouveau_pm_memtiming *t)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         t->reg[0] = (e->tRP << 24 | e->tRAS << 16 | e->tRFC << 8 | e->tRC);
 
         /* XXX: I don't trust the -1's and +1's... they must come
@@ -494,7 +58,7 @@ nv40_mem_timing_calc(struct drm_device *dev, u32 freq,
                      e->tRCDWR << 8 |
                      e->tRCDRD);
 
-        NV_DEBUG(dev, "Entry %d: 220: %08x %08x %08x\n", t->id,
+        NV_DEBUG(drm, "Entry %d: 220: %08x %08x %08x\n", t->id,
                  t->reg[0], t->reg[1], t->reg[2]);
         return 0;
 }
@@ -505,7 +69,9 @@ nv50_mem_timing_calc(struct drm_device *dev, u32 freq,
                      struct nouveau_pm_memtiming *boot,
                      struct nouveau_pm_memtiming *t)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct bit_entry P;
         uint8_t unk18 = 1, unk20 = 0, unk21 = 0, tmp7_3;
 
@@ -559,7 +125,7 @@ nv50_mem_timing_calc(struct drm_device *dev, u32 freq,
                 t->reg[7] = 0x4000202 | (e->tCL - 1) << 16;
 
                 /* XXX: P.version == 1 only has DDR2 and GDDR3? */
-                if (dev_priv->vram_type == NV_MEM_TYPE_DDR2) {
+                if (pfb->ram.type == NV_MEM_TYPE_DDR2) {
                         t->reg[5] |= (e->tCL + 3) << 8;
                         t->reg[6] |= (t->tCWL - 2) << 8;
                         t->reg[8] |= (e->tCL - 4);
@@ -592,11 +158,11 @@ nv50_mem_timing_calc(struct drm_device *dev, u32 freq,
                             0x202;
         }
 
-        NV_DEBUG(dev, "Entry %d: 220: %08x %08x %08x %08x\n", t->id,
+        NV_DEBUG(drm, "Entry %d: 220: %08x %08x %08x %08x\n", t->id,
                  t->reg[0], t->reg[1], t->reg[2], t->reg[3]);
-        NV_DEBUG(dev, "         230: %08x %08x %08x %08x\n",
+        NV_DEBUG(drm, "         230: %08x %08x %08x %08x\n",
                  t->reg[4], t->reg[5], t->reg[6], t->reg[7]);
-        NV_DEBUG(dev, "         240: %08x\n", t->reg[8]);
+        NV_DEBUG(drm, "         240: %08x\n", t->reg[8]);
         return 0;
 }
 
@@ -606,6 +172,8 @@ nvc0_mem_timing_calc(struct drm_device *dev, u32 freq,
                      struct nouveau_pm_memtiming *boot,
                      struct nouveau_pm_memtiming *t)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         if (e->tCWL > 0)
                 t->tCWL = e->tCWL;
 
@@ -628,9 +196,9 @@ nvc0_mem_timing_calc(struct drm_device *dev, u32 freq,
         t->reg[4] = (boot->reg[4] & 0xfff00fff) |
                     (e->tRRD&0x1f) << 15;
 
-        NV_DEBUG(dev, "Entry %d: 290: %08x %08x %08x %08x\n", t->id,
+        NV_DEBUG(drm, "Entry %d: 290: %08x %08x %08x %08x\n", t->id,
                  t->reg[0], t->reg[1], t->reg[2], t->reg[3]);
-        NV_DEBUG(dev, "         2a0: %08x\n", t->reg[4]);
+        NV_DEBUG(drm, "         2a0: %08x\n", t->reg[4]);
         return 0;
 }
 
@@ -644,6 +212,8 @@ nouveau_mem_ddr2_mr(struct drm_device *dev, u32 freq,
                     struct nouveau_pm_memtiming *boot,
                     struct nouveau_pm_memtiming *t)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         t->drive_strength = 0;
         if (len < 15) {
                 t->odt = boot->odt;
@@ -652,17 +222,17 @@ nouveau_mem_ddr2_mr(struct drm_device *dev, u32 freq,
         }
 
         if (e->tCL >= NV_MEM_CL_DDR2_MAX) {
-                NV_WARN(dev, "(%u) Invalid tCL: %u", t->id, e->tCL);
+                NV_WARN(drm, "(%u) Invalid tCL: %u", t->id, e->tCL);
                 return -ERANGE;
         }
 
         if (e->tWR >= NV_MEM_WR_DDR2_MAX) {
-                NV_WARN(dev, "(%u) Invalid tWR: %u", t->id, e->tWR);
+                NV_WARN(drm, "(%u) Invalid tWR: %u", t->id, e->tWR);
                 return -ERANGE;
         }
 
         if (t->odt > 3) {
-                NV_WARN(dev, "(%u) Invalid odt value, assuming disabled: %x",
+                NV_WARN(drm, "(%u) Invalid odt value, assuming disabled: %x",
                         t->id, t->odt);
                 t->odt = 0;
         }
@@ -674,11 +244,11 @@ nouveau_mem_ddr2_mr(struct drm_device *dev, u32 freq,
                    (t->odt & 0x1) << 2 |
                    (t->odt & 0x2) << 5;
 
-        NV_DEBUG(dev, "(%u) MR: %08x", t->id, t->mr[0]);
+        NV_DEBUG(drm, "(%u) MR: %08x", t->id, t->mr[0]);
         return 0;
 }
 
-uint8_t nv_mem_wr_lut_ddr3[NV_MEM_WR_DDR3_MAX] = {
+static const uint8_t nv_mem_wr_lut_ddr3[NV_MEM_WR_DDR3_MAX] = {
         0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 0, 0};
 
 static int
@@ -687,6 +257,7 @@ nouveau_mem_ddr3_mr(struct drm_device *dev, u32 freq,
                     struct nouveau_pm_memtiming *boot,
                     struct nouveau_pm_memtiming *t)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 cl = e->tCL - 4;
 
         t->drive_strength = 0;
@@ -697,17 +268,17 @@ nouveau_mem_ddr3_mr(struct drm_device *dev, u32 freq,
         }
 
         if (e->tCL >= NV_MEM_CL_DDR3_MAX || e->tCL < 4) {
-                NV_WARN(dev, "(%u) Invalid tCL: %u", t->id, e->tCL);
+                NV_WARN(drm, "(%u) Invalid tCL: %u", t->id, e->tCL);
                 return -ERANGE;
         }
 
         if (e->tWR >= NV_MEM_WR_DDR3_MAX || e->tWR < 4) {
-                NV_WARN(dev, "(%u) Invalid tWR: %u", t->id, e->tWR);
+                NV_WARN(drm, "(%u) Invalid tWR: %u", t->id, e->tWR);
                 return -ERANGE;
         }
 
         if (e->tCWL < 5) {
-                NV_WARN(dev, "(%u) Invalid tCWL: %u", t->id, e->tCWL);
+                NV_WARN(drm, "(%u) Invalid tCWL: %u", t->id, e->tCWL);
                 return -ERANGE;
         }
 
@@ -722,13 +293,13 @@ nouveau_mem_ddr3_mr(struct drm_device *dev, u32 freq,
                    (t->odt & 0x4) << 7;
         t->mr[2] = (boot->mr[2] & 0x20ffb7) | (e->tCWL - 5) << 3;
 
-        NV_DEBUG(dev, "(%u) MR: %08x %08x", t->id, t->mr[0], t->mr[2]);
+        NV_DEBUG(drm, "(%u) MR: %08x %08x", t->id, t->mr[0], t->mr[2]);
         return 0;
 }
 
-uint8_t nv_mem_cl_lut_gddr3[NV_MEM_CL_GDDR3_MAX] = {
+static const uint8_t nv_mem_cl_lut_gddr3[NV_MEM_CL_GDDR3_MAX] = {
         0, 0, 0, 0, 4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 10, 11};
-uint8_t nv_mem_wr_lut_gddr3[NV_MEM_WR_GDDR3_MAX] = {
+static const uint8_t nv_mem_wr_lut_gddr3[NV_MEM_WR_GDDR3_MAX] = {
         0, 0, 0, 0, 0, 2, 3, 8, 9, 10, 11, 0, 0, 1, 1, 0, 3};
 
 static int
@@ -737,6 +308,8 @@ nouveau_mem_gddr3_mr(struct drm_device *dev, u32 freq,
                      struct nouveau_pm_memtiming *boot,
                      struct nouveau_pm_memtiming *t)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         if (len < 15) {
                 t->drive_strength = boot->drive_strength;
                 t->odt = boot->odt;
@@ -746,17 +319,17 @@ nouveau_mem_gddr3_mr(struct drm_device *dev, u32 freq,
         }
 
         if (e->tCL >= NV_MEM_CL_GDDR3_MAX) {
-                NV_WARN(dev, "(%u) Invalid tCL: %u", t->id, e->tCL);
+                NV_WARN(drm, "(%u) Invalid tCL: %u", t->id, e->tCL);
                 return -ERANGE;
         }
 
         if (e->tWR >= NV_MEM_WR_GDDR3_MAX) {
-                NV_WARN(dev, "(%u) Invalid tWR: %u", t->id, e->tWR);
+                NV_WARN(drm, "(%u) Invalid tWR: %u", t->id, e->tWR);
                 return -ERANGE;
         }
 
         if (t->odt > 3) {
-                NV_WARN(dev, "(%u) Invalid odt value, assuming autocal: %x",
+                NV_WARN(drm, "(%u) Invalid odt value, assuming autocal: %x",
                         t->id, t->odt);
                 t->odt = 0;
         }
@@ -770,7 +343,7 @@ nouveau_mem_gddr3_mr(struct drm_device *dev, u32 freq,
                    (nv_mem_wr_lut_gddr3[e->tWR] & 0xf) << 4;
         t->mr[2] = boot->mr[2];
 
-        NV_DEBUG(dev, "(%u) MR: %08x %08x %08x", t->id,
+        NV_DEBUG(drm, "(%u) MR: %08x %08x %08x", t->id,
                       t->mr[0], t->mr[1], t->mr[2]);
         return 0;
 }
@@ -781,6 +354,8 @@ nouveau_mem_gddr5_mr(struct drm_device *dev, u32 freq,
                      struct nouveau_pm_memtiming *boot,
                      struct nouveau_pm_memtiming *t)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         if (len < 15) {
                 t->drive_strength = boot->drive_strength;
                 t->odt = boot->odt;
@@ -790,17 +365,17 @@ nouveau_mem_gddr5_mr(struct drm_device *dev, u32 freq,
         }
 
         if (e->tCL >= NV_MEM_CL_GDDR5_MAX) {
-                NV_WARN(dev, "(%u) Invalid tCL: %u", t->id, e->tCL);
+                NV_WARN(drm, "(%u) Invalid tCL: %u", t->id, e->tCL);
                 return -ERANGE;
         }
 
         if (e->tWR >= NV_MEM_WR_GDDR5_MAX) {
-                NV_WARN(dev, "(%u) Invalid tWR: %u", t->id, e->tWR);
+                NV_WARN(drm, "(%u) Invalid tWR: %u", t->id, e->tWR);
                 return -ERANGE;
         }
 
         if (t->odt > 3) {
-                NV_WARN(dev, "(%u) Invalid odt value, assuming autocal: %x",
+                NV_WARN(drm, "(%u) Invalid odt value, assuming autocal: %x",
                         t->id, t->odt);
                 t->odt = 0;
         }
@@ -812,7 +387,7 @@ nouveau_mem_gddr5_mr(struct drm_device *dev, u32 freq,
                    t->drive_strength |
                    (t->odt << 2);
 
-        NV_DEBUG(dev, "(%u) MR: %08x %08x", t->id, t->mr[0], t->mr[1]);
+        NV_DEBUG(drm, "(%u) MR: %08x %08x", t->id, t->mr[0], t->mr[1]);
         return 0;
 }
 
@@ -820,8 +395,9 @@ int
 nouveau_mem_timing_calc(struct drm_device *dev, u32 freq,
                         struct nouveau_pm_memtiming *t)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_memtiming *boot = &pm->boot.timing;
         struct nouveau_pm_tbl_entry *e;
         u8 ver, len, *ptr, *ramcfg;
@@ -836,7 +412,7 @@ nouveau_mem_timing_calc(struct drm_device *dev, u32 freq,
 
         t->tCWL = boot->tCWL;
 
-        switch (dev_priv->card_type) {
+        switch (device->card_type) {
         case NV_40:
                 ret = nv40_mem_timing_calc(dev, freq, e, len, boot, t);
                 break;
@@ -852,7 +428,7 @@ nouveau_mem_timing_calc(struct drm_device *dev, u32 freq,
                 break;
         }
 
-        switch (dev_priv->vram_type * !ret) {
+        switch (pfb->ram.type * !ret) {
         case NV_MEM_TYPE_GDDR3:
                 ret = nouveau_mem_gddr3_mr(dev, freq, e, len, boot, t);
                 break;
@@ -879,7 +455,7 @@ nouveau_mem_timing_calc(struct drm_device *dev, u32 freq,
                 else
                         dll_off = !!(ramcfg[2] & 0x40);
 
-                switch (dev_priv->vram_type) {
+                switch (pfb->ram.type) {
                 case NV_MEM_TYPE_GDDR3:
                         t->mr[1] &= ~0x00000040;
                         t->mr[1] |=  0x00000040 * dll_off;
@@ -897,11 +473,12 @@ nouveau_mem_timing_calc(struct drm_device *dev, u32 freq,
 void
 nouveau_mem_timing_read(struct drm_device *dev, struct nouveau_pm_memtiming *t)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
         u32 timing_base, timing_regs, mr_base;
         int i;
 
-        if (dev_priv->card_type >= 0xC0) {
+        if (device->card_type >= 0xC0) {
                 timing_base = 0x10f290;
                 mr_base = 0x10f300;
         } else {
@@ -911,7 +488,7 @@ nouveau_mem_timing_read(struct drm_device *dev, struct nouveau_pm_memtiming *t)
 
         t->id = -1;
 
-        switch (dev_priv->card_type) {
+        switch (device->card_type) {
         case NV_50:
                 timing_regs = 9;
                 break;
@@ -928,24 +505,24 @@ nouveau_mem_timing_read(struct drm_device *dev, struct nouveau_pm_memtiming *t)
                 return;
         }
         for(i = 0; i < timing_regs; i++)
-                t->reg[i] = nv_rd32(dev, timing_base + (0x04 * i));
+                t->reg[i] = nv_rd32(device, timing_base + (0x04 * i));
 
         t->tCWL = 0;
-        if (dev_priv->card_type < NV_C0) {
-                t->tCWL = ((nv_rd32(dev, 0x100228) & 0x0f000000) >> 24) + 1;
-        } else if (dev_priv->card_type <= NV_D0) {
-                t->tCWL = ((nv_rd32(dev, 0x10f294) & 0x00000f80) >> 7);
+        if (device->card_type < NV_C0) {
+                t->tCWL = ((nv_rd32(device, 0x100228) & 0x0f000000) >> 24) + 1;
+        } else if (device->card_type <= NV_D0) {
+                t->tCWL = ((nv_rd32(device, 0x10f294) & 0x00000f80) >> 7);
         }
 
-        t->mr[0] = nv_rd32(dev, mr_base);
-        t->mr[1] = nv_rd32(dev, mr_base + 0x04);
-        t->mr[2] = nv_rd32(dev, mr_base + 0x20);
-        t->mr[3] = nv_rd32(dev, mr_base + 0x24);
+        t->mr[0] = nv_rd32(device, mr_base);
+        t->mr[1] = nv_rd32(device, mr_base + 0x04);
+        t->mr[2] = nv_rd32(device, mr_base + 0x20);
+        t->mr[3] = nv_rd32(device, mr_base + 0x24);
 
         t->odt = 0;
         t->drive_strength = 0;
 
-        switch (dev_priv->vram_type) {
+        switch (pfb->ram.type) {
         case NV_MEM_TYPE_DDR3:
                 t->odt |= (t->mr[1] & 0x200) >> 7;
         case NV_MEM_TYPE_DDR2:
@@ -966,13 +543,15 @@ int
 nouveau_mem_exec(struct nouveau_mem_exec_func *exec,
                  struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = exec->dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(exec->dev);
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
         struct nouveau_pm_memtiming *info = &perflvl->timing;
         u32 tMRD = 1000, tCKSRE = 0, tCKSRX = 0, tXS = 0, tDLLK = 0;
         u32 mr[3] = { info->mr[0], info->mr[1], info->mr[2] };
         u32 mr1_dlloff;
 
-        switch (dev_priv->vram_type) {
+        switch (pfb->ram.type) {
         case NV_MEM_TYPE_DDR2:
                 tDLLK = 2000;
                 mr1_dlloff = 0x00000001;
@@ -988,12 +567,12 @@ nouveau_mem_exec(struct nouveau_mem_exec_func *exec,
                 mr1_dlloff = 0x00000040;
                 break;
         default:
-                NV_ERROR(exec->dev, "cannot reclock unsupported memtype\n");
+                NV_ERROR(drm, "cannot reclock unsupported memtype\n");
                 return -ENODEV;
         }
 
         /* fetch current MRs */
-        switch (dev_priv->vram_type) {
+        switch (pfb->ram.type) {
         case NV_MEM_TYPE_GDDR3:
         case NV_MEM_TYPE_DDR3:
                 mr[2] = exec->mrg(exec, 2);
@@ -1060,194 +639,9 @@ nouveau_mem_exec(struct nouveau_mem_exec_func *exec,
                 exec->mrs (exec, 0, info->mr[0] | 0x00000000);
                 exec->wait(exec, tMRD);
                 exec->wait(exec, tDLLK);
-                if (dev_priv->vram_type == NV_MEM_TYPE_GDDR3)
+                if (pfb->ram.type == NV_MEM_TYPE_GDDR3)
                         exec->precharge(exec);
         }
 
         return 0;
 }
-
-int
-nouveau_mem_vbios_type(struct drm_device *dev)
-{
-        struct bit_entry M;
-        u8 ramcfg = (nv_rd32(dev, 0x101000) & 0x0000003c) >> 2;
-        if (!bit_table(dev, 'M', &M) || M.version != 2 || M.length < 5) {
-                u8 *table = ROMPTR(dev, M.data[3]);
-                if (table && table[0] == 0x10 && ramcfg < table[3]) {
-                        u8 *entry = table + table[1] + (ramcfg * table[2]);
-                        switch (entry[0] & 0x0f) {
-                        case 0: return NV_MEM_TYPE_DDR2;
-                        case 1: return NV_MEM_TYPE_DDR3;
-                        case 2: return NV_MEM_TYPE_GDDR3;
-                        case 3: return NV_MEM_TYPE_GDDR5;
-                        default:
-                                break;
-                        }
-
-                }
-        }
-        return NV_MEM_TYPE_UNKNOWN;
-}
-
-static int
-nouveau_vram_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
-{
-        /* nothing to do */
-        return 0;
-}
-
-static int
-nouveau_vram_manager_fini(struct ttm_mem_type_manager *man)
-{
-        /* nothing to do */
-        return 0;
-}
-
-static inline void
-nouveau_mem_node_cleanup(struct nouveau_mem *node)
-{
-        if (node->vma[0].node) {
-                nouveau_vm_unmap(&node->vma[0]);
-                nouveau_vm_put(&node->vma[0]);
-        }
-
-        if (node->vma[1].node) {
-                nouveau_vm_unmap(&node->vma[1]);
-                nouveau_vm_put(&node->vma[1]);
-        }
-}
-
-static void
-nouveau_vram_manager_del(struct ttm_mem_type_manager *man,
-                         struct ttm_mem_reg *mem)
-{
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(man->bdev);
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-        struct drm_device *dev = dev_priv->dev;
-
-        nouveau_mem_node_cleanup(mem->mm_node);
-        vram->put(dev, (struct nouveau_mem **)&mem->mm_node);
-}
-
-static int
-nouveau_vram_manager_new(struct ttm_mem_type_manager *man,
-                         struct ttm_buffer_object *bo,
-                         struct ttm_placement *placement,
-                         struct ttm_mem_reg *mem)
-{
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(man->bdev);
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-        struct drm_device *dev = dev_priv->dev;
-        struct nouveau_bo *nvbo = nouveau_bo(bo);
-        struct nouveau_mem *node;
-        u32 size_nc = 0;
-        int ret;
-
-        if (nvbo->tile_flags & NOUVEAU_GEM_TILE_NONCONTIG)
-                size_nc = 1 << nvbo->page_shift;
-
-        ret = vram->get(dev, mem->num_pages << PAGE_SHIFT,
-                        mem->page_alignment << PAGE_SHIFT, size_nc,
-                        (nvbo->tile_flags >> 8) & 0x3ff, &node);
-        if (ret) {
-                mem->mm_node = NULL;
-                return (ret == -ENOSPC) ? 0 : ret;
-        }
-
-        node->page_shift = nvbo->page_shift;
-
-        mem->mm_node = node;
-        mem->start   = node->offset >> PAGE_SHIFT;
-        return 0;
-}
-
-void
-nouveau_vram_manager_debug(struct ttm_mem_type_manager *man, const char *prefix)
-{
-        struct nouveau_mm *mm = man->priv;
-        struct nouveau_mm_node *r;
-        u32 total = 0, free = 0;
-
-        mutex_lock(&mm->mutex);
-        list_for_each_entry(r, &mm->nodes, nl_entry) {
-                printk(KERN_DEBUG "%s %d: 0x%010llx 0x%010llx\n",
-                       prefix, r->type, ((u64)r->offset << 12),
-                       (((u64)r->offset + r->length) << 12));
-
-                total += r->length;
-                if (!r->type)
-                        free += r->length;
-        }
-        mutex_unlock(&mm->mutex);
-
-        printk(KERN_DEBUG "%s  total: 0x%010llx free: 0x%010llx\n",
-               prefix, (u64)total << 12, (u64)free << 12);
-        printk(KERN_DEBUG "%s  block: 0x%08x\n",
-               prefix, mm->block_size << 12);
-}
-
-const struct ttm_mem_type_manager_func nouveau_vram_manager = {
-        nouveau_vram_manager_init,
-        nouveau_vram_manager_fini,
-        nouveau_vram_manager_new,
-        nouveau_vram_manager_del,
-        nouveau_vram_manager_debug
-};
-
-static int
-nouveau_gart_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
-{
-        return 0;
-}
-
-static int
-nouveau_gart_manager_fini(struct ttm_mem_type_manager *man)
-{
-        return 0;
-}
-
-static void
-nouveau_gart_manager_del(struct ttm_mem_type_manager *man,
-                         struct ttm_mem_reg *mem)
-{
-        nouveau_mem_node_cleanup(mem->mm_node);
-        kfree(mem->mm_node);
-        mem->mm_node = NULL;
-}
-
-static int
-nouveau_gart_manager_new(struct ttm_mem_type_manager *man,
-                         struct ttm_buffer_object *bo,
-                         struct ttm_placement *placement,
-                         struct ttm_mem_reg *mem)
-{
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bo->bdev);
-        struct nouveau_mem *node;
-
-        if (unlikely((mem->num_pages << PAGE_SHIFT) >=
-                     dev_priv->gart_info.aper_size))
-                return -ENOMEM;
-
-        node = kzalloc(sizeof(*node), GFP_KERNEL);
-        if (!node)
-                return -ENOMEM;
-        node->page_shift = 12;
-
-        mem->mm_node = node;
-        mem->start   = 0;
-        return 0;
-}
-
-void
-nouveau_gart_manager_debug(struct ttm_mem_type_manager *man, const char *prefix)
-{
-}
-
-const struct ttm_mem_type_manager_func nouveau_gart_manager = {
-        nouveau_gart_manager_init,
-        nouveau_gart_manager_fini,
-        nouveau_gart_manager_new,
-        nouveau_gart_manager_del,
-        nouveau_gart_manager_debug
-};
diff --git a/drivers/gpu/drm/nouveau/nouveau_mm.h b/drivers/gpu/drm/nouveau/nouveau_mm.h
deleted file mode 100644
index 57a600c35c95..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_mm.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * 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
- */
-
-#ifndef __NOUVEAU_REGION_H__
-#define __NOUVEAU_REGION_H__
-
-struct nouveau_mm_node {
-        struct list_head nl_entry;
-        struct list_head fl_entry;
-        struct list_head rl_entry;
-
-        u8  type;
-        u32 offset;
-        u32 length;
-};
-
-struct nouveau_mm {
-        struct list_head nodes;
-        struct list_head free;
-
-        struct mutex mutex;
-
-        u32 block_size;
-        int heap_nodes;
-};
-
-int  nouveau_mm_init(struct nouveau_mm *, u32 offset, u32 length, u32 block);
-int  nouveau_mm_fini(struct nouveau_mm *);
-int  nouveau_mm_pre(struct nouveau_mm *);
-int  nouveau_mm_get(struct nouveau_mm *, int type, u32 size, u32 size_nc,
-                    u32 align, struct nouveau_mm_node **);
-void nouveau_mm_put(struct nouveau_mm *, struct nouveau_mm_node *);
-
-int  nv50_vram_init(struct drm_device *);
-void nv50_vram_fini(struct drm_device *);
-int  nv50_vram_new(struct drm_device *, u64 size, u32 align, u32 size_nc,
-                    u32 memtype, struct nouveau_mem **);
-void nv50_vram_del(struct drm_device *, struct nouveau_mem **);
-bool nv50_vram_flags_valid(struct drm_device *, u32 tile_flags);
-
-int  nvc0_vram_init(struct drm_device *);
-int  nvc0_vram_new(struct drm_device *, u64 size, u32 align, u32 ncmin,
-                    u32 memtype, struct nouveau_mem **);
-bool nvc0_vram_flags_valid(struct drm_device *, u32 tile_flags);
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_mxm.c b/drivers/gpu/drm/nouveau/nouveau_mxm.c
deleted file mode 100644
index 07d0d1e03690..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_mxm.c
+++ /dev/null
@@ -1,723 +0,0 @@
-/*
- * Copyright 2011 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 <linux/acpi.h>
-
-#include "drmP.h"
-#include "nouveau_drv.h"
-
-#define MXM_DBG(dev, fmt, args...) NV_DEBUG((dev), "MXM: " fmt, ##args)
-#define MXM_MSG(dev, fmt, args...) NV_INFO((dev), "MXM: " fmt, ##args)
-
-static u8 *
-mxms_data(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return dev_priv->mxms;
-
-}
-
-static u16
-mxms_version(struct drm_device *dev)
-{
-        u8 *mxms = mxms_data(dev);
-        u16 version = (mxms[4] << 8) | mxms[5];
-        switch (version ) {
-        case 0x0200:
-        case 0x0201:
-        case 0x0300:
-                return version;
-        default:
-                break;
-        }
-
-        MXM_DBG(dev, "unknown version %d.%d\n", mxms[4], mxms[5]);
-        return 0x0000;
-}
-
-static u16
-mxms_headerlen(struct drm_device *dev)
-{
-        return 8;
-}
-
-static u16
-mxms_structlen(struct drm_device *dev)
-{
-        return *(u16 *)&mxms_data(dev)[6];
-}
-
-static bool
-mxms_checksum(struct drm_device *dev)
-{
-        u16 size = mxms_headerlen(dev) + mxms_structlen(dev);
-        u8 *mxms = mxms_data(dev), sum = 0;
-        while (size--)
-                sum += *mxms++;
-        if (sum) {
-                MXM_DBG(dev, "checksum invalid\n");
-                return false;
-        }
-        return true;
-}
-
-static bool
-mxms_valid(struct drm_device *dev)
-{
-        u8 *mxms = mxms_data(dev);
-        if (*(u32 *)mxms != 0x5f4d584d) {
-                MXM_DBG(dev, "signature invalid\n");
-                return false;
-        }
-
-        if (!mxms_version(dev) || !mxms_checksum(dev))
-                return false;
-
-        return true;
-}
-
-static bool
-mxms_foreach(struct drm_device *dev, u8 types,
-             bool (*exec)(struct drm_device *, u8 *, void *), void *info)
-{
-        u8 *mxms = mxms_data(dev);
-        u8 *desc = mxms + mxms_headerlen(dev);
-        u8 *fini = desc + mxms_structlen(dev) - 1;
-        while (desc < fini) {
-                u8 type = desc[0] & 0x0f;
-                u8 headerlen = 0;
-                u8 recordlen = 0;
-                u8 entries = 0;
-
-                switch (type) {
-                case 0: /* Output Device Structure */
-                        if (mxms_version(dev) >= 0x0300)
-                                headerlen = 8;
-                        else
-                                headerlen = 6;
-                        break;
-                case 1: /* System Cooling Capability Structure */
-                case 2: /* Thermal Structure */
-                case 3: /* Input Power Structure */
-                        headerlen = 4;
-                        break;
-                case 4: /* GPIO Device Structure */
-                        headerlen = 4;
-                        recordlen = 2;
-                        entries   = (ROM32(desc[0]) & 0x01f00000) >> 20;
-                        break;
-                case 5: /* Vendor Specific Structure */
-                        headerlen = 8;
-                        break;
-                case 6: /* Backlight Control Structure */
-                        if (mxms_version(dev) >= 0x0300) {
-                                headerlen = 4;
-                                recordlen = 8;
-                                entries   = (desc[1] & 0xf0) >> 4;
-                        } else {
-                                headerlen = 8;
-                        }
-                        break;
-                case 7: /* Fan Control Structure */
-                        headerlen = 8;
-                        recordlen = 4;
-                        entries   = desc[1] & 0x07;
-                        break;
-                default:
-                        MXM_DBG(dev, "unknown descriptor type %d\n", type);
-                        return false;
-                }
-
-                if ((drm_debug & DRM_UT_DRIVER) && (exec == NULL)) {
-                        static const char * mxms_desc_name[] = {
-                                "ODS", "SCCS", "TS", "IPS",
-                                "GSD", "VSS", "BCS", "FCS",
-                        };
-                        u8 *dump = desc;
-                        int i, j;
-
-                        MXM_DBG(dev, "%4s: ", mxms_desc_name[type]);
-                        for (j = headerlen - 1; j >= 0; j--)
-                                printk("%02x", dump[j]);
-                        printk("\n");
-                        dump += headerlen;
-
-                        for (i = 0; i < entries; i++, dump += recordlen) {
-                                MXM_DBG(dev, "      ");
-                                for (j = recordlen - 1; j >= 0; j--)
-                                        printk("%02x", dump[j]);
-                                printk("\n");
-                        }
-                }
-
-                if (types & (1 << type)) {
-                        if (!exec(dev, desc, info))
-                                return false;
-                }
-
-                desc += headerlen + (entries * recordlen);
-        }
-
-        return true;
-}
-
-static u8 *
-mxm_table(struct drm_device *dev, u8 *size)
-{
-        struct bit_entry x;
-
-        if (bit_table(dev, 'x', &x)) {
-                MXM_DBG(dev, "BIT 'x' table not present\n");
-                return NULL;
-        }
-
-        if (x.version != 1 || x.length < 3) {
-                MXM_MSG(dev, "BIT x table %d/%d unknown\n",
-                        x.version, x.length);
-                return NULL;
-        }
-
-        *size = x.length;
-        return x.data;
-}
-
-/* These map MXM v2.x digital connection values to the appropriate SOR/link,
- * hopefully they're correct for all boards within the same chipset...
- *
- * MXM v3.x VBIOS are nicer and provide pointers to these tables.
- */
-static u8 nv84_sor_map[16] = {
-        0x00, 0x12, 0x22, 0x11, 0x32, 0x31, 0x11, 0x31,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static u8 nv92_sor_map[16] = {
-        0x00, 0x12, 0x22, 0x11, 0x32, 0x31, 0x11, 0x31,
-        0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static u8 nv94_sor_map[16] = {
-        0x00, 0x14, 0x24, 0x11, 0x34, 0x31, 0x11, 0x31,
-        0x11, 0x31, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static u8 nv96_sor_map[16] = {
-        0x00, 0x14, 0x24, 0x00, 0x34, 0x00, 0x11, 0x31,
-        0x11, 0x31, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static u8 nv98_sor_map[16] = {
-        0x00, 0x14, 0x12, 0x11, 0x00, 0x31, 0x11, 0x31,
-        0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-static u8
-mxm_sor_map(struct drm_device *dev, u8 conn)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u8 len, *mxm = mxm_table(dev, &len);
-        if (mxm && len >= 6) {
-                u8 *map = ROMPTR(dev, mxm[4]);
-                if (map) {
-                        if (map[0] == 0x10) {
-                                if (conn < map[3])
-                                        return map[map[1] + conn];
-                                return 0x00;
-                        }
-
-                        MXM_MSG(dev, "unknown sor map 0x%02x\n", map[0]);
-                }
-        }
-
-        if (dev_priv->chipset == 0x84 || dev_priv->chipset == 0x86)
-                return nv84_sor_map[conn];
-        if (dev_priv->chipset == 0x92)
-                return nv92_sor_map[conn];
-        if (dev_priv->chipset == 0x94)
-                return nv94_sor_map[conn];
-        if (dev_priv->chipset == 0x96)
-                return nv96_sor_map[conn];
-        if (dev_priv->chipset == 0x98)
-                return nv98_sor_map[conn];
-
-        MXM_MSG(dev, "missing sor map\n");
-        return 0x00;
-}
-
-static u8
-mxm_ddc_map(struct drm_device *dev, u8 port)
-{
-        u8 len, *mxm = mxm_table(dev, &len);
-        if (mxm && len >= 8) {
-                u8 *map = ROMPTR(dev, mxm[6]);
-                if (map) {
-                        if (map[0] == 0x10) {
-                                if (port < map[3])
-                                        return map[map[1] + port];
-                                return 0x00;
-                        }
-
-                        MXM_MSG(dev, "unknown ddc map 0x%02x\n", map[0]);
-                }
-        }
-
-        /* v2.x: directly write port as dcb i2cidx */
-        return (port << 4) | port;
-}
-
-struct mxms_odev {
-        u8 outp_type;
-        u8 conn_type;
-        u8 ddc_port;
-        u8 dig_conn;
-};
-
-static void
-mxms_output_device(struct drm_device *dev, u8 *pdata, struct mxms_odev *desc)
-{
-        u64 data = ROM32(pdata[0]);
-        if (mxms_version(dev) >= 0x0300)
-                data |= (u64)ROM16(pdata[4]) << 32;
-
-        desc->outp_type = (data & 0x00000000000000f0ULL) >> 4;
-        desc->ddc_port  = (data & 0x0000000000000f00ULL) >> 8;
-        desc->conn_type = (data & 0x000000000001f000ULL) >> 12;
-        desc->dig_conn  = (data & 0x0000000000780000ULL) >> 19;
-}
-
-struct context {
-        u32 *outp;
-        struct mxms_odev desc;
-};
-
-static bool
-mxm_match_tmds_partner(struct drm_device *dev, u8 *data, void *info)
-{
-        struct context *ctx = info;
-        struct mxms_odev desc;
-
-        mxms_output_device(dev, data, &desc);
-        if (desc.outp_type == 2 &&
-            desc.dig_conn == ctx->desc.dig_conn)
-                return false;
-        return true;
-}
-
-static bool
-mxm_match_dcb(struct drm_device *dev, u8 *data, void *info)
-{
-        struct context *ctx = info;
-        u64 desc = *(u64 *)data;
-
-        mxms_output_device(dev, data, &ctx->desc);
-
-        /* match dcb encoder type to mxm-ods device type */
-        if ((ctx->outp[0] & 0x0000000f) != ctx->desc.outp_type)
-                return true;
-
-        /* digital output, have some extra stuff to match here, there's a
-         * table in the vbios that provides a mapping from the mxm digital
-         * connection enum values to SOR/link
-         */
-        if ((desc & 0x00000000000000f0) >= 0x20) {
-                /* check against sor index */
-                u8 link = mxm_sor_map(dev, ctx->desc.dig_conn);
-                if ((ctx->outp[0] & 0x0f000000) != (link & 0x0f) << 24)
-                        return true;
-
-                /* check dcb entry has a compatible link field */
-                link = (link & 0x30) >> 4;
-                if ((link & ((ctx->outp[1] & 0x00000030) >> 4)) != link)
-                        return true;
-        }
-
-        /* mark this descriptor accounted for by setting invalid device type,
-         * except of course some manufactures don't follow specs properly and
-         * we need to avoid killing off the TMDS function on DP connectors
-         * if MXM-SIS is missing an entry for it.
-         */
-        data[0] &= ~0xf0;
-        if (ctx->desc.outp_type == 6 && ctx->desc.conn_type == 6 &&
-            mxms_foreach(dev, 0x01, mxm_match_tmds_partner, ctx)) {
-                data[0] |= 0x20; /* modify descriptor to match TMDS now */
-        } else {
-                data[0] |= 0xf0;
-        }
-
-        return false;
-}
-
-static int
-mxm_dcb_sanitise_entry(struct drm_device *dev, void *data, int idx, u8 *dcbe)
-{
-        struct context ctx = { .outp = (u32 *)dcbe };
-        u8 type, i2cidx, link;
-        u8 *conn;
-
-        /* look for an output device structure that matches this dcb entry.
-         * if one isn't found, disable it.
-         */
-        if (mxms_foreach(dev, 0x01, mxm_match_dcb, &ctx)) {
-                MXM_DBG(dev, "disable %d: 0x%08x 0x%08x\n",
-                        idx, ctx.outp[0], ctx.outp[1]);
-                ctx.outp[0] |= 0x0000000f;
-                return 0;
-        }
-
-        /* modify the output's ddc/aux port, there's a pointer to a table
-         * with the mapping from mxm ddc/aux port to dcb i2c_index in the
-         * vbios mxm table
-         */
-        i2cidx = mxm_ddc_map(dev, ctx.desc.ddc_port);
-        if ((ctx.outp[0] & 0x0000000f) != OUTPUT_DP)
-                i2cidx = (i2cidx & 0x0f) << 4;
-        else
-                i2cidx = (i2cidx & 0xf0);
-
-        if (i2cidx != 0xf0) {
-                ctx.outp[0] &= ~0x000000f0;
-                ctx.outp[0] |= i2cidx;
-        }
-
-        /* override dcb sorconf.link, based on what mxm data says */
-        switch (ctx.desc.outp_type) {
-        case 0x00: /* Analog CRT */
-        case 0x01: /* Analog TV/HDTV */
-                break;
-        default:
-                link = mxm_sor_map(dev, ctx.desc.dig_conn) & 0x30;
-                ctx.outp[1] &= ~0x00000030;
-                ctx.outp[1] |= link;
-                break;
-        }
-
-        /* we may need to fixup various other vbios tables based on what
-         * the descriptor says the connector type should be.
-         *
-         * in a lot of cases, the vbios tables will claim DVI-I is possible,
-         * and the mxm data says the connector is really HDMI.  another
-         * common example is DP->eDP.
-         */
-        conn = dcb_conn(dev, (ctx.outp[0] & 0x0000f000) >> 12);
-        type = conn[0];
-        switch (ctx.desc.conn_type) {
-        case 0x01: /* LVDS */
-                ctx.outp[1] |= 0x00000004; /* use_power_scripts */
-                /* XXX: modify default link width in LVDS table */
-                break;
-        case 0x02: /* HDMI */
-                type = DCB_CONNECTOR_HDMI_1;
-                break;
-        case 0x03: /* DVI-D */
-                type = DCB_CONNECTOR_DVI_D;
-                break;
-        case 0x0e: /* eDP, falls through to DPint */
-                ctx.outp[1] |= 0x00010000;
-        case 0x07: /* DP internal, wtf is this?? HP8670w */
-                ctx.outp[1] |= 0x00000004; /* use_power_scripts? */
-                type = DCB_CONNECTOR_eDP;
-                break;
-        default:
-                break;
-        }
-
-        if (mxms_version(dev) >= 0x0300)
-                conn[0] = type;
-
-        return 0;
-}
-
-static bool
-mxm_show_unmatched(struct drm_device *dev, u8 *data, void *info)
-{
-        u64 desc = *(u64 *)data;
-        if ((desc & 0xf0) != 0xf0)
-                MXM_MSG(dev, "unmatched output device 0x%016llx\n", desc);
-        return true;
-}
-
-static void
-mxm_dcb_sanitise(struct drm_device *dev)
-{
-        u8 *dcb = dcb_table(dev);
-        if (!dcb || dcb[0] != 0x40) {
-                MXM_DBG(dev, "unsupported DCB version\n");
-                return;
-        }
-
-        dcb_outp_foreach(dev, NULL, mxm_dcb_sanitise_entry);
-        mxms_foreach(dev, 0x01, mxm_show_unmatched, NULL);
-}
-
-static bool
-mxm_shadow_rom_fetch(struct nouveau_i2c_chan *i2c, u8 addr,
-                     u8 offset, u8 size, u8 *data)
-{
-        struct i2c_msg msgs[] = {
-                { .addr = addr, .flags = 0, .len = 1, .buf = &offset },
-                { .addr = addr, .flags = I2C_M_RD, .len = size, .buf = data, },
-        };
-
-        return i2c_transfer(&i2c->adapter, msgs, 2) == 2;
-}
-
-static bool
-mxm_shadow_rom(struct drm_device *dev, u8 version)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_i2c_chan *i2c = NULL;
-        u8 i2cidx, mxms[6], addr, size;
-
-        i2cidx = mxm_ddc_map(dev, 1 /* LVDS_DDC */) & 0x0f;
-        if (i2cidx < 0x0f)
-                i2c = nouveau_i2c_find(dev, i2cidx);
-        if (!i2c)
-                return false;
-
-        addr = 0x54;
-        if (!mxm_shadow_rom_fetch(i2c, addr, 0, 6, mxms)) {
-                addr = 0x56;
-                if (!mxm_shadow_rom_fetch(i2c, addr, 0, 6, mxms))
-                        return false;
-        }
-
-        dev_priv->mxms = mxms;
-        size = mxms_headerlen(dev) + mxms_structlen(dev);
-        dev_priv->mxms = kmalloc(size, GFP_KERNEL);
-
-        if (dev_priv->mxms &&
-            mxm_shadow_rom_fetch(i2c, addr, 0, size, dev_priv->mxms))
-                return true;
-
-        kfree(dev_priv->mxms);
-        dev_priv->mxms = NULL;
-        return false;
-}
-
-#if defined(CONFIG_ACPI)
-static bool
-mxm_shadow_dsm(struct drm_device *dev, u8 version)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        static char muid[] = {
-                0x00, 0xA4, 0x04, 0x40, 0x7D, 0x91, 0xF2, 0x4C,
-                0xB8, 0x9C, 0x79, 0xB6, 0x2F, 0xD5, 0x56, 0x65
-        };
-        u32 mxms_args[] = { 0x00000000 };
-        union acpi_object args[4] = {
-                /* _DSM MUID */
-                { .buffer.type = 3,
-                  .buffer.length = sizeof(muid),
-                  .buffer.pointer = muid,
-                },
-                /* spec says this can be zero to mean "highest revision", but
-                 * of course there's at least one bios out there which fails
-                 * unless you pass in exactly the version it supports..
-                 */
-                { .integer.type = ACPI_TYPE_INTEGER,
-                  .integer.value = (version & 0xf0) << 4 | (version & 0x0f),
-                },
-                /* MXMS function */
-                { .integer.type = ACPI_TYPE_INTEGER,
-                  .integer.value = 0x00000010,
-                },
-                /* Pointer to MXMS arguments */
-                { .buffer.type = ACPI_TYPE_BUFFER,
-                  .buffer.length = sizeof(mxms_args),
-                  .buffer.pointer = (char *)mxms_args,
-                },
-        };
-        struct acpi_object_list list = { ARRAY_SIZE(args), args };
-        struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_handle handle;
-        int ret;
-
-        handle = DEVICE_ACPI_HANDLE(&dev->pdev->dev);
-        if (!handle)
-                return false;
-
-        ret = acpi_evaluate_object(handle, "_DSM", &list, &retn);
-        if (ret) {
-                MXM_DBG(dev, "DSM MXMS failed: %d\n", ret);
-                return false;
-        }
-
-        obj = retn.pointer;
-        if (obj->type == ACPI_TYPE_BUFFER) {
-                dev_priv->mxms = kmemdup(obj->buffer.pointer,
-                                         obj->buffer.length, GFP_KERNEL);
-        } else
-        if (obj->type == ACPI_TYPE_INTEGER) {
-                MXM_DBG(dev, "DSM MXMS returned 0x%llx\n", obj->integer.value);
-        }
-
-        kfree(obj);
-        return dev_priv->mxms != NULL;
-}
-#endif
-
-#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
-
-#define WMI_WMMX_GUID "F6CB5C3C-9CAE-4EBD-B577-931EA32A2CC0"
-
-static u8
-wmi_wmmx_mxmi(struct drm_device *dev, u8 version)
-{
-        u32 mxmi_args[] = { 0x494D584D /* MXMI */, version, 0 };
-        struct acpi_buffer args = { sizeof(mxmi_args), mxmi_args };
-        struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-
-        status = wmi_evaluate_method(WMI_WMMX_GUID, 0, 0, &args, &retn);
-        if (ACPI_FAILURE(status)) {
-                MXM_DBG(dev, "WMMX MXMI returned %d\n", status);
-                return 0x00;
-        }
-
-        obj = retn.pointer;
-        if (obj->type == ACPI_TYPE_INTEGER) {
-                version = obj->integer.value;
-                MXM_DBG(dev, "WMMX MXMI version %d.%d\n",
-                             (version >> 4), version & 0x0f);
-        } else {
-                version = 0;
-                MXM_DBG(dev, "WMMX MXMI returned non-integer\n");
-        }
-
-        kfree(obj);
-        return version;
-}
-
-static bool
-mxm_shadow_wmi(struct drm_device *dev, u8 version)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 mxms_args[] = { 0x534D584D /* MXMS */, version, 0 };
-        struct acpi_buffer args = { sizeof(mxms_args), mxms_args };
-        struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-
-        if (!wmi_has_guid(WMI_WMMX_GUID)) {
-                MXM_DBG(dev, "WMMX GUID not found\n");
-                return false;
-        }
-
-        mxms_args[1] = wmi_wmmx_mxmi(dev, 0x00);
-        if (!mxms_args[1])
-                mxms_args[1] = wmi_wmmx_mxmi(dev, version);
-        if (!mxms_args[1])
-                return false;
-
-        status = wmi_evaluate_method(WMI_WMMX_GUID, 0, 0, &args, &retn);
-        if (ACPI_FAILURE(status)) {
-                MXM_DBG(dev, "WMMX MXMS returned %d\n", status);
-                return false;
-        }
-
-        obj = retn.pointer;
-        if (obj->type == ACPI_TYPE_BUFFER) {
-                dev_priv->mxms = kmemdup(obj->buffer.pointer,
-                                         obj->buffer.length, GFP_KERNEL);
-        }
-
-        kfree(obj);
-        return dev_priv->mxms != NULL;
-}
-#endif
-
-struct mxm_shadow_h {
-        const char *name;
-        bool (*exec)(struct drm_device *, u8 version);
-} _mxm_shadow[] = {
-        { "ROM", mxm_shadow_rom },
-#if defined(CONFIG_ACPI)
-        { "DSM", mxm_shadow_dsm },
-#endif
-#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
-        { "WMI", mxm_shadow_wmi },
-#endif
-        {}
-};
-
-static int
-mxm_shadow(struct drm_device *dev, u8 version)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct mxm_shadow_h *shadow = _mxm_shadow;
-        do {
-                MXM_DBG(dev, "checking %s\n", shadow->name);
-                if (shadow->exec(dev, version)) {
-                        if (mxms_valid(dev))
-                                return 0;
-                        kfree(dev_priv->mxms);
-                        dev_priv->mxms = NULL;
-                }
-        } while ((++shadow)->name);
-        return -ENOENT;
-}
-
-int
-nouveau_mxm_init(struct drm_device *dev)
-{
-        u8 mxm_size, *mxm = mxm_table(dev, &mxm_size);
-        if (!mxm || !mxm[0]) {
-                MXM_MSG(dev, "no VBIOS data, nothing to do\n");
-                return 0;
-        }
-
-        MXM_MSG(dev, "BIOS version %d.%d\n", mxm[0] >> 4, mxm[0] & 0x0f);
-
-        if (mxm_shadow(dev, mxm[0])) {
-                MXM_MSG(dev, "failed to locate valid SIS\n");
-#if 0
-                /* we should, perhaps, fall back to some kind of limited
-                 * mode here if the x86 vbios hasn't already done the
-                 * work for us (so we prevent loading with completely
-                 * whacked vbios tables).
-                 */
-                return -EINVAL;
-#else
-                return 0;
-#endif
-        }
-
-        MXM_MSG(dev, "MXMS Version %d.%d\n",
-                mxms_version(dev) >> 8, mxms_version(dev) & 0xff);
-        mxms_foreach(dev, 0, NULL, NULL);
-
-        if (nouveau_mxmdcb)
-                mxm_dcb_sanitise(dev);
-        return 0;
-}
-
-void
-nouveau_mxm_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        kfree(dev_priv->mxms);
-        dev_priv->mxms = NULL;
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_notifier.c b/drivers/gpu/drm/nouveau/nouveau_notifier.c
deleted file mode 100644
index 69c93b864519..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_notifier.c
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright (C) 2007 Ben Skeggs.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_ramht.h"
-
-int
-nouveau_notifier_init_channel(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_bo *ntfy = NULL;
-        uint32_t flags, ttmpl;
-        int ret;
-
-        if (nouveau_vram_notify) {
-                flags = NOUVEAU_GEM_DOMAIN_VRAM;
-                ttmpl = TTM_PL_FLAG_VRAM;
-        } else {
-                flags = NOUVEAU_GEM_DOMAIN_GART;
-                ttmpl = TTM_PL_FLAG_TT;
-        }
-
-        ret = nouveau_gem_new(dev, PAGE_SIZE, 0, flags, 0, 0, &ntfy);
-        if (ret)
-                return ret;
-
-        ret = nouveau_bo_pin(ntfy, ttmpl);
-        if (ret)
-                goto out_err;
-
-        ret = nouveau_bo_map(ntfy);
-        if (ret)
-                goto out_err;
-
-        if (dev_priv->card_type >= NV_50) {
-                ret = nouveau_bo_vma_add(ntfy, chan->vm, &chan->notifier_vma);
-                if (ret)
-                        goto out_err;
-        }
-
-        ret = drm_mm_init(&chan->notifier_heap, 0, ntfy->bo.mem.size);
-        if (ret)
-                goto out_err;
-
-        chan->notifier_bo = ntfy;
-out_err:
-        if (ret) {
-                nouveau_bo_vma_del(ntfy, &chan->notifier_vma);
-                drm_gem_object_unreference_unlocked(ntfy->gem);
-        }
-
-        return ret;
-}
-
-void
-nouveau_notifier_takedown_channel(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-
-        if (!chan->notifier_bo)
-                return;
-
-        nouveau_bo_vma_del(chan->notifier_bo, &chan->notifier_vma);
-        nouveau_bo_unmap(chan->notifier_bo);
-        mutex_lock(&dev->struct_mutex);
-        nouveau_bo_unpin(chan->notifier_bo);
-        mutex_unlock(&dev->struct_mutex);
-        drm_gem_object_unreference_unlocked(chan->notifier_bo->gem);
-        drm_mm_takedown(&chan->notifier_heap);
-}
-
-static void
-nouveau_notifier_gpuobj_dtor(struct drm_device *dev,
-                             struct nouveau_gpuobj *gpuobj)
-{
-        NV_DEBUG(dev, "\n");
-
-        if (gpuobj->priv)
-                drm_mm_put_block(gpuobj->priv);
-}
-
-int
-nouveau_notifier_alloc(struct nouveau_channel *chan, uint32_t handle,
-                       int size, uint32_t start, uint32_t end,
-                       uint32_t *b_offset)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *nobj = NULL;
-        struct drm_mm_node *mem;
-        uint64_t offset;
-        int target, ret;
-
-        mem = drm_mm_search_free_in_range(&chan->notifier_heap, size, 0,
-                                          start, end, 0);
-        if (mem)
-                mem = drm_mm_get_block_range(mem, size, 0, start, end);
-        if (!mem) {
-                NV_ERROR(dev, "Channel %d notifier block full\n", chan->id);
-                return -ENOMEM;
-        }
-
-        if (dev_priv->card_type < NV_50) {
-                if (chan->notifier_bo->bo.mem.mem_type == TTM_PL_VRAM)
-                        target = NV_MEM_TARGET_VRAM;
-                else
-                        target = NV_MEM_TARGET_GART;
-                offset  = chan->notifier_bo->bo.offset;
-        } else {
-                target = NV_MEM_TARGET_VM;
-                offset = chan->notifier_vma.offset;
-        }
-        offset += mem->start;
-
-        ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, offset,
-                                     mem->size, NV_MEM_ACCESS_RW, target,
-                                     &nobj);
-        if (ret) {
-                drm_mm_put_block(mem);
-                NV_ERROR(dev, "Error creating notifier ctxdma: %d\n", ret);
-                return ret;
-        }
-        nobj->dtor = nouveau_notifier_gpuobj_dtor;
-        nobj->priv = mem;
-
-        ret = nouveau_ramht_insert(chan, handle, nobj);
-        nouveau_gpuobj_ref(NULL, &nobj);
-        if (ret) {
-                drm_mm_put_block(mem);
-                NV_ERROR(dev, "Error adding notifier to ramht: %d\n", ret);
-                return ret;
-        }
-
-        *b_offset = mem->start;
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_perf.c b/drivers/gpu/drm/nouveau/nouveau_perf.c
index ea6acf1c4a78..a11d2e4f8f6e 100644
--- a/drivers/gpu/drm/nouveau/nouveau_perf.c
+++ b/drivers/gpu/drm/nouveau/nouveau_perf.c
@@ -24,14 +24,15 @@
 
 #include "drmP.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_pm.h"
 
 static u8 *
 nouveau_perf_table(struct drm_device *dev, u8 *ver)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         struct bit_entry P;
 
         if (!bit_table(dev, 'P', &P) && P.version && P.version <= 2) {
@@ -87,7 +88,7 @@ u8 *
 nouveau_perf_rammap(struct drm_device *dev, u32 freq,
                     u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct bit_entry P;
         u8 *perf, i = 0;
 
@@ -114,8 +115,8 @@ nouveau_perf_rammap(struct drm_device *dev, u32 freq,
                 return NULL;
         }
 
-        if (dev_priv->chipset == 0x49 ||
-            dev_priv->chipset == 0x4b)
+        if (nv_device(drm->device)->chipset == 0x49 ||
+            nv_device(drm->device)->chipset == 0x4b)
                 freq /= 2;
 
         while ((perf = nouveau_perf_entry(dev, i++, ver, hdr, cnt, len))) {
@@ -142,12 +143,13 @@ nouveau_perf_rammap(struct drm_device *dev, u32 freq,
 u8 *
 nouveau_perf_ramcfg(struct drm_device *dev, u32 freq, u8 *ver, u8 *len)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         u8 strap, hdr, cnt;
         u8 *rammap;
 
-        strap = (nv_rd32(dev, 0x101000) & 0x0000003c) >> 2;
+        strap = (nv_rd32(device, 0x101000) & 0x0000003c) >> 2;
         if (bios->ram_restrict_tbl_ptr)
                 strap = bios->data[bios->ram_restrict_tbl_ptr + strap];
 
@@ -161,8 +163,8 @@ nouveau_perf_ramcfg(struct drm_device *dev, u32 freq, u8 *ver, u8 *len)
 u8 *
 nouveau_perf_timing(struct drm_device *dev, u32 freq, u8 *ver, u8 *len)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
         struct bit_entry P;
         u8 *perf, *timing = NULL;
         u8 i = 0, hdr, cnt;
@@ -202,20 +204,21 @@ nouveau_perf_timing(struct drm_device *dev, u32 freq, u8 *ver, u8 *len)
 static void
 legacy_perf_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nvbios *bios = &drm->vbios;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         char *perf, *entry, *bmp = &bios->data[bios->offset];
         int headerlen, use_straps;
 
         if (bmp[5] < 0x5 || bmp[6] < 0x14) {
-                NV_DEBUG(dev, "BMP version too old for perf\n");
+                NV_DEBUG(drm, "BMP version too old for perf\n");
                 return;
         }
 
         perf = ROMPTR(dev, bmp[0x73]);
         if (!perf) {
-                NV_DEBUG(dev, "No memclock table pointer found.\n");
+                NV_DEBUG(drm, "No memclock table pointer found.\n");
                 return;
         }
 
@@ -231,13 +234,13 @@ legacy_perf_init(struct drm_device *dev)
                 headerlen = (use_straps ? 8 : 2);
                 break;
         default:
-                NV_WARN(dev, "Unknown memclock table version %x.\n", perf[0]);
+                NV_WARN(drm, "Unknown memclock table version %x.\n", perf[0]);
                 return;
         }
 
         entry = perf + headerlen;
         if (use_straps)
-                entry += (nv_rd32(dev, NV_PEXTDEV_BOOT_0) & 0x3c) >> 1;
+                entry += (nv_rd32(device, NV_PEXTDEV_BOOT_0) & 0x3c) >> 1;
 
         sprintf(pm->perflvl[0].name, "performance_level_0");
         pm->perflvl[0].memory = ROM16(entry[0]) * 20;
@@ -247,7 +250,7 @@ legacy_perf_init(struct drm_device *dev)
 static void
 nouveau_perf_voltage(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct bit_entry P;
         u8 *vmap;
         int id;
@@ -258,7 +261,7 @@ nouveau_perf_voltage(struct drm_device *dev, struct nouveau_pm_level *perflvl)
         /* boards using voltage table version <0x40 store the voltage
          * level directly in the perflvl entry as a multiple of 10mV
          */
-        if (dev_priv->engine.pm.voltage.version < 0x40) {
+        if (drm->pm->voltage.version < 0x40) {
                 perflvl->volt_min = id * 10000;
                 perflvl->volt_max = perflvl->volt_min;
                 return;
@@ -268,14 +271,14 @@ nouveau_perf_voltage(struct drm_device *dev, struct nouveau_pm_level *perflvl)
          * vbios table containing a min/max voltage value for the perflvl
          */
         if (bit_table(dev, 'P', &P) || P.version != 2 || P.length < 34) {
-                NV_DEBUG(dev, "where's our volt map table ptr? %d %d\n",
+                NV_DEBUG(drm, "where's our volt map table ptr? %d %d\n",
                          P.version, P.length);
                 return;
         }
 
         vmap = ROMPTR(dev, P.data[32]);
         if (!vmap) {
-                NV_DEBUG(dev, "volt map table pointer invalid\n");
+                NV_DEBUG(drm, "volt map table pointer invalid\n");
                 return;
         }
 
@@ -289,9 +292,9 @@ nouveau_perf_voltage(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 void
 nouveau_perf_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_pm *pm = nouveau_pm(dev);
+        struct nvbios *bios = &drm->vbios;
         u8 *perf, ver, hdr, cnt, len;
         int ret, vid, i = -1;
 
@@ -301,8 +304,6 @@ nouveau_perf_init(struct drm_device *dev)
         }
 
         perf = nouveau_perf_table(dev, &ver);
-        if (ver >= 0x20 && ver < 0x40)
-                pm->fan.pwm_divisor = ROM16(perf[6]);
 
         while ((perf = nouveau_perf_entry(dev, ++i, &ver, &hdr, &cnt, &len))) {
                 struct nouveau_pm_level *perflvl = &pm->perflvl[pm->nr_perflvl];
@@ -328,8 +329,8 @@ nouveau_perf_init(struct drm_device *dev)
                         perflvl->shader = ROM16(perf[6]) * 1000;
                         perflvl->core = perflvl->shader;
                         perflvl->core += (signed char)perf[8] * 1000;
-                        if (dev_priv->chipset == 0x49 ||
-                            dev_priv->chipset == 0x4b)
+                        if (nv_device(drm->device)->chipset == 0x49 ||
+                            nv_device(drm->device)->chipset == 0x4b)
                                 perflvl->memory = ROM16(perf[11]) * 1000;
                         else
                                 perflvl->memory = ROM16(perf[11]) * 2000;
@@ -356,7 +357,7 @@ nouveau_perf_init(struct drm_device *dev)
 #define subent(n) ((ROM16(perf[hdr + (n) * len]) & 0xfff) * 1000)
                         perflvl->fanspeed = 0; /*XXX*/
                         perflvl->volt_min = perf[2];
-                        if (dev_priv->card_type == NV_50) {
+                        if (nv_device(drm->device)->card_type == NV_50) {
                                 perflvl->core   = subent(0);
                                 perflvl->shader = subent(1);
                                 perflvl->memory = subent(2);
@@ -382,7 +383,7 @@ nouveau_perf_init(struct drm_device *dev)
                 if (pm->voltage.supported && perflvl->volt_min) {
                         vid = nouveau_volt_vid_lookup(dev, perflvl->volt_min);
                         if (vid < 0) {
-                                NV_DEBUG(dev, "perflvl %d, bad vid\n", i);
+                                NV_DEBUG(drm, "perflvl %d, bad vid\n", i);
                                 continue;
                         }
                 }
@@ -391,7 +392,7 @@ nouveau_perf_init(struct drm_device *dev)
                 ret = nouveau_mem_timing_calc(dev, perflvl->memory,
                                                   &perflvl->timing);
                 if (ret) {
-                        NV_DEBUG(dev, "perflvl %d, bad timing: %d\n", i, ret);
+                        NV_DEBUG(drm, "perflvl %d, bad timing: %d\n", i, ret);
                         continue;
                 }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_pm.c b/drivers/gpu/drm/nouveau/nouveau_pm.c
index da3e7c3abab7..b9d5335df742 100644
--- a/drivers/gpu/drm/nouveau/nouveau_pm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_pm.c
@@ -22,12 +22,6 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_pm.h"
-#include "nouveau_gpio.h"
-
 #ifdef CONFIG_ACPI
 #include <linux/acpi.h>
 #endif
@@ -35,85 +29,41 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 
-static int
-nouveau_pwmfan_get(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct gpio_func gpio;
-        u32 divs, duty;
-        int ret;
+#include "drmP.h"
 
-        if (!pm->pwm_get)
-                return -ENODEV;
+#include "nouveau_drm.h"
+#include "nouveau_pm.h"
 
-        ret = nouveau_gpio_find(dev, 0, DCB_GPIO_PWM_FAN, 0xff, &gpio);
-        if (ret == 0) {
-                ret = pm->pwm_get(dev, gpio.line, &divs, &duty);
-                if (ret == 0 && divs) {
-                        divs = max(divs, duty);
-                        if (dev_priv->card_type <= NV_40 || (gpio.log[0] & 1))
-                                duty = divs - duty;
-                        return (duty * 100) / divs;
-                }
+#include <subdev/gpio.h>
+#include <subdev/timer.h>
+#include <subdev/therm.h>
 
-                return nouveau_gpio_func_get(dev, gpio.func) * 100;
-        }
+MODULE_PARM_DESC(perflvl, "Performance level (default: boot)");
+static char *nouveau_perflvl;
+module_param_named(perflvl, nouveau_perflvl, charp, 0400);
 
-        return -ENODEV;
-}
-
-static int
-nouveau_pwmfan_set(struct drm_device *dev, int percent)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct gpio_func gpio;
-        u32 divs, duty;
-        int ret;
-
-        if (!pm->pwm_set)
-                return -ENODEV;
-
-        ret = nouveau_gpio_find(dev, 0, DCB_GPIO_PWM_FAN, 0xff, &gpio);
-        if (ret == 0) {
-                divs = pm->fan.pwm_divisor;
-                if (pm->fan.pwm_freq) {
-                        /*XXX: PNVIO clock more than likely... */
-                        divs = 135000 / pm->fan.pwm_freq;
-                        if (dev_priv->chipset < 0xa3)
-                                divs /= 4;
-                }
-
-                duty = ((divs * percent) + 99) / 100;
-                if (dev_priv->card_type <= NV_40 || (gpio.log[0] & 1))
-                        duty = divs - duty;
-
-                ret = pm->pwm_set(dev, gpio.line, divs, duty);
-                if (!ret)
-                        pm->fan.percent = percent;
-                return ret;
-        }
-
-        return -ENODEV;
-}
+MODULE_PARM_DESC(perflvl_wr, "Allow perflvl changes (warning: dangerous!)");
+static int nouveau_perflvl_wr;
+module_param_named(perflvl_wr, nouveau_perflvl_wr, int, 0400);
 
 static int
 nouveau_pm_perflvl_aux(struct drm_device *dev, struct nouveau_pm_level *perflvl,
                        struct nouveau_pm_level *a, struct nouveau_pm_level *b)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_pm *pm = nouveau_pm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm);
         int ret;
 
         /*XXX: not on all boards, we should control based on temperature
          *     on recent boards..  or maybe on some other factor we don't
          *     know about?
          */
-        if (a->fanspeed && b->fanspeed && b->fanspeed > a->fanspeed) {
-                ret = nouveau_pwmfan_set(dev, perflvl->fanspeed);
+        if (therm && therm->fan_set &&
+                a->fanspeed && b->fanspeed && b->fanspeed > a->fanspeed) {
+                ret = therm->fan_set(therm, perflvl->fanspeed);
                 if (ret && ret != -ENODEV) {
-                        NV_ERROR(dev, "fanspeed set failed: %d\n", ret);
+                        NV_ERROR(drm, "fanspeed set failed: %d\n", ret);
                         return ret;
                 }
         }
@@ -122,7 +72,7 @@ nouveau_pm_perflvl_aux(struct drm_device *dev, struct nouveau_pm_level *perflvl,
                 if (perflvl->volt_min && b->volt_min > a->volt_min) {
                         ret = pm->voltage_set(dev, perflvl->volt_min);
                         if (ret) {
-                                NV_ERROR(dev, "voltage set failed: %d\n", ret);
+                                NV_ERROR(drm, "voltage set failed: %d\n", ret);
                                 return ret;
                         }
                 }
@@ -134,8 +84,7 @@ nouveau_pm_perflvl_aux(struct drm_device *dev, struct nouveau_pm_level *perflvl,
 static int
 nouveau_pm_perflvl_set(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         void *state;
         int ret;
 
@@ -171,8 +120,9 @@ error:
 void
 nouveau_pm_trigger(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_timer *ptimer = nouveau_timer(drm->device);
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_profile *profile = NULL;
         struct nouveau_pm_level *perflvl = NULL;
         int ret;
@@ -194,24 +144,22 @@ nouveau_pm_trigger(struct drm_device *dev)
 
         /* change perflvl, if necessary */
         if (perflvl != pm->cur) {
-                struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
-                u64 time0 = ptimer->read(dev);
+                u64 time0 = ptimer->read(ptimer);
 
-                NV_INFO(dev, "setting performance level: %d", perflvl->id);
+                NV_INFO(drm, "setting performance level: %d", perflvl->id);
                 ret = nouveau_pm_perflvl_set(dev, perflvl);
                 if (ret)
-                        NV_INFO(dev, "> reclocking failed: %d\n\n", ret);
+                        NV_INFO(drm, "> reclocking failed: %d\n\n", ret);
 
-                NV_INFO(dev, "> reclocking took %lluns\n\n",
-                             ptimer->read(dev) - time0);
+                NV_INFO(drm, "> reclocking took %lluns\n\n",
+                             ptimer->read(ptimer) - time0);
         }
 }
 
 static struct nouveau_pm_profile *
 profile_find(struct drm_device *dev, const char *string)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_profile *profile;
 
         list_for_each_entry(profile, &pm->profiles, head) {
@@ -225,8 +173,7 @@ profile_find(struct drm_device *dev, const char *string)
 static int
 nouveau_pm_profile_set(struct drm_device *dev, const char *profile)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_profile *ac = NULL, *dc = NULL;
         char string[16], *cur = string, *ptr;
 
@@ -279,8 +226,9 @@ const struct nouveau_pm_profile_func nouveau_pm_static_profile_func = {
 static int
 nouveau_pm_perflvl_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_pm *pm = nouveau_pm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         int ret;
 
         memset(perflvl, 0, sizeof(*perflvl));
@@ -299,9 +247,11 @@ nouveau_pm_perflvl_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
                 }
         }
 
-        ret = nouveau_pwmfan_get(dev);
-        if (ret > 0)
-                perflvl->fanspeed = ret;
+        if (therm && therm->fan_get) {
+                ret = therm->fan_get(therm);
+                if (ret >= 0)
+                        perflvl->fanspeed = ret;
+        }
 
         nouveau_mem_timing_read(dev, &perflvl->timing);
         return 0;
@@ -362,8 +312,7 @@ static ssize_t
 nouveau_pm_get_perflvl(struct device *d, struct device_attribute *a, char *buf)
 {
         struct drm_device *dev = pci_get_drvdata(to_pci_dev(d));
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_level cur;
         int len = PAGE_SIZE, ret;
         char *ptr = buf;
@@ -398,8 +347,8 @@ static DEVICE_ATTR(performance_level, S_IRUGO | S_IWUSR,
 static int
 nouveau_sysfs_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct device *d = &dev->pdev->dev;
         int ret, i;
 
@@ -418,7 +367,7 @@ nouveau_sysfs_init(struct drm_device *dev)
 
                 ret = device_create_file(d, &perflvl->dev_attr);
                 if (ret) {
-                        NV_ERROR(dev, "failed pervlvl %d sysfs: %d\n",
+                        NV_ERROR(drm, "failed pervlvl %d sysfs: %d\n",
                                  perflvl->id, i);
                         perflvl->dev_attr.attr.name = NULL;
                         nouveau_pm_fini(dev);
@@ -432,8 +381,7 @@ nouveau_sysfs_init(struct drm_device *dev)
 static void
 nouveau_sysfs_fini(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct device *d = &dev->pdev->dev;
         int i;
 
@@ -453,10 +401,10 @@ static ssize_t
 nouveau_hwmon_show_temp(struct device *d, struct device_attribute *a, char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
 
-        return snprintf(buf, PAGE_SIZE, "%d\n", pm->temp_get(dev)*1000);
+        return snprintf(buf, PAGE_SIZE, "%d\n", therm->temp_get(therm) * 1000);
 }
 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, nouveau_hwmon_show_temp,
                                                   NULL, 0);
@@ -465,28 +413,25 @@ static ssize_t
 nouveau_hwmon_max_temp(struct device *d, struct device_attribute *a, char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
 
-        return snprintf(buf, PAGE_SIZE, "%d\n", temp->down_clock*1000);
+        return snprintf(buf, PAGE_SIZE, "%d\n",
+               therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK) * 1000);
 }
 static ssize_t
 nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a,
                                                 const char *buf, size_t count)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         long value;
 
         if (kstrtol(buf, 10, &value) == -EINVAL)
                 return count;
 
-        temp->down_clock = value/1000;
-
-        nouveau_temp_safety_checks(dev);
+        therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK, value / 1000);
 
         return count;
 }
@@ -499,11 +444,11 @@ nouveau_hwmon_critical_temp(struct device *d, struct device_attribute *a,
                                                         char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
 
-        return snprintf(buf, PAGE_SIZE, "%d\n", temp->critical*1000);
+        return snprintf(buf, PAGE_SIZE, "%d\n",
+               therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL) * 1000);
 }
 static ssize_t
 nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a,
@@ -511,17 +456,14 @@ nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a,
                                                                 size_t count)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_threshold_temp *temp = &pm->threshold_temp;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         long value;
 
         if (kstrtol(buf, 10, &value) == -EINVAL)
                 return count;
 
-        temp->critical = value/1000;
-
-        nouveau_temp_safety_checks(dev);
+        therm->attr_set(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL, value / 1000);
 
         return count;
 }
@@ -553,47 +495,62 @@ nouveau_hwmon_show_fan0_input(struct device *d, struct device_attribute *attr,
                               char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
-        struct gpio_func gpio;
-        u32 cycles, cur, prev;
-        u64 start;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", therm->fan_sense(therm));
+}
+static SENSOR_DEVICE_ATTR(fan0_input, S_IRUGO, nouveau_hwmon_show_fan0_input,
+                          NULL, 0);
+
+ static ssize_t
+nouveau_hwmon_get_pwm1_enable(struct device *d,
+                           struct device_attribute *a, char *buf)
+{
+        struct drm_device *dev = dev_get_drvdata(d);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         int ret;
 
-        ret = nouveau_gpio_find(dev, 0, DCB_GPIO_FAN_SENSE, 0xff, &gpio);
-        if (ret)
+        ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MODE);
+        if (ret < 0)
                 return ret;
 
-        /* Monitor the GPIO input 0x3b for 250ms.
-         * When the fan spins, it changes the value of GPIO FAN_SENSE.
-         * We get 4 changes (0 -> 1 -> 0 -> 1 -> [...]) per complete rotation.
-         */
-        start = ptimer->read(dev);
-        prev = nouveau_gpio_sense(dev, 0, gpio.line);
-        cycles = 0;
-        do {
-                cur = nouveau_gpio_sense(dev, 0, gpio.line);
-                if (prev != cur) {
-                        cycles++;
-                        prev = cur;
-                }
+        return sprintf(buf, "%i\n", ret);
+}
 
-                usleep_range(500, 1000); /* supports 0 < rpm < 7500 */
-        } while (ptimer->read(dev) - start < 250000000);
+static ssize_t
+nouveau_hwmon_set_pwm1_enable(struct device *d, struct device_attribute *a,
+                           const char *buf, size_t count)
+{
+        struct drm_device *dev = dev_get_drvdata(d);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
+        long value;
+        int ret;
+
+        if (strict_strtol(buf, 10, &value) == -EINVAL)
+                return -EINVAL;
 
-        /* interpolate to get rpm */
-        return sprintf(buf, "%i\n", cycles / 4 * 4 * 60);
+        ret = therm->attr_set(therm, NOUVEAU_THERM_ATTR_FAN_MODE, value);
+        if (ret)
+                return ret;
+        else
+                return count;
 }
-static SENSOR_DEVICE_ATTR(fan0_input, S_IRUGO, nouveau_hwmon_show_fan0_input,
-                          NULL, 0);
+static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
+                          nouveau_hwmon_get_pwm1_enable,
+                          nouveau_hwmon_set_pwm1_enable, 0);
 
 static ssize_t
-nouveau_hwmon_get_pwm0(struct device *d, struct device_attribute *a, char *buf)
+nouveau_hwmon_get_pwm1(struct device *d, struct device_attribute *a, char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         int ret;
 
-        ret = nouveau_pwmfan_get(dev);
+        ret = therm->fan_get(therm);
         if (ret < 0)
                 return ret;
 
@@ -601,12 +558,12 @@ nouveau_hwmon_get_pwm0(struct device *d, struct device_attribute *a, char *buf)
 }
 
 static ssize_t
-nouveau_hwmon_set_pwm0(struct device *d, struct device_attribute *a,
+nouveau_hwmon_set_pwm1(struct device *d, struct device_attribute *a,
                        const char *buf, size_t count)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         int ret = -ENODEV;
         long value;
 
@@ -616,103 +573,96 @@ nouveau_hwmon_set_pwm0(struct device *d, struct device_attribute *a,
         if (kstrtol(buf, 10, &value) == -EINVAL)
                 return -EINVAL;
 
-        if (value < pm->fan.min_duty)
-                value = pm->fan.min_duty;
-        if (value > pm->fan.max_duty)
-                value = pm->fan.max_duty;
-
-        ret = nouveau_pwmfan_set(dev, value);
+        ret = therm->fan_set(therm, value);
         if (ret)
                 return ret;
 
         return count;
 }
 
-static SENSOR_DEVICE_ATTR(pwm0, S_IRUGO | S_IWUSR,
-                          nouveau_hwmon_get_pwm0,
-                          nouveau_hwmon_set_pwm0, 0);
+static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR,
+                          nouveau_hwmon_get_pwm1,
+                          nouveau_hwmon_set_pwm1, 0);
 
 static ssize_t
-nouveau_hwmon_get_pwm0_min(struct device *d,
+nouveau_hwmon_get_pwm1_min(struct device *d,
                            struct device_attribute *a, char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
+        int ret;
+
+        ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY);
+        if (ret < 0)
+                return ret;
 
-        return sprintf(buf, "%i\n", pm->fan.min_duty);
+        return sprintf(buf, "%i\n", ret);
 }
 
 static ssize_t
-nouveau_hwmon_set_pwm0_min(struct device *d, struct device_attribute *a,
+nouveau_hwmon_set_pwm1_min(struct device *d, struct device_attribute *a,
                            const char *buf, size_t count)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         long value;
+        int ret;
 
         if (kstrtol(buf, 10, &value) == -EINVAL)
                 return -EINVAL;
 
-        if (value < 0)
-                value = 0;
-
-        if (pm->fan.max_duty - value < 10)
-                value = pm->fan.max_duty - 10;
-
-        if (value < 10)
-                pm->fan.min_duty = 10;
-        else
-                pm->fan.min_duty = value;
+        ret = therm->attr_set(therm, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY, value);
+        if (ret < 0)
+                return ret;
 
         return count;
 }
 
-static SENSOR_DEVICE_ATTR(pwm0_min, S_IRUGO | S_IWUSR,
-                          nouveau_hwmon_get_pwm0_min,
-                          nouveau_hwmon_set_pwm0_min, 0);
+static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO | S_IWUSR,
+                          nouveau_hwmon_get_pwm1_min,
+                          nouveau_hwmon_set_pwm1_min, 0);
 
 static ssize_t
-nouveau_hwmon_get_pwm0_max(struct device *d,
+nouveau_hwmon_get_pwm1_max(struct device *d,
                            struct device_attribute *a, char *buf)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
+        int ret;
+
+        ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY);
+        if (ret < 0)
+                return ret;
 
-        return sprintf(buf, "%i\n", pm->fan.max_duty);
+        return sprintf(buf, "%i\n", ret);
 }
 
 static ssize_t
-nouveau_hwmon_set_pwm0_max(struct device *d, struct device_attribute *a,
+nouveau_hwmon_set_pwm1_max(struct device *d, struct device_attribute *a,
                            const char *buf, size_t count)
 {
         struct drm_device *dev = dev_get_drvdata(d);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
         long value;
+        int ret;
 
         if (kstrtol(buf, 10, &value) == -EINVAL)
                 return -EINVAL;
 
-        if (value < 0)
-                value = 0;
-
-        if (value - pm->fan.min_duty < 10)
-                value = pm->fan.min_duty + 10;
-
-        if (value > 100)
-                pm->fan.max_duty = 100;
-        else
-                pm->fan.max_duty = value;
+        ret = therm->attr_set(therm, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY, value);
+        if (ret < 0)
+                return ret;
 
         return count;
 }
 
-static SENSOR_DEVICE_ATTR(pwm0_max, S_IRUGO | S_IWUSR,
-                          nouveau_hwmon_get_pwm0_max,
-                          nouveau_hwmon_set_pwm0_max, 0);
+static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO | S_IWUSR,
+                          nouveau_hwmon_get_pwm1_max,
+                          nouveau_hwmon_set_pwm1_max, 0);
 
 static struct attribute *hwmon_attributes[] = {
         &sensor_dev_attr_temp1_input.dev_attr.attr,
@@ -727,9 +677,10 @@ static struct attribute *hwmon_fan_rpm_attributes[] = {
         NULL
 };
 static struct attribute *hwmon_pwm_fan_attributes[] = {
-        &sensor_dev_attr_pwm0.dev_attr.attr,
-        &sensor_dev_attr_pwm0_min.dev_attr.attr,
-        &sensor_dev_attr_pwm0_max.dev_attr.attr,
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_pwm1_min.dev_attr.attr,
+        &sensor_dev_attr_pwm1_max.dev_attr.attr,
         NULL
 };
 
@@ -747,20 +698,22 @@ static const struct attribute_group hwmon_pwm_fan_attrgroup = {
 static int
 nouveau_hwmon_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_therm *therm = nouveau_therm(drm->device);
+
 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
         struct device *hwmon_dev;
         int ret = 0;
 
-        if (!pm->temp_get)
+        if (!therm || !therm->temp_get || !therm->attr_get ||
+                !therm->attr_set || therm->temp_get(therm) < 0)
                 return -ENODEV;
 
         hwmon_dev = hwmon_device_register(&dev->pdev->dev);
         if (IS_ERR(hwmon_dev)) {
                 ret = PTR_ERR(hwmon_dev);
-                NV_ERROR(dev,
-                        "Unable to register hwmon device: %d\n", ret);
+                NV_ERROR(drm, "Unable to register hwmon device: %d\n", ret);
                 return ret;
         }
         dev_set_drvdata(hwmon_dev, dev);
@@ -776,7 +729,7 @@ nouveau_hwmon_init(struct drm_device *dev)
         /*XXX: incorrect, need better detection for this, some boards have
          *     the gpio entries for pwm fan control even when there's no
          *     actual fan connected to it... therm table? */
-        if (nouveau_pwmfan_get(dev) >= 0) {
+        if (therm->fan_get && therm->fan_get(therm) >= 0) {
                 ret = sysfs_create_group(&dev->pdev->dev.kobj,
                                          &hwmon_pwm_fan_attrgroup);
                 if (ret)
@@ -784,7 +737,7 @@ nouveau_hwmon_init(struct drm_device *dev)
         }
 
         /* if the card can read the fan rpm */
-        if (nouveau_gpio_func_valid(dev, DCB_GPIO_FAN_SENSE)) {
+        if (therm->fan_sense(therm) >= 0) {
                 ret = sysfs_create_group(&dev->pdev->dev.kobj,
                                          &hwmon_fan_rpm_attrgroup);
                 if (ret)
@@ -796,7 +749,7 @@ nouveau_hwmon_init(struct drm_device *dev)
         return 0;
 
 error:
-        NV_ERROR(dev, "Unable to create some hwmon sysfs files: %d\n", ret);
+        NV_ERROR(drm, "Unable to create some hwmon sysfs files: %d\n", ret);
         hwmon_device_unregister(hwmon_dev);
         pm->hwmon = NULL;
         return ret;
@@ -810,8 +763,7 @@ static void
 nouveau_hwmon_fini(struct drm_device *dev)
 {
 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
 
         if (pm->hwmon) {
                 sysfs_remove_group(&dev->pdev->dev.kobj, &hwmon_attrgroup);
@@ -829,16 +781,15 @@ nouveau_hwmon_fini(struct drm_device *dev)
 static int
 nouveau_pm_acpi_event(struct notifier_block *nb, unsigned long val, void *data)
 {
-        struct drm_nouveau_private *dev_priv =
-                container_of(nb, struct drm_nouveau_private, engine.pm.acpi_nb);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_pm *pm = container_of(nb, struct nouveau_pm, acpi_nb);
+        struct nouveau_drm *drm = nouveau_drm(pm->dev);
         struct acpi_bus_event *entry = (struct acpi_bus_event *)data;
 
         if (strcmp(entry->device_class, "ac_adapter") == 0) {
                 bool ac = power_supply_is_system_supplied();
 
-                NV_DEBUG(dev, "power supply changed: %s\n", ac ? "AC" : "DC");
-                nouveau_pm_trigger(dev);
+                NV_DEBUG(drm, "power supply changed: %s\n", ac ? "AC" : "DC");
+                nouveau_pm_trigger(pm->dev);
         }
 
         return NOTIFY_OK;
@@ -848,19 +799,67 @@ nouveau_pm_acpi_event(struct notifier_block *nb, unsigned long val, void *data)
 int
 nouveau_pm_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_pm *pm;
         char info[256];
         int ret, i;
 
+        pm = drm->pm = kzalloc(sizeof(*pm), GFP_KERNEL);
+        if (!pm)
+                return -ENOMEM;
+
+        pm->dev = dev;
+
+        if (device->card_type < NV_40) {
+                pm->clocks_get = nv04_pm_clocks_get;
+                pm->clocks_pre = nv04_pm_clocks_pre;
+                pm->clocks_set = nv04_pm_clocks_set;
+                if (nouveau_gpio(drm->device)) {
+                        pm->voltage_get = nouveau_voltage_gpio_get;
+                        pm->voltage_set = nouveau_voltage_gpio_set;
+                }
+        } else
+        if (device->card_type < NV_50) {
+                pm->clocks_get = nv40_pm_clocks_get;
+                pm->clocks_pre = nv40_pm_clocks_pre;
+                pm->clocks_set = nv40_pm_clocks_set;
+                pm->voltage_get = nouveau_voltage_gpio_get;
+                pm->voltage_set = nouveau_voltage_gpio_set;
+        } else
+        if (device->card_type < NV_C0) {
+                if (device->chipset <  0xa3 ||
+                    device->chipset == 0xaa ||
+                    device->chipset == 0xac) {
+                        pm->clocks_get = nv50_pm_clocks_get;
+                        pm->clocks_pre = nv50_pm_clocks_pre;
+                        pm->clocks_set = nv50_pm_clocks_set;
+                } else {
+                        pm->clocks_get = nva3_pm_clocks_get;
+                        pm->clocks_pre = nva3_pm_clocks_pre;
+                        pm->clocks_set = nva3_pm_clocks_set;
+                }
+                pm->voltage_get = nouveau_voltage_gpio_get;
+                pm->voltage_set = nouveau_voltage_gpio_set;
+        } else
+        if (device->card_type < NV_E0) {
+                pm->clocks_get = nvc0_pm_clocks_get;
+                pm->clocks_pre = nvc0_pm_clocks_pre;
+                pm->clocks_set = nvc0_pm_clocks_set;
+                pm->voltage_get = nouveau_voltage_gpio_get;
+                pm->voltage_set = nouveau_voltage_gpio_set;
+        }
+
+
         /* parse aux tables from vbios */
         nouveau_volt_init(dev);
-        nouveau_temp_init(dev);
+
+        INIT_LIST_HEAD(&pm->profiles);
 
         /* determine current ("boot") performance level */
         ret = nouveau_pm_perflvl_get(dev, &pm->boot);
         if (ret) {
-                NV_ERROR(dev, "failed to determine boot perflvl\n");
+                NV_ERROR(drm, "failed to determine boot perflvl\n");
                 return ret;
         }
 
@@ -868,7 +867,6 @@ nouveau_pm_init(struct drm_device *dev)
         strncpy(pm->boot.profile.name, "boot", 4);
         pm->boot.profile.func = &nouveau_pm_static_profile_func;
 
-        INIT_LIST_HEAD(&pm->profiles);
         list_add(&pm->boot.profile.head, &pm->profiles);
 
         pm->profile_ac = &pm->boot.profile;
@@ -880,22 +878,19 @@ nouveau_pm_init(struct drm_device *dev)
         nouveau_perf_init(dev);
 
         /* display available performance levels */
-        NV_INFO(dev, "%d available performance level(s)\n", pm->nr_perflvl);
+        NV_INFO(drm, "%d available performance level(s)\n", pm->nr_perflvl);
         for (i = 0; i < pm->nr_perflvl; i++) {
                 nouveau_pm_perflvl_info(&pm->perflvl[i], info, sizeof(info));
-                NV_INFO(dev, "%d:%s", pm->perflvl[i].id, info);
+                NV_INFO(drm, "%d:%s", pm->perflvl[i].id, info);
         }
 
         nouveau_pm_perflvl_info(&pm->boot, info, sizeof(info));
-        NV_INFO(dev, "c:%s", info);
+        NV_INFO(drm, "c:%s", info);
 
         /* switch performance levels now if requested */
         if (nouveau_perflvl != NULL)
                 nouveau_pm_profile_set(dev, nouveau_perflvl);
 
-        /* determine the current fan speed */
-        pm->fan.percent = nouveau_pwmfan_get(dev);
-
         nouveau_sysfs_init(dev);
         nouveau_hwmon_init(dev);
 #if defined(CONFIG_ACPI) && defined(CONFIG_POWER_SUPPLY)
@@ -909,8 +904,7 @@ nouveau_pm_init(struct drm_device *dev)
 void
 nouveau_pm_fini(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_profile *profile, *tmp;
 
         list_for_each_entry_safe(profile, tmp, &pm->profiles, head) {
@@ -921,7 +915,6 @@ nouveau_pm_fini(struct drm_device *dev)
         if (pm->cur != &pm->boot)
                 nouveau_pm_perflvl_set(dev, &pm->boot);
 
-        nouveau_temp_fini(dev);
         nouveau_perf_fini(dev);
         nouveau_volt_fini(dev);
 
@@ -930,13 +923,15 @@ nouveau_pm_fini(struct drm_device *dev)
 #endif
         nouveau_hwmon_fini(dev);
         nouveau_sysfs_fini(dev);
+
+        nouveau_drm(dev)->pm = NULL;
+        kfree(pm);
 }
 
 void
 nouveau_pm_resume(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_level *perflvl;
 
         if (!pm->cur || pm->cur == &pm->boot)
@@ -945,5 +940,4 @@ nouveau_pm_resume(struct drm_device *dev)
         perflvl = pm->cur;
         pm->cur = &pm->boot;
         nouveau_pm_perflvl_set(dev, perflvl);
-        nouveau_pwmfan_set(dev, pm->fan.percent);
 }
diff --git a/drivers/gpu/drm/nouveau/nouveau_pm.h b/drivers/gpu/drm/nouveau/nouveau_pm.h
index 07cac72c72b4..73b789c230a9 100644
--- a/drivers/gpu/drm/nouveau/nouveau_pm.h
+++ b/drivers/gpu/drm/nouveau/nouveau_pm.h
@@ -25,6 +25,165 @@
 #ifndef __NOUVEAU_PM_H__
 #define __NOUVEAU_PM_H__
 
+#include <subdev/bios/pll.h>
+#include <subdev/clock.h>
+
+struct nouveau_pm_voltage_level {
+        u32 voltage; /* microvolts */
+        u8  vid;
+};
+
+struct nouveau_pm_voltage {
+        bool supported;
+        u8 version;
+        u8 vid_mask;
+
+        struct nouveau_pm_voltage_level *level;
+        int nr_level;
+};
+
+/* Exclusive upper limits */
+#define NV_MEM_CL_DDR2_MAX 8
+#define NV_MEM_WR_DDR2_MAX 9
+#define NV_MEM_CL_DDR3_MAX 17
+#define NV_MEM_WR_DDR3_MAX 17
+#define NV_MEM_CL_GDDR3_MAX 16
+#define NV_MEM_WR_GDDR3_MAX 18
+#define NV_MEM_CL_GDDR5_MAX 21
+#define NV_MEM_WR_GDDR5_MAX 20
+
+struct nouveau_pm_memtiming {
+        int id;
+
+        u32 reg[9];
+        u32 mr[4];
+
+        u8 tCWL;
+
+        u8 odt;
+        u8 drive_strength;
+};
+
+struct nouveau_pm_tbl_header {
+        u8 version;
+        u8 header_len;
+        u8 entry_cnt;
+        u8 entry_len;
+};
+
+struct nouveau_pm_tbl_entry {
+        u8 tWR;
+        u8 tWTR;
+        u8 tCL;
+        u8 tRC;
+        u8 empty_4;
+        u8 tRFC;        /* Byte 5 */
+        u8 empty_6;
+        u8 tRAS;        /* Byte 7 */
+        u8 empty_8;
+        u8 tRP;         /* Byte 9 */
+        u8 tRCDRD;
+        u8 tRCDWR;
+        u8 tRRD;
+        u8 tUNK_13;
+        u8 RAM_FT1;             /* 14, a bitmask of random RAM features */
+        u8 empty_15;
+        u8 tUNK_16;
+        u8 empty_17;
+        u8 tUNK_18;
+        u8 tCWL;
+        u8 tUNK_20, tUNK_21;
+};
+
+struct nouveau_pm_profile;
+struct nouveau_pm_profile_func {
+        void (*destroy)(struct nouveau_pm_profile *);
+        void (*init)(struct nouveau_pm_profile *);
+        void (*fini)(struct nouveau_pm_profile *);
+        struct nouveau_pm_level *(*select)(struct nouveau_pm_profile *);
+};
+
+struct nouveau_pm_profile {
+        const struct nouveau_pm_profile_func *func;
+        struct list_head head;
+        char name[8];
+};
+
+#define NOUVEAU_PM_MAX_LEVEL 8
+struct nouveau_pm_level {
+        struct nouveau_pm_profile profile;
+        struct device_attribute dev_attr;
+        char name[32];
+        int id;
+
+        struct nouveau_pm_memtiming timing;
+        u32 memory;
+        u16 memscript;
+
+        u32 core;
+        u32 shader;
+        u32 rop;
+        u32 copy;
+        u32 daemon;
+        u32 vdec;
+        u32 dom6;
+        u32 unka0;      /* nva3:nvc0 */
+        u32 hub01;      /* nvc0- */
+        u32 hub06;      /* nvc0- */
+        u32 hub07;      /* nvc0- */
+
+        u32 volt_min; /* microvolts */
+        u32 volt_max;
+        u8  fanspeed;
+};
+
+struct nouveau_pm_temp_sensor_constants {
+        u16 offset_constant;
+        s16 offset_mult;
+        s16 offset_div;
+        s16 slope_mult;
+        s16 slope_div;
+};
+
+struct nouveau_pm_threshold_temp {
+        s16 critical;
+        s16 down_clock;
+};
+
+struct nouveau_pm {
+        struct drm_device *dev;
+
+        struct nouveau_pm_voltage voltage;
+        struct nouveau_pm_level perflvl[NOUVEAU_PM_MAX_LEVEL];
+        int nr_perflvl;
+        struct nouveau_pm_temp_sensor_constants sensor_constants;
+        struct nouveau_pm_threshold_temp threshold_temp;
+
+        struct nouveau_pm_profile *profile_ac;
+        struct nouveau_pm_profile *profile_dc;
+        struct nouveau_pm_profile *profile;
+        struct list_head profiles;
+
+        struct nouveau_pm_level boot;
+        struct nouveau_pm_level *cur;
+
+        struct device *hwmon;
+        struct notifier_block acpi_nb;
+
+        int  (*clocks_get)(struct drm_device *, struct nouveau_pm_level *);
+        void *(*clocks_pre)(struct drm_device *, struct nouveau_pm_level *);
+        int (*clocks_set)(struct drm_device *, void *);
+
+        int (*voltage_get)(struct drm_device *);
+        int (*voltage_set)(struct drm_device *, int voltage);
+};
+
+static inline struct nouveau_pm *
+nouveau_pm(struct drm_device *dev)
+{
+        return nouveau_drm(dev)->pm;
+}
+
 struct nouveau_mem_exec_func {
         struct drm_device *dev;
         void (*precharge)(struct nouveau_mem_exec_func *);
@@ -99,11 +258,26 @@ int nvc0_pm_clocks_get(struct drm_device *, struct nouveau_pm_level *);
 void *nvc0_pm_clocks_pre(struct drm_device *, struct nouveau_pm_level *);
 int nvc0_pm_clocks_set(struct drm_device *, void *);
 
-/* nouveau_temp.c */
-void nouveau_temp_init(struct drm_device *dev);
-void nouveau_temp_fini(struct drm_device *dev);
-void nouveau_temp_safety_checks(struct drm_device *dev);
-int nv40_temp_get(struct drm_device *dev);
-int nv84_temp_get(struct drm_device *dev);
+/* nouveau_mem.c */
+int  nouveau_mem_timing_calc(struct drm_device *, u32 freq,
+                             struct nouveau_pm_memtiming *);
+void nouveau_mem_timing_read(struct drm_device *,
+                             struct nouveau_pm_memtiming *);
+
+static inline int
+nva3_calc_pll(struct drm_device *dev, struct nvbios_pll *pll, u32 freq,
+              int *N, int *fN, int *M, int *P)
+{
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_clock *clk = nouveau_clock(device);
+        struct nouveau_pll_vals pv;
+        int ret;
+
+        ret = clk->pll_calc(clk, pll, freq, &pv);
+        *N = pv.N1;
+        *M = pv.M1;
+        *P = pv.log2P;
+        return ret;
+}
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_prime.c b/drivers/gpu/drm/nouveau/nouveau_prime.c
index a25cf2cb931f..4ffa655545e5 100644
--- a/drivers/gpu/drm/nouveau/nouveau_prime.c
+++ b/drivers/gpu/drm/nouveau/nouveau_prime.c
@@ -22,14 +22,13 @@
  * Authors: Dave Airlie
  */
 
+#include <linux/dma-buf.h>
+
 #include "drmP.h"
 #include "drm.h"
 
-#include "nouveau_drv.h"
 #include "nouveau_drm.h"
-#include "nouveau_dma.h"
-
-#include <linux/dma-buf.h>
+#include "nouveau_gem.h"
 
 static struct sg_table *nouveau_gem_map_dma_buf(struct dma_buf_attachment *attachment,
                                           enum dma_data_direction dir)
diff --git a/drivers/gpu/drm/nouveau/nouveau_ramht.c b/drivers/gpu/drm/nouveau/nouveau_ramht.c
deleted file mode 100644
index a24a81f5a89e..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_ramht.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * 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"
-#include "nouveau_ramht.h"
-
-static u32
-nouveau_ramht_hash_handle(struct nouveau_channel *chan, u32 handle)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_ramht *ramht = chan->ramht;
-        u32 hash = 0;
-        int i;
-
-        NV_DEBUG(dev, "ch%d handle=0x%08x\n", chan->id, handle);
-
-        for (i = 32; i > 0; i -= ramht->bits) {
-                hash ^= (handle & ((1 << ramht->bits) - 1));
-                handle >>= ramht->bits;
-        }
-
-        if (dev_priv->card_type < NV_50)
-                hash ^= chan->id << (ramht->bits - 4);
-        hash <<= 3;
-
-        NV_DEBUG(dev, "hash=0x%08x\n", hash);
-        return hash;
-}
-
-static int
-nouveau_ramht_entry_valid(struct drm_device *dev, struct nouveau_gpuobj *ramht,
-                          u32 offset)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 ctx = nv_ro32(ramht, offset + 4);
-
-        if (dev_priv->card_type < NV_40)
-                return ((ctx & NV_RAMHT_CONTEXT_VALID) != 0);
-        return (ctx != 0);
-}
-
-static int
-nouveau_ramht_entry_same_channel(struct nouveau_channel *chan,
-                                 struct nouveau_gpuobj *ramht, u32 offset)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        u32 ctx = nv_ro32(ramht, offset + 4);
-
-        if (dev_priv->card_type >= NV_50)
-                return true;
-        else if (dev_priv->card_type >= NV_40)
-                return chan->id ==
-                        ((ctx >> NV40_RAMHT_CONTEXT_CHANNEL_SHIFT) & 0x1f);
-        else
-                return chan->id ==
-                        ((ctx >> NV_RAMHT_CONTEXT_CHANNEL_SHIFT) & 0x1f);
-}
-
-int
-nouveau_ramht_insert(struct nouveau_channel *chan, u32 handle,
-                     struct nouveau_gpuobj *gpuobj)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *instmem = &dev_priv->engine.instmem;
-        struct nouveau_ramht_entry *entry;
-        struct nouveau_gpuobj *ramht = chan->ramht->gpuobj;
-        unsigned long flags;
-        u32 ctx, co, ho;
-
-        if (nouveau_ramht_find(chan, handle))
-                return -EEXIST;
-
-        entry = kmalloc(sizeof(*entry), GFP_KERNEL);
-        if (!entry)
-                return -ENOMEM;
-        entry->channel = chan;
-        entry->gpuobj = NULL;
-        entry->handle = handle;
-        nouveau_gpuobj_ref(gpuobj, &entry->gpuobj);
-
-        if (dev_priv->card_type < NV_40) {
-                ctx = NV_RAMHT_CONTEXT_VALID | (gpuobj->pinst >> 4) |
-                      (chan->id << NV_RAMHT_CONTEXT_CHANNEL_SHIFT) |
-                      (gpuobj->engine << NV_RAMHT_CONTEXT_ENGINE_SHIFT);
-        } else
-        if (dev_priv->card_type < NV_50) {
-                ctx = (gpuobj->pinst >> 4) |
-                      (chan->id << NV40_RAMHT_CONTEXT_CHANNEL_SHIFT) |
-                      (gpuobj->engine << NV40_RAMHT_CONTEXT_ENGINE_SHIFT);
-        } else {
-                if (gpuobj->engine == NVOBJ_ENGINE_DISPLAY) {
-                        ctx = (gpuobj->cinst << 10) |
-                              (chan->id << 28) |
-                              chan->id; /* HASH_TAG */
-                } else {
-                        ctx = (gpuobj->cinst >> 4) |
-                              ((gpuobj->engine <<
-                                NV40_RAMHT_CONTEXT_ENGINE_SHIFT));
-                }
-        }
-
-        spin_lock_irqsave(&chan->ramht->lock, flags);
-        list_add(&entry->head, &chan->ramht->entries);
-
-        co = ho = nouveau_ramht_hash_handle(chan, handle);
-        do {
-                if (!nouveau_ramht_entry_valid(dev, ramht, co)) {
-                        NV_DEBUG(dev,
-                                 "insert ch%d 0x%08x: h=0x%08x, c=0x%08x\n",
-                                 chan->id, co, handle, ctx);
-                        nv_wo32(ramht, co + 0, handle);
-                        nv_wo32(ramht, co + 4, ctx);
-
-                        spin_unlock_irqrestore(&chan->ramht->lock, flags);
-                        instmem->flush(dev);
-                        return 0;
-                }
-                NV_DEBUG(dev, "collision ch%d 0x%08x: h=0x%08x\n",
-                         chan->id, co, nv_ro32(ramht, co));
-
-                co += 8;
-                if (co >= ramht->size)
-                        co = 0;
-        } while (co != ho);
-
-        NV_ERROR(dev, "RAMHT space exhausted. ch=%d\n", chan->id);
-        list_del(&entry->head);
-        spin_unlock_irqrestore(&chan->ramht->lock, flags);
-        kfree(entry);
-        return -ENOMEM;
-}
-
-static struct nouveau_ramht_entry *
-nouveau_ramht_remove_entry(struct nouveau_channel *chan, u32 handle)
-{
-        struct nouveau_ramht *ramht = chan ? chan->ramht : NULL;
-        struct nouveau_ramht_entry *entry;
-        unsigned long flags;
-
-        if (!ramht)
-                return NULL;
-
-        spin_lock_irqsave(&ramht->lock, flags);
-        list_for_each_entry(entry, &ramht->entries, head) {
-                if (entry->channel == chan &&
-                    (!handle || entry->handle == handle)) {
-                        list_del(&entry->head);
-                        spin_unlock_irqrestore(&ramht->lock, flags);
-
-                        return entry;
-                }
-        }
-        spin_unlock_irqrestore(&ramht->lock, flags);
-
-        return NULL;
-}
-
-static void
-nouveau_ramht_remove_hash(struct nouveau_channel *chan, u32 handle)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *instmem = &dev_priv->engine.instmem;
-        struct nouveau_gpuobj *ramht = chan->ramht->gpuobj;
-        unsigned long flags;
-        u32 co, ho;
-
-        spin_lock_irqsave(&chan->ramht->lock, flags);
-        co = ho = nouveau_ramht_hash_handle(chan, handle);
-        do {
-                if (nouveau_ramht_entry_valid(dev, ramht, co) &&
-                    nouveau_ramht_entry_same_channel(chan, ramht, co) &&
-                    (handle == nv_ro32(ramht, co))) {
-                        NV_DEBUG(dev,
-                                 "remove ch%d 0x%08x: h=0x%08x, c=0x%08x\n",
-                                 chan->id, co, handle, nv_ro32(ramht, co + 4));
-                        nv_wo32(ramht, co + 0, 0x00000000);
-                        nv_wo32(ramht, co + 4, 0x00000000);
-                        instmem->flush(dev);
-                        goto out;
-                }
-
-                co += 8;
-                if (co >= ramht->size)
-                        co = 0;
-        } while (co != ho);
-
-        NV_ERROR(dev, "RAMHT entry not found. ch=%d, handle=0x%08x\n",
-                 chan->id, handle);
-out:
-        spin_unlock_irqrestore(&chan->ramht->lock, flags);
-}
-
-int
-nouveau_ramht_remove(struct nouveau_channel *chan, u32 handle)
-{
-        struct nouveau_ramht_entry *entry;
-
-        entry = nouveau_ramht_remove_entry(chan, handle);
-        if (!entry)
-                return -ENOENT;
-
-        nouveau_ramht_remove_hash(chan, entry->handle);
-        nouveau_gpuobj_ref(NULL, &entry->gpuobj);
-        kfree(entry);
-        return 0;
-}
-
-struct nouveau_gpuobj *
-nouveau_ramht_find(struct nouveau_channel *chan, u32 handle)
-{
-        struct nouveau_ramht *ramht = chan->ramht;
-        struct nouveau_ramht_entry *entry;
-        struct nouveau_gpuobj *gpuobj = NULL;
-        unsigned long flags;
-
-        if (unlikely(!chan->ramht))
-                return NULL;
-
-        spin_lock_irqsave(&ramht->lock, flags);
-        list_for_each_entry(entry, &chan->ramht->entries, head) {
-                if (entry->channel == chan && entry->handle == handle) {
-                        gpuobj = entry->gpuobj;
-                        break;
-                }
-        }
-        spin_unlock_irqrestore(&ramht->lock, flags);
-
-        return gpuobj;
-}
-
-int
-nouveau_ramht_new(struct drm_device *dev, struct nouveau_gpuobj *gpuobj,
-                  struct nouveau_ramht **pramht)
-{
-        struct nouveau_ramht *ramht;
-
-        ramht = kzalloc(sizeof(*ramht), GFP_KERNEL);
-        if (!ramht)
-                return -ENOMEM;
-
-        ramht->dev = dev;
-        kref_init(&ramht->refcount);
-        ramht->bits = drm_order(gpuobj->size / 8);
-        INIT_LIST_HEAD(&ramht->entries);
-        spin_lock_init(&ramht->lock);
-        nouveau_gpuobj_ref(gpuobj, &ramht->gpuobj);
-
-        *pramht = ramht;
-        return 0;
-}
-
-static void
-nouveau_ramht_del(struct kref *ref)
-{
-        struct nouveau_ramht *ramht =
-                container_of(ref, struct nouveau_ramht, refcount);
-
-        nouveau_gpuobj_ref(NULL, &ramht->gpuobj);
-        kfree(ramht);
-}
-
-void
-nouveau_ramht_ref(struct nouveau_ramht *ref, struct nouveau_ramht **ptr,
-                  struct nouveau_channel *chan)
-{
-        struct nouveau_ramht_entry *entry;
-        struct nouveau_ramht *ramht;
-
-        if (ref)
-                kref_get(&ref->refcount);
-
-        ramht = *ptr;
-        if (ramht) {
-                while ((entry = nouveau_ramht_remove_entry(chan, 0))) {
-                        nouveau_ramht_remove_hash(chan, entry->handle);
-                        nouveau_gpuobj_ref(NULL, &entry->gpuobj);
-                        kfree(entry);
-                }
-
-                kref_put(&ramht->refcount, nouveau_ramht_del);
-        }
-        *ptr = ref;
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_sgdma.c b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
index 38483a042bc2..ca5492ac2da5 100644
--- a/drivers/gpu/drm/nouveau/nouveau_sgdma.c
+++ b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
@@ -1,11 +1,10 @@
-#include "drmP.h"
-#include "nouveau_drv.h"
 #include <linux/pagemap.h>
 #include <linux/slab.h>
 
-#define NV_CTXDMA_PAGE_SHIFT 12
-#define NV_CTXDMA_PAGE_SIZE  (1 << NV_CTXDMA_PAGE_SHIFT)
-#define NV_CTXDMA_PAGE_MASK  (NV_CTXDMA_PAGE_SIZE - 1)
+#include <subdev/fb.h>
+
+#include "nouveau_drm.h"
+#include "nouveau_ttm.h"
 
 struct nouveau_sgdma_be {
         /* this has to be the first field so populate/unpopulated in
@@ -13,7 +12,7 @@ struct nouveau_sgdma_be {
          */
         struct ttm_dma_tt ttm;
         struct drm_device *dev;
-        u64 offset;
+        struct nouveau_mem *node;
 };
 
 static void
@@ -22,7 +21,6 @@ nouveau_sgdma_destroy(struct ttm_tt *ttm)
         struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
 
         if (ttm) {
-                NV_DEBUG(nvbe->dev, "\n");
                 ttm_dma_tt_fini(&nvbe->ttm);
                 kfree(nvbe);
         }
@@ -32,25 +30,18 @@ static int
 nv04_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem)
 {
         struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_device *dev = nvbe->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj = dev_priv->gart_info.sg_ctxdma;
-        unsigned i, j, pte;
-
-        NV_DEBUG(dev, "pg=0x%lx\n", mem->start);
-
-        nvbe->offset = mem->start << PAGE_SHIFT;
-        pte = (nvbe->offset >> NV_CTXDMA_PAGE_SHIFT) + 2;
-        for (i = 0; i < ttm->num_pages; i++) {
-                dma_addr_t dma_offset = nvbe->ttm.dma_address[i];
-                uint32_t offset_l = lower_32_bits(dma_offset);
+        struct nouveau_mem *node = mem->mm_node;
+        u64 size = mem->num_pages << 12;
 
-                for (j = 0; j < PAGE_SIZE / NV_CTXDMA_PAGE_SIZE; j++, pte++) {
-                        nv_wo32(gpuobj, (pte * 4) + 0, offset_l | 3);
-                        offset_l += NV_CTXDMA_PAGE_SIZE;
-                }
+        if (ttm->sg) {
+                node->sg = ttm->sg;
+                nouveau_vm_map_sg_table(&node->vma[0], 0, size, node);
+        } else {
+                node->pages = nvbe->ttm.dma_address;
+                nouveau_vm_map_sg(&node->vma[0], 0, size, node);
         }
 
+        nvbe->node = node;
         return 0;
 }
 
@@ -58,22 +49,7 @@ static int
 nv04_sgdma_unbind(struct ttm_tt *ttm)
 {
         struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_device *dev = nvbe->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj = dev_priv->gart_info.sg_ctxdma;
-        unsigned i, j, pte;
-
-        NV_DEBUG(dev, "\n");
-
-        if (ttm->state != tt_bound)
-                return 0;
-
-        pte = (nvbe->offset >> NV_CTXDMA_PAGE_SHIFT) + 2;
-        for (i = 0; i < ttm->num_pages; i++) {
-                for (j = 0; j < PAGE_SIZE / NV_CTXDMA_PAGE_SIZE; j++, pte++)
-                        nv_wo32(gpuobj, (pte * 4) + 0, 0x00000000);
-        }
-
+        nouveau_vm_unmap(&nvbe->node->vma[0]);
         return 0;
 }
 
@@ -83,206 +59,6 @@ static struct ttm_backend_func nv04_sgdma_backend = {
         .destroy                = nouveau_sgdma_destroy
 };
 
-static void
-nv41_sgdma_flush(struct nouveau_sgdma_be *nvbe)
-{
-        struct drm_device *dev = nvbe->dev;
-
-        nv_wr32(dev, 0x100810, 0x00000022);
-        if (!nv_wait(dev, 0x100810, 0x00000100, 0x00000100))
-                NV_ERROR(dev, "vm flush timeout: 0x%08x\n",
-                         nv_rd32(dev, 0x100810));
-        nv_wr32(dev, 0x100810, 0x00000000);
-}
-
-static int
-nv41_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem)
-{
-        struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_nouveau_private *dev_priv = nvbe->dev->dev_private;
-        struct nouveau_gpuobj *pgt = dev_priv->gart_info.sg_ctxdma;
-        dma_addr_t *list = nvbe->ttm.dma_address;
-        u32 pte = mem->start << 2;
-        u32 cnt = ttm->num_pages;
-
-        nvbe->offset = mem->start << PAGE_SHIFT;
-
-        while (cnt--) {
-                nv_wo32(pgt, pte, (*list++ >> 7) | 1);
-                pte += 4;
-        }
-
-        nv41_sgdma_flush(nvbe);
-        return 0;
-}
-
-static int
-nv41_sgdma_unbind(struct ttm_tt *ttm)
-{
-        struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_nouveau_private *dev_priv = nvbe->dev->dev_private;
-        struct nouveau_gpuobj *pgt = dev_priv->gart_info.sg_ctxdma;
-        u32 pte = (nvbe->offset >> 12) << 2;
-        u32 cnt = ttm->num_pages;
-
-        while (cnt--) {
-                nv_wo32(pgt, pte, 0x00000000);
-                pte += 4;
-        }
-
-        nv41_sgdma_flush(nvbe);
-        return 0;
-}
-
-static struct ttm_backend_func nv41_sgdma_backend = {
-        .bind                   = nv41_sgdma_bind,
-        .unbind                 = nv41_sgdma_unbind,
-        .destroy                = nouveau_sgdma_destroy
-};
-
-static void
-nv44_sgdma_flush(struct ttm_tt *ttm)
-{
-        struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_device *dev = nvbe->dev;
-
-        nv_wr32(dev, 0x100814, (ttm->num_pages - 1) << 12);
-        nv_wr32(dev, 0x100808, nvbe->offset | 0x20);
-        if (!nv_wait(dev, 0x100808, 0x00000001, 0x00000001))
-                NV_ERROR(dev, "gart flush timeout: 0x%08x\n",
-                         nv_rd32(dev, 0x100808));
-        nv_wr32(dev, 0x100808, 0x00000000);
-}
-
-static void
-nv44_sgdma_fill(struct nouveau_gpuobj *pgt, dma_addr_t *list, u32 base, u32 cnt)
-{
-        struct drm_nouveau_private *dev_priv = pgt->dev->dev_private;
-        dma_addr_t dummy = dev_priv->gart_info.dummy.addr;
-        u32 pte, tmp[4];
-
-        pte   = base >> 2;
-        base &= ~0x0000000f;
-
-        tmp[0] = nv_ro32(pgt, base + 0x0);
-        tmp[1] = nv_ro32(pgt, base + 0x4);
-        tmp[2] = nv_ro32(pgt, base + 0x8);
-        tmp[3] = nv_ro32(pgt, base + 0xc);
-        while (cnt--) {
-                u32 addr = list ? (*list++ >> 12) : (dummy >> 12);
-                switch (pte++ & 0x3) {
-                case 0:
-                        tmp[0] &= ~0x07ffffff;
-                        tmp[0] |= addr;
-                        break;
-                case 1:
-                        tmp[0] &= ~0xf8000000;
-                        tmp[0] |= addr << 27;
-                        tmp[1] &= ~0x003fffff;
-                        tmp[1] |= addr >> 5;
-                        break;
-                case 2:
-                        tmp[1] &= ~0xffc00000;
-                        tmp[1] |= addr << 22;
-                        tmp[2] &= ~0x0001ffff;
-                        tmp[2] |= addr >> 10;
-                        break;
-                case 3:
-                        tmp[2] &= ~0xfffe0000;
-                        tmp[2] |= addr << 17;
-                        tmp[3] &= ~0x00000fff;
-                        tmp[3] |= addr >> 15;
-                        break;
-                }
-        }
-
-        tmp[3] |= 0x40000000;
-
-        nv_wo32(pgt, base + 0x0, tmp[0]);
-        nv_wo32(pgt, base + 0x4, tmp[1]);
-        nv_wo32(pgt, base + 0x8, tmp[2]);
-        nv_wo32(pgt, base + 0xc, tmp[3]);
-}
-
-static int
-nv44_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem)
-{
-        struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_nouveau_private *dev_priv = nvbe->dev->dev_private;
-        struct nouveau_gpuobj *pgt = dev_priv->gart_info.sg_ctxdma;
-        dma_addr_t *list = nvbe->ttm.dma_address;
-        u32 pte = mem->start << 2, tmp[4];
-        u32 cnt = ttm->num_pages;
-        int i;
-
-        nvbe->offset = mem->start << PAGE_SHIFT;
-
-        if (pte & 0x0000000c) {
-                u32  max = 4 - ((pte >> 2) & 0x3);
-                u32 part = (cnt > max) ? max : cnt;
-                nv44_sgdma_fill(pgt, list, pte, part);
-                pte  += (part << 2);
-                list += part;
-                cnt  -= part;
-        }
-
-        while (cnt >= 4) {
-                for (i = 0; i < 4; i++)
-                        tmp[i] = *list++ >> 12;
-                nv_wo32(pgt, pte + 0x0, tmp[0] >>  0 | tmp[1] << 27);
-                nv_wo32(pgt, pte + 0x4, tmp[1] >>  5 | tmp[2] << 22);
-                nv_wo32(pgt, pte + 0x8, tmp[2] >> 10 | tmp[3] << 17);
-                nv_wo32(pgt, pte + 0xc, tmp[3] >> 15 | 0x40000000);
-                pte  += 0x10;
-                cnt  -= 4;
-        }
-
-        if (cnt)
-                nv44_sgdma_fill(pgt, list, pte, cnt);
-
-        nv44_sgdma_flush(ttm);
-        return 0;
-}
-
-static int
-nv44_sgdma_unbind(struct ttm_tt *ttm)
-{
-        struct nouveau_sgdma_be *nvbe = (struct nouveau_sgdma_be *)ttm;
-        struct drm_nouveau_private *dev_priv = nvbe->dev->dev_private;
-        struct nouveau_gpuobj *pgt = dev_priv->gart_info.sg_ctxdma;
-        u32 pte = (nvbe->offset >> 12) << 2;
-        u32 cnt = ttm->num_pages;
-
-        if (pte & 0x0000000c) {
-                u32  max = 4 - ((pte >> 2) & 0x3);
-                u32 part = (cnt > max) ? max : cnt;
-                nv44_sgdma_fill(pgt, NULL, pte, part);
-                pte  += (part << 2);
-                cnt  -= part;
-        }
-
-        while (cnt >= 4) {
-                nv_wo32(pgt, pte + 0x0, 0x00000000);
-                nv_wo32(pgt, pte + 0x4, 0x00000000);
-                nv_wo32(pgt, pte + 0x8, 0x00000000);
-                nv_wo32(pgt, pte + 0xc, 0x00000000);
-                pte  += 0x10;
-                cnt  -= 4;
-        }
-
-        if (cnt)
-                nv44_sgdma_fill(pgt, NULL, pte, cnt);
-
-        nv44_sgdma_flush(ttm);
-        return 0;
-}
-
-static struct ttm_backend_func nv44_sgdma_backend = {
-        .bind                   = nv44_sgdma_bind,
-        .unbind                 = nv44_sgdma_unbind,
-        .destroy                = nouveau_sgdma_destroy
-};
-
 static int
 nv50_sgdma_bind(struct ttm_tt *ttm, struct ttm_mem_reg *mem)
 {
@@ -315,16 +91,18 @@ nouveau_sgdma_create_ttm(struct ttm_bo_device *bdev,
                          unsigned long size, uint32_t page_flags,
                          struct page *dummy_read_page)
 {
-        struct drm_nouveau_private *dev_priv = nouveau_bdev(bdev);
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_bdev(bdev);
         struct nouveau_sgdma_be *nvbe;
 
         nvbe = kzalloc(sizeof(*nvbe), GFP_KERNEL);
         if (!nvbe)
                 return NULL;
 
-        nvbe->dev = dev;
-        nvbe->ttm.ttm.func = dev_priv->gart_info.func;
+        nvbe->dev = drm->dev;
+        if (nv_device(drm->device)->card_type < NV_50)
+                nvbe->ttm.ttm.func = &nv04_sgdma_backend;
+        else
+                nvbe->ttm.ttm.func = &nv50_sgdma_backend;
 
         if (ttm_dma_tt_init(&nvbe->ttm, bdev, size, page_flags, dummy_read_page)) {
                 kfree(nvbe);
@@ -332,116 +110,3 @@ nouveau_sgdma_create_ttm(struct ttm_bo_device *bdev,
         }
         return &nvbe->ttm.ttm;
 }
-
-int
-nouveau_sgdma_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj = NULL;
-        u32 aper_size, align;
-        int ret;
-
-        if (dev_priv->card_type >= NV_40)
-                aper_size = 512 * 1024 * 1024;
-        else
-                aper_size = 128 * 1024 * 1024;
-
-        /* Dear NVIDIA, NV44+ would like proper present bits in PTEs for
-         * christmas.  The cards before it have them, the cards after
-         * it have them, why is NV44 so unloved?
-         */
-        dev_priv->gart_info.dummy.page = alloc_page(GFP_DMA32 | GFP_KERNEL);
-        if (!dev_priv->gart_info.dummy.page)
-                return -ENOMEM;
-
-        dev_priv->gart_info.dummy.addr =
-                pci_map_page(dev->pdev, dev_priv->gart_info.dummy.page,
-                             0, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-        if (pci_dma_mapping_error(dev->pdev, dev_priv->gart_info.dummy.addr)) {
-                NV_ERROR(dev, "error mapping dummy page\n");
-                __free_page(dev_priv->gart_info.dummy.page);
-                dev_priv->gart_info.dummy.page = NULL;
-                return -ENOMEM;
-        }
-
-        if (dev_priv->card_type >= NV_50) {
-                dev_priv->gart_info.aper_base = 0;
-                dev_priv->gart_info.aper_size = aper_size;
-                dev_priv->gart_info.type = NOUVEAU_GART_HW;
-                dev_priv->gart_info.func = &nv50_sgdma_backend;
-        } else
-        if (0 && pci_is_pcie(dev->pdev) &&
-            dev_priv->chipset > 0x40 && dev_priv->chipset != 0x45) {
-                if (nv44_graph_class(dev)) {
-                        dev_priv->gart_info.func = &nv44_sgdma_backend;
-                        align = 512 * 1024;
-                } else {
-                        dev_priv->gart_info.func = &nv41_sgdma_backend;
-                        align = 16;
-                }
-
-                ret = nouveau_gpuobj_new(dev, NULL, aper_size / 1024, align,
-                                         NVOBJ_FLAG_ZERO_ALLOC |
-                                         NVOBJ_FLAG_ZERO_FREE, &gpuobj);
-                if (ret) {
-                        NV_ERROR(dev, "Error creating sgdma object: %d\n", ret);
-                        return ret;
-                }
-
-                dev_priv->gart_info.sg_ctxdma = gpuobj;
-                dev_priv->gart_info.aper_base = 0;
-                dev_priv->gart_info.aper_size = aper_size;
-                dev_priv->gart_info.type = NOUVEAU_GART_HW;
-        } else {
-                ret = nouveau_gpuobj_new(dev, NULL, (aper_size / 1024) + 8, 16,
-                                         NVOBJ_FLAG_ZERO_ALLOC |
-                                         NVOBJ_FLAG_ZERO_FREE, &gpuobj);
-                if (ret) {
-                        NV_ERROR(dev, "Error creating sgdma object: %d\n", ret);
-                        return ret;
-                }
-
-                nv_wo32(gpuobj, 0, NV_CLASS_DMA_IN_MEMORY |
-                                   (1 << 12) /* PT present */ |
-                                   (0 << 13) /* PT *not* linear */ |
-                                   (0 << 14) /* RW */ |
-                                   (2 << 16) /* PCI */);
-                nv_wo32(gpuobj, 4, aper_size - 1);
-
-                dev_priv->gart_info.sg_ctxdma = gpuobj;
-                dev_priv->gart_info.aper_base = 0;
-                dev_priv->gart_info.aper_size = aper_size;
-                dev_priv->gart_info.type = NOUVEAU_GART_PDMA;
-                dev_priv->gart_info.func = &nv04_sgdma_backend;
-        }
-
-        return 0;
-}
-
-void
-nouveau_sgdma_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nouveau_gpuobj_ref(NULL, &dev_priv->gart_info.sg_ctxdma);
-
-        if (dev_priv->gart_info.dummy.page) {
-                pci_unmap_page(dev->pdev, dev_priv->gart_info.dummy.addr,
-                               PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-                __free_page(dev_priv->gart_info.dummy.page);
-                dev_priv->gart_info.dummy.page = NULL;
-        }
-}
-
-uint32_t
-nouveau_sgdma_get_physical(struct drm_device *dev, uint32_t offset)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gpuobj = dev_priv->gart_info.sg_ctxdma;
-        int pte = (offset >> NV_CTXDMA_PAGE_SHIFT) + 2;
-
-        BUG_ON(dev_priv->card_type >= NV_50);
-
-        return (nv_ro32(gpuobj, 4 * pte) & ~NV_CTXDMA_PAGE_MASK) |
-                (offset & NV_CTXDMA_PAGE_MASK);
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_software.h b/drivers/gpu/drm/nouveau/nouveau_software.h
deleted file mode 100644
index 709e5ac680ec..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_software.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef __NOUVEAU_SOFTWARE_H__
-#define __NOUVEAU_SOFTWARE_H__
-
-struct nouveau_software_priv {
-        struct nouveau_exec_engine base;
-        struct list_head vblank;
-        spinlock_t peephole_lock;
-};
-
-struct nouveau_software_chan {
-        struct list_head flip;
-        struct {
-                struct list_head list;
-                u32 channel;
-                u32 ctxdma;
-                u32 offset;
-                u32 value;
-                u32 head;
-        } vblank;
-};
-
-static inline void
-nouveau_software_context_new(struct nouveau_software_chan *pch)
-{
-        INIT_LIST_HEAD(&pch->flip);
-        INIT_LIST_HEAD(&pch->vblank.list);
-}
-
-static inline void
-nouveau_software_create(struct nouveau_software_priv *psw)
-{
-        INIT_LIST_HEAD(&psw->vblank);
-        spin_lock_init(&psw->peephole_lock);
-}
-
-static inline u16
-nouveau_software_class(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        if (dev_priv->card_type <= NV_04)
-                return 0x006e;
-        if (dev_priv->card_type <= NV_40)
-                return 0x016e;
-        if (dev_priv->card_type <= NV_50)
-                return 0x506e;
-        if (dev_priv->card_type <= NV_E0)
-                return 0x906e;
-        return 0x0000;
-}
-
-int nv04_software_create(struct drm_device *);
-int nv50_software_create(struct drm_device *);
-int nvc0_software_create(struct drm_device *);
-u64 nvc0_software_crtc(struct nouveau_channel *, int crtc);
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_state.c b/drivers/gpu/drm/nouveau/nouveau_state.c
deleted file mode 100644
index c61014442aa9..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_state.c
+++ /dev/null
@@ -1,1306 +0,0 @@
-/*
- * Copyright 2005 Stephane Marchesin
- * Copyright 2008 Stuart Bennett
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include <linux/swab.h>
-#include <linux/slab.h>
-#include "drmP.h"
-#include "drm.h"
-#include "drm_sarea.h"
-#include "drm_crtc_helper.h"
-#include <linux/vgaarb.h>
-#include <linux/vga_switcheroo.h>
-
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-#include "nouveau_fbcon.h"
-#include "nouveau_ramht.h"
-#include "nouveau_gpio.h"
-#include "nouveau_pm.h"
-#include "nv50_display.h"
-#include "nouveau_fifo.h"
-#include "nouveau_fence.h"
-#include "nouveau_software.h"
-
-static void nouveau_stub_takedown(struct drm_device *dev) {}
-static int nouveau_stub_init(struct drm_device *dev) { return 0; }
-
-static int nouveau_init_engine_ptrs(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_engine *engine = &dev_priv->engine;
-
-        switch (dev_priv->chipset & 0xf0) {
-        case 0x00:
-                engine->instmem.init            = nv04_instmem_init;
-                engine->instmem.takedown        = nv04_instmem_takedown;
-                engine->instmem.suspend         = nv04_instmem_suspend;
-                engine->instmem.resume          = nv04_instmem_resume;
-                engine->instmem.get             = nv04_instmem_get;
-                engine->instmem.put             = nv04_instmem_put;
-                engine->instmem.map             = nv04_instmem_map;
-                engine->instmem.unmap           = nv04_instmem_unmap;
-                engine->instmem.flush           = nv04_instmem_flush;
-                engine->mc.init                 = nv04_mc_init;
-                engine->mc.takedown             = nv04_mc_takedown;
-                engine->timer.init              = nv04_timer_init;
-                engine->timer.read              = nv04_timer_read;
-                engine->timer.takedown          = nv04_timer_takedown;
-                engine->fb.init                 = nv04_fb_init;
-                engine->fb.takedown             = nv04_fb_takedown;
-                engine->display.early_init      = nv04_display_early_init;
-                engine->display.late_takedown   = nv04_display_late_takedown;
-                engine->display.create          = nv04_display_create;
-                engine->display.destroy         = nv04_display_destroy;
-                engine->display.init            = nv04_display_init;
-                engine->display.fini            = nv04_display_fini;
-                engine->pm.clocks_get           = nv04_pm_clocks_get;
-                engine->pm.clocks_pre           = nv04_pm_clocks_pre;
-                engine->pm.clocks_set           = nv04_pm_clocks_set;
-                engine->vram.init               = nv04_fb_vram_init;
-                engine->vram.takedown           = nouveau_stub_takedown;
-                engine->vram.flags_valid        = nouveau_mem_flags_valid;
-                break;
-        case 0x10:
-                engine->instmem.init            = nv04_instmem_init;
-                engine->instmem.takedown        = nv04_instmem_takedown;
-                engine->instmem.suspend         = nv04_instmem_suspend;
-                engine->instmem.resume          = nv04_instmem_resume;
-                engine->instmem.get             = nv04_instmem_get;
-                engine->instmem.put             = nv04_instmem_put;
-                engine->instmem.map             = nv04_instmem_map;
-                engine->instmem.unmap           = nv04_instmem_unmap;
-                engine->instmem.flush           = nv04_instmem_flush;
-                engine->mc.init                 = nv04_mc_init;
-                engine->mc.takedown             = nv04_mc_takedown;
-                engine->timer.init              = nv04_timer_init;
-                engine->timer.read              = nv04_timer_read;
-                engine->timer.takedown          = nv04_timer_takedown;
-                engine->fb.init                 = nv10_fb_init;
-                engine->fb.takedown             = nv10_fb_takedown;
-                engine->fb.init_tile_region     = nv10_fb_init_tile_region;
-                engine->fb.set_tile_region      = nv10_fb_set_tile_region;
-                engine->fb.free_tile_region     = nv10_fb_free_tile_region;
-                engine->display.early_init      = nv04_display_early_init;
-                engine->display.late_takedown   = nv04_display_late_takedown;
-                engine->display.create          = nv04_display_create;
-                engine->display.destroy         = nv04_display_destroy;
-                engine->display.init            = nv04_display_init;
-                engine->display.fini            = nv04_display_fini;
-                engine->gpio.drive              = nv10_gpio_drive;
-                engine->gpio.sense              = nv10_gpio_sense;
-                engine->pm.clocks_get           = nv04_pm_clocks_get;
-                engine->pm.clocks_pre           = nv04_pm_clocks_pre;
-                engine->pm.clocks_set           = nv04_pm_clocks_set;
-                if (dev_priv->chipset == 0x1a ||
-                    dev_priv->chipset == 0x1f)
-                        engine->vram.init       = nv1a_fb_vram_init;
-                else
-                        engine->vram.init       = nv10_fb_vram_init;
-                engine->vram.takedown           = nouveau_stub_takedown;
-                engine->vram.flags_valid        = nouveau_mem_flags_valid;
-                break;
-        case 0x20:
-                engine->instmem.init            = nv04_instmem_init;
-                engine->instmem.takedown        = nv04_instmem_takedown;
-                engine->instmem.suspend         = nv04_instmem_suspend;
-                engine->instmem.resume          = nv04_instmem_resume;
-                engine->instmem.get             = nv04_instmem_get;
-                engine->instmem.put             = nv04_instmem_put;
-                engine->instmem.map             = nv04_instmem_map;
-                engine->instmem.unmap           = nv04_instmem_unmap;
-                engine->instmem.flush           = nv04_instmem_flush;
-                engine->mc.init                 = nv04_mc_init;
-                engine->mc.takedown             = nv04_mc_takedown;
-                engine->timer.init              = nv04_timer_init;
-                engine->timer.read              = nv04_timer_read;
-                engine->timer.takedown          = nv04_timer_takedown;
-                engine->fb.init                 = nv20_fb_init;
-                engine->fb.takedown             = nv20_fb_takedown;
-                engine->fb.init_tile_region     = nv20_fb_init_tile_region;
-                engine->fb.set_tile_region      = nv20_fb_set_tile_region;
-                engine->fb.free_tile_region     = nv20_fb_free_tile_region;
-                engine->display.early_init      = nv04_display_early_init;
-                engine->display.late_takedown   = nv04_display_late_takedown;
-                engine->display.create          = nv04_display_create;
-                engine->display.destroy         = nv04_display_destroy;
-                engine->display.init            = nv04_display_init;
-                engine->display.fini            = nv04_display_fini;
-                engine->gpio.drive              = nv10_gpio_drive;
-                engine->gpio.sense              = nv10_gpio_sense;
-                engine->pm.clocks_get           = nv04_pm_clocks_get;
-                engine->pm.clocks_pre           = nv04_pm_clocks_pre;
-                engine->pm.clocks_set           = nv04_pm_clocks_set;
-                engine->vram.init               = nv20_fb_vram_init;
-                engine->vram.takedown           = nouveau_stub_takedown;
-                engine->vram.flags_valid        = nouveau_mem_flags_valid;
-                break;
-        case 0x30:
-                engine->instmem.init            = nv04_instmem_init;
-                engine->instmem.takedown        = nv04_instmem_takedown;
-                engine->instmem.suspend         = nv04_instmem_suspend;
-                engine->instmem.resume          = nv04_instmem_resume;
-                engine->instmem.get             = nv04_instmem_get;
-                engine->instmem.put             = nv04_instmem_put;
-                engine->instmem.map             = nv04_instmem_map;
-                engine->instmem.unmap           = nv04_instmem_unmap;
-                engine->instmem.flush           = nv04_instmem_flush;
-                engine->mc.init                 = nv04_mc_init;
-                engine->mc.takedown             = nv04_mc_takedown;
-                engine->timer.init              = nv04_timer_init;
-                engine->timer.read              = nv04_timer_read;
-                engine->timer.takedown          = nv04_timer_takedown;
-                engine->fb.init                 = nv30_fb_init;
-                engine->fb.takedown             = nv30_fb_takedown;
-                engine->fb.init_tile_region     = nv30_fb_init_tile_region;
-                engine->fb.set_tile_region      = nv10_fb_set_tile_region;
-                engine->fb.free_tile_region     = nv30_fb_free_tile_region;
-                engine->display.early_init      = nv04_display_early_init;
-                engine->display.late_takedown   = nv04_display_late_takedown;
-                engine->display.create          = nv04_display_create;
-                engine->display.destroy         = nv04_display_destroy;
-                engine->display.init            = nv04_display_init;
-                engine->display.fini            = nv04_display_fini;
-                engine->gpio.drive              = nv10_gpio_drive;
-                engine->gpio.sense              = nv10_gpio_sense;
-                engine->pm.clocks_get           = nv04_pm_clocks_get;
-                engine->pm.clocks_pre           = nv04_pm_clocks_pre;
-                engine->pm.clocks_set           = nv04_pm_clocks_set;
-                engine->pm.voltage_get          = nouveau_voltage_gpio_get;
-                engine->pm.voltage_set          = nouveau_voltage_gpio_set;
-                engine->vram.init               = nv20_fb_vram_init;
-                engine->vram.takedown           = nouveau_stub_takedown;
-                engine->vram.flags_valid        = nouveau_mem_flags_valid;
-                break;
-        case 0x40:
-        case 0x60:
-                engine->instmem.init            = nv04_instmem_init;
-                engine->instmem.takedown        = nv04_instmem_takedown;
-                engine->instmem.suspend         = nv04_instmem_suspend;
-                engine->instmem.resume          = nv04_instmem_resume;
-                engine->instmem.get             = nv04_instmem_get;
-                engine->instmem.put             = nv04_instmem_put;
-                engine->instmem.map             = nv04_instmem_map;
-                engine->instmem.unmap           = nv04_instmem_unmap;
-                engine->instmem.flush           = nv04_instmem_flush;
-                engine->mc.init                 = nv40_mc_init;
-                engine->mc.takedown             = nv40_mc_takedown;
-                engine->timer.init              = nv04_timer_init;
-                engine->timer.read              = nv04_timer_read;
-                engine->timer.takedown          = nv04_timer_takedown;
-                engine->fb.init                 = nv40_fb_init;
-                engine->fb.takedown             = nv40_fb_takedown;
-                engine->fb.init_tile_region     = nv30_fb_init_tile_region;
-                engine->fb.set_tile_region      = nv40_fb_set_tile_region;
-                engine->fb.free_tile_region     = nv30_fb_free_tile_region;
-                engine->display.early_init      = nv04_display_early_init;
-                engine->display.late_takedown   = nv04_display_late_takedown;
-                engine->display.create          = nv04_display_create;
-                engine->display.destroy         = nv04_display_destroy;
-                engine->display.init            = nv04_display_init;
-                engine->display.fini            = nv04_display_fini;
-                engine->gpio.init               = nv10_gpio_init;
-                engine->gpio.fini               = nv10_gpio_fini;
-                engine->gpio.drive              = nv10_gpio_drive;
-                engine->gpio.sense              = nv10_gpio_sense;
-                engine->gpio.irq_enable         = nv10_gpio_irq_enable;
-                engine->pm.clocks_get           = nv40_pm_clocks_get;
-                engine->pm.clocks_pre           = nv40_pm_clocks_pre;
-                engine->pm.clocks_set           = nv40_pm_clocks_set;
-                engine->pm.voltage_get          = nouveau_voltage_gpio_get;
-                engine->pm.voltage_set          = nouveau_voltage_gpio_set;
-                engine->pm.temp_get             = nv40_temp_get;
-                engine->pm.pwm_get              = nv40_pm_pwm_get;
-                engine->pm.pwm_set              = nv40_pm_pwm_set;
-                engine->vram.init               = nv40_fb_vram_init;
-                engine->vram.takedown           = nouveau_stub_takedown;
-                engine->vram.flags_valid        = nouveau_mem_flags_valid;
-                break;
-        case 0x50:
-        case 0x80: /* gotta love NVIDIA's consistency.. */
-        case 0x90:
-        case 0xa0:
-                engine->instmem.init            = nv50_instmem_init;
-                engine->instmem.takedown        = nv50_instmem_takedown;
-                engine->instmem.suspend         = nv50_instmem_suspend;
-                engine->instmem.resume          = nv50_instmem_resume;
-                engine->instmem.get             = nv50_instmem_get;
-                engine->instmem.put             = nv50_instmem_put;
-                engine->instmem.map             = nv50_instmem_map;
-                engine->instmem.unmap           = nv50_instmem_unmap;
-                if (dev_priv->chipset == 0x50)
-                        engine->instmem.flush   = nv50_instmem_flush;
-                else
-                        engine->instmem.flush   = nv84_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                 = nv50_fb_init;
-                engine->fb.takedown             = nv50_fb_takedown;
-                engine->display.early_init      = nv50_display_early_init;
-                engine->display.late_takedown   = nv50_display_late_takedown;
-                engine->display.create          = nv50_display_create;
-                engine->display.destroy         = nv50_display_destroy;
-                engine->display.init            = nv50_display_init;
-                engine->display.fini            = nv50_display_fini;
-                engine->gpio.init               = nv50_gpio_init;
-                engine->gpio.fini               = nv50_gpio_fini;
-                engine->gpio.drive              = nv50_gpio_drive;
-                engine->gpio.sense              = nv50_gpio_sense;
-                engine->gpio.irq_enable         = nv50_gpio_irq_enable;
-                switch (dev_priv->chipset) {
-                case 0x84:
-                case 0x86:
-                case 0x92:
-                case 0x94:
-                case 0x96:
-                case 0x98:
-                case 0xa0:
-                case 0xaa:
-                case 0xac:
-                case 0x50:
-                        engine->pm.clocks_get   = nv50_pm_clocks_get;
-                        engine->pm.clocks_pre   = nv50_pm_clocks_pre;
-                        engine->pm.clocks_set   = nv50_pm_clocks_set;
-                        break;
-                default:
-                        engine->pm.clocks_get   = nva3_pm_clocks_get;
-                        engine->pm.clocks_pre   = nva3_pm_clocks_pre;
-                        engine->pm.clocks_set   = nva3_pm_clocks_set;
-                        break;
-                }
-                engine->pm.voltage_get          = nouveau_voltage_gpio_get;
-                engine->pm.voltage_set          = nouveau_voltage_gpio_set;
-                if (dev_priv->chipset >= 0x84)
-                        engine->pm.temp_get     = nv84_temp_get;
-                else
-                        engine->pm.temp_get     = nv40_temp_get;
-                engine->pm.pwm_get              = nv50_pm_pwm_get;
-                engine->pm.pwm_set              = nv50_pm_pwm_set;
-                engine->vram.init               = nv50_vram_init;
-                engine->vram.takedown           = nv50_vram_fini;
-                engine->vram.get                = nv50_vram_new;
-                engine->vram.put                = nv50_vram_del;
-                engine->vram.flags_valid        = nv50_vram_flags_valid;
-                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.get             = nv50_instmem_get;
-                engine->instmem.put             = nv50_instmem_put;
-                engine->instmem.map             = nv50_instmem_map;
-                engine->instmem.unmap           = nv50_instmem_unmap;
-                engine->instmem.flush           = nv84_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->display.early_init      = nv50_display_early_init;
-                engine->display.late_takedown   = nv50_display_late_takedown;
-                engine->display.create          = nv50_display_create;
-                engine->display.destroy         = nv50_display_destroy;
-                engine->display.init            = nv50_display_init;
-                engine->display.fini            = nv50_display_fini;
-                engine->gpio.init               = nv50_gpio_init;
-                engine->gpio.fini               = nv50_gpio_fini;
-                engine->gpio.drive              = nv50_gpio_drive;
-                engine->gpio.sense              = nv50_gpio_sense;
-                engine->gpio.irq_enable         = nv50_gpio_irq_enable;
-                engine->vram.init               = nvc0_vram_init;
-                engine->vram.takedown           = nv50_vram_fini;
-                engine->vram.get                = nvc0_vram_new;
-                engine->vram.put                = nv50_vram_del;
-                engine->vram.flags_valid        = nvc0_vram_flags_valid;
-                engine->pm.temp_get             = nv84_temp_get;
-                engine->pm.clocks_get           = nvc0_pm_clocks_get;
-                engine->pm.clocks_pre           = nvc0_pm_clocks_pre;
-                engine->pm.clocks_set           = nvc0_pm_clocks_set;
-                engine->pm.voltage_get          = nouveau_voltage_gpio_get;
-                engine->pm.voltage_set          = nouveau_voltage_gpio_set;
-                engine->pm.pwm_get              = nv50_pm_pwm_get;
-                engine->pm.pwm_set              = nv50_pm_pwm_set;
-                break;
-        case 0xd0:
-                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.get             = nv50_instmem_get;
-                engine->instmem.put             = nv50_instmem_put;
-                engine->instmem.map             = nv50_instmem_map;
-                engine->instmem.unmap           = nv50_instmem_unmap;
-                engine->instmem.flush           = nv84_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->display.early_init      = nouveau_stub_init;
-                engine->display.late_takedown   = nouveau_stub_takedown;
-                engine->display.create          = nvd0_display_create;
-                engine->display.destroy         = nvd0_display_destroy;
-                engine->display.init            = nvd0_display_init;
-                engine->display.fini            = nvd0_display_fini;
-                engine->gpio.init               = nv50_gpio_init;
-                engine->gpio.fini               = nv50_gpio_fini;
-                engine->gpio.drive              = nvd0_gpio_drive;
-                engine->gpio.sense              = nvd0_gpio_sense;
-                engine->gpio.irq_enable         = nv50_gpio_irq_enable;
-                engine->vram.init               = nvc0_vram_init;
-                engine->vram.takedown           = nv50_vram_fini;
-                engine->vram.get                = nvc0_vram_new;
-                engine->vram.put                = nv50_vram_del;
-                engine->vram.flags_valid        = nvc0_vram_flags_valid;
-                engine->pm.temp_get             = nv84_temp_get;
-                engine->pm.clocks_get           = nvc0_pm_clocks_get;
-                engine->pm.clocks_pre           = nvc0_pm_clocks_pre;
-                engine->pm.clocks_set           = nvc0_pm_clocks_set;
-                engine->pm.voltage_get          = nouveau_voltage_gpio_get;
-                engine->pm.voltage_set          = nouveau_voltage_gpio_set;
-                break;
-        case 0xe0:
-                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.get             = nv50_instmem_get;
-                engine->instmem.put             = nv50_instmem_put;
-                engine->instmem.map             = nv50_instmem_map;
-                engine->instmem.unmap           = nv50_instmem_unmap;
-                engine->instmem.flush           = nv84_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->display.early_init      = nouveau_stub_init;
-                engine->display.late_takedown   = nouveau_stub_takedown;
-                engine->display.create          = nvd0_display_create;
-                engine->display.destroy         = nvd0_display_destroy;
-                engine->display.init            = nvd0_display_init;
-                engine->display.fini            = nvd0_display_fini;
-                engine->gpio.init               = nv50_gpio_init;
-                engine->gpio.fini               = nv50_gpio_fini;
-                engine->gpio.drive              = nvd0_gpio_drive;
-                engine->gpio.sense              = nvd0_gpio_sense;
-                engine->gpio.irq_enable         = nv50_gpio_irq_enable;
-                engine->vram.init               = nvc0_vram_init;
-                engine->vram.takedown           = nv50_vram_fini;
-                engine->vram.get                = nvc0_vram_new;
-                engine->vram.put                = nv50_vram_del;
-                engine->vram.flags_valid        = nvc0_vram_flags_valid;
-                break;
-        default:
-                NV_ERROR(dev, "NV%02x unsupported\n", dev_priv->chipset);
-                return 1;
-        }
-
-        /* headless mode */
-        if (nouveau_modeset == 2) {
-                engine->display.early_init = nouveau_stub_init;
-                engine->display.late_takedown = nouveau_stub_takedown;
-                engine->display.create = nouveau_stub_init;
-                engine->display.init = nouveau_stub_init;
-                engine->display.destroy = nouveau_stub_takedown;
-        }
-
-        return 0;
-}
-
-static unsigned int
-nouveau_vga_set_decode(void *priv, bool state)
-{
-        struct drm_device *dev = priv;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (dev_priv->chipset >= 0x40)
-                nv_wr32(dev, 0x88054, state);
-        else
-                nv_wr32(dev, 0x1854, state);
-
-        if (state)
-                return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
-                       VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
-        else
-                return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
-}
-
-static void nouveau_switcheroo_set_state(struct pci_dev *pdev,
-                                         enum vga_switcheroo_state state)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-        pm_message_t pmm = { .event = PM_EVENT_SUSPEND };
-        if (state == VGA_SWITCHEROO_ON) {
-                printk(KERN_ERR "VGA switcheroo: switched nouveau on\n");
-                dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
-                nouveau_pci_resume(pdev);
-                drm_kms_helper_poll_enable(dev);
-                dev->switch_power_state = DRM_SWITCH_POWER_ON;
-        } else {
-                printk(KERN_ERR "VGA switcheroo: switched nouveau off\n");
-                dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
-                drm_kms_helper_poll_disable(dev);
-                nouveau_switcheroo_optimus_dsm();
-                nouveau_pci_suspend(pdev, pmm);
-                dev->switch_power_state = DRM_SWITCH_POWER_OFF;
-        }
-}
-
-static void nouveau_switcheroo_reprobe(struct pci_dev *pdev)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-        nouveau_fbcon_output_poll_changed(dev);
-}
-
-static bool nouveau_switcheroo_can_switch(struct pci_dev *pdev)
-{
-        struct drm_device *dev = pci_get_drvdata(pdev);
-        bool can_switch;
-
-        spin_lock(&dev->count_lock);
-        can_switch = (dev->open_count == 0);
-        spin_unlock(&dev->count_lock);
-        return can_switch;
-}
-
-static void
-nouveau_card_channel_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (dev_priv->channel)
-                nouveau_channel_put_unlocked(&dev_priv->channel);
-}
-
-static int
-nouveau_card_channel_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan;
-        int ret;
-
-        ret = nouveau_channel_alloc(dev, &chan, NULL, NvDmaFB, NvDmaTT);
-        dev_priv->channel = chan;
-        if (ret)
-                return ret;
-        mutex_unlock(&dev_priv->channel->mutex);
-
-        nouveau_bo_move_init(chan);
-        return 0;
-}
-
-static const struct vga_switcheroo_client_ops nouveau_switcheroo_ops = {
-        .set_gpu_state = nouveau_switcheroo_set_state,
-        .reprobe = nouveau_switcheroo_reprobe,
-        .can_switch = nouveau_switcheroo_can_switch,
-};
-
-int
-nouveau_card_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_engine *engine;
-        int ret, e = 0;
-
-        vga_client_register(dev->pdev, dev, NULL, nouveau_vga_set_decode);
-        vga_switcheroo_register_client(dev->pdev, &nouveau_switcheroo_ops);
-
-        /* Initialise internal driver API hooks */
-        ret = nouveau_init_engine_ptrs(dev);
-        if (ret)
-                goto out;
-        engine = &dev_priv->engine;
-        spin_lock_init(&dev_priv->channels.lock);
-        spin_lock_init(&dev_priv->tile.lock);
-        spin_lock_init(&dev_priv->context_switch_lock);
-        spin_lock_init(&dev_priv->vm_lock);
-
-        /* Make the CRTCs and I2C buses accessible */
-        ret = engine->display.early_init(dev);
-        if (ret)
-                goto out;
-
-        /* Parse BIOS tables / Run init tables if card not POSTed */
-        ret = nouveau_bios_init(dev);
-        if (ret)
-                goto out_display_early;
-
-        /* workaround an odd issue on nvc1 by disabling the device's
-         * nosnoop capability.  hopefully won't cause issues until a
-         * better fix is found - assuming there is one...
-         */
-        if (dev_priv->chipset == 0xc1) {
-                nv_mask(dev, 0x00088080, 0x00000800, 0x00000000);
-        }
-
-        /* PMC */
-        ret = engine->mc.init(dev);
-        if (ret)
-                goto out_bios;
-
-        /* PTIMER */
-        ret = engine->timer.init(dev);
-        if (ret)
-                goto out_mc;
-
-        /* PFB */
-        ret = engine->fb.init(dev);
-        if (ret)
-                goto out_timer;
-
-        ret = engine->vram.init(dev);
-        if (ret)
-                goto out_fb;
-
-        /* PGPIO */
-        ret = nouveau_gpio_create(dev);
-        if (ret)
-                goto out_vram;
-
-        ret = nouveau_gpuobj_init(dev);
-        if (ret)
-                goto out_gpio;
-
-        ret = engine->instmem.init(dev);
-        if (ret)
-                goto out_gpuobj;
-
-        ret = nouveau_mem_vram_init(dev);
-        if (ret)
-                goto out_instmem;
-
-        ret = nouveau_mem_gart_init(dev);
-        if (ret)
-                goto out_ttmvram;
-
-        if (!dev_priv->noaccel) {
-                switch (dev_priv->card_type) {
-                case NV_04:
-                        nv04_fifo_create(dev);
-                        break;
-                case NV_10:
-                case NV_20:
-                case NV_30:
-                        if (dev_priv->chipset < 0x17)
-                                nv10_fifo_create(dev);
-                        else
-                                nv17_fifo_create(dev);
-                        break;
-                case NV_40:
-                        nv40_fifo_create(dev);
-                        break;
-                case NV_50:
-                        if (dev_priv->chipset == 0x50)
-                                nv50_fifo_create(dev);
-                        else
-                                nv84_fifo_create(dev);
-                        break;
-                case NV_C0:
-                case NV_D0:
-                        nvc0_fifo_create(dev);
-                        break;
-                case NV_E0:
-                        nve0_fifo_create(dev);
-                        break;
-                default:
-                        break;
-                }
-
-                switch (dev_priv->card_type) {
-                case NV_04:
-                        nv04_fence_create(dev);
-                        break;
-                case NV_10:
-                case NV_20:
-                case NV_30:
-                case NV_40:
-                case NV_50:
-                        if (dev_priv->chipset < 0x84)
-                                nv10_fence_create(dev);
-                        else
-                                nv84_fence_create(dev);
-                        break;
-                case NV_C0:
-                case NV_D0:
-                case NV_E0:
-                        nvc0_fence_create(dev);
-                        break;
-                default:
-                        break;
-                }
-
-                switch (dev_priv->card_type) {
-                case NV_04:
-                case NV_10:
-                case NV_20:
-                case NV_30:
-                case NV_40:
-                        nv04_software_create(dev);
-                        break;
-                case NV_50:
-                        nv50_software_create(dev);
-                        break;
-                case NV_C0:
-                case NV_D0:
-                case NV_E0:
-                        nvc0_software_create(dev);
-                        break;
-                default:
-                        break;
-                }
-
-                switch (dev_priv->card_type) {
-                case NV_04:
-                        nv04_graph_create(dev);
-                        break;
-                case NV_10:
-                        nv10_graph_create(dev);
-                        break;
-                case NV_20:
-                case NV_30:
-                        nv20_graph_create(dev);
-                        break;
-                case NV_40:
-                        nv40_graph_create(dev);
-                        break;
-                case NV_50:
-                        nv50_graph_create(dev);
-                        break;
-                case NV_C0:
-                case NV_D0:
-                        nvc0_graph_create(dev);
-                        break;
-                case NV_E0:
-                        nve0_graph_create(dev);
-                        break;
-                default:
-                        break;
-                }
-
-                switch (dev_priv->chipset) {
-                case 0x84:
-                case 0x86:
-                case 0x92:
-                case 0x94:
-                case 0x96:
-                case 0xa0:
-                        nv84_crypt_create(dev);
-                        break;
-                case 0x98:
-                case 0xaa:
-                case 0xac:
-                        nv98_crypt_create(dev);
-                        break;
-                }
-
-                switch (dev_priv->card_type) {
-                case NV_50:
-                        switch (dev_priv->chipset) {
-                        case 0xa3:
-                        case 0xa5:
-                        case 0xa8:
-                                nva3_copy_create(dev);
-                                break;
-                        }
-                        break;
-                case NV_C0:
-                        if (!(nv_rd32(dev, 0x022500) & 0x00000200))
-                                nvc0_copy_create(dev, 1);
-                case NV_D0:
-                        if (!(nv_rd32(dev, 0x022500) & 0x00000100))
-                                nvc0_copy_create(dev, 0);
-                        break;
-                default:
-                        break;
-                }
-
-                if (dev_priv->chipset >= 0xa3 || dev_priv->chipset == 0x98) {
-                        nv84_bsp_create(dev);
-                        nv84_vp_create(dev);
-                        nv98_ppp_create(dev);
-                } else
-                if (dev_priv->chipset >= 0x84) {
-                        nv50_mpeg_create(dev);
-                        nv84_bsp_create(dev);
-                        nv84_vp_create(dev);
-                } else
-                if (dev_priv->chipset >= 0x50) {
-                        nv50_mpeg_create(dev);
-                } else
-                if (dev_priv->card_type == NV_40 ||
-                    dev_priv->chipset == 0x31 ||
-                    dev_priv->chipset == 0x34 ||
-                    dev_priv->chipset == 0x36) {
-                        nv31_mpeg_create(dev);
-                }
-
-                for (e = 0; e < NVOBJ_ENGINE_NR; e++) {
-                        if (dev_priv->eng[e]) {
-                                ret = dev_priv->eng[e]->init(dev, e);
-                                if (ret)
-                                        goto out_engine;
-                        }
-                }
-        }
-
-        ret = nouveau_irq_init(dev);
-        if (ret)
-                goto out_engine;
-
-        ret = nouveau_display_create(dev);
-        if (ret)
-                goto out_irq;
-
-        nouveau_backlight_init(dev);
-        nouveau_pm_init(dev);
-
-        if (dev_priv->eng[NVOBJ_ENGINE_GR]) {
-                ret = nouveau_card_channel_init(dev);
-                if (ret)
-                        goto out_pm;
-        }
-
-        if (dev->mode_config.num_crtc) {
-                ret = nouveau_display_init(dev);
-                if (ret)
-                        goto out_chan;
-
-                nouveau_fbcon_init(dev);
-        }
-
-        return 0;
-
-out_chan:
-        nouveau_card_channel_fini(dev);
-out_pm:
-        nouveau_pm_fini(dev);
-        nouveau_backlight_exit(dev);
-        nouveau_display_destroy(dev);
-out_irq:
-        nouveau_irq_fini(dev);
-out_engine:
-        if (!dev_priv->noaccel) {
-                for (e = e - 1; e >= 0; e--) {
-                        if (!dev_priv->eng[e])
-                                continue;
-                        dev_priv->eng[e]->fini(dev, e, false);
-                        dev_priv->eng[e]->destroy(dev,e );
-                }
-        }
-        nouveau_mem_gart_fini(dev);
-out_ttmvram:
-        nouveau_mem_vram_fini(dev);
-out_instmem:
-        engine->instmem.takedown(dev);
-out_gpuobj:
-        nouveau_gpuobj_takedown(dev);
-out_gpio:
-        nouveau_gpio_destroy(dev);
-out_vram:
-        engine->vram.takedown(dev);
-out_fb:
-        engine->fb.takedown(dev);
-out_timer:
-        engine->timer.takedown(dev);
-out_mc:
-        engine->mc.takedown(dev);
-out_bios:
-        nouveau_bios_takedown(dev);
-out_display_early:
-        engine->display.late_takedown(dev);
-out:
-        vga_switcheroo_unregister_client(dev->pdev);
-        vga_client_register(dev->pdev, NULL, NULL, NULL);
-        return ret;
-}
-
-static void nouveau_card_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_engine *engine = &dev_priv->engine;
-        int e;
-
-        if (dev->mode_config.num_crtc) {
-                nouveau_fbcon_fini(dev);
-                nouveau_display_fini(dev);
-        }
-
-        nouveau_card_channel_fini(dev);
-        nouveau_pm_fini(dev);
-        nouveau_backlight_exit(dev);
-        nouveau_display_destroy(dev);
-
-        if (!dev_priv->noaccel) {
-                for (e = NVOBJ_ENGINE_NR - 1; e >= 0; e--) {
-                        if (dev_priv->eng[e]) {
-                                dev_priv->eng[e]->fini(dev, e, false);
-                                dev_priv->eng[e]->destroy(dev,e );
-                        }
-                }
-        }
-
-        if (dev_priv->vga_ram) {
-                nouveau_bo_unpin(dev_priv->vga_ram);
-                nouveau_bo_ref(NULL, &dev_priv->vga_ram);
-        }
-
-        mutex_lock(&dev->struct_mutex);
-        ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_VRAM);
-        ttm_bo_clean_mm(&dev_priv->ttm.bdev, TTM_PL_TT);
-        mutex_unlock(&dev->struct_mutex);
-        nouveau_mem_gart_fini(dev);
-        nouveau_mem_vram_fini(dev);
-
-        engine->instmem.takedown(dev);
-        nouveau_gpuobj_takedown(dev);
-
-        nouveau_gpio_destroy(dev);
-        engine->vram.takedown(dev);
-        engine->fb.takedown(dev);
-        engine->timer.takedown(dev);
-        engine->mc.takedown(dev);
-
-        nouveau_bios_takedown(dev);
-        engine->display.late_takedown(dev);
-
-        nouveau_irq_fini(dev);
-
-        vga_switcheroo_unregister_client(dev->pdev);
-        vga_client_register(dev->pdev, NULL, NULL, NULL);
-}
-
-int
-nouveau_open(struct drm_device *dev, struct drm_file *file_priv)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fpriv *fpriv;
-        int ret;
-
-        fpriv = kzalloc(sizeof(*fpriv), GFP_KERNEL);
-        if (unlikely(!fpriv))
-                return -ENOMEM;
-
-        spin_lock_init(&fpriv->lock);
-        INIT_LIST_HEAD(&fpriv->channels);
-
-        if (dev_priv->card_type == NV_50) {
-                ret = nouveau_vm_new(dev, 0, (1ULL << 40), 0x0020000000ULL,
-                                     &fpriv->vm);
-                if (ret) {
-                        kfree(fpriv);
-                        return ret;
-                }
-        } else
-        if (dev_priv->card_type >= NV_C0) {
-                ret = nouveau_vm_new(dev, 0, (1ULL << 40), 0x0008000000ULL,
-                                     &fpriv->vm);
-                if (ret) {
-                        kfree(fpriv);
-                        return ret;
-                }
-        }
-
-        file_priv->driver_priv = fpriv;
-        return 0;
-}
-
-/* here a client dies, release the stuff that was allocated for its
- * file_priv */
-void nouveau_preclose(struct drm_device *dev, struct drm_file *file_priv)
-{
-        nouveau_channel_cleanup(dev, file_priv);
-}
-
-void
-nouveau_postclose(struct drm_device *dev, struct drm_file *file_priv)
-{
-        struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
-        nouveau_vm_ref(NULL, &fpriv->vm, NULL);
-        kfree(fpriv);
-}
-
-/* first module load, setup the mmio/fb mapping */
-/* KMS: we need mmio at load time, not when the first drm client opens. */
-int nouveau_firstopen(struct drm_device *dev)
-{
-        return 0;
-}
-
-/* if we have an OF card, copy vbios to RAMIN */
-static void nouveau_OF_copy_vbios_to_ramin(struct drm_device *dev)
-{
-#if defined(__powerpc__)
-        int size, i;
-        const uint32_t *bios;
-        struct device_node *dn = pci_device_to_OF_node(dev->pdev);
-        if (!dn) {
-                NV_INFO(dev, "Unable to get the OF node\n");
-                return;
-        }
-
-        bios = of_get_property(dn, "NVDA,BMP", &size);
-        if (bios) {
-                for (i = 0; i < size; i += 4)
-                        nv_wi32(dev, i, bios[i/4]);
-                NV_INFO(dev, "OF bios successfully copied (%d bytes)\n", size);
-        } else {
-                NV_INFO(dev, "Unable to get the OF bios\n");
-        }
-#endif
-}
-
-static struct apertures_struct *nouveau_get_apertures(struct drm_device *dev)
-{
-        struct pci_dev *pdev = dev->pdev;
-        struct apertures_struct *aper = alloc_apertures(3);
-        if (!aper)
-                return NULL;
-
-        aper->ranges[0].base = pci_resource_start(pdev, 1);
-        aper->ranges[0].size = pci_resource_len(pdev, 1);
-        aper->count = 1;
-
-        if (pci_resource_len(pdev, 2)) {
-                aper->ranges[aper->count].base = pci_resource_start(pdev, 2);
-                aper->ranges[aper->count].size = pci_resource_len(pdev, 2);
-                aper->count++;
-        }
-
-        if (pci_resource_len(pdev, 3)) {
-                aper->ranges[aper->count].base = pci_resource_start(pdev, 3);
-                aper->ranges[aper->count].size = pci_resource_len(pdev, 3);
-                aper->count++;
-        }
-
-        return aper;
-}
-
-static int nouveau_remove_conflicting_drivers(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        bool primary = false;
-        dev_priv->apertures = nouveau_get_apertures(dev);
-        if (!dev_priv->apertures)
-                return -ENOMEM;
-
-#ifdef CONFIG_X86
-        primary = dev->pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
-#endif
-
-        remove_conflicting_framebuffers(dev_priv->apertures, "nouveaufb", primary);
-        return 0;
-}
-
-int nouveau_load(struct drm_device *dev, unsigned long flags)
-{
-        struct drm_nouveau_private *dev_priv;
-        unsigned long long offset, length;
-        uint32_t reg0 = ~0, strap;
-        int ret;
-
-        dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
-        if (!dev_priv) {
-                ret = -ENOMEM;
-                goto err_out;
-        }
-        dev->dev_private = dev_priv;
-        dev_priv->dev = dev;
-
-        pci_set_master(dev->pdev);
-
-        dev_priv->flags = flags & NOUVEAU_FLAGS;
-
-        NV_DEBUG(dev, "vendor: 0x%X device: 0x%X class: 0x%X\n",
-                 dev->pci_vendor, dev->pci_device, dev->pdev->class);
-
-        /* first up, map the start of mmio and determine the chipset */
-        dev_priv->mmio = ioremap(pci_resource_start(dev->pdev, 0), PAGE_SIZE);
-        if (dev_priv->mmio) {
-#ifdef __BIG_ENDIAN
-                /* put the card into big-endian mode if it's not */
-                if (nv_rd32(dev, NV03_PMC_BOOT_1) != 0x01000001)
-                        nv_wr32(dev, NV03_PMC_BOOT_1, 0x01000001);
-                DRM_MEMORYBARRIER();
-#endif
-
-                /* determine chipset and derive architecture from it */
-                reg0 = nv_rd32(dev, NV03_PMC_BOOT_0);
-                if ((reg0 & 0x0f000000) > 0) {
-                        dev_priv->chipset = (reg0 & 0xff00000) >> 20;
-                        switch (dev_priv->chipset & 0xf0) {
-                        case 0x10:
-                        case 0x20:
-                        case 0x30:
-                                dev_priv->card_type = dev_priv->chipset & 0xf0;
-                                break;
-                        case 0x40:
-                        case 0x60:
-                                dev_priv->card_type = NV_40;
-                                break;
-                        case 0x50:
-                        case 0x80:
-                        case 0x90:
-                        case 0xa0:
-                                dev_priv->card_type = NV_50;
-                                break;
-                        case 0xc0:
-                                dev_priv->card_type = NV_C0;
-                                break;
-                        case 0xd0:
-                                dev_priv->card_type = NV_D0;
-                                break;
-                        case 0xe0:
-                                dev_priv->card_type = NV_E0;
-                                break;
-                        default:
-                                break;
-                        }
-                } else
-                if ((reg0 & 0xff00fff0) == 0x20004000) {
-                        if (reg0 & 0x00f00000)
-                                dev_priv->chipset = 0x05;
-                        else
-                                dev_priv->chipset = 0x04;
-                        dev_priv->card_type = NV_04;
-                }
-
-                iounmap(dev_priv->mmio);
-        }
-
-        if (!dev_priv->card_type) {
-                NV_ERROR(dev, "unsupported chipset 0x%08x\n", reg0);
-                ret = -EINVAL;
-                goto err_priv;
-        }
-
-        NV_INFO(dev, "Detected an NV%02x generation card (0x%08x)\n",
-                     dev_priv->card_type, reg0);
-
-        /* map the mmio regs, limiting the amount to preserve vmap space */
-        offset = pci_resource_start(dev->pdev, 0);
-        length = pci_resource_len(dev->pdev, 0);
-        if (dev_priv->card_type < NV_E0)
-                length = min(length, (unsigned long long)0x00800000);
-
-        dev_priv->mmio = ioremap(offset, length);
-        if (!dev_priv->mmio) {
-                NV_ERROR(dev, "Unable to initialize the mmio mapping. "
-                         "Please report your setup to " DRIVER_EMAIL "\n");
-                ret = -EINVAL;
-                goto err_priv;
-        }
-        NV_DEBUG(dev, "regs mapped ok at 0x%llx\n", offset);
-
-        /* determine frequency of timing crystal */
-        strap = nv_rd32(dev, 0x101000);
-        if ( dev_priv->chipset < 0x17 ||
-            (dev_priv->chipset >= 0x20 && dev_priv->chipset <= 0x25))
-                strap &= 0x00000040;
-        else
-                strap &= 0x00400040;
-
-        switch (strap) {
-        case 0x00000000: dev_priv->crystal = 13500; break;
-        case 0x00000040: dev_priv->crystal = 14318; break;
-        case 0x00400000: dev_priv->crystal = 27000; break;
-        case 0x00400040: dev_priv->crystal = 25000; break;
-        }
-
-        NV_DEBUG(dev, "crystal freq: %dKHz\n", dev_priv->crystal);
-
-        /* Determine whether we'll attempt acceleration or not, some
-         * cards are disabled by default here due to them being known
-         * non-functional, or never been tested due to lack of hw.
-         */
-        dev_priv->noaccel = !!nouveau_noaccel;
-        if (nouveau_noaccel == -1) {
-                switch (dev_priv->chipset) {
-                case 0xd9: /* known broken */
-                case 0xe4: /* needs binary driver firmware */
-                case 0xe7: /* needs binary driver firmware */
-                        NV_INFO(dev, "acceleration disabled by default, pass "
-                                     "noaccel=0 to force enable\n");
-                        dev_priv->noaccel = true;
-                        break;
-                default:
-                        dev_priv->noaccel = false;
-                        break;
-                }
-        }
-
-        ret = nouveau_remove_conflicting_drivers(dev);
-        if (ret)
-                goto err_mmio;
-
-        /* Map PRAMIN BAR, or on older cards, the aperture within BAR0 */
-        if (dev_priv->card_type >= NV_40) {
-                int ramin_bar = 2;
-                if (pci_resource_len(dev->pdev, ramin_bar) == 0)
-                        ramin_bar = 3;
-
-                dev_priv->ramin_size = pci_resource_len(dev->pdev, ramin_bar);
-                dev_priv->ramin =
-                        ioremap(pci_resource_start(dev->pdev, ramin_bar),
-                                dev_priv->ramin_size);
-                if (!dev_priv->ramin) {
-                        NV_ERROR(dev, "Failed to map PRAMIN BAR\n");
-                        ret = -ENOMEM;
-                        goto err_mmio;
-                }
-        } else {
-                dev_priv->ramin_size = 1 * 1024 * 1024;
-                dev_priv->ramin = ioremap(offset + NV_RAMIN,
-                                          dev_priv->ramin_size);
-                if (!dev_priv->ramin) {
-                        NV_ERROR(dev, "Failed to map BAR0 PRAMIN.\n");
-                        ret = -ENOMEM;
-                        goto err_mmio;
-                }
-        }
-
-        nouveau_OF_copy_vbios_to_ramin(dev);
-
-        /* Special flags */
-        if (dev->pci_device == 0x01a0)
-                dev_priv->flags |= NV_NFORCE;
-        else if (dev->pci_device == 0x01f0)
-                dev_priv->flags |= NV_NFORCE2;
-
-        /* For kernel modesetting, init card now and bring up fbcon */
-        ret = nouveau_card_init(dev);
-        if (ret)
-                goto err_ramin;
-
-        return 0;
-
-err_ramin:
-        iounmap(dev_priv->ramin);
-err_mmio:
-        iounmap(dev_priv->mmio);
-err_priv:
-        kfree(dev_priv);
-        dev->dev_private = NULL;
-err_out:
-        return ret;
-}
-
-void nouveau_lastclose(struct drm_device *dev)
-{
-        vga_switcheroo_process_delayed_switch();
-}
-
-int nouveau_unload(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nouveau_card_takedown(dev);
-
-        iounmap(dev_priv->mmio);
-        iounmap(dev_priv->ramin);
-
-        kfree(dev_priv);
-        dev->dev_private = NULL;
-        return 0;
-}
-
-/* Wait until (value(reg) & mask) == val, up until timeout has hit */
-bool
-nouveau_wait_eq(struct drm_device *dev, uint64_t timeout,
-                uint32_t reg, uint32_t mask, uint32_t val)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
-        uint64_t start = ptimer->read(dev);
-
-        do {
-                if ((nv_rd32(dev, reg) & mask) == val)
-                        return true;
-        } while (ptimer->read(dev) - start < timeout);
-
-        return false;
-}
-
-/* Wait until (value(reg) & mask) != val, up until timeout has hit */
-bool
-nouveau_wait_ne(struct drm_device *dev, uint64_t timeout,
-                uint32_t reg, uint32_t mask, uint32_t val)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
-        uint64_t start = ptimer->read(dev);
-
-        do {
-                if ((nv_rd32(dev, reg) & mask) != val)
-                        return true;
-        } while (ptimer->read(dev) - start < timeout);
-
-        return false;
-}
-
-/* Wait until cond(data) == true, up until timeout has hit */
-bool
-nouveau_wait_cb(struct drm_device *dev, u64 timeout,
-                bool (*cond)(void *), void *data)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
-        u64 start = ptimer->read(dev);
-
-        do {
-                if (cond(data) == true)
-                        return true;
-        } while (ptimer->read(dev) - start < timeout);
-
-        return false;
-}
-
-/* Waits for PGRAPH to go completely idle */
-bool nouveau_wait_for_idle(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t mask = ~0;
-
-        if (dev_priv->card_type == NV_40)
-                mask &= ~NV40_PGRAPH_STATUS_SYNC_STALL;
-
-        if (!nv_wait(dev, NV04_PGRAPH_STATUS, mask, 0)) {
-                NV_ERROR(dev, "PGRAPH idle timed out with status 0x%08x\n",
-                         nv_rd32(dev, NV04_PGRAPH_STATUS));
-                return false;
-        }
-
-        return true;
-}
-
diff --git a/drivers/gpu/drm/nouveau/nouveau_temp.c b/drivers/gpu/drm/nouveau/nouveau_temp.c
deleted file mode 100644
index 0f5a30160556..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_temp.c
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * Copyright 2010 PathScale 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: Martin Peres
- */
-
-#include <linux/module.h>
-
-#include "drmP.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_pm.h"
-
-static void
-nouveau_temp_vbios_parse(struct drm_device *dev, u8 *temp)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
-        struct nouveau_pm_threshold_temp *temps = &pm->threshold_temp;
-        int i, headerlen, recordlen, entries;
-
-        if (!temp) {
-                NV_DEBUG(dev, "temperature table pointer invalid\n");
-                return;
-        }
-
-        /* Set the default sensor's contants */
-        sensor->offset_constant = 0;
-        sensor->offset_mult = 0;
-        sensor->offset_div = 1;
-        sensor->slope_mult = 1;
-        sensor->slope_div = 1;
-
-        /* Set the default temperature thresholds */
-        temps->critical = 110;
-        temps->down_clock = 100;
-        temps->fan_boost = 90;
-
-        /* Set the default range for the pwm fan */
-        pm->fan.min_duty = 30;
-        pm->fan.max_duty = 100;
-
-        /* Set the known default values to setup the temperature sensor */
-        if (dev_priv->card_type >= NV_40) {
-                switch (dev_priv->chipset) {
-                case 0x43:
-                        sensor->offset_mult = 32060;
-                        sensor->offset_div = 1000;
-                        sensor->slope_mult = 792;
-                        sensor->slope_div = 1000;
-                        break;
-
-                case 0x44:
-                case 0x47:
-                case 0x4a:
-                        sensor->offset_mult = 27839;
-                        sensor->offset_div = 1000;
-                        sensor->slope_mult = 780;
-                        sensor->slope_div = 1000;
-                        break;
-
-                case 0x46:
-                        sensor->offset_mult = -24775;
-                        sensor->offset_div = 100;
-                        sensor->slope_mult = 467;
-                        sensor->slope_div = 10000;
-                        break;
-
-                case 0x49:
-                        sensor->offset_mult = -25051;
-                        sensor->offset_div = 100;
-                        sensor->slope_mult = 458;
-                        sensor->slope_div = 10000;
-                        break;
-
-                case 0x4b:
-                        sensor->offset_mult = -24088;
-                        sensor->offset_div = 100;
-                        sensor->slope_mult = 442;
-                        sensor->slope_div = 10000;
-                        break;
-
-                case 0x50:
-                        sensor->offset_mult = -22749;
-                        sensor->offset_div = 100;
-                        sensor->slope_mult = 431;
-                        sensor->slope_div = 10000;
-                        break;
-
-                case 0x67:
-                        sensor->offset_mult = -26149;
-                        sensor->offset_div = 100;
-                        sensor->slope_mult = 484;
-                        sensor->slope_div = 10000;
-                        break;
-                }
-        }
-
-        headerlen = temp[1];
-        recordlen = temp[2];
-        entries = temp[3];
-        temp = temp + headerlen;
-
-        /* Read the entries from the table */
-        for (i = 0; i < entries; i++) {
-                s16 value = ROM16(temp[1]);
-
-                switch (temp[0]) {
-                case 0x01:
-                        if ((value & 0x8f) == 0)
-                                sensor->offset_constant = (value >> 9) & 0x7f;
-                        break;
-
-                case 0x04:
-                        if ((value & 0xf00f) == 0xa000) /* core */
-                                temps->critical = (value&0x0ff0) >> 4;
-                        break;
-
-                case 0x07:
-                        if ((value & 0xf00f) == 0xa000) /* core */
-                                temps->down_clock = (value&0x0ff0) >> 4;
-                        break;
-
-                case 0x08:
-                        if ((value & 0xf00f) == 0xa000) /* core */
-                                temps->fan_boost = (value&0x0ff0) >> 4;
-                        break;
-
-                case 0x10:
-                        sensor->offset_mult = value;
-                        break;
-
-                case 0x11:
-                        sensor->offset_div = value;
-                        break;
-
-                case 0x12:
-                        sensor->slope_mult = value;
-                        break;
-
-                case 0x13:
-                        sensor->slope_div = value;
-                        break;
-                case 0x22:
-                        pm->fan.min_duty = value & 0xff;
-                        pm->fan.max_duty = (value & 0xff00) >> 8;
-                        break;
-                case 0x26:
-                        pm->fan.pwm_freq = value;
-                        break;
-                }
-                temp += recordlen;
-        }
-
-        nouveau_temp_safety_checks(dev);
-
-        /* check the fan min/max settings */
-        if (pm->fan.min_duty < 10)
-                pm->fan.min_duty = 10;
-        if (pm->fan.max_duty > 100)
-                pm->fan.max_duty = 100;
-        if (pm->fan.max_duty < pm->fan.min_duty)
-                pm->fan.max_duty = pm->fan.min_duty;
-}
-
-static int
-nv40_sensor_setup(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
-        s32 offset = sensor->offset_mult / sensor->offset_div;
-        s32 sensor_calibration;
-
-        /* set up the sensors */
-        sensor_calibration = 120 - offset - sensor->offset_constant;
-        sensor_calibration = sensor_calibration * sensor->slope_div /
-                                sensor->slope_mult;
-
-        if (dev_priv->chipset >= 0x46)
-                sensor_calibration |= 0x80000000;
-        else
-                sensor_calibration |= 0x10000000;
-
-        nv_wr32(dev, 0x0015b0, sensor_calibration);
-
-        /* Wait for the sensor to update */
-        msleep(5);
-
-        /* read */
-        return nv_rd32(dev, 0x0015b4) & 0x1fff;
-}
-
-int
-nv40_temp_get(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
-        int offset = sensor->offset_mult / sensor->offset_div;
-        int core_temp;
-
-        if (dev_priv->card_type >= NV_50) {
-                core_temp = nv_rd32(dev, 0x20008);
-        } else {
-                core_temp = nv_rd32(dev, 0x0015b4) & 0x1fff;
-                /* Setup the sensor if the temperature is 0 */
-                if (core_temp == 0)
-                        core_temp = nv40_sensor_setup(dev);
-        }
-
-        core_temp = core_temp * sensor->slope_mult / sensor->slope_div;
-        core_temp = core_temp + offset + sensor->offset_constant;
-
-        return core_temp;
-}
-
-int
-nv84_temp_get(struct drm_device *dev)
-{
-        return nv_rd32(dev, 0x20400);
-}
-
-void
-nouveau_temp_safety_checks(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
-        struct nouveau_pm_threshold_temp *temps = &pm->threshold_temp;
-
-        if (temps->critical > 120)
-                temps->critical = 120;
-        else if (temps->critical < 80)
-                temps->critical = 80;
-
-        if (temps->down_clock > 110)
-                temps->down_clock = 110;
-        else if (temps->down_clock < 60)
-                temps->down_clock = 60;
-
-        if (temps->fan_boost > 100)
-                temps->fan_boost = 100;
-        else if (temps->fan_boost < 40)
-                temps->fan_boost = 40;
-}
-
-static bool
-probe_monitoring_device(struct nouveau_i2c_chan *i2c,
-                        struct i2c_board_info *info)
-{
-        struct i2c_client *client;
-
-        request_module("%s%s", I2C_MODULE_PREFIX, info->type);
-
-        client = i2c_new_device(&i2c->adapter, info);
-        if (!client)
-                return false;
-
-        if (!client->driver || client->driver->detect(client, info)) {
-                i2c_unregister_device(client);
-                return false;
-        }
-
-        return true;
-}
-
-static void
-nouveau_temp_probe_i2c(struct drm_device *dev)
-{
-        struct i2c_board_info info[] = {
-                { I2C_BOARD_INFO("w83l785ts", 0x2d) },
-                { I2C_BOARD_INFO("w83781d", 0x2d) },
-                { I2C_BOARD_INFO("adt7473", 0x2e) },
-                { I2C_BOARD_INFO("f75375", 0x2e) },
-                { I2C_BOARD_INFO("lm99", 0x4c) },
-                { }
-        };
-
-        nouveau_i2c_identify(dev, "monitoring device", info,
-                             probe_monitoring_device, NV_I2C_DEFAULT(0));
-}
-
-void
-nouveau_temp_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvbios *bios = &dev_priv->vbios;
-        struct bit_entry P;
-        u8 *temp = NULL;
-
-        if (bios->type == NVBIOS_BIT) {
-                if (bit_table(dev, 'P', &P))
-                        return;
-
-                if (P.version == 1)
-                        temp = ROMPTR(dev, P.data[12]);
-                else if (P.version == 2)
-                        temp = ROMPTR(dev, P.data[16]);
-                else
-                        NV_WARN(dev, "unknown temp for BIT P %d\n", P.version);
-
-                nouveau_temp_vbios_parse(dev, temp);
-        }
-
-        nouveau_temp_probe_i2c(dev);
-}
-
-void
-nouveau_temp_fini(struct drm_device *dev)
-{
-
-}
diff --git a/drivers/gpu/drm/nouveau/nouveau_ttm.c b/drivers/gpu/drm/nouveau/nouveau_ttm.c
index bd35f930568c..9be9cb58e19b 100644
--- a/drivers/gpu/drm/nouveau/nouveau_ttm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_ttm.c
@@ -24,21 +24,253 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include "drmP.h"
+#include <subdev/fb.h>
+#include <subdev/vm.h>
+#include <subdev/instmem.h>
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_ttm.h"
+#include "nouveau_gem.h"
+
+static int
+nouveau_vram_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
+{
+        /* nothing to do */
+        return 0;
+}
+
+static int
+nouveau_vram_manager_fini(struct ttm_mem_type_manager *man)
+{
+        /* nothing to do */
+        return 0;
+}
+
+static inline void
+nouveau_mem_node_cleanup(struct nouveau_mem *node)
+{
+        if (node->vma[0].node) {
+                nouveau_vm_unmap(&node->vma[0]);
+                nouveau_vm_put(&node->vma[0]);
+        }
+
+        if (node->vma[1].node) {
+                nouveau_vm_unmap(&node->vma[1]);
+                nouveau_vm_put(&node->vma[1]);
+        }
+}
+
+static void
+nouveau_vram_manager_del(struct ttm_mem_type_manager *man,
+                         struct ttm_mem_reg *mem)
+{
+        struct nouveau_drm *drm = nouveau_bdev(man->bdev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
+        nouveau_mem_node_cleanup(mem->mm_node);
+        pfb->ram.put(pfb, (struct nouveau_mem **)&mem->mm_node);
+}
+
+static int
+nouveau_vram_manager_new(struct ttm_mem_type_manager *man,
+                         struct ttm_buffer_object *bo,
+                         struct ttm_placement *placement,
+                         struct ttm_mem_reg *mem)
+{
+        struct nouveau_drm *drm = nouveau_bdev(man->bdev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
+        struct nouveau_bo *nvbo = nouveau_bo(bo);
+        struct nouveau_mem *node;
+        u32 size_nc = 0;
+        int ret;
+
+        if (nvbo->tile_flags & NOUVEAU_GEM_TILE_NONCONTIG)
+                size_nc = 1 << nvbo->page_shift;
+
+        ret = pfb->ram.get(pfb, mem->num_pages << PAGE_SHIFT,
+                           mem->page_alignment << PAGE_SHIFT, size_nc,
+                           (nvbo->tile_flags >> 8) & 0x3ff, &node);
+        if (ret) {
+                mem->mm_node = NULL;
+                return (ret == -ENOSPC) ? 0 : ret;
+        }
+
+        node->page_shift = nvbo->page_shift;
+
+        mem->mm_node = node;
+        mem->start   = node->offset >> PAGE_SHIFT;
+        return 0;
+}
+
+static void
+nouveau_vram_manager_debug(struct ttm_mem_type_manager *man, const char *prefix)
+{
+        struct nouveau_mm *mm = man->priv;
+        struct nouveau_mm_node *r;
+        u32 total = 0, free = 0;
+
+        mutex_lock(&mm->mutex);
+        list_for_each_entry(r, &mm->nodes, nl_entry) {
+                printk(KERN_DEBUG "%s %d: 0x%010llx 0x%010llx\n",
+                       prefix, r->type, ((u64)r->offset << 12),
+                       (((u64)r->offset + r->length) << 12));
+
+                total += r->length;
+                if (!r->type)
+                        free += r->length;
+        }
+        mutex_unlock(&mm->mutex);
+
+        printk(KERN_DEBUG "%s  total: 0x%010llx free: 0x%010llx\n",
+               prefix, (u64)total << 12, (u64)free << 12);
+        printk(KERN_DEBUG "%s  block: 0x%08x\n",
+               prefix, mm->block_size << 12);
+}
+
+const struct ttm_mem_type_manager_func nouveau_vram_manager = {
+        nouveau_vram_manager_init,
+        nouveau_vram_manager_fini,
+        nouveau_vram_manager_new,
+        nouveau_vram_manager_del,
+        nouveau_vram_manager_debug
+};
+
+static int
+nouveau_gart_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
+{
+        return 0;
+}
+
+static int
+nouveau_gart_manager_fini(struct ttm_mem_type_manager *man)
+{
+        return 0;
+}
+
+static void
+nouveau_gart_manager_del(struct ttm_mem_type_manager *man,
+                         struct ttm_mem_reg *mem)
+{
+        nouveau_mem_node_cleanup(mem->mm_node);
+        kfree(mem->mm_node);
+        mem->mm_node = NULL;
+}
+
+static int
+nouveau_gart_manager_new(struct ttm_mem_type_manager *man,
+                         struct ttm_buffer_object *bo,
+                         struct ttm_placement *placement,
+                         struct ttm_mem_reg *mem)
+{
+        struct nouveau_mem *node;
+
+        if (unlikely((mem->num_pages << PAGE_SHIFT) >= 512 * 1024 * 1024))
+                return -ENOMEM;
+
+        node = kzalloc(sizeof(*node), GFP_KERNEL);
+        if (!node)
+                return -ENOMEM;
+        node->page_shift = 12;
+
+        mem->mm_node = node;
+        mem->start   = 0;
+        return 0;
+}
+
+static void
+nouveau_gart_manager_debug(struct ttm_mem_type_manager *man, const char *prefix)
+{
+}
+
+const struct ttm_mem_type_manager_func nouveau_gart_manager = {
+        nouveau_gart_manager_init,
+        nouveau_gart_manager_fini,
+        nouveau_gart_manager_new,
+        nouveau_gart_manager_del,
+        nouveau_gart_manager_debug
+};
+
+#include <core/subdev/vm/nv04.h>
+static int
+nv04_gart_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
+{
+        struct nouveau_drm *drm = nouveau_bdev(man->bdev);
+        struct nouveau_vmmgr *vmm = nouveau_vmmgr(drm->device);
+        struct nv04_vmmgr_priv *priv = (void *)vmm;
+        struct nouveau_vm *vm = NULL;
+        nouveau_vm_ref(priv->vm, &vm, NULL);
+        man->priv = vm;
+        return 0;
+}
+
+static int
+nv04_gart_manager_fini(struct ttm_mem_type_manager *man)
+{
+        struct nouveau_vm *vm = man->priv;
+        nouveau_vm_ref(NULL, &vm, NULL);
+        man->priv = NULL;
+        return 0;
+}
+
+static void
+nv04_gart_manager_del(struct ttm_mem_type_manager *man, struct ttm_mem_reg *mem)
+{
+        struct nouveau_mem *node = mem->mm_node;
+        if (node->vma[0].node)
+                nouveau_vm_put(&node->vma[0]);
+        kfree(mem->mm_node);
+        mem->mm_node = NULL;
+}
+
+static int
+nv04_gart_manager_new(struct ttm_mem_type_manager *man,
+                      struct ttm_buffer_object *bo,
+                      struct ttm_placement *placement,
+                      struct ttm_mem_reg *mem)
+{
+        struct nouveau_mem *node;
+        int ret;
+
+        node = kzalloc(sizeof(*node), GFP_KERNEL);
+        if (!node)
+                return -ENOMEM;
+
+        node->page_shift = 12;
+
+        ret = nouveau_vm_get(man->priv, mem->num_pages << 12, node->page_shift,
+                             NV_MEM_ACCESS_RW, &node->vma[0]);
+        if (ret) {
+                kfree(node);
+                return ret;
+        }
+
+        mem->mm_node = node;
+        mem->start   = node->vma[0].offset >> PAGE_SHIFT;
+        return 0;
+}
+
+static void
+nv04_gart_manager_debug(struct ttm_mem_type_manager *man, const char *prefix)
+{
+}
+
+const struct ttm_mem_type_manager_func nv04_gart_manager = {
+        nv04_gart_manager_init,
+        nv04_gart_manager_fini,
+        nv04_gart_manager_new,
+        nv04_gart_manager_del,
+        nv04_gart_manager_debug
+};
 
 int
 nouveau_ttm_mmap(struct file *filp, struct vm_area_struct *vma)
 {
         struct drm_file *file_priv = filp->private_data;
-        struct drm_nouveau_private *dev_priv =
-                file_priv->minor->dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(file_priv->minor->dev);
 
         if (unlikely(vma->vm_pgoff < DRM_FILE_PAGE_OFFSET))
                 return drm_mmap(filp, vma);
 
-        return ttm_bo_mmap(filp, vma, &dev_priv->ttm.bdev);
+        return ttm_bo_mmap(filp, vma, &drm->ttm.bdev);
 }
 
 static int
@@ -54,12 +286,12 @@ nouveau_ttm_mem_global_release(struct drm_global_reference *ref)
 }
 
 int
-nouveau_ttm_global_init(struct drm_nouveau_private *dev_priv)
+nouveau_ttm_global_init(struct nouveau_drm *drm)
 {
         struct drm_global_reference *global_ref;
         int ret;
 
-        global_ref = &dev_priv->ttm.mem_global_ref;
+        global_ref = &drm->ttm.mem_global_ref;
         global_ref->global_type = DRM_GLOBAL_TTM_MEM;
         global_ref->size = sizeof(struct ttm_mem_global);
         global_ref->init = &nouveau_ttm_mem_global_init;
@@ -68,12 +300,12 @@ nouveau_ttm_global_init(struct drm_nouveau_private *dev_priv)
         ret = drm_global_item_ref(global_ref);
         if (unlikely(ret != 0)) {
                 DRM_ERROR("Failed setting up TTM memory accounting\n");
-                dev_priv->ttm.mem_global_ref.release = NULL;
+                drm->ttm.mem_global_ref.release = NULL;
                 return ret;
         }
 
-        dev_priv->ttm.bo_global_ref.mem_glob = global_ref->object;
-        global_ref = &dev_priv->ttm.bo_global_ref.ref;
+        drm->ttm.bo_global_ref.mem_glob = global_ref->object;
+        global_ref = &drm->ttm.bo_global_ref.ref;
         global_ref->global_type = DRM_GLOBAL_TTM_BO;
         global_ref->size = sizeof(struct ttm_bo_global);
         global_ref->init = &ttm_bo_global_init;
@@ -82,8 +314,8 @@ nouveau_ttm_global_init(struct drm_nouveau_private *dev_priv)
         ret = drm_global_item_ref(global_ref);
         if (unlikely(ret != 0)) {
                 DRM_ERROR("Failed setting up TTM BO subsystem\n");
-                drm_global_item_unref(&dev_priv->ttm.mem_global_ref);
-                dev_priv->ttm.mem_global_ref.release = NULL;
+                drm_global_item_unref(&drm->ttm.mem_global_ref);
+                drm->ttm.mem_global_ref.release = NULL;
                 return ret;
         }
 
@@ -91,13 +323,101 @@ nouveau_ttm_global_init(struct drm_nouveau_private *dev_priv)
 }
 
 void
-nouveau_ttm_global_release(struct drm_nouveau_private *dev_priv)
+nouveau_ttm_global_release(struct nouveau_drm *drm)
 {
-        if (dev_priv->ttm.mem_global_ref.release == NULL)
+        if (drm->ttm.mem_global_ref.release == NULL)
                 return;
 
-        drm_global_item_unref(&dev_priv->ttm.bo_global_ref.ref);
-        drm_global_item_unref(&dev_priv->ttm.mem_global_ref);
-        dev_priv->ttm.mem_global_ref.release = NULL;
+        drm_global_item_unref(&drm->ttm.bo_global_ref.ref);
+        drm_global_item_unref(&drm->ttm.mem_global_ref);
+        drm->ttm.mem_global_ref.release = NULL;
 }
 
+int
+nouveau_ttm_init(struct nouveau_drm *drm)
+{
+        struct drm_device *dev = drm->dev;
+        u32 bits;
+        int ret;
+
+        bits = nouveau_vmmgr(drm->device)->dma_bits;
+        if ( drm->agp.stat == ENABLED ||
+            !pci_dma_supported(dev->pdev, DMA_BIT_MASK(bits)))
+                bits = 32;
+
+        ret = pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(bits));
+        if (ret)
+                return ret;
+
+        ret = pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(bits));
+        if (ret)
+                pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32));
+
+        ret = nouveau_ttm_global_init(drm);
+        if (ret)
+                return ret;
+
+        ret = ttm_bo_device_init(&drm->ttm.bdev,
+                                  drm->ttm.bo_global_ref.ref.object,
+                                  &nouveau_bo_driver, DRM_FILE_PAGE_OFFSET,
+                                  bits <= 32 ? true : false);
+        if (ret) {
+                NV_ERROR(drm, "error initialising bo driver, %d\n", ret);
+                return ret;
+        }
+
+        /* VRAM init */
+        drm->gem.vram_available  = nouveau_fb(drm->device)->ram.size;
+        drm->gem.vram_available -= nouveau_instmem(drm->device)->reserved;
+
+        ret = ttm_bo_init_mm(&drm->ttm.bdev, TTM_PL_VRAM,
+                              drm->gem.vram_available >> PAGE_SHIFT);
+        if (ret) {
+                NV_ERROR(drm, "VRAM mm init failed, %d\n", ret);
+                return ret;
+        }
+
+        drm->ttm.mtrr = drm_mtrr_add(pci_resource_start(dev->pdev, 1),
+                                     pci_resource_len(dev->pdev, 1),
+                                     DRM_MTRR_WC);
+
+        /* GART init */
+        if (drm->agp.stat != ENABLED) {
+                drm->gem.gart_available = nouveau_vmmgr(drm->device)->limit;
+                if (drm->gem.gart_available > 512 * 1024 * 1024)
+                        drm->gem.gart_available = 512 * 1024 * 1024;
+        } else {
+                drm->gem.gart_available = drm->agp.size;
+        }
+
+        ret = ttm_bo_init_mm(&drm->ttm.bdev, TTM_PL_TT,
+                              drm->gem.gart_available >> PAGE_SHIFT);
+        if (ret) {
+                NV_ERROR(drm, "GART mm init failed, %d\n", ret);
+                return ret;
+        }
+
+        NV_INFO(drm, "VRAM: %d MiB\n", (u32)(drm->gem.vram_available >> 20));
+        NV_INFO(drm, "GART: %d MiB\n", (u32)(drm->gem.gart_available >> 20));
+        return 0;
+}
+
+void
+nouveau_ttm_fini(struct nouveau_drm *drm)
+{
+        mutex_lock(&drm->dev->struct_mutex);
+        ttm_bo_clean_mm(&drm->ttm.bdev, TTM_PL_VRAM);
+        ttm_bo_clean_mm(&drm->ttm.bdev, TTM_PL_TT);
+        mutex_unlock(&drm->dev->struct_mutex);
+
+        ttm_bo_device_release(&drm->ttm.bdev);
+
+        nouveau_ttm_global_release(drm);
+
+        if (drm->ttm.mtrr >= 0) {
+                drm_mtrr_del(drm->ttm.mtrr,
+                             pci_resource_start(drm->dev->pdev, 1),
+                             pci_resource_len(drm->dev->pdev, 1), DRM_MTRR_WC);
+                drm->ttm.mtrr = -1;
+        }
+}
diff --git a/drivers/gpu/drm/nouveau/nouveau_ttm.h b/drivers/gpu/drm/nouveau/nouveau_ttm.h
new file mode 100644
index 000000000000..25b0de413352
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_ttm.h
@@ -0,0 +1,25 @@
+#ifndef __NOUVEAU_TTM_H__
+#define __NOUVEAU_TTM_H__
+
+static inline struct nouveau_drm *
+nouveau_bdev(struct ttm_bo_device *bd)
+{
+        return container_of(bd, struct nouveau_drm, ttm.bdev);
+}
+
+extern const struct ttm_mem_type_manager_func nouveau_vram_manager;
+extern const struct ttm_mem_type_manager_func nouveau_gart_manager;
+extern const struct ttm_mem_type_manager_func nv04_gart_manager;
+
+struct ttm_tt *nouveau_sgdma_create_ttm(struct ttm_bo_device *,
+                                        unsigned long size, u32 page_flags,
+                                        struct page *dummy_read_page);
+
+int  nouveau_ttm_init(struct nouveau_drm *drm);
+void nouveau_ttm_fini(struct nouveau_drm *drm);
+int  nouveau_ttm_mmap(struct file *, struct vm_area_struct *);
+
+int  nouveau_ttm_global_init(struct nouveau_drm *);
+void nouveau_ttm_global_release(struct nouveau_drm *);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_util.h b/drivers/gpu/drm/nouveau/nouveau_util.h
deleted file mode 100644
index b97719fbb739..000000000000
--- a/drivers/gpu/drm/nouveau/nouveau_util.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2010 Nouveau Project
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#ifndef __NOUVEAU_UTIL_H__
-#define __NOUVEAU_UTIL_H__
-
-struct nouveau_bitfield {
-        u32 mask;
-        const char *name;
-};
-
-struct nouveau_enum {
-        u32 value;
-        const char *name;
-        void *data;
-};
-
-void nouveau_bitfield_print(const struct nouveau_bitfield *, u32 value);
-void nouveau_enum_print(const struct nouveau_enum *, u32 value);
-const struct nouveau_enum *
-nouveau_enum_find(const struct nouveau_enum *, u32 value);
-
-int nouveau_ratelimit(void);
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_vga.c b/drivers/gpu/drm/nouveau/nouveau_vga.c
new file mode 100644
index 000000000000..7bf7d131eee0
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_vga.c
@@ -0,0 +1,99 @@
+#include <linux/vgaarb.h>
+#include <linux/vga_switcheroo.h>
+
+#include "drmP.h"
+#include "drm_crtc_helper.h"
+
+#include "nouveau_drm.h"
+#include "nouveau_acpi.h"
+#include "nouveau_fbcon.h"
+#include "nouveau_vga.h"
+
+static unsigned int
+nouveau_vga_set_decode(void *priv, bool state)
+{
+        struct nouveau_device *device = nouveau_dev(priv);
+
+        if (device->chipset >= 0x40)
+                nv_wr32(device, 0x088054, state);
+        else
+                nv_wr32(device, 0x001854, state);
+
+        if (state)
+                return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
+                       VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
+        else
+                return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
+}
+
+static void
+nouveau_switcheroo_set_state(struct pci_dev *pdev,
+                             enum vga_switcheroo_state state)
+{
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        pm_message_t pmm = { .event = PM_EVENT_SUSPEND };
+
+        if (state == VGA_SWITCHEROO_ON) {
+                printk(KERN_ERR "VGA switcheroo: switched nouveau on\n");
+                dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
+                nouveau_drm_resume(pdev);
+                drm_kms_helper_poll_enable(dev);
+                dev->switch_power_state = DRM_SWITCH_POWER_ON;
+        } else {
+                printk(KERN_ERR "VGA switcheroo: switched nouveau off\n");
+                dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
+                drm_kms_helper_poll_disable(dev);
+                nouveau_switcheroo_optimus_dsm();
+                nouveau_drm_suspend(pdev, pmm);
+                dev->switch_power_state = DRM_SWITCH_POWER_OFF;
+        }
+}
+
+static void
+nouveau_switcheroo_reprobe(struct pci_dev *pdev)
+{
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        nouveau_fbcon_output_poll_changed(dev);
+}
+
+static bool
+nouveau_switcheroo_can_switch(struct pci_dev *pdev)
+{
+        struct drm_device *dev = pci_get_drvdata(pdev);
+        bool can_switch;
+
+        spin_lock(&dev->count_lock);
+        can_switch = (dev->open_count == 0);
+        spin_unlock(&dev->count_lock);
+        return can_switch;
+}
+
+static const struct vga_switcheroo_client_ops
+nouveau_switcheroo_ops = {
+        .set_gpu_state = nouveau_switcheroo_set_state,
+        .reprobe = nouveau_switcheroo_reprobe,
+        .can_switch = nouveau_switcheroo_can_switch,
+};
+
+void
+nouveau_vga_init(struct nouveau_drm *drm)
+{
+        struct drm_device *dev = drm->dev;
+        vga_client_register(dev->pdev, dev, NULL, nouveau_vga_set_decode);
+        vga_switcheroo_register_client(dev->pdev, &nouveau_switcheroo_ops);
+}
+
+void
+nouveau_vga_fini(struct nouveau_drm *drm)
+{
+        struct drm_device *dev = drm->dev;
+        vga_switcheroo_unregister_client(dev->pdev);
+        vga_client_register(dev->pdev, NULL, NULL, NULL);
+}
+
+
+void
+nouveau_vga_lastclose(struct drm_device *dev)
+{
+        vga_switcheroo_process_delayed_switch();
+}
diff --git a/drivers/gpu/drm/nouveau/nouveau_vga.h b/drivers/gpu/drm/nouveau/nouveau_vga.h
new file mode 100644
index 000000000000..ea3ad6974c65
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nouveau_vga.h
@@ -0,0 +1,8 @@
+#ifndef __NOUVEAU_VGA_H__
+#define __NOUVEAU_VGA_H__
+
+void nouveau_vga_init(struct nouveau_drm *);
+void nouveau_vga_fini(struct nouveau_drm *);
+void nouveau_vga_lastclose(struct drm_device *dev);
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nouveau_volt.c b/drivers/gpu/drm/nouveau/nouveau_volt.c
index b010cb997b34..c2cc8e2d6539 100644
--- a/drivers/gpu/drm/nouveau/nouveau_volt.c
+++ b/drivers/gpu/drm/nouveau/nouveau_volt.c
@@ -24,18 +24,21 @@
 
 #include "drmP.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_pm.h"
-#include "nouveau_gpio.h"
 
-static const enum dcb_gpio_tag vidtag[] = { 0x04, 0x05, 0x06, 0x1a, 0x73 };
+#include <subdev/bios/gpio.h>
+#include <subdev/gpio.h>
+
+static const enum dcb_gpio_func_name vidtag[] = { 0x04, 0x05, 0x06, 0x1a, 0x73 };
 static int nr_vidtag = sizeof(vidtag) / sizeof(vidtag[0]);
 
 int
 nouveau_voltage_gpio_get(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
+        struct nouveau_pm_voltage *volt = &nouveau_pm(dev)->voltage;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(device);
         u8 vid = 0;
         int i;
 
@@ -43,7 +46,7 @@ nouveau_voltage_gpio_get(struct drm_device *dev)
                 if (!(volt->vid_mask & (1 << i)))
                         continue;
 
-                vid |= nouveau_gpio_func_get(dev, vidtag[i]) << i;
+                vid |= gpio->get(gpio, 0, vidtag[i], 0xff) << i;
         }
 
         return nouveau_volt_lvl_lookup(dev, vid);
@@ -52,8 +55,9 @@ nouveau_voltage_gpio_get(struct drm_device *dev)
 int
 nouveau_voltage_gpio_set(struct drm_device *dev, int voltage)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(device);
+        struct nouveau_pm_voltage *volt = &nouveau_pm(dev)->voltage;
         int vid, i;
 
         vid = nouveau_volt_vid_lookup(dev, voltage);
@@ -64,7 +68,7 @@ nouveau_voltage_gpio_set(struct drm_device *dev, int voltage)
                 if (!(volt->vid_mask & (1 << i)))
                         continue;
 
-                nouveau_gpio_func_set(dev, vidtag[i], !!(vid & (1 << i)));
+                gpio->set(gpio, 0, vidtag[i], 0xff, !!(vid & (1 << i)));
         }
 
         return 0;
@@ -73,8 +77,7 @@ nouveau_voltage_gpio_set(struct drm_device *dev, int voltage)
 int
 nouveau_volt_vid_lookup(struct drm_device *dev, int voltage)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
+        struct nouveau_pm_voltage *volt = &nouveau_pm(dev)->voltage;
         int i;
 
         for (i = 0; i < volt->nr_level; i++) {
@@ -88,8 +91,7 @@ nouveau_volt_vid_lookup(struct drm_device *dev, int voltage)
 int
 nouveau_volt_lvl_lookup(struct drm_device *dev, int vid)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
+        struct nouveau_pm_voltage *volt = &nouveau_pm(dev)->voltage;
         int i;
 
         for (i = 0; i < volt->nr_level; i++) {
@@ -103,10 +105,12 @@ nouveau_volt_lvl_lookup(struct drm_device *dev, int vid)
 void
 nouveau_volt_init(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
+        struct nouveau_pm *pm = nouveau_pm(dev);
         struct nouveau_pm_voltage *voltage = &pm->voltage;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nvbios *bios = &drm->vbios;
+        struct dcb_gpio_func func;
         struct bit_entry P;
         u8 *volt = NULL, *entry;
         int i, headerlen, recordlen, entries, vidmask, vidshift;
@@ -121,11 +125,11 @@ nouveau_volt_init(struct drm_device *dev)
                 if (P.version == 2)
                         volt = ROMPTR(dev, P.data[12]);
                 else {
-                        NV_WARN(dev, "unknown volt for BIT P %d\n", P.version);
+                        NV_WARN(drm, "unknown volt for BIT P %d\n", P.version);
                 }
         } else {
                 if (bios->data[bios->offset + 6] < 0x27) {
-                        NV_DEBUG(dev, "BMP version too old for voltage\n");
+                        NV_DEBUG(drm, "BMP version too old for voltage\n");
                         return;
                 }
 
@@ -133,7 +137,7 @@ nouveau_volt_init(struct drm_device *dev)
         }
 
         if (!volt) {
-                NV_DEBUG(dev, "voltage table pointer invalid\n");
+                NV_DEBUG(drm, "voltage table pointer invalid\n");
                 return;
         }
 
@@ -177,7 +181,7 @@ nouveau_volt_init(struct drm_device *dev)
                 vidshift  = 0;
                 break;
         default:
-                NV_WARN(dev, "voltage table 0x%02x unknown\n", volt[0]);
+                NV_WARN(drm, "voltage table 0x%02x unknown\n", volt[0]);
                 return;
         }
 
@@ -189,12 +193,12 @@ nouveau_volt_init(struct drm_device *dev)
         i = 0;
         while (vidmask) {
                 if (i > nr_vidtag) {
-                        NV_DEBUG(dev, "vid bit %d unknown\n", i);
+                        NV_DEBUG(drm, "vid bit %d unknown\n", i);
                         return;
                 }
 
-                if (!nouveau_gpio_func_valid(dev, vidtag[i])) {
-                        NV_DEBUG(dev, "vid bit %d has no gpio tag\n", i);
+                if (gpio && gpio->find(gpio, 0, vidtag[i], 0xff, &func)) {
+                        NV_DEBUG(drm, "vid bit %d has no gpio tag\n", i);
                         return;
                 }
 
@@ -240,8 +244,7 @@ nouveau_volt_init(struct drm_device *dev)
 void
 nouveau_volt_fini(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
+        struct nouveau_pm_voltage *volt = &nouveau_pm(dev)->voltage;
 
         kfree(volt->level);
 }
diff --git a/drivers/gpu/drm/nouveau/nv04_crtc.c b/drivers/gpu/drm/nouveau/nv04_crtc.c
index 43accc11102f..8b8a9d3d9e8b 100644
--- a/drivers/gpu/drm/nouveau/nv04_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv04_crtc.c
@@ -26,14 +26,20 @@
 #include "drmP.h"
 #include "drm_crtc_helper.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
+#include "nouveau_bo.h"
+#include "nouveau_gem.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
-#include "nouveau_fb.h"
 #include "nouveau_hw.h"
 #include "nvreg.h"
 #include "nouveau_fbcon.h"
+#include "nv04_display.h"
+
+#include <subdev/bios/pll.h>
+#include <subdev/clock.h>
 
 static int
 nv04_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
@@ -49,8 +55,8 @@ crtc_wr_cio_state(struct drm_crtc *crtc, struct nv04_crtc_reg *crtcstate, int in
 static void nv_crtc_set_digital_vibrance(struct drm_crtc *crtc, int level)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
+        struct drm_device *dev = crtc->dev;
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
 
         regp->CRTC[NV_CIO_CRE_CSB] = nv_crtc->saturation = level;
         if (nv_crtc->saturation && nv_gf4_disp_arch(crtc->dev)) {
@@ -64,8 +70,8 @@ static void nv_crtc_set_digital_vibrance(struct drm_crtc *crtc, int level)
 static void nv_crtc_set_image_sharpening(struct drm_crtc *crtc, int level)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
+        struct drm_device *dev = crtc->dev;
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
 
         nv_crtc->sharpness = level;
         if (level < 0)  /* blur is in hw range 0x3f -> 0x20 */
@@ -103,14 +109,17 @@ static void nv_crtc_set_image_sharpening(struct drm_crtc *crtc, int level)
 static void nv_crtc_calc_state_ext(struct drm_crtc *crtc, struct drm_display_mode * mode, int dot_clock)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_bios *bios = nouveau_bios(drm->device);
+        struct nouveau_clock *clk = nouveau_clock(drm->device);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct nv04_mode_state *state = &dev_priv->mode_reg;
+        struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
         struct nv04_crtc_reg *regp = &state->crtc_reg[nv_crtc->index];
         struct nouveau_pll_vals *pv = &regp->pllvals;
-        struct pll_lims pll_lim;
+        struct nvbios_pll pll_lim;
 
-        if (get_pll_limits(dev, nv_crtc->index ? PLL_VPLL1 : PLL_VPLL0, &pll_lim))
+        if (nvbios_pll_parse(bios, nv_crtc->index ? PLL_VPLL1 : PLL_VPLL0,
+                            &pll_lim))
                 return;
 
         /* NM2 == 0 is used to determine single stage mode on two stage plls */
@@ -126,28 +135,29 @@ static void nv_crtc_calc_state_ext(struct drm_crtc *crtc, struct drm_display_mod
          * has yet been observed in allowing the use a single stage pll on all
          * nv43 however.  the behaviour of single stage use is untested on nv40
          */
-        if (dev_priv->chipset > 0x40 && dot_clock <= (pll_lim.vco1.maxfreq / 2))
+        if (nv_device(drm->device)->chipset > 0x40 && dot_clock <= (pll_lim.vco1.max_freq / 2))
                 memset(&pll_lim.vco2, 0, sizeof(pll_lim.vco2));
 
-        if (!nouveau_calc_pll_mnp(dev, &pll_lim, dot_clock, pv))
+
+        if (!clk->pll_calc(clk, &pll_lim, dot_clock, pv))
                 return;
 
         state->pllsel &= PLLSEL_VPLL1_MASK | PLLSEL_VPLL2_MASK | PLLSEL_TV_MASK;
 
         /* The blob uses this always, so let's do the same */
-        if (dev_priv->card_type == NV_40)
+        if (nv_device(drm->device)->card_type == NV_40)
                 state->pllsel |= NV_PRAMDAC_PLL_COEFF_SELECT_USE_VPLL2_TRUE;
         /* again nv40 and some nv43 act more like nv3x as described above */
-        if (dev_priv->chipset < 0x41)
+        if (nv_device(drm->device)->chipset < 0x41)
                 state->pllsel |= NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_MPLL |
                                  NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_NVPLL;
         state->pllsel |= nv_crtc->index ? PLLSEL_VPLL2_MASK : PLLSEL_VPLL1_MASK;
 
         if (pv->NM2)
-                NV_DEBUG_KMS(dev, "vpll: n1 %d n2 %d m1 %d m2 %d log2p %d\n",
+                NV_DEBUG(drm, "vpll: n1 %d n2 %d m1 %d m2 %d log2p %d\n",
                          pv->N1, pv->N2, pv->M1, pv->M2, pv->log2P);
         else
-                NV_DEBUG_KMS(dev, "vpll: n %d m %d log2p %d\n",
+                NV_DEBUG(drm, "vpll: n %d m %d log2p %d\n",
                          pv->N1, pv->M1, pv->log2P);
 
         nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.offset);
@@ -158,10 +168,11 @@ nv_crtc_dpms(struct drm_crtc *crtc, int mode)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_device *dev = crtc->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         unsigned char seq1 = 0, crtc17 = 0;
         unsigned char crtc1A;
 
-        NV_DEBUG_KMS(dev, "Setting dpms mode %d on CRTC %d\n", mode,
+        NV_DEBUG(drm, "Setting dpms mode %d on CRTC %d\n", mode,
                                                         nv_crtc->index);
 
         if (nv_crtc->last_dpms == mode) /* Don't do unnecessary mode changes. */
@@ -225,9 +236,8 @@ static void
 nv_crtc_mode_set_vga(struct drm_crtc *crtc, struct drm_display_mode *mode)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
         struct drm_framebuffer *fb = crtc->fb;
 
         /* Calculate our timings */
@@ -251,8 +261,8 @@ nv_crtc_mode_set_vga(struct drm_crtc *crtc, struct drm_display_mode *mode)
                 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 
                 if (encoder->crtc == crtc &&
-                    (nv_encoder->dcb->type == OUTPUT_LVDS ||
-                     nv_encoder->dcb->type == OUTPUT_TMDS))
+                    (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
+                     nv_encoder->dcb->type == DCB_OUTPUT_TMDS))
                         fp_output = true;
         }
 
@@ -264,7 +274,7 @@ nv_crtc_mode_set_vga(struct drm_crtc *crtc, struct drm_display_mode *mode)
                 horizEnd = horizTotal - 2;
                 horizBlankEnd = horizTotal + 4;
 #if 0
-                if (dev->overlayAdaptor && dev_priv->card_type >= NV_10)
+                if (dev->overlayAdaptor && nv_device(drm->device)->card_type >= NV_10)
                         /* This reportedly works around some video overlay bandwidth problems */
                         horizTotal += 2;
 #endif
@@ -452,10 +462,10 @@ static void
 nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
-        struct nv04_crtc_reg *savep = &dev_priv->saved_reg.crtc_reg[nv_crtc->index];
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
+        struct nv04_crtc_reg *savep = &nv04_display(dev)->saved_reg.crtc_reg[nv_crtc->index];
         struct drm_encoder *encoder;
         bool lvds_output = false, tmds_output = false, tv_output = false,
                 off_chip_digital = false;
@@ -467,11 +477,11 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
                 if (encoder->crtc != crtc)
                         continue;
 
-                if (nv_encoder->dcb->type == OUTPUT_LVDS)
+                if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS)
                         digital = lvds_output = true;
-                if (nv_encoder->dcb->type == OUTPUT_TV)
+                if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
                         tv_output = true;
-                if (nv_encoder->dcb->type == OUTPUT_TMDS)
+                if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS)
                         digital = tmds_output = true;
                 if (nv_encoder->dcb->location != DCB_LOC_ON_CHIP && digital)
                         off_chip_digital = true;
@@ -500,7 +510,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
         regp->cursor_cfg = NV_PCRTC_CURSOR_CONFIG_CUR_LINES_64 |
                              NV_PCRTC_CURSOR_CONFIG_CUR_PIXELS_64 |
                              NV_PCRTC_CURSOR_CONFIG_ADDRESS_SPACE_PNVM;
-        if (dev_priv->chipset >= 0x11)
+        if (nv_device(drm->device)->chipset >= 0x11)
                 regp->cursor_cfg |= NV_PCRTC_CURSOR_CONFIG_CUR_BPP_32;
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                 regp->cursor_cfg |= NV_PCRTC_CURSOR_CONFIG_DOUBLE_SCAN_ENABLE;
@@ -533,7 +543,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
 
         /* The blob seems to take the current value from crtc 0, add 4 to that
          * and reuse the old value for crtc 1 */
-        regp->CRTC[NV_CIO_CRE_TVOUT_LATENCY] = dev_priv->saved_reg.crtc_reg[0].CRTC[NV_CIO_CRE_TVOUT_LATENCY];
+        regp->CRTC[NV_CIO_CRE_TVOUT_LATENCY] = nv04_display(dev)->saved_reg.crtc_reg[0].CRTC[NV_CIO_CRE_TVOUT_LATENCY];
         if (!nv_crtc->index)
                 regp->CRTC[NV_CIO_CRE_TVOUT_LATENCY] += 4;
 
@@ -541,26 +551,26 @@ 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)
+        if (nv_device(drm->device)->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;
 
-        if (dev_priv->card_type == NV_40)
+        if (nv_device(drm->device)->card_type == NV_40)
                 /* This is what the blob does */
                 regp->crtc_850 = NVReadCRTC(dev, 0, NV_PCRTC_850);
 
-        if (dev_priv->card_type >= NV_30)
+        if (nv_device(drm->device)->card_type >= NV_30)
                 regp->gpio_ext = NVReadCRTC(dev, 0, NV_PCRTC_GPIO_EXT);
 
-        if (dev_priv->card_type >= NV_10)
+        if (nv_device(drm->device)->card_type >= NV_10)
                 regp->crtc_cfg = NV10_PCRTC_CONFIG_START_ADDRESS_HSYNC;
         else
                 regp->crtc_cfg = NV04_PCRTC_CONFIG_START_ADDRESS_HSYNC;
 
         /* Some misc regs */
-        if (dev_priv->card_type == NV_40) {
+        if (nv_device(drm->device)->card_type == NV_40) {
                 regp->CRTC[NV_CIO_CRE_85] = 0xFF;
                 regp->CRTC[NV_CIO_CRE_86] = 0x1;
         }
@@ -572,7 +582,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
 
         /* Generic PRAMDAC regs */
 
-        if (dev_priv->card_type >= NV_10)
+        if (nv_device(drm->device)->card_type >= NV_10)
                 /* Only bit that bios and blob set. */
                 regp->nv10_cursync = (1 << 25);
 
@@ -581,7 +591,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
                                 NV_PRAMDAC_GENERAL_CONTROL_PIXMIX_ON;
         if (crtc->fb->depth == 16)
                 regp->ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_ALT_MODE_SEL;
-        if (dev_priv->chipset >= 0x11)
+        if (nv_device(drm->device)->chipset >= 0x11)
                 regp->ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_PIPE_LONG;
 
         regp->ramdac_630 = 0; /* turn off green mode (tv test pattern?) */
@@ -611,9 +621,9 @@ nv_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
 {
         struct drm_device *dev = crtc->dev;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        NV_DEBUG_KMS(dev, "CTRC mode on CRTC %d:\n", nv_crtc->index);
+        NV_DEBUG(drm, "CTRC mode on CRTC %d:\n", nv_crtc->index);
         drm_mode_debug_printmodeline(adjusted_mode);
 
         /* unlock must come after turning off FP_TG_CONTROL in output_prepare */
@@ -621,8 +631,8 @@ nv_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
 
         nv_crtc_mode_set_vga(crtc, adjusted_mode);
         /* calculated in nv04_dfp_prepare, nv40 needs it written before calculating PLLs */
-        if (dev_priv->card_type == NV_40)
-                NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, dev_priv->mode_reg.sel_clk);
+        if (nv_device(drm->device)->card_type == NV_40)
+                NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, nv04_display(dev)->mode_reg.sel_clk);
         nv_crtc_mode_set_regs(crtc, adjusted_mode);
         nv_crtc_calc_state_ext(crtc, mode, adjusted_mode->clock);
         return 0;
@@ -631,10 +641,10 @@ nv_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
 static void nv_crtc_save(struct drm_crtc *crtc)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
-        struct nv04_mode_state *state = &dev_priv->mode_reg;
+        struct drm_device *dev = crtc->dev;
+        struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
         struct nv04_crtc_reg *crtc_state = &state->crtc_reg[nv_crtc->index];
-        struct nv04_mode_state *saved = &dev_priv->saved_reg;
+        struct nv04_mode_state *saved = &nv04_display(dev)->saved_reg;
         struct nv04_crtc_reg *crtc_saved = &saved->crtc_reg[nv_crtc->index];
 
         if (nv_two_heads(crtc->dev))
@@ -652,14 +662,14 @@ static void nv_crtc_save(struct drm_crtc *crtc)
 static void nv_crtc_restore(struct drm_crtc *crtc)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
+        struct drm_device *dev = crtc->dev;
         int head = nv_crtc->index;
-        uint8_t saved_cr21 = dev_priv->saved_reg.crtc_reg[head].CRTC[NV_CIO_CRE_21];
+        uint8_t saved_cr21 = nv04_display(dev)->saved_reg.crtc_reg[head].CRTC[NV_CIO_CRE_21];
 
         if (nv_two_heads(crtc->dev))
                 NVSetOwner(crtc->dev, head);
 
-        nouveau_hw_load_state(crtc->dev, head, &dev_priv->saved_reg);
+        nouveau_hw_load_state(crtc->dev, head, &nv04_display(dev)->saved_reg);
         nv_lock_vga_crtc_shadow(crtc->dev, head, saved_cr21);
 
         nv_crtc->last_dpms = NV_DPMS_CLEARED;
@@ -668,7 +678,7 @@ static void nv_crtc_restore(struct drm_crtc *crtc)
 static void nv_crtc_prepare(struct drm_crtc *crtc)
 {
         struct drm_device *dev = crtc->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_crtc_helper_funcs *funcs = crtc->helper_private;
 
@@ -682,7 +692,7 @@ static void nv_crtc_prepare(struct drm_crtc *crtc)
 
         /* Some more preparation. */
         NVWriteCRTC(dev, nv_crtc->index, NV_PCRTC_CONFIG, NV_PCRTC_CONFIG_START_ADDRESS_NON_VGA);
-        if (dev_priv->card_type == NV_40) {
+        if (nv_device(drm->device)->card_type == NV_40) {
                 uint32_t reg900 = NVReadRAMDAC(dev, nv_crtc->index, NV_PRAMDAC_900);
                 NVWriteRAMDAC(dev, nv_crtc->index, NV_PRAMDAC_900, reg900 & ~0x10000);
         }
@@ -692,10 +702,9 @@ static void nv_crtc_commit(struct drm_crtc *crtc)
 {
         struct drm_device *dev = crtc->dev;
         struct drm_crtc_helper_funcs *funcs = crtc->helper_private;
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 
-        nouveau_hw_load_state(dev, nv_crtc->index, &dev_priv->mode_reg);
+        nouveau_hw_load_state(dev, nv_crtc->index, &nv04_display(dev)->mode_reg);
         nv04_crtc_mode_set_base(crtc, crtc->x, crtc->y, NULL);
 
 #ifdef __BIG_ENDIAN
@@ -715,8 +724,6 @@ static void nv_crtc_destroy(struct drm_crtc *crtc)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 
-        NV_DEBUG_KMS(crtc->dev, "\n");
-
         if (!nv_crtc)
                 return;
 
@@ -732,18 +739,17 @@ nv_crtc_gamma_load(struct drm_crtc *crtc)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_device *dev = nv_crtc->base.dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct rgb { uint8_t r, g, b; } __attribute__((packed)) *rgbs;
         int i;
 
-        rgbs = (struct rgb *)dev_priv->mode_reg.crtc_reg[nv_crtc->index].DAC;
+        rgbs = (struct rgb *)nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index].DAC;
         for (i = 0; i < 256; i++) {
                 rgbs[i].r = nv_crtc->lut.r[i] >> 8;
                 rgbs[i].g = nv_crtc->lut.g[i] >> 8;
                 rgbs[i].b = nv_crtc->lut.b[i] >> 8;
         }
 
-        nouveau_hw_load_state_palette(dev, nv_crtc->index, &dev_priv->mode_reg);
+        nouveau_hw_load_state_palette(dev, nv_crtc->index, &nv04_display(dev)->mode_reg);
 }
 
 static void
@@ -779,18 +785,18 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_device *dev = crtc->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
         struct drm_framebuffer *drm_fb;
         struct nouveau_framebuffer *fb;
         int arb_burst, arb_lwm;
         int ret;
 
-        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
+        NV_DEBUG(drm, "index %d\n", nv_crtc->index);
 
         /* no fb bound */
         if (!atomic && !crtc->fb) {
-                NV_DEBUG_KMS(dev, "No FB bound\n");
+                NV_DEBUG(drm, "No FB bound\n");
                 return 0;
         }
 
@@ -858,7 +864,7 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
         crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_FF_INDEX);
         crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_FFLWM__INDEX);
 
-        if (dev_priv->card_type >= NV_20) {
+        if (nv_device(drm->device)->card_type >= NV_20) {
                 regp->CRTC[NV_CIO_CRE_47] = arb_lwm >> 8;
                 crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_47);
         }
@@ -878,8 +884,8 @@ nv04_crtc_mode_set_base_atomic(struct drm_crtc *crtc,
                                struct drm_framebuffer *fb,
                                int x, int y, enum mode_set_atomic state)
 {
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
+        struct drm_device *dev = drm->dev;
 
         if (state == ENTER_ATOMIC_MODE_SET)
                 nouveau_fbcon_save_disable_accel(dev);
@@ -934,9 +940,9 @@ static void nv11_cursor_upload(struct drm_device *dev, struct nouveau_bo *src,
 
 #ifdef __BIG_ENDIAN
                 {
-                        struct drm_nouveau_private *dev_priv = dev->dev_private;
+                        struct nouveau_drm *drm = nouveau_drm(dev);
 
-                        if (dev_priv->chipset == 0x11) {
+                        if (nv_device(drm->device)->chipset == 0x11) {
                                 pixel = ((pixel & 0x000000ff) << 24) |
                                         ((pixel & 0x0000ff00) << 8) |
                                         ((pixel & 0x00ff0000) >> 8) |
@@ -953,8 +959,8 @@ static int
 nv04_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
                      uint32_t buffer_handle, uint32_t width, uint32_t height)
 {
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
-        struct drm_device *dev = dev_priv->dev;
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
+        struct drm_device *dev = drm->dev;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct nouveau_bo *cursor = NULL;
         struct drm_gem_object *gem;
@@ -977,7 +983,7 @@ nv04_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
         if (ret)
                 goto out;
 
-        if (dev_priv->chipset >= 0x11)
+        if (nv_device(drm->device)->chipset >= 0x11)
                 nv11_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);
         else
                 nv04_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);
diff --git a/drivers/gpu/drm/nouveau/nv04_cursor.c b/drivers/gpu/drm/nouveau/nv04_cursor.c
index aaf3de3bc816..d2ea8b460364 100644
--- a/drivers/gpu/drm/nouveau/nv04_cursor.c
+++ b/drivers/gpu/drm/nouveau/nv04_cursor.c
@@ -1,7 +1,7 @@
 #include "drmP.h"
 #include "drm_mode.h"
+#include "nouveau_drm.h"
 #include "nouveau_reg.h"
-#include "nouveau_drv.h"
 #include "nouveau_crtc.h"
 #include "nouveau_hw.h"
 
@@ -38,8 +38,8 @@ static void
 nv04_cursor_set_offset(struct nouveau_crtc *nv_crtc, uint32_t offset)
 {
         struct drm_device *dev = nv_crtc->base.dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
         struct drm_crtc *crtc = &nv_crtc->base;
 
         regp->CRTC[NV_CIO_CRE_HCUR_ADDR0_INDEX] =
@@ -55,7 +55,7 @@ nv04_cursor_set_offset(struct nouveau_crtc *nv_crtc, uint32_t offset)
         crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX);
         crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX);
         crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX);
-        if (dev_priv->card_type == NV_40)
+        if (nv_device(drm->device)->card_type == NV_40)
                 nv_fix_nv40_hw_cursor(dev, nv_crtc->index);
 }
 
diff --git a/drivers/gpu/drm/nouveau/nv04_dac.c b/drivers/gpu/drm/nouveau/nv04_dac.c
index 38f19479417c..336f953084f9 100644
--- a/drivers/gpu/drm/nouveau/nv04_dac.c
+++ b/drivers/gpu/drm/nouveau/nv04_dac.c
@@ -27,22 +27,25 @@
 #include "drmP.h"
 #include "drm_crtc_helper.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
 #include "nouveau_hw.h"
-#include "nouveau_gpio.h"
 #include "nvreg.h"
 
+#include <subdev/bios/gpio.h>
+#include <subdev/gpio.h>
+#include <subdev/timer.h>
+
 int nv04_dac_output_offset(struct drm_encoder *encoder)
 {
-        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
         int offset = 0;
 
-        if (dcb->or & (8 | OUTPUT_C))
+        if (dcb->or & (8 | DCB_OUTPUT_C))
                 offset += 0x68;
-        if (dcb->or & (8 | OUTPUT_B))
+        if (dcb->or & (8 | DCB_OUTPUT_B))
                 offset += 0x2000;
 
         return offset;
@@ -62,6 +65,8 @@ int nv04_dac_output_offset(struct drm_encoder *encoder)
 
 static int sample_load_twice(struct drm_device *dev, bool sense[2])
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_timer *ptimer = nouveau_timer(device);
         int i;
 
         for (i = 0; i < 2; i++) {
@@ -75,27 +80,30 @@ static int sample_load_twice(struct drm_device *dev, bool sense[2])
                  * use a 10ms timeout (guards against crtc being inactive, in
                  * which case blank state would never change)
                  */
-                if (!nouveau_wait_eq(dev, 10000000, NV_PRMCIO_INP0__COLOR,
-                                     0x00000001, 0x00000000))
+                if (!nouveau_timer_wait_eq(ptimer, 10000000,
+                                           NV_PRMCIO_INP0__COLOR,
+                                           0x00000001, 0x00000000))
                         return -EBUSY;
-                if (!nouveau_wait_eq(dev, 10000000, NV_PRMCIO_INP0__COLOR,
-                                     0x00000001, 0x00000001))
+                if (!nouveau_timer_wait_eq(ptimer, 10000000,
+                                           NV_PRMCIO_INP0__COLOR,
+                                           0x00000001, 0x00000001))
                         return -EBUSY;
-                if (!nouveau_wait_eq(dev, 10000000, NV_PRMCIO_INP0__COLOR,
-                                     0x00000001, 0x00000000))
+                if (!nouveau_timer_wait_eq(ptimer, 10000000,
+                                           NV_PRMCIO_INP0__COLOR,
+                                           0x00000001, 0x00000000))
                         return -EBUSY;
 
                 udelay(100);
                 /* when level triggers, sense is _LO_ */
-                sense_a = nv_rd08(dev, NV_PRMCIO_INP0) & 0x10;
+                sense_a = nv_rd08(device, NV_PRMCIO_INP0) & 0x10;
 
                 /* take another reading until it agrees with sense_a... */
                 do {
                         udelay(100);
-                        sense_b = nv_rd08(dev, NV_PRMCIO_INP0) & 0x10;
+                        sense_b = nv_rd08(device, NV_PRMCIO_INP0) & 0x10;
                         if (sense_a != sense_b) {
                                 sense_b_prime =
-                                        nv_rd08(dev, NV_PRMCIO_INP0) & 0x10;
+                                        nv_rd08(device, NV_PRMCIO_INP0) & 0x10;
                                 if (sense_b == sense_b_prime) {
                                         /* ... unless two consecutive subsequent
                                          * samples agree; sense_a is replaced */
@@ -120,6 +128,8 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
                                                  struct drm_connector *connector)
 {
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         uint8_t saved_seq1, saved_pi, saved_rpc1, saved_cr_mode;
         uint8_t saved_palette0[3], saved_palette_mask;
         uint32_t saved_rtest_ctrl, saved_rgen_ctrl;
@@ -154,11 +164,11 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
         saved_rpc1 = NVReadVgaCrtc(dev, 0, NV_CIO_CRE_RPC1_INDEX);
         NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_RPC1_INDEX, saved_rpc1 & ~0xc0);
 
-        nv_wr08(dev, NV_PRMDIO_READ_MODE_ADDRESS, 0x0);
+        nv_wr08(device, NV_PRMDIO_READ_MODE_ADDRESS, 0x0);
         for (i = 0; i < 3; i++)
-                saved_palette0[i] = nv_rd08(dev, NV_PRMDIO_PALETTE_DATA);
-        saved_palette_mask = nv_rd08(dev, NV_PRMDIO_PIXEL_MASK);
-        nv_wr08(dev, NV_PRMDIO_PIXEL_MASK, 0);
+                saved_palette0[i] = nv_rd08(device, NV_PRMDIO_PALETTE_DATA);
+        saved_palette_mask = nv_rd08(device, NV_PRMDIO_PIXEL_MASK);
+        nv_wr08(device, NV_PRMDIO_PIXEL_MASK, 0);
 
         saved_rgen_ctrl = NVReadRAMDAC(dev, 0, NV_PRAMDAC_GENERAL_CONTROL);
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_GENERAL_CONTROL,
@@ -171,11 +181,11 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
         do {
                 bool sense_pair[2];
 
-                nv_wr08(dev, NV_PRMDIO_WRITE_MODE_ADDRESS, 0);
-                nv_wr08(dev, NV_PRMDIO_PALETTE_DATA, 0);
-                nv_wr08(dev, NV_PRMDIO_PALETTE_DATA, 0);
+                nv_wr08(device, NV_PRMDIO_WRITE_MODE_ADDRESS, 0);
+                nv_wr08(device, NV_PRMDIO_PALETTE_DATA, 0);
+                nv_wr08(device, NV_PRMDIO_PALETTE_DATA, 0);
                 /* testing blue won't find monochrome monitors.  I don't care */
-                nv_wr08(dev, NV_PRMDIO_PALETTE_DATA, blue);
+                nv_wr08(device, NV_PRMDIO_PALETTE_DATA, blue);
 
                 i = 0;
                 /* take sample pairs until both samples in the pair agree */
@@ -198,11 +208,11 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
         } while (++blue < 0x18 && sense);
 
 out:
-        nv_wr08(dev, NV_PRMDIO_PIXEL_MASK, saved_palette_mask);
+        nv_wr08(device, NV_PRMDIO_PIXEL_MASK, saved_palette_mask);
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_GENERAL_CONTROL, saved_rgen_ctrl);
-        nv_wr08(dev, NV_PRMDIO_WRITE_MODE_ADDRESS, 0);
+        nv_wr08(device, NV_PRMDIO_WRITE_MODE_ADDRESS, 0);
         for (i = 0; i < 3; i++)
-                nv_wr08(dev, NV_PRMDIO_PALETTE_DATA, saved_palette0[i]);
+                nv_wr08(device, NV_PRMDIO_PALETTE_DATA, saved_palette0[i]);
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL, saved_rtest_ctrl);
         NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_PIXEL_INDEX, saved_pi);
         NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_RPC1_INDEX, saved_rpc1);
@@ -210,7 +220,7 @@ out:
         NVWriteVgaCrtc(dev, 0, NV_CIO_CR_MODE_INDEX, saved_cr_mode);
 
         if (blue == 0x18) {
-                NV_INFO(dev, "Load detected on head A\n");
+                NV_INFO(drm, "Load detected on head A\n");
                 return connector_status_connected;
         }
 
@@ -220,43 +230,46 @@ out:
 uint32_t nv17_dac_sample_load(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(device);
+        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
         uint32_t sample, testval, regoffset = nv04_dac_output_offset(encoder);
         uint32_t saved_powerctrl_2 = 0, saved_powerctrl_4 = 0, saved_routput,
-                saved_rtest_ctrl, saved_gpio0, saved_gpio1, temp, routput;
+                saved_rtest_ctrl, saved_gpio0 = 0, saved_gpio1 = 0, temp, routput;
         int head;
 
 #define RGB_TEST_DATA(r, g, b) (r << 0 | g << 10 | b << 20)
-        if (dcb->type == OUTPUT_TV) {
+        if (dcb->type == DCB_OUTPUT_TV) {
                 testval = RGB_TEST_DATA(0xa0, 0xa0, 0xa0);
 
-                if (dev_priv->vbios.tvdactestval)
-                        testval = dev_priv->vbios.tvdactestval;
+                if (drm->vbios.tvdactestval)
+                        testval = drm->vbios.tvdactestval;
         } else {
                 testval = RGB_TEST_DATA(0x140, 0x140, 0x140); /* 0x94050140 */
 
-                if (dev_priv->vbios.dactestval)
-                        testval = dev_priv->vbios.dactestval;
+                if (drm->vbios.dactestval)
+                        testval = drm->vbios.dactestval;
         }
 
         saved_rtest_ctrl = NVReadRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset);
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset,
                       saved_rtest_ctrl & ~NV_PRAMDAC_TEST_CONTROL_PWRDWN_DAC_OFF);
 
-        saved_powerctrl_2 = nvReadMC(dev, NV_PBUS_POWERCTRL_2);
+        saved_powerctrl_2 = nv_rd32(device, NV_PBUS_POWERCTRL_2);
 
-        nvWriteMC(dev, NV_PBUS_POWERCTRL_2, saved_powerctrl_2 & 0xd7ffffff);
+        nv_wr32(device, NV_PBUS_POWERCTRL_2, saved_powerctrl_2 & 0xd7ffffff);
         if (regoffset == 0x68) {
-                saved_powerctrl_4 = nvReadMC(dev, NV_PBUS_POWERCTRL_4);
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_4, saved_powerctrl_4 & 0xffffffcf);
+                saved_powerctrl_4 = nv_rd32(device, NV_PBUS_POWERCTRL_4);
+                nv_wr32(device, NV_PBUS_POWERCTRL_4, saved_powerctrl_4 & 0xffffffcf);
         }
 
-        saved_gpio1 = nouveau_gpio_func_get(dev, DCB_GPIO_TVDAC1);
-        saved_gpio0 = nouveau_gpio_func_get(dev, DCB_GPIO_TVDAC0);
-
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC1, dcb->type == OUTPUT_TV);
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC0, dcb->type == OUTPUT_TV);
+        if (gpio) {
+                saved_gpio1 = gpio->get(gpio, 0, DCB_GPIO_TVDAC1, 0xff);
+                saved_gpio0 = gpio->get(gpio, 0, DCB_GPIO_TVDAC0, 0xff);
+                gpio->set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, dcb->type == DCB_OUTPUT_TV);
+                gpio->set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, dcb->type == DCB_OUTPUT_TV);
+        }
 
         msleep(4);
 
@@ -270,8 +283,8 @@ uint32_t nv17_dac_sample_load(struct drm_encoder *encoder)
         /* nv driver and nv31 use 0xfffffeee, nv34 and 6600 use 0xfffffece */
         routput = (saved_routput & 0xfffffece) | head << 8;
 
-        if (dev_priv->card_type >= NV_40) {
-                if (dcb->type == OUTPUT_TV)
+        if (nv_device(drm->device)->card_type >= NV_40) {
+                if (dcb->type == DCB_OUTPUT_TV)
                         routput |= 0x1a << 16;
                 else
                         routput &= ~(0x1a << 16);
@@ -303,11 +316,13 @@ uint32_t nv17_dac_sample_load(struct drm_encoder *encoder)
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_DACCLK + regoffset, saved_routput);
         NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset, saved_rtest_ctrl);
         if (regoffset == 0x68)
-                nvWriteMC(dev, NV_PBUS_POWERCTRL_4, saved_powerctrl_4);
-        nvWriteMC(dev, NV_PBUS_POWERCTRL_2, saved_powerctrl_2);
+                nv_wr32(device, NV_PBUS_POWERCTRL_4, saved_powerctrl_4);
+        nv_wr32(device, NV_PBUS_POWERCTRL_2, saved_powerctrl_2);
 
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC1, saved_gpio1);
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC0, saved_gpio0);
+        if (gpio) {
+                gpio->set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, saved_gpio1);
+                gpio->set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, saved_gpio0);
+        }
 
         return sample;
 }
@@ -315,15 +330,15 @@ uint32_t nv17_dac_sample_load(struct drm_encoder *encoder)
 static enum drm_connector_status
 nv17_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 {
-        struct drm_device *dev = encoder->dev;
-        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
 
         if (nv04_dac_in_use(encoder))
                 return connector_status_disconnected;
 
         if (nv17_dac_sample_load(encoder) &
             NV_PRAMDAC_TEST_CONTROL_SENSEB_ALLHI) {
-                NV_INFO(dev, "Load detected on output %c\n",
+                NV_INFO(drm, "Load detected on output %c\n",
                         '@' + ffs(dcb->or));
                 return connector_status_connected;
         } else {
@@ -357,7 +372,7 @@ static void nv04_dac_mode_set(struct drm_encoder *encoder,
                               struct drm_display_mode *adjusted_mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int head = nouveau_crtc(encoder->crtc)->index;
 
         if (nv_gf4_disp_arch(dev)) {
@@ -372,7 +387,7 @@ static void nv04_dac_mode_set(struct drm_encoder *encoder,
                 /* force any other vga encoders to bind to the other crtc */
                 list_for_each_entry(rebind, &dev->mode_config.encoder_list, head) {
                         if (rebind == encoder
-                            || nouveau_encoder(rebind)->dcb->type != OUTPUT_ANALOG)
+                            || nouveau_encoder(rebind)->dcb->type != DCB_OUTPUT_ANALOG)
                                 continue;
 
                         dac_offset = nv04_dac_output_offset(rebind);
@@ -383,7 +398,7 @@ static void nv04_dac_mode_set(struct drm_encoder *encoder,
         }
 
         /* This could use refinement for flatpanels, but it should work this way */
-        if (dev_priv->chipset < 0x44)
+        if (nv_device(drm->device)->chipset < 0x44)
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0xf0000000);
         else
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);
@@ -392,13 +407,13 @@ static void nv04_dac_mode_set(struct drm_encoder *encoder,
 static void nv04_dac_commit(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
         struct drm_encoder_helper_funcs *helper = encoder->helper_private;
 
         helper->dpms(encoder, DRM_MODE_DPMS_ON);
 
-        NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
+        NV_INFO(drm, "Output %s is running on CRTC %d using output %c\n",
                 drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
 }
@@ -406,11 +421,10 @@ static void nv04_dac_commit(struct drm_encoder *encoder)
 void nv04_dac_update_dacclk(struct drm_encoder *encoder, bool enable)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
 
         if (nv_gf4_disp_arch(dev)) {
-                uint32_t *dac_users = &dev_priv->dac_users[ffs(dcb->or) - 1];
+                uint32_t *dac_users = &nv04_display(dev)->dac_users[ffs(dcb->or) - 1];
                 int dacclk_off = NV_PRAMDAC_DACCLK + nv04_dac_output_offset(encoder);
                 uint32_t dacclk = NVReadRAMDAC(dev, 0, dacclk_off);
 
@@ -431,23 +445,23 @@ void nv04_dac_update_dacclk(struct drm_encoder *encoder, bool enable)
  * someone else. */
 bool nv04_dac_in_use(struct drm_encoder *encoder)
 {
-        struct drm_nouveau_private *dev_priv = encoder->dev->dev_private;
-        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct drm_device *dev = encoder->dev;
+        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
 
         return nv_gf4_disp_arch(encoder->dev) &&
-                (dev_priv->dac_users[ffs(dcb->or) - 1] & ~(1 << dcb->index));
+                (nv04_display(dev)->dac_users[ffs(dcb->or) - 1] & ~(1 << dcb->index));
 }
 
 static void nv04_dac_dpms(struct drm_encoder *encoder, int mode)
 {
-        struct drm_device *dev = encoder->dev;
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
 
         if (nv_encoder->last_dpms == mode)
                 return;
         nv_encoder->last_dpms = mode;
 
-        NV_INFO(dev, "Setting dpms mode %d on vga encoder (output %d)\n",
+        NV_INFO(drm, "Setting dpms mode %d on vga encoder (output %d)\n",
                      mode, nv_encoder->dcb->index);
 
         nv04_dac_update_dacclk(encoder, mode == DRM_MODE_DPMS_ON);
@@ -479,8 +493,6 @@ static void nv04_dac_destroy(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 
-        NV_DEBUG_KMS(encoder->dev, "\n");
-
         drm_encoder_cleanup(encoder);
         kfree(nv_encoder);
 }
@@ -512,7 +524,7 @@ static const struct drm_encoder_funcs nv04_dac_funcs = {
 };
 
 int
-nv04_dac_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv04_dac_create(struct drm_connector *connector, struct dcb_output *entry)
 {
         const struct drm_encoder_helper_funcs *helper;
         struct nouveau_encoder *nv_encoder = NULL;
diff --git a/drivers/gpu/drm/nouveau/nv04_dfp.c b/drivers/gpu/drm/nouveau/nv04_dfp.c
index c2675623b7cd..e53df742cc01 100644
--- a/drivers/gpu/drm/nouveau/nv04_dfp.c
+++ b/drivers/gpu/drm/nouveau/nv04_dfp.c
@@ -27,7 +27,8 @@
 #include "drmP.h"
 #include "drm_crtc_helper.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
@@ -36,6 +37,8 @@
 
 #include "i2c/sil164.h"
 
+#include <subdev/i2c.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)
@@ -49,20 +52,20 @@ static inline bool is_fpc_off(uint32_t fpc)
                         FP_TG_CONTROL_OFF);
 }
 
-int nv04_dfp_get_bound_head(struct drm_device *dev, struct dcb_entry *dcbent)
+int nv04_dfp_get_bound_head(struct drm_device *dev, struct dcb_output *dcbent)
 {
         /* special case of nv_read_tmds to find crtc associated with an output.
          * this does not give a correct answer for off-chip dvi, but there's no
          * use for such an answer anyway
          */
-        int ramdac = (dcbent->or & OUTPUT_C) >> 2;
+        int ramdac = (dcbent->or & DCB_OUTPUT_C) >> 2;
 
         NVWriteRAMDAC(dev, ramdac, NV_PRAMDAC_FP_TMDS_CONTROL,
         NV_PRAMDAC_FP_TMDS_CONTROL_WRITE_DISABLE | 0x4);
         return ((NVReadRAMDAC(dev, ramdac, NV_PRAMDAC_FP_TMDS_DATA) & 0x8) >> 3) ^ ramdac;
 }
 
-void nv04_dfp_bind_head(struct drm_device *dev, struct dcb_entry *dcbent,
+void nv04_dfp_bind_head(struct drm_device *dev, struct dcb_output *dcbent,
                         int head, bool dl)
 {
         /* The BIOS scripts don't do this for us, sadly
@@ -72,13 +75,13 @@ void nv04_dfp_bind_head(struct drm_device *dev, struct dcb_entry *dcbent,
          * (for VT restore etc.)
          */
 
-        int ramdac = (dcbent->or & OUTPUT_C) >> 2;
+        int ramdac = (dcbent->or & DCB_OUTPUT_C) >> 2;
         uint8_t tmds04 = 0x80;
 
         if (head != ramdac)
                 tmds04 = 0x88;
 
-        if (dcbent->type == OUTPUT_LVDS)
+        if (dcbent->type == DCB_OUTPUT_LVDS)
                 tmds04 |= 0x01;
 
         nv_write_tmds(dev, dcbent->or, 0, 0x04, tmds04);
@@ -89,8 +92,7 @@ void nv04_dfp_bind_head(struct drm_device *dev, struct dcb_entry *dcbent,
 
 void nv04_dfp_disable(struct drm_device *dev, int head)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_crtc_reg *crtcstate = dev_priv->mode_reg.crtc_reg;
+        struct nv04_crtc_reg *crtcstate = nv04_display(dev)->mode_reg.crtc_reg;
 
         if (NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL) &
             FP_TG_CONTROL_ON) {
@@ -111,14 +113,13 @@ void nv04_dfp_disable(struct drm_device *dev, int head)
 void nv04_dfp_update_fp_control(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct drm_crtc *crtc;
         struct nouveau_crtc *nv_crtc;
         uint32_t *fpc;
 
         if (mode == DRM_MODE_DPMS_ON) {
                 nv_crtc = nouveau_crtc(encoder->crtc);
-                fpc = &dev_priv->mode_reg.crtc_reg[nv_crtc->index].fp_control;
+                fpc = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index].fp_control;
 
                 if (is_fpc_off(*fpc)) {
                         /* using saved value is ok, as (is_digital && dpms_on &&
@@ -133,7 +134,7 @@ void nv04_dfp_update_fp_control(struct drm_encoder *encoder, int mode)
         } else {
                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
                         nv_crtc = nouveau_crtc(crtc);
-                        fpc = &dev_priv->mode_reg.crtc_reg[nv_crtc->index].fp_control;
+                        fpc = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index].fp_control;
 
                         nv_crtc->fp_users &= ~(1 << nouveau_encoder(encoder)->dcb->index);
                         if (!is_fpc_off(*fpc) && !nv_crtc->fp_users) {
@@ -151,10 +152,10 @@ 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 dcb_output *dcb = nouveau_encoder(encoder)->dcb;
         struct drm_encoder *slave;
 
-        if (dcb->type != OUTPUT_TMDS || dcb->location == DCB_LOC_ON_CHIP)
+        if (dcb->type != DCB_OUTPUT_TMDS || dcb->location == DCB_LOC_ON_CHIP)
                 return NULL;
 
         /* Some BIOSes (e.g. the one in a Quadro FX1000) report several
@@ -168,9 +169,9 @@ static struct drm_encoder *get_tmds_slave(struct drm_encoder *encoder)
          * 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;
+                struct dcb_output *slave_dcb = nouveau_encoder(slave)->dcb;
 
-                if (slave_dcb->type == OUTPUT_TMDS && get_slave_funcs(slave) &&
+                if (slave_dcb->type == DCB_OUTPUT_TMDS && get_slave_funcs(slave) &&
                     slave_dcb->tmdsconf.slave_addr == dcb->tmdsconf.slave_addr)
                         return slave;
         }
@@ -202,9 +203,8 @@ static bool nv04_dfp_mode_fixup(struct drm_encoder *encoder,
 static void nv04_dfp_prepare_sel_clk(struct drm_device *dev,
                                      struct nouveau_encoder *nv_encoder, int head)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_mode_state *state = &dev_priv->mode_reg;
-        uint32_t bits1618 = nv_encoder->dcb->or & OUTPUT_A ? 0x10000 : 0x40000;
+        struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
+        uint32_t bits1618 = nv_encoder->dcb->or & DCB_OUTPUT_A ? 0x10000 : 0x40000;
 
         if (nv_encoder->dcb->location != DCB_LOC_ON_CHIP)
                 return;
@@ -233,8 +233,8 @@ static void nv04_dfp_prepare_sel_clk(struct drm_device *dev,
          *      and which bit-pair to use, is unclear on nv40 (for earlier cards, the fp table
          *      entry has the necessary info)
          */
-        if (nv_encoder->dcb->type == OUTPUT_LVDS && dev_priv->saved_reg.sel_clk & 0xf0) {
-                int shift = (dev_priv->saved_reg.sel_clk & 0x50) ? 0 : 1;
+        if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS && nv04_display(dev)->saved_reg.sel_clk & 0xf0) {
+                int shift = (nv04_display(dev)->saved_reg.sel_clk & 0x50) ? 0 : 1;
 
                 state->sel_clk &= ~0xf0;
                 state->sel_clk |= (head ? 0x40 : 0x10) << shift;
@@ -246,9 +246,8 @@ static void nv04_dfp_prepare(struct drm_encoder *encoder)
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_encoder_helper_funcs *helper = encoder->helper_private;
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         int head = nouveau_crtc(encoder->crtc)->index;
-        struct nv04_crtc_reg *crtcstate = dev_priv->mode_reg.crtc_reg;
+        struct nv04_crtc_reg *crtcstate = nv04_display(dev)->mode_reg.crtc_reg;
         uint8_t *cr_lcd = &crtcstate[head].CRTC[NV_CIO_CRE_LCD__INDEX];
         uint8_t *cr_lcd_oth = &crtcstate[head ^ 1].CRTC[NV_CIO_CRE_LCD__INDEX];
 
@@ -263,7 +262,7 @@ static void nv04_dfp_prepare(struct drm_encoder *encoder)
                         *cr_lcd |= head ? 0x0 : 0x8;
                 else {
                         *cr_lcd |= (nv_encoder->dcb->or << 4) & 0x30;
-                        if (nv_encoder->dcb->type == OUTPUT_LVDS)
+                        if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS)
                                 *cr_lcd |= 0x30;
                         if ((*cr_lcd & 0x30) == (*cr_lcd_oth & 0x30)) {
                                 /* avoid being connected to both crtcs */
@@ -282,17 +281,18 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
                               struct drm_display_mode *adjusted_mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
-        struct nv04_crtc_reg *savep = &dev_priv->saved_reg.crtc_reg[nv_crtc->index];
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
+        struct nv04_crtc_reg *savep = &nv04_display(dev)->saved_reg.crtc_reg[nv_crtc->index];
         struct nouveau_connector *nv_connector = nouveau_crtc_connector_get(nv_crtc);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_display_mode *output_mode = &nv_encoder->mode;
         struct drm_connector *connector = &nv_connector->base;
         uint32_t mode_ratio, panel_ratio;
 
-        NV_DEBUG_KMS(dev, "Output mode on CRTC %d:\n", nv_crtc->index);
+        NV_DEBUG(drm, "Output mode on CRTC %d:\n", nv_crtc->index);
         drm_mode_debug_printmodeline(output_mode);
 
         /* Initialize the FP registers in this CRTC. */
@@ -300,10 +300,10 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
         regp->fp_horiz_regs[FP_TOTAL] = output_mode->htotal - 1;
         if (!nv_gf4_disp_arch(dev) ||
             (output_mode->hsync_start - output_mode->hdisplay) >=
-                                        dev_priv->vbios.digital_min_front_porch)
+                                        drm->vbios.digital_min_front_porch)
                 regp->fp_horiz_regs[FP_CRTC] = output_mode->hdisplay;
         else
-                regp->fp_horiz_regs[FP_CRTC] = output_mode->hsync_start - dev_priv->vbios.digital_min_front_porch - 1;
+                regp->fp_horiz_regs[FP_CRTC] = output_mode->hsync_start - drm->vbios.digital_min_front_porch - 1;
         regp->fp_horiz_regs[FP_SYNC_START] = output_mode->hsync_start - 1;
         regp->fp_horiz_regs[FP_SYNC_END] = output_mode->hsync_end - 1;
         regp->fp_horiz_regs[FP_VALID_START] = output_mode->hskew;
@@ -335,12 +335,12 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
                 regp->fp_control |= NV_PRAMDAC_FP_TG_CONTROL_MODE_NATIVE;
         else /* gpu needs to scale */
                 regp->fp_control |= NV_PRAMDAC_FP_TG_CONTROL_MODE_SCALE;
-        if (nvReadEXTDEV(dev, NV_PEXTDEV_BOOT_0) & NV_PEXTDEV_BOOT_0_STRAP_FP_IFACE_12BIT)
+        if (nv_rd32(device, NV_PEXTDEV_BOOT_0) & NV_PEXTDEV_BOOT_0_STRAP_FP_IFACE_12BIT)
                 regp->fp_control |= NV_PRAMDAC_FP_TG_CONTROL_WIDTH_12;
         if (nv_encoder->dcb->location != DCB_LOC_ON_CHIP &&
             output_mode->clock > 165000)
                 regp->fp_control |= (2 << 24);
-        if (nv_encoder->dcb->type == OUTPUT_LVDS) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS) {
                 bool duallink = false, dummy;
                 if (nv_connector->edid &&
                     nv_connector->type == DCB_CONNECTOR_LVDS_SPWG) {
@@ -416,7 +416,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
         if ((nv_connector->dithering_mode == DITHERING_MODE_ON) ||
             (nv_connector->dithering_mode == DITHERING_MODE_AUTO &&
              encoder->crtc->fb->depth > connector->display_info.bpc * 3)) {
-                if (dev_priv->chipset == 0x11)
+                if (nv_device(drm->device)->chipset == 0x11)
                         regp->dither = savep->dither | 0x00010000;
                 else {
                         int i;
@@ -427,7 +427,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
                         }
                 }
         } else {
-                if (dev_priv->chipset != 0x11) {
+                if (nv_device(drm->device)->chipset != 0x11) {
                         /* reset them */
                         int i;
                         for (i = 0; i < 3; i++) {
@@ -444,26 +444,26 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
 static void nv04_dfp_commit(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_encoder_helper_funcs *helper = encoder->helper_private;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct dcb_entry *dcbe = nv_encoder->dcb;
+        struct dcb_output *dcbe = nv_encoder->dcb;
         int head = nouveau_crtc(encoder->crtc)->index;
         struct drm_encoder *slave_encoder;
 
-        if (dcbe->type == OUTPUT_TMDS)
+        if (dcbe->type == DCB_OUTPUT_TMDS)
                 run_tmds_table(dev, dcbe, head, nv_encoder->mode.clock);
-        else if (dcbe->type == OUTPUT_LVDS)
+        else if (dcbe->type == DCB_OUTPUT_LVDS)
                 call_lvds_script(dev, dcbe, head, LVDS_RESET, nv_encoder->mode.clock);
 
         /* update fp_control state for any changes made by scripts,
          * so correct value is written at DPMS on */
-        dev_priv->mode_reg.crtc_reg[head].fp_control =
+        nv04_display(dev)->mode_reg.crtc_reg[head].fp_control =
                 NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL);
 
         /* This could use refinement for flatpanels, but it should work this way */
-        if (dev_priv->chipset < 0x44)
+        if (nv_device(drm->device)->chipset < 0x44)
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0xf0000000);
         else
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);
@@ -476,7 +476,7 @@ static void nv04_dfp_commit(struct drm_encoder *encoder)
 
         helper->dpms(encoder, DRM_MODE_DPMS_ON);
 
-        NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
+        NV_INFO(drm, "Output %s is running on CRTC %d using output %c\n",
                 drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base),
                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
 }
@@ -485,6 +485,7 @@ static void nv04_dfp_update_backlight(struct drm_encoder *encoder, int mode)
 {
 #ifdef __powerpc__
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
 
         /* BIOS scripts usually take care of the backlight, thanks
          * Apple for your consistency.
@@ -492,11 +493,11 @@ static void nv04_dfp_update_backlight(struct drm_encoder *encoder, int mode)
         if (dev->pci_device == 0x0179 || dev->pci_device == 0x0189 ||
             dev->pci_device == 0x0329) {
                 if (mode == DRM_MODE_DPMS_ON) {
-                        nv_mask(dev, NV_PBUS_DEBUG_DUALHEAD_CTL, 0, 1 << 31);
-                        nv_mask(dev, NV_PCRTC_GPIO_EXT, 3, 1);
+                        nv_mask(device, NV_PBUS_DEBUG_DUALHEAD_CTL, 0, 1 << 31);
+                        nv_mask(device, NV_PCRTC_GPIO_EXT, 3, 1);
                 } else {
-                        nv_mask(dev, NV_PBUS_DEBUG_DUALHEAD_CTL, 1 << 31, 0);
-                        nv_mask(dev, NV_PCRTC_GPIO_EXT, 3, 0);
+                        nv_mask(device, NV_PBUS_DEBUG_DUALHEAD_CTL, 1 << 31, 0);
+                        nv_mask(device, NV_PCRTC_GPIO_EXT, 3, 0);
                 }
         }
 #endif
@@ -511,7 +512,7 @@ static void nv04_lvds_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
         struct drm_crtc *crtc = encoder->crtc;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         bool was_powersaving = is_powersaving_dpms(nv_encoder->last_dpms);
 
@@ -519,7 +520,7 @@ static void nv04_lvds_dpms(struct drm_encoder *encoder, int mode)
                 return;
         nv_encoder->last_dpms = mode;
 
-        NV_INFO(dev, "Setting dpms mode %d on lvds encoder (output %d)\n",
+        NV_INFO(drm, "Setting dpms mode %d on lvds encoder (output %d)\n",
                      mode, nv_encoder->dcb->index);
 
         if (was_powersaving && is_powersaving_dpms(mode))
@@ -549,22 +550,22 @@ static void nv04_lvds_dpms(struct drm_encoder *encoder, int mode)
         if (mode == DRM_MODE_DPMS_ON)
                 nv04_dfp_prepare_sel_clk(dev, nv_encoder, nouveau_crtc(crtc)->index);
         else {
-                dev_priv->mode_reg.sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK);
-                dev_priv->mode_reg.sel_clk &= ~0xf0;
+                nv04_display(dev)->mode_reg.sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK);
+                nv04_display(dev)->mode_reg.sel_clk &= ~0xf0;
         }
-        NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, dev_priv->mode_reg.sel_clk);
+        NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, nv04_display(dev)->mode_reg.sel_clk);
 }
 
 static void nv04_tmds_dpms(struct drm_encoder *encoder, int mode)
 {
-        struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 
         if (nv_encoder->last_dpms == mode)
                 return;
         nv_encoder->last_dpms = mode;
 
-        NV_INFO(dev, "Setting dpms mode %d on tmds encoder (output %d)\n",
+        NV_INFO(drm, "Setting dpms mode %d on tmds encoder (output %d)\n",
                      mode, nv_encoder->dcb->index);
 
         nv04_dfp_update_backlight(encoder, mode);
@@ -585,10 +586,9 @@ static void nv04_dfp_restore(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         int head = nv_encoder->restore.head;
 
-        if (nv_encoder->dcb->type == OUTPUT_LVDS) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS) {
                 struct nouveau_connector *connector =
                         nouveau_encoder_connector_get(nv_encoder);
 
@@ -597,9 +597,9 @@ static void nv04_dfp_restore(struct drm_encoder *encoder)
                                          LVDS_PANEL_ON,
                                          connector->native_mode->clock);
 
-        } else if (nv_encoder->dcb->type == OUTPUT_TMDS) {
+        } else if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS) {
                 int clock = nouveau_hw_pllvals_to_clk
-                                        (&dev_priv->saved_reg.crtc_reg[head].pllvals);
+                                        (&nv04_display(dev)->saved_reg.crtc_reg[head].pllvals);
 
                 run_tmds_table(dev, nv_encoder->dcb, head, clock);
         }
@@ -611,8 +611,6 @@ static void nv04_dfp_destroy(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 
-        NV_DEBUG_KMS(encoder->dev, "\n");
-
         if (get_slave_funcs(encoder))
                 get_slave_funcs(encoder)->destroy(encoder);
 
@@ -623,8 +621,10 @@ static void nv04_dfp_destroy(struct drm_encoder *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 dcb_output *dcb = nouveau_encoder(encoder)->dcb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+        struct nouveau_i2c_port *port = i2c->find(i2c, 2);
         struct i2c_board_info info[] = {
                 {
                         .type = "sil164",
@@ -637,16 +637,16 @@ static void nv04_tmds_slave_init(struct drm_encoder *encoder)
         };
         int type;
 
-        if (!nv_gf4_disp_arch(dev) || !i2c ||
+        if (!nv_gf4_disp_arch(dev) || !port ||
             get_tmds_slave(encoder))
                 return;
 
-        type = nouveau_i2c_identify(dev, "TMDS transmitter", info, NULL, 2);
+        type = i2c->identify(i2c, 2, "TMDS transmitter", info, NULL);
         if (type < 0)
                 return;
 
         drm_i2c_encoder_init(dev, to_encoder_slave(encoder),
-                             &i2c->adapter, &info[type]);
+                             &port->adapter, &info[type]);
 }
 
 static const struct drm_encoder_helper_funcs nv04_lvds_helper_funcs = {
@@ -676,7 +676,7 @@ static const struct drm_encoder_funcs nv04_dfp_funcs = {
 };
 
 int
-nv04_dfp_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv04_dfp_create(struct drm_connector *connector, struct dcb_output *entry)
 {
         const struct drm_encoder_helper_funcs *helper;
         struct nouveau_encoder *nv_encoder = NULL;
@@ -684,11 +684,11 @@ nv04_dfp_create(struct drm_connector *connector, struct dcb_entry *entry)
         int type;
 
         switch (entry->type) {
-        case OUTPUT_TMDS:
+        case DCB_OUTPUT_TMDS:
                 type = DRM_MODE_ENCODER_TMDS;
                 helper = &nv04_tmds_helper_funcs;
                 break;
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 type = DRM_MODE_ENCODER_LVDS;
                 helper = &nv04_lvds_helper_funcs;
                 break;
@@ -711,7 +711,7 @@ 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 &&
+        if (entry->type == DCB_OUTPUT_TMDS &&
             entry->location != DCB_LOC_ON_CHIP)
                 nv04_tmds_slave_init(encoder);
 
diff --git a/drivers/gpu/drm/nouveau/nv04_display.c b/drivers/gpu/drm/nouveau/nv04_display.c
index 44488e3a257d..b25b8d9c2fcc 100644
--- a/drivers/gpu/drm/nouveau/nv04_display.c
+++ b/drivers/gpu/drm/nouveau/nv04_display.c
@@ -26,78 +26,15 @@
 #include "drm.h"
 #include "drm_crtc_helper.h"
 
-#include "nouveau_drv.h"
-#include "nouveau_fb.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_hw.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 
-static void nv04_vblank_crtc0_isr(struct drm_device *);
-static void nv04_vblank_crtc1_isr(struct drm_device *);
-
-static void
-nv04_display_store_initial_head_owner(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (dev_priv->chipset != 0x11) {
-                dev_priv->crtc_owner = NVReadVgaCrtc(dev, 0, NV_CIO_CRE_44);
-                return;
-        }
-
-        /* reading CR44 is broken on nv11, so we attempt to infer it */
-        if (nvReadMC(dev, NV_PBUS_DEBUG_1) & (1 << 28)) /* heads tied, restore both */
-                dev_priv->crtc_owner = 0x4;
-        else {
-                uint8_t slaved_on_A, slaved_on_B;
-                bool tvA = false;
-                bool tvB = false;
-
-                slaved_on_B = NVReadVgaCrtc(dev, 1, NV_CIO_CRE_PIXEL_INDEX) &
-                                                                        0x80;
-                if (slaved_on_B)
-                        tvB = !(NVReadVgaCrtc(dev, 1, NV_CIO_CRE_LCD__INDEX) &
-                                        MASK(NV_CIO_CRE_LCD_LCD_SELECT));
-
-                slaved_on_A = NVReadVgaCrtc(dev, 0, NV_CIO_CRE_PIXEL_INDEX) &
-                                                                        0x80;
-                if (slaved_on_A)
-                        tvA = !(NVReadVgaCrtc(dev, 0, NV_CIO_CRE_LCD__INDEX) &
-                                        MASK(NV_CIO_CRE_LCD_LCD_SELECT));
-
-                if (slaved_on_A && !tvA)
-                        dev_priv->crtc_owner = 0x0;
-                else if (slaved_on_B && !tvB)
-                        dev_priv->crtc_owner = 0x3;
-                else if (slaved_on_A)
-                        dev_priv->crtc_owner = 0x0;
-                else if (slaved_on_B)
-                        dev_priv->crtc_owner = 0x3;
-                else
-                        dev_priv->crtc_owner = 0x0;
-        }
-}
-
 int
 nv04_display_early_init(struct drm_device *dev)
 {
-        /* Make the I2C buses accessible. */
-        if (!nv_gf4_disp_arch(dev)) {
-                uint32_t pmc_enable = nv_rd32(dev, NV03_PMC_ENABLE);
-
-                if (!(pmc_enable & 1))
-                        nv_wr32(dev, NV03_PMC_ENABLE, pmc_enable | 1);
-        }
-
-        /* Unlock the VGA CRTCs. */
-        NVLockVgaCrtcs(dev, false);
-
-        /* Make sure the CRTCs aren't in slaved mode. */
-        if (nv_two_heads(dev)) {
-                nv04_display_store_initial_head_owner(dev);
-                NVSetOwner(dev, 0);
-        }
-
         /* ensure vblank interrupts are off, they can't be enabled until
          * drm_vblank has been initialised
          */
@@ -111,25 +48,29 @@ nv04_display_early_init(struct drm_device *dev)
 void
 nv04_display_late_takedown(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (nv_two_heads(dev))
-                NVSetOwner(dev, dev_priv->crtc_owner);
-
-        NVLockVgaCrtcs(dev, true);
 }
 
 int
 nv04_display_create(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct dcb_table *dcb = &dev_priv->vbios.dcb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct dcb_table *dcb = &drm->vbios.dcb;
         struct drm_connector *connector, *ct;
         struct drm_encoder *encoder;
         struct drm_crtc *crtc;
+        struct nv04_display *disp;
         int i, ret;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
+
+        disp = kzalloc(sizeof(*disp), GFP_KERNEL);
+        if (!disp)
+                return -ENOMEM;
+
+        nouveau_display(dev)->priv = disp;
+        nouveau_display(dev)->dtor = nv04_display_destroy;
+        nouveau_display(dev)->init = nv04_display_init;
+        nouveau_display(dev)->fini = nv04_display_fini;
 
         nouveau_hw_save_vga_fonts(dev, 1);
 
@@ -138,28 +79,28 @@ nv04_display_create(struct drm_device *dev)
                 nv04_crtc_create(dev, 1);
 
         for (i = 0; i < dcb->entries; i++) {
-                struct dcb_entry *dcbent = &dcb->entry[i];
+                struct dcb_output *dcbent = &dcb->entry[i];
 
                 connector = nouveau_connector_create(dev, dcbent->connector);
                 if (IS_ERR(connector))
                         continue;
 
                 switch (dcbent->type) {
-                case OUTPUT_ANALOG:
+                case DCB_OUTPUT_ANALOG:
                         ret = nv04_dac_create(connector, dcbent);
                         break;
-                case OUTPUT_LVDS:
-                case OUTPUT_TMDS:
+                case DCB_OUTPUT_LVDS:
+                case DCB_OUTPUT_TMDS:
                         ret = nv04_dfp_create(connector, dcbent);
                         break;
-                case OUTPUT_TV:
+                case DCB_OUTPUT_TV:
                         if (dcbent->location == DCB_LOC_ON_CHIP)
                                 ret = nv17_tv_create(connector, dcbent);
                         else
                                 ret = nv04_tv_create(connector, dcbent);
                         break;
                 default:
-                        NV_WARN(dev, "DCB type %d not known\n", dcbent->type);
+                        NV_WARN(drm, "DCB type %d not known\n", dcbent->type);
                         continue;
                 }
 
@@ -170,7 +111,7 @@ nv04_display_create(struct drm_device *dev)
         list_for_each_entry_safe(connector, ct,
                                  &dev->mode_config.connector_list, head) {
                 if (!connector->encoder_ids[0]) {
-                        NV_WARN(dev, "%s has no encoders, removing\n",
+                        NV_WARN(drm, "%s has no encoders, removing\n",
                                 drm_get_connector_name(connector));
                         connector->funcs->destroy(connector);
                 }
@@ -186,21 +127,18 @@ nv04_display_create(struct drm_device *dev)
                 func->save(encoder);
         }
 
-        nouveau_irq_register(dev, 24, nv04_vblank_crtc0_isr);
-        nouveau_irq_register(dev, 25, nv04_vblank_crtc1_isr);
         return 0;
 }
 
 void
 nv04_display_destroy(struct drm_device *dev)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nv04_display *disp = nv04_display(dev);
         struct drm_encoder *encoder;
         struct drm_crtc *crtc;
 
-        NV_DEBUG_KMS(dev, "\n");
-
-        nouveau_irq_unregister(dev, 24);
-        nouveau_irq_unregister(dev, 25);
+        NV_DEBUG(drm, "\n");
 
         /* Turn every CRTC off. */
         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
@@ -222,6 +160,9 @@ nv04_display_destroy(struct drm_device *dev)
                 crtc->funcs->restore(crtc);
 
         nouveau_hw_save_vga_fonts(dev, 0);
+
+        nouveau_display(dev)->priv = NULL;
+        kfree(disp);
 }
 
 int
@@ -258,17 +199,3 @@ nv04_display_fini(struct drm_device *dev)
         if (nv_two_heads(dev))
                 NVWriteCRTC(dev, 1, NV_PCRTC_INTR_EN_0, 0);
 }
-
-static void
-nv04_vblank_crtc0_isr(struct drm_device *dev)
-{
-        nv_wr32(dev, NV_CRTC0_INTSTAT, NV_CRTC_INTR_VBLANK);
-        drm_handle_vblank(dev, 0);
-}
-
-static void
-nv04_vblank_crtc1_isr(struct drm_device *dev)
-{
-        nv_wr32(dev, NV_CRTC1_INTSTAT, NV_CRTC_INTR_VBLANK);
-        drm_handle_vblank(dev, 1);
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_display.h b/drivers/gpu/drm/nouveau/nv04_display.h
new file mode 100644
index 000000000000..45322802e37d
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nv04_display.h
@@ -0,0 +1,184 @@
+#ifndef __NV04_DISPLAY_H__
+#define __NV04_DISPLAY_H__
+
+#include <subdev/bios/pll.h>
+
+#include "nouveau_display.h"
+
+enum nv04_fp_display_regs {
+        FP_DISPLAY_END,
+        FP_TOTAL,
+        FP_CRTC,
+        FP_SYNC_START,
+        FP_SYNC_END,
+        FP_VALID_START,
+        FP_VALID_END
+};
+
+struct nv04_crtc_reg {
+        unsigned char MiscOutReg;
+        uint8_t CRTC[0xa0];
+        uint8_t CR58[0x10];
+        uint8_t Sequencer[5];
+        uint8_t Graphics[9];
+        uint8_t Attribute[21];
+        unsigned char DAC[768];
+
+        /* PCRTC regs */
+        uint32_t fb_start;
+        uint32_t crtc_cfg;
+        uint32_t cursor_cfg;
+        uint32_t gpio_ext;
+        uint32_t crtc_830;
+        uint32_t crtc_834;
+        uint32_t crtc_850;
+        uint32_t crtc_eng_ctrl;
+
+        /* PRAMDAC regs */
+        uint32_t nv10_cursync;
+        struct nouveau_pll_vals pllvals;
+        uint32_t ramdac_gen_ctrl;
+        uint32_t ramdac_630;
+        uint32_t ramdac_634;
+        uint32_t tv_setup;
+        uint32_t tv_vtotal;
+        uint32_t tv_vskew;
+        uint32_t tv_vsync_delay;
+        uint32_t tv_htotal;
+        uint32_t tv_hskew;
+        uint32_t tv_hsync_delay;
+        uint32_t tv_hsync_delay2;
+        uint32_t fp_horiz_regs[7];
+        uint32_t fp_vert_regs[7];
+        uint32_t dither;
+        uint32_t fp_control;
+        uint32_t dither_regs[6];
+        uint32_t fp_debug_0;
+        uint32_t fp_debug_1;
+        uint32_t fp_debug_2;
+        uint32_t fp_margin_color;
+        uint32_t ramdac_8c0;
+        uint32_t ramdac_a20;
+        uint32_t ramdac_a24;
+        uint32_t ramdac_a34;
+        uint32_t ctv_regs[38];
+};
+
+struct nv04_output_reg {
+        uint32_t output;
+        int head;
+};
+
+struct nv04_mode_state {
+        struct nv04_crtc_reg crtc_reg[2];
+        uint32_t pllsel;
+        uint32_t sel_clk;
+};
+
+struct nv04_display {
+        struct nv04_mode_state mode_reg;
+        struct nv04_mode_state saved_reg;
+        uint32_t saved_vga_font[4][16384];
+        uint32_t dac_users[4];
+};
+
+static inline struct nv04_display *
+nv04_display(struct drm_device *dev)
+{
+        return nouveau_display(dev)->priv;
+}
+
+/* nv04_display.c */
+int nv04_display_early_init(struct drm_device *);
+void nv04_display_late_takedown(struct drm_device *);
+int nv04_display_create(struct drm_device *);
+void nv04_display_destroy(struct drm_device *);
+int nv04_display_init(struct drm_device *);
+void nv04_display_fini(struct drm_device *);
+
+/* nv04_crtc.c */
+int nv04_crtc_create(struct drm_device *, int index);
+
+/* nv04_dac.c */
+int nv04_dac_create(struct drm_connector *, struct dcb_output *);
+uint32_t nv17_dac_sample_load(struct drm_encoder *encoder);
+int nv04_dac_output_offset(struct drm_encoder *encoder);
+void nv04_dac_update_dacclk(struct drm_encoder *encoder, bool enable);
+bool nv04_dac_in_use(struct drm_encoder *encoder);
+
+/* nv04_dfp.c */
+int nv04_dfp_create(struct drm_connector *, struct dcb_output *);
+int nv04_dfp_get_bound_head(struct drm_device *dev, struct dcb_output *dcbent);
+void nv04_dfp_bind_head(struct drm_device *dev, struct dcb_output *dcbent,
+                               int head, bool dl);
+void nv04_dfp_disable(struct drm_device *dev, int head);
+void nv04_dfp_update_fp_control(struct drm_encoder *encoder, int mode);
+
+/* nv04_tv.c */
+int nv04_tv_identify(struct drm_device *dev, int i2c_index);
+int nv04_tv_create(struct drm_connector *, struct dcb_output *);
+
+/* nv17_tv.c */
+int nv17_tv_create(struct drm_connector *, struct dcb_output *);
+
+static inline bool
+nv_two_heads(struct drm_device *dev)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        const int impl = dev->pci_device & 0x0ff0;
+
+        if (nv_device(drm->device)->card_type >= NV_10 && impl != 0x0100 &&
+            impl != 0x0150 && impl != 0x01a0 && impl != 0x0200)
+                return true;
+
+        return false;
+}
+
+static inline bool
+nv_gf4_disp_arch(struct drm_device *dev)
+{
+        return nv_two_heads(dev) && (dev->pci_device & 0x0ff0) != 0x0110;
+}
+
+static inline bool
+nv_two_reg_pll(struct drm_device *dev)
+{
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        const int impl = dev->pci_device & 0x0ff0;
+
+        if (impl == 0x0310 || impl == 0x0340 || nv_device(drm->device)->card_type >= NV_40)
+                return true;
+        return false;
+}
+
+static inline bool
+nv_match_device(struct drm_device *dev, unsigned device,
+                unsigned sub_vendor, unsigned sub_device)
+{
+        return dev->pdev->device == device &&
+                dev->pdev->subsystem_vendor == sub_vendor &&
+                dev->pdev->subsystem_device == sub_device;
+}
+
+#include <subdev/bios.h>
+#include <subdev/bios/init.h>
+
+static inline void
+nouveau_bios_run_init_table(struct drm_device *dev, u16 table,
+                            struct dcb_output *outp, int crtc)
+{
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nvbios_init init = {
+                .subdev = nv_subdev(bios),
+                .bios = bios,
+                .offset = table,
+                .outp = outp,
+                .crtc = crtc,
+                .execute = 1,
+        };
+
+        nvbios_exec(&init);
+}
+
+#endif
diff --git a/drivers/gpu/drm/nouveau/nv04_fb.c b/drivers/gpu/drm/nouveau/nv04_fb.c
deleted file mode 100644
index d5eedd67afe5..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_fb.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-int
-nv04_fb_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 boot0 = nv_rd32(dev, NV04_PFB_BOOT_0);
-
-        if (boot0 & 0x00000100) {
-                dev_priv->vram_size  = ((boot0 >> 12) & 0xf) * 2 + 2;
-                dev_priv->vram_size *= 1024 * 1024;
-        } else {
-                switch (boot0 & NV04_PFB_BOOT_0_RAM_AMOUNT) {
-                case NV04_PFB_BOOT_0_RAM_AMOUNT_32MB:
-                        dev_priv->vram_size = 32 * 1024 * 1024;
-                        break;
-                case NV04_PFB_BOOT_0_RAM_AMOUNT_16MB:
-                        dev_priv->vram_size = 16 * 1024 * 1024;
-                        break;
-                case NV04_PFB_BOOT_0_RAM_AMOUNT_8MB:
-                        dev_priv->vram_size = 8 * 1024 * 1024;
-                        break;
-                case NV04_PFB_BOOT_0_RAM_AMOUNT_4MB:
-                        dev_priv->vram_size = 4 * 1024 * 1024;
-                        break;
-                }
-        }
-
-        if ((boot0 & 0x00000038) <= 0x10)
-                dev_priv->vram_type = NV_MEM_TYPE_SGRAM;
-        else
-                dev_priv->vram_type = NV_MEM_TYPE_SDRAM;
-
-        return 0;
-}
-
-int
-nv04_fb_init(struct drm_device *dev)
-{
-        /* This is what the DDX did for NV_ARCH_04, but a mmio-trace shows
-         * nvidia reading PFB_CFG_0, then writing back its original value.
-         * (which was 0x701114 in this case)
-         */
-
-        nv_wr32(dev, NV04_PFB_CFG0, 0x1114);
-        return 0;
-}
-
-void
-nv04_fb_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_fbcon.c b/drivers/gpu/drm/nouveau/nv04_fbcon.c
index 7cd7857347ef..77dcc9c50777 100644
--- a/drivers/gpu/drm/nouveau/nv04_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nv04_fbcon.c
@@ -22,19 +22,18 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include <core/object.h>
+
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fbcon.h"
 
 int
 nv04_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         ret = RING_SPACE(chan, 4);
@@ -53,9 +52,8 @@ int
 nv04_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         ret = RING_SPACE(chan, 7);
@@ -81,9 +79,8 @@ int
 nv04_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         uint32_t fg;
         uint32_t bg;
         uint32_t dsize;
@@ -142,9 +139,10 @@ nv04_fbcon_accel_init(struct fb_info *info)
 {
         struct nouveau_fbdev *nfbdev = info->par;
         struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
-        const int sub = NvSubCtxSurf2D;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_channel *chan = drm->channel;
+        struct nouveau_device *device = nv_device(drm->device);
+        struct nouveau_object *object;
         int surface_fmt, pattern_fmt, rect_fmt;
         int ret;
 
@@ -176,31 +174,35 @@ nv04_fbcon_accel_init(struct fb_info *info)
                 return -EINVAL;
         }
 
-        ret = nouveau_gpuobj_gr_new(chan, NvCtxSurf2D,
-                                    dev_priv->card_type >= NV_10 ?
-                                    0x0062 : 0x0042);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvCtxSurf2D,
+                                 device->card_type >= NV_10 ? 0x0062 : 0x0042,
+                                 NULL, 0, &object);
         if (ret)
                 return ret;
 
-        ret = nouveau_gpuobj_gr_new(chan, NvClipRect, 0x0019);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvClipRect,
+                                 0x0019, NULL, 0, &object);
         if (ret)
                 return ret;
 
-        ret = nouveau_gpuobj_gr_new(chan, NvRop, 0x0043);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvRop,
+                                 0x0043, NULL, 0, &object);
         if (ret)
                 return ret;
 
-        ret = nouveau_gpuobj_gr_new(chan, NvImagePatt, 0x0044);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvImagePatt,
+                                 0x0044, NULL, 0, &object);
         if (ret)
                 return ret;
 
-        ret = nouveau_gpuobj_gr_new(chan, NvGdiRect, 0x004a);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvGdiRect,
+                                 0x004a, NULL, 0, &object);
         if (ret)
                 return ret;
 
-        ret = nouveau_gpuobj_gr_new(chan, NvImageBlit,
-                                    dev_priv->chipset >= 0x11 ?
-                                    0x009f : 0x005f);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvImageBlit,
+                                 device->chipset >= 0x11 ? 0x009f : 0x005f,
+                                 NULL, 0, &object);
         if (ret)
                 return ret;
 
@@ -209,25 +211,25 @@ nv04_fbcon_accel_init(struct fb_info *info)
                 return 0;
         }
 
-        BEGIN_NV04(chan, sub, 0x0000, 1);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0000, 1);
         OUT_RING(chan, NvCtxSurf2D);
-        BEGIN_NV04(chan, sub, 0x0184, 2);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0184, 2);
         OUT_RING(chan, NvDmaFB);
         OUT_RING(chan, NvDmaFB);
-        BEGIN_NV04(chan, sub, 0x0300, 4);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0300, 4);
         OUT_RING(chan, surface_fmt);
         OUT_RING(chan, info->fix.line_length | (info->fix.line_length << 16));
         OUT_RING(chan, info->fix.smem_start - dev->mode_config.fb_base);
         OUT_RING(chan, info->fix.smem_start - dev->mode_config.fb_base);
 
-        BEGIN_NV04(chan, sub, 0x0000, 1);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0000, 1);
         OUT_RING(chan, NvRop);
-        BEGIN_NV04(chan, sub, 0x0300, 1);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0300, 1);
         OUT_RING(chan, 0x55);
 
-        BEGIN_NV04(chan, sub, 0x0000, 1);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0000, 1);
         OUT_RING(chan, NvImagePatt);
-        BEGIN_NV04(chan, sub, 0x0300, 8);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0300, 8);
         OUT_RING(chan, pattern_fmt);
 #ifdef __BIG_ENDIAN
         OUT_RING(chan, 2);
@@ -241,9 +243,9 @@ nv04_fbcon_accel_init(struct fb_info *info)
         OUT_RING(chan, ~0);
         OUT_RING(chan, ~0);
 
-        BEGIN_NV04(chan, sub, 0x0000, 1);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0000, 1);
         OUT_RING(chan, NvClipRect);
-        BEGIN_NV04(chan, sub, 0x0300, 2);
+        BEGIN_NV04(chan, NvSubCtxSurf2D, 0x0300, 2);
         OUT_RING(chan, 0);
         OUT_RING(chan, (info->var.yres_virtual << 16) | info->var.xres_virtual);
 
diff --git a/drivers/gpu/drm/nouveau/nv04_fence.c b/drivers/gpu/drm/nouveau/nv04_fence.c
index abe89db6de24..a220b94ba9f2 100644
--- a/drivers/gpu/drm/nouveau/nv04_fence.c
+++ b/drivers/gpu/drm/nouveau/nv04_fence.c
@@ -22,15 +22,14 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include <engine/fifo.h>
+
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fence.h"
 
 struct nv04_fence_chan {
         struct nouveau_fence_chan base;
-        atomic_t sequence;
 };
 
 struct nv04_fence_priv {
@@ -57,84 +56,56 @@ nv04_fence_sync(struct nouveau_fence *fence,
         return -ENODEV;
 }
 
-int
-nv04_fence_mthd(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        struct nv04_fence_chan *fctx = chan->engctx[NVOBJ_ENGINE_FENCE];
-        atomic_set(&fctx->sequence, data);
-        return 0;
-}
-
 static u32
 nv04_fence_read(struct nouveau_channel *chan)
 {
-        struct nv04_fence_chan *fctx = chan->engctx[NVOBJ_ENGINE_FENCE];
-        return atomic_read(&fctx->sequence);
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
+        return atomic_read(&fifo->refcnt);
 }
 
 static void
-nv04_fence_context_del(struct nouveau_channel *chan, int engine)
+nv04_fence_context_del(struct nouveau_channel *chan)
 {
-        struct nv04_fence_chan *fctx = chan->engctx[engine];
+        struct nv04_fence_chan *fctx = chan->fence;
         nouveau_fence_context_del(&fctx->base);
-        chan->engctx[engine] = NULL;
+        chan->fence = NULL;
         kfree(fctx);
 }
 
 static int
-nv04_fence_context_new(struct nouveau_channel *chan, int engine)
+nv04_fence_context_new(struct nouveau_channel *chan)
 {
         struct nv04_fence_chan *fctx = kzalloc(sizeof(*fctx), GFP_KERNEL);
         if (fctx) {
                 nouveau_fence_context_new(&fctx->base);
-                atomic_set(&fctx->sequence, 0);
-                chan->engctx[engine] = fctx;
+                chan->fence = fctx;
                 return 0;
         }
         return -ENOMEM;
 }
 
-static int
-nv04_fence_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static int
-nv04_fence_init(struct drm_device *dev, int engine)
-{
-        return 0;
-}
-
 static void
-nv04_fence_destroy(struct drm_device *dev, int engine)
+nv04_fence_destroy(struct nouveau_drm *drm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fence_priv *priv = nv_engine(dev, engine);
-
-        dev_priv->eng[engine] = NULL;
+        struct nv04_fence_priv *priv = drm->fence;
+        drm->fence = NULL;
         kfree(priv);
 }
 
 int
-nv04_fence_create(struct drm_device *dev)
+nv04_fence_create(struct nouveau_drm *drm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nv04_fence_priv *priv;
-        int ret;
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = drm->fence = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
-        priv->base.engine.destroy = nv04_fence_destroy;
-        priv->base.engine.init = nv04_fence_init;
-        priv->base.engine.fini = nv04_fence_fini;
-        priv->base.engine.context_new = nv04_fence_context_new;
-        priv->base.engine.context_del = nv04_fence_context_del;
+        priv->base.dtor = nv04_fence_destroy;
+        priv->base.context_new = nv04_fence_context_new;
+        priv->base.context_del = nv04_fence_context_del;
         priv->base.emit = nv04_fence_emit;
         priv->base.sync = nv04_fence_sync;
         priv->base.read = nv04_fence_read;
-        dev_priv->eng[NVOBJ_ENGINE_FENCE] = &priv->base.engine;
-        return ret;
+        return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/nv04_fifo.c b/drivers/gpu/drm/nouveau/nv04_fifo.c
deleted file mode 100644
index a6295cd00ec7..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_fifo.c
+++ /dev/null
@@ -1,506 +0,0 @@
-/*
- * Copyright (C) 2012 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_util.h"
-#include "nouveau_ramht.h"
-#include "nouveau_software.h"
-
-static struct ramfc_desc {
-        unsigned bits:6;
-        unsigned ctxs:5;
-        unsigned ctxp:8;
-        unsigned regs:5;
-        unsigned regp;
-} nv04_ramfc[] = {
-        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
-        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
-        { 16,  0, 0x08,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
-        { 16, 16, 0x08,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
-        { 32,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_STATE },
-        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
-        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_ENGINE },
-        { 32,  0, 0x18,  0, NV04_PFIFO_CACHE1_PULL1 },
-        {}
-};
-
-struct nv04_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct ramfc_desc *ramfc_desc;
-};
-
-struct nv04_fifo_chan {
-        struct nouveau_fifo_chan base;
-        struct nouveau_gpuobj *ramfc;
-};
-
-bool
-nv04_fifo_cache_pull(struct drm_device *dev, bool enable)
-{
-        int pull = nv_mask(dev, NV04_PFIFO_CACHE1_PULL0, 1, enable);
-
-        if (!enable) {
-                /* In some cases the PFIFO puller may be left in an
-                 * inconsistent state if you try to stop it when it's
-                 * busy translating handles. Sometimes you get a
-                 * PFIFO_CACHE_ERROR, sometimes it just fails silently
-                 * sending incorrect instance offsets to PGRAPH after
-                 * it's started up again. To avoid the latter we
-                 * invalidate the most recently calculated instance.
-                 */
-                if (!nv_wait(dev, NV04_PFIFO_CACHE1_PULL0,
-                                  NV04_PFIFO_CACHE1_PULL0_HASH_BUSY, 0))
-                        NV_ERROR(dev, "Timeout idling the PFIFO puller.\n");
-
-                if (nv_rd32(dev, NV04_PFIFO_CACHE1_PULL0) &
-                                 NV04_PFIFO_CACHE1_PULL0_HASH_FAILED)
-                        nv_wr32(dev, NV03_PFIFO_INTR_0,
-                                     NV_PFIFO_INTR_CACHE_ERROR);
-
-                nv_wr32(dev, NV04_PFIFO_CACHE1_HASH, 0);
-        }
-
-        return pull & 1;
-}
-
-static int
-nv04_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fifo_priv *priv = nv_engine(dev, engine);
-        struct nv04_fifo_chan *fctx;
-        unsigned long flags;
-        int ret;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-
-        /* map channel control registers */
-        chan->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                             NV03_USER(chan->id), PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        /* initialise default fifo context */
-        ret = nouveau_gpuobj_new_fake(dev, dev_priv->ramfc->pinst +
-                                      chan->id * 32, ~0, 32,
-                                      NVOBJ_FLAG_ZERO_FREE, &fctx->ramfc);
-        if (ret)
-                goto error;
-
-        nv_wo32(fctx->ramfc, 0x00, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x04, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x08, chan->pushbuf->pinst >> 4);
-        nv_wo32(fctx->ramfc, 0x0c, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x10, NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
-                                   NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
-#ifdef __BIG_ENDIAN
-                                   NV_PFIFO_CACHE1_BIG_ENDIAN |
-#endif
-                                   NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
-        nv_wo32(fctx->ramfc, 0x14, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x18, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x1c, 0x00000000);
-
-        /* enable dma mode on the channel */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PFIFO_MODE, (1 << chan->id), (1 << chan->id));
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-void
-nv04_fifo_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fifo_priv *priv = nv_engine(chan->dev, engine);
-        struct nv04_fifo_chan *fctx = chan->engctx[engine];
-        struct ramfc_desc *c = priv->ramfc_desc;
-        unsigned long flags;
-        int chid;
-
-        /* prevent fifo context switches */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 0);
-
-        /* if this channel is active, replace it with a null context */
-        chid = nv_rd32(dev, NV03_PFIFO_CACHE1_PUSH1) & priv->base.channels;
-        if (chid == chan->id) {
-                nv_mask(dev, NV04_PFIFO_CACHE1_DMA_PUSH, 0x00000001, 0);
-                nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0, 0);
-                nv_mask(dev, NV04_PFIFO_CACHE1_PULL0, 0x00000001, 0);
-
-                do {
-                        u32 mask = ((1ULL << c->bits) - 1) << c->regs;
-                        nv_mask(dev, c->regp, mask, 0x00000000);
-                } while ((++c)->bits);
-
-                nv_wr32(dev, NV03_PFIFO_CACHE1_GET, 0);
-                nv_wr32(dev, NV03_PFIFO_CACHE1_PUT, 0);
-                nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH1, priv->base.channels);
-                nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0, 1);
-                nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 1);
-        }
-
-        /* restore normal operation, after disabling dma mode */
-        nv_mask(dev, NV04_PFIFO_MODE, 1 << chan->id, 0);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 1);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* clean up */
-        nouveau_gpuobj_ref(NULL, &fctx->ramfc);
-        nouveau_gpuobj_ref(NULL, &chan->ramfc); /*XXX: nv40 */
-        if (chan->user) {
-                iounmap(chan->user);
-                chan->user = NULL;
-        }
-}
-
-int
-nv04_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-
-        nv_mask(dev, NV03_PMC_ENABLE, NV_PMC_ENABLE_PFIFO, 0);
-        nv_mask(dev, NV03_PMC_ENABLE, NV_PMC_ENABLE_PFIFO, NV_PMC_ENABLE_PFIFO);
-
-        nv_wr32(dev, NV04_PFIFO_DELAY_0, 0x000000ff);
-        nv_wr32(dev, NV04_PFIFO_DMA_TIMESLICE, 0x0101ffff);
-
-        nv_wr32(dev, NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ |
-                                       ((dev_priv->ramht->bits - 9) << 16) |
-                                       (dev_priv->ramht->gpuobj->pinst >> 8));
-        nv_wr32(dev, NV03_PFIFO_RAMRO, dev_priv->ramro->pinst >> 8);
-        nv_wr32(dev, NV03_PFIFO_RAMFC, dev_priv->ramfc->pinst >> 8);
-
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH1, priv->base.channels);
-
-        nv_wr32(dev, NV03_PFIFO_INTR_0, 0xffffffff);
-        nv_wr32(dev, NV03_PFIFO_INTR_EN_0, 0xffffffff);
-
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0, 1);
-        nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 1);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 1);
-
-        for (i = 0; i < priv->base.channels; i++) {
-                if (dev_priv->channels.ptr[i])
-                        nv_mask(dev, NV04_PFIFO_MODE, (1 << i), (1 << i));
-        }
-
-        return 0;
-}
-
-int
-nv04_fifo_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fifo_priv *priv = nv_engine(dev, engine);
-        struct nouveau_channel *chan;
-        int chid;
-
-        /* prevent context switches and halt fifo operation */
-        nv_wr32(dev, NV03_PFIFO_CACHES, 0);
-        nv_wr32(dev, NV04_PFIFO_CACHE1_DMA_PUSH, 0);
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0, 0);
-        nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 0);
-
-        /* store current fifo context in ramfc */
-        chid = nv_rd32(dev, NV03_PFIFO_CACHE1_PUSH1) & priv->base.channels;
-        chan = dev_priv->channels.ptr[chid];
-        if (suspend && chid != priv->base.channels && chan) {
-                struct nv04_fifo_chan *fctx = chan->engctx[engine];
-                struct nouveau_gpuobj *ctx = fctx->ramfc;
-                struct ramfc_desc *c = priv->ramfc_desc;
-                do {
-                        u32 rm = ((1ULL << c->bits) - 1) << c->regs;
-                        u32 cm = ((1ULL << c->bits) - 1) << c->ctxs;
-                        u32 rv = (nv_rd32(dev, c->regp) &  rm) >> c->regs;
-                        u32 cv = (nv_ro32(ctx, c->ctxp) & ~cm);
-                        nv_wo32(ctx, c->ctxp, cv | (rv << c->ctxs));
-                } while ((++c)->bits);
-        }
-
-        nv_wr32(dev, NV03_PFIFO_INTR_EN_0, 0x00000000);
-        return 0;
-}
-
-static bool
-nouveau_fifo_swmthd(struct drm_device *dev, u32 chid, u32 addr, u32 data)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = NULL;
-        struct nouveau_gpuobj *obj;
-        unsigned long flags;
-        const int subc = (addr >> 13) & 0x7;
-        const int mthd = addr & 0x1ffc;
-        bool handled = false;
-        u32 engine;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        if (likely(chid >= 0 && chid < pfifo->channels))
-                chan = dev_priv->channels.ptr[chid];
-        if (unlikely(!chan))
-                goto out;
-
-        switch (mthd) {
-        case 0x0000: /* bind object to subchannel */
-                obj = nouveau_ramht_find(chan, data);
-                if (unlikely(!obj || obj->engine != NVOBJ_ENGINE_SW))
-                        break;
-
-                engine = 0x0000000f << (subc * 4);
-
-                nv_mask(dev, NV04_PFIFO_CACHE1_ENGINE, engine, 0x00000000);
-                handled = true;
-                break;
-        default:
-                engine = nv_rd32(dev, NV04_PFIFO_CACHE1_ENGINE);
-                if (unlikely(((engine >> (subc * 4)) & 0xf) != 0))
-                        break;
-
-                if (!nouveau_gpuobj_mthd_call(chan, nouveau_software_class(dev),
-                                              mthd, data))
-                        handled = true;
-                break;
-        }
-
-out:
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return handled;
-}
-
-static const char *nv_dma_state_err(u32 state)
-{
-        static const char * const desc[] = {
-                "NONE", "CALL_SUBR_ACTIVE", "INVALID_MTHD", "RET_SUBR_INACTIVE",
-                "INVALID_CMD", "IB_EMPTY"/* NV50+ */, "MEM_FAULT", "UNK"
-        };
-        return desc[(state >> 29) & 0x7];
-}
-
-void
-nv04_fifo_isr(struct drm_device *dev)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t status, reassign;
-        int cnt = 0;
-
-        reassign = nv_rd32(dev, NV03_PFIFO_CACHES) & 1;
-        while ((status = nv_rd32(dev, NV03_PFIFO_INTR_0)) && (cnt++ < 100)) {
-                uint32_t chid, get;
-
-                nv_wr32(dev, NV03_PFIFO_CACHES, 0);
-
-                chid = nv_rd32(dev, NV03_PFIFO_CACHE1_PUSH1) & pfifo->channels;
-                get  = nv_rd32(dev, NV03_PFIFO_CACHE1_GET);
-
-                if (status & NV_PFIFO_INTR_CACHE_ERROR) {
-                        uint32_t mthd, data;
-                        int ptr;
-
-                        /* NV_PFIFO_CACHE1_GET actually goes to 0xffc before
-                         * wrapping on my G80 chips, but CACHE1 isn't big
-                         * enough for this much data.. Tests show that it
-                         * wraps around to the start at GET=0x800.. No clue
-                         * as to why..
-                         */
-                        ptr = (get & 0x7ff) >> 2;
-
-                        if (dev_priv->card_type < NV_40) {
-                                mthd = nv_rd32(dev,
-                                        NV04_PFIFO_CACHE1_METHOD(ptr));
-                                data = nv_rd32(dev,
-                                        NV04_PFIFO_CACHE1_DATA(ptr));
-                        } else {
-                                mthd = nv_rd32(dev,
-                                        NV40_PFIFO_CACHE1_METHOD(ptr));
-                                data = nv_rd32(dev,
-                                        NV40_PFIFO_CACHE1_DATA(ptr));
-                        }
-
-                        if (!nouveau_fifo_swmthd(dev, chid, mthd, data)) {
-                                NV_INFO(dev, "PFIFO_CACHE_ERROR - Ch %d/%d "
-                                             "Mthd 0x%04x Data 0x%08x\n",
-                                        chid, (mthd >> 13) & 7, mthd & 0x1ffc,
-                                        data);
-                        }
-
-                        nv_wr32(dev, NV04_PFIFO_CACHE1_DMA_PUSH, 0);
-                        nv_wr32(dev, NV03_PFIFO_INTR_0,
-                                                NV_PFIFO_INTR_CACHE_ERROR);
-
-                        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0,
-                                nv_rd32(dev, NV03_PFIFO_CACHE1_PUSH0) & ~1);
-                        nv_wr32(dev, NV03_PFIFO_CACHE1_GET, get + 4);
-                        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0,
-                                nv_rd32(dev, NV03_PFIFO_CACHE1_PUSH0) | 1);
-                        nv_wr32(dev, NV04_PFIFO_CACHE1_HASH, 0);
-
-                        nv_wr32(dev, NV04_PFIFO_CACHE1_DMA_PUSH,
-                                nv_rd32(dev, NV04_PFIFO_CACHE1_DMA_PUSH) | 1);
-                        nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 1);
-
-                        status &= ~NV_PFIFO_INTR_CACHE_ERROR;
-                }
-
-                if (status & NV_PFIFO_INTR_DMA_PUSHER) {
-                        u32 dma_get = nv_rd32(dev, 0x003244);
-                        u32 dma_put = nv_rd32(dev, 0x003240);
-                        u32 push = nv_rd32(dev, 0x003220);
-                        u32 state = nv_rd32(dev, 0x003228);
-
-                        if (dev_priv->card_type == NV_50) {
-                                u32 ho_get = nv_rd32(dev, 0x003328);
-                                u32 ho_put = nv_rd32(dev, 0x003320);
-                                u32 ib_get = nv_rd32(dev, 0x003334);
-                                u32 ib_put = nv_rd32(dev, 0x003330);
-
-                                if (nouveau_ratelimit())
-                                        NV_INFO(dev, "PFIFO_DMA_PUSHER - Ch %d Get 0x%02x%08x "
-                                             "Put 0x%02x%08x IbGet 0x%08x IbPut 0x%08x "
-                                             "State 0x%08x (err: %s) Push 0x%08x\n",
-                                                chid, ho_get, dma_get, ho_put,
-                                                dma_put, ib_get, ib_put, state,
-                                                nv_dma_state_err(state),
-                                                push);
-
-                                /* METHOD_COUNT, in DMA_STATE on earlier chipsets */
-                                nv_wr32(dev, 0x003364, 0x00000000);
-                                if (dma_get != dma_put || ho_get != ho_put) {
-                                        nv_wr32(dev, 0x003244, dma_put);
-                                        nv_wr32(dev, 0x003328, ho_put);
-                                } else
-                                if (ib_get != ib_put) {
-                                        nv_wr32(dev, 0x003334, ib_put);
-                                }
-                        } else {
-                                NV_INFO(dev, "PFIFO_DMA_PUSHER - Ch %d Get 0x%08x "
-                                             "Put 0x%08x State 0x%08x (err: %s) Push 0x%08x\n",
-                                        chid, dma_get, dma_put, state,
-                                        nv_dma_state_err(state), push);
-
-                                if (dma_get != dma_put)
-                                        nv_wr32(dev, 0x003244, dma_put);
-                        }
-
-                        nv_wr32(dev, 0x003228, 0x00000000);
-                        nv_wr32(dev, 0x003220, 0x00000001);
-                        nv_wr32(dev, 0x002100, NV_PFIFO_INTR_DMA_PUSHER);
-                        status &= ~NV_PFIFO_INTR_DMA_PUSHER;
-                }
-
-                if (status & NV_PFIFO_INTR_SEMAPHORE) {
-                        uint32_t sem;
-
-                        status &= ~NV_PFIFO_INTR_SEMAPHORE;
-                        nv_wr32(dev, NV03_PFIFO_INTR_0,
-                                NV_PFIFO_INTR_SEMAPHORE);
-
-                        sem = nv_rd32(dev, NV10_PFIFO_CACHE1_SEMAPHORE);
-                        nv_wr32(dev, NV10_PFIFO_CACHE1_SEMAPHORE, sem | 0x1);
-
-                        nv_wr32(dev, NV03_PFIFO_CACHE1_GET, get + 4);
-                        nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 1);
-                }
-
-                if (dev_priv->card_type == NV_50) {
-                        if (status & 0x00000010) {
-                                nv50_fb_vm_trap(dev, nouveau_ratelimit());
-                                status &= ~0x00000010;
-                                nv_wr32(dev, 0x002100, 0x00000010);
-                        }
-                }
-
-                if (status) {
-                        if (nouveau_ratelimit())
-                                NV_INFO(dev, "PFIFO_INTR 0x%08x - Ch %d\n",
-                                        status, chid);
-                        nv_wr32(dev, NV03_PFIFO_INTR_0, status);
-                        status = 0;
-                }
-
-                nv_wr32(dev, NV03_PFIFO_CACHES, reassign);
-        }
-
-        if (status) {
-                NV_INFO(dev, "PFIFO still angry after %d spins, halt\n", cnt);
-                nv_wr32(dev, 0x2140, 0);
-                nv_wr32(dev, 0x140, 0);
-        }
-
-        nv_wr32(dev, NV03_PMC_INTR_0, NV_PMC_INTR_0_PFIFO_PENDING);
-}
-
-void
-nv04_fifo_destroy(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fifo_priv *priv = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 8);
-
-        dev_priv->eng[engine] = NULL;
-        kfree(priv);
-}
-
-int
-nv04_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_fifo_priv *priv;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nv04_fifo_destroy;
-        priv->base.base.init = nv04_fifo_init;
-        priv->base.base.fini = nv04_fifo_fini;
-        priv->base.base.context_new = nv04_fifo_context_new;
-        priv->base.base.context_del = nv04_fifo_context_del;
-        priv->base.channels = 15;
-        priv->ramfc_desc = nv04_ramfc;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        nouveau_irq_register(dev, 8, nv04_fifo_isr);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_graph.c b/drivers/gpu/drm/nouveau/nv04_graph.c
deleted file mode 100644
index 72f1a62903b3..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_graph.c
+++ /dev/null
@@ -1,1326 +0,0 @@
-/*
- * Copyright 2007 Stephane Marchesin
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_hw.h"
-#include "nouveau_util.h"
-#include "nouveau_ramht.h"
-
-struct nv04_graph_engine {
-        struct nouveau_exec_engine base;
-};
-
-static uint32_t nv04_graph_ctx_regs[] = {
-        0x0040053c,
-        0x00400544,
-        0x00400540,
-        0x00400548,
-        NV04_PGRAPH_CTX_SWITCH1,
-        NV04_PGRAPH_CTX_SWITCH2,
-        NV04_PGRAPH_CTX_SWITCH3,
-        NV04_PGRAPH_CTX_SWITCH4,
-        NV04_PGRAPH_CTX_CACHE1,
-        NV04_PGRAPH_CTX_CACHE2,
-        NV04_PGRAPH_CTX_CACHE3,
-        NV04_PGRAPH_CTX_CACHE4,
-        0x00400184,
-        0x004001a4,
-        0x004001c4,
-        0x004001e4,
-        0x00400188,
-        0x004001a8,
-        0x004001c8,
-        0x004001e8,
-        0x0040018c,
-        0x004001ac,
-        0x004001cc,
-        0x004001ec,
-        0x00400190,
-        0x004001b0,
-        0x004001d0,
-        0x004001f0,
-        0x00400194,
-        0x004001b4,
-        0x004001d4,
-        0x004001f4,
-        0x00400198,
-        0x004001b8,
-        0x004001d8,
-        0x004001f8,
-        0x0040019c,
-        0x004001bc,
-        0x004001dc,
-        0x004001fc,
-        0x00400174,
-        NV04_PGRAPH_DMA_START_0,
-        NV04_PGRAPH_DMA_START_1,
-        NV04_PGRAPH_DMA_LENGTH,
-        NV04_PGRAPH_DMA_MISC,
-        NV04_PGRAPH_DMA_PITCH,
-        NV04_PGRAPH_BOFFSET0,
-        NV04_PGRAPH_BBASE0,
-        NV04_PGRAPH_BLIMIT0,
-        NV04_PGRAPH_BOFFSET1,
-        NV04_PGRAPH_BBASE1,
-        NV04_PGRAPH_BLIMIT1,
-        NV04_PGRAPH_BOFFSET2,
-        NV04_PGRAPH_BBASE2,
-        NV04_PGRAPH_BLIMIT2,
-        NV04_PGRAPH_BOFFSET3,
-        NV04_PGRAPH_BBASE3,
-        NV04_PGRAPH_BLIMIT3,
-        NV04_PGRAPH_BOFFSET4,
-        NV04_PGRAPH_BBASE4,
-        NV04_PGRAPH_BLIMIT4,
-        NV04_PGRAPH_BOFFSET5,
-        NV04_PGRAPH_BBASE5,
-        NV04_PGRAPH_BLIMIT5,
-        NV04_PGRAPH_BPITCH0,
-        NV04_PGRAPH_BPITCH1,
-        NV04_PGRAPH_BPITCH2,
-        NV04_PGRAPH_BPITCH3,
-        NV04_PGRAPH_BPITCH4,
-        NV04_PGRAPH_SURFACE,
-        NV04_PGRAPH_STATE,
-        NV04_PGRAPH_BSWIZZLE2,
-        NV04_PGRAPH_BSWIZZLE5,
-        NV04_PGRAPH_BPIXEL,
-        NV04_PGRAPH_NOTIFY,
-        NV04_PGRAPH_PATT_COLOR0,
-        NV04_PGRAPH_PATT_COLOR1,
-        NV04_PGRAPH_PATT_COLORRAM+0x00,
-        NV04_PGRAPH_PATT_COLORRAM+0x04,
-        NV04_PGRAPH_PATT_COLORRAM+0x08,
-        NV04_PGRAPH_PATT_COLORRAM+0x0c,
-        NV04_PGRAPH_PATT_COLORRAM+0x10,
-        NV04_PGRAPH_PATT_COLORRAM+0x14,
-        NV04_PGRAPH_PATT_COLORRAM+0x18,
-        NV04_PGRAPH_PATT_COLORRAM+0x1c,
-        NV04_PGRAPH_PATT_COLORRAM+0x20,
-        NV04_PGRAPH_PATT_COLORRAM+0x24,
-        NV04_PGRAPH_PATT_COLORRAM+0x28,
-        NV04_PGRAPH_PATT_COLORRAM+0x2c,
-        NV04_PGRAPH_PATT_COLORRAM+0x30,
-        NV04_PGRAPH_PATT_COLORRAM+0x34,
-        NV04_PGRAPH_PATT_COLORRAM+0x38,
-        NV04_PGRAPH_PATT_COLORRAM+0x3c,
-        NV04_PGRAPH_PATT_COLORRAM+0x40,
-        NV04_PGRAPH_PATT_COLORRAM+0x44,
-        NV04_PGRAPH_PATT_COLORRAM+0x48,
-        NV04_PGRAPH_PATT_COLORRAM+0x4c,
-        NV04_PGRAPH_PATT_COLORRAM+0x50,
-        NV04_PGRAPH_PATT_COLORRAM+0x54,
-        NV04_PGRAPH_PATT_COLORRAM+0x58,
-        NV04_PGRAPH_PATT_COLORRAM+0x5c,
-        NV04_PGRAPH_PATT_COLORRAM+0x60,
-        NV04_PGRAPH_PATT_COLORRAM+0x64,
-        NV04_PGRAPH_PATT_COLORRAM+0x68,
-        NV04_PGRAPH_PATT_COLORRAM+0x6c,
-        NV04_PGRAPH_PATT_COLORRAM+0x70,
-        NV04_PGRAPH_PATT_COLORRAM+0x74,
-        NV04_PGRAPH_PATT_COLORRAM+0x78,
-        NV04_PGRAPH_PATT_COLORRAM+0x7c,
-        NV04_PGRAPH_PATT_COLORRAM+0x80,
-        NV04_PGRAPH_PATT_COLORRAM+0x84,
-        NV04_PGRAPH_PATT_COLORRAM+0x88,
-        NV04_PGRAPH_PATT_COLORRAM+0x8c,
-        NV04_PGRAPH_PATT_COLORRAM+0x90,
-        NV04_PGRAPH_PATT_COLORRAM+0x94,
-        NV04_PGRAPH_PATT_COLORRAM+0x98,
-        NV04_PGRAPH_PATT_COLORRAM+0x9c,
-        NV04_PGRAPH_PATT_COLORRAM+0xa0,
-        NV04_PGRAPH_PATT_COLORRAM+0xa4,
-        NV04_PGRAPH_PATT_COLORRAM+0xa8,
-        NV04_PGRAPH_PATT_COLORRAM+0xac,
-        NV04_PGRAPH_PATT_COLORRAM+0xb0,
-        NV04_PGRAPH_PATT_COLORRAM+0xb4,
-        NV04_PGRAPH_PATT_COLORRAM+0xb8,
-        NV04_PGRAPH_PATT_COLORRAM+0xbc,
-        NV04_PGRAPH_PATT_COLORRAM+0xc0,
-        NV04_PGRAPH_PATT_COLORRAM+0xc4,
-        NV04_PGRAPH_PATT_COLORRAM+0xc8,
-        NV04_PGRAPH_PATT_COLORRAM+0xcc,
-        NV04_PGRAPH_PATT_COLORRAM+0xd0,
-        NV04_PGRAPH_PATT_COLORRAM+0xd4,
-        NV04_PGRAPH_PATT_COLORRAM+0xd8,
-        NV04_PGRAPH_PATT_COLORRAM+0xdc,
-        NV04_PGRAPH_PATT_COLORRAM+0xe0,
-        NV04_PGRAPH_PATT_COLORRAM+0xe4,
-        NV04_PGRAPH_PATT_COLORRAM+0xe8,
-        NV04_PGRAPH_PATT_COLORRAM+0xec,
-        NV04_PGRAPH_PATT_COLORRAM+0xf0,
-        NV04_PGRAPH_PATT_COLORRAM+0xf4,
-        NV04_PGRAPH_PATT_COLORRAM+0xf8,
-        NV04_PGRAPH_PATT_COLORRAM+0xfc,
-        NV04_PGRAPH_PATTERN,
-        0x0040080c,
-        NV04_PGRAPH_PATTERN_SHAPE,
-        0x00400600,
-        NV04_PGRAPH_ROP3,
-        NV04_PGRAPH_CHROMA,
-        NV04_PGRAPH_BETA_AND,
-        NV04_PGRAPH_BETA_PREMULT,
-        NV04_PGRAPH_CONTROL0,
-        NV04_PGRAPH_CONTROL1,
-        NV04_PGRAPH_CONTROL2,
-        NV04_PGRAPH_BLEND,
-        NV04_PGRAPH_STORED_FMT,
-        NV04_PGRAPH_SOURCE_COLOR,
-        0x00400560,
-        0x00400568,
-        0x00400564,
-        0x0040056c,
-        0x00400400,
-        0x00400480,
-        0x00400404,
-        0x00400484,
-        0x00400408,
-        0x00400488,
-        0x0040040c,
-        0x0040048c,
-        0x00400410,
-        0x00400490,
-        0x00400414,
-        0x00400494,
-        0x00400418,
-        0x00400498,
-        0x0040041c,
-        0x0040049c,
-        0x00400420,
-        0x004004a0,
-        0x00400424,
-        0x004004a4,
-        0x00400428,
-        0x004004a8,
-        0x0040042c,
-        0x004004ac,
-        0x00400430,
-        0x004004b0,
-        0x00400434,
-        0x004004b4,
-        0x00400438,
-        0x004004b8,
-        0x0040043c,
-        0x004004bc,
-        0x00400440,
-        0x004004c0,
-        0x00400444,
-        0x004004c4,
-        0x00400448,
-        0x004004c8,
-        0x0040044c,
-        0x004004cc,
-        0x00400450,
-        0x004004d0,
-        0x00400454,
-        0x004004d4,
-        0x00400458,
-        0x004004d8,
-        0x0040045c,
-        0x004004dc,
-        0x00400460,
-        0x004004e0,
-        0x00400464,
-        0x004004e4,
-        0x00400468,
-        0x004004e8,
-        0x0040046c,
-        0x004004ec,
-        0x00400470,
-        0x004004f0,
-        0x00400474,
-        0x004004f4,
-        0x00400478,
-        0x004004f8,
-        0x0040047c,
-        0x004004fc,
-        0x00400534,
-        0x00400538,
-        0x00400514,
-        0x00400518,
-        0x0040051c,
-        0x00400520,
-        0x00400524,
-        0x00400528,
-        0x0040052c,
-        0x00400530,
-        0x00400d00,
-        0x00400d40,
-        0x00400d80,
-        0x00400d04,
-        0x00400d44,
-        0x00400d84,
-        0x00400d08,
-        0x00400d48,
-        0x00400d88,
-        0x00400d0c,
-        0x00400d4c,
-        0x00400d8c,
-        0x00400d10,
-        0x00400d50,
-        0x00400d90,
-        0x00400d14,
-        0x00400d54,
-        0x00400d94,
-        0x00400d18,
-        0x00400d58,
-        0x00400d98,
-        0x00400d1c,
-        0x00400d5c,
-        0x00400d9c,
-        0x00400d20,
-        0x00400d60,
-        0x00400da0,
-        0x00400d24,
-        0x00400d64,
-        0x00400da4,
-        0x00400d28,
-        0x00400d68,
-        0x00400da8,
-        0x00400d2c,
-        0x00400d6c,
-        0x00400dac,
-        0x00400d30,
-        0x00400d70,
-        0x00400db0,
-        0x00400d34,
-        0x00400d74,
-        0x00400db4,
-        0x00400d38,
-        0x00400d78,
-        0x00400db8,
-        0x00400d3c,
-        0x00400d7c,
-        0x00400dbc,
-        0x00400590,
-        0x00400594,
-        0x00400598,
-        0x0040059c,
-        0x004005a8,
-        0x004005ac,
-        0x004005b0,
-        0x004005b4,
-        0x004005c0,
-        0x004005c4,
-        0x004005c8,
-        0x004005cc,
-        0x004005d0,
-        0x004005d4,
-        0x004005d8,
-        0x004005dc,
-        0x004005e0,
-        NV04_PGRAPH_PASSTHRU_0,
-        NV04_PGRAPH_PASSTHRU_1,
-        NV04_PGRAPH_PASSTHRU_2,
-        NV04_PGRAPH_DVD_COLORFMT,
-        NV04_PGRAPH_SCALED_FORMAT,
-        NV04_PGRAPH_MISC24_0,
-        NV04_PGRAPH_MISC24_1,
-        NV04_PGRAPH_MISC24_2,
-        0x00400500,
-        0x00400504,
-        NV04_PGRAPH_VALID1,
-        NV04_PGRAPH_VALID2,
-        NV04_PGRAPH_DEBUG_3
-};
-
-struct graph_state {
-        uint32_t nv04[ARRAY_SIZE(nv04_graph_ctx_regs)];
-};
-
-static struct nouveau_channel *
-nv04_graph_channel(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chid = 15;
-
-        if (nv_rd32(dev, NV04_PGRAPH_CTX_CONTROL) & 0x00010000)
-                chid = nv_rd32(dev, NV04_PGRAPH_CTX_USER) >> 24;
-
-        if (chid > 15)
-                return NULL;
-
-        return dev_priv->channels.ptr[chid];
-}
-
-static uint32_t *ctx_reg(struct graph_state *ctx, uint32_t reg)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(nv04_graph_ctx_regs); i++) {
-                if (nv04_graph_ctx_regs[i] == reg)
-                        return &ctx->nv04[i];
-        }
-
-        return NULL;
-}
-
-static int
-nv04_graph_load_context(struct nouveau_channel *chan)
-{
-        struct graph_state *pgraph_ctx = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        uint32_t tmp;
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(nv04_graph_ctx_regs); i++)
-                nv_wr32(dev, nv04_graph_ctx_regs[i], pgraph_ctx->nv04[i]);
-
-        nv_wr32(dev, NV04_PGRAPH_CTX_CONTROL, 0x10010100);
-
-        tmp  = nv_rd32(dev, NV04_PGRAPH_CTX_USER) & 0x00ffffff;
-        nv_wr32(dev, NV04_PGRAPH_CTX_USER, tmp | chan->id << 24);
-
-        tmp = nv_rd32(dev, NV04_PGRAPH_FFINTFC_ST2);
-        nv_wr32(dev, NV04_PGRAPH_FFINTFC_ST2, tmp & 0x000fffff);
-
-        return 0;
-}
-
-static int
-nv04_graph_unload_context(struct drm_device *dev)
-{
-        struct nouveau_channel *chan = NULL;
-        struct graph_state *ctx;
-        uint32_t tmp;
-        int i;
-
-        chan = nv04_graph_channel(dev);
-        if (!chan)
-                return 0;
-        ctx = chan->engctx[NVOBJ_ENGINE_GR];
-
-        for (i = 0; i < ARRAY_SIZE(nv04_graph_ctx_regs); i++)
-                ctx->nv04[i] = nv_rd32(dev, nv04_graph_ctx_regs[i]);
-
-        nv_wr32(dev, NV04_PGRAPH_CTX_CONTROL, 0x10000000);
-        tmp  = nv_rd32(dev, NV04_PGRAPH_CTX_USER) & 0x00ffffff;
-        tmp |= 15 << 24;
-        nv_wr32(dev, NV04_PGRAPH_CTX_USER, tmp);
-        return 0;
-}
-
-static int
-nv04_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct graph_state *pgraph_ctx;
-        NV_DEBUG(chan->dev, "nv04_graph_context_create %d\n", chan->id);
-
-        pgraph_ctx = kzalloc(sizeof(*pgraph_ctx), GFP_KERNEL);
-        if (pgraph_ctx == NULL)
-                return -ENOMEM;
-
-        *ctx_reg(pgraph_ctx, NV04_PGRAPH_DEBUG_3) = 0xfad4ff31;
-
-        chan->engctx[engine] = pgraph_ctx;
-        return 0;
-}
-
-static void
-nv04_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct graph_state *pgraph_ctx = chan->engctx[engine];
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-
-        /* Unload the context if it's the currently active one */
-        if (nv04_graph_channel(dev) == chan)
-                nv04_graph_unload_context(dev);
-
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* Free the context resources */
-        kfree(pgraph_ctx);
-        chan->engctx[engine] = NULL;
-}
-
-int
-nv04_graph_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 1;
-        obj->class  = class;
-
-#ifdef __BIG_ENDIAN
-        nv_wo32(obj, 0x00, 0x00080000 | class);
-#else
-        nv_wo32(obj, 0x00, class);
-#endif
-        nv_wo32(obj, 0x04, 0x00000000);
-        nv_wo32(obj, 0x08, 0x00000000);
-        nv_wo32(obj, 0x0c, 0x00000000);
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static int
-nv04_graph_init(struct drm_device *dev, int engine)
-{
-        uint32_t tmp;
-
-        nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) &
-                        ~NV_PMC_ENABLE_PGRAPH);
-        nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) |
-                         NV_PMC_ENABLE_PGRAPH);
-
-        /* Enable PGRAPH interrupts */
-        nv_wr32(dev, NV03_PGRAPH_INTR, 0xFFFFFFFF);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
-
-        nv_wr32(dev, NV04_PGRAPH_VALID1, 0);
-        nv_wr32(dev, NV04_PGRAPH_VALID2, 0);
-        /*nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x000001FF);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x001FFFFF);*/
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x1231c000);
-        /*1231C000 blob, 001 haiku*/
-        /*V_WRITE(NV04_PGRAPH_DEBUG_1, 0xf2d91100);*/
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_1, 0x72111100);
-        /*0x72111100 blob , 01 haiku*/
-        /*nv_wr32(dev, NV04_PGRAPH_DEBUG_2, 0x11d5f870);*/
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_2, 0x11d5f071);
-        /*haiku same*/
-
-        /*nv_wr32(dev, NV04_PGRAPH_DEBUG_3, 0xfad4ff31);*/
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_3, 0xf0d4ff31);
-        /*haiku and blob 10d4*/
-
-        nv_wr32(dev, NV04_PGRAPH_STATE        , 0xFFFFFFFF);
-        nv_wr32(dev, NV04_PGRAPH_CTX_CONTROL  , 0x10000100);
-        tmp  = nv_rd32(dev, NV04_PGRAPH_CTX_USER) & 0x00ffffff;
-        tmp |= 15 << 24;
-        nv_wr32(dev, NV04_PGRAPH_CTX_USER, tmp);
-
-        /* These don't belong here, they're part of a per-channel context */
-        nv_wr32(dev, NV04_PGRAPH_PATTERN_SHAPE, 0x00000000);
-        nv_wr32(dev, NV04_PGRAPH_BETA_AND     , 0xFFFFFFFF);
-
-        return 0;
-}
-
-static int
-nv04_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-        if (!nv_wait(dev, NV04_PGRAPH_STATUS, ~0, 0) && suspend) {
-                nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-                return -EBUSY;
-        }
-        nv04_graph_unload_context(dev);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0x00000000);
-        return 0;
-}
-
-/*
- * Software methods, why they are needed, and how they all work:
- *
- * NV04 and NV05 keep most of the state in PGRAPH context itself, but some
- * 2d engine settings are kept inside the grobjs themselves. The grobjs are
- * 3 words long on both. grobj format on NV04 is:
- *
- * word 0:
- *  - bits 0-7: class
- *  - bit 12: color key active
- *  - bit 13: clip rect active
- *  - bit 14: if set, destination surface is swizzled and taken from buffer 5
- *            [set by NV04_SWIZZLED_SURFACE], otherwise it's linear and taken
- *            from buffer 0 [set by NV04_CONTEXT_SURFACES_2D or
- *            NV03_CONTEXT_SURFACE_DST].
- *  - bits 15-17: 2d operation [aka patch config]
- *  - bit 24: patch valid [enables rendering using this object]
- *  - bit 25: surf3d valid [for tex_tri and multitex_tri only]
- * word 1:
- *  - bits 0-1: mono format
- *  - bits 8-13: color format
- *  - bits 16-31: DMA_NOTIFY instance
- * word 2:
- *  - bits 0-15: DMA_A instance
- *  - bits 16-31: DMA_B instance
- *
- * On NV05 it's:
- *
- * word 0:
- *  - bits 0-7: class
- *  - bit 12: color key active
- *  - bit 13: clip rect active
- *  - bit 14: if set, destination surface is swizzled and taken from buffer 5
- *            [set by NV04_SWIZZLED_SURFACE], otherwise it's linear and taken
- *            from buffer 0 [set by NV04_CONTEXT_SURFACES_2D or
- *            NV03_CONTEXT_SURFACE_DST].
- *  - bits 15-17: 2d operation [aka patch config]
- *  - bits 20-22: dither mode
- *  - bit 24: patch valid [enables rendering using this object]
- *  - bit 25: surface_dst/surface_color/surf2d/surf3d valid
- *  - bit 26: surface_src/surface_zeta valid
- *  - bit 27: pattern valid
- *  - bit 28: rop valid
- *  - bit 29: beta1 valid
- *  - bit 30: beta4 valid
- * word 1:
- *  - bits 0-1: mono format
- *  - bits 8-13: color format
- *  - bits 16-31: DMA_NOTIFY instance
- * word 2:
- *  - bits 0-15: DMA_A instance
- *  - bits 16-31: DMA_B instance
- *
- * NV05 will set/unset the relevant valid bits when you poke the relevant
- * object-binding methods with object of the proper type, or with the NULL
- * type. It'll only allow rendering using the grobj if all needed objects
- * are bound. The needed set of objects depends on selected operation: for
- * example rop object is needed by ROP_AND, but not by SRCCOPY_AND.
- *
- * NV04 doesn't have these methods implemented at all, and doesn't have the
- * relevant bits in grobj. Instead, it'll allow rendering whenever bit 24
- * is set. So we have to emulate them in software, internally keeping the
- * same bits as NV05 does. Since grobjs are aligned to 16 bytes on nv04,
- * but the last word isn't actually used for anything, we abuse it for this
- * purpose.
- *
- * Actually, NV05 can optionally check bit 24 too, but we disable this since
- * there's no use for it.
- *
- * For unknown reasons, NV04 implements surf3d binding in hardware as an
- * exception. Also for unknown reasons, NV04 doesn't implement the clipping
- * methods on the surf3d object, so we have to emulate them too.
- */
-
-static void
-nv04_graph_set_ctx1(struct nouveau_channel *chan, u32 mask, u32 value)
-{
-        struct drm_device *dev = chan->dev;
-        u32 instance = (nv_rd32(dev, NV04_PGRAPH_CTX_SWITCH4) & 0xffff) << 4;
-        int subc = (nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR) >> 13) & 0x7;
-        u32 tmp;
-
-        tmp  = nv_ri32(dev, instance);
-        tmp &= ~mask;
-        tmp |= value;
-
-        nv_wi32(dev, instance, tmp);
-        nv_wr32(dev, NV04_PGRAPH_CTX_SWITCH1, tmp);
-        nv_wr32(dev, NV04_PGRAPH_CTX_CACHE1 + (subc<<2), tmp);
-}
-
-static void
-nv04_graph_set_ctx_val(struct nouveau_channel *chan, u32 mask, u32 value)
-{
-        struct drm_device *dev = chan->dev;
-        u32 instance = (nv_rd32(dev, NV04_PGRAPH_CTX_SWITCH4) & 0xffff) << 4;
-        u32 tmp, ctx1;
-        int class, op, valid = 1;
-
-        ctx1 = nv_ri32(dev, instance);
-        class = ctx1 & 0xff;
-        op = (ctx1 >> 15) & 7;
-        tmp  = nv_ri32(dev, instance + 0xc);
-        tmp &= ~mask;
-        tmp |= value;
-        nv_wi32(dev, instance + 0xc, tmp);
-
-        /* check for valid surf2d/surf_dst/surf_color */
-        if (!(tmp & 0x02000000))
-                valid = 0;
-        /* check for valid surf_src/surf_zeta */
-        if ((class == 0x1f || class == 0x48) && !(tmp & 0x04000000))
-                valid = 0;
-
-        switch (op) {
-        /* SRCCOPY_AND, SRCCOPY: no extra objects required */
-        case 0:
-        case 3:
-                break;
-        /* ROP_AND: requires pattern and rop */
-        case 1:
-                if (!(tmp & 0x18000000))
-                        valid = 0;
-                break;
-        /* BLEND_AND: requires beta1 */
-        case 2:
-                if (!(tmp & 0x20000000))
-                        valid = 0;
-                break;
-        /* SRCCOPY_PREMULT, BLEND_PREMULT: beta4 required */
-        case 4:
-        case 5:
-                if (!(tmp & 0x40000000))
-                        valid = 0;
-                break;
-        }
-
-        nv04_graph_set_ctx1(chan, 0x01000000, valid << 24);
-}
-
-static int
-nv04_graph_mthd_set_operation(struct nouveau_channel *chan,
-                              u32 class, u32 mthd, u32 data)
-{
-        if (data > 5)
-                return 1;
-        /* Old versions of the objects only accept first three operations. */
-        if (data > 2 && class < 0x40)
-                return 1;
-        nv04_graph_set_ctx1(chan, 0x00038000, data << 15);
-        /* changing operation changes set of objects needed for validation */
-        nv04_graph_set_ctx_val(chan, 0, 0);
-        return 0;
-}
-
-static int
-nv04_graph_mthd_surf3d_clip_h(struct nouveau_channel *chan,
-                              u32 class, u32 mthd, u32 data)
-{
-        uint32_t min = data & 0xffff, max;
-        uint32_t w = data >> 16;
-        if (min & 0x8000)
-                /* too large */
-                return 1;
-        if (w & 0x8000)
-                /* yes, it accepts negative for some reason. */
-                w |= 0xffff0000;
-        max = min + w;
-        max &= 0x3ffff;
-        nv_wr32(chan->dev, 0x40053c, min);
-        nv_wr32(chan->dev, 0x400544, max);
-        return 0;
-}
-
-static int
-nv04_graph_mthd_surf3d_clip_v(struct nouveau_channel *chan,
-                              u32 class, u32 mthd, u32 data)
-{
-        uint32_t min = data & 0xffff, max;
-        uint32_t w = data >> 16;
-        if (min & 0x8000)
-                /* too large */
-                return 1;
-        if (w & 0x8000)
-                /* yes, it accepts negative for some reason. */
-                w |= 0xffff0000;
-        max = min + w;
-        max &= 0x3ffff;
-        nv_wr32(chan->dev, 0x400540, min);
-        nv_wr32(chan->dev, 0x400548, max);
-        return 0;
-}
-
-static int
-nv04_graph_mthd_bind_surf2d(struct nouveau_channel *chan,
-                            u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx1(chan, 0x00004000, 0);
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0);
-                return 0;
-        case 0x42:
-                nv04_graph_set_ctx1(chan, 0x00004000, 0);
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0x02000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_surf2d_swzsurf(struct nouveau_channel *chan,
-                                    u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx1(chan, 0x00004000, 0);
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0);
-                return 0;
-        case 0x42:
-                nv04_graph_set_ctx1(chan, 0x00004000, 0);
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0x02000000);
-                return 0;
-        case 0x52:
-                nv04_graph_set_ctx1(chan, 0x00004000, 0x00004000);
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0x02000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_nv01_patt(struct nouveau_channel *chan,
-                               u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x08000000, 0);
-                return 0;
-        case 0x18:
-                nv04_graph_set_ctx_val(chan, 0x08000000, 0x08000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_nv04_patt(struct nouveau_channel *chan,
-                               u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x08000000, 0);
-                return 0;
-        case 0x44:
-                nv04_graph_set_ctx_val(chan, 0x08000000, 0x08000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_rop(struct nouveau_channel *chan,
-                         u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x10000000, 0);
-                return 0;
-        case 0x43:
-                nv04_graph_set_ctx_val(chan, 0x10000000, 0x10000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_beta1(struct nouveau_channel *chan,
-                           u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x20000000, 0);
-                return 0;
-        case 0x12:
-                nv04_graph_set_ctx_val(chan, 0x20000000, 0x20000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_beta4(struct nouveau_channel *chan,
-                           u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x40000000, 0);
-                return 0;
-        case 0x72:
-                nv04_graph_set_ctx_val(chan, 0x40000000, 0x40000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_surf_dst(struct nouveau_channel *chan,
-                              u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0);
-                return 0;
-        case 0x58:
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0x02000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_surf_src(struct nouveau_channel *chan,
-                              u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x04000000, 0);
-                return 0;
-        case 0x59:
-                nv04_graph_set_ctx_val(chan, 0x04000000, 0x04000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_surf_color(struct nouveau_channel *chan,
-                                u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0);
-                return 0;
-        case 0x5a:
-                nv04_graph_set_ctx_val(chan, 0x02000000, 0x02000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_surf_zeta(struct nouveau_channel *chan,
-                               u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx_val(chan, 0x04000000, 0);
-                return 0;
-        case 0x5b:
-                nv04_graph_set_ctx_val(chan, 0x04000000, 0x04000000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_clip(struct nouveau_channel *chan,
-                          u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx1(chan, 0x2000, 0);
-                return 0;
-        case 0x19:
-                nv04_graph_set_ctx1(chan, 0x2000, 0x2000);
-                return 0;
-        }
-        return 1;
-}
-
-static int
-nv04_graph_mthd_bind_chroma(struct nouveau_channel *chan,
-                            u32 class, u32 mthd, u32 data)
-{
-        switch (nv_ri32(chan->dev, data << 4) & 0xff) {
-        case 0x30:
-                nv04_graph_set_ctx1(chan, 0x1000, 0);
-                return 0;
-        /* Yes, for some reason even the old versions of objects
-         * accept 0x57 and not 0x17. Consistency be damned.
-         */
-        case 0x57:
-                nv04_graph_set_ctx1(chan, 0x1000, 0x1000);
-                return 0;
-        }
-        return 1;
-}
-
-static struct nouveau_bitfield nv04_graph_intr[] = {
-        { NV_PGRAPH_INTR_NOTIFY, "NOTIFY" },
-        {}
-};
-
-static struct nouveau_bitfield nv04_graph_nstatus[] = {
-        { NV04_PGRAPH_NSTATUS_STATE_IN_USE,       "STATE_IN_USE" },
-        { NV04_PGRAPH_NSTATUS_INVALID_STATE,      "INVALID_STATE" },
-        { NV04_PGRAPH_NSTATUS_BAD_ARGUMENT,       "BAD_ARGUMENT" },
-        { NV04_PGRAPH_NSTATUS_PROTECTION_FAULT,   "PROTECTION_FAULT" },
-        {}
-};
-
-struct nouveau_bitfield nv04_graph_nsource[] = {
-        { NV03_PGRAPH_NSOURCE_NOTIFICATION,       "NOTIFICATION" },
-        { NV03_PGRAPH_NSOURCE_DATA_ERROR,         "DATA_ERROR" },
-        { NV03_PGRAPH_NSOURCE_PROTECTION_ERROR,   "PROTECTION_ERROR" },
-        { NV03_PGRAPH_NSOURCE_RANGE_EXCEPTION,    "RANGE_EXCEPTION" },
-        { NV03_PGRAPH_NSOURCE_LIMIT_COLOR,        "LIMIT_COLOR" },
-        { NV03_PGRAPH_NSOURCE_LIMIT_ZETA,         "LIMIT_ZETA" },
-        { NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD,       "ILLEGAL_MTHD" },
-        { NV03_PGRAPH_NSOURCE_DMA_R_PROTECTION,   "DMA_R_PROTECTION" },
-        { NV03_PGRAPH_NSOURCE_DMA_W_PROTECTION,   "DMA_W_PROTECTION" },
-        { NV03_PGRAPH_NSOURCE_FORMAT_EXCEPTION,   "FORMAT_EXCEPTION" },
-        { NV03_PGRAPH_NSOURCE_PATCH_EXCEPTION,    "PATCH_EXCEPTION" },
-        { NV03_PGRAPH_NSOURCE_STATE_INVALID,      "STATE_INVALID" },
-        { NV03_PGRAPH_NSOURCE_DOUBLE_NOTIFY,      "DOUBLE_NOTIFY" },
-        { NV03_PGRAPH_NSOURCE_NOTIFY_IN_USE,      "NOTIFY_IN_USE" },
-        { NV03_PGRAPH_NSOURCE_METHOD_CNT,         "METHOD_CNT" },
-        { NV03_PGRAPH_NSOURCE_BFR_NOTIFICATION,   "BFR_NOTIFICATION" },
-        { NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION, "DMA_VTX_PROTECTION" },
-        { NV03_PGRAPH_NSOURCE_DMA_WIDTH_A,        "DMA_WIDTH_A" },
-        { NV03_PGRAPH_NSOURCE_DMA_WIDTH_B,        "DMA_WIDTH_B" },
-        {}
-};
-
-static void
-nv04_graph_context_switch(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = NULL;
-        int chid;
-
-        nouveau_wait_for_idle(dev);
-
-        /* If previous context is valid, we need to save it */
-        nv04_graph_unload_context(dev);
-
-        /* Load context for next channel */
-        chid = nv_rd32(dev, NV03_PFIFO_CACHE1_PUSH1) &
-                            NV03_PFIFO_CACHE1_PUSH1_CHID_MASK;
-        chan = dev_priv->channels.ptr[chid];
-        if (chan)
-                nv04_graph_load_context(chan);
-}
-
-static void
-nv04_graph_isr(struct drm_device *dev)
-{
-        u32 stat;
-
-        while ((stat = nv_rd32(dev, NV03_PGRAPH_INTR))) {
-                u32 nsource = nv_rd32(dev, NV03_PGRAPH_NSOURCE);
-                u32 nstatus = nv_rd32(dev, NV03_PGRAPH_NSTATUS);
-                u32 addr = nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR);
-                u32 chid = (addr & 0x0f000000) >> 24;
-                u32 subc = (addr & 0x0000e000) >> 13;
-                u32 mthd = (addr & 0x00001ffc);
-                u32 data = nv_rd32(dev, NV04_PGRAPH_TRAPPED_DATA);
-                u32 class = nv_rd32(dev, 0x400180 + subc * 4) & 0xff;
-                u32 show = stat;
-
-                if (stat & NV_PGRAPH_INTR_NOTIFY) {
-                        if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
-                                if (!nouveau_gpuobj_mthd_call2(dev, chid, class, mthd, data))
-                                        show &= ~NV_PGRAPH_INTR_NOTIFY;
-                        }
-                }
-
-                if (stat & NV_PGRAPH_INTR_CONTEXT_SWITCH) {
-                        nv_wr32(dev, NV03_PGRAPH_INTR, NV_PGRAPH_INTR_CONTEXT_SWITCH);
-                        stat &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
-                        show &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
-                        nv04_graph_context_switch(dev);
-                }
-
-                nv_wr32(dev, NV03_PGRAPH_INTR, stat);
-                nv_wr32(dev, NV04_PGRAPH_FIFO, 0x00000001);
-
-                if (show && nouveau_ratelimit()) {
-                        NV_INFO(dev, "PGRAPH -");
-                        nouveau_bitfield_print(nv04_graph_intr, show);
-                        printk(" nsource:");
-                        nouveau_bitfield_print(nv04_graph_nsource, nsource);
-                        printk(" nstatus:");
-                        nouveau_bitfield_print(nv04_graph_nstatus, nstatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - ch %d/%d class 0x%04x "
-                                     "mthd 0x%04x data 0x%08x\n",
-                                chid, subc, class, mthd, data);
-                }
-        }
-}
-
-static void
-nv04_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nv04_graph_engine *pgraph = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 12);
-
-        NVOBJ_ENGINE_DEL(dev, GR);
-        kfree(pgraph);
-}
-
-int
-nv04_graph_create(struct drm_device *dev)
-{
-        struct nv04_graph_engine *pgraph;
-
-        pgraph = kzalloc(sizeof(*pgraph), GFP_KERNEL);
-        if (!pgraph)
-                return -ENOMEM;
-
-        pgraph->base.destroy = nv04_graph_destroy;
-        pgraph->base.init = nv04_graph_init;
-        pgraph->base.fini = nv04_graph_fini;
-        pgraph->base.context_new = nv04_graph_context_new;
-        pgraph->base.context_del = nv04_graph_context_del;
-        pgraph->base.object_new = nv04_graph_object_new;
-
-        NVOBJ_ENGINE_ADD(dev, GR, &pgraph->base);
-        nouveau_irq_register(dev, 12, nv04_graph_isr);
-
-        /* dvd subpicture */
-        NVOBJ_CLASS(dev, 0x0038, GR);
-
-        /* m2mf */
-        NVOBJ_CLASS(dev, 0x0039, GR);
-
-        /* nv03 gdirect */
-        NVOBJ_CLASS(dev, 0x004b, GR);
-        NVOBJ_MTHD (dev, 0x004b, 0x0184, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x004b, 0x0188, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x004b, 0x018c, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x004b, 0x0190, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x004b, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 gdirect */
-        NVOBJ_CLASS(dev, 0x004a, GR);
-        NVOBJ_MTHD (dev, 0x004a, 0x0188, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x004a, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x004a, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x004a, 0x0194, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x004a, 0x0198, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x004a, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv01 imageblit */
-        NVOBJ_CLASS(dev, 0x001f, GR);
-        NVOBJ_MTHD (dev, 0x001f, 0x0184, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x001f, 0x0188, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x001f, 0x018c, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x001f, 0x0190, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x001f, 0x0194, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x001f, 0x0198, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x001f, 0x019c, nv04_graph_mthd_bind_surf_src);
-        NVOBJ_MTHD (dev, 0x001f, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 imageblit */
-        NVOBJ_CLASS(dev, 0x005f, GR);
-        NVOBJ_MTHD (dev, 0x005f, 0x0184, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x005f, 0x0188, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x005f, 0x018c, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x005f, 0x0190, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x005f, 0x0194, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x005f, 0x0198, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x005f, 0x019c, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x005f, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 iifc */
-        NVOBJ_CLASS(dev, 0x0060, GR);
-        NVOBJ_MTHD (dev, 0x0060, 0x0188, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x0060, 0x018c, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x0060, 0x0190, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x0060, 0x0194, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0060, 0x0198, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0060, 0x019c, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x0060, 0x01a0, nv04_graph_mthd_bind_surf2d_swzsurf);
-        NVOBJ_MTHD (dev, 0x0060, 0x03e4, nv04_graph_mthd_set_operation);
-
-        /* nv05 iifc */
-        NVOBJ_CLASS(dev, 0x0064, GR);
-
-        /* nv01 ifc */
-        NVOBJ_CLASS(dev, 0x0021, GR);
-        NVOBJ_MTHD (dev, 0x0021, 0x0184, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x0021, 0x0188, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x0021, 0x018c, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x0021, 0x0190, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0021, 0x0194, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0021, 0x0198, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x0021, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 ifc */
-        NVOBJ_CLASS(dev, 0x0061, GR);
-        NVOBJ_MTHD (dev, 0x0061, 0x0184, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x0061, 0x0188, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x0061, 0x018c, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x0061, 0x0190, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0061, 0x0194, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0061, 0x0198, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x0061, 0x019c, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x0061, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv05 ifc */
-        NVOBJ_CLASS(dev, 0x0065, GR);
-
-        /* nv03 sifc */
-        NVOBJ_CLASS(dev, 0x0036, GR);
-        NVOBJ_MTHD (dev, 0x0036, 0x0184, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x0036, 0x0188, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x0036, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0036, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0036, 0x0194, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x0036, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 sifc */
-        NVOBJ_CLASS(dev, 0x0076, GR);
-        NVOBJ_MTHD (dev, 0x0076, 0x0184, nv04_graph_mthd_bind_chroma);
-        NVOBJ_MTHD (dev, 0x0076, 0x0188, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x0076, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0076, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0076, 0x0194, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x0076, 0x0198, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x0076, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv05 sifc */
-        NVOBJ_CLASS(dev, 0x0066, GR);
-
-        /* nv03 sifm */
-        NVOBJ_CLASS(dev, 0x0037, GR);
-        NVOBJ_MTHD (dev, 0x0037, 0x0188, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x0037, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0037, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0037, 0x0194, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x0037, 0x0304, nv04_graph_mthd_set_operation);
-
-        /* nv04 sifm */
-        NVOBJ_CLASS(dev, 0x0077, GR);
-        NVOBJ_MTHD (dev, 0x0077, 0x0188, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x0077, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x0077, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x0077, 0x0194, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x0077, 0x0198, nv04_graph_mthd_bind_surf2d_swzsurf);
-        NVOBJ_MTHD (dev, 0x0077, 0x0304, nv04_graph_mthd_set_operation);
-
-        /* null */
-        NVOBJ_CLASS(dev, 0x0030, GR);
-
-        /* surf2d */
-        NVOBJ_CLASS(dev, 0x0042, GR);
-
-        /* rop */
-        NVOBJ_CLASS(dev, 0x0043, GR);
-
-        /* beta1 */
-        NVOBJ_CLASS(dev, 0x0012, GR);
-
-        /* beta4 */
-        NVOBJ_CLASS(dev, 0x0072, GR);
-
-        /* cliprect */
-        NVOBJ_CLASS(dev, 0x0019, GR);
-
-        /* nv01 pattern */
-        NVOBJ_CLASS(dev, 0x0018, GR);
-
-        /* nv04 pattern */
-        NVOBJ_CLASS(dev, 0x0044, GR);
-
-        /* swzsurf */
-        NVOBJ_CLASS(dev, 0x0052, GR);
-
-        /* surf3d */
-        NVOBJ_CLASS(dev, 0x0053, GR);
-        NVOBJ_MTHD (dev, 0x0053, 0x02f8, nv04_graph_mthd_surf3d_clip_h);
-        NVOBJ_MTHD (dev, 0x0053, 0x02fc, nv04_graph_mthd_surf3d_clip_v);
-
-        /* nv03 tex_tri */
-        NVOBJ_CLASS(dev, 0x0048, GR);
-        NVOBJ_MTHD (dev, 0x0048, 0x0188, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x0048, 0x018c, nv04_graph_mthd_bind_surf_color);
-        NVOBJ_MTHD (dev, 0x0048, 0x0190, nv04_graph_mthd_bind_surf_zeta);
-
-        /* tex_tri */
-        NVOBJ_CLASS(dev, 0x0054, GR);
-
-        /* multitex_tri */
-        NVOBJ_CLASS(dev, 0x0055, GR);
-
-        /* nv01 chroma */
-        NVOBJ_CLASS(dev, 0x0017, GR);
-
-        /* nv04 chroma */
-        NVOBJ_CLASS(dev, 0x0057, GR);
-
-        /* surf_dst */
-        NVOBJ_CLASS(dev, 0x0058, GR);
-
-        /* surf_src */
-        NVOBJ_CLASS(dev, 0x0059, GR);
-
-        /* surf_color */
-        NVOBJ_CLASS(dev, 0x005a, GR);
-
-        /* surf_zeta */
-        NVOBJ_CLASS(dev, 0x005b, GR);
-
-        /* nv01 line */
-        NVOBJ_CLASS(dev, 0x001c, GR);
-        NVOBJ_MTHD (dev, 0x001c, 0x0184, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x001c, 0x0188, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x001c, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x001c, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x001c, 0x0194, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x001c, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 line */
-        NVOBJ_CLASS(dev, 0x005c, GR);
-        NVOBJ_MTHD (dev, 0x005c, 0x0184, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x005c, 0x0188, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x005c, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x005c, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x005c, 0x0194, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x005c, 0x0198, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x005c, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv01 tri */
-        NVOBJ_CLASS(dev, 0x001d, GR);
-        NVOBJ_MTHD (dev, 0x001d, 0x0184, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x001d, 0x0188, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x001d, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x001d, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x001d, 0x0194, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x001d, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 tri */
-        NVOBJ_CLASS(dev, 0x005d, GR);
-        NVOBJ_MTHD (dev, 0x005d, 0x0184, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x005d, 0x0188, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x005d, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x005d, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x005d, 0x0194, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x005d, 0x0198, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x005d, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv01 rect */
-        NVOBJ_CLASS(dev, 0x001e, GR);
-        NVOBJ_MTHD (dev, 0x001e, 0x0184, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x001e, 0x0188, nv04_graph_mthd_bind_nv01_patt);
-        NVOBJ_MTHD (dev, 0x001e, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x001e, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x001e, 0x0194, nv04_graph_mthd_bind_surf_dst);
-        NVOBJ_MTHD (dev, 0x001e, 0x02fc, nv04_graph_mthd_set_operation);
-
-        /* nv04 rect */
-        NVOBJ_CLASS(dev, 0x005e, GR);
-        NVOBJ_MTHD (dev, 0x005e, 0x0184, nv04_graph_mthd_bind_clip);
-        NVOBJ_MTHD (dev, 0x005e, 0x0188, nv04_graph_mthd_bind_nv04_patt);
-        NVOBJ_MTHD (dev, 0x005e, 0x018c, nv04_graph_mthd_bind_rop);
-        NVOBJ_MTHD (dev, 0x005e, 0x0190, nv04_graph_mthd_bind_beta1);
-        NVOBJ_MTHD (dev, 0x005e, 0x0194, nv04_graph_mthd_bind_beta4);
-        NVOBJ_MTHD (dev, 0x005e, 0x0198, nv04_graph_mthd_bind_surf2d);
-        NVOBJ_MTHD (dev, 0x005e, 0x02fc, nv04_graph_mthd_set_operation);
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_instmem.c b/drivers/gpu/drm/nouveau/nv04_instmem.c
deleted file mode 100644
index ef7a934a499a..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_instmem.c
+++ /dev/null
@@ -1,193 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-
-/* returns the size of fifo context */
-static int
-nouveau_fifo_ctx_size(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (dev_priv->chipset >= 0x40)
-                return 128 * 32;
-        else
-        if (dev_priv->chipset >= 0x17)
-                return 64 * 32;
-        else
-        if (dev_priv->chipset >= 0x10)
-                return 32 * 32;
-
-        return 32 * 16;
-}
-
-int nv04_instmem_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ramht = NULL;
-        u32 offset, length;
-        int ret;
-
-        /* RAMIN always available */
-        dev_priv->ramin_available = true;
-
-        /* Reserve space at end of VRAM for PRAMIN */
-        if (dev_priv->card_type >= NV_40) {
-                u32 vs = hweight8((nv_rd32(dev, 0x001540) & 0x0000ff00) >> 8);
-                u32 rsvd;
-
-                /* estimate grctx size, the magics come from nv40_grctx.c */
-                if      (dev_priv->chipset == 0x40) rsvd = 0x6aa0 * vs;
-                else if (dev_priv->chipset  < 0x43) rsvd = 0x4f00 * vs;
-                else if (nv44_graph_class(dev))     rsvd = 0x4980 * vs;
-                else                                rsvd = 0x4a40 * vs;
-                rsvd += 16 * 1024;
-                rsvd *= 32; /* per-channel */
-
-                rsvd += 512 * 1024; /* pci(e)gart table */
-                rsvd += 512 * 1024; /* object storage */
-
-                dev_priv->ramin_rsvd_vram = round_up(rsvd, 4096);
-        } else {
-                dev_priv->ramin_rsvd_vram = 512 * 1024;
-        }
-
-        /* Setup shared RAMHT */
-        ret = nouveau_gpuobj_new_fake(dev, 0x10000, ~0, 4096,
-                                      NVOBJ_FLAG_ZERO_ALLOC, &ramht);
-        if (ret)
-                return ret;
-
-        ret = nouveau_ramht_new(dev, ramht, &dev_priv->ramht);
-        nouveau_gpuobj_ref(NULL, &ramht);
-        if (ret)
-                return ret;
-
-        /* And RAMRO */
-        ret = nouveau_gpuobj_new_fake(dev, 0x11200, ~0, 512,
-                                      NVOBJ_FLAG_ZERO_ALLOC, &dev_priv->ramro);
-        if (ret)
-                return ret;
-
-        /* And RAMFC */
-        length = nouveau_fifo_ctx_size(dev);
-        switch (dev_priv->card_type) {
-        case NV_40:
-                offset = 0x20000;
-                break;
-        default:
-                offset = 0x11400;
-                break;
-        }
-
-        ret = nouveau_gpuobj_new_fake(dev, offset, ~0, length,
-                                      NVOBJ_FLAG_ZERO_ALLOC, &dev_priv->ramfc);
-        if (ret)
-                return ret;
-
-        /* Only allow space after RAMFC to be used for object allocation */
-        offset += length;
-
-        /* It appears RAMRO (or something?) is controlled by 0x2220/0x2230
-         * on certain NV4x chipsets as well as RAMFC.  When 0x2230 == 0
-         * ("new style" control) the upper 16-bits of 0x2220 points at this
-         * other mysterious table that's clobbering important things.
-         *
-         * We're now pointing this at RAMIN+0x30000 to avoid RAMFC getting
-         * smashed to pieces on us, so reserve 0x30000-0x40000 too..
-         */
-        if (dev_priv->card_type >= NV_40) {
-                if (offset < 0x40000)
-                        offset = 0x40000;
-        }
-
-        ret = drm_mm_init(&dev_priv->ramin_heap, offset,
-                          dev_priv->ramin_rsvd_vram - offset);
-        if (ret) {
-                NV_ERROR(dev, "Failed to init RAMIN heap: %d\n", ret);
-                return ret;
-        }
-
-        return 0;
-}
-
-void
-nv04_instmem_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nouveau_ramht_ref(NULL, &dev_priv->ramht, NULL);
-        nouveau_gpuobj_ref(NULL, &dev_priv->ramro);
-        nouveau_gpuobj_ref(NULL, &dev_priv->ramfc);
-
-        if (drm_mm_initialized(&dev_priv->ramin_heap))
-                drm_mm_takedown(&dev_priv->ramin_heap);
-}
-
-int
-nv04_instmem_suspend(struct drm_device *dev)
-{
-        return 0;
-}
-
-void
-nv04_instmem_resume(struct drm_device *dev)
-{
-}
-
-int
-nv04_instmem_get(struct nouveau_gpuobj *gpuobj, struct nouveau_channel *chan,
-                 u32 size, u32 align)
-{
-        struct drm_nouveau_private *dev_priv = gpuobj->dev->dev_private;
-        struct drm_mm_node *ramin = NULL;
-
-        do {
-                if (drm_mm_pre_get(&dev_priv->ramin_heap))
-                        return -ENOMEM;
-
-                spin_lock(&dev_priv->ramin_lock);
-                ramin = drm_mm_search_free(&dev_priv->ramin_heap, size, align, 0);
-                if (ramin == NULL) {
-                        spin_unlock(&dev_priv->ramin_lock);
-                        return -ENOMEM;
-                }
-
-                ramin = drm_mm_get_block_atomic(ramin, size, align);
-                spin_unlock(&dev_priv->ramin_lock);
-        } while (ramin == NULL);
-
-        gpuobj->node  = ramin;
-        gpuobj->vinst = ramin->start;
-        return 0;
-}
-
-void
-nv04_instmem_put(struct nouveau_gpuobj *gpuobj)
-{
-        struct drm_nouveau_private *dev_priv = gpuobj->dev->dev_private;
-
-        spin_lock(&dev_priv->ramin_lock);
-        drm_mm_put_block(gpuobj->node);
-        gpuobj->node = NULL;
-        spin_unlock(&dev_priv->ramin_lock);
-}
-
-int
-nv04_instmem_map(struct nouveau_gpuobj *gpuobj)
-{
-        gpuobj->pinst = gpuobj->vinst;
-        return 0;
-}
-
-void
-nv04_instmem_unmap(struct nouveau_gpuobj *gpuobj)
-{
-}
-
-void
-nv04_instmem_flush(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_mc.c b/drivers/gpu/drm/nouveau/nv04_mc.c
deleted file mode 100644
index 2af43a1cb2ec..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_mc.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-int
-nv04_mc_init(struct drm_device *dev)
-{
-        /* Power up everything, resetting each individual unit will
-         * be done later if needed.
-         */
-
-        nv_wr32(dev, NV03_PMC_ENABLE, 0xFFFFFFFF);
-
-        /* Disable PROM access. */
-        nv_wr32(dev, NV_PBUS_PCI_NV_20, NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);
-
-        return 0;
-}
-
-void
-nv04_mc_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_pm.c b/drivers/gpu/drm/nouveau/nv04_pm.c
index 6e7589918fa9..410be011c2f0 100644
--- a/drivers/gpu/drm/nouveau/nv04_pm.c
+++ b/drivers/gpu/drm/nouveau/nv04_pm.c
@@ -23,10 +23,15 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_hw.h"
 #include "nouveau_pm.h"
 
+#include <subdev/bios/pll.h>
+#include <subdev/clock.h>
+#include <subdev/timer.h>
+
 int
 nv04_pm_clocks_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
@@ -46,7 +51,7 @@ nv04_pm_clocks_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 }
 
 struct nv04_pm_clock {
-        struct pll_lims pll;
+        struct nvbios_pll pll;
         struct nouveau_pll_vals calc;
 };
 
@@ -58,13 +63,16 @@ struct nv04_pm_state {
 static int
 calc_pll(struct drm_device *dev, u32 id, int khz, struct nv04_pm_clock *clk)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nouveau_clock *pclk = nouveau_clock(device);
         int ret;
 
-        ret = get_pll_limits(dev, id, &clk->pll);
+        ret = nvbios_pll_parse(bios, id, &clk->pll);
         if (ret)
                 return ret;
 
-        ret = nouveau_calc_pll_mnp(dev, &clk->pll, khz, &clk->calc);
+        ret = pclk->pll_calc(pclk, &clk->pll, khz, &clk->calc);
         if (!ret)
                 return -EINVAL;
 
@@ -100,37 +108,38 @@ error:
 static void
 prog_pll(struct drm_device *dev, struct nv04_pm_clock *clk)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_clock *pclk = nouveau_clock(device);
         u32 reg = clk->pll.reg;
 
         /* thank the insane nouveau_hw_setpll() interface for this */
-        if (dev_priv->card_type >= NV_40)
+        if (device->card_type >= NV_40)
                 reg += 4;
 
-        nouveau_hw_setpll(dev, reg, &clk->calc);
+        pclk->pll_prog(pclk, reg, &clk->calc);
 }
 
 int
 nv04_pm_clocks_set(struct drm_device *dev, void *pre_state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_timer *ptimer = nouveau_timer(device);
         struct nv04_pm_state *state = pre_state;
 
         prog_pll(dev, &state->core);
 
         if (state->memory.pll.reg) {
                 prog_pll(dev, &state->memory);
-                if (dev_priv->card_type < NV_30) {
-                        if (dev_priv->card_type == NV_20)
-                                nv_mask(dev, 0x1002c4, 0, 1 << 20);
+                if (device->card_type < NV_30) {
+                        if (device->card_type == NV_20)
+                                nv_mask(device, 0x1002c4, 0, 1 << 20);
 
                         /* Reset the DLLs */
-                        nv_mask(dev, 0x1002c0, 0, 1 << 8);
+                        nv_mask(device, 0x1002c0, 0, 1 << 8);
                 }
         }
 
-        ptimer->init(dev);
+        nv_ofuncs(ptimer)->init(nv_object(ptimer));
 
         kfree(state);
         return 0;
diff --git a/drivers/gpu/drm/nouveau/nv04_software.c b/drivers/gpu/drm/nouveau/nv04_software.c
deleted file mode 100644
index 0c41abf48774..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_software.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright 2012 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"
-#include "nouveau_ramht.h"
-#include "nouveau_fence.h"
-#include "nouveau_software.h"
-#include "nouveau_hw.h"
-
-struct nv04_software_priv {
-        struct nouveau_software_priv base;
-};
-
-struct nv04_software_chan {
-        struct nouveau_software_chan base;
-};
-
-static int
-mthd_flip(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-
-        struct nouveau_page_flip_state state;
-
-        if (!nouveau_finish_page_flip(chan, &state)) {
-                nv_set_crtc_base(chan->dev, state.crtc, state.offset +
-                                 state.y * state.pitch +
-                                 state.x * state.bpp / 8);
-        }
-
-        return 0;
-}
-
-static int
-nv04_software_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv04_software_chan *pch;
-
-        pch = kzalloc(sizeof(*pch), GFP_KERNEL);
-        if (!pch)
-                return -ENOMEM;
-
-        nouveau_software_context_new(&pch->base);
-        chan->engctx[engine] = pch;
-        return 0;
-}
-
-static void
-nv04_software_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv04_software_chan *pch = chan->engctx[engine];
-        chan->engctx[engine] = NULL;
-        kfree(pch);
-}
-
-static int
-nv04_software_object_new(struct nouveau_channel *chan, int engine,
-                         u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, 0, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 0;
-        obj->class  = class;
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static int
-nv04_software_init(struct drm_device *dev, int engine)
-{
-        return 0;
-}
-
-static int
-nv04_software_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static void
-nv04_software_destroy(struct drm_device *dev, int engine)
-{
-        struct nv04_software_priv *psw = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, SW);
-        kfree(psw);
-}
-
-int
-nv04_software_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_software_priv *psw;
-
-        psw = kzalloc(sizeof(*psw), GFP_KERNEL);
-        if (!psw)
-                return -ENOMEM;
-
-        psw->base.base.destroy = nv04_software_destroy;
-        psw->base.base.init = nv04_software_init;
-        psw->base.base.fini = nv04_software_fini;
-        psw->base.base.context_new = nv04_software_context_new;
-        psw->base.base.context_del = nv04_software_context_del;
-        psw->base.base.object_new = nv04_software_object_new;
-        nouveau_software_create(&psw->base);
-
-        NVOBJ_ENGINE_ADD(dev, SW, &psw->base.base);
-        if (dev_priv->card_type <= NV_04) {
-                NVOBJ_CLASS(dev, 0x006e, SW);
-                NVOBJ_MTHD (dev, 0x006e, 0x0150, nv04_fence_mthd);
-                NVOBJ_MTHD (dev, 0x006e, 0x0500, mthd_flip);
-        } else {
-                NVOBJ_CLASS(dev, 0x016e, SW);
-                NVOBJ_MTHD (dev, 0x016e, 0x0500, mthd_flip);
-        }
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_timer.c b/drivers/gpu/drm/nouveau/nv04_timer.c
deleted file mode 100644
index 55c945290e52..000000000000
--- a/drivers/gpu/drm/nouveau/nv04_timer.c
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-#include "nouveau_hw.h"
-
-int
-nv04_timer_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 m, n, d;
-
-        nv_wr32(dev, NV04_PTIMER_INTR_EN_0, 0x00000000);
-        nv_wr32(dev, NV04_PTIMER_INTR_0, 0xFFFFFFFF);
-
-        /* aim for 31.25MHz, which gives us nanosecond timestamps */
-        d = 1000000 / 32;
-
-        /* determine base clock for timer source */
-        if (dev_priv->chipset < 0x40) {
-                n = nouveau_hw_get_clock(dev, PLL_CORE);
-        } else
-        if (dev_priv->chipset == 0x40) {
-                /*XXX: figure this out */
-                n = 0;
-        } else {
-                n = dev_priv->crystal;
-                m = 1;
-                while (n < (d * 2)) {
-                        n += (n / m);
-                        m++;
-                }
-
-                nv_wr32(dev, 0x009220, m - 1);
-        }
-
-        if (!n) {
-                NV_WARN(dev, "PTIMER: unknown input clock freq\n");
-                if (!nv_rd32(dev, NV04_PTIMER_NUMERATOR) ||
-                    !nv_rd32(dev, NV04_PTIMER_DENOMINATOR)) {
-                        nv_wr32(dev, NV04_PTIMER_NUMERATOR, 1);
-                        nv_wr32(dev, NV04_PTIMER_DENOMINATOR, 1);
-                }
-                return 0;
-        }
-
-        /* reduce ratio to acceptable values */
-        while (((n % 5) == 0) && ((d % 5) == 0)) {
-                n /= 5;
-                d /= 5;
-        }
-
-        while (((n % 2) == 0) && ((d % 2) == 0)) {
-                n /= 2;
-                d /= 2;
-        }
-
-        while (n > 0xffff || d > 0xffff) {
-                n >>= 1;
-                d >>= 1;
-        }
-
-        nv_wr32(dev, NV04_PTIMER_NUMERATOR, n);
-        nv_wr32(dev, NV04_PTIMER_DENOMINATOR, d);
-        return 0;
-}
-
-u64
-nv04_timer_read(struct drm_device *dev)
-{
-        u32 hi, lo;
-
-        do {
-                hi = nv_rd32(dev, NV04_PTIMER_TIME_1);
-                lo = nv_rd32(dev, NV04_PTIMER_TIME_0);
-        } while (hi != nv_rd32(dev, NV04_PTIMER_TIME_1));
-
-        return ((u64)hi << 32 | lo);
-}
-
-void
-nv04_timer_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv04_tv.c b/drivers/gpu/drm/nouveau/nv04_tv.c
index 3eb605ddfd03..45c5c039e7e4 100644
--- a/drivers/gpu/drm/nouveau/nv04_tv.c
+++ b/drivers/gpu/drm/nouveau/nv04_tv.c
@@ -25,7 +25,8 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
@@ -34,6 +35,8 @@
 
 #include "i2c/ch7006.h"
 
+#include <subdev/i2c.h>
+
 static struct i2c_board_info nv04_tv_encoder_info[] = {
         {
                 I2C_BOARD_INFO("ch7006", 0x75),
@@ -49,8 +52,11 @@ static struct i2c_board_info nv04_tv_encoder_info[] = {
 
 int nv04_tv_identify(struct drm_device *dev, int i2c_index)
 {
-        return nouveau_i2c_identify(dev, "TV encoder", nv04_tv_encoder_info,
-                                    NULL, i2c_index);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+
+        return i2c->identify(i2c, i2c_index, "TV encoder",
+                             nv04_tv_encoder_info, NULL);
 }
 
 
@@ -64,12 +70,12 @@ int nv04_tv_identify(struct drm_device *dev, int i2c_index)
 static void nv04_tv_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_mode_state *state = &dev_priv->mode_reg;
+        struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
         uint8_t crtc1A;
 
-        NV_INFO(dev, "Setting dpms mode %d on TV encoder (output %d)\n",
+        NV_INFO(drm, "Setting dpms mode %d on TV encoder (output %d)\n",
                 mode, nv_encoder->dcb->index);
 
         state->pllsel &= ~(PLLSEL_TV_CRTC1_MASK | PLLSEL_TV_CRTC2_MASK);
@@ -94,8 +100,7 @@ static void nv04_tv_dpms(struct drm_encoder *encoder, int mode)
 
 static void nv04_tv_bind(struct drm_device *dev, int head, bool bind)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv04_crtc_reg *state = &dev_priv->mode_reg.crtc_reg[head];
+        struct nv04_crtc_reg *state = &nv04_display(dev)->mode_reg.crtc_reg[head];
 
         state->tv_setup = 0;
 
@@ -133,9 +138,8 @@ static void nv04_tv_mode_set(struct drm_encoder *encoder,
                              struct drm_display_mode *adjusted_mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
-        struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
+        struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
 
         regp->tv_htotal = adjusted_mode->htotal;
         regp->tv_vtotal = adjusted_mode->vtotal;
@@ -157,12 +161,13 @@ static void nv04_tv_commit(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
         struct drm_encoder_helper_funcs *helper = encoder->helper_private;
 
         helper->dpms(encoder, DRM_MODE_DPMS_ON);
 
-        NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
+        NV_INFO(drm, "Output %s is running on CRTC %d using output %c\n",
                       drm_get_connector_name(&nouveau_encoder_connector_get(nv_encoder)->base), nv_crtc->index,
                       '@' + ffs(nv_encoder->dcb->or));
 }
@@ -181,15 +186,16 @@ static const struct drm_encoder_funcs nv04_tv_funcs = {
 };
 
 int
-nv04_tv_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv04_tv_create(struct drm_connector *connector, struct dcb_output *entry)
 {
         struct nouveau_encoder *nv_encoder;
         struct drm_encoder *encoder;
         struct drm_device *dev = connector->dev;
         struct drm_encoder_helper_funcs *hfuncs;
         struct drm_encoder_slave_funcs *sfuncs;
-        struct nouveau_i2c_chan *i2c =
-                nouveau_i2c_find(dev, entry->i2c_index);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+        struct nouveau_i2c_port *port = i2c->find(i2c, entry->i2c_index);
         int type, ret;
 
         /* Ensure that we can talk to this encoder */
@@ -221,7 +227,7 @@ nv04_tv_create(struct drm_connector *connector, struct dcb_entry *entry)
 
         /* Run the slave-specific initialization */
         ret = drm_i2c_encoder_init(dev, to_encoder_slave(encoder),
-                                   &i2c->adapter, &nv04_tv_encoder_info[type]);
+                                   &port->adapter, &nv04_tv_encoder_info[type]);
         if (ret < 0)
                 goto fail_cleanup;
 
diff --git a/drivers/gpu/drm/nouveau/nv10_fb.c b/drivers/gpu/drm/nouveau/nv10_fb.c
deleted file mode 100644
index 420b1608536d..000000000000
--- a/drivers/gpu/drm/nouveau/nv10_fb.c
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-void
-nv10_fb_init_tile_region(struct drm_device *dev, int i, uint32_t addr,
-                         uint32_t size, uint32_t pitch, uint32_t flags)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        tile->addr  = 0x80000000 | addr;
-        tile->limit = max(1u, addr + size) - 1;
-        tile->pitch = pitch;
-}
-
-void
-nv10_fb_free_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        tile->addr = tile->limit = tile->pitch = tile->zcomp = 0;
-}
-
-void
-nv10_fb_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        nv_wr32(dev, NV10_PFB_TLIMIT(i), tile->limit);
-        nv_wr32(dev, NV10_PFB_TSIZE(i), tile->pitch);
-        nv_wr32(dev, NV10_PFB_TILE(i), tile->addr);
-}
-
-int
-nv1a_fb_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct pci_dev *bridge;
-        uint32_t mem, mib;
-
-        bridge = pci_get_bus_and_slot(0, PCI_DEVFN(0, 1));
-        if (!bridge) {
-                NV_ERROR(dev, "no bridge device\n");
-                return 0;
-        }
-
-        if (dev_priv->chipset == 0x1a) {
-                pci_read_config_dword(bridge, 0x7c, &mem);
-                mib = ((mem >> 6) & 31) + 1;
-        } else {
-                pci_read_config_dword(bridge, 0x84, &mem);
-                mib = ((mem >> 4) & 127) + 1;
-        }
-
-        dev_priv->vram_size = mib * 1024 * 1024;
-        return 0;
-}
-
-int
-nv10_fb_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 fifo_data = nv_rd32(dev, NV04_PFB_FIFO_DATA);
-        u32 cfg0 = nv_rd32(dev, 0x100200);
-
-        dev_priv->vram_size = fifo_data & NV10_PFB_FIFO_DATA_RAM_AMOUNT_MB_MASK;
-
-        if (cfg0 & 0x00000001)
-                dev_priv->vram_type = NV_MEM_TYPE_DDR1;
-        else
-                dev_priv->vram_type = NV_MEM_TYPE_SDRAM;
-
-        return 0;
-}
-
-int
-nv10_fb_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        int i;
-
-        /* Turn all the tiling regions off. */
-        pfb->num_tiles = NV10_PFB_TILE__SIZE;
-        for (i = 0; i < pfb->num_tiles; i++)
-                pfb->set_tile_region(dev, i);
-
-        return 0;
-}
-
-void
-nv10_fb_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        int i;
-
-        for (i = 0; i < pfb->num_tiles; i++)
-                pfb->free_tile_region(dev, i);
-}
diff --git a/drivers/gpu/drm/nouveau/nv10_fence.c b/drivers/gpu/drm/nouveau/nv10_fence.c
index 8a1b75009185..ce752bf5cc4e 100644
--- a/drivers/gpu/drm/nouveau/nv10_fence.c
+++ b/drivers/gpu/drm/nouveau/nv10_fence.c
@@ -22,10 +22,11 @@
  * Authors: Ben Skeggs <bskeggs@redhat.com>
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include <core/object.h>
+#include <core/class.h>
+
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fence.h"
 
 struct nv10_fence_chan {
@@ -39,7 +40,7 @@ struct nv10_fence_priv {
         u32 sequence;
 };
 
-static int
+int
 nv10_fence_emit(struct nouveau_fence *fence)
 {
         struct nouveau_channel *chan = fence->channel;
@@ -60,15 +61,15 @@ nv10_fence_sync(struct nouveau_fence *fence,
         return -ENODEV;
 }
 
-static int
+int
 nv17_fence_sync(struct nouveau_fence *fence,
                 struct nouveau_channel *prev, struct nouveau_channel *chan)
 {
-        struct nv10_fence_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_FENCE);
+        struct nv10_fence_priv *priv = chan->drm->fence;
         u32 value;
         int ret;
 
-        if (!mutex_trylock(&prev->mutex))
+        if (!mutex_trylock(&prev->cli->mutex))
                 return -EBUSY;
 
         spin_lock(&priv->lock);
@@ -95,34 +96,33 @@ nv17_fence_sync(struct nouveau_fence *fence,
                 FIRE_RING (chan);
         }
 
-        mutex_unlock(&prev->mutex);
+        mutex_unlock(&prev->cli->mutex);
         return 0;
 }
 
-static u32
+u32
 nv10_fence_read(struct nouveau_channel *chan)
 {
-        return nvchan_rd32(chan, 0x0048);
+        return nv_ro32(chan->object, 0x0048);
 }
 
-static void
-nv10_fence_context_del(struct nouveau_channel *chan, int engine)
+void
+nv10_fence_context_del(struct nouveau_channel *chan)
 {
-        struct nv10_fence_chan *fctx = chan->engctx[engine];
+        struct nv10_fence_chan *fctx = chan->fence;
         nouveau_fence_context_del(&fctx->base);
-        chan->engctx[engine] = NULL;
+        chan->fence = NULL;
         kfree(fctx);
 }
 
 static int
-nv10_fence_context_new(struct nouveau_channel *chan, int engine)
+nv10_fence_context_new(struct nouveau_channel *chan)
 {
-        struct nv10_fence_priv *priv = nv_engine(chan->dev, engine);
+        struct nv10_fence_priv *priv = chan->drm->fence;
         struct nv10_fence_chan *fctx;
-        struct nouveau_gpuobj *obj;
         int ret = 0;
 
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
+        fctx = chan->fence = kzalloc(sizeof(*fctx), GFP_KERNEL);
         if (!fctx)
                 return -ENOMEM;
 
@@ -130,69 +130,56 @@ nv10_fence_context_new(struct nouveau_channel *chan, int engine)
 
         if (priv->bo) {
                 struct ttm_mem_reg *mem = &priv->bo->bo.mem;
-
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_FROM_MEMORY,
-                                             mem->start * PAGE_SIZE, mem->size,
-                                             NV_MEM_ACCESS_RW,
-                                             NV_MEM_TARGET_VRAM, &obj);
-                if (!ret) {
-                        ret = nouveau_ramht_insert(chan, NvSema, obj);
-                        nouveau_gpuobj_ref(NULL, &obj);
-                }
+                struct nouveau_object *object;
+                u32 start = mem->start * PAGE_SIZE;
+                u32 limit = mem->start + mem->size - 1;
+
+                ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
+                                         NvSema, 0x0002,
+                                         &(struct nv_dma_class) {
+                                                .flags = NV_DMA_TARGET_VRAM |
+                                                         NV_DMA_ACCESS_RDWR,
+                                                .start = start,
+                                                .limit = limit,
+                                         }, sizeof(struct nv_dma_class),
+                                         &object);
         }
 
         if (ret)
-                nv10_fence_context_del(chan, engine);
+                nv10_fence_context_del(chan);
         return ret;
 }
 
-static int
-nv10_fence_fini(struct drm_device *dev, int engine, bool suspend)
+void
+nv10_fence_destroy(struct nouveau_drm *drm)
 {
-        return 0;
-}
-
-static int
-nv10_fence_init(struct drm_device *dev, int engine)
-{
-        return 0;
-}
-
-static void
-nv10_fence_destroy(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv10_fence_priv *priv = nv_engine(dev, engine);
-
+        struct nv10_fence_priv *priv = drm->fence;
+        nouveau_bo_unmap(priv->bo);
         nouveau_bo_ref(NULL, &priv->bo);
-        dev_priv->eng[engine] = NULL;
+        drm->fence = NULL;
         kfree(priv);
 }
 
 int
-nv10_fence_create(struct drm_device *dev)
+nv10_fence_create(struct nouveau_drm *drm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nv10_fence_priv *priv;
         int ret = 0;
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = drm->fence = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
-        priv->base.engine.destroy = nv10_fence_destroy;
-        priv->base.engine.init = nv10_fence_init;
-        priv->base.engine.fini = nv10_fence_fini;
-        priv->base.engine.context_new = nv10_fence_context_new;
-        priv->base.engine.context_del = nv10_fence_context_del;
+        priv->base.dtor = nv10_fence_destroy;
+        priv->base.context_new = nv10_fence_context_new;
+        priv->base.context_del = nv10_fence_context_del;
         priv->base.emit = nv10_fence_emit;
         priv->base.read = nv10_fence_read;
         priv->base.sync = nv10_fence_sync;
-        dev_priv->eng[NVOBJ_ENGINE_FENCE] = &priv->base.engine;
         spin_lock_init(&priv->lock);
 
-        if (dev_priv->chipset >= 0x17) {
-                ret = nouveau_bo_new(dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
+        if (nv_device(drm->device)->chipset >= 0x17) {
+                ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
                                      0, 0x0000, NULL, &priv->bo);
                 if (!ret) {
                         ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
@@ -209,6 +196,6 @@ nv10_fence_create(struct drm_device *dev)
         }
 
         if (ret)
-                nv10_fence_destroy(dev, NVOBJ_ENGINE_FENCE);
+                nv10_fence_destroy(drm);
         return ret;
 }
diff --git a/drivers/gpu/drm/nouveau/nv10_fifo.c b/drivers/gpu/drm/nouveau/nv10_fifo.c
deleted file mode 100644
index f1fe7d758241..000000000000
--- a/drivers/gpu/drm/nouveau/nv10_fifo.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (C) 2012 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_util.h"
-#include "nouveau_ramht.h"
-
-static struct ramfc_desc {
-        unsigned bits:6;
-        unsigned ctxs:5;
-        unsigned ctxp:8;
-        unsigned regs:5;
-        unsigned regp;
-} nv10_ramfc[] = {
-        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
-        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
-        { 32,  0, 0x08,  0, NV10_PFIFO_CACHE1_REF_CNT },
-        { 16,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
-        { 16, 16, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
-        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_STATE },
-        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
-        { 32,  0, 0x18,  0, NV04_PFIFO_CACHE1_ENGINE },
-        { 32,  0, 0x1c,  0, NV04_PFIFO_CACHE1_PULL1 },
-        {}
-};
-
-struct nv10_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct ramfc_desc *ramfc_desc;
-};
-
-struct nv10_fifo_chan {
-        struct nouveau_fifo_chan base;
-        struct nouveau_gpuobj *ramfc;
-};
-
-static int
-nv10_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv10_fifo_priv *priv = nv_engine(dev, engine);
-        struct nv10_fifo_chan *fctx;
-        unsigned long flags;
-        int ret;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-
-        /* map channel control registers */
-        chan->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                             NV03_USER(chan->id), PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        /* initialise default fifo context */
-        ret = nouveau_gpuobj_new_fake(dev, dev_priv->ramfc->pinst +
-                                      chan->id * 32, ~0, 32,
-                                      NVOBJ_FLAG_ZERO_FREE, &fctx->ramfc);
-        if (ret)
-                goto error;
-
-        nv_wo32(fctx->ramfc, 0x00, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x04, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x08, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x0c, chan->pushbuf->pinst >> 4);
-        nv_wo32(fctx->ramfc, 0x10, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x14, NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
-                                   NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
-#ifdef __BIG_ENDIAN
-                                   NV_PFIFO_CACHE1_BIG_ENDIAN |
-#endif
-                                   NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
-        nv_wo32(fctx->ramfc, 0x18, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x1c, 0x00000000);
-
-        /* enable dma mode on the channel */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PFIFO_MODE, (1 << chan->id), (1 << chan->id));
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-int
-nv10_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv10_fifo_priv *priv;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nv04_fifo_destroy;
-        priv->base.base.init = nv04_fifo_init;
-        priv->base.base.fini = nv04_fifo_fini;
-        priv->base.base.context_new = nv10_fifo_context_new;
-        priv->base.base.context_del = nv04_fifo_context_del;
-        priv->base.channels = 31;
-        priv->ramfc_desc = nv10_ramfc;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        nouveau_irq_register(dev, 8, nv04_fifo_isr);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv10_gpio.c b/drivers/gpu/drm/nouveau/nv10_gpio.c
deleted file mode 100644
index 9d79180069df..000000000000
--- a/drivers/gpu/drm/nouveau/nv10_gpio.c
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (C) 2009 Francisco Jerez.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_hw.h"
-#include "nouveau_gpio.h"
-
-int
-nv10_gpio_sense(struct drm_device *dev, int line)
-{
-        if (line < 2) {
-                line = line * 16;
-                line = NVReadCRTC(dev, 0, NV_PCRTC_GPIO) >> line;
-                return !!(line & 0x0100);
-        } else
-        if (line < 10) {
-                line = (line - 2) * 4;
-                line = NVReadCRTC(dev, 0, NV_PCRTC_GPIO_EXT) >> line;
-                return !!(line & 0x04);
-        } else
-        if (line < 14) {
-                line = (line - 10) * 4;
-                line = NVReadCRTC(dev, 0, NV_PCRTC_850) >> line;
-                return !!(line & 0x04);
-        }
-
-        return -EINVAL;
-}
-
-int
-nv10_gpio_drive(struct drm_device *dev, int line, int dir, int out)
-{
-        u32 reg, mask, data;
-
-        if (line < 2) {
-                line = line * 16;
-                reg  = NV_PCRTC_GPIO;
-                mask = 0x00000011;
-                data = (dir << 4) | out;
-        } else
-        if (line < 10) {
-                line = (line - 2) * 4;
-                reg  = NV_PCRTC_GPIO_EXT;
-                mask = 0x00000003;
-                data = (dir << 1) | out;
-        } else
-        if (line < 14) {
-                line = (line - 10) * 4;
-                reg  = NV_PCRTC_850;
-                mask = 0x00000003;
-                data = (dir << 1) | out;
-        } else {
-                return -EINVAL;
-        }
-
-        mask = NVReadCRTC(dev, 0, reg) & ~(mask << line);
-        NVWriteCRTC(dev, 0, reg, mask | (data << line));
-        return 0;
-}
-
-void
-nv10_gpio_irq_enable(struct drm_device *dev, int line, bool on)
-{
-        u32 mask = 0x00010001 << line;
-
-        nv_wr32(dev, 0x001104, mask);
-        nv_mask(dev, 0x001144, mask, on ? mask : 0);
-}
-
-static void
-nv10_gpio_isr(struct drm_device *dev)
-{
-        u32 intr = nv_rd32(dev, 0x1104);
-        u32 hi = (intr & 0x0000ffff) >> 0;
-        u32 lo = (intr & 0xffff0000) >> 16;
-
-        nouveau_gpio_isr(dev, 0, hi | lo);
-
-        nv_wr32(dev, 0x001104, intr);
-}
-
-int
-nv10_gpio_init(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x001140, 0x00000000);
-        nv_wr32(dev, 0x001100, 0xffffffff);
-        nv_wr32(dev, 0x001144, 0x00000000);
-        nv_wr32(dev, 0x001104, 0xffffffff);
-        nouveau_irq_register(dev, 28, nv10_gpio_isr); /* PBUS */
-        return 0;
-}
-
-void
-nv10_gpio_fini(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x001140, 0x00000000);
-        nv_wr32(dev, 0x001144, 0x00000000);
-        nouveau_irq_unregister(dev, 28);
-}
diff --git a/drivers/gpu/drm/nouveau/nv10_graph.c b/drivers/gpu/drm/nouveau/nv10_graph.c
deleted file mode 100644
index fb1d88a951de..000000000000
--- a/drivers/gpu/drm/nouveau/nv10_graph.c
+++ /dev/null
@@ -1,1189 +0,0 @@
-/*
- * Copyright 2007 Matthieu CASTET <castet.matthieu@free.fr>
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_util.h"
-
-struct nv10_graph_engine {
-        struct nouveau_exec_engine base;
-};
-
-struct pipe_state {
-        uint32_t pipe_0x0000[0x040/4];
-        uint32_t pipe_0x0040[0x010/4];
-        uint32_t pipe_0x0200[0x0c0/4];
-        uint32_t pipe_0x4400[0x080/4];
-        uint32_t pipe_0x6400[0x3b0/4];
-        uint32_t pipe_0x6800[0x2f0/4];
-        uint32_t pipe_0x6c00[0x030/4];
-        uint32_t pipe_0x7000[0x130/4];
-        uint32_t pipe_0x7400[0x0c0/4];
-        uint32_t pipe_0x7800[0x0c0/4];
-};
-
-static int nv10_graph_ctx_regs[] = {
-        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,
-        NV04_PGRAPH_DMA_LENGTH,
-        NV04_PGRAPH_DMA_MISC,
-        NV10_PGRAPH_DMA_PITCH,
-        NV04_PGRAPH_BOFFSET0,
-        NV04_PGRAPH_BBASE0,
-        NV04_PGRAPH_BLIMIT0,
-        NV04_PGRAPH_BOFFSET1,
-        NV04_PGRAPH_BBASE1,
-        NV04_PGRAPH_BLIMIT1,
-        NV04_PGRAPH_BOFFSET2,
-        NV04_PGRAPH_BBASE2,
-        NV04_PGRAPH_BLIMIT2,
-        NV04_PGRAPH_BOFFSET3,
-        NV04_PGRAPH_BBASE3,
-        NV04_PGRAPH_BLIMIT3,
-        NV04_PGRAPH_BOFFSET4,
-        NV04_PGRAPH_BBASE4,
-        NV04_PGRAPH_BLIMIT4,
-        NV04_PGRAPH_BOFFSET5,
-        NV04_PGRAPH_BBASE5,
-        NV04_PGRAPH_BLIMIT5,
-        NV04_PGRAPH_BPITCH0,
-        NV04_PGRAPH_BPITCH1,
-        NV04_PGRAPH_BPITCH2,
-        NV04_PGRAPH_BPITCH3,
-        NV04_PGRAPH_BPITCH4,
-        NV10_PGRAPH_SURFACE,
-        NV10_PGRAPH_STATE,
-        NV04_PGRAPH_BSWIZZLE2,
-        NV04_PGRAPH_BSWIZZLE5,
-        NV04_PGRAPH_BPIXEL,
-        NV10_PGRAPH_NOTIFY,
-        NV04_PGRAPH_PATT_COLOR0,
-        NV04_PGRAPH_PATT_COLOR1,
-        NV04_PGRAPH_PATT_COLORRAM, /* 64 values from 0x400900 to 0x4009fc */
-        0x00400904,
-        0x00400908,
-        0x0040090c,
-        0x00400910,
-        0x00400914,
-        0x00400918,
-        0x0040091c,
-        0x00400920,
-        0x00400924,
-        0x00400928,
-        0x0040092c,
-        0x00400930,
-        0x00400934,
-        0x00400938,
-        0x0040093c,
-        0x00400940,
-        0x00400944,
-        0x00400948,
-        0x0040094c,
-        0x00400950,
-        0x00400954,
-        0x00400958,
-        0x0040095c,
-        0x00400960,
-        0x00400964,
-        0x00400968,
-        0x0040096c,
-        0x00400970,
-        0x00400974,
-        0x00400978,
-        0x0040097c,
-        0x00400980,
-        0x00400984,
-        0x00400988,
-        0x0040098c,
-        0x00400990,
-        0x00400994,
-        0x00400998,
-        0x0040099c,
-        0x004009a0,
-        0x004009a4,
-        0x004009a8,
-        0x004009ac,
-        0x004009b0,
-        0x004009b4,
-        0x004009b8,
-        0x004009bc,
-        0x004009c0,
-        0x004009c4,
-        0x004009c8,
-        0x004009cc,
-        0x004009d0,
-        0x004009d4,
-        0x004009d8,
-        0x004009dc,
-        0x004009e0,
-        0x004009e4,
-        0x004009e8,
-        0x004009ec,
-        0x004009f0,
-        0x004009f4,
-        0x004009f8,
-        0x004009fc,
-        NV04_PGRAPH_PATTERN,    /* 2 values from 0x400808 to 0x40080c */
-        0x0040080c,
-        NV04_PGRAPH_PATTERN_SHAPE,
-        NV03_PGRAPH_MONO_COLOR0,
-        NV04_PGRAPH_ROP3,
-        NV04_PGRAPH_CHROMA,
-        NV04_PGRAPH_BETA_AND,
-        NV04_PGRAPH_BETA_PREMULT,
-        0x00400e70,
-        0x00400e74,
-        0x00400e78,
-        0x00400e7c,
-        0x00400e80,
-        0x00400e84,
-        0x00400e88,
-        0x00400e8c,
-        0x00400ea0,
-        0x00400ea4,
-        0x00400ea8,
-        0x00400e90,
-        0x00400e94,
-        0x00400e98,
-        0x00400e9c,
-        NV10_PGRAPH_WINDOWCLIP_HORIZONTAL, /* 8 values from 0x400f00-0x400f1c */
-        NV10_PGRAPH_WINDOWCLIP_VERTICAL,   /* 8 values from 0x400f20-0x400f3c */
-        0x00400f04,
-        0x00400f24,
-        0x00400f08,
-        0x00400f28,
-        0x00400f0c,
-        0x00400f2c,
-        0x00400f10,
-        0x00400f30,
-        0x00400f14,
-        0x00400f34,
-        0x00400f18,
-        0x00400f38,
-        0x00400f1c,
-        0x00400f3c,
-        NV10_PGRAPH_XFMODE0,
-        NV10_PGRAPH_XFMODE1,
-        NV10_PGRAPH_GLOBALSTATE0,
-        NV10_PGRAPH_GLOBALSTATE1,
-        NV04_PGRAPH_STORED_FMT,
-        NV04_PGRAPH_SOURCE_COLOR,
-        NV03_PGRAPH_ABS_X_RAM,  /* 32 values from 0x400400 to 0x40047c */
-        NV03_PGRAPH_ABS_Y_RAM,  /* 32 values from 0x400480 to 0x4004fc */
-        0x00400404,
-        0x00400484,
-        0x00400408,
-        0x00400488,
-        0x0040040c,
-        0x0040048c,
-        0x00400410,
-        0x00400490,
-        0x00400414,
-        0x00400494,
-        0x00400418,
-        0x00400498,
-        0x0040041c,
-        0x0040049c,
-        0x00400420,
-        0x004004a0,
-        0x00400424,
-        0x004004a4,
-        0x00400428,
-        0x004004a8,
-        0x0040042c,
-        0x004004ac,
-        0x00400430,
-        0x004004b0,
-        0x00400434,
-        0x004004b4,
-        0x00400438,
-        0x004004b8,
-        0x0040043c,
-        0x004004bc,
-        0x00400440,
-        0x004004c0,
-        0x00400444,
-        0x004004c4,
-        0x00400448,
-        0x004004c8,
-        0x0040044c,
-        0x004004cc,
-        0x00400450,
-        0x004004d0,
-        0x00400454,
-        0x004004d4,
-        0x00400458,
-        0x004004d8,
-        0x0040045c,
-        0x004004dc,
-        0x00400460,
-        0x004004e0,
-        0x00400464,
-        0x004004e4,
-        0x00400468,
-        0x004004e8,
-        0x0040046c,
-        0x004004ec,
-        0x00400470,
-        0x004004f0,
-        0x00400474,
-        0x004004f4,
-        0x00400478,
-        0x004004f8,
-        0x0040047c,
-        0x004004fc,
-        NV03_PGRAPH_ABS_UCLIP_XMIN,
-        NV03_PGRAPH_ABS_UCLIP_XMAX,
-        NV03_PGRAPH_ABS_UCLIP_YMIN,
-        NV03_PGRAPH_ABS_UCLIP_YMAX,
-        0x00400550,
-        0x00400558,
-        0x00400554,
-        0x0040055c,
-        NV03_PGRAPH_ABS_UCLIPA_XMIN,
-        NV03_PGRAPH_ABS_UCLIPA_XMAX,
-        NV03_PGRAPH_ABS_UCLIPA_YMIN,
-        NV03_PGRAPH_ABS_UCLIPA_YMAX,
-        NV03_PGRAPH_ABS_ICLIP_XMAX,
-        NV03_PGRAPH_ABS_ICLIP_YMAX,
-        NV03_PGRAPH_XY_LOGIC_MISC0,
-        NV03_PGRAPH_XY_LOGIC_MISC1,
-        NV03_PGRAPH_XY_LOGIC_MISC2,
-        NV03_PGRAPH_XY_LOGIC_MISC3,
-        NV03_PGRAPH_CLIPX_0,
-        NV03_PGRAPH_CLIPX_1,
-        NV03_PGRAPH_CLIPY_0,
-        NV03_PGRAPH_CLIPY_1,
-        NV10_PGRAPH_COMBINER0_IN_ALPHA,
-        NV10_PGRAPH_COMBINER1_IN_ALPHA,
-        NV10_PGRAPH_COMBINER0_IN_RGB,
-        NV10_PGRAPH_COMBINER1_IN_RGB,
-        NV10_PGRAPH_COMBINER_COLOR0,
-        NV10_PGRAPH_COMBINER_COLOR1,
-        NV10_PGRAPH_COMBINER0_OUT_ALPHA,
-        NV10_PGRAPH_COMBINER1_OUT_ALPHA,
-        NV10_PGRAPH_COMBINER0_OUT_RGB,
-        NV10_PGRAPH_COMBINER1_OUT_RGB,
-        NV10_PGRAPH_COMBINER_FINAL0,
-        NV10_PGRAPH_COMBINER_FINAL1,
-        0x00400e00,
-        0x00400e04,
-        0x00400e08,
-        0x00400e0c,
-        0x00400e10,
-        0x00400e14,
-        0x00400e18,
-        0x00400e1c,
-        0x00400e20,
-        0x00400e24,
-        0x00400e28,
-        0x00400e2c,
-        0x00400e30,
-        0x00400e34,
-        0x00400e38,
-        0x00400e3c,
-        NV04_PGRAPH_PASSTHRU_0,
-        NV04_PGRAPH_PASSTHRU_1,
-        NV04_PGRAPH_PASSTHRU_2,
-        NV10_PGRAPH_DIMX_TEXTURE,
-        NV10_PGRAPH_WDIMX_TEXTURE,
-        NV10_PGRAPH_DVD_COLORFMT,
-        NV10_PGRAPH_SCALED_FORMAT,
-        NV04_PGRAPH_MISC24_0,
-        NV04_PGRAPH_MISC24_1,
-        NV04_PGRAPH_MISC24_2,
-        NV03_PGRAPH_X_MISC,
-        NV03_PGRAPH_Y_MISC,
-        NV04_PGRAPH_VALID1,
-        NV04_PGRAPH_VALID2,
-};
-
-static int nv17_graph_ctx_regs[] = {
-        NV10_PGRAPH_DEBUG_4,
-        0x004006b0,
-        0x00400eac,
-        0x00400eb0,
-        0x00400eb4,
-        0x00400eb8,
-        0x00400ebc,
-        0x00400ec0,
-        0x00400ec4,
-        0x00400ec8,
-        0x00400ecc,
-        0x00400ed0,
-        0x00400ed4,
-        0x00400ed8,
-        0x00400edc,
-        0x00400ee0,
-        0x00400a00,
-        0x00400a04,
-};
-
-struct graph_state {
-        int nv10[ARRAY_SIZE(nv10_graph_ctx_regs)];
-        int nv17[ARRAY_SIZE(nv17_graph_ctx_regs)];
-        struct pipe_state pipe_state;
-        uint32_t lma_window[4];
-};
-
-#define PIPE_SAVE(dev, state, addr)                                     \
-        do {                                                            \
-                int __i;                                                \
-                nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, addr);           \
-                for (__i = 0; __i < ARRAY_SIZE(state); __i++)           \
-                        state[__i] = nv_rd32(dev, NV10_PGRAPH_PIPE_DATA); \
-        } while (0)
-
-#define PIPE_RESTORE(dev, state, addr)                                  \
-        do {                                                            \
-                int __i;                                                \
-                nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, addr);           \
-                for (__i = 0; __i < ARRAY_SIZE(state); __i++)           \
-                        nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, state[__i]); \
-        } while (0)
-
-static void nv10_graph_save_pipe(struct nouveau_channel *chan)
-{
-        struct graph_state *pgraph_ctx = chan->engctx[NVOBJ_ENGINE_GR];
-        struct pipe_state *pipe = &pgraph_ctx->pipe_state;
-        struct drm_device *dev = chan->dev;
-
-        PIPE_SAVE(dev, pipe->pipe_0x4400, 0x4400);
-        PIPE_SAVE(dev, pipe->pipe_0x0200, 0x0200);
-        PIPE_SAVE(dev, pipe->pipe_0x6400, 0x6400);
-        PIPE_SAVE(dev, pipe->pipe_0x6800, 0x6800);
-        PIPE_SAVE(dev, pipe->pipe_0x6c00, 0x6c00);
-        PIPE_SAVE(dev, pipe->pipe_0x7000, 0x7000);
-        PIPE_SAVE(dev, pipe->pipe_0x7400, 0x7400);
-        PIPE_SAVE(dev, pipe->pipe_0x7800, 0x7800);
-        PIPE_SAVE(dev, pipe->pipe_0x0040, 0x0040);
-        PIPE_SAVE(dev, pipe->pipe_0x0000, 0x0000);
-}
-
-static void nv10_graph_load_pipe(struct nouveau_channel *chan)
-{
-        struct graph_state *pgraph_ctx = chan->engctx[NVOBJ_ENGINE_GR];
-        struct pipe_state *pipe = &pgraph_ctx->pipe_state;
-        struct drm_device *dev = chan->dev;
-        uint32_t xfmode0, xfmode1;
-        int i;
-
-        nouveau_wait_for_idle(dev);
-        /* XXX check haiku comments */
-        xfmode0 = nv_rd32(dev, NV10_PGRAPH_XFMODE0);
-        xfmode1 = nv_rd32(dev, NV10_PGRAPH_XFMODE1);
-        nv_wr32(dev, NV10_PGRAPH_XFMODE0, 0x10000000);
-        nv_wr32(dev, NV10_PGRAPH_XFMODE1, 0x00000000);
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x000064c0);
-        for (i = 0; i < 4; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
-        for (i = 0; i < 4; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000000);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x00006ab0);
-        for (i = 0; i < 3; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x00006a80);
-        for (i = 0; i < 3; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000000);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x00000040);
-        nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000008);
-
-
-        PIPE_RESTORE(dev, pipe->pipe_0x0200, 0x0200);
-        nouveau_wait_for_idle(dev);
-
-        /* restore XFMODE */
-        nv_wr32(dev, NV10_PGRAPH_XFMODE0, xfmode0);
-        nv_wr32(dev, NV10_PGRAPH_XFMODE1, xfmode1);
-        PIPE_RESTORE(dev, pipe->pipe_0x6400, 0x6400);
-        PIPE_RESTORE(dev, pipe->pipe_0x6800, 0x6800);
-        PIPE_RESTORE(dev, pipe->pipe_0x6c00, 0x6c00);
-        PIPE_RESTORE(dev, pipe->pipe_0x7000, 0x7000);
-        PIPE_RESTORE(dev, pipe->pipe_0x7400, 0x7400);
-        PIPE_RESTORE(dev, pipe->pipe_0x7800, 0x7800);
-        PIPE_RESTORE(dev, pipe->pipe_0x4400, 0x4400);
-        PIPE_RESTORE(dev, pipe->pipe_0x0000, 0x0000);
-        PIPE_RESTORE(dev, pipe->pipe_0x0040, 0x0040);
-        nouveau_wait_for_idle(dev);
-}
-
-static void nv10_graph_create_pipe(struct nouveau_channel *chan)
-{
-        struct graph_state *pgraph_ctx = chan->engctx[NVOBJ_ENGINE_GR];
-        struct pipe_state *fifo_pipe_state = &pgraph_ctx->pipe_state;
-        struct drm_device *dev = chan->dev;
-        uint32_t *fifo_pipe_state_addr;
-        int i;
-#define PIPE_INIT(addr) \
-        do { \
-                fifo_pipe_state_addr = fifo_pipe_state->pipe_##addr; \
-        } while (0)
-#define PIPE_INIT_END(addr) \
-        do { \
-                uint32_t *__end_addr = fifo_pipe_state->pipe_##addr + \
-                                ARRAY_SIZE(fifo_pipe_state->pipe_##addr); \
-                if (fifo_pipe_state_addr != __end_addr) \
-                        NV_ERROR(dev, "incomplete pipe init for 0x%x :  %p/%p\n", \
-                                addr, fifo_pipe_state_addr, __end_addr); \
-        } while (0)
-#define NV_WRITE_PIPE_INIT(value) *(fifo_pipe_state_addr++) = value
-
-        PIPE_INIT(0x0200);
-        for (i = 0; i < 48; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x0200);
-
-        PIPE_INIT(0x6400);
-        for (i = 0; i < 211; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        NV_WRITE_PIPE_INIT(0x40000000);
-        NV_WRITE_PIPE_INIT(0x40000000);
-        NV_WRITE_PIPE_INIT(0x40000000);
-        NV_WRITE_PIPE_INIT(0x40000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x3f000000);
-        NV_WRITE_PIPE_INIT(0x3f000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        PIPE_INIT_END(0x6400);
-
-        PIPE_INIT(0x6800);
-        for (i = 0; i < 162; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x3f800000);
-        for (i = 0; i < 25; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x6800);
-
-        PIPE_INIT(0x6c00);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0xbf800000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x6c00);
-
-        PIPE_INIT(0x7000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x00000000);
-        NV_WRITE_PIPE_INIT(0x7149f2ca);
-        for (i = 0; i < 35; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x7000);
-
-        PIPE_INIT(0x7400);
-        for (i = 0; i < 48; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x7400);
-
-        PIPE_INIT(0x7800);
-        for (i = 0; i < 48; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x7800);
-
-        PIPE_INIT(0x4400);
-        for (i = 0; i < 32; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x4400);
-
-        PIPE_INIT(0x0000);
-        for (i = 0; i < 16; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x0000);
-
-        PIPE_INIT(0x0040);
-        for (i = 0; i < 4; i++)
-                NV_WRITE_PIPE_INIT(0x00000000);
-        PIPE_INIT_END(0x0040);
-
-#undef PIPE_INIT
-#undef PIPE_INIT_END
-#undef NV_WRITE_PIPE_INIT
-}
-
-static int nv10_graph_ctx_regs_find_offset(struct drm_device *dev, int reg)
-{
-        int i;
-        for (i = 0; i < ARRAY_SIZE(nv10_graph_ctx_regs); i++) {
-                if (nv10_graph_ctx_regs[i] == reg)
-                        return i;
-        }
-        NV_ERROR(dev, "unknow offset nv10_ctx_regs %d\n", reg);
-        return -1;
-}
-
-static int nv17_graph_ctx_regs_find_offset(struct drm_device *dev, int reg)
-{
-        int i;
-        for (i = 0; i < ARRAY_SIZE(nv17_graph_ctx_regs); i++) {
-                if (nv17_graph_ctx_regs[i] == reg)
-                        return i;
-        }
-        NV_ERROR(dev, "unknow offset nv17_ctx_regs %d\n", reg);
-        return -1;
-}
-
-static void nv10_graph_load_dma_vtxbuf(struct nouveau_channel *chan,
-                                       uint32_t inst)
-{
-        struct drm_device *dev = chan->dev;
-        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);
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-
-        /* 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);
-}
-
-static int
-nv10_graph_load_context(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct graph_state *pgraph_ctx = chan->engctx[NVOBJ_ENGINE_GR];
-        uint32_t tmp;
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(nv10_graph_ctx_regs); i++)
-                nv_wr32(dev, nv10_graph_ctx_regs[i], pgraph_ctx->nv10[i]);
-        if (dev_priv->chipset >= 0x17) {
-                for (i = 0; i < ARRAY_SIZE(nv17_graph_ctx_regs); i++)
-                        nv_wr32(dev, nv17_graph_ctx_regs[i],
-                                                pgraph_ctx->nv17[i]);
-        }
-
-        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);
-        nv_wr32(dev, NV10_PGRAPH_CTX_USER, (tmp & 0xffffff) | chan->id << 24);
-        tmp = nv_rd32(dev, NV10_PGRAPH_FFINTFC_ST2);
-        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2, tmp & 0xcfffffff);
-        return 0;
-}
-
-static int
-nv10_graph_unload_context(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan;
-        struct graph_state *ctx;
-        uint32_t tmp;
-        int i;
-
-        chan = nv10_graph_channel(dev);
-        if (!chan)
-                return 0;
-        ctx = chan->engctx[NVOBJ_ENGINE_GR];
-
-        for (i = 0; i < ARRAY_SIZE(nv10_graph_ctx_regs); i++)
-                ctx->nv10[i] = nv_rd32(dev, nv10_graph_ctx_regs[i]);
-
-        if (dev_priv->chipset >= 0x17) {
-                for (i = 0; i < ARRAY_SIZE(nv17_graph_ctx_regs); i++)
-                        ctx->nv17[i] = nv_rd32(dev, nv17_graph_ctx_regs[i]);
-        }
-
-        nv10_graph_save_pipe(chan);
-
-        nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10000000);
-        tmp  = nv_rd32(dev, NV10_PGRAPH_CTX_USER) & 0x00ffffff;
-        tmp |= 31 << 24;
-        nv_wr32(dev, NV10_PGRAPH_CTX_USER, tmp);
-        return 0;
-}
-
-static void
-nv10_graph_context_switch(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = NULL;
-        int chid;
-
-        nouveau_wait_for_idle(dev);
-
-        /* If previous context is valid, we need to save it */
-        nv10_graph_unload_context(dev);
-
-        /* Load context for next channel */
-        chid = (nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR) >> 20) & 0x1f;
-        chan = dev_priv->channels.ptr[chid];
-        if (chan && chan->engctx[NVOBJ_ENGINE_GR])
-                nv10_graph_load_context(chan);
-}
-
-#define NV_WRITE_CTX(reg, val) do { \
-        int offset = nv10_graph_ctx_regs_find_offset(dev, reg); \
-        if (offset > 0) \
-                pgraph_ctx->nv10[offset] = val; \
-        } while (0)
-
-#define NV17_WRITE_CTX(reg, val) do { \
-        int offset = nv17_graph_ctx_regs_find_offset(dev, reg); \
-        if (offset > 0) \
-                pgraph_ctx->nv17[offset] = val; \
-        } while (0)
-
-struct nouveau_channel *
-nv10_graph_channel(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chid = 31;
-
-        if (nv_rd32(dev, NV10_PGRAPH_CTX_CONTROL) & 0x00010000)
-                chid = nv_rd32(dev, NV10_PGRAPH_CTX_USER) >> 24;
-
-        if (chid >= 31)
-                return NULL;
-
-        return dev_priv->channels.ptr[chid];
-}
-
-static int
-nv10_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct graph_state *pgraph_ctx;
-
-        NV_DEBUG(dev, "nv10_graph_context_create %d\n", chan->id);
-
-        pgraph_ctx = kzalloc(sizeof(*pgraph_ctx), GFP_KERNEL);
-        if (pgraph_ctx == NULL)
-                return -ENOMEM;
-        chan->engctx[engine] = pgraph_ctx;
-
-        NV_WRITE_CTX(0x00400e88, 0x08000000);
-        NV_WRITE_CTX(0x00400e9c, 0x4b7fffff);
-        NV_WRITE_CTX(NV03_PGRAPH_XY_LOGIC_MISC0, 0x0001ffff);
-        NV_WRITE_CTX(0x00400e10, 0x00001000);
-        NV_WRITE_CTX(0x00400e14, 0x00001000);
-        NV_WRITE_CTX(0x00400e30, 0x00080008);
-        NV_WRITE_CTX(0x00400e34, 0x00080008);
-        if (dev_priv->chipset >= 0x17) {
-                /* is it really needed ??? */
-                NV17_WRITE_CTX(NV10_PGRAPH_DEBUG_4,
-                                        nv_rd32(dev, NV10_PGRAPH_DEBUG_4));
-                NV17_WRITE_CTX(0x004006b0, nv_rd32(dev, 0x004006b0));
-                NV17_WRITE_CTX(0x00400eac, 0x0fff0000);
-                NV17_WRITE_CTX(0x00400eb0, 0x0fff0000);
-                NV17_WRITE_CTX(0x00400ec0, 0x00000080);
-                NV17_WRITE_CTX(0x00400ed0, 0x00000080);
-        }
-        NV_WRITE_CTX(NV10_PGRAPH_CTX_USER, chan->id << 24);
-
-        nv10_graph_create_pipe(chan);
-        return 0;
-}
-
-static void
-nv10_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct graph_state *pgraph_ctx = chan->engctx[engine];
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-
-        /* Unload the context if it's the currently active one */
-        if (nv10_graph_channel(dev) == chan)
-                nv10_graph_unload_context(dev);
-
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* Free the context resources */
-        chan->engctx[engine] = NULL;
-        kfree(pgraph_ctx);
-}
-
-static void
-nv10_graph_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        nv_wr32(dev, NV10_PGRAPH_TLIMIT(i), tile->limit);
-        nv_wr32(dev, NV10_PGRAPH_TSIZE(i), tile->pitch);
-        nv_wr32(dev, NV10_PGRAPH_TILE(i), tile->addr);
-}
-
-static int
-nv10_graph_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 tmp;
-        int i;
-
-        nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) &
-                        ~NV_PMC_ENABLE_PGRAPH);
-        nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) |
-                         NV_PMC_ENABLE_PGRAPH);
-
-        nv_wr32(dev, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
-
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x00000000);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_1, 0x00118700);
-        /* nv_wr32(dev, NV04_PGRAPH_DEBUG_2, 0x24E00810); */ /* 0x25f92ad9 */
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_2, 0x25f92ad9);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_3, 0x55DE0830 |
-                                      (1<<29) |
-                                      (1<<31));
-        if (dev_priv->chipset >= 0x17) {
-                nv_wr32(dev, NV10_PGRAPH_DEBUG_4, 0x1f000000);
-                nv_wr32(dev, 0x400a10, 0x3ff3fb6);
-                nv_wr32(dev, 0x400838, 0x2f8684);
-                nv_wr32(dev, 0x40083c, 0x115f3f);
-                nv_wr32(dev, 0x004006b0, 0x40000020);
-        } else
-                nv_wr32(dev, NV10_PGRAPH_DEBUG_4, 0x00000000);
-
-        /* Turn all the tiling regions off. */
-        for (i = 0; i < NV10_PFB_TILE__SIZE; i++)
-                nv10_graph_set_tile_region(dev, i);
-
-        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 |= 31 << 24;
-        nv_wr32(dev, NV10_PGRAPH_CTX_USER, tmp);
-        nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10000100);
-        nv_wr32(dev, NV10_PGRAPH_FFINTFC_ST2, 0x08000000);
-
-        return 0;
-}
-
-static int
-nv10_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-        if (!nv_wait(dev, NV04_PGRAPH_STATUS, ~0, 0) && suspend) {
-                nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-                return -EBUSY;
-        }
-        nv10_graph_unload_context(dev);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0x00000000);
-        return 0;
-}
-
-static int
-nv17_graph_mthd_lma_window(struct nouveau_channel *chan,
-                           u32 class, u32 mthd, u32 data)
-{
-        struct graph_state *ctx = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        struct pipe_state *pipe = &ctx->pipe_state;
-        uint32_t pipe_0x0040[1], pipe_0x64c0[8], pipe_0x6a80[3], pipe_0x6ab0[3];
-        uint32_t xfmode0, xfmode1;
-        int i;
-
-        ctx->lma_window[(mthd - 0x1638) / 4] = data;
-
-        if (mthd != 0x1644)
-                return 0;
-
-        nouveau_wait_for_idle(dev);
-
-        PIPE_SAVE(dev, pipe_0x0040, 0x0040);
-        PIPE_SAVE(dev, pipe->pipe_0x0200, 0x0200);
-
-        PIPE_RESTORE(dev, ctx->lma_window, 0x6790);
-
-        nouveau_wait_for_idle(dev);
-
-        xfmode0 = nv_rd32(dev, NV10_PGRAPH_XFMODE0);
-        xfmode1 = nv_rd32(dev, NV10_PGRAPH_XFMODE1);
-
-        PIPE_SAVE(dev, pipe->pipe_0x4400, 0x4400);
-        PIPE_SAVE(dev, pipe_0x64c0, 0x64c0);
-        PIPE_SAVE(dev, pipe_0x6ab0, 0x6ab0);
-        PIPE_SAVE(dev, pipe_0x6a80, 0x6a80);
-
-        nouveau_wait_for_idle(dev);
-
-        nv_wr32(dev, NV10_PGRAPH_XFMODE0, 0x10000000);
-        nv_wr32(dev, NV10_PGRAPH_XFMODE1, 0x00000000);
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x000064c0);
-        for (i = 0; i < 4; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
-        for (i = 0; i < 4; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000000);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x00006ab0);
-        for (i = 0; i < 3; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x3f800000);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x00006a80);
-        for (i = 0; i < 3; i++)
-                nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000000);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x00000040);
-        nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000008);
-
-        PIPE_RESTORE(dev, pipe->pipe_0x0200, 0x0200);
-
-        nouveau_wait_for_idle(dev);
-
-        PIPE_RESTORE(dev, pipe_0x0040, 0x0040);
-
-        nv_wr32(dev, NV10_PGRAPH_XFMODE0, xfmode0);
-        nv_wr32(dev, NV10_PGRAPH_XFMODE1, xfmode1);
-
-        PIPE_RESTORE(dev, pipe_0x64c0, 0x64c0);
-        PIPE_RESTORE(dev, pipe_0x6ab0, 0x6ab0);
-        PIPE_RESTORE(dev, pipe_0x6a80, 0x6a80);
-        PIPE_RESTORE(dev, pipe->pipe_0x4400, 0x4400);
-
-        nv_wr32(dev, NV10_PGRAPH_PIPE_ADDRESS, 0x000000c0);
-        nv_wr32(dev, NV10_PGRAPH_PIPE_DATA, 0x00000000);
-
-        nouveau_wait_for_idle(dev);
-
-        return 0;
-}
-
-static int
-nv17_graph_mthd_lma_enable(struct nouveau_channel *chan,
-                           u32 class, u32 mthd, u32 data)
-{
-        struct drm_device *dev = chan->dev;
-
-        nouveau_wait_for_idle(dev);
-
-        nv_wr32(dev, NV10_PGRAPH_DEBUG_4,
-                nv_rd32(dev, NV10_PGRAPH_DEBUG_4) | 0x1 << 8);
-        nv_wr32(dev, 0x004006b0,
-                nv_rd32(dev, 0x004006b0) | 0x8 << 24);
-
-        return 0;
-}
-
-struct nouveau_bitfield nv10_graph_intr[] = {
-        { NV_PGRAPH_INTR_NOTIFY, "NOTIFY" },
-        { NV_PGRAPH_INTR_ERROR,  "ERROR"  },
-        {}
-};
-
-struct nouveau_bitfield nv10_graph_nstatus[] = {
-        { NV10_PGRAPH_NSTATUS_STATE_IN_USE,       "STATE_IN_USE" },
-        { NV10_PGRAPH_NSTATUS_INVALID_STATE,      "INVALID_STATE" },
-        { NV10_PGRAPH_NSTATUS_BAD_ARGUMENT,       "BAD_ARGUMENT" },
-        { NV10_PGRAPH_NSTATUS_PROTECTION_FAULT,   "PROTECTION_FAULT" },
-        {}
-};
-
-static void
-nv10_graph_isr(struct drm_device *dev)
-{
-        u32 stat;
-
-        while ((stat = nv_rd32(dev, NV03_PGRAPH_INTR))) {
-                u32 nsource = nv_rd32(dev, NV03_PGRAPH_NSOURCE);
-                u32 nstatus = nv_rd32(dev, NV03_PGRAPH_NSTATUS);
-                u32 addr = nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR);
-                u32 chid = (addr & 0x01f00000) >> 20;
-                u32 subc = (addr & 0x00070000) >> 16;
-                u32 mthd = (addr & 0x00001ffc);
-                u32 data = nv_rd32(dev, NV04_PGRAPH_TRAPPED_DATA);
-                u32 class = nv_rd32(dev, 0x400160 + subc * 4) & 0xfff;
-                u32 show = stat;
-
-                if (stat & NV_PGRAPH_INTR_ERROR) {
-                        if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
-                                if (!nouveau_gpuobj_mthd_call2(dev, chid, class, mthd, data))
-                                        show &= ~NV_PGRAPH_INTR_ERROR;
-                        }
-                }
-
-                if (stat & NV_PGRAPH_INTR_CONTEXT_SWITCH) {
-                        nv_wr32(dev, NV03_PGRAPH_INTR, NV_PGRAPH_INTR_CONTEXT_SWITCH);
-                        stat &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
-                        show &= ~NV_PGRAPH_INTR_CONTEXT_SWITCH;
-                        nv10_graph_context_switch(dev);
-                }
-
-                nv_wr32(dev, NV03_PGRAPH_INTR, stat);
-                nv_wr32(dev, NV04_PGRAPH_FIFO, 0x00000001);
-
-                if (show && nouveau_ratelimit()) {
-                        NV_INFO(dev, "PGRAPH -");
-                        nouveau_bitfield_print(nv10_graph_intr, show);
-                        printk(" nsource:");
-                        nouveau_bitfield_print(nv04_graph_nsource, nsource);
-                        printk(" nstatus:");
-                        nouveau_bitfield_print(nv10_graph_nstatus, nstatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - ch %d/%d class 0x%04x "
-                                     "mthd 0x%04x data 0x%08x\n",
-                                chid, subc, class, mthd, data);
-                }
-        }
-}
-
-static void
-nv10_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nv10_graph_engine *pgraph = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 12);
-        kfree(pgraph);
-}
-
-int
-nv10_graph_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv10_graph_engine *pgraph;
-
-        pgraph = kzalloc(sizeof(*pgraph), GFP_KERNEL);
-        if (!pgraph)
-                return -ENOMEM;
-
-        pgraph->base.destroy = nv10_graph_destroy;
-        pgraph->base.init = nv10_graph_init;
-        pgraph->base.fini = nv10_graph_fini;
-        pgraph->base.context_new = nv10_graph_context_new;
-        pgraph->base.context_del = nv10_graph_context_del;
-        pgraph->base.object_new = nv04_graph_object_new;
-        pgraph->base.set_tile_region = nv10_graph_set_tile_region;
-
-        NVOBJ_ENGINE_ADD(dev, GR, &pgraph->base);
-        nouveau_irq_register(dev, 12, nv10_graph_isr);
-
-        NVOBJ_CLASS(dev, 0x0030, GR); /* null */
-        NVOBJ_CLASS(dev, 0x0039, GR); /* m2mf */
-        NVOBJ_CLASS(dev, 0x004a, GR); /* gdirect */
-        NVOBJ_CLASS(dev, 0x005f, GR); /* imageblit */
-        NVOBJ_CLASS(dev, 0x009f, GR); /* imageblit (nv12) */
-        NVOBJ_CLASS(dev, 0x008a, GR); /* ifc */
-        NVOBJ_CLASS(dev, 0x0089, GR); /* sifm */
-        NVOBJ_CLASS(dev, 0x0062, GR); /* surf2d */
-        NVOBJ_CLASS(dev, 0x0043, GR); /* rop */
-        NVOBJ_CLASS(dev, 0x0012, GR); /* beta1 */
-        NVOBJ_CLASS(dev, 0x0072, GR); /* beta4 */
-        NVOBJ_CLASS(dev, 0x0019, GR); /* cliprect */
-        NVOBJ_CLASS(dev, 0x0044, GR); /* pattern */
-        NVOBJ_CLASS(dev, 0x0052, GR); /* swzsurf */
-        NVOBJ_CLASS(dev, 0x0093, GR); /* surf3d */
-        NVOBJ_CLASS(dev, 0x0094, GR); /* tex_tri */
-        NVOBJ_CLASS(dev, 0x0095, GR); /* multitex_tri */
-
-        /* celcius */
-        if (dev_priv->chipset <= 0x10) {
-                NVOBJ_CLASS(dev, 0x0056, GR);
-        } else
-        if (dev_priv->chipset < 0x17 || dev_priv->chipset == 0x1a) {
-                NVOBJ_CLASS(dev, 0x0096, GR);
-        } else {
-                NVOBJ_CLASS(dev, 0x0099, GR);
-                NVOBJ_MTHD (dev, 0x0099, 0x1638, nv17_graph_mthd_lma_window);
-                NVOBJ_MTHD (dev, 0x0099, 0x163c, nv17_graph_mthd_lma_window);
-                NVOBJ_MTHD (dev, 0x0099, 0x1640, nv17_graph_mthd_lma_window);
-                NVOBJ_MTHD (dev, 0x0099, 0x1644, nv17_graph_mthd_lma_window);
-                NVOBJ_MTHD (dev, 0x0099, 0x1658, nv17_graph_mthd_lma_enable);
-        }
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv17_fifo.c b/drivers/gpu/drm/nouveau/nv17_fifo.c
deleted file mode 100644
index d9e482e4abee..000000000000
--- a/drivers/gpu/drm/nouveau/nv17_fifo.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (C) 2012 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_util.h"
-#include "nouveau_ramht.h"
-
-static struct ramfc_desc {
-        unsigned bits:6;
-        unsigned ctxs:5;
-        unsigned ctxp:8;
-        unsigned regs:5;
-        unsigned regp;
-} nv17_ramfc[] = {
-        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
-        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
-        { 32,  0, 0x08,  0, NV10_PFIFO_CACHE1_REF_CNT },
-        { 16,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
-        { 16, 16, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
-        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_STATE },
-        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
-        { 32,  0, 0x18,  0, NV04_PFIFO_CACHE1_ENGINE },
-        { 32,  0, 0x1c,  0, NV04_PFIFO_CACHE1_PULL1 },
-        { 32,  0, 0x20,  0, NV10_PFIFO_CACHE1_ACQUIRE_VALUE },
-        { 32,  0, 0x24,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMESTAMP },
-        { 32,  0, 0x28,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMEOUT },
-        { 32,  0, 0x2c,  0, NV10_PFIFO_CACHE1_SEMAPHORE },
-        { 32,  0, 0x30,  0, NV10_PFIFO_CACHE1_DMA_SUBROUTINE },
-        {}
-};
-
-struct nv17_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct ramfc_desc *ramfc_desc;
-};
-
-struct nv17_fifo_chan {
-        struct nouveau_fifo_chan base;
-        struct nouveau_gpuobj *ramfc;
-};
-
-static int
-nv17_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv17_fifo_priv *priv = nv_engine(dev, engine);
-        struct nv17_fifo_chan *fctx;
-        unsigned long flags;
-        int ret;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-
-        /* map channel control registers */
-        chan->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                             NV03_USER(chan->id), PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        /* initialise default fifo context */
-        ret = nouveau_gpuobj_new_fake(dev, dev_priv->ramfc->pinst +
-                                      chan->id * 64, ~0, 64,
-                                      NVOBJ_FLAG_ZERO_ALLOC |
-                                      NVOBJ_FLAG_ZERO_FREE, &fctx->ramfc);
-        if (ret)
-                goto error;
-
-        nv_wo32(fctx->ramfc, 0x00, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x04, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x0c, chan->pushbuf->pinst >> 4);
-        nv_wo32(fctx->ramfc, 0x14, NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
-                                   NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
-#ifdef __BIG_ENDIAN
-                                   NV_PFIFO_CACHE1_BIG_ENDIAN |
-#endif
-                                   NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
-
-        /* enable dma mode on the channel */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PFIFO_MODE, (1 << chan->id), (1 << chan->id));
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static int
-nv17_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv17_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-
-        nv_mask(dev, NV03_PMC_ENABLE, NV_PMC_ENABLE_PFIFO, 0);
-        nv_mask(dev, NV03_PMC_ENABLE, NV_PMC_ENABLE_PFIFO, NV_PMC_ENABLE_PFIFO);
-
-        nv_wr32(dev, NV04_PFIFO_DELAY_0, 0x000000ff);
-        nv_wr32(dev, NV04_PFIFO_DMA_TIMESLICE, 0x0101ffff);
-
-        nv_wr32(dev, NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ |
-                                       ((dev_priv->ramht->bits - 9) << 16) |
-                                       (dev_priv->ramht->gpuobj->pinst >> 8));
-        nv_wr32(dev, NV03_PFIFO_RAMRO, dev_priv->ramro->pinst >> 8);
-        nv_wr32(dev, NV03_PFIFO_RAMFC, 0x00010000 |
-                                       dev_priv->ramfc->pinst >> 8);
-
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH1, priv->base.channels);
-
-        nv_wr32(dev, NV03_PFIFO_INTR_0, 0xffffffff);
-        nv_wr32(dev, NV03_PFIFO_INTR_EN_0, 0xffffffff);
-
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0, 1);
-        nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 1);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 1);
-
-        for (i = 0; i < priv->base.channels; i++) {
-                if (dev_priv->channels.ptr[i])
-                        nv_mask(dev, NV04_PFIFO_MODE, (1 << i), (1 << i));
-        }
-
-        return 0;
-}
-
-int
-nv17_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv17_fifo_priv *priv;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nv04_fifo_destroy;
-        priv->base.base.init = nv17_fifo_init;
-        priv->base.base.fini = nv04_fifo_fini;
-        priv->base.base.context_new = nv17_fifo_context_new;
-        priv->base.base.context_del = nv04_fifo_context_del;
-        priv->base.channels = 31;
-        priv->ramfc_desc = nv17_ramfc;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        nouveau_irq_register(dev, 8, nv04_fifo_isr);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv17_tv.c b/drivers/gpu/drm/nouveau/nv17_tv.c
index 67be5db021f5..dd85f0f79acf 100644
--- a/drivers/gpu/drm/nouveau/nv17_tv.c
+++ b/drivers/gpu/drm/nouveau/nv17_tv.c
@@ -26,18 +26,32 @@
 
 #include "drmP.h"
 #include "drm_crtc_helper.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_reg.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
-#include "nouveau_gpio.h"
 #include "nouveau_hw.h"
 #include "nv17_tv.h"
 
+#include <core/device.h>
+
+#include <subdev/bios/gpio.h>
+#include <subdev/gpio.h>
+
+MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
+                 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, NTSC-M, NTSC-J,\n"
+                 "\t\t\thd480i, hd480p, hd576i, hd576p, hd720p, hd1080i.\n"
+                 "\t\tDefault: PAL\n"
+                 "\t\t*NOTE* Ignored for cards with external TV encoders.");
+static char *nouveau_tv_norm;
+module_param_named(tv_norm, nouveau_tv_norm, charp, 0400);
+
 static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
         uint32_t testval, regoffset = nv04_dac_output_offset(encoder);
         uint32_t gpio0, gpio1, fp_htotal, fp_hsync_start, fp_hsync_end,
                 fp_control, test_ctrl, dacclk, ctv_14, ctv_1c, ctv_6c;
@@ -46,15 +60,15 @@ static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
 
 #define RGB_TEST_DATA(r, g, b) (r << 0 | g << 10 | b << 20)
         testval = RGB_TEST_DATA(0x82, 0xeb, 0x82);
-        if (dev_priv->vbios.tvdactestval)
-                testval = dev_priv->vbios.tvdactestval;
+        if (drm->vbios.tvdactestval)
+                testval = drm->vbios.tvdactestval;
 
         dacclk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_DACCLK + regoffset);
         head = (dacclk & 0x100) >> 8;
 
         /* Save the previous state. */
-        gpio1 = nouveau_gpio_func_get(dev, DCB_GPIO_TVDAC1);
-        gpio0 = nouveau_gpio_func_get(dev, DCB_GPIO_TVDAC0);
+        gpio1 = gpio->get(gpio, 0, DCB_GPIO_TVDAC1, 0xff);
+        gpio0 = gpio->get(gpio, 0, DCB_GPIO_TVDAC0, 0xff);
         fp_htotal = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_HTOTAL);
         fp_hsync_start = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_START);
         fp_hsync_end = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_END);
@@ -65,8 +79,8 @@ static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
         ctv_6c = NVReadRAMDAC(dev, head, 0x680c6c);
 
         /* Prepare the DAC for load detection.  */
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC1, true);
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC0, true);
+        gpio->set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, true);
+        gpio->set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, true);
 
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HTOTAL, 1343);
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_START, 1047);
@@ -111,8 +125,8 @@ static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_END, fp_hsync_end);
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_START, fp_hsync_start);
         NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HTOTAL, fp_htotal);
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC1, gpio1);
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC0, gpio0);
+        gpio->set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, gpio1);
+        gpio->set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, gpio0);
 
         return sample;
 }
@@ -120,15 +134,18 @@ static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
 static bool
 get_tv_detect_quirks(struct drm_device *dev, uint32_t *pin_mask)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_object *device = drm->device;
+
         /* Zotac FX5200 */
-        if (nv_match_device(dev, 0x0322, 0x19da, 0x1035) ||
-            nv_match_device(dev, 0x0322, 0x19da, 0x2035)) {
+        if (nv_device_match(device, 0x0322, 0x19da, 0x1035) ||
+            nv_device_match(device, 0x0322, 0x19da, 0x2035)) {
                 *pin_mask = 0xc;
                 return false;
         }
 
         /* MSI nForce2 IGP */
-        if (nv_match_device(dev, 0x01f0, 0x1462, 0x5710)) {
+        if (nv_device_match(device, 0x01f0, 0x1462, 0x5710)) {
                 *pin_mask = 0xc;
                 return false;
         }
@@ -140,18 +157,18 @@ static enum drm_connector_status
 nv17_tv_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_mode_config *conf = &dev->mode_config;
         struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
-        struct dcb_entry *dcb = tv_enc->base.dcb;
+        struct dcb_output *dcb = tv_enc->base.dcb;
         bool reliable = get_tv_detect_quirks(dev, &tv_enc->pin_mask);
 
         if (nv04_dac_in_use(encoder))
                 return connector_status_disconnected;
 
         if (reliable) {
-                if (dev_priv->chipset == 0x42 ||
-                    dev_priv->chipset == 0x43)
+                if (nv_device(drm->device)->chipset == 0x42 ||
+                    nv_device(drm->device)->chipset == 0x43)
                         tv_enc->pin_mask =
                                 nv42_tv_sample_load(encoder) >> 28 & 0xe;
                 else
@@ -185,7 +202,7 @@ nv17_tv_detect(struct drm_encoder *encoder, struct drm_connector *connector)
         if (!reliable) {
                 return connector_status_unknown;
         } else if (tv_enc->subconnector) {
-                NV_INFO(dev, "Load detected on output %c\n",
+                NV_INFO(drm, "Load detected on output %c\n",
                         '@' + ffs(dcb->or));
                 return connector_status_connected;
         } else {
@@ -357,6 +374,8 @@ static bool nv17_tv_mode_fixup(struct drm_encoder *encoder,
 static void  nv17_tv_dpms(struct drm_encoder *encoder, int mode)
 {
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
         struct nv17_tv_state *regs = &to_tv_enc(encoder)->state;
         struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
 
@@ -364,7 +383,7 @@ static void  nv17_tv_dpms(struct drm_encoder *encoder, int mode)
                 return;
         nouveau_encoder(encoder)->last_dpms = mode;
 
-        NV_INFO(dev, "Setting dpms mode %d on TV encoder (output %d)\n",
+        NV_INFO(drm, "Setting dpms mode %d on TV encoder (output %d)\n",
                  mode, nouveau_encoder(encoder)->dcb->index);
 
         regs->ptv_200 &= ~1;
@@ -381,8 +400,8 @@ static void  nv17_tv_dpms(struct drm_encoder *encoder, int mode)
 
         nv_load_ptv(dev, regs, 200);
 
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC1, mode == DRM_MODE_DPMS_ON);
-        nouveau_gpio_func_set(dev, DCB_GPIO_TVDAC0, mode == DRM_MODE_DPMS_ON);
+        gpio->set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, mode == DRM_MODE_DPMS_ON);
+        gpio->set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, mode == DRM_MODE_DPMS_ON);
 
         nv04_dac_update_dacclk(encoder, mode == DRM_MODE_DPMS_ON);
 }
@@ -390,11 +409,11 @@ static void  nv17_tv_dpms(struct drm_encoder *encoder, int mode)
 static void nv17_tv_prepare(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_encoder_helper_funcs *helper = encoder->helper_private;
         struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
         int head = nouveau_crtc(encoder->crtc)->index;
-        uint8_t *cr_lcd = &dev_priv->mode_reg.crtc_reg[head].CRTC[
+        uint8_t *cr_lcd = &nv04_display(dev)->mode_reg.crtc_reg[head].CRTC[
                                                         NV_CIO_CRE_LCD__INDEX];
         uint32_t dacclk_off = NV_PRAMDAC_DACCLK +
                                         nv04_dac_output_offset(encoder);
@@ -410,14 +429,14 @@ static void nv17_tv_prepare(struct drm_encoder *encoder)
                 struct drm_encoder *enc;
 
                 list_for_each_entry(enc, &dev->mode_config.encoder_list, head) {
-                        struct dcb_entry *dcb = nouveau_encoder(enc)->dcb;
+                        struct dcb_output *dcb = nouveau_encoder(enc)->dcb;
 
-                        if ((dcb->type == OUTPUT_TMDS ||
-                             dcb->type == OUTPUT_LVDS) &&
+                        if ((dcb->type == DCB_OUTPUT_TMDS ||
+                             dcb->type == DCB_OUTPUT_LVDS) &&
                              !enc->crtc &&
                              nv04_dfp_get_bound_head(dev, dcb) == head) {
                                 nv04_dfp_bind_head(dev, dcb, head ^ 1,
-                                                dev_priv->vbios.fp.dual_link);
+                                                drm->vbios.fp.dual_link);
                         }
                 }
 
@@ -429,7 +448,7 @@ static void nv17_tv_prepare(struct drm_encoder *encoder)
         /* Set the DACCLK register */
         dacclk = (NVReadRAMDAC(dev, 0, dacclk_off) & ~0x30) | 0x1;
 
-        if (dev_priv->card_type == NV_40)
+        if (nv_device(drm->device)->card_type == NV_40)
                 dacclk |= 0x1a << 16;
 
         if (tv_norm->kind == CTV_ENC_MODE) {
@@ -453,9 +472,9 @@ static void nv17_tv_mode_set(struct drm_encoder *encoder,
                              struct drm_display_mode *adjusted_mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int head = nouveau_crtc(encoder->crtc)->index;
-        struct nv04_crtc_reg *regs = &dev_priv->mode_reg.crtc_reg[head];
+        struct nv04_crtc_reg *regs = &nv04_display(dev)->mode_reg.crtc_reg[head];
         struct nv17_tv_state *tv_regs = &to_tv_enc(encoder)->state;
         struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
         int i;
@@ -486,7 +505,7 @@ static void nv17_tv_mode_set(struct drm_encoder *encoder,
                         tv_regs->ptv_614 = 0x13;
                 }
 
-                if (dev_priv->card_type >= NV_30) {
+                if (nv_device(drm->device)->card_type >= NV_30) {
                         tv_regs->ptv_500 = 0xe8e0;
                         tv_regs->ptv_504 = 0x1710;
                         tv_regs->ptv_604 = 0x0;
@@ -566,7 +585,7 @@ static void nv17_tv_mode_set(struct drm_encoder *encoder,
 static void nv17_tv_commit(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_encoder_helper_funcs *helper = encoder->helper_private;
@@ -581,7 +600,7 @@ static void nv17_tv_commit(struct drm_encoder *encoder)
         nv17_tv_state_load(dev, &to_tv_enc(encoder)->state);
 
         /* This could use refinement for flatpanels, but it should work */
-        if (dev_priv->chipset < 0x44)
+        if (nv_device(drm->device)->chipset < 0x44)
                 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL +
                                         nv04_dac_output_offset(encoder),
                                         0xf0000000);
@@ -592,7 +611,7 @@ static void nv17_tv_commit(struct drm_encoder *encoder)
 
         helper->dpms(encoder, DRM_MODE_DPMS_ON);
 
-        NV_INFO(dev, "Output %s is running on CRTC %d using output %c\n",
+        NV_INFO(drm, "Output %s is running on CRTC %d using output %c\n",
                 drm_get_connector_name(
                         &nouveau_encoder_connector_get(nv_encoder)->base),
                 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
@@ -630,9 +649,10 @@ static int nv17_tv_create_resources(struct drm_encoder *encoder,
                                     struct drm_connector *connector)
 {
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_mode_config *conf = &dev->mode_config;
         struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
-        struct dcb_entry *dcb = nouveau_encoder(encoder)->dcb;
+        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
         int num_tv_norms = dcb->tvconf.has_component_output ? NUM_TV_NORMS :
                                                         NUM_LD_TV_NORMS;
         int i;
@@ -646,7 +666,7 @@ static int nv17_tv_create_resources(struct drm_encoder *encoder,
                 }
 
                 if (i == num_tv_norms)
-                        NV_WARN(dev, "Invalid TV norm setting \"%s\"\n",
+                        NV_WARN(drm, "Invalid TV norm setting \"%s\"\n",
                                 nouveau_tv_norm);
         }
 
@@ -759,8 +779,6 @@ static void nv17_tv_destroy(struct drm_encoder *encoder)
 {
         struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
 
-        NV_DEBUG_KMS(encoder->dev, "\n");
-
         drm_encoder_cleanup(encoder);
         kfree(tv_enc);
 }
@@ -788,7 +806,7 @@ static struct drm_encoder_funcs nv17_tv_funcs = {
 };
 
 int
-nv17_tv_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv17_tv_create(struct drm_connector *connector, struct dcb_output *entry)
 {
         struct drm_device *dev = connector->dev;
         struct drm_encoder *encoder;
diff --git a/drivers/gpu/drm/nouveau/nv17_tv.h b/drivers/gpu/drm/nouveau/nv17_tv.h
index 622e72221682..7b331543a41b 100644
--- a/drivers/gpu/drm/nouveau/nv17_tv.h
+++ b/drivers/gpu/drm/nouveau/nv17_tv.h
@@ -130,12 +130,14 @@ void nv17_ctv_update_rescaler(struct drm_encoder *encoder);
 static inline void nv_write_ptv(struct drm_device *dev, uint32_t reg,
                                 uint32_t val)
 {
-        nv_wr32(dev, reg, val);
+        struct nouveau_device *device = nouveau_dev(dev);
+        nv_wr32(device, reg, val);
 }
 
 static inline uint32_t nv_read_ptv(struct drm_device *dev, uint32_t reg)
 {
-        return nv_rd32(dev, reg);
+        struct nouveau_device *device = nouveau_dev(dev);
+        return nv_rd32(device, reg);
 }
 
 static inline void nv_write_tv_enc(struct drm_device *dev, uint8_t reg,
diff --git a/drivers/gpu/drm/nouveau/nv17_tv_modes.c b/drivers/gpu/drm/nouveau/nv17_tv_modes.c
index 4d1d29f60307..a4c4b0c2c7ce 100644
--- a/drivers/gpu/drm/nouveau/nv17_tv_modes.c
+++ b/drivers/gpu/drm/nouveau/nv17_tv_modes.c
@@ -26,7 +26,7 @@
 
 #include "drmP.h"
 #include "drm_crtc_helper.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
 #include "nouveau_hw.h"
@@ -543,10 +543,9 @@ void nv17_tv_update_rescaler(struct drm_encoder *encoder)
 void nv17_ctv_update_rescaler(struct drm_encoder *encoder)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
         int head = nouveau_crtc(encoder->crtc)->index;
-        struct nv04_crtc_reg *regs = &dev_priv->mode_reg.crtc_reg[head];
+        struct nv04_crtc_reg *regs = &nv04_display(dev)->mode_reg.crtc_reg[head];
         struct drm_display_mode *crtc_mode = &encoder->crtc->mode;
         struct drm_display_mode *output_mode =
                 &get_tv_norm(encoder)->ctv_enc_mode.mode;
diff --git a/drivers/gpu/drm/nouveau/nv20_fb.c b/drivers/gpu/drm/nouveau/nv20_fb.c
deleted file mode 100644
index 19bd64059a66..000000000000
--- a/drivers/gpu/drm/nouveau/nv20_fb.c
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-static struct drm_mm_node *
-nv20_fb_alloc_tag(struct drm_device *dev, uint32_t size)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        struct drm_mm_node *mem;
-        int ret;
-
-        ret = drm_mm_pre_get(&pfb->tag_heap);
-        if (ret)
-                return NULL;
-
-        spin_lock(&dev_priv->tile.lock);
-        mem = drm_mm_search_free(&pfb->tag_heap, size, 0, 0);
-        if (mem)
-                mem = drm_mm_get_block_atomic(mem, size, 0);
-        spin_unlock(&dev_priv->tile.lock);
-
-        return mem;
-}
-
-static void
-nv20_fb_free_tag(struct drm_device *dev, struct drm_mm_node **pmem)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct drm_mm_node *mem = *pmem;
-        if (mem) {
-                spin_lock(&dev_priv->tile.lock);
-                drm_mm_put_block(mem);
-                spin_unlock(&dev_priv->tile.lock);
-                *pmem = NULL;
-        }
-}
-
-void
-nv20_fb_init_tile_region(struct drm_device *dev, int i, uint32_t addr,
-                         uint32_t size, uint32_t pitch, uint32_t flags)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-        int bpp = (flags & NOUVEAU_GEM_TILE_32BPP ? 32 : 16);
-
-        tile->addr  = 0x00000001 | addr;
-        tile->limit = max(1u, addr + size) - 1;
-        tile->pitch = pitch;
-
-        /* Allocate some of the on-die tag memory, used to store Z
-         * compression meta-data (most likely just a bitmap determining
-         * if a given tile is compressed or not).
-         */
-        if (flags & NOUVEAU_GEM_TILE_ZETA) {
-                tile->tag_mem = nv20_fb_alloc_tag(dev, size / 256);
-                if (tile->tag_mem) {
-                        /* Enable Z compression */
-                        tile->zcomp = tile->tag_mem->start;
-                        if (dev_priv->chipset >= 0x25) {
-                                if (bpp == 16)
-                                        tile->zcomp |= NV25_PFB_ZCOMP_MODE_16;
-                                else
-                                        tile->zcomp |= NV25_PFB_ZCOMP_MODE_32;
-                        } else {
-                                tile->zcomp |= NV20_PFB_ZCOMP_EN;
-                                if (bpp != 16)
-                                        tile->zcomp |= NV20_PFB_ZCOMP_MODE_32;
-                        }
-                }
-
-                tile->addr |= 2;
-        }
-}
-
-void
-nv20_fb_free_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        tile->addr = tile->limit = tile->pitch = tile->zcomp = 0;
-        nv20_fb_free_tag(dev, &tile->tag_mem);
-}
-
-void
-nv20_fb_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        nv_wr32(dev, NV10_PFB_TLIMIT(i), tile->limit);
-        nv_wr32(dev, NV10_PFB_TSIZE(i), tile->pitch);
-        nv_wr32(dev, NV10_PFB_TILE(i), tile->addr);
-        nv_wr32(dev, NV20_PFB_ZCOMP(i), tile->zcomp);
-}
-
-int
-nv20_fb_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 mem_size = nv_rd32(dev, 0x10020c);
-        u32 pbus1218 = nv_rd32(dev, 0x001218);
-
-        dev_priv->vram_size = mem_size & 0xff000000;
-        switch (pbus1218 & 0x00000300) {
-        case 0x00000000: dev_priv->vram_type = NV_MEM_TYPE_SDRAM; break;
-        case 0x00000100: dev_priv->vram_type = NV_MEM_TYPE_DDR1; break;
-        case 0x00000200: dev_priv->vram_type = NV_MEM_TYPE_GDDR3; break;
-        case 0x00000300: dev_priv->vram_type = NV_MEM_TYPE_GDDR2; break;
-        }
-
-        return 0;
-}
-
-int
-nv20_fb_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        int i;
-
-        if (dev_priv->chipset >= 0x25)
-                drm_mm_init(&pfb->tag_heap, 0, 64 * 1024);
-        else
-                drm_mm_init(&pfb->tag_heap, 0, 32 * 1024);
-
-        /* Turn all the tiling regions off. */
-        pfb->num_tiles = NV10_PFB_TILE__SIZE;
-        for (i = 0; i < pfb->num_tiles; i++)
-                pfb->set_tile_region(dev, i);
-
-        return 0;
-}
-
-void
-nv20_fb_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        int i;
-
-        for (i = 0; i < pfb->num_tiles; i++)
-                pfb->free_tile_region(dev, i);
-
-        drm_mm_takedown(&pfb->tag_heap);
-}
diff --git a/drivers/gpu/drm/nouveau/nv20_graph.c b/drivers/gpu/drm/nouveau/nv20_graph.c
deleted file mode 100644
index e34ea30758f6..000000000000
--- a/drivers/gpu/drm/nouveau/nv20_graph.c
+++ /dev/null
@@ -1,836 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-/*
- * NV20
- * -----
- * There are 3 families :
- * NV20 is 0x10de:0x020*
- * NV25/28 is 0x10de:0x025* / 0x10de:0x028*
- * NV2A is 0x10de:0x02A0
- *
- * NV30
- * -----
- * There are 3 families :
- * NV30/31 is 0x10de:0x030* / 0x10de:0x031*
- * NV34 is 0x10de:0x032*
- * NV35/36 is 0x10de:0x033* / 0x10de:0x034*
- *
- * Not seen in the wild, no dumps (probably NV35) :
- * NV37 is 0x10de:0x00fc, 0x10de:0x00fd
- * NV38 is 0x10de:0x0333, 0x10de:0x00fe
- *
- */
-
-struct nv20_graph_engine {
-        struct nouveau_exec_engine base;
-        struct nouveau_gpuobj *ctxtab;
-        void (*grctx_init)(struct nouveau_gpuobj *);
-        u32 grctx_size;
-        u32 grctx_user;
-};
-
-#define NV20_GRCTX_SIZE (3580*4)
-#define NV25_GRCTX_SIZE (3529*4)
-#define NV2A_GRCTX_SIZE (3500*4)
-
-#define NV30_31_GRCTX_SIZE (24392)
-#define NV34_GRCTX_SIZE    (18140)
-#define NV35_36_GRCTX_SIZE (22396)
-
-int
-nv20_graph_unload_context(struct drm_device *dev)
-{
-        struct nouveau_channel *chan;
-        struct nouveau_gpuobj *grctx;
-        u32 tmp;
-
-        chan = nv10_graph_channel(dev);
-        if (!chan)
-                return 0;
-        grctx = chan->engctx[NVOBJ_ENGINE_GR];
-
-        nv_wr32(dev, NV20_PGRAPH_CHANNEL_CTX_POINTER, grctx->pinst >> 4);
-        nv_wr32(dev, NV20_PGRAPH_CHANNEL_CTX_XFER,
-                     NV20_PGRAPH_CHANNEL_CTX_XFER_SAVE);
-
-        nouveau_wait_for_idle(dev);
-
-        nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10000000);
-        tmp  = nv_rd32(dev, NV10_PGRAPH_CTX_USER) & 0x00ffffff;
-        tmp |= 31 << 24;
-        nv_wr32(dev, NV10_PGRAPH_CTX_USER, tmp);
-        return 0;
-}
-
-static void
-nv20_graph_rdi(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int i, writecount = 32;
-        uint32_t rdi_index = 0x2c80000;
-
-        if (dev_priv->chipset == 0x20) {
-                rdi_index = 0x3d0000;
-                writecount = 15;
-        }
-
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, rdi_index);
-        for (i = 0; i < writecount; i++)
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA, 0);
-
-        nouveau_wait_for_idle(dev);
-}
-
-static void
-nv20_graph_context_init(struct nouveau_gpuobj *ctx)
-{
-        int i;
-
-        nv_wo32(ctx, 0x033c, 0xffff0000);
-        nv_wo32(ctx, 0x03a0, 0x0fff0000);
-        nv_wo32(ctx, 0x03a4, 0x0fff0000);
-        nv_wo32(ctx, 0x047c, 0x00000101);
-        nv_wo32(ctx, 0x0490, 0x00000111);
-        nv_wo32(ctx, 0x04a8, 0x44400000);
-        for (i = 0x04d4; i <= 0x04e0; i += 4)
-                nv_wo32(ctx, i, 0x00030303);
-        for (i = 0x04f4; i <= 0x0500; i += 4)
-                nv_wo32(ctx, i, 0x00080000);
-        for (i = 0x050c; i <= 0x0518; i += 4)
-                nv_wo32(ctx, i, 0x01012000);
-        for (i = 0x051c; i <= 0x0528; i += 4)
-                nv_wo32(ctx, i, 0x000105b8);
-        for (i = 0x052c; i <= 0x0538; i += 4)
-                nv_wo32(ctx, i, 0x00080008);
-        for (i = 0x055c; i <= 0x0598; i += 4)
-                nv_wo32(ctx, i, 0x07ff0000);
-        nv_wo32(ctx, 0x05a4, 0x4b7fffff);
-        nv_wo32(ctx, 0x05fc, 0x00000001);
-        nv_wo32(ctx, 0x0604, 0x00004000);
-        nv_wo32(ctx, 0x0610, 0x00000001);
-        nv_wo32(ctx, 0x0618, 0x00040000);
-        nv_wo32(ctx, 0x061c, 0x00010000);
-        for (i = 0x1c1c; i <= 0x248c; i += 16) {
-                nv_wo32(ctx, (i + 0), 0x10700ff9);
-                nv_wo32(ctx, (i + 4), 0x0436086c);
-                nv_wo32(ctx, (i + 8), 0x000c001b);
-        }
-        nv_wo32(ctx, 0x281c, 0x3f800000);
-        nv_wo32(ctx, 0x2830, 0x3f800000);
-        nv_wo32(ctx, 0x285c, 0x40000000);
-        nv_wo32(ctx, 0x2860, 0x3f800000);
-        nv_wo32(ctx, 0x2864, 0x3f000000);
-        nv_wo32(ctx, 0x286c, 0x40000000);
-        nv_wo32(ctx, 0x2870, 0x3f800000);
-        nv_wo32(ctx, 0x2878, 0xbf800000);
-        nv_wo32(ctx, 0x2880, 0xbf800000);
-        nv_wo32(ctx, 0x34a4, 0x000fe000);
-        nv_wo32(ctx, 0x3530, 0x000003f8);
-        nv_wo32(ctx, 0x3540, 0x002fe000);
-        for (i = 0x355c; i <= 0x3578; i += 4)
-                nv_wo32(ctx, i, 0x001c527c);
-}
-
-static void
-nv25_graph_context_init(struct nouveau_gpuobj *ctx)
-{
-        int i;
-
-        nv_wo32(ctx, 0x035c, 0xffff0000);
-        nv_wo32(ctx, 0x03c0, 0x0fff0000);
-        nv_wo32(ctx, 0x03c4, 0x0fff0000);
-        nv_wo32(ctx, 0x049c, 0x00000101);
-        nv_wo32(ctx, 0x04b0, 0x00000111);
-        nv_wo32(ctx, 0x04c8, 0x00000080);
-        nv_wo32(ctx, 0x04cc, 0xffff0000);
-        nv_wo32(ctx, 0x04d0, 0x00000001);
-        nv_wo32(ctx, 0x04e4, 0x44400000);
-        nv_wo32(ctx, 0x04fc, 0x4b800000);
-        for (i = 0x0510; i <= 0x051c; i += 4)
-                nv_wo32(ctx, i, 0x00030303);
-        for (i = 0x0530; i <= 0x053c; i += 4)
-                nv_wo32(ctx, i, 0x00080000);
-        for (i = 0x0548; i <= 0x0554; i += 4)
-                nv_wo32(ctx, i, 0x01012000);
-        for (i = 0x0558; i <= 0x0564; i += 4)
-                nv_wo32(ctx, i, 0x000105b8);
-        for (i = 0x0568; i <= 0x0574; i += 4)
-                nv_wo32(ctx, i, 0x00080008);
-        for (i = 0x0598; i <= 0x05d4; i += 4)
-                nv_wo32(ctx, i, 0x07ff0000);
-        nv_wo32(ctx, 0x05e0, 0x4b7fffff);
-        nv_wo32(ctx, 0x0620, 0x00000080);
-        nv_wo32(ctx, 0x0624, 0x30201000);
-        nv_wo32(ctx, 0x0628, 0x70605040);
-        nv_wo32(ctx, 0x062c, 0xb0a09080);
-        nv_wo32(ctx, 0x0630, 0xf0e0d0c0);
-        nv_wo32(ctx, 0x0664, 0x00000001);
-        nv_wo32(ctx, 0x066c, 0x00004000);
-        nv_wo32(ctx, 0x0678, 0x00000001);
-        nv_wo32(ctx, 0x0680, 0x00040000);
-        nv_wo32(ctx, 0x0684, 0x00010000);
-        for (i = 0x1b04; i <= 0x2374; i += 16) {
-                nv_wo32(ctx, (i + 0), 0x10700ff9);
-                nv_wo32(ctx, (i + 4), 0x0436086c);
-                nv_wo32(ctx, (i + 8), 0x000c001b);
-        }
-        nv_wo32(ctx, 0x2704, 0x3f800000);
-        nv_wo32(ctx, 0x2718, 0x3f800000);
-        nv_wo32(ctx, 0x2744, 0x40000000);
-        nv_wo32(ctx, 0x2748, 0x3f800000);
-        nv_wo32(ctx, 0x274c, 0x3f000000);
-        nv_wo32(ctx, 0x2754, 0x40000000);
-        nv_wo32(ctx, 0x2758, 0x3f800000);
-        nv_wo32(ctx, 0x2760, 0xbf800000);
-        nv_wo32(ctx, 0x2768, 0xbf800000);
-        nv_wo32(ctx, 0x308c, 0x000fe000);
-        nv_wo32(ctx, 0x3108, 0x000003f8);
-        nv_wo32(ctx, 0x3468, 0x002fe000);
-        for (i = 0x3484; i <= 0x34a0; i += 4)
-                nv_wo32(ctx, i, 0x001c527c);
-}
-
-static void
-nv2a_graph_context_init(struct nouveau_gpuobj *ctx)
-{
-        int i;
-
-        nv_wo32(ctx, 0x033c, 0xffff0000);
-        nv_wo32(ctx, 0x03a0, 0x0fff0000);
-        nv_wo32(ctx, 0x03a4, 0x0fff0000);
-        nv_wo32(ctx, 0x047c, 0x00000101);
-        nv_wo32(ctx, 0x0490, 0x00000111);
-        nv_wo32(ctx, 0x04a8, 0x44400000);
-        for (i = 0x04d4; i <= 0x04e0; i += 4)
-                nv_wo32(ctx, i, 0x00030303);
-        for (i = 0x04f4; i <= 0x0500; i += 4)
-                nv_wo32(ctx, i, 0x00080000);
-        for (i = 0x050c; i <= 0x0518; i += 4)
-                nv_wo32(ctx, i, 0x01012000);
-        for (i = 0x051c; i <= 0x0528; i += 4)
-                nv_wo32(ctx, i, 0x000105b8);
-        for (i = 0x052c; i <= 0x0538; i += 4)
-                nv_wo32(ctx, i, 0x00080008);
-        for (i = 0x055c; i <= 0x0598; i += 4)
-                nv_wo32(ctx, i, 0x07ff0000);
-        nv_wo32(ctx, 0x05a4, 0x4b7fffff);
-        nv_wo32(ctx, 0x05fc, 0x00000001);
-        nv_wo32(ctx, 0x0604, 0x00004000);
-        nv_wo32(ctx, 0x0610, 0x00000001);
-        nv_wo32(ctx, 0x0618, 0x00040000);
-        nv_wo32(ctx, 0x061c, 0x00010000);
-        for (i = 0x1a9c; i <= 0x22fc; i += 16) { /*XXX: check!! */
-                nv_wo32(ctx, (i + 0), 0x10700ff9);
-                nv_wo32(ctx, (i + 4), 0x0436086c);
-                nv_wo32(ctx, (i + 8), 0x000c001b);
-        }
-        nv_wo32(ctx, 0x269c, 0x3f800000);
-        nv_wo32(ctx, 0x26b0, 0x3f800000);
-        nv_wo32(ctx, 0x26dc, 0x40000000);
-        nv_wo32(ctx, 0x26e0, 0x3f800000);
-        nv_wo32(ctx, 0x26e4, 0x3f000000);
-        nv_wo32(ctx, 0x26ec, 0x40000000);
-        nv_wo32(ctx, 0x26f0, 0x3f800000);
-        nv_wo32(ctx, 0x26f8, 0xbf800000);
-        nv_wo32(ctx, 0x2700, 0xbf800000);
-        nv_wo32(ctx, 0x3024, 0x000fe000);
-        nv_wo32(ctx, 0x30a0, 0x000003f8);
-        nv_wo32(ctx, 0x33fc, 0x002fe000);
-        for (i = 0x341c; i <= 0x3438; i += 4)
-                nv_wo32(ctx, i, 0x001c527c);
-}
-
-static void
-nv30_31_graph_context_init(struct nouveau_gpuobj *ctx)
-{
-        int i;
-
-        nv_wo32(ctx, 0x0410, 0x00000101);
-        nv_wo32(ctx, 0x0424, 0x00000111);
-        nv_wo32(ctx, 0x0428, 0x00000060);
-        nv_wo32(ctx, 0x0444, 0x00000080);
-        nv_wo32(ctx, 0x0448, 0xffff0000);
-        nv_wo32(ctx, 0x044c, 0x00000001);
-        nv_wo32(ctx, 0x0460, 0x44400000);
-        nv_wo32(ctx, 0x048c, 0xffff0000);
-        for (i = 0x04e0; i < 0x04e8; i += 4)
-                nv_wo32(ctx, i, 0x0fff0000);
-        nv_wo32(ctx, 0x04ec, 0x00011100);
-        for (i = 0x0508; i < 0x0548; i += 4)
-                nv_wo32(ctx, i, 0x07ff0000);
-        nv_wo32(ctx, 0x0550, 0x4b7fffff);
-        nv_wo32(ctx, 0x058c, 0x00000080);
-        nv_wo32(ctx, 0x0590, 0x30201000);
-        nv_wo32(ctx, 0x0594, 0x70605040);
-        nv_wo32(ctx, 0x0598, 0xb8a89888);
-        nv_wo32(ctx, 0x059c, 0xf8e8d8c8);
-        nv_wo32(ctx, 0x05b0, 0xb0000000);
-        for (i = 0x0600; i < 0x0640; i += 4)
-                nv_wo32(ctx, i, 0x00010588);
-        for (i = 0x0640; i < 0x0680; i += 4)
-                nv_wo32(ctx, i, 0x00030303);
-        for (i = 0x06c0; i < 0x0700; i += 4)
-                nv_wo32(ctx, i, 0x0008aae4);
-        for (i = 0x0700; i < 0x0740; i += 4)
-                nv_wo32(ctx, i, 0x01012000);
-        for (i = 0x0740; i < 0x0780; i += 4)
-                nv_wo32(ctx, i, 0x00080008);
-        nv_wo32(ctx, 0x085c, 0x00040000);
-        nv_wo32(ctx, 0x0860, 0x00010000);
-        for (i = 0x0864; i < 0x0874; i += 4)
-                nv_wo32(ctx, i, 0x00040004);
-        for (i = 0x1f18; i <= 0x3088 ; i += 16) {
-                nv_wo32(ctx, i + 0, 0x10700ff9);
-                nv_wo32(ctx, i + 1, 0x0436086c);
-                nv_wo32(ctx, i + 2, 0x000c001b);
-        }
-        for (i = 0x30b8; i < 0x30c8; i += 4)
-                nv_wo32(ctx, i, 0x0000ffff);
-        nv_wo32(ctx, 0x344c, 0x3f800000);
-        nv_wo32(ctx, 0x3808, 0x3f800000);
-        nv_wo32(ctx, 0x381c, 0x3f800000);
-        nv_wo32(ctx, 0x3848, 0x40000000);
-        nv_wo32(ctx, 0x384c, 0x3f800000);
-        nv_wo32(ctx, 0x3850, 0x3f000000);
-        nv_wo32(ctx, 0x3858, 0x40000000);
-        nv_wo32(ctx, 0x385c, 0x3f800000);
-        nv_wo32(ctx, 0x3864, 0xbf800000);
-        nv_wo32(ctx, 0x386c, 0xbf800000);
-}
-
-static void
-nv34_graph_context_init(struct nouveau_gpuobj *ctx)
-{
-        int i;
-
-        nv_wo32(ctx, 0x040c, 0x01000101);
-        nv_wo32(ctx, 0x0420, 0x00000111);
-        nv_wo32(ctx, 0x0424, 0x00000060);
-        nv_wo32(ctx, 0x0440, 0x00000080);
-        nv_wo32(ctx, 0x0444, 0xffff0000);
-        nv_wo32(ctx, 0x0448, 0x00000001);
-        nv_wo32(ctx, 0x045c, 0x44400000);
-        nv_wo32(ctx, 0x0480, 0xffff0000);
-        for (i = 0x04d4; i < 0x04dc; i += 4)
-                nv_wo32(ctx, i, 0x0fff0000);
-        nv_wo32(ctx, 0x04e0, 0x00011100);
-        for (i = 0x04fc; i < 0x053c; i += 4)
-                nv_wo32(ctx, i, 0x07ff0000);
-        nv_wo32(ctx, 0x0544, 0x4b7fffff);
-        nv_wo32(ctx, 0x057c, 0x00000080);
-        nv_wo32(ctx, 0x0580, 0x30201000);
-        nv_wo32(ctx, 0x0584, 0x70605040);
-        nv_wo32(ctx, 0x0588, 0xb8a89888);
-        nv_wo32(ctx, 0x058c, 0xf8e8d8c8);
-        nv_wo32(ctx, 0x05a0, 0xb0000000);
-        for (i = 0x05f0; i < 0x0630; i += 4)
-                nv_wo32(ctx, i, 0x00010588);
-        for (i = 0x0630; i < 0x0670; i += 4)
-                nv_wo32(ctx, i, 0x00030303);
-        for (i = 0x06b0; i < 0x06f0; i += 4)
-                nv_wo32(ctx, i, 0x0008aae4);
-        for (i = 0x06f0; i < 0x0730; i += 4)
-                nv_wo32(ctx, i, 0x01012000);
-        for (i = 0x0730; i < 0x0770; i += 4)
-                nv_wo32(ctx, i, 0x00080008);
-        nv_wo32(ctx, 0x0850, 0x00040000);
-        nv_wo32(ctx, 0x0854, 0x00010000);
-        for (i = 0x0858; i < 0x0868; i += 4)
-                nv_wo32(ctx, i, 0x00040004);
-        for (i = 0x15ac; i <= 0x271c ; i += 16) {
-                nv_wo32(ctx, i + 0, 0x10700ff9);
-                nv_wo32(ctx, i + 1, 0x0436086c);
-                nv_wo32(ctx, i + 2, 0x000c001b);
-        }
-        for (i = 0x274c; i < 0x275c; i += 4)
-                nv_wo32(ctx, i, 0x0000ffff);
-        nv_wo32(ctx, 0x2ae0, 0x3f800000);
-        nv_wo32(ctx, 0x2e9c, 0x3f800000);
-        nv_wo32(ctx, 0x2eb0, 0x3f800000);
-        nv_wo32(ctx, 0x2edc, 0x40000000);
-        nv_wo32(ctx, 0x2ee0, 0x3f800000);
-        nv_wo32(ctx, 0x2ee4, 0x3f000000);
-        nv_wo32(ctx, 0x2eec, 0x40000000);
-        nv_wo32(ctx, 0x2ef0, 0x3f800000);
-        nv_wo32(ctx, 0x2ef8, 0xbf800000);
-        nv_wo32(ctx, 0x2f00, 0xbf800000);
-}
-
-static void
-nv35_36_graph_context_init(struct nouveau_gpuobj *ctx)
-{
-        int i;
-
-        nv_wo32(ctx, 0x040c, 0x00000101);
-        nv_wo32(ctx, 0x0420, 0x00000111);
-        nv_wo32(ctx, 0x0424, 0x00000060);
-        nv_wo32(ctx, 0x0440, 0x00000080);
-        nv_wo32(ctx, 0x0444, 0xffff0000);
-        nv_wo32(ctx, 0x0448, 0x00000001);
-        nv_wo32(ctx, 0x045c, 0x44400000);
-        nv_wo32(ctx, 0x0488, 0xffff0000);
-        for (i = 0x04dc; i < 0x04e4; i += 4)
-                nv_wo32(ctx, i, 0x0fff0000);
-        nv_wo32(ctx, 0x04e8, 0x00011100);
-        for (i = 0x0504; i < 0x0544; i += 4)
-                nv_wo32(ctx, i, 0x07ff0000);
-        nv_wo32(ctx, 0x054c, 0x4b7fffff);
-        nv_wo32(ctx, 0x0588, 0x00000080);
-        nv_wo32(ctx, 0x058c, 0x30201000);
-        nv_wo32(ctx, 0x0590, 0x70605040);
-        nv_wo32(ctx, 0x0594, 0xb8a89888);
-        nv_wo32(ctx, 0x0598, 0xf8e8d8c8);
-        nv_wo32(ctx, 0x05ac, 0xb0000000);
-        for (i = 0x0604; i < 0x0644; i += 4)
-                nv_wo32(ctx, i, 0x00010588);
-        for (i = 0x0644; i < 0x0684; i += 4)
-                nv_wo32(ctx, i, 0x00030303);
-        for (i = 0x06c4; i < 0x0704; i += 4)
-                nv_wo32(ctx, i, 0x0008aae4);
-        for (i = 0x0704; i < 0x0744; i += 4)
-                nv_wo32(ctx, i, 0x01012000);
-        for (i = 0x0744; i < 0x0784; i += 4)
-                nv_wo32(ctx, i, 0x00080008);
-        nv_wo32(ctx, 0x0860, 0x00040000);
-        nv_wo32(ctx, 0x0864, 0x00010000);
-        for (i = 0x0868; i < 0x0878; i += 4)
-                nv_wo32(ctx, i, 0x00040004);
-        for (i = 0x1f1c; i <= 0x308c ; i += 16) {
-                nv_wo32(ctx, i + 0, 0x10700ff9);
-                nv_wo32(ctx, i + 4, 0x0436086c);
-                nv_wo32(ctx, i + 8, 0x000c001b);
-        }
-        for (i = 0x30bc; i < 0x30cc; i += 4)
-                nv_wo32(ctx, i, 0x0000ffff);
-        nv_wo32(ctx, 0x3450, 0x3f800000);
-        nv_wo32(ctx, 0x380c, 0x3f800000);
-        nv_wo32(ctx, 0x3820, 0x3f800000);
-        nv_wo32(ctx, 0x384c, 0x40000000);
-        nv_wo32(ctx, 0x3850, 0x3f800000);
-        nv_wo32(ctx, 0x3854, 0x3f000000);
-        nv_wo32(ctx, 0x385c, 0x40000000);
-        nv_wo32(ctx, 0x3860, 0x3f800000);
-        nv_wo32(ctx, 0x3868, 0xbf800000);
-        nv_wo32(ctx, 0x3870, 0xbf800000);
-}
-
-int
-nv20_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv20_graph_engine *pgraph = nv_engine(chan->dev, engine);
-        struct nouveau_gpuobj *grctx = NULL;
-        struct drm_device *dev = chan->dev;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, NULL, pgraph->grctx_size, 16,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &grctx);
-        if (ret)
-                return ret;
-
-        /* Initialise default context values */
-        pgraph->grctx_init(grctx);
-
-        /* nv20: nv_wo32(dev, chan->ramin_grctx->gpuobj, 10, chan->id<<24); */
-        /* CTX_USER */
-        nv_wo32(grctx, pgraph->grctx_user, (chan->id << 24) | 0x1);
-
-        nv_wo32(pgraph->ctxtab, chan->id * 4, grctx->pinst >> 4);
-        chan->engctx[engine] = grctx;
-        return 0;
-}
-
-void
-nv20_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv20_graph_engine *pgraph = nv_engine(chan->dev, engine);
-        struct nouveau_gpuobj *grctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-
-        /* Unload the context if it's the currently active one */
-        if (nv10_graph_channel(dev) == chan)
-                nv20_graph_unload_context(dev);
-
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* Free the context resources */
-        nv_wo32(pgraph->ctxtab, chan->id * 4, 0);
-
-        nouveau_gpuobj_ref(NULL, &grctx);
-        chan->engctx[engine] = NULL;
-}
-
-static void
-nv20_graph_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        nv_wr32(dev, NV20_PGRAPH_TLIMIT(i), tile->limit);
-        nv_wr32(dev, NV20_PGRAPH_TSIZE(i), tile->pitch);
-        nv_wr32(dev, NV20_PGRAPH_TILE(i), tile->addr);
-
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0030 + 4 * i);
-        nv_wr32(dev, NV10_PGRAPH_RDI_DATA, tile->limit);
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0050 + 4 * i);
-        nv_wr32(dev, NV10_PGRAPH_RDI_DATA, tile->pitch);
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0010 + 4 * i);
-        nv_wr32(dev, NV10_PGRAPH_RDI_DATA, tile->addr);
-
-        if (dev_priv->card_type == NV_20) {
-                nv_wr32(dev, NV20_PGRAPH_ZCOMP(i), tile->zcomp);
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00ea0090 + 4 * i);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA, tile->zcomp);
-        }
-}
-
-int
-nv20_graph_init(struct drm_device *dev, int engine)
-{
-        struct nv20_graph_engine *pgraph = nv_engine(dev, engine);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t tmp, vramsz;
-        int i;
-
-        nv_wr32(dev, NV03_PMC_ENABLE,
-                nv_rd32(dev, NV03_PMC_ENABLE) & ~NV_PMC_ENABLE_PGRAPH);
-        nv_wr32(dev, NV03_PMC_ENABLE,
-                nv_rd32(dev, NV03_PMC_ENABLE) |  NV_PMC_ENABLE_PGRAPH);
-
-        nv_wr32(dev, NV20_PGRAPH_CHANNEL_CTX_TABLE, pgraph->ctxtab->pinst >> 4);
-
-        nv20_graph_rdi(dev);
-
-        nv_wr32(dev, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
-
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x00000000);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_1, 0x00118700);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_3, 0xF3CE0475); /* 0x4 = auto ctx switch */
-        nv_wr32(dev, NV10_PGRAPH_DEBUG_4, 0x00000000);
-        nv_wr32(dev, 0x40009C           , 0x00000040);
-
-        if (dev_priv->chipset >= 0x25) {
-                nv_wr32(dev, 0x400890, 0x00a8cfff);
-                nv_wr32(dev, 0x400610, 0x304B1FB6);
-                nv_wr32(dev, 0x400B80, 0x1cbd3883);
-                nv_wr32(dev, 0x400B84, 0x44000000);
-                nv_wr32(dev, 0x400098, 0x40000080);
-                nv_wr32(dev, 0x400B88, 0x000000ff);
-
-        } else {
-                nv_wr32(dev, 0x400880, 0x0008c7df);
-                nv_wr32(dev, 0x400094, 0x00000005);
-                nv_wr32(dev, 0x400B80, 0x45eae20e);
-                nv_wr32(dev, 0x400B84, 0x24000000);
-                nv_wr32(dev, 0x400098, 0x00000040);
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00E00038);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA , 0x00000030);
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00E10038);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA , 0x00000030);
-        }
-
-        /* Turn all the tiling regions off. */
-        for (i = 0; i < NV10_PFB_TILE__SIZE; i++)
-                nv20_graph_set_tile_region(dev, i);
-
-        nv_wr32(dev, 0x4009a0, nv_rd32(dev, 0x100324));
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA000C);
-        nv_wr32(dev, NV10_PGRAPH_RDI_DATA, nv_rd32(dev, 0x100324));
-
-        nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10000100);
-        nv_wr32(dev, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
-
-        tmp = nv_rd32(dev, NV10_PGRAPH_SURFACE) & 0x0007ff00;
-        nv_wr32(dev, NV10_PGRAPH_SURFACE, tmp);
-        tmp = nv_rd32(dev, NV10_PGRAPH_SURFACE) | 0x00020100;
-        nv_wr32(dev, NV10_PGRAPH_SURFACE, tmp);
-
-        /* begin RAM config */
-        vramsz = pci_resource_len(dev->pdev, 0) - 1;
-        nv_wr32(dev, 0x4009A4, nv_rd32(dev, NV04_PFB_CFG0));
-        nv_wr32(dev, 0x4009A8, nv_rd32(dev, NV04_PFB_CFG1));
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
-        nv_wr32(dev, NV10_PGRAPH_RDI_DATA , nv_rd32(dev, NV04_PFB_CFG0));
-        nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0004);
-        nv_wr32(dev, NV10_PGRAPH_RDI_DATA , nv_rd32(dev, NV04_PFB_CFG1));
-        nv_wr32(dev, 0x400820, 0);
-        nv_wr32(dev, 0x400824, 0);
-        nv_wr32(dev, 0x400864, vramsz - 1);
-        nv_wr32(dev, 0x400868, vramsz - 1);
-
-        /* interesting.. the below overwrites some of the tile setup above.. */
-        nv_wr32(dev, 0x400B20, 0x00000000);
-        nv_wr32(dev, 0x400B04, 0xFFFFFFFF);
-
-        nv_wr32(dev, NV03_PGRAPH_ABS_UCLIP_XMIN, 0);
-        nv_wr32(dev, NV03_PGRAPH_ABS_UCLIP_YMIN, 0);
-        nv_wr32(dev, NV03_PGRAPH_ABS_UCLIP_XMAX, 0x7fff);
-        nv_wr32(dev, NV03_PGRAPH_ABS_UCLIP_YMAX, 0x7fff);
-
-        return 0;
-}
-
-int
-nv30_graph_init(struct drm_device *dev, int engine)
-{
-        struct nv20_graph_engine *pgraph = nv_engine(dev, engine);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int i;
-
-        nv_wr32(dev, NV03_PMC_ENABLE,
-                nv_rd32(dev, NV03_PMC_ENABLE) & ~NV_PMC_ENABLE_PGRAPH);
-        nv_wr32(dev, NV03_PMC_ENABLE,
-                nv_rd32(dev, NV03_PMC_ENABLE) |  NV_PMC_ENABLE_PGRAPH);
-
-        nv_wr32(dev, NV20_PGRAPH_CHANNEL_CTX_TABLE, pgraph->ctxtab->pinst >> 4);
-
-        nv_wr32(dev, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0xFFFFFFFF);
-
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x00000000);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_1, 0x401287c0);
-        nv_wr32(dev, 0x400890, 0x01b463ff);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_3, 0xf2de0475);
-        nv_wr32(dev, NV10_PGRAPH_DEBUG_4, 0x00008000);
-        nv_wr32(dev, NV04_PGRAPH_LIMIT_VIOL_PIX, 0xf04bdff6);
-        nv_wr32(dev, 0x400B80, 0x1003d888);
-        nv_wr32(dev, 0x400B84, 0x0c000000);
-        nv_wr32(dev, 0x400098, 0x00000000);
-        nv_wr32(dev, 0x40009C, 0x0005ad00);
-        nv_wr32(dev, 0x400B88, 0x62ff00ff); /* suspiciously like PGRAPH_DEBUG_2 */
-        nv_wr32(dev, 0x4000a0, 0x00000000);
-        nv_wr32(dev, 0x4000a4, 0x00000008);
-        nv_wr32(dev, 0x4008a8, 0xb784a400);
-        nv_wr32(dev, 0x400ba0, 0x002f8685);
-        nv_wr32(dev, 0x400ba4, 0x00231f3f);
-        nv_wr32(dev, 0x4008a4, 0x40000020);
-
-        if (dev_priv->chipset == 0x34) {
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0004);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA , 0x00200201);
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0008);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA , 0x00000008);
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA , 0x00000032);
-                nv_wr32(dev, NV10_PGRAPH_RDI_INDEX, 0x00E00004);
-                nv_wr32(dev, NV10_PGRAPH_RDI_DATA , 0x00000002);
-        }
-
-        nv_wr32(dev, 0x4000c0, 0x00000016);
-
-        /* Turn all the tiling regions off. */
-        for (i = 0; i < NV10_PFB_TILE__SIZE; i++)
-                nv20_graph_set_tile_region(dev, i);
-
-        nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10000100);
-        nv_wr32(dev, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
-        nv_wr32(dev, 0x0040075c             , 0x00000001);
-
-        /* begin RAM config */
-        /* vramsz = pci_resource_len(dev->pdev, 0) - 1; */
-        nv_wr32(dev, 0x4009A4, nv_rd32(dev, NV04_PFB_CFG0));
-        nv_wr32(dev, 0x4009A8, nv_rd32(dev, NV04_PFB_CFG1));
-        if (dev_priv->chipset != 0x34) {
-                nv_wr32(dev, 0x400750, 0x00EA0000);
-                nv_wr32(dev, 0x400754, nv_rd32(dev, NV04_PFB_CFG0));
-                nv_wr32(dev, 0x400750, 0x00EA0004);
-                nv_wr32(dev, 0x400754, nv_rd32(dev, NV04_PFB_CFG1));
-        }
-
-        return 0;
-}
-
-int
-nv20_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000000);
-        if (!nv_wait(dev, NV04_PGRAPH_STATUS, ~0, 0) && suspend) {
-                nv_mask(dev, NV04_PGRAPH_FIFO, 0x00000001, 0x00000001);
-                return -EBUSY;
-        }
-        nv20_graph_unload_context(dev);
-        nv_wr32(dev, NV03_PGRAPH_INTR_EN, 0x00000000);
-        return 0;
-}
-
-static void
-nv20_graph_isr(struct drm_device *dev)
-{
-        u32 stat;
-
-        while ((stat = nv_rd32(dev, NV03_PGRAPH_INTR))) {
-                u32 nsource = nv_rd32(dev, NV03_PGRAPH_NSOURCE);
-                u32 nstatus = nv_rd32(dev, NV03_PGRAPH_NSTATUS);
-                u32 addr = nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR);
-                u32 chid = (addr & 0x01f00000) >> 20;
-                u32 subc = (addr & 0x00070000) >> 16;
-                u32 mthd = (addr & 0x00001ffc);
-                u32 data = nv_rd32(dev, NV04_PGRAPH_TRAPPED_DATA);
-                u32 class = nv_rd32(dev, 0x400160 + subc * 4) & 0xfff;
-                u32 show = stat;
-
-                if (stat & NV_PGRAPH_INTR_ERROR) {
-                        if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
-                                if (!nouveau_gpuobj_mthd_call2(dev, chid, class, mthd, data))
-                                        show &= ~NV_PGRAPH_INTR_ERROR;
-                        }
-                }
-
-                nv_wr32(dev, NV03_PGRAPH_INTR, stat);
-                nv_wr32(dev, NV04_PGRAPH_FIFO, 0x00000001);
-
-                if (show && nouveau_ratelimit()) {
-                        NV_INFO(dev, "PGRAPH -");
-                        nouveau_bitfield_print(nv10_graph_intr, show);
-                        printk(" nsource:");
-                        nouveau_bitfield_print(nv04_graph_nsource, nsource);
-                        printk(" nstatus:");
-                        nouveau_bitfield_print(nv10_graph_nstatus, nstatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - ch %d/%d class 0x%04x "
-                                     "mthd 0x%04x data 0x%08x\n",
-                                chid, subc, class, mthd, data);
-                }
-        }
-}
-
-static void
-nv20_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nv20_graph_engine *pgraph = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 12);
-        nouveau_gpuobj_ref(NULL, &pgraph->ctxtab);
-
-        NVOBJ_ENGINE_DEL(dev, GR);
-        kfree(pgraph);
-}
-
-int
-nv20_graph_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv20_graph_engine *pgraph;
-        int ret;
-
-        pgraph = kzalloc(sizeof(*pgraph), GFP_KERNEL);
-        if (!pgraph)
-                return -ENOMEM;
-
-        pgraph->base.destroy = nv20_graph_destroy;
-        pgraph->base.fini = nv20_graph_fini;
-        pgraph->base.context_new = nv20_graph_context_new;
-        pgraph->base.context_del = nv20_graph_context_del;
-        pgraph->base.object_new = nv04_graph_object_new;
-        pgraph->base.set_tile_region = nv20_graph_set_tile_region;
-
-        pgraph->grctx_user = 0x0028;
-        if (dev_priv->card_type == NV_20) {
-                pgraph->base.init = nv20_graph_init;
-                switch (dev_priv->chipset) {
-                case 0x20:
-                        pgraph->grctx_init = nv20_graph_context_init;
-                        pgraph->grctx_size = NV20_GRCTX_SIZE;
-                        pgraph->grctx_user = 0x0000;
-                        break;
-                case 0x25:
-                case 0x28:
-                        pgraph->grctx_init = nv25_graph_context_init;
-                        pgraph->grctx_size = NV25_GRCTX_SIZE;
-                        break;
-                case 0x2a:
-                        pgraph->grctx_init = nv2a_graph_context_init;
-                        pgraph->grctx_size = NV2A_GRCTX_SIZE;
-                        pgraph->grctx_user = 0x0000;
-                        break;
-                default:
-                        NV_ERROR(dev, "PGRAPH: unknown chipset\n");
-                        kfree(pgraph);
-                        return 0;
-                }
-        } else {
-                pgraph->base.init = nv30_graph_init;
-                switch (dev_priv->chipset) {
-                case 0x30:
-                case 0x31:
-                        pgraph->grctx_init = nv30_31_graph_context_init;
-                        pgraph->grctx_size = NV30_31_GRCTX_SIZE;
-                        break;
-                case 0x34:
-                        pgraph->grctx_init = nv34_graph_context_init;
-                        pgraph->grctx_size = NV34_GRCTX_SIZE;
-                        break;
-                case 0x35:
-                case 0x36:
-                        pgraph->grctx_init = nv35_36_graph_context_init;
-                        pgraph->grctx_size = NV35_36_GRCTX_SIZE;
-                        break;
-                default:
-                        NV_ERROR(dev, "PGRAPH: unknown chipset\n");
-                        kfree(pgraph);
-                        return 0;
-                }
-        }
-
-        /* Create Context Pointer Table */
-        ret = nouveau_gpuobj_new(dev, NULL, 32 * 4, 16, NVOBJ_FLAG_ZERO_ALLOC,
-                                 &pgraph->ctxtab);
-        if (ret) {
-                kfree(pgraph);
-                return ret;
-        }
-
-        NVOBJ_ENGINE_ADD(dev, GR, &pgraph->base);
-        nouveau_irq_register(dev, 12, nv20_graph_isr);
-
-        NVOBJ_CLASS(dev, 0x0030, GR); /* null */
-        NVOBJ_CLASS(dev, 0x0039, GR); /* m2mf */
-        NVOBJ_CLASS(dev, 0x004a, GR); /* gdirect */
-        NVOBJ_CLASS(dev, 0x009f, GR); /* imageblit (nv12) */
-        NVOBJ_CLASS(dev, 0x008a, GR); /* ifc */
-        NVOBJ_CLASS(dev, 0x0089, GR); /* sifm */
-        NVOBJ_CLASS(dev, 0x0062, GR); /* surf2d */
-        NVOBJ_CLASS(dev, 0x0043, GR); /* rop */
-        NVOBJ_CLASS(dev, 0x0012, GR); /* beta1 */
-        NVOBJ_CLASS(dev, 0x0072, GR); /* beta4 */
-        NVOBJ_CLASS(dev, 0x0019, GR); /* cliprect */
-        NVOBJ_CLASS(dev, 0x0044, GR); /* pattern */
-        if (dev_priv->card_type == NV_20) {
-                NVOBJ_CLASS(dev, 0x009e, GR); /* swzsurf */
-                NVOBJ_CLASS(dev, 0x0096, GR); /* celcius */
-
-                /* kelvin */
-                if (dev_priv->chipset < 0x25)
-                        NVOBJ_CLASS(dev, 0x0097, GR);
-                else
-                        NVOBJ_CLASS(dev, 0x0597, GR);
-        } else {
-                NVOBJ_CLASS(dev, 0x038a, GR); /* ifc (nv30) */
-                NVOBJ_CLASS(dev, 0x0389, GR); /* sifm (nv30) */
-                NVOBJ_CLASS(dev, 0x0362, GR); /* surf2d (nv30) */
-                NVOBJ_CLASS(dev, 0x039e, GR); /* swzsurf */
-
-                /* rankine */
-                if (0x00000003 & (1 << (dev_priv->chipset & 0x0f)))
-                        NVOBJ_CLASS(dev, 0x0397, GR);
-                else
-                if (0x00000010 & (1 << (dev_priv->chipset & 0x0f)))
-                        NVOBJ_CLASS(dev, 0x0697, GR);
-                else
-                if (0x000001e0 & (1 << (dev_priv->chipset & 0x0f)))
-                        NVOBJ_CLASS(dev, 0x0497, GR);
-        }
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv30_fb.c b/drivers/gpu/drm/nouveau/nv30_fb.c
deleted file mode 100644
index e0135f0e2144..000000000000
--- a/drivers/gpu/drm/nouveau/nv30_fb.c
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2010 Francisco Jerez.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-void
-nv30_fb_init_tile_region(struct drm_device *dev, int i, uint32_t addr,
-                         uint32_t size, uint32_t pitch, uint32_t flags)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        tile->addr = addr | 1;
-        tile->limit = max(1u, addr + size) - 1;
-        tile->pitch = pitch;
-}
-
-void
-nv30_fb_free_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        tile->addr = tile->limit = tile->pitch = 0;
-}
-
-static int
-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 m = (l >> (8 * i) & 0xff) + calc_bias(dev, k, i, j);
-
-                x |= (0x80 | clamp(m, 0, 0x1f)) << (8 * j);
-        }
-
-        return x;
-}
-
-int
-nv30_fb_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        int i, j;
-
-        pfb->num_tiles = NV10_PFB_TILE__SIZE;
-
-        /* Turn all the tiling regions off. */
-        for (i = 0; i < pfb->num_tiles; i++)
-                pfb->set_tile_region(dev, i);
-
-        /* Init the memory timing regs at 0x10037c/0x1003ac */
-        if (dev_priv->chipset == 0x30 ||
-            dev_priv->chipset == 0x31 ||
-            dev_priv->chipset == 0x35) {
-                /* Related to ROP count */
-                int n = (dev_priv->chipset == 0x31 ? 2 : 4);
-                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(dev, l, 0, j));
-
-                        for (j = 0; j < 2; j++)
-                                nv_wr32(dev, 0x1003ac + 0x8 * i + 0x4 * j,
-                                        calc_ref(dev, l, 1, j));
-                }
-        }
-
-        return 0;
-}
-
-void
-nv30_fb_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv31_mpeg.c b/drivers/gpu/drm/nouveau/nv31_mpeg.c
deleted file mode 100644
index 5f239bf658c4..000000000000
--- a/drivers/gpu/drm/nouveau/nv31_mpeg.c
+++ /dev/null
@@ -1,346 +0,0 @@
-/*
- * Copyright 2011 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"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-
-struct nv31_mpeg_engine {
-        struct nouveau_exec_engine base;
-        atomic_t refcount;
-};
-
-
-static int
-nv31_mpeg_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv31_mpeg_engine *pmpeg = nv_engine(chan->dev, engine);
-
-        if (!atomic_add_unless(&pmpeg->refcount, 1, 1))
-                return -EBUSY;
-
-        chan->engctx[engine] = (void *)0xdeadcafe;
-        return 0;
-}
-
-static void
-nv31_mpeg_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv31_mpeg_engine *pmpeg = nv_engine(chan->dev, engine);
-        atomic_dec(&pmpeg->refcount);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nv40_mpeg_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ctx = NULL;
-        unsigned long flags;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d\n", chan->id);
-
-        ret = nouveau_gpuobj_new(dev, NULL, 264 * 4, 16, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &ctx);
-        if (ret)
-                return ret;
-
-        nv_wo32(ctx, 0x78, 0x02001ec1);
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x002500, 0x00000001, 0x00000000);
-        if ((nv_rd32(dev, 0x003204) & 0x1f) == chan->id)
-                nv_wr32(dev, 0x00330c, ctx->pinst >> 4);
-        nv_wo32(chan->ramfc, 0x54, ctx->pinst >> 4);
-        nv_mask(dev, 0x002500, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        chan->engctx[engine] = ctx;
-        return 0;
-}
-
-static void
-nv40_mpeg_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct nouveau_gpuobj *ctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        unsigned long flags;
-        u32 inst = 0x80000000 | (ctx->pinst >> 4);
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x00b32c, 0x00000001, 0x00000000);
-        if (nv_rd32(dev, 0x00b318) == inst)
-                nv_mask(dev, 0x00b318, 0x80000000, 0x00000000);
-        nv_mask(dev, 0x00b32c, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        nouveau_gpuobj_ref(NULL, &ctx);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nv31_mpeg_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 20, 16, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 2;
-        obj->class  = class;
-
-        nv_wo32(obj, 0x00, class);
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static int
-nv31_mpeg_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv31_mpeg_engine *pmpeg = nv_engine(dev, engine);
-        int i;
-
-        /* VPE init */
-        nv_mask(dev, 0x000200, 0x00000002, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00000002, 0x00000002);
-        nv_wr32(dev, 0x00b0e0, 0x00000020); /* nvidia: rd 0x01, wr 0x20 */
-        nv_wr32(dev, 0x00b0e8, 0x00000020); /* nvidia: rd 0x01, wr 0x20 */
-
-        for (i = 0; i < dev_priv->engine.fb.num_tiles; i++)
-                pmpeg->base.set_tile_region(dev, i);
-
-        /* PMPEG init */
-        nv_wr32(dev, 0x00b32c, 0x00000000);
-        nv_wr32(dev, 0x00b314, 0x00000100);
-        nv_wr32(dev, 0x00b220, nv44_graph_class(dev) ? 0x00000044 : 0x00000031);
-        nv_wr32(dev, 0x00b300, 0x02001ec1);
-        nv_mask(dev, 0x00b32c, 0x00000001, 0x00000001);
-
-        nv_wr32(dev, 0x00b100, 0xffffffff);
-        nv_wr32(dev, 0x00b140, 0xffffffff);
-
-        if (!nv_wait(dev, 0x00b200, 0x00000001, 0x00000000)) {
-                NV_ERROR(dev, "PMPEG init: 0x%08x\n", nv_rd32(dev, 0x00b200));
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static int
-nv31_mpeg_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        /*XXX: context save? */
-        nv_mask(dev, 0x00b32c, 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x00b140, 0x00000000);
-        return 0;
-}
-
-static int
-nv31_mpeg_mthd_dma(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        struct drm_device *dev = chan->dev;
-        u32 inst = data << 4;
-        u32 dma0 = nv_ri32(dev, inst + 0);
-        u32 dma1 = nv_ri32(dev, inst + 4);
-        u32 dma2 = nv_ri32(dev, inst + 8);
-        u32 base = (dma2 & 0xfffff000) | (dma0 >> 20);
-        u32 size = dma1 + 1;
-
-        /* only allow linear DMA objects */
-        if (!(dma0 & 0x00002000))
-                return -EINVAL;
-
-        if (mthd == 0x0190) {
-                /* DMA_CMD */
-                nv_mask(dev, 0x00b300, 0x00030000, (dma0 & 0x00030000));
-                nv_wr32(dev, 0x00b334, base);
-                nv_wr32(dev, 0x00b324, size);
-        } else
-        if (mthd == 0x01a0) {
-                /* DMA_DATA */
-                nv_mask(dev, 0x00b300, 0x000c0000, (dma0 & 0x00030000) << 2);
-                nv_wr32(dev, 0x00b360, base);
-                nv_wr32(dev, 0x00b364, size);
-        } else {
-                /* DMA_IMAGE, VRAM only */
-                if (dma0 & 0x000c0000)
-                        return -EINVAL;
-
-                nv_wr32(dev, 0x00b370, base);
-                nv_wr32(dev, 0x00b374, size);
-        }
-
-        return 0;
-}
-
-static int
-nv31_mpeg_isr_chid(struct drm_device *dev, u32 inst)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ctx;
-        unsigned long flags;
-        int i;
-
-        /* hardcode drm channel id on nv3x, so swmthd lookup works */
-        if (dev_priv->card_type < NV_40)
-                return 0;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (i = 0; i < pfifo->channels; i++) {
-                if (!dev_priv->channels.ptr[i])
-                        continue;
-
-                ctx = dev_priv->channels.ptr[i]->engctx[NVOBJ_ENGINE_MPEG];
-                if (ctx && ctx->pinst == inst)
-                        break;
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return i;
-}
-
-static void
-nv31_vpe_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        nv_wr32(dev, 0x00b008 + (i * 0x10), tile->pitch);
-        nv_wr32(dev, 0x00b004 + (i * 0x10), tile->limit);
-        nv_wr32(dev, 0x00b000 + (i * 0x10), tile->addr);
-}
-
-static void
-nv31_mpeg_isr(struct drm_device *dev)
-{
-        u32 inst = (nv_rd32(dev, 0x00b318) & 0x000fffff) << 4;
-        u32 chid = nv31_mpeg_isr_chid(dev, inst);
-        u32 stat = nv_rd32(dev, 0x00b100);
-        u32 type = nv_rd32(dev, 0x00b230);
-        u32 mthd = nv_rd32(dev, 0x00b234);
-        u32 data = nv_rd32(dev, 0x00b238);
-        u32 show = stat;
-
-        if (stat & 0x01000000) {
-                /* happens on initial binding of the object */
-                if (type == 0x00000020 && mthd == 0x0000) {
-                        nv_mask(dev, 0x00b308, 0x00000000, 0x00000000);
-                        show &= ~0x01000000;
-                }
-
-                if (type == 0x00000010) {
-                        if (!nouveau_gpuobj_mthd_call2(dev, chid, 0x3174, mthd, data))
-                                show &= ~0x01000000;
-                }
-        }
-
-        nv_wr32(dev, 0x00b100, stat);
-        nv_wr32(dev, 0x00b230, 0x00000001);
-
-        if (show && nouveau_ratelimit()) {
-                NV_INFO(dev, "PMPEG: Ch %d [0x%08x] 0x%08x 0x%08x 0x%08x 0x%08x\n",
-                        chid, inst, stat, type, mthd, data);
-        }
-}
-
-static void
-nv31_vpe_isr(struct drm_device *dev)
-{
-        if (nv_rd32(dev, 0x00b100))
-                nv31_mpeg_isr(dev);
-
-        if (nv_rd32(dev, 0x00b800)) {
-                u32 stat = nv_rd32(dev, 0x00b800);
-                NV_INFO(dev, "PMSRCH: 0x%08x\n", stat);
-                nv_wr32(dev, 0xb800, stat);
-        }
-}
-
-static void
-nv31_mpeg_destroy(struct drm_device *dev, int engine)
-{
-        struct nv31_mpeg_engine *pmpeg = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 0);
-
-        NVOBJ_ENGINE_DEL(dev, MPEG);
-        kfree(pmpeg);
-}
-
-int
-nv31_mpeg_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv31_mpeg_engine *pmpeg;
-
-        pmpeg = kzalloc(sizeof(*pmpeg), GFP_KERNEL);
-        if (!pmpeg)
-                return -ENOMEM;
-        atomic_set(&pmpeg->refcount, 0);
-
-        pmpeg->base.destroy = nv31_mpeg_destroy;
-        pmpeg->base.init = nv31_mpeg_init;
-        pmpeg->base.fini = nv31_mpeg_fini;
-        if (dev_priv->card_type < NV_40) {
-                pmpeg->base.context_new = nv31_mpeg_context_new;
-                pmpeg->base.context_del = nv31_mpeg_context_del;
-        } else {
-                pmpeg->base.context_new = nv40_mpeg_context_new;
-                pmpeg->base.context_del = nv40_mpeg_context_del;
-        }
-        pmpeg->base.object_new = nv31_mpeg_object_new;
-
-        /* ISR vector, PMC_ENABLE bit,  and TILE regs are shared between
-         * all VPE engines, for this driver's purposes the PMPEG engine
-         * will be treated as the "master" and handle the global VPE
-         * bits too
-         */
-        pmpeg->base.set_tile_region = nv31_vpe_set_tile_region;
-        nouveau_irq_register(dev, 0, nv31_vpe_isr);
-
-        NVOBJ_ENGINE_ADD(dev, MPEG, &pmpeg->base);
-        NVOBJ_CLASS(dev, 0x3174, MPEG);
-        NVOBJ_MTHD (dev, 0x3174, 0x0190, nv31_mpeg_mthd_dma);
-        NVOBJ_MTHD (dev, 0x3174, 0x01a0, nv31_mpeg_mthd_dma);
-        NVOBJ_MTHD (dev, 0x3174, 0x01b0, nv31_mpeg_mthd_dma);
-
-#if 0
-        NVOBJ_ENGINE_ADD(dev, ME, &pme->base);
-        NVOBJ_CLASS(dev, 0x4075, ME);
-#endif
-        return 0;
-
-}
diff --git a/drivers/gpu/drm/nouveau/nv40_fb.c b/drivers/gpu/drm/nouveau/nv40_fb.c
deleted file mode 100644
index 7fbcb334c096..000000000000
--- a/drivers/gpu/drm/nouveau/nv40_fb.c
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-void
-nv40_fb_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        switch (dev_priv->chipset) {
-        case 0x40:
-                nv_wr32(dev, NV10_PFB_TLIMIT(i), tile->limit);
-                nv_wr32(dev, NV10_PFB_TSIZE(i), tile->pitch);
-                nv_wr32(dev, NV10_PFB_TILE(i), tile->addr);
-                break;
-
-        default:
-                nv_wr32(dev, NV40_PFB_TLIMIT(i), tile->limit);
-                nv_wr32(dev, NV40_PFB_TSIZE(i), tile->pitch);
-                nv_wr32(dev, NV40_PFB_TILE(i), tile->addr);
-                break;
-        }
-}
-
-static void
-nv40_fb_init_gart(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gart = dev_priv->gart_info.sg_ctxdma;
-
-        if (dev_priv->gart_info.type != NOUVEAU_GART_HW) {
-                nv_wr32(dev, 0x100800, 0x00000001);
-                return;
-        }
-
-        nv_wr32(dev, 0x100800, gart->pinst | 0x00000002);
-        nv_mask(dev, 0x10008c, 0x00000100, 0x00000100);
-        nv_wr32(dev, 0x100820, 0x00000000);
-}
-
-static void
-nv44_fb_init_gart(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *gart = dev_priv->gart_info.sg_ctxdma;
-        u32 vinst;
-
-        if (dev_priv->gart_info.type != NOUVEAU_GART_HW) {
-                nv_wr32(dev, 0x100850, 0x80000000);
-                nv_wr32(dev, 0x100800, 0x00000001);
-                return;
-        }
-
-        /* calculate vram address of this PRAMIN block, object
-         * must be allocated on 512KiB alignment, and not exceed
-         * a total size of 512KiB for this to work correctly
-         */
-        vinst  = nv_rd32(dev, 0x10020c);
-        vinst -= ((gart->pinst >> 19) + 1) << 19;
-
-        nv_wr32(dev, 0x100850, 0x80000000);
-        nv_wr32(dev, 0x100818, dev_priv->gart_info.dummy.addr);
-
-        nv_wr32(dev, 0x100804, dev_priv->gart_info.aper_size);
-        nv_wr32(dev, 0x100850, 0x00008000);
-        nv_mask(dev, 0x10008c, 0x00000200, 0x00000200);
-        nv_wr32(dev, 0x100820, 0x00000000);
-        nv_wr32(dev, 0x10082c, 0x00000001);
-        nv_wr32(dev, 0x100800, vinst | 0x00000010);
-}
-
-int
-nv40_fb_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        /* 0x001218 is actually present on a few other NV4X I looked at,
-         * and even contains sane values matching 0x100474.  From looking
-         * at various vbios images however, this isn't the case everywhere.
-         * So, I chose to use the same regs I've seen NVIDIA reading around
-         * the memory detection, hopefully that'll get us the right numbers
-         */
-        if (dev_priv->chipset == 0x40) {
-                u32 pbus1218 = nv_rd32(dev, 0x001218);
-                switch (pbus1218 & 0x00000300) {
-                case 0x00000000: dev_priv->vram_type = NV_MEM_TYPE_SDRAM; break;
-                case 0x00000100: dev_priv->vram_type = NV_MEM_TYPE_DDR1; break;
-                case 0x00000200: dev_priv->vram_type = NV_MEM_TYPE_GDDR3; break;
-                case 0x00000300: dev_priv->vram_type = NV_MEM_TYPE_DDR2; break;
-                }
-        } else
-        if (dev_priv->chipset == 0x49 || dev_priv->chipset == 0x4b) {
-                u32 pfb914 = nv_rd32(dev, 0x100914);
-                switch (pfb914 & 0x00000003) {
-                case 0x00000000: dev_priv->vram_type = NV_MEM_TYPE_DDR1; break;
-                case 0x00000001: dev_priv->vram_type = NV_MEM_TYPE_DDR2; break;
-                case 0x00000002: dev_priv->vram_type = NV_MEM_TYPE_GDDR3; break;
-                case 0x00000003: break;
-                }
-        } else
-        if (dev_priv->chipset != 0x4e) {
-                u32 pfb474 = nv_rd32(dev, 0x100474);
-                if (pfb474 & 0x00000004)
-                        dev_priv->vram_type = NV_MEM_TYPE_GDDR3;
-                if (pfb474 & 0x00000002)
-                        dev_priv->vram_type = NV_MEM_TYPE_DDR2;
-                if (pfb474 & 0x00000001)
-                        dev_priv->vram_type = NV_MEM_TYPE_DDR1;
-        } else {
-                dev_priv->vram_type = NV_MEM_TYPE_STOLEN;
-        }
-
-        dev_priv->vram_size = nv_rd32(dev, 0x10020c) & 0xff000000;
-        return 0;
-}
-
-int
-nv40_fb_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        uint32_t tmp;
-        int i;
-
-        if (dev_priv->chipset != 0x40 && dev_priv->chipset != 0x45) {
-                if (nv44_graph_class(dev))
-                        nv44_fb_init_gart(dev);
-                else
-                        nv40_fb_init_gart(dev);
-        }
-
-        switch (dev_priv->chipset) {
-        case 0x40:
-        case 0x45:
-                tmp = nv_rd32(dev, NV10_PFB_CLOSE_PAGE2);
-                nv_wr32(dev, NV10_PFB_CLOSE_PAGE2, tmp & ~(1 << 15));
-                pfb->num_tiles = NV10_PFB_TILE__SIZE;
-                break;
-        case 0x46: /* G72 */
-        case 0x47: /* G70 */
-        case 0x49: /* G71 */
-        case 0x4b: /* G73 */
-        case 0x4c: /* C51 (G7X version) */
-                pfb->num_tiles = NV40_PFB_TILE__SIZE_1;
-                break;
-        default:
-                pfb->num_tiles = NV40_PFB_TILE__SIZE_0;
-                break;
-        }
-
-        /* Turn all the tiling regions off. */
-        for (i = 0; i < pfb->num_tiles; i++)
-                pfb->set_tile_region(dev, i);
-
-        return 0;
-}
-
-void
-nv40_fb_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv40_fifo.c b/drivers/gpu/drm/nouveau/nv40_fifo.c
deleted file mode 100644
index cdc818479b0a..000000000000
--- a/drivers/gpu/drm/nouveau/nv40_fifo.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright (C) 2012 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_util.h"
-#include "nouveau_ramht.h"
-
-static struct ramfc_desc {
-        unsigned bits:6;
-        unsigned ctxs:5;
-        unsigned ctxp:8;
-        unsigned regs:5;
-        unsigned regp;
-} nv40_ramfc[] = {
-        { 32,  0, 0x00,  0, NV04_PFIFO_CACHE1_DMA_PUT },
-        { 32,  0, 0x04,  0, NV04_PFIFO_CACHE1_DMA_GET },
-        { 32,  0, 0x08,  0, NV10_PFIFO_CACHE1_REF_CNT },
-        { 32,  0, 0x0c,  0, NV04_PFIFO_CACHE1_DMA_INSTANCE },
-        { 32,  0, 0x10,  0, NV04_PFIFO_CACHE1_DMA_DCOUNT },
-        { 32,  0, 0x14,  0, NV04_PFIFO_CACHE1_DMA_STATE },
-        { 28,  0, 0x18,  0, NV04_PFIFO_CACHE1_DMA_FETCH },
-        {  2, 28, 0x18, 28, 0x002058 },
-        { 32,  0, 0x1c,  0, NV04_PFIFO_CACHE1_ENGINE },
-        { 32,  0, 0x20,  0, NV04_PFIFO_CACHE1_PULL1 },
-        { 32,  0, 0x24,  0, NV10_PFIFO_CACHE1_ACQUIRE_VALUE },
-        { 32,  0, 0x28,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMESTAMP },
-        { 32,  0, 0x2c,  0, NV10_PFIFO_CACHE1_ACQUIRE_TIMEOUT },
-        { 32,  0, 0x30,  0, NV10_PFIFO_CACHE1_SEMAPHORE },
-        { 32,  0, 0x34,  0, NV10_PFIFO_CACHE1_DMA_SUBROUTINE },
-        { 32,  0, 0x38,  0, NV40_PFIFO_GRCTX_INSTANCE },
-        { 17,  0, 0x3c,  0, NV04_PFIFO_DMA_TIMESLICE },
-        { 32,  0, 0x40,  0, 0x0032e4 },
-        { 32,  0, 0x44,  0, 0x0032e8 },
-        { 32,  0, 0x4c,  0, 0x002088 },
-        { 32,  0, 0x50,  0, 0x003300 },
-        { 32,  0, 0x54,  0, 0x00330c },
-        {}
-};
-
-struct nv40_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct ramfc_desc *ramfc_desc;
-};
-
-struct nv40_fifo_chan {
-        struct nouveau_fifo_chan base;
-        struct nouveau_gpuobj *ramfc;
-};
-
-static int
-nv40_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv40_fifo_priv *priv = nv_engine(dev, engine);
-        struct nv40_fifo_chan *fctx;
-        unsigned long flags;
-        int ret;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-
-        /* map channel control registers */
-        chan->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                             NV03_USER(chan->id), PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        /* initialise default fifo context */
-        ret = nouveau_gpuobj_new_fake(dev, dev_priv->ramfc->pinst +
-                                      chan->id * 128, ~0, 128,
-                                      NVOBJ_FLAG_ZERO_ALLOC |
-                                      NVOBJ_FLAG_ZERO_FREE, &fctx->ramfc);
-        if (ret)
-                goto error;
-
-        nv_wo32(fctx->ramfc, 0x00, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x04, chan->pushbuf_base);
-        nv_wo32(fctx->ramfc, 0x0c, chan->pushbuf->pinst >> 4);
-        nv_wo32(fctx->ramfc, 0x18, 0x30000000 |
-                                   NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES |
-                                   NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES |
-#ifdef __BIG_ENDIAN
-                                   NV_PFIFO_CACHE1_BIG_ENDIAN |
-#endif
-                                   NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8);
-        nv_wo32(fctx->ramfc, 0x3c, 0x0001ffff);
-
-        /* enable dma mode on the channel */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, NV04_PFIFO_MODE, (1 << chan->id), (1 << chan->id));
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /*XXX: remove this later, need fifo engine context commit hook */
-        nouveau_gpuobj_ref(fctx->ramfc, &chan->ramfc);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static int
-nv40_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv40_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-
-        nv_mask(dev, NV03_PMC_ENABLE, NV_PMC_ENABLE_PFIFO, 0);
-        nv_mask(dev, NV03_PMC_ENABLE, NV_PMC_ENABLE_PFIFO, NV_PMC_ENABLE_PFIFO);
-
-        nv_wr32(dev, 0x002040, 0x000000ff);
-        nv_wr32(dev, 0x002044, 0x2101ffff);
-        nv_wr32(dev, 0x002058, 0x00000001);
-
-        nv_wr32(dev, NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ |
-                                       ((dev_priv->ramht->bits - 9) << 16) |
-                                       (dev_priv->ramht->gpuobj->pinst >> 8));
-        nv_wr32(dev, NV03_PFIFO_RAMRO, dev_priv->ramro->pinst >> 8);
-
-        switch (dev_priv->chipset) {
-        case 0x47:
-        case 0x49:
-        case 0x4b:
-                nv_wr32(dev, 0x002230, 0x00000001);
-        case 0x40:
-        case 0x41:
-        case 0x42:
-        case 0x43:
-        case 0x45:
-        case 0x48:
-                nv_wr32(dev, 0x002220, 0x00030002);
-                break;
-        default:
-                nv_wr32(dev, 0x002230, 0x00000000);
-                nv_wr32(dev, 0x002220, ((dev_priv->vram_size - 512 * 1024 +
-                                         dev_priv->ramfc->pinst) >> 16) |
-                                       0x00030000);
-                break;
-        }
-
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH1, priv->base.channels);
-
-        nv_wr32(dev, NV03_PFIFO_INTR_0, 0xffffffff);
-        nv_wr32(dev, NV03_PFIFO_INTR_EN_0, 0xffffffff);
-
-        nv_wr32(dev, NV03_PFIFO_CACHE1_PUSH0, 1);
-        nv_wr32(dev, NV04_PFIFO_CACHE1_PULL0, 1);
-        nv_wr32(dev, NV03_PFIFO_CACHES, 1);
-
-        for (i = 0; i < priv->base.channels; i++) {
-                if (dev_priv->channels.ptr[i])
-                        nv_mask(dev, NV04_PFIFO_MODE, (1 << i), (1 << i));
-        }
-
-        return 0;
-}
-
-int
-nv40_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv40_fifo_priv *priv;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nv04_fifo_destroy;
-        priv->base.base.init = nv40_fifo_init;
-        priv->base.base.fini = nv04_fifo_fini;
-        priv->base.base.context_new = nv40_fifo_context_new;
-        priv->base.base.context_del = nv04_fifo_context_del;
-        priv->base.channels = 31;
-        priv->ramfc_desc = nv40_ramfc;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        nouveau_irq_register(dev, 8, nv04_fifo_isr);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv40_graph.c b/drivers/gpu/drm/nouveau/nv40_graph.c
deleted file mode 100644
index aa9e2df64a26..000000000000
--- a/drivers/gpu/drm/nouveau/nv40_graph.c
+++ /dev/null
@@ -1,467 +0,0 @@
-/*
- * Copyright (C) 2007 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-
-struct nv40_graph_engine {
-        struct nouveau_exec_engine base;
-        u32 grctx_size;
-};
-
-static int
-nv40_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv40_graph_engine *pgraph = nv_engine(chan->dev, engine);
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *grctx = NULL;
-        unsigned long flags;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, NULL, pgraph->grctx_size, 16,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &grctx);
-        if (ret)
-                return ret;
-
-        /* Initialise default context values */
-        nv40_grctx_fill(dev, grctx);
-        nv_wo32(grctx, 0, grctx->vinst);
-
-        /* init grctx pointer in ramfc, and on PFIFO if channel is
-         * already active there
-         */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_wo32(chan->ramfc, 0x38, grctx->vinst >> 4);
-        nv_mask(dev, 0x002500, 0x00000001, 0x00000000);
-        if ((nv_rd32(dev, 0x003204) & 0x0000001f) == chan->id)
-                nv_wr32(dev, 0x0032e0, grctx->vinst >> 4);
-        nv_mask(dev, 0x002500, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        chan->engctx[engine] = grctx;
-        return 0;
-}
-
-static void
-nv40_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nouveau_gpuobj *grctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 inst = 0x01000000 | (grctx->pinst >> 4);
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x400720, 0x00000000, 0x00000001);
-        if (nv_rd32(dev, 0x40032c) == inst)
-                nv_mask(dev, 0x40032c, 0x01000000, 0x00000000);
-        if (nv_rd32(dev, 0x400330) == inst)
-                nv_mask(dev, 0x400330, 0x01000000, 0x00000000);
-        nv_mask(dev, 0x400720, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* Free the context resources */
-        nouveau_gpuobj_ref(NULL, &grctx);
-        chan->engctx[engine] = NULL;
-}
-
-int
-nv40_graph_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 20, 16, NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 1;
-        obj->class  = class;
-
-        nv_wo32(obj, 0x00, class);
-        nv_wo32(obj, 0x04, 0x00000000);
-#ifndef __BIG_ENDIAN
-        nv_wo32(obj, 0x08, 0x00000000);
-#else
-        nv_wo32(obj, 0x08, 0x01000000);
-#endif
-        nv_wo32(obj, 0x0c, 0x00000000);
-        nv_wo32(obj, 0x10, 0x00000000);
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static void
-nv40_graph_set_tile_region(struct drm_device *dev, int i)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_tile_reg *tile = &dev_priv->tile.reg[i];
-
-        switch (dev_priv->chipset) {
-        case 0x40:
-        case 0x41: /* guess */
-        case 0x42:
-        case 0x43:
-        case 0x45: /* guess */
-        case 0x4e:
-                nv_wr32(dev, NV20_PGRAPH_TSIZE(i), tile->pitch);
-                nv_wr32(dev, NV20_PGRAPH_TLIMIT(i), tile->limit);
-                nv_wr32(dev, NV20_PGRAPH_TILE(i), tile->addr);
-                nv_wr32(dev, NV40_PGRAPH_TSIZE1(i), tile->pitch);
-                nv_wr32(dev, NV40_PGRAPH_TLIMIT1(i), tile->limit);
-                nv_wr32(dev, NV40_PGRAPH_TILE1(i), tile->addr);
-                break;
-        case 0x44:
-        case 0x4a:
-                nv_wr32(dev, NV20_PGRAPH_TSIZE(i), tile->pitch);
-                nv_wr32(dev, NV20_PGRAPH_TLIMIT(i), tile->limit);
-                nv_wr32(dev, NV20_PGRAPH_TILE(i), tile->addr);
-                break;
-        case 0x46:
-        case 0x47:
-        case 0x49:
-        case 0x4b:
-        case 0x4c:
-        case 0x67:
-        default:
-                nv_wr32(dev, NV47_PGRAPH_TSIZE(i), tile->pitch);
-                nv_wr32(dev, NV47_PGRAPH_TLIMIT(i), tile->limit);
-                nv_wr32(dev, NV47_PGRAPH_TILE(i), tile->addr);
-                nv_wr32(dev, NV40_PGRAPH_TSIZE1(i), tile->pitch);
-                nv_wr32(dev, NV40_PGRAPH_TLIMIT1(i), tile->limit);
-                nv_wr32(dev, NV40_PGRAPH_TILE1(i), tile->addr);
-                break;
-        }
-}
-
-/*
- * G70          0x47
- * G71          0x49
- * NV45         0x48
- * G72[M]       0x46
- * G73          0x4b
- * C51_G7X      0x4c
- * C51          0x4e
- */
-int
-nv40_graph_init(struct drm_device *dev, int engine)
-{
-        struct nv40_graph_engine *pgraph = nv_engine(dev, engine);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        uint32_t vramsz;
-        int i, j;
-
-        nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) &
-                        ~NV_PMC_ENABLE_PGRAPH);
-        nv_wr32(dev, NV03_PMC_ENABLE, nv_rd32(dev, NV03_PMC_ENABLE) |
-                         NV_PMC_ENABLE_PGRAPH);
-
-        /* generate and upload context program */
-        nv40_grctx_init(dev, &pgraph->grctx_size);
-
-        /* No context present currently */
-        nv_wr32(dev, NV40_PGRAPH_CTXCTL_CUR, 0x00000000);
-
-        nv_wr32(dev, NV03_PGRAPH_INTR   , 0xFFFFFFFF);
-        nv_wr32(dev, NV40_PGRAPH_INTR_EN, 0xFFFFFFFF);
-
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0xFFFFFFFF);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_0, 0x00000000);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_1, 0x401287c0);
-        nv_wr32(dev, NV04_PGRAPH_DEBUG_3, 0xe0de8055);
-        nv_wr32(dev, NV10_PGRAPH_DEBUG_4, 0x00008000);
-        nv_wr32(dev, NV04_PGRAPH_LIMIT_VIOL_PIX, 0x00be3c5f);
-
-        nv_wr32(dev, NV10_PGRAPH_CTX_CONTROL, 0x10010100);
-        nv_wr32(dev, NV10_PGRAPH_STATE      , 0xFFFFFFFF);
-
-        j = nv_rd32(dev, 0x1540) & 0xff;
-        if (j) {
-                for (i = 0; !(j & 1); j >>= 1, i++)
-                        ;
-                nv_wr32(dev, 0x405000, i);
-        }
-
-        if (dev_priv->chipset == 0x40) {
-                nv_wr32(dev, 0x4009b0, 0x83280fff);
-                nv_wr32(dev, 0x4009b4, 0x000000a0);
-        } else {
-                nv_wr32(dev, 0x400820, 0x83280eff);
-                nv_wr32(dev, 0x400824, 0x000000a0);
-        }
-
-        switch (dev_priv->chipset) {
-        case 0x40:
-        case 0x45:
-                nv_wr32(dev, 0x4009b8, 0x0078e366);
-                nv_wr32(dev, 0x4009bc, 0x0000014c);
-                break;
-        case 0x41:
-        case 0x42: /* pciid also 0x00Cx */
-        /* case 0x0120: XXX (pciid) */
-                nv_wr32(dev, 0x400828, 0x007596ff);
-                nv_wr32(dev, 0x40082c, 0x00000108);
-                break;
-        case 0x43:
-                nv_wr32(dev, 0x400828, 0x0072cb77);
-                nv_wr32(dev, 0x40082c, 0x00000108);
-                break;
-        case 0x44:
-        case 0x46: /* G72 */
-        case 0x4a:
-        case 0x4c: /* G7x-based C51 */
-        case 0x4e:
-                nv_wr32(dev, 0x400860, 0);
-                nv_wr32(dev, 0x400864, 0);
-                break;
-        case 0x47: /* G70 */
-        case 0x49: /* G71 */
-        case 0x4b: /* G73 */
-                nv_wr32(dev, 0x400828, 0x07830610);
-                nv_wr32(dev, 0x40082c, 0x0000016A);
-                break;
-        default:
-                break;
-        }
-
-        nv_wr32(dev, 0x400b38, 0x2ffff800);
-        nv_wr32(dev, 0x400b3c, 0x00006000);
-
-        /* Tiling related stuff. */
-        switch (dev_priv->chipset) {
-        case 0x44:
-        case 0x4a:
-                nv_wr32(dev, 0x400bc4, 0x1003d888);
-                nv_wr32(dev, 0x400bbc, 0xb7a7b500);
-                break;
-        case 0x46:
-                nv_wr32(dev, 0x400bc4, 0x0000e024);
-                nv_wr32(dev, 0x400bbc, 0xb7a7b520);
-                break;
-        case 0x4c:
-        case 0x4e:
-        case 0x67:
-                nv_wr32(dev, 0x400bc4, 0x1003d888);
-                nv_wr32(dev, 0x400bbc, 0xb7a7b540);
-                break;
-        default:
-                break;
-        }
-
-        /* Turn all the tiling regions off. */
-        for (i = 0; i < pfb->num_tiles; i++)
-                nv40_graph_set_tile_region(dev, i);
-
-        /* begin RAM config */
-        vramsz = pci_resource_len(dev->pdev, 0) - 1;
-        switch (dev_priv->chipset) {
-        case 0x40:
-                nv_wr32(dev, 0x4009A4, nv_rd32(dev, NV04_PFB_CFG0));
-                nv_wr32(dev, 0x4009A8, nv_rd32(dev, NV04_PFB_CFG1));
-                nv_wr32(dev, 0x4069A4, nv_rd32(dev, NV04_PFB_CFG0));
-                nv_wr32(dev, 0x4069A8, nv_rd32(dev, NV04_PFB_CFG1));
-                nv_wr32(dev, 0x400820, 0);
-                nv_wr32(dev, 0x400824, 0);
-                nv_wr32(dev, 0x400864, vramsz);
-                nv_wr32(dev, 0x400868, vramsz);
-                break;
-        default:
-                switch (dev_priv->chipset) {
-                case 0x41:
-                case 0x42:
-                case 0x43:
-                case 0x45:
-                case 0x4e:
-                case 0x44:
-                case 0x4a:
-                        nv_wr32(dev, 0x4009F0, nv_rd32(dev, NV04_PFB_CFG0));
-                        nv_wr32(dev, 0x4009F4, nv_rd32(dev, NV04_PFB_CFG1));
-                        break;
-                default:
-                        nv_wr32(dev, 0x400DF0, nv_rd32(dev, NV04_PFB_CFG0));
-                        nv_wr32(dev, 0x400DF4, nv_rd32(dev, NV04_PFB_CFG1));
-                        break;
-                }
-                nv_wr32(dev, 0x4069F0, nv_rd32(dev, NV04_PFB_CFG0));
-                nv_wr32(dev, 0x4069F4, nv_rd32(dev, NV04_PFB_CFG1));
-                nv_wr32(dev, 0x400840, 0);
-                nv_wr32(dev, 0x400844, 0);
-                nv_wr32(dev, 0x4008A0, vramsz);
-                nv_wr32(dev, 0x4008A4, vramsz);
-                break;
-        }
-
-        return 0;
-}
-
-static int
-nv40_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        u32 inst = nv_rd32(dev, 0x40032c);
-        if (inst & 0x01000000) {
-                nv_wr32(dev, 0x400720, 0x00000000);
-                nv_wr32(dev, 0x400784, inst);
-                nv_mask(dev, 0x400310, 0x00000020, 0x00000020);
-                nv_mask(dev, 0x400304, 0x00000001, 0x00000001);
-                if (!nv_wait(dev, 0x400300, 0x00000001, 0x00000000)) {
-                        u32 insn = nv_rd32(dev, 0x400308);
-                        NV_ERROR(dev, "PGRAPH: ctxprog timeout 0x%08x\n", insn);
-                }
-                nv_mask(dev, 0x40032c, 0x01000000, 0x00000000);
-        }
-        return 0;
-}
-
-static int
-nv40_graph_isr_chid(struct drm_device *dev, u32 inst)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *grctx;
-        unsigned long flags;
-        int i;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (i = 0; i < pfifo->channels; i++) {
-                if (!dev_priv->channels.ptr[i])
-                        continue;
-                grctx = dev_priv->channels.ptr[i]->engctx[NVOBJ_ENGINE_GR];
-
-                if (grctx && grctx->pinst == inst)
-                        break;
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return i;
-}
-
-static void
-nv40_graph_isr(struct drm_device *dev)
-{
-        u32 stat;
-
-        while ((stat = nv_rd32(dev, NV03_PGRAPH_INTR))) {
-                u32 nsource = nv_rd32(dev, NV03_PGRAPH_NSOURCE);
-                u32 nstatus = nv_rd32(dev, NV03_PGRAPH_NSTATUS);
-                u32 inst = (nv_rd32(dev, 0x40032c) & 0x000fffff) << 4;
-                u32 chid = nv40_graph_isr_chid(dev, inst);
-                u32 addr = nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR);
-                u32 subc = (addr & 0x00070000) >> 16;
-                u32 mthd = (addr & 0x00001ffc);
-                u32 data = nv_rd32(dev, NV04_PGRAPH_TRAPPED_DATA);
-                u32 class = nv_rd32(dev, 0x400160 + subc * 4) & 0xffff;
-                u32 show = stat;
-
-                if (stat & NV_PGRAPH_INTR_ERROR) {
-                        if (nsource & NV03_PGRAPH_NSOURCE_ILLEGAL_MTHD) {
-                                if (!nouveau_gpuobj_mthd_call2(dev, chid, class, mthd, data))
-                                        show &= ~NV_PGRAPH_INTR_ERROR;
-                        } else
-                        if (nsource & NV03_PGRAPH_NSOURCE_DMA_VTX_PROTECTION) {
-                                nv_mask(dev, 0x402000, 0, 0);
-                        }
-                }
-
-                nv_wr32(dev, NV03_PGRAPH_INTR, stat);
-                nv_wr32(dev, NV04_PGRAPH_FIFO, 0x00000001);
-
-                if (show && nouveau_ratelimit()) {
-                        NV_INFO(dev, "PGRAPH -");
-                        nouveau_bitfield_print(nv10_graph_intr, show);
-                        printk(" nsource:");
-                        nouveau_bitfield_print(nv04_graph_nsource, nsource);
-                        printk(" nstatus:");
-                        nouveau_bitfield_print(nv10_graph_nstatus, nstatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - ch %d (0x%08x) subc %d "
-                                     "class 0x%04x mthd 0x%04x data 0x%08x\n",
-                                chid, inst, subc, class, mthd, data);
-                }
-        }
-}
-
-static void
-nv40_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nv40_graph_engine *pgraph = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 12);
-
-        NVOBJ_ENGINE_DEL(dev, GR);
-        kfree(pgraph);
-}
-
-int
-nv40_graph_create(struct drm_device *dev)
-{
-        struct nv40_graph_engine *pgraph;
-
-        pgraph = kzalloc(sizeof(*pgraph), GFP_KERNEL);
-        if (!pgraph)
-                return -ENOMEM;
-
-        pgraph->base.destroy = nv40_graph_destroy;
-        pgraph->base.init = nv40_graph_init;
-        pgraph->base.fini = nv40_graph_fini;
-        pgraph->base.context_new = nv40_graph_context_new;
-        pgraph->base.context_del = nv40_graph_context_del;
-        pgraph->base.object_new = nv40_graph_object_new;
-        pgraph->base.set_tile_region = nv40_graph_set_tile_region;
-
-        NVOBJ_ENGINE_ADD(dev, GR, &pgraph->base);
-        nouveau_irq_register(dev, 12, nv40_graph_isr);
-
-        NVOBJ_CLASS(dev, 0x0030, GR); /* null */
-        NVOBJ_CLASS(dev, 0x0039, GR); /* m2mf */
-        NVOBJ_CLASS(dev, 0x004a, GR); /* gdirect */
-        NVOBJ_CLASS(dev, 0x009f, GR); /* imageblit (nv12) */
-        NVOBJ_CLASS(dev, 0x008a, GR); /* ifc */
-        NVOBJ_CLASS(dev, 0x0089, GR); /* sifm */
-        NVOBJ_CLASS(dev, 0x3089, GR); /* sifm (nv40) */
-        NVOBJ_CLASS(dev, 0x0062, GR); /* surf2d */
-        NVOBJ_CLASS(dev, 0x3062, GR); /* surf2d (nv40) */
-        NVOBJ_CLASS(dev, 0x0043, GR); /* rop */
-        NVOBJ_CLASS(dev, 0x0012, GR); /* beta1 */
-        NVOBJ_CLASS(dev, 0x0072, GR); /* beta4 */
-        NVOBJ_CLASS(dev, 0x0019, GR); /* cliprect */
-        NVOBJ_CLASS(dev, 0x0044, GR); /* pattern */
-        NVOBJ_CLASS(dev, 0x309e, GR); /* swzsurf */
-
-        /* curie */
-        if (nv44_graph_class(dev))
-                NVOBJ_CLASS(dev, 0x4497, GR);
-        else
-                NVOBJ_CLASS(dev, 0x4097, GR);
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv40_mc.c b/drivers/gpu/drm/nouveau/nv40_mc.c
deleted file mode 100644
index 03c0d4c3f355..000000000000
--- a/drivers/gpu/drm/nouveau/nv40_mc.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-int
-nv40_mc_init(struct drm_device *dev)
-{
-        /* Power up everything, resetting each individual unit will
-         * be done later if needed.
-         */
-        nv_wr32(dev, NV03_PMC_ENABLE, 0xFFFFFFFF);
-
-        if (nv44_graph_class(dev)) {
-                u32 tmp = nv_rd32(dev, NV04_PFB_FIFO_DATA);
-                nv_wr32(dev, NV40_PMC_1700, tmp);
-                nv_wr32(dev, NV40_PMC_1704, 0);
-                nv_wr32(dev, NV40_PMC_1708, 0);
-                nv_wr32(dev, NV40_PMC_170C, tmp);
-        }
-
-        return 0;
-}
-
-void
-nv40_mc_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv40_pm.c b/drivers/gpu/drm/nouveau/nv40_pm.c
index e66273aff493..e9b81a97c481 100644
--- a/drivers/gpu/drm/nouveau/nv40_pm.c
+++ b/drivers/gpu/drm/nouveau/nv40_pm.c
@@ -23,18 +23,24 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_bios.h"
 #include "nouveau_pm.h"
 #include "nouveau_hw.h"
-#include "nouveau_fifo.h"
+
+#include <subdev/bios/pll.h>
+#include <subdev/clock.h>
+#include <subdev/timer.h>
+
+#include <engine/fifo.h>
 
 #define min2(a,b) ((a) < (b) ? (a) : (b))
 
 static u32
 read_pll_1(struct drm_device *dev, u32 reg)
 {
-        u32 ctrl = nv_rd32(dev, reg + 0x00);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ctrl = nv_rd32(device, reg + 0x00);
         int P = (ctrl & 0x00070000) >> 16;
         int N = (ctrl & 0x0000ff00) >> 8;
         int M = (ctrl & 0x000000ff) >> 0;
@@ -49,8 +55,9 @@ read_pll_1(struct drm_device *dev, u32 reg)
 static u32
 read_pll_2(struct drm_device *dev, u32 reg)
 {
-        u32 ctrl = nv_rd32(dev, reg + 0x00);
-        u32 coef = nv_rd32(dev, reg + 0x04);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ctrl = nv_rd32(device, reg + 0x00);
+        u32 coef = nv_rd32(device, reg + 0x04);
         int N2 = (coef & 0xff000000) >> 24;
         int M2 = (coef & 0x00ff0000) >> 16;
         int N1 = (coef & 0x0000ff00) >> 8;
@@ -89,7 +96,8 @@ read_clk(struct drm_device *dev, u32 src)
 int
 nv40_pm_clocks_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        u32 ctrl = nv_rd32(dev, 0x00c040);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ctrl = nv_rd32(device, 0x00c040);
 
         perflvl->core   = read_clk(dev, (ctrl & 0x00000003) >> 0);
         perflvl->shader = read_clk(dev, (ctrl & 0x00000030) >> 4);
@@ -107,27 +115,30 @@ struct nv40_pm_state {
 };
 
 static int
-nv40_calc_pll(struct drm_device *dev, u32 reg, struct pll_lims *pll,
+nv40_calc_pll(struct drm_device *dev, u32 reg, struct nvbios_pll *pll,
               u32 clk, int *N1, int *M1, int *N2, int *M2, int *log2P)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nouveau_clock *pclk = nouveau_clock(device);
         struct nouveau_pll_vals coef;
         int ret;
 
-        ret = get_pll_limits(dev, reg, pll);
+        ret = nvbios_pll_parse(bios, reg, pll);
         if (ret)
                 return ret;
 
-        if (clk < pll->vco1.maxfreq)
-                pll->vco2.maxfreq = 0;
+        if (clk < pll->vco1.max_freq)
+                pll->vco2.max_freq = 0;
 
-        ret = nouveau_calc_pll_mnp(dev, pll, clk, &coef);
+        pclk->pll_calc(pclk, pll, clk, &coef);
         if (ret == 0)
                 return -ERANGE;
 
         *N1 = coef.N1;
         *M1 = coef.M1;
         if (N2 && M2) {
-                if (pll->vco2.maxfreq) {
+                if (pll->vco2.max_freq) {
                         *N2 = coef.N2;
                         *M2 = coef.M2;
                 } else {
@@ -143,7 +154,7 @@ void *
 nv40_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
         struct nv40_pm_state *info;
-        struct pll_lims pll;
+        struct nvbios_pll pll;
         int N1, N2, M1, M2, log2P;
         int ret;
 
@@ -191,7 +202,7 @@ nv40_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
                 goto out;
 
         info->mpll_ctrl  = 0x80000000 | (log2P << 16);
-        info->mpll_ctrl |= min2(pll.log2p_bias + log2P, pll.max_log2p) << 20;
+        info->mpll_ctrl |= min2(pll.bias_p + log2P, pll.max_p) << 20;
         if (N2 == M2) {
                 info->mpll_ctrl |= 0x00000100;
                 info->mpll_coef  = (N1 << 8) | M1;
@@ -212,12 +223,13 @@ static bool
 nv40_pm_gr_idle(void *data)
 {
         struct drm_device *dev = data;
+        struct nouveau_device *device = nouveau_dev(dev);
 
-        if ((nv_rd32(dev, 0x400760) & 0x000000f0) >> 4 !=
-            (nv_rd32(dev, 0x400760) & 0x0000000f))
+        if ((nv_rd32(device, 0x400760) & 0x000000f0) >> 4 !=
+            (nv_rd32(device, 0x400760) & 0x0000000f))
                 return false;
 
-        if (nv_rd32(dev, 0x400700))
+        if (nv_rd32(device, 0x400700))
                 return false;
 
         return true;
@@ -226,7 +238,9 @@ nv40_pm_gr_idle(void *data)
 int
 nv40_pm_clocks_set(struct drm_device *dev, void *pre_state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_fifo *pfifo = nouveau_fifo(device);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv40_pm_state *info = pre_state;
         unsigned long flags;
         struct bit_entry M;
@@ -236,12 +250,12 @@ nv40_pm_clocks_set(struct drm_device *dev, void *pre_state)
 
         /* determine which CRTCs are active, fetch VGA_SR1 for each */
         for (i = 0; i < 2; i++) {
-                u32 vbl = nv_rd32(dev, 0x600808 + (i * 0x2000));
+                u32 vbl = nv_rd32(device, 0x600808 + (i * 0x2000));
                 u32 cnt = 0;
                 do {
-                        if (vbl != nv_rd32(dev, 0x600808 + (i * 0x2000))) {
-                                nv_wr08(dev, 0x0c03c4 + (i * 0x2000), 0x01);
-                                sr1[i] = nv_rd08(dev, 0x0c03c5 + (i * 0x2000));
+                        if (vbl != nv_rd32(device, 0x600808 + (i * 0x2000))) {
+                                nv_wr08(device, 0x0c03c4 + (i * 0x2000), 0x01);
+                                sr1[i] = nv_rd08(device, 0x0c03c5 + (i * 0x2000));
                                 if (!(sr1[i] & 0x20))
                                         crtc_mask |= (1 << i);
                                 break;
@@ -251,28 +265,20 @@ nv40_pm_clocks_set(struct drm_device *dev, void *pre_state)
         }
 
         /* halt and idle engines */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x002500, 0x00000001, 0x00000000);
-        if (!nv_wait(dev, 0x002500, 0x00000010, 0x00000000))
-                goto resume;
-        nv_mask(dev, 0x003220, 0x00000001, 0x00000000);
-        if (!nv_wait(dev, 0x003220, 0x00000010, 0x00000000))
-                goto resume;
-        nv_mask(dev, 0x003200, 0x00000001, 0x00000000);
-        nv04_fifo_cache_pull(dev, false);
+        pfifo->pause(pfifo, &flags);
 
-        if (!nv_wait_cb(dev, nv40_pm_gr_idle, dev))
+        if (!nv_wait_cb(device, nv40_pm_gr_idle, dev))
                 goto resume;
 
         ret = 0;
 
         /* set engine clocks */
-        nv_mask(dev, 0x00c040, 0x00000333, 0x00000000);
-        nv_wr32(dev, 0x004004, info->npll_coef);
-        nv_mask(dev, 0x004000, 0xc0070100, info->npll_ctrl);
-        nv_mask(dev, 0x004008, 0xc007ffff, info->spll);
+        nv_mask(device, 0x00c040, 0x00000333, 0x00000000);
+        nv_wr32(device, 0x004004, info->npll_coef);
+        nv_mask(device, 0x004000, 0xc0070100, info->npll_ctrl);
+        nv_mask(device, 0x004008, 0xc007ffff, info->spll);
         mdelay(5);
-        nv_mask(dev, 0x00c040, 0x00000333, info->ctrl);
+        nv_mask(device, 0x00c040, 0x00000333, info->ctrl);
 
         if (!info->mpll_ctrl)
                 goto resume;
@@ -281,52 +287,52 @@ nv40_pm_clocks_set(struct drm_device *dev, void *pre_state)
         for (i = 0; i < 2; i++) {
                 if (!(crtc_mask & (1 << i)))
                         continue;
-                nv_wait(dev, 0x600808 + (i * 0x2000), 0x00010000, 0x00000000);
-                nv_wait(dev, 0x600808 + (i * 0x2000), 0x00010000, 0x00010000);
-                nv_wr08(dev, 0x0c03c4 + (i * 0x2000), 0x01);
-                nv_wr08(dev, 0x0c03c5 + (i * 0x2000), sr1[i] | 0x20);
+                nv_wait(device, 0x600808 + (i * 0x2000), 0x00010000, 0x00000000);
+                nv_wait(device, 0x600808 + (i * 0x2000), 0x00010000, 0x00010000);
+                nv_wr08(device, 0x0c03c4 + (i * 0x2000), 0x01);
+                nv_wr08(device, 0x0c03c5 + (i * 0x2000), sr1[i] | 0x20);
         }
 
         /* prepare ram for reclocking */
-        nv_wr32(dev, 0x1002d4, 0x00000001); /* precharge */
-        nv_wr32(dev, 0x1002d0, 0x00000001); /* refresh */
-        nv_wr32(dev, 0x1002d0, 0x00000001); /* refresh */
-        nv_mask(dev, 0x100210, 0x80000000, 0x00000000); /* no auto refresh */
-        nv_wr32(dev, 0x1002dc, 0x00000001); /* enable self-refresh */
+        nv_wr32(device, 0x1002d4, 0x00000001); /* precharge */
+        nv_wr32(device, 0x1002d0, 0x00000001); /* refresh */
+        nv_wr32(device, 0x1002d0, 0x00000001); /* refresh */
+        nv_mask(device, 0x100210, 0x80000000, 0x00000000); /* no auto refresh */
+        nv_wr32(device, 0x1002dc, 0x00000001); /* enable self-refresh */
 
         /* change the PLL of each memory partition */
-        nv_mask(dev, 0x00c040, 0x0000c000, 0x00000000);
-        switch (dev_priv->chipset) {
+        nv_mask(device, 0x00c040, 0x0000c000, 0x00000000);
+        switch (nv_device(drm->device)->chipset) {
         case 0x40:
         case 0x45:
         case 0x41:
         case 0x42:
         case 0x47:
-                nv_mask(dev, 0x004044, 0xc0771100, info->mpll_ctrl);
-                nv_mask(dev, 0x00402c, 0xc0771100, info->mpll_ctrl);
-                nv_wr32(dev, 0x004048, info->mpll_coef);
-                nv_wr32(dev, 0x004030, info->mpll_coef);
+                nv_mask(device, 0x004044, 0xc0771100, info->mpll_ctrl);
+                nv_mask(device, 0x00402c, 0xc0771100, info->mpll_ctrl);
+                nv_wr32(device, 0x004048, info->mpll_coef);
+                nv_wr32(device, 0x004030, info->mpll_coef);
         case 0x43:
         case 0x49:
         case 0x4b:
-                nv_mask(dev, 0x004038, 0xc0771100, info->mpll_ctrl);
-                nv_wr32(dev, 0x00403c, info->mpll_coef);
+                nv_mask(device, 0x004038, 0xc0771100, info->mpll_ctrl);
+                nv_wr32(device, 0x00403c, info->mpll_coef);
         default:
-                nv_mask(dev, 0x004020, 0xc0771100, info->mpll_ctrl);
-                nv_wr32(dev, 0x004024, info->mpll_coef);
+                nv_mask(device, 0x004020, 0xc0771100, info->mpll_ctrl);
+                nv_wr32(device, 0x004024, info->mpll_coef);
                 break;
         }
         udelay(100);
-        nv_mask(dev, 0x00c040, 0x0000c000, 0x0000c000);
+        nv_mask(device, 0x00c040, 0x0000c000, 0x0000c000);
 
         /* re-enable normal operation of memory controller */
-        nv_wr32(dev, 0x1002dc, 0x00000000);
-        nv_mask(dev, 0x100210, 0x80000000, 0x80000000);
+        nv_wr32(device, 0x1002dc, 0x00000000);
+        nv_mask(device, 0x100210, 0x80000000, 0x80000000);
         udelay(100);
 
         /* execute memory reset script from vbios */
         if (!bit_table(dev, 'M', &M))
-                nouveau_bios_init_exec(dev, ROM16(M.data[0]));
+                nouveau_bios_run_init_table(dev, ROM16(M.data[0]), NULL, 0);
 
         /* make sure we're in vblank (hopefully the same one as before), and
          * then re-enable crtc memory access
@@ -334,62 +340,14 @@ nv40_pm_clocks_set(struct drm_device *dev, void *pre_state)
         for (i = 0; i < 2; i++) {
                 if (!(crtc_mask & (1 << i)))
                         continue;
-                nv_wait(dev, 0x600808 + (i * 0x2000), 0x00010000, 0x00010000);
-                nv_wr08(dev, 0x0c03c4 + (i * 0x2000), 0x01);
-                nv_wr08(dev, 0x0c03c5 + (i * 0x2000), sr1[i]);
+                nv_wait(device, 0x600808 + (i * 0x2000), 0x00010000, 0x00010000);
+                nv_wr08(device, 0x0c03c4 + (i * 0x2000), 0x01);
+                nv_wr08(device, 0x0c03c5 + (i * 0x2000), sr1[i]);
         }
 
         /* resume engines */
 resume:
-        nv_wr32(dev, 0x003250, 0x00000001);
-        nv_mask(dev, 0x003220, 0x00000001, 0x00000001);
-        nv_wr32(dev, 0x003200, 0x00000001);
-        nv_wr32(dev, 0x002500, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
+        pfifo->start(pfifo, &flags);
         kfree(info);
         return ret;
 }
-
-int
-nv40_pm_pwm_get(struct drm_device *dev, int line, u32 *divs, u32 *duty)
-{
-        if (line == 2) {
-                u32 reg = nv_rd32(dev, 0x0010f0);
-                if (reg & 0x80000000) {
-                        *duty = (reg & 0x7fff0000) >> 16;
-                        *divs = (reg & 0x00007fff);
-                        return 0;
-                }
-        } else
-        if (line == 9) {
-                u32 reg = nv_rd32(dev, 0x0015f4);
-                if (reg & 0x80000000) {
-                        *divs = nv_rd32(dev, 0x0015f8);
-                        *duty = (reg & 0x7fffffff);
-                        return 0;
-                }
-        } else {
-                NV_ERROR(dev, "unknown pwm ctrl for gpio %d\n", line);
-                return -ENODEV;
-        }
-
-        return -EINVAL;
-}
-
-int
-nv40_pm_pwm_set(struct drm_device *dev, int line, u32 divs, u32 duty)
-{
-        if (line == 2) {
-                nv_wr32(dev, 0x0010f0, 0x80000000 | (duty << 16) | divs);
-        } else
-        if (line == 9) {
-                nv_wr32(dev, 0x0015f8, divs);
-                nv_wr32(dev, 0x0015f4, duty | 0x80000000);
-        } else {
-                NV_ERROR(dev, "unknown pwm ctrl for gpio %d\n", line);
-                return -ENODEV;
-        }
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_crtc.c b/drivers/gpu/drm/nouveau/nv50_crtc.c
index 22cebd5dd694..a771e9067ebf 100644
--- a/drivers/gpu/drm/nouveau/nv50_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv50_crtc.c
@@ -28,24 +28,27 @@
 #include "drm_mode.h"
 #include "drm_crtc_helper.h"
 
-#define NOUVEAU_DMA_DEBUG (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
 #include "nouveau_reg.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
+#include "nouveau_gem.h"
 #include "nouveau_hw.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
-#include "nouveau_fb.h"
 #include "nouveau_connector.h"
 #include "nv50_display.h"
 
+#include <subdev/clock.h>
+
 static void
 nv50_crtc_lut_load(struct drm_crtc *crtc)
 {
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         void __iomem *lut = nvbo_kmap_obj_iovirtual(nv_crtc->lut.nvbo);
         int i;
 
-        NV_DEBUG_KMS(crtc->dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         for (i = 0; i < 256; i++) {
                 writew(nv_crtc->lut.r[i] >> 2, lut + 8*i + 0);
@@ -64,25 +67,25 @@ int
 nv50_crtc_blank(struct nouveau_crtc *nv_crtc, bool blanked)
 {
         struct drm_device *dev = nv_crtc->base.dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         int index = nv_crtc->index, ret;
 
-        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
-        NV_DEBUG_KMS(dev, "%s\n", blanked ? "blanked" : "unblanked");
+        NV_DEBUG(drm, "index %d\n", nv_crtc->index);
+        NV_DEBUG(drm, "%s\n", blanked ? "blanked" : "unblanked");
 
         if (blanked) {
                 nv_crtc->cursor.hide(nv_crtc, false);
 
-                ret = RING_SPACE(evo, dev_priv->chipset != 0x50 ? 7 : 5);
+                ret = RING_SPACE(evo, nv_device(drm->device)->chipset != 0x50 ? 7 : 5);
                 if (ret) {
-                        NV_ERROR(dev, "no space while blanking crtc\n");
+                        NV_ERROR(drm, "no space while blanking crtc\n");
                         return ret;
                 }
                 BEGIN_NV04(evo, 0, NV50_EVO_CRTC(index, CLUT_MODE), 2);
                 OUT_RING(evo, NV50_EVO_CRTC_CLUT_MODE_BLANK);
                 OUT_RING(evo, 0);
-                if (dev_priv->chipset != 0x50) {
+                if (nv_device(drm->device)->chipset != 0x50) {
                         BEGIN_NV04(evo, 0, NV84_EVO_CRTC(index, CLUT_DMA), 1);
                         OUT_RING(evo, NV84_EVO_CRTC_CLUT_DMA_HANDLE_NONE);
                 }
@@ -95,9 +98,9 @@ nv50_crtc_blank(struct nouveau_crtc *nv_crtc, bool blanked)
                 else
                         nv_crtc->cursor.hide(nv_crtc, false);
 
-                ret = RING_SPACE(evo, dev_priv->chipset != 0x50 ? 10 : 8);
+                ret = RING_SPACE(evo, nv_device(drm->device)->chipset != 0x50 ? 10 : 8);
                 if (ret) {
-                        NV_ERROR(dev, "no space while unblanking crtc\n");
+                        NV_ERROR(drm, "no space while unblanking crtc\n");
                         return ret;
                 }
                 BEGIN_NV04(evo, 0, NV50_EVO_CRTC(index, CLUT_MODE), 2);
@@ -105,7 +108,7 @@ nv50_crtc_blank(struct nouveau_crtc *nv_crtc, bool blanked)
                                 NV50_EVO_CRTC_CLUT_MODE_OFF :
                                 NV50_EVO_CRTC_CLUT_MODE_ON);
                 OUT_RING(evo, nv_crtc->lut.nvbo->bo.offset >> 8);
-                if (dev_priv->chipset != 0x50) {
+                if (nv_device(drm->device)->chipset != 0x50) {
                         BEGIN_NV04(evo, 0, NV84_EVO_CRTC(index, CLUT_DMA), 1);
                         OUT_RING(evo, NvEvoVRAM);
                 }
@@ -114,7 +117,7 @@ nv50_crtc_blank(struct nouveau_crtc *nv_crtc, bool blanked)
                 OUT_RING(evo, nv_crtc->fb.offset >> 8);
                 OUT_RING(evo, 0);
                 BEGIN_NV04(evo, 0, NV50_EVO_CRTC(index, FB_DMA), 1);
-                if (dev_priv->chipset != 0x50)
+                if (nv_device(drm->device)->chipset != 0x50)
                         if (nv_crtc->fb.tile_flags == 0x7a00 ||
                             nv_crtc->fb.tile_flags == 0xfe00)
                                 OUT_RING(evo, NvEvoFB32);
@@ -174,17 +177,18 @@ static int
 nv50_crtc_set_color_vibrance(struct nouveau_crtc *nv_crtc, bool update)
 {
         struct drm_device *dev = nv_crtc->base.dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         int ret;
         int adj;
         u32 hue, vib;
 
-        NV_DEBUG_KMS(dev, "vibrance = %i, hue = %i\n",
+        NV_DEBUG(drm, "vibrance = %i, hue = %i\n",
                      nv_crtc->color_vibrance, nv_crtc->vibrant_hue);
 
         ret = RING_SPACE(evo, 2 + (update ? 2 : 0));
         if (ret) {
-                NV_ERROR(dev, "no space while setting color vibrance\n");
+                NV_ERROR(drm, "no space while setting color vibrance\n");
                 return ret;
         }
 
@@ -229,17 +233,18 @@ nv50_crtc_set_scale(struct nouveau_crtc *nv_crtc, bool update)
         struct nouveau_connector *nv_connector;
         struct drm_crtc *crtc = &nv_crtc->base;
         struct drm_device *dev = crtc->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         struct drm_display_mode *umode = &crtc->mode;
         struct drm_display_mode *omode;
         int scaling_mode, ret;
         u32 ctrl = 0, oX, oY;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         nv_connector = nouveau_crtc_connector_get(nv_crtc);
         if (!nv_connector || !nv_connector->native_mode) {
-                NV_ERROR(dev, "no native mode, forcing panel scaling\n");
+                NV_ERROR(drm, "no native mode, forcing panel scaling\n");
                 scaling_mode = DRM_MODE_SCALE_NONE;
         } else {
                 scaling_mode = nv_connector->scaling_mode;
@@ -329,63 +334,19 @@ nv50_crtc_set_scale(struct nouveau_crtc *nv_crtc, bool update)
 int
 nv50_crtc_set_clock(struct drm_device *dev, int head, int pclk)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct pll_lims pll;
-        uint32_t reg1, reg2;
-        int ret, N1, M1, N2, M2, P;
-
-        ret = get_pll_limits(dev, PLL_VPLL0 + head, &pll);
-        if (ret)
-                return ret;
-
-        if (pll.vco2.maxfreq) {
-                ret = nv50_calc_pll(dev, &pll, pclk, &N1, &M1, &N2, &M2, &P);
-                if (ret <= 0)
-                        return 0;
-
-                NV_DEBUG(dev, "pclk %d out %d NM1 %d %d NM2 %d %d P %d\n",
-                         pclk, ret, N1, M1, N2, M2, P);
-
-                reg1 = nv_rd32(dev, pll.reg + 4) & 0xff00ff00;
-                reg2 = nv_rd32(dev, pll.reg + 8) & 0x8000ff00;
-                nv_wr32(dev, pll.reg + 0, 0x10000611);
-                nv_wr32(dev, pll.reg + 4, reg1 | (M1 << 16) | N1);
-                nv_wr32(dev, pll.reg + 8, reg2 | (P << 28) | (M2 << 16) | N2);
-        } else
-        if (dev_priv->chipset < NV_C0) {
-                ret = nva3_calc_pll(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);
-
-                reg1 = nv_rd32(dev, pll.reg + 4) & 0xffc00000;
-                nv_wr32(dev, pll.reg + 0, 0x50000610);
-                nv_wr32(dev, pll.reg + 4, reg1 | (P << 16) | (M1 << 8) | N1);
-                nv_wr32(dev, pll.reg + 8, N2);
-        } else {
-                ret = nva3_calc_pll(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);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_clock *clk = nouveau_clock(device);
 
-                nv_mask(dev, pll.reg + 0x0c, 0x00000000, 0x00000100);
-                nv_wr32(dev, pll.reg + 0x04, (P << 16) | (N1 << 8) | M1);
-                nv_wr32(dev, pll.reg + 0x10, N2 << 16);
-        }
-
-        return 0;
+        return clk->pll_set(clk, PLL_VPLL0 + head, pclk);
 }
 
 static void
 nv50_crtc_destroy(struct drm_crtc *crtc)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
 
-        NV_DEBUG_KMS(crtc->dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         nouveau_bo_unmap(nv_crtc->lut.nvbo);
         nouveau_bo_ref(NULL, &nv_crtc->lut.nvbo);
@@ -474,13 +435,15 @@ nv50_crtc_gamma_set(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
 static void
 nv50_crtc_save(struct drm_crtc *crtc)
 {
-        NV_ERROR(crtc->dev, "!!\n");
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
+        NV_ERROR(drm, "!!\n");
 }
 
 static void
 nv50_crtc_restore(struct drm_crtc *crtc)
 {
-        NV_ERROR(crtc->dev, "!!\n");
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
+        NV_ERROR(drm, "!!\n");
 }
 
 static const struct drm_crtc_funcs nv50_crtc_funcs = {
@@ -504,8 +467,9 @@ nv50_crtc_prepare(struct drm_crtc *crtc)
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_device *dev = crtc->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
+        NV_DEBUG(drm, "index %d\n", nv_crtc->index);
 
         nv50_display_flip_stop(crtc);
         drm_vblank_pre_modeset(dev, nv_crtc->index);
@@ -516,9 +480,10 @@ static void
 nv50_crtc_commit(struct drm_crtc *crtc)
 {
         struct drm_device *dev = crtc->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
 
-        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
+        NV_DEBUG(drm, "index %d\n", nv_crtc->index);
 
         nv50_crtc_blank(nv_crtc, false);
         drm_vblank_post_modeset(dev, nv_crtc->index);
@@ -540,17 +505,17 @@ nv50_crtc_do_mode_set_base(struct drm_crtc *crtc,
 {
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         struct drm_device *dev = nv_crtc->base.dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         struct drm_framebuffer *drm_fb;
         struct nouveau_framebuffer *fb;
         int ret;
 
-        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
+        NV_DEBUG(drm, "index %d\n", nv_crtc->index);
 
         /* no fb bound */
         if (!atomic && !crtc->fb) {
-                NV_DEBUG_KMS(dev, "No FB bound\n");
+                NV_DEBUG(drm, "No FB bound\n");
                 return 0;
         }
 
@@ -580,7 +545,7 @@ nv50_crtc_do_mode_set_base(struct drm_crtc *crtc,
         nv_crtc->fb.offset = fb->nvbo->bo.offset;
         nv_crtc->fb.tile_flags = nouveau_bo_tile_layout(fb->nvbo);
         nv_crtc->fb.cpp = drm_fb->bits_per_pixel / 8;
-        if (!nv_crtc->fb.blanked && dev_priv->chipset != 0x50) {
+        if (!nv_crtc->fb.blanked && nv_device(drm->device)->chipset != 0x50) {
                 ret = RING_SPACE(evo, 2);
                 if (ret)
                         return ret;
@@ -738,10 +703,11 @@ static const struct drm_crtc_helper_funcs nv50_crtc_helper_funcs = {
 int
 nv50_crtc_create(struct drm_device *dev, int index)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_crtc *nv_crtc = NULL;
         int ret, i;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         nv_crtc = kzalloc(sizeof(*nv_crtc), GFP_KERNEL);
         if (!nv_crtc)
diff --git a/drivers/gpu/drm/nouveau/nv50_cursor.c b/drivers/gpu/drm/nouveau/nv50_cursor.c
index af4ec7bf3670..ba047e9251b3 100644
--- a/drivers/gpu/drm/nouveau/nv50_cursor.c
+++ b/drivers/gpu/drm/nouveau/nv50_cursor.c
@@ -27,9 +27,8 @@
 #include "drmP.h"
 #include "drm_mode.h"
 
-#define NOUVEAU_DMA_DEBUG (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
-#include "nouveau_reg.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
 #include "nouveau_crtc.h"
 #include "nv50_display.h"
 
@@ -37,22 +36,22 @@ static void
 nv50_cursor_show(struct nouveau_crtc *nv_crtc, bool update)
 {
         struct drm_device *dev = nv_crtc->base.dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         int ret;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         if (update && nv_crtc->cursor.visible)
                 return;
 
-        ret = RING_SPACE(evo, (dev_priv->chipset != 0x50 ? 5 : 3) + update * 2);
+        ret = RING_SPACE(evo, (nv_device(drm->device)->chipset != 0x50 ? 5 : 3) + update * 2);
         if (ret) {
-                NV_ERROR(dev, "no space while unhiding cursor\n");
+                NV_ERROR(drm, "no space while unhiding cursor\n");
                 return;
         }
 
-        if (dev_priv->chipset != 0x50) {
+        if (nv_device(drm->device)->chipset != 0x50) {
                 BEGIN_NV04(evo, 0, NV84_EVO_CRTC(nv_crtc->index, CURSOR_DMA), 1);
                 OUT_RING(evo, NvEvoVRAM);
         }
@@ -72,24 +71,24 @@ static void
 nv50_cursor_hide(struct nouveau_crtc *nv_crtc, bool update)
 {
         struct drm_device *dev = nv_crtc->base.dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         int ret;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         if (update && !nv_crtc->cursor.visible)
                 return;
 
-        ret = RING_SPACE(evo, (dev_priv->chipset != 0x50 ? 5 : 3) + update * 2);
+        ret = RING_SPACE(evo, (nv_device(drm->device)->chipset != 0x50 ? 5 : 3) + update * 2);
         if (ret) {
-                NV_ERROR(dev, "no space while hiding cursor\n");
+                NV_ERROR(drm, "no space while hiding cursor\n");
                 return;
         }
         BEGIN_NV04(evo, 0, NV50_EVO_CRTC(nv_crtc->index, CURSOR_CTRL), 2);
         OUT_RING(evo, NV50_EVO_CRTC_CURSOR_CTRL_HIDE);
         OUT_RING(evo, 0);
-        if (dev_priv->chipset != 0x50) {
+        if (nv_device(drm->device)->chipset != 0x50) {
                 BEGIN_NV04(evo, 0, NV84_EVO_CRTC(nv_crtc->index, CURSOR_DMA), 1);
                 OUT_RING(evo, NV84_EVO_CRTC_CURSOR_DMA_HANDLE_NONE);
         }
@@ -105,19 +104,18 @@ nv50_cursor_hide(struct nouveau_crtc *nv_crtc, bool update)
 static void
 nv50_cursor_set_pos(struct nouveau_crtc *nv_crtc, int x, int y)
 {
-        struct drm_device *dev = nv_crtc->base.dev;
+        struct nouveau_device *device = nouveau_dev(nv_crtc->base.dev);
 
         nv_crtc->cursor_saved_x = x; nv_crtc->cursor_saved_y = y;
-        nv_wr32(dev, NV50_PDISPLAY_CURSOR_USER_POS(nv_crtc->index),
+        nv_wr32(device, NV50_PDISPLAY_CURSOR_USER_POS(nv_crtc->index),
                 ((y & 0xFFFF) << 16) | (x & 0xFFFF));
         /* Needed to make the cursor move. */
-        nv_wr32(dev, NV50_PDISPLAY_CURSOR_USER_POS_CTRL(nv_crtc->index), 0);
+        nv_wr32(device, NV50_PDISPLAY_CURSOR_USER_POS_CTRL(nv_crtc->index), 0);
 }
 
 static void
 nv50_cursor_set_offset(struct nouveau_crtc *nv_crtc, uint32_t offset)
 {
-        NV_DEBUG_KMS(nv_crtc->base.dev, "\n");
         if (offset == nv_crtc->cursor.offset)
                 return;
 
diff --git a/drivers/gpu/drm/nouveau/nv50_dac.c b/drivers/gpu/drm/nouveau/nv50_dac.c
index 2c36a6b92c53..4a01b49d5ece 100644
--- a/drivers/gpu/drm/nouveau/nv50_dac.c
+++ b/drivers/gpu/drm/nouveau/nv50_dac.c
@@ -29,18 +29,21 @@
 
 #define NOUVEAU_DMA_DEBUG (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
 #include "nouveau_reg.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
 #include "nv50_display.h"
 
+#include <subdev/timer.h>
+
 static void
 nv50_dac_disconnect(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_channel *evo = nv50_display(dev)->master;
         int ret;
 
@@ -48,11 +51,11 @@ nv50_dac_disconnect(struct drm_encoder *encoder)
                 return;
         nv50_crtc_blank(nouveau_crtc(nv_encoder->crtc), true);
 
-        NV_DEBUG_KMS(dev, "Disconnecting DAC %d\n", nv_encoder->or);
+        NV_DEBUG(drm, "Disconnecting DAC %d\n", nv_encoder->or);
 
         ret = RING_SPACE(evo, 4);
         if (ret) {
-                NV_ERROR(dev, "no space while disconnecting DAC\n");
+                NV_ERROR(drm, "no space while disconnecting DAC\n");
                 return;
         }
         BEGIN_NV04(evo, 0, NV50_EVO_DAC(nv_encoder->or, MODE_CTRL), 1);
@@ -67,43 +70,43 @@ static enum drm_connector_status
 nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         enum drm_connector_status status = connector_status_disconnected;
         uint32_t dpms_state, load_pattern, load_state;
         int or = nv_encoder->or;
 
-        nv_wr32(dev, NV50_PDISPLAY_DAC_CLK_CTRL1(or), 0x00000001);
-        dpms_state = nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or));
+        nv_wr32(device, NV50_PDISPLAY_DAC_CLK_CTRL1(or), 0x00000001);
+        dpms_state = nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or));
 
-        nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
+        nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
                 0x00150000 | NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
-        if (!nv_wait(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
+        if (!nv_wait(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
                      NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING, 0)) {
-                NV_ERROR(dev, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
-                NV_ERROR(dev, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
-                          nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
+                NV_ERROR(drm, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
+                NV_ERROR(drm, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
+                          nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
                 return status;
         }
 
         /* Use bios provided value if possible. */
-        if (dev_priv->vbios.dactestval) {
-                load_pattern = dev_priv->vbios.dactestval;
-                NV_DEBUG_KMS(dev, "Using bios provided load_pattern of %d\n",
+        if (drm->vbios.dactestval) {
+                load_pattern = drm->vbios.dactestval;
+                NV_DEBUG(drm, "Using bios provided load_pattern of %d\n",
                           load_pattern);
         } else {
                 load_pattern = 340;
-                NV_DEBUG_KMS(dev, "Using default load_pattern of %d\n",
+                NV_DEBUG(drm, "Using default load_pattern of %d\n",
                          load_pattern);
         }
 
-        nv_wr32(dev, NV50_PDISPLAY_DAC_LOAD_CTRL(or),
+        nv_wr32(device, NV50_PDISPLAY_DAC_LOAD_CTRL(or),
                 NV50_PDISPLAY_DAC_LOAD_CTRL_ACTIVE | load_pattern);
         mdelay(45); /* give it some time to process */
-        load_state = nv_rd32(dev, NV50_PDISPLAY_DAC_LOAD_CTRL(or));
+        load_state = nv_rd32(device, NV50_PDISPLAY_DAC_LOAD_CTRL(or));
 
-        nv_wr32(dev, NV50_PDISPLAY_DAC_LOAD_CTRL(or), 0);
-        nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or), dpms_state |
+        nv_wr32(device, NV50_PDISPLAY_DAC_LOAD_CTRL(or), 0);
+        nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or), dpms_state |
                 NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
 
         if ((load_state & NV50_PDISPLAY_DAC_LOAD_CTRL_PRESENT) ==
@@ -111,9 +114,9 @@ nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
                 status = connector_status_connected;
 
         if (status == connector_status_connected)
-                NV_DEBUG_KMS(dev, "Load was detected on output with or %d\n", or);
+                NV_DEBUG(drm, "Load was detected on output with or %d\n", or);
         else
-                NV_DEBUG_KMS(dev, "Load was not detected on output with or %d\n", or);
+                NV_DEBUG(drm, "Load was not detected on output with or %d\n", or);
 
         return status;
 }
@@ -121,23 +124,24 @@ nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 static void
 nv50_dac_dpms(struct drm_encoder *encoder, int mode)
 {
-        struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         uint32_t val;
         int or = nv_encoder->or;
 
-        NV_DEBUG_KMS(dev, "or %d mode %d\n", or, mode);
+        NV_DEBUG(drm, "or %d mode %d\n", or, mode);
 
         /* wait for it to be done */
-        if (!nv_wait(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
+        if (!nv_wait(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
                      NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING, 0)) {
-                NV_ERROR(dev, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
-                NV_ERROR(dev, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
-                         nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
+                NV_ERROR(drm, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
+                NV_ERROR(drm, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
+                         nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
                 return;
         }
 
-        val = nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or)) & ~0x7F;
+        val = nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or)) & ~0x7F;
 
         if (mode != DRM_MODE_DPMS_ON)
                 val |= NV50_PDISPLAY_DAC_DPMS_CTRL_BLANKED;
@@ -158,20 +162,22 @@ nv50_dac_dpms(struct drm_encoder *encoder, int mode)
                 break;
         }
 
-        nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or), val |
+        nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or), val |
                 NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
 }
 
 static void
 nv50_dac_save(struct drm_encoder *encoder)
 {
-        NV_ERROR(encoder->dev, "!!\n");
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        NV_ERROR(drm, "!!\n");
 }
 
 static void
 nv50_dac_restore(struct drm_encoder *encoder)
 {
-        NV_ERROR(encoder->dev, "!!\n");
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        NV_ERROR(drm, "!!\n");
 }
 
 static bool
@@ -179,14 +185,15 @@ nv50_dac_mode_fixup(struct drm_encoder *encoder,
                     const struct drm_display_mode *mode,
                     struct drm_display_mode *adjusted_mode)
 {
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct nouveau_connector *connector;
 
-        NV_DEBUG_KMS(encoder->dev, "or %d\n", nv_encoder->or);
+        NV_DEBUG(drm, "or %d\n", nv_encoder->or);
 
         connector = nouveau_encoder_connector_get(nv_encoder);
         if (!connector) {
-                NV_ERROR(encoder->dev, "Encoder has no connector\n");
+                NV_ERROR(drm, "Encoder has no connector\n");
                 return false;
         }
 
@@ -207,13 +214,14 @@ nv50_dac_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                   struct drm_display_mode *adjusted_mode)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct drm_device *dev = encoder->dev;
         struct nouveau_channel *evo = nv50_display(dev)->master;
         struct nouveau_crtc *crtc = nouveau_crtc(encoder->crtc);
         uint32_t mode_ctl = 0, mode_ctl2 = 0;
         int ret;
 
-        NV_DEBUG_KMS(dev, "or %d type %d crtc %d\n",
+        NV_DEBUG(drm, "or %d type %d crtc %d\n",
                      nv_encoder->or, nv_encoder->dcb->type, crtc->index);
 
         nv50_dac_dpms(encoder, DRM_MODE_DPMS_ON);
@@ -224,10 +232,10 @@ nv50_dac_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                 mode_ctl |= NV50_EVO_DAC_MODE_CTRL_CRTC0;
 
         /* Lacking a working tv-out, this is not a 100% sure. */
-        if (nv_encoder->dcb->type == OUTPUT_ANALOG)
+        if (nv_encoder->dcb->type == DCB_OUTPUT_ANALOG)
                 mode_ctl |= 0x40;
         else
-        if (nv_encoder->dcb->type == OUTPUT_TV)
+        if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
                 mode_ctl |= 0x100;
 
         if (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC)
@@ -238,7 +246,7 @@ nv50_dac_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
 
         ret = RING_SPACE(evo, 3);
         if (ret) {
-                NV_ERROR(dev, "no space while connecting DAC\n");
+                NV_ERROR(drm, "no space while connecting DAC\n");
                 return;
         }
         BEGIN_NV04(evo, 0, NV50_EVO_DAC(nv_encoder->or, MODE_CTRL), 2);
@@ -271,11 +279,12 @@ static void
 nv50_dac_destroy(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
 
         if (!encoder)
                 return;
 
-        NV_DEBUG_KMS(encoder->dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         drm_encoder_cleanup(encoder);
         kfree(nv_encoder);
@@ -286,7 +295,7 @@ static const struct drm_encoder_funcs nv50_dac_encoder_funcs = {
 };
 
 int
-nv50_dac_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv50_dac_create(struct drm_connector *connector, struct dcb_output *entry)
 {
         struct nouveau_encoder *nv_encoder;
         struct drm_encoder *encoder;
diff --git a/drivers/gpu/drm/nouveau/nv50_display.c b/drivers/gpu/drm/nouveau/nv50_display.c
index b244d9968c5d..787ddc9f314c 100644
--- a/drivers/gpu/drm/nouveau/nv50_display.c
+++ b/drivers/gpu/drm/nouveau/nv50_display.c
@@ -24,28 +24,30 @@
  *
  */
 
-#define NOUVEAU_DMA_DEBUG (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
+
 #include "nv50_display.h"
 #include "nouveau_crtc.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
-#include "nouveau_fb.h"
 #include "nouveau_fbcon.h"
-#include "nouveau_ramht.h"
-#include "nouveau_software.h"
 #include "drm_crtc_helper.h"
+#include "nouveau_fence.h"
+
+#include <core/gpuobj.h>
+#include <subdev/timer.h>
 
-static void nv50_display_isr(struct drm_device *);
 static void nv50_display_bh(unsigned long);
 
 static inline int
 nv50_sor_nr(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
 
-        if (dev_priv->chipset  < 0x90 ||
-            dev_priv->chipset == 0x92 ||
-            dev_priv->chipset == 0xa0)
+        if (device->chipset  < 0x90 ||
+            device->chipset == 0x92 ||
+            device->chipset == 0xa0)
                 return 2;
 
         return 4;
@@ -54,73 +56,29 @@ nv50_sor_nr(struct drm_device *dev)
 u32
 nv50_display_active_crtcs(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
         u32 mask = 0;
         int i;
 
-        if (dev_priv->chipset  < 0x90 ||
-            dev_priv->chipset == 0x92 ||
-            dev_priv->chipset == 0xa0) {
+        if (device->chipset  < 0x90 ||
+            device->chipset == 0x92 ||
+            device->chipset == 0xa0) {
                 for (i = 0; i < 2; i++)
-                        mask |= nv_rd32(dev, NV50_PDISPLAY_SOR_MODE_CTRL_C(i));
+                        mask |= nv_rd32(device, NV50_PDISPLAY_SOR_MODE_CTRL_C(i));
         } else {
                 for (i = 0; i < 4; i++)
-                        mask |= nv_rd32(dev, NV90_PDISPLAY_SOR_MODE_CTRL_C(i));
+                        mask |= nv_rd32(device, NV90_PDISPLAY_SOR_MODE_CTRL_C(i));
         }
 
         for (i = 0; i < 3; i++)
-                mask |= nv_rd32(dev, NV50_PDISPLAY_DAC_MODE_CTRL_C(i));
+                mask |= nv_rd32(device, NV50_PDISPLAY_DAC_MODE_CTRL_C(i));
 
         return mask & 3;
 }
 
-static int
-evo_icmd(struct drm_device *dev, int ch, u32 mthd, u32 data)
-{
-        int ret = 0;
-        nv_mask(dev, 0x610300 + (ch * 0x08), 0x00000001, 0x00000001);
-        nv_wr32(dev, 0x610304 + (ch * 0x08), data);
-        nv_wr32(dev, 0x610300 + (ch * 0x08), 0x80000001 | mthd);
-        if (!nv_wait(dev, 0x610300 + (ch * 0x08), 0x80000000, 0x00000000))
-                ret = -EBUSY;
-        if (ret || (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO))
-                NV_INFO(dev, "EvoPIO: %d 0x%04x 0x%08x\n", ch, mthd, data);
-        nv_mask(dev, 0x610300 + (ch * 0x08), 0x00000001, 0x00000000);
-        return ret;
-}
-
 int
 nv50_display_early_init(struct drm_device *dev)
 {
-        u32 ctrl = nv_rd32(dev, 0x610200);
-        int i;
-
-        /* check if master evo channel is already active, a good a sign as any
-         * that the display engine is in a weird state (hibernate/kexec), if
-         * it is, do our best to reset the display engine...
-         */
-        if ((ctrl & 0x00000003) == 0x00000003) {
-                NV_INFO(dev, "PDISP: EVO(0) 0x%08x, resetting...\n", ctrl);
-
-                /* deactivate both heads first, PDISP will disappear forever
-                 * (well, until you power cycle) on some boards as soon as
-                 * PMC_ENABLE is hit unless they are..
-                 */
-                for (i = 0; i < 2; i++) {
-                        evo_icmd(dev, 0, 0x0880 + (i * 0x400), 0x05000000);
-                        evo_icmd(dev, 0, 0x089c + (i * 0x400), 0);
-                        evo_icmd(dev, 0, 0x0840 + (i * 0x400), 0);
-                        evo_icmd(dev, 0, 0x0844 + (i * 0x400), 0);
-                        evo_icmd(dev, 0, 0x085c + (i * 0x400), 0);
-                        evo_icmd(dev, 0, 0x0874 + (i * 0x400), 0);
-                }
-                evo_icmd(dev, 0, 0x0080, 0);
-
-                /* reset PDISP */
-                nv_mask(dev, 0x000200, 0x40000000, 0x00000000);
-                nv_mask(dev, 0x000200, 0x40000000, 0x40000000);
-        }
-
         return 0;
 }
 
@@ -132,11 +90,8 @@ nv50_display_late_takedown(struct drm_device *dev)
 int
 nv50_display_sync(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
         struct nv50_display *disp = nv50_display(dev);
         struct nouveau_channel *evo = disp->master;
-        u64 start;
         int ret;
 
         ret = RING_SPACE(evo, 6);
@@ -148,29 +103,28 @@ nv50_display_sync(struct drm_device *dev)
                 BEGIN_NV04(evo, 0, 0x0084, 1);
                 OUT_RING  (evo, 0x00000000);
 
-                nv_wo32(disp->ntfy, 0x000, 0x00000000);
+                nv_wo32(disp->ramin, 0x2000, 0x00000000);
                 FIRE_RING (evo);
 
-                start = ptimer->read(dev);
-                do {
-                        if (nv_ro32(disp->ntfy, 0x000))
-                                return 0;
-                } while (ptimer->read(dev) - start < 2000000000ULL);
+                if (nv_wait_ne(disp->ramin, 0x2000, 0xffffffff, 0x00000000))
+                        return 0;
         }
 
-        return -EBUSY;
+        return 0;
 }
 
 int
 nv50_display_init(struct drm_device *dev)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nouveau_channel *evo;
         int ret, i;
         u32 val;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
-        nv_wr32(dev, 0x00610184, nv_rd32(dev, 0x00614004));
+        nv_wr32(device, 0x00610184, nv_rd32(device, 0x00614004));
 
         /*
          * I think the 0x006101XX range is some kind of main control area
@@ -178,82 +132,82 @@ nv50_display_init(struct drm_device *dev)
          */
         /* CRTC? */
         for (i = 0; i < 2; i++) {
-                val = nv_rd32(dev, 0x00616100 + (i * 0x800));
-                nv_wr32(dev, 0x00610190 + (i * 0x10), val);
-                val = nv_rd32(dev, 0x00616104 + (i * 0x800));
-                nv_wr32(dev, 0x00610194 + (i * 0x10), val);
-                val = nv_rd32(dev, 0x00616108 + (i * 0x800));
-                nv_wr32(dev, 0x00610198 + (i * 0x10), val);
-                val = nv_rd32(dev, 0x0061610c + (i * 0x800));
-                nv_wr32(dev, 0x0061019c + (i * 0x10), val);
+                val = nv_rd32(device, 0x00616100 + (i * 0x800));
+                nv_wr32(device, 0x00610190 + (i * 0x10), val);
+                val = nv_rd32(device, 0x00616104 + (i * 0x800));
+                nv_wr32(device, 0x00610194 + (i * 0x10), val);
+                val = nv_rd32(device, 0x00616108 + (i * 0x800));
+                nv_wr32(device, 0x00610198 + (i * 0x10), val);
+                val = nv_rd32(device, 0x0061610c + (i * 0x800));
+                nv_wr32(device, 0x0061019c + (i * 0x10), val);
         }
 
         /* DAC */
         for (i = 0; i < 3; i++) {
-                val = nv_rd32(dev, 0x0061a000 + (i * 0x800));
-                nv_wr32(dev, 0x006101d0 + (i * 0x04), val);
+                val = nv_rd32(device, 0x0061a000 + (i * 0x800));
+                nv_wr32(device, 0x006101d0 + (i * 0x04), val);
         }
 
         /* SOR */
         for (i = 0; i < nv50_sor_nr(dev); i++) {
-                val = nv_rd32(dev, 0x0061c000 + (i * 0x800));
-                nv_wr32(dev, 0x006101e0 + (i * 0x04), val);
+                val = nv_rd32(device, 0x0061c000 + (i * 0x800));
+                nv_wr32(device, 0x006101e0 + (i * 0x04), val);
         }
 
         /* EXT */
         for (i = 0; i < 3; i++) {
-                val = nv_rd32(dev, 0x0061e000 + (i * 0x800));
-                nv_wr32(dev, 0x006101f0 + (i * 0x04), val);
+                val = nv_rd32(device, 0x0061e000 + (i * 0x800));
+                nv_wr32(device, 0x006101f0 + (i * 0x04), val);
         }
 
         for (i = 0; i < 3; i++) {
-                nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(i), 0x00550000 |
+                nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(i), 0x00550000 |
                         NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
-                nv_wr32(dev, NV50_PDISPLAY_DAC_CLK_CTRL1(i), 0x00000001);
+                nv_wr32(device, NV50_PDISPLAY_DAC_CLK_CTRL1(i), 0x00000001);
         }
 
         /* The precise purpose is unknown, i suspect it has something to do
          * with text mode.
          */
-        if (nv_rd32(dev, NV50_PDISPLAY_INTR_1) & 0x100) {
-                nv_wr32(dev, NV50_PDISPLAY_INTR_1, 0x100);
-                nv_wr32(dev, 0x006194e8, nv_rd32(dev, 0x006194e8) & ~1);
-                if (!nv_wait(dev, 0x006194e8, 2, 0)) {
-                        NV_ERROR(dev, "timeout: (0x6194e8 & 2) != 0\n");
-                        NV_ERROR(dev, "0x6194e8 = 0x%08x\n",
-                                                nv_rd32(dev, 0x6194e8));
+        if (nv_rd32(device, NV50_PDISPLAY_INTR_1) & 0x100) {
+                nv_wr32(device, NV50_PDISPLAY_INTR_1, 0x100);
+                nv_wr32(device, 0x006194e8, nv_rd32(device, 0x006194e8) & ~1);
+                if (!nv_wait(device, 0x006194e8, 2, 0)) {
+                        NV_ERROR(drm, "timeout: (0x6194e8 & 2) != 0\n");
+                        NV_ERROR(drm, "0x6194e8 = 0x%08x\n",
+                                                nv_rd32(device, 0x6194e8));
                         return -EBUSY;
                 }
         }
 
         for (i = 0; i < 2; i++) {
-                nv_wr32(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i), 0x2000);
-                if (!nv_wait(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
+                nv_wr32(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i), 0x2000);
+                if (!nv_wait(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
                              NV50_PDISPLAY_CURSOR_CURSOR_CTRL2_STATUS, 0)) {
-                        NV_ERROR(dev, "timeout: CURSOR_CTRL2_STATUS == 0\n");
-                        NV_ERROR(dev, "CURSOR_CTRL2 = 0x%08x\n",
-                                 nv_rd32(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i)));
+                        NV_ERROR(drm, "timeout: CURSOR_CTRL2_STATUS == 0\n");
+                        NV_ERROR(drm, "CURSOR_CTRL2 = 0x%08x\n",
+                                 nv_rd32(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i)));
                         return -EBUSY;
                 }
 
-                nv_wr32(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
+                nv_wr32(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
                         NV50_PDISPLAY_CURSOR_CURSOR_CTRL2_ON);
-                if (!nv_wait(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
+                if (!nv_wait(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
                              NV50_PDISPLAY_CURSOR_CURSOR_CTRL2_STATUS,
                              NV50_PDISPLAY_CURSOR_CURSOR_CTRL2_STATUS_ACTIVE)) {
-                        NV_ERROR(dev, "timeout: "
+                        NV_ERROR(drm, "timeout: "
                                       "CURSOR_CTRL2_STATUS_ACTIVE(%d)\n", i);
-                        NV_ERROR(dev, "CURSOR_CTRL2(%d) = 0x%08x\n", i,
-                                 nv_rd32(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i)));
+                        NV_ERROR(drm, "CURSOR_CTRL2(%d) = 0x%08x\n", i,
+                                 nv_rd32(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i)));
                         return -EBUSY;
                 }
         }
 
-        nv_wr32(dev, NV50_PDISPLAY_PIO_CTRL, 0x00000000);
-        nv_mask(dev, NV50_PDISPLAY_INTR_0, 0x00000000, 0x00000000);
-        nv_wr32(dev, NV50_PDISPLAY_INTR_EN_0, 0x00000000);
-        nv_mask(dev, NV50_PDISPLAY_INTR_1, 0x00000000, 0x00000000);
-        nv_wr32(dev, NV50_PDISPLAY_INTR_EN_1,
+        nv_wr32(device, NV50_PDISPLAY_PIO_CTRL, 0x00000000);
+        nv_mask(device, NV50_PDISPLAY_INTR_0, 0x00000000, 0x00000000);
+        nv_wr32(device, NV50_PDISPLAY_INTR_EN_0, 0x00000000);
+        nv_mask(device, NV50_PDISPLAY_INTR_1, 0x00000000, 0x00000000);
+        nv_wr32(device, NV50_PDISPLAY_INTR_EN_1,
                      NV50_PDISPLAY_INTR_EN_1_CLK_UNK10 |
                      NV50_PDISPLAY_INTR_EN_1_CLK_UNK20 |
                      NV50_PDISPLAY_INTR_EN_1_CLK_UNK40);
@@ -263,7 +217,7 @@ nv50_display_init(struct drm_device *dev)
                 return ret;
         evo = nv50_display(dev)->master;
 
-        nv_wr32(dev, NV50_PDISPLAY_OBJECTS, (evo->ramin->vinst >> 8) | 9);
+        nv_wr32(device, NV50_PDISPLAY_OBJECTS, (nv50_display(dev)->ramin->addr >> 8) | 9);
 
         ret = RING_SPACE(evo, 3);
         if (ret)
@@ -278,12 +232,14 @@ nv50_display_init(struct drm_device *dev)
 void
 nv50_display_fini(struct drm_device *dev)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nv50_display *disp = nv50_display(dev);
         struct nouveau_channel *evo = disp->master;
         struct drm_crtc *drm_crtc;
         int ret, i;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         list_for_each_entry(drm_crtc, &dev->mode_config.crtc_list, head) {
                 struct nouveau_crtc *crtc = nouveau_crtc(drm_crtc);
@@ -308,55 +264,59 @@ nv50_display_fini(struct drm_device *dev)
                 if (!crtc->base.enabled)
                         continue;
 
-                nv_wr32(dev, NV50_PDISPLAY_INTR_1, mask);
-                if (!nv_wait(dev, NV50_PDISPLAY_INTR_1, mask, mask)) {
-                        NV_ERROR(dev, "timeout: (0x610024 & 0x%08x) == "
+                nv_wr32(device, NV50_PDISPLAY_INTR_1, mask);
+                if (!nv_wait(device, NV50_PDISPLAY_INTR_1, mask, mask)) {
+                        NV_ERROR(drm, "timeout: (0x610024 & 0x%08x) == "
                                       "0x%08x\n", mask, mask);
-                        NV_ERROR(dev, "0x610024 = 0x%08x\n",
-                                 nv_rd32(dev, NV50_PDISPLAY_INTR_1));
+                        NV_ERROR(drm, "0x610024 = 0x%08x\n",
+                                 nv_rd32(device, NV50_PDISPLAY_INTR_1));
                 }
         }
 
         for (i = 0; i < 2; i++) {
-                nv_wr32(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i), 0);
-                if (!nv_wait(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
+                nv_wr32(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i), 0);
+                if (!nv_wait(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i),
                              NV50_PDISPLAY_CURSOR_CURSOR_CTRL2_STATUS, 0)) {
-                        NV_ERROR(dev, "timeout: CURSOR_CTRL2_STATUS == 0\n");
-                        NV_ERROR(dev, "CURSOR_CTRL2 = 0x%08x\n",
-                                 nv_rd32(dev, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i)));
+                        NV_ERROR(drm, "timeout: CURSOR_CTRL2_STATUS == 0\n");
+                        NV_ERROR(drm, "CURSOR_CTRL2 = 0x%08x\n",
+                                 nv_rd32(device, NV50_PDISPLAY_CURSOR_CURSOR_CTRL2(i)));
                 }
         }
 
         nv50_evo_fini(dev);
 
         for (i = 0; i < 3; i++) {
-                if (!nv_wait(dev, NV50_PDISPLAY_SOR_DPMS_STATE(i),
+                if (!nv_wait(device, NV50_PDISPLAY_SOR_DPMS_STATE(i),
                              NV50_PDISPLAY_SOR_DPMS_STATE_WAIT, 0)) {
-                        NV_ERROR(dev, "timeout: SOR_DPMS_STATE_WAIT(%d) == 0\n", i);
-                        NV_ERROR(dev, "SOR_DPMS_STATE(%d) = 0x%08x\n", i,
-                                  nv_rd32(dev, NV50_PDISPLAY_SOR_DPMS_STATE(i)));
+                        NV_ERROR(drm, "timeout: SOR_DPMS_STATE_WAIT(%d) == 0\n", i);
+                        NV_ERROR(drm, "SOR_DPMS_STATE(%d) = 0x%08x\n", i,
+                                  nv_rd32(device, NV50_PDISPLAY_SOR_DPMS_STATE(i)));
                 }
         }
 
         /* disable interrupts. */
-        nv_wr32(dev, NV50_PDISPLAY_INTR_EN_1, 0x00000000);
+        nv_wr32(device, NV50_PDISPLAY_INTR_EN_1, 0x00000000);
 }
 
 int
 nv50_display_create(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct dcb_table *dcb = &dev_priv->vbios.dcb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct dcb_table *dcb = &drm->vbios.dcb;
         struct drm_connector *connector, *ct;
         struct nv50_display *priv;
         int ret, i;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
-        dev_priv->engine.display.priv = priv;
+
+        nouveau_display(dev)->priv = priv;
+        nouveau_display(dev)->dtor = nv50_display_destroy;
+        nouveau_display(dev)->init = nv50_display_init;
+        nouveau_display(dev)->fini = nv50_display_fini;
 
         /* Create CRTC objects */
         for (i = 0; i < 2; i++) {
@@ -367,10 +327,10 @@ nv50_display_create(struct drm_device *dev)
 
         /* We setup the encoders from the BIOS table */
         for (i = 0 ; i < dcb->entries; i++) {
-                struct dcb_entry *entry = &dcb->entry[i];
+                struct dcb_output *entry = &dcb->entry[i];
 
                 if (entry->location != DCB_LOC_ON_CHIP) {
-                        NV_WARN(dev, "Off-chip encoder %d/%d unsupported\n",
+                        NV_WARN(drm, "Off-chip encoder %d/%d unsupported\n",
                                 entry->type, ffs(entry->or) - 1);
                         continue;
                 }
@@ -380,16 +340,16 @@ nv50_display_create(struct drm_device *dev)
                         continue;
 
                 switch (entry->type) {
-                case OUTPUT_TMDS:
-                case OUTPUT_LVDS:
-                case OUTPUT_DP:
+                case DCB_OUTPUT_TMDS:
+                case DCB_OUTPUT_LVDS:
+                case DCB_OUTPUT_DP:
                         nv50_sor_create(connector, entry);
                         break;
-                case OUTPUT_ANALOG:
+                case DCB_OUTPUT_ANALOG:
                         nv50_dac_create(connector, entry);
                         break;
                 default:
-                        NV_WARN(dev, "DCB encoder %d unknown\n", entry->type);
+                        NV_WARN(drm, "DCB encoder %d unknown\n", entry->type);
                         continue;
                 }
         }
@@ -397,14 +357,13 @@ nv50_display_create(struct drm_device *dev)
         list_for_each_entry_safe(connector, ct,
                                  &dev->mode_config.connector_list, head) {
                 if (!connector->encoder_ids[0]) {
-                        NV_WARN(dev, "%s has no encoders, removing\n",
+                        NV_WARN(drm, "%s has no encoders, removing\n",
                                 drm_get_connector_name(connector));
                         connector->funcs->destroy(connector);
                 }
         }
 
         tasklet_init(&priv->tasklet, nv50_display_bh, (unsigned long)dev);
-        nouveau_irq_register(dev, 26, nv50_display_isr);
 
         ret = nv50_evo_create(dev);
         if (ret) {
@@ -420,13 +379,16 @@ nv50_display_destroy(struct drm_device *dev)
 {
         struct nv50_display *disp = nv50_display(dev);
 
-        NV_DEBUG_KMS(dev, "\n");
-
         nv50_evo_destroy(dev);
-        nouveau_irq_unregister(dev, 26);
         kfree(disp);
 }
 
+struct nouveau_bo *
+nv50_display_crtc_sema(struct drm_device *dev, int crtc)
+{
+        return nv50_display(dev)->crtc[crtc].sem.bo;
+}
+
 void
 nv50_display_flip_stop(struct drm_crtc *crtc)
 {
@@ -457,7 +419,7 @@ int
 nv50_display_flip_next(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                        struct nouveau_channel *chan)
 {
-        struct drm_nouveau_private *dev_priv = crtc->dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
         struct nouveau_framebuffer *nv_fb = nouveau_framebuffer(fb);
         struct nv50_display *disp = nv50_display(crtc->dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
@@ -477,7 +439,7 @@ nv50_display_flip_next(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                         return ret;
                 }
 
-                if (dev_priv->chipset < 0xc0) {
+                if (nv_device(drm->device)->chipset < 0xc0) {
                         BEGIN_NV04(chan, 0, 0x0060, 2);
                         OUT_RING  (chan, NvEvoSema0 + nv_crtc->index);
                         OUT_RING  (chan, dispc->sem.offset);
@@ -487,12 +449,12 @@ nv50_display_flip_next(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                         OUT_RING  (chan, dispc->sem.offset ^ 0x10);
                         OUT_RING  (chan, 0x74b1e000);
                         BEGIN_NV04(chan, 0, 0x0060, 1);
-                        if (dev_priv->chipset < 0x84)
+                        if (nv_device(drm->device)->chipset < 0x84)
                                 OUT_RING  (chan, NvSema);
                         else
-                                OUT_RING  (chan, chan->vram_handle);
+                                OUT_RING  (chan, chan->vram);
                 } else {
-                        u64 offset = nvc0_software_crtc(chan, nv_crtc->index);
+                        u64 offset = nvc0_fence_crtc(chan, nv_crtc->index);
                         offset += dispc->sem.offset;
                         BEGIN_NVC0(chan, 0, 0x0010, 4);
                         OUT_RING  (chan, upper_32_bits(offset));
@@ -555,13 +517,13 @@ nv50_display_flip_next(struct drm_crtc *crtc, struct drm_framebuffer *fb,
 }
 
 static u16
-nv50_display_script_select(struct drm_device *dev, struct dcb_entry *dcb,
+nv50_display_script_select(struct drm_device *dev, struct dcb_output *dcb,
                            u32 mc, int pxclk)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_connector *nv_connector = NULL;
         struct drm_encoder *encoder;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nvbios *bios = &drm->vbios;
         u32 script = 0, or;
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
@@ -576,7 +538,7 @@ nv50_display_script_select(struct drm_device *dev, struct dcb_entry *dcb,
 
         or = ffs(dcb->or) - 1;
         switch (dcb->type) {
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 script = (mc >> 8) & 0xf;
                 if (bios->fp_no_ddc) {
                         if (bios->fp.dual_link)
@@ -609,34 +571,20 @@ nv50_display_script_select(struct drm_device *dev, struct dcb_entry *dcb,
                             (nv_connector->edid->input & 0x70) >= 0x20)
                                 script |= 0x0200;
                 }
-
-                if (nouveau_uscript_lvds >= 0) {
-                        NV_INFO(dev, "override script 0x%04x with 0x%04x "
-                                     "for output LVDS-%d\n", script,
-                                     nouveau_uscript_lvds, or);
-                        script = nouveau_uscript_lvds;
-                }
                 break;
-        case OUTPUT_TMDS:
+        case DCB_OUTPUT_TMDS:
                 script = (mc >> 8) & 0xf;
                 if (pxclk >= 165000)
                         script |= 0x0100;
-
-                if (nouveau_uscript_tmds >= 0) {
-                        NV_INFO(dev, "override script 0x%04x with 0x%04x "
-                                     "for output TMDS-%d\n", script,
-                                     nouveau_uscript_tmds, or);
-                        script = nouveau_uscript_tmds;
-                }
                 break;
-        case OUTPUT_DP:
+        case DCB_OUTPUT_DP:
                 script = (mc >> 8) & 0xf;
                 break;
-        case OUTPUT_ANALOG:
+        case DCB_OUTPUT_ANALOG:
                 script = 0xff;
                 break;
         default:
-                NV_ERROR(dev, "modeset on unsupported output type!\n");
+                NV_ERROR(drm, "modeset on unsupported output type!\n");
                 break;
         }
 
@@ -644,59 +592,18 @@ nv50_display_script_select(struct drm_device *dev, struct dcb_entry *dcb,
 }
 
 static void
-nv50_display_vblank_crtc_handler(struct drm_device *dev, int crtc)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_software_priv *psw = nv_engine(dev, NVOBJ_ENGINE_SW);
-        struct nouveau_software_chan *pch, *tmp;
-
-        list_for_each_entry_safe(pch, tmp, &psw->vblank, vblank.list) {
-                if (pch->vblank.head != crtc)
-                        continue;
-
-                spin_lock(&psw->peephole_lock);
-                nv_wr32(dev, 0x001704, pch->vblank.channel);
-                nv_wr32(dev, 0x001710, 0x80000000 | pch->vblank.ctxdma);
-                if (dev_priv->chipset == 0x50) {
-                        nv_wr32(dev, 0x001570, pch->vblank.offset);
-                        nv_wr32(dev, 0x001574, pch->vblank.value);
-                } else {
-                        nv_wr32(dev, 0x060010, pch->vblank.offset);
-                        nv_wr32(dev, 0x060014, pch->vblank.value);
-                }
-                spin_unlock(&psw->peephole_lock);
-
-                list_del(&pch->vblank.list);
-                drm_vblank_put(dev, crtc);
-        }
-
-        drm_handle_vblank(dev, crtc);
-}
-
-static void
-nv50_display_vblank_handler(struct drm_device *dev, uint32_t intr)
-{
-        if (intr & NV50_PDISPLAY_INTR_1_VBLANK_CRTC_0)
-                nv50_display_vblank_crtc_handler(dev, 0);
-
-        if (intr & NV50_PDISPLAY_INTR_1_VBLANK_CRTC_1)
-                nv50_display_vblank_crtc_handler(dev, 1);
-
-        nv_wr32(dev, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_VBLANK_CRTC);
-}
-
-static void
 nv50_display_unk10_handler(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv50_display *disp = nv50_display(dev);
-        u32 unk30 = nv_rd32(dev, 0x610030), mc;
-        int i, crtc, or = 0, type = OUTPUT_ANY;
+        u32 unk30 = nv_rd32(device, 0x610030), mc;
+        int i, crtc, or = 0, type = DCB_OUTPUT_ANY;
 
-        NV_DEBUG_KMS(dev, "0x610030: 0x%08x\n", unk30);
+        NV_DEBUG(drm, "0x610030: 0x%08x\n", unk30);
         disp->irq.dcb = NULL;
 
-        nv_wr32(dev, 0x619494, nv_rd32(dev, 0x619494) & ~8);
+        nv_wr32(device, 0x619494, nv_rd32(device, 0x619494) & ~8);
 
         /* Determine which CRTC we're dealing with, only 1 ever will be
          * signalled at the same time with the current nouveau code.
@@ -711,44 +618,44 @@ nv50_display_unk10_handler(struct drm_device *dev)
                 goto ack;
 
         /* Find which encoder was connected to the CRTC */
-        for (i = 0; type == OUTPUT_ANY && i < 3; i++) {
-                mc = nv_rd32(dev, NV50_PDISPLAY_DAC_MODE_CTRL_C(i));
-                NV_DEBUG_KMS(dev, "DAC-%d mc: 0x%08x\n", i, mc);
+        for (i = 0; type == DCB_OUTPUT_ANY && i < 3; i++) {
+                mc = nv_rd32(device, NV50_PDISPLAY_DAC_MODE_CTRL_C(i));
+                NV_DEBUG(drm, "DAC-%d mc: 0x%08x\n", i, mc);
                 if (!(mc & (1 << crtc)))
                         continue;
 
                 switch ((mc & 0x00000f00) >> 8) {
-                case 0: type = OUTPUT_ANALOG; break;
-                case 1: type = OUTPUT_TV; break;
+                case 0: type = DCB_OUTPUT_ANALOG; break;
+                case 1: type = DCB_OUTPUT_TV; break;
                 default:
-                        NV_ERROR(dev, "invalid mc, DAC-%d: 0x%08x\n", i, mc);
+                        NV_ERROR(drm, "invalid mc, DAC-%d: 0x%08x\n", i, mc);
                         goto ack;
                 }
 
                 or = i;
         }
 
-        for (i = 0; type == OUTPUT_ANY && i < nv50_sor_nr(dev); i++) {
-                if (dev_priv->chipset  < 0x90 ||
-                    dev_priv->chipset == 0x92 ||
-                    dev_priv->chipset == 0xa0)
-                        mc = nv_rd32(dev, NV50_PDISPLAY_SOR_MODE_CTRL_C(i));
+        for (i = 0; type == DCB_OUTPUT_ANY && i < nv50_sor_nr(dev); i++) {
+                if (nv_device(drm->device)->chipset  < 0x90 ||
+                    nv_device(drm->device)->chipset == 0x92 ||
+                    nv_device(drm->device)->chipset == 0xa0)
+                        mc = nv_rd32(device, NV50_PDISPLAY_SOR_MODE_CTRL_C(i));
                 else
-                        mc = nv_rd32(dev, NV90_PDISPLAY_SOR_MODE_CTRL_C(i));
+                        mc = nv_rd32(device, NV90_PDISPLAY_SOR_MODE_CTRL_C(i));
 
-                NV_DEBUG_KMS(dev, "SOR-%d mc: 0x%08x\n", i, mc);
+                NV_DEBUG(drm, "SOR-%d mc: 0x%08x\n", i, mc);
                 if (!(mc & (1 << crtc)))
                         continue;
 
                 switch ((mc & 0x00000f00) >> 8) {
-                case 0: type = OUTPUT_LVDS; break;
-                case 1: type = OUTPUT_TMDS; break;
-                case 2: type = OUTPUT_TMDS; break;
-                case 5: type = OUTPUT_TMDS; break;
-                case 8: type = OUTPUT_DP; break;
-                case 9: type = OUTPUT_DP; break;
+                case 0: type = DCB_OUTPUT_LVDS; break;
+                case 1: type = DCB_OUTPUT_TMDS; break;
+                case 2: type = DCB_OUTPUT_TMDS; break;
+                case 5: type = DCB_OUTPUT_TMDS; break;
+                case 8: type = DCB_OUTPUT_DP; break;
+                case 9: type = DCB_OUTPUT_DP; break;
                 default:
-                        NV_ERROR(dev, "invalid mc, SOR-%d: 0x%08x\n", i, mc);
+                        NV_ERROR(drm, "invalid mc, SOR-%d: 0x%08x\n", i, mc);
                         goto ack;
                 }
 
@@ -756,12 +663,12 @@ nv50_display_unk10_handler(struct drm_device *dev)
         }
 
         /* There was no encoder to disable */
-        if (type == OUTPUT_ANY)
+        if (type == DCB_OUTPUT_ANY)
                 goto ack;
 
         /* Disable the encoder */
-        for (i = 0; i < dev_priv->vbios.dcb.entries; i++) {
-                struct dcb_entry *dcb = &dev_priv->vbios.dcb.entry[i];
+        for (i = 0; i < drm->vbios.dcb.entries; i++) {
+                struct dcb_output *dcb = &drm->vbios.dcb.entry[i];
 
                 if (dcb->type == type && (dcb->or & (1 << or))) {
                         nouveau_bios_run_display_table(dev, 0, -1, dcb, -1);
@@ -770,22 +677,23 @@ nv50_display_unk10_handler(struct drm_device *dev)
                 }
         }
 
-        NV_ERROR(dev, "no dcb for %d %d 0x%08x\n", or, type, mc);
+        NV_ERROR(drm, "no dcb for %d %d 0x%08x\n", or, type, mc);
 ack:
-        nv_wr32(dev, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_CLK_UNK10);
-        nv_wr32(dev, 0x610030, 0x80000000);
+        nv_wr32(device, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_CLK_UNK10);
+        nv_wr32(device, 0x610030, 0x80000000);
 }
 
 static void
 nv50_display_unk20_handler(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv50_display *disp = nv50_display(dev);
-        u32 unk30 = nv_rd32(dev, 0x610030), tmp, pclk, script, mc = 0;
-        struct dcb_entry *dcb;
-        int i, crtc, or = 0, type = OUTPUT_ANY;
+        u32 unk30 = nv_rd32(device, 0x610030), tmp, pclk, script, mc = 0;
+        struct dcb_output *dcb;
+        int i, crtc, or = 0, type = DCB_OUTPUT_ANY;
 
-        NV_DEBUG_KMS(dev, "0x610030: 0x%08x\n", unk30);
+        NV_DEBUG(drm, "0x610030: 0x%08x\n", unk30);
         dcb = disp->irq.dcb;
         if (dcb) {
                 nouveau_bios_run_display_table(dev, 0, -2, dcb, -1);
@@ -795,86 +703,86 @@ nv50_display_unk20_handler(struct drm_device *dev)
         /* CRTC clock change requested? */
         crtc = ffs((unk30 & 0x00000600) >> 9) - 1;
         if (crtc >= 0) {
-                pclk  = nv_rd32(dev, NV50_PDISPLAY_CRTC_P(crtc, CLOCK));
+                pclk  = nv_rd32(device, NV50_PDISPLAY_CRTC_P(crtc, CLOCK));
                 pclk &= 0x003fffff;
                 if (pclk)
                         nv50_crtc_set_clock(dev, crtc, pclk);
 
-                tmp = nv_rd32(dev, NV50_PDISPLAY_CRTC_CLK_CTRL2(crtc));
+                tmp = nv_rd32(device, NV50_PDISPLAY_CRTC_CLK_CTRL2(crtc));
                 tmp &= ~0x000000f;
-                nv_wr32(dev, NV50_PDISPLAY_CRTC_CLK_CTRL2(crtc), tmp);
+                nv_wr32(device, NV50_PDISPLAY_CRTC_CLK_CTRL2(crtc), tmp);
         }
 
         /* Nothing needs to be done for the encoder */
         crtc = ffs((unk30 & 0x00000180) >> 7) - 1;
         if (crtc < 0)
                 goto ack;
-        pclk  = nv_rd32(dev, NV50_PDISPLAY_CRTC_P(crtc, CLOCK)) & 0x003fffff;
+        pclk  = nv_rd32(device, NV50_PDISPLAY_CRTC_P(crtc, CLOCK)) & 0x003fffff;
 
         /* Find which encoder is connected to the CRTC */
-        for (i = 0; type == OUTPUT_ANY && i < 3; i++) {
-                mc = nv_rd32(dev, NV50_PDISPLAY_DAC_MODE_CTRL_P(i));
-                NV_DEBUG_KMS(dev, "DAC-%d mc: 0x%08x\n", i, mc);
+        for (i = 0; type == DCB_OUTPUT_ANY && i < 3; i++) {
+                mc = nv_rd32(device, NV50_PDISPLAY_DAC_MODE_CTRL_P(i));
+                NV_DEBUG(drm, "DAC-%d mc: 0x%08x\n", i, mc);
                 if (!(mc & (1 << crtc)))
                         continue;
 
                 switch ((mc & 0x00000f00) >> 8) {
-                case 0: type = OUTPUT_ANALOG; break;
-                case 1: type = OUTPUT_TV; break;
+                case 0: type = DCB_OUTPUT_ANALOG; break;
+                case 1: type = DCB_OUTPUT_TV; break;
                 default:
-                        NV_ERROR(dev, "invalid mc, DAC-%d: 0x%08x\n", i, mc);
+                        NV_ERROR(drm, "invalid mc, DAC-%d: 0x%08x\n", i, mc);
                         goto ack;
                 }
 
                 or = i;
         }
 
-        for (i = 0; type == OUTPUT_ANY && i < nv50_sor_nr(dev); i++) {
-                if (dev_priv->chipset  < 0x90 ||
-                    dev_priv->chipset == 0x92 ||
-                    dev_priv->chipset == 0xa0)
-                        mc = nv_rd32(dev, NV50_PDISPLAY_SOR_MODE_CTRL_P(i));
+        for (i = 0; type == DCB_OUTPUT_ANY && i < nv50_sor_nr(dev); i++) {
+                if (nv_device(drm->device)->chipset  < 0x90 ||
+                    nv_device(drm->device)->chipset == 0x92 ||
+                    nv_device(drm->device)->chipset == 0xa0)
+                        mc = nv_rd32(device, NV50_PDISPLAY_SOR_MODE_CTRL_P(i));
                 else
-                        mc = nv_rd32(dev, NV90_PDISPLAY_SOR_MODE_CTRL_P(i));
+                        mc = nv_rd32(device, NV90_PDISPLAY_SOR_MODE_CTRL_P(i));
 
-                NV_DEBUG_KMS(dev, "SOR-%d mc: 0x%08x\n", i, mc);
+                NV_DEBUG(drm, "SOR-%d mc: 0x%08x\n", i, mc);
                 if (!(mc & (1 << crtc)))
                         continue;
 
                 switch ((mc & 0x00000f00) >> 8) {
-                case 0: type = OUTPUT_LVDS; break;
-                case 1: type = OUTPUT_TMDS; break;
-                case 2: type = OUTPUT_TMDS; break;
-                case 5: type = OUTPUT_TMDS; break;
-                case 8: type = OUTPUT_DP; break;
-                case 9: type = OUTPUT_DP; break;
+                case 0: type = DCB_OUTPUT_LVDS; break;
+                case 1: type = DCB_OUTPUT_TMDS; break;
+                case 2: type = DCB_OUTPUT_TMDS; break;
+                case 5: type = DCB_OUTPUT_TMDS; break;
+                case 8: type = DCB_OUTPUT_DP; break;
+                case 9: type = DCB_OUTPUT_DP; break;
                 default:
-                        NV_ERROR(dev, "invalid mc, SOR-%d: 0x%08x\n", i, mc);
+                        NV_ERROR(drm, "invalid mc, SOR-%d: 0x%08x\n", i, mc);
                         goto ack;
                 }
 
                 or = i;
         }
 
-        if (type == OUTPUT_ANY)
+        if (type == DCB_OUTPUT_ANY)
                 goto ack;
 
         /* Enable the encoder */
-        for (i = 0; i < dev_priv->vbios.dcb.entries; i++) {
-                dcb = &dev_priv->vbios.dcb.entry[i];
+        for (i = 0; i < drm->vbios.dcb.entries; i++) {
+                dcb = &drm->vbios.dcb.entry[i];
                 if (dcb->type == type && (dcb->or & (1 << or)))
                         break;
         }
 
-        if (i == dev_priv->vbios.dcb.entries) {
-                NV_ERROR(dev, "no dcb for %d %d 0x%08x\n", or, type, mc);
+        if (i == drm->vbios.dcb.entries) {
+                NV_ERROR(drm, "no dcb for %d %d 0x%08x\n", or, type, mc);
                 goto ack;
         }
 
         script = nv50_display_script_select(dev, dcb, mc, pclk);
         nouveau_bios_run_display_table(dev, script, pclk, dcb, -1);
 
-        if (type == OUTPUT_DP) {
+        if (type == DCB_OUTPUT_DP) {
                 int link = !(dcb->dpconf.sor.link & 1);
                 if ((mc & 0x000f0000) == 0x00020000)
                         nv50_sor_dp_calc_tu(dev, or, link, pclk, 18);
@@ -882,14 +790,14 @@ nv50_display_unk20_handler(struct drm_device *dev)
                         nv50_sor_dp_calc_tu(dev, or, link, pclk, 24);
         }
 
-        if (dcb->type != OUTPUT_ANALOG) {
-                tmp = nv_rd32(dev, NV50_PDISPLAY_SOR_CLK_CTRL2(or));
+        if (dcb->type != DCB_OUTPUT_ANALOG) {
+                tmp = nv_rd32(device, NV50_PDISPLAY_SOR_CLK_CTRL2(or));
                 tmp &= ~0x00000f0f;
                 if (script & 0x0100)
                         tmp |= 0x00000101;
-                nv_wr32(dev, NV50_PDISPLAY_SOR_CLK_CTRL2(or), tmp);
+                nv_wr32(device, NV50_PDISPLAY_SOR_CLK_CTRL2(or), tmp);
         } else {
-                nv_wr32(dev, NV50_PDISPLAY_DAC_CLK_CTRL2(or), 0);
+                nv_wr32(device, NV50_PDISPLAY_DAC_CLK_CTRL2(or), 0);
         }
 
         disp->irq.dcb = dcb;
@@ -897,8 +805,8 @@ nv50_display_unk20_handler(struct drm_device *dev)
         disp->irq.script = script;
 
 ack:
-        nv_wr32(dev, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_CLK_UNK20);
-        nv_wr32(dev, 0x610030, 0x80000000);
+        nv_wr32(device, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_CLK_UNK20);
+        nv_wr32(device, 0x610030, 0x80000000);
 }
 
 /* If programming a TMDS output on a SOR that can also be configured for
@@ -910,23 +818,24 @@ ack:
  * programmed for DisplayPort.
  */
 static void
-nv50_display_unk40_dp_set_tmds(struct drm_device *dev, struct dcb_entry *dcb)
+nv50_display_unk40_dp_set_tmds(struct drm_device *dev, struct dcb_output *dcb)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         int or = ffs(dcb->or) - 1, link = !(dcb->dpconf.sor.link & 1);
         struct drm_encoder *encoder;
         u32 tmp;
 
-        if (dcb->type != OUTPUT_TMDS)
+        if (dcb->type != DCB_OUTPUT_TMDS)
                 return;
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
 
-                if (nv_encoder->dcb->type == OUTPUT_DP &&
+                if (nv_encoder->dcb->type == DCB_OUTPUT_DP &&
                     nv_encoder->dcb->or & (1 << or)) {
-                        tmp  = nv_rd32(dev, NV50_SOR_DP_CTRL(or, link));
+                        tmp  = nv_rd32(device, NV50_SOR_DP_CTRL(or, link));
                         tmp &= ~NV50_SOR_DP_CTRL_ENABLED;
-                        nv_wr32(dev, NV50_SOR_DP_CTRL(or, link), tmp);
+                        nv_wr32(device, NV50_SOR_DP_CTRL(or, link), tmp);
                         break;
                 }
         }
@@ -935,12 +844,14 @@ nv50_display_unk40_dp_set_tmds(struct drm_device *dev, struct dcb_entry *dcb)
 static void
 nv50_display_unk40_handler(struct drm_device *dev)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv50_display *disp = nv50_display(dev);
-        struct dcb_entry *dcb = disp->irq.dcb;
+        struct dcb_output *dcb = disp->irq.dcb;
         u16 script = disp->irq.script;
-        u32 unk30 = nv_rd32(dev, 0x610030), pclk = disp->irq.pclk;
+        u32 unk30 = nv_rd32(device, 0x610030), pclk = disp->irq.pclk;
 
-        NV_DEBUG_KMS(dev, "0x610030: 0x%08x\n", unk30);
+        NV_DEBUG(drm, "0x610030: 0x%08x\n", unk30);
         disp->irq.dcb = NULL;
         if (!dcb)
                 goto ack;
@@ -949,21 +860,23 @@ nv50_display_unk40_handler(struct drm_device *dev)
         nv50_display_unk40_dp_set_tmds(dev, dcb);
 
 ack:
-        nv_wr32(dev, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_CLK_UNK40);
-        nv_wr32(dev, 0x610030, 0x80000000);
-        nv_wr32(dev, 0x619494, nv_rd32(dev, 0x619494) | 8);
+        nv_wr32(device, NV50_PDISPLAY_INTR_1, NV50_PDISPLAY_INTR_1_CLK_UNK40);
+        nv_wr32(device, 0x610030, 0x80000000);
+        nv_wr32(device, 0x619494, nv_rd32(device, 0x619494) | 8);
 }
 
 static void
 nv50_display_bh(unsigned long data)
 {
         struct drm_device *dev = (struct drm_device *)data;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
         for (;;) {
-                uint32_t intr0 = nv_rd32(dev, NV50_PDISPLAY_INTR_0);
-                uint32_t intr1 = nv_rd32(dev, NV50_PDISPLAY_INTR_1);
+                uint32_t intr0 = nv_rd32(device, NV50_PDISPLAY_INTR_0);
+                uint32_t intr1 = nv_rd32(device, NV50_PDISPLAY_INTR_1);
 
-                NV_DEBUG_KMS(dev, "PDISPLAY_INTR_BH 0x%08x 0x%08x\n", intr0, intr1);
+                NV_DEBUG(drm, "PDISPLAY_INTR_BH 0x%08x 0x%08x\n", intr0, intr1);
 
                 if (intr1 & NV50_PDISPLAY_INTR_1_CLK_UNK10)
                         nv50_display_unk10_handler(dev);
@@ -977,13 +890,15 @@ nv50_display_bh(unsigned long data)
                         break;
         }
 
-        nv_wr32(dev, NV03_PMC_INTR_EN_0, 1);
+        nv_wr32(device, NV03_PMC_INTR_EN_0, 1);
 }
 
 static void
 nv50_display_error_handler(struct drm_device *dev)
 {
-        u32 channels = (nv_rd32(dev, NV50_PDISPLAY_INTR_0) & 0x001f0000) >> 16;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        u32 channels = (nv_rd32(device, NV50_PDISPLAY_INTR_0) & 0x001f0000) >> 16;
         u32 addr, data;
         int chid;
 
@@ -991,29 +906,31 @@ nv50_display_error_handler(struct drm_device *dev)
                 if (!(channels & (1 << chid)))
                         continue;
 
-                nv_wr32(dev, NV50_PDISPLAY_INTR_0, 0x00010000 << chid);
-                addr = nv_rd32(dev, NV50_PDISPLAY_TRAPPED_ADDR(chid));
-                data = nv_rd32(dev, NV50_PDISPLAY_TRAPPED_DATA(chid));
-                NV_ERROR(dev, "EvoCh %d Mthd 0x%04x Data 0x%08x "
+                nv_wr32(device, NV50_PDISPLAY_INTR_0, 0x00010000 << chid);
+                addr = nv_rd32(device, NV50_PDISPLAY_TRAPPED_ADDR(chid));
+                data = nv_rd32(device, NV50_PDISPLAY_TRAPPED_DATA(chid));
+                NV_ERROR(drm, "EvoCh %d Mthd 0x%04x Data 0x%08x "
                               "(0x%04x 0x%02x)\n", chid,
                          addr & 0xffc, data, addr >> 16, (addr >> 12) & 0xf);
 
-                nv_wr32(dev, NV50_PDISPLAY_TRAPPED_ADDR(chid), 0x90000000);
+                nv_wr32(device, NV50_PDISPLAY_TRAPPED_ADDR(chid), 0x90000000);
         }
 }
 
-static void
-nv50_display_isr(struct drm_device *dev)
+void
+nv50_display_intr(struct drm_device *dev)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv50_display *disp = nv50_display(dev);
         uint32_t delayed = 0;
 
-        while (nv_rd32(dev, NV50_PMC_INTR_0) & NV50_PMC_INTR_0_DISPLAY) {
-                uint32_t intr0 = nv_rd32(dev, NV50_PDISPLAY_INTR_0);
-                uint32_t intr1 = nv_rd32(dev, NV50_PDISPLAY_INTR_1);
+        while (nv_rd32(device, NV50_PMC_INTR_0) & NV50_PMC_INTR_0_DISPLAY) {
+                uint32_t intr0 = nv_rd32(device, NV50_PDISPLAY_INTR_0);
+                uint32_t intr1 = nv_rd32(device, NV50_PDISPLAY_INTR_1);
                 uint32_t clock;
 
-                NV_DEBUG_KMS(dev, "PDISPLAY_INTR 0x%08x 0x%08x\n", intr0, intr1);
+                NV_DEBUG(drm, "PDISPLAY_INTR 0x%08x 0x%08x\n", intr0, intr1);
 
                 if (!intr0 && !(intr1 & ~delayed))
                         break;
@@ -1024,29 +941,29 @@ nv50_display_isr(struct drm_device *dev)
                 }
 
                 if (intr1 & NV50_PDISPLAY_INTR_1_VBLANK_CRTC) {
-                        nv50_display_vblank_handler(dev, intr1);
                         intr1 &= ~NV50_PDISPLAY_INTR_1_VBLANK_CRTC;
+                        delayed |= NV50_PDISPLAY_INTR_1_VBLANK_CRTC;
                 }
 
                 clock = (intr1 & (NV50_PDISPLAY_INTR_1_CLK_UNK10 |
                                   NV50_PDISPLAY_INTR_1_CLK_UNK20 |
                                   NV50_PDISPLAY_INTR_1_CLK_UNK40));
                 if (clock) {
-                        nv_wr32(dev, NV03_PMC_INTR_EN_0, 0);
+                        nv_wr32(device, NV03_PMC_INTR_EN_0, 0);
                         tasklet_schedule(&disp->tasklet);
                         delayed |= clock;
                         intr1 &= ~clock;
                 }
 
                 if (intr0) {
-                        NV_ERROR(dev, "unknown PDISPLAY_INTR_0: 0x%08x\n", intr0);
-                        nv_wr32(dev, NV50_PDISPLAY_INTR_0, intr0);
+                        NV_ERROR(drm, "unknown PDISPLAY_INTR_0: 0x%08x\n", intr0);
+                        nv_wr32(device, NV50_PDISPLAY_INTR_0, intr0);
                 }
 
                 if (intr1) {
-                        NV_ERROR(dev,
+                        NV_ERROR(drm,
                                  "unknown PDISPLAY_INTR_1: 0x%08x\n", intr1);
-                        nv_wr32(dev, NV50_PDISPLAY_INTR_1, intr1);
+                        nv_wr32(device, NV50_PDISPLAY_INTR_1, intr1);
                 }
         }
 }
diff --git a/drivers/gpu/drm/nouveau/nv50_display.h b/drivers/gpu/drm/nouveau/nv50_display.h
index e9db9b97f041..973554d8a7a6 100644
--- a/drivers/gpu/drm/nouveau/nv50_display.h
+++ b/drivers/gpu/drm/nouveau/nv50_display.h
@@ -27,13 +27,9 @@
 #ifndef __NV50_DISPLAY_H__
 #define __NV50_DISPLAY_H__
 
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_dma.h"
-#include "nouveau_reg.h"
+#include "nouveau_display.h"
 #include "nouveau_crtc.h"
-#include "nouveau_software.h"
+#include "nouveau_reg.h"
 #include "nv50_evo.h"
 
 struct nv50_display_crtc {
@@ -47,13 +43,16 @@ struct nv50_display_crtc {
 
 struct nv50_display {
         struct nouveau_channel *master;
-        struct nouveau_gpuobj *ntfy;
+
+        struct nouveau_gpuobj *ramin;
+        u32 dmao;
+        u32 hash;
 
         struct nv50_display_crtc crtc[2];
 
         struct tasklet_struct tasklet;
         struct {
-                struct dcb_entry *dcb;
+                struct dcb_output *dcb;
                 u16 script;
                 u32 pclk;
         } irq;
@@ -62,8 +61,7 @@ struct nv50_display {
 static inline struct nv50_display *
 nv50_display(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return dev_priv->engine.display.priv;
+        return nouveau_display(dev)->priv;
 }
 
 int nv50_display_early_init(struct drm_device *dev);
@@ -72,6 +70,7 @@ int nv50_display_create(struct drm_device *dev);
 int nv50_display_init(struct drm_device *dev);
 void nv50_display_fini(struct drm_device *dev);
 void nv50_display_destroy(struct drm_device *dev);
+void nv50_display_intr(struct drm_device *);
 int nv50_crtc_blank(struct nouveau_crtc *, bool blank);
 int nv50_crtc_set_clock(struct drm_device *, int head, int pclk);
 
@@ -91,4 +90,17 @@ void nv50_evo_dmaobj_init(struct nouveau_gpuobj *, u32 memtype, u64 base,
 int  nv50_evo_dmaobj_new(struct nouveau_channel *, u32 handle, u32 memtype,
                          u64 base, u64 size, struct nouveau_gpuobj **);
 
+int  nvd0_display_create(struct drm_device *);
+void nvd0_display_destroy(struct drm_device *);
+int  nvd0_display_init(struct drm_device *);
+void nvd0_display_fini(struct drm_device *);
+void nvd0_display_intr(struct drm_device *);
+
+void nvd0_display_flip_stop(struct drm_crtc *);
+int  nvd0_display_flip_next(struct drm_crtc *, struct drm_framebuffer *,
+                            struct nouveau_channel *, u32 swap_interval);
+
+struct nouveau_bo *nv50_display_crtc_sema(struct drm_device *, int head);
+struct nouveau_bo *nvd0_display_crtc_sema(struct drm_device *, int head);
+
 #endif /* __NV50_DISPLAY_H__ */
diff --git a/drivers/gpu/drm/nouveau/nv50_evo.c b/drivers/gpu/drm/nouveau/nv50_evo.c
index ddcd55595824..0f534160c021 100644
--- a/drivers/gpu/drm/nouveau/nv50_evo.c
+++ b/drivers/gpu/drm/nouveau/nv50_evo.c
@@ -24,11 +24,29 @@
 
 #include "drmP.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_ramht.h"
 #include "nv50_display.h"
 
+#include <core/gpuobj.h>
+
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
+static u32
+nv50_evo_rd32(struct nouveau_object *object, u32 addr)
+{
+        void __iomem *iomem = object->oclass->ofuncs->rd08;
+        return ioread32_native(iomem + addr);
+}
+
+static void
+nv50_evo_wr32(struct nouveau_object *object, u32 addr, u32 data)
+{
+        void __iomem *iomem = object->oclass->ofuncs->rd08;
+        iowrite32_native(data, iomem + addr);
+}
+
 static void
 nv50_evo_channel_del(struct nouveau_channel **pevo)
 {
@@ -38,26 +56,29 @@ nv50_evo_channel_del(struct nouveau_channel **pevo)
                 return;
         *pevo = NULL;
 
-        nouveau_ramht_ref(NULL, &evo->ramht, evo);
-        nouveau_gpuobj_channel_takedown(evo);
-        nouveau_bo_unmap(evo->pushbuf_bo);
-        nouveau_bo_ref(NULL, &evo->pushbuf_bo);
+        nouveau_bo_unmap(evo->push.buffer);
+        nouveau_bo_ref(NULL, &evo->push.buffer);
 
-        if (evo->user)
-                iounmap(evo->user);
+        if (evo->object)
+                iounmap(evo->object->oclass->ofuncs);
 
         kfree(evo);
 }
 
-void
-nv50_evo_dmaobj_init(struct nouveau_gpuobj *obj, u32 memtype, u64 base, u64 size)
+int
+nv50_evo_dmaobj_new(struct nouveau_channel *evo, u32 handle, u32 memtype,
+                    u64 base, u64 size, struct nouveau_gpuobj **pobj)
 {
-        struct drm_nouveau_private *dev_priv = obj->dev->dev_private;
+        struct drm_device *dev = evo->fence;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nv50_display *disp = nv50_display(dev);
+        u32 dmao = disp->dmao;
+        u32 hash = disp->hash;
         u32 flags5;
 
-        if (dev_priv->chipset < 0xc0) {
+        if (nv_device(drm->device)->chipset < 0xc0) {
                 /* not supported on 0x50, specified in format mthd */
-                if (dev_priv->chipset == 0x50)
+                if (nv_device(drm->device)->chipset == 0x50)
                         memtype = 0;
                 flags5 = 0x00010000;
         } else {
@@ -67,42 +88,28 @@ nv50_evo_dmaobj_init(struct nouveau_gpuobj *obj, u32 memtype, u64 base, u64 size
                         flags5 = 0x00020000;
         }
 
-        nv50_gpuobj_dma_init(obj, 0, 0x3d, base, size, NV_MEM_TARGET_VRAM,
-                             NV_MEM_ACCESS_RW, (memtype >> 8) & 0xff, 0);
-        nv_wo32(obj, 0x14, flags5);
-        dev_priv->engine.instmem.flush(obj->dev);
-}
+        nv_wo32(disp->ramin, dmao + 0x00, 0x0019003d | (memtype << 22));
+        nv_wo32(disp->ramin, dmao + 0x04, lower_32_bits(base + size - 1));
+        nv_wo32(disp->ramin, dmao + 0x08, lower_32_bits(base));
+        nv_wo32(disp->ramin, dmao + 0x0c, upper_32_bits(base + size - 1) << 24 |
+                                          upper_32_bits(base));
+        nv_wo32(disp->ramin, dmao + 0x10, 0x00000000);
+        nv_wo32(disp->ramin, dmao + 0x14, flags5);
 
-int
-nv50_evo_dmaobj_new(struct nouveau_channel *evo, u32 handle, u32 memtype,
-                    u64 base, u64 size, struct nouveau_gpuobj **pobj)
-{
-        struct nv50_display *disp = nv50_display(evo->dev);
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(evo->dev, disp->master, 6*4, 32, 0, &obj);
-        if (ret)
-                return ret;
-        obj->engine = NVOBJ_ENGINE_DISPLAY;
-
-        nv50_evo_dmaobj_init(obj, memtype, base, size);
-
-        ret = nouveau_ramht_insert(evo, handle, obj);
-        if (ret)
-                goto out;
+        nv_wo32(disp->ramin, hash + 0x00, handle);
+        nv_wo32(disp->ramin, hash + 0x04, (evo->handle << 28) | (dmao << 10) |
+                                           evo->handle);
 
-        if (pobj)
-                nouveau_gpuobj_ref(obj, pobj);
-out:
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
+        disp->dmao += 0x20;
+        disp->hash += 0x08;
+        return 0;
 }
 
 static int
 nv50_evo_channel_new(struct drm_device *dev, int chid,
                      struct nouveau_channel **pevo)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv50_display *disp = nv50_display(dev);
         struct nouveau_channel *evo;
         int ret;
@@ -112,79 +119,84 @@ nv50_evo_channel_new(struct drm_device *dev, int chid,
                 return -ENOMEM;
         *pevo = evo;
 
-        evo->id = chid;
-        evo->dev = dev;
+        evo->drm = drm;
+        evo->handle = chid;
+        evo->fence = dev;
         evo->user_get = 4;
         evo->user_put = 0;
 
         ret = nouveau_bo_new(dev, 4096, 0, TTM_PL_FLAG_VRAM, 0, 0, NULL,
-                             &evo->pushbuf_bo);
+                             &evo->push.buffer);
         if (ret == 0)
-                ret = nouveau_bo_pin(evo->pushbuf_bo, TTM_PL_FLAG_VRAM);
+                ret = nouveau_bo_pin(evo->push.buffer, TTM_PL_FLAG_VRAM);
         if (ret) {
-                NV_ERROR(dev, "Error creating EVO DMA push buffer: %d\n", ret);
+                NV_ERROR(drm, "Error creating EVO DMA push buffer: %d\n", ret);
                 nv50_evo_channel_del(pevo);
                 return ret;
         }
 
-        ret = nouveau_bo_map(evo->pushbuf_bo);
+        ret = nouveau_bo_map(evo->push.buffer);
         if (ret) {
-                NV_ERROR(dev, "Error mapping EVO DMA push buffer: %d\n", ret);
+                NV_ERROR(drm, "Error mapping EVO DMA push buffer: %d\n", ret);
                 nv50_evo_channel_del(pevo);
                 return ret;
         }
 
-        evo->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                            NV50_PDISPLAY_USER(evo->id), PAGE_SIZE);
-        if (!evo->user) {
-                NV_ERROR(dev, "Error mapping EVO control regs.\n");
-                nv50_evo_channel_del(pevo);
-                return -ENOMEM;
-        }
-
-        /* bind primary evo channel's ramht to the channel */
-        if (disp->master && evo != disp->master)
-                nouveau_ramht_ref(disp->master->ramht, &evo->ramht, NULL);
-
+        evo->object = kzalloc(sizeof(*evo->object), GFP_KERNEL);
+#ifdef NOUVEAU_OBJECT_MAGIC
+        evo->object->_magic = NOUVEAU_OBJECT_MAGIC;
+#endif
+        evo->object->parent = nv_object(disp->ramin)->parent;
+        evo->object->engine = nv_object(disp->ramin)->engine;
+        evo->object->oclass =
+                kzalloc(sizeof(*evo->object->oclass), GFP_KERNEL);
+        evo->object->oclass->ofuncs =
+                kzalloc(sizeof(*evo->object->oclass->ofuncs), GFP_KERNEL);
+        evo->object->oclass->ofuncs->rd32 = nv50_evo_rd32;
+        evo->object->oclass->ofuncs->wr32 = nv50_evo_wr32;
+        evo->object->oclass->ofuncs->rd08 =
+                ioremap(pci_resource_start(dev->pdev, 0) +
+                        NV50_PDISPLAY_USER(evo->handle), PAGE_SIZE);
         return 0;
 }
 
 static int
 nv50_evo_channel_init(struct nouveau_channel *evo)
 {
-        struct drm_device *dev = evo->dev;
-        int id = evo->id, ret, i;
-        u64 pushbuf = evo->pushbuf_bo->bo.offset;
+        struct nouveau_drm *drm = evo->drm;
+        struct nouveau_device *device = nv_device(drm->device);
+        int id = evo->handle, ret, i;
+        u64 pushbuf = evo->push.buffer->bo.offset;
         u32 tmp;
 
-        tmp = nv_rd32(dev, NV50_PDISPLAY_EVO_CTRL(id));
+        tmp = nv_rd32(device, NV50_PDISPLAY_EVO_CTRL(id));
         if ((tmp & 0x009f0000) == 0x00020000)
-                nv_wr32(dev, NV50_PDISPLAY_EVO_CTRL(id), tmp | 0x00800000);
+                nv_wr32(device, NV50_PDISPLAY_EVO_CTRL(id), tmp | 0x00800000);
 
-        tmp = nv_rd32(dev, NV50_PDISPLAY_EVO_CTRL(id));
+        tmp = nv_rd32(device, NV50_PDISPLAY_EVO_CTRL(id));
         if ((tmp & 0x003f0000) == 0x00030000)
-                nv_wr32(dev, NV50_PDISPLAY_EVO_CTRL(id), tmp | 0x00600000);
+                nv_wr32(device, NV50_PDISPLAY_EVO_CTRL(id), tmp | 0x00600000);
 
         /* initialise fifo */
-        nv_wr32(dev, NV50_PDISPLAY_EVO_DMA_CB(id), pushbuf >> 8 |
+        nv_wr32(device, NV50_PDISPLAY_EVO_DMA_CB(id), pushbuf >> 8 |
                      NV50_PDISPLAY_EVO_DMA_CB_LOCATION_VRAM |
                      NV50_PDISPLAY_EVO_DMA_CB_VALID);
-        nv_wr32(dev, NV50_PDISPLAY_EVO_UNK2(id), 0x00010000);
-        nv_wr32(dev, NV50_PDISPLAY_EVO_HASH_TAG(id), id);
-        nv_mask(dev, NV50_PDISPLAY_EVO_CTRL(id), NV50_PDISPLAY_EVO_CTRL_DMA,
+        nv_wr32(device, NV50_PDISPLAY_EVO_UNK2(id), 0x00010000);
+        nv_wr32(device, NV50_PDISPLAY_EVO_HASH_TAG(id), id);
+        nv_mask(device, NV50_PDISPLAY_EVO_CTRL(id), NV50_PDISPLAY_EVO_CTRL_DMA,
                      NV50_PDISPLAY_EVO_CTRL_DMA_ENABLED);
 
-        nv_wr32(dev, NV50_PDISPLAY_USER_PUT(id), 0x00000000);
-        nv_wr32(dev, NV50_PDISPLAY_EVO_CTRL(id), 0x01000003 |
+        nv_wr32(device, NV50_PDISPLAY_USER_PUT(id), 0x00000000);
+        nv_wr32(device, NV50_PDISPLAY_EVO_CTRL(id), 0x01000003 |
                      NV50_PDISPLAY_EVO_CTRL_DMA_ENABLED);
-        if (!nv_wait(dev, NV50_PDISPLAY_EVO_CTRL(id), 0x80000000, 0x00000000)) {
-                NV_ERROR(dev, "EvoCh %d init timeout: 0x%08x\n", id,
-                         nv_rd32(dev, NV50_PDISPLAY_EVO_CTRL(id)));
+        if (!nv_wait(device, NV50_PDISPLAY_EVO_CTRL(id), 0x80000000, 0x00000000)) {
+                NV_ERROR(drm, "EvoCh %d init timeout: 0x%08x\n", id,
+                         nv_rd32(device, NV50_PDISPLAY_EVO_CTRL(id)));
                 return -EBUSY;
         }
 
         /* enable error reporting on the channel */
-        nv_mask(dev, 0x610028, 0x00000000, 0x00010001 << id);
+        nv_mask(device, 0x610028, 0x00000000, 0x00010001 << id);
 
         evo->dma.max = (4096/4) - 2;
         evo->dma.max &= ~7;
@@ -205,16 +217,17 @@ nv50_evo_channel_init(struct nouveau_channel *evo)
 static void
 nv50_evo_channel_fini(struct nouveau_channel *evo)
 {
-        struct drm_device *dev = evo->dev;
-        int id = evo->id;
-
-        nv_mask(dev, 0x610028, 0x00010001 << id, 0x00000000);
-        nv_mask(dev, NV50_PDISPLAY_EVO_CTRL(id), 0x00001010, 0x00001000);
-        nv_wr32(dev, NV50_PDISPLAY_INTR_0, (1 << id));
-        nv_mask(dev, NV50_PDISPLAY_EVO_CTRL(id), 0x00000003, 0x00000000);
-        if (!nv_wait(dev, NV50_PDISPLAY_EVO_CTRL(id), 0x001e0000, 0x00000000)) {
-                NV_ERROR(dev, "EvoCh %d takedown timeout: 0x%08x\n", id,
-                         nv_rd32(dev, NV50_PDISPLAY_EVO_CTRL(id)));
+        struct nouveau_drm *drm = evo->drm;
+        struct nouveau_device *device = nv_device(drm->device);
+        int id = evo->handle;
+
+        nv_mask(device, 0x610028, 0x00010001 << id, 0x00000000);
+        nv_mask(device, NV50_PDISPLAY_EVO_CTRL(id), 0x00001010, 0x00001000);
+        nv_wr32(device, NV50_PDISPLAY_INTR_0, (1 << id));
+        nv_mask(device, NV50_PDISPLAY_EVO_CTRL(id), 0x00000003, 0x00000000);
+        if (!nv_wait(device, NV50_PDISPLAY_EVO_CTRL(id), 0x001e0000, 0x00000000)) {
+                NV_ERROR(drm, "EvoCh %d takedown timeout: 0x%08x\n", id,
+                         nv_rd32(device, NV50_PDISPLAY_EVO_CTRL(id)));
         }
 }
 
@@ -231,93 +244,66 @@ nv50_evo_destroy(struct drm_device *dev)
                 }
                 nv50_evo_channel_del(&disp->crtc[i].sync);
         }
-        nouveau_gpuobj_ref(NULL, &disp->ntfy);
         nv50_evo_channel_del(&disp->master);
+        nouveau_gpuobj_ref(NULL, &disp->ramin);
 }
 
 int
 nv50_evo_create(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_fb *pfb = nouveau_fb(drm->device);
         struct nv50_display *disp = nv50_display(dev);
-        struct nouveau_gpuobj *ramht = NULL;
         struct nouveau_channel *evo;
         int ret, i, j;
 
-        /* create primary evo channel, the one we use for modesetting
-         * purporses
-         */
-        ret = nv50_evo_channel_new(dev, 0, &disp->master);
-        if (ret)
-                return ret;
-        evo = disp->master;
-
         /* setup object management on it, any other evo channel will
          * use this also as there's no per-channel support on the
          * hardware
          */
-        ret = nouveau_gpuobj_new(dev, NULL, 32768, 65536,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &evo->ramin);
-        if (ret) {
-                NV_ERROR(dev, "Error allocating EVO channel memory: %d\n", ret);
-                goto err;
-        }
-
-        ret = drm_mm_init(&evo->ramin_heap, 0, 32768);
+        ret = nouveau_gpuobj_new(drm->device, NULL, 32768, 65536,
+                                 NVOBJ_FLAG_ZERO_ALLOC, &disp->ramin);
         if (ret) {
-                NV_ERROR(dev, "Error initialising EVO PRAMIN heap: %d\n", ret);
+                NV_ERROR(drm, "Error allocating EVO channel memory: %d\n", ret);
                 goto err;
         }
 
-        ret = nouveau_gpuobj_new(dev, evo, 4096, 16, 0, &ramht);
-        if (ret) {
-                NV_ERROR(dev, "Unable to allocate EVO RAMHT: %d\n", ret);
-                goto err;
-        }
-
-        ret = nouveau_ramht_new(dev, ramht, &evo->ramht);
-        nouveau_gpuobj_ref(NULL, &ramht);
-        if (ret)
-                goto err;
+        disp->hash = 0x0000;
+        disp->dmao = 0x1000;
 
-        /* not sure exactly what this is..
-         *
-         * the first dword of the structure is used by nvidia to wait on
-         * full completion of an EVO "update" command.
-         *
-         * method 0x8c on the master evo channel will fill a lot more of
-         * this structure with some undefined info
+        /* create primary evo channel, the one we use for modesetting
+         * purporses
          */
-        ret = nouveau_gpuobj_new(dev, disp->master, 0x1000, 0,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &disp->ntfy);
+        ret = nv50_evo_channel_new(dev, 0, &disp->master);
         if (ret)
-                goto err;
+                return ret;
+        evo = disp->master;
 
         ret = nv50_evo_dmaobj_new(disp->master, NvEvoSync, 0x0000,
-                                  disp->ntfy->vinst, disp->ntfy->size, NULL);
+                                  disp->ramin->addr + 0x2000, 0x1000, NULL);
         if (ret)
                 goto err;
 
         /* create some default objects for the scanout memtypes we support */
         ret = nv50_evo_dmaobj_new(disp->master, NvEvoVRAM, 0x0000,
-                                  0, dev_priv->vram_size, NULL);
+                                  0, pfb->ram.size, NULL);
         if (ret)
                 goto err;
 
         ret = nv50_evo_dmaobj_new(disp->master, NvEvoVRAM_LP, 0x80000000,
-                                  0, dev_priv->vram_size, NULL);
+                                  0, pfb->ram.size, NULL);
         if (ret)
                 goto err;
 
         ret = nv50_evo_dmaobj_new(disp->master, NvEvoFB32, 0x80000000 |
-                                  (dev_priv->chipset < 0xc0 ? 0x7a00 : 0xfe00),
-                                  0, dev_priv->vram_size, NULL);
+                                  (nv_device(drm->device)->chipset < 0xc0 ? 0x7a : 0xfe),
+                                  0, pfb->ram.size, NULL);
         if (ret)
                 goto err;
 
         ret = nv50_evo_dmaobj_new(disp->master, NvEvoFB16, 0x80000000 |
-                                  (dev_priv->chipset < 0xc0 ? 0x7000 : 0xfe00),
-                                  0, dev_priv->vram_size, NULL);
+                                  (nv_device(drm->device)->chipset < 0xc0 ? 0x70 : 0xfe),
+                                  0, pfb->ram.size, NULL);
         if (ret)
                 goto err;
 
@@ -352,21 +338,21 @@ nv50_evo_create(struct drm_device *dev)
                         goto err;
 
                 ret = nv50_evo_dmaobj_new(dispc->sync, NvEvoVRAM_LP, 0x80000000,
-                                          0, dev_priv->vram_size, NULL);
+                                          0, pfb->ram.size, NULL);
                 if (ret)
                         goto err;
 
                 ret = nv50_evo_dmaobj_new(dispc->sync, NvEvoFB32, 0x80000000 |
-                                          (dev_priv->chipset < 0xc0 ?
-                                          0x7a00 : 0xfe00),
-                                          0, dev_priv->vram_size, NULL);
+                                          (nv_device(drm->device)->chipset < 0xc0 ?
+                                          0x7a : 0xfe),
+                                          0, pfb->ram.size, NULL);
                 if (ret)
                         goto err;
 
                 ret = nv50_evo_dmaobj_new(dispc->sync, NvEvoFB16, 0x80000000 |
-                                          (dev_priv->chipset < 0xc0 ?
-                                          0x7000 : 0xfe00),
-                                          0, dev_priv->vram_size, NULL);
+                                          (nv_device(drm->device)->chipset < 0xc0 ?
+                                          0x70 : 0xfe),
+                                          0, pfb->ram.size, NULL);
                 if (ret)
                         goto err;
 
diff --git a/drivers/gpu/drm/nouveau/nv50_fb.c b/drivers/gpu/drm/nouveau/nv50_fb.c
deleted file mode 100644
index f1e4b9e07d14..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_fb.c
+++ /dev/null
@@ -1,296 +0,0 @@
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-#include "nouveau_fifo.h"
-
-struct nv50_fb_priv {
-        struct page *r100c08_page;
-        dma_addr_t r100c08;
-};
-
-static void
-nv50_fb_destroy(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        struct nv50_fb_priv *priv = pfb->priv;
-
-        if (drm_mm_initialized(&pfb->tag_heap))
-                drm_mm_takedown(&pfb->tag_heap);
-
-        if (priv->r100c08_page) {
-                pci_unmap_page(dev->pdev, priv->r100c08, PAGE_SIZE,
-                               PCI_DMA_BIDIRECTIONAL);
-                __free_page(priv->r100c08_page);
-        }
-
-        kfree(priv);
-        pfb->priv = NULL;
-}
-
-static int
-nv50_fb_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        struct nv50_fb_priv *priv;
-        u32 tagmem;
-        int ret;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-        pfb->priv = priv;
-
-        priv->r100c08_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
-        if (!priv->r100c08_page) {
-                nv50_fb_destroy(dev);
-                return -ENOMEM;
-        }
-
-        priv->r100c08 = pci_map_page(dev->pdev, priv->r100c08_page, 0,
-                                     PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-        if (pci_dma_mapping_error(dev->pdev, priv->r100c08)) {
-                nv50_fb_destroy(dev);
-                return -EFAULT;
-        }
-
-        tagmem = nv_rd32(dev, 0x100320);
-        NV_DEBUG(dev, "%d tags available\n", tagmem);
-        ret = drm_mm_init(&pfb->tag_heap, 0, tagmem);
-        if (ret) {
-                nv50_fb_destroy(dev);
-                return ret;
-        }
-
-        return 0;
-}
-
-int
-nv50_fb_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_fb_priv *priv;
-        int ret;
-
-        if (!dev_priv->engine.fb.priv) {
-                ret = nv50_fb_create(dev);
-                if (ret)
-                        return ret;
-        }
-        priv = dev_priv->engine.fb.priv;
-
-        /* Not a clue what this is exactly.  Without pointing it at a
-         * scratch page, VRAM->GART blits with M2MF (as in DDX DFS)
-         * cause IOMMU "read from address 0" errors (rh#561267)
-         */
-        nv_wr32(dev, 0x100c08, priv->r100c08 >> 8);
-
-        /* This is needed to get meaningful information from 100c90
-         * on traps. No idea what these values mean exactly. */
-        switch (dev_priv->chipset) {
-        case 0x50:
-                nv_wr32(dev, 0x100c90, 0x000707ff);
-                break;
-        case 0xa3:
-        case 0xa5:
-        case 0xa8:
-                nv_wr32(dev, 0x100c90, 0x000d0fff);
-                break;
-        case 0xaf:
-                nv_wr32(dev, 0x100c90, 0x089d1fff);
-                break;
-        default:
-                nv_wr32(dev, 0x100c90, 0x001d07ff);
-                break;
-        }
-
-        return 0;
-}
-
-void
-nv50_fb_takedown(struct drm_device *dev)
-{
-        nv50_fb_destroy(dev);
-}
-
-static struct nouveau_enum vm_dispatch_subclients[] = {
-        { 0x00000000, "GRCTX", NULL },
-        { 0x00000001, "NOTIFY", NULL },
-        { 0x00000002, "QUERY", NULL },
-        { 0x00000003, "COND", NULL },
-        { 0x00000004, "M2M_IN", NULL },
-        { 0x00000005, "M2M_OUT", NULL },
-        { 0x00000006, "M2M_NOTIFY", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_ccache_subclients[] = {
-        { 0x00000000, "CB", NULL },
-        { 0x00000001, "TIC", NULL },
-        { 0x00000002, "TSC", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_prop_subclients[] = {
-        { 0x00000000, "RT0", NULL },
-        { 0x00000001, "RT1", NULL },
-        { 0x00000002, "RT2", NULL },
-        { 0x00000003, "RT3", NULL },
-        { 0x00000004, "RT4", NULL },
-        { 0x00000005, "RT5", NULL },
-        { 0x00000006, "RT6", NULL },
-        { 0x00000007, "RT7", NULL },
-        { 0x00000008, "ZETA", NULL },
-        { 0x00000009, "LOCAL", NULL },
-        { 0x0000000a, "GLOBAL", NULL },
-        { 0x0000000b, "STACK", NULL },
-        { 0x0000000c, "DST2D", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_pfifo_subclients[] = {
-        { 0x00000000, "PUSHBUF", NULL },
-        { 0x00000001, "SEMAPHORE", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_bar_subclients[] = {
-        { 0x00000000, "FB", NULL },
-        { 0x00000001, "IN", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_client[] = {
-        { 0x00000000, "STRMOUT", NULL },
-        { 0x00000003, "DISPATCH", vm_dispatch_subclients },
-        { 0x00000004, "PFIFO_WRITE", NULL },
-        { 0x00000005, "CCACHE", vm_ccache_subclients },
-        { 0x00000006, "PPPP", NULL },
-        { 0x00000007, "CLIPID", NULL },
-        { 0x00000008, "PFIFO_READ", NULL },
-        { 0x00000009, "VFETCH", NULL },
-        { 0x0000000a, "TEXTURE", NULL },
-        { 0x0000000b, "PROP", vm_prop_subclients },
-        { 0x0000000c, "PVP", NULL },
-        { 0x0000000d, "PBSP", NULL },
-        { 0x0000000e, "PCRYPT", NULL },
-        { 0x0000000f, "PCOUNTER", NULL },
-        { 0x00000011, "PDAEMON", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_engine[] = {
-        { 0x00000000, "PGRAPH", NULL },
-        { 0x00000001, "PVP", NULL },
-        { 0x00000004, "PEEPHOLE", NULL },
-        { 0x00000005, "PFIFO", vm_pfifo_subclients },
-        { 0x00000006, "BAR", vm_bar_subclients },
-        { 0x00000008, "PPPP", NULL },
-        { 0x00000009, "PBSP", NULL },
-        { 0x0000000a, "PCRYPT", NULL },
-        { 0x0000000b, "PCOUNTER", NULL },
-        { 0x0000000c, "SEMAPHORE_BG", NULL },
-        { 0x0000000d, "PCOPY", NULL },
-        { 0x0000000e, "PDAEMON", NULL },
-        {}
-};
-
-static struct nouveau_enum vm_fault[] = {
-        { 0x00000000, "PT_NOT_PRESENT", NULL },
-        { 0x00000001, "PT_TOO_SHORT", NULL },
-        { 0x00000002, "PAGE_NOT_PRESENT", NULL },
-        { 0x00000003, "PAGE_SYSTEM_ONLY", NULL },
-        { 0x00000004, "PAGE_READ_ONLY", NULL },
-        { 0x00000006, "NULL_DMAOBJ", NULL },
-        { 0x00000007, "WRONG_MEMTYPE", NULL },
-        { 0x0000000b, "VRAM_LIMIT", NULL },
-        { 0x0000000f, "DMAOBJ_LIMIT", NULL },
-        {}
-};
-
-void
-nv50_fb_vm_trap(struct drm_device *dev, int display)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        const struct nouveau_enum *en, *cl;
-        unsigned long flags;
-        u32 trap[6], idx, chinst;
-        u8 st0, st1, st2, st3;
-        int i, ch;
-
-        idx = nv_rd32(dev, 0x100c90);
-        if (!(idx & 0x80000000))
-                return;
-        idx &= 0x00ffffff;
-
-        for (i = 0; i < 6; i++) {
-                nv_wr32(dev, 0x100c90, idx | i << 24);
-                trap[i] = nv_rd32(dev, 0x100c94);
-        }
-        nv_wr32(dev, 0x100c90, idx | 0x80000000);
-
-        if (!display)
-                return;
-
-        /* lookup channel id */
-        chinst = (trap[2] << 16) | trap[1];
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (ch = 0; ch < pfifo->channels; ch++) {
-                struct nouveau_channel *chan = dev_priv->channels.ptr[ch];
-
-                if (!chan || !chan->ramin)
-                        continue;
-
-                if (chinst == chan->ramin->vinst >> 12)
-                        break;
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-
-        /* decode status bits into something more useful */
-        if (dev_priv->chipset  < 0xa3 ||
-            dev_priv->chipset == 0xaa || dev_priv->chipset == 0xac) {
-                st0 = (trap[0] & 0x0000000f) >> 0;
-                st1 = (trap[0] & 0x000000f0) >> 4;
-                st2 = (trap[0] & 0x00000f00) >> 8;
-                st3 = (trap[0] & 0x0000f000) >> 12;
-        } else {
-                st0 = (trap[0] & 0x000000ff) >> 0;
-                st1 = (trap[0] & 0x0000ff00) >> 8;
-                st2 = (trap[0] & 0x00ff0000) >> 16;
-                st3 = (trap[0] & 0xff000000) >> 24;
-        }
-
-        NV_INFO(dev, "VM: trapped %s at 0x%02x%04x%04x on ch %d [0x%08x] ",
-                (trap[5] & 0x00000100) ? "read" : "write",
-                trap[5] & 0xff, trap[4] & 0xffff, trap[3] & 0xffff, ch, chinst);
-
-        en = nouveau_enum_find(vm_engine, st0);
-        if (en)
-                printk("%s/", en->name);
-        else
-                printk("%02x/", st0);
-
-        cl = nouveau_enum_find(vm_client, st2);
-        if (cl)
-                printk("%s/", cl->name);
-        else
-                printk("%02x/", st2);
-
-        if      (cl && cl->data) cl = nouveau_enum_find(cl->data, st3);
-        else if (en && en->data) cl = nouveau_enum_find(en->data, st3);
-        else                     cl = NULL;
-        if (cl)
-                printk("%s", cl->name);
-        else
-                printk("%02x", st3);
-
-        printk(" reason: ");
-        en = nouveau_enum_find(vm_fault, st1);
-        if (en)
-                printk("%s\n", en->name);
-        else
-                printk("0x%08x\n", st1);
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_fbcon.c b/drivers/gpu/drm/nouveau/nv50_fbcon.c
index e3c8b05dcae4..52068a0910dc 100644
--- a/drivers/gpu/drm/nouveau/nv50_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nv50_fbcon.c
@@ -22,20 +22,16 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fbcon.h"
-#include "nouveau_mm.h"
 
 int
 nv50_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         ret = RING_SPACE(chan, rect->rop == ROP_COPY ? 7 : 11);
@@ -69,9 +65,8 @@ int
 nv50_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         ret = RING_SPACE(chan, 12);
@@ -98,9 +93,8 @@ int
 nv50_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         uint32_t width, dwords, *data = (uint32_t *)image->data;
         uint32_t mask = ~(~0 >> (32 - info->var.bits_per_pixel));
         uint32_t *palette = info->pseudo_palette;
@@ -156,10 +150,11 @@ int
 nv50_fbcon_accel_init(struct fb_info *info)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
         struct nouveau_framebuffer *fb = &nfbdev->nouveau_fb;
+        struct drm_device *dev = nfbdev->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_channel *chan = drm->channel;
+        struct nouveau_object *object;
         int ret, format;
 
         switch (info->var.bits_per_pixel) {
@@ -189,7 +184,8 @@ nv50_fbcon_accel_init(struct fb_info *info)
                 return -EINVAL;
         }
 
-        ret = nouveau_gpuobj_gr_new(dev_priv->channel, Nv2D, 0x502d);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, Nv2D,
+                                 0x502d, NULL, 0, &object);
         if (ret)
                 return ret;
 
@@ -202,9 +198,9 @@ nv50_fbcon_accel_init(struct fb_info *info)
         BEGIN_NV04(chan, NvSub2D, 0x0000, 1);
         OUT_RING(chan, Nv2D);
         BEGIN_NV04(chan, NvSub2D, 0x0184, 3);
-        OUT_RING(chan, chan->vram_handle);
-        OUT_RING(chan, chan->vram_handle);
-        OUT_RING(chan, chan->vram_handle);
+        OUT_RING(chan, NvDmaFB);
+        OUT_RING(chan, NvDmaFB);
+        OUT_RING(chan, NvDmaFB);
         BEGIN_NV04(chan, NvSub2D, 0x0290, 1);
         OUT_RING(chan, 0);
         BEGIN_NV04(chan, NvSub2D, 0x0888, 1);
diff --git a/drivers/gpu/drm/nouveau/nv50_fence.c b/drivers/gpu/drm/nouveau/nv50_fence.c
new file mode 100644
index 000000000000..e0763ea88ee2
--- /dev/null
+++ b/drivers/gpu/drm/nouveau/nv50_fence.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2012 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 <bskeggs@redhat.com>
+ */
+
+#include <core/object.h>
+#include <core/class.h>
+
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
+#include "nouveau_fence.h"
+
+#include "nv50_display.h"
+
+struct nv50_fence_chan {
+        struct nouveau_fence_chan base;
+};
+
+struct nv50_fence_priv {
+        struct nouveau_fence_priv base;
+        struct nouveau_bo *bo;
+        spinlock_t lock;
+        u32 sequence;
+};
+
+static int
+nv50_fence_context_new(struct nouveau_channel *chan)
+{
+        struct drm_device *dev = chan->drm->dev;
+        struct nv50_fence_priv *priv = chan->drm->fence;
+        struct nv50_fence_chan *fctx;
+        struct ttm_mem_reg *mem = &priv->bo->bo.mem;
+        struct nouveau_object *object;
+        int ret, i;
+
+        fctx = chan->fence = kzalloc(sizeof(*fctx), GFP_KERNEL);
+        if (!fctx)
+                return -ENOMEM;
+
+        nouveau_fence_context_new(&fctx->base);
+
+        ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
+                                 NvSema, 0x0002,
+                                 &(struct nv_dma_class) {
+                                        .flags = NV_DMA_TARGET_VRAM |
+                                                 NV_DMA_ACCESS_RDWR,
+                                        .start = mem->start * PAGE_SIZE,
+                                        .limit = mem->size - 1,
+                                 }, sizeof(struct nv_dma_class),
+                                 &object);
+
+        /* dma objects for display sync channel semaphore blocks */
+        for (i = 0; !ret && i < dev->mode_config.num_crtc; i++) {
+                struct nouveau_bo *bo = nv50_display_crtc_sema(dev, i);
+
+                ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
+                                         NvEvoSema0 + i, 0x003d,
+                                         &(struct nv_dma_class) {
+                                                .flags = NV_DMA_TARGET_VRAM |
+                                                         NV_DMA_ACCESS_RDWR,
+                                                .start = bo->bo.offset,
+                                                .limit = bo->bo.offset + 0xfff,
+                                         }, sizeof(struct nv_dma_class),
+                                         &object);
+        }
+
+        if (ret)
+                nv10_fence_context_del(chan);
+        return ret;
+}
+
+int
+nv50_fence_create(struct nouveau_drm *drm)
+{
+        struct nv50_fence_priv *priv;
+        int ret = 0;
+
+        priv = drm->fence = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->base.dtor = nv10_fence_destroy;
+        priv->base.context_new = nv50_fence_context_new;
+        priv->base.context_del = nv10_fence_context_del;
+        priv->base.emit = nv10_fence_emit;
+        priv->base.read = nv10_fence_read;
+        priv->base.sync = nv17_fence_sync;
+        spin_lock_init(&priv->lock);
+
+        ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
+                             0, 0x0000, NULL, &priv->bo);
+        if (!ret) {
+                ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
+                if (!ret)
+                        ret = nouveau_bo_map(priv->bo);
+                if (ret)
+                        nouveau_bo_ref(NULL, &priv->bo);
+        }
+
+        if (ret == 0) {
+                nouveau_bo_wr32(priv->bo, 0x000, 0x00000000);
+                priv->base.sync = nv17_fence_sync;
+        }
+
+        if (ret)
+                nv10_fence_destroy(drm);
+        return ret;
+}
diff --git a/drivers/gpu/drm/nouveau/nv50_fifo.c b/drivers/gpu/drm/nouveau/nv50_fifo.c
deleted file mode 100644
index 55383b85db0b..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_fifo.c
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * Copyright (C) 2012 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-#include "nouveau_vm.h"
-
-struct nv50_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct nouveau_gpuobj *playlist[2];
-        int cur_playlist;
-};
-
-struct nv50_fifo_chan {
-        struct nouveau_fifo_chan base;
-};
-
-void
-nv50_fifo_playlist_update(struct drm_device *dev)
-{
-        struct nv50_fifo_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *cur;
-        int i, p;
-
-        cur = priv->playlist[priv->cur_playlist];
-        priv->cur_playlist = !priv->cur_playlist;
-
-        for (i = 0, p = 0; i < priv->base.channels; i++) {
-                if (nv_rd32(dev, 0x002600 + (i * 4)) & 0x80000000)
-                        nv_wo32(cur, p++ * 4, i);
-        }
-
-        dev_priv->engine.instmem.flush(dev);
-
-        nv_wr32(dev, 0x0032f4, cur->vinst >> 12);
-        nv_wr32(dev, 0x0032ec, p);
-        nv_wr32(dev, 0x002500, 0x00000101);
-}
-
-static int
-nv50_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv50_fifo_priv *priv = nv_engine(chan->dev, engine);
-        struct nv50_fifo_chan *fctx;
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u64 ib_offset = chan->pushbuf_base + chan->dma.ib_base * 4;
-        u64 instance = chan->ramin->vinst >> 12;
-        unsigned long flags;
-        int ret = 0, i;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-        atomic_inc(&chan->vm->engref[engine]);
-
-        chan->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                             NV50_USER(chan->id), PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        for (i = 0; i < 0x100; i += 4)
-                nv_wo32(chan->ramin, i, 0x00000000);
-        nv_wo32(chan->ramin, 0x3c, 0x403f6078);
-        nv_wo32(chan->ramin, 0x40, 0x00000000);
-        nv_wo32(chan->ramin, 0x44, 0x01003fff);
-        nv_wo32(chan->ramin, 0x48, chan->pushbuf->cinst >> 4);
-        nv_wo32(chan->ramin, 0x50, lower_32_bits(ib_offset));
-        nv_wo32(chan->ramin, 0x54, upper_32_bits(ib_offset) |
-                                   drm_order(chan->dma.ib_max + 1) << 16);
-        nv_wo32(chan->ramin, 0x60, 0x7fffffff);
-        nv_wo32(chan->ramin, 0x78, 0x00000000);
-        nv_wo32(chan->ramin, 0x7c, 0x30000001);
-        nv_wo32(chan->ramin, 0x80, ((chan->ramht->bits - 9) << 27) |
-                                   (4 << 24) /* SEARCH_FULL */ |
-                                   (chan->ramht->gpuobj->cinst >> 4));
-
-        dev_priv->engine.instmem.flush(dev);
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_wr32(dev, 0x002600 + (chan->id * 4), 0x80000000 | instance);
-        nv50_fifo_playlist_update(dev);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static bool
-nv50_fifo_kickoff(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-        bool done = true;
-        u32 me;
-
-        /* HW bug workaround:
-         *
-         * PFIFO will hang forever if the connected engines don't report
-         * that they've processed the context switch request.
-         *
-         * In order for the kickoff to work, we need to ensure all the
-         * connected engines are in a state where they can answer.
-         *
-         * Newer chipsets don't seem to suffer from this issue, and well,
-         * there's also a "ignore these engines" bitmask reg we can use
-         * if we hit the issue there..
-         */
-
-        /* PME: make sure engine is enabled */
-        me = nv_mask(dev, 0x00b860, 0x00000001, 0x00000001);
-
-        /* do the kickoff... */
-        nv_wr32(dev, 0x0032fc, chan->ramin->vinst >> 12);
-        if (!nv_wait_ne(dev, 0x0032fc, 0xffffffff, 0xffffffff)) {
-                NV_INFO(dev, "PFIFO: channel %d unload timeout\n", chan->id);
-                done = false;
-        }
-
-        /* restore any engine states we changed, and exit */
-        nv_wr32(dev, 0x00b860, me);
-        return done;
-}
-
-static void
-nv50_fifo_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv50_fifo_chan *fctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-
-        /* remove channel from playlist, will context switch if active */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x002600 + (chan->id * 4), 0x80000000, 0x00000000);
-        nv50_fifo_playlist_update(dev);
-
-        /* tell any engines on this channel to unload their contexts */
-        nv50_fifo_kickoff(chan);
-
-        nv_wr32(dev, 0x002600 + (chan->id * 4), 0x00000000);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* clean up */
-        if (chan->user) {
-                iounmap(chan->user);
-                chan->user = NULL;
-        }
-
-        atomic_dec(&chan->vm->engref[engine]);
-        chan->engctx[engine] = NULL;
-        kfree(fctx);
-}
-
-static int
-nv50_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 instance;
-        int i;
-
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000100);
-        nv_wr32(dev, 0x00250c, 0x6f3cfc34);
-        nv_wr32(dev, 0x002044, 0x01003fff);
-
-        nv_wr32(dev, 0x002100, 0xffffffff);
-        nv_wr32(dev, 0x002140, 0xffffffff);
-
-        for (i = 0; i < 128; i++) {
-                struct nouveau_channel *chan = dev_priv->channels.ptr[i];
-                if (chan && chan->engctx[engine])
-                        instance = 0x80000000 | chan->ramin->vinst >> 12;
-                else
-                        instance = 0x00000000;
-                nv_wr32(dev, 0x002600 + (i * 4), instance);
-        }
-
-        nv50_fifo_playlist_update(dev);
-
-        nv_wr32(dev, 0x003200, 1);
-        nv_wr32(dev, 0x003250, 1);
-        nv_wr32(dev, 0x002500, 1);
-        return 0;
-}
-
-static int
-nv50_fifo_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-
-        /* set playlist length to zero, fifo will unload context */
-        nv_wr32(dev, 0x0032ec, 0);
-
-        /* tell all connected engines to unload their contexts */
-        for (i = 0; i < priv->base.channels; i++) {
-                struct nouveau_channel *chan = dev_priv->channels.ptr[i];
-                if (chan && !nv50_fifo_kickoff(chan))
-                        return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x002140, 0);
-        return 0;
-}
-
-void
-nv50_fifo_tlb_flush(struct drm_device *dev, int engine)
-{
-        nv50_vm_flush_engine(dev, 5);
-}
-
-void
-nv50_fifo_destroy(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_fifo_priv *priv = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 8);
-
-        nouveau_gpuobj_ref(NULL, &priv->playlist[0]);
-        nouveau_gpuobj_ref(NULL, &priv->playlist[1]);
-
-        dev_priv->eng[engine] = NULL;
-        kfree(priv);
-}
-
-int
-nv50_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_fifo_priv *priv;
-        int ret;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nv50_fifo_destroy;
-        priv->base.base.init = nv50_fifo_init;
-        priv->base.base.fini = nv50_fifo_fini;
-        priv->base.base.context_new = nv50_fifo_context_new;
-        priv->base.base.context_del = nv50_fifo_context_del;
-        priv->base.base.tlb_flush = nv50_fifo_tlb_flush;
-        priv->base.channels = 127;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        ret = nouveau_gpuobj_new(dev, NULL, priv->base.channels * 4, 0x1000,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->playlist[0]);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, priv->base.channels * 4, 0x1000,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->playlist[1]);
-        if (ret)
-                goto error;
-
-        nouveau_irq_register(dev, 8, nv04_fifo_isr);
-error:
-        if (ret)
-                priv->base.base.destroy(dev, NVOBJ_ENGINE_FIFO);
-        return ret;
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_gpio.c b/drivers/gpu/drm/nouveau/nv50_gpio.c
deleted file mode 100644
index c399d510b27a..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_gpio.c
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * 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 <linux/dmi.h>
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_hw.h"
-#include "nouveau_gpio.h"
-
-#include "nv50_display.h"
-
-static int
-nv50_gpio_location(int line, u32 *reg, u32 *shift)
-{
-        const uint32_t nv50_gpio_reg[4] = { 0xe104, 0xe108, 0xe280, 0xe284 };
-
-        if (line >= 32)
-                return -EINVAL;
-
-        *reg = nv50_gpio_reg[line >> 3];
-        *shift = (line & 7) << 2;
-        return 0;
-}
-
-int
-nv50_gpio_drive(struct drm_device *dev, int line, int dir, int out)
-{
-        u32 reg, shift;
-
-        if (nv50_gpio_location(line, &reg, &shift))
-                return -EINVAL;
-
-        nv_mask(dev, reg, 7 << shift, (((dir ^ 1) << 1) | out) << shift);
-        return 0;
-}
-
-int
-nv50_gpio_sense(struct drm_device *dev, int line)
-{
-        u32 reg, shift;
-
-        if (nv50_gpio_location(line, &reg, &shift))
-                return -EINVAL;
-
-        return !!(nv_rd32(dev, reg) & (4 << shift));
-}
-
-void
-nv50_gpio_irq_enable(struct drm_device *dev, int line, bool on)
-{
-        u32 reg  = line < 16 ? 0xe050 : 0xe070;
-        u32 mask = 0x00010001 << (line & 0xf);
-
-        nv_wr32(dev, reg + 4, mask);
-        nv_mask(dev, reg + 0, mask, on ? mask : 0);
-}
-
-int
-nvd0_gpio_drive(struct drm_device *dev, int line, int dir, int out)
-{
-        u32 data = ((dir ^ 1) << 13) | (out << 12);
-        nv_mask(dev, 0x00d610 + (line * 4), 0x00003000, data);
-        nv_mask(dev, 0x00d604, 0x00000001, 0x00000001); /* update? */
-        return 0;
-}
-
-int
-nvd0_gpio_sense(struct drm_device *dev, int line)
-{
-        return !!(nv_rd32(dev, 0x00d610 + (line * 4)) & 0x00004000);
-}
-
-static void
-nv50_gpio_isr(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 intr0, intr1 = 0;
-        u32 hi, lo;
-
-        intr0 = nv_rd32(dev, 0xe054) & nv_rd32(dev, 0xe050);
-        if (dev_priv->chipset >= 0x90)
-                intr1 = nv_rd32(dev, 0xe074) & nv_rd32(dev, 0xe070);
-
-        hi = (intr0 & 0x0000ffff) | (intr1 << 16);
-        lo = (intr0 >> 16) | (intr1 & 0xffff0000);
-        nouveau_gpio_isr(dev, 0, hi | lo);
-
-        nv_wr32(dev, 0xe054, intr0);
-        if (dev_priv->chipset >= 0x90)
-                nv_wr32(dev, 0xe074, intr1);
-}
-
-static struct dmi_system_id gpio_reset_ids[] = {
-        {
-                .ident = "Apple Macbook 10,1",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro10,1"),
-                }
-        },
-        { }
-};
-
-int
-nv50_gpio_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        /* initialise gpios and routing to vbios defaults */
-        if (dmi_check_system(gpio_reset_ids))
-                nouveau_gpio_reset(dev);
-
-        /* disable, and ack any pending gpio interrupts */
-        nv_wr32(dev, 0xe050, 0x00000000);
-        nv_wr32(dev, 0xe054, 0xffffffff);
-        if (dev_priv->chipset >= 0x90) {
-                nv_wr32(dev, 0xe070, 0x00000000);
-                nv_wr32(dev, 0xe074, 0xffffffff);
-        }
-
-        nouveau_irq_register(dev, 21, nv50_gpio_isr);
-        return 0;
-}
-
-void
-nv50_gpio_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nv_wr32(dev, 0xe050, 0x00000000);
-        if (dev_priv->chipset >= 0x90)
-                nv_wr32(dev, 0xe070, 0x00000000);
-        nouveau_irq_unregister(dev, 21);
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_graph.c b/drivers/gpu/drm/nouveau/nv50_graph.c
deleted file mode 100644
index 437608d1dfe7..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_graph.c
+++ /dev/null
@@ -1,868 +0,0 @@
-/*
- * Copyright (C) 2007 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-#include "nouveau_dma.h"
-#include "nouveau_vm.h"
-#include "nv50_evo.h"
-
-struct nv50_graph_engine {
-        struct nouveau_exec_engine base;
-        u32 ctxprog[512];
-        u32 ctxprog_size;
-        u32 grctx_size;
-};
-
-static int
-nv50_graph_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_graph_engine *pgraph = nv_engine(dev, engine);
-        u32 units = nv_rd32(dev, 0x001540);
-        int i;
-
-        NV_DEBUG(dev, "\n");
-
-        /* master reset */
-        nv_mask(dev, 0x000200, 0x00201000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00201000, 0x00201000);
-        nv_wr32(dev, 0x40008c, 0x00000004); /* HW_CTX_SWITCH_ENABLED */
-
-        /* reset/enable traps and interrupts */
-        nv_wr32(dev, 0x400804, 0xc0000000);
-        nv_wr32(dev, 0x406800, 0xc0000000);
-        nv_wr32(dev, 0x400c04, 0xc0000000);
-        nv_wr32(dev, 0x401800, 0xc0000000);
-        nv_wr32(dev, 0x405018, 0xc0000000);
-        nv_wr32(dev, 0x402000, 0xc0000000);
-        for (i = 0; i < 16; i++) {
-                if (!(units & (1 << i)))
-                        continue;
-
-                if (dev_priv->chipset < 0xa0) {
-                        nv_wr32(dev, 0x408900 + (i << 12), 0xc0000000);
-                        nv_wr32(dev, 0x408e08 + (i << 12), 0xc0000000);
-                        nv_wr32(dev, 0x408314 + (i << 12), 0xc0000000);
-                } else {
-                        nv_wr32(dev, 0x408600 + (i << 11), 0xc0000000);
-                        nv_wr32(dev, 0x408708 + (i << 11), 0xc0000000);
-                        nv_wr32(dev, 0x40831c + (i << 11), 0xc0000000);
-                }
-        }
-
-        nv_wr32(dev, 0x400108, 0xffffffff);
-        nv_wr32(dev, 0x400138, 0xffffffff);
-        nv_wr32(dev, 0x400100, 0xffffffff);
-        nv_wr32(dev, 0x40013c, 0xffffffff);
-        nv_wr32(dev, 0x400500, 0x00010001);
-
-        /* upload context program, initialise ctxctl defaults */
-        nv_wr32(dev, 0x400324, 0x00000000);
-        for (i = 0; i < pgraph->ctxprog_size; i++)
-                nv_wr32(dev, 0x400328, pgraph->ctxprog[i]);
-        nv_wr32(dev, 0x400824, 0x00000000);
-        nv_wr32(dev, 0x400828, 0x00000000);
-        nv_wr32(dev, 0x40082c, 0x00000000);
-        nv_wr32(dev, 0x400830, 0x00000000);
-        nv_wr32(dev, 0x400724, 0x00000000);
-        nv_wr32(dev, 0x40032c, 0x00000000);
-        nv_wr32(dev, 0x400320, 4);      /* CTXCTL_CMD = NEWCTXDMA */
-
-        /* some unknown zcull magic */
-        switch (dev_priv->chipset & 0xf0) {
-        case 0x50:
-        case 0x80:
-        case 0x90:
-                nv_wr32(dev, 0x402ca8, 0x00000800);
-                break;
-        case 0xa0:
-        default:
-                nv_wr32(dev, 0x402cc0, 0x00000000);
-                if (dev_priv->chipset == 0xa0 ||
-                    dev_priv->chipset == 0xaa ||
-                    dev_priv->chipset == 0xac) {
-                        nv_wr32(dev, 0x402ca8, 0x00000802);
-                } else {
-                        nv_wr32(dev, 0x402cc0, 0x00000000);
-                        nv_wr32(dev, 0x402ca8, 0x00000002);
-                }
-
-                break;
-        }
-
-        /* zero out zcull regions */
-        for (i = 0; i < 8; i++) {
-                nv_wr32(dev, 0x402c20 + (i * 8), 0x00000000);
-                nv_wr32(dev, 0x402c24 + (i * 8), 0x00000000);
-                nv_wr32(dev, 0x402c28 + (i * 8), 0x00000000);
-                nv_wr32(dev, 0x402c2c + (i * 8), 0x00000000);
-        }
-
-        return 0;
-}
-
-static int
-nv50_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_wr32(dev, 0x40013c, 0x00000000);
-        return 0;
-}
-
-static int
-nv50_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ramin = chan->ramin;
-        struct nouveau_gpuobj *grctx = NULL;
-        struct nv50_graph_engine *pgraph = nv_engine(dev, engine);
-        int hdr, ret;
-
-        NV_DEBUG(dev, "ch%d\n", chan->id);
-
-        ret = nouveau_gpuobj_new(dev, NULL, pgraph->grctx_size, 0,
-                                 NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &grctx);
-        if (ret)
-                return ret;
-
-        hdr = (dev_priv->chipset == 0x50) ? 0x200 : 0x20;
-        nv_wo32(ramin, hdr + 0x00, 0x00190002);
-        nv_wo32(ramin, hdr + 0x04, grctx->vinst + grctx->size - 1);
-        nv_wo32(ramin, hdr + 0x08, grctx->vinst);
-        nv_wo32(ramin, hdr + 0x0c, 0);
-        nv_wo32(ramin, hdr + 0x10, 0);
-        nv_wo32(ramin, hdr + 0x14, 0x00010000);
-
-        nv50_grctx_fill(dev, grctx);
-        nv_wo32(grctx, 0x00000, chan->ramin->vinst >> 12);
-
-        dev_priv->engine.instmem.flush(dev);
-
-        atomic_inc(&chan->vm->engref[NVOBJ_ENGINE_GR]);
-        chan->engctx[NVOBJ_ENGINE_GR] = grctx;
-        return 0;
-}
-
-static void
-nv50_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nouveau_gpuobj *grctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int i, hdr = (dev_priv->chipset == 0x50) ? 0x200 : 0x20;
-
-        for (i = hdr; i < hdr + 24; i += 4)
-                nv_wo32(chan->ramin, i, 0);
-        dev_priv->engine.instmem.flush(dev);
-
-        atomic_dec(&chan->vm->engref[engine]);
-        nouveau_gpuobj_ref(NULL, &grctx);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nv50_graph_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 1;
-        obj->class  = class;
-
-        nv_wo32(obj, 0x00, class);
-        nv_wo32(obj, 0x04, 0x00000000);
-        nv_wo32(obj, 0x08, 0x00000000);
-        nv_wo32(obj, 0x0c, 0x00000000);
-        dev_priv->engine.instmem.flush(dev);
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static void
-nv50_graph_tlb_flush(struct drm_device *dev, int engine)
-{
-        nv50_vm_flush_engine(dev, 0);
-}
-
-static void
-nv84_graph_tlb_flush(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_timer_engine *ptimer = &dev_priv->engine.timer;
-        bool idle, timeout = false;
-        unsigned long flags;
-        u64 start;
-        u32 tmp;
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x400500, 0x00000001, 0x00000000);
-
-        start = ptimer->read(dev);
-        do {
-                idle = true;
-
-                for (tmp = nv_rd32(dev, 0x400380); tmp && idle; tmp >>= 3) {
-                        if ((tmp & 7) == 1)
-                                idle = false;
-                }
-
-                for (tmp = nv_rd32(dev, 0x400384); tmp && idle; tmp >>= 3) {
-                        if ((tmp & 7) == 1)
-                                idle = false;
-                }
-
-                for (tmp = nv_rd32(dev, 0x400388); tmp && idle; tmp >>= 3) {
-                        if ((tmp & 7) == 1)
-                                idle = false;
-                }
-        } while (!idle && !(timeout = ptimer->read(dev) - start > 2000000000));
-
-        if (timeout) {
-                NV_ERROR(dev, "PGRAPH TLB flush idle timeout fail: "
-                              "0x%08x 0x%08x 0x%08x 0x%08x\n",
-                         nv_rd32(dev, 0x400700), nv_rd32(dev, 0x400380),
-                         nv_rd32(dev, 0x400384), nv_rd32(dev, 0x400388));
-        }
-
-        nv50_vm_flush_engine(dev, 0);
-
-        nv_mask(dev, 0x400500, 0x00000001, 0x00000001);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-}
-
-static struct nouveau_enum nv50_mp_exec_error_names[] = {
-        { 3, "STACK_UNDERFLOW", NULL },
-        { 4, "QUADON_ACTIVE", NULL },
-        { 8, "TIMEOUT", NULL },
-        { 0x10, "INVALID_OPCODE", NULL },
-        { 0x40, "BREAKPOINT", NULL },
-        {}
-};
-
-static struct nouveau_bitfield nv50_graph_trap_m2mf[] = {
-        { 0x00000001, "NOTIFY" },
-        { 0x00000002, "IN" },
-        { 0x00000004, "OUT" },
-        {}
-};
-
-static struct nouveau_bitfield nv50_graph_trap_vfetch[] = {
-        { 0x00000001, "FAULT" },
-        {}
-};
-
-static struct nouveau_bitfield nv50_graph_trap_strmout[] = {
-        { 0x00000001, "FAULT" },
-        {}
-};
-
-static struct nouveau_bitfield nv50_graph_trap_ccache[] = {
-        { 0x00000001, "FAULT" },
-        {}
-};
-
-/* There must be a *lot* of these. Will take some time to gather them up. */
-struct nouveau_enum nv50_data_error_names[] = {
-        { 0x00000003, "INVALID_OPERATION", NULL },
-        { 0x00000004, "INVALID_VALUE", NULL },
-        { 0x00000005, "INVALID_ENUM", NULL },
-        { 0x00000008, "INVALID_OBJECT", NULL },
-        { 0x00000009, "READ_ONLY_OBJECT", NULL },
-        { 0x0000000a, "SUPERVISOR_OBJECT", NULL },
-        { 0x0000000b, "INVALID_ADDRESS_ALIGNMENT", NULL },
-        { 0x0000000c, "INVALID_BITFIELD", NULL },
-        { 0x0000000d, "BEGIN_END_ACTIVE", NULL },
-        { 0x0000000e, "SEMANTIC_COLOR_BACK_OVER_LIMIT", NULL },
-        { 0x0000000f, "VIEWPORT_ID_NEEDS_GP", NULL },
-        { 0x00000010, "RT_DOUBLE_BIND", NULL },
-        { 0x00000011, "RT_TYPES_MISMATCH", NULL },
-        { 0x00000012, "RT_LINEAR_WITH_ZETA", NULL },
-        { 0x00000015, "FP_TOO_FEW_REGS", NULL },
-        { 0x00000016, "ZETA_FORMAT_CSAA_MISMATCH", NULL },
-        { 0x00000017, "RT_LINEAR_WITH_MSAA", NULL },
-        { 0x00000018, "FP_INTERPOLANT_START_OVER_LIMIT", NULL },
-        { 0x00000019, "SEMANTIC_LAYER_OVER_LIMIT", NULL },
-        { 0x0000001a, "RT_INVALID_ALIGNMENT", NULL },
-        { 0x0000001b, "SAMPLER_OVER_LIMIT", NULL },
-        { 0x0000001c, "TEXTURE_OVER_LIMIT", NULL },
-        { 0x0000001e, "GP_TOO_MANY_OUTPUTS", NULL },
-        { 0x0000001f, "RT_BPP128_WITH_MS8", NULL },
-        { 0x00000021, "Z_OUT_OF_BOUNDS", NULL },
-        { 0x00000023, "XY_OUT_OF_BOUNDS", NULL },
-        { 0x00000024, "VP_ZERO_INPUTS", NULL },
-        { 0x00000027, "CP_MORE_PARAMS_THAN_SHARED", NULL },
-        { 0x00000028, "CP_NO_REG_SPACE_STRIPED", NULL },
-        { 0x00000029, "CP_NO_REG_SPACE_PACKED", NULL },
-        { 0x0000002a, "CP_NOT_ENOUGH_WARPS", NULL },
-        { 0x0000002b, "CP_BLOCK_SIZE_MISMATCH", NULL },
-        { 0x0000002c, "CP_NOT_ENOUGH_LOCAL_WARPS", NULL },
-        { 0x0000002d, "CP_NOT_ENOUGH_STACK_WARPS", NULL },
-        { 0x0000002e, "CP_NO_BLOCKDIM_LATCH", NULL },
-        { 0x00000031, "ENG2D_FORMAT_MISMATCH", NULL },
-        { 0x0000003f, "PRIMITIVE_ID_NEEDS_GP", NULL },
-        { 0x00000044, "SEMANTIC_VIEWPORT_OVER_LIMIT", NULL },
-        { 0x00000045, "SEMANTIC_COLOR_FRONT_OVER_LIMIT", NULL },
-        { 0x00000046, "LAYER_ID_NEEDS_GP", NULL },
-        { 0x00000047, "SEMANTIC_CLIP_OVER_LIMIT", NULL },
-        { 0x00000048, "SEMANTIC_PTSZ_OVER_LIMIT", NULL },
-        {}
-};
-
-static struct nouveau_bitfield nv50_graph_intr[] = {
-        { 0x00000001, "NOTIFY" },
-        { 0x00000002, "COMPUTE_QUERY" },
-        { 0x00000010, "ILLEGAL_MTHD" },
-        { 0x00000020, "ILLEGAL_CLASS" },
-        { 0x00000040, "DOUBLE_NOTIFY" },
-        { 0x00001000, "CONTEXT_SWITCH" },
-        { 0x00010000, "BUFFER_NOTIFY" },
-        { 0x00100000, "DATA_ERROR" },
-        { 0x00200000, "TRAP" },
-        { 0x01000000, "SINGLE_STEP" },
-        {}
-};
-
-static void
-nv50_pgraph_mp_trap(struct drm_device *dev, int tpid, int display)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        uint32_t units = nv_rd32(dev, 0x1540);
-        uint32_t addr, mp10, status, pc, oplow, ophigh;
-        int i;
-        int mps = 0;
-        for (i = 0; i < 4; i++) {
-                if (!(units & 1 << (i+24)))
-                        continue;
-                if (dev_priv->chipset < 0xa0)
-                        addr = 0x408200 + (tpid << 12) + (i << 7);
-                else
-                        addr = 0x408100 + (tpid << 11) + (i << 7);
-                mp10 = nv_rd32(dev, addr + 0x10);
-                status = nv_rd32(dev, addr + 0x14);
-                if (!status)
-                        continue;
-                if (display) {
-                        nv_rd32(dev, addr + 0x20);
-                        pc = nv_rd32(dev, addr + 0x24);
-                        oplow = nv_rd32(dev, addr + 0x70);
-                        ophigh = nv_rd32(dev, addr + 0x74);
-                        NV_INFO(dev, "PGRAPH_TRAP_MP_EXEC - "
-                                        "TP %d MP %d: ", tpid, i);
-                        nouveau_enum_print(nv50_mp_exec_error_names, status);
-                        printk(" at %06x warp %d, opcode %08x %08x\n",
-                                        pc&0xffffff, pc >> 24,
-                                        oplow, ophigh);
-                }
-                nv_wr32(dev, addr + 0x10, mp10);
-                nv_wr32(dev, addr + 0x14, 0);
-                mps++;
-        }
-        if (!mps && display)
-                NV_INFO(dev, "PGRAPH_TRAP_MP_EXEC - TP %d: "
-                                "No MPs claiming errors?\n", tpid);
-}
-
-static void
-nv50_pgraph_tp_trap(struct drm_device *dev, int type, uint32_t ustatus_old,
-                uint32_t ustatus_new, int display, const char *name)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int tps = 0;
-        uint32_t units = nv_rd32(dev, 0x1540);
-        int i, r;
-        uint32_t ustatus_addr, ustatus;
-        for (i = 0; i < 16; i++) {
-                if (!(units & (1 << i)))
-                        continue;
-                if (dev_priv->chipset < 0xa0)
-                        ustatus_addr = ustatus_old + (i << 12);
-                else
-                        ustatus_addr = ustatus_new + (i << 11);
-                ustatus = nv_rd32(dev, ustatus_addr) & 0x7fffffff;
-                if (!ustatus)
-                        continue;
-                tps++;
-                switch (type) {
-                case 6: /* texture error... unknown for now */
-                        if (display) {
-                                NV_ERROR(dev, "magic set %d:\n", i);
-                                for (r = ustatus_addr + 4; r <= ustatus_addr + 0x10; r += 4)
-                                        NV_ERROR(dev, "\t0x%08x: 0x%08x\n", r,
-                                                nv_rd32(dev, r));
-                        }
-                        break;
-                case 7: /* MP error */
-                        if (ustatus & 0x04030000) {
-                                nv50_pgraph_mp_trap(dev, i, display);
-                                ustatus &= ~0x04030000;
-                        }
-                        break;
-                case 8: /* TPDMA error */
-                        {
-                        uint32_t e0c = nv_rd32(dev, ustatus_addr + 4);
-                        uint32_t e10 = nv_rd32(dev, ustatus_addr + 8);
-                        uint32_t e14 = nv_rd32(dev, ustatus_addr + 0xc);
-                        uint32_t e18 = nv_rd32(dev, ustatus_addr + 0x10);
-                        uint32_t e1c = nv_rd32(dev, ustatus_addr + 0x14);
-                        uint32_t e20 = nv_rd32(dev, ustatus_addr + 0x18);
-                        uint32_t e24 = nv_rd32(dev, ustatus_addr + 0x1c);
-                        /* 2d engine destination */
-                        if (ustatus & 0x00000010) {
-                                if (display) {
-                                        NV_INFO(dev, "PGRAPH_TRAP_TPDMA_2D - TP %d - Unknown fault at address %02x%08x\n",
-                                                        i, e14, e10);
-                                        NV_INFO(dev, "PGRAPH_TRAP_TPDMA_2D - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
-                                                        i, e0c, e18, e1c, e20, e24);
-                                }
-                                ustatus &= ~0x00000010;
-                        }
-                        /* Render target */
-                        if (ustatus & 0x00000040) {
-                                if (display) {
-                                        NV_INFO(dev, "PGRAPH_TRAP_TPDMA_RT - TP %d - Unknown fault at address %02x%08x\n",
-                                                        i, e14, e10);
-                                        NV_INFO(dev, "PGRAPH_TRAP_TPDMA_RT - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
-                                                        i, e0c, e18, e1c, e20, e24);
-                                }
-                                ustatus &= ~0x00000040;
-                        }
-                        /* CUDA memory: l[], g[] or stack. */
-                        if (ustatus & 0x00000080) {
-                                if (display) {
-                                        if (e18 & 0x80000000) {
-                                                /* g[] read fault? */
-                                                NV_INFO(dev, "PGRAPH_TRAP_TPDMA - TP %d - Global read fault at address %02x%08x\n",
-                                                                i, e14, e10 | ((e18 >> 24) & 0x1f));
-                                                e18 &= ~0x1f000000;
-                                        } else if (e18 & 0xc) {
-                                                /* g[] write fault? */
-                                                NV_INFO(dev, "PGRAPH_TRAP_TPDMA - TP %d - Global write fault at address %02x%08x\n",
-                                                                i, e14, e10 | ((e18 >> 7) & 0x1f));
-                                                e18 &= ~0x00000f80;
-                                        } else {
-                                                NV_INFO(dev, "PGRAPH_TRAP_TPDMA - TP %d - Unknown CUDA fault at address %02x%08x\n",
-                                                                i, e14, e10);
-                                        }
-                                        NV_INFO(dev, "PGRAPH_TRAP_TPDMA - TP %d - e0c: %08x, e18: %08x, e1c: %08x, e20: %08x, e24: %08x\n",
-                                                        i, e0c, e18, e1c, e20, e24);
-                                }
-                                ustatus &= ~0x00000080;
-                        }
-                        }
-                        break;
-                }
-                if (ustatus) {
-                        if (display)
-                                NV_INFO(dev, "%s - TP%d: Unhandled ustatus 0x%08x\n", name, i, ustatus);
-                }
-                nv_wr32(dev, ustatus_addr, 0xc0000000);
-        }
-
-        if (!tps && display)
-                NV_INFO(dev, "%s - No TPs claiming errors?\n", name);
-}
-
-static int
-nv50_pgraph_trap_handler(struct drm_device *dev, u32 display, u64 inst, u32 chid)
-{
-        u32 status = nv_rd32(dev, 0x400108);
-        u32 ustatus;
-
-        if (!status && display) {
-                NV_INFO(dev, "PGRAPH - TRAP: no units reporting traps?\n");
-                return 1;
-        }
-
-        /* DISPATCH: Relays commands to other units and handles NOTIFY,
-         * COND, QUERY. If you get a trap from it, the command is still stuck
-         * in DISPATCH and you need to do something about it. */
-        if (status & 0x001) {
-                ustatus = nv_rd32(dev, 0x400804) & 0x7fffffff;
-                if (!ustatus && display) {
-                        NV_INFO(dev, "PGRAPH_TRAP_DISPATCH - no ustatus?\n");
-                }
-
-                nv_wr32(dev, 0x400500, 0x00000000);
-
-                /* Known to be triggered by screwed up NOTIFY and COND... */
-                if (ustatus & 0x00000001) {
-                        u32 addr = nv_rd32(dev, 0x400808);
-                        u32 subc = (addr & 0x00070000) >> 16;
-                        u32 mthd = (addr & 0x00001ffc);
-                        u32 datal = nv_rd32(dev, 0x40080c);
-                        u32 datah = nv_rd32(dev, 0x400810);
-                        u32 class = nv_rd32(dev, 0x400814);
-                        u32 r848 = nv_rd32(dev, 0x400848);
-
-                        NV_INFO(dev, "PGRAPH - TRAP DISPATCH_FAULT\n");
-                        if (display && (addr & 0x80000000)) {
-                                NV_INFO(dev, "PGRAPH - ch %d (0x%010llx) "
-                                             "subc %d class 0x%04x mthd 0x%04x "
-                                             "data 0x%08x%08x "
-                                             "400808 0x%08x 400848 0x%08x\n",
-                                        chid, inst, subc, class, mthd, datah,
-                                        datal, addr, r848);
-                        } else
-                        if (display) {
-                                NV_INFO(dev, "PGRAPH - no stuck command?\n");
-                        }
-
-                        nv_wr32(dev, 0x400808, 0);
-                        nv_wr32(dev, 0x4008e8, nv_rd32(dev, 0x4008e8) & 3);
-                        nv_wr32(dev, 0x400848, 0);
-                        ustatus &= ~0x00000001;
-                }
-
-                if (ustatus & 0x00000002) {
-                        u32 addr = nv_rd32(dev, 0x40084c);
-                        u32 subc = (addr & 0x00070000) >> 16;
-                        u32 mthd = (addr & 0x00001ffc);
-                        u32 data = nv_rd32(dev, 0x40085c);
-                        u32 class = nv_rd32(dev, 0x400814);
-
-                        NV_INFO(dev, "PGRAPH - TRAP DISPATCH_QUERY\n");
-                        if (display && (addr & 0x80000000)) {
-                                NV_INFO(dev, "PGRAPH - ch %d (0x%010llx) "
-                                             "subc %d class 0x%04x mthd 0x%04x "
-                                             "data 0x%08x 40084c 0x%08x\n",
-                                        chid, inst, subc, class, mthd,
-                                        data, addr);
-                        } else
-                        if (display) {
-                                NV_INFO(dev, "PGRAPH - no stuck command?\n");
-                        }
-
-                        nv_wr32(dev, 0x40084c, 0);
-                        ustatus &= ~0x00000002;
-                }
-
-                if (ustatus && display) {
-                        NV_INFO(dev, "PGRAPH - TRAP_DISPATCH (unknown "
-                                      "0x%08x)\n", ustatus);
-                }
-
-                nv_wr32(dev, 0x400804, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x001);
-                status &= ~0x001;
-                if (!status)
-                        return 0;
-        }
-
-        /* M2MF: Memory to memory copy engine. */
-        if (status & 0x002) {
-                u32 ustatus = nv_rd32(dev, 0x406800) & 0x7fffffff;
-                if (display) {
-                        NV_INFO(dev, "PGRAPH - TRAP_M2MF");
-                        nouveau_bitfield_print(nv50_graph_trap_m2mf, ustatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - TRAP_M2MF %08x %08x %08x %08x\n",
-                                nv_rd32(dev, 0x406804), nv_rd32(dev, 0x406808),
-                                nv_rd32(dev, 0x40680c), nv_rd32(dev, 0x406810));
-
-                }
-
-                /* No sane way found yet -- just reset the bugger. */
-                nv_wr32(dev, 0x400040, 2);
-                nv_wr32(dev, 0x400040, 0);
-                nv_wr32(dev, 0x406800, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x002);
-                status &= ~0x002;
-        }
-
-        /* VFETCH: Fetches data from vertex buffers. */
-        if (status & 0x004) {
-                u32 ustatus = nv_rd32(dev, 0x400c04) & 0x7fffffff;
-                if (display) {
-                        NV_INFO(dev, "PGRAPH - TRAP_VFETCH");
-                        nouveau_bitfield_print(nv50_graph_trap_vfetch, ustatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - TRAP_VFETCH %08x %08x %08x %08x\n",
-                                nv_rd32(dev, 0x400c00), nv_rd32(dev, 0x400c08),
-                                nv_rd32(dev, 0x400c0c), nv_rd32(dev, 0x400c10));
-                }
-
-                nv_wr32(dev, 0x400c04, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x004);
-                status &= ~0x004;
-        }
-
-        /* STRMOUT: DirectX streamout / OpenGL transform feedback. */
-        if (status & 0x008) {
-                ustatus = nv_rd32(dev, 0x401800) & 0x7fffffff;
-                if (display) {
-                        NV_INFO(dev, "PGRAPH - TRAP_STRMOUT");
-                        nouveau_bitfield_print(nv50_graph_trap_strmout, ustatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - TRAP_STRMOUT %08x %08x %08x %08x\n",
-                                nv_rd32(dev, 0x401804), nv_rd32(dev, 0x401808),
-                                nv_rd32(dev, 0x40180c), nv_rd32(dev, 0x401810));
-
-                }
-
-                /* No sane way found yet -- just reset the bugger. */
-                nv_wr32(dev, 0x400040, 0x80);
-                nv_wr32(dev, 0x400040, 0);
-                nv_wr32(dev, 0x401800, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x008);
-                status &= ~0x008;
-        }
-
-        /* CCACHE: Handles code and c[] caches and fills them. */
-        if (status & 0x010) {
-                ustatus = nv_rd32(dev, 0x405018) & 0x7fffffff;
-                if (display) {
-                        NV_INFO(dev, "PGRAPH - TRAP_CCACHE");
-                        nouveau_bitfield_print(nv50_graph_trap_ccache, ustatus);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - TRAP_CCACHE %08x %08x %08x %08x"
-                                     " %08x %08x %08x\n",
-                                nv_rd32(dev, 0x405000), nv_rd32(dev, 0x405004),
-                                nv_rd32(dev, 0x405008), nv_rd32(dev, 0x40500c),
-                                nv_rd32(dev, 0x405010), nv_rd32(dev, 0x405014),
-                                nv_rd32(dev, 0x40501c));
-
-                }
-
-                nv_wr32(dev, 0x405018, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x010);
-                status &= ~0x010;
-        }
-
-        /* Unknown, not seen yet... 0x402000 is the only trap status reg
-         * remaining, so try to handle it anyway. Perhaps related to that
-         * unknown DMA slot on tesla? */
-        if (status & 0x20) {
-                ustatus = nv_rd32(dev, 0x402000) & 0x7fffffff;
-                if (display)
-                        NV_INFO(dev, "PGRAPH - TRAP_UNKC04 0x%08x\n", ustatus);
-                nv_wr32(dev, 0x402000, 0xc0000000);
-                /* no status modifiction on purpose */
-        }
-
-        /* TEXTURE: CUDA texturing units */
-        if (status & 0x040) {
-                nv50_pgraph_tp_trap(dev, 6, 0x408900, 0x408600, display,
-                                    "PGRAPH - TRAP_TEXTURE");
-                nv_wr32(dev, 0x400108, 0x040);
-                status &= ~0x040;
-        }
-
-        /* MP: CUDA execution engines. */
-        if (status & 0x080) {
-                nv50_pgraph_tp_trap(dev, 7, 0x408314, 0x40831c, display,
-                                    "PGRAPH - TRAP_MP");
-                nv_wr32(dev, 0x400108, 0x080);
-                status &= ~0x080;
-        }
-
-        /* TPDMA:  Handles TP-initiated uncached memory accesses:
-         * l[], g[], stack, 2d surfaces, render targets. */
-        if (status & 0x100) {
-                nv50_pgraph_tp_trap(dev, 8, 0x408e08, 0x408708, display,
-                                    "PGRAPH - TRAP_TPDMA");
-                nv_wr32(dev, 0x400108, 0x100);
-                status &= ~0x100;
-        }
-
-        if (status) {
-                if (display)
-                        NV_INFO(dev, "PGRAPH - TRAP: unknown 0x%08x\n", status);
-                nv_wr32(dev, 0x400108, status);
-        }
-
-        return 1;
-}
-
-int
-nv50_graph_isr_chid(struct drm_device *dev, u64 inst)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan;
-        unsigned long flags;
-        int i;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (i = 0; i < pfifo->channels; i++) {
-                chan = dev_priv->channels.ptr[i];
-                if (!chan || !chan->ramin)
-                        continue;
-
-                if (inst == chan->ramin->vinst)
-                        break;
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return i;
-}
-
-static void
-nv50_graph_isr(struct drm_device *dev)
-{
-        u32 stat;
-
-        while ((stat = nv_rd32(dev, 0x400100))) {
-                u64 inst = (u64)(nv_rd32(dev, 0x40032c) & 0x0fffffff) << 12;
-                u32 chid = nv50_graph_isr_chid(dev, inst);
-                u32 addr = nv_rd32(dev, NV04_PGRAPH_TRAPPED_ADDR);
-                u32 subc = (addr & 0x00070000) >> 16;
-                u32 mthd = (addr & 0x00001ffc);
-                u32 data = nv_rd32(dev, NV04_PGRAPH_TRAPPED_DATA);
-                u32 class = nv_rd32(dev, 0x400814);
-                u32 show = stat;
-
-                if (stat & 0x00000010) {
-                        if (!nouveau_gpuobj_mthd_call2(dev, chid, class,
-                                                       mthd, data))
-                                show &= ~0x00000010;
-                }
-
-                show = (show && nouveau_ratelimit()) ? show : 0;
-
-                if (show & 0x00100000) {
-                        u32 ecode = nv_rd32(dev, 0x400110);
-                        NV_INFO(dev, "PGRAPH - DATA_ERROR ");
-                        nouveau_enum_print(nv50_data_error_names, ecode);
-                        printk("\n");
-                }
-
-                if (stat & 0x00200000) {
-                        if (!nv50_pgraph_trap_handler(dev, show, inst, chid))
-                                show &= ~0x00200000;
-                }
-
-                nv_wr32(dev, 0x400100, stat);
-                nv_wr32(dev, 0x400500, 0x00010001);
-
-                if (show) {
-                        NV_INFO(dev, "PGRAPH -");
-                        nouveau_bitfield_print(nv50_graph_intr, show);
-                        printk("\n");
-                        NV_INFO(dev, "PGRAPH - ch %d (0x%010llx) subc %d "
-                                     "class 0x%04x mthd 0x%04x data 0x%08x\n",
-                                chid, inst, subc, class, mthd, data);
-                        nv50_fb_vm_trap(dev, 1);
-                }
-        }
-
-        if (nv_rd32(dev, 0x400824) & (1 << 31))
-                nv_wr32(dev, 0x400824, nv_rd32(dev, 0x400824) & ~(1 << 31));
-}
-
-static void
-nv50_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nv50_graph_engine *pgraph = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, GR);
-
-        nouveau_irq_unregister(dev, 12);
-        kfree(pgraph);
-}
-
-int
-nv50_graph_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_graph_engine *pgraph;
-        int ret;
-
-        pgraph = kzalloc(sizeof(*pgraph),GFP_KERNEL);
-        if (!pgraph)
-                return -ENOMEM;
-
-        ret = nv50_grctx_init(dev, pgraph->ctxprog, ARRAY_SIZE(pgraph->ctxprog),
-                                  &pgraph->ctxprog_size,
-                                  &pgraph->grctx_size);
-        if (ret) {
-                NV_ERROR(dev, "PGRAPH: ctxprog build failed\n");
-                kfree(pgraph);
-                return 0;
-        }
-
-        pgraph->base.destroy = nv50_graph_destroy;
-        pgraph->base.init = nv50_graph_init;
-        pgraph->base.fini = nv50_graph_fini;
-        pgraph->base.context_new = nv50_graph_context_new;
-        pgraph->base.context_del = nv50_graph_context_del;
-        pgraph->base.object_new = nv50_graph_object_new;
-        if (dev_priv->chipset == 0x50 || dev_priv->chipset == 0xac)
-                pgraph->base.tlb_flush = nv50_graph_tlb_flush;
-        else
-                pgraph->base.tlb_flush = nv84_graph_tlb_flush;
-
-        nouveau_irq_register(dev, 12, nv50_graph_isr);
-
-        NVOBJ_ENGINE_ADD(dev, GR, &pgraph->base);
-        NVOBJ_CLASS(dev, 0x0030, GR); /* null */
-        NVOBJ_CLASS(dev, 0x5039, GR); /* m2mf */
-        NVOBJ_CLASS(dev, 0x502d, GR); /* 2d */
-
-        /* tesla */
-        if (dev_priv->chipset == 0x50)
-                NVOBJ_CLASS(dev, 0x5097, GR); /* tesla (nv50) */
-        else
-        if (dev_priv->chipset < 0xa0)
-                NVOBJ_CLASS(dev, 0x8297, GR); /* tesla (nv8x/nv9x) */
-        else {
-                switch (dev_priv->chipset) {
-                case 0xa0:
-                case 0xaa:
-                case 0xac:
-                        NVOBJ_CLASS(dev, 0x8397, GR);
-                        break;
-                case 0xa3:
-                case 0xa5:
-                case 0xa8:
-                        NVOBJ_CLASS(dev, 0x8597, GR);
-                        break;
-                case 0xaf:
-                        NVOBJ_CLASS(dev, 0x8697, GR);
-                        break;
-                }
-        }
-
-        /* compute */
-        NVOBJ_CLASS(dev, 0x50c0, GR);
-        if (dev_priv->chipset  > 0xa0 &&
-            dev_priv->chipset != 0xaa &&
-            dev_priv->chipset != 0xac)
-                NVOBJ_CLASS(dev, 0x85c0, GR);
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_instmem.c b/drivers/gpu/drm/nouveau/nv50_instmem.c
deleted file mode 100644
index 0bba54f11800..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_instmem.c
+++ /dev/null
@@ -1,428 +0,0 @@
-/*
- * Copyright (C) 2007 Ben Skeggs.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_vm.h"
-
-#define BAR1_VM_BASE 0x0020000000ULL
-#define BAR1_VM_SIZE pci_resource_len(dev->pdev, 1)
-#define BAR3_VM_BASE 0x0000000000ULL
-#define BAR3_VM_SIZE pci_resource_len(dev->pdev, 3)
-
-struct nv50_instmem_priv {
-        uint32_t save1700[5]; /* 0x1700->0x1710 */
-
-        struct nouveau_gpuobj *bar1_dmaobj;
-        struct nouveau_gpuobj *bar3_dmaobj;
-};
-
-static void
-nv50_channel_del(struct nouveau_channel **pchan)
-{
-        struct nouveau_channel *chan;
-
-        chan = *pchan;
-        *pchan = NULL;
-        if (!chan)
-                return;
-
-        nouveau_gpuobj_ref(NULL, &chan->ramfc);
-        nouveau_vm_ref(NULL, &chan->vm, chan->vm_pd);
-        nouveau_gpuobj_ref(NULL, &chan->vm_pd);
-        if (drm_mm_initialized(&chan->ramin_heap))
-                drm_mm_takedown(&chan->ramin_heap);
-        nouveau_gpuobj_ref(NULL, &chan->ramin);
-        kfree(chan);
-}
-
-static int
-nv50_channel_new(struct drm_device *dev, u32 size, struct nouveau_vm *vm,
-                 struct nouveau_channel **pchan)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 pgd = (dev_priv->chipset == 0x50) ? 0x1400 : 0x0200;
-        u32  fc = (dev_priv->chipset == 0x50) ? 0x0000 : 0x4200;
-        struct nouveau_channel *chan;
-        int ret, i;
-
-        chan = kzalloc(sizeof(*chan), GFP_KERNEL);
-        if (!chan)
-                return -ENOMEM;
-        chan->dev = dev;
-
-        ret = nouveau_gpuobj_new(dev, NULL, size, 0x1000, 0, &chan->ramin);
-        if (ret) {
-                nv50_channel_del(&chan);
-                return ret;
-        }
-
-        ret = drm_mm_init(&chan->ramin_heap, 0x6000, chan->ramin->size - 0x6000);
-        if (ret) {
-                nv50_channel_del(&chan);
-                return ret;
-        }
-
-        ret = nouveau_gpuobj_new_fake(dev, chan->ramin->pinst == ~0 ? ~0 :
-                                      chan->ramin->pinst + pgd,
-                                      chan->ramin->vinst + pgd,
-                                      0x4000, NVOBJ_FLAG_ZERO_ALLOC,
-                                      &chan->vm_pd);
-        if (ret) {
-                nv50_channel_del(&chan);
-                return ret;
-        }
-
-        for (i = 0; i < 0x4000; i += 8) {
-                nv_wo32(chan->vm_pd, i + 0, 0x00000000);
-                nv_wo32(chan->vm_pd, i + 4, 0xdeadcafe);
-        }
-
-        ret = nouveau_vm_ref(vm, &chan->vm, chan->vm_pd);
-        if (ret) {
-                nv50_channel_del(&chan);
-                return ret;
-        }
-
-        ret = nouveau_gpuobj_new_fake(dev, chan->ramin->pinst == ~0 ? ~0 :
-                                      chan->ramin->pinst + fc,
-                                      chan->ramin->vinst + fc, 0x100,
-                                      NVOBJ_FLAG_ZERO_ALLOC, &chan->ramfc);
-        if (ret) {
-                nv50_channel_del(&chan);
-                return ret;
-        }
-
-        *pchan = chan;
-        return 0;
-}
-
-int
-nv50_instmem_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_instmem_priv *priv;
-        struct nouveau_channel *chan;
-        struct nouveau_vm *vm;
-        int ret, i;
-        u32 tmp;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-        dev_priv->engine.instmem.priv = priv;
-
-        /* Save state, will restore at takedown. */
-        for (i = 0x1700; i <= 0x1710; i += 4)
-                priv->save1700[(i-0x1700)/4] = nv_rd32(dev, i);
-
-        /* Global PRAMIN heap */
-        ret = drm_mm_init(&dev_priv->ramin_heap, 0, dev_priv->ramin_size);
-        if (ret) {
-                NV_ERROR(dev, "Failed to init RAMIN heap\n");
-                goto error;
-        }
-
-        /* BAR3 */
-        ret = nouveau_vm_new(dev, BAR3_VM_BASE, BAR3_VM_SIZE, BAR3_VM_BASE,
-                             &dev_priv->bar3_vm);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, (BAR3_VM_SIZE >> 12) * 8,
-                                 0x1000, NVOBJ_FLAG_DONT_MAP |
-                                 NVOBJ_FLAG_ZERO_ALLOC,
-                                 &dev_priv->bar3_vm->pgt[0].obj[0]);
-        if (ret)
-                goto error;
-        dev_priv->bar3_vm->pgt[0].refcount[0] = 1;
-
-        nv50_instmem_map(dev_priv->bar3_vm->pgt[0].obj[0]);
-
-        ret = nv50_channel_new(dev, 128 * 1024, dev_priv->bar3_vm, &chan);
-        if (ret)
-                goto error;
-        dev_priv->channels.ptr[0] = dev_priv->channels.ptr[127] = chan;
-
-        ret = nv50_gpuobj_dma_new(chan, 0x0000, BAR3_VM_BASE, BAR3_VM_SIZE,
-                                  NV_MEM_TARGET_VM, NV_MEM_ACCESS_VM,
-                                  NV_MEM_TYPE_VM, NV_MEM_COMP_VM,
-                                  &priv->bar3_dmaobj);
-        if (ret)
-                goto error;
-
-        nv_wr32(dev, 0x001704, 0x00000000 | (chan->ramin->vinst >> 12));
-        nv_wr32(dev, 0x001704, 0x40000000 | (chan->ramin->vinst >> 12));
-        nv_wr32(dev, 0x00170c, 0x80000000 | (priv->bar3_dmaobj->cinst >> 4));
-
-        dev_priv->engine.instmem.flush(dev);
-        dev_priv->ramin_available = true;
-
-        tmp = nv_ro32(chan->ramin, 0);
-        nv_wo32(chan->ramin, 0, ~tmp);
-        if (nv_ro32(chan->ramin, 0) != ~tmp) {
-                NV_ERROR(dev, "PRAMIN readback failed\n");
-                ret = -EIO;
-                goto error;
-        }
-        nv_wo32(chan->ramin, 0, tmp);
-
-        /* BAR1 */
-        ret = nouveau_vm_new(dev, BAR1_VM_BASE, BAR1_VM_SIZE, BAR1_VM_BASE, &vm);
-        if (ret)
-                goto error;
-
-        ret = nouveau_vm_ref(vm, &dev_priv->bar1_vm, chan->vm_pd);
-        if (ret)
-                goto error;
-        nouveau_vm_ref(NULL, &vm, NULL);
-
-        ret = nv50_gpuobj_dma_new(chan, 0x0000, BAR1_VM_BASE, BAR1_VM_SIZE,
-                                  NV_MEM_TARGET_VM, NV_MEM_ACCESS_VM,
-                                  NV_MEM_TYPE_VM, NV_MEM_COMP_VM,
-                                  &priv->bar1_dmaobj);
-        if (ret)
-                goto error;
-
-        nv_wr32(dev, 0x001708, 0x80000000 | (priv->bar1_dmaobj->cinst >> 4));
-        for (i = 0; i < 8; i++)
-                nv_wr32(dev, 0x1900 + (i*4), 0);
-
-        /* Create shared channel VM, space is reserved at the beginning
-         * to catch "NULL pointer" references
-         */
-        ret = nouveau_vm_new(dev, 0, (1ULL << 40), 0x0020000000ULL,
-                             &dev_priv->chan_vm);
-        if (ret)
-                return ret;
-
-        return 0;
-
-error:
-        nv50_instmem_takedown(dev);
-        return ret;
-}
-
-void
-nv50_instmem_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_instmem_priv *priv = dev_priv->engine.instmem.priv;
-        struct nouveau_channel *chan = dev_priv->channels.ptr[0];
-        int i;
-
-        NV_DEBUG(dev, "\n");
-
-        if (!priv)
-                return;
-
-        dev_priv->ramin_available = false;
-
-        nouveau_vm_ref(NULL, &dev_priv->chan_vm, NULL);
-
-        for (i = 0x1700; i <= 0x1710; i += 4)
-                nv_wr32(dev, i, priv->save1700[(i - 0x1700) / 4]);
-
-        nouveau_gpuobj_ref(NULL, &priv->bar3_dmaobj);
-        nouveau_gpuobj_ref(NULL, &priv->bar1_dmaobj);
-
-        nouveau_vm_ref(NULL, &dev_priv->bar1_vm, chan->vm_pd);
-        dev_priv->channels.ptr[127] = 0;
-        nv50_channel_del(&dev_priv->channels.ptr[0]);
-
-        nouveau_gpuobj_ref(NULL, &dev_priv->bar3_vm->pgt[0].obj[0]);
-        nouveau_vm_ref(NULL, &dev_priv->bar3_vm, NULL);
-
-        if (drm_mm_initialized(&dev_priv->ramin_heap))
-                drm_mm_takedown(&dev_priv->ramin_heap);
-
-        dev_priv->engine.instmem.priv = NULL;
-        kfree(priv);
-}
-
-int
-nv50_instmem_suspend(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        dev_priv->ramin_available = false;
-        return 0;
-}
-
-void
-nv50_instmem_resume(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_instmem_priv *priv = dev_priv->engine.instmem.priv;
-        struct nouveau_channel *chan = dev_priv->channels.ptr[0];
-        int i;
-
-        /* Poke the relevant regs, and pray it works :) */
-        nv_wr32(dev, NV50_PUNK_BAR_CFG_BASE, (chan->ramin->vinst >> 12));
-        nv_wr32(dev, NV50_PUNK_UNK1710, 0);
-        nv_wr32(dev, NV50_PUNK_BAR_CFG_BASE, (chan->ramin->vinst >> 12) |
-                                         NV50_PUNK_BAR_CFG_BASE_VALID);
-        nv_wr32(dev, NV50_PUNK_BAR1_CTXDMA, (priv->bar1_dmaobj->cinst >> 4) |
-                                        NV50_PUNK_BAR1_CTXDMA_VALID);
-        nv_wr32(dev, NV50_PUNK_BAR3_CTXDMA, (priv->bar3_dmaobj->cinst >> 4) |
-                                        NV50_PUNK_BAR3_CTXDMA_VALID);
-
-        for (i = 0; i < 8; i++)
-                nv_wr32(dev, 0x1900 + (i*4), 0);
-
-        dev_priv->ramin_available = true;
-}
-
-struct nv50_gpuobj_node {
-        struct nouveau_mem *vram;
-        struct nouveau_vma chan_vma;
-        u32 align;
-};
-
-int
-nv50_instmem_get(struct nouveau_gpuobj *gpuobj, struct nouveau_channel *chan,
-                 u32 size, u32 align)
-{
-        struct drm_device *dev = gpuobj->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-        struct nv50_gpuobj_node *node = NULL;
-        int ret;
-
-        node = kzalloc(sizeof(*node), GFP_KERNEL);
-        if (!node)
-                return -ENOMEM;
-        node->align = align;
-
-        size  = (size + 4095) & ~4095;
-        align = max(align, (u32)4096);
-
-        ret = vram->get(dev, size, align, 0, 0, &node->vram);
-        if (ret) {
-                kfree(node);
-                return ret;
-        }
-
-        gpuobj->vinst = node->vram->offset;
-
-        if (gpuobj->flags & NVOBJ_FLAG_VM) {
-                u32 flags = NV_MEM_ACCESS_RW;
-                if (!(gpuobj->flags & NVOBJ_FLAG_VM_USER))
-                        flags |= NV_MEM_ACCESS_SYS;
-
-                ret = nouveau_vm_get(chan->vm, size, 12, flags,
-                                     &node->chan_vma);
-                if (ret) {
-                        vram->put(dev, &node->vram);
-                        kfree(node);
-                        return ret;
-                }
-
-                nouveau_vm_map(&node->chan_vma, node->vram);
-                gpuobj->linst = node->chan_vma.offset;
-        }
-
-        gpuobj->size = size;
-        gpuobj->node = node;
-        return 0;
-}
-
-void
-nv50_instmem_put(struct nouveau_gpuobj *gpuobj)
-{
-        struct drm_device *dev = gpuobj->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-        struct nv50_gpuobj_node *node;
-
-        node = gpuobj->node;
-        gpuobj->node = NULL;
-
-        if (node->chan_vma.node) {
-                nouveau_vm_unmap(&node->chan_vma);
-                nouveau_vm_put(&node->chan_vma);
-        }
-        vram->put(dev, &node->vram);
-        kfree(node);
-}
-
-int
-nv50_instmem_map(struct nouveau_gpuobj *gpuobj)
-{
-        struct drm_nouveau_private *dev_priv = gpuobj->dev->dev_private;
-        struct nv50_gpuobj_node *node = gpuobj->node;
-        int ret;
-
-        ret = nouveau_vm_get(dev_priv->bar3_vm, gpuobj->size, 12,
-                             NV_MEM_ACCESS_RW, &node->vram->bar_vma);
-        if (ret)
-                return ret;
-
-        nouveau_vm_map(&node->vram->bar_vma, node->vram);
-        gpuobj->pinst = node->vram->bar_vma.offset;
-        return 0;
-}
-
-void
-nv50_instmem_unmap(struct nouveau_gpuobj *gpuobj)
-{
-        struct nv50_gpuobj_node *node = gpuobj->node;
-
-        if (node->vram->bar_vma.node) {
-                nouveau_vm_unmap(&node->vram->bar_vma);
-                nouveau_vm_put(&node->vram->bar_vma);
-        }
-}
-
-void
-nv50_instmem_flush(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->vm_lock, flags);
-        nv_wr32(dev, 0x00330c, 0x00000001);
-        if (!nv_wait(dev, 0x00330c, 0x00000002, 0x00000000))
-                NV_ERROR(dev, "PRAMIN flush timeout\n");
-        spin_unlock_irqrestore(&dev_priv->vm_lock, flags);
-}
-
-void
-nv84_instmem_flush(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dev_priv->vm_lock, flags);
-        nv_wr32(dev, 0x070000, 0x00000001);
-        if (!nv_wait(dev, 0x070000, 0x00000002, 0x00000000))
-                NV_ERROR(dev, "PRAMIN flush timeout\n");
-        spin_unlock_irqrestore(&dev_priv->vm_lock, flags);
-}
-
diff --git a/drivers/gpu/drm/nouveau/nv50_mc.c b/drivers/gpu/drm/nouveau/nv50_mc.c
deleted file mode 100644
index e0a9c3faa202..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_mc.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2007 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-
-int
-nv50_mc_init(struct drm_device *dev)
-{
-        nv_wr32(dev, NV03_PMC_ENABLE, 0xFFFFFFFF);
-        return 0;
-}
-
-void nv50_mc_takedown(struct drm_device *dev)
-{
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_mpeg.c b/drivers/gpu/drm/nouveau/nv50_mpeg.c
deleted file mode 100644
index 90e8ed22cfcb..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_mpeg.c
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * Copyright 2011 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"
-#include "nouveau_ramht.h"
-
-struct nv50_mpeg_engine {
-        struct nouveau_exec_engine base;
-};
-
-static inline u32
-CTX_PTR(struct drm_device *dev, u32 offset)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (dev_priv->chipset == 0x50)
-                offset += 0x0260;
-        else
-                offset += 0x0060;
-
-        return offset;
-}
-
-static int
-nv50_mpeg_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ramin = chan->ramin;
-        struct nouveau_gpuobj *ctx = NULL;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d\n", chan->id);
-
-        ret = nouveau_gpuobj_new(dev, chan, 128 * 4, 0, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &ctx);
-        if (ret)
-                return ret;
-
-        nv_wo32(ramin, CTX_PTR(dev, 0x00), 0x80190002);
-        nv_wo32(ramin, CTX_PTR(dev, 0x04), ctx->vinst + ctx->size - 1);
-        nv_wo32(ramin, CTX_PTR(dev, 0x08), ctx->vinst);
-        nv_wo32(ramin, CTX_PTR(dev, 0x0c), 0);
-        nv_wo32(ramin, CTX_PTR(dev, 0x10), 0);
-        nv_wo32(ramin, CTX_PTR(dev, 0x14), 0x00010000);
-
-        nv_wo32(ctx, 0x70, 0x00801ec1);
-        nv_wo32(ctx, 0x7c, 0x0000037c);
-        dev_priv->engine.instmem.flush(dev);
-
-        chan->engctx[engine] = ctx;
-        return 0;
-}
-
-static void
-nv50_mpeg_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nouveau_gpuobj *ctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        int i;
-
-        for (i = 0x00; i <= 0x14; i += 4)
-                nv_wo32(chan->ramin, CTX_PTR(dev, i), 0x00000000);
-
-        nouveau_gpuobj_ref(NULL, &ctx);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nv50_mpeg_object_new(struct nouveau_channel *chan, int engine,
-                     u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 2;
-        obj->class  = class;
-
-        nv_wo32(obj, 0x00, class);
-        nv_wo32(obj, 0x04, 0x00000000);
-        nv_wo32(obj, 0x08, 0x00000000);
-        nv_wo32(obj, 0x0c, 0x00000000);
-        dev_priv->engine.instmem.flush(dev);
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static void
-nv50_mpeg_tlb_flush(struct drm_device *dev, int engine)
-{
-        nv50_vm_flush_engine(dev, 0x08);
-}
-
-static int
-nv50_mpeg_init(struct drm_device *dev, int engine)
-{
-        nv_wr32(dev, 0x00b32c, 0x00000000);
-        nv_wr32(dev, 0x00b314, 0x00000100);
-        nv_wr32(dev, 0x00b0e0, 0x0000001a);
-
-        nv_wr32(dev, 0x00b220, 0x00000044);
-        nv_wr32(dev, 0x00b300, 0x00801ec1);
-        nv_wr32(dev, 0x00b390, 0x00000000);
-        nv_wr32(dev, 0x00b394, 0x00000000);
-        nv_wr32(dev, 0x00b398, 0x00000000);
-        nv_mask(dev, 0x00b32c, 0x00000001, 0x00000001);
-
-        nv_wr32(dev, 0x00b100, 0xffffffff);
-        nv_wr32(dev, 0x00b140, 0xffffffff);
-
-        if (!nv_wait(dev, 0x00b200, 0x00000001, 0x00000000)) {
-                NV_ERROR(dev, "PMPEG init: 0x%08x\n", nv_rd32(dev, 0x00b200));
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static int
-nv50_mpeg_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_mask(dev, 0x00b32c, 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x00b140, 0x00000000);
-        return 0;
-}
-
-static void
-nv50_mpeg_isr(struct drm_device *dev)
-{
-        u32 stat = nv_rd32(dev, 0x00b100);
-        u32 type = nv_rd32(dev, 0x00b230);
-        u32 mthd = nv_rd32(dev, 0x00b234);
-        u32 data = nv_rd32(dev, 0x00b238);
-        u32 show = stat;
-
-        if (stat & 0x01000000) {
-                /* happens on initial binding of the object */
-                if (type == 0x00000020 && mthd == 0x0000) {
-                        nv_wr32(dev, 0x00b308, 0x00000100);
-                        show &= ~0x01000000;
-                }
-        }
-
-        if (show && nouveau_ratelimit()) {
-                NV_INFO(dev, "PMPEG - 0x%08x 0x%08x 0x%08x 0x%08x\n",
-                        stat, type, mthd, data);
-        }
-
-        nv_wr32(dev, 0x00b100, stat);
-        nv_wr32(dev, 0x00b230, 0x00000001);
-        nv50_fb_vm_trap(dev, 1);
-}
-
-static void
-nv50_vpe_isr(struct drm_device *dev)
-{
-        if (nv_rd32(dev, 0x00b100))
-                nv50_mpeg_isr(dev);
-
-        if (nv_rd32(dev, 0x00b800)) {
-                u32 stat = nv_rd32(dev, 0x00b800);
-                NV_INFO(dev, "PMSRCH: 0x%08x\n", stat);
-                nv_wr32(dev, 0xb800, stat);
-        }
-}
-
-static void
-nv50_mpeg_destroy(struct drm_device *dev, int engine)
-{
-        struct nv50_mpeg_engine *pmpeg = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 0);
-
-        NVOBJ_ENGINE_DEL(dev, MPEG);
-        kfree(pmpeg);
-}
-
-int
-nv50_mpeg_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv50_mpeg_engine *pmpeg;
-
-        pmpeg = kzalloc(sizeof(*pmpeg), GFP_KERNEL);
-        if (!pmpeg)
-                return -ENOMEM;
-
-        pmpeg->base.destroy = nv50_mpeg_destroy;
-        pmpeg->base.init = nv50_mpeg_init;
-        pmpeg->base.fini = nv50_mpeg_fini;
-        pmpeg->base.context_new = nv50_mpeg_context_new;
-        pmpeg->base.context_del = nv50_mpeg_context_del;
-        pmpeg->base.object_new = nv50_mpeg_object_new;
-        pmpeg->base.tlb_flush = nv50_mpeg_tlb_flush;
-
-        if (dev_priv->chipset == 0x50) {
-                nouveau_irq_register(dev, 0, nv50_vpe_isr);
-                NVOBJ_ENGINE_ADD(dev, MPEG, &pmpeg->base);
-                NVOBJ_CLASS(dev, 0x3174, MPEG);
-#if 0
-                NVOBJ_ENGINE_ADD(dev, ME, &pme->base);
-                NVOBJ_CLASS(dev, 0x4075, ME);
-#endif
-        } else {
-                nouveau_irq_register(dev, 0, nv50_mpeg_isr);
-                NVOBJ_ENGINE_ADD(dev, MPEG, &pmpeg->base);
-                NVOBJ_CLASS(dev, 0x8274, MPEG);
-        }
-
-        return 0;
-
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_pm.c b/drivers/gpu/drm/nouveau/nv50_pm.c
index d020ed4979b4..7724eae5db98 100644
--- a/drivers/gpu/drm/nouveau/nv50_pm.c
+++ b/drivers/gpu/drm/nouveau/nv50_pm.c
@@ -23,13 +23,19 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_bios.h"
 #include "nouveau_hw.h"
 #include "nouveau_pm.h"
 #include "nouveau_hwsq.h"
+
 #include "nv50_display.h"
 
+#include <subdev/bios/pll.h>
+#include <subdev/clock.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
 enum clk_src {
         clk_src_crystal,
         clk_src_href,
@@ -49,19 +55,20 @@ static u32 read_clk(struct drm_device *, enum clk_src);
 static u32
 read_div(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
 
-        switch (dev_priv->chipset) {
+        switch (nv_device(drm->device)->chipset) {
         case 0x50: /* it exists, but only has bit 31, not the dividers.. */
         case 0x84:
         case 0x86:
         case 0x98:
         case 0xa0:
-                return nv_rd32(dev, 0x004700);
+                return nv_rd32(device, 0x004700);
         case 0x92:
         case 0x94:
         case 0x96:
-                return nv_rd32(dev, 0x004800);
+                return nv_rd32(device, 0x004800);
         default:
                 return 0x00000000;
         }
@@ -70,12 +77,13 @@ read_div(struct drm_device *dev)
 static u32
 read_pll_src(struct drm_device *dev, u32 base)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u32 coef, ref = read_clk(dev, clk_src_crystal);
-        u32 rsel = nv_rd32(dev, 0x00e18c);
+        u32 rsel = nv_rd32(device, 0x00e18c);
         int P, N, M, id;
 
-        switch (dev_priv->chipset) {
+        switch (nv_device(drm->device)->chipset) {
         case 0x50:
         case 0xa0:
                 switch (base) {
@@ -84,11 +92,11 @@ read_pll_src(struct drm_device *dev, u32 base)
                 case 0x4008: id = !!(rsel & 0x00000008); break;
                 case 0x4030: id = 0; break;
                 default:
-                        NV_ERROR(dev, "ref: bad pll 0x%06x\n", base);
+                        NV_ERROR(drm, "ref: bad pll 0x%06x\n", base);
                         return 0;
                 }
 
-                coef = nv_rd32(dev, 0x00e81c + (id * 0x0c));
+                coef = nv_rd32(device, 0x00e81c + (id * 0x0c));
                 ref *=  (coef & 0x01000000) ? 2 : 4;
                 P    =  (coef & 0x00070000) >> 16;
                 N    = ((coef & 0x0000ff00) >> 8) + 1;
@@ -97,7 +105,7 @@ read_pll_src(struct drm_device *dev, u32 base)
         case 0x84:
         case 0x86:
         case 0x92:
-                coef = nv_rd32(dev, 0x00e81c);
+                coef = nv_rd32(device, 0x00e81c);
                 P    = (coef & 0x00070000) >> 16;
                 N    = (coef & 0x0000ff00) >> 8;
                 M    = (coef & 0x000000ff) >> 0;
@@ -105,14 +113,14 @@ read_pll_src(struct drm_device *dev, u32 base)
         case 0x94:
         case 0x96:
         case 0x98:
-                rsel = nv_rd32(dev, 0x00c050);
+                rsel = nv_rd32(device, 0x00c050);
                 switch (base) {
                 case 0x4020: rsel = (rsel & 0x00000003) >> 0; break;
                 case 0x4008: rsel = (rsel & 0x0000000c) >> 2; break;
                 case 0x4028: rsel = (rsel & 0x00001800) >> 11; break;
                 case 0x4030: rsel = 3; break;
                 default:
-                        NV_ERROR(dev, "ref: bad pll 0x%06x\n", base);
+                        NV_ERROR(drm, "ref: bad pll 0x%06x\n", base);
                         return 0;
                 }
 
@@ -123,8 +131,8 @@ read_pll_src(struct drm_device *dev, u32 base)
                 case 3: id = 0; break;
                 }
 
-                coef =  nv_rd32(dev, 0x00e81c + (id * 0x28));
-                P    = (nv_rd32(dev, 0x00e824 + (id * 0x28)) >> 16) & 7;
+                coef =  nv_rd32(device, 0x00e81c + (id * 0x28));
+                P    = (nv_rd32(device, 0x00e824 + (id * 0x28)) >> 16) & 7;
                 P   += (coef & 0x00070000) >> 16;
                 N    = (coef & 0x0000ff00) >> 8;
                 M    = (coef & 0x000000ff) >> 0;
@@ -141,7 +149,9 @@ read_pll_src(struct drm_device *dev, u32 base)
 static u32
 read_pll_ref(struct drm_device *dev, u32 base)
 {
-        u32 src, mast = nv_rd32(dev, 0x00c040);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        u32 src, mast = nv_rd32(device, 0x00c040);
 
         switch (base) {
         case 0x004028:
@@ -159,7 +169,7 @@ read_pll_ref(struct drm_device *dev, u32 base)
         case 0x00e810:
                 return read_clk(dev, clk_src_crystal);
         default:
-                NV_ERROR(dev, "bad pll 0x%06x\n", base);
+                NV_ERROR(drm, "bad pll 0x%06x\n", base);
                 return 0;
         }
 
@@ -171,17 +181,18 @@ read_pll_ref(struct drm_device *dev, u32 base)
 static u32
 read_pll(struct drm_device *dev, u32 base)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 mast = nv_rd32(dev, 0x00c040);
-        u32 ctrl = nv_rd32(dev, base + 0);
-        u32 coef = nv_rd32(dev, base + 4);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        u32 mast = nv_rd32(device, 0x00c040);
+        u32 ctrl = nv_rd32(device, base + 0);
+        u32 coef = nv_rd32(device, base + 4);
         u32 ref = read_pll_ref(dev, base);
         u32 clk = 0;
         int N1, N2, M1, M2;
 
         if (base == 0x004028 && (mast & 0x00100000)) {
                 /* wtf, appears to only disable post-divider on nva0 */
-                if (dev_priv->chipset != 0xa0)
+                if (nv_device(drm->device)->chipset != 0xa0)
                         return read_clk(dev, clk_src_dom6);
         }
 
@@ -205,13 +216,14 @@ read_pll(struct drm_device *dev, u32 base)
 static u32
 read_clk(struct drm_device *dev, enum clk_src src)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u32 mast = nv_rd32(dev, 0x00c040);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        u32 mast = nv_rd32(device, 0x00c040);
         u32 P = 0;
 
         switch (src) {
         case clk_src_crystal:
-                return dev_priv->crystal;
+                return device->crystal;
         case clk_src_href:
                 return 100000; /* PCIE reference clock */
         case clk_src_hclk:
@@ -230,7 +242,7 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 break;
         case clk_src_nvclk:
                 if (!(mast & 0x00100000))
-                        P = (nv_rd32(dev, 0x004028) & 0x00070000) >> 16;
+                        P = (nv_rd32(device, 0x004028) & 0x00070000) >> 16;
                 switch (mast & 0x00000003) {
                 case 0x00000000: return read_clk(dev, clk_src_crystal) >> P;
                 case 0x00000001: return read_clk(dev, clk_src_dom6);
@@ -239,7 +251,7 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 }
                 break;
         case clk_src_sclk:
-                P = (nv_rd32(dev, 0x004020) & 0x00070000) >> 16;
+                P = (nv_rd32(device, 0x004020) & 0x00070000) >> 16;
                 switch (mast & 0x00000030) {
                 case 0x00000000:
                         if (mast & 0x00000080)
@@ -251,8 +263,8 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 }
                 break;
         case clk_src_mclk:
-                P = (nv_rd32(dev, 0x004008) & 0x00070000) >> 16;
-                if (nv_rd32(dev, 0x004008) & 0x00000200) {
+                P = (nv_rd32(device, 0x004008) & 0x00070000) >> 16;
+                if (nv_rd32(device, 0x004008) & 0x00000200) {
                         switch (mast & 0x0000c000) {
                         case 0x00000000:
                                 return read_clk(dev, clk_src_crystal) >> P;
@@ -266,7 +278,7 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 break;
         case clk_src_vdec:
                 P = (read_div(dev) & 0x00000700) >> 8;
-                switch (dev_priv->chipset) {
+                switch (nv_device(drm->device)->chipset) {
                 case 0x84:
                 case 0x86:
                 case 0x92:
@@ -275,7 +287,7 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 case 0xa0:
                         switch (mast & 0x00000c00) {
                         case 0x00000000:
-                                if (dev_priv->chipset == 0xa0) /* wtf?? */
+                                if (nv_device(drm->device)->chipset == 0xa0) /* wtf?? */
                                         return read_clk(dev, clk_src_nvclk) >> P;
                                 return read_clk(dev, clk_src_crystal) >> P;
                         case 0x00000400:
@@ -303,7 +315,7 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 }
                 break;
         case clk_src_dom6:
-                switch (dev_priv->chipset) {
+                switch (nv_device(drm->device)->chipset) {
                 case 0x50:
                 case 0xa0:
                         return read_pll(dev, 0x00e810) >> 2;
@@ -329,22 +341,22 @@ read_clk(struct drm_device *dev, enum clk_src src)
                 break;
         }
 
-        NV_DEBUG(dev, "unknown clock source %d 0x%08x\n", src, mast);
+        NV_DEBUG(drm, "unknown clock source %d 0x%08x\n", src, mast);
         return 0;
 }
 
 int
 nv50_pm_clocks_get(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        if (dev_priv->chipset == 0xaa ||
-            dev_priv->chipset == 0xac)
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        if (nv_device(drm->device)->chipset == 0xaa ||
+            nv_device(drm->device)->chipset == 0xac)
                 return 0;
 
         perflvl->core   = read_clk(dev, clk_src_nvclk);
         perflvl->shader = read_clk(dev, clk_src_sclk);
         perflvl->memory = read_clk(dev, clk_src_mclk);
-        if (dev_priv->chipset != 0x50) {
+        if (nv_device(drm->device)->chipset != 0x50) {
                 perflvl->vdec = read_clk(dev, clk_src_vdec);
                 perflvl->dom6 = read_clk(dev, clk_src_dom6);
         }
@@ -363,22 +375,25 @@ struct nv50_pm_state {
 };
 
 static u32
-calc_pll(struct drm_device *dev, u32 reg, struct pll_lims *pll,
+calc_pll(struct drm_device *dev, u32 reg, struct nvbios_pll *pll,
          u32 clk, int *N1, int *M1, int *log2P)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nouveau_clock *pclk = nouveau_clock(device);
         struct nouveau_pll_vals coef;
         int ret;
 
-        ret = get_pll_limits(dev, reg, pll);
+        ret = nvbios_pll_parse(bios, reg, pll);
         if (ret)
                 return 0;
 
-        pll->vco2.maxfreq = 0;
+        pll->vco2.max_freq = 0;
         pll->refclk = read_pll_ref(dev, reg);
         if (!pll->refclk)
                 return 0;
 
-        ret = nouveau_calc_pll_mnp(dev, pll, clk, &coef);
+        ret = pclk->pll_calc(pclk, pll, clk, &coef);
         if (ret == 0)
                 return 0;
 
@@ -461,27 +476,29 @@ mclk_wait(struct nouveau_mem_exec_func *exec, u32 nsec)
 static u32
 mclk_mrg(struct nouveau_mem_exec_func *exec, int mr)
 {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         if (mr <= 1)
-                return nv_rd32(exec->dev, 0x1002c0 + ((mr - 0) * 4));
+                return nv_rd32(device, 0x1002c0 + ((mr - 0) * 4));
         if (mr <= 3)
-                return nv_rd32(exec->dev, 0x1002e0 + ((mr - 2) * 4));
+                return nv_rd32(device, 0x1002e0 + ((mr - 2) * 4));
         return 0;
 }
 
 static void
 mclk_mrs(struct nouveau_mem_exec_func *exec, int mr, u32 data)
 {
-        struct drm_nouveau_private *dev_priv = exec->dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
         struct nv50_pm_state *info = exec->priv;
         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
 
         if (mr <= 1) {
-                if (dev_priv->vram_rank_B)
+                if (pfb->ram.ranks > 1)
                         hwsq_wr32(hwsq, 0x1002c8 + ((mr - 0) * 4), data);
                 hwsq_wr32(hwsq, 0x1002c0 + ((mr - 0) * 4), data);
         } else
         if (mr <= 3) {
-                if (dev_priv->vram_rank_B)
+                if (pfb->ram.ranks > 1)
                         hwsq_wr32(hwsq, 0x1002e8 + ((mr - 2) * 4), data);
                 hwsq_wr32(hwsq, 0x1002e0 + ((mr - 2) * 4), data);
         }
@@ -490,11 +507,12 @@ mclk_mrs(struct nouveau_mem_exec_func *exec, int mr, u32 data)
 static void
 mclk_clock_set(struct nouveau_mem_exec_func *exec)
 {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         struct nv50_pm_state *info = exec->priv;
         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
-        u32 ctrl = nv_rd32(exec->dev, 0x004008);
+        u32 ctrl = nv_rd32(device, 0x004008);
 
-        info->mmast = nv_rd32(exec->dev, 0x00c040);
+        info->mmast = nv_rd32(device, 0x00c040);
         info->mmast &= ~0xc0000000; /* get MCLK_2 from HREF */
         info->mmast |=  0x0000c000; /* use MCLK_2 as MPLL_BYPASS clock */
 
@@ -508,7 +526,7 @@ mclk_clock_set(struct nouveau_mem_exec_func *exec)
 static void
 mclk_timing_set(struct nouveau_mem_exec_func *exec)
 {
-        struct drm_device *dev = exec->dev;
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         struct nv50_pm_state *info = exec->priv;
         struct nouveau_pm_level *perflvl = info->perflvl;
         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
@@ -516,7 +534,7 @@ mclk_timing_set(struct nouveau_mem_exec_func *exec)
 
         for (i = 0; i < 9; i++) {
                 u32 reg = 0x100220 + (i * 4);
-                u32 val = nv_rd32(dev, reg);
+                u32 val = nv_rd32(device, reg);
                 if (val != perflvl->timing.reg[i])
                         hwsq_wr32(hwsq, reg, perflvl->timing.reg[i]);
         }
@@ -526,7 +544,8 @@ static int
 calc_mclk(struct drm_device *dev, struct nouveau_pm_level *perflvl,
           struct nv50_pm_state *info)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
         u32 crtc_mask = nv50_display_active_crtcs(dev);
         struct nouveau_mem_exec_func exec = {
                 .dev = dev,
@@ -542,22 +561,22 @@ calc_mclk(struct drm_device *dev, struct nouveau_pm_level *perflvl,
                 .priv = info
         };
         struct hwsq_ucode *hwsq = &info->mclk_hwsq;
-        struct pll_lims pll;
+        struct nvbios_pll pll;
         int N, M, P;
         int ret;
 
         /* use pcie refclock if possible, otherwise use mpll */
-        info->mctrl  = nv_rd32(dev, 0x004008);
+        info->mctrl  = nv_rd32(device, 0x004008);
         info->mctrl &= ~0x81ff0200;
         if (clk_same(perflvl->memory, read_clk(dev, clk_src_href))) {
-                info->mctrl |= 0x00000200 | (pll.log2p_bias << 19);
+                info->mctrl |= 0x00000200 | (pll.bias_p << 19);
         } else {
                 ret = calc_pll(dev, 0x4008, &pll, perflvl->memory, &N, &M, &P);
                 if (ret == 0)
                         return -EINVAL;
 
                 info->mctrl |= 0x80000000 | (P << 22) | (P << 16);
-                info->mctrl |= pll.log2p_bias << 19;
+                info->mctrl |= pll.bias_p << 19;
                 info->mcoef  = (N << 8) | M;
         }
 
@@ -567,7 +586,7 @@ calc_mclk(struct drm_device *dev, struct nouveau_pm_level *perflvl,
                 hwsq_op5f(hwsq, crtc_mask, 0x00); /* wait for scanout */
                 hwsq_op5f(hwsq, crtc_mask, 0x01); /* wait for vblank */
         }
-        if (dev_priv->chipset >= 0x92)
+        if (nv_device(drm->device)->chipset >= 0x92)
                 hwsq_wr32(hwsq, 0x611200, 0x00003300); /* disable scanout */
         hwsq_setf(hwsq, 0x10, 0); /* disable bus access */
         hwsq_op5f(hwsq, 0x00, 0x01); /* no idea :s */
@@ -578,7 +597,7 @@ calc_mclk(struct drm_device *dev, struct nouveau_pm_level *perflvl,
 
         hwsq_setf(hwsq, 0x10, 1); /* enable bus access */
         hwsq_op5f(hwsq, 0x00, 0x00); /* no idea, reverse of 0x00, 0x01? */
-        if (dev_priv->chipset >= 0x92)
+        if (nv_device(drm->device)->chipset >= 0x92)
                 hwsq_wr32(hwsq, 0x611200, 0x00003330); /* enable scanout */
         hwsq_fini(hwsq);
         return 0;
@@ -587,16 +606,17 @@ calc_mclk(struct drm_device *dev, struct nouveau_pm_level *perflvl,
 void *
 nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nv50_pm_state *info;
         struct hwsq_ucode *hwsq;
-        struct pll_lims pll;
+        struct nvbios_pll pll;
         u32 out, mast, divs, ctrl;
         int clk, ret = -EINVAL;
         int N, M, P1, P2;
 
-        if (dev_priv->chipset == 0xaa ||
-            dev_priv->chipset == 0xac)
+        if (nv_device(drm->device)->chipset == 0xaa ||
+            nv_device(drm->device)->chipset == 0xac)
                 return ERR_PTR(-ENODEV);
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
@@ -645,7 +665,7 @@ nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
                 clk = calc_div(perflvl->core, perflvl->vdec, &P1);
 
                 /* see how close we can get using xpll/hclk as a source */
-                if (dev_priv->chipset != 0x98)
+                if (nv_device(drm->device)->chipset != 0x98)
                         out = read_pll(dev, 0x004030);
                 else
                         out = read_clk(dev, clk_src_hclkm3d2);
@@ -654,7 +674,7 @@ nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
                 /* select whichever gets us closest */
                 if (abs((int)perflvl->vdec - clk) <=
                     abs((int)perflvl->vdec - out)) {
-                        if (dev_priv->chipset != 0x98)
+                        if (nv_device(drm->device)->chipset != 0x98)
                                 mast |= 0x00000c00;
                         divs |= P1 << 8;
                 } else {
@@ -682,7 +702,7 @@ nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
         }
 
         /* vdec/dom6: complete switch to new clocks */
-        switch (dev_priv->chipset) {
+        switch (nv_device(drm->device)->chipset) {
         case 0x92:
         case 0x94:
         case 0x96:
@@ -698,7 +718,7 @@ nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
         /* core/shader: make sure sclk/nvclk are disconnected from their
          * PLLs (nvclk to dom6, sclk to hclk)
          */
-        if (dev_priv->chipset < 0x92)
+        if (nv_device(drm->device)->chipset < 0x92)
                 mast = (mast & ~0x001000b0) | 0x00100080;
         else
                 mast = (mast & ~0x000000b3) | 0x00000081;
@@ -710,7 +730,7 @@ nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
         if (clk == 0)
                 goto error;
 
-        ctrl  = nv_rd32(dev, 0x004028) & ~0xc03f0100;
+        ctrl  = nv_rd32(device, 0x004028) & ~0xc03f0100;
         mast &= ~0x00100000;
         mast |= 3;
 
@@ -723,7 +743,7 @@ nv50_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
          * cases will be handled by tying to nvclk, but it's possible there's
          * corners
          */
-        ctrl = nv_rd32(dev, 0x004020) & ~0xc03f0100;
+        ctrl = nv_rd32(device, 0x004020) & ~0xc03f0100;
 
         if (P1-- && perflvl->shader == (perflvl->core << 1)) {
                 hwsq_wr32(hwsq, 0x004020, (P1 << 19) | (P1 << 16) | ctrl);
@@ -752,11 +772,12 @@ error:
 static int
 prog_hwsq(struct drm_device *dev, struct hwsq_ucode *hwsq)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u32 hwsq_data, hwsq_kick;
         int i;
 
-        if (dev_priv->chipset < 0x94) {
+        if (nv_device(drm->device)->chipset < 0x94) {
                 hwsq_data = 0x001400;
                 hwsq_kick = 0x00000003;
         } else {
@@ -764,22 +785,22 @@ prog_hwsq(struct drm_device *dev, struct hwsq_ucode *hwsq)
                 hwsq_kick = 0x00000001;
         }
         /* upload hwsq ucode */
-        nv_mask(dev, 0x001098, 0x00000008, 0x00000000);
-        nv_wr32(dev, 0x001304, 0x00000000);
-        if (dev_priv->chipset >= 0x92)
-                nv_wr32(dev, 0x001318, 0x00000000);
+        nv_mask(device, 0x001098, 0x00000008, 0x00000000);
+        nv_wr32(device, 0x001304, 0x00000000);
+        if (nv_device(drm->device)->chipset >= 0x92)
+                nv_wr32(device, 0x001318, 0x00000000);
         for (i = 0; i < hwsq->len / 4; i++)
-                nv_wr32(dev, hwsq_data + (i * 4), hwsq->ptr.u32[i]);
-        nv_mask(dev, 0x001098, 0x00000018, 0x00000018);
+                nv_wr32(device, hwsq_data + (i * 4), hwsq->ptr.u32[i]);
+        nv_mask(device, 0x001098, 0x00000018, 0x00000018);
 
         /* launch, and wait for completion */
-        nv_wr32(dev, 0x00130c, hwsq_kick);
-        if (!nv_wait(dev, 0x001308, 0x00000100, 0x00000000)) {
-                NV_ERROR(dev, "hwsq ucode exec timed out\n");
-                NV_ERROR(dev, "0x001308: 0x%08x\n", nv_rd32(dev, 0x001308));
+        nv_wr32(device, 0x00130c, hwsq_kick);
+        if (!nv_wait(device, 0x001308, 0x00000100, 0x00000000)) {
+                NV_ERROR(drm, "hwsq ucode exec timed out\n");
+                NV_ERROR(drm, "0x001308: 0x%08x\n", nv_rd32(device, 0x001308));
                 for (i = 0; i < hwsq->len / 4; i++) {
-                        NV_ERROR(dev, "0x%06x: 0x%08x\n", 0x1400 + (i * 4),
-                                 nv_rd32(dev, 0x001400 + (i * 4)));
+                        NV_ERROR(drm, "0x%06x: 0x%08x\n", 0x1400 + (i * 4),
+                                 nv_rd32(device, 0x001400 + (i * 4)));
                 }
 
                 return -EIO;
@@ -791,20 +812,22 @@ prog_hwsq(struct drm_device *dev, struct hwsq_ucode *hwsq)
 int
 nv50_pm_clocks_set(struct drm_device *dev, void *data)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nv50_pm_state *info = data;
         struct bit_entry M;
         int ret = -EBUSY;
 
         /* halt and idle execution engines */
-        nv_mask(dev, 0x002504, 0x00000001, 0x00000001);
-        if (!nv_wait(dev, 0x002504, 0x00000010, 0x00000010))
+        nv_mask(device, 0x002504, 0x00000001, 0x00000001);
+        if (!nv_wait(device, 0x002504, 0x00000010, 0x00000010))
                 goto resume;
-        if (!nv_wait(dev, 0x00251c, 0x0000003f, 0x0000003f))
+        if (!nv_wait(device, 0x00251c, 0x0000003f, 0x0000003f))
                 goto resume;
 
         /* program memory clock, if necessary - must come before engine clock
          * reprogramming due to how we construct the hwsq scripts in pre()
          */
+#define nouveau_bios_init_exec(a,b) nouveau_bios_run_init_table((a), (b), NULL, 0)
         if (info->mclk_hwsq.len) {
                 /* execute some scripts that do ??? from the vbios.. */
                 if (!bit_table(dev, 'M', &M) && M.version == 1) {
@@ -826,61 +849,7 @@ nv50_pm_clocks_set(struct drm_device *dev, void *data)
         ret = prog_hwsq(dev, &info->eclk_hwsq);
 
 resume:
-        nv_mask(dev, 0x002504, 0x00000001, 0x00000000);
+        nv_mask(device, 0x002504, 0x00000001, 0x00000000);
         kfree(info);
         return ret;
 }
-
-static int
-pwm_info(struct drm_device *dev, int *line, int *ctrl, int *indx)
-{
-        if (*line == 0x04) {
-                *ctrl = 0x00e100;
-                *line = 4;
-                *indx = 0;
-        } else
-        if (*line == 0x09) {
-                *ctrl = 0x00e100;
-                *line = 9;
-                *indx = 1;
-        } else
-        if (*line == 0x10) {
-                *ctrl = 0x00e28c;
-                *line = 0;
-                *indx = 0;
-        } else {
-                NV_ERROR(dev, "unknown pwm ctrl for gpio %d\n", *line);
-                return -ENODEV;
-        }
-
-        return 0;
-}
-
-int
-nv50_pm_pwm_get(struct drm_device *dev, int line, u32 *divs, u32 *duty)
-{
-        int ctrl, id, ret = pwm_info(dev, &line, &ctrl, &id);
-        if (ret)
-                return ret;
-
-        if (nv_rd32(dev, ctrl) & (1 << line)) {
-                *divs = nv_rd32(dev, 0x00e114 + (id * 8));
-                *duty = nv_rd32(dev, 0x00e118 + (id * 8));
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
-int
-nv50_pm_pwm_set(struct drm_device *dev, int line, u32 divs, u32 duty)
-{
-        int ctrl, id, ret = pwm_info(dev, &line, &ctrl, &id);
-        if (ret)
-                return ret;
-
-        nv_mask(dev, ctrl, 0x00010001 << line, 0x00000001 << line);
-        nv_wr32(dev, 0x00e114 + (id * 8), divs);
-        nv_wr32(dev, 0x00e118 + (id * 8), duty | 0x80000000);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_software.c b/drivers/gpu/drm/nouveau/nv50_software.c
deleted file mode 100644
index df554d9dacb8..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_software.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright 2012 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"
-#include "nouveau_ramht.h"
-#include "nouveau_software.h"
-
-#include "nv50_display.h"
-
-struct nv50_software_priv {
-        struct nouveau_software_priv base;
-};
-
-struct nv50_software_chan {
-        struct nouveau_software_chan base;
-};
-
-static int
-mthd_dma_vblsem(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        struct nv50_software_chan *pch = chan->engctx[NVOBJ_ENGINE_SW];
-        struct nouveau_gpuobj *gpuobj;
-
-        gpuobj = nouveau_ramht_find(chan, data);
-        if (!gpuobj)
-                return -ENOENT;
-
-        pch->base.vblank.ctxdma = gpuobj->cinst >> 4;
-        return 0;
-}
-
-static int
-mthd_vblsem_offset(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        struct nv50_software_chan *pch = chan->engctx[NVOBJ_ENGINE_SW];
-        pch->base.vblank.offset = data;
-        return 0;
-}
-
-static int
-mthd_vblsem_value(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        struct nv50_software_chan *pch = chan->engctx[NVOBJ_ENGINE_SW];
-        pch->base.vblank.value = data;
-        return 0;
-}
-
-static int
-mthd_vblsem_release(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        struct nv50_software_priv *psw = nv_engine(chan->dev, NVOBJ_ENGINE_SW);
-        struct nv50_software_chan *pch = chan->engctx[NVOBJ_ENGINE_SW];
-        struct drm_device *dev = chan->dev;
-
-        if (data > 1)
-                return -EINVAL;
-
-        drm_vblank_get(dev, data);
-
-        pch->base.vblank.head = data;
-        list_add(&pch->base.vblank.list, &psw->base.vblank);
-        return 0;
-}
-
-static int
-mthd_flip(struct nouveau_channel *chan, u32 class, u32 mthd, u32 data)
-{
-        nouveau_finish_page_flip(chan, NULL);
-        return 0;
-}
-
-static int
-nv50_software_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv50_software_priv *psw = nv_engine(chan->dev, NVOBJ_ENGINE_SW);
-        struct nv50_display *pdisp = nv50_display(chan->dev);
-        struct nv50_software_chan *pch;
-        int ret = 0, i;
-
-        pch = kzalloc(sizeof(*pch), GFP_KERNEL);
-        if (!pch)
-                return -ENOMEM;
-
-        nouveau_software_context_new(&pch->base);
-        pch->base.vblank.channel = chan->ramin->vinst >> 12;
-        chan->engctx[engine] = pch;
-
-        /* dma objects for display sync channel semaphore blocks */
-        for (i = 0; i < chan->dev->mode_config.num_crtc; i++) {
-                struct nv50_display_crtc *dispc = &pdisp->crtc[i];
-                struct nouveau_gpuobj *obj = NULL;
-
-                ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY,
-                                             dispc->sem.bo->bo.offset, 0x1000,
-                                             NV_MEM_ACCESS_RW,
-                                             NV_MEM_TARGET_VRAM, &obj);
-                if (ret)
-                        break;
-
-                ret = nouveau_ramht_insert(chan, NvEvoSema0 + i, obj);
-                nouveau_gpuobj_ref(NULL, &obj);
-        }
-
-        if (ret)
-                psw->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nv50_software_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv50_software_chan *pch = chan->engctx[engine];
-        chan->engctx[engine] = NULL;
-        kfree(pch);
-}
-
-static int
-nv50_software_object_new(struct nouveau_channel *chan, int engine,
-                         u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, 0, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 0;
-        obj->class  = class;
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static int
-nv50_software_init(struct drm_device *dev, int engine)
-{
-        return 0;
-}
-
-static int
-nv50_software_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static void
-nv50_software_destroy(struct drm_device *dev, int engine)
-{
-        struct nv50_software_priv *psw = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, SW);
-        kfree(psw);
-}
-
-int
-nv50_software_create(struct drm_device *dev)
-{
-        struct nv50_software_priv *psw = kzalloc(sizeof(*psw), GFP_KERNEL);
-        if (!psw)
-                return -ENOMEM;
-
-        psw->base.base.destroy = nv50_software_destroy;
-        psw->base.base.init = nv50_software_init;
-        psw->base.base.fini = nv50_software_fini;
-        psw->base.base.context_new = nv50_software_context_new;
-        psw->base.base.context_del = nv50_software_context_del;
-        psw->base.base.object_new = nv50_software_object_new;
-        nouveau_software_create(&psw->base);
-
-        NVOBJ_ENGINE_ADD(dev, SW, &psw->base.base);
-        NVOBJ_CLASS(dev, 0x506e, SW);
-        NVOBJ_MTHD (dev, 0x506e, 0x018c, mthd_dma_vblsem);
-        NVOBJ_MTHD (dev, 0x506e, 0x0400, mthd_vblsem_offset);
-        NVOBJ_MTHD (dev, 0x506e, 0x0404, mthd_vblsem_value);
-        NVOBJ_MTHD (dev, 0x506e, 0x0408, mthd_vblsem_release);
-        NVOBJ_MTHD (dev, 0x506e, 0x0500, mthd_flip);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv50_sor.c b/drivers/gpu/drm/nouveau/nv50_sor.c
index 93240bde891b..48644e379e86 100644
--- a/drivers/gpu/drm/nouveau/nv50_sor.c
+++ b/drivers/gpu/drm/nouveau/nv50_sor.c
@@ -29,35 +29,40 @@
 
 #define NOUVEAU_DMA_DEBUG (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
 #include "nouveau_reg.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
 #include "nv50_display.h"
 
+#include <subdev/timer.h>
+
 static u32
-nv50_sor_dp_lane_map(struct drm_device *dev, struct dcb_entry *dcb, u8 lane)
+nv50_sor_dp_lane_map(struct drm_device *dev, struct dcb_output *dcb, u8 lane)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         static const u8 nvaf[] = { 24, 16, 8, 0 }; /* thanks, apple.. */
         static const u8 nv50[] = { 16, 8, 0, 24 };
-        if (dev_priv->chipset == 0xaf)
+        if (nv_device(drm->device)->chipset == 0xaf)
                 return nvaf[lane];
         return nv50[lane];
 }
 
 static void
-nv50_sor_dp_train_set(struct drm_device *dev, struct dcb_entry *dcb, u8 pattern)
+nv50_sor_dp_train_set(struct drm_device *dev, struct dcb_output *dcb, u8 pattern)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
-        nv_mask(dev, NV50_SOR_DP_CTRL(or, link), 0x0f000000, pattern << 24);
+        nv_mask(device, NV50_SOR_DP_CTRL(or, link), 0x0f000000, pattern << 24);
 }
 
 static void
-nv50_sor_dp_train_adj(struct drm_device *dev, struct dcb_entry *dcb,
+nv50_sor_dp_train_adj(struct drm_device *dev, struct dcb_output *dcb,
                       u8 lane, u8 swing, u8 preem)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
         u32 shift = nv50_sor_dp_lane_map(dev, dcb, lane);
         u32 mask = 0x000000ff << shift;
@@ -65,7 +70,7 @@ nv50_sor_dp_train_adj(struct drm_device *dev, struct dcb_entry *dcb,
 
         table = nouveau_dp_bios_data(dev, dcb, &entry);
         if (!table || (table[0] != 0x20 && table[0] != 0x21)) {
-                NV_ERROR(dev, "PDISP: unsupported DP table for chipset\n");
+                NV_ERROR(drm, "PDISP: unsupported DP table for chipset\n");
                 return;
         }
 
@@ -76,24 +81,26 @@ nv50_sor_dp_train_adj(struct drm_device *dev, struct dcb_entry *dcb,
                         return;
         }
 
-        nv_mask(dev, NV50_SOR_DP_UNK118(or, link), mask, config[2] << shift);
-        nv_mask(dev, NV50_SOR_DP_UNK120(or, link), mask, config[3] << shift);
-        nv_mask(dev, NV50_SOR_DP_UNK130(or, link), 0x0000ff00, config[4] << 8);
+        nv_mask(device, NV50_SOR_DP_UNK118(or, link), mask, config[2] << shift);
+        nv_mask(device, NV50_SOR_DP_UNK120(or, link), mask, config[3] << shift);
+        nv_mask(device, NV50_SOR_DP_UNK130(or, link), 0x0000ff00, config[4] << 8);
 }
 
 static void
-nv50_sor_dp_link_set(struct drm_device *dev, struct dcb_entry *dcb, int crtc,
+nv50_sor_dp_link_set(struct drm_device *dev, struct dcb_output *dcb, int crtc,
                      int link_nr, u32 link_bw, bool enhframe)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
-        u32 dpctrl = nv_rd32(dev, NV50_SOR_DP_CTRL(or, link)) & ~0x001f4000;
-        u32 clksor = nv_rd32(dev, 0x614300 + (or * 0x800)) & ~0x000c0000;
+        u32 dpctrl = nv_rd32(device, NV50_SOR_DP_CTRL(or, link)) & ~0x001f4000;
+        u32 clksor = nv_rd32(device, 0x614300 + (or * 0x800)) & ~0x000c0000;
         u8 *table, *entry, mask;
         int i;
 
         table = nouveau_dp_bios_data(dev, dcb, &entry);
         if (!table || (table[0] != 0x20 && table[0] != 0x21)) {
-                NV_ERROR(dev, "PDISP: unsupported DP table for chipset\n");
+                NV_ERROR(drm, "PDISP: unsupported DP table for chipset\n");
                 return;
         }
 
@@ -112,20 +119,21 @@ nv50_sor_dp_link_set(struct drm_device *dev, struct dcb_entry *dcb, int crtc,
         if (link_bw > 162000)
                 clksor |= 0x00040000;
 
-        nv_wr32(dev, 0x614300 + (or * 0x800), clksor);
-        nv_wr32(dev, NV50_SOR_DP_CTRL(or, link), dpctrl);
+        nv_wr32(device, 0x614300 + (or * 0x800), clksor);
+        nv_wr32(device, NV50_SOR_DP_CTRL(or, link), dpctrl);
 
         mask = 0;
         for (i = 0; i < link_nr; i++)
                 mask |= 1 << (nv50_sor_dp_lane_map(dev, dcb, i) >> 3);
-        nv_mask(dev, NV50_SOR_DP_UNK130(or, link), 0x0000000f, mask);
+        nv_mask(device, NV50_SOR_DP_UNK130(or, link), 0x0000000f, mask);
 }
 
 static void
 nv50_sor_dp_link_get(struct drm_device *dev, u32 or, u32 link, u32 *nr, u32 *bw)
 {
-        u32 dpctrl = nv_rd32(dev, NV50_SOR_DP_CTRL(or, link)) & 0x000f0000;
-        u32 clksor = nv_rd32(dev, 0x614300 + (or * 0x800));
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 dpctrl = nv_rd32(device, NV50_SOR_DP_CTRL(or, link)) & 0x000f0000;
+        u32 clksor = nv_rd32(device, 0x614300 + (or * 0x800));
         if (clksor & 0x000c0000)
                 *bw = 270000;
         else
@@ -139,6 +147,8 @@ nv50_sor_dp_link_get(struct drm_device *dev, u32 or, u32 link, u32 *nr, u32 *bw)
 void
 nv50_sor_dp_calc_tu(struct drm_device *dev, int or, int link, u32 clk, u32 bpp)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         const u32 symbol = 100000;
         int bestTU = 0, bestVTUi = 0, bestVTUf = 0, bestVTUa = 0;
         int TU, VTUi, VTUf, VTUa;
@@ -206,7 +216,7 @@ nv50_sor_dp_calc_tu(struct drm_device *dev, int or, int link, u32 clk, u32 bpp)
         }
 
         if (!bestTU) {
-                NV_ERROR(dev, "DP: unable to find suitable config\n");
+                NV_ERROR(drm, "DP: unable to find suitable config\n");
                 return;
         }
 
@@ -217,8 +227,8 @@ nv50_sor_dp_calc_tu(struct drm_device *dev, int or, int link, u32 clk, u32 bpp)
         r = do_div(unk, symbol);
         unk += 6;
 
-        nv_mask(dev, NV50_SOR_DP_CTRL(or, link), 0x000001fc, bestTU << 2);
-        nv_mask(dev, NV50_SOR_DP_SCFG(or, link), 0x010f7f3f, bestVTUa << 24 |
+        nv_mask(device, NV50_SOR_DP_CTRL(or, link), 0x000001fc, bestTU << 2);
+        nv_mask(device, NV50_SOR_DP_SCFG(or, link), 0x010f7f3f, bestVTUa << 24 |
                                                              bestVTUf << 16 |
                                                              bestVTUi << 8 |
                                                              unk);
@@ -227,6 +237,7 @@ static void
 nv50_sor_disconnect(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct drm_device *dev = encoder->dev;
         struct nouveau_channel *evo = nv50_display(dev)->master;
         int ret;
@@ -235,11 +246,11 @@ nv50_sor_disconnect(struct drm_encoder *encoder)
                 return;
         nv50_crtc_blank(nouveau_crtc(nv_encoder->crtc), true);
 
-        NV_DEBUG_KMS(dev, "Disconnecting SOR %d\n", nv_encoder->or);
+        NV_DEBUG(drm, "Disconnecting SOR %d\n", nv_encoder->or);
 
         ret = RING_SPACE(evo, 4);
         if (ret) {
-                NV_ERROR(dev, "no space while disconnecting SOR\n");
+                NV_ERROR(drm, "no space while disconnecting SOR\n");
                 return;
         }
         BEGIN_NV04(evo, 0, NV50_EVO_SOR(nv_encoder->or, MODE_CTRL), 1);
@@ -256,22 +267,24 @@ nv50_sor_disconnect(struct drm_encoder *encoder)
 static void
 nv50_sor_dpms(struct drm_encoder *encoder, int mode)
 {
+        struct nouveau_device *device = nouveau_dev(encoder->dev);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct drm_device *dev = encoder->dev;
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_encoder *enc;
         uint32_t val;
         int or = nv_encoder->or;
 
-        NV_DEBUG_KMS(dev, "or %d type %d mode %d\n", or, nv_encoder->dcb->type, mode);
+        NV_DEBUG(drm, "or %d type %d mode %d\n", or, nv_encoder->dcb->type, mode);
 
         nv_encoder->last_dpms = mode;
         list_for_each_entry(enc, &dev->mode_config.encoder_list, head) {
                 struct nouveau_encoder *nvenc = nouveau_encoder(enc);
 
                 if (nvenc == nv_encoder ||
-                    (nvenc->dcb->type != OUTPUT_TMDS &&
-                     nvenc->dcb->type != OUTPUT_LVDS &&
-                     nvenc->dcb->type != OUTPUT_DP) ||
+                    (nvenc->dcb->type != DCB_OUTPUT_TMDS &&
+                     nvenc->dcb->type != DCB_OUTPUT_LVDS &&
+                     nvenc->dcb->type != DCB_OUTPUT_DP) ||
                     nvenc->dcb->or != nv_encoder->dcb->or)
                         continue;
 
@@ -280,30 +293,30 @@ nv50_sor_dpms(struct drm_encoder *encoder, int mode)
         }
 
         /* wait for it to be done */
-        if (!nv_wait(dev, NV50_PDISPLAY_SOR_DPMS_CTRL(or),
+        if (!nv_wait(device, NV50_PDISPLAY_SOR_DPMS_CTRL(or),
                      NV50_PDISPLAY_SOR_DPMS_CTRL_PENDING, 0)) {
-                NV_ERROR(dev, "timeout: SOR_DPMS_CTRL_PENDING(%d) == 0\n", or);
-                NV_ERROR(dev, "SOR_DPMS_CTRL(%d) = 0x%08x\n", or,
-                         nv_rd32(dev, NV50_PDISPLAY_SOR_DPMS_CTRL(or)));
+                NV_ERROR(drm, "timeout: SOR_DPMS_CTRL_PENDING(%d) == 0\n", or);
+                NV_ERROR(drm, "SOR_DPMS_CTRL(%d) = 0x%08x\n", or,
+                         nv_rd32(device, NV50_PDISPLAY_SOR_DPMS_CTRL(or)));
         }
 
-        val = nv_rd32(dev, NV50_PDISPLAY_SOR_DPMS_CTRL(or));
+        val = nv_rd32(device, NV50_PDISPLAY_SOR_DPMS_CTRL(or));
 
         if (mode == DRM_MODE_DPMS_ON)
                 val |= NV50_PDISPLAY_SOR_DPMS_CTRL_ON;
         else
                 val &= ~NV50_PDISPLAY_SOR_DPMS_CTRL_ON;
 
-        nv_wr32(dev, NV50_PDISPLAY_SOR_DPMS_CTRL(or), val |
+        nv_wr32(device, NV50_PDISPLAY_SOR_DPMS_CTRL(or), val |
                 NV50_PDISPLAY_SOR_DPMS_CTRL_PENDING);
-        if (!nv_wait(dev, NV50_PDISPLAY_SOR_DPMS_STATE(or),
+        if (!nv_wait(device, NV50_PDISPLAY_SOR_DPMS_STATE(or),
                      NV50_PDISPLAY_SOR_DPMS_STATE_WAIT, 0)) {
-                NV_ERROR(dev, "timeout: SOR_DPMS_STATE_WAIT(%d) == 0\n", or);
-                NV_ERROR(dev, "SOR_DPMS_STATE(%d) = 0x%08x\n", or,
-                         nv_rd32(dev, NV50_PDISPLAY_SOR_DPMS_STATE(or)));
+                NV_ERROR(drm, "timeout: SOR_DPMS_STATE_WAIT(%d) == 0\n", or);
+                NV_ERROR(drm, "SOR_DPMS_STATE(%d) = 0x%08x\n", or,
+                         nv_rd32(device, NV50_PDISPLAY_SOR_DPMS_STATE(or)));
         }
 
-        if (nv_encoder->dcb->type == OUTPUT_DP) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_DP) {
                 struct dp_train_func func = {
                         .link_set = nv50_sor_dp_link_set,
                         .train_set = nv50_sor_dp_train_set,
@@ -317,13 +330,15 @@ nv50_sor_dpms(struct drm_encoder *encoder, int mode)
 static void
 nv50_sor_save(struct drm_encoder *encoder)
 {
-        NV_ERROR(encoder->dev, "!!\n");
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        NV_ERROR(drm, "!!\n");
 }
 
 static void
 nv50_sor_restore(struct drm_encoder *encoder)
 {
-        NV_ERROR(encoder->dev, "!!\n");
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        NV_ERROR(drm, "!!\n");
 }
 
 static bool
@@ -331,14 +346,15 @@ nv50_sor_mode_fixup(struct drm_encoder *encoder,
                     const struct drm_display_mode *mode,
                     struct drm_display_mode *adjusted_mode)
 {
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct nouveau_connector *connector;
 
-        NV_DEBUG_KMS(encoder->dev, "or %d\n", nv_encoder->or);
+        NV_DEBUG(drm, "or %d\n", nv_encoder->or);
 
         connector = nouveau_encoder_connector_get(nv_encoder);
         if (!connector) {
-                NV_ERROR(encoder->dev, "Encoder has no connector\n");
+                NV_ERROR(drm, "Encoder has no connector\n");
                 return false;
         }
 
@@ -354,7 +370,7 @@ nv50_sor_prepare(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         nv50_sor_disconnect(encoder);
-        if (nv_encoder->dcb->type == OUTPUT_DP) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_DP) {
                 /* avoid race between link training and supervisor intr */
                 nv50_display_sync(encoder->dev);
         }
@@ -371,18 +387,18 @@ nv50_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 {
         struct nouveau_channel *evo = nv50_display(encoder->dev)->master;
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-        struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
         struct nouveau_crtc *crtc = nouveau_crtc(encoder->crtc);
         struct nouveau_connector *nv_connector;
         uint32_t mode_ctl = 0;
         int ret;
 
-        NV_DEBUG_KMS(dev, "or %d type %d -> crtc %d\n",
+        NV_DEBUG(drm, "or %d type %d -> crtc %d\n",
                      nv_encoder->or, nv_encoder->dcb->type, crtc->index);
         nv_encoder->crtc = encoder->crtc;
 
         switch (nv_encoder->dcb->type) {
-        case OUTPUT_TMDS:
+        case DCB_OUTPUT_TMDS:
                 if (nv_encoder->dcb->sorconf.link & 1) {
                         if (mode->clock < 165000)
                                 mode_ctl = 0x0100;
@@ -393,7 +409,7 @@ nv50_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 
                 nouveau_hdmi_mode_set(encoder, mode);
                 break;
-        case OUTPUT_DP:
+        case DCB_OUTPUT_DP:
                 nv_connector = nouveau_encoder_connector_get(nv_encoder);
                 if (nv_connector && nv_connector->base.display_info.bpc == 6) {
                         nv_encoder->dp.datarate = mode->clock * 18 / 8;
@@ -427,7 +443,7 @@ nv50_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 
         ret = RING_SPACE(evo, 2);
         if (ret) {
-                NV_ERROR(dev, "no space while connecting SOR\n");
+                NV_ERROR(drm, "no space while connecting SOR\n");
                 nv_encoder->crtc = NULL;
                 return;
         }
@@ -458,11 +474,9 @@ static void
 nv50_sor_destroy(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
 
-        if (!encoder)
-                return;
-
-        NV_DEBUG_KMS(encoder->dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         drm_encoder_cleanup(encoder);
 
@@ -474,21 +488,22 @@ static const struct drm_encoder_funcs nv50_sor_encoder_funcs = {
 };
 
 int
-nv50_sor_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv50_sor_create(struct drm_connector *connector, struct dcb_output *entry)
 {
         struct nouveau_encoder *nv_encoder = NULL;
         struct drm_device *dev = connector->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct drm_encoder *encoder;
         int type;
 
-        NV_DEBUG_KMS(dev, "\n");
+        NV_DEBUG(drm, "\n");
 
         switch (entry->type) {
-        case OUTPUT_TMDS:
-        case OUTPUT_DP:
+        case DCB_OUTPUT_TMDS:
+        case DCB_OUTPUT_DP:
                 type = DRM_MODE_ENCODER_TMDS;
                 break;
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 type = DRM_MODE_ENCODER_LVDS;
                 break;
         default:
diff --git a/drivers/gpu/drm/nouveau/nv50_vram.c b/drivers/gpu/drm/nouveau/nv50_vram.c
deleted file mode 100644
index 9ed9ae397d75..000000000000
--- a/drivers/gpu/drm/nouveau/nv50_vram.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * 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"
-#include "nouveau_mm.h"
-
-static int types[0x80] = {
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0,
-        1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 0, 0,
-        0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 2, 2, 2, 2,
-        1, 0, 2, 0, 1, 0, 2, 0, 1, 1, 2, 2, 1, 1, 0, 0
-};
-
-bool
-nv50_vram_flags_valid(struct drm_device *dev, u32 tile_flags)
-{
-        int type = (tile_flags & NOUVEAU_GEM_TILE_LAYOUT_MASK) >> 8;
-
-        if (likely(type < ARRAY_SIZE(types) && types[type]))
-                return true;
-        return false;
-}
-
-void
-nv50_vram_del(struct drm_device *dev, struct nouveau_mem **pmem)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_mm *mm = &dev_priv->engine.vram.mm;
-        struct nouveau_mm_node *this;
-        struct nouveau_mem *mem;
-
-        mem = *pmem;
-        *pmem = NULL;
-        if (unlikely(mem == NULL))
-                return;
-
-        mutex_lock(&mm->mutex);
-        while (!list_empty(&mem->regions)) {
-                this = list_first_entry(&mem->regions, struct nouveau_mm_node, rl_entry);
-
-                list_del(&this->rl_entry);
-                nouveau_mm_put(mm, this);
-        }
-
-        if (mem->tag) {
-                drm_mm_put_block(mem->tag);
-                mem->tag = NULL;
-        }
-        mutex_unlock(&mm->mutex);
-
-        kfree(mem);
-}
-
-int
-nv50_vram_new(struct drm_device *dev, u64 size, u32 align, u32 size_nc,
-              u32 memtype, struct nouveau_mem **pmem)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_mm *mm = &dev_priv->engine.vram.mm;
-        struct nouveau_mm_node *r;
-        struct nouveau_mem *mem;
-        int comp = (memtype & 0x300) >> 8;
-        int type = (memtype & 0x07f);
-        int ret;
-
-        if (!types[type])
-                return -EINVAL;
-        size >>= 12;
-        align >>= 12;
-        size_nc >>= 12;
-
-        mem = kzalloc(sizeof(*mem), GFP_KERNEL);
-        if (!mem)
-                return -ENOMEM;
-
-        mutex_lock(&mm->mutex);
-        if (comp) {
-                if (align == 16) {
-                        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-                        int n = (size >> 4) * comp;
-
-                        mem->tag = drm_mm_search_free(&pfb->tag_heap, n, 0, 0);
-                        if (mem->tag)
-                                mem->tag = drm_mm_get_block(mem->tag, n, 0);
-                }
-
-                if (unlikely(!mem->tag))
-                        comp = 0;
-        }
-
-        INIT_LIST_HEAD(&mem->regions);
-        mem->dev = dev_priv->dev;
-        mem->memtype = (comp << 7) | type;
-        mem->size = size;
-
-        do {
-                ret = nouveau_mm_get(mm, types[type], size, size_nc, align, &r);
-                if (ret) {
-                        mutex_unlock(&mm->mutex);
-                        nv50_vram_del(dev, &mem);
-                        return ret;
-                }
-
-                list_add_tail(&r->rl_entry, &mem->regions);
-                size -= r->length;
-        } while (size);
-        mutex_unlock(&mm->mutex);
-
-        r = list_first_entry(&mem->regions, struct nouveau_mm_node, rl_entry);
-        mem->offset = (u64)r->offset << 12;
-        *pmem = mem;
-        return 0;
-}
-
-static u32
-nv50_vram_rblock(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int i, parts, colbits, rowbitsa, rowbitsb, banks;
-        u64 rowsize, predicted;
-        u32 r0, r4, rt, ru, rblock_size;
-
-        r0 = nv_rd32(dev, 0x100200);
-        r4 = nv_rd32(dev, 0x100204);
-        rt = nv_rd32(dev, 0x100250);
-        ru = nv_rd32(dev, 0x001540);
-        NV_DEBUG(dev, "memcfg 0x%08x 0x%08x 0x%08x 0x%08x\n", r0, r4, rt, ru);
-
-        for (i = 0, parts = 0; i < 8; i++) {
-                if (ru & (0x00010000 << i))
-                        parts++;
-        }
-
-        colbits  =  (r4 & 0x0000f000) >> 12;
-        rowbitsa = ((r4 & 0x000f0000) >> 16) + 8;
-        rowbitsb = ((r4 & 0x00f00000) >> 20) + 8;
-        banks    = 1 << (((r4 & 0x03000000) >> 24) + 2);
-
-        rowsize = parts * banks * (1 << colbits) * 8;
-        predicted = rowsize << rowbitsa;
-        if (r0 & 0x00000004)
-                predicted += rowsize << rowbitsb;
-
-        if (predicted != dev_priv->vram_size) {
-                NV_WARN(dev, "memory controller reports %dMiB VRAM\n",
-                        (u32)(dev_priv->vram_size >> 20));
-                NV_WARN(dev, "we calculated %dMiB VRAM\n",
-                        (u32)(predicted >> 20));
-        }
-
-        rblock_size = rowsize;
-        if (rt & 1)
-                rblock_size *= 3;
-
-        NV_DEBUG(dev, "rblock %d bytes\n", rblock_size);
-        return rblock_size;
-}
-
-int
-nv50_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-        const u32 rsvd_head = ( 256 * 1024) >> 12; /* vga memory */
-        const u32 rsvd_tail = (1024 * 1024) >> 12; /* vbios etc */
-        u32 pfb714 = nv_rd32(dev, 0x100714);
-        u32 rblock, length;
-
-        switch (pfb714 & 0x00000007) {
-        case 0: dev_priv->vram_type = NV_MEM_TYPE_DDR1; break;
-        case 1:
-                if (nouveau_mem_vbios_type(dev) == NV_MEM_TYPE_DDR3)
-                        dev_priv->vram_type = NV_MEM_TYPE_DDR3;
-                else
-                        dev_priv->vram_type = NV_MEM_TYPE_DDR2;
-                break;
-        case 2: dev_priv->vram_type = NV_MEM_TYPE_GDDR3; break;
-        case 3: dev_priv->vram_type = NV_MEM_TYPE_GDDR4; break;
-        case 4: dev_priv->vram_type = NV_MEM_TYPE_GDDR5; break;
-        default:
-                break;
-        }
-
-        dev_priv->vram_rank_B = !!(nv_rd32(dev, 0x100200) & 0x4);
-        dev_priv->vram_size  = nv_rd32(dev, 0x10020c);
-        dev_priv->vram_size |= (dev_priv->vram_size & 0xff) << 32;
-        dev_priv->vram_size &= 0xffffffff00ULL;
-
-        /* IGPs, no funky reordering happens here, they don't have VRAM */
-        if (dev_priv->chipset == 0xaa ||
-            dev_priv->chipset == 0xac ||
-            dev_priv->chipset == 0xaf) {
-                dev_priv->vram_sys_base = (u64)nv_rd32(dev, 0x100e10) << 12;
-                rblock = 4096 >> 12;
-        } else {
-                rblock = nv50_vram_rblock(dev) >> 12;
-        }
-
-        length = (dev_priv->vram_size >> 12) - rsvd_head - rsvd_tail;
-
-        return nouveau_mm_init(&vram->mm, rsvd_head, length, rblock);
-}
-
-void
-nv50_vram_fini(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-
-        nouveau_mm_fini(&vram->mm);
-}
diff --git a/drivers/gpu/drm/nouveau/nv84_bsp.c b/drivers/gpu/drm/nouveau/nv84_bsp.c
deleted file mode 100644
index 74875739bcc0..000000000000
--- a/drivers/gpu/drm/nouveau/nv84_bsp.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2011 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"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
-
-/*XXX: This stub is currently used on NV98+ also, as soon as this becomes
- *     more than just an enable/disable stub this needs to be split out to
- *     nv98_bsp.c...
- */
-
-struct nv84_bsp_engine {
-        struct nouveau_exec_engine base;
-};
-
-static int
-nv84_bsp_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        if (!(nv_rd32(dev, 0x000200) & 0x00008000))
-                return 0;
-
-        nv_mask(dev, 0x000200, 0x00008000, 0x00000000);
-        return 0;
-}
-
-static int
-nv84_bsp_init(struct drm_device *dev, int engine)
-{
-        nv_mask(dev, 0x000200, 0x00008000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00008000, 0x00008000);
-        return 0;
-}
-
-static void
-nv84_bsp_destroy(struct drm_device *dev, int engine)
-{
-        struct nv84_bsp_engine *pbsp = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, BSP);
-
-        kfree(pbsp);
-}
-
-int
-nv84_bsp_create(struct drm_device *dev)
-{
-        struct nv84_bsp_engine *pbsp;
-
-        pbsp = kzalloc(sizeof(*pbsp), GFP_KERNEL);
-        if (!pbsp)
-                return -ENOMEM;
-
-        pbsp->base.destroy = nv84_bsp_destroy;
-        pbsp->base.init = nv84_bsp_init;
-        pbsp->base.fini = nv84_bsp_fini;
-
-        NVOBJ_ENGINE_ADD(dev, BSP, &pbsp->base);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv84_crypt.c b/drivers/gpu/drm/nouveau/nv84_crypt.c
deleted file mode 100644
index bbfcc73b6708..000000000000
--- a/drivers/gpu/drm/nouveau/nv84_crypt.c
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * 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"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
-
-struct nv84_crypt_engine {
-        struct nouveau_exec_engine base;
-};
-
-static int
-nv84_crypt_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ramin = chan->ramin;
-        struct nouveau_gpuobj *ctx;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d\n", chan->id);
-
-        ret = nouveau_gpuobj_new(dev, chan, 256, 0, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &ctx);
-        if (ret)
-                return ret;
-
-        nv_wo32(ramin, 0xa0, 0x00190000);
-        nv_wo32(ramin, 0xa4, ctx->vinst + ctx->size - 1);
-        nv_wo32(ramin, 0xa8, ctx->vinst);
-        nv_wo32(ramin, 0xac, 0);
-        nv_wo32(ramin, 0xb0, 0);
-        nv_wo32(ramin, 0xb4, 0);
-        dev_priv->engine.instmem.flush(dev);
-
-        atomic_inc(&chan->vm->engref[engine]);
-        chan->engctx[engine] = ctx;
-        return 0;
-}
-
-static void
-nv84_crypt_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nouveau_gpuobj *ctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        u32 inst;
-
-        inst  = (chan->ramin->vinst >> 12);
-        inst |= 0x80000000;
-
-        /* mark context as invalid if still on the hardware, not
-         * doing this causes issues the next time PCRYPT is used,
-         * unsurprisingly :)
-         */
-        nv_wr32(dev, 0x10200c, 0x00000000);
-        if (nv_rd32(dev, 0x102188) == inst)
-                nv_mask(dev, 0x102188, 0x80000000, 0x00000000);
-        if (nv_rd32(dev, 0x10218c) == inst)
-                nv_mask(dev, 0x10218c, 0x80000000, 0x00000000);
-        nv_wr32(dev, 0x10200c, 0x00000010);
-
-        nouveau_gpuobj_ref(NULL, &ctx);
-
-        atomic_dec(&chan->vm->engref[engine]);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nv84_crypt_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *obj = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 16, 16, NVOBJ_FLAG_ZERO_FREE, &obj);
-        if (ret)
-                return ret;
-        obj->engine = 5;
-        obj->class  = class;
-
-        nv_wo32(obj, 0x00, class);
-        dev_priv->engine.instmem.flush(dev);
-
-        ret = nouveau_ramht_insert(chan, handle, obj);
-        nouveau_gpuobj_ref(NULL, &obj);
-        return ret;
-}
-
-static void
-nv84_crypt_tlb_flush(struct drm_device *dev, int engine)
-{
-        nv50_vm_flush_engine(dev, 0x0a);
-}
-
-static struct nouveau_bitfield nv84_crypt_intr[] = {
-        { 0x00000001, "INVALID_STATE" },
-        { 0x00000002, "ILLEGAL_MTHD" },
-        { 0x00000004, "ILLEGAL_CLASS" },
-        { 0x00000080, "QUERY" },
-        { 0x00000100, "FAULT" },
-        {}
-};
-
-static void
-nv84_crypt_isr(struct drm_device *dev)
-{
-        u32 stat = nv_rd32(dev, 0x102130);
-        u32 mthd = nv_rd32(dev, 0x102190);
-        u32 data = nv_rd32(dev, 0x102194);
-        u64 inst = (u64)(nv_rd32(dev, 0x102188) & 0x7fffffff) << 12;
-        int show = nouveau_ratelimit();
-        int chid = nv50_graph_isr_chid(dev, inst);
-
-        if (show) {
-                NV_INFO(dev, "PCRYPT:");
-                nouveau_bitfield_print(nv84_crypt_intr, stat);
-                printk(KERN_CONT " ch %d (0x%010llx) mthd 0x%04x data 0x%08x\n",
-                        chid, inst, mthd, data);
-        }
-
-        nv_wr32(dev, 0x102130, stat);
-        nv_wr32(dev, 0x10200c, 0x10);
-
-        nv50_fb_vm_trap(dev, show);
-}
-
-static int
-nv84_crypt_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_wr32(dev, 0x102140, 0x00000000);
-        return 0;
-}
-
-static int
-nv84_crypt_init(struct drm_device *dev, int engine)
-{
-        nv_mask(dev, 0x000200, 0x00004000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00004000, 0x00004000);
-
-        nv_wr32(dev, 0x102130, 0xffffffff);
-        nv_wr32(dev, 0x102140, 0xffffffbf);
-
-        nv_wr32(dev, 0x10200c, 0x00000010);
-        return 0;
-}
-
-static void
-nv84_crypt_destroy(struct drm_device *dev, int engine)
-{
-        struct nv84_crypt_engine *pcrypt = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, CRYPT);
-
-        nouveau_irq_unregister(dev, 14);
-        kfree(pcrypt);
-}
-
-int
-nv84_crypt_create(struct drm_device *dev)
-{
-        struct nv84_crypt_engine *pcrypt;
-
-        pcrypt = kzalloc(sizeof(*pcrypt), GFP_KERNEL);
-        if (!pcrypt)
-                return -ENOMEM;
-
-        pcrypt->base.destroy = nv84_crypt_destroy;
-        pcrypt->base.init = nv84_crypt_init;
-        pcrypt->base.fini = nv84_crypt_fini;
-        pcrypt->base.context_new = nv84_crypt_context_new;
-        pcrypt->base.context_del = nv84_crypt_context_del;
-        pcrypt->base.object_new = nv84_crypt_object_new;
-        pcrypt->base.tlb_flush = nv84_crypt_tlb_flush;
-
-        nouveau_irq_register(dev, 14, nv84_crypt_isr);
-
-        NVOBJ_ENGINE_ADD(dev, CRYPT, &pcrypt->base);
-        NVOBJ_CLASS (dev, 0x74c1, CRYPT);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv84_fence.c b/drivers/gpu/drm/nouveau/nv84_fence.c
index c2f889b0d340..c686650584b6 100644
--- a/drivers/gpu/drm/nouveau/nv84_fence.c
+++ b/drivers/gpu/drm/nouveau/nv84_fence.c
@@ -22,13 +22,17 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include <core/object.h>
+#include <core/class.h>
+
+#include <engine/fifo.h>
+
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fence.h"
 
+#include "nv50_display.h"
+
 struct nv84_fence_chan {
         struct nouveau_fence_chan base;
 };
@@ -42,13 +46,14 @@ static int
 nv84_fence_emit(struct nouveau_fence *fence)
 {
         struct nouveau_channel *chan = fence->channel;
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
         int ret = RING_SPACE(chan, 7);
         if (ret == 0) {
                 BEGIN_NV04(chan, 0, NV11_SUBCHAN_DMA_SEMAPHORE, 1);
                 OUT_RING  (chan, NvSema);
                 BEGIN_NV04(chan, 0, NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH, 4);
-                OUT_RING  (chan, upper_32_bits(chan->id * 16));
-                OUT_RING  (chan, lower_32_bits(chan->id * 16));
+                OUT_RING  (chan, upper_32_bits(fifo->chid * 16));
+                OUT_RING  (chan, lower_32_bits(fifo->chid * 16));
                 OUT_RING  (chan, fence->sequence);
                 OUT_RING  (chan, NV84_SUBCHAN_SEMAPHORE_TRIGGER_WRITE_LONG);
                 FIRE_RING (chan);
@@ -61,13 +66,14 @@ static int
 nv84_fence_sync(struct nouveau_fence *fence,
                 struct nouveau_channel *prev, struct nouveau_channel *chan)
 {
+        struct nouveau_fifo_chan *fifo = (void *)prev->object;
         int ret = RING_SPACE(chan, 7);
         if (ret == 0) {
                 BEGIN_NV04(chan, 0, NV11_SUBCHAN_DMA_SEMAPHORE, 1);
                 OUT_RING  (chan, NvSema);
                 BEGIN_NV04(chan, 0, NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH, 4);
-                OUT_RING  (chan, upper_32_bits(prev->id * 16));
-                OUT_RING  (chan, lower_32_bits(prev->id * 16));
+                OUT_RING  (chan, upper_32_bits(fifo->chid * 16));
+                OUT_RING  (chan, lower_32_bits(fifo->chid * 16));
                 OUT_RING  (chan, fence->sequence);
                 OUT_RING  (chan, NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_GEQUAL);
                 FIRE_RING (chan);
@@ -78,100 +84,99 @@ nv84_fence_sync(struct nouveau_fence *fence,
 static u32
 nv84_fence_read(struct nouveau_channel *chan)
 {
-        struct nv84_fence_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_FENCE);
-        return nv_ro32(priv->mem, chan->id * 16);
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
+        struct nv84_fence_priv *priv = chan->drm->fence;
+        return nv_ro32(priv->mem, fifo->chid * 16);
 }
 
 static void
-nv84_fence_context_del(struct nouveau_channel *chan, int engine)
+nv84_fence_context_del(struct nouveau_channel *chan)
 {
-        struct nv84_fence_chan *fctx = chan->engctx[engine];
+        struct nv84_fence_chan *fctx = chan->fence;
         nouveau_fence_context_del(&fctx->base);
-        chan->engctx[engine] = NULL;
+        chan->fence = NULL;
         kfree(fctx);
 }
 
 static int
-nv84_fence_context_new(struct nouveau_channel *chan, int engine)
+nv84_fence_context_new(struct nouveau_channel *chan)
 {
-        struct nv84_fence_priv *priv = nv_engine(chan->dev, engine);
+        struct drm_device *dev = chan->drm->dev;
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
+        struct nv84_fence_priv *priv = chan->drm->fence;
         struct nv84_fence_chan *fctx;
-        struct nouveau_gpuobj *obj;
-        int ret;
+        struct nouveau_object *object;
+        int ret, i;
 
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
+        fctx = chan->fence = kzalloc(sizeof(*fctx), GFP_KERNEL);
         if (!fctx)
                 return -ENOMEM;
 
         nouveau_fence_context_new(&fctx->base);
 
-        ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_FROM_MEMORY,
-                                     priv->mem->vinst, priv->mem->size,
-                                     NV_MEM_ACCESS_RW,
-                                     NV_MEM_TARGET_VRAM, &obj);
-        if (ret == 0) {
-                ret = nouveau_ramht_insert(chan, NvSema, obj);
-                nouveau_gpuobj_ref(NULL, &obj);
-                nv_wo32(priv->mem, chan->id * 16, 0x00000000);
+        ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
+                                 NvSema, 0x0002,
+                                 &(struct nv_dma_class) {
+                                        .flags = NV_DMA_TARGET_VRAM |
+                                                 NV_DMA_ACCESS_RDWR,
+                                        .start = priv->mem->addr,
+                                        .limit = priv->mem->addr +
+                                                 priv->mem->size - 1,
+                                 }, sizeof(struct nv_dma_class),
+                                 &object);
+
+        /* dma objects for display sync channel semaphore blocks */
+        for (i = 0; !ret && i < dev->mode_config.num_crtc; i++) {
+                struct nouveau_bo *bo = nv50_display_crtc_sema(dev, i);
+
+                ret = nouveau_object_new(nv_object(chan->cli), chan->handle,
+                                         NvEvoSema0 + i, 0x003d,
+                                         &(struct nv_dma_class) {
+                                                .flags = NV_DMA_TARGET_VRAM |
+                                                         NV_DMA_ACCESS_RDWR,
+                                                .start = bo->bo.offset,
+                                                .limit = bo->bo.offset + 0xfff,
+                                         }, sizeof(struct nv_dma_class),
+                                         &object);
         }
 
         if (ret)
-                nv84_fence_context_del(chan, engine);
+                nv84_fence_context_del(chan);
+        nv_wo32(priv->mem, fifo->chid * 16, 0x00000000);
         return ret;
 }
 
-static int
-nv84_fence_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static int
-nv84_fence_init(struct drm_device *dev, int engine)
-{
-        return 0;
-}
-
 static void
-nv84_fence_destroy(struct drm_device *dev, int engine)
+nv84_fence_destroy(struct nouveau_drm *drm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv84_fence_priv *priv = nv_engine(dev, engine);
-
+        struct nv84_fence_priv *priv = drm->fence;
         nouveau_gpuobj_ref(NULL, &priv->mem);
-        dev_priv->eng[engine] = NULL;
+        drm->fence = NULL;
         kfree(priv);
 }
 
 int
-nv84_fence_create(struct drm_device *dev)
+nv84_fence_create(struct nouveau_drm *drm)
 {
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_fifo *pfifo = nouveau_fifo(drm->device);
         struct nv84_fence_priv *priv;
+        u32 chan = pfifo->max + 1;
         int ret;
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = drm->fence = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
-        priv->base.engine.destroy = nv84_fence_destroy;
-        priv->base.engine.init = nv84_fence_init;
-        priv->base.engine.fini = nv84_fence_fini;
-        priv->base.engine.context_new = nv84_fence_context_new;
-        priv->base.engine.context_del = nv84_fence_context_del;
+        priv->base.dtor = nv84_fence_destroy;
+        priv->base.context_new = nv84_fence_context_new;
+        priv->base.context_del = nv84_fence_context_del;
         priv->base.emit = nv84_fence_emit;
         priv->base.sync = nv84_fence_sync;
         priv->base.read = nv84_fence_read;
-        dev_priv->eng[NVOBJ_ENGINE_FENCE] = &priv->base.engine;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 16 * pfifo->channels,
-                                 0x1000, 0, &priv->mem);
-        if (ret)
-                goto out;
 
-out:
+        ret = nouveau_gpuobj_new(drm->device, NULL, chan * 16, 0x1000, 0,
+                                &priv->mem);
         if (ret)
-                nv84_fence_destroy(dev, NVOBJ_ENGINE_FENCE);
+                nv84_fence_destroy(drm);
         return ret;
 }
diff --git a/drivers/gpu/drm/nouveau/nv84_fifo.c b/drivers/gpu/drm/nouveau/nv84_fifo.c
deleted file mode 100644
index c564c5e4c30a..000000000000
--- a/drivers/gpu/drm/nouveau/nv84_fifo.c
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * Copyright (C) 2012 Ben Skeggs.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
-#include "nouveau_vm.h"
-
-struct nv84_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct nouveau_gpuobj *playlist[2];
-        int cur_playlist;
-};
-
-struct nv84_fifo_chan {
-        struct nouveau_fifo_chan base;
-        struct nouveau_gpuobj *ramfc;
-        struct nouveau_gpuobj *cache;
-};
-
-static int
-nv84_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nv84_fifo_priv *priv = nv_engine(chan->dev, engine);
-        struct nv84_fifo_chan *fctx;
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        u64 ib_offset = chan->pushbuf_base + chan->dma.ib_base * 4;
-        u64 instance;
-        unsigned long flags;
-        int ret;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-        atomic_inc(&chan->vm->engref[engine]);
-
-        chan->user = ioremap(pci_resource_start(dev->pdev, 0) +
-                             NV50_USER(chan->id), PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        ret = nouveau_gpuobj_new(dev, chan, 256, 256, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &fctx->ramfc);
-        if (ret)
-                goto error;
-
-        instance = fctx->ramfc->vinst >> 8;
-
-        ret = nouveau_gpuobj_new(dev, chan, 4096, 1024, 0, &fctx->cache);
-        if (ret)
-                goto error;
-
-        nv_wo32(fctx->ramfc, 0x3c, 0x403f6078);
-        nv_wo32(fctx->ramfc, 0x40, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x44, 0x01003fff);
-        nv_wo32(fctx->ramfc, 0x48, chan->pushbuf->cinst >> 4);
-        nv_wo32(fctx->ramfc, 0x50, lower_32_bits(ib_offset));
-        nv_wo32(fctx->ramfc, 0x54, upper_32_bits(ib_offset) |
-                                   drm_order(chan->dma.ib_max + 1) << 16);
-        nv_wo32(fctx->ramfc, 0x60, 0x7fffffff);
-        nv_wo32(fctx->ramfc, 0x78, 0x00000000);
-        nv_wo32(fctx->ramfc, 0x7c, 0x30000001);
-        nv_wo32(fctx->ramfc, 0x80, ((chan->ramht->bits - 9) << 27) |
-                                   (4 << 24) /* SEARCH_FULL */ |
-                                   (chan->ramht->gpuobj->cinst >> 4));
-        nv_wo32(fctx->ramfc, 0x88, fctx->cache->vinst >> 10);
-        nv_wo32(fctx->ramfc, 0x98, chan->ramin->vinst >> 12);
-
-        nv_wo32(chan->ramin, 0x00, chan->id);
-        nv_wo32(chan->ramin, 0x04, fctx->ramfc->vinst >> 8);
-
-        dev_priv->engine.instmem.flush(dev);
-
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_wr32(dev, 0x002600 + (chan->id * 4), 0x80000000 | instance);
-        nv50_fifo_playlist_update(dev);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nv84_fifo_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv84_fifo_chan *fctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        unsigned long flags;
-        u32 save;
-
-        /* remove channel from playlist, will context switch if active */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_mask(dev, 0x002600 + (chan->id * 4), 0x80000000, 0x00000000);
-        nv50_fifo_playlist_update(dev);
-
-        save = nv_mask(dev, 0x002520, 0x0000003f, 0x15);
-
-        /* tell any engines on this channel to unload their contexts */
-        nv_wr32(dev, 0x0032fc, chan->ramin->vinst >> 12);
-        if (!nv_wait_ne(dev, 0x0032fc, 0xffffffff, 0xffffffff))
-                NV_INFO(dev, "PFIFO: channel %d unload timeout\n", chan->id);
-
-        nv_wr32(dev, 0x002520, save);
-
-        nv_wr32(dev, 0x002600 + (chan->id * 4), 0x00000000);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
-
-        /* clean up */
-        if (chan->user) {
-                iounmap(chan->user);
-                chan->user = NULL;
-        }
-
-        nouveau_gpuobj_ref(NULL, &fctx->ramfc);
-        nouveau_gpuobj_ref(NULL, &fctx->cache);
-
-        atomic_dec(&chan->vm->engref[engine]);
-        chan->engctx[engine] = NULL;
-        kfree(fctx);
-}
-
-static int
-nv84_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv84_fifo_chan *fctx;
-        u32 instance;
-        int i;
-
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000100);
-        nv_wr32(dev, 0x00250c, 0x6f3cfc34);
-        nv_wr32(dev, 0x002044, 0x01003fff);
-
-        nv_wr32(dev, 0x002100, 0xffffffff);
-        nv_wr32(dev, 0x002140, 0xffffffff);
-
-        for (i = 0; i < 128; i++) {
-                struct nouveau_channel *chan = dev_priv->channels.ptr[i];
-                if (chan && (fctx = chan->engctx[engine]))
-                        instance = 0x80000000 | fctx->ramfc->vinst >> 8;
-                else
-                        instance = 0x00000000;
-                nv_wr32(dev, 0x002600 + (i * 4), instance);
-        }
-
-        nv50_fifo_playlist_update(dev);
-
-        nv_wr32(dev, 0x003200, 1);
-        nv_wr32(dev, 0x003250, 1);
-        nv_wr32(dev, 0x002500, 1);
-        return 0;
-}
-
-static int
-nv84_fifo_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv84_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-        u32 save;
-
-        /* set playlist length to zero, fifo will unload context */
-        nv_wr32(dev, 0x0032ec, 0);
-
-        save = nv_mask(dev, 0x002520, 0x0000003f, 0x15);
-
-        /* tell all connected engines to unload their contexts */
-        for (i = 0; i < priv->base.channels; i++) {
-                struct nouveau_channel *chan = dev_priv->channels.ptr[i];
-                if (chan)
-                        nv_wr32(dev, 0x0032fc, chan->ramin->vinst >> 12);
-                if (!nv_wait_ne(dev, 0x0032fc, 0xffffffff, 0xffffffff)) {
-                        NV_INFO(dev, "PFIFO: channel %d unload timeout\n", i);
-                        return -EBUSY;
-                }
-        }
-
-        nv_wr32(dev, 0x002520, save);
-        nv_wr32(dev, 0x002140, 0);
-        return 0;
-}
-
-int
-nv84_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv84_fifo_priv *priv;
-        int ret;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nv50_fifo_destroy;
-        priv->base.base.init = nv84_fifo_init;
-        priv->base.base.fini = nv84_fifo_fini;
-        priv->base.base.context_new = nv84_fifo_context_new;
-        priv->base.base.context_del = nv84_fifo_context_del;
-        priv->base.base.tlb_flush = nv50_fifo_tlb_flush;
-        priv->base.channels = 127;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        ret = nouveau_gpuobj_new(dev, NULL, priv->base.channels * 4, 0x1000,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->playlist[0]);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, priv->base.channels * 4, 0x1000,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->playlist[1]);
-        if (ret)
-                goto error;
-
-        nouveau_irq_register(dev, 8, nv04_fifo_isr);
-error:
-        if (ret)
-                priv->base.base.destroy(dev, NVOBJ_ENGINE_FIFO);
-        return ret;
-}
diff --git a/drivers/gpu/drm/nouveau/nv84_vp.c b/drivers/gpu/drm/nouveau/nv84_vp.c
deleted file mode 100644
index 6570d300ab85..000000000000
--- a/drivers/gpu/drm/nouveau/nv84_vp.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2011 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"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
-
-/*XXX: This stub is currently used on NV98+ also, as soon as this becomes
- *     more than just an enable/disable stub this needs to be split out to
- *     nv98_vp.c...
- */
-
-struct nv84_vp_engine {
-        struct nouveau_exec_engine base;
-};
-
-static int
-nv84_vp_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        if (!(nv_rd32(dev, 0x000200) & 0x00020000))
-                return 0;
-
-        nv_mask(dev, 0x000200, 0x00020000, 0x00000000);
-        return 0;
-}
-
-static int
-nv84_vp_init(struct drm_device *dev, int engine)
-{
-        nv_mask(dev, 0x000200, 0x00020000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00020000, 0x00020000);
-        return 0;
-}
-
-static void
-nv84_vp_destroy(struct drm_device *dev, int engine)
-{
-        struct nv84_vp_engine *pvp = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, VP);
-
-        kfree(pvp);
-}
-
-int
-nv84_vp_create(struct drm_device *dev)
-{
-        struct nv84_vp_engine *pvp;
-
-        pvp = kzalloc(sizeof(*pvp), GFP_KERNEL);
-        if (!pvp)
-                return -ENOMEM;
-
-        pvp->base.destroy = nv84_vp_destroy;
-        pvp->base.init = nv84_vp_init;
-        pvp->base.fini = nv84_vp_fini;
-
-        NVOBJ_ENGINE_ADD(dev, VP, &pvp->base);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nv98_crypt.c b/drivers/gpu/drm/nouveau/nv98_crypt.c
deleted file mode 100644
index e25e13fb894e..000000000000
--- a/drivers/gpu/drm/nouveau/nv98_crypt.c
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * Copyright 2011 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"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
-
-#include "nv98_crypt.fuc.h"
-
-struct nv98_crypt_priv {
-        struct nouveau_exec_engine base;
-};
-
-struct nv98_crypt_chan {
-        struct nouveau_gpuobj *mem;
-};
-
-static int
-nv98_crypt_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nv98_crypt_priv *priv = nv_engine(dev, engine);
-        struct nv98_crypt_chan *cctx;
-        int ret;
-
-        cctx = chan->engctx[engine] = kzalloc(sizeof(*cctx), GFP_KERNEL);
-        if (!cctx)
-                return -ENOMEM;
-
-        atomic_inc(&chan->vm->engref[engine]);
-
-        ret = nouveau_gpuobj_new(dev, chan, 256, 0, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &cctx->mem);
-        if (ret)
-                goto error;
-
-        nv_wo32(chan->ramin, 0xa0, 0x00190000);
-        nv_wo32(chan->ramin, 0xa4, cctx->mem->vinst + cctx->mem->size - 1);
-        nv_wo32(chan->ramin, 0xa8, cctx->mem->vinst);
-        nv_wo32(chan->ramin, 0xac, 0x00000000);
-        nv_wo32(chan->ramin, 0xb0, 0x00000000);
-        nv_wo32(chan->ramin, 0xb4, 0x00000000);
-        dev_priv->engine.instmem.flush(dev);
-
-error:
-        if (ret)
-                priv->base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nv98_crypt_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nv98_crypt_chan *cctx = chan->engctx[engine];
-        int i;
-
-        for (i = 0xa0; i < 0xb4; i += 4)
-                nv_wo32(chan->ramin, i, 0x00000000);
-
-        nouveau_gpuobj_ref(NULL, &cctx->mem);
-
-        atomic_dec(&chan->vm->engref[engine]);
-        chan->engctx[engine] = NULL;
-        kfree(cctx);
-}
-
-static int
-nv98_crypt_object_new(struct nouveau_channel *chan, int engine,
-                     u32 handle, u16 class)
-{
-        struct nv98_crypt_chan *cctx = chan->engctx[engine];
-
-        /* fuc engine doesn't need an object, our ramht code does.. */
-        cctx->mem->engine = 5;
-        cctx->mem->class  = class;
-        return nouveau_ramht_insert(chan, handle, cctx->mem);
-}
-
-static void
-nv98_crypt_tlb_flush(struct drm_device *dev, int engine)
-{
-        nv50_vm_flush_engine(dev, 0x0a);
-}
-
-static int
-nv98_crypt_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_mask(dev, 0x000200, 0x00004000, 0x00000000);
-        return 0;
-}
-
-static int
-nv98_crypt_init(struct drm_device *dev, int engine)
-{
-        int i;
-
-        /* reset! */
-        nv_mask(dev, 0x000200, 0x00004000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00004000, 0x00004000);
-
-        /* wait for exit interrupt to signal */
-        nv_wait(dev, 0x087008, 0x00000010, 0x00000010);
-        nv_wr32(dev, 0x087004, 0x00000010);
-
-        /* upload microcode code and data segments */
-        nv_wr32(dev, 0x087ff8, 0x00100000);
-        for (i = 0; i < ARRAY_SIZE(nv98_pcrypt_code); i++)
-                nv_wr32(dev, 0x087ff4, nv98_pcrypt_code[i]);
-
-        nv_wr32(dev, 0x087ff8, 0x00000000);
-        for (i = 0; i < ARRAY_SIZE(nv98_pcrypt_data); i++)
-                nv_wr32(dev, 0x087ff4, nv98_pcrypt_data[i]);
-
-        /* start it running */
-        nv_wr32(dev, 0x08710c, 0x00000000);
-        nv_wr32(dev, 0x087104, 0x00000000); /* ENTRY */
-        nv_wr32(dev, 0x087100, 0x00000002); /* TRIGGER */
-        return 0;
-}
-
-static struct nouveau_enum nv98_crypt_isr_error_name[] = {
-        { 0x0000, "ILLEGAL_MTHD" },
-        { 0x0001, "INVALID_BITFIELD" },
-        { 0x0002, "INVALID_ENUM" },
-        { 0x0003, "QUERY" },
-        {}
-};
-
-static void
-nv98_crypt_isr(struct drm_device *dev)
-{
-        u32 disp = nv_rd32(dev, 0x08701c);
-        u32 stat = nv_rd32(dev, 0x087008) & disp & ~(disp >> 16);
-        u32 inst = nv_rd32(dev, 0x087050) & 0x3fffffff;
-        u32 ssta = nv_rd32(dev, 0x087040) & 0x0000ffff;
-        u32 addr = nv_rd32(dev, 0x087040) >> 16;
-        u32 mthd = (addr & 0x07ff) << 2;
-        u32 subc = (addr & 0x3800) >> 11;
-        u32 data = nv_rd32(dev, 0x087044);
-        int chid = nv50_graph_isr_chid(dev, inst);
-
-        if (stat & 0x00000040) {
-                NV_INFO(dev, "PCRYPT: DISPATCH_ERROR [");
-                nouveau_enum_print(nv98_crypt_isr_error_name, ssta);
-                printk("] ch %d [0x%08x] subc %d mthd 0x%04x data 0x%08x\n",
-                        chid, inst, subc, mthd, data);
-                nv_wr32(dev, 0x087004, 0x00000040);
-                stat &= ~0x00000040;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PCRYPT: unhandled intr 0x%08x\n", stat);
-                nv_wr32(dev, 0x087004, stat);
-        }
-
-        nv50_fb_vm_trap(dev, 1);
-}
-
-static void
-nv98_crypt_destroy(struct drm_device *dev, int engine)
-{
-        struct nv98_crypt_priv *priv = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 14);
-        NVOBJ_ENGINE_DEL(dev, CRYPT);
-        kfree(priv);
-}
-
-int
-nv98_crypt_create(struct drm_device *dev)
-{
-        struct nv98_crypt_priv *priv;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.destroy = nv98_crypt_destroy;
-        priv->base.init = nv98_crypt_init;
-        priv->base.fini = nv98_crypt_fini;
-        priv->base.context_new = nv98_crypt_context_new;
-        priv->base.context_del = nv98_crypt_context_del;
-        priv->base.object_new = nv98_crypt_object_new;
-        priv->base.tlb_flush = nv98_crypt_tlb_flush;
-
-        nouveau_irq_register(dev, 14, nv98_crypt_isr);
-
-        NVOBJ_ENGINE_ADD(dev, CRYPT, &priv->base);
-        NVOBJ_CLASS(dev, 0x88b4, CRYPT);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nva3_copy.c b/drivers/gpu/drm/nouveau/nva3_copy.c
deleted file mode 100644
index 0387dc7f4f42..000000000000
--- a/drivers/gpu/drm/nouveau/nva3_copy.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright 2011 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 <linux/firmware.h>
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
-#include "nva3_copy.fuc.h"
-
-struct nva3_copy_engine {
-        struct nouveau_exec_engine base;
-};
-
-static int
-nva3_copy_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ramin = chan->ramin;
-        struct nouveau_gpuobj *ctx = NULL;
-        int ret;
-
-        NV_DEBUG(dev, "ch%d\n", chan->id);
-
-        ret = nouveau_gpuobj_new(dev, chan, 256, 0, NVOBJ_FLAG_ZERO_ALLOC |
-                                 NVOBJ_FLAG_ZERO_FREE, &ctx);
-        if (ret)
-                return ret;
-
-        nv_wo32(ramin, 0xc0, 0x00190000);
-        nv_wo32(ramin, 0xc4, ctx->vinst + ctx->size - 1);
-        nv_wo32(ramin, 0xc8, ctx->vinst);
-        nv_wo32(ramin, 0xcc, 0x00000000);
-        nv_wo32(ramin, 0xd0, 0x00000000);
-        nv_wo32(ramin, 0xd4, 0x00000000);
-        dev_priv->engine.instmem.flush(dev);
-
-        atomic_inc(&chan->vm->engref[engine]);
-        chan->engctx[engine] = ctx;
-        return 0;
-}
-
-static int
-nva3_copy_object_new(struct nouveau_channel *chan, int engine,
-                     u32 handle, u16 class)
-{
-        struct nouveau_gpuobj *ctx = chan->engctx[engine];
-
-        /* fuc engine doesn't need an object, our ramht code does.. */
-        ctx->engine = 3;
-        ctx->class  = class;
-        return nouveau_ramht_insert(chan, handle, ctx);
-}
-
-static void
-nva3_copy_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nouveau_gpuobj *ctx = chan->engctx[engine];
-        int i;
-
-        for (i = 0xc0; i <= 0xd4; i += 4)
-                nv_wo32(chan->ramin, i, 0x00000000);
-
-        atomic_dec(&chan->vm->engref[engine]);
-        nouveau_gpuobj_ref(NULL, &ctx);
-        chan->engctx[engine] = ctx;
-}
-
-static void
-nva3_copy_tlb_flush(struct drm_device *dev, int engine)
-{
-        nv50_vm_flush_engine(dev, 0x0d);
-}
-
-static int
-nva3_copy_init(struct drm_device *dev, int engine)
-{
-        int i;
-
-        nv_mask(dev, 0x000200, 0x00002000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00002000, 0x00002000);
-        nv_wr32(dev, 0x104014, 0xffffffff); /* disable all interrupts */
-
-        /* upload ucode */
-        nv_wr32(dev, 0x1041c0, 0x01000000);
-        for (i = 0; i < sizeof(nva3_pcopy_data) / 4; i++)
-                nv_wr32(dev, 0x1041c4, nva3_pcopy_data[i]);
-
-        nv_wr32(dev, 0x104180, 0x01000000);
-        for (i = 0; i < sizeof(nva3_pcopy_code) / 4; i++) {
-                if ((i & 0x3f) == 0)
-                        nv_wr32(dev, 0x104188, i >> 6);
-                nv_wr32(dev, 0x104184, nva3_pcopy_code[i]);
-        }
-
-        /* start it running */
-        nv_wr32(dev, 0x10410c, 0x00000000);
-        nv_wr32(dev, 0x104104, 0x00000000); /* ENTRY */
-        nv_wr32(dev, 0x104100, 0x00000002); /* TRIGGER */
-        return 0;
-}
-
-static int
-nva3_copy_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        nv_mask(dev, 0x104048, 0x00000003, 0x00000000);
-        nv_wr32(dev, 0x104014, 0xffffffff);
-        return 0;
-}
-
-static struct nouveau_enum nva3_copy_isr_error_name[] = {
-        { 0x0001, "ILLEGAL_MTHD" },
-        { 0x0002, "INVALID_ENUM" },
-        { 0x0003, "INVALID_BITFIELD" },
-        {}
-};
-
-static void
-nva3_copy_isr(struct drm_device *dev)
-{
-        u32 dispatch = nv_rd32(dev, 0x10401c);
-        u32 stat = nv_rd32(dev, 0x104008) & dispatch & ~(dispatch >> 16);
-        u32 inst = nv_rd32(dev, 0x104050) & 0x3fffffff;
-        u32 ssta = nv_rd32(dev, 0x104040) & 0x0000ffff;
-        u32 addr = nv_rd32(dev, 0x104040) >> 16;
-        u32 mthd = (addr & 0x07ff) << 2;
-        u32 subc = (addr & 0x3800) >> 11;
-        u32 data = nv_rd32(dev, 0x104044);
-        int chid = nv50_graph_isr_chid(dev, inst);
-
-        if (stat & 0x00000040) {
-                NV_INFO(dev, "PCOPY: DISPATCH_ERROR [");
-                nouveau_enum_print(nva3_copy_isr_error_name, ssta);
-                printk("] ch %d [0x%08x] subc %d mthd 0x%04x data 0x%08x\n",
-                        chid, inst, subc, mthd, data);
-                nv_wr32(dev, 0x104004, 0x00000040);
-                stat &= ~0x00000040;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PCOPY: unhandled intr 0x%08x\n", stat);
-                nv_wr32(dev, 0x104004, stat);
-        }
-        nv50_fb_vm_trap(dev, 1);
-}
-
-static void
-nva3_copy_destroy(struct drm_device *dev, int engine)
-{
-        struct nva3_copy_engine *pcopy = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, 22);
-
-        NVOBJ_ENGINE_DEL(dev, COPY0);
-        kfree(pcopy);
-}
-
-int
-nva3_copy_create(struct drm_device *dev)
-{
-        struct nva3_copy_engine *pcopy;
-
-        pcopy = kzalloc(sizeof(*pcopy), GFP_KERNEL);
-        if (!pcopy)
-                return -ENOMEM;
-
-        pcopy->base.destroy = nva3_copy_destroy;
-        pcopy->base.init = nva3_copy_init;
-        pcopy->base.fini = nva3_copy_fini;
-        pcopy->base.context_new = nva3_copy_context_new;
-        pcopy->base.context_del = nva3_copy_context_del;
-        pcopy->base.object_new = nva3_copy_object_new;
-        pcopy->base.tlb_flush = nva3_copy_tlb_flush;
-
-        nouveau_irq_register(dev, 22, nva3_copy_isr);
-
-        NVOBJ_ENGINE_ADD(dev, COPY0, &pcopy->base);
-        NVOBJ_CLASS(dev, 0x85b5, COPY0);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nva3_pm.c b/drivers/gpu/drm/nouveau/nva3_pm.c
index 798829353fb6..3f69e46436cf 100644
--- a/drivers/gpu/drm/nouveau/nva3_pm.c
+++ b/drivers/gpu/drm/nouveau/nva3_pm.c
@@ -23,17 +23,24 @@
  */
 
 #include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_bios.h"
 #include "nouveau_pm.h"
 
+#include <subdev/bios/pll.h>
+#include <subdev/bios.h>
+#include <subdev/clock.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
 static u32 read_clk(struct drm_device *, int, bool);
 static u32 read_pll(struct drm_device *, int, u32);
 
 static u32
 read_vco(struct drm_device *dev, int clk)
 {
-        u32 sctl = nv_rd32(dev, 0x4120 + (clk * 4));
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 sctl = nv_rd32(device, 0x4120 + (clk * 4));
         if ((sctl & 0x00000030) != 0x00000030)
                 return read_pll(dev, 0x41, 0x00e820);
         return read_pll(dev, 0x42, 0x00e8a0);
@@ -42,26 +49,27 @@ read_vco(struct drm_device *dev, int clk)
 static u32
 read_clk(struct drm_device *dev, int clk, bool ignore_en)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u32 sctl, sdiv, sclk;
 
         /* refclk for the 0xe8xx plls is a fixed frequency */
         if (clk >= 0x40) {
-                if (dev_priv->chipset == 0xaf) {
+                if (nv_device(drm->device)->chipset == 0xaf) {
                         /* no joke.. seriously.. sigh.. */
-                        return nv_rd32(dev, 0x00471c) * 1000;
+                        return nv_rd32(device, 0x00471c) * 1000;
                 }
 
-                return dev_priv->crystal;
+                return device->crystal;
         }
 
-        sctl = nv_rd32(dev, 0x4120 + (clk * 4));
+        sctl = nv_rd32(device, 0x4120 + (clk * 4));
         if (!ignore_en && !(sctl & 0x00000100))
                 return 0;
 
         switch (sctl & 0x00003000) {
         case 0x00000000:
-                return dev_priv->crystal;
+                return device->crystal;
         case 0x00002000:
                 if (sctl & 0x00000040)
                         return 108000;
@@ -78,12 +86,13 @@ read_clk(struct drm_device *dev, int clk, bool ignore_en)
 static u32
 read_pll(struct drm_device *dev, int clk, u32 pll)
 {
-        u32 ctrl = nv_rd32(dev, pll + 0);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ctrl = nv_rd32(device, pll + 0);
         u32 sclk = 0, P = 1, N = 1, M = 1;
 
         if (!(ctrl & 0x00000008)) {
                 if (ctrl & 0x00000001) {
-                        u32 coef = nv_rd32(dev, pll + 4);
+                        u32 coef = nv_rd32(device, pll + 4);
                         M = (coef & 0x000000ff) >> 0;
                         N = (coef & 0x0000ff00) >> 8;
                         P = (coef & 0x003f0000) >> 16;
@@ -111,7 +120,10 @@ struct creg {
 static int
 calc_clk(struct drm_device *dev, int clk, u32 pll, u32 khz, struct creg *reg)
 {
-        struct pll_lims limits;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nvbios_pll limits;
         u32 oclk, sclk, sdiv;
         int P, N, M, diff;
         int ret;
@@ -119,7 +131,7 @@ calc_clk(struct drm_device *dev, int clk, u32 pll, u32 khz, struct creg *reg)
         reg->pll = 0;
         reg->clk = 0;
         if (!khz) {
-                NV_DEBUG(dev, "no clock for 0x%04x/0x%02x\n", pll, clk);
+                NV_DEBUG(drm, "no clock for 0x%04x/0x%02x\n", pll, clk);
                 return 0;
         }
 
@@ -154,14 +166,14 @@ calc_clk(struct drm_device *dev, int clk, u32 pll, u32 khz, struct creg *reg)
                 }
 
                 if (!pll) {
-                        NV_ERROR(dev, "bad freq %02x: %d %d\n", clk, khz, sclk);
+                        NV_ERROR(drm, "bad freq %02x: %d %d\n", clk, khz, sclk);
                         return -ERANGE;
                 }
 
                 break;
         }
 
-        ret = get_pll_limits(dev, pll, &limits);
+        ret = nvbios_pll_parse(bios, pll, &limits);
         if (ret)
                 return ret;
 
@@ -171,54 +183,60 @@ calc_clk(struct drm_device *dev, int clk, u32 pll, u32 khz, struct creg *reg)
 
         ret = nva3_calc_pll(dev, &limits, khz, &N, NULL, &M, &P);
         if (ret >= 0) {
-                reg->clk = nv_rd32(dev, 0x4120 + (clk * 4));
+                reg->clk = nv_rd32(device, 0x4120 + (clk * 4));
                 reg->pll = (P << 16) | (N << 8) | M;
         }
+
         return ret;
 }
 
 static void
 prog_pll(struct drm_device *dev, int clk, u32 pll, struct creg *reg)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         const u32 src0 = 0x004120 + (clk * 4);
         const u32 src1 = 0x004160 + (clk * 4);
         const u32 ctrl = pll + 0;
         const u32 coef = pll + 4;
 
         if (!reg->clk && !reg->pll) {
-                NV_DEBUG(dev, "no clock for %02x\n", clk);
+                NV_DEBUG(drm, "no clock for %02x\n", clk);
                 return;
         }
 
         if (reg->pll) {
-                nv_mask(dev, src0, 0x00000101, 0x00000101);
-                nv_wr32(dev, coef, reg->pll);
-                nv_mask(dev, ctrl, 0x00000015, 0x00000015);
-                nv_mask(dev, ctrl, 0x00000010, 0x00000000);
-                nv_wait(dev, ctrl, 0x00020000, 0x00020000);
-                nv_mask(dev, ctrl, 0x00000010, 0x00000010);
-                nv_mask(dev, ctrl, 0x00000008, 0x00000000);
-                nv_mask(dev, src1, 0x00000100, 0x00000000);
-                nv_mask(dev, src1, 0x00000001, 0x00000000);
+                nv_mask(device, src0, 0x00000101, 0x00000101);
+                nv_wr32(device, coef, reg->pll);
+                nv_mask(device, ctrl, 0x00000015, 0x00000015);
+                nv_mask(device, ctrl, 0x00000010, 0x00000000);
+                nv_wait(device, ctrl, 0x00020000, 0x00020000);
+                nv_mask(device, ctrl, 0x00000010, 0x00000010);
+                nv_mask(device, ctrl, 0x00000008, 0x00000000);
+                nv_mask(device, src1, 0x00000100, 0x00000000);
+                nv_mask(device, src1, 0x00000001, 0x00000000);
         } else {
-                nv_mask(dev, src1, 0x003f3141, 0x00000101 | reg->clk);
-                nv_mask(dev, ctrl, 0x00000018, 0x00000018);
+                nv_mask(device, src1, 0x003f3141, 0x00000101 | reg->clk);
+                nv_mask(device, ctrl, 0x00000018, 0x00000018);
                 udelay(20);
-                nv_mask(dev, ctrl, 0x00000001, 0x00000000);
-                nv_mask(dev, src0, 0x00000100, 0x00000000);
-                nv_mask(dev, src0, 0x00000001, 0x00000000);
+                nv_mask(device, ctrl, 0x00000001, 0x00000000);
+                nv_mask(device, src0, 0x00000100, 0x00000000);
+                nv_mask(device, src0, 0x00000001, 0x00000000);
         }
 }
 
 static void
 prog_clk(struct drm_device *dev, int clk, struct creg *reg)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
         if (!reg->clk) {
-                NV_DEBUG(dev, "no clock for %02x\n", clk);
+                NV_DEBUG(drm, "no clock for %02x\n", clk);
                 return;
         }
 
-        nv_mask(dev, 0x004120 + (clk * 4), 0x003f3141, 0x00000101 | reg->clk);
+        nv_mask(device, 0x004120 + (clk * 4), 0x003f3141, 0x00000101 | reg->clk);
 }
 
 int
@@ -309,10 +327,11 @@ static bool
 nva3_pm_grcp_idle(void *data)
 {
         struct drm_device *dev = data;
+        struct nouveau_device *device = nouveau_dev(dev);
 
-        if (!(nv_rd32(dev, 0x400304) & 0x00000001))
+        if (!(nv_rd32(device, 0x400304) & 0x00000001))
                 return true;
-        if (nv_rd32(dev, 0x400308) == 0x0050001c)
+        if (nv_rd32(device, 0x400308) == 0x0050001c)
                 return true;
         return false;
 }
@@ -320,85 +339,91 @@ nva3_pm_grcp_idle(void *data)
 static void
 mclk_precharge(struct nouveau_mem_exec_func *exec)
 {
-        nv_wr32(exec->dev, 0x1002d4, 0x00000001);
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        nv_wr32(device, 0x1002d4, 0x00000001);
 }
 
 static void
 mclk_refresh(struct nouveau_mem_exec_func *exec)
 {
-        nv_wr32(exec->dev, 0x1002d0, 0x00000001);
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        nv_wr32(device, 0x1002d0, 0x00000001);
 }
 
 static void
 mclk_refresh_auto(struct nouveau_mem_exec_func *exec, bool enable)
 {
-        nv_wr32(exec->dev, 0x100210, enable ? 0x80000000 : 0x00000000);
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        nv_wr32(device, 0x100210, enable ? 0x80000000 : 0x00000000);
 }
 
 static void
 mclk_refresh_self(struct nouveau_mem_exec_func *exec, bool enable)
 {
-        nv_wr32(exec->dev, 0x1002dc, enable ? 0x00000001 : 0x00000000);
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        nv_wr32(device, 0x1002dc, enable ? 0x00000001 : 0x00000000);
 }
 
 static void
 mclk_wait(struct nouveau_mem_exec_func *exec, u32 nsec)
 {
-        volatile u32 post = nv_rd32(exec->dev, 0); (void)post;
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        volatile u32 post = nv_rd32(device, 0); (void)post;
         udelay((nsec + 500) / 1000);
 }
 
 static u32
 mclk_mrg(struct nouveau_mem_exec_func *exec, int mr)
 {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         if (mr <= 1)
-                return nv_rd32(exec->dev, 0x1002c0 + ((mr - 0) * 4));
+                return nv_rd32(device, 0x1002c0 + ((mr - 0) * 4));
         if (mr <= 3)
-                return nv_rd32(exec->dev, 0x1002e0 + ((mr - 2) * 4));
+                return nv_rd32(device, 0x1002e0 + ((mr - 2) * 4));
         return 0;
 }
 
 static void
 mclk_mrs(struct nouveau_mem_exec_func *exec, int mr, u32 data)
 {
-        struct drm_nouveau_private *dev_priv = exec->dev->dev_private;
-
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
         if (mr <= 1) {
-                if (dev_priv->vram_rank_B)
-                        nv_wr32(exec->dev, 0x1002c8 + ((mr - 0) * 4), data);
-                nv_wr32(exec->dev, 0x1002c0 + ((mr - 0) * 4), data);
+                if (pfb->ram.ranks > 1)
+                        nv_wr32(device, 0x1002c8 + ((mr - 0) * 4), data);
+                nv_wr32(device, 0x1002c0 + ((mr - 0) * 4), data);
         } else
         if (mr <= 3) {
-                if (dev_priv->vram_rank_B)
-                        nv_wr32(exec->dev, 0x1002e8 + ((mr - 2) * 4), data);
-                nv_wr32(exec->dev, 0x1002e0 + ((mr - 2) * 4), data);
+                if (pfb->ram.ranks > 1)
+                        nv_wr32(device, 0x1002e8 + ((mr - 2) * 4), data);
+                nv_wr32(device, 0x1002e0 + ((mr - 2) * 4), data);
         }
 }
 
 static void
 mclk_clock_set(struct nouveau_mem_exec_func *exec)
 {
-        struct drm_device *dev = exec->dev;
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         struct nva3_pm_state *info = exec->priv;
         u32 ctrl;
 
-        ctrl = nv_rd32(dev, 0x004000);
+        ctrl = nv_rd32(device, 0x004000);
         if (!(ctrl & 0x00000008) && info->mclk.pll) {
-                nv_wr32(dev, 0x004000, (ctrl |=  0x00000008));
-                nv_mask(dev, 0x1110e0, 0x00088000, 0x00088000);
-                nv_wr32(dev, 0x004018, 0x00001000);
-                nv_wr32(dev, 0x004000, (ctrl &= ~0x00000001));
-                nv_wr32(dev, 0x004004, info->mclk.pll);
-                nv_wr32(dev, 0x004000, (ctrl |=  0x00000001));
+                nv_wr32(device, 0x004000, (ctrl |=  0x00000008));
+                nv_mask(device, 0x1110e0, 0x00088000, 0x00088000);
+                nv_wr32(device, 0x004018, 0x00001000);
+                nv_wr32(device, 0x004000, (ctrl &= ~0x00000001));
+                nv_wr32(device, 0x004004, info->mclk.pll);
+                nv_wr32(device, 0x004000, (ctrl |=  0x00000001));
                 udelay(64);
-                nv_wr32(dev, 0x004018, 0x00005000 | info->r004018);
+                nv_wr32(device, 0x004018, 0x00005000 | info->r004018);
                 udelay(20);
         } else
         if (!info->mclk.pll) {
-                nv_mask(dev, 0x004168, 0x003f3040, info->mclk.clk);
-                nv_wr32(dev, 0x004000, (ctrl |= 0x00000008));
-                nv_mask(dev, 0x1110e0, 0x00088000, 0x00088000);
-                nv_wr32(dev, 0x004018, 0x0000d000 | info->r004018);
+                nv_mask(device, 0x004168, 0x003f3040, info->mclk.clk);
+                nv_wr32(device, 0x004000, (ctrl |= 0x00000008));
+                nv_mask(device, 0x1110e0, 0x00088000, 0x00088000);
+                nv_wr32(device, 0x004018, 0x0000d000 | info->r004018);
         }
 
         if (info->rammap) {
@@ -410,67 +435,68 @@ mclk_clock_set(struct nouveau_mem_exec_func *exec)
                                      (info->ramcfg[3] & 0x0f) << 16 |
                                      (info->ramcfg[9] & 0x0f) |
                                      0x80000000;
-                        nv_wr32(dev, 0x1005a0, unk5a0);
-                        nv_wr32(dev, 0x1005a4, unk5a4);
-                        nv_wr32(dev, 0x10f804, unk804);
-                        nv_mask(dev, 0x10053c, 0x00001000, 0x00000000);
+                        nv_wr32(device, 0x1005a0, unk5a0);
+                        nv_wr32(device, 0x1005a4, unk5a4);
+                        nv_wr32(device, 0x10f804, unk804);
+                        nv_mask(device, 0x10053c, 0x00001000, 0x00000000);
                 } else {
-                        nv_mask(dev, 0x10053c, 0x00001000, 0x00001000);
-                        nv_mask(dev, 0x10f804, 0x80000000, 0x00000000);
-                        nv_mask(dev, 0x100760, 0x22222222, info->r100760);
-                        nv_mask(dev, 0x1007a0, 0x22222222, info->r100760);
-                        nv_mask(dev, 0x1007e0, 0x22222222, info->r100760);
+                        nv_mask(device, 0x10053c, 0x00001000, 0x00001000);
+                        nv_mask(device, 0x10f804, 0x80000000, 0x00000000);
+                        nv_mask(device, 0x100760, 0x22222222, info->r100760);
+                        nv_mask(device, 0x1007a0, 0x22222222, info->r100760);
+                        nv_mask(device, 0x1007e0, 0x22222222, info->r100760);
                 }
         }
 
         if (info->mclk.pll) {
-                nv_mask(dev, 0x1110e0, 0x00088000, 0x00011000);
-                nv_wr32(dev, 0x004000, (ctrl &= ~0x00000008));
+                nv_mask(device, 0x1110e0, 0x00088000, 0x00011000);
+                nv_wr32(device, 0x004000, (ctrl &= ~0x00000008));
         }
 }
 
 static void
 mclk_timing_set(struct nouveau_mem_exec_func *exec)
 {
-        struct drm_device *dev = exec->dev;
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         struct nva3_pm_state *info = exec->priv;
         struct nouveau_pm_level *perflvl = info->perflvl;
         int i;
 
         for (i = 0; i < 9; i++)
-                nv_wr32(dev, 0x100220 + (i * 4), perflvl->timing.reg[i]);
+                nv_wr32(device, 0x100220 + (i * 4), perflvl->timing.reg[i]);
 
         if (info->ramcfg) {
                 u32 data = (info->ramcfg[2] & 0x08) ? 0x00000000 : 0x00001000;
-                nv_mask(dev, 0x100200, 0x00001000, data);
+                nv_mask(device, 0x100200, 0x00001000, data);
         }
 
         if (info->ramcfg) {
-                u32 unk714 = nv_rd32(dev, 0x100714) & ~0xf0000010;
-                u32 unk718 = nv_rd32(dev, 0x100718) & ~0x00000100;
-                u32 unk71c = nv_rd32(dev, 0x10071c) & ~0x00000100;
+                u32 unk714 = nv_rd32(device, 0x100714) & ~0xf0000010;
+                u32 unk718 = nv_rd32(device, 0x100718) & ~0x00000100;
+                u32 unk71c = nv_rd32(device, 0x10071c) & ~0x00000100;
                 if ( (info->ramcfg[2] & 0x20))
                         unk714 |= 0xf0000000;
                 if (!(info->ramcfg[2] & 0x04))
                         unk714 |= 0x00000010;
-                nv_wr32(dev, 0x100714, unk714);
+                nv_wr32(device, 0x100714, unk714);
 
                 if (info->ramcfg[2] & 0x01)
                         unk71c |= 0x00000100;
-                nv_wr32(dev, 0x10071c, unk71c);
+                nv_wr32(device, 0x10071c, unk71c);
 
                 if (info->ramcfg[2] & 0x02)
                         unk718 |= 0x00000100;
-                nv_wr32(dev, 0x100718, unk718);
+                nv_wr32(device, 0x100718, unk718);
 
                 if (info->ramcfg[2] & 0x10)
-                        nv_wr32(dev, 0x111100, 0x48000000); /*XXX*/
+                        nv_wr32(device, 0x111100, 0x48000000); /*XXX*/
         }
 }
 
 static void
 prog_mem(struct drm_device *dev, struct nva3_pm_state *info)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nouveau_mem_exec_func exec = {
                 .dev = dev,
                 .precharge = mclk_precharge,
@@ -492,17 +518,17 @@ prog_mem(struct drm_device *dev, struct nva3_pm_state *info)
                 info->r100760 = 0x22222222;
         }
 
-        ctrl = nv_rd32(dev, 0x004000);
+        ctrl = nv_rd32(device, 0x004000);
         if (ctrl & 0x00000008) {
                 if (info->mclk.pll) {
-                        nv_mask(dev, 0x004128, 0x00000101, 0x00000101);
-                        nv_wr32(dev, 0x004004, info->mclk.pll);
-                        nv_wr32(dev, 0x004000, (ctrl |= 0x00000001));
-                        nv_wr32(dev, 0x004000, (ctrl &= 0xffffffef));
-                        nv_wait(dev, 0x004000, 0x00020000, 0x00020000);
-                        nv_wr32(dev, 0x004000, (ctrl |= 0x00000010));
-                        nv_wr32(dev, 0x004018, 0x00005000 | info->r004018);
-                        nv_wr32(dev, 0x004000, (ctrl |= 0x00000004));
+                        nv_mask(device, 0x004128, 0x00000101, 0x00000101);
+                        nv_wr32(device, 0x004004, info->mclk.pll);
+                        nv_wr32(device, 0x004000, (ctrl |= 0x00000001));
+                        nv_wr32(device, 0x004000, (ctrl &= 0xffffffef));
+                        nv_wait(device, 0x004000, 0x00020000, 0x00020000);
+                        nv_wr32(device, 0x004000, (ctrl |= 0x00000010));
+                        nv_wr32(device, 0x004018, 0x00005000 | info->r004018);
+                        nv_wr32(device, 0x004000, (ctrl |= 0x00000004));
                 }
         } else {
                 u32 ssel = 0x00000101;
@@ -510,68 +536,67 @@ prog_mem(struct drm_device *dev, struct nva3_pm_state *info)
                         ssel |= info->mclk.clk;
                 else
                         ssel |= 0x00080000; /* 324MHz, shouldn't matter... */
-                nv_mask(dev, 0x004168, 0x003f3141, ctrl);
+                nv_mask(device, 0x004168, 0x003f3141, ctrl);
         }
 
         if (info->ramcfg) {
                 if (info->ramcfg[2] & 0x10) {
-                        nv_mask(dev, 0x111104, 0x00000600, 0x00000000);
+                        nv_mask(device, 0x111104, 0x00000600, 0x00000000);
                 } else {
-                        nv_mask(dev, 0x111100, 0x40000000, 0x40000000);
-                        nv_mask(dev, 0x111104, 0x00000180, 0x00000000);
+                        nv_mask(device, 0x111100, 0x40000000, 0x40000000);
+                        nv_mask(device, 0x111104, 0x00000180, 0x00000000);
                 }
         }
         if (info->rammap && !(info->rammap[4] & 0x02))
-                nv_mask(dev, 0x100200, 0x00000800, 0x00000000);
-        nv_wr32(dev, 0x611200, 0x00003300);
+                nv_mask(device, 0x100200, 0x00000800, 0x00000000);
+        nv_wr32(device, 0x611200, 0x00003300);
         if (!(info->ramcfg[2] & 0x10))
-                nv_wr32(dev, 0x111100, 0x4c020000); /*XXX*/
+                nv_wr32(device, 0x111100, 0x4c020000); /*XXX*/
 
         nouveau_mem_exec(&exec, info->perflvl);
 
-        nv_wr32(dev, 0x611200, 0x00003330);
+        nv_wr32(device, 0x611200, 0x00003330);
         if (info->rammap && (info->rammap[4] & 0x02))
-                nv_mask(dev, 0x100200, 0x00000800, 0x00000800);
+                nv_mask(device, 0x100200, 0x00000800, 0x00000800);
         if (info->ramcfg) {
                 if (info->ramcfg[2] & 0x10) {
-                        nv_mask(dev, 0x111104, 0x00000180, 0x00000180);
-                        nv_mask(dev, 0x111100, 0x40000000, 0x00000000);
+                        nv_mask(device, 0x111104, 0x00000180, 0x00000180);
+                        nv_mask(device, 0x111100, 0x40000000, 0x00000000);
                 } else {
-                        nv_mask(dev, 0x111104, 0x00000600, 0x00000600);
+                        nv_mask(device, 0x111104, 0x00000600, 0x00000600);
                 }
         }
 
         if (info->mclk.pll) {
-                nv_mask(dev, 0x004168, 0x00000001, 0x00000000);
-                nv_mask(dev, 0x004168, 0x00000100, 0x00000000);
+                nv_mask(device, 0x004168, 0x00000001, 0x00000000);
+                nv_mask(device, 0x004168, 0x00000100, 0x00000000);
         } else {
-                nv_mask(dev, 0x004000, 0x00000001, 0x00000000);
-                nv_mask(dev, 0x004128, 0x00000001, 0x00000000);
-                nv_mask(dev, 0x004128, 0x00000100, 0x00000000);
+                nv_mask(device, 0x004000, 0x00000001, 0x00000000);
+                nv_mask(device, 0x004128, 0x00000001, 0x00000000);
+                nv_mask(device, 0x004128, 0x00000100, 0x00000000);
         }
 }
 
 int
 nva3_pm_clocks_set(struct drm_device *dev, void *pre_state)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nva3_pm_state *info = pre_state;
-        unsigned long flags;
         int ret = -EAGAIN;
 
         /* prevent any new grctx switches from starting */
-        spin_lock_irqsave(&dev_priv->context_switch_lock, flags);
-        nv_wr32(dev, 0x400324, 0x00000000);
-        nv_wr32(dev, 0x400328, 0x0050001c); /* wait flag 0x1c */
+        nv_wr32(device, 0x400324, 0x00000000);
+        nv_wr32(device, 0x400328, 0x0050001c); /* wait flag 0x1c */
         /* wait for any pending grctx switches to complete */
-        if (!nv_wait_cb(dev, nva3_pm_grcp_idle, dev)) {
-                NV_ERROR(dev, "pm: ctxprog didn't go idle\n");
+        if (!nv_wait_cb(device, nva3_pm_grcp_idle, dev)) {
+                NV_ERROR(drm, "pm: ctxprog didn't go idle\n");
                 goto cleanup;
         }
         /* freeze PFIFO */
-        nv_mask(dev, 0x002504, 0x00000001, 0x00000001);
-        if (!nv_wait(dev, 0x002504, 0x00000010, 0x00000010)) {
-                NV_ERROR(dev, "pm: fifo didn't go idle\n");
+        nv_mask(device, 0x002504, 0x00000001, 0x00000001);
+        if (!nv_wait(device, 0x002504, 0x00000010, 0x00000010)) {
+                NV_ERROR(drm, "pm: fifo didn't go idle\n");
                 goto cleanup;
         }
 
@@ -587,14 +612,13 @@ nva3_pm_clocks_set(struct drm_device *dev, void *pre_state)
 
 cleanup:
         /* unfreeze PFIFO */
-        nv_mask(dev, 0x002504, 0x00000001, 0x00000000);
+        nv_mask(device, 0x002504, 0x00000001, 0x00000000);
         /* restore ctxprog to normal */
-        nv_wr32(dev, 0x400324, 0x00000000);
-        nv_wr32(dev, 0x400328, 0x0070009c); /* set flag 0x1c */
+        nv_wr32(device, 0x400324, 0x00000000);
+        nv_wr32(device, 0x400328, 0x0070009c); /* set flag 0x1c */
         /* unblock it if necessary */
-        if (nv_rd32(dev, 0x400308) == 0x0050001c)
-                nv_mask(dev, 0x400824, 0x10000000, 0x10000000);
-        spin_unlock_irqrestore(&dev_priv->context_switch_lock, flags);
+        if (nv_rd32(device, 0x400308) == 0x0050001c)
+                nv_mask(device, 0x400824, 0x10000000, 0x10000000);
         kfree(info);
         return ret;
 }
diff --git a/drivers/gpu/drm/nouveau/nvc0_copy.c b/drivers/gpu/drm/nouveau/nvc0_copy.c
deleted file mode 100644
index dddf006f6d88..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_copy.c
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * Copyright 2011 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 <linux/firmware.h>
-#include "drmP.h"
-#include "nouveau_drv.h"
-#include "nouveau_util.h"
-#include "nouveau_vm.h"
-#include "nouveau_ramht.h"
-#include "nvc0_copy.fuc.h"
-
-struct nvc0_copy_engine {
-        struct nouveau_exec_engine base;
-        u32 irq;
-        u32 pmc;
-        u32 fuc;
-        u32 ctx;
-};
-
-static int
-nvc0_copy_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct nvc0_copy_engine *pcopy = nv_engine(chan->dev, engine);
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj *ramin = chan->ramin;
-        struct nouveau_gpuobj *ctx = NULL;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 256, 256,
-                                 NVOBJ_FLAG_VM | NVOBJ_FLAG_VM_USER |
-                                 NVOBJ_FLAG_ZERO_ALLOC, &ctx);
-        if (ret)
-                return ret;
-
-        nv_wo32(ramin, pcopy->ctx + 0, lower_32_bits(ctx->linst));
-        nv_wo32(ramin, pcopy->ctx + 4, upper_32_bits(ctx->linst));
-        dev_priv->engine.instmem.flush(dev);
-
-        chan->engctx[engine] = ctx;
-        return 0;
-}
-
-static int
-nvc0_copy_object_new(struct nouveau_channel *chan, int engine,
-                     u32 handle, u16 class)
-{
-        return 0;
-}
-
-static void
-nvc0_copy_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nvc0_copy_engine *pcopy = nv_engine(chan->dev, engine);
-        struct nouveau_gpuobj *ctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-        u32 inst;
-
-        inst  = (chan->ramin->vinst >> 12);
-        inst |= 0x40000000;
-
-        /* disable fifo access */
-        nv_wr32(dev, pcopy->fuc + 0x048, 0x00000000);
-        /* mark channel as unloaded if it's currently active */
-        if (nv_rd32(dev, pcopy->fuc + 0x050) == inst)
-                nv_mask(dev, pcopy->fuc + 0x050, 0x40000000, 0x00000000);
-        /* mark next channel as invalid if it's about to be loaded */
-        if (nv_rd32(dev, pcopy->fuc + 0x054) == inst)
-                nv_mask(dev, pcopy->fuc + 0x054, 0x40000000, 0x00000000);
-        /* restore fifo access */
-        nv_wr32(dev, pcopy->fuc + 0x048, 0x00000003);
-
-        nv_wo32(chan->ramin, pcopy->ctx + 0, 0x00000000);
-        nv_wo32(chan->ramin, pcopy->ctx + 4, 0x00000000);
-        nouveau_gpuobj_ref(NULL, &ctx);
-
-        chan->engctx[engine] = ctx;
-}
-
-static int
-nvc0_copy_init(struct drm_device *dev, int engine)
-{
-        struct nvc0_copy_engine *pcopy = nv_engine(dev, engine);
-        int i;
-
-        nv_mask(dev, 0x000200, pcopy->pmc, 0x00000000);
-        nv_mask(dev, 0x000200, pcopy->pmc, pcopy->pmc);
-        nv_wr32(dev, pcopy->fuc + 0x014, 0xffffffff);
-
-        nv_wr32(dev, pcopy->fuc + 0x1c0, 0x01000000);
-        for (i = 0; i < sizeof(nvc0_pcopy_data) / 4; i++)
-                nv_wr32(dev, pcopy->fuc + 0x1c4, nvc0_pcopy_data[i]);
-
-        nv_wr32(dev, pcopy->fuc + 0x180, 0x01000000);
-        for (i = 0; i < sizeof(nvc0_pcopy_code) / 4; i++) {
-                if ((i & 0x3f) == 0)
-                        nv_wr32(dev, pcopy->fuc + 0x188, i >> 6);
-                nv_wr32(dev, pcopy->fuc + 0x184, nvc0_pcopy_code[i]);
-        }
-
-        nv_wr32(dev, pcopy->fuc + 0x084, engine - NVOBJ_ENGINE_COPY0);
-        nv_wr32(dev, pcopy->fuc + 0x10c, 0x00000000);
-        nv_wr32(dev, pcopy->fuc + 0x104, 0x00000000); /* ENTRY */
-        nv_wr32(dev, pcopy->fuc + 0x100, 0x00000002); /* TRIGGER */
-        return 0;
-}
-
-static int
-nvc0_copy_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        struct nvc0_copy_engine *pcopy = nv_engine(dev, engine);
-
-        nv_mask(dev, pcopy->fuc + 0x048, 0x00000003, 0x00000000);
-
-        /* trigger fuc context unload */
-        nv_wait(dev, pcopy->fuc + 0x008, 0x0000000c, 0x00000000);
-        nv_mask(dev, pcopy->fuc + 0x054, 0x40000000, 0x00000000);
-        nv_wr32(dev, pcopy->fuc + 0x000, 0x00000008);
-        nv_wait(dev, pcopy->fuc + 0x008, 0x00000008, 0x00000000);
-
-        nv_wr32(dev, pcopy->fuc + 0x014, 0xffffffff);
-        return 0;
-}
-
-static struct nouveau_enum nvc0_copy_isr_error_name[] = {
-        { 0x0001, "ILLEGAL_MTHD" },
-        { 0x0002, "INVALID_ENUM" },
-        { 0x0003, "INVALID_BITFIELD" },
-        {}
-};
-
-static void
-nvc0_copy_isr(struct drm_device *dev, int engine)
-{
-        struct nvc0_copy_engine *pcopy = nv_engine(dev, engine);
-        u32 disp = nv_rd32(dev, pcopy->fuc + 0x01c);
-        u32 stat = nv_rd32(dev, pcopy->fuc + 0x008) & disp & ~(disp >> 16);
-        u64 inst = (u64)(nv_rd32(dev, pcopy->fuc + 0x050) & 0x0fffffff) << 12;
-        u32 chid = nvc0_graph_isr_chid(dev, inst);
-        u32 ssta = nv_rd32(dev, pcopy->fuc + 0x040) & 0x0000ffff;
-        u32 addr = nv_rd32(dev, pcopy->fuc + 0x040) >> 16;
-        u32 mthd = (addr & 0x07ff) << 2;
-        u32 subc = (addr & 0x3800) >> 11;
-        u32 data = nv_rd32(dev, pcopy->fuc + 0x044);
-
-        if (stat & 0x00000040) {
-                NV_INFO(dev, "PCOPY: DISPATCH_ERROR [");
-                nouveau_enum_print(nvc0_copy_isr_error_name, ssta);
-                printk("] ch %d [0x%010llx] subc %d mthd 0x%04x data 0x%08x\n",
-                        chid, inst, subc, mthd, data);
-                nv_wr32(dev, pcopy->fuc + 0x004, 0x00000040);
-                stat &= ~0x00000040;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PCOPY: unhandled intr 0x%08x\n", stat);
-                nv_wr32(dev, pcopy->fuc + 0x004, stat);
-        }
-}
-
-static void
-nvc0_copy_isr_0(struct drm_device *dev)
-{
-        nvc0_copy_isr(dev, NVOBJ_ENGINE_COPY0);
-}
-
-static void
-nvc0_copy_isr_1(struct drm_device *dev)
-{
-        nvc0_copy_isr(dev, NVOBJ_ENGINE_COPY1);
-}
-
-static void
-nvc0_copy_destroy(struct drm_device *dev, int engine)
-{
-        struct nvc0_copy_engine *pcopy = nv_engine(dev, engine);
-
-        nouveau_irq_unregister(dev, pcopy->irq);
-
-        if (engine == NVOBJ_ENGINE_COPY0)
-                NVOBJ_ENGINE_DEL(dev, COPY0);
-        else
-                NVOBJ_ENGINE_DEL(dev, COPY1);
-        kfree(pcopy);
-}
-
-int
-nvc0_copy_create(struct drm_device *dev, int engine)
-{
-        struct nvc0_copy_engine *pcopy;
-
-        pcopy = kzalloc(sizeof(*pcopy), GFP_KERNEL);
-        if (!pcopy)
-                return -ENOMEM;
-
-        pcopy->base.destroy = nvc0_copy_destroy;
-        pcopy->base.init = nvc0_copy_init;
-        pcopy->base.fini = nvc0_copy_fini;
-        pcopy->base.context_new = nvc0_copy_context_new;
-        pcopy->base.context_del = nvc0_copy_context_del;
-        pcopy->base.object_new = nvc0_copy_object_new;
-
-        if (engine == 0) {
-                pcopy->irq = 5;
-                pcopy->pmc = 0x00000040;
-                pcopy->fuc = 0x104000;
-                pcopy->ctx = 0x0230;
-                nouveau_irq_register(dev, pcopy->irq, nvc0_copy_isr_0);
-                NVOBJ_ENGINE_ADD(dev, COPY0, &pcopy->base);
-                NVOBJ_CLASS(dev, 0x90b5, COPY0);
-        } else {
-                pcopy->irq = 6;
-                pcopy->pmc = 0x00000080;
-                pcopy->fuc = 0x105000;
-                pcopy->ctx = 0x0240;
-                nouveau_irq_register(dev, pcopy->irq, nvc0_copy_isr_1);
-                NVOBJ_ENGINE_ADD(dev, COPY1, &pcopy->base);
-                NVOBJ_CLASS(dev, 0x90b8, COPY1);
-        }
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nvc0_fb.c b/drivers/gpu/drm/nouveau/nvc0_fb.c
deleted file mode 100644
index f704e942372e..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_fb.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright 2011 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 "drm.h"
-#include "nouveau_drv.h"
-#include "nouveau_drm.h"
-
-struct nvc0_fb_priv {
-        struct page *r100c10_page;
-        dma_addr_t r100c10;
-};
-
-static inline void
-nvc0_mfb_subp_isr(struct drm_device *dev, int unit, int subp)
-{
-        u32 subp_base = 0x141000 + (unit * 0x2000) + (subp * 0x400);
-        u32 stat = nv_rd32(dev, subp_base + 0x020);
-
-        if (stat) {
-                NV_INFO(dev, "PMFB%d_SUBP%d: 0x%08x\n", unit, subp, stat);
-                nv_wr32(dev, subp_base + 0x020, stat);
-        }
-}
-
-static void
-nvc0_mfb_isr(struct drm_device *dev)
-{
-        u32 units = nv_rd32(dev, 0x00017c);
-        while (units) {
-                u32 subp, unit = ffs(units) - 1;
-                for (subp = 0; subp < 2; subp++)
-                        nvc0_mfb_subp_isr(dev, unit, subp);
-                units &= ~(1 << unit);
-        }
-
-        /* we do something horribly wrong and upset PMFB a lot, so mask off
-         * interrupts from it after the first one until it's fixed
-         */
-        nv_mask(dev, 0x000640, 0x02000000, 0x00000000);
-}
-
-static void
-nvc0_fb_destroy(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        struct nvc0_fb_priv *priv = pfb->priv;
-
-        nouveau_irq_unregister(dev, 25);
-
-        if (priv->r100c10_page) {
-                pci_unmap_page(dev->pdev, priv->r100c10, PAGE_SIZE,
-                               PCI_DMA_BIDIRECTIONAL);
-                __free_page(priv->r100c10_page);
-        }
-
-        kfree(priv);
-        pfb->priv = NULL;
-}
-
-static int
-nvc0_fb_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
-        struct nvc0_fb_priv *priv;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-        pfb->priv = priv;
-
-        priv->r100c10_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
-        if (!priv->r100c10_page) {
-                nvc0_fb_destroy(dev);
-                return -ENOMEM;
-        }
-
-        priv->r100c10 = pci_map_page(dev->pdev, priv->r100c10_page, 0,
-                                     PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-        if (pci_dma_mapping_error(dev->pdev, priv->r100c10)) {
-                nvc0_fb_destroy(dev);
-                return -EFAULT;
-        }
-
-        nouveau_irq_register(dev, 25, nvc0_mfb_isr);
-        return 0;
-}
-
-int
-nvc0_fb_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_fb_priv *priv;
-        int ret;
-
-        if (!dev_priv->engine.fb.priv) {
-                ret = nvc0_fb_create(dev);
-                if (ret)
-                        return ret;
-        }
-        priv = dev_priv->engine.fb.priv;
-
-        nv_wr32(dev, 0x100c10, priv->r100c10 >> 8);
-        return 0;
-}
-
-void
-nvc0_fb_takedown(struct drm_device *dev)
-{
-        nvc0_fb_destroy(dev);
-}
diff --git a/drivers/gpu/drm/nouveau/nvc0_fbcon.c b/drivers/gpu/drm/nouveau/nvc0_fbcon.c
index 797159e7b7a6..9dcd30f3e1e0 100644
--- a/drivers/gpu/drm/nouveau/nvc0_fbcon.c
+++ b/drivers/gpu/drm/nouveau/nvc0_fbcon.c
@@ -22,20 +22,16 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fbcon.h"
-#include "nouveau_mm.h"
 
 int
 nvc0_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         ret = RING_SPACE(chan, rect->rop == ROP_COPY ? 7 : 11);
@@ -69,9 +65,8 @@ int
 nvc0_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         int ret;
 
         ret = RING_SPACE(chan, 12);
@@ -98,9 +93,8 @@ int
 nvc0_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct nouveau_fbdev *nfbdev = info->par;
-        struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
+        struct nouveau_drm *drm = nouveau_drm(nfbdev->dev);
+        struct nouveau_channel *chan = drm->channel;
         uint32_t width, dwords, *data = (uint32_t *)image->data;
         uint32_t mask = ~(~0 >> (32 - info->var.bits_per_pixel));
         uint32_t *palette = info->pseudo_palette;
@@ -157,12 +151,14 @@ nvc0_fbcon_accel_init(struct fb_info *info)
 {
         struct nouveau_fbdev *nfbdev = info->par;
         struct drm_device *dev = nfbdev->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = dev_priv->channel;
         struct nouveau_framebuffer *fb = &nfbdev->nouveau_fb;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_channel *chan = drm->channel;
+        struct nouveau_object *object;
         int ret, format;
 
-        ret = nouveau_gpuobj_gr_new(chan, 0x902d, 0x902d);
+        ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, Nv2D,
+                                 0x902d, NULL, 0, &object);
         if (ret)
                 return ret;
 
@@ -202,9 +198,6 @@ nvc0_fbcon_accel_init(struct fb_info *info)
 
         BEGIN_NVC0(chan, NvSub2D, 0x0000, 1);
         OUT_RING  (chan, 0x0000902d);
-        BEGIN_NVC0(chan, NvSub2D, 0x0104, 2);
-        OUT_RING  (chan, upper_32_bits(chan->notifier_vma.offset));
-        OUT_RING  (chan, lower_32_bits(chan->notifier_vma.offset));
         BEGIN_NVC0(chan, NvSub2D, 0x0290, 1);
         OUT_RING  (chan, 0);
         BEGIN_NVC0(chan, NvSub2D, 0x0888, 1);
diff --git a/drivers/gpu/drm/nouveau/nvc0_fence.c b/drivers/gpu/drm/nouveau/nvc0_fence.c
index 47ab388a606e..53299eac9676 100644
--- a/drivers/gpu/drm/nouveau/nvc0_fence.c
+++ b/drivers/gpu/drm/nouveau/nvc0_fence.c
@@ -22,29 +22,44 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include <core/object.h>
+#include <core/client.h>
+#include <core/class.h>
+
+#include <engine/fifo.h>
+
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
-#include "nouveau_fifo.h"
-#include "nouveau_ramht.h"
 #include "nouveau_fence.h"
 
+#include "nv50_display.h"
+
 struct nvc0_fence_priv {
         struct nouveau_fence_priv base;
         struct nouveau_bo *bo;
+        u32 *suspend;
 };
 
 struct nvc0_fence_chan {
         struct nouveau_fence_chan base;
         struct nouveau_vma vma;
+        struct nouveau_vma dispc_vma[4];
 };
 
+u64
+nvc0_fence_crtc(struct nouveau_channel *chan, int crtc)
+{
+        struct nvc0_fence_chan *fctx = chan->fence;
+        return fctx->dispc_vma[crtc].offset;
+}
+
 static int
 nvc0_fence_emit(struct nouveau_fence *fence)
 {
         struct nouveau_channel *chan = fence->channel;
-        struct nvc0_fence_chan *fctx = chan->engctx[NVOBJ_ENGINE_FENCE];
-        u64 addr = fctx->vma.offset + chan->id * 16;
+        struct nvc0_fence_chan *fctx = chan->fence;
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
+        u64 addr = fctx->vma.offset + fifo->chid * 16;
         int ret;
 
         ret = RING_SPACE(chan, 5);
@@ -64,8 +79,9 @@ static int
 nvc0_fence_sync(struct nouveau_fence *fence,
                 struct nouveau_channel *prev, struct nouveau_channel *chan)
 {
-        struct nvc0_fence_chan *fctx = chan->engctx[NVOBJ_ENGINE_FENCE];
-        u64 addr = fctx->vma.offset + prev->id * 16;
+        struct nvc0_fence_chan *fctx = chan->fence;
+        struct nouveau_fifo_chan *fifo = (void *)prev->object;
+        u64 addr = fctx->vma.offset + fifo->chid * 16;
         int ret;
 
         ret = RING_SPACE(chan, 5);
@@ -85,91 +101,135 @@ nvc0_fence_sync(struct nouveau_fence *fence,
 static u32
 nvc0_fence_read(struct nouveau_channel *chan)
 {
-        struct nvc0_fence_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_FENCE);
-        return nouveau_bo_rd32(priv->bo, chan->id * 16/4);
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
+        struct nvc0_fence_priv *priv = chan->drm->fence;
+        return nouveau_bo_rd32(priv->bo, fifo->chid * 16/4);
 }
 
 static void
-nvc0_fence_context_del(struct nouveau_channel *chan, int engine)
+nvc0_fence_context_del(struct nouveau_channel *chan)
 {
-        struct nvc0_fence_priv *priv = nv_engine(chan->dev, engine);
-        struct nvc0_fence_chan *fctx = chan->engctx[engine];
+        struct drm_device *dev = chan->drm->dev;
+        struct nvc0_fence_priv *priv = chan->drm->fence;
+        struct nvc0_fence_chan *fctx = chan->fence;
+        int i;
+
+        if (nv_device(chan->drm->device)->card_type >= NV_D0) {
+                for (i = 0; i < dev->mode_config.num_crtc; i++) {
+                        struct nouveau_bo *bo = nvd0_display_crtc_sema(dev, i);
+                        nouveau_bo_vma_del(bo, &fctx->dispc_vma[i]);
+                }
+        } else
+        if (nv_device(chan->drm->device)->card_type >= NV_50) {
+                for (i = 0; i < dev->mode_config.num_crtc; i++) {
+                        struct nouveau_bo *bo = nv50_display_crtc_sema(dev, i);
+                        nouveau_bo_vma_del(bo, &fctx->dispc_vma[i]);
+                }
+        }
 
         nouveau_bo_vma_del(priv->bo, &fctx->vma);
         nouveau_fence_context_del(&fctx->base);
-        chan->engctx[engine] = NULL;
+        chan->fence = NULL;
         kfree(fctx);
 }
 
 static int
-nvc0_fence_context_new(struct nouveau_channel *chan, int engine)
+nvc0_fence_context_new(struct nouveau_channel *chan)
 {
-        struct nvc0_fence_priv *priv = nv_engine(chan->dev, engine);
+        struct nouveau_fifo_chan *fifo = (void *)chan->object;
+        struct nouveau_client *client = nouveau_client(fifo);
+        struct nvc0_fence_priv *priv = chan->drm->fence;
         struct nvc0_fence_chan *fctx;
-        int ret;
+        int ret, i;
 
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
+        fctx = chan->fence = kzalloc(sizeof(*fctx), GFP_KERNEL);
         if (!fctx)
                 return -ENOMEM;
 
         nouveau_fence_context_new(&fctx->base);
 
-        ret = nouveau_bo_vma_add(priv->bo, chan->vm, &fctx->vma);
+        ret = nouveau_bo_vma_add(priv->bo, client->vm, &fctx->vma);
         if (ret)
-                nvc0_fence_context_del(chan, engine);
+                nvc0_fence_context_del(chan);
+
+        /* map display semaphore buffers into channel's vm */
+        for (i = 0; !ret && i < chan->drm->dev->mode_config.num_crtc; i++) {
+                struct nouveau_bo *bo;
+                if (nv_device(chan->drm->device)->card_type >= NV_D0)
+                        bo = nvd0_display_crtc_sema(chan->drm->dev, i);
+                else
+                        bo = nv50_display_crtc_sema(chan->drm->dev, i);
 
-        nouveau_bo_wr32(priv->bo, chan->id * 16/4, 0x00000000);
+                ret = nouveau_bo_vma_add(bo, client->vm, &fctx->dispc_vma[i]);
+        }
+
+        nouveau_bo_wr32(priv->bo, fifo->chid * 16/4, 0x00000000);
         return ret;
 }
 
-static int
-nvc0_fence_fini(struct drm_device *dev, int engine, bool suspend)
+static bool
+nvc0_fence_suspend(struct nouveau_drm *drm)
 {
-        return 0;
+        struct nouveau_fifo *pfifo = nouveau_fifo(drm->device);
+        struct nvc0_fence_priv *priv = drm->fence;
+        int i;
+
+        priv->suspend = vmalloc((pfifo->max + 1) * sizeof(u32));
+        if (priv->suspend) {
+                for (i = 0; i <= pfifo->max; i++)
+                        priv->suspend[i] = nouveau_bo_rd32(priv->bo, i);
+        }
+
+        return priv->suspend != NULL;
 }
 
-static int
-nvc0_fence_init(struct drm_device *dev, int engine)
+static void
+nvc0_fence_resume(struct nouveau_drm *drm)
 {
-        return 0;
+        struct nouveau_fifo *pfifo = nouveau_fifo(drm->device);
+        struct nvc0_fence_priv *priv = drm->fence;
+        int i;
+
+        if (priv->suspend) {
+                for (i = 0; i <= pfifo->max; i++)
+                        nouveau_bo_wr32(priv->bo, i, priv->suspend[i]);
+                vfree(priv->suspend);
+                priv->suspend = NULL;
+        }
 }
 
 static void
-nvc0_fence_destroy(struct drm_device *dev, int engine)
+nvc0_fence_destroy(struct nouveau_drm *drm)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_fence_priv *priv = nv_engine(dev, engine);
-
+        struct nvc0_fence_priv *priv = drm->fence;
         nouveau_bo_unmap(priv->bo);
         nouveau_bo_ref(NULL, &priv->bo);
-        dev_priv->eng[engine] = NULL;
+        drm->fence = NULL;
         kfree(priv);
 }
 
 int
-nvc0_fence_create(struct drm_device *dev)
+nvc0_fence_create(struct nouveau_drm *drm)
 {
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_fifo *pfifo = nouveau_fifo(drm->device);
         struct nvc0_fence_priv *priv;
         int ret;
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = drm->fence = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
-        priv->base.engine.destroy = nvc0_fence_destroy;
-        priv->base.engine.init = nvc0_fence_init;
-        priv->base.engine.fini = nvc0_fence_fini;
-        priv->base.engine.context_new = nvc0_fence_context_new;
-        priv->base.engine.context_del = nvc0_fence_context_del;
+        priv->base.dtor = nvc0_fence_destroy;
+        priv->base.suspend = nvc0_fence_suspend;
+        priv->base.resume = nvc0_fence_resume;
+        priv->base.context_new = nvc0_fence_context_new;
+        priv->base.context_del = nvc0_fence_context_del;
         priv->base.emit = nvc0_fence_emit;
         priv->base.sync = nvc0_fence_sync;
         priv->base.read = nvc0_fence_read;
-        dev_priv->eng[NVOBJ_ENGINE_FENCE] = &priv->base.engine;
 
-        ret = nouveau_bo_new(dev, 16 * pfifo->channels, 0, TTM_PL_FLAG_VRAM,
-                             0, 0, NULL, &priv->bo);
+        ret = nouveau_bo_new(drm->dev, 16 * (pfifo->max + 1), 0,
+                             TTM_PL_FLAG_VRAM, 0, 0, NULL, &priv->bo);
         if (ret == 0) {
                 ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
                 if (ret == 0)
@@ -179,6 +239,6 @@ nvc0_fence_create(struct drm_device *dev)
         }
 
         if (ret)
-                nvc0_fence_destroy(dev, NVOBJ_ENGINE_FENCE);
+                nvc0_fence_destroy(drm);
         return ret;
 }
diff --git a/drivers/gpu/drm/nouveau/nvc0_fifo.c b/drivers/gpu/drm/nouveau/nvc0_fifo.c
deleted file mode 100644
index 7d85553d518c..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_fifo.c
+++ /dev/null
@@ -1,476 +0,0 @@
-/*
- * 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"
-#include "nouveau_mm.h"
-#include "nouveau_fifo.h"
-
-static void nvc0_fifo_isr(struct drm_device *);
-
-struct nvc0_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct nouveau_gpuobj *playlist[2];
-        int cur_playlist;
-        struct nouveau_vma user_vma;
-        int spoon_nr;
-};
-
-struct nvc0_fifo_chan {
-        struct nouveau_fifo_chan base;
-        struct nouveau_gpuobj *user;
-};
-
-static void
-nvc0_fifo_playlist_update(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nvc0_fifo_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct nouveau_gpuobj *cur;
-        int i, p;
-
-        cur = priv->playlist[priv->cur_playlist];
-        priv->cur_playlist = !priv->cur_playlist;
-
-        for (i = 0, p = 0; i < 128; i++) {
-                if (!(nv_rd32(dev, 0x3004 + (i * 8)) & 1))
-                        continue;
-                nv_wo32(cur, p + 0, i);
-                nv_wo32(cur, p + 4, 0x00000004);
-                p += 8;
-        }
-        pinstmem->flush(dev);
-
-        nv_wr32(dev, 0x002270, cur->vinst >> 12);
-        nv_wr32(dev, 0x002274, 0x01f00000 | (p >> 3));
-        if (!nv_wait(dev, 0x00227c, 0x00100000, 0x00000000))
-                NV_ERROR(dev, "PFIFO - playlist update failed\n");
-}
-
-static int
-nvc0_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nvc0_fifo_priv *priv = nv_engine(dev, engine);
-        struct nvc0_fifo_chan *fctx;
-        u64 ib_virt = chan->pushbuf_base + chan->dma.ib_base * 4;
-        int ret, i;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-
-        chan->user = ioremap_wc(pci_resource_start(dev->pdev, 1) +
-                                priv->user_vma.offset + (chan->id * 0x1000),
-                                PAGE_SIZE);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        /* allocate vram for control regs, map into polling area */
-        ret = nouveau_gpuobj_new(dev, NULL, 0x1000, 0x1000,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &fctx->user);
-        if (ret)
-                goto error;
-
-        nouveau_vm_map_at(&priv->user_vma, chan->id * 0x1000,
-                          *(struct nouveau_mem **)fctx->user->node);
-
-        for (i = 0; i < 0x100; i += 4)
-                nv_wo32(chan->ramin, i, 0x00000000);
-        nv_wo32(chan->ramin, 0x08, lower_32_bits(fctx->user->vinst));
-        nv_wo32(chan->ramin, 0x0c, upper_32_bits(fctx->user->vinst));
-        nv_wo32(chan->ramin, 0x10, 0x0000face);
-        nv_wo32(chan->ramin, 0x30, 0xfffff902);
-        nv_wo32(chan->ramin, 0x48, lower_32_bits(ib_virt));
-        nv_wo32(chan->ramin, 0x4c, drm_order(chan->dma.ib_max + 1) << 16 |
-                                   upper_32_bits(ib_virt));
-        nv_wo32(chan->ramin, 0x54, 0x00000002);
-        nv_wo32(chan->ramin, 0x84, 0x20400000);
-        nv_wo32(chan->ramin, 0x94, 0x30000001);
-        nv_wo32(chan->ramin, 0x9c, 0x00000100);
-        nv_wo32(chan->ramin, 0xa4, 0x1f1f1f1f);
-        nv_wo32(chan->ramin, 0xa8, 0x1f1f1f1f);
-        nv_wo32(chan->ramin, 0xac, 0x0000001f);
-        nv_wo32(chan->ramin, 0xb8, 0xf8000000);
-        nv_wo32(chan->ramin, 0xf8, 0x10003080); /* 0x002310 */
-        nv_wo32(chan->ramin, 0xfc, 0x10000010); /* 0x002350 */
-        pinstmem->flush(dev);
-
-        nv_wr32(dev, 0x003000 + (chan->id * 8), 0xc0000000 |
-                                                (chan->ramin->vinst >> 12));
-        nv_wr32(dev, 0x003004 + (chan->id * 8), 0x001f0001);
-        nvc0_fifo_playlist_update(dev);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nvc0_fifo_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nvc0_fifo_chan *fctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-
-        nv_mask(dev, 0x003004 + (chan->id * 8), 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x002634, chan->id);
-        if (!nv_wait(dev, 0x0002634, 0xffffffff, chan->id))
-                NV_WARN(dev, "0x2634 != chid: 0x%08x\n", nv_rd32(dev, 0x2634));
-        nvc0_fifo_playlist_update(dev);
-        nv_wr32(dev, 0x003000 + (chan->id * 8), 0x00000000);
-
-        nouveau_gpuobj_ref(NULL, &fctx->user);
-        if (chan->user) {
-                iounmap(chan->user);
-                chan->user = NULL;
-        }
-
-        chan->engctx[engine] = NULL;
-        kfree(fctx);
-}
-
-static int
-nvc0_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_fifo_priv *priv = nv_engine(dev, engine);
-        struct nouveau_channel *chan;
-        int i;
-
-        /* reset PFIFO, enable all available PSUBFIFO areas */
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000100);
-        nv_wr32(dev, 0x000204, 0xffffffff);
-        nv_wr32(dev, 0x002204, 0xffffffff);
-
-        priv->spoon_nr = hweight32(nv_rd32(dev, 0x002204));
-        NV_DEBUG(dev, "PFIFO: %d subfifo(s)\n", priv->spoon_nr);
-
-        /* assign engines to subfifos */
-        if (priv->spoon_nr >= 3) {
-                nv_wr32(dev, 0x002208, ~(1 << 0)); /* PGRAPH */
-                nv_wr32(dev, 0x00220c, ~(1 << 1)); /* PVP */
-                nv_wr32(dev, 0x002210, ~(1 << 1)); /* PPP */
-                nv_wr32(dev, 0x002214, ~(1 << 1)); /* PBSP */
-                nv_wr32(dev, 0x002218, ~(1 << 2)); /* PCE0 */
-                nv_wr32(dev, 0x00221c, ~(1 << 1)); /* PCE1 */
-        }
-
-        /* PSUBFIFO[n] */
-        for (i = 0; i < priv->spoon_nr; i++) {
-                nv_mask(dev, 0x04013c + (i * 0x2000), 0x10000100, 0x00000000);
-                nv_wr32(dev, 0x040108 + (i * 0x2000), 0xffffffff); /* INTR */
-                nv_wr32(dev, 0x04010c + (i * 0x2000), 0xfffffeff); /* INTR_EN */
-        }
-
-        nv_mask(dev, 0x002200, 0x00000001, 0x00000001);
-        nv_wr32(dev, 0x002254, 0x10000000 | priv->user_vma.offset >> 12);
-
-        nv_wr32(dev, 0x002a00, 0xffffffff); /* clears PFIFO.INTR bit 30 */
-        nv_wr32(dev, 0x002100, 0xffffffff);
-        nv_wr32(dev, 0x002140, 0xbfffffff);
-
-        /* restore PFIFO context table */
-        for (i = 0; i < 128; i++) {
-                chan = dev_priv->channels.ptr[i];
-                if (!chan || !chan->engctx[engine])
-                        continue;
-
-                nv_wr32(dev, 0x003000 + (i * 8), 0xc0000000 |
-                                                 (chan->ramin->vinst >> 12));
-                nv_wr32(dev, 0x003004 + (i * 8), 0x001f0001);
-        }
-        nvc0_fifo_playlist_update(dev);
-
-        return 0;
-}
-
-static int
-nvc0_fifo_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        int i;
-
-        for (i = 0; i < 128; i++) {
-                if (!(nv_rd32(dev, 0x003004 + (i * 8)) & 1))
-                        continue;
-
-                nv_mask(dev, 0x003004 + (i * 8), 0x00000001, 0x00000000);
-                nv_wr32(dev, 0x002634, i);
-                if (!nv_wait(dev, 0x002634, 0xffffffff, i)) {
-                        NV_INFO(dev, "PFIFO: kick ch %d failed: 0x%08x\n",
-                                i, nv_rd32(dev, 0x002634));
-                        return -EBUSY;
-                }
-        }
-
-        nv_wr32(dev, 0x002140, 0x00000000);
-        return 0;
-}
-
-
-struct nouveau_enum nvc0_fifo_fault_unit[] = {
-        { 0x00, "PGRAPH" },
-        { 0x03, "PEEPHOLE" },
-        { 0x04, "BAR1" },
-        { 0x05, "BAR3" },
-        { 0x07, "PFIFO" },
-        { 0x10, "PBSP" },
-        { 0x11, "PPPP" },
-        { 0x13, "PCOUNTER" },
-        { 0x14, "PVP" },
-        { 0x15, "PCOPY0" },
-        { 0x16, "PCOPY1" },
-        { 0x17, "PDAEMON" },
-        {}
-};
-
-struct nouveau_enum nvc0_fifo_fault_reason[] = {
-        { 0x00, "PT_NOT_PRESENT" },
-        { 0x01, "PT_TOO_SHORT" },
-        { 0x02, "PAGE_NOT_PRESENT" },
-        { 0x03, "VM_LIMIT_EXCEEDED" },
-        { 0x04, "NO_CHANNEL" },
-        { 0x05, "PAGE_SYSTEM_ONLY" },
-        { 0x06, "PAGE_READ_ONLY" },
-        { 0x0a, "COMPRESSED_SYSRAM" },
-        { 0x0c, "INVALID_STORAGE_TYPE" },
-        {}
-};
-
-struct nouveau_enum nvc0_fifo_fault_hubclient[] = {
-        { 0x01, "PCOPY0" },
-        { 0x02, "PCOPY1" },
-        { 0x04, "DISPATCH" },
-        { 0x05, "CTXCTL" },
-        { 0x06, "PFIFO" },
-        { 0x07, "BAR_READ" },
-        { 0x08, "BAR_WRITE" },
-        { 0x0b, "PVP" },
-        { 0x0c, "PPPP" },
-        { 0x0d, "PBSP" },
-        { 0x11, "PCOUNTER" },
-        { 0x12, "PDAEMON" },
-        { 0x14, "CCACHE" },
-        { 0x15, "CCACHE_POST" },
-        {}
-};
-
-struct nouveau_enum nvc0_fifo_fault_gpcclient[] = {
-        { 0x01, "TEX" },
-        { 0x0c, "ESETUP" },
-        { 0x0e, "CTXCTL" },
-        { 0x0f, "PROP" },
-        {}
-};
-
-struct nouveau_bitfield nvc0_fifo_subfifo_intr[] = {
-/*      { 0x00008000, "" }      seen with null ib push */
-        { 0x00200000, "ILLEGAL_MTHD" },
-        { 0x00800000, "EMPTY_SUBC" },
-        {}
-};
-
-static void
-nvc0_fifo_isr_vm_fault(struct drm_device *dev, int unit)
-{
-        u32 inst = nv_rd32(dev, 0x2800 + (unit * 0x10));
-        u32 valo = nv_rd32(dev, 0x2804 + (unit * 0x10));
-        u32 vahi = nv_rd32(dev, 0x2808 + (unit * 0x10));
-        u32 stat = nv_rd32(dev, 0x280c + (unit * 0x10));
-        u32 client = (stat & 0x00001f00) >> 8;
-
-        NV_INFO(dev, "PFIFO: %s fault at 0x%010llx [",
-                (stat & 0x00000080) ? "write" : "read", (u64)vahi << 32 | valo);
-        nouveau_enum_print(nvc0_fifo_fault_reason, stat & 0x0000000f);
-        printk("] from ");
-        nouveau_enum_print(nvc0_fifo_fault_unit, unit);
-        if (stat & 0x00000040) {
-                printk("/");
-                nouveau_enum_print(nvc0_fifo_fault_hubclient, client);
-        } else {
-                printk("/GPC%d/", (stat & 0x1f000000) >> 24);
-                nouveau_enum_print(nvc0_fifo_fault_gpcclient, client);
-        }
-        printk(" on channel 0x%010llx\n", (u64)inst << 12);
-}
-
-static int
-nvc0_fifo_page_flip(struct drm_device *dev, u32 chid)
-{
-        struct nvc0_fifo_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = NULL;
-        unsigned long flags;
-        int ret = -EINVAL;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        if (likely(chid >= 0 && chid < priv->base.channels)) {
-                chan = dev_priv->channels.ptr[chid];
-                if (likely(chan))
-                        ret = nouveau_finish_page_flip(chan, NULL);
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return ret;
-}
-
-static void
-nvc0_fifo_isr_subfifo_intr(struct drm_device *dev, int unit)
-{
-        u32 stat = nv_rd32(dev, 0x040108 + (unit * 0x2000));
-        u32 addr = nv_rd32(dev, 0x0400c0 + (unit * 0x2000));
-        u32 data = nv_rd32(dev, 0x0400c4 + (unit * 0x2000));
-        u32 chid = nv_rd32(dev, 0x040120 + (unit * 0x2000)) & 0x7f;
-        u32 subc = (addr & 0x00070000);
-        u32 mthd = (addr & 0x00003ffc);
-        u32 show = stat;
-
-        if (stat & 0x00200000) {
-                if (mthd == 0x0054) {
-                        if (!nvc0_fifo_page_flip(dev, chid))
-                                show &= ~0x00200000;
-                }
-        }
-
-        if (show) {
-                NV_INFO(dev, "PFIFO%d:", unit);
-                nouveau_bitfield_print(nvc0_fifo_subfifo_intr, show);
-                NV_INFO(dev, "PFIFO%d: ch %d subc %d mthd 0x%04x data 0x%08x\n",
-                             unit, chid, subc, mthd, data);
-        }
-
-        nv_wr32(dev, 0x0400c0 + (unit * 0x2000), 0x80600008);
-        nv_wr32(dev, 0x040108 + (unit * 0x2000), stat);
-}
-
-static void
-nvc0_fifo_isr(struct drm_device *dev)
-{
-        u32 stat = nv_rd32(dev, 0x002100);
-
-        if (stat & 0x00000100) {
-                NV_INFO(dev, "PFIFO: unknown status 0x00000100\n");
-                nv_wr32(dev, 0x002100, 0x00000100);
-                stat &= ~0x00000100;
-        }
-
-        if (stat & 0x10000000) {
-                u32 units = nv_rd32(dev, 0x00259c);
-                u32 u = units;
-
-                while (u) {
-                        int i = ffs(u) - 1;
-                        nvc0_fifo_isr_vm_fault(dev, i);
-                        u &= ~(1 << i);
-                }
-
-                nv_wr32(dev, 0x00259c, units);
-                stat &= ~0x10000000;
-        }
-
-        if (stat & 0x20000000) {
-                u32 units = nv_rd32(dev, 0x0025a0);
-                u32 u = units;
-
-                while (u) {
-                        int i = ffs(u) - 1;
-                        nvc0_fifo_isr_subfifo_intr(dev, i);
-                        u &= ~(1 << i);
-                }
-
-                nv_wr32(dev, 0x0025a0, units);
-                stat &= ~0x20000000;
-        }
-
-        if (stat & 0x40000000) {
-                NV_INFO(dev, "PFIFO: unknown status 0x40000000\n");
-                nv_mask(dev, 0x002a00, 0x00000000, 0x00000000);
-                stat &= ~0x40000000;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PFIFO: unhandled status 0x%08x\n", stat);
-                nv_wr32(dev, 0x002100, stat);
-                nv_wr32(dev, 0x002140, 0);
-        }
-}
-
-static void
-nvc0_fifo_destroy(struct drm_device *dev, int engine)
-{
-        struct nvc0_fifo_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nouveau_vm_put(&priv->user_vma);
-        nouveau_gpuobj_ref(NULL, &priv->playlist[1]);
-        nouveau_gpuobj_ref(NULL, &priv->playlist[0]);
-
-        dev_priv->eng[engine] = NULL;
-        kfree(priv);
-}
-
-int
-nvc0_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_fifo_priv *priv;
-        int ret;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nvc0_fifo_destroy;
-        priv->base.base.init = nvc0_fifo_init;
-        priv->base.base.fini = nvc0_fifo_fini;
-        priv->base.base.context_new = nvc0_fifo_context_new;
-        priv->base.base.context_del = nvc0_fifo_context_del;
-        priv->base.channels = 128;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 4096, 4096, 0, &priv->playlist[0]);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 4096, 4096, 0, &priv->playlist[1]);
-        if (ret)
-                goto error;
-
-        ret = nouveau_vm_get(dev_priv->bar1_vm, priv->base.channels * 0x1000,
-                             12, NV_MEM_ACCESS_RW, &priv->user_vma);
-        if (ret)
-                goto error;
-
-        nouveau_irq_register(dev, 8, nvc0_fifo_isr);
-error:
-        if (ret)
-                priv->base.base.destroy(dev, NVOBJ_ENGINE_FIFO);
-        return ret;
-}
diff --git a/drivers/gpu/drm/nouveau/nvc0_graph.c b/drivers/gpu/drm/nouveau/nvc0_graph.c
deleted file mode 100644
index 2a01e6e47724..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_graph.c
+++ /dev/null
@@ -1,897 +0,0 @@
-/*
- * 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 <linux/firmware.h>
-#include <linux/module.h>
-
-#include "drmP.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_mm.h"
-#include "nouveau_fifo.h"
-
-#include "nvc0_graph.h"
-#include "nvc0_grhub.fuc.h"
-#include "nvc0_grgpc.fuc.h"
-
-static void
-nvc0_graph_ctxctl_debug_unit(struct drm_device *dev, u32 base)
-{
-        NV_INFO(dev, "PGRAPH: %06x - done 0x%08x\n", base,
-                nv_rd32(dev, base + 0x400));
-        NV_INFO(dev, "PGRAPH: %06x - stat 0x%08x 0x%08x 0x%08x 0x%08x\n", base,
-                nv_rd32(dev, base + 0x800), nv_rd32(dev, base + 0x804),
-                nv_rd32(dev, base + 0x808), nv_rd32(dev, base + 0x80c));
-        NV_INFO(dev, "PGRAPH: %06x - stat 0x%08x 0x%08x 0x%08x 0x%08x\n", base,
-                nv_rd32(dev, base + 0x810), nv_rd32(dev, base + 0x814),
-                nv_rd32(dev, base + 0x818), nv_rd32(dev, base + 0x81c));
-}
-
-static void
-nvc0_graph_ctxctl_debug(struct drm_device *dev)
-{
-        u32 gpcnr = nv_rd32(dev, 0x409604) & 0xffff;
-        u32 gpc;
-
-        nvc0_graph_ctxctl_debug_unit(dev, 0x409000);
-        for (gpc = 0; gpc < gpcnr; gpc++)
-                nvc0_graph_ctxctl_debug_unit(dev, 0x502000 + (gpc * 0x8000));
-}
-
-static int
-nvc0_graph_load_context(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-
-        nv_wr32(dev, 0x409840, 0x00000030);
-        nv_wr32(dev, 0x409500, 0x80000000 | chan->ramin->vinst >> 12);
-        nv_wr32(dev, 0x409504, 0x00000003);
-        if (!nv_wait(dev, 0x409800, 0x00000010, 0x00000010))
-                NV_ERROR(dev, "PGRAPH: load_ctx timeout\n");
-
-        return 0;
-}
-
-static int
-nvc0_graph_unload_context_to(struct drm_device *dev, u64 chan)
-{
-        nv_wr32(dev, 0x409840, 0x00000003);
-        nv_wr32(dev, 0x409500, 0x80000000 | chan >> 12);
-        nv_wr32(dev, 0x409504, 0x00000009);
-        if (!nv_wait(dev, 0x409800, 0x00000001, 0x00000000)) {
-                NV_ERROR(dev, "PGRAPH: unload_ctx timeout\n");
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static int
-nvc0_graph_construct_context(struct nouveau_channel *chan)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct nvc0_graph_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_GR);
-        struct nvc0_graph_chan *grch = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        int ret, i;
-        u32 *ctx;
-
-        ctx = kmalloc(priv->grctx_size, GFP_KERNEL);
-        if (!ctx)
-                return -ENOMEM;
-
-        if (!nouveau_ctxfw) {
-                nv_wr32(dev, 0x409840, 0x80000000);
-                nv_wr32(dev, 0x409500, 0x80000000 | chan->ramin->vinst >> 12);
-                nv_wr32(dev, 0x409504, 0x00000001);
-                if (!nv_wait(dev, 0x409800, 0x80000000, 0x80000000)) {
-                        NV_ERROR(dev, "PGRAPH: HUB_SET_CHAN timeout\n");
-                        nvc0_graph_ctxctl_debug(dev);
-                        ret = -EBUSY;
-                        goto err;
-                }
-        } else {
-                nvc0_graph_load_context(chan);
-
-                nv_wo32(grch->grctx, 0x1c, 1);
-                nv_wo32(grch->grctx, 0x20, 0);
-                nv_wo32(grch->grctx, 0x28, 0);
-                nv_wo32(grch->grctx, 0x2c, 0);
-                dev_priv->engine.instmem.flush(dev);
-        }
-
-        ret = nvc0_grctx_generate(chan);
-        if (ret)
-                goto err;
-
-        if (!nouveau_ctxfw) {
-                nv_wr32(dev, 0x409840, 0x80000000);
-                nv_wr32(dev, 0x409500, 0x80000000 | chan->ramin->vinst >> 12);
-                nv_wr32(dev, 0x409504, 0x00000002);
-                if (!nv_wait(dev, 0x409800, 0x80000000, 0x80000000)) {
-                        NV_ERROR(dev, "PGRAPH: HUB_CTX_SAVE timeout\n");
-                        nvc0_graph_ctxctl_debug(dev);
-                        ret = -EBUSY;
-                        goto err;
-                }
-        } else {
-                ret = nvc0_graph_unload_context_to(dev, chan->ramin->vinst);
-                if (ret)
-                        goto err;
-        }
-
-        for (i = 0; i < priv->grctx_size; i += 4)
-                ctx[i / 4] = nv_ro32(grch->grctx, i);
-
-        priv->grctx_vals = ctx;
-        return 0;
-
-err:
-        kfree(ctx);
-        return ret;
-}
-
-static int
-nvc0_graph_create_context_mmio_list(struct nouveau_channel *chan)
-{
-        struct nvc0_graph_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_GR);
-        struct nvc0_graph_chan *grch = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int i = 0, gpc, tp, ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 0x2000, 256, NVOBJ_FLAG_VM,
-                                 &grch->unk408004);
-        if (ret)
-                return ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 0x8000, 256, NVOBJ_FLAG_VM,
-                                 &grch->unk40800c);
-        if (ret)
-                return ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 384 * 1024, 4096,
-                                 NVOBJ_FLAG_VM | NVOBJ_FLAG_VM_USER,
-                                 &grch->unk418810);
-        if (ret)
-                return ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 0x1000, 0, NVOBJ_FLAG_VM,
-                                 &grch->mmio);
-        if (ret)
-                return ret;
-
-
-        nv_wo32(grch->mmio, i++ * 4, 0x00408004);
-        nv_wo32(grch->mmio, i++ * 4, grch->unk408004->linst >> 8);
-        nv_wo32(grch->mmio, i++ * 4, 0x00408008);
-        nv_wo32(grch->mmio, i++ * 4, 0x80000018);
-
-        nv_wo32(grch->mmio, i++ * 4, 0x0040800c);
-        nv_wo32(grch->mmio, i++ * 4, grch->unk40800c->linst >> 8);
-        nv_wo32(grch->mmio, i++ * 4, 0x00408010);
-        nv_wo32(grch->mmio, i++ * 4, 0x80000000);
-
-        nv_wo32(grch->mmio, i++ * 4, 0x00418810);
-        nv_wo32(grch->mmio, i++ * 4, 0x80000000 | grch->unk418810->linst >> 12);
-        nv_wo32(grch->mmio, i++ * 4, 0x00419848);
-        nv_wo32(grch->mmio, i++ * 4, 0x10000000 | grch->unk418810->linst >> 12);
-
-        nv_wo32(grch->mmio, i++ * 4, 0x00419004);
-        nv_wo32(grch->mmio, i++ * 4, grch->unk40800c->linst >> 8);
-        nv_wo32(grch->mmio, i++ * 4, 0x00419008);
-        nv_wo32(grch->mmio, i++ * 4, 0x00000000);
-
-        nv_wo32(grch->mmio, i++ * 4, 0x00418808);
-        nv_wo32(grch->mmio, i++ * 4, grch->unk408004->linst >> 8);
-        nv_wo32(grch->mmio, i++ * 4, 0x0041880c);
-        nv_wo32(grch->mmio, i++ * 4, 0x80000018);
-
-        if (dev_priv->chipset != 0xc1) {
-                u32 magic = 0x02180000;
-                nv_wo32(grch->mmio, i++ * 4, 0x00405830);
-                nv_wo32(grch->mmio, i++ * 4, magic);
-                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                        for (tp = 0; tp < priv->tp_nr[gpc]; tp++) {
-                                u32 reg = TP_UNIT(gpc, tp, 0x520);
-                                nv_wo32(grch->mmio, i++ * 4, reg);
-                                nv_wo32(grch->mmio, i++ * 4, magic);
-                                magic += 0x0324;
-                        }
-                }
-        } else {
-                u32 magic = 0x02180000;
-                nv_wo32(grch->mmio, i++ * 4, 0x00405830);
-                nv_wo32(grch->mmio, i++ * 4, magic | 0x0000218);
-                nv_wo32(grch->mmio, i++ * 4, 0x004064c4);
-                nv_wo32(grch->mmio, i++ * 4, 0x0086ffff);
-                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                        for (tp = 0; tp < priv->tp_nr[gpc]; tp++) {
-                                u32 reg = TP_UNIT(gpc, tp, 0x520);
-                                nv_wo32(grch->mmio, i++ * 4, reg);
-                                nv_wo32(grch->mmio, i++ * 4, (1 << 28) | magic);
-                                magic += 0x0324;
-                        }
-                        for (tp = 0; tp < priv->tp_nr[gpc]; tp++) {
-                                u32 reg = TP_UNIT(gpc, tp, 0x544);
-                                nv_wo32(grch->mmio, i++ * 4, reg);
-                                nv_wo32(grch->mmio, i++ * 4, magic);
-                                magic += 0x0324;
-                        }
-                }
-        }
-
-        grch->mmio_nr = i / 2;
-        return 0;
-}
-
-static int
-nvc0_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nvc0_graph_priv *priv = nv_engine(dev, engine);
-        struct nvc0_graph_chan *grch;
-        struct nouveau_gpuobj *grctx;
-        int ret, i;
-
-        grch = kzalloc(sizeof(*grch), GFP_KERNEL);
-        if (!grch)
-                return -ENOMEM;
-        chan->engctx[NVOBJ_ENGINE_GR] = grch;
-
-        ret = nouveau_gpuobj_new(dev, chan, priv->grctx_size, 256,
-                                 NVOBJ_FLAG_VM | NVOBJ_FLAG_ZERO_ALLOC,
-                                 &grch->grctx);
-        if (ret)
-                goto error;
-        grctx = grch->grctx;
-
-        ret = nvc0_graph_create_context_mmio_list(chan);
-        if (ret)
-                goto error;
-
-        nv_wo32(chan->ramin, 0x0210, lower_32_bits(grctx->linst) | 4);
-        nv_wo32(chan->ramin, 0x0214, upper_32_bits(grctx->linst));
-        pinstmem->flush(dev);
-
-        if (!priv->grctx_vals) {
-                ret = nvc0_graph_construct_context(chan);
-                if (ret)
-                        goto error;
-        }
-
-        for (i = 0; i < priv->grctx_size; i += 4)
-                nv_wo32(grctx, i, priv->grctx_vals[i / 4]);
-
-        if (!nouveau_ctxfw) {
-                nv_wo32(grctx, 0x00, grch->mmio_nr);
-                nv_wo32(grctx, 0x04, grch->mmio->linst >> 8);
-        } else {
-                nv_wo32(grctx, 0xf4, 0);
-                nv_wo32(grctx, 0xf8, 0);
-                nv_wo32(grctx, 0x10, grch->mmio_nr);
-                nv_wo32(grctx, 0x14, lower_32_bits(grch->mmio->linst));
-                nv_wo32(grctx, 0x18, upper_32_bits(grch->mmio->linst));
-                nv_wo32(grctx, 0x1c, 1);
-                nv_wo32(grctx, 0x20, 0);
-                nv_wo32(grctx, 0x28, 0);
-                nv_wo32(grctx, 0x2c, 0);
-        }
-        pinstmem->flush(dev);
-        return 0;
-
-error:
-        priv->base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nvc0_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nvc0_graph_chan *grch = chan->engctx[engine];
-
-        nouveau_gpuobj_ref(NULL, &grch->mmio);
-        nouveau_gpuobj_ref(NULL, &grch->unk418810);
-        nouveau_gpuobj_ref(NULL, &grch->unk40800c);
-        nouveau_gpuobj_ref(NULL, &grch->unk408004);
-        nouveau_gpuobj_ref(NULL, &grch->grctx);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nvc0_graph_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        return 0;
-}
-
-static int
-nvc0_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static void
-nvc0_graph_init_obj418880(struct drm_device *dev)
-{
-        struct nvc0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        int i;
-
-        nv_wr32(dev, GPC_BCAST(0x0880), 0x00000000);
-        nv_wr32(dev, GPC_BCAST(0x08a4), 0x00000000);
-        for (i = 0; i < 4; i++)
-                nv_wr32(dev, GPC_BCAST(0x0888) + (i * 4), 0x00000000);
-        nv_wr32(dev, GPC_BCAST(0x08b4), priv->unk4188b4->vinst >> 8);
-        nv_wr32(dev, GPC_BCAST(0x08b8), priv->unk4188b8->vinst >> 8);
-}
-
-static void
-nvc0_graph_init_regs(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x400080, 0x003083c2);
-        nv_wr32(dev, 0x400088, 0x00006fe7);
-        nv_wr32(dev, 0x40008c, 0x00000000);
-        nv_wr32(dev, 0x400090, 0x00000030);
-        nv_wr32(dev, 0x40013c, 0x013901f7);
-        nv_wr32(dev, 0x400140, 0x00000100);
-        nv_wr32(dev, 0x400144, 0x00000000);
-        nv_wr32(dev, 0x400148, 0x00000110);
-        nv_wr32(dev, 0x400138, 0x00000000);
-        nv_wr32(dev, 0x400130, 0x00000000);
-        nv_wr32(dev, 0x400134, 0x00000000);
-        nv_wr32(dev, 0x400124, 0x00000002);
-}
-
-static void
-nvc0_graph_init_gpc_0(struct drm_device *dev)
-{
-        struct nvc0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, priv->tp_total);
-        u32 data[TP_MAX / 8];
-        u8  tpnr[GPC_MAX];
-        int i, gpc, tpc;
-
-        nv_wr32(dev, TP_UNIT(0, 0, 0x5c), 1); /* affects TFB offset queries */
-
-        /*
-         *      TP      ROP UNKVAL(magic_not_rop_nr)
-         * 450: 4/0/0/0 2        3
-         * 460: 3/4/0/0 4        1
-         * 465: 3/4/4/0 4        7
-         * 470: 3/3/4/4 5        5
-         * 480: 3/4/4/4 6        6
-         */
-
-        memset(data, 0x00, sizeof(data));
-        memcpy(tpnr, priv->tp_nr, sizeof(priv->tp_nr));
-        for (i = 0, gpc = -1; i < priv->tp_total; i++) {
-                do {
-                        gpc = (gpc + 1) % priv->gpc_nr;
-                } while (!tpnr[gpc]);
-                tpc = priv->tp_nr[gpc] - tpnr[gpc]--;
-
-                data[i / 8] |= tpc << ((i % 8) * 4);
-        }
-
-        nv_wr32(dev, GPC_BCAST(0x0980), data[0]);
-        nv_wr32(dev, GPC_BCAST(0x0984), data[1]);
-        nv_wr32(dev, GPC_BCAST(0x0988), data[2]);
-        nv_wr32(dev, GPC_BCAST(0x098c), data[3]);
-
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0914), priv->magic_not_rop_nr << 8 |
-                                                  priv->tp_nr[gpc]);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0910), 0x00040000 | priv->tp_total);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0918), magicgpc918);
-        }
-
-        nv_wr32(dev, GPC_BCAST(0x1bd4), magicgpc918);
-        nv_wr32(dev, GPC_BCAST(0x08ac), nv_rd32(dev, 0x100800));
-}
-
-static void
-nvc0_graph_init_units(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x409c24, 0x000f0000);
-        nv_wr32(dev, 0x404000, 0xc0000000); /* DISPATCH */
-        nv_wr32(dev, 0x404600, 0xc0000000); /* M2MF */
-        nv_wr32(dev, 0x408030, 0xc0000000);
-        nv_wr32(dev, 0x40601c, 0xc0000000);
-        nv_wr32(dev, 0x404490, 0xc0000000); /* MACRO */
-        nv_wr32(dev, 0x406018, 0xc0000000);
-        nv_wr32(dev, 0x405840, 0xc0000000);
-        nv_wr32(dev, 0x405844, 0x00ffffff);
-        nv_mask(dev, 0x419cc0, 0x00000008, 0x00000008);
-        nv_mask(dev, 0x419eb4, 0x00001000, 0x00001000);
-}
-
-static void
-nvc0_graph_init_gpc_1(struct drm_device *dev)
-{
-        struct nvc0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        int gpc, tp;
-
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0420), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0900), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x1028), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0824), 0xc0000000);
-                for (tp = 0; tp < priv->tp_nr[gpc]; tp++) {
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x508), 0xffffffff);
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x50c), 0xffffffff);
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x224), 0xc0000000);
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x48c), 0xc0000000);
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x084), 0xc0000000);
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x644), 0x001ffffe);
-                        nv_wr32(dev, TP_UNIT(gpc, tp, 0x64c), 0x0000000f);
-                }
-                nv_wr32(dev, GPC_UNIT(gpc, 0x2c90), 0xffffffff);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x2c94), 0xffffffff);
-        }
-}
-
-static void
-nvc0_graph_init_rop(struct drm_device *dev)
-{
-        struct nvc0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        int rop;
-
-        for (rop = 0; rop < priv->rop_nr; rop++) {
-                nv_wr32(dev, ROP_UNIT(rop, 0x144), 0xc0000000);
-                nv_wr32(dev, ROP_UNIT(rop, 0x070), 0xc0000000);
-                nv_wr32(dev, ROP_UNIT(rop, 0x204), 0xffffffff);
-                nv_wr32(dev, ROP_UNIT(rop, 0x208), 0xffffffff);
-        }
-}
-
-static void
-nvc0_graph_init_fuc(struct drm_device *dev, u32 fuc_base,
-                    struct nvc0_graph_fuc *code, struct nvc0_graph_fuc *data)
-{
-        int i;
-
-        nv_wr32(dev, fuc_base + 0x01c0, 0x01000000);
-        for (i = 0; i < data->size / 4; i++)
-                nv_wr32(dev, fuc_base + 0x01c4, data->data[i]);
-
-        nv_wr32(dev, fuc_base + 0x0180, 0x01000000);
-        for (i = 0; i < code->size / 4; i++) {
-                if ((i & 0x3f) == 0)
-                        nv_wr32(dev, fuc_base + 0x0188, i >> 6);
-                nv_wr32(dev, fuc_base + 0x0184, code->data[i]);
-        }
-}
-
-static int
-nvc0_graph_init_ctxctl(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        u32 r000260;
-        int i;
-
-        if (!nouveau_ctxfw) {
-                /* load HUB microcode */
-                r000260 = nv_mask(dev, 0x000260, 0x00000001, 0x00000000);
-                nv_wr32(dev, 0x4091c0, 0x01000000);
-                for (i = 0; i < sizeof(nvc0_grhub_data) / 4; i++)
-                        nv_wr32(dev, 0x4091c4, nvc0_grhub_data[i]);
-
-                nv_wr32(dev, 0x409180, 0x01000000);
-                for (i = 0; i < sizeof(nvc0_grhub_code) / 4; i++) {
-                        if ((i & 0x3f) == 0)
-                                nv_wr32(dev, 0x409188, i >> 6);
-                        nv_wr32(dev, 0x409184, nvc0_grhub_code[i]);
-                }
-
-                /* load GPC microcode */
-                nv_wr32(dev, 0x41a1c0, 0x01000000);
-                for (i = 0; i < sizeof(nvc0_grgpc_data) / 4; i++)
-                        nv_wr32(dev, 0x41a1c4, nvc0_grgpc_data[i]);
-
-                nv_wr32(dev, 0x41a180, 0x01000000);
-                for (i = 0; i < sizeof(nvc0_grgpc_code) / 4; i++) {
-                        if ((i & 0x3f) == 0)
-                                nv_wr32(dev, 0x41a188, i >> 6);
-                        nv_wr32(dev, 0x41a184, nvc0_grgpc_code[i]);
-                }
-                nv_wr32(dev, 0x000260, r000260);
-
-                /* start HUB ucode running, it'll init the GPCs */
-                nv_wr32(dev, 0x409800, dev_priv->chipset);
-                nv_wr32(dev, 0x40910c, 0x00000000);
-                nv_wr32(dev, 0x409100, 0x00000002);
-                if (!nv_wait(dev, 0x409800, 0x80000000, 0x80000000)) {
-                        NV_ERROR(dev, "PGRAPH: HUB_INIT timed out\n");
-                        nvc0_graph_ctxctl_debug(dev);
-                        return -EBUSY;
-                }
-
-                priv->grctx_size = nv_rd32(dev, 0x409804);
-                return 0;
-        }
-
-        /* load fuc microcode */
-        r000260 = nv_mask(dev, 0x000260, 0x00000001, 0x00000000);
-        nvc0_graph_init_fuc(dev, 0x409000, &priv->fuc409c, &priv->fuc409d);
-        nvc0_graph_init_fuc(dev, 0x41a000, &priv->fuc41ac, &priv->fuc41ad);
-        nv_wr32(dev, 0x000260, r000260);
-
-        /* start both of them running */
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x41a10c, 0x00000000);
-        nv_wr32(dev, 0x40910c, 0x00000000);
-        nv_wr32(dev, 0x41a100, 0x00000002);
-        nv_wr32(dev, 0x409100, 0x00000002);
-        if (!nv_wait(dev, 0x409800, 0x00000001, 0x00000001))
-                NV_INFO(dev, "0x409800 wait failed\n");
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x7fffffff);
-        nv_wr32(dev, 0x409504, 0x00000021);
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x00000000);
-        nv_wr32(dev, 0x409504, 0x00000010);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x10 timeout\n");
-                return -EBUSY;
-        }
-        priv->grctx_size = nv_rd32(dev, 0x409800);
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x00000000);
-        nv_wr32(dev, 0x409504, 0x00000016);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x16 timeout\n");
-                return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x00000000);
-        nv_wr32(dev, 0x409504, 0x00000025);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x25 timeout\n");
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static int
-nvc0_graph_init(struct drm_device *dev, int engine)
-{
-        int ret;
-
-        nv_mask(dev, 0x000200, 0x18001000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x18001000, 0x18001000);
-
-        nvc0_graph_init_obj418880(dev);
-        nvc0_graph_init_regs(dev);
-        /*nvc0_graph_init_unitplemented_magics(dev);*/
-        nvc0_graph_init_gpc_0(dev);
-        /*nvc0_graph_init_unitplemented_c242(dev);*/
-
-        nv_wr32(dev, 0x400500, 0x00010001);
-        nv_wr32(dev, 0x400100, 0xffffffff);
-        nv_wr32(dev, 0x40013c, 0xffffffff);
-
-        nvc0_graph_init_units(dev);
-        nvc0_graph_init_gpc_1(dev);
-        nvc0_graph_init_rop(dev);
-
-        nv_wr32(dev, 0x400108, 0xffffffff);
-        nv_wr32(dev, 0x400138, 0xffffffff);
-        nv_wr32(dev, 0x400118, 0xffffffff);
-        nv_wr32(dev, 0x400130, 0xffffffff);
-        nv_wr32(dev, 0x40011c, 0xffffffff);
-        nv_wr32(dev, 0x400134, 0xffffffff);
-        nv_wr32(dev, 0x400054, 0x34ce3464);
-
-        ret = nvc0_graph_init_ctxctl(dev);
-        if (ret)
-                return ret;
-
-        return 0;
-}
-
-int
-nvc0_graph_isr_chid(struct drm_device *dev, u64 inst)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan;
-        unsigned long flags;
-        int i;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (i = 0; i < pfifo->channels; i++) {
-                chan = dev_priv->channels.ptr[i];
-                if (!chan || !chan->ramin)
-                        continue;
-
-                if (inst == chan->ramin->vinst)
-                        break;
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return i;
-}
-
-static void
-nvc0_graph_ctxctl_isr(struct drm_device *dev)
-{
-        u32 ustat = nv_rd32(dev, 0x409c18);
-
-        if (ustat & 0x00000001)
-                NV_INFO(dev, "PGRAPH: CTXCTRL ucode error\n");
-        if (ustat & 0x00080000)
-                NV_INFO(dev, "PGRAPH: CTXCTRL watchdog timeout\n");
-        if (ustat & ~0x00080001)
-                NV_INFO(dev, "PGRAPH: CTXCTRL 0x%08x\n", ustat);
-
-        nvc0_graph_ctxctl_debug(dev);
-        nv_wr32(dev, 0x409c20, ustat);
-}
-
-static void
-nvc0_graph_isr(struct drm_device *dev)
-{
-        u64 inst = (u64)(nv_rd32(dev, 0x409b00) & 0x0fffffff) << 12;
-        u32 chid = nvc0_graph_isr_chid(dev, inst);
-        u32 stat = nv_rd32(dev, 0x400100);
-        u32 addr = nv_rd32(dev, 0x400704);
-        u32 mthd = (addr & 0x00003ffc);
-        u32 subc = (addr & 0x00070000) >> 16;
-        u32 data = nv_rd32(dev, 0x400708);
-        u32 code = nv_rd32(dev, 0x400110);
-        u32 class = nv_rd32(dev, 0x404200 + (subc * 4));
-
-        if (stat & 0x00000010) {
-                if (nouveau_gpuobj_mthd_call2(dev, chid, class, mthd, data)) {
-                        NV_INFO(dev, "PGRAPH: ILLEGAL_MTHD ch %d [0x%010llx] "
-                                     "subc %d class 0x%04x mthd 0x%04x "
-                                     "data 0x%08x\n",
-                                chid, inst, subc, class, mthd, data);
-                }
-                nv_wr32(dev, 0x400100, 0x00000010);
-                stat &= ~0x00000010;
-        }
-
-        if (stat & 0x00000020) {
-                NV_INFO(dev, "PGRAPH: ILLEGAL_CLASS ch %d [0x%010llx] subc %d "
-                             "class 0x%04x mthd 0x%04x data 0x%08x\n",
-                        chid, inst, subc, class, mthd, data);
-                nv_wr32(dev, 0x400100, 0x00000020);
-                stat &= ~0x00000020;
-        }
-
-        if (stat & 0x00100000) {
-                NV_INFO(dev, "PGRAPH: DATA_ERROR [");
-                nouveau_enum_print(nv50_data_error_names, code);
-                printk("] ch %d [0x%010llx] subc %d class 0x%04x "
-                       "mthd 0x%04x data 0x%08x\n",
-                       chid, inst, subc, class, mthd, data);
-                nv_wr32(dev, 0x400100, 0x00100000);
-                stat &= ~0x00100000;
-        }
-
-        if (stat & 0x00200000) {
-                u32 trap = nv_rd32(dev, 0x400108);
-                NV_INFO(dev, "PGRAPH: TRAP ch %d status 0x%08x\n", chid, trap);
-                nv_wr32(dev, 0x400108, trap);
-                nv_wr32(dev, 0x400100, 0x00200000);
-                stat &= ~0x00200000;
-        }
-
-        if (stat & 0x00080000) {
-                nvc0_graph_ctxctl_isr(dev);
-                nv_wr32(dev, 0x400100, 0x00080000);
-                stat &= ~0x00080000;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PGRAPH: unknown stat 0x%08x\n", stat);
-                nv_wr32(dev, 0x400100, stat);
-        }
-
-        nv_wr32(dev, 0x400500, 0x00010001);
-}
-
-static int
-nvc0_graph_create_fw(struct drm_device *dev, const char *fwname,
-                     struct nvc0_graph_fuc *fuc)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        const struct firmware *fw;
-        char f[32];
-        int ret;
-
-        snprintf(f, sizeof(f), "nouveau/nv%02x_%s", dev_priv->chipset, fwname);
-        ret = request_firmware(&fw, f, &dev->pdev->dev);
-        if (ret) {
-                snprintf(f, sizeof(f), "nouveau/%s", fwname);
-                ret = request_firmware(&fw, f, &dev->pdev->dev);
-                if (ret) {
-                        NV_ERROR(dev, "failed to load %s\n", fwname);
-                        return ret;
-                }
-        }
-
-        fuc->size = fw->size;
-        fuc->data = kmemdup(fw->data, fuc->size, GFP_KERNEL);
-        release_firmware(fw);
-        return (fuc->data != NULL) ? 0 : -ENOMEM;
-}
-
-static void
-nvc0_graph_destroy_fw(struct nvc0_graph_fuc *fuc)
-{
-        if (fuc->data) {
-                kfree(fuc->data);
-                fuc->data = NULL;
-        }
-}
-
-static void
-nvc0_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nvc0_graph_priv *priv = nv_engine(dev, engine);
-
-        if (nouveau_ctxfw) {
-                nvc0_graph_destroy_fw(&priv->fuc409c);
-                nvc0_graph_destroy_fw(&priv->fuc409d);
-                nvc0_graph_destroy_fw(&priv->fuc41ac);
-                nvc0_graph_destroy_fw(&priv->fuc41ad);
-        }
-
-        nouveau_irq_unregister(dev, 12);
-
-        nouveau_gpuobj_ref(NULL, &priv->unk4188b8);
-        nouveau_gpuobj_ref(NULL, &priv->unk4188b4);
-
-        if (priv->grctx_vals)
-                kfree(priv->grctx_vals);
-
-        NVOBJ_ENGINE_DEL(dev, GR);
-        kfree(priv);
-}
-
-int
-nvc0_graph_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_graph_priv *priv;
-        int ret, gpc, i;
-        u32 fermi;
-
-        fermi = nvc0_graph_class(dev);
-        if (!fermi) {
-                NV_ERROR(dev, "PGRAPH: unsupported chipset, please report!\n");
-                return 0;
-        }
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.destroy = nvc0_graph_destroy;
-        priv->base.init = nvc0_graph_init;
-        priv->base.fini = nvc0_graph_fini;
-        priv->base.context_new = nvc0_graph_context_new;
-        priv->base.context_del = nvc0_graph_context_del;
-        priv->base.object_new = nvc0_graph_object_new;
-
-        NVOBJ_ENGINE_ADD(dev, GR, &priv->base);
-        nouveau_irq_register(dev, 12, nvc0_graph_isr);
-
-        if (nouveau_ctxfw) {
-                NV_INFO(dev, "PGRAPH: using external firmware\n");
-                if (nvc0_graph_create_fw(dev, "fuc409c", &priv->fuc409c) ||
-                    nvc0_graph_create_fw(dev, "fuc409d", &priv->fuc409d) ||
-                    nvc0_graph_create_fw(dev, "fuc41ac", &priv->fuc41ac) ||
-                    nvc0_graph_create_fw(dev, "fuc41ad", &priv->fuc41ad)) {
-                        ret = 0;
-                        goto error;
-                }
-        }
-
-        ret = nouveau_gpuobj_new(dev, NULL, 0x1000, 256, 0, &priv->unk4188b4);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 0x1000, 256, 0, &priv->unk4188b8);
-        if (ret)
-                goto error;
-
-        for (i = 0; i < 0x1000; i += 4) {
-                nv_wo32(priv->unk4188b4, i, 0x00000010);
-                nv_wo32(priv->unk4188b8, i, 0x00000010);
-        }
-
-        priv->gpc_nr  =  nv_rd32(dev, 0x409604) & 0x0000001f;
-        priv->rop_nr = (nv_rd32(dev, 0x409604) & 0x001f0000) >> 16;
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                priv->tp_nr[gpc] = nv_rd32(dev, GPC_UNIT(gpc, 0x2608));
-                priv->tp_total += priv->tp_nr[gpc];
-        }
-
-        /*XXX: these need figuring out... */
-        switch (dev_priv->chipset) {
-        case 0xc0:
-                if (priv->tp_total == 11) { /* 465, 3/4/4/0, 4 */
-                        priv->magic_not_rop_nr = 0x07;
-                } else
-                if (priv->tp_total == 14) { /* 470, 3/3/4/4, 5 */
-                        priv->magic_not_rop_nr = 0x05;
-                } else
-                if (priv->tp_total == 15) { /* 480, 3/4/4/4, 6 */
-                        priv->magic_not_rop_nr = 0x06;
-                }
-                break;
-        case 0xc3: /* 450, 4/0/0/0, 2 */
-                priv->magic_not_rop_nr = 0x03;
-                break;
-        case 0xc4: /* 460, 3/4/0/0, 4 */
-                priv->magic_not_rop_nr = 0x01;
-                break;
-        case 0xc1: /* 2/0/0/0, 1 */
-                priv->magic_not_rop_nr = 0x01;
-                break;
-        case 0xc8: /* 4/4/3/4, 5 */
-                priv->magic_not_rop_nr = 0x06;
-                break;
-        case 0xce: /* 4/4/0/0, 4 */
-                priv->magic_not_rop_nr = 0x03;
-                break;
-        case 0xcf: /* 4/0/0/0, 3 */
-                priv->magic_not_rop_nr = 0x03;
-                break;
-        case 0xd9: /* 1/0/0/0, 1 */
-                priv->magic_not_rop_nr = 0x01;
-                break;
-        }
-
-        if (!priv->magic_not_rop_nr) {
-                NV_ERROR(dev, "PGRAPH: unknown config: %d/%d/%d/%d, %d\n",
-                         priv->tp_nr[0], priv->tp_nr[1], priv->tp_nr[2],
-                         priv->tp_nr[3], priv->rop_nr);
-                priv->magic_not_rop_nr = 0x00;
-        }
-
-        NVOBJ_CLASS(dev, 0x902d, GR); /* 2D */
-        NVOBJ_CLASS(dev, 0x9039, GR); /* M2MF */
-        NVOBJ_CLASS(dev, 0x9097, GR); /* 3D */
-        if (fermi >= 0x9197)
-                NVOBJ_CLASS(dev, 0x9197, GR); /* 3D (NVC1-) */
-        if (fermi >= 0x9297)
-                NVOBJ_CLASS(dev, 0x9297, GR); /* 3D (NVC8-) */
-        NVOBJ_CLASS(dev, 0x90c0, GR); /* COMPUTE */
-        return 0;
-
-error:
-        nvc0_graph_destroy(dev, NVOBJ_ENGINE_GR);
-        return ret;
-}
diff --git a/drivers/gpu/drm/nouveau/nvc0_graph.h b/drivers/gpu/drm/nouveau/nvc0_graph.h
deleted file mode 100644
index 91d44ea662d9..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_graph.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * 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
- */
-
-#ifndef __NVC0_GRAPH_H__
-#define __NVC0_GRAPH_H__
-
-#define GPC_MAX 4
-#define TP_MAX 32
-
-#define ROP_BCAST(r)     (0x408800 + (r))
-#define ROP_UNIT(u, r)   (0x410000 + (u) * 0x400 + (r))
-#define GPC_BCAST(r)     (0x418000 + (r))
-#define GPC_UNIT(t, r)   (0x500000 + (t) * 0x8000 + (r))
-#define TP_UNIT(t, m, r) (0x504000 + (t) * 0x8000 + (m) * 0x800 + (r))
-
-struct nvc0_graph_fuc {
-        u32 *data;
-        u32  size;
-};
-
-struct nvc0_graph_priv {
-        struct nouveau_exec_engine base;
-
-        struct nvc0_graph_fuc fuc409c;
-        struct nvc0_graph_fuc fuc409d;
-        struct nvc0_graph_fuc fuc41ac;
-        struct nvc0_graph_fuc fuc41ad;
-
-        u8 gpc_nr;
-        u8 rop_nr;
-        u8 tp_nr[GPC_MAX];
-        u8 tp_total;
-
-        u32  grctx_size;
-        u32 *grctx_vals;
-        struct nouveau_gpuobj *unk4188b4;
-        struct nouveau_gpuobj *unk4188b8;
-
-        u8 magic_not_rop_nr;
-};
-
-struct nvc0_graph_chan {
-        struct nouveau_gpuobj *grctx;
-        struct nouveau_gpuobj *unk408004; /* 0x418810 too */
-        struct nouveau_gpuobj *unk40800c; /* 0x419004 too */
-        struct nouveau_gpuobj *unk418810; /* 0x419848 too */
-        struct nouveau_gpuobj *mmio;
-        int mmio_nr;
-};
-
-int nvc0_grctx_generate(struct nouveau_channel *);
-
-/* nvc0_graph.c uses this also to determine supported chipsets */
-static inline u32
-nvc0_graph_class(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        switch (dev_priv->chipset) {
-        case 0xc0:
-        case 0xc3:
-        case 0xc4:
-        case 0xce: /* guess, mmio trace shows only 0x9097 state */
-        case 0xcf: /* guess, mmio trace shows only 0x9097 state */
-                return 0x9097;
-        case 0xc1:
-                return 0x9197;
-        case 0xc8:
-        case 0xd9:
-                return 0x9297;
-        default:
-                return 0;
-        }
-}
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nvc0_grctx.c b/drivers/gpu/drm/nouveau/nvc0_grctx.c
deleted file mode 100644
index de77842b31c0..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_grctx.c
+++ /dev/null
@@ -1,2878 +0,0 @@
-/*
- * 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"
-#include "nouveau_mm.h"
-#include "nvc0_graph.h"
-
-static void
-nv_icmd(struct drm_device *dev, u32 icmd, u32 data)
-{
-        nv_wr32(dev, 0x400204, data);
-        nv_wr32(dev, 0x400200, icmd);
-        while (nv_rd32(dev, 0x400700) & 2) {}
-}
-
-static void
-nv_mthd(struct drm_device *dev, u32 class, u32 mthd, u32 data)
-{
-        nv_wr32(dev, 0x40448c, data);
-        nv_wr32(dev, 0x404488, 0x80000000 | (mthd << 14) | class);
-}
-
-static void
-nvc0_grctx_generate_9097(struct drm_device *dev)
-{
-        u32 fermi = nvc0_graph_class(dev);
-        u32 mthd;
-
-        nv_mthd(dev, 0x9097, 0x0800, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0840, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0880, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x08c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0900, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0940, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0980, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x09c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0804, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0844, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0884, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x08c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0904, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0944, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0984, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x09c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0808, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x0848, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x0888, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x08c8, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x0908, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x0948, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x0988, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x09c8, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x080c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x084c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x088c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x08cc, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x090c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x094c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x098c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x09cc, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x0810, 0x000000cf);
-        nv_mthd(dev, 0x9097, 0x0850, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0890, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x08d0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0910, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0950, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0990, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x09d0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0814, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0854, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0894, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x08d4, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0914, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0954, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0994, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x09d4, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0818, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0858, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0898, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x08d8, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0918, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0958, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0998, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x09d8, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x081c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x085c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x089c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x08dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x091c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x095c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x099c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x09dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0820, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0860, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x08a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x08e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0920, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0960, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x09a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x09e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2700, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2720, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2740, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2760, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2780, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2704, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2724, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2744, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2764, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2784, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2708, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2728, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2748, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2768, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2788, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27a8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27c8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x270c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x272c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x274c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x276c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x278c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27ac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x27ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2710, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x2730, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x2750, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x2770, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x2790, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x27b0, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x27d0, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x27f0, 0x00014000);
-        nv_mthd(dev, 0x9097, 0x2714, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x2734, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x2754, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x2774, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x2794, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x27b4, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x27d4, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x27f4, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x1c00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ca0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cb0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cc0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cd0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ce0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cf0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c24, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c34, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c64, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c94, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ca4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cb4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cc4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cd4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ce4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cf4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c18, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c28, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c38, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c58, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c68, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c78, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c98, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ca8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cb8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cc8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cd8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ce8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cf8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c0c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c1c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c2c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c3c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c4c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c5c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c6c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c7c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1c9c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cbc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ccc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cdc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1cfc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1da0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1db0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dc0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dd0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1de0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1df0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d24, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d34, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d64, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d94, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1da4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1db4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dc4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dd4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1de4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1df4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d18, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d28, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d38, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d58, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d68, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d78, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d98, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1da8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1db8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dc8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dd8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1de8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1df8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d0c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d1c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d2c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d3c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d4c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d5c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d6c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d7c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1d9c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dbc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dcc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ddc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1dfc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f18, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f28, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f38, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f58, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f68, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f78, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f0c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f1c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f24, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f2c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f34, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f3c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f4c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f5c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f64, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f6c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f7c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f98, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fa0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fa8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fb0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fb8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fc0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fc8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fd0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fd8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fe0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fe8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ff0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ff8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f94, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1f9c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fa4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fb4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fbc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fc4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fcc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fd4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fdc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fe4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1fec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ff4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1ffc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2200, 0x00000022);
-        nv_mthd(dev, 0x9097, 0x2210, 0x00000022);
-        nv_mthd(dev, 0x9097, 0x2220, 0x00000022);
-        nv_mthd(dev, 0x9097, 0x2230, 0x00000022);
-        nv_mthd(dev, 0x9097, 0x2240, 0x00000022);
-        nv_mthd(dev, 0x9097, 0x2000, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2040, 0x00000011);
-        nv_mthd(dev, 0x9097, 0x2080, 0x00000020);
-        nv_mthd(dev, 0x9097, 0x20c0, 0x00000030);
-        nv_mthd(dev, 0x9097, 0x2100, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x2140, 0x00000051);
-        nv_mthd(dev, 0x9097, 0x200c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x204c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x208c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x20cc, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x210c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x214c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x2010, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2050, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2090, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x20d0, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x2110, 0x00000003);
-        nv_mthd(dev, 0x9097, 0x2150, 0x00000004);
-        nv_mthd(dev, 0x9097, 0x0380, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0384, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0388, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03a8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03c8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x038c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03ac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x03ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0700, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0710, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0720, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0730, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0704, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0714, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0724, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0734, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0708, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0718, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0728, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0738, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2800, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2804, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2808, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x280c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2810, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2814, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2818, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x281c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2820, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2824, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2828, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x282c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2830, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2834, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2838, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x283c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2840, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2844, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2848, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x284c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2850, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2854, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2858, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x285c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2860, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2864, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2868, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x286c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2870, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2874, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2878, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x287c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2880, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2884, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2888, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x288c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2890, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2894, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2898, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x289c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28a8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28ac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28b0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28b4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28b8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28bc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28c8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28d0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28d4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28d8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28f0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28f4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28f8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x28fc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2900, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2904, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2908, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x290c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2910, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2914, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2918, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x291c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2920, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2924, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2928, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x292c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2930, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2934, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2938, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x293c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2940, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2944, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2948, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x294c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2950, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2954, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2958, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x295c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2960, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2964, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2968, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x296c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2970, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2974, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2978, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x297c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2980, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2984, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2988, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x298c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2990, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2994, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2998, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x299c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29a8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29ac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29b0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29b4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29b8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29bc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29c8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29d0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29d4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29d8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29f0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29f4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29f8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x29fc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0aa0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ac0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ae0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ba0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bc0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0be0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a24, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a64, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0aa4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ac4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ae4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b24, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b64, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ba4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bc4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0be4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a28, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a68, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0aa8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ac8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ae8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b28, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b68, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ba8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bc8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0be8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a0c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a2c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a4c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a6c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0aac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0acc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0aec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b0c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b2c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b4c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b6c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bcc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ab0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ad0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0af0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bb0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bd0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bf0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a34, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0a94, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ab4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ad4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0af4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b34, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0b94, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bb4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bd4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0bf4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ca0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cb0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cc0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cd0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ce0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cf0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c24, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c34, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c64, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c94, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ca4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cb4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cc4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cd4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ce4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cf4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c18, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c28, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c38, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c58, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c68, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c78, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c98, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ca8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cb8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cc8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cd8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ce8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0cf8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0c0c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c1c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c2c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c3c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c4c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c5c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c6c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c7c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c8c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0c9c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0cac, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0cbc, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0ccc, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0cdc, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0cec, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0cfc, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0d00, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d08, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d10, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d18, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d20, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d28, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d30, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d38, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d04, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d0c, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d14, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d1c, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d24, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d2c, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d34, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d3c, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e00, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e20, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e30, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e60, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e70, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ea0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0eb0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ec0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ed0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ee0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ef0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0e04, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e14, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e24, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e34, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e44, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e54, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e64, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e74, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e84, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e94, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ea4, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0eb4, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ec4, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ed4, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ee4, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ef4, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e08, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e18, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e28, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e38, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e48, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e58, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e68, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e78, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e88, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0e98, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ea8, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0eb8, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ec8, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ed8, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ee8, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0ef8, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d40, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d48, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d50, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d58, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d44, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d4c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d5c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1e00, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e20, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e40, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e60, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e80, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ea0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ec0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ee0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e04, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e24, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e44, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e64, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e84, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ea4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ec4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ee4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e08, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e28, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e48, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e68, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e88, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1ea8, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1ec8, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1ee8, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e0c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e2c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e4c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e6c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e8c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1eac, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ecc, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1eec, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e10, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e30, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e50, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e70, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e90, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1eb0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ed0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ef0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e14, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e34, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e54, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e74, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e94, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1eb4, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1ed4, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1ef4, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1e18, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e38, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e58, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e78, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1e98, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1eb8, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ed8, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1ef8, 0x00000001);
-        if (fermi == 0x9097) {
-                for (mthd = 0x3400; mthd <= 0x35fc; mthd += 4)
-                        nv_mthd(dev, 0x9097, mthd, 0x00000000);
-        }
-        nv_mthd(dev, 0x9097, 0x030c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1944, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1514, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d68, 0x0000ffff);
-        nv_mthd(dev, 0x9097, 0x121c, 0x0fac6881);
-        nv_mthd(dev, 0x9097, 0x0fac, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1538, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0fe0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0fe4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0fe8, 0x00000014);
-        nv_mthd(dev, 0x9097, 0x0fec, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x0ff0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x179c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1228, 0x00000400);
-        nv_mthd(dev, 0x9097, 0x122c, 0x00000300);
-        nv_mthd(dev, 0x9097, 0x1230, 0x00010001);
-        nv_mthd(dev, 0x9097, 0x07f8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x15b4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x15cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1534, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0fb0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x15d0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x153c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x16b4, 0x00000003);
-        nv_mthd(dev, 0x9097, 0x0fbc, 0x0000ffff);
-        nv_mthd(dev, 0x9097, 0x0fc0, 0x0000ffff);
-        nv_mthd(dev, 0x9097, 0x0fc4, 0x0000ffff);
-        nv_mthd(dev, 0x9097, 0x0fc8, 0x0000ffff);
-        nv_mthd(dev, 0x9097, 0x0df8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0dfc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1948, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1970, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x161c, 0x000009f0);
-        nv_mthd(dev, 0x9097, 0x0dcc, 0x00000010);
-        nv_mthd(dev, 0x9097, 0x163c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x15e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1160, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1164, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1168, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x116c, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1170, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1174, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1178, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x117c, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1180, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1184, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1188, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x118c, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1190, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1194, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1198, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x119c, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11a0, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11a4, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11a8, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11ac, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11b0, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11b4, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11b8, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11bc, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11c0, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11c4, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11c8, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11cc, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11d0, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11d4, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11d8, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x11dc, 0x25e00040);
-        nv_mthd(dev, 0x9097, 0x1880, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1884, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1888, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x188c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1890, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1894, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1898, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x189c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18a8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18ac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18b0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18b4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18b8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18bc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18c8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18d0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18d4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18d8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18e0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18f0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18f4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18f8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x18fc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x17c8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x17cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x17d0, 0x000000ff);
-        nv_mthd(dev, 0x9097, 0x17d4, 0xffffffff);
-        nv_mthd(dev, 0x9097, 0x17d8, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x17dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x15f4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x15f8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1434, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1438, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d74, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0dec, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x13a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1318, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1644, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0748, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0de8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1648, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x12a4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1120, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1124, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1128, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x112c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1118, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x164c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1658, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1910, 0x00000290);
-        nv_mthd(dev, 0x9097, 0x1518, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x165c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1520, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1604, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1570, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x13b0, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x13b4, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x020c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1670, 0x30201000);
-        nv_mthd(dev, 0x9097, 0x1674, 0x70605040);
-        nv_mthd(dev, 0x9097, 0x1678, 0xb8a89888);
-        nv_mthd(dev, 0x9097, 0x167c, 0xf8e8d8c8);
-        nv_mthd(dev, 0x9097, 0x166c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1680, 0x00ffff00);
-        nv_mthd(dev, 0x9097, 0x12d0, 0x00000003);
-        nv_mthd(dev, 0x9097, 0x12d4, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1684, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1688, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0dac, 0x00001b02);
-        nv_mthd(dev, 0x9097, 0x0db0, 0x00001b02);
-        nv_mthd(dev, 0x9097, 0x0db4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x168c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x15bc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x156c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x187c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1110, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0dc0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0dc4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0dc8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1234, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1690, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x12ac, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x02c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0790, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0794, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0798, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x079c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x07a0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x077c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1000, 0x00000010);
-        nv_mthd(dev, 0x9097, 0x10fc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1290, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0218, 0x00000010);
-        nv_mthd(dev, 0x9097, 0x12d8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x12dc, 0x00000010);
-        nv_mthd(dev, 0x9097, 0x0d94, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x155c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1560, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1564, 0x00001fff);
-        nv_mthd(dev, 0x9097, 0x1574, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1578, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x157c, 0x003fffff);
-        nv_mthd(dev, 0x9097, 0x1354, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1664, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1610, 0x00000012);
-        nv_mthd(dev, 0x9097, 0x1608, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x160c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x162c, 0x00000003);
-        nv_mthd(dev, 0x9097, 0x0210, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0320, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0324, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0328, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x032c, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0330, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0334, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0338, 0x3f800000);
-        nv_mthd(dev, 0x9097, 0x0750, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0760, 0x39291909);
-        nv_mthd(dev, 0x9097, 0x0764, 0x79695949);
-        nv_mthd(dev, 0x9097, 0x0768, 0xb9a99989);
-        nv_mthd(dev, 0x9097, 0x076c, 0xf9e9d9c9);
-        nv_mthd(dev, 0x9097, 0x0770, 0x30201000);
-        nv_mthd(dev, 0x9097, 0x0774, 0x70605040);
-        nv_mthd(dev, 0x9097, 0x0778, 0x00009080);
-        nv_mthd(dev, 0x9097, 0x0780, 0x39291909);
-        nv_mthd(dev, 0x9097, 0x0784, 0x79695949);
-        nv_mthd(dev, 0x9097, 0x0788, 0xb9a99989);
-        nv_mthd(dev, 0x9097, 0x078c, 0xf9e9d9c9);
-        nv_mthd(dev, 0x9097, 0x07d0, 0x30201000);
-        nv_mthd(dev, 0x9097, 0x07d4, 0x70605040);
-        nv_mthd(dev, 0x9097, 0x07d8, 0x00009080);
-        nv_mthd(dev, 0x9097, 0x037c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0740, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0744, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x2600, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1918, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x191c, 0x00000900);
-        nv_mthd(dev, 0x9097, 0x1920, 0x00000405);
-        nv_mthd(dev, 0x9097, 0x1308, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1924, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x13ac, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x192c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x193c, 0x00002c1c);
-        nv_mthd(dev, 0x9097, 0x0d7c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x02c0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1510, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1940, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ff4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0ff8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x194c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1950, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1968, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1590, 0x0000003f);
-        nv_mthd(dev, 0x9097, 0x07e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x07ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x07f0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x07f4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x196c, 0x00000011);
-        nv_mthd(dev, 0x9097, 0x197c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0fcc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0fd0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x02d8, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x1980, 0x00000080);
-        nv_mthd(dev, 0x9097, 0x1504, 0x00000080);
-        nv_mthd(dev, 0x9097, 0x1984, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0300, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x13a8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x12ec, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1310, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1314, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1380, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1384, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1388, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x138c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1390, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1394, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x139c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1398, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1594, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1598, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x159c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x15a0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x15a4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x0f54, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f58, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f5c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x19bc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f9c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0fa0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x12cc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x12e8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x130c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1360, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1364, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1368, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x136c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1370, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1374, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1378, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x137c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x133c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1340, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1344, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1348, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x134c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1350, 0x00000002);
-        nv_mthd(dev, 0x9097, 0x1358, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x12e4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x131c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1320, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1324, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1328, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x19c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1140, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x19c4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x19c8, 0x00001500);
-        nv_mthd(dev, 0x9097, 0x135c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x19e0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19e4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19e8, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19ec, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19f0, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19f4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19f8, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19fc, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x19cc, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x15b8, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a00, 0x00001111);
-        nv_mthd(dev, 0x9097, 0x1a04, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a08, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a0c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a10, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a14, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a18, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1a1c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d6c, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x0d70, 0xffff0000);
-        nv_mthd(dev, 0x9097, 0x10f8, 0x00001010);
-        nv_mthd(dev, 0x9097, 0x0d80, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d84, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d88, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d8c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0d90, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0da0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1508, 0x80000000);
-        nv_mthd(dev, 0x9097, 0x150c, 0x40000000);
-        nv_mthd(dev, 0x9097, 0x1668, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0318, 0x00000008);
-        nv_mthd(dev, 0x9097, 0x031c, 0x00000008);
-        nv_mthd(dev, 0x9097, 0x0d9c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x07dc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x074c, 0x00000055);
-        nv_mthd(dev, 0x9097, 0x1420, 0x00000003);
-        nv_mthd(dev, 0x9097, 0x17bc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x17c0, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x17c4, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1008, 0x00000008);
-        nv_mthd(dev, 0x9097, 0x100c, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x1010, 0x0000012c);
-        nv_mthd(dev, 0x9097, 0x0d60, 0x00000040);
-        nv_mthd(dev, 0x9097, 0x075c, 0x00000003);
-        nv_mthd(dev, 0x9097, 0x1018, 0x00000020);
-        nv_mthd(dev, 0x9097, 0x101c, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1020, 0x00000020);
-        nv_mthd(dev, 0x9097, 0x1024, 0x00000001);
-        nv_mthd(dev, 0x9097, 0x1444, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x1448, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x144c, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0360, 0x20164010);
-        nv_mthd(dev, 0x9097, 0x0364, 0x00000020);
-        nv_mthd(dev, 0x9097, 0x0368, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0de4, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0204, 0x00000006);
-        nv_mthd(dev, 0x9097, 0x0208, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x02cc, 0x003fffff);
-        nv_mthd(dev, 0x9097, 0x02d0, 0x00000c48);
-        nv_mthd(dev, 0x9097, 0x1220, 0x00000005);
-        nv_mthd(dev, 0x9097, 0x0fdc, 0x00000000);
-        nv_mthd(dev, 0x9097, 0x0f98, 0x00300008);
-        nv_mthd(dev, 0x9097, 0x1284, 0x04000080);
-        nv_mthd(dev, 0x9097, 0x1450, 0x00300008);
-        nv_mthd(dev, 0x9097, 0x1454, 0x04000080);
-        nv_mthd(dev, 0x9097, 0x0214, 0x00000000);
-        /* in trace, right after 0x90c0, not here */
-        nv_mthd(dev, 0x9097, 0x3410, 0x80002006);
-}
-
-static void
-nvc0_grctx_generate_9197(struct drm_device *dev)
-{
-        u32 fermi = nvc0_graph_class(dev);
-        u32 mthd;
-
-        if (fermi == 0x9197) {
-                for (mthd = 0x3400; mthd <= 0x35fc; mthd += 4)
-                        nv_mthd(dev, 0x9197, mthd, 0x00000000);
-        }
-        nv_mthd(dev, 0x9197, 0x02e4, 0x0000b001);
-}
-
-static void
-nvc0_grctx_generate_9297(struct drm_device *dev)
-{
-        u32 fermi = nvc0_graph_class(dev);
-        u32 mthd;
-
-        if (fermi == 0x9297) {
-                for (mthd = 0x3400; mthd <= 0x35fc; mthd += 4)
-                        nv_mthd(dev, 0x9297, mthd, 0x00000000);
-        }
-        nv_mthd(dev, 0x9297, 0x036c, 0x00000000);
-        nv_mthd(dev, 0x9297, 0x0370, 0x00000000);
-        nv_mthd(dev, 0x9297, 0x07a4, 0x00000000);
-        nv_mthd(dev, 0x9297, 0x07a8, 0x00000000);
-        nv_mthd(dev, 0x9297, 0x0374, 0x00000000);
-        nv_mthd(dev, 0x9297, 0x0378, 0x00000020);
-}
-
-static void
-nvc0_grctx_generate_902d(struct drm_device *dev)
-{
-        nv_mthd(dev, 0x902d, 0x0200, 0x000000cf);
-        nv_mthd(dev, 0x902d, 0x0204, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0208, 0x00000020);
-        nv_mthd(dev, 0x902d, 0x020c, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0210, 0x00000000);
-        nv_mthd(dev, 0x902d, 0x0214, 0x00000080);
-        nv_mthd(dev, 0x902d, 0x0218, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x021c, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x0220, 0x00000000);
-        nv_mthd(dev, 0x902d, 0x0224, 0x00000000);
-        nv_mthd(dev, 0x902d, 0x0230, 0x000000cf);
-        nv_mthd(dev, 0x902d, 0x0234, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0238, 0x00000020);
-        nv_mthd(dev, 0x902d, 0x023c, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0244, 0x00000080);
-        nv_mthd(dev, 0x902d, 0x0248, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x024c, 0x00000100);
-}
-
-static void
-nvc0_grctx_generate_9039(struct drm_device *dev)
-{
-        nv_mthd(dev, 0x9039, 0x030c, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x0310, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x0314, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x0320, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x0238, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x023c, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x0318, 0x00000000);
-        nv_mthd(dev, 0x9039, 0x031c, 0x00000000);
-}
-
-static void
-nvc0_grctx_generate_90c0(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int i;
-
-        for (i = 0; dev_priv->chipset == 0xd9 && i < 4; i++) {
-                nv_mthd(dev, 0x90c0, 0x2700 + (i * 0x40), 0x00000000);
-                nv_mthd(dev, 0x90c0, 0x2720 + (i * 0x40), 0x00000000);
-                nv_mthd(dev, 0x90c0, 0x2704 + (i * 0x40), 0x00000000);
-                nv_mthd(dev, 0x90c0, 0x2724 + (i * 0x40), 0x00000000);
-                nv_mthd(dev, 0x90c0, 0x2708 + (i * 0x40), 0x00000000);
-                nv_mthd(dev, 0x90c0, 0x2728 + (i * 0x40), 0x00000000);
-        }
-        nv_mthd(dev, 0x90c0, 0x270c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x272c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x274c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x276c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x278c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x27ac, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x27cc, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x27ec, 0x00000000);
-        for (i = 0; dev_priv->chipset == 0xd9 && i < 4; i++) {
-                nv_mthd(dev, 0x90c0, 0x2710 + (i * 0x40), 0x00014000);
-                nv_mthd(dev, 0x90c0, 0x2730 + (i * 0x40), 0x00014000);
-                nv_mthd(dev, 0x90c0, 0x2714 + (i * 0x40), 0x00000040);
-                nv_mthd(dev, 0x90c0, 0x2734 + (i * 0x40), 0x00000040);
-        }
-        nv_mthd(dev, 0x90c0, 0x030c, 0x00000001);
-        nv_mthd(dev, 0x90c0, 0x1944, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0758, 0x00000100);
-        nv_mthd(dev, 0x90c0, 0x02c4, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0790, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0794, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0798, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x079c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x07a0, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x077c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0204, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0208, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x020c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0214, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x024c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x0d94, 0x00000001);
-        nv_mthd(dev, 0x90c0, 0x1608, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x160c, 0x00000000);
-        nv_mthd(dev, 0x90c0, 0x1664, 0x00000000);
-}
-
-static void
-nvc0_grctx_generate_dispatch(struct drm_device *dev)
-{
-        int i;
-
-        nv_wr32(dev, 0x404004, 0x00000000);
-        nv_wr32(dev, 0x404008, 0x00000000);
-        nv_wr32(dev, 0x40400c, 0x00000000);
-        nv_wr32(dev, 0x404010, 0x00000000);
-        nv_wr32(dev, 0x404014, 0x00000000);
-        nv_wr32(dev, 0x404018, 0x00000000);
-        nv_wr32(dev, 0x40401c, 0x00000000);
-        nv_wr32(dev, 0x404020, 0x00000000);
-        nv_wr32(dev, 0x404024, 0x00000000);
-        nv_wr32(dev, 0x404028, 0x00000000);
-        nv_wr32(dev, 0x40402c, 0x00000000);
-        nv_wr32(dev, 0x404044, 0x00000000);
-        nv_wr32(dev, 0x404094, 0x00000000);
-        nv_wr32(dev, 0x404098, 0x00000000);
-        nv_wr32(dev, 0x40409c, 0x00000000);
-        nv_wr32(dev, 0x4040a0, 0x00000000);
-        nv_wr32(dev, 0x4040a4, 0x00000000);
-        nv_wr32(dev, 0x4040a8, 0x00000000);
-        nv_wr32(dev, 0x4040ac, 0x00000000);
-        nv_wr32(dev, 0x4040b0, 0x00000000);
-        nv_wr32(dev, 0x4040b4, 0x00000000);
-        nv_wr32(dev, 0x4040b8, 0x00000000);
-        nv_wr32(dev, 0x4040bc, 0x00000000);
-        nv_wr32(dev, 0x4040c0, 0x00000000);
-        nv_wr32(dev, 0x4040c4, 0x00000000);
-        nv_wr32(dev, 0x4040c8, 0xf0000087);
-        nv_wr32(dev, 0x4040d4, 0x00000000);
-        nv_wr32(dev, 0x4040d8, 0x00000000);
-        nv_wr32(dev, 0x4040dc, 0x00000000);
-        nv_wr32(dev, 0x4040e0, 0x00000000);
-        nv_wr32(dev, 0x4040e4, 0x00000000);
-        nv_wr32(dev, 0x4040e8, 0x00001000);
-        nv_wr32(dev, 0x4040f8, 0x00000000);
-        nv_wr32(dev, 0x404130, 0x00000000);
-        nv_wr32(dev, 0x404134, 0x00000000);
-        nv_wr32(dev, 0x404138, 0x20000040);
-        nv_wr32(dev, 0x404150, 0x0000002e);
-        nv_wr32(dev, 0x404154, 0x00000400);
-        nv_wr32(dev, 0x404158, 0x00000200);
-        nv_wr32(dev, 0x404164, 0x00000055);
-        nv_wr32(dev, 0x404168, 0x00000000);
-        nv_wr32(dev, 0x404174, 0x00000000);
-        nv_wr32(dev, 0x404178, 0x00000000);
-        nv_wr32(dev, 0x40417c, 0x00000000);
-        for (i = 0; i < 8; i++)
-                nv_wr32(dev, 0x404200 + (i * 4), 0x00000000); /* subc */
-}
-
-static void
-nvc0_grctx_generate_macro(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404404, 0x00000000);
-        nv_wr32(dev, 0x404408, 0x00000000);
-        nv_wr32(dev, 0x40440c, 0x00000000);
-        nv_wr32(dev, 0x404410, 0x00000000);
-        nv_wr32(dev, 0x404414, 0x00000000);
-        nv_wr32(dev, 0x404418, 0x00000000);
-        nv_wr32(dev, 0x40441c, 0x00000000);
-        nv_wr32(dev, 0x404420, 0x00000000);
-        nv_wr32(dev, 0x404424, 0x00000000);
-        nv_wr32(dev, 0x404428, 0x00000000);
-        nv_wr32(dev, 0x40442c, 0x00000000);
-        nv_wr32(dev, 0x404430, 0x00000000);
-        nv_wr32(dev, 0x404434, 0x00000000);
-        nv_wr32(dev, 0x404438, 0x00000000);
-        nv_wr32(dev, 0x404460, 0x00000000);
-        nv_wr32(dev, 0x404464, 0x00000000);
-        nv_wr32(dev, 0x404468, 0x00ffffff);
-        nv_wr32(dev, 0x40446c, 0x00000000);
-        nv_wr32(dev, 0x404480, 0x00000001);
-        nv_wr32(dev, 0x404498, 0x00000001);
-}
-
-static void
-nvc0_grctx_generate_m2mf(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404604, 0x00000015);
-        nv_wr32(dev, 0x404608, 0x00000000);
-        nv_wr32(dev, 0x40460c, 0x00002e00);
-        nv_wr32(dev, 0x404610, 0x00000100);
-        nv_wr32(dev, 0x404618, 0x00000000);
-        nv_wr32(dev, 0x40461c, 0x00000000);
-        nv_wr32(dev, 0x404620, 0x00000000);
-        nv_wr32(dev, 0x404624, 0x00000000);
-        nv_wr32(dev, 0x404628, 0x00000000);
-        nv_wr32(dev, 0x40462c, 0x00000000);
-        nv_wr32(dev, 0x404630, 0x00000000);
-        nv_wr32(dev, 0x404634, 0x00000000);
-        nv_wr32(dev, 0x404638, 0x00000004);
-        nv_wr32(dev, 0x40463c, 0x00000000);
-        nv_wr32(dev, 0x404640, 0x00000000);
-        nv_wr32(dev, 0x404644, 0x00000000);
-        nv_wr32(dev, 0x404648, 0x00000000);
-        nv_wr32(dev, 0x40464c, 0x00000000);
-        nv_wr32(dev, 0x404650, 0x00000000);
-        nv_wr32(dev, 0x404654, 0x00000000);
-        nv_wr32(dev, 0x404658, 0x00000000);
-        nv_wr32(dev, 0x40465c, 0x007f0100);
-        nv_wr32(dev, 0x404660, 0x00000000);
-        nv_wr32(dev, 0x404664, 0x00000000);
-        nv_wr32(dev, 0x404668, 0x00000000);
-        nv_wr32(dev, 0x40466c, 0x00000000);
-        nv_wr32(dev, 0x404670, 0x00000000);
-        nv_wr32(dev, 0x404674, 0x00000000);
-        nv_wr32(dev, 0x404678, 0x00000000);
-        nv_wr32(dev, 0x40467c, 0x00000002);
-        nv_wr32(dev, 0x404680, 0x00000000);
-        nv_wr32(dev, 0x404684, 0x00000000);
-        nv_wr32(dev, 0x404688, 0x00000000);
-        nv_wr32(dev, 0x40468c, 0x00000000);
-        nv_wr32(dev, 0x404690, 0x00000000);
-        nv_wr32(dev, 0x404694, 0x00000000);
-        nv_wr32(dev, 0x404698, 0x00000000);
-        nv_wr32(dev, 0x40469c, 0x00000000);
-        nv_wr32(dev, 0x4046a0, 0x007f0080);
-        nv_wr32(dev, 0x4046a4, 0x00000000);
-        nv_wr32(dev, 0x4046a8, 0x00000000);
-        nv_wr32(dev, 0x4046ac, 0x00000000);
-        nv_wr32(dev, 0x4046b0, 0x00000000);
-        nv_wr32(dev, 0x4046b4, 0x00000000);
-        nv_wr32(dev, 0x4046b8, 0x00000000);
-        nv_wr32(dev, 0x4046bc, 0x00000000);
-        nv_wr32(dev, 0x4046c0, 0x00000000);
-        nv_wr32(dev, 0x4046c4, 0x00000000);
-        nv_wr32(dev, 0x4046c8, 0x00000000);
-        nv_wr32(dev, 0x4046cc, 0x00000000);
-        nv_wr32(dev, 0x4046d0, 0x00000000);
-        nv_wr32(dev, 0x4046d4, 0x00000000);
-        nv_wr32(dev, 0x4046d8, 0x00000000);
-        nv_wr32(dev, 0x4046dc, 0x00000000);
-        nv_wr32(dev, 0x4046e0, 0x00000000);
-        nv_wr32(dev, 0x4046e4, 0x00000000);
-        nv_wr32(dev, 0x4046e8, 0x00000000);
-        nv_wr32(dev, 0x4046f0, 0x00000000);
-        nv_wr32(dev, 0x4046f4, 0x00000000);
-}
-
-static void
-nvc0_grctx_generate_unk47xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404700, 0x00000000);
-        nv_wr32(dev, 0x404704, 0x00000000);
-        nv_wr32(dev, 0x404708, 0x00000000);
-        nv_wr32(dev, 0x40470c, 0x00000000);
-        nv_wr32(dev, 0x404710, 0x00000000);
-        nv_wr32(dev, 0x404714, 0x00000000);
-        nv_wr32(dev, 0x404718, 0x00000000);
-        nv_wr32(dev, 0x40471c, 0x00000000);
-        nv_wr32(dev, 0x404720, 0x00000000);
-        nv_wr32(dev, 0x404724, 0x00000000);
-        nv_wr32(dev, 0x404728, 0x00000000);
-        nv_wr32(dev, 0x40472c, 0x00000000);
-        nv_wr32(dev, 0x404730, 0x00000000);
-        nv_wr32(dev, 0x404734, 0x00000100);
-        nv_wr32(dev, 0x404738, 0x00000000);
-        nv_wr32(dev, 0x40473c, 0x00000000);
-        nv_wr32(dev, 0x404740, 0x00000000);
-        nv_wr32(dev, 0x404744, 0x00000000);
-        nv_wr32(dev, 0x404748, 0x00000000);
-        nv_wr32(dev, 0x40474c, 0x00000000);
-        nv_wr32(dev, 0x404750, 0x00000000);
-        nv_wr32(dev, 0x404754, 0x00000000);
-}
-
-static void
-nvc0_grctx_generate_shaders(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        if (dev_priv->chipset == 0xd9) {
-                nv_wr32(dev, 0x405800, 0x0f8000bf);
-                nv_wr32(dev, 0x405830, 0x02180218);
-                nv_wr32(dev, 0x405834, 0x08000000);
-        } else
-        if (dev_priv->chipset == 0xc1) {
-                nv_wr32(dev, 0x405800, 0x0f8000bf);
-                nv_wr32(dev, 0x405830, 0x02180218);
-                nv_wr32(dev, 0x405834, 0x00000000);
-        } else {
-                nv_wr32(dev, 0x405800, 0x078000bf);
-                nv_wr32(dev, 0x405830, 0x02180000);
-                nv_wr32(dev, 0x405834, 0x00000000);
-        }
-        nv_wr32(dev, 0x405838, 0x00000000);
-        nv_wr32(dev, 0x405854, 0x00000000);
-        nv_wr32(dev, 0x405870, 0x00000001);
-        nv_wr32(dev, 0x405874, 0x00000001);
-        nv_wr32(dev, 0x405878, 0x00000001);
-        nv_wr32(dev, 0x40587c, 0x00000001);
-        nv_wr32(dev, 0x405a00, 0x00000000);
-        nv_wr32(dev, 0x405a04, 0x00000000);
-        nv_wr32(dev, 0x405a18, 0x00000000);
-}
-
-static void
-nvc0_grctx_generate_unk60xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x406020, 0x000103c1);
-        nv_wr32(dev, 0x406028, 0x00000001);
-        nv_wr32(dev, 0x40602c, 0x00000001);
-        nv_wr32(dev, 0x406030, 0x00000001);
-        nv_wr32(dev, 0x406034, 0x00000001);
-}
-
-static void
-nvc0_grctx_generate_unk64xx(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        nv_wr32(dev, 0x4064a8, 0x00000000);
-        nv_wr32(dev, 0x4064ac, 0x00003fff);
-        nv_wr32(dev, 0x4064b4, 0x00000000);
-        nv_wr32(dev, 0x4064b8, 0x00000000);
-        if (dev_priv->chipset == 0xd9)
-                nv_wr32(dev, 0x4064bc, 0x00000000);
-        if (dev_priv->chipset == 0xc1 ||
-            dev_priv->chipset == 0xd9) {
-                nv_wr32(dev, 0x4064c0, 0x80140078);
-                nv_wr32(dev, 0x4064c4, 0x0086ffff);
-        }
-}
-
-static void
-nvc0_grctx_generate_tpbus(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x407804, 0x00000023);
-        nv_wr32(dev, 0x40780c, 0x0a418820);
-        nv_wr32(dev, 0x407810, 0x062080e6);
-        nv_wr32(dev, 0x407814, 0x020398a4);
-        nv_wr32(dev, 0x407818, 0x0e629062);
-        nv_wr32(dev, 0x40781c, 0x0a418820);
-        nv_wr32(dev, 0x407820, 0x000000e6);
-        nv_wr32(dev, 0x4078bc, 0x00000103);
-}
-
-static void
-nvc0_grctx_generate_ccache(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x408000, 0x00000000);
-        nv_wr32(dev, 0x408004, 0x00000000);
-        nv_wr32(dev, 0x408008, 0x00000018);
-        nv_wr32(dev, 0x40800c, 0x00000000);
-        nv_wr32(dev, 0x408010, 0x00000000);
-        nv_wr32(dev, 0x408014, 0x00000069);
-        nv_wr32(dev, 0x408018, 0xe100e100);
-        nv_wr32(dev, 0x408064, 0x00000000);
-}
-
-static void
-nvc0_grctx_generate_rop(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chipset = dev_priv->chipset;
-
-        /* ROPC_BROADCAST */
-        nv_wr32(dev, 0x408800, 0x02802a3c);
-        nv_wr32(dev, 0x408804, 0x00000040);
-        if (chipset == 0xd9) {
-                nv_wr32(dev, 0x408808, 0x1043e005);
-                nv_wr32(dev, 0x408900, 0x3080b801);
-                nv_wr32(dev, 0x408904, 0x1043e005);
-                nv_wr32(dev, 0x408908, 0x00c8102f);
-        } else
-        if (chipset == 0xc1) {
-                nv_wr32(dev, 0x408808, 0x1003e005);
-                nv_wr32(dev, 0x408900, 0x3080b801);
-                nv_wr32(dev, 0x408904, 0x62000001);
-                nv_wr32(dev, 0x408908, 0x00c80929);
-        } else {
-                nv_wr32(dev, 0x408808, 0x0003e00d);
-                nv_wr32(dev, 0x408900, 0x3080b801);
-                nv_wr32(dev, 0x408904, 0x02000001);
-                nv_wr32(dev, 0x408908, 0x00c80929);
-        }
-        nv_wr32(dev, 0x40890c, 0x00000000);
-        nv_wr32(dev, 0x408980, 0x0000011d);
-}
-
-static void
-nvc0_grctx_generate_gpc(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chipset = dev_priv->chipset;
-        int i;
-
-        /* GPC_BROADCAST */
-        nv_wr32(dev, 0x418380, 0x00000016);
-        nv_wr32(dev, 0x418400, 0x38004e00);
-        nv_wr32(dev, 0x418404, 0x71e0ffff);
-        nv_wr32(dev, 0x418408, 0x00000000);
-        nv_wr32(dev, 0x41840c, 0x00001008);
-        nv_wr32(dev, 0x418410, 0x0fff0fff);
-        nv_wr32(dev, 0x418414, chipset != 0xd9 ? 0x00200fff : 0x02200fff);
-        nv_wr32(dev, 0x418450, 0x00000000);
-        nv_wr32(dev, 0x418454, 0x00000000);
-        nv_wr32(dev, 0x418458, 0x00000000);
-        nv_wr32(dev, 0x41845c, 0x00000000);
-        nv_wr32(dev, 0x418460, 0x00000000);
-        nv_wr32(dev, 0x418464, 0x00000000);
-        nv_wr32(dev, 0x418468, 0x00000001);
-        nv_wr32(dev, 0x41846c, 0x00000000);
-        nv_wr32(dev, 0x418470, 0x00000000);
-        nv_wr32(dev, 0x418600, 0x0000001f);
-        nv_wr32(dev, 0x418684, 0x0000000f);
-        nv_wr32(dev, 0x418700, 0x00000002);
-        nv_wr32(dev, 0x418704, 0x00000080);
-        nv_wr32(dev, 0x418708, 0x00000000);
-        nv_wr32(dev, 0x41870c, chipset != 0xd9 ? 0x07c80000 : 0x00000000);
-        nv_wr32(dev, 0x418710, 0x00000000);
-        nv_wr32(dev, 0x418800, chipset != 0xd9 ? 0x0006860a : 0x7006860a);
-        nv_wr32(dev, 0x418808, 0x00000000);
-        nv_wr32(dev, 0x41880c, 0x00000000);
-        nv_wr32(dev, 0x418810, 0x00000000);
-        nv_wr32(dev, 0x418828, 0x00008442);
-        if (chipset == 0xc1 || chipset == 0xd9)
-                nv_wr32(dev, 0x418830, 0x10000001);
-        else
-                nv_wr32(dev, 0x418830, 0x00000001);
-        nv_wr32(dev, 0x4188d8, 0x00000008);
-        nv_wr32(dev, 0x4188e0, 0x01000000);
-        nv_wr32(dev, 0x4188e8, 0x00000000);
-        nv_wr32(dev, 0x4188ec, 0x00000000);
-        nv_wr32(dev, 0x4188f0, 0x00000000);
-        nv_wr32(dev, 0x4188f4, 0x00000000);
-        nv_wr32(dev, 0x4188f8, 0x00000000);
-        if (chipset == 0xd9)
-                nv_wr32(dev, 0x4188fc, 0x20100008);
-        else if (chipset == 0xc1)
-                nv_wr32(dev, 0x4188fc, 0x00100018);
-        else
-                nv_wr32(dev, 0x4188fc, 0x00100000);
-        nv_wr32(dev, 0x41891c, 0x00ff00ff);
-        nv_wr32(dev, 0x418924, 0x00000000);
-        nv_wr32(dev, 0x418928, 0x00ffff00);
-        nv_wr32(dev, 0x41892c, 0x0000ff00);
-        for (i = 0; i < 8; i++) {
-                nv_wr32(dev, 0x418a00 + (i * 0x20), 0x00000000);
-                nv_wr32(dev, 0x418a04 + (i * 0x20), 0x00000000);
-                nv_wr32(dev, 0x418a08 + (i * 0x20), 0x00000000);
-                nv_wr32(dev, 0x418a0c + (i * 0x20), 0x00010000);
-                nv_wr32(dev, 0x418a10 + (i * 0x20), 0x00000000);
-                nv_wr32(dev, 0x418a14 + (i * 0x20), 0x00000000);
-                nv_wr32(dev, 0x418a18 + (i * 0x20), 0x00000000);
-        }
-        nv_wr32(dev, 0x418b00, chipset != 0xd9 ? 0x00000000 : 0x00000006);
-        nv_wr32(dev, 0x418b08, 0x0a418820);
-        nv_wr32(dev, 0x418b0c, 0x062080e6);
-        nv_wr32(dev, 0x418b10, 0x020398a4);
-        nv_wr32(dev, 0x418b14, 0x0e629062);
-        nv_wr32(dev, 0x418b18, 0x0a418820);
-        nv_wr32(dev, 0x418b1c, 0x000000e6);
-        nv_wr32(dev, 0x418bb8, 0x00000103);
-        nv_wr32(dev, 0x418c08, 0x00000001);
-        nv_wr32(dev, 0x418c10, 0x00000000);
-        nv_wr32(dev, 0x418c14, 0x00000000);
-        nv_wr32(dev, 0x418c18, 0x00000000);
-        nv_wr32(dev, 0x418c1c, 0x00000000);
-        nv_wr32(dev, 0x418c20, 0x00000000);
-        nv_wr32(dev, 0x418c24, 0x00000000);
-        nv_wr32(dev, 0x418c28, 0x00000000);
-        nv_wr32(dev, 0x418c2c, 0x00000000);
-        if (chipset == 0xc1 || chipset == 0xd9)
-                nv_wr32(dev, 0x418c6c, 0x00000001);
-        nv_wr32(dev, 0x418c80, 0x20200004);
-        nv_wr32(dev, 0x418c8c, 0x00000001);
-        nv_wr32(dev, 0x419000, 0x00000780);
-        nv_wr32(dev, 0x419004, 0x00000000);
-        nv_wr32(dev, 0x419008, 0x00000000);
-        nv_wr32(dev, 0x419014, 0x00000004);
-}
-
-static void
-nvc0_grctx_generate_tp(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        int chipset = dev_priv->chipset;
-
-        /* GPC_BROADCAST.TP_BROADCAST */
-        nv_wr32(dev, 0x419818, 0x00000000);
-        nv_wr32(dev, 0x41983c, 0x00038bc7);
-        nv_wr32(dev, 0x419848, 0x00000000);
-        if (chipset == 0xc1 || chipset == 0xd9)
-                nv_wr32(dev, 0x419864, 0x00000129);
-        else
-                nv_wr32(dev, 0x419864, 0x0000012a);
-        nv_wr32(dev, 0x419888, 0x00000000);
-        nv_wr32(dev, 0x419a00, 0x000001f0);
-        nv_wr32(dev, 0x419a04, 0x00000001);
-        nv_wr32(dev, 0x419a08, 0x00000023);
-        nv_wr32(dev, 0x419a0c, 0x00020000);
-        nv_wr32(dev, 0x419a10, 0x00000000);
-        nv_wr32(dev, 0x419a14, 0x00000200);
-        nv_wr32(dev, 0x419a1c, 0x00000000);
-        nv_wr32(dev, 0x419a20, 0x00000800);
-        if (chipset == 0xd9)
-                nv_wr32(dev, 0x00419ac4, 0x0017f440);
-        else if (chipset != 0xc0 && chipset != 0xc8)
-                nv_wr32(dev, 0x00419ac4, 0x0007f440);
-        nv_wr32(dev, 0x419b00, 0x0a418820);
-        nv_wr32(dev, 0x419b04, 0x062080e6);
-        nv_wr32(dev, 0x419b08, 0x020398a4);
-        nv_wr32(dev, 0x419b0c, 0x0e629062);
-        nv_wr32(dev, 0x419b10, 0x0a418820);
-        nv_wr32(dev, 0x419b14, 0x000000e6);
-        nv_wr32(dev, 0x419bd0, 0x00900103);
-        if (chipset == 0xc1 || chipset == 0xd9)
-                nv_wr32(dev, 0x419be0, 0x00400001);
-        else
-                nv_wr32(dev, 0x419be0, 0x00000001);
-        nv_wr32(dev, 0x419be4, 0x00000000);
-        nv_wr32(dev, 0x419c00, chipset != 0xd9 ? 0x00000002 : 0x0000000a);
-        nv_wr32(dev, 0x419c04, 0x00000006);
-        nv_wr32(dev, 0x419c08, 0x00000002);
-        nv_wr32(dev, 0x419c20, 0x00000000);
-        if (dev_priv->chipset == 0xd9) {
-                nv_wr32(dev, 0x419c24, 0x00084210);
-                nv_wr32(dev, 0x419c28, 0x3cf3cf3c);
-                nv_wr32(dev, 0x419cb0, 0x00020048);
-        } else
-        if (chipset == 0xce || chipset == 0xcf) {
-                nv_wr32(dev, 0x419cb0, 0x00020048);
-        } else {
-                nv_wr32(dev, 0x419cb0, 0x00060048);
-        }
-        nv_wr32(dev, 0x419ce8, 0x00000000);
-        nv_wr32(dev, 0x419cf4, 0x00000183);
-        if (chipset == 0xc1 || chipset == 0xd9)
-                nv_wr32(dev, 0x419d20, 0x12180000);
-        else
-                nv_wr32(dev, 0x419d20, 0x02180000);
-        nv_wr32(dev, 0x419d24, 0x00001fff);
-        if (chipset == 0xc1 || chipset == 0xd9)
-                nv_wr32(dev, 0x419d44, 0x02180218);
-        nv_wr32(dev, 0x419e04, 0x00000000);
-        nv_wr32(dev, 0x419e08, 0x00000000);
-        nv_wr32(dev, 0x419e0c, 0x00000000);
-        nv_wr32(dev, 0x419e10, 0x00000002);
-        nv_wr32(dev, 0x419e44, 0x001beff2);
-        nv_wr32(dev, 0x419e48, 0x00000000);
-        nv_wr32(dev, 0x419e4c, 0x0000000f);
-        nv_wr32(dev, 0x419e50, 0x00000000);
-        nv_wr32(dev, 0x419e54, 0x00000000);
-        nv_wr32(dev, 0x419e58, 0x00000000);
-        nv_wr32(dev, 0x419e5c, 0x00000000);
-        nv_wr32(dev, 0x419e60, 0x00000000);
-        nv_wr32(dev, 0x419e64, 0x00000000);
-        nv_wr32(dev, 0x419e68, 0x00000000);
-        nv_wr32(dev, 0x419e6c, 0x00000000);
-        nv_wr32(dev, 0x419e70, 0x00000000);
-        nv_wr32(dev, 0x419e74, 0x00000000);
-        nv_wr32(dev, 0x419e78, 0x00000000);
-        nv_wr32(dev, 0x419e7c, 0x00000000);
-        nv_wr32(dev, 0x419e80, 0x00000000);
-        nv_wr32(dev, 0x419e84, 0x00000000);
-        nv_wr32(dev, 0x419e88, 0x00000000);
-        nv_wr32(dev, 0x419e8c, 0x00000000);
-        nv_wr32(dev, 0x419e90, 0x00000000);
-        nv_wr32(dev, 0x419e98, 0x00000000);
-        if (chipset != 0xc0 && chipset != 0xc8)
-                nv_wr32(dev, 0x419ee0, 0x00011110);
-        nv_wr32(dev, 0x419f50, 0x00000000);
-        nv_wr32(dev, 0x419f54, 0x00000000);
-        if (chipset != 0xc0 && chipset != 0xc8)
-                nv_wr32(dev, 0x419f58, 0x00000000);
-}
-
-int
-nvc0_grctx_generate(struct nouveau_channel *chan)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct nvc0_graph_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_GR);
-        struct nvc0_graph_chan *grch = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        int i, gpc, tp, id;
-        u32 fermi = nvc0_graph_class(dev);
-        u32 r000260, tmp;
-
-        r000260 = nv_rd32(dev, 0x000260);
-        nv_wr32(dev, 0x000260, r000260 & ~1);
-        nv_wr32(dev, 0x400208, 0x00000000);
-
-        nvc0_grctx_generate_dispatch(dev);
-        nvc0_grctx_generate_macro(dev);
-        nvc0_grctx_generate_m2mf(dev);
-        nvc0_grctx_generate_unk47xx(dev);
-        nvc0_grctx_generate_shaders(dev);
-        nvc0_grctx_generate_unk60xx(dev);
-        nvc0_grctx_generate_unk64xx(dev);
-        nvc0_grctx_generate_tpbus(dev);
-        nvc0_grctx_generate_ccache(dev);
-        nvc0_grctx_generate_rop(dev);
-        nvc0_grctx_generate_gpc(dev);
-        nvc0_grctx_generate_tp(dev);
-
-        nv_wr32(dev, 0x404154, 0x00000000);
-
-        /* fuc "mmio list" writes */
-        for (i = 0; i < grch->mmio_nr * 8; i += 8) {
-                u32 reg = nv_ro32(grch->mmio, i + 0);
-                nv_wr32(dev, reg, nv_ro32(grch->mmio, i + 4));
-        }
-
-        for (tp = 0, id = 0; tp < 4; tp++) {
-                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                        if (tp < priv->tp_nr[gpc]) {
-                                nv_wr32(dev, TP_UNIT(gpc, tp, 0x698), id);
-                                nv_wr32(dev, TP_UNIT(gpc, tp, 0x4e8), id);
-                                nv_wr32(dev, GPC_UNIT(gpc, 0x0c10 + tp * 4), id);
-                                nv_wr32(dev, TP_UNIT(gpc, tp, 0x088), id);
-                                id++;
-                        }
-
-                        nv_wr32(dev, GPC_UNIT(gpc, 0x0c08), priv->tp_nr[gpc]);
-                        nv_wr32(dev, GPC_UNIT(gpc, 0x0c8c), priv->tp_nr[gpc]);
-                }
-        }
-
-        tmp = 0;
-        for (i = 0; i < priv->gpc_nr; i++)
-                tmp |= priv->tp_nr[i] << (i * 4);
-        nv_wr32(dev, 0x406028, tmp);
-        nv_wr32(dev, 0x405870, tmp);
-
-        nv_wr32(dev, 0x40602c, 0x00000000);
-        nv_wr32(dev, 0x405874, 0x00000000);
-        nv_wr32(dev, 0x406030, 0x00000000);
-        nv_wr32(dev, 0x405878, 0x00000000);
-        nv_wr32(dev, 0x406034, 0x00000000);
-        nv_wr32(dev, 0x40587c, 0x00000000);
-
-        if (1) {
-                u8 tpnr[GPC_MAX], data[TP_MAX];
-
-                memcpy(tpnr, priv->tp_nr, sizeof(priv->tp_nr));
-                memset(data, 0x1f, sizeof(data));
-
-                gpc = -1;
-                for (tp = 0; tp < priv->tp_total; tp++) {
-                        do {
-                                gpc = (gpc + 1) % priv->gpc_nr;
-                        } while (!tpnr[gpc]);
-                        tpnr[gpc]--;
-                        data[tp] = gpc;
-                }
-
-                for (i = 0; i < 4; i++)
-                        nv_wr32(dev, 0x4060a8 + (i * 4), ((u32 *)data)[i]);
-        }
-
-        if (1) {
-                u32 data[6] = {}, data2[2] = {};
-                u8 tpnr[GPC_MAX];
-                u8 shift, ntpcv;
-
-                /* calculate first set of magics */
-                memcpy(tpnr, priv->tp_nr, sizeof(priv->tp_nr));
-
-                gpc = -1;
-                for (tp = 0; tp < priv->tp_total; tp++) {
-                        do {
-                                gpc = (gpc + 1) % priv->gpc_nr;
-                        } while (!tpnr[gpc]);
-                        tpnr[gpc]--;
-
-                        data[tp / 6] |= gpc << ((tp % 6) * 5);
-                }
-
-                for (; tp < 32; tp++)
-                        data[tp / 6] |= 7 << ((tp % 6) * 5);
-
-                /* and the second... */
-                shift = 0;
-                ntpcv = priv->tp_total;
-                while (!(ntpcv & (1 << 4))) {
-                        ntpcv <<= 1;
-                        shift++;
-                }
-
-                data2[0]  = (ntpcv << 16);
-                data2[0] |= (shift << 21);
-                data2[0] |= (((1 << (0 + 5)) % ntpcv) << 24);
-                for (i = 1; i < 7; i++)
-                        data2[1] |= ((1 << (i + 5)) % ntpcv) << ((i - 1) * 5);
-
-                /* GPC_BROADCAST */
-                nv_wr32(dev, 0x418bb8, (priv->tp_total << 8) |
-                                        priv->magic_not_rop_nr);
-                for (i = 0; i < 6; i++)
-                        nv_wr32(dev, 0x418b08 + (i * 4), data[i]);
-
-                /* GPC_BROADCAST.TP_BROADCAST */
-                nv_wr32(dev, 0x419bd0, (priv->tp_total << 8) |
-                                       priv->magic_not_rop_nr |
-                                       data2[0]);
-                nv_wr32(dev, 0x419be4, data2[1]);
-                for (i = 0; i < 6; i++)
-                        nv_wr32(dev, 0x419b00 + (i * 4), data[i]);
-
-                /* UNK78xx */
-                nv_wr32(dev, 0x4078bc, (priv->tp_total << 8) |
-                                        priv->magic_not_rop_nr);
-                for (i = 0; i < 6; i++)
-                        nv_wr32(dev, 0x40780c + (i * 4), data[i]);
-        }
-
-        if (1) {
-                u32 tp_mask = 0, tp_set = 0;
-                u8  tpnr[GPC_MAX], a, b;
-
-                memcpy(tpnr, priv->tp_nr, sizeof(priv->tp_nr));
-                for (gpc = 0; gpc < priv->gpc_nr; gpc++)
-                        tp_mask |= ((1 << priv->tp_nr[gpc]) - 1) << (gpc * 8);
-
-                for (i = 0, gpc = -1, b = -1; i < 32; i++) {
-                        a = (i * (priv->tp_total - 1)) / 32;
-                        if (a != b) {
-                                b = a;
-                                do {
-                                        gpc = (gpc + 1) % priv->gpc_nr;
-                                } while (!tpnr[gpc]);
-                                tp = priv->tp_nr[gpc] - tpnr[gpc]--;
-
-                                tp_set |= 1 << ((gpc * 8) + tp);
-                        }
-
-                        nv_wr32(dev, 0x406800 + (i * 0x20), tp_set);
-                        nv_wr32(dev, 0x406c00 + (i * 0x20), tp_set ^ tp_mask);
-                }
-        }
-
-        nv_wr32(dev, 0x400208, 0x80000000);
-
-        nv_icmd(dev, 0x00001000, 0x00000004);
-        nv_icmd(dev, 0x000000a9, 0x0000ffff);
-        nv_icmd(dev, 0x00000038, 0x0fac6881);
-        nv_icmd(dev, 0x0000003d, 0x00000001);
-        nv_icmd(dev, 0x000000e8, 0x00000400);
-        nv_icmd(dev, 0x000000e9, 0x00000400);
-        nv_icmd(dev, 0x000000ea, 0x00000400);
-        nv_icmd(dev, 0x000000eb, 0x00000400);
-        nv_icmd(dev, 0x000000ec, 0x00000400);
-        nv_icmd(dev, 0x000000ed, 0x00000400);
-        nv_icmd(dev, 0x000000ee, 0x00000400);
-        nv_icmd(dev, 0x000000ef, 0x00000400);
-        nv_icmd(dev, 0x00000078, 0x00000300);
-        nv_icmd(dev, 0x00000079, 0x00000300);
-        nv_icmd(dev, 0x0000007a, 0x00000300);
-        nv_icmd(dev, 0x0000007b, 0x00000300);
-        nv_icmd(dev, 0x0000007c, 0x00000300);
-        nv_icmd(dev, 0x0000007d, 0x00000300);
-        nv_icmd(dev, 0x0000007e, 0x00000300);
-        nv_icmd(dev, 0x0000007f, 0x00000300);
-        nv_icmd(dev, 0x00000050, 0x00000011);
-        nv_icmd(dev, 0x00000058, 0x00000008);
-        nv_icmd(dev, 0x00000059, 0x00000008);
-        nv_icmd(dev, 0x0000005a, 0x00000008);
-        nv_icmd(dev, 0x0000005b, 0x00000008);
-        nv_icmd(dev, 0x0000005c, 0x00000008);
-        nv_icmd(dev, 0x0000005d, 0x00000008);
-        nv_icmd(dev, 0x0000005e, 0x00000008);
-        nv_icmd(dev, 0x0000005f, 0x00000008);
-        nv_icmd(dev, 0x00000208, 0x00000001);
-        nv_icmd(dev, 0x00000209, 0x00000001);
-        nv_icmd(dev, 0x0000020a, 0x00000001);
-        nv_icmd(dev, 0x0000020b, 0x00000001);
-        nv_icmd(dev, 0x0000020c, 0x00000001);
-        nv_icmd(dev, 0x0000020d, 0x00000001);
-        nv_icmd(dev, 0x0000020e, 0x00000001);
-        nv_icmd(dev, 0x0000020f, 0x00000001);
-        nv_icmd(dev, 0x00000081, 0x00000001);
-        nv_icmd(dev, 0x00000085, 0x00000004);
-        nv_icmd(dev, 0x00000088, 0x00000400);
-        nv_icmd(dev, 0x00000090, 0x00000300);
-        nv_icmd(dev, 0x00000098, 0x00001001);
-        nv_icmd(dev, 0x000000e3, 0x00000001);
-        nv_icmd(dev, 0x000000da, 0x00000001);
-        nv_icmd(dev, 0x000000f8, 0x00000003);
-        nv_icmd(dev, 0x000000fa, 0x00000001);
-        nv_icmd(dev, 0x0000009f, 0x0000ffff);
-        nv_icmd(dev, 0x000000a0, 0x0000ffff);
-        nv_icmd(dev, 0x000000a1, 0x0000ffff);
-        nv_icmd(dev, 0x000000a2, 0x0000ffff);
-        nv_icmd(dev, 0x000000b1, 0x00000001);
-        nv_icmd(dev, 0x000000b2, 0x00000000);
-        nv_icmd(dev, 0x000000b3, 0x00000000);
-        nv_icmd(dev, 0x000000b4, 0x00000000);
-        nv_icmd(dev, 0x000000b5, 0x00000000);
-        nv_icmd(dev, 0x000000b6, 0x00000000);
-        nv_icmd(dev, 0x000000b7, 0x00000000);
-        nv_icmd(dev, 0x000000b8, 0x00000000);
-        nv_icmd(dev, 0x000000b9, 0x00000000);
-        nv_icmd(dev, 0x000000ba, 0x00000000);
-        nv_icmd(dev, 0x000000bb, 0x00000000);
-        nv_icmd(dev, 0x000000bc, 0x00000000);
-        nv_icmd(dev, 0x000000bd, 0x00000000);
-        nv_icmd(dev, 0x000000be, 0x00000000);
-        nv_icmd(dev, 0x000000bf, 0x00000000);
-        nv_icmd(dev, 0x000000c0, 0x00000000);
-        nv_icmd(dev, 0x000000c1, 0x00000000);
-        nv_icmd(dev, 0x000000c2, 0x00000000);
-        nv_icmd(dev, 0x000000c3, 0x00000000);
-        nv_icmd(dev, 0x000000c4, 0x00000000);
-        nv_icmd(dev, 0x000000c5, 0x00000000);
-        nv_icmd(dev, 0x000000c6, 0x00000000);
-        nv_icmd(dev, 0x000000c7, 0x00000000);
-        nv_icmd(dev, 0x000000c8, 0x00000000);
-        nv_icmd(dev, 0x000000c9, 0x00000000);
-        nv_icmd(dev, 0x000000ca, 0x00000000);
-        nv_icmd(dev, 0x000000cb, 0x00000000);
-        nv_icmd(dev, 0x000000cc, 0x00000000);
-        nv_icmd(dev, 0x000000cd, 0x00000000);
-        nv_icmd(dev, 0x000000ce, 0x00000000);
-        nv_icmd(dev, 0x000000cf, 0x00000000);
-        nv_icmd(dev, 0x000000d0, 0x00000000);
-        nv_icmd(dev, 0x000000d1, 0x00000000);
-        nv_icmd(dev, 0x000000d2, 0x00000000);
-        nv_icmd(dev, 0x000000d3, 0x00000000);
-        nv_icmd(dev, 0x000000d4, 0x00000000);
-        nv_icmd(dev, 0x000000d5, 0x00000000);
-        nv_icmd(dev, 0x000000d6, 0x00000000);
-        nv_icmd(dev, 0x000000d7, 0x00000000);
-        nv_icmd(dev, 0x000000d8, 0x00000000);
-        nv_icmd(dev, 0x000000d9, 0x00000000);
-        nv_icmd(dev, 0x00000210, 0x00000040);
-        nv_icmd(dev, 0x00000211, 0x00000040);
-        nv_icmd(dev, 0x00000212, 0x00000040);
-        nv_icmd(dev, 0x00000213, 0x00000040);
-        nv_icmd(dev, 0x00000214, 0x00000040);
-        nv_icmd(dev, 0x00000215, 0x00000040);
-        nv_icmd(dev, 0x00000216, 0x00000040);
-        nv_icmd(dev, 0x00000217, 0x00000040);
-        if (dev_priv->chipset == 0xd9) {
-                for (i = 0x0400; i <= 0x0417; i++)
-                        nv_icmd(dev, i, 0x00000040);
-        }
-        nv_icmd(dev, 0x00000218, 0x0000c080);
-        nv_icmd(dev, 0x00000219, 0x0000c080);
-        nv_icmd(dev, 0x0000021a, 0x0000c080);
-        nv_icmd(dev, 0x0000021b, 0x0000c080);
-        nv_icmd(dev, 0x0000021c, 0x0000c080);
-        nv_icmd(dev, 0x0000021d, 0x0000c080);
-        nv_icmd(dev, 0x0000021e, 0x0000c080);
-        nv_icmd(dev, 0x0000021f, 0x0000c080);
-        if (dev_priv->chipset == 0xd9) {
-                for (i = 0x0440; i <= 0x0457; i++)
-                        nv_icmd(dev, i, 0x0000c080);
-        }
-        nv_icmd(dev, 0x000000ad, 0x0000013e);
-        nv_icmd(dev, 0x000000e1, 0x00000010);
-        nv_icmd(dev, 0x00000290, 0x00000000);
-        nv_icmd(dev, 0x00000291, 0x00000000);
-        nv_icmd(dev, 0x00000292, 0x00000000);
-        nv_icmd(dev, 0x00000293, 0x00000000);
-        nv_icmd(dev, 0x00000294, 0x00000000);
-        nv_icmd(dev, 0x00000295, 0x00000000);
-        nv_icmd(dev, 0x00000296, 0x00000000);
-        nv_icmd(dev, 0x00000297, 0x00000000);
-        nv_icmd(dev, 0x00000298, 0x00000000);
-        nv_icmd(dev, 0x00000299, 0x00000000);
-        nv_icmd(dev, 0x0000029a, 0x00000000);
-        nv_icmd(dev, 0x0000029b, 0x00000000);
-        nv_icmd(dev, 0x0000029c, 0x00000000);
-        nv_icmd(dev, 0x0000029d, 0x00000000);
-        nv_icmd(dev, 0x0000029e, 0x00000000);
-        nv_icmd(dev, 0x0000029f, 0x00000000);
-        nv_icmd(dev, 0x000003b0, 0x00000000);
-        nv_icmd(dev, 0x000003b1, 0x00000000);
-        nv_icmd(dev, 0x000003b2, 0x00000000);
-        nv_icmd(dev, 0x000003b3, 0x00000000);
-        nv_icmd(dev, 0x000003b4, 0x00000000);
-        nv_icmd(dev, 0x000003b5, 0x00000000);
-        nv_icmd(dev, 0x000003b6, 0x00000000);
-        nv_icmd(dev, 0x000003b7, 0x00000000);
-        nv_icmd(dev, 0x000003b8, 0x00000000);
-        nv_icmd(dev, 0x000003b9, 0x00000000);
-        nv_icmd(dev, 0x000003ba, 0x00000000);
-        nv_icmd(dev, 0x000003bb, 0x00000000);
-        nv_icmd(dev, 0x000003bc, 0x00000000);
-        nv_icmd(dev, 0x000003bd, 0x00000000);
-        nv_icmd(dev, 0x000003be, 0x00000000);
-        nv_icmd(dev, 0x000003bf, 0x00000000);
-        nv_icmd(dev, 0x000002a0, 0x00000000);
-        nv_icmd(dev, 0x000002a1, 0x00000000);
-        nv_icmd(dev, 0x000002a2, 0x00000000);
-        nv_icmd(dev, 0x000002a3, 0x00000000);
-        nv_icmd(dev, 0x000002a4, 0x00000000);
-        nv_icmd(dev, 0x000002a5, 0x00000000);
-        nv_icmd(dev, 0x000002a6, 0x00000000);
-        nv_icmd(dev, 0x000002a7, 0x00000000);
-        nv_icmd(dev, 0x000002a8, 0x00000000);
-        nv_icmd(dev, 0x000002a9, 0x00000000);
-        nv_icmd(dev, 0x000002aa, 0x00000000);
-        nv_icmd(dev, 0x000002ab, 0x00000000);
-        nv_icmd(dev, 0x000002ac, 0x00000000);
-        nv_icmd(dev, 0x000002ad, 0x00000000);
-        nv_icmd(dev, 0x000002ae, 0x00000000);
-        nv_icmd(dev, 0x000002af, 0x00000000);
-        nv_icmd(dev, 0x00000420, 0x00000000);
-        nv_icmd(dev, 0x00000421, 0x00000000);
-        nv_icmd(dev, 0x00000422, 0x00000000);
-        nv_icmd(dev, 0x00000423, 0x00000000);
-        nv_icmd(dev, 0x00000424, 0x00000000);
-        nv_icmd(dev, 0x00000425, 0x00000000);
-        nv_icmd(dev, 0x00000426, 0x00000000);
-        nv_icmd(dev, 0x00000427, 0x00000000);
-        nv_icmd(dev, 0x00000428, 0x00000000);
-        nv_icmd(dev, 0x00000429, 0x00000000);
-        nv_icmd(dev, 0x0000042a, 0x00000000);
-        nv_icmd(dev, 0x0000042b, 0x00000000);
-        nv_icmd(dev, 0x0000042c, 0x00000000);
-        nv_icmd(dev, 0x0000042d, 0x00000000);
-        nv_icmd(dev, 0x0000042e, 0x00000000);
-        nv_icmd(dev, 0x0000042f, 0x00000000);
-        nv_icmd(dev, 0x000002b0, 0x00000000);
-        nv_icmd(dev, 0x000002b1, 0x00000000);
-        nv_icmd(dev, 0x000002b2, 0x00000000);
-        nv_icmd(dev, 0x000002b3, 0x00000000);
-        nv_icmd(dev, 0x000002b4, 0x00000000);
-        nv_icmd(dev, 0x000002b5, 0x00000000);
-        nv_icmd(dev, 0x000002b6, 0x00000000);
-        nv_icmd(dev, 0x000002b7, 0x00000000);
-        nv_icmd(dev, 0x000002b8, 0x00000000);
-        nv_icmd(dev, 0x000002b9, 0x00000000);
-        nv_icmd(dev, 0x000002ba, 0x00000000);
-        nv_icmd(dev, 0x000002bb, 0x00000000);
-        nv_icmd(dev, 0x000002bc, 0x00000000);
-        nv_icmd(dev, 0x000002bd, 0x00000000);
-        nv_icmd(dev, 0x000002be, 0x00000000);
-        nv_icmd(dev, 0x000002bf, 0x00000000);
-        nv_icmd(dev, 0x00000430, 0x00000000);
-        nv_icmd(dev, 0x00000431, 0x00000000);
-        nv_icmd(dev, 0x00000432, 0x00000000);
-        nv_icmd(dev, 0x00000433, 0x00000000);
-        nv_icmd(dev, 0x00000434, 0x00000000);
-        nv_icmd(dev, 0x00000435, 0x00000000);
-        nv_icmd(dev, 0x00000436, 0x00000000);
-        nv_icmd(dev, 0x00000437, 0x00000000);
-        nv_icmd(dev, 0x00000438, 0x00000000);
-        nv_icmd(dev, 0x00000439, 0x00000000);
-        nv_icmd(dev, 0x0000043a, 0x00000000);
-        nv_icmd(dev, 0x0000043b, 0x00000000);
-        nv_icmd(dev, 0x0000043c, 0x00000000);
-        nv_icmd(dev, 0x0000043d, 0x00000000);
-        nv_icmd(dev, 0x0000043e, 0x00000000);
-        nv_icmd(dev, 0x0000043f, 0x00000000);
-        nv_icmd(dev, 0x000002c0, 0x00000000);
-        nv_icmd(dev, 0x000002c1, 0x00000000);
-        nv_icmd(dev, 0x000002c2, 0x00000000);
-        nv_icmd(dev, 0x000002c3, 0x00000000);
-        nv_icmd(dev, 0x000002c4, 0x00000000);
-        nv_icmd(dev, 0x000002c5, 0x00000000);
-        nv_icmd(dev, 0x000002c6, 0x00000000);
-        nv_icmd(dev, 0x000002c7, 0x00000000);
-        nv_icmd(dev, 0x000002c8, 0x00000000);
-        nv_icmd(dev, 0x000002c9, 0x00000000);
-        nv_icmd(dev, 0x000002ca, 0x00000000);
-        nv_icmd(dev, 0x000002cb, 0x00000000);
-        nv_icmd(dev, 0x000002cc, 0x00000000);
-        nv_icmd(dev, 0x000002cd, 0x00000000);
-        nv_icmd(dev, 0x000002ce, 0x00000000);
-        nv_icmd(dev, 0x000002cf, 0x00000000);
-        nv_icmd(dev, 0x000004d0, 0x00000000);
-        nv_icmd(dev, 0x000004d1, 0x00000000);
-        nv_icmd(dev, 0x000004d2, 0x00000000);
-        nv_icmd(dev, 0x000004d3, 0x00000000);
-        nv_icmd(dev, 0x000004d4, 0x00000000);
-        nv_icmd(dev, 0x000004d5, 0x00000000);
-        nv_icmd(dev, 0x000004d6, 0x00000000);
-        nv_icmd(dev, 0x000004d7, 0x00000000);
-        nv_icmd(dev, 0x000004d8, 0x00000000);
-        nv_icmd(dev, 0x000004d9, 0x00000000);
-        nv_icmd(dev, 0x000004da, 0x00000000);
-        nv_icmd(dev, 0x000004db, 0x00000000);
-        nv_icmd(dev, 0x000004dc, 0x00000000);
-        nv_icmd(dev, 0x000004dd, 0x00000000);
-        nv_icmd(dev, 0x000004de, 0x00000000);
-        nv_icmd(dev, 0x000004df, 0x00000000);
-        nv_icmd(dev, 0x00000720, 0x00000000);
-        nv_icmd(dev, 0x00000721, 0x00000000);
-        nv_icmd(dev, 0x00000722, 0x00000000);
-        nv_icmd(dev, 0x00000723, 0x00000000);
-        nv_icmd(dev, 0x00000724, 0x00000000);
-        nv_icmd(dev, 0x00000725, 0x00000000);
-        nv_icmd(dev, 0x00000726, 0x00000000);
-        nv_icmd(dev, 0x00000727, 0x00000000);
-        nv_icmd(dev, 0x00000728, 0x00000000);
-        nv_icmd(dev, 0x00000729, 0x00000000);
-        nv_icmd(dev, 0x0000072a, 0x00000000);
-        nv_icmd(dev, 0x0000072b, 0x00000000);
-        nv_icmd(dev, 0x0000072c, 0x00000000);
-        nv_icmd(dev, 0x0000072d, 0x00000000);
-        nv_icmd(dev, 0x0000072e, 0x00000000);
-        nv_icmd(dev, 0x0000072f, 0x00000000);
-        nv_icmd(dev, 0x000008c0, 0x00000000);
-        nv_icmd(dev, 0x000008c1, 0x00000000);
-        nv_icmd(dev, 0x000008c2, 0x00000000);
-        nv_icmd(dev, 0x000008c3, 0x00000000);
-        nv_icmd(dev, 0x000008c4, 0x00000000);
-        nv_icmd(dev, 0x000008c5, 0x00000000);
-        nv_icmd(dev, 0x000008c6, 0x00000000);
-        nv_icmd(dev, 0x000008c7, 0x00000000);
-        nv_icmd(dev, 0x000008c8, 0x00000000);
-        nv_icmd(dev, 0x000008c9, 0x00000000);
-        nv_icmd(dev, 0x000008ca, 0x00000000);
-        nv_icmd(dev, 0x000008cb, 0x00000000);
-        nv_icmd(dev, 0x000008cc, 0x00000000);
-        nv_icmd(dev, 0x000008cd, 0x00000000);
-        nv_icmd(dev, 0x000008ce, 0x00000000);
-        nv_icmd(dev, 0x000008cf, 0x00000000);
-        nv_icmd(dev, 0x00000890, 0x00000000);
-        nv_icmd(dev, 0x00000891, 0x00000000);
-        nv_icmd(dev, 0x00000892, 0x00000000);
-        nv_icmd(dev, 0x00000893, 0x00000000);
-        nv_icmd(dev, 0x00000894, 0x00000000);
-        nv_icmd(dev, 0x00000895, 0x00000000);
-        nv_icmd(dev, 0x00000896, 0x00000000);
-        nv_icmd(dev, 0x00000897, 0x00000000);
-        nv_icmd(dev, 0x00000898, 0x00000000);
-        nv_icmd(dev, 0x00000899, 0x00000000);
-        nv_icmd(dev, 0x0000089a, 0x00000000);
-        nv_icmd(dev, 0x0000089b, 0x00000000);
-        nv_icmd(dev, 0x0000089c, 0x00000000);
-        nv_icmd(dev, 0x0000089d, 0x00000000);
-        nv_icmd(dev, 0x0000089e, 0x00000000);
-        nv_icmd(dev, 0x0000089f, 0x00000000);
-        nv_icmd(dev, 0x000008e0, 0x00000000);
-        nv_icmd(dev, 0x000008e1, 0x00000000);
-        nv_icmd(dev, 0x000008e2, 0x00000000);
-        nv_icmd(dev, 0x000008e3, 0x00000000);
-        nv_icmd(dev, 0x000008e4, 0x00000000);
-        nv_icmd(dev, 0x000008e5, 0x00000000);
-        nv_icmd(dev, 0x000008e6, 0x00000000);
-        nv_icmd(dev, 0x000008e7, 0x00000000);
-        nv_icmd(dev, 0x000008e8, 0x00000000);
-        nv_icmd(dev, 0x000008e9, 0x00000000);
-        nv_icmd(dev, 0x000008ea, 0x00000000);
-        nv_icmd(dev, 0x000008eb, 0x00000000);
-        nv_icmd(dev, 0x000008ec, 0x00000000);
-        nv_icmd(dev, 0x000008ed, 0x00000000);
-        nv_icmd(dev, 0x000008ee, 0x00000000);
-        nv_icmd(dev, 0x000008ef, 0x00000000);
-        nv_icmd(dev, 0x000008a0, 0x00000000);
-        nv_icmd(dev, 0x000008a1, 0x00000000);
-        nv_icmd(dev, 0x000008a2, 0x00000000);
-        nv_icmd(dev, 0x000008a3, 0x00000000);
-        nv_icmd(dev, 0x000008a4, 0x00000000);
-        nv_icmd(dev, 0x000008a5, 0x00000000);
-        nv_icmd(dev, 0x000008a6, 0x00000000);
-        nv_icmd(dev, 0x000008a7, 0x00000000);
-        nv_icmd(dev, 0x000008a8, 0x00000000);
-        nv_icmd(dev, 0x000008a9, 0x00000000);
-        nv_icmd(dev, 0x000008aa, 0x00000000);
-        nv_icmd(dev, 0x000008ab, 0x00000000);
-        nv_icmd(dev, 0x000008ac, 0x00000000);
-        nv_icmd(dev, 0x000008ad, 0x00000000);
-        nv_icmd(dev, 0x000008ae, 0x00000000);
-        nv_icmd(dev, 0x000008af, 0x00000000);
-        nv_icmd(dev, 0x000008f0, 0x00000000);
-        nv_icmd(dev, 0x000008f1, 0x00000000);
-        nv_icmd(dev, 0x000008f2, 0x00000000);
-        nv_icmd(dev, 0x000008f3, 0x00000000);
-        nv_icmd(dev, 0x000008f4, 0x00000000);
-        nv_icmd(dev, 0x000008f5, 0x00000000);
-        nv_icmd(dev, 0x000008f6, 0x00000000);
-        nv_icmd(dev, 0x000008f7, 0x00000000);
-        nv_icmd(dev, 0x000008f8, 0x00000000);
-        nv_icmd(dev, 0x000008f9, 0x00000000);
-        nv_icmd(dev, 0x000008fa, 0x00000000);
-        nv_icmd(dev, 0x000008fb, 0x00000000);
-        nv_icmd(dev, 0x000008fc, 0x00000000);
-        nv_icmd(dev, 0x000008fd, 0x00000000);
-        nv_icmd(dev, 0x000008fe, 0x00000000);
-        nv_icmd(dev, 0x000008ff, 0x00000000);
-        nv_icmd(dev, 0x0000094c, 0x000000ff);
-        nv_icmd(dev, 0x0000094d, 0xffffffff);
-        nv_icmd(dev, 0x0000094e, 0x00000002);
-        nv_icmd(dev, 0x000002ec, 0x00000001);
-        nv_icmd(dev, 0x00000303, 0x00000001);
-        nv_icmd(dev, 0x000002e6, 0x00000001);
-        nv_icmd(dev, 0x00000466, 0x00000052);
-        nv_icmd(dev, 0x00000301, 0x3f800000);
-        nv_icmd(dev, 0x00000304, 0x30201000);
-        nv_icmd(dev, 0x00000305, 0x70605040);
-        nv_icmd(dev, 0x00000306, 0xb8a89888);
-        nv_icmd(dev, 0x00000307, 0xf8e8d8c8);
-        nv_icmd(dev, 0x0000030a, 0x00ffff00);
-        nv_icmd(dev, 0x0000030b, 0x0000001a);
-        nv_icmd(dev, 0x0000030c, 0x00000001);
-        nv_icmd(dev, 0x00000318, 0x00000001);
-        nv_icmd(dev, 0x00000340, 0x00000000);
-        nv_icmd(dev, 0x00000375, 0x00000001);
-        nv_icmd(dev, 0x00000351, 0x00000100);
-        nv_icmd(dev, 0x0000037d, 0x00000006);
-        nv_icmd(dev, 0x000003a0, 0x00000002);
-        nv_icmd(dev, 0x000003aa, 0x00000001);
-        nv_icmd(dev, 0x000003a9, 0x00000001);
-        nv_icmd(dev, 0x00000380, 0x00000001);
-        nv_icmd(dev, 0x00000360, 0x00000040);
-        nv_icmd(dev, 0x00000366, 0x00000000);
-        nv_icmd(dev, 0x00000367, 0x00000000);
-        nv_icmd(dev, 0x00000368, 0x00001fff);
-        nv_icmd(dev, 0x00000370, 0x00000000);
-        nv_icmd(dev, 0x00000371, 0x00000000);
-        nv_icmd(dev, 0x00000372, 0x003fffff);
-        nv_icmd(dev, 0x0000037a, 0x00000012);
-        nv_icmd(dev, 0x000005e0, 0x00000022);
-        nv_icmd(dev, 0x000005e1, 0x00000022);
-        nv_icmd(dev, 0x000005e2, 0x00000022);
-        nv_icmd(dev, 0x000005e3, 0x00000022);
-        nv_icmd(dev, 0x000005e4, 0x00000022);
-        nv_icmd(dev, 0x00000619, 0x00000003);
-        nv_icmd(dev, 0x00000811, 0x00000003);
-        nv_icmd(dev, 0x00000812, 0x00000004);
-        nv_icmd(dev, 0x00000813, 0x00000006);
-        nv_icmd(dev, 0x00000814, 0x00000008);
-        nv_icmd(dev, 0x00000815, 0x0000000b);
-        nv_icmd(dev, 0x00000800, 0x00000001);
-        nv_icmd(dev, 0x00000801, 0x00000001);
-        nv_icmd(dev, 0x00000802, 0x00000001);
-        nv_icmd(dev, 0x00000803, 0x00000001);
-        nv_icmd(dev, 0x00000804, 0x00000001);
-        nv_icmd(dev, 0x00000805, 0x00000001);
-        nv_icmd(dev, 0x00000632, 0x00000001);
-        nv_icmd(dev, 0x00000633, 0x00000002);
-        nv_icmd(dev, 0x00000634, 0x00000003);
-        nv_icmd(dev, 0x00000635, 0x00000004);
-        nv_icmd(dev, 0x00000654, 0x3f800000);
-        nv_icmd(dev, 0x00000657, 0x3f800000);
-        nv_icmd(dev, 0x00000655, 0x3f800000);
-        nv_icmd(dev, 0x00000656, 0x3f800000);
-        nv_icmd(dev, 0x000006cd, 0x3f800000);
-        nv_icmd(dev, 0x000007f5, 0x3f800000);
-        nv_icmd(dev, 0x000007dc, 0x39291909);
-        nv_icmd(dev, 0x000007dd, 0x79695949);
-        nv_icmd(dev, 0x000007de, 0xb9a99989);
-        nv_icmd(dev, 0x000007df, 0xf9e9d9c9);
-        nv_icmd(dev, 0x000007e8, 0x00003210);
-        nv_icmd(dev, 0x000007e9, 0x00007654);
-        nv_icmd(dev, 0x000007ea, 0x00000098);
-        nv_icmd(dev, 0x000007ec, 0x39291909);
-        nv_icmd(dev, 0x000007ed, 0x79695949);
-        nv_icmd(dev, 0x000007ee, 0xb9a99989);
-        nv_icmd(dev, 0x000007ef, 0xf9e9d9c9);
-        nv_icmd(dev, 0x000007f0, 0x00003210);
-        nv_icmd(dev, 0x000007f1, 0x00007654);
-        nv_icmd(dev, 0x000007f2, 0x00000098);
-        nv_icmd(dev, 0x000005a5, 0x00000001);
-        nv_icmd(dev, 0x00000980, 0x00000000);
-        nv_icmd(dev, 0x00000981, 0x00000000);
-        nv_icmd(dev, 0x00000982, 0x00000000);
-        nv_icmd(dev, 0x00000983, 0x00000000);
-        nv_icmd(dev, 0x00000984, 0x00000000);
-        nv_icmd(dev, 0x00000985, 0x00000000);
-        nv_icmd(dev, 0x00000986, 0x00000000);
-        nv_icmd(dev, 0x00000987, 0x00000000);
-        nv_icmd(dev, 0x00000988, 0x00000000);
-        nv_icmd(dev, 0x00000989, 0x00000000);
-        nv_icmd(dev, 0x0000098a, 0x00000000);
-        nv_icmd(dev, 0x0000098b, 0x00000000);
-        nv_icmd(dev, 0x0000098c, 0x00000000);
-        nv_icmd(dev, 0x0000098d, 0x00000000);
-        nv_icmd(dev, 0x0000098e, 0x00000000);
-        nv_icmd(dev, 0x0000098f, 0x00000000);
-        nv_icmd(dev, 0x00000990, 0x00000000);
-        nv_icmd(dev, 0x00000991, 0x00000000);
-        nv_icmd(dev, 0x00000992, 0x00000000);
-        nv_icmd(dev, 0x00000993, 0x00000000);
-        nv_icmd(dev, 0x00000994, 0x00000000);
-        nv_icmd(dev, 0x00000995, 0x00000000);
-        nv_icmd(dev, 0x00000996, 0x00000000);
-        nv_icmd(dev, 0x00000997, 0x00000000);
-        nv_icmd(dev, 0x00000998, 0x00000000);
-        nv_icmd(dev, 0x00000999, 0x00000000);
-        nv_icmd(dev, 0x0000099a, 0x00000000);
-        nv_icmd(dev, 0x0000099b, 0x00000000);
-        nv_icmd(dev, 0x0000099c, 0x00000000);
-        nv_icmd(dev, 0x0000099d, 0x00000000);
-        nv_icmd(dev, 0x0000099e, 0x00000000);
-        nv_icmd(dev, 0x0000099f, 0x00000000);
-        nv_icmd(dev, 0x000009a0, 0x00000000);
-        nv_icmd(dev, 0x000009a1, 0x00000000);
-        nv_icmd(dev, 0x000009a2, 0x00000000);
-        nv_icmd(dev, 0x000009a3, 0x00000000);
-        nv_icmd(dev, 0x000009a4, 0x00000000);
-        nv_icmd(dev, 0x000009a5, 0x00000000);
-        nv_icmd(dev, 0x000009a6, 0x00000000);
-        nv_icmd(dev, 0x000009a7, 0x00000000);
-        nv_icmd(dev, 0x000009a8, 0x00000000);
-        nv_icmd(dev, 0x000009a9, 0x00000000);
-        nv_icmd(dev, 0x000009aa, 0x00000000);
-        nv_icmd(dev, 0x000009ab, 0x00000000);
-        nv_icmd(dev, 0x000009ac, 0x00000000);
-        nv_icmd(dev, 0x000009ad, 0x00000000);
-        nv_icmd(dev, 0x000009ae, 0x00000000);
-        nv_icmd(dev, 0x000009af, 0x00000000);
-        nv_icmd(dev, 0x000009b0, 0x00000000);
-        nv_icmd(dev, 0x000009b1, 0x00000000);
-        nv_icmd(dev, 0x000009b2, 0x00000000);
-        nv_icmd(dev, 0x000009b3, 0x00000000);
-        nv_icmd(dev, 0x000009b4, 0x00000000);
-        nv_icmd(dev, 0x000009b5, 0x00000000);
-        nv_icmd(dev, 0x000009b6, 0x00000000);
-        nv_icmd(dev, 0x000009b7, 0x00000000);
-        nv_icmd(dev, 0x000009b8, 0x00000000);
-        nv_icmd(dev, 0x000009b9, 0x00000000);
-        nv_icmd(dev, 0x000009ba, 0x00000000);
-        nv_icmd(dev, 0x000009bb, 0x00000000);
-        nv_icmd(dev, 0x000009bc, 0x00000000);
-        nv_icmd(dev, 0x000009bd, 0x00000000);
-        nv_icmd(dev, 0x000009be, 0x00000000);
-        nv_icmd(dev, 0x000009bf, 0x00000000);
-        nv_icmd(dev, 0x000009c0, 0x00000000);
-        nv_icmd(dev, 0x000009c1, 0x00000000);
-        nv_icmd(dev, 0x000009c2, 0x00000000);
-        nv_icmd(dev, 0x000009c3, 0x00000000);
-        nv_icmd(dev, 0x000009c4, 0x00000000);
-        nv_icmd(dev, 0x000009c5, 0x00000000);
-        nv_icmd(dev, 0x000009c6, 0x00000000);
-        nv_icmd(dev, 0x000009c7, 0x00000000);
-        nv_icmd(dev, 0x000009c8, 0x00000000);
-        nv_icmd(dev, 0x000009c9, 0x00000000);
-        nv_icmd(dev, 0x000009ca, 0x00000000);
-        nv_icmd(dev, 0x000009cb, 0x00000000);
-        nv_icmd(dev, 0x000009cc, 0x00000000);
-        nv_icmd(dev, 0x000009cd, 0x00000000);
-        nv_icmd(dev, 0x000009ce, 0x00000000);
-        nv_icmd(dev, 0x000009cf, 0x00000000);
-        nv_icmd(dev, 0x000009d0, 0x00000000);
-        nv_icmd(dev, 0x000009d1, 0x00000000);
-        nv_icmd(dev, 0x000009d2, 0x00000000);
-        nv_icmd(dev, 0x000009d3, 0x00000000);
-        nv_icmd(dev, 0x000009d4, 0x00000000);
-        nv_icmd(dev, 0x000009d5, 0x00000000);
-        nv_icmd(dev, 0x000009d6, 0x00000000);
-        nv_icmd(dev, 0x000009d7, 0x00000000);
-        nv_icmd(dev, 0x000009d8, 0x00000000);
-        nv_icmd(dev, 0x000009d9, 0x00000000);
-        nv_icmd(dev, 0x000009da, 0x00000000);
-        nv_icmd(dev, 0x000009db, 0x00000000);
-        nv_icmd(dev, 0x000009dc, 0x00000000);
-        nv_icmd(dev, 0x000009dd, 0x00000000);
-        nv_icmd(dev, 0x000009de, 0x00000000);
-        nv_icmd(dev, 0x000009df, 0x00000000);
-        nv_icmd(dev, 0x000009e0, 0x00000000);
-        nv_icmd(dev, 0x000009e1, 0x00000000);
-        nv_icmd(dev, 0x000009e2, 0x00000000);
-        nv_icmd(dev, 0x000009e3, 0x00000000);
-        nv_icmd(dev, 0x000009e4, 0x00000000);
-        nv_icmd(dev, 0x000009e5, 0x00000000);
-        nv_icmd(dev, 0x000009e6, 0x00000000);
-        nv_icmd(dev, 0x000009e7, 0x00000000);
-        nv_icmd(dev, 0x000009e8, 0x00000000);
-        nv_icmd(dev, 0x000009e9, 0x00000000);
-        nv_icmd(dev, 0x000009ea, 0x00000000);
-        nv_icmd(dev, 0x000009eb, 0x00000000);
-        nv_icmd(dev, 0x000009ec, 0x00000000);
-        nv_icmd(dev, 0x000009ed, 0x00000000);
-        nv_icmd(dev, 0x000009ee, 0x00000000);
-        nv_icmd(dev, 0x000009ef, 0x00000000);
-        nv_icmd(dev, 0x000009f0, 0x00000000);
-        nv_icmd(dev, 0x000009f1, 0x00000000);
-        nv_icmd(dev, 0x000009f2, 0x00000000);
-        nv_icmd(dev, 0x000009f3, 0x00000000);
-        nv_icmd(dev, 0x000009f4, 0x00000000);
-        nv_icmd(dev, 0x000009f5, 0x00000000);
-        nv_icmd(dev, 0x000009f6, 0x00000000);
-        nv_icmd(dev, 0x000009f7, 0x00000000);
-        nv_icmd(dev, 0x000009f8, 0x00000000);
-        nv_icmd(dev, 0x000009f9, 0x00000000);
-        nv_icmd(dev, 0x000009fa, 0x00000000);
-        nv_icmd(dev, 0x000009fb, 0x00000000);
-        nv_icmd(dev, 0x000009fc, 0x00000000);
-        nv_icmd(dev, 0x000009fd, 0x00000000);
-        nv_icmd(dev, 0x000009fe, 0x00000000);
-        nv_icmd(dev, 0x000009ff, 0x00000000);
-        nv_icmd(dev, 0x00000468, 0x00000004);
-        nv_icmd(dev, 0x0000046c, 0x00000001);
-        nv_icmd(dev, 0x00000470, 0x00000000);
-        nv_icmd(dev, 0x00000471, 0x00000000);
-        nv_icmd(dev, 0x00000472, 0x00000000);
-        nv_icmd(dev, 0x00000473, 0x00000000);
-        nv_icmd(dev, 0x00000474, 0x00000000);
-        nv_icmd(dev, 0x00000475, 0x00000000);
-        nv_icmd(dev, 0x00000476, 0x00000000);
-        nv_icmd(dev, 0x00000477, 0x00000000);
-        nv_icmd(dev, 0x00000478, 0x00000000);
-        nv_icmd(dev, 0x00000479, 0x00000000);
-        nv_icmd(dev, 0x0000047a, 0x00000000);
-        nv_icmd(dev, 0x0000047b, 0x00000000);
-        nv_icmd(dev, 0x0000047c, 0x00000000);
-        nv_icmd(dev, 0x0000047d, 0x00000000);
-        nv_icmd(dev, 0x0000047e, 0x00000000);
-        nv_icmd(dev, 0x0000047f, 0x00000000);
-        nv_icmd(dev, 0x00000480, 0x00000000);
-        nv_icmd(dev, 0x00000481, 0x00000000);
-        nv_icmd(dev, 0x00000482, 0x00000000);
-        nv_icmd(dev, 0x00000483, 0x00000000);
-        nv_icmd(dev, 0x00000484, 0x00000000);
-        nv_icmd(dev, 0x00000485, 0x00000000);
-        nv_icmd(dev, 0x00000486, 0x00000000);
-        nv_icmd(dev, 0x00000487, 0x00000000);
-        nv_icmd(dev, 0x00000488, 0x00000000);
-        nv_icmd(dev, 0x00000489, 0x00000000);
-        nv_icmd(dev, 0x0000048a, 0x00000000);
-        nv_icmd(dev, 0x0000048b, 0x00000000);
-        nv_icmd(dev, 0x0000048c, 0x00000000);
-        nv_icmd(dev, 0x0000048d, 0x00000000);
-        nv_icmd(dev, 0x0000048e, 0x00000000);
-        nv_icmd(dev, 0x0000048f, 0x00000000);
-        nv_icmd(dev, 0x00000490, 0x00000000);
-        nv_icmd(dev, 0x00000491, 0x00000000);
-        nv_icmd(dev, 0x00000492, 0x00000000);
-        nv_icmd(dev, 0x00000493, 0x00000000);
-        nv_icmd(dev, 0x00000494, 0x00000000);
-        nv_icmd(dev, 0x00000495, 0x00000000);
-        nv_icmd(dev, 0x00000496, 0x00000000);
-        nv_icmd(dev, 0x00000497, 0x00000000);
-        nv_icmd(dev, 0x00000498, 0x00000000);
-        nv_icmd(dev, 0x00000499, 0x00000000);
-        nv_icmd(dev, 0x0000049a, 0x00000000);
-        nv_icmd(dev, 0x0000049b, 0x00000000);
-        nv_icmd(dev, 0x0000049c, 0x00000000);
-        nv_icmd(dev, 0x0000049d, 0x00000000);
-        nv_icmd(dev, 0x0000049e, 0x00000000);
-        nv_icmd(dev, 0x0000049f, 0x00000000);
-        nv_icmd(dev, 0x000004a0, 0x00000000);
-        nv_icmd(dev, 0x000004a1, 0x00000000);
-        nv_icmd(dev, 0x000004a2, 0x00000000);
-        nv_icmd(dev, 0x000004a3, 0x00000000);
-        nv_icmd(dev, 0x000004a4, 0x00000000);
-        nv_icmd(dev, 0x000004a5, 0x00000000);
-        nv_icmd(dev, 0x000004a6, 0x00000000);
-        nv_icmd(dev, 0x000004a7, 0x00000000);
-        nv_icmd(dev, 0x000004a8, 0x00000000);
-        nv_icmd(dev, 0x000004a9, 0x00000000);
-        nv_icmd(dev, 0x000004aa, 0x00000000);
-        nv_icmd(dev, 0x000004ab, 0x00000000);
-        nv_icmd(dev, 0x000004ac, 0x00000000);
-        nv_icmd(dev, 0x000004ad, 0x00000000);
-        nv_icmd(dev, 0x000004ae, 0x00000000);
-        nv_icmd(dev, 0x000004af, 0x00000000);
-        nv_icmd(dev, 0x000004b0, 0x00000000);
-        nv_icmd(dev, 0x000004b1, 0x00000000);
-        nv_icmd(dev, 0x000004b2, 0x00000000);
-        nv_icmd(dev, 0x000004b3, 0x00000000);
-        nv_icmd(dev, 0x000004b4, 0x00000000);
-        nv_icmd(dev, 0x000004b5, 0x00000000);
-        nv_icmd(dev, 0x000004b6, 0x00000000);
-        nv_icmd(dev, 0x000004b7, 0x00000000);
-        nv_icmd(dev, 0x000004b8, 0x00000000);
-        nv_icmd(dev, 0x000004b9, 0x00000000);
-        nv_icmd(dev, 0x000004ba, 0x00000000);
-        nv_icmd(dev, 0x000004bb, 0x00000000);
-        nv_icmd(dev, 0x000004bc, 0x00000000);
-        nv_icmd(dev, 0x000004bd, 0x00000000);
-        nv_icmd(dev, 0x000004be, 0x00000000);
-        nv_icmd(dev, 0x000004bf, 0x00000000);
-        nv_icmd(dev, 0x000004c0, 0x00000000);
-        nv_icmd(dev, 0x000004c1, 0x00000000);
-        nv_icmd(dev, 0x000004c2, 0x00000000);
-        nv_icmd(dev, 0x000004c3, 0x00000000);
-        nv_icmd(dev, 0x000004c4, 0x00000000);
-        nv_icmd(dev, 0x000004c5, 0x00000000);
-        nv_icmd(dev, 0x000004c6, 0x00000000);
-        nv_icmd(dev, 0x000004c7, 0x00000000);
-        nv_icmd(dev, 0x000004c8, 0x00000000);
-        nv_icmd(dev, 0x000004c9, 0x00000000);
-        nv_icmd(dev, 0x000004ca, 0x00000000);
-        nv_icmd(dev, 0x000004cb, 0x00000000);
-        nv_icmd(dev, 0x000004cc, 0x00000000);
-        nv_icmd(dev, 0x000004cd, 0x00000000);
-        nv_icmd(dev, 0x000004ce, 0x00000000);
-        nv_icmd(dev, 0x000004cf, 0x00000000);
-        nv_icmd(dev, 0x00000510, 0x3f800000);
-        nv_icmd(dev, 0x00000511, 0x3f800000);
-        nv_icmd(dev, 0x00000512, 0x3f800000);
-        nv_icmd(dev, 0x00000513, 0x3f800000);
-        nv_icmd(dev, 0x00000514, 0x3f800000);
-        nv_icmd(dev, 0x00000515, 0x3f800000);
-        nv_icmd(dev, 0x00000516, 0x3f800000);
-        nv_icmd(dev, 0x00000517, 0x3f800000);
-        nv_icmd(dev, 0x00000518, 0x3f800000);
-        nv_icmd(dev, 0x00000519, 0x3f800000);
-        nv_icmd(dev, 0x0000051a, 0x3f800000);
-        nv_icmd(dev, 0x0000051b, 0x3f800000);
-        nv_icmd(dev, 0x0000051c, 0x3f800000);
-        nv_icmd(dev, 0x0000051d, 0x3f800000);
-        nv_icmd(dev, 0x0000051e, 0x3f800000);
-        nv_icmd(dev, 0x0000051f, 0x3f800000);
-        nv_icmd(dev, 0x00000520, 0x000002b6);
-        nv_icmd(dev, 0x00000529, 0x00000001);
-        nv_icmd(dev, 0x00000530, 0xffff0000);
-        nv_icmd(dev, 0x00000531, 0xffff0000);
-        nv_icmd(dev, 0x00000532, 0xffff0000);
-        nv_icmd(dev, 0x00000533, 0xffff0000);
-        nv_icmd(dev, 0x00000534, 0xffff0000);
-        nv_icmd(dev, 0x00000535, 0xffff0000);
-        nv_icmd(dev, 0x00000536, 0xffff0000);
-        nv_icmd(dev, 0x00000537, 0xffff0000);
-        nv_icmd(dev, 0x00000538, 0xffff0000);
-        nv_icmd(dev, 0x00000539, 0xffff0000);
-        nv_icmd(dev, 0x0000053a, 0xffff0000);
-        nv_icmd(dev, 0x0000053b, 0xffff0000);
-        nv_icmd(dev, 0x0000053c, 0xffff0000);
-        nv_icmd(dev, 0x0000053d, 0xffff0000);
-        nv_icmd(dev, 0x0000053e, 0xffff0000);
-        nv_icmd(dev, 0x0000053f, 0xffff0000);
-        nv_icmd(dev, 0x00000585, 0x0000003f);
-        nv_icmd(dev, 0x00000576, 0x00000003);
-        if (dev_priv->chipset == 0xc1 ||
-            dev_priv->chipset == 0xd9)
-                nv_icmd(dev, 0x0000057b, 0x00000059);
-        nv_icmd(dev, 0x00000586, 0x00000040);
-        nv_icmd(dev, 0x00000582, 0x00000080);
-        nv_icmd(dev, 0x00000583, 0x00000080);
-        nv_icmd(dev, 0x000005c2, 0x00000001);
-        nv_icmd(dev, 0x00000638, 0x00000001);
-        nv_icmd(dev, 0x00000639, 0x00000001);
-        nv_icmd(dev, 0x0000063a, 0x00000002);
-        nv_icmd(dev, 0x0000063b, 0x00000001);
-        nv_icmd(dev, 0x0000063c, 0x00000001);
-        nv_icmd(dev, 0x0000063d, 0x00000002);
-        nv_icmd(dev, 0x0000063e, 0x00000001);
-        nv_icmd(dev, 0x000008b8, 0x00000001);
-        nv_icmd(dev, 0x000008b9, 0x00000001);
-        nv_icmd(dev, 0x000008ba, 0x00000001);
-        nv_icmd(dev, 0x000008bb, 0x00000001);
-        nv_icmd(dev, 0x000008bc, 0x00000001);
-        nv_icmd(dev, 0x000008bd, 0x00000001);
-        nv_icmd(dev, 0x000008be, 0x00000001);
-        nv_icmd(dev, 0x000008bf, 0x00000001);
-        nv_icmd(dev, 0x00000900, 0x00000001);
-        nv_icmd(dev, 0x00000901, 0x00000001);
-        nv_icmd(dev, 0x00000902, 0x00000001);
-        nv_icmd(dev, 0x00000903, 0x00000001);
-        nv_icmd(dev, 0x00000904, 0x00000001);
-        nv_icmd(dev, 0x00000905, 0x00000001);
-        nv_icmd(dev, 0x00000906, 0x00000001);
-        nv_icmd(dev, 0x00000907, 0x00000001);
-        nv_icmd(dev, 0x00000908, 0x00000002);
-        nv_icmd(dev, 0x00000909, 0x00000002);
-        nv_icmd(dev, 0x0000090a, 0x00000002);
-        nv_icmd(dev, 0x0000090b, 0x00000002);
-        nv_icmd(dev, 0x0000090c, 0x00000002);
-        nv_icmd(dev, 0x0000090d, 0x00000002);
-        nv_icmd(dev, 0x0000090e, 0x00000002);
-        nv_icmd(dev, 0x0000090f, 0x00000002);
-        nv_icmd(dev, 0x00000910, 0x00000001);
-        nv_icmd(dev, 0x00000911, 0x00000001);
-        nv_icmd(dev, 0x00000912, 0x00000001);
-        nv_icmd(dev, 0x00000913, 0x00000001);
-        nv_icmd(dev, 0x00000914, 0x00000001);
-        nv_icmd(dev, 0x00000915, 0x00000001);
-        nv_icmd(dev, 0x00000916, 0x00000001);
-        nv_icmd(dev, 0x00000917, 0x00000001);
-        nv_icmd(dev, 0x00000918, 0x00000001);
-        nv_icmd(dev, 0x00000919, 0x00000001);
-        nv_icmd(dev, 0x0000091a, 0x00000001);
-        nv_icmd(dev, 0x0000091b, 0x00000001);
-        nv_icmd(dev, 0x0000091c, 0x00000001);
-        nv_icmd(dev, 0x0000091d, 0x00000001);
-        nv_icmd(dev, 0x0000091e, 0x00000001);
-        nv_icmd(dev, 0x0000091f, 0x00000001);
-        nv_icmd(dev, 0x00000920, 0x00000002);
-        nv_icmd(dev, 0x00000921, 0x00000002);
-        nv_icmd(dev, 0x00000922, 0x00000002);
-        nv_icmd(dev, 0x00000923, 0x00000002);
-        nv_icmd(dev, 0x00000924, 0x00000002);
-        nv_icmd(dev, 0x00000925, 0x00000002);
-        nv_icmd(dev, 0x00000926, 0x00000002);
-        nv_icmd(dev, 0x00000927, 0x00000002);
-        nv_icmd(dev, 0x00000928, 0x00000001);
-        nv_icmd(dev, 0x00000929, 0x00000001);
-        nv_icmd(dev, 0x0000092a, 0x00000001);
-        nv_icmd(dev, 0x0000092b, 0x00000001);
-        nv_icmd(dev, 0x0000092c, 0x00000001);
-        nv_icmd(dev, 0x0000092d, 0x00000001);
-        nv_icmd(dev, 0x0000092e, 0x00000001);
-        nv_icmd(dev, 0x0000092f, 0x00000001);
-        nv_icmd(dev, 0x00000648, 0x00000001);
-        nv_icmd(dev, 0x00000649, 0x00000001);
-        nv_icmd(dev, 0x0000064a, 0x00000001);
-        nv_icmd(dev, 0x0000064b, 0x00000001);
-        nv_icmd(dev, 0x0000064c, 0x00000001);
-        nv_icmd(dev, 0x0000064d, 0x00000001);
-        nv_icmd(dev, 0x0000064e, 0x00000001);
-        nv_icmd(dev, 0x0000064f, 0x00000001);
-        nv_icmd(dev, 0x00000650, 0x00000001);
-        nv_icmd(dev, 0x00000658, 0x0000000f);
-        nv_icmd(dev, 0x000007ff, 0x0000000a);
-        nv_icmd(dev, 0x0000066a, 0x40000000);
-        nv_icmd(dev, 0x0000066b, 0x10000000);
-        nv_icmd(dev, 0x0000066c, 0xffff0000);
-        nv_icmd(dev, 0x0000066d, 0xffff0000);
-        nv_icmd(dev, 0x000007af, 0x00000008);
-        nv_icmd(dev, 0x000007b0, 0x00000008);
-        nv_icmd(dev, 0x000007f6, 0x00000001);
-        nv_icmd(dev, 0x000006b2, 0x00000055);
-        nv_icmd(dev, 0x000007ad, 0x00000003);
-        nv_icmd(dev, 0x00000937, 0x00000001);
-        nv_icmd(dev, 0x00000971, 0x00000008);
-        nv_icmd(dev, 0x00000972, 0x00000040);
-        nv_icmd(dev, 0x00000973, 0x0000012c);
-        nv_icmd(dev, 0x0000097c, 0x00000040);
-        nv_icmd(dev, 0x00000979, 0x00000003);
-        nv_icmd(dev, 0x00000975, 0x00000020);
-        nv_icmd(dev, 0x00000976, 0x00000001);
-        nv_icmd(dev, 0x00000977, 0x00000020);
-        nv_icmd(dev, 0x00000978, 0x00000001);
-        nv_icmd(dev, 0x00000957, 0x00000003);
-        nv_icmd(dev, 0x0000095e, 0x20164010);
-        nv_icmd(dev, 0x0000095f, 0x00000020);
-        if (dev_priv->chipset == 0xd9)
-                nv_icmd(dev, 0x0000097d, 0x00000020);
-        nv_icmd(dev, 0x00000683, 0x00000006);
-        nv_icmd(dev, 0x00000685, 0x003fffff);
-        nv_icmd(dev, 0x00000687, 0x00000c48);
-        nv_icmd(dev, 0x000006a0, 0x00000005);
-        nv_icmd(dev, 0x00000840, 0x00300008);
-        nv_icmd(dev, 0x00000841, 0x04000080);
-        nv_icmd(dev, 0x00000842, 0x00300008);
-        nv_icmd(dev, 0x00000843, 0x04000080);
-        nv_icmd(dev, 0x00000818, 0x00000000);
-        nv_icmd(dev, 0x00000819, 0x00000000);
-        nv_icmd(dev, 0x0000081a, 0x00000000);
-        nv_icmd(dev, 0x0000081b, 0x00000000);
-        nv_icmd(dev, 0x0000081c, 0x00000000);
-        nv_icmd(dev, 0x0000081d, 0x00000000);
-        nv_icmd(dev, 0x0000081e, 0x00000000);
-        nv_icmd(dev, 0x0000081f, 0x00000000);
-        nv_icmd(dev, 0x00000848, 0x00000000);
-        nv_icmd(dev, 0x00000849, 0x00000000);
-        nv_icmd(dev, 0x0000084a, 0x00000000);
-        nv_icmd(dev, 0x0000084b, 0x00000000);
-        nv_icmd(dev, 0x0000084c, 0x00000000);
-        nv_icmd(dev, 0x0000084d, 0x00000000);
-        nv_icmd(dev, 0x0000084e, 0x00000000);
-        nv_icmd(dev, 0x0000084f, 0x00000000);
-        nv_icmd(dev, 0x00000850, 0x00000000);
-        nv_icmd(dev, 0x00000851, 0x00000000);
-        nv_icmd(dev, 0x00000852, 0x00000000);
-        nv_icmd(dev, 0x00000853, 0x00000000);
-        nv_icmd(dev, 0x00000854, 0x00000000);
-        nv_icmd(dev, 0x00000855, 0x00000000);
-        nv_icmd(dev, 0x00000856, 0x00000000);
-        nv_icmd(dev, 0x00000857, 0x00000000);
-        nv_icmd(dev, 0x00000738, 0x00000000);
-        nv_icmd(dev, 0x000006aa, 0x00000001);
-        nv_icmd(dev, 0x000006ab, 0x00000002);
-        nv_icmd(dev, 0x000006ac, 0x00000080);
-        nv_icmd(dev, 0x000006ad, 0x00000100);
-        nv_icmd(dev, 0x000006ae, 0x00000100);
-        nv_icmd(dev, 0x000006b1, 0x00000011);
-        nv_icmd(dev, 0x000006bb, 0x000000cf);
-        nv_icmd(dev, 0x000006ce, 0x2a712488);
-        nv_icmd(dev, 0x00000739, 0x4085c000);
-        nv_icmd(dev, 0x0000073a, 0x00000080);
-        nv_icmd(dev, 0x00000786, 0x80000100);
-        nv_icmd(dev, 0x0000073c, 0x00010100);
-        nv_icmd(dev, 0x0000073d, 0x02800000);
-        nv_icmd(dev, 0x00000787, 0x000000cf);
-        nv_icmd(dev, 0x0000078c, 0x00000008);
-        nv_icmd(dev, 0x00000792, 0x00000001);
-        nv_icmd(dev, 0x00000794, 0x00000001);
-        nv_icmd(dev, 0x00000795, 0x00000001);
-        nv_icmd(dev, 0x00000796, 0x00000001);
-        nv_icmd(dev, 0x00000797, 0x000000cf);
-        nv_icmd(dev, 0x00000836, 0x00000001);
-        nv_icmd(dev, 0x0000079a, 0x00000002);
-        nv_icmd(dev, 0x00000833, 0x04444480);
-        nv_icmd(dev, 0x000007a1, 0x00000001);
-        nv_icmd(dev, 0x000007a3, 0x00000001);
-        nv_icmd(dev, 0x000007a4, 0x00000001);
-        nv_icmd(dev, 0x000007a5, 0x00000001);
-        nv_icmd(dev, 0x00000831, 0x00000004);
-        nv_icmd(dev, 0x0000080c, 0x00000002);
-        nv_icmd(dev, 0x0000080d, 0x00000100);
-        nv_icmd(dev, 0x0000080e, 0x00000100);
-        nv_icmd(dev, 0x0000080f, 0x00000001);
-        nv_icmd(dev, 0x00000823, 0x00000002);
-        nv_icmd(dev, 0x00000824, 0x00000100);
-        nv_icmd(dev, 0x00000825, 0x00000100);
-        nv_icmd(dev, 0x00000826, 0x00000001);
-        nv_icmd(dev, 0x0000095d, 0x00000001);
-        nv_icmd(dev, 0x0000082b, 0x00000004);
-        nv_icmd(dev, 0x00000942, 0x00010001);
-        nv_icmd(dev, 0x00000943, 0x00000001);
-        nv_icmd(dev, 0x00000944, 0x00000022);
-        nv_icmd(dev, 0x000007c5, 0x00010001);
-        nv_icmd(dev, 0x00000834, 0x00000001);
-        nv_icmd(dev, 0x000007c7, 0x00000001);
-        nv_icmd(dev, 0x0000c1b0, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b1, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b2, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b3, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b4, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b5, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b6, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b7, 0x0000000f);
-        nv_icmd(dev, 0x0000c1b8, 0x0fac6881);
-        nv_icmd(dev, 0x0000c1b9, 0x00fac688);
-        nv_icmd(dev, 0x0001e100, 0x00000001);
-        nv_icmd(dev, 0x00001000, 0x00000002);
-        nv_icmd(dev, 0x000006aa, 0x00000001);
-        nv_icmd(dev, 0x000006ad, 0x00000100);
-        nv_icmd(dev, 0x000006ae, 0x00000100);
-        nv_icmd(dev, 0x000006b1, 0x00000011);
-        nv_icmd(dev, 0x0000078c, 0x00000008);
-        nv_icmd(dev, 0x00000792, 0x00000001);
-        nv_icmd(dev, 0x00000794, 0x00000001);
-        nv_icmd(dev, 0x00000795, 0x00000001);
-        nv_icmd(dev, 0x00000796, 0x00000001);
-        nv_icmd(dev, 0x00000797, 0x000000cf);
-        nv_icmd(dev, 0x0000079a, 0x00000002);
-        nv_icmd(dev, 0x00000833, 0x04444480);
-        nv_icmd(dev, 0x000007a1, 0x00000001);
-        nv_icmd(dev, 0x000007a3, 0x00000001);
-        nv_icmd(dev, 0x000007a4, 0x00000001);
-        nv_icmd(dev, 0x000007a5, 0x00000001);
-        nv_icmd(dev, 0x00000831, 0x00000004);
-        nv_icmd(dev, 0x0001e100, 0x00000001);
-        nv_icmd(dev, 0x00001000, 0x00000014);
-        nv_icmd(dev, 0x00000351, 0x00000100);
-        nv_icmd(dev, 0x00000957, 0x00000003);
-        nv_icmd(dev, 0x0000095d, 0x00000001);
-        nv_icmd(dev, 0x0000082b, 0x00000004);
-        nv_icmd(dev, 0x00000942, 0x00010001);
-        nv_icmd(dev, 0x00000943, 0x00000001);
-        nv_icmd(dev, 0x000007c5, 0x00010001);
-        nv_icmd(dev, 0x00000834, 0x00000001);
-        nv_icmd(dev, 0x000007c7, 0x00000001);
-        nv_icmd(dev, 0x0001e100, 0x00000001);
-        nv_icmd(dev, 0x00001000, 0x00000001);
-        nv_icmd(dev, 0x0000080c, 0x00000002);
-        nv_icmd(dev, 0x0000080d, 0x00000100);
-        nv_icmd(dev, 0x0000080e, 0x00000100);
-        nv_icmd(dev, 0x0000080f, 0x00000001);
-        nv_icmd(dev, 0x00000823, 0x00000002);
-        nv_icmd(dev, 0x00000824, 0x00000100);
-        nv_icmd(dev, 0x00000825, 0x00000100);
-        nv_icmd(dev, 0x00000826, 0x00000001);
-        nv_icmd(dev, 0x0001e100, 0x00000001);
-        nv_wr32(dev, 0x400208, 0x00000000);
-        nv_wr32(dev, 0x404154, 0x00000400);
-
-        nvc0_grctx_generate_9097(dev);
-        if (fermi >= 0x9197)
-                nvc0_grctx_generate_9197(dev);
-        if (fermi >= 0x9297)
-                nvc0_grctx_generate_9297(dev);
-        nvc0_grctx_generate_902d(dev);
-        nvc0_grctx_generate_9039(dev);
-        nvc0_grctx_generate_90c0(dev);
-
-        nv_wr32(dev, 0x000260, r000260);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nvc0_instmem.c b/drivers/gpu/drm/nouveau/nvc0_instmem.c
deleted file mode 100644
index b701c439c92e..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_instmem.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * 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"
-#include "nouveau_vm.h"
-
-struct nvc0_instmem_priv {
-        struct nouveau_gpuobj  *bar1_pgd;
-        struct nouveau_channel *bar1;
-        struct nouveau_gpuobj  *bar3_pgd;
-        struct nouveau_channel *bar3;
-};
-
-int
-nvc0_instmem_suspend(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        dev_priv->ramin_available = false;
-        return 0;
-}
-
-void
-nvc0_instmem_resume(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_instmem_priv *priv = dev_priv->engine.instmem.priv;
-
-        nv_mask(dev, 0x100c80, 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x001704, 0x80000000 | priv->bar1->ramin->vinst >> 12);
-        nv_wr32(dev, 0x001714, 0xc0000000 | priv->bar3->ramin->vinst >> 12);
-        dev_priv->ramin_available = true;
-}
-
-static void
-nvc0_channel_del(struct nouveau_channel **pchan)
-{
-        struct nouveau_channel *chan;
-
-        chan = *pchan;
-        *pchan = NULL;
-        if (!chan)
-                return;
-
-        nouveau_vm_ref(NULL, &chan->vm, NULL);
-        if (drm_mm_initialized(&chan->ramin_heap))
-                drm_mm_takedown(&chan->ramin_heap);
-        nouveau_gpuobj_ref(NULL, &chan->ramin);
-        kfree(chan);
-}
-
-static int
-nvc0_channel_new(struct drm_device *dev, u32 size, struct nouveau_vm *vm,
-                 struct nouveau_channel **pchan,
-                 struct nouveau_gpuobj *pgd, u64 vm_size)
-{
-        struct nouveau_channel *chan;
-        int ret;
-
-        chan = kzalloc(sizeof(*chan), GFP_KERNEL);
-        if (!chan)
-                return -ENOMEM;
-        chan->dev = dev;
-
-        ret = nouveau_gpuobj_new(dev, NULL, size, 0x1000, 0, &chan->ramin);
-        if (ret) {
-                nvc0_channel_del(&chan);
-                return ret;
-        }
-
-        ret = drm_mm_init(&chan->ramin_heap, 0x1000, size - 0x1000);
-        if (ret) {
-                nvc0_channel_del(&chan);
-                return ret;
-        }
-
-        ret = nouveau_vm_ref(vm, &chan->vm, NULL);
-        if (ret) {
-                nvc0_channel_del(&chan);
-                return ret;
-        }
-
-        nv_wo32(chan->ramin, 0x0200, lower_32_bits(pgd->vinst));
-        nv_wo32(chan->ramin, 0x0204, upper_32_bits(pgd->vinst));
-        nv_wo32(chan->ramin, 0x0208, lower_32_bits(vm_size - 1));
-        nv_wo32(chan->ramin, 0x020c, upper_32_bits(vm_size - 1));
-
-        *pchan = chan;
-        return 0;
-}
-
-int
-nvc0_instmem_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct pci_dev *pdev = dev->pdev;
-        struct nvc0_instmem_priv *priv;
-        struct nouveau_vm *vm = NULL;
-        int ret;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-        pinstmem->priv = priv;
-
-        /* BAR3 VM */
-        ret = nouveau_vm_new(dev, 0, pci_resource_len(pdev, 3), 0,
-                             &dev_priv->bar3_vm);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL,
-                                 (pci_resource_len(pdev, 3) >> 12) * 8, 0,
-                                 NVOBJ_FLAG_DONT_MAP |
-                                 NVOBJ_FLAG_ZERO_ALLOC,
-                                 &dev_priv->bar3_vm->pgt[0].obj[0]);
-        if (ret)
-                goto error;
-        dev_priv->bar3_vm->pgt[0].refcount[0] = 1;
-
-        nv50_instmem_map(dev_priv->bar3_vm->pgt[0].obj[0]);
-
-        ret = nouveau_gpuobj_new(dev, NULL, 0x8000, 4096,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->bar3_pgd);
-        if (ret)
-                goto error;
-
-        ret = nouveau_vm_ref(dev_priv->bar3_vm, &vm, priv->bar3_pgd);
-        if (ret)
-                goto error;
-        nouveau_vm_ref(NULL, &vm, NULL);
-
-        ret = nvc0_channel_new(dev, 8192, dev_priv->bar3_vm, &priv->bar3,
-                               priv->bar3_pgd, pci_resource_len(dev->pdev, 3));
-        if (ret)
-                goto error;
-
-        /* BAR1 VM */
-        ret = nouveau_vm_new(dev, 0, pci_resource_len(pdev, 1), 0, &vm);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 0x8000, 4096,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->bar1_pgd);
-        if (ret)
-                goto error;
-
-        ret = nouveau_vm_ref(vm, &dev_priv->bar1_vm, priv->bar1_pgd);
-        if (ret)
-                goto error;
-        nouveau_vm_ref(NULL, &vm, NULL);
-
-        ret = nvc0_channel_new(dev, 8192, dev_priv->bar1_vm, &priv->bar1,
-                               priv->bar1_pgd, pci_resource_len(dev->pdev, 1));
-        if (ret)
-                goto error;
-
-        /* channel vm */
-        ret = nouveau_vm_new(dev, 0, (1ULL << 40), 0x0008000000ULL,
-                             &dev_priv->chan_vm);
-        if (ret)
-                goto error;
-
-        nvc0_instmem_resume(dev);
-        return 0;
-error:
-        nvc0_instmem_takedown(dev);
-        return ret;
-}
-
-void
-nvc0_instmem_takedown(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_instmem_priv *priv = dev_priv->engine.instmem.priv;
-        struct nouveau_vm *vm = NULL;
-
-        nvc0_instmem_suspend(dev);
-
-        nv_wr32(dev, 0x1704, 0x00000000);
-        nv_wr32(dev, 0x1714, 0x00000000);
-
-        nouveau_vm_ref(NULL, &dev_priv->chan_vm, NULL);
-
-        nvc0_channel_del(&priv->bar1);
-        nouveau_vm_ref(NULL, &dev_priv->bar1_vm, priv->bar1_pgd);
-        nouveau_gpuobj_ref(NULL, &priv->bar1_pgd);
-
-        nvc0_channel_del(&priv->bar3);
-        nouveau_vm_ref(dev_priv->bar3_vm, &vm, NULL);
-        nouveau_vm_ref(NULL, &vm, priv->bar3_pgd);
-        nouveau_gpuobj_ref(NULL, &priv->bar3_pgd);
-        nouveau_gpuobj_ref(NULL, &dev_priv->bar3_vm->pgt[0].obj[0]);
-        nouveau_vm_ref(NULL, &dev_priv->bar3_vm, NULL);
-
-        dev_priv->engine.instmem.priv = NULL;
-        kfree(priv);
-}
-
diff --git a/drivers/gpu/drm/nouveau/nvc0_pm.c b/drivers/gpu/drm/nouveau/nvc0_pm.c
index 4e712b10ebdb..0d34eb581179 100644
--- a/drivers/gpu/drm/nouveau/nvc0_pm.c
+++ b/drivers/gpu/drm/nouveau/nvc0_pm.c
@@ -22,18 +22,24 @@
  * Authors: Ben Skeggs
  */
 
-#include "drmP.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_bios.h"
 #include "nouveau_pm.h"
 
+#include <subdev/bios/pll.h>
+#include <subdev/bios.h>
+#include <subdev/clock.h>
+#include <subdev/timer.h>
+#include <subdev/fb.h>
+
 static u32 read_div(struct drm_device *, int, u32, u32);
 static u32 read_pll(struct drm_device *, u32);
 
 static u32
 read_vco(struct drm_device *dev, u32 dsrc)
 {
-        u32 ssrc = nv_rd32(dev, dsrc);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ssrc = nv_rd32(device, dsrc);
         if (!(ssrc & 0x00000100))
                 return read_pll(dev, 0x00e800);
         return read_pll(dev, 0x00e820);
@@ -42,8 +48,9 @@ read_vco(struct drm_device *dev, u32 dsrc)
 static u32
 read_pll(struct drm_device *dev, u32 pll)
 {
-        u32 ctrl = nv_rd32(dev, pll + 0);
-        u32 coef = nv_rd32(dev, pll + 4);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ctrl = nv_rd32(device, pll + 0);
+        u32 coef = nv_rd32(device, pll + 4);
         u32 P = (coef & 0x003f0000) >> 16;
         u32 N = (coef & 0x0000ff00) >> 8;
         u32 M = (coef & 0x000000ff) >> 0;
@@ -83,8 +90,9 @@ read_pll(struct drm_device *dev, u32 pll)
 static u32
 read_div(struct drm_device *dev, int doff, u32 dsrc, u32 dctl)
 {
-        u32 ssrc = nv_rd32(dev, dsrc + (doff * 4));
-        u32 sctl = nv_rd32(dev, dctl + (doff * 4));
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ssrc = nv_rd32(device, dsrc + (doff * 4));
+        u32 sctl = nv_rd32(device, dctl + (doff * 4));
 
         switch (ssrc & 0x00000003) {
         case 0:
@@ -109,7 +117,8 @@ read_div(struct drm_device *dev, int doff, u32 dsrc, u32 dctl)
 static u32
 read_mem(struct drm_device *dev)
 {
-        u32 ssel = nv_rd32(dev, 0x1373f0);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 ssel = nv_rd32(device, 0x1373f0);
         if (ssel & 0x00000001)
                 return read_div(dev, 0, 0x137300, 0x137310);
         return read_pll(dev, 0x132000);
@@ -118,8 +127,9 @@ read_mem(struct drm_device *dev)
 static u32
 read_clk(struct drm_device *dev, int clk)
 {
-        u32 sctl = nv_rd32(dev, 0x137250 + (clk * 4));
-        u32 ssel = nv_rd32(dev, 0x137100);
+        struct nouveau_device *device = nouveau_dev(dev);
+        u32 sctl = nv_rd32(device, 0x137250 + (clk * 4));
+        u32 ssel = nv_rd32(device, 0x137100);
         u32 sclk, sdiv;
 
         if (ssel & (1 << clk)) {
@@ -212,10 +222,12 @@ calc_src(struct drm_device *dev, int clk, u32 freq, u32 *dsrc, u32 *ddiv)
 static u32
 calc_pll(struct drm_device *dev, int clk, u32 freq, u32 *coef)
 {
-        struct pll_lims limits;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nvbios_pll limits;
         int N, M, P, ret;
 
-        ret = get_pll_limits(dev, 0x137000 + (clk * 0x20), &limits);
+        ret = nvbios_pll_parse(bios, 0x137000 + (clk * 0x20), &limits);
         if (ret)
                 return 0;
 
@@ -308,31 +320,33 @@ calc_clk(struct drm_device *dev, int clk, struct nvc0_pm_clock *info, u32 freq)
 static int
 calc_mem(struct drm_device *dev, struct nvc0_pm_clock *info, u32 freq)
 {
-        struct pll_lims pll;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_bios *bios = nouveau_bios(device);
+        struct nvbios_pll pll;
         int N, M, P, ret;
         u32 ctrl;
 
         /* mclk pll input freq comes from another pll, make sure it's on */
-        ctrl = nv_rd32(dev, 0x132020);
+        ctrl = nv_rd32(device, 0x132020);
         if (!(ctrl & 0x00000001)) {
                 /* if not, program it to 567MHz.  nfi where this value comes
                  * from - it looks like it's in the pll limits table for
                  * 132000 but the binary driver ignores all my attempts to
                  * change this value.
                  */
-                nv_wr32(dev, 0x137320, 0x00000103);
-                nv_wr32(dev, 0x137330, 0x81200606);
-                nv_wait(dev, 0x132020, 0x00010000, 0x00010000);
-                nv_wr32(dev, 0x132024, 0x0001150f);
-                nv_mask(dev, 0x132020, 0x00000001, 0x00000001);
-                nv_wait(dev, 0x137390, 0x00020000, 0x00020000);
-                nv_mask(dev, 0x132020, 0x00000004, 0x00000004);
+                nv_wr32(device, 0x137320, 0x00000103);
+                nv_wr32(device, 0x137330, 0x81200606);
+                nv_wait(device, 0x132020, 0x00010000, 0x00010000);
+                nv_wr32(device, 0x132024, 0x0001150f);
+                nv_mask(device, 0x132020, 0x00000001, 0x00000001);
+                nv_wait(device, 0x137390, 0x00020000, 0x00020000);
+                nv_mask(device, 0x132020, 0x00000004, 0x00000004);
         }
 
         /* for the moment, until the clock tree is better understood, use
          * pll mode for all clock frequencies
          */
-        ret = get_pll_limits(dev, 0x132000, &pll);
+        ret = nvbios_pll_parse(bios, 0x132000, &pll);
         if (ret == 0) {
                 pll.refclk = read_pll(dev, 0x132020);
                 if (pll.refclk) {
@@ -350,7 +364,7 @@ calc_mem(struct drm_device *dev, struct nvc0_pm_clock *info, u32 freq)
 void *
 nvc0_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nvc0_pm_state *info;
         int ret;
 
@@ -364,7 +378,7 @@ nvc0_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
          * are always the same freq with the binary driver even when the
          * performance table says they should differ.
          */
-        if (dev_priv->chipset == 0xd9)
+        if (device->chipset == 0xd9)
                 perflvl->rop = 0;
 
         if ((ret = calc_clk(dev, 0x00, &info->eng[0x00], perflvl->shader)) ||
@@ -394,38 +408,40 @@ nvc0_pm_clocks_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl)
 static void
 prog_clk(struct drm_device *dev, int clk, struct nvc0_pm_clock *info)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+
         /* program dividers at 137160/1371d0 first */
         if (clk < 7 && !info->ssel) {
-                nv_mask(dev, 0x1371d0 + (clk * 0x04), 0x80003f3f, info->ddiv);
-                nv_wr32(dev, 0x137160 + (clk * 0x04), info->dsrc);
+                nv_mask(device, 0x1371d0 + (clk * 0x04), 0x80003f3f, info->ddiv);
+                nv_wr32(device, 0x137160 + (clk * 0x04), info->dsrc);
         }
 
         /* switch clock to non-pll mode */
-        nv_mask(dev, 0x137100, (1 << clk), 0x00000000);
-        nv_wait(dev, 0x137100, (1 << clk), 0x00000000);
+        nv_mask(device, 0x137100, (1 << clk), 0x00000000);
+        nv_wait(device, 0x137100, (1 << clk), 0x00000000);
 
         /* reprogram pll */
         if (clk < 7) {
                 /* make sure it's disabled first... */
                 u32 base = 0x137000 + (clk * 0x20);
-                u32 ctrl = nv_rd32(dev, base + 0x00);
+                u32 ctrl = nv_rd32(device, base + 0x00);
                 if (ctrl & 0x00000001) {
-                        nv_mask(dev, base + 0x00, 0x00000004, 0x00000000);
-                        nv_mask(dev, base + 0x00, 0x00000001, 0x00000000);
+                        nv_mask(device, base + 0x00, 0x00000004, 0x00000000);
+                        nv_mask(device, base + 0x00, 0x00000001, 0x00000000);
                 }
                 /* program it to new values, if necessary */
                 if (info->ssel) {
-                        nv_wr32(dev, base + 0x04, info->coef);
-                        nv_mask(dev, base + 0x00, 0x00000001, 0x00000001);
-                        nv_wait(dev, base + 0x00, 0x00020000, 0x00020000);
-                        nv_mask(dev, base + 0x00, 0x00020004, 0x00000004);
+                        nv_wr32(device, base + 0x04, info->coef);
+                        nv_mask(device, base + 0x00, 0x00000001, 0x00000001);
+                        nv_wait(device, base + 0x00, 0x00020000, 0x00020000);
+                        nv_mask(device, base + 0x00, 0x00020004, 0x00000004);
                 }
         }
 
         /* select pll/non-pll mode, and program final clock divider */
-        nv_mask(dev, 0x137100, (1 << clk), info->ssel);
-        nv_wait(dev, 0x137100, (1 << clk), info->ssel);
-        nv_mask(dev, 0x137250 + (clk * 0x04), 0x00003f3f, info->mdiv);
+        nv_mask(device, 0x137100, (1 << clk), info->ssel);
+        nv_wait(device, 0x137100, (1 << clk), info->ssel);
+        nv_mask(device, 0x137250 + (clk * 0x04), 0x00003f3f, info->mdiv);
 }
 
 static void
@@ -441,7 +457,8 @@ mclk_refresh(struct nouveau_mem_exec_func *exec)
 static void
 mclk_refresh_auto(struct nouveau_mem_exec_func *exec, bool enable)
 {
-        nv_wr32(exec->dev, 0x10f210, enable ? 0x80000000 : 0x00000000);
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        nv_wr32(device, 0x10f210, enable ? 0x80000000 : 0x00000000);
 }
 
 static void
@@ -458,83 +475,84 @@ mclk_wait(struct nouveau_mem_exec_func *exec, u32 nsec)
 static u32
 mclk_mrg(struct nouveau_mem_exec_func *exec, int mr)
 {
-        struct drm_device *dev = exec->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        if (dev_priv->vram_type != NV_MEM_TYPE_GDDR5) {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        if (pfb->ram.type != NV_MEM_TYPE_GDDR5) {
                 if (mr <= 1)
-                        return nv_rd32(dev, 0x10f300 + ((mr - 0) * 4));
-                return nv_rd32(dev, 0x10f320 + ((mr - 2) * 4));
+                        return nv_rd32(device, 0x10f300 + ((mr - 0) * 4));
+                return nv_rd32(device, 0x10f320 + ((mr - 2) * 4));
         } else {
                 if (mr == 0)
-                        return nv_rd32(dev, 0x10f300 + (mr * 4));
+                        return nv_rd32(device, 0x10f300 + (mr * 4));
                 else
                 if (mr <= 7)
-                        return nv_rd32(dev, 0x10f32c + (mr * 4));
-                return nv_rd32(dev, 0x10f34c);
+                        return nv_rd32(device, 0x10f32c + (mr * 4));
+                return nv_rd32(device, 0x10f34c);
         }
 }
 
 static void
 mclk_mrs(struct nouveau_mem_exec_func *exec, int mr, u32 data)
 {
-        struct drm_device *dev = exec->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        if (dev_priv->vram_type != NV_MEM_TYPE_GDDR5) {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        if (pfb->ram.type != NV_MEM_TYPE_GDDR5) {
                 if (mr <= 1) {
-                        nv_wr32(dev, 0x10f300 + ((mr - 0) * 4), data);
-                        if (dev_priv->vram_rank_B)
-                                nv_wr32(dev, 0x10f308 + ((mr - 0) * 4), data);
+                        nv_wr32(device, 0x10f300 + ((mr - 0) * 4), data);
+                        if (pfb->ram.ranks > 1)
+                                nv_wr32(device, 0x10f308 + ((mr - 0) * 4), data);
                 } else
                 if (mr <= 3) {
-                        nv_wr32(dev, 0x10f320 + ((mr - 2) * 4), data);
-                        if (dev_priv->vram_rank_B)
-                                nv_wr32(dev, 0x10f328 + ((mr - 2) * 4), data);
+                        nv_wr32(device, 0x10f320 + ((mr - 2) * 4), data);
+                        if (pfb->ram.ranks > 1)
+                                nv_wr32(device, 0x10f328 + ((mr - 2) * 4), data);
                 }
         } else {
-                if      (mr ==  0) nv_wr32(dev, 0x10f300 + (mr * 4), data);
-                else if (mr <=  7) nv_wr32(dev, 0x10f32c + (mr * 4), data);
-                else if (mr == 15) nv_wr32(dev, 0x10f34c, data);
+                if      (mr ==  0) nv_wr32(device, 0x10f300 + (mr * 4), data);
+                else if (mr <=  7) nv_wr32(device, 0x10f32c + (mr * 4), data);
+                else if (mr == 15) nv_wr32(device, 0x10f34c, data);
         }
 }
 
 static void
 mclk_clock_set(struct nouveau_mem_exec_func *exec)
 {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         struct nvc0_pm_state *info = exec->priv;
-        struct drm_device *dev = exec->dev;
-        u32 ctrl = nv_rd32(dev, 0x132000);
+        u32 ctrl = nv_rd32(device, 0x132000);
 
-        nv_wr32(dev, 0x137360, 0x00000001);
-        nv_wr32(dev, 0x137370, 0x00000000);
-        nv_wr32(dev, 0x137380, 0x00000000);
+        nv_wr32(device, 0x137360, 0x00000001);
+        nv_wr32(device, 0x137370, 0x00000000);
+        nv_wr32(device, 0x137380, 0x00000000);
         if (ctrl & 0x00000001)
-                nv_wr32(dev, 0x132000, (ctrl &= ~0x00000001));
+                nv_wr32(device, 0x132000, (ctrl &= ~0x00000001));
 
-        nv_wr32(dev, 0x132004, info->mem.coef);
-        nv_wr32(dev, 0x132000, (ctrl |= 0x00000001));
-        nv_wait(dev, 0x137390, 0x00000002, 0x00000002);
-        nv_wr32(dev, 0x132018, 0x00005000);
+        nv_wr32(device, 0x132004, info->mem.coef);
+        nv_wr32(device, 0x132000, (ctrl |= 0x00000001));
+        nv_wait(device, 0x137390, 0x00000002, 0x00000002);
+        nv_wr32(device, 0x132018, 0x00005000);
 
-        nv_wr32(dev, 0x137370, 0x00000001);
-        nv_wr32(dev, 0x137380, 0x00000001);
-        nv_wr32(dev, 0x137360, 0x00000000);
+        nv_wr32(device, 0x137370, 0x00000001);
+        nv_wr32(device, 0x137380, 0x00000001);
+        nv_wr32(device, 0x137360, 0x00000000);
 }
 
 static void
 mclk_timing_set(struct nouveau_mem_exec_func *exec)
 {
+        struct nouveau_device *device = nouveau_dev(exec->dev);
         struct nvc0_pm_state *info = exec->priv;
         struct nouveau_pm_level *perflvl = info->perflvl;
         int i;
 
         for (i = 0; i < 5; i++)
-                nv_wr32(exec->dev, 0x10f290 + (i * 4), perflvl->timing.reg[i]);
+                nv_wr32(device, 0x10f290 + (i * 4), perflvl->timing.reg[i]);
 }
 
 static void
 prog_mem(struct drm_device *dev, struct nvc0_pm_state *info)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nouveau_mem_exec_func exec = {
                 .dev = dev,
                 .precharge = mclk_precharge,
@@ -549,17 +567,17 @@ prog_mem(struct drm_device *dev, struct nvc0_pm_state *info)
                 .priv = info
         };
 
-        if (dev_priv->chipset < 0xd0)
-                nv_wr32(dev, 0x611200, 0x00003300);
+        if (device->chipset < 0xd0)
+                nv_wr32(device, 0x611200, 0x00003300);
         else
-                nv_wr32(dev, 0x62c000, 0x03030000);
+                nv_wr32(device, 0x62c000, 0x03030000);
 
         nouveau_mem_exec(&exec, info->perflvl);
 
-        if (dev_priv->chipset < 0xd0)
-                nv_wr32(dev, 0x611200, 0x00003330);
+        if (device->chipset < 0xd0)
+                nv_wr32(device, 0x611200, 0x00003330);
         else
-                nv_wr32(dev, 0x62c000, 0x03030300);
+                nv_wr32(device, 0x62c000, 0x03030300);
 }
 int
 nvc0_pm_clocks_set(struct drm_device *dev, void *data)
diff --git a/drivers/gpu/drm/nouveau/nvc0_software.c b/drivers/gpu/drm/nouveau/nvc0_software.c
deleted file mode 100644
index 93e8c164fec6..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_software.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Copyright 2012 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"
-#include "nouveau_ramht.h"
-#include "nouveau_software.h"
-
-#include "nv50_display.h"
-
-struct nvc0_software_priv {
-        struct nouveau_software_priv base;
-};
-
-struct nvc0_software_chan {
-        struct nouveau_software_chan base;
-        struct nouveau_vma dispc_vma[4];
-};
-
-u64
-nvc0_software_crtc(struct nouveau_channel *chan, int crtc)
-{
-        struct nvc0_software_chan *pch = chan->engctx[NVOBJ_ENGINE_SW];
-        return pch->dispc_vma[crtc].offset;
-}
-
-static int
-nvc0_software_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_software_priv *psw = nv_engine(dev, NVOBJ_ENGINE_SW);
-        struct nvc0_software_chan *pch;
-        int ret = 0, i;
-
-        pch = kzalloc(sizeof(*pch), GFP_KERNEL);
-        if (!pch)
-                return -ENOMEM;
-
-        nouveau_software_context_new(&pch->base);
-        chan->engctx[engine] = pch;
-
-        /* map display semaphore buffers into channel's vm */
-        for (i = 0; !ret && i < dev->mode_config.num_crtc; i++) {
-                struct nouveau_bo *bo;
-                if (dev_priv->card_type >= NV_D0)
-                        bo = nvd0_display_crtc_sema(dev, i);
-                else
-                        bo = nv50_display(dev)->crtc[i].sem.bo;
-
-                ret = nouveau_bo_vma_add(bo, chan->vm, &pch->dispc_vma[i]);
-        }
-
-        if (ret)
-                psw->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nvc0_software_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nvc0_software_chan *pch = chan->engctx[engine];
-        int i;
-
-        if (dev_priv->card_type >= NV_D0) {
-                for (i = 0; i < dev->mode_config.num_crtc; i++) {
-                        struct nouveau_bo *bo = nvd0_display_crtc_sema(dev, i);
-                        nouveau_bo_vma_del(bo, &pch->dispc_vma[i]);
-                }
-        } else
-        if (dev_priv->card_type >= NV_50) {
-                struct nv50_display *disp = nv50_display(dev);
-                for (i = 0; i < dev->mode_config.num_crtc; i++) {
-                        struct nv50_display_crtc *dispc = &disp->crtc[i];
-                        nouveau_bo_vma_del(dispc->sem.bo, &pch->dispc_vma[i]);
-                }
-        }
-
-        chan->engctx[engine] = NULL;
-        kfree(pch);
-}
-
-static int
-nvc0_software_object_new(struct nouveau_channel *chan, int engine,
-                         u32 handle, u16 class)
-{
-        return 0;
-}
-
-static int
-nvc0_software_init(struct drm_device *dev, int engine)
-{
-        return 0;
-}
-
-static int
-nvc0_software_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static void
-nvc0_software_destroy(struct drm_device *dev, int engine)
-{
-        struct nvc0_software_priv *psw = nv_engine(dev, engine);
-
-        NVOBJ_ENGINE_DEL(dev, SW);
-        kfree(psw);
-}
-
-int
-nvc0_software_create(struct drm_device *dev)
-{
-        struct nvc0_software_priv *psw = kzalloc(sizeof(*psw), GFP_KERNEL);
-        if (!psw)
-                return -ENOMEM;
-
-        psw->base.base.destroy = nvc0_software_destroy;
-        psw->base.base.init = nvc0_software_init;
-        psw->base.base.fini = nvc0_software_fini;
-        psw->base.base.context_new = nvc0_software_context_new;
-        psw->base.base.context_del = nvc0_software_context_del;
-        psw->base.base.object_new = nvc0_software_object_new;
-        nouveau_software_create(&psw->base);
-
-        NVOBJ_ENGINE_ADD(dev, SW, &psw->base.base);
-        NVOBJ_CLASS(dev, 0x906e, SW);
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nvc0_vram.c b/drivers/gpu/drm/nouveau/nvc0_vram.c
deleted file mode 100644
index a7eef8934c07..000000000000
--- a/drivers/gpu/drm/nouveau/nvc0_vram.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * 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"
-#include "nouveau_mm.h"
-
-/* 0 = unsupported
- * 1 = non-compressed
- * 3 = compressed
- */
-static const u8 types[256] = {
-        1, 1, 3, 3, 3, 3, 0, 3, 3, 3, 3, 0, 0, 0, 0, 0,
-        0, 1, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
-        3, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 1, 1, 1, 1, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 3, 3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
-        3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3,
-        3, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 3, 0, 3,
-        3, 0, 3, 3, 3, 3, 3, 0, 0, 3, 0, 3, 0, 3, 3, 0,
-        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 1, 1, 0
-};
-
-bool
-nvc0_vram_flags_valid(struct drm_device *dev, u32 tile_flags)
-{
-        u8 memtype = (tile_flags & NOUVEAU_GEM_TILE_LAYOUT_MASK) >> 8;
-        return likely((types[memtype] == 1));
-}
-
-int
-nvc0_vram_new(struct drm_device *dev, u64 size, u32 align, u32 ncmin,
-              u32 type, struct nouveau_mem **pmem)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_mm *mm = &dev_priv->engine.vram.mm;
-        struct nouveau_mm_node *r;
-        struct nouveau_mem *mem;
-        int ret;
-
-        size  >>= 12;
-        align >>= 12;
-        ncmin >>= 12;
-
-        mem = kzalloc(sizeof(*mem), GFP_KERNEL);
-        if (!mem)
-                return -ENOMEM;
-
-        INIT_LIST_HEAD(&mem->regions);
-        mem->dev = dev_priv->dev;
-        mem->memtype = (type & 0xff);
-        mem->size = size;
-
-        mutex_lock(&mm->mutex);
-        do {
-                ret = nouveau_mm_get(mm, 1, size, ncmin, align, &r);
-                if (ret) {
-                        mutex_unlock(&mm->mutex);
-                        nv50_vram_del(dev, &mem);
-                        return ret;
-                }
-
-                list_add_tail(&r->rl_entry, &mem->regions);
-                size -= r->length;
-        } while (size);
-        mutex_unlock(&mm->mutex);
-
-        r = list_first_entry(&mem->regions, struct nouveau_mm_node, rl_entry);
-        mem->offset = (u64)r->offset << 12;
-        *pmem = mem;
-        return 0;
-}
-
-int
-nvc0_vram_init(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_vram_engine *vram = &dev_priv->engine.vram;
-        const u32 rsvd_head = ( 256 * 1024) >> 12; /* vga memory */
-        const u32 rsvd_tail = (1024 * 1024) >> 12; /* vbios etc */
-        u32 parts = nv_rd32(dev, 0x022438);
-        u32 pmask = nv_rd32(dev, 0x022554);
-        u32 bsize = nv_rd32(dev, 0x10f20c);
-        u32 offset, length;
-        bool uniform = true;
-        int ret, part;
-
-        NV_DEBUG(dev, "0x100800: 0x%08x\n", nv_rd32(dev, 0x100800));
-        NV_DEBUG(dev, "parts 0x%08x mask 0x%08x\n", parts, pmask);
-
-        dev_priv->vram_type = nouveau_mem_vbios_type(dev);
-        dev_priv->vram_rank_B = !!(nv_rd32(dev, 0x10f200) & 0x00000004);
-
-        /* read amount of vram attached to each memory controller */
-        for (part = 0; part < parts; part++) {
-                if (!(pmask & (1 << part))) {
-                        u32 psize = nv_rd32(dev, 0x11020c + (part * 0x1000));
-                        if (psize != bsize) {
-                                if (psize < bsize)
-                                        bsize = psize;
-                                uniform = false;
-                        }
-
-                        NV_DEBUG(dev, "%d: mem_amount 0x%08x\n", part, psize);
-                        dev_priv->vram_size += (u64)psize << 20;
-                }
-        }
-
-        /* if all controllers have the same amount attached, there's no holes */
-        if (uniform) {
-                offset = rsvd_head;
-                length = (dev_priv->vram_size >> 12) - rsvd_head - rsvd_tail;
-                return nouveau_mm_init(&vram->mm, offset, length, 1);
-        }
-
-        /* otherwise, address lowest common amount from 0GiB */
-        ret = nouveau_mm_init(&vram->mm, rsvd_head, (bsize << 8) * parts, 1);
-        if (ret)
-                return ret;
-
-        /* and the rest starting from (8GiB + common_size) */
-        offset = (0x0200000000ULL >> 12) + (bsize << 8);
-        length = (dev_priv->vram_size >> 12) - (bsize << 8) - rsvd_tail;
-
-        ret = nouveau_mm_init(&vram->mm, offset, length, 0);
-        if (ret) {
-                nouveau_mm_fini(&vram->mm);
-                return ret;
-        }
-
-        return 0;
-}
diff --git a/drivers/gpu/drm/nouveau/nvd0_display.c b/drivers/gpu/drm/nouveau/nvd0_display.c
index 8a2fc89b7763..37037bc33266 100644
--- a/drivers/gpu/drm/nouveau/nvd0_display.c
+++ b/drivers/gpu/drm/nouveau/nvd0_display.c
@@ -27,15 +27,21 @@
 #include "drmP.h"
 #include "drm_crtc_helper.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
+#include "nouveau_dma.h"
+#include "nouveau_gem.h"
 #include "nouveau_connector.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
-#include "nouveau_dma.h"
-#include "nouveau_fb.h"
-#include "nouveau_software.h"
+#include "nouveau_fence.h"
 #include "nv50_display.h"
 
+#include <core/gpuobj.h>
+
+#include <subdev/timer.h>
+#include <subdev/bar.h>
+#include <subdev/fb.h>
+
 #define EVO_DMA_NR 9
 
 #define EVO_MASTER  (0x00)
@@ -72,8 +78,7 @@ struct nvd0_display {
 static struct nvd0_display *
 nvd0_display(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        return dev_priv->engine.display.priv;
+        return nouveau_display(dev)->priv;
 }
 
 static struct drm_crtc *
@@ -88,55 +93,47 @@ nvd0_display_crtc_get(struct drm_encoder *encoder)
 static inline int
 evo_icmd(struct drm_device *dev, int id, u32 mthd, u32 data)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         int ret = 0;
-        nv_mask(dev, 0x610700 + (id * 0x10), 0x00000001, 0x00000001);
-        nv_wr32(dev, 0x610704 + (id * 0x10), data);
-        nv_mask(dev, 0x610704 + (id * 0x10), 0x80000ffc, 0x80000000 | mthd);
-        if (!nv_wait(dev, 0x610704 + (id * 0x10), 0x80000000, 0x00000000))
+        nv_mask(device, 0x610700 + (id * 0x10), 0x00000001, 0x00000001);
+        nv_wr32(device, 0x610704 + (id * 0x10), data);
+        nv_mask(device, 0x610704 + (id * 0x10), 0x80000ffc, 0x80000000 | mthd);
+        if (!nv_wait(device, 0x610704 + (id * 0x10), 0x80000000, 0x00000000))
                 ret = -EBUSY;
-        nv_mask(dev, 0x610700 + (id * 0x10), 0x00000001, 0x00000000);
+        nv_mask(device, 0x610700 + (id * 0x10), 0x00000001, 0x00000000);
         return ret;
 }
 
 static u32 *
 evo_wait(struct drm_device *dev, int id, int nr)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nvd0_display *disp = nvd0_display(dev);
-        u32 put = nv_rd32(dev, 0x640000 + (id * 0x1000)) / 4;
+        u32 put = nv_rd32(device, 0x640000 + (id * 0x1000)) / 4;
 
         if (put + nr >= (PAGE_SIZE / 4)) {
                 disp->evo[id].ptr[put] = 0x20000000;
 
-                nv_wr32(dev, 0x640000 + (id * 0x1000), 0x00000000);
-                if (!nv_wait(dev, 0x640004 + (id * 0x1000), ~0, 0x00000000)) {
-                        NV_ERROR(dev, "evo %d dma stalled\n", id);
+                nv_wr32(device, 0x640000 + (id * 0x1000), 0x00000000);
+                if (!nv_wait(device, 0x640004 + (id * 0x1000), ~0, 0x00000000)) {
+                        NV_ERROR(drm, "evo %d dma stalled\n", id);
                         return NULL;
                 }
 
                 put = 0;
         }
 
-        if (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
-                NV_INFO(dev, "Evo%d: %p START\n", id, disp->evo[id].ptr + put);
-
         return disp->evo[id].ptr + put;
 }
 
 static void
 evo_kick(u32 *push, struct drm_device *dev, int id)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nvd0_display *disp = nvd0_display(dev);
 
-        if (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO) {
-                u32 curp = nv_rd32(dev, 0x640000 + (id * 0x1000)) >> 2;
-                u32 *cur = disp->evo[id].ptr + curp;
-
-                while (cur < push)
-                        NV_INFO(dev, "Evo%d: 0x%08x\n", id, *cur++);
-                NV_INFO(dev, "Evo%d: %p KICK!\n", id, push);
-        }
-
-        nv_wr32(dev, 0x640000 + (id * 0x1000), (push - disp->evo[id].ptr) << 2);
+        nv_wr32(device, 0x640000 + (id * 0x1000), (push - disp->evo[id].ptr) << 2);
 }
 
 #define evo_mthd(p,m,s) *((p)++) = (((s) << 18) | (m))
@@ -145,6 +142,8 @@ evo_kick(u32 *push, struct drm_device *dev, int id)
 static int
 evo_init_dma(struct drm_device *dev, int ch)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nvd0_display *disp = nvd0_display(dev);
         u32 flags;
 
@@ -152,68 +151,76 @@ evo_init_dma(struct drm_device *dev, int ch)
         if (ch == EVO_MASTER)
                 flags |= 0x01000000;
 
-        nv_wr32(dev, 0x610494 + (ch * 0x0010), (disp->evo[ch].handle >> 8) | 3);
-        nv_wr32(dev, 0x610498 + (ch * 0x0010), 0x00010000);
-        nv_wr32(dev, 0x61049c + (ch * 0x0010), 0x00000001);
-        nv_mask(dev, 0x610490 + (ch * 0x0010), 0x00000010, 0x00000010);
-        nv_wr32(dev, 0x640000 + (ch * 0x1000), 0x00000000);
-        nv_wr32(dev, 0x610490 + (ch * 0x0010), 0x00000013 | flags);
-        if (!nv_wait(dev, 0x610490 + (ch * 0x0010), 0x80000000, 0x00000000)) {
-                NV_ERROR(dev, "PDISP: ch%d 0x%08x\n", ch,
-                              nv_rd32(dev, 0x610490 + (ch * 0x0010)));
+        nv_wr32(device, 0x610494 + (ch * 0x0010), (disp->evo[ch].handle >> 8) | 3);
+        nv_wr32(device, 0x610498 + (ch * 0x0010), 0x00010000);
+        nv_wr32(device, 0x61049c + (ch * 0x0010), 0x00000001);
+        nv_mask(device, 0x610490 + (ch * 0x0010), 0x00000010, 0x00000010);
+        nv_wr32(device, 0x640000 + (ch * 0x1000), 0x00000000);
+        nv_wr32(device, 0x610490 + (ch * 0x0010), 0x00000013 | flags);
+        if (!nv_wait(device, 0x610490 + (ch * 0x0010), 0x80000000, 0x00000000)) {
+                NV_ERROR(drm, "PDISP: ch%d 0x%08x\n", ch,
+                              nv_rd32(device, 0x610490 + (ch * 0x0010)));
                 return -EBUSY;
         }
 
-        nv_mask(dev, 0x610090, (1 << ch), (1 << ch));
-        nv_mask(dev, 0x6100a0, (1 << ch), (1 << ch));
+        nv_mask(device, 0x610090, (1 << ch), (1 << ch));
+        nv_mask(device, 0x6100a0, (1 << ch), (1 << ch));
         return 0;
 }
 
 static void
 evo_fini_dma(struct drm_device *dev, int ch)
 {
-        if (!(nv_rd32(dev, 0x610490 + (ch * 0x0010)) & 0x00000010))
+        struct nouveau_device *device = nouveau_dev(dev);
+
+        if (!(nv_rd32(device, 0x610490 + (ch * 0x0010)) & 0x00000010))
                 return;
 
-        nv_mask(dev, 0x610490 + (ch * 0x0010), 0x00000010, 0x00000000);
-        nv_mask(dev, 0x610490 + (ch * 0x0010), 0x00000003, 0x00000000);
-        nv_wait(dev, 0x610490 + (ch * 0x0010), 0x80000000, 0x00000000);
-        nv_mask(dev, 0x610090, (1 << ch), 0x00000000);
-        nv_mask(dev, 0x6100a0, (1 << ch), 0x00000000);
+        nv_mask(device, 0x610490 + (ch * 0x0010), 0x00000010, 0x00000000);
+        nv_mask(device, 0x610490 + (ch * 0x0010), 0x00000003, 0x00000000);
+        nv_wait(device, 0x610490 + (ch * 0x0010), 0x80000000, 0x00000000);
+        nv_mask(device, 0x610090, (1 << ch), 0x00000000);
+        nv_mask(device, 0x6100a0, (1 << ch), 0x00000000);
 }
 
 static inline void
 evo_piow(struct drm_device *dev, int ch, u16 mthd, u32 data)
 {
-        nv_wr32(dev, 0x640000 + (ch * 0x1000) + mthd, data);
+        struct nouveau_device *device = nouveau_dev(dev);
+        nv_wr32(device, 0x640000 + (ch * 0x1000) + mthd, data);
 }
 
 static int
 evo_init_pio(struct drm_device *dev, int ch)
 {
-        nv_wr32(dev, 0x610490 + (ch * 0x0010), 0x00000001);
-        if (!nv_wait(dev, 0x610490 + (ch * 0x0010), 0x00010000, 0x00010000)) {
-                NV_ERROR(dev, "PDISP: ch%d 0x%08x\n", ch,
-                              nv_rd32(dev, 0x610490 + (ch * 0x0010)));
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+
+        nv_wr32(device, 0x610490 + (ch * 0x0010), 0x00000001);
+        if (!nv_wait(device, 0x610490 + (ch * 0x0010), 0x00010000, 0x00010000)) {
+                NV_ERROR(drm, "PDISP: ch%d 0x%08x\n", ch,
+                              nv_rd32(device, 0x610490 + (ch * 0x0010)));
                 return -EBUSY;
         }
 
-        nv_mask(dev, 0x610090, (1 << ch), (1 << ch));
-        nv_mask(dev, 0x6100a0, (1 << ch), (1 << ch));
+        nv_mask(device, 0x610090, (1 << ch), (1 << ch));
+        nv_mask(device, 0x6100a0, (1 << ch), (1 << ch));
         return 0;
 }
 
 static void
 evo_fini_pio(struct drm_device *dev, int ch)
 {
-        if (!(nv_rd32(dev, 0x610490 + (ch * 0x0010)) & 0x00000001))
+        struct nouveau_device *device = nouveau_dev(dev);
+
+        if (!(nv_rd32(device, 0x610490 + (ch * 0x0010)) & 0x00000001))
                 return;
 
-        nv_mask(dev, 0x610490 + (ch * 0x0010), 0x00000010, 0x00000010);
-        nv_mask(dev, 0x610490 + (ch * 0x0010), 0x00000001, 0x00000000);
-        nv_wait(dev, 0x610490 + (ch * 0x0010), 0x00010000, 0x00000000);
-        nv_mask(dev, 0x610090, (1 << ch), 0x00000000);
-        nv_mask(dev, 0x6100a0, (1 << ch), 0x00000000);
+        nv_mask(device, 0x610490 + (ch * 0x0010), 0x00000010, 0x00000010);
+        nv_mask(device, 0x610490 + (ch * 0x0010), 0x00000001, 0x00000000);
+        nv_wait(device, 0x610490 + (ch * 0x0010), 0x00010000, 0x00000000);
+        nv_mask(device, 0x610090, (1 << ch), 0x00000000);
+        nv_mask(device, 0x6100a0, (1 << ch), 0x00000000);
 }
 
 static bool
@@ -225,6 +232,7 @@ evo_sync_wait(void *data)
 static int
 evo_sync(struct drm_device *dev, int ch)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         struct nvd0_display *disp = nvd0_display(dev);
         u32 *push = evo_wait(dev, ch, 8);
         if (push) {
@@ -235,7 +243,7 @@ evo_sync(struct drm_device *dev, int ch)
                 evo_data(push, 0x00000000);
                 evo_data(push, 0x00000000);
                 evo_kick(push, dev, ch);
-                if (nv_wait_cb(dev, evo_sync_wait, disp->sync))
+                if (nv_wait_cb(device, evo_sync_wait, disp->sync))
                         return 0;
         }
 
@@ -300,7 +308,7 @@ nvd0_display_flip_next(struct drm_crtc *crtc, struct drm_framebuffer *fb,
                         return ret;
 
 
-                offset  = nvc0_software_crtc(chan, nv_crtc->index);
+                offset  = nvc0_fence_crtc(chan, nv_crtc->index);
                 offset += evo->sem.offset;
 
                 BEGIN_NVC0(chan, 0, NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH, 4);
@@ -363,7 +371,7 @@ nvd0_display_flip_next(struct drm_crtc *crtc, struct drm_framebuffer *fb,
 static int
 nvd0_crtc_set_dither(struct nouveau_crtc *nv_crtc, bool update)
 {
-        struct drm_nouveau_private *dev_priv = nv_crtc->base.dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(nv_crtc->base.dev);
         struct drm_device *dev = nv_crtc->base.dev;
         struct nouveau_connector *nv_connector;
         struct drm_connector *connector;
@@ -386,7 +394,7 @@ nvd0_crtc_set_dither(struct nouveau_crtc *nv_crtc, bool update)
                 mode |= nv_connector->dithering_depth;
         }
 
-        if (dev_priv->card_type < NV_E0)
+        if (nv_device(drm->device)->card_type < NV_E0)
                 mthd = 0x0490 + (nv_crtc->index * 0x0300);
         else
                 mthd = 0x04a0 + (nv_crtc->index * 0x0300);
@@ -701,11 +709,12 @@ static int
 nvd0_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
                         struct drm_framebuffer *old_fb)
 {
+        struct nouveau_drm *drm = nouveau_drm(crtc->dev);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
         int ret;
 
         if (!crtc->fb) {
-                NV_DEBUG_KMS(crtc->dev, "No FB bound\n");
+                NV_DEBUG(drm, "No FB bound\n");
                 return 0;
         }
 
@@ -923,6 +932,7 @@ nvd0_dac_dpms(struct drm_encoder *encoder, int mode)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         int or = nv_encoder->or;
         u32 dpms_ctrl;
 
@@ -932,9 +942,9 @@ nvd0_dac_dpms(struct drm_encoder *encoder, int mode)
         if (mode == DRM_MODE_DPMS_SUSPEND || mode == DRM_MODE_DPMS_OFF)
                 dpms_ctrl |= 0x00000004;
 
-        nv_wait(dev, 0x61a004 + (or * 0x0800), 0x80000000, 0x00000000);
-        nv_mask(dev, 0x61a004 + (or * 0x0800), 0xc000007f, dpms_ctrl);
-        nv_wait(dev, 0x61a004 + (or * 0x0800), 0x80000000, 0x00000000);
+        nv_wait(device, 0x61a004 + (or * 0x0800), 0x80000000, 0x00000000);
+        nv_mask(device, 0x61a004 + (or * 0x0800), 0xc000007f, dpms_ctrl);
+        nv_wait(device, 0x61a004 + (or * 0x0800), 0x80000000, 0x00000000);
 }
 
 static bool
@@ -1025,18 +1035,19 @@ nvd0_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
         enum drm_connector_status status = connector_status_disconnected;
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         int or = nv_encoder->or;
         u32 load;
 
-        nv_wr32(dev, 0x61a00c + (or * 0x800), 0x00100000);
+        nv_wr32(device, 0x61a00c + (or * 0x800), 0x00100000);
         udelay(9500);
-        nv_wr32(dev, 0x61a00c + (or * 0x800), 0x80000000);
+        nv_wr32(device, 0x61a00c + (or * 0x800), 0x80000000);
 
-        load = nv_rd32(dev, 0x61a00c + (or * 0x800));
+        load = nv_rd32(device, 0x61a00c + (or * 0x800));
         if ((load & 0x38000000) == 0x38000000)
                 status = connector_status_connected;
 
-        nv_wr32(dev, 0x61a00c + (or * 0x800), 0x00000000);
+        nv_wr32(device, 0x61a00c + (or * 0x800), 0x00000000);
         return status;
 }
 
@@ -1063,7 +1074,7 @@ static const struct drm_encoder_funcs nvd0_dac_func = {
 };
 
 static int
-nvd0_dac_create(struct drm_connector *connector, struct dcb_entry *dcbe)
+nvd0_dac_create(struct drm_connector *connector, struct dcb_output *dcbe)
 {
         struct drm_device *dev = connector->dev;
         struct nouveau_encoder *nv_encoder;
@@ -1094,24 +1105,25 @@ nvd0_audio_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode)
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct nouveau_connector *nv_connector;
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         int i, or = nv_encoder->or * 0x30;
 
         nv_connector = nouveau_encoder_connector_get(nv_encoder);
         if (!drm_detect_monitor_audio(nv_connector->edid))
                 return;
 
-        nv_mask(dev, 0x10ec10 + or, 0x80000003, 0x80000001);
+        nv_mask(device, 0x10ec10 + or, 0x80000003, 0x80000001);
 
         drm_edid_to_eld(&nv_connector->base, nv_connector->edid);
         if (nv_connector->base.eld[0]) {
                 u8 *eld = nv_connector->base.eld;
 
                 for (i = 0; i < eld[2] * 4; i++)
-                        nv_wr32(dev, 0x10ec00 + or, (i << 8) | eld[i]);
+                        nv_wr32(device, 0x10ec00 + or, (i << 8) | eld[i]);
                 for (i = eld[2] * 4; i < 0x60; i++)
-                        nv_wr32(dev, 0x10ec00 + or, (i << 8) | 0x00);
+                        nv_wr32(device, 0x10ec00 + or, (i << 8) | 0x00);
 
-                nv_mask(dev, 0x10ec10 + or, 0x80000002, 0x80000002);
+                nv_mask(device, 0x10ec10 + or, 0x80000002, 0x80000002);
         }
 }
 
@@ -1120,9 +1132,10 @@ nvd0_audio_disconnect(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         int or = nv_encoder->or * 0x30;
 
-        nv_mask(dev, 0x10ec10 + or, 0x80000003, 0x80000000);
+        nv_mask(device, 0x10ec10 + or, 0x80000003, 0x80000000);
 }
 
 /******************************************************************************
@@ -1135,6 +1148,7 @@ nvd0_hdmi_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode)
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
         struct nouveau_connector *nv_connector;
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         int head = nv_crtc->index * 0x800;
         u32 rekey = 56; /* binary driver, and tegra constant */
         u32 max_ac_packet;
@@ -1149,25 +1163,25 @@ nvd0_hdmi_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode)
         max_ac_packet /= 32;
 
         /* AVI InfoFrame */
-        nv_mask(dev, 0x616714 + head, 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x61671c + head, 0x000d0282);
-        nv_wr32(dev, 0x616720 + head, 0x0000006f);
-        nv_wr32(dev, 0x616724 + head, 0x00000000);
-        nv_wr32(dev, 0x616728 + head, 0x00000000);
-        nv_wr32(dev, 0x61672c + head, 0x00000000);
-        nv_mask(dev, 0x616714 + head, 0x00000001, 0x00000001);
+        nv_mask(device, 0x616714 + head, 0x00000001, 0x00000000);
+        nv_wr32(device, 0x61671c + head, 0x000d0282);
+        nv_wr32(device, 0x616720 + head, 0x0000006f);
+        nv_wr32(device, 0x616724 + head, 0x00000000);
+        nv_wr32(device, 0x616728 + head, 0x00000000);
+        nv_wr32(device, 0x61672c + head, 0x00000000);
+        nv_mask(device, 0x616714 + head, 0x00000001, 0x00000001);
 
         /* ??? InfoFrame? */
-        nv_mask(dev, 0x6167a4 + head, 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x6167ac + head, 0x00000010);
-        nv_mask(dev, 0x6167a4 + head, 0x00000001, 0x00000001);
+        nv_mask(device, 0x6167a4 + head, 0x00000001, 0x00000000);
+        nv_wr32(device, 0x6167ac + head, 0x00000010);
+        nv_mask(device, 0x6167a4 + head, 0x00000001, 0x00000001);
 
         /* HDMI_CTRL */
-        nv_mask(dev, 0x616798 + head, 0x401f007f, 0x40000000 | rekey |
+        nv_mask(device, 0x616798 + head, 0x401f007f, 0x40000000 | rekey |
                                                   max_ac_packet << 16);
 
         /* NFI, audio doesn't work without it though.. */
-        nv_mask(dev, 0x616548 + head, 0x00000070, 0x00000000);
+        nv_mask(device, 0x616548 + head, 0x00000070, 0x00000000);
 
         nvd0_audio_mode_set(encoder, mode);
 }
@@ -1178,37 +1192,41 @@ nvd0_hdmi_disconnect(struct drm_encoder *encoder)
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(nv_encoder->crtc);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         int head = nv_crtc->index * 0x800;
 
         nvd0_audio_disconnect(encoder);
 
-        nv_mask(dev, 0x616798 + head, 0x40000000, 0x00000000);
-        nv_mask(dev, 0x6167a4 + head, 0x00000001, 0x00000000);
-        nv_mask(dev, 0x616714 + head, 0x00000001, 0x00000000);
+        nv_mask(device, 0x616798 + head, 0x40000000, 0x00000000);
+        nv_mask(device, 0x6167a4 + head, 0x00000001, 0x00000000);
+        nv_mask(device, 0x616714 + head, 0x00000001, 0x00000000);
 }
 
 /******************************************************************************
  * SOR
  *****************************************************************************/
 static inline u32
-nvd0_sor_dp_lane_map(struct drm_device *dev, struct dcb_entry *dcb, u8 lane)
+nvd0_sor_dp_lane_map(struct drm_device *dev, struct dcb_output *dcb, u8 lane)
 {
         static const u8 nvd0[] = { 16, 8, 0, 24 };
         return nvd0[lane];
 }
 
 static void
-nvd0_sor_dp_train_set(struct drm_device *dev, struct dcb_entry *dcb, u8 pattern)
+nvd0_sor_dp_train_set(struct drm_device *dev, struct dcb_output *dcb, u8 pattern)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         const u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
         const u32 loff = (or * 0x800) + (link * 0x80);
-        nv_mask(dev, 0x61c110 + loff, 0x0f0f0f0f, 0x01010101 * pattern);
+        nv_mask(device, 0x61c110 + loff, 0x0f0f0f0f, 0x01010101 * pattern);
 }
 
 static void
-nvd0_sor_dp_train_adj(struct drm_device *dev, struct dcb_entry *dcb,
+nvd0_sor_dp_train_adj(struct drm_device *dev, struct dcb_output *dcb,
                       u8 lane, u8 swing, u8 preem)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         const u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
         const u32 loff = (or * 0x800) + (link * 0x80);
         u32 shift = nvd0_sor_dp_lane_map(dev, dcb, lane);
@@ -1236,25 +1254,26 @@ nvd0_sor_dp_train_adj(struct drm_device *dev, struct dcb_entry *dcb,
         }
 
         if (!config) {
-                NV_ERROR(dev, "PDISP: unsupported DP table for chipset\n");
+                NV_ERROR(drm, "PDISP: unsupported DP table for chipset\n");
                 return;
         }
 
-        nv_mask(dev, 0x61c118 + loff, mask, config[1] << shift);
-        nv_mask(dev, 0x61c120 + loff, mask, config[2] << shift);
-        nv_mask(dev, 0x61c130 + loff, 0x0000ff00, config[3] << 8);
-        nv_mask(dev, 0x61c13c + loff, 0x00000000, 0x00000000);
+        nv_mask(device, 0x61c118 + loff, mask, config[1] << shift);
+        nv_mask(device, 0x61c120 + loff, mask, config[2] << shift);
+        nv_mask(device, 0x61c130 + loff, 0x0000ff00, config[3] << 8);
+        nv_mask(device, 0x61c13c + loff, 0x00000000, 0x00000000);
 }
 
 static void
-nvd0_sor_dp_link_set(struct drm_device *dev, struct dcb_entry *dcb, int crtc,
+nvd0_sor_dp_link_set(struct drm_device *dev, struct dcb_output *dcb, int crtc,
                      int link_nr, u32 link_bw, bool enhframe)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         const u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
         const u32 loff = (or * 0x800) + (link * 0x80);
         const u32 soff = (or * 0x800);
-        u32 dpctrl = nv_rd32(dev, 0x61c10c + loff) & ~0x001f4000;
-        u32 clksor = nv_rd32(dev, 0x612300 + soff) & ~0x007c0000;
+        u32 dpctrl = nv_rd32(device, 0x61c10c + loff) & ~0x001f4000;
+        u32 clksor = nv_rd32(device, 0x612300 + soff) & ~0x007c0000;
         u32 script = 0x0000, lane_mask = 0;
         u8 *table, *entry;
         int i;
@@ -1284,20 +1303,21 @@ nvd0_sor_dp_link_set(struct drm_device *dev, struct dcb_entry *dcb, int crtc,
         for (i = 0; i < link_nr; i++)
                 lane_mask |= 1 << (nvd0_sor_dp_lane_map(dev, dcb, i) >> 3);
 
-        nv_wr32(dev, 0x612300 + soff, clksor);
-        nv_wr32(dev, 0x61c10c + loff, dpctrl);
-        nv_mask(dev, 0x61c130 + loff, 0x0000000f, lane_mask);
+        nv_wr32(device, 0x612300 + soff, clksor);
+        nv_wr32(device, 0x61c10c + loff, dpctrl);
+        nv_mask(device, 0x61c130 + loff, 0x0000000f, lane_mask);
 }
 
 static void
-nvd0_sor_dp_link_get(struct drm_device *dev, struct dcb_entry *dcb,
+nvd0_sor_dp_link_get(struct drm_device *dev, struct dcb_output *dcb,
                      u32 *link_nr, u32 *link_bw)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         const u32 or = ffs(dcb->or) - 1, link = !(dcb->sorconf.link & 1);
         const u32 loff = (or * 0x800) + (link * 0x80);
         const u32 soff = (or * 0x800);
-        u32 dpctrl = nv_rd32(dev, 0x61c10c + loff) & 0x000f0000;
-        u32 clksor = nv_rd32(dev, 0x612300 + soff);
+        u32 dpctrl = nv_rd32(device, 0x61c10c + loff) & 0x000f0000;
+        u32 clksor = nv_rd32(device, 0x612300 + soff);
 
         if      (dpctrl > 0x00030000) *link_nr = 4;
         else if (dpctrl > 0x00010000) *link_nr = 2;
@@ -1308,9 +1328,10 @@ nvd0_sor_dp_link_get(struct drm_device *dev, struct dcb_entry *dcb,
 }
 
 static void
-nvd0_sor_dp_calc_tu(struct drm_device *dev, struct dcb_entry *dcb,
+nvd0_sor_dp_calc_tu(struct drm_device *dev, struct dcb_output *dcb,
                     u32 crtc, u32 datarate)
 {
+        struct nouveau_device *device = nouveau_dev(dev);
         const u32 symbol = 100000;
         const u32 TU = 64;
         u32 link_nr, link_bw;
@@ -1330,7 +1351,7 @@ nvd0_sor_dp_calc_tu(struct drm_device *dev, struct dcb_entry *dcb,
         value += 5;
         value |= 0x08000000;
 
-        nv_wr32(dev, 0x616610 + (crtc * 0x800), value);
+        nv_wr32(device, 0x616610 + (crtc * 0x800), value);
 }
 
 static void
@@ -1338,6 +1359,7 @@ nvd0_sor_dpms(struct drm_encoder *encoder, int mode)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_device *device = nouveau_dev(dev);
         struct drm_encoder *partner;
         int or = nv_encoder->or;
         u32 dpms_ctrl;
@@ -1361,12 +1383,12 @@ nvd0_sor_dpms(struct drm_encoder *encoder, int mode)
         dpms_ctrl  = (mode == DRM_MODE_DPMS_ON);
         dpms_ctrl |= 0x80000000;
 
-        nv_wait(dev, 0x61c004 + (or * 0x0800), 0x80000000, 0x00000000);
-        nv_mask(dev, 0x61c004 + (or * 0x0800), 0x80000001, dpms_ctrl);
-        nv_wait(dev, 0x61c004 + (or * 0x0800), 0x80000000, 0x00000000);
-        nv_wait(dev, 0x61c030 + (or * 0x0800), 0x10000000, 0x00000000);
+        nv_wait(device, 0x61c004 + (or * 0x0800), 0x80000000, 0x00000000);
+        nv_mask(device, 0x61c004 + (or * 0x0800), 0x80000001, dpms_ctrl);
+        nv_wait(device, 0x61c004 + (or * 0x0800), 0x80000000, 0x00000000);
+        nv_wait(device, 0x61c030 + (or * 0x0800), 0x10000000, 0x00000000);
 
-        if (nv_encoder->dcb->type == OUTPUT_DP) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_DP) {
                 struct dp_train_func func = {
                         .link_set = nvd0_sor_dp_link_set,
                         .train_set = nvd0_sor_dp_train_set,
@@ -1427,7 +1449,7 @@ static void
 nvd0_sor_prepare(struct drm_encoder *encoder)
 {
         nvd0_sor_disconnect(encoder);
-        if (nouveau_encoder(encoder)->dcb->type == OUTPUT_DP)
+        if (nouveau_encoder(encoder)->dcb->type == DCB_OUTPUT_DP)
                 evo_sync(encoder->dev, EVO_MASTER);
 }
 
@@ -1441,11 +1463,11 @@ nvd0_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
                   struct drm_display_mode *mode)
 {
         struct drm_device *dev = encoder->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
         struct nouveau_connector *nv_connector;
-        struct nvbios *bios = &dev_priv->vbios;
+        struct nvbios *bios = &drm->vbios;
         u32 mode_ctrl = (1 << nv_crtc->index);
         u32 syncs, magic, *push;
         u32 or_config;
@@ -1462,7 +1484,7 @@ nvd0_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 
         nv_connector = nouveau_encoder_connector_get(nv_encoder);
         switch (nv_encoder->dcb->type) {
-        case OUTPUT_TMDS:
+        case DCB_OUTPUT_TMDS:
                 if (nv_encoder->dcb->sorconf.link & 1) {
                         if (mode->clock < 165000)
                                 mode_ctrl |= 0x00000100;
@@ -1478,7 +1500,7 @@ nvd0_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 
                 nvd0_hdmi_mode_set(encoder, mode);
                 break;
-        case OUTPUT_LVDS:
+        case DCB_OUTPUT_LVDS:
                 or_config = (mode_ctrl & 0x00000f00) >> 8;
                 if (bios->fp_no_ddc) {
                         if (bios->fp.dual_link)
@@ -1507,7 +1529,7 @@ nvd0_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 
                 }
                 break;
-        case OUTPUT_DP:
+        case DCB_OUTPUT_DP:
                 if (nv_connector->base.display_info.bpc == 6) {
                         nv_encoder->dp.datarate = mode->clock * 18 / 8;
                         syncs |= 0x00000002 << 6;
@@ -1530,7 +1552,7 @@ nvd0_sor_mode_set(struct drm_encoder *encoder, struct drm_display_mode *umode,
 
         nvd0_sor_dpms(encoder, DRM_MODE_DPMS_ON);
 
-        if (nv_encoder->dcb->type == OUTPUT_DP) {
+        if (nv_encoder->dcb->type == DCB_OUTPUT_DP) {
                 nvd0_sor_dp_calc_tu(dev, nv_encoder->dcb, nv_crtc->index,
                                          nv_encoder->dp.datarate);
         }
@@ -1571,7 +1593,7 @@ static const struct drm_encoder_funcs nvd0_sor_func = {
 };
 
 static int
-nvd0_sor_create(struct drm_connector *connector, struct dcb_entry *dcbe)
+nvd0_sor_create(struct drm_connector *connector, struct dcb_output *dcbe)
 {
         struct drm_device *dev = connector->dev;
         struct nouveau_encoder *nv_encoder;
@@ -1597,50 +1619,51 @@ nvd0_sor_create(struct drm_connector *connector, struct dcb_entry *dcbe)
 /******************************************************************************
  * IRQ
  *****************************************************************************/
-static struct dcb_entry *
+static struct dcb_output *
 lookup_dcb(struct drm_device *dev, int id, u32 mc)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int type, or, i, link = -1;
 
         if (id < 4) {
-                type = OUTPUT_ANALOG;
+                type = DCB_OUTPUT_ANALOG;
                 or   = id;
         } else {
                 switch (mc & 0x00000f00) {
-                case 0x00000000: link = 0; type = OUTPUT_LVDS; break;
-                case 0x00000100: link = 0; type = OUTPUT_TMDS; break;
-                case 0x00000200: link = 1; type = OUTPUT_TMDS; break;
-                case 0x00000500: link = 0; type = OUTPUT_TMDS; break;
-                case 0x00000800: link = 0; type = OUTPUT_DP; break;
-                case 0x00000900: link = 1; type = OUTPUT_DP; break;
+                case 0x00000000: link = 0; type = DCB_OUTPUT_LVDS; break;
+                case 0x00000100: link = 0; type = DCB_OUTPUT_TMDS; break;
+                case 0x00000200: link = 1; type = DCB_OUTPUT_TMDS; break;
+                case 0x00000500: link = 0; type = DCB_OUTPUT_TMDS; break;
+                case 0x00000800: link = 0; type = DCB_OUTPUT_DP; break;
+                case 0x00000900: link = 1; type = DCB_OUTPUT_DP; break;
                 default:
-                        NV_ERROR(dev, "PDISP: unknown SOR mc 0x%08x\n", mc);
+                        NV_ERROR(drm, "PDISP: unknown SOR mc 0x%08x\n", mc);
                         return NULL;
                 }
 
                 or = id - 4;
         }
 
-        for (i = 0; i < dev_priv->vbios.dcb.entries; i++) {
-                struct dcb_entry *dcb = &dev_priv->vbios.dcb.entry[i];
+        for (i = 0; i < drm->vbios.dcb.entries; i++) {
+                struct dcb_output *dcb = &drm->vbios.dcb.entry[i];
                 if (dcb->type == type && (dcb->or & (1 << or)) &&
                     (link < 0 || link == !(dcb->sorconf.link & 1)))
                         return dcb;
         }
 
-        NV_ERROR(dev, "PDISP: DCB for %d/0x%08x not found\n", id, mc);
+        NV_ERROR(drm, "PDISP: DCB for %d/0x%08x not found\n", id, mc);
         return NULL;
 }
 
 static void
 nvd0_display_unk1_handler(struct drm_device *dev, u32 crtc, u32 mask)
 {
-        struct dcb_entry *dcb;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct dcb_output *dcb;
         int i;
 
         for (i = 0; mask && i < 8; i++) {
-                u32 mcc = nv_rd32(dev, 0x640180 + (i * 0x20));
+                u32 mcc = nv_rd32(device, 0x640180 + (i * 0x20));
                 if (!(mcc & (1 << crtc)))
                         continue;
 
@@ -1651,20 +1674,22 @@ nvd0_display_unk1_handler(struct drm_device *dev, u32 crtc, u32 mask)
                 nouveau_bios_run_display_table(dev, 0x0000, -1, dcb, crtc);
         }
 
-        nv_wr32(dev, 0x6101d4, 0x00000000);
-        nv_wr32(dev, 0x6109d4, 0x00000000);
-        nv_wr32(dev, 0x6101d0, 0x80000000);
+        nv_wr32(device, 0x6101d4, 0x00000000);
+        nv_wr32(device, 0x6109d4, 0x00000000);
+        nv_wr32(device, 0x6101d0, 0x80000000);
 }
 
 static void
 nvd0_display_unk2_handler(struct drm_device *dev, u32 crtc, u32 mask)
 {
-        struct dcb_entry *dcb;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct dcb_output *dcb;
         u32 or, tmp, pclk;
         int i;
 
         for (i = 0; mask && i < 8; i++) {
-                u32 mcc = nv_rd32(dev, 0x640180 + (i * 0x20));
+                u32 mcc = nv_rd32(device, 0x640180 + (i * 0x20));
                 if (!(mcc & (1 << crtc)))
                         continue;
 
@@ -1675,16 +1700,16 @@ nvd0_display_unk2_handler(struct drm_device *dev, u32 crtc, u32 mask)
                 nouveau_bios_run_display_table(dev, 0x0000, -2, dcb, crtc);
         }
 
-        pclk = nv_rd32(dev, 0x660450 + (crtc * 0x300)) / 1000;
-        NV_DEBUG_KMS(dev, "PDISP: crtc %d pclk %d mask 0x%08x\n",
+        pclk = nv_rd32(device, 0x660450 + (crtc * 0x300)) / 1000;
+        NV_DEBUG(drm, "PDISP: crtc %d pclk %d mask 0x%08x\n",
                           crtc, pclk, mask);
         if (pclk && (mask & 0x00010000)) {
                 nv50_crtc_set_clock(dev, crtc, pclk);
         }
 
         for (i = 0; mask && i < 8; i++) {
-                u32 mcp = nv_rd32(dev, 0x660180 + (i * 0x20));
-                u32 cfg = nv_rd32(dev, 0x660184 + (i * 0x20));
+                u32 mcp = nv_rd32(device, 0x660180 + (i * 0x20));
+                u32 cfg = nv_rd32(device, 0x660184 + (i * 0x20));
                 if (!(mcp & (1 << crtc)))
                         continue;
 
@@ -1695,20 +1720,20 @@ nvd0_display_unk2_handler(struct drm_device *dev, u32 crtc, u32 mask)
 
                 nouveau_bios_run_display_table(dev, cfg, pclk, dcb, crtc);
 
-                nv_wr32(dev, 0x612200 + (crtc * 0x800), 0x00000000);
+                nv_wr32(device, 0x612200 + (crtc * 0x800), 0x00000000);
                 switch (dcb->type) {
-                case OUTPUT_ANALOG:
-                        nv_wr32(dev, 0x612280 + (or * 0x800), 0x00000000);
+                case DCB_OUTPUT_ANALOG:
+                        nv_wr32(device, 0x612280 + (or * 0x800), 0x00000000);
                         break;
-                case OUTPUT_TMDS:
-                case OUTPUT_LVDS:
-                case OUTPUT_DP:
+                case DCB_OUTPUT_TMDS:
+                case DCB_OUTPUT_LVDS:
+                case DCB_OUTPUT_DP:
                         if (cfg & 0x00000100)
                                 tmp = 0x00000101;
                         else
                                 tmp = 0x00000000;
 
-                        nv_mask(dev, 0x612300 + (or * 0x800), 0x00000707, tmp);
+                        nv_mask(device, 0x612300 + (or * 0x800), 0x00000707, tmp);
                         break;
                 default:
                         break;
@@ -1717,22 +1742,23 @@ nvd0_display_unk2_handler(struct drm_device *dev, u32 crtc, u32 mask)
                 break;
         }
 
-        nv_wr32(dev, 0x6101d4, 0x00000000);
-        nv_wr32(dev, 0x6109d4, 0x00000000);
-        nv_wr32(dev, 0x6101d0, 0x80000000);
+        nv_wr32(device, 0x6101d4, 0x00000000);
+        nv_wr32(device, 0x6109d4, 0x00000000);
+        nv_wr32(device, 0x6101d0, 0x80000000);
 }
 
 static void
 nvd0_display_unk4_handler(struct drm_device *dev, u32 crtc, u32 mask)
 {
-        struct dcb_entry *dcb;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct dcb_output *dcb;
         int pclk, i;
 
-        pclk = nv_rd32(dev, 0x660450 + (crtc * 0x300)) / 1000;
+        pclk = nv_rd32(device, 0x660450 + (crtc * 0x300)) / 1000;
 
         for (i = 0; mask && i < 8; i++) {
-                u32 mcp = nv_rd32(dev, 0x660180 + (i * 0x20));
-                u32 cfg = nv_rd32(dev, 0x660184 + (i * 0x20));
+                u32 mcp = nv_rd32(device, 0x660180 + (i * 0x20));
+                u32 cfg = nv_rd32(device, 0x660184 + (i * 0x20));
                 if (!(mcp & (1 << crtc)))
                         continue;
 
@@ -1743,34 +1769,36 @@ nvd0_display_unk4_handler(struct drm_device *dev, u32 crtc, u32 mask)
                 nouveau_bios_run_display_table(dev, cfg, -pclk, dcb, crtc);
         }
 
-        nv_wr32(dev, 0x6101d4, 0x00000000);
-        nv_wr32(dev, 0x6109d4, 0x00000000);
-        nv_wr32(dev, 0x6101d0, 0x80000000);
+        nv_wr32(device, 0x6101d4, 0x00000000);
+        nv_wr32(device, 0x6109d4, 0x00000000);
+        nv_wr32(device, 0x6101d0, 0x80000000);
 }
 
 static void
 nvd0_display_bh(unsigned long data)
 {
         struct drm_device *dev = (struct drm_device *)data;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct nvd0_display *disp = nvd0_display(dev);
         u32 mask = 0, crtc = ~0;
         int i;
 
         if (drm_debug & (DRM_UT_DRIVER | DRM_UT_KMS)) {
-                NV_INFO(dev, "PDISP: modeset req %d\n", disp->modeset);
-                NV_INFO(dev, " STAT: 0x%08x 0x%08x 0x%08x\n",
-                         nv_rd32(dev, 0x6101d0),
-                         nv_rd32(dev, 0x6101d4), nv_rd32(dev, 0x6109d4));
+                NV_INFO(drm, "PDISP: modeset req %d\n", disp->modeset);
+                NV_INFO(drm, " STAT: 0x%08x 0x%08x 0x%08x\n",
+                         nv_rd32(device, 0x6101d0),
+                         nv_rd32(device, 0x6101d4), nv_rd32(device, 0x6109d4));
                 for (i = 0; i < 8; i++) {
-                        NV_INFO(dev, " %s%d: 0x%08x 0x%08x\n",
+                        NV_INFO(drm, " %s%d: 0x%08x 0x%08x\n",
                                 i < 4 ? "DAC" : "SOR", i,
-                                nv_rd32(dev, 0x640180 + (i * 0x20)),
-                                nv_rd32(dev, 0x660180 + (i * 0x20)));
+                                nv_rd32(device, 0x640180 + (i * 0x20)),
+                                nv_rd32(device, 0x660180 + (i * 0x20)));
                 }
         }
 
         while (!mask && ++crtc < dev->mode_config.num_crtc)
-                mask = nv_rd32(dev, 0x6101d4 + (crtc * 0x800));
+                mask = nv_rd32(device, 0x6101d4 + (crtc * 0x800));
 
         if (disp->modeset & 0x00000001)
                 nvd0_display_unk1_handler(dev, crtc, mask);
@@ -1780,67 +1808,60 @@ nvd0_display_bh(unsigned long data)
                 nvd0_display_unk4_handler(dev, crtc, mask);
 }
 
-static void
+void
 nvd0_display_intr(struct drm_device *dev)
 {
         struct nvd0_display *disp = nvd0_display(dev);
-        u32 intr = nv_rd32(dev, 0x610088);
-        int i;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        u32 intr = nv_rd32(device, 0x610088);
 
         if (intr & 0x00000001) {
-                u32 stat = nv_rd32(dev, 0x61008c);
-                nv_wr32(dev, 0x61008c, stat);
+                u32 stat = nv_rd32(device, 0x61008c);
+                nv_wr32(device, 0x61008c, stat);
                 intr &= ~0x00000001;
         }
 
         if (intr & 0x00000002) {
-                u32 stat = nv_rd32(dev, 0x61009c);
+                u32 stat = nv_rd32(device, 0x61009c);
                 int chid = ffs(stat) - 1;
                 if (chid >= 0) {
-                        u32 mthd = nv_rd32(dev, 0x6101f0 + (chid * 12));
-                        u32 data = nv_rd32(dev, 0x6101f4 + (chid * 12));
-                        u32 unkn = nv_rd32(dev, 0x6101f8 + (chid * 12));
+                        u32 mthd = nv_rd32(device, 0x6101f0 + (chid * 12));
+                        u32 data = nv_rd32(device, 0x6101f4 + (chid * 12));
+                        u32 unkn = nv_rd32(device, 0x6101f8 + (chid * 12));
 
-                        NV_INFO(dev, "EvoCh: chid %d mthd 0x%04x data 0x%08x "
+                        NV_INFO(drm, "EvoCh: chid %d mthd 0x%04x data 0x%08x "
                                      "0x%08x 0x%08x\n",
                                 chid, (mthd & 0x0000ffc), data, mthd, unkn);
-                        nv_wr32(dev, 0x61009c, (1 << chid));
-                        nv_wr32(dev, 0x6101f0 + (chid * 12), 0x90000000);
+                        nv_wr32(device, 0x61009c, (1 << chid));
+                        nv_wr32(device, 0x6101f0 + (chid * 12), 0x90000000);
                 }
 
                 intr &= ~0x00000002;
         }
 
         if (intr & 0x00100000) {
-                u32 stat = nv_rd32(dev, 0x6100ac);
+                u32 stat = nv_rd32(device, 0x6100ac);
 
                 if (stat & 0x00000007) {
                         disp->modeset = stat;
                         tasklet_schedule(&disp->tasklet);
 
-                        nv_wr32(dev, 0x6100ac, (stat & 0x00000007));
+                        nv_wr32(device, 0x6100ac, (stat & 0x00000007));
                         stat &= ~0x00000007;
                 }
 
                 if (stat) {
-                        NV_INFO(dev, "PDISP: unknown intr24 0x%08x\n", stat);
-                        nv_wr32(dev, 0x6100ac, stat);
+                        NV_INFO(drm, "PDISP: unknown intr24 0x%08x\n", stat);
+                        nv_wr32(device, 0x6100ac, stat);
                 }
 
                 intr &= ~0x00100000;
         }
 
-        for (i = 0; i < dev->mode_config.num_crtc; i++) {
-                u32 mask = 0x01000000 << i;
-                if (intr & mask) {
-                        u32 stat = nv_rd32(dev, 0x6100bc + (i * 0x800));
-                        nv_wr32(dev, 0x6100bc + (i * 0x800), stat);
-                        intr &= ~mask;
-                }
-        }
-
+        intr &= ~0x0f000000; /* vblank, handled in core */
         if (intr)
-                NV_INFO(dev, "PDISP: unknown intr 0x%08x\n", intr);
+                NV_INFO(drm, "PDISP: unknown intr 0x%08x\n", intr);
 }
 
 /******************************************************************************
@@ -1867,15 +1888,17 @@ int
 nvd0_display_init(struct drm_device *dev)
 {
         struct nvd0_display *disp = nvd0_display(dev);
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int ret, i;
         u32 *push;
 
-        if (nv_rd32(dev, 0x6100ac) & 0x00000100) {
-                nv_wr32(dev, 0x6100ac, 0x00000100);
-                nv_mask(dev, 0x6194e8, 0x00000001, 0x00000000);
-                if (!nv_wait(dev, 0x6194e8, 0x00000002, 0x00000000)) {
-                        NV_ERROR(dev, "PDISP: 0x6194e8 0x%08x\n",
-                                 nv_rd32(dev, 0x6194e8));
+        if (nv_rd32(device, 0x6100ac) & 0x00000100) {
+                nv_wr32(device, 0x6100ac, 0x00000100);
+                nv_mask(device, 0x6194e8, 0x00000001, 0x00000000);
+                if (!nv_wait(device, 0x6194e8, 0x00000002, 0x00000000)) {
+                        NV_ERROR(drm, "PDISP: 0x6194e8 0x%08x\n",
+                                 nv_rd32(device, 0x6194e8));
                         return -EBUSY;
                 }
         }
@@ -1884,27 +1907,27 @@ nvd0_display_init(struct drm_device *dev)
          * work at all unless you do the SOR part below.
          */
         for (i = 0; i < 3; i++) {
-                u32 dac = nv_rd32(dev, 0x61a000 + (i * 0x800));
-                nv_wr32(dev, 0x6101c0 + (i * 0x800), dac);
+                u32 dac = nv_rd32(device, 0x61a000 + (i * 0x800));
+                nv_wr32(device, 0x6101c0 + (i * 0x800), dac);
         }
 
         for (i = 0; i < 4; i++) {
-                u32 sor = nv_rd32(dev, 0x61c000 + (i * 0x800));
-                nv_wr32(dev, 0x6301c4 + (i * 0x800), sor);
+                u32 sor = nv_rd32(device, 0x61c000 + (i * 0x800));
+                nv_wr32(device, 0x6301c4 + (i * 0x800), sor);
         }
 
         for (i = 0; i < dev->mode_config.num_crtc; i++) {
-                u32 crtc0 = nv_rd32(dev, 0x616104 + (i * 0x800));
-                u32 crtc1 = nv_rd32(dev, 0x616108 + (i * 0x800));
-                u32 crtc2 = nv_rd32(dev, 0x61610c + (i * 0x800));
-                nv_wr32(dev, 0x6101b4 + (i * 0x800), crtc0);
-                nv_wr32(dev, 0x6101b8 + (i * 0x800), crtc1);
-                nv_wr32(dev, 0x6101bc + (i * 0x800), crtc2);
+                u32 crtc0 = nv_rd32(device, 0x616104 + (i * 0x800));
+                u32 crtc1 = nv_rd32(device, 0x616108 + (i * 0x800));
+                u32 crtc2 = nv_rd32(device, 0x61610c + (i * 0x800));
+                nv_wr32(device, 0x6101b4 + (i * 0x800), crtc0);
+                nv_wr32(device, 0x6101b8 + (i * 0x800), crtc1);
+                nv_wr32(device, 0x6101bc + (i * 0x800), crtc2);
         }
 
         /* point at our hash table / objects, enable interrupts */
-        nv_wr32(dev, 0x610010, (disp->mem->vinst >> 8) | 9);
-        nv_mask(dev, 0x6100b0, 0x00000307, 0x00000307);
+        nv_wr32(device, 0x610010, (disp->mem->addr >> 8) | 9);
+        nv_mask(device, 0x6100b0, 0x00000307, 0x00000307);
 
         /* init master */
         ret = evo_init_dma(dev, EVO_MASTER);
@@ -1944,7 +1967,6 @@ error:
 void
 nvd0_display_destroy(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nvd0_display *disp = nvd0_display(dev);
         struct pci_dev *pdev = dev->pdev;
         int i;
@@ -1957,31 +1979,36 @@ nvd0_display_destroy(struct drm_device *dev)
         nouveau_gpuobj_ref(NULL, &disp->mem);
         nouveau_bo_unmap(disp->sync);
         nouveau_bo_ref(NULL, &disp->sync);
-        nouveau_irq_unregister(dev, 26);
 
-        dev_priv->engine.display.priv = NULL;
+        nouveau_display(dev)->priv = NULL;
         kfree(disp);
 }
 
 int
 nvd0_display_create(struct drm_device *dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct dcb_table *dcb = &dev_priv->vbios.dcb;
+        struct nouveau_device *device = nouveau_dev(dev);
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_bar *bar = nouveau_bar(device);
+        struct nouveau_fb *pfb = nouveau_fb(device);
+        struct dcb_table *dcb = &drm->vbios.dcb;
         struct drm_connector *connector, *tmp;
         struct pci_dev *pdev = dev->pdev;
         struct nvd0_display *disp;
-        struct dcb_entry *dcbe;
+        struct dcb_output *dcbe;
         int crtcs, ret, i;
 
         disp = kzalloc(sizeof(*disp), GFP_KERNEL);
         if (!disp)
                 return -ENOMEM;
-        dev_priv->engine.display.priv = disp;
+
+        nouveau_display(dev)->priv = disp;
+        nouveau_display(dev)->dtor = nvd0_display_destroy;
+        nouveau_display(dev)->init = nvd0_display_init;
+        nouveau_display(dev)->fini = nvd0_display_fini;
 
         /* create crtc objects to represent the hw heads */
-        crtcs = nv_rd32(dev, 0x022448);
+        crtcs = nv_rd32(device, 0x022448);
         for (i = 0; i < crtcs; i++) {
                 ret = nvd0_crtc_create(dev, i);
                 if (ret)
@@ -1995,22 +2022,22 @@ nvd0_display_create(struct drm_device *dev)
                         continue;
 
                 if (dcbe->location != DCB_LOC_ON_CHIP) {
-                        NV_WARN(dev, "skipping off-chip encoder %d/%d\n",
+                        NV_WARN(drm, "skipping off-chip encoder %d/%d\n",
                                 dcbe->type, ffs(dcbe->or) - 1);
                         continue;
                 }
 
                 switch (dcbe->type) {
-                case OUTPUT_TMDS:
-                case OUTPUT_LVDS:
-                case OUTPUT_DP:
+                case DCB_OUTPUT_TMDS:
+                case DCB_OUTPUT_LVDS:
+                case DCB_OUTPUT_DP:
                         nvd0_sor_create(connector, dcbe);
                         break;
-                case OUTPUT_ANALOG:
+                case DCB_OUTPUT_ANALOG:
                         nvd0_dac_create(connector, dcbe);
                         break;
                 default:
-                        NV_WARN(dev, "skipping unsupported encoder %d/%d\n",
+                        NV_WARN(drm, "skipping unsupported encoder %d/%d\n",
                                 dcbe->type, ffs(dcbe->or) - 1);
                         continue;
                 }
@@ -2021,14 +2048,13 @@ nvd0_display_create(struct drm_device *dev)
                 if (connector->encoder_ids[0])
                         continue;
 
-                NV_WARN(dev, "%s has no encoders, removing\n",
+                NV_WARN(drm, "%s has no encoders, removing\n",
                         drm_get_connector_name(connector));
                 connector->funcs->destroy(connector);
         }
 
         /* setup interrupt handling */
         tasklet_init(&disp->tasklet, nvd0_display_bh, (unsigned long)dev);
-        nouveau_irq_register(dev, 26, nvd0_display_intr);
 
         /* small shared memory area we use for notifiers and semaphores */
         ret = nouveau_bo_new(dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
@@ -2045,7 +2071,7 @@ nvd0_display_create(struct drm_device *dev)
                 goto out;
 
         /* hash table and dma objects for the memory areas we care about */
-        ret = nouveau_gpuobj_new(dev, NULL, 0x4000, 0x10000,
+        ret = nouveau_gpuobj_new(nv_object(device), NULL, 0x4000, 0x10000,
                                  NVOBJ_FLAG_ZERO_ALLOC, &disp->mem);
         if (ret)
                 goto out;
@@ -2077,7 +2103,7 @@ nvd0_display_create(struct drm_device *dev)
 
                 nv_wo32(disp->mem, dmao + 0x20, 0x00000049);
                 nv_wo32(disp->mem, dmao + 0x24, 0x00000000);
-                nv_wo32(disp->mem, dmao + 0x28, (dev_priv->vram_size - 1) >> 8);
+                nv_wo32(disp->mem, dmao + 0x28, (pfb->ram.size - 1) >> 8);
                 nv_wo32(disp->mem, dmao + 0x2c, 0x00000000);
                 nv_wo32(disp->mem, dmao + 0x30, 0x00000000);
                 nv_wo32(disp->mem, dmao + 0x34, 0x00000000);
@@ -2087,7 +2113,7 @@ nvd0_display_create(struct drm_device *dev)
 
                 nv_wo32(disp->mem, dmao + 0x40, 0x00000009);
                 nv_wo32(disp->mem, dmao + 0x44, 0x00000000);
-                nv_wo32(disp->mem, dmao + 0x48, (dev_priv->vram_size - 1) >> 8);
+                nv_wo32(disp->mem, dmao + 0x48, (pfb->ram.size - 1) >> 8);
                 nv_wo32(disp->mem, dmao + 0x4c, 0x00000000);
                 nv_wo32(disp->mem, dmao + 0x50, 0x00000000);
                 nv_wo32(disp->mem, dmao + 0x54, 0x00000000);
@@ -2097,7 +2123,7 @@ nvd0_display_create(struct drm_device *dev)
 
                 nv_wo32(disp->mem, dmao + 0x60, 0x0fe00009);
                 nv_wo32(disp->mem, dmao + 0x64, 0x00000000);
-                nv_wo32(disp->mem, dmao + 0x68, (dev_priv->vram_size - 1) >> 8);
+                nv_wo32(disp->mem, dmao + 0x68, (pfb->ram.size - 1) >> 8);
                 nv_wo32(disp->mem, dmao + 0x6c, 0x00000000);
                 nv_wo32(disp->mem, dmao + 0x70, 0x00000000);
                 nv_wo32(disp->mem, dmao + 0x74, 0x00000000);
@@ -2106,7 +2132,7 @@ nvd0_display_create(struct drm_device *dev)
                                                 ((dmao + 0x60) << 9));
         }
 
-        pinstmem->flush(dev);
+        bar->flush(bar);
 
 out:
         if (ret)
diff --git a/drivers/gpu/drm/nouveau/nve0_fifo.c b/drivers/gpu/drm/nouveau/nve0_fifo.c
deleted file mode 100644
index e98d144e6eb9..000000000000
--- a/drivers/gpu/drm/nouveau/nve0_fifo.c
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * 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"
-#include "nouveau_mm.h"
-#include "nouveau_fifo.h"
-
-#define NVE0_FIFO_ENGINE_NUM 32
-
-static void nve0_fifo_isr(struct drm_device *);
-
-struct nve0_fifo_engine {
-        struct nouveau_gpuobj *playlist[2];
-        int cur_playlist;
-};
-
-struct nve0_fifo_priv {
-        struct nouveau_fifo_priv base;
-        struct nve0_fifo_engine engine[NVE0_FIFO_ENGINE_NUM];
-        struct {
-                struct nouveau_gpuobj *mem;
-                struct nouveau_vma bar;
-        } user;
-        int spoon_nr;
-};
-
-struct nve0_fifo_chan {
-        struct nouveau_fifo_chan base;
-        u32 engine;
-};
-
-static void
-nve0_fifo_playlist_update(struct drm_device *dev, u32 engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nve0_fifo_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct nve0_fifo_engine *peng = &priv->engine[engine];
-        struct nouveau_gpuobj *cur;
-        u32 match = (engine << 16) | 0x00000001;
-        int ret, i, p;
-
-        cur = peng->playlist[peng->cur_playlist];
-        if (unlikely(cur == NULL)) {
-                ret = nouveau_gpuobj_new(dev, NULL, 0x8000, 0x1000, 0, &cur);
-                if (ret) {
-                        NV_ERROR(dev, "PFIFO: playlist alloc failed\n");
-                        return;
-                }
-
-                peng->playlist[peng->cur_playlist] = cur;
-        }
-
-        peng->cur_playlist = !peng->cur_playlist;
-
-        for (i = 0, p = 0; i < priv->base.channels; i++) {
-                u32 ctrl = nv_rd32(dev, 0x800004 + (i * 8)) & 0x001f0001;
-                if (ctrl != match)
-                        continue;
-                nv_wo32(cur, p + 0, i);
-                nv_wo32(cur, p + 4, 0x00000000);
-                p += 8;
-        }
-        pinstmem->flush(dev);
-
-        nv_wr32(dev, 0x002270, cur->vinst >> 12);
-        nv_wr32(dev, 0x002274, (engine << 20) | (p >> 3));
-        if (!nv_wait(dev, 0x002284 + (engine * 4), 0x00100000, 0x00000000))
-                NV_ERROR(dev, "PFIFO: playlist %d update timeout\n", engine);
-}
-
-static int
-nve0_fifo_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nve0_fifo_priv *priv = nv_engine(dev, engine);
-        struct nve0_fifo_chan *fctx;
-        u64 usermem = priv->user.mem->vinst + chan->id * 512;
-        u64 ib_virt = chan->pushbuf_base + chan->dma.ib_base * 4;
-        int ret = 0, i;
-
-        fctx = chan->engctx[engine] = kzalloc(sizeof(*fctx), GFP_KERNEL);
-        if (!fctx)
-                return -ENOMEM;
-
-        fctx->engine = 0; /* PGRAPH */
-
-        /* allocate vram for control regs, map into polling area */
-        chan->user = ioremap_wc(pci_resource_start(dev->pdev, 1) +
-                                priv->user.bar.offset + (chan->id * 512), 512);
-        if (!chan->user) {
-                ret = -ENOMEM;
-                goto error;
-        }
-
-        for (i = 0; i < 0x100; i += 4)
-                nv_wo32(chan->ramin, i, 0x00000000);
-        nv_wo32(chan->ramin, 0x08, lower_32_bits(usermem));
-        nv_wo32(chan->ramin, 0x0c, upper_32_bits(usermem));
-        nv_wo32(chan->ramin, 0x10, 0x0000face);
-        nv_wo32(chan->ramin, 0x30, 0xfffff902);
-        nv_wo32(chan->ramin, 0x48, lower_32_bits(ib_virt));
-        nv_wo32(chan->ramin, 0x4c, drm_order(chan->dma.ib_max + 1) << 16 |
-                                     upper_32_bits(ib_virt));
-        nv_wo32(chan->ramin, 0x84, 0x20400000);
-        nv_wo32(chan->ramin, 0x94, 0x30000001);
-        nv_wo32(chan->ramin, 0x9c, 0x00000100);
-        nv_wo32(chan->ramin, 0xac, 0x0000001f);
-        nv_wo32(chan->ramin, 0xe4, 0x00000000);
-        nv_wo32(chan->ramin, 0xe8, chan->id);
-        nv_wo32(chan->ramin, 0xf8, 0x10003080); /* 0x002310 */
-        nv_wo32(chan->ramin, 0xfc, 0x10000010); /* 0x002350 */
-        pinstmem->flush(dev);
-
-        nv_wr32(dev, 0x800000 + (chan->id * 8), 0x80000000 |
-                                                (chan->ramin->vinst >> 12));
-        nv_mask(dev, 0x800004 + (chan->id * 8), 0x00000400, 0x00000400);
-        nve0_fifo_playlist_update(dev, fctx->engine);
-        nv_mask(dev, 0x800004 + (chan->id * 8), 0x00000400, 0x00000400);
-
-error:
-        if (ret)
-                priv->base.base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nve0_fifo_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nve0_fifo_chan *fctx = chan->engctx[engine];
-        struct drm_device *dev = chan->dev;
-
-        nv_mask(dev, 0x800004 + (chan->id * 8), 0x00000800, 0x00000800);
-        nv_wr32(dev, 0x002634, chan->id);
-        if (!nv_wait(dev, 0x0002634, 0xffffffff, chan->id))
-                NV_WARN(dev, "0x2634 != chid: 0x%08x\n", nv_rd32(dev, 0x2634));
-        nve0_fifo_playlist_update(dev, fctx->engine);
-        nv_wr32(dev, 0x800000 + (chan->id * 8), 0x00000000);
-
-        if (chan->user) {
-                iounmap(chan->user);
-                chan->user = NULL;
-        }
-
-        chan->engctx[NVOBJ_ENGINE_FIFO] = NULL;
-        kfree(fctx);
-}
-
-static int
-nve0_fifo_init(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nve0_fifo_priv *priv = nv_engine(dev, engine);
-        struct nve0_fifo_chan *fctx;
-        int i;
-
-        /* reset PFIFO, enable all available PSUBFIFO areas */
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000000);
-        nv_mask(dev, 0x000200, 0x00000100, 0x00000100);
-        nv_wr32(dev, 0x000204, 0xffffffff);
-
-        priv->spoon_nr = hweight32(nv_rd32(dev, 0x000204));
-        NV_DEBUG(dev, "PFIFO: %d subfifo(s)\n", priv->spoon_nr);
-
-        /* PSUBFIFO[n] */
-        for (i = 0; i < priv->spoon_nr; i++) {
-                nv_mask(dev, 0x04013c + (i * 0x2000), 0x10000100, 0x00000000);
-                nv_wr32(dev, 0x040108 + (i * 0x2000), 0xffffffff); /* INTR */
-                nv_wr32(dev, 0x04010c + (i * 0x2000), 0xfffffeff); /* INTR_EN */
-        }
-
-        nv_wr32(dev, 0x002254, 0x10000000 | priv->user.bar.offset >> 12);
-
-        nv_wr32(dev, 0x002a00, 0xffffffff);
-        nv_wr32(dev, 0x002100, 0xffffffff);
-        nv_wr32(dev, 0x002140, 0xbfffffff);
-
-        /* restore PFIFO context table */
-        for (i = 0; i < priv->base.channels; i++) {
-                struct nouveau_channel *chan = dev_priv->channels.ptr[i];
-                if (!chan || !(fctx = chan->engctx[engine]))
-                        continue;
-
-                nv_wr32(dev, 0x800000 + (i * 8), 0x80000000 |
-                                                 (chan->ramin->vinst >> 12));
-                nv_mask(dev, 0x800004 + (i * 8), 0x00000400, 0x00000400);
-                nve0_fifo_playlist_update(dev, fctx->engine);
-                nv_mask(dev, 0x800004 + (i * 8), 0x00000400, 0x00000400);
-        }
-
-        return 0;
-}
-
-static int
-nve0_fifo_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        struct nve0_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-
-        for (i = 0; i < priv->base.channels; i++) {
-                if (!(nv_rd32(dev, 0x800004 + (i * 8)) & 1))
-                        continue;
-
-                nv_mask(dev, 0x800004 + (i * 8), 0x00000800, 0x00000800);
-                nv_wr32(dev, 0x002634, i);
-                if (!nv_wait(dev, 0x002634, 0xffffffff, i)) {
-                        NV_INFO(dev, "PFIFO: kick ch %d failed: 0x%08x\n",
-                                i, nv_rd32(dev, 0x002634));
-                        return -EBUSY;
-                }
-        }
-
-        nv_wr32(dev, 0x002140, 0x00000000);
-        return 0;
-}
-
-struct nouveau_enum nve0_fifo_fault_unit[] = {
-        {}
-};
-
-struct nouveau_enum nve0_fifo_fault_reason[] = {
-        { 0x00, "PT_NOT_PRESENT" },
-        { 0x01, "PT_TOO_SHORT" },
-        { 0x02, "PAGE_NOT_PRESENT" },
-        { 0x03, "VM_LIMIT_EXCEEDED" },
-        { 0x04, "NO_CHANNEL" },
-        { 0x05, "PAGE_SYSTEM_ONLY" },
-        { 0x06, "PAGE_READ_ONLY" },
-        { 0x0a, "COMPRESSED_SYSRAM" },
-        { 0x0c, "INVALID_STORAGE_TYPE" },
-        {}
-};
-
-struct nouveau_enum nve0_fifo_fault_hubclient[] = {
-        {}
-};
-
-struct nouveau_enum nve0_fifo_fault_gpcclient[] = {
-        {}
-};
-
-struct nouveau_bitfield nve0_fifo_subfifo_intr[] = {
-        { 0x00200000, "ILLEGAL_MTHD" },
-        { 0x00800000, "EMPTY_SUBC" },
-        {}
-};
-
-static void
-nve0_fifo_isr_vm_fault(struct drm_device *dev, int unit)
-{
-        u32 inst = nv_rd32(dev, 0x2800 + (unit * 0x10));
-        u32 valo = nv_rd32(dev, 0x2804 + (unit * 0x10));
-        u32 vahi = nv_rd32(dev, 0x2808 + (unit * 0x10));
-        u32 stat = nv_rd32(dev, 0x280c + (unit * 0x10));
-        u32 client = (stat & 0x00001f00) >> 8;
-
-        NV_INFO(dev, "PFIFO: %s fault at 0x%010llx [",
-                (stat & 0x00000080) ? "write" : "read", (u64)vahi << 32 | valo);
-        nouveau_enum_print(nve0_fifo_fault_reason, stat & 0x0000000f);
-        printk("] from ");
-        nouveau_enum_print(nve0_fifo_fault_unit, unit);
-        if (stat & 0x00000040) {
-                printk("/");
-                nouveau_enum_print(nve0_fifo_fault_hubclient, client);
-        } else {
-                printk("/GPC%d/", (stat & 0x1f000000) >> 24);
-                nouveau_enum_print(nve0_fifo_fault_gpcclient, client);
-        }
-        printk(" on channel 0x%010llx\n", (u64)inst << 12);
-}
-
-static int
-nve0_fifo_page_flip(struct drm_device *dev, u32 chid)
-{
-        struct nve0_fifo_priv *priv = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan = NULL;
-        unsigned long flags;
-        int ret = -EINVAL;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        if (likely(chid >= 0 && chid < priv->base.channels)) {
-                chan = dev_priv->channels.ptr[chid];
-                if (likely(chan))
-                        ret = nouveau_finish_page_flip(chan, NULL);
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return ret;
-}
-
-static void
-nve0_fifo_isr_subfifo_intr(struct drm_device *dev, int unit)
-{
-        u32 stat = nv_rd32(dev, 0x040108 + (unit * 0x2000));
-        u32 addr = nv_rd32(dev, 0x0400c0 + (unit * 0x2000));
-        u32 data = nv_rd32(dev, 0x0400c4 + (unit * 0x2000));
-        u32 chid = nv_rd32(dev, 0x040120 + (unit * 0x2000)) & 0x7f;
-        u32 subc = (addr & 0x00070000);
-        u32 mthd = (addr & 0x00003ffc);
-        u32 show = stat;
-
-        if (stat & 0x00200000) {
-                if (mthd == 0x0054) {
-                        if (!nve0_fifo_page_flip(dev, chid))
-                                show &= ~0x00200000;
-                }
-        }
-
-        if (show) {
-                NV_INFO(dev, "PFIFO%d:", unit);
-                nouveau_bitfield_print(nve0_fifo_subfifo_intr, show);
-                NV_INFO(dev, "PFIFO%d: ch %d subc %d mthd 0x%04x data 0x%08x\n",
-                        unit, chid, subc, mthd, data);
-        }
-
-        nv_wr32(dev, 0x0400c0 + (unit * 0x2000), 0x80600008);
-        nv_wr32(dev, 0x040108 + (unit * 0x2000), stat);
-}
-
-static void
-nve0_fifo_isr(struct drm_device *dev)
-{
-        u32 stat = nv_rd32(dev, 0x002100);
-
-        if (stat & 0x00000100) {
-                NV_INFO(dev, "PFIFO: unknown status 0x00000100\n");
-                nv_wr32(dev, 0x002100, 0x00000100);
-                stat &= ~0x00000100;
-        }
-
-        if (stat & 0x10000000) {
-                u32 units = nv_rd32(dev, 0x00259c);
-                u32 u = units;
-
-                while (u) {
-                        int i = ffs(u) - 1;
-                        nve0_fifo_isr_vm_fault(dev, i);
-                        u &= ~(1 << i);
-                }
-
-                nv_wr32(dev, 0x00259c, units);
-                stat &= ~0x10000000;
-        }
-
-        if (stat & 0x20000000) {
-                u32 units = nv_rd32(dev, 0x0025a0);
-                u32 u = units;
-
-                while (u) {
-                        int i = ffs(u) - 1;
-                        nve0_fifo_isr_subfifo_intr(dev, i);
-                        u &= ~(1 << i);
-                }
-
-                nv_wr32(dev, 0x0025a0, units);
-                stat &= ~0x20000000;
-        }
-
-        if (stat & 0x40000000) {
-                NV_INFO(dev, "PFIFO: unknown status 0x40000000\n");
-                nv_mask(dev, 0x002a00, 0x00000000, 0x00000000);
-                stat &= ~0x40000000;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PFIFO: unhandled status 0x%08x\n", stat);
-                nv_wr32(dev, 0x002100, stat);
-                nv_wr32(dev, 0x002140, 0);
-        }
-}
-
-static void
-nve0_fifo_destroy(struct drm_device *dev, int engine)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nve0_fifo_priv *priv = nv_engine(dev, engine);
-        int i;
-
-        nouveau_vm_put(&priv->user.bar);
-        nouveau_gpuobj_ref(NULL, &priv->user.mem);
-
-        for (i = 0; i < NVE0_FIFO_ENGINE_NUM; i++) {
-                nouveau_gpuobj_ref(NULL, &priv->engine[i].playlist[0]);
-                nouveau_gpuobj_ref(NULL, &priv->engine[i].playlist[1]);
-        }
-
-        dev_priv->eng[engine] = NULL;
-        kfree(priv);
-}
-
-int
-nve0_fifo_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nve0_fifo_priv *priv;
-        int ret;
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.base.destroy = nve0_fifo_destroy;
-        priv->base.base.init = nve0_fifo_init;
-        priv->base.base.fini = nve0_fifo_fini;
-        priv->base.base.context_new = nve0_fifo_context_new;
-        priv->base.base.context_del = nve0_fifo_context_del;
-        priv->base.channels = 4096;
-        dev_priv->eng[NVOBJ_ENGINE_FIFO] = &priv->base.base;
-
-        ret = nouveau_gpuobj_new(dev, NULL, priv->base.channels * 512, 0x1000,
-                                 NVOBJ_FLAG_ZERO_ALLOC, &priv->user.mem);
-        if (ret)
-                goto error;
-
-        ret = nouveau_vm_get(dev_priv->bar1_vm, priv->user.mem->size,
-                             12, NV_MEM_ACCESS_RW, &priv->user.bar);
-        if (ret)
-                goto error;
-
-        nouveau_vm_map(&priv->user.bar, *(struct nouveau_mem **)priv->user.mem->node);
-
-        nouveau_irq_register(dev, 8, nve0_fifo_isr);
-error:
-        if (ret)
-                priv->base.base.destroy(dev, NVOBJ_ENGINE_FIFO);
-        return ret;
-}
diff --git a/drivers/gpu/drm/nouveau/nve0_graph.c b/drivers/gpu/drm/nouveau/nve0_graph.c
deleted file mode 100644
index 8a8051b68f10..000000000000
--- a/drivers/gpu/drm/nouveau/nve0_graph.c
+++ /dev/null
@@ -1,831 +0,0 @@
-/*
- * 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 <linux/firmware.h>
-#include <linux/module.h>
-
-#include "drmP.h"
-
-#include "nouveau_drv.h"
-#include "nouveau_mm.h"
-#include "nouveau_fifo.h"
-
-#include "nve0_graph.h"
-
-static void
-nve0_graph_ctxctl_debug_unit(struct drm_device *dev, u32 base)
-{
-        NV_INFO(dev, "PGRAPH: %06x - done 0x%08x\n", base,
-                nv_rd32(dev, base + 0x400));
-        NV_INFO(dev, "PGRAPH: %06x - stat 0x%08x 0x%08x 0x%08x 0x%08x\n", base,
-                nv_rd32(dev, base + 0x800), nv_rd32(dev, base + 0x804),
-                nv_rd32(dev, base + 0x808), nv_rd32(dev, base + 0x80c));
-        NV_INFO(dev, "PGRAPH: %06x - stat 0x%08x 0x%08x 0x%08x 0x%08x\n", base,
-                nv_rd32(dev, base + 0x810), nv_rd32(dev, base + 0x814),
-                nv_rd32(dev, base + 0x818), nv_rd32(dev, base + 0x81c));
-}
-
-static void
-nve0_graph_ctxctl_debug(struct drm_device *dev)
-{
-        u32 gpcnr = nv_rd32(dev, 0x409604) & 0xffff;
-        u32 gpc;
-
-        nve0_graph_ctxctl_debug_unit(dev, 0x409000);
-        for (gpc = 0; gpc < gpcnr; gpc++)
-                nve0_graph_ctxctl_debug_unit(dev, 0x502000 + (gpc * 0x8000));
-}
-
-static int
-nve0_graph_load_context(struct nouveau_channel *chan)
-{
-        struct drm_device *dev = chan->dev;
-
-        nv_wr32(dev, 0x409840, 0x00000030);
-        nv_wr32(dev, 0x409500, 0x80000000 | chan->ramin->vinst >> 12);
-        nv_wr32(dev, 0x409504, 0x00000003);
-        if (!nv_wait(dev, 0x409800, 0x00000010, 0x00000010))
-                NV_ERROR(dev, "PGRAPH: load_ctx timeout\n");
-
-        return 0;
-}
-
-static int
-nve0_graph_unload_context_to(struct drm_device *dev, u64 chan)
-{
-        nv_wr32(dev, 0x409840, 0x00000003);
-        nv_wr32(dev, 0x409500, 0x80000000 | chan >> 12);
-        nv_wr32(dev, 0x409504, 0x00000009);
-        if (!nv_wait(dev, 0x409800, 0x00000001, 0x00000000)) {
-                NV_ERROR(dev, "PGRAPH: unload_ctx timeout\n");
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static int
-nve0_graph_construct_context(struct nouveau_channel *chan)
-{
-        struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
-        struct nve0_graph_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_GR);
-        struct nve0_graph_chan *grch = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        int ret, i;
-        u32 *ctx;
-
-        ctx = kmalloc(priv->grctx_size, GFP_KERNEL);
-        if (!ctx)
-                return -ENOMEM;
-
-        nve0_graph_load_context(chan);
-
-        nv_wo32(grch->grctx, 0x1c, 1);
-        nv_wo32(grch->grctx, 0x20, 0);
-        nv_wo32(grch->grctx, 0x28, 0);
-        nv_wo32(grch->grctx, 0x2c, 0);
-        dev_priv->engine.instmem.flush(dev);
-
-        ret = nve0_grctx_generate(chan);
-        if (ret)
-                goto err;
-
-        ret = nve0_graph_unload_context_to(dev, chan->ramin->vinst);
-        if (ret)
-                goto err;
-
-        for (i = 0; i < priv->grctx_size; i += 4)
-                ctx[i / 4] = nv_ro32(grch->grctx, i);
-
-        priv->grctx_vals = ctx;
-        return 0;
-
-err:
-        kfree(ctx);
-        return ret;
-}
-
-static int
-nve0_graph_create_context_mmio_list(struct nouveau_channel *chan)
-{
-        struct nve0_graph_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_GR);
-        struct nve0_graph_chan *grch = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        u32 magic[GPC_MAX][2];
-        u16 offset = 0x0000;
-        int gpc;
-        int ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 0x3000, 256, NVOBJ_FLAG_VM,
-                                 &grch->unk408004);
-        if (ret)
-                return ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 0x8000, 256, NVOBJ_FLAG_VM,
-                                 &grch->unk40800c);
-        if (ret)
-                return ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 384 * 1024, 4096,
-                                 NVOBJ_FLAG_VM | NVOBJ_FLAG_VM_USER,
-                                 &grch->unk418810);
-        if (ret)
-                return ret;
-
-        ret = nouveau_gpuobj_new(dev, chan, 0x1000, 0, NVOBJ_FLAG_VM,
-                                 &grch->mmio);
-        if (ret)
-                return ret;
-
-#define mmio(r,v) do {                                                         \
-        nv_wo32(grch->mmio, (grch->mmio_nr * 8) + 0, (r));                     \
-        nv_wo32(grch->mmio, (grch->mmio_nr * 8) + 4, (v));                     \
-        grch->mmio_nr++;                                                       \
-} while (0)
-        mmio(0x40800c, grch->unk40800c->linst >> 8);
-        mmio(0x408010, 0x80000000);
-        mmio(0x419004, grch->unk40800c->linst >> 8);
-        mmio(0x419008, 0x00000000);
-        mmio(0x4064cc, 0x80000000);
-        mmio(0x408004, grch->unk408004->linst >> 8);
-        mmio(0x408008, 0x80000030);
-        mmio(0x418808, grch->unk408004->linst >> 8);
-        mmio(0x41880c, 0x80000030);
-        mmio(0x4064c8, 0x01800600);
-        mmio(0x418810, 0x80000000 | grch->unk418810->linst >> 12);
-        mmio(0x419848, 0x10000000 | grch->unk418810->linst >> 12);
-        mmio(0x405830, 0x02180648);
-        mmio(0x4064c4, 0x0192ffff);
-
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                u16 magic0 = 0x0218 * priv->tpc_nr[gpc];
-                u16 magic1 = 0x0648 * priv->tpc_nr[gpc];
-                magic[gpc][0]  = 0x10000000 | (magic0 << 16) | offset;
-                magic[gpc][1]  = 0x00000000 | (magic1 << 16);
-                offset += 0x0324 * priv->tpc_nr[gpc];
-        }
-
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                mmio(GPC_UNIT(gpc, 0x30c0), magic[gpc][0]);
-                mmio(GPC_UNIT(gpc, 0x30e4), magic[gpc][1] | offset);
-                offset += 0x07ff * priv->tpc_nr[gpc];
-        }
-
-        mmio(0x17e91c, 0x06060609);
-        mmio(0x17e920, 0x00090a05);
-#undef mmio
-        return 0;
-}
-
-static int
-nve0_graph_context_new(struct nouveau_channel *chan, int engine)
-{
-        struct drm_device *dev = chan->dev;
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_instmem_engine *pinstmem = &dev_priv->engine.instmem;
-        struct nve0_graph_priv *priv = nv_engine(dev, engine);
-        struct nve0_graph_chan *grch;
-        struct nouveau_gpuobj *grctx;
-        int ret, i;
-
-        grch = kzalloc(sizeof(*grch), GFP_KERNEL);
-        if (!grch)
-                return -ENOMEM;
-        chan->engctx[NVOBJ_ENGINE_GR] = grch;
-
-        ret = nouveau_gpuobj_new(dev, chan, priv->grctx_size, 256,
-                                 NVOBJ_FLAG_VM | NVOBJ_FLAG_ZERO_ALLOC,
-                                 &grch->grctx);
-        if (ret)
-                goto error;
-        grctx = grch->grctx;
-
-        ret = nve0_graph_create_context_mmio_list(chan);
-        if (ret)
-                goto error;
-
-        nv_wo32(chan->ramin, 0x0210, lower_32_bits(grctx->linst) | 4);
-        nv_wo32(chan->ramin, 0x0214, upper_32_bits(grctx->linst));
-        pinstmem->flush(dev);
-
-        if (!priv->grctx_vals) {
-                ret = nve0_graph_construct_context(chan);
-                if (ret)
-                        goto error;
-        }
-
-        for (i = 0; i < priv->grctx_size; i += 4)
-                nv_wo32(grctx, i, priv->grctx_vals[i / 4]);
-        nv_wo32(grctx, 0xf4, 0);
-        nv_wo32(grctx, 0xf8, 0);
-        nv_wo32(grctx, 0x10, grch->mmio_nr);
-        nv_wo32(grctx, 0x14, lower_32_bits(grch->mmio->linst));
-        nv_wo32(grctx, 0x18, upper_32_bits(grch->mmio->linst));
-        nv_wo32(grctx, 0x1c, 1);
-        nv_wo32(grctx, 0x20, 0);
-        nv_wo32(grctx, 0x28, 0);
-        nv_wo32(grctx, 0x2c, 0);
-
-        pinstmem->flush(dev);
-        return 0;
-
-error:
-        priv->base.context_del(chan, engine);
-        return ret;
-}
-
-static void
-nve0_graph_context_del(struct nouveau_channel *chan, int engine)
-{
-        struct nve0_graph_chan *grch = chan->engctx[engine];
-
-        nouveau_gpuobj_ref(NULL, &grch->mmio);
-        nouveau_gpuobj_ref(NULL, &grch->unk418810);
-        nouveau_gpuobj_ref(NULL, &grch->unk40800c);
-        nouveau_gpuobj_ref(NULL, &grch->unk408004);
-        nouveau_gpuobj_ref(NULL, &grch->grctx);
-        chan->engctx[engine] = NULL;
-}
-
-static int
-nve0_graph_object_new(struct nouveau_channel *chan, int engine,
-                      u32 handle, u16 class)
-{
-        return 0;
-}
-
-static int
-nve0_graph_fini(struct drm_device *dev, int engine, bool suspend)
-{
-        return 0;
-}
-
-static void
-nve0_graph_init_obj418880(struct drm_device *dev)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        int i;
-
-        nv_wr32(dev, GPC_BCAST(0x0880), 0x00000000);
-        nv_wr32(dev, GPC_BCAST(0x08a4), 0x00000000);
-        for (i = 0; i < 4; i++)
-                nv_wr32(dev, GPC_BCAST(0x0888) + (i * 4), 0x00000000);
-        nv_wr32(dev, GPC_BCAST(0x08b4), priv->unk4188b4->vinst >> 8);
-        nv_wr32(dev, GPC_BCAST(0x08b8), priv->unk4188b8->vinst >> 8);
-}
-
-static void
-nve0_graph_init_regs(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x400080, 0x003083c2);
-        nv_wr32(dev, 0x400088, 0x0001ffe7);
-        nv_wr32(dev, 0x40008c, 0x00000000);
-        nv_wr32(dev, 0x400090, 0x00000030);
-        nv_wr32(dev, 0x40013c, 0x003901f7);
-        nv_wr32(dev, 0x400140, 0x00000100);
-        nv_wr32(dev, 0x400144, 0x00000000);
-        nv_wr32(dev, 0x400148, 0x00000110);
-        nv_wr32(dev, 0x400138, 0x00000000);
-        nv_wr32(dev, 0x400130, 0x00000000);
-        nv_wr32(dev, 0x400134, 0x00000000);
-        nv_wr32(dev, 0x400124, 0x00000002);
-}
-
-static void
-nve0_graph_init_units(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x409ffc, 0x00000000);
-        nv_wr32(dev, 0x409c14, 0x00003e3e);
-        nv_wr32(dev, 0x409c24, 0x000f0000);
-
-        nv_wr32(dev, 0x404000, 0xc0000000);
-        nv_wr32(dev, 0x404600, 0xc0000000);
-        nv_wr32(dev, 0x408030, 0xc0000000);
-        nv_wr32(dev, 0x404490, 0xc0000000);
-        nv_wr32(dev, 0x406018, 0xc0000000);
-        nv_wr32(dev, 0x407020, 0xc0000000);
-        nv_wr32(dev, 0x405840, 0xc0000000);
-        nv_wr32(dev, 0x405844, 0x00ffffff);
-
-        nv_mask(dev, 0x419cc0, 0x00000008, 0x00000008);
-        nv_mask(dev, 0x419eb4, 0x00001000, 0x00001000);
-
-}
-
-static void
-nve0_graph_init_gpc_0(struct drm_device *dev)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, priv->tpc_total);
-        u32 data[TPC_MAX / 8];
-        u8  tpcnr[GPC_MAX];
-        int i, gpc, tpc;
-
-        nv_wr32(dev, GPC_UNIT(0, 0x3018), 0x00000001);
-
-        memset(data, 0x00, sizeof(data));
-        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
-        for (i = 0, gpc = -1; i < priv->tpc_total; i++) {
-                do {
-                        gpc = (gpc + 1) % priv->gpc_nr;
-                } while (!tpcnr[gpc]);
-                tpc = priv->tpc_nr[gpc] - tpcnr[gpc]--;
-
-                data[i / 8] |= tpc << ((i % 8) * 4);
-        }
-
-        nv_wr32(dev, GPC_BCAST(0x0980), data[0]);
-        nv_wr32(dev, GPC_BCAST(0x0984), data[1]);
-        nv_wr32(dev, GPC_BCAST(0x0988), data[2]);
-        nv_wr32(dev, GPC_BCAST(0x098c), data[3]);
-
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0914), priv->magic_not_rop_nr << 8 |
-                                                  priv->tpc_nr[gpc]);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0910), 0x00040000 | priv->tpc_total);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0918), magicgpc918);
-        }
-
-        nv_wr32(dev, GPC_BCAST(0x1bd4), magicgpc918);
-        nv_wr32(dev, GPC_BCAST(0x08ac), nv_rd32(dev, 0x100800));
-}
-
-static void
-nve0_graph_init_gpc_1(struct drm_device *dev)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        int gpc, tpc;
-
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                nv_wr32(dev, GPC_UNIT(gpc, 0x3038), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0420), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0900), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x1028), 0xc0000000);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x0824), 0xc0000000);
-                for (tpc = 0; tpc < priv->tpc_nr[gpc]; tpc++) {
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x508), 0xffffffff);
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x50c), 0xffffffff);
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x224), 0xc0000000);
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x48c), 0xc0000000);
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x084), 0xc0000000);
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x644), 0x001ffffe);
-                        nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x64c), 0x0000000f);
-                }
-                nv_wr32(dev, GPC_UNIT(gpc, 0x2c90), 0xffffffff);
-                nv_wr32(dev, GPC_UNIT(gpc, 0x2c94), 0xffffffff);
-        }
-}
-
-static void
-nve0_graph_init_rop(struct drm_device *dev)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        int rop;
-
-        for (rop = 0; rop < priv->rop_nr; rop++) {
-                nv_wr32(dev, ROP_UNIT(rop, 0x144), 0xc0000000);
-                nv_wr32(dev, ROP_UNIT(rop, 0x070), 0xc0000000);
-                nv_wr32(dev, ROP_UNIT(rop, 0x204), 0xffffffff);
-                nv_wr32(dev, ROP_UNIT(rop, 0x208), 0xffffffff);
-        }
-}
-
-static void
-nve0_graph_init_fuc(struct drm_device *dev, u32 fuc_base,
-                    struct nve0_graph_fuc *code, struct nve0_graph_fuc *data)
-{
-        int i;
-
-        nv_wr32(dev, fuc_base + 0x01c0, 0x01000000);
-        for (i = 0; i < data->size / 4; i++)
-                nv_wr32(dev, fuc_base + 0x01c4, data->data[i]);
-
-        nv_wr32(dev, fuc_base + 0x0180, 0x01000000);
-        for (i = 0; i < code->size / 4; i++) {
-                if ((i & 0x3f) == 0)
-                        nv_wr32(dev, fuc_base + 0x0188, i >> 6);
-                nv_wr32(dev, fuc_base + 0x0184, code->data[i]);
-        }
-}
-
-static int
-nve0_graph_init_ctxctl(struct drm_device *dev)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        u32 r000260;
-
-        /* load fuc microcode */
-        r000260 = nv_mask(dev, 0x000260, 0x00000001, 0x00000000);
-        nve0_graph_init_fuc(dev, 0x409000, &priv->fuc409c, &priv->fuc409d);
-        nve0_graph_init_fuc(dev, 0x41a000, &priv->fuc41ac, &priv->fuc41ad);
-        nv_wr32(dev, 0x000260, r000260);
-
-        /* start both of them running */
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x41a10c, 0x00000000);
-        nv_wr32(dev, 0x40910c, 0x00000000);
-        nv_wr32(dev, 0x41a100, 0x00000002);
-        nv_wr32(dev, 0x409100, 0x00000002);
-        if (!nv_wait(dev, 0x409800, 0x00000001, 0x00000001))
-                NV_INFO(dev, "0x409800 wait failed\n");
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x7fffffff);
-        nv_wr32(dev, 0x409504, 0x00000021);
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x00000000);
-        nv_wr32(dev, 0x409504, 0x00000010);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x10 timeout\n");
-                return -EBUSY;
-        }
-        priv->grctx_size = nv_rd32(dev, 0x409800);
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x00000000);
-        nv_wr32(dev, 0x409504, 0x00000016);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x16 timeout\n");
-                return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x409840, 0xffffffff);
-        nv_wr32(dev, 0x409500, 0x00000000);
-        nv_wr32(dev, 0x409504, 0x00000025);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x25 timeout\n");
-                return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x409800, 0x00000000);
-        nv_wr32(dev, 0x409500, 0x00000001);
-        nv_wr32(dev, 0x409504, 0x00000030);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x30 timeout\n");
-                return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x409810, 0xb00095c8);
-        nv_wr32(dev, 0x409800, 0x00000000);
-        nv_wr32(dev, 0x409500, 0x00000001);
-        nv_wr32(dev, 0x409504, 0x00000031);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x31 timeout\n");
-                return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x409810, 0x00080420);
-        nv_wr32(dev, 0x409800, 0x00000000);
-        nv_wr32(dev, 0x409500, 0x00000001);
-        nv_wr32(dev, 0x409504, 0x00000032);
-        if (!nv_wait_ne(dev, 0x409800, 0xffffffff, 0x00000000)) {
-                NV_ERROR(dev, "fuc09 req 0x32 timeout\n");
-                return -EBUSY;
-        }
-
-        nv_wr32(dev, 0x409614, 0x00000070);
-        nv_wr32(dev, 0x409614, 0x00000770);
-        nv_wr32(dev, 0x40802c, 0x00000001);
-        return 0;
-}
-
-static int
-nve0_graph_init(struct drm_device *dev, int engine)
-{
-        int ret;
-
-        nv_mask(dev, 0x000200, 0x18001000, 0x00000000);
-        nv_mask(dev, 0x000200, 0x18001000, 0x18001000);
-
-        nve0_graph_init_obj418880(dev);
-        nve0_graph_init_regs(dev);
-        nve0_graph_init_gpc_0(dev);
-
-        nv_wr32(dev, 0x400500, 0x00010001);
-        nv_wr32(dev, 0x400100, 0xffffffff);
-        nv_wr32(dev, 0x40013c, 0xffffffff);
-
-        nve0_graph_init_units(dev);
-        nve0_graph_init_gpc_1(dev);
-        nve0_graph_init_rop(dev);
-
-        nv_wr32(dev, 0x400108, 0xffffffff);
-        nv_wr32(dev, 0x400138, 0xffffffff);
-        nv_wr32(dev, 0x400118, 0xffffffff);
-        nv_wr32(dev, 0x400130, 0xffffffff);
-        nv_wr32(dev, 0x40011c, 0xffffffff);
-        nv_wr32(dev, 0x400134, 0xffffffff);
-        nv_wr32(dev, 0x400054, 0x34ce3464);
-
-        ret = nve0_graph_init_ctxctl(dev);
-        if (ret)
-                return ret;
-
-        return 0;
-}
-
-int
-nve0_graph_isr_chid(struct drm_device *dev, u64 inst)
-{
-        struct nouveau_fifo_priv *pfifo = nv_engine(dev, NVOBJ_ENGINE_FIFO);
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_channel *chan;
-        unsigned long flags;
-        int i;
-
-        spin_lock_irqsave(&dev_priv->channels.lock, flags);
-        for (i = 0; i < pfifo->channels; i++) {
-                chan = dev_priv->channels.ptr[i];
-                if (!chan || !chan->ramin)
-                        continue;
-
-                if (inst == chan->ramin->vinst)
-                        break;
-        }
-        spin_unlock_irqrestore(&dev_priv->channels.lock, flags);
-        return i;
-}
-
-static void
-nve0_graph_ctxctl_isr(struct drm_device *dev)
-{
-        u32 ustat = nv_rd32(dev, 0x409c18);
-
-        if (ustat & 0x00000001)
-                NV_INFO(dev, "PGRAPH: CTXCTRL ucode error\n");
-        if (ustat & 0x00080000)
-                NV_INFO(dev, "PGRAPH: CTXCTRL watchdog timeout\n");
-        if (ustat & ~0x00080001)
-                NV_INFO(dev, "PGRAPH: CTXCTRL 0x%08x\n", ustat);
-
-        nve0_graph_ctxctl_debug(dev);
-        nv_wr32(dev, 0x409c20, ustat);
-}
-
-static void
-nve0_graph_trap_isr(struct drm_device *dev, int chid)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, NVOBJ_ENGINE_GR);
-        u32 trap = nv_rd32(dev, 0x400108);
-        int rop;
-
-        if (trap & 0x00000001) {
-                u32 stat = nv_rd32(dev, 0x404000);
-                NV_INFO(dev, "PGRAPH: DISPATCH ch %d 0x%08x\n", chid, stat);
-                nv_wr32(dev, 0x404000, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x00000001);
-                trap &= ~0x00000001;
-        }
-
-        if (trap & 0x00000010) {
-                u32 stat = nv_rd32(dev, 0x405840);
-                NV_INFO(dev, "PGRAPH: SHADER ch %d 0x%08x\n", chid, stat);
-                nv_wr32(dev, 0x405840, 0xc0000000);
-                nv_wr32(dev, 0x400108, 0x00000010);
-                trap &= ~0x00000010;
-        }
-
-        if (trap & 0x02000000) {
-                for (rop = 0; rop < priv->rop_nr; rop++) {
-                        u32 statz = nv_rd32(dev, ROP_UNIT(rop, 0x070));
-                        u32 statc = nv_rd32(dev, ROP_UNIT(rop, 0x144));
-                        NV_INFO(dev, "PGRAPH: ROP%d ch %d 0x%08x 0x%08x\n",
-                                     rop, chid, statz, statc);
-                        nv_wr32(dev, ROP_UNIT(rop, 0x070), 0xc0000000);
-                        nv_wr32(dev, ROP_UNIT(rop, 0x144), 0xc0000000);
-                }
-                nv_wr32(dev, 0x400108, 0x02000000);
-                trap &= ~0x02000000;
-        }
-
-        if (trap) {
-                NV_INFO(dev, "PGRAPH: TRAP ch %d 0x%08x\n", chid, trap);
-                nv_wr32(dev, 0x400108, trap);
-        }
-}
-
-static void
-nve0_graph_isr(struct drm_device *dev)
-{
-        u64 inst = (u64)(nv_rd32(dev, 0x409b00) & 0x0fffffff) << 12;
-        u32 chid = nve0_graph_isr_chid(dev, inst);
-        u32 stat = nv_rd32(dev, 0x400100);
-        u32 addr = nv_rd32(dev, 0x400704);
-        u32 mthd = (addr & 0x00003ffc);
-        u32 subc = (addr & 0x00070000) >> 16;
-        u32 data = nv_rd32(dev, 0x400708);
-        u32 code = nv_rd32(dev, 0x400110);
-        u32 class = nv_rd32(dev, 0x404200 + (subc * 4));
-
-        if (stat & 0x00000010) {
-                if (nouveau_gpuobj_mthd_call2(dev, chid, class, mthd, data)) {
-                        NV_INFO(dev, "PGRAPH: ILLEGAL_MTHD ch %d [0x%010llx] "
-                                     "subc %d class 0x%04x mthd 0x%04x "
-                                     "data 0x%08x\n",
-                                chid, inst, subc, class, mthd, data);
-                }
-                nv_wr32(dev, 0x400100, 0x00000010);
-                stat &= ~0x00000010;
-        }
-
-        if (stat & 0x00000020) {
-                NV_INFO(dev, "PGRAPH: ILLEGAL_CLASS ch %d [0x%010llx] subc %d "
-                             "class 0x%04x mthd 0x%04x data 0x%08x\n",
-                        chid, inst, subc, class, mthd, data);
-                nv_wr32(dev, 0x400100, 0x00000020);
-                stat &= ~0x00000020;
-        }
-
-        if (stat & 0x00100000) {
-                NV_INFO(dev, "PGRAPH: DATA_ERROR [");
-                nouveau_enum_print(nv50_data_error_names, code);
-                printk("] ch %d [0x%010llx] subc %d class 0x%04x "
-                       "mthd 0x%04x data 0x%08x\n",
-                       chid, inst, subc, class, mthd, data);
-                nv_wr32(dev, 0x400100, 0x00100000);
-                stat &= ~0x00100000;
-        }
-
-        if (stat & 0x00200000) {
-                nve0_graph_trap_isr(dev, chid);
-                nv_wr32(dev, 0x400100, 0x00200000);
-                stat &= ~0x00200000;
-        }
-
-        if (stat & 0x00080000) {
-                nve0_graph_ctxctl_isr(dev);
-                nv_wr32(dev, 0x400100, 0x00080000);
-                stat &= ~0x00080000;
-        }
-
-        if (stat) {
-                NV_INFO(dev, "PGRAPH: unknown stat 0x%08x\n", stat);
-                nv_wr32(dev, 0x400100, stat);
-        }
-
-        nv_wr32(dev, 0x400500, 0x00010001);
-}
-
-static int
-nve0_graph_create_fw(struct drm_device *dev, const char *fwname,
-                     struct nve0_graph_fuc *fuc)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        const struct firmware *fw;
-        char f[32];
-        int ret;
-
-        snprintf(f, sizeof(f), "nouveau/nv%02x_%s", dev_priv->chipset, fwname);
-        ret = request_firmware(&fw, f, &dev->pdev->dev);
-        if (ret)
-                return ret;
-
-        fuc->size = fw->size;
-        fuc->data = kmemdup(fw->data, fuc->size, GFP_KERNEL);
-        release_firmware(fw);
-        return (fuc->data != NULL) ? 0 : -ENOMEM;
-}
-
-static void
-nve0_graph_destroy_fw(struct nve0_graph_fuc *fuc)
-{
-        if (fuc->data) {
-                kfree(fuc->data);
-                fuc->data = NULL;
-        }
-}
-
-static void
-nve0_graph_destroy(struct drm_device *dev, int engine)
-{
-        struct nve0_graph_priv *priv = nv_engine(dev, engine);
-
-        nve0_graph_destroy_fw(&priv->fuc409c);
-        nve0_graph_destroy_fw(&priv->fuc409d);
-        nve0_graph_destroy_fw(&priv->fuc41ac);
-        nve0_graph_destroy_fw(&priv->fuc41ad);
-
-        nouveau_irq_unregister(dev, 12);
-
-        nouveau_gpuobj_ref(NULL, &priv->unk4188b8);
-        nouveau_gpuobj_ref(NULL, &priv->unk4188b4);
-
-        if (priv->grctx_vals)
-                kfree(priv->grctx_vals);
-
-        NVOBJ_ENGINE_DEL(dev, GR);
-        kfree(priv);
-}
-
-int
-nve0_graph_create(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nve0_graph_priv *priv;
-        int ret, gpc, i;
-        u32 kepler;
-
-        kepler = nve0_graph_class(dev);
-        if (!kepler) {
-                NV_ERROR(dev, "PGRAPH: unsupported chipset, please report!\n");
-                return 0;
-        }
-
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-
-        priv->base.destroy = nve0_graph_destroy;
-        priv->base.init = nve0_graph_init;
-        priv->base.fini = nve0_graph_fini;
-        priv->base.context_new = nve0_graph_context_new;
-        priv->base.context_del = nve0_graph_context_del;
-        priv->base.object_new = nve0_graph_object_new;
-
-        NVOBJ_ENGINE_ADD(dev, GR, &priv->base);
-        nouveau_irq_register(dev, 12, nve0_graph_isr);
-
-        NV_INFO(dev, "PGRAPH: using external firmware\n");
-        if (nve0_graph_create_fw(dev, "fuc409c", &priv->fuc409c) ||
-            nve0_graph_create_fw(dev, "fuc409d", &priv->fuc409d) ||
-            nve0_graph_create_fw(dev, "fuc41ac", &priv->fuc41ac) ||
-            nve0_graph_create_fw(dev, "fuc41ad", &priv->fuc41ad)) {
-                ret = 0;
-                goto error;
-        }
-
-        ret = nouveau_gpuobj_new(dev, NULL, 0x1000, 256, 0, &priv->unk4188b4);
-        if (ret)
-                goto error;
-
-        ret = nouveau_gpuobj_new(dev, NULL, 0x1000, 256, 0, &priv->unk4188b8);
-        if (ret)
-                goto error;
-
-        for (i = 0; i < 0x1000; i += 4) {
-                nv_wo32(priv->unk4188b4, i, 0x00000010);
-                nv_wo32(priv->unk4188b8, i, 0x00000010);
-        }
-
-        priv->gpc_nr  =  nv_rd32(dev, 0x409604) & 0x0000001f;
-        priv->rop_nr = (nv_rd32(dev, 0x409604) & 0x001f0000) >> 16;
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                priv->tpc_nr[gpc] = nv_rd32(dev, GPC_UNIT(gpc, 0x2608));
-                priv->tpc_total += priv->tpc_nr[gpc];
-        }
-
-        switch (dev_priv->chipset) {
-        case 0xe4:
-                if (priv->tpc_total == 8)
-                        priv->magic_not_rop_nr = 3;
-                else
-                if (priv->tpc_total == 7)
-                        priv->magic_not_rop_nr = 1;
-                break;
-        case 0xe7:
-                priv->magic_not_rop_nr = 1;
-                break;
-        default:
-                break;
-        }
-
-        if (!priv->magic_not_rop_nr) {
-                NV_ERROR(dev, "PGRAPH: unknown config: %d/%d/%d/%d, %d\n",
-                         priv->tpc_nr[0], priv->tpc_nr[1], priv->tpc_nr[2],
-                         priv->tpc_nr[3], priv->rop_nr);
-                priv->magic_not_rop_nr = 0x00;
-        }
-
-        NVOBJ_CLASS(dev, 0xa097, GR); /* subc 0: 3D */
-        NVOBJ_CLASS(dev, 0xa0c0, GR); /* subc 1: COMPUTE */
-        NVOBJ_CLASS(dev, 0xa040, GR); /* subc 2: P2MF */
-        NVOBJ_CLASS(dev, 0x902d, GR); /* subc 3: 2D */
-        NVOBJ_CLASS(dev, 0xa0b5, GR); /* subc 4: COPY */
-        return 0;
-
-error:
-        nve0_graph_destroy(dev, NVOBJ_ENGINE_GR);
-        return ret;
-}
diff --git a/drivers/gpu/drm/nouveau/nve0_graph.h b/drivers/gpu/drm/nouveau/nve0_graph.h
deleted file mode 100644
index 2ba70449ba01..000000000000
--- a/drivers/gpu/drm/nouveau/nve0_graph.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 2012 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
- */
-
-#ifndef __NVE0_GRAPH_H__
-#define __NVE0_GRAPH_H__
-
-#define GPC_MAX 4
-#define TPC_MAX 32
-
-#define ROP_BCAST(r)     (0x408800 + (r))
-#define ROP_UNIT(u, r)   (0x410000 + (u) * 0x400 + (r))
-#define GPC_BCAST(r)     (0x418000 + (r))
-#define GPC_UNIT(t, r)   (0x500000 + (t) * 0x8000 + (r))
-#define TPC_UNIT(t, m, r) (0x504000 + (t) * 0x8000 + (m) * 0x800 + (r))
-
-struct nve0_graph_fuc {
-        u32 *data;
-        u32  size;
-};
-
-struct nve0_graph_priv {
-        struct nouveau_exec_engine base;
-
-        struct nve0_graph_fuc fuc409c;
-        struct nve0_graph_fuc fuc409d;
-        struct nve0_graph_fuc fuc41ac;
-        struct nve0_graph_fuc fuc41ad;
-
-        u8 gpc_nr;
-        u8 rop_nr;
-        u8 tpc_nr[GPC_MAX];
-        u8 tpc_total;
-
-        u32  grctx_size;
-        u32 *grctx_vals;
-        struct nouveau_gpuobj *unk4188b4;
-        struct nouveau_gpuobj *unk4188b8;
-
-        u8 magic_not_rop_nr;
-};
-
-struct nve0_graph_chan {
-        struct nouveau_gpuobj *grctx;
-        struct nouveau_gpuobj *unk408004; /* 0x418810 too */
-        struct nouveau_gpuobj *unk40800c; /* 0x419004 too */
-        struct nouveau_gpuobj *unk418810; /* 0x419848 too */
-        struct nouveau_gpuobj *mmio;
-        int mmio_nr;
-};
-
-int nve0_grctx_generate(struct nouveau_channel *);
-
-/* nve0_graph.c uses this also to determine supported chipsets */
-static inline u32
-nve0_graph_class(struct drm_device *dev)
-{
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        switch (dev_priv->chipset) {
-        case 0xe4:
-        case 0xe7:
-                return 0xa097;
-        default:
-                return 0;
-        }
-}
-
-#endif
diff --git a/drivers/gpu/drm/nouveau/nve0_grctx.c b/drivers/gpu/drm/nouveau/nve0_grctx.c
deleted file mode 100644
index d8cb360e92c1..000000000000
--- a/drivers/gpu/drm/nouveau/nve0_grctx.c
+++ /dev/null
@@ -1,2777 +0,0 @@
-/*
- * 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"
-#include "nouveau_mm.h"
-#include "nve0_graph.h"
-
-static void
-nv_icmd(struct drm_device *dev, u32 icmd, u32 data)
-{
-        nv_wr32(dev, 0x400204, data);
-        nv_wr32(dev, 0x400200, icmd);
-        while (nv_rd32(dev, 0x400700) & 0x00000002) {}
-}
-
-static void
-nve0_grctx_generate_icmd(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x400208, 0x80000000);
-        nv_icmd(dev, 0x001000, 0x00000004);
-        nv_icmd(dev, 0x000039, 0x00000000);
-        nv_icmd(dev, 0x00003a, 0x00000000);
-        nv_icmd(dev, 0x00003b, 0x00000000);
-        nv_icmd(dev, 0x0000a9, 0x0000ffff);
-        nv_icmd(dev, 0x000038, 0x0fac6881);
-        nv_icmd(dev, 0x00003d, 0x00000001);
-        nv_icmd(dev, 0x0000e8, 0x00000400);
-        nv_icmd(dev, 0x0000e9, 0x00000400);
-        nv_icmd(dev, 0x0000ea, 0x00000400);
-        nv_icmd(dev, 0x0000eb, 0x00000400);
-        nv_icmd(dev, 0x0000ec, 0x00000400);
-        nv_icmd(dev, 0x0000ed, 0x00000400);
-        nv_icmd(dev, 0x0000ee, 0x00000400);
-        nv_icmd(dev, 0x0000ef, 0x00000400);
-        nv_icmd(dev, 0x000078, 0x00000300);
-        nv_icmd(dev, 0x000079, 0x00000300);
-        nv_icmd(dev, 0x00007a, 0x00000300);
-        nv_icmd(dev, 0x00007b, 0x00000300);
-        nv_icmd(dev, 0x00007c, 0x00000300);
-        nv_icmd(dev, 0x00007d, 0x00000300);
-        nv_icmd(dev, 0x00007e, 0x00000300);
-        nv_icmd(dev, 0x00007f, 0x00000300);
-        nv_icmd(dev, 0x000050, 0x00000011);
-        nv_icmd(dev, 0x000058, 0x00000008);
-        nv_icmd(dev, 0x000059, 0x00000008);
-        nv_icmd(dev, 0x00005a, 0x00000008);
-        nv_icmd(dev, 0x00005b, 0x00000008);
-        nv_icmd(dev, 0x00005c, 0x00000008);
-        nv_icmd(dev, 0x00005d, 0x00000008);
-        nv_icmd(dev, 0x00005e, 0x00000008);
-        nv_icmd(dev, 0x00005f, 0x00000008);
-        nv_icmd(dev, 0x000208, 0x00000001);
-        nv_icmd(dev, 0x000209, 0x00000001);
-        nv_icmd(dev, 0x00020a, 0x00000001);
-        nv_icmd(dev, 0x00020b, 0x00000001);
-        nv_icmd(dev, 0x00020c, 0x00000001);
-        nv_icmd(dev, 0x00020d, 0x00000001);
-        nv_icmd(dev, 0x00020e, 0x00000001);
-        nv_icmd(dev, 0x00020f, 0x00000001);
-        nv_icmd(dev, 0x000081, 0x00000001);
-        nv_icmd(dev, 0x000085, 0x00000004);
-        nv_icmd(dev, 0x000088, 0x00000400);
-        nv_icmd(dev, 0x000090, 0x00000300);
-        nv_icmd(dev, 0x000098, 0x00001001);
-        nv_icmd(dev, 0x0000e3, 0x00000001);
-        nv_icmd(dev, 0x0000da, 0x00000001);
-        nv_icmd(dev, 0x0000f8, 0x00000003);
-        nv_icmd(dev, 0x0000fa, 0x00000001);
-        nv_icmd(dev, 0x00009f, 0x0000ffff);
-        nv_icmd(dev, 0x0000a0, 0x0000ffff);
-        nv_icmd(dev, 0x0000a1, 0x0000ffff);
-        nv_icmd(dev, 0x0000a2, 0x0000ffff);
-        nv_icmd(dev, 0x0000b1, 0x00000001);
-        nv_icmd(dev, 0x0000ad, 0x0000013e);
-        nv_icmd(dev, 0x0000e1, 0x00000010);
-        nv_icmd(dev, 0x000290, 0x00000000);
-        nv_icmd(dev, 0x000291, 0x00000000);
-        nv_icmd(dev, 0x000292, 0x00000000);
-        nv_icmd(dev, 0x000293, 0x00000000);
-        nv_icmd(dev, 0x000294, 0x00000000);
-        nv_icmd(dev, 0x000295, 0x00000000);
-        nv_icmd(dev, 0x000296, 0x00000000);
-        nv_icmd(dev, 0x000297, 0x00000000);
-        nv_icmd(dev, 0x000298, 0x00000000);
-        nv_icmd(dev, 0x000299, 0x00000000);
-        nv_icmd(dev, 0x00029a, 0x00000000);
-        nv_icmd(dev, 0x00029b, 0x00000000);
-        nv_icmd(dev, 0x00029c, 0x00000000);
-        nv_icmd(dev, 0x00029d, 0x00000000);
-        nv_icmd(dev, 0x00029e, 0x00000000);
-        nv_icmd(dev, 0x00029f, 0x00000000);
-        nv_icmd(dev, 0x0003b0, 0x00000000);
-        nv_icmd(dev, 0x0003b1, 0x00000000);
-        nv_icmd(dev, 0x0003b2, 0x00000000);
-        nv_icmd(dev, 0x0003b3, 0x00000000);
-        nv_icmd(dev, 0x0003b4, 0x00000000);
-        nv_icmd(dev, 0x0003b5, 0x00000000);
-        nv_icmd(dev, 0x0003b6, 0x00000000);
-        nv_icmd(dev, 0x0003b7, 0x00000000);
-        nv_icmd(dev, 0x0003b8, 0x00000000);
-        nv_icmd(dev, 0x0003b9, 0x00000000);
-        nv_icmd(dev, 0x0003ba, 0x00000000);
-        nv_icmd(dev, 0x0003bb, 0x00000000);
-        nv_icmd(dev, 0x0003bc, 0x00000000);
-        nv_icmd(dev, 0x0003bd, 0x00000000);
-        nv_icmd(dev, 0x0003be, 0x00000000);
-        nv_icmd(dev, 0x0003bf, 0x00000000);
-        nv_icmd(dev, 0x0002a0, 0x00000000);
-        nv_icmd(dev, 0x0002a1, 0x00000000);
-        nv_icmd(dev, 0x0002a2, 0x00000000);
-        nv_icmd(dev, 0x0002a3, 0x00000000);
-        nv_icmd(dev, 0x0002a4, 0x00000000);
-        nv_icmd(dev, 0x0002a5, 0x00000000);
-        nv_icmd(dev, 0x0002a6, 0x00000000);
-        nv_icmd(dev, 0x0002a7, 0x00000000);
-        nv_icmd(dev, 0x0002a8, 0x00000000);
-        nv_icmd(dev, 0x0002a9, 0x00000000);
-        nv_icmd(dev, 0x0002aa, 0x00000000);
-        nv_icmd(dev, 0x0002ab, 0x00000000);
-        nv_icmd(dev, 0x0002ac, 0x00000000);
-        nv_icmd(dev, 0x0002ad, 0x00000000);
-        nv_icmd(dev, 0x0002ae, 0x00000000);
-        nv_icmd(dev, 0x0002af, 0x00000000);
-        nv_icmd(dev, 0x000420, 0x00000000);
-        nv_icmd(dev, 0x000421, 0x00000000);
-        nv_icmd(dev, 0x000422, 0x00000000);
-        nv_icmd(dev, 0x000423, 0x00000000);
-        nv_icmd(dev, 0x000424, 0x00000000);
-        nv_icmd(dev, 0x000425, 0x00000000);
-        nv_icmd(dev, 0x000426, 0x00000000);
-        nv_icmd(dev, 0x000427, 0x00000000);
-        nv_icmd(dev, 0x000428, 0x00000000);
-        nv_icmd(dev, 0x000429, 0x00000000);
-        nv_icmd(dev, 0x00042a, 0x00000000);
-        nv_icmd(dev, 0x00042b, 0x00000000);
-        nv_icmd(dev, 0x00042c, 0x00000000);
-        nv_icmd(dev, 0x00042d, 0x00000000);
-        nv_icmd(dev, 0x00042e, 0x00000000);
-        nv_icmd(dev, 0x00042f, 0x00000000);
-        nv_icmd(dev, 0x0002b0, 0x00000000);
-        nv_icmd(dev, 0x0002b1, 0x00000000);
-        nv_icmd(dev, 0x0002b2, 0x00000000);
-        nv_icmd(dev, 0x0002b3, 0x00000000);
-        nv_icmd(dev, 0x0002b4, 0x00000000);
-        nv_icmd(dev, 0x0002b5, 0x00000000);
-        nv_icmd(dev, 0x0002b6, 0x00000000);
-        nv_icmd(dev, 0x0002b7, 0x00000000);
-        nv_icmd(dev, 0x0002b8, 0x00000000);
-        nv_icmd(dev, 0x0002b9, 0x00000000);
-        nv_icmd(dev, 0x0002ba, 0x00000000);
-        nv_icmd(dev, 0x0002bb, 0x00000000);
-        nv_icmd(dev, 0x0002bc, 0x00000000);
-        nv_icmd(dev, 0x0002bd, 0x00000000);
-        nv_icmd(dev, 0x0002be, 0x00000000);
-        nv_icmd(dev, 0x0002bf, 0x00000000);
-        nv_icmd(dev, 0x000430, 0x00000000);
-        nv_icmd(dev, 0x000431, 0x00000000);
-        nv_icmd(dev, 0x000432, 0x00000000);
-        nv_icmd(dev, 0x000433, 0x00000000);
-        nv_icmd(dev, 0x000434, 0x00000000);
-        nv_icmd(dev, 0x000435, 0x00000000);
-        nv_icmd(dev, 0x000436, 0x00000000);
-        nv_icmd(dev, 0x000437, 0x00000000);
-        nv_icmd(dev, 0x000438, 0x00000000);
-        nv_icmd(dev, 0x000439, 0x00000000);
-        nv_icmd(dev, 0x00043a, 0x00000000);
-        nv_icmd(dev, 0x00043b, 0x00000000);
-        nv_icmd(dev, 0x00043c, 0x00000000);
-        nv_icmd(dev, 0x00043d, 0x00000000);
-        nv_icmd(dev, 0x00043e, 0x00000000);
-        nv_icmd(dev, 0x00043f, 0x00000000);
-        nv_icmd(dev, 0x0002c0, 0x00000000);
-        nv_icmd(dev, 0x0002c1, 0x00000000);
-        nv_icmd(dev, 0x0002c2, 0x00000000);
-        nv_icmd(dev, 0x0002c3, 0x00000000);
-        nv_icmd(dev, 0x0002c4, 0x00000000);
-        nv_icmd(dev, 0x0002c5, 0x00000000);
-        nv_icmd(dev, 0x0002c6, 0x00000000);
-        nv_icmd(dev, 0x0002c7, 0x00000000);
-        nv_icmd(dev, 0x0002c8, 0x00000000);
-        nv_icmd(dev, 0x0002c9, 0x00000000);
-        nv_icmd(dev, 0x0002ca, 0x00000000);
-        nv_icmd(dev, 0x0002cb, 0x00000000);
-        nv_icmd(dev, 0x0002cc, 0x00000000);
-        nv_icmd(dev, 0x0002cd, 0x00000000);
-        nv_icmd(dev, 0x0002ce, 0x00000000);
-        nv_icmd(dev, 0x0002cf, 0x00000000);
-        nv_icmd(dev, 0x0004d0, 0x00000000);
-        nv_icmd(dev, 0x0004d1, 0x00000000);
-        nv_icmd(dev, 0x0004d2, 0x00000000);
-        nv_icmd(dev, 0x0004d3, 0x00000000);
-        nv_icmd(dev, 0x0004d4, 0x00000000);
-        nv_icmd(dev, 0x0004d5, 0x00000000);
-        nv_icmd(dev, 0x0004d6, 0x00000000);
-        nv_icmd(dev, 0x0004d7, 0x00000000);
-        nv_icmd(dev, 0x0004d8, 0x00000000);
-        nv_icmd(dev, 0x0004d9, 0x00000000);
-        nv_icmd(dev, 0x0004da, 0x00000000);
-        nv_icmd(dev, 0x0004db, 0x00000000);
-        nv_icmd(dev, 0x0004dc, 0x00000000);
-        nv_icmd(dev, 0x0004dd, 0x00000000);
-        nv_icmd(dev, 0x0004de, 0x00000000);
-        nv_icmd(dev, 0x0004df, 0x00000000);
-        nv_icmd(dev, 0x000720, 0x00000000);
-        nv_icmd(dev, 0x000721, 0x00000000);
-        nv_icmd(dev, 0x000722, 0x00000000);
-        nv_icmd(dev, 0x000723, 0x00000000);
-        nv_icmd(dev, 0x000724, 0x00000000);
-        nv_icmd(dev, 0x000725, 0x00000000);
-        nv_icmd(dev, 0x000726, 0x00000000);
-        nv_icmd(dev, 0x000727, 0x00000000);
-        nv_icmd(dev, 0x000728, 0x00000000);
-        nv_icmd(dev, 0x000729, 0x00000000);
-        nv_icmd(dev, 0x00072a, 0x00000000);
-        nv_icmd(dev, 0x00072b, 0x00000000);
-        nv_icmd(dev, 0x00072c, 0x00000000);
-        nv_icmd(dev, 0x00072d, 0x00000000);
-        nv_icmd(dev, 0x00072e, 0x00000000);
-        nv_icmd(dev, 0x00072f, 0x00000000);
-        nv_icmd(dev, 0x0008c0, 0x00000000);
-        nv_icmd(dev, 0x0008c1, 0x00000000);
-        nv_icmd(dev, 0x0008c2, 0x00000000);
-        nv_icmd(dev, 0x0008c3, 0x00000000);
-        nv_icmd(dev, 0x0008c4, 0x00000000);
-        nv_icmd(dev, 0x0008c5, 0x00000000);
-        nv_icmd(dev, 0x0008c6, 0x00000000);
-        nv_icmd(dev, 0x0008c7, 0x00000000);
-        nv_icmd(dev, 0x0008c8, 0x00000000);
-        nv_icmd(dev, 0x0008c9, 0x00000000);
-        nv_icmd(dev, 0x0008ca, 0x00000000);
-        nv_icmd(dev, 0x0008cb, 0x00000000);
-        nv_icmd(dev, 0x0008cc, 0x00000000);
-        nv_icmd(dev, 0x0008cd, 0x00000000);
-        nv_icmd(dev, 0x0008ce, 0x00000000);
-        nv_icmd(dev, 0x0008cf, 0x00000000);
-        nv_icmd(dev, 0x000890, 0x00000000);
-        nv_icmd(dev, 0x000891, 0x00000000);
-        nv_icmd(dev, 0x000892, 0x00000000);
-        nv_icmd(dev, 0x000893, 0x00000000);
-        nv_icmd(dev, 0x000894, 0x00000000);
-        nv_icmd(dev, 0x000895, 0x00000000);
-        nv_icmd(dev, 0x000896, 0x00000000);
-        nv_icmd(dev, 0x000897, 0x00000000);
-        nv_icmd(dev, 0x000898, 0x00000000);
-        nv_icmd(dev, 0x000899, 0x00000000);
-        nv_icmd(dev, 0x00089a, 0x00000000);
-        nv_icmd(dev, 0x00089b, 0x00000000);
-        nv_icmd(dev, 0x00089c, 0x00000000);
-        nv_icmd(dev, 0x00089d, 0x00000000);
-        nv_icmd(dev, 0x00089e, 0x00000000);
-        nv_icmd(dev, 0x00089f, 0x00000000);
-        nv_icmd(dev, 0x0008e0, 0x00000000);
-        nv_icmd(dev, 0x0008e1, 0x00000000);
-        nv_icmd(dev, 0x0008e2, 0x00000000);
-        nv_icmd(dev, 0x0008e3, 0x00000000);
-        nv_icmd(dev, 0x0008e4, 0x00000000);
-        nv_icmd(dev, 0x0008e5, 0x00000000);
-        nv_icmd(dev, 0x0008e6, 0x00000000);
-        nv_icmd(dev, 0x0008e7, 0x00000000);
-        nv_icmd(dev, 0x0008e8, 0x00000000);
-        nv_icmd(dev, 0x0008e9, 0x00000000);
-        nv_icmd(dev, 0x0008ea, 0x00000000);
-        nv_icmd(dev, 0x0008eb, 0x00000000);
-        nv_icmd(dev, 0x0008ec, 0x00000000);
-        nv_icmd(dev, 0x0008ed, 0x00000000);
-        nv_icmd(dev, 0x0008ee, 0x00000000);
-        nv_icmd(dev, 0x0008ef, 0x00000000);
-        nv_icmd(dev, 0x0008a0, 0x00000000);
-        nv_icmd(dev, 0x0008a1, 0x00000000);
-        nv_icmd(dev, 0x0008a2, 0x00000000);
-        nv_icmd(dev, 0x0008a3, 0x00000000);
-        nv_icmd(dev, 0x0008a4, 0x00000000);
-        nv_icmd(dev, 0x0008a5, 0x00000000);
-        nv_icmd(dev, 0x0008a6, 0x00000000);
-        nv_icmd(dev, 0x0008a7, 0x00000000);
-        nv_icmd(dev, 0x0008a8, 0x00000000);
-        nv_icmd(dev, 0x0008a9, 0x00000000);
-        nv_icmd(dev, 0x0008aa, 0x00000000);
-        nv_icmd(dev, 0x0008ab, 0x00000000);
-        nv_icmd(dev, 0x0008ac, 0x00000000);
-        nv_icmd(dev, 0x0008ad, 0x00000000);
-        nv_icmd(dev, 0x0008ae, 0x00000000);
-        nv_icmd(dev, 0x0008af, 0x00000000);
-        nv_icmd(dev, 0x0008f0, 0x00000000);
-        nv_icmd(dev, 0x0008f1, 0x00000000);
-        nv_icmd(dev, 0x0008f2, 0x00000000);
-        nv_icmd(dev, 0x0008f3, 0x00000000);
-        nv_icmd(dev, 0x0008f4, 0x00000000);
-        nv_icmd(dev, 0x0008f5, 0x00000000);
-        nv_icmd(dev, 0x0008f6, 0x00000000);
-        nv_icmd(dev, 0x0008f7, 0x00000000);
-        nv_icmd(dev, 0x0008f8, 0x00000000);
-        nv_icmd(dev, 0x0008f9, 0x00000000);
-        nv_icmd(dev, 0x0008fa, 0x00000000);
-        nv_icmd(dev, 0x0008fb, 0x00000000);
-        nv_icmd(dev, 0x0008fc, 0x00000000);
-        nv_icmd(dev, 0x0008fd, 0x00000000);
-        nv_icmd(dev, 0x0008fe, 0x00000000);
-        nv_icmd(dev, 0x0008ff, 0x00000000);
-        nv_icmd(dev, 0x00094c, 0x000000ff);
-        nv_icmd(dev, 0x00094d, 0xffffffff);
-        nv_icmd(dev, 0x00094e, 0x00000002);
-        nv_icmd(dev, 0x0002ec, 0x00000001);
-        nv_icmd(dev, 0x000303, 0x00000001);
-        nv_icmd(dev, 0x0002e6, 0x00000001);
-        nv_icmd(dev, 0x000466, 0x00000052);
-        nv_icmd(dev, 0x000301, 0x3f800000);
-        nv_icmd(dev, 0x000304, 0x30201000);
-        nv_icmd(dev, 0x000305, 0x70605040);
-        nv_icmd(dev, 0x000306, 0xb8a89888);
-        nv_icmd(dev, 0x000307, 0xf8e8d8c8);
-        nv_icmd(dev, 0x00030a, 0x00ffff00);
-        nv_icmd(dev, 0x00030b, 0x0000001a);
-        nv_icmd(dev, 0x00030c, 0x00000001);
-        nv_icmd(dev, 0x000318, 0x00000001);
-        nv_icmd(dev, 0x000340, 0x00000000);
-        nv_icmd(dev, 0x000375, 0x00000001);
-        nv_icmd(dev, 0x00037d, 0x00000006);
-        nv_icmd(dev, 0x0003a0, 0x00000002);
-        nv_icmd(dev, 0x0003aa, 0x00000001);
-        nv_icmd(dev, 0x0003a9, 0x00000001);
-        nv_icmd(dev, 0x000380, 0x00000001);
-        nv_icmd(dev, 0x000383, 0x00000011);
-        nv_icmd(dev, 0x000360, 0x00000040);
-        nv_icmd(dev, 0x000366, 0x00000000);
-        nv_icmd(dev, 0x000367, 0x00000000);
-        nv_icmd(dev, 0x000368, 0x00000fff);
-        nv_icmd(dev, 0x000370, 0x00000000);
-        nv_icmd(dev, 0x000371, 0x00000000);
-        nv_icmd(dev, 0x000372, 0x000fffff);
-        nv_icmd(dev, 0x00037a, 0x00000012);
-        nv_icmd(dev, 0x000619, 0x00000003);
-        nv_icmd(dev, 0x000811, 0x00000003);
-        nv_icmd(dev, 0x000812, 0x00000004);
-        nv_icmd(dev, 0x000813, 0x00000006);
-        nv_icmd(dev, 0x000814, 0x00000008);
-        nv_icmd(dev, 0x000815, 0x0000000b);
-        nv_icmd(dev, 0x000800, 0x00000001);
-        nv_icmd(dev, 0x000801, 0x00000001);
-        nv_icmd(dev, 0x000802, 0x00000001);
-        nv_icmd(dev, 0x000803, 0x00000001);
-        nv_icmd(dev, 0x000804, 0x00000001);
-        nv_icmd(dev, 0x000805, 0x00000001);
-        nv_icmd(dev, 0x000632, 0x00000001);
-        nv_icmd(dev, 0x000633, 0x00000002);
-        nv_icmd(dev, 0x000634, 0x00000003);
-        nv_icmd(dev, 0x000635, 0x00000004);
-        nv_icmd(dev, 0x000654, 0x3f800000);
-        nv_icmd(dev, 0x000657, 0x3f800000);
-        nv_icmd(dev, 0x000655, 0x3f800000);
-        nv_icmd(dev, 0x000656, 0x3f800000);
-        nv_icmd(dev, 0x0006cd, 0x3f800000);
-        nv_icmd(dev, 0x0007f5, 0x3f800000);
-        nv_icmd(dev, 0x0007dc, 0x39291909);
-        nv_icmd(dev, 0x0007dd, 0x79695949);
-        nv_icmd(dev, 0x0007de, 0xb9a99989);
-        nv_icmd(dev, 0x0007df, 0xf9e9d9c9);
-        nv_icmd(dev, 0x0007e8, 0x00003210);
-        nv_icmd(dev, 0x0007e9, 0x00007654);
-        nv_icmd(dev, 0x0007ea, 0x00000098);
-        nv_icmd(dev, 0x0007ec, 0x39291909);
-        nv_icmd(dev, 0x0007ed, 0x79695949);
-        nv_icmd(dev, 0x0007ee, 0xb9a99989);
-        nv_icmd(dev, 0x0007ef, 0xf9e9d9c9);
-        nv_icmd(dev, 0x0007f0, 0x00003210);
-        nv_icmd(dev, 0x0007f1, 0x00007654);
-        nv_icmd(dev, 0x0007f2, 0x00000098);
-        nv_icmd(dev, 0x0005a5, 0x00000001);
-        nv_icmd(dev, 0x000980, 0x00000000);
-        nv_icmd(dev, 0x000981, 0x00000000);
-        nv_icmd(dev, 0x000982, 0x00000000);
-        nv_icmd(dev, 0x000983, 0x00000000);
-        nv_icmd(dev, 0x000984, 0x00000000);
-        nv_icmd(dev, 0x000985, 0x00000000);
-        nv_icmd(dev, 0x000986, 0x00000000);
-        nv_icmd(dev, 0x000987, 0x00000000);
-        nv_icmd(dev, 0x000988, 0x00000000);
-        nv_icmd(dev, 0x000989, 0x00000000);
-        nv_icmd(dev, 0x00098a, 0x00000000);
-        nv_icmd(dev, 0x00098b, 0x00000000);
-        nv_icmd(dev, 0x00098c, 0x00000000);
-        nv_icmd(dev, 0x00098d, 0x00000000);
-        nv_icmd(dev, 0x00098e, 0x00000000);
-        nv_icmd(dev, 0x00098f, 0x00000000);
-        nv_icmd(dev, 0x000990, 0x00000000);
-        nv_icmd(dev, 0x000991, 0x00000000);
-        nv_icmd(dev, 0x000992, 0x00000000);
-        nv_icmd(dev, 0x000993, 0x00000000);
-        nv_icmd(dev, 0x000994, 0x00000000);
-        nv_icmd(dev, 0x000995, 0x00000000);
-        nv_icmd(dev, 0x000996, 0x00000000);
-        nv_icmd(dev, 0x000997, 0x00000000);
-        nv_icmd(dev, 0x000998, 0x00000000);
-        nv_icmd(dev, 0x000999, 0x00000000);
-        nv_icmd(dev, 0x00099a, 0x00000000);
-        nv_icmd(dev, 0x00099b, 0x00000000);
-        nv_icmd(dev, 0x00099c, 0x00000000);
-        nv_icmd(dev, 0x00099d, 0x00000000);
-        nv_icmd(dev, 0x00099e, 0x00000000);
-        nv_icmd(dev, 0x00099f, 0x00000000);
-        nv_icmd(dev, 0x0009a0, 0x00000000);
-        nv_icmd(dev, 0x0009a1, 0x00000000);
-        nv_icmd(dev, 0x0009a2, 0x00000000);
-        nv_icmd(dev, 0x0009a3, 0x00000000);
-        nv_icmd(dev, 0x0009a4, 0x00000000);
-        nv_icmd(dev, 0x0009a5, 0x00000000);
-        nv_icmd(dev, 0x0009a6, 0x00000000);
-        nv_icmd(dev, 0x0009a7, 0x00000000);
-        nv_icmd(dev, 0x0009a8, 0x00000000);
-        nv_icmd(dev, 0x0009a9, 0x00000000);
-        nv_icmd(dev, 0x0009aa, 0x00000000);
-        nv_icmd(dev, 0x0009ab, 0x00000000);
-        nv_icmd(dev, 0x0009ac, 0x00000000);
-        nv_icmd(dev, 0x0009ad, 0x00000000);
-        nv_icmd(dev, 0x0009ae, 0x00000000);
-        nv_icmd(dev, 0x0009af, 0x00000000);
-        nv_icmd(dev, 0x0009b0, 0x00000000);
-        nv_icmd(dev, 0x0009b1, 0x00000000);
-        nv_icmd(dev, 0x0009b2, 0x00000000);
-        nv_icmd(dev, 0x0009b3, 0x00000000);
-        nv_icmd(dev, 0x0009b4, 0x00000000);
-        nv_icmd(dev, 0x0009b5, 0x00000000);
-        nv_icmd(dev, 0x0009b6, 0x00000000);
-        nv_icmd(dev, 0x0009b7, 0x00000000);
-        nv_icmd(dev, 0x0009b8, 0x00000000);
-        nv_icmd(dev, 0x0009b9, 0x00000000);
-        nv_icmd(dev, 0x0009ba, 0x00000000);
-        nv_icmd(dev, 0x0009bb, 0x00000000);
-        nv_icmd(dev, 0x0009bc, 0x00000000);
-        nv_icmd(dev, 0x0009bd, 0x00000000);
-        nv_icmd(dev, 0x0009be, 0x00000000);
-        nv_icmd(dev, 0x0009bf, 0x00000000);
-        nv_icmd(dev, 0x0009c0, 0x00000000);
-        nv_icmd(dev, 0x0009c1, 0x00000000);
-        nv_icmd(dev, 0x0009c2, 0x00000000);
-        nv_icmd(dev, 0x0009c3, 0x00000000);
-        nv_icmd(dev, 0x0009c4, 0x00000000);
-        nv_icmd(dev, 0x0009c5, 0x00000000);
-        nv_icmd(dev, 0x0009c6, 0x00000000);
-        nv_icmd(dev, 0x0009c7, 0x00000000);
-        nv_icmd(dev, 0x0009c8, 0x00000000);
-        nv_icmd(dev, 0x0009c9, 0x00000000);
-        nv_icmd(dev, 0x0009ca, 0x00000000);
-        nv_icmd(dev, 0x0009cb, 0x00000000);
-        nv_icmd(dev, 0x0009cc, 0x00000000);
-        nv_icmd(dev, 0x0009cd, 0x00000000);
-        nv_icmd(dev, 0x0009ce, 0x00000000);
-        nv_icmd(dev, 0x0009cf, 0x00000000);
-        nv_icmd(dev, 0x0009d0, 0x00000000);
-        nv_icmd(dev, 0x0009d1, 0x00000000);
-        nv_icmd(dev, 0x0009d2, 0x00000000);
-        nv_icmd(dev, 0x0009d3, 0x00000000);
-        nv_icmd(dev, 0x0009d4, 0x00000000);
-        nv_icmd(dev, 0x0009d5, 0x00000000);
-        nv_icmd(dev, 0x0009d6, 0x00000000);
-        nv_icmd(dev, 0x0009d7, 0x00000000);
-        nv_icmd(dev, 0x0009d8, 0x00000000);
-        nv_icmd(dev, 0x0009d9, 0x00000000);
-        nv_icmd(dev, 0x0009da, 0x00000000);
-        nv_icmd(dev, 0x0009db, 0x00000000);
-        nv_icmd(dev, 0x0009dc, 0x00000000);
-        nv_icmd(dev, 0x0009dd, 0x00000000);
-        nv_icmd(dev, 0x0009de, 0x00000000);
-        nv_icmd(dev, 0x0009df, 0x00000000);
-        nv_icmd(dev, 0x0009e0, 0x00000000);
-        nv_icmd(dev, 0x0009e1, 0x00000000);
-        nv_icmd(dev, 0x0009e2, 0x00000000);
-        nv_icmd(dev, 0x0009e3, 0x00000000);
-        nv_icmd(dev, 0x0009e4, 0x00000000);
-        nv_icmd(dev, 0x0009e5, 0x00000000);
-        nv_icmd(dev, 0x0009e6, 0x00000000);
-        nv_icmd(dev, 0x0009e7, 0x00000000);
-        nv_icmd(dev, 0x0009e8, 0x00000000);
-        nv_icmd(dev, 0x0009e9, 0x00000000);
-        nv_icmd(dev, 0x0009ea, 0x00000000);
-        nv_icmd(dev, 0x0009eb, 0x00000000);
-        nv_icmd(dev, 0x0009ec, 0x00000000);
-        nv_icmd(dev, 0x0009ed, 0x00000000);
-        nv_icmd(dev, 0x0009ee, 0x00000000);
-        nv_icmd(dev, 0x0009ef, 0x00000000);
-        nv_icmd(dev, 0x0009f0, 0x00000000);
-        nv_icmd(dev, 0x0009f1, 0x00000000);
-        nv_icmd(dev, 0x0009f2, 0x00000000);
-        nv_icmd(dev, 0x0009f3, 0x00000000);
-        nv_icmd(dev, 0x0009f4, 0x00000000);
-        nv_icmd(dev, 0x0009f5, 0x00000000);
-        nv_icmd(dev, 0x0009f6, 0x00000000);
-        nv_icmd(dev, 0x0009f7, 0x00000000);
-        nv_icmd(dev, 0x0009f8, 0x00000000);
-        nv_icmd(dev, 0x0009f9, 0x00000000);
-        nv_icmd(dev, 0x0009fa, 0x00000000);
-        nv_icmd(dev, 0x0009fb, 0x00000000);
-        nv_icmd(dev, 0x0009fc, 0x00000000);
-        nv_icmd(dev, 0x0009fd, 0x00000000);
-        nv_icmd(dev, 0x0009fe, 0x00000000);
-        nv_icmd(dev, 0x0009ff, 0x00000000);
-        nv_icmd(dev, 0x000468, 0x00000004);
-        nv_icmd(dev, 0x00046c, 0x00000001);
-        nv_icmd(dev, 0x000470, 0x00000000);
-        nv_icmd(dev, 0x000471, 0x00000000);
-        nv_icmd(dev, 0x000472, 0x00000000);
-        nv_icmd(dev, 0x000473, 0x00000000);
-        nv_icmd(dev, 0x000474, 0x00000000);
-        nv_icmd(dev, 0x000475, 0x00000000);
-        nv_icmd(dev, 0x000476, 0x00000000);
-        nv_icmd(dev, 0x000477, 0x00000000);
-        nv_icmd(dev, 0x000478, 0x00000000);
-        nv_icmd(dev, 0x000479, 0x00000000);
-        nv_icmd(dev, 0x00047a, 0x00000000);
-        nv_icmd(dev, 0x00047b, 0x00000000);
-        nv_icmd(dev, 0x00047c, 0x00000000);
-        nv_icmd(dev, 0x00047d, 0x00000000);
-        nv_icmd(dev, 0x00047e, 0x00000000);
-        nv_icmd(dev, 0x00047f, 0x00000000);
-        nv_icmd(dev, 0x000480, 0x00000000);
-        nv_icmd(dev, 0x000481, 0x00000000);
-        nv_icmd(dev, 0x000482, 0x00000000);
-        nv_icmd(dev, 0x000483, 0x00000000);
-        nv_icmd(dev, 0x000484, 0x00000000);
-        nv_icmd(dev, 0x000485, 0x00000000);
-        nv_icmd(dev, 0x000486, 0x00000000);
-        nv_icmd(dev, 0x000487, 0x00000000);
-        nv_icmd(dev, 0x000488, 0x00000000);
-        nv_icmd(dev, 0x000489, 0x00000000);
-        nv_icmd(dev, 0x00048a, 0x00000000);
-        nv_icmd(dev, 0x00048b, 0x00000000);
-        nv_icmd(dev, 0x00048c, 0x00000000);
-        nv_icmd(dev, 0x00048d, 0x00000000);
-        nv_icmd(dev, 0x00048e, 0x00000000);
-        nv_icmd(dev, 0x00048f, 0x00000000);
-        nv_icmd(dev, 0x000490, 0x00000000);
-        nv_icmd(dev, 0x000491, 0x00000000);
-        nv_icmd(dev, 0x000492, 0x00000000);
-        nv_icmd(dev, 0x000493, 0x00000000);
-        nv_icmd(dev, 0x000494, 0x00000000);
-        nv_icmd(dev, 0x000495, 0x00000000);
-        nv_icmd(dev, 0x000496, 0x00000000);
-        nv_icmd(dev, 0x000497, 0x00000000);
-        nv_icmd(dev, 0x000498, 0x00000000);
-        nv_icmd(dev, 0x000499, 0x00000000);
-        nv_icmd(dev, 0x00049a, 0x00000000);
-        nv_icmd(dev, 0x00049b, 0x00000000);
-        nv_icmd(dev, 0x00049c, 0x00000000);
-        nv_icmd(dev, 0x00049d, 0x00000000);
-        nv_icmd(dev, 0x00049e, 0x00000000);
-        nv_icmd(dev, 0x00049f, 0x00000000);
-        nv_icmd(dev, 0x0004a0, 0x00000000);
-        nv_icmd(dev, 0x0004a1, 0x00000000);
-        nv_icmd(dev, 0x0004a2, 0x00000000);
-        nv_icmd(dev, 0x0004a3, 0x00000000);
-        nv_icmd(dev, 0x0004a4, 0x00000000);
-        nv_icmd(dev, 0x0004a5, 0x00000000);
-        nv_icmd(dev, 0x0004a6, 0x00000000);
-        nv_icmd(dev, 0x0004a7, 0x00000000);
-        nv_icmd(dev, 0x0004a8, 0x00000000);
-        nv_icmd(dev, 0x0004a9, 0x00000000);
-        nv_icmd(dev, 0x0004aa, 0x00000000);
-        nv_icmd(dev, 0x0004ab, 0x00000000);
-        nv_icmd(dev, 0x0004ac, 0x00000000);
-        nv_icmd(dev, 0x0004ad, 0x00000000);
-        nv_icmd(dev, 0x0004ae, 0x00000000);
-        nv_icmd(dev, 0x0004af, 0x00000000);
-        nv_icmd(dev, 0x0004b0, 0x00000000);
-        nv_icmd(dev, 0x0004b1, 0x00000000);
-        nv_icmd(dev, 0x0004b2, 0x00000000);
-        nv_icmd(dev, 0x0004b3, 0x00000000);
-        nv_icmd(dev, 0x0004b4, 0x00000000);
-        nv_icmd(dev, 0x0004b5, 0x00000000);
-        nv_icmd(dev, 0x0004b6, 0x00000000);
-        nv_icmd(dev, 0x0004b7, 0x00000000);
-        nv_icmd(dev, 0x0004b8, 0x00000000);
-        nv_icmd(dev, 0x0004b9, 0x00000000);
-        nv_icmd(dev, 0x0004ba, 0x00000000);
-        nv_icmd(dev, 0x0004bb, 0x00000000);
-        nv_icmd(dev, 0x0004bc, 0x00000000);
-        nv_icmd(dev, 0x0004bd, 0x00000000);
-        nv_icmd(dev, 0x0004be, 0x00000000);
-        nv_icmd(dev, 0x0004bf, 0x00000000);
-        nv_icmd(dev, 0x0004c0, 0x00000000);
-        nv_icmd(dev, 0x0004c1, 0x00000000);
-        nv_icmd(dev, 0x0004c2, 0x00000000);
-        nv_icmd(dev, 0x0004c3, 0x00000000);
-        nv_icmd(dev, 0x0004c4, 0x00000000);
-        nv_icmd(dev, 0x0004c5, 0x00000000);
-        nv_icmd(dev, 0x0004c6, 0x00000000);
-        nv_icmd(dev, 0x0004c7, 0x00000000);
-        nv_icmd(dev, 0x0004c8, 0x00000000);
-        nv_icmd(dev, 0x0004c9, 0x00000000);
-        nv_icmd(dev, 0x0004ca, 0x00000000);
-        nv_icmd(dev, 0x0004cb, 0x00000000);
-        nv_icmd(dev, 0x0004cc, 0x00000000);
-        nv_icmd(dev, 0x0004cd, 0x00000000);
-        nv_icmd(dev, 0x0004ce, 0x00000000);
-        nv_icmd(dev, 0x0004cf, 0x00000000);
-        nv_icmd(dev, 0x000510, 0x3f800000);
-        nv_icmd(dev, 0x000511, 0x3f800000);
-        nv_icmd(dev, 0x000512, 0x3f800000);
-        nv_icmd(dev, 0x000513, 0x3f800000);
-        nv_icmd(dev, 0x000514, 0x3f800000);
-        nv_icmd(dev, 0x000515, 0x3f800000);
-        nv_icmd(dev, 0x000516, 0x3f800000);
-        nv_icmd(dev, 0x000517, 0x3f800000);
-        nv_icmd(dev, 0x000518, 0x3f800000);
-        nv_icmd(dev, 0x000519, 0x3f800000);
-        nv_icmd(dev, 0x00051a, 0x3f800000);
-        nv_icmd(dev, 0x00051b, 0x3f800000);
-        nv_icmd(dev, 0x00051c, 0x3f800000);
-        nv_icmd(dev, 0x00051d, 0x3f800000);
-        nv_icmd(dev, 0x00051e, 0x3f800000);
-        nv_icmd(dev, 0x00051f, 0x3f800000);
-        nv_icmd(dev, 0x000520, 0x000002b6);
-        nv_icmd(dev, 0x000529, 0x00000001);
-        nv_icmd(dev, 0x000530, 0xffff0000);
-        nv_icmd(dev, 0x000531, 0xffff0000);
-        nv_icmd(dev, 0x000532, 0xffff0000);
-        nv_icmd(dev, 0x000533, 0xffff0000);
-        nv_icmd(dev, 0x000534, 0xffff0000);
-        nv_icmd(dev, 0x000535, 0xffff0000);
-        nv_icmd(dev, 0x000536, 0xffff0000);
-        nv_icmd(dev, 0x000537, 0xffff0000);
-        nv_icmd(dev, 0x000538, 0xffff0000);
-        nv_icmd(dev, 0x000539, 0xffff0000);
-        nv_icmd(dev, 0x00053a, 0xffff0000);
-        nv_icmd(dev, 0x00053b, 0xffff0000);
-        nv_icmd(dev, 0x00053c, 0xffff0000);
-        nv_icmd(dev, 0x00053d, 0xffff0000);
-        nv_icmd(dev, 0x00053e, 0xffff0000);
-        nv_icmd(dev, 0x00053f, 0xffff0000);
-        nv_icmd(dev, 0x000585, 0x0000003f);
-        nv_icmd(dev, 0x000576, 0x00000003);
-        nv_icmd(dev, 0x00057b, 0x00000059);
-        nv_icmd(dev, 0x000586, 0x00000040);
-        nv_icmd(dev, 0x000582, 0x00000080);
-        nv_icmd(dev, 0x000583, 0x00000080);
-        nv_icmd(dev, 0x0005c2, 0x00000001);
-        nv_icmd(dev, 0x000638, 0x00000001);
-        nv_icmd(dev, 0x000639, 0x00000001);
-        nv_icmd(dev, 0x00063a, 0x00000002);
-        nv_icmd(dev, 0x00063b, 0x00000001);
-        nv_icmd(dev, 0x00063c, 0x00000001);
-        nv_icmd(dev, 0x00063d, 0x00000002);
-        nv_icmd(dev, 0x00063e, 0x00000001);
-        nv_icmd(dev, 0x0008b8, 0x00000001);
-        nv_icmd(dev, 0x0008b9, 0x00000001);
-        nv_icmd(dev, 0x0008ba, 0x00000001);
-        nv_icmd(dev, 0x0008bb, 0x00000001);
-        nv_icmd(dev, 0x0008bc, 0x00000001);
-        nv_icmd(dev, 0x0008bd, 0x00000001);
-        nv_icmd(dev, 0x0008be, 0x00000001);
-        nv_icmd(dev, 0x0008bf, 0x00000001);
-        nv_icmd(dev, 0x000900, 0x00000001);
-        nv_icmd(dev, 0x000901, 0x00000001);
-        nv_icmd(dev, 0x000902, 0x00000001);
-        nv_icmd(dev, 0x000903, 0x00000001);
-        nv_icmd(dev, 0x000904, 0x00000001);
-        nv_icmd(dev, 0x000905, 0x00000001);
-        nv_icmd(dev, 0x000906, 0x00000001);
-        nv_icmd(dev, 0x000907, 0x00000001);
-        nv_icmd(dev, 0x000908, 0x00000002);
-        nv_icmd(dev, 0x000909, 0x00000002);
-        nv_icmd(dev, 0x00090a, 0x00000002);
-        nv_icmd(dev, 0x00090b, 0x00000002);
-        nv_icmd(dev, 0x00090c, 0x00000002);
-        nv_icmd(dev, 0x00090d, 0x00000002);
-        nv_icmd(dev, 0x00090e, 0x00000002);
-        nv_icmd(dev, 0x00090f, 0x00000002);
-        nv_icmd(dev, 0x000910, 0x00000001);
-        nv_icmd(dev, 0x000911, 0x00000001);
-        nv_icmd(dev, 0x000912, 0x00000001);
-        nv_icmd(dev, 0x000913, 0x00000001);
-        nv_icmd(dev, 0x000914, 0x00000001);
-        nv_icmd(dev, 0x000915, 0x00000001);
-        nv_icmd(dev, 0x000916, 0x00000001);
-        nv_icmd(dev, 0x000917, 0x00000001);
-        nv_icmd(dev, 0x000918, 0x00000001);
-        nv_icmd(dev, 0x000919, 0x00000001);
-        nv_icmd(dev, 0x00091a, 0x00000001);
-        nv_icmd(dev, 0x00091b, 0x00000001);
-        nv_icmd(dev, 0x00091c, 0x00000001);
-        nv_icmd(dev, 0x00091d, 0x00000001);
-        nv_icmd(dev, 0x00091e, 0x00000001);
-        nv_icmd(dev, 0x00091f, 0x00000001);
-        nv_icmd(dev, 0x000920, 0x00000002);
-        nv_icmd(dev, 0x000921, 0x00000002);
-        nv_icmd(dev, 0x000922, 0x00000002);
-        nv_icmd(dev, 0x000923, 0x00000002);
-        nv_icmd(dev, 0x000924, 0x00000002);
-        nv_icmd(dev, 0x000925, 0x00000002);
-        nv_icmd(dev, 0x000926, 0x00000002);
-        nv_icmd(dev, 0x000927, 0x00000002);
-        nv_icmd(dev, 0x000928, 0x00000001);
-        nv_icmd(dev, 0x000929, 0x00000001);
-        nv_icmd(dev, 0x00092a, 0x00000001);
-        nv_icmd(dev, 0x00092b, 0x00000001);
-        nv_icmd(dev, 0x00092c, 0x00000001);
-        nv_icmd(dev, 0x00092d, 0x00000001);
-        nv_icmd(dev, 0x00092e, 0x00000001);
-        nv_icmd(dev, 0x00092f, 0x00000001);
-        nv_icmd(dev, 0x000648, 0x00000001);
-        nv_icmd(dev, 0x000649, 0x00000001);
-        nv_icmd(dev, 0x00064a, 0x00000001);
-        nv_icmd(dev, 0x00064b, 0x00000001);
-        nv_icmd(dev, 0x00064c, 0x00000001);
-        nv_icmd(dev, 0x00064d, 0x00000001);
-        nv_icmd(dev, 0x00064e, 0x00000001);
-        nv_icmd(dev, 0x00064f, 0x00000001);
-        nv_icmd(dev, 0x000650, 0x00000001);
-        nv_icmd(dev, 0x000658, 0x0000000f);
-        nv_icmd(dev, 0x0007ff, 0x0000000a);
-        nv_icmd(dev, 0x00066a, 0x40000000);
-        nv_icmd(dev, 0x00066b, 0x10000000);
-        nv_icmd(dev, 0x00066c, 0xffff0000);
-        nv_icmd(dev, 0x00066d, 0xffff0000);
-        nv_icmd(dev, 0x0007af, 0x00000008);
-        nv_icmd(dev, 0x0007b0, 0x00000008);
-        nv_icmd(dev, 0x0007f6, 0x00000001);
-        nv_icmd(dev, 0x0006b2, 0x00000055);
-        nv_icmd(dev, 0x0007ad, 0x00000003);
-        nv_icmd(dev, 0x000937, 0x00000001);
-        nv_icmd(dev, 0x000971, 0x00000008);
-        nv_icmd(dev, 0x000972, 0x00000040);
-        nv_icmd(dev, 0x000973, 0x0000012c);
-        nv_icmd(dev, 0x00097c, 0x00000040);
-        nv_icmd(dev, 0x000979, 0x00000003);
-        nv_icmd(dev, 0x000975, 0x00000020);
-        nv_icmd(dev, 0x000976, 0x00000001);
-        nv_icmd(dev, 0x000977, 0x00000020);
-        nv_icmd(dev, 0x000978, 0x00000001);
-        nv_icmd(dev, 0x000957, 0x00000003);
-        nv_icmd(dev, 0x00095e, 0x20164010);
-        nv_icmd(dev, 0x00095f, 0x00000020);
-        nv_icmd(dev, 0x00097d, 0x00000020);
-        nv_icmd(dev, 0x000683, 0x00000006);
-        nv_icmd(dev, 0x000685, 0x003fffff);
-        nv_icmd(dev, 0x000687, 0x003fffff);
-        nv_icmd(dev, 0x0006a0, 0x00000005);
-        nv_icmd(dev, 0x000840, 0x00400008);
-        nv_icmd(dev, 0x000841, 0x08000080);
-        nv_icmd(dev, 0x000842, 0x00400008);
-        nv_icmd(dev, 0x000843, 0x08000080);
-        nv_icmd(dev, 0x000818, 0x00000000);
-        nv_icmd(dev, 0x000819, 0x00000000);
-        nv_icmd(dev, 0x00081a, 0x00000000);
-        nv_icmd(dev, 0x00081b, 0x00000000);
-        nv_icmd(dev, 0x00081c, 0x00000000);
-        nv_icmd(dev, 0x00081d, 0x00000000);
-        nv_icmd(dev, 0x00081e, 0x00000000);
-        nv_icmd(dev, 0x00081f, 0x00000000);
-        nv_icmd(dev, 0x000848, 0x00000000);
-        nv_icmd(dev, 0x000849, 0x00000000);
-        nv_icmd(dev, 0x00084a, 0x00000000);
-        nv_icmd(dev, 0x00084b, 0x00000000);
-        nv_icmd(dev, 0x00084c, 0x00000000);
-        nv_icmd(dev, 0x00084d, 0x00000000);
-        nv_icmd(dev, 0x00084e, 0x00000000);
-        nv_icmd(dev, 0x00084f, 0x00000000);
-        nv_icmd(dev, 0x000850, 0x00000000);
-        nv_icmd(dev, 0x000851, 0x00000000);
-        nv_icmd(dev, 0x000852, 0x00000000);
-        nv_icmd(dev, 0x000853, 0x00000000);
-        nv_icmd(dev, 0x000854, 0x00000000);
-        nv_icmd(dev, 0x000855, 0x00000000);
-        nv_icmd(dev, 0x000856, 0x00000000);
-        nv_icmd(dev, 0x000857, 0x00000000);
-        nv_icmd(dev, 0x000738, 0x00000000);
-        nv_icmd(dev, 0x0006aa, 0x00000001);
-        nv_icmd(dev, 0x0006ab, 0x00000002);
-        nv_icmd(dev, 0x0006ac, 0x00000080);
-        nv_icmd(dev, 0x0006ad, 0x00000100);
-        nv_icmd(dev, 0x0006ae, 0x00000100);
-        nv_icmd(dev, 0x0006b1, 0x00000011);
-        nv_icmd(dev, 0x0006bb, 0x000000cf);
-        nv_icmd(dev, 0x0006ce, 0x2a712488);
-        nv_icmd(dev, 0x000739, 0x4085c000);
-        nv_icmd(dev, 0x00073a, 0x00000080);
-        nv_icmd(dev, 0x000786, 0x80000100);
-        nv_icmd(dev, 0x00073c, 0x00010100);
-        nv_icmd(dev, 0x00073d, 0x02800000);
-        nv_icmd(dev, 0x000787, 0x000000cf);
-        nv_icmd(dev, 0x00078c, 0x00000008);
-        nv_icmd(dev, 0x000792, 0x00000001);
-        nv_icmd(dev, 0x000794, 0x00000001);
-        nv_icmd(dev, 0x000795, 0x00000001);
-        nv_icmd(dev, 0x000796, 0x00000001);
-        nv_icmd(dev, 0x000797, 0x000000cf);
-        nv_icmd(dev, 0x000836, 0x00000001);
-        nv_icmd(dev, 0x00079a, 0x00000002);
-        nv_icmd(dev, 0x000833, 0x04444480);
-        nv_icmd(dev, 0x0007a1, 0x00000001);
-        nv_icmd(dev, 0x0007a3, 0x00000001);
-        nv_icmd(dev, 0x0007a4, 0x00000001);
-        nv_icmd(dev, 0x0007a5, 0x00000001);
-        nv_icmd(dev, 0x000831, 0x00000004);
-        nv_icmd(dev, 0x000b07, 0x00000002);
-        nv_icmd(dev, 0x000b08, 0x00000100);
-        nv_icmd(dev, 0x000b09, 0x00000100);
-        nv_icmd(dev, 0x000b0a, 0x00000001);
-        nv_icmd(dev, 0x000a04, 0x000000ff);
-        nv_icmd(dev, 0x000a0b, 0x00000040);
-        nv_icmd(dev, 0x00097f, 0x00000100);
-        nv_icmd(dev, 0x000a02, 0x00000001);
-        nv_icmd(dev, 0x000809, 0x00000007);
-        nv_icmd(dev, 0x00c221, 0x00000040);
-        nv_icmd(dev, 0x00c1b0, 0x0000000f);
-        nv_icmd(dev, 0x00c1b1, 0x0000000f);
-        nv_icmd(dev, 0x00c1b2, 0x0000000f);
-        nv_icmd(dev, 0x00c1b3, 0x0000000f);
-        nv_icmd(dev, 0x00c1b4, 0x0000000f);
-        nv_icmd(dev, 0x00c1b5, 0x0000000f);
-        nv_icmd(dev, 0x00c1b6, 0x0000000f);
-        nv_icmd(dev, 0x00c1b7, 0x0000000f);
-        nv_icmd(dev, 0x00c1b8, 0x0fac6881);
-        nv_icmd(dev, 0x00c1b9, 0x00fac688);
-        nv_icmd(dev, 0x00c401, 0x00000001);
-        nv_icmd(dev, 0x00c402, 0x00010001);
-        nv_icmd(dev, 0x00c403, 0x00000001);
-        nv_icmd(dev, 0x00c404, 0x00000001);
-        nv_icmd(dev, 0x00c40e, 0x00000020);
-        nv_icmd(dev, 0x00c500, 0x00000003);
-        nv_icmd(dev, 0x01e100, 0x00000001);
-        nv_icmd(dev, 0x001000, 0x00000002);
-        nv_icmd(dev, 0x0006aa, 0x00000001);
-        nv_icmd(dev, 0x0006ad, 0x00000100);
-        nv_icmd(dev, 0x0006ae, 0x00000100);
-        nv_icmd(dev, 0x0006b1, 0x00000011);
-        nv_icmd(dev, 0x00078c, 0x00000008);
-        nv_icmd(dev, 0x000792, 0x00000001);
-        nv_icmd(dev, 0x000794, 0x00000001);
-        nv_icmd(dev, 0x000795, 0x00000001);
-        nv_icmd(dev, 0x000796, 0x00000001);
-        nv_icmd(dev, 0x000797, 0x000000cf);
-        nv_icmd(dev, 0x00079a, 0x00000002);
-        nv_icmd(dev, 0x000833, 0x04444480);
-        nv_icmd(dev, 0x0007a1, 0x00000001);
-        nv_icmd(dev, 0x0007a3, 0x00000001);
-        nv_icmd(dev, 0x0007a4, 0x00000001);
-        nv_icmd(dev, 0x0007a5, 0x00000001);
-        nv_icmd(dev, 0x000831, 0x00000004);
-        nv_icmd(dev, 0x01e100, 0x00000001);
-        nv_icmd(dev, 0x001000, 0x00000008);
-        nv_icmd(dev, 0x000039, 0x00000000);
-        nv_icmd(dev, 0x00003a, 0x00000000);
-        nv_icmd(dev, 0x00003b, 0x00000000);
-        nv_icmd(dev, 0x000380, 0x00000001);
-        nv_icmd(dev, 0x000366, 0x00000000);
-        nv_icmd(dev, 0x000367, 0x00000000);
-        nv_icmd(dev, 0x000368, 0x00000fff);
-        nv_icmd(dev, 0x000370, 0x00000000);
-        nv_icmd(dev, 0x000371, 0x00000000);
-        nv_icmd(dev, 0x000372, 0x000fffff);
-        nv_icmd(dev, 0x000813, 0x00000006);
-        nv_icmd(dev, 0x000814, 0x00000008);
-        nv_icmd(dev, 0x000957, 0x00000003);
-        nv_icmd(dev, 0x000818, 0x00000000);
-        nv_icmd(dev, 0x000819, 0x00000000);
-        nv_icmd(dev, 0x00081a, 0x00000000);
-        nv_icmd(dev, 0x00081b, 0x00000000);
-        nv_icmd(dev, 0x00081c, 0x00000000);
-        nv_icmd(dev, 0x00081d, 0x00000000);
-        nv_icmd(dev, 0x00081e, 0x00000000);
-        nv_icmd(dev, 0x00081f, 0x00000000);
-        nv_icmd(dev, 0x000848, 0x00000000);
-        nv_icmd(dev, 0x000849, 0x00000000);
-        nv_icmd(dev, 0x00084a, 0x00000000);
-        nv_icmd(dev, 0x00084b, 0x00000000);
-        nv_icmd(dev, 0x00084c, 0x00000000);
-        nv_icmd(dev, 0x00084d, 0x00000000);
-        nv_icmd(dev, 0x00084e, 0x00000000);
-        nv_icmd(dev, 0x00084f, 0x00000000);
-        nv_icmd(dev, 0x000850, 0x00000000);
-        nv_icmd(dev, 0x000851, 0x00000000);
-        nv_icmd(dev, 0x000852, 0x00000000);
-        nv_icmd(dev, 0x000853, 0x00000000);
-        nv_icmd(dev, 0x000854, 0x00000000);
-        nv_icmd(dev, 0x000855, 0x00000000);
-        nv_icmd(dev, 0x000856, 0x00000000);
-        nv_icmd(dev, 0x000857, 0x00000000);
-        nv_icmd(dev, 0x000738, 0x00000000);
-        nv_icmd(dev, 0x000b07, 0x00000002);
-        nv_icmd(dev, 0x000b08, 0x00000100);
-        nv_icmd(dev, 0x000b09, 0x00000100);
-        nv_icmd(dev, 0x000b0a, 0x00000001);
-        nv_icmd(dev, 0x000a04, 0x000000ff);
-        nv_icmd(dev, 0x00097f, 0x00000100);
-        nv_icmd(dev, 0x000a02, 0x00000001);
-        nv_icmd(dev, 0x000809, 0x00000007);
-        nv_icmd(dev, 0x00c221, 0x00000040);
-        nv_icmd(dev, 0x00c401, 0x00000001);
-        nv_icmd(dev, 0x00c402, 0x00010001);
-        nv_icmd(dev, 0x00c403, 0x00000001);
-        nv_icmd(dev, 0x00c404, 0x00000001);
-        nv_icmd(dev, 0x00c40e, 0x00000020);
-        nv_icmd(dev, 0x00c500, 0x00000003);
-        nv_icmd(dev, 0x01e100, 0x00000001);
-        nv_icmd(dev, 0x001000, 0x00000001);
-        nv_icmd(dev, 0x000b07, 0x00000002);
-        nv_icmd(dev, 0x000b08, 0x00000100);
-        nv_icmd(dev, 0x000b09, 0x00000100);
-        nv_icmd(dev, 0x000b0a, 0x00000001);
-        nv_icmd(dev, 0x01e100, 0x00000001);
-        nv_wr32(dev, 0x400208, 0x00000000);
-}
-
-static void
-nv_mthd(struct drm_device *dev, u32 class, u32 mthd, u32 data)
-{
-        nv_wr32(dev, 0x40448c, data);
-        nv_wr32(dev, 0x404488, 0x80000000 | (mthd << 14) | class);
-}
-
-static void
-nve0_grctx_generate_a097(struct drm_device *dev)
-{
-        nv_mthd(dev, 0xa097, 0x0800, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0840, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0880, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x08c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0900, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0940, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0980, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x09c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0804, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0844, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0884, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x08c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0904, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0944, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0984, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x09c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0808, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x0848, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x0888, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x08c8, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x0908, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x0948, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x0988, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x09c8, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x080c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x084c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x088c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x08cc, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x090c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x094c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x098c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x09cc, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x0810, 0x000000cf);
-        nv_mthd(dev, 0xa097, 0x0850, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0890, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x08d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0910, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0950, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0990, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x09d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0814, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0854, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0894, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x08d4, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0914, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0954, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0994, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x09d4, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0818, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0858, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0898, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x08d8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0918, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0958, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0998, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x09d8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x081c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x085c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x089c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x08dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x091c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x095c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x099c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x09dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0820, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0860, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x08a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x08e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0920, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0960, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x09a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x09e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ca0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cb0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cc0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cd0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ce0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cf0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c24, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c34, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c64, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c94, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ca4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cb4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cc4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cd4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ce4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cf4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c18, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c28, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c38, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c58, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c68, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c78, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c98, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ca8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cb8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cc8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cd8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ce8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cf8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c0c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c1c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c2c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c3c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c4c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c5c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c6c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c7c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1c9c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cbc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ccc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cdc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1cfc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1da0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1db0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dc0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dd0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1de0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1df0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d24, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d34, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d64, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d94, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1da4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1db4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dc4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dd4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1de4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1df4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d18, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d28, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d38, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d58, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d68, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d78, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d98, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1da8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1db8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dc8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dd8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1de8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1df8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d0c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d1c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d2c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d3c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d4c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d5c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d6c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d7c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1d9c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dbc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dcc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ddc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1dfc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f18, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f28, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f38, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f58, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f68, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f78, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f0c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f1c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f24, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f2c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f34, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f3c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f4c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f5c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f64, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f6c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f7c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f98, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fa0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fa8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fb0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fb8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fc0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fc8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fd0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fd8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fe0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fe8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ff0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ff8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f94, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1f9c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fa4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fb4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fbc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fc4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fcc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fd4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fdc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fe4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1fec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ff4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1ffc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2000, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2040, 0x00000011);
-        nv_mthd(dev, 0xa097, 0x2080, 0x00000020);
-        nv_mthd(dev, 0xa097, 0x20c0, 0x00000030);
-        nv_mthd(dev, 0xa097, 0x2100, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x2140, 0x00000051);
-        nv_mthd(dev, 0xa097, 0x200c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x204c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x208c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x20cc, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x210c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x214c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x2010, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2050, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2090, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x20d0, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x2110, 0x00000003);
-        nv_mthd(dev, 0xa097, 0x2150, 0x00000004);
-        nv_mthd(dev, 0xa097, 0x0380, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0384, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0388, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x038c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x03ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0700, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0710, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0720, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0730, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0704, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0714, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0724, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0734, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0708, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0718, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0728, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0738, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2800, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2804, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2808, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x280c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2810, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2814, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2818, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x281c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2820, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2824, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2828, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x282c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2830, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2834, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2838, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x283c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2840, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2844, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2848, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x284c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2850, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2854, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2858, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x285c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2860, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2864, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2868, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x286c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2870, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2874, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2878, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x287c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2880, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2884, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2888, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x288c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2890, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2894, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2898, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x289c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28b0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28b4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28b8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28d4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28d8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28f0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x28fc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2900, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2904, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2908, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x290c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2910, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2914, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2918, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x291c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2920, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2924, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2928, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x292c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2930, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2934, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2938, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x293c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2940, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2944, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2948, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x294c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2950, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2954, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2958, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x295c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2960, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2964, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2968, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x296c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2970, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2974, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2978, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x297c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2980, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2984, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2988, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x298c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2990, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2994, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2998, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x299c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29b0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29b4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29b8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29d4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29d8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29f0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x29fc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0aa0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ac0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ae0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ba0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bc0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0be0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a24, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a64, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0aa4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ac4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ae4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b24, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b64, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ba4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bc4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0be4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a28, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a68, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0aa8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ac8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ae8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b28, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b68, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ba8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bc8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0be8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a0c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a2c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a4c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a6c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0aac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0acc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0aec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b0c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b2c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b4c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b6c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bcc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ab0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ad0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0af0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bb0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bd0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bf0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a34, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0a94, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ab4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ad4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0af4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b34, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0b94, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bb4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bd4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0bf4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ca0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cb0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cc0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cd0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ce0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cf0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c24, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c34, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c64, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c94, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ca4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cb4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cc4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cd4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ce4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cf4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c18, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c28, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c38, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c58, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c68, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c78, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c98, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ca8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cb8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cc8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cd8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ce8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0cf8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0c0c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c1c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c2c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c3c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c4c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c5c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c6c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c7c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c8c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0c9c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0cac, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0cbc, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0ccc, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0cdc, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0cec, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0cfc, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0d00, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d08, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d10, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d18, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d20, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d28, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d30, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d38, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d04, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d0c, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d14, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d1c, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d24, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d2c, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d34, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d3c, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e00, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e20, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e30, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e60, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e70, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ea0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0eb0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ec0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ed0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ee0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ef0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0e04, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e14, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e24, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e34, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e44, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e54, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e64, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e74, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e84, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e94, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ea4, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0eb4, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ec4, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ed4, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ee4, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ef4, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e08, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e18, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e28, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e38, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e48, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e58, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e68, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e78, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e88, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0e98, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ea8, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0eb8, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ec8, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ed8, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ee8, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0ef8, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d40, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d48, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d50, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d58, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d44, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d4c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d5c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1e00, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e20, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e40, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e60, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e80, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ea0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ec0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ee0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e04, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e24, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e44, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e64, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e84, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ea4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ec4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ee4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e08, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e28, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e48, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e68, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e88, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1ea8, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1ec8, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1ee8, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e0c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e2c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e4c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e6c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e8c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1eac, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ecc, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1eec, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e10, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e30, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e50, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e70, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e90, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1eb0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ed0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ef0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e14, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e34, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e54, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e74, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e94, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1eb4, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1ed4, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1ef4, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1e18, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e38, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e58, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e78, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1e98, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1eb8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ed8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1ef8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x3400, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3404, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3408, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x340c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3410, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3414, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3418, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x341c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3420, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3424, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3428, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x342c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3430, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3434, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3438, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x343c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3440, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3444, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3448, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x344c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3450, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3454, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3458, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x345c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3460, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3464, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3468, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x346c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3470, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3474, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3478, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x347c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3480, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3484, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3488, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x348c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3490, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3494, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3498, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x349c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34b0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34b4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34b8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34d4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34d8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34f0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x34fc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3500, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3504, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3508, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x350c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3510, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3514, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3518, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x351c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3520, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3524, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3528, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x352c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3530, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3534, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3538, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x353c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3540, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3544, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3548, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x354c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3550, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3554, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3558, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x355c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3560, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3564, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3568, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x356c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3570, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3574, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3578, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x357c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3580, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3584, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3588, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x358c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3590, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3594, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x3598, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x359c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35b0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35b4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35b8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35d4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35d8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35f0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x35fc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x030c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1944, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1514, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d68, 0x0000ffff);
-        nv_mthd(dev, 0xa097, 0x121c, 0x0fac6881);
-        nv_mthd(dev, 0xa097, 0x0fac, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1538, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0fe0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0fe4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0fe8, 0x00000014);
-        nv_mthd(dev, 0xa097, 0x0fec, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x0ff0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x179c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1228, 0x00000400);
-        nv_mthd(dev, 0xa097, 0x122c, 0x00000300);
-        nv_mthd(dev, 0xa097, 0x1230, 0x00010001);
-        nv_mthd(dev, 0xa097, 0x07f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x15b4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x15cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1534, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0fb0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x15d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x153c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x16b4, 0x00000003);
-        nv_mthd(dev, 0xa097, 0x0fbc, 0x0000ffff);
-        nv_mthd(dev, 0xa097, 0x0fc0, 0x0000ffff);
-        nv_mthd(dev, 0xa097, 0x0fc4, 0x0000ffff);
-        nv_mthd(dev, 0xa097, 0x0fc8, 0x0000ffff);
-        nv_mthd(dev, 0xa097, 0x0df8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0dfc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1948, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1970, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x161c, 0x000009f0);
-        nv_mthd(dev, 0xa097, 0x0dcc, 0x00000010);
-        nv_mthd(dev, 0xa097, 0x163c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x15e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1160, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1164, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1168, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x116c, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1170, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1174, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1178, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x117c, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1180, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1184, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1188, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x118c, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1190, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1194, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1198, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x119c, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11a0, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11a4, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11a8, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11ac, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11b0, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11b4, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11b8, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11bc, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11c0, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11c4, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11c8, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11cc, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11d0, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11d4, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11d8, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x11dc, 0x25e00040);
-        nv_mthd(dev, 0xa097, 0x1880, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1884, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1888, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x188c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1890, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1894, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1898, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x189c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18b0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18b4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18b8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18d0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18d4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18d8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18e0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18f0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x18fc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x17c8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x17cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x17d0, 0x000000ff);
-        nv_mthd(dev, 0xa097, 0x17d4, 0xffffffff);
-        nv_mthd(dev, 0xa097, 0x17d8, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x17dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x15f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x15f8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1434, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1438, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d74, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0dec, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x13a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1318, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1644, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0748, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0de8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1648, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x12a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1120, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1124, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1128, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x112c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1118, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x164c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1658, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1910, 0x00000290);
-        nv_mthd(dev, 0xa097, 0x1518, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x165c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1520, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1604, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1570, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x13b0, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x13b4, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x020c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1670, 0x30201000);
-        nv_mthd(dev, 0xa097, 0x1674, 0x70605040);
-        nv_mthd(dev, 0xa097, 0x1678, 0xb8a89888);
-        nv_mthd(dev, 0xa097, 0x167c, 0xf8e8d8c8);
-        nv_mthd(dev, 0xa097, 0x166c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1680, 0x00ffff00);
-        nv_mthd(dev, 0xa097, 0x12d0, 0x00000003);
-        nv_mthd(dev, 0xa097, 0x12d4, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1684, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1688, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0dac, 0x00001b02);
-        nv_mthd(dev, 0xa097, 0x0db0, 0x00001b02);
-        nv_mthd(dev, 0xa097, 0x0db4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x168c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x15bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x156c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x187c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1110, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0dc0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0dc4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0dc8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1234, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1690, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x12ac, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0790, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0794, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0798, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x079c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07a0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x077c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1000, 0x00000010);
-        nv_mthd(dev, 0xa097, 0x10fc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1290, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0218, 0x00000010);
-        nv_mthd(dev, 0xa097, 0x12d8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x12dc, 0x00000010);
-        nv_mthd(dev, 0xa097, 0x0d94, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x155c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1560, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1564, 0x00000fff);
-        nv_mthd(dev, 0xa097, 0x1574, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1578, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x157c, 0x000fffff);
-        nv_mthd(dev, 0xa097, 0x1354, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1610, 0x00000012);
-        nv_mthd(dev, 0xa097, 0x1608, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x160c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x260c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x162c, 0x00000003);
-        nv_mthd(dev, 0xa097, 0x0210, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0320, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0324, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0328, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x032c, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0330, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0334, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0338, 0x3f800000);
-        nv_mthd(dev, 0xa097, 0x0750, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0760, 0x39291909);
-        nv_mthd(dev, 0xa097, 0x0764, 0x79695949);
-        nv_mthd(dev, 0xa097, 0x0768, 0xb9a99989);
-        nv_mthd(dev, 0xa097, 0x076c, 0xf9e9d9c9);
-        nv_mthd(dev, 0xa097, 0x0770, 0x30201000);
-        nv_mthd(dev, 0xa097, 0x0774, 0x70605040);
-        nv_mthd(dev, 0xa097, 0x0778, 0x00009080);
-        nv_mthd(dev, 0xa097, 0x0780, 0x39291909);
-        nv_mthd(dev, 0xa097, 0x0784, 0x79695949);
-        nv_mthd(dev, 0xa097, 0x0788, 0xb9a99989);
-        nv_mthd(dev, 0xa097, 0x078c, 0xf9e9d9c9);
-        nv_mthd(dev, 0xa097, 0x07d0, 0x30201000);
-        nv_mthd(dev, 0xa097, 0x07d4, 0x70605040);
-        nv_mthd(dev, 0xa097, 0x07d8, 0x00009080);
-        nv_mthd(dev, 0xa097, 0x037c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0740, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0744, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x2600, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1918, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x191c, 0x00000900);
-        nv_mthd(dev, 0xa097, 0x1920, 0x00000405);
-        nv_mthd(dev, 0xa097, 0x1308, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1924, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x13ac, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x192c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x193c, 0x00002c1c);
-        nv_mthd(dev, 0xa097, 0x0d7c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x02c0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1510, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1940, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ff4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0ff8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x194c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1950, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1968, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1590, 0x0000003f);
-        nv_mthd(dev, 0xa097, 0x07e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07f0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07f4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x196c, 0x00000011);
-        nv_mthd(dev, 0xa097, 0x02e4, 0x0000b001);
-        nv_mthd(dev, 0xa097, 0x036c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0370, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x197c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0fcc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0fd0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x02d8, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x1980, 0x00000080);
-        nv_mthd(dev, 0xa097, 0x1504, 0x00000080);
-        nv_mthd(dev, 0xa097, 0x1984, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0300, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x13a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x12ec, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1310, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1314, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1380, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1384, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1388, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x138c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1390, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1394, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x139c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1398, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1594, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1598, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x159c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x15a0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x15a4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0f54, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f58, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f5c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x19bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f9c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0fa0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x12cc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x12e8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x130c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1360, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1364, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1368, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x136c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1370, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1374, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1378, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x137c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x133c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1340, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1344, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1348, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x134c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1350, 0x00000002);
-        nv_mthd(dev, 0xa097, 0x1358, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x12e4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x131c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1320, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1324, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1328, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x19c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1140, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x19c4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x19c8, 0x00001500);
-        nv_mthd(dev, 0xa097, 0x135c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x19e0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19e4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19e8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19ec, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19f0, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19f4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19f8, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19fc, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x19cc, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x15b8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a00, 0x00001111);
-        nv_mthd(dev, 0xa097, 0x1a04, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a08, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a0c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a10, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a14, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a18, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1a1c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d6c, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x0d70, 0xffff0000);
-        nv_mthd(dev, 0xa097, 0x10f8, 0x00001010);
-        nv_mthd(dev, 0xa097, 0x0d80, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d84, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d88, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d8c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0d90, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0da0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07a4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x07a8, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1508, 0x80000000);
-        nv_mthd(dev, 0xa097, 0x150c, 0x40000000);
-        nv_mthd(dev, 0xa097, 0x1668, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0318, 0x00000008);
-        nv_mthd(dev, 0xa097, 0x031c, 0x00000008);
-        nv_mthd(dev, 0xa097, 0x0d9c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x0374, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0378, 0x00000020);
-        nv_mthd(dev, 0xa097, 0x07dc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x074c, 0x00000055);
-        nv_mthd(dev, 0xa097, 0x1420, 0x00000003);
-        nv_mthd(dev, 0xa097, 0x17bc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x17c0, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x17c4, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1008, 0x00000008);
-        nv_mthd(dev, 0xa097, 0x100c, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x1010, 0x0000012c);
-        nv_mthd(dev, 0xa097, 0x0d60, 0x00000040);
-        nv_mthd(dev, 0xa097, 0x075c, 0x00000003);
-        nv_mthd(dev, 0xa097, 0x1018, 0x00000020);
-        nv_mthd(dev, 0xa097, 0x101c, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1020, 0x00000020);
-        nv_mthd(dev, 0xa097, 0x1024, 0x00000001);
-        nv_mthd(dev, 0xa097, 0x1444, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x1448, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x144c, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0360, 0x20164010);
-        nv_mthd(dev, 0xa097, 0x0364, 0x00000020);
-        nv_mthd(dev, 0xa097, 0x0368, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0de4, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0204, 0x00000006);
-        nv_mthd(dev, 0xa097, 0x0208, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x02cc, 0x003fffff);
-        nv_mthd(dev, 0xa097, 0x02d0, 0x003fffff);
-        nv_mthd(dev, 0xa097, 0x1220, 0x00000005);
-        nv_mthd(dev, 0xa097, 0x0fdc, 0x00000000);
-        nv_mthd(dev, 0xa097, 0x0f98, 0x00400008);
-        nv_mthd(dev, 0xa097, 0x1284, 0x08000080);
-        nv_mthd(dev, 0xa097, 0x1450, 0x00400008);
-        nv_mthd(dev, 0xa097, 0x1454, 0x08000080);
-        nv_mthd(dev, 0xa097, 0x0214, 0x00000000);
-}
-
-static void
-nve0_grctx_generate_902d(struct drm_device *dev)
-{
-        nv_mthd(dev, 0x902d, 0x0200, 0x000000cf);
-        nv_mthd(dev, 0x902d, 0x0204, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0208, 0x00000020);
-        nv_mthd(dev, 0x902d, 0x020c, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0210, 0x00000000);
-        nv_mthd(dev, 0x902d, 0x0214, 0x00000080);
-        nv_mthd(dev, 0x902d, 0x0218, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x021c, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x0220, 0x00000000);
-        nv_mthd(dev, 0x902d, 0x0224, 0x00000000);
-        nv_mthd(dev, 0x902d, 0x0230, 0x000000cf);
-        nv_mthd(dev, 0x902d, 0x0234, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0238, 0x00000020);
-        nv_mthd(dev, 0x902d, 0x023c, 0x00000001);
-        nv_mthd(dev, 0x902d, 0x0244, 0x00000080);
-        nv_mthd(dev, 0x902d, 0x0248, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x024c, 0x00000100);
-        nv_mthd(dev, 0x902d, 0x3410, 0x00000000);
-}
-
-static void
-nve0_graph_generate_unk40xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404010, 0x0);
-        nv_wr32(dev, 0x404014, 0x0);
-        nv_wr32(dev, 0x404018, 0x0);
-        nv_wr32(dev, 0x40401c, 0x0);
-        nv_wr32(dev, 0x404020, 0x0);
-        nv_wr32(dev, 0x404024, 0xe000);
-        nv_wr32(dev, 0x404028, 0x0);
-        nv_wr32(dev, 0x4040a8, 0x0);
-        nv_wr32(dev, 0x4040ac, 0x0);
-        nv_wr32(dev, 0x4040b0, 0x0);
-        nv_wr32(dev, 0x4040b4, 0x0);
-        nv_wr32(dev, 0x4040b8, 0x0);
-        nv_wr32(dev, 0x4040bc, 0x0);
-        nv_wr32(dev, 0x4040c0, 0x0);
-        nv_wr32(dev, 0x4040c4, 0x0);
-        nv_wr32(dev, 0x4040c8, 0xf800008f);
-        nv_wr32(dev, 0x4040d0, 0x0);
-        nv_wr32(dev, 0x4040d4, 0x0);
-        nv_wr32(dev, 0x4040d8, 0x0);
-        nv_wr32(dev, 0x4040dc, 0x0);
-        nv_wr32(dev, 0x4040e0, 0x0);
-        nv_wr32(dev, 0x4040e4, 0x0);
-        nv_wr32(dev, 0x4040e8, 0x1000);
-        nv_wr32(dev, 0x4040f8, 0x0);
-        nv_wr32(dev, 0x404130, 0x0);
-        nv_wr32(dev, 0x404134, 0x0);
-        nv_wr32(dev, 0x404138, 0x20000040);
-        nv_wr32(dev, 0x404150, 0x2e);
-        nv_wr32(dev, 0x404154, 0x400);
-        nv_wr32(dev, 0x404158, 0x200);
-        nv_wr32(dev, 0x404164, 0x55);
-        nv_wr32(dev, 0x4041a0, 0x0);
-        nv_wr32(dev, 0x4041a4, 0x0);
-        nv_wr32(dev, 0x4041a8, 0x0);
-        nv_wr32(dev, 0x4041ac, 0x0);
-        nv_wr32(dev, 0x404200, 0x0);
-        nv_wr32(dev, 0x404204, 0x0);
-        nv_wr32(dev, 0x404208, 0x0);
-        nv_wr32(dev, 0x40420c, 0x0);
-}
-
-static void
-nve0_graph_generate_unk44xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404404, 0x0);
-        nv_wr32(dev, 0x404408, 0x0);
-        nv_wr32(dev, 0x40440c, 0x0);
-        nv_wr32(dev, 0x404410, 0x0);
-        nv_wr32(dev, 0x404414, 0x0);
-        nv_wr32(dev, 0x404418, 0x0);
-        nv_wr32(dev, 0x40441c, 0x0);
-        nv_wr32(dev, 0x404420, 0x0);
-        nv_wr32(dev, 0x404424, 0x0);
-        nv_wr32(dev, 0x404428, 0x0);
-        nv_wr32(dev, 0x40442c, 0x0);
-        nv_wr32(dev, 0x404430, 0x0);
-        nv_wr32(dev, 0x404434, 0x0);
-        nv_wr32(dev, 0x404438, 0x0);
-        nv_wr32(dev, 0x404460, 0x0);
-        nv_wr32(dev, 0x404464, 0x0);
-        nv_wr32(dev, 0x404468, 0xffffff);
-        nv_wr32(dev, 0x40446c, 0x0);
-        nv_wr32(dev, 0x404480, 0x1);
-        nv_wr32(dev, 0x404498, 0x1);
-}
-
-static void
-nve0_graph_generate_unk46xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404604, 0x14);
-        nv_wr32(dev, 0x404608, 0x0);
-        nv_wr32(dev, 0x40460c, 0x3fff);
-        nv_wr32(dev, 0x404610, 0x100);
-        nv_wr32(dev, 0x404618, 0x0);
-        nv_wr32(dev, 0x40461c, 0x0);
-        nv_wr32(dev, 0x404620, 0x0);
-        nv_wr32(dev, 0x404624, 0x0);
-        nv_wr32(dev, 0x40462c, 0x0);
-        nv_wr32(dev, 0x404630, 0x0);
-        nv_wr32(dev, 0x404640, 0x0);
-        nv_wr32(dev, 0x404654, 0x0);
-        nv_wr32(dev, 0x404660, 0x0);
-        nv_wr32(dev, 0x404678, 0x0);
-        nv_wr32(dev, 0x40467c, 0x2);
-        nv_wr32(dev, 0x404680, 0x0);
-        nv_wr32(dev, 0x404684, 0x0);
-        nv_wr32(dev, 0x404688, 0x0);
-        nv_wr32(dev, 0x40468c, 0x0);
-        nv_wr32(dev, 0x404690, 0x0);
-        nv_wr32(dev, 0x404694, 0x0);
-        nv_wr32(dev, 0x404698, 0x0);
-        nv_wr32(dev, 0x40469c, 0x0);
-        nv_wr32(dev, 0x4046a0, 0x7f0080);
-        nv_wr32(dev, 0x4046a4, 0x0);
-        nv_wr32(dev, 0x4046a8, 0x0);
-        nv_wr32(dev, 0x4046ac, 0x0);
-        nv_wr32(dev, 0x4046b0, 0x0);
-        nv_wr32(dev, 0x4046b4, 0x0);
-        nv_wr32(dev, 0x4046b8, 0x0);
-        nv_wr32(dev, 0x4046bc, 0x0);
-        nv_wr32(dev, 0x4046c0, 0x0);
-        nv_wr32(dev, 0x4046c8, 0x0);
-        nv_wr32(dev, 0x4046cc, 0x0);
-        nv_wr32(dev, 0x4046d0, 0x0);
-}
-
-static void
-nve0_graph_generate_unk47xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x404700, 0x0);
-        nv_wr32(dev, 0x404704, 0x0);
-        nv_wr32(dev, 0x404708, 0x0);
-        nv_wr32(dev, 0x404718, 0x0);
-        nv_wr32(dev, 0x40471c, 0x0);
-        nv_wr32(dev, 0x404720, 0x0);
-        nv_wr32(dev, 0x404724, 0x0);
-        nv_wr32(dev, 0x404728, 0x0);
-        nv_wr32(dev, 0x40472c, 0x0);
-        nv_wr32(dev, 0x404730, 0x0);
-        nv_wr32(dev, 0x404734, 0x100);
-        nv_wr32(dev, 0x404738, 0x0);
-        nv_wr32(dev, 0x40473c, 0x0);
-        nv_wr32(dev, 0x404744, 0x0);
-        nv_wr32(dev, 0x404748, 0x0);
-        nv_wr32(dev, 0x404754, 0x0);
-}
-
-static void
-nve0_graph_generate_unk58xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x405800, 0xf8000bf);
-        nv_wr32(dev, 0x405830, 0x2180648);
-        nv_wr32(dev, 0x405834, 0x8000000);
-        nv_wr32(dev, 0x405838, 0x0);
-        nv_wr32(dev, 0x405854, 0x0);
-        nv_wr32(dev, 0x405870, 0x1);
-        nv_wr32(dev, 0x405874, 0x1);
-        nv_wr32(dev, 0x405878, 0x1);
-        nv_wr32(dev, 0x40587c, 0x1);
-        nv_wr32(dev, 0x405a00, 0x0);
-        nv_wr32(dev, 0x405a04, 0x0);
-        nv_wr32(dev, 0x405a18, 0x0);
-        nv_wr32(dev, 0x405b00, 0x0);
-        nv_wr32(dev, 0x405b10, 0x1000);
-}
-
-static void
-nve0_graph_generate_unk60xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x406020, 0x4103c1);
-        nv_wr32(dev, 0x406028, 0x1);
-        nv_wr32(dev, 0x40602c, 0x1);
-        nv_wr32(dev, 0x406030, 0x1);
-        nv_wr32(dev, 0x406034, 0x1);
-}
-
-static void
-nve0_graph_generate_unk64xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x4064a8, 0x0);
-        nv_wr32(dev, 0x4064ac, 0x3fff);
-        nv_wr32(dev, 0x4064b4, 0x0);
-        nv_wr32(dev, 0x4064b8, 0x0);
-        nv_wr32(dev, 0x4064c0, 0x801a00f0);
-        nv_wr32(dev, 0x4064c4, 0x192ffff);
-        nv_wr32(dev, 0x4064c8, 0x1800600);
-        nv_wr32(dev, 0x4064cc, 0x0);
-        nv_wr32(dev, 0x4064d0, 0x0);
-        nv_wr32(dev, 0x4064d4, 0x0);
-        nv_wr32(dev, 0x4064d8, 0x0);
-        nv_wr32(dev, 0x4064dc, 0x0);
-        nv_wr32(dev, 0x4064e0, 0x0);
-        nv_wr32(dev, 0x4064e4, 0x0);
-        nv_wr32(dev, 0x4064e8, 0x0);
-        nv_wr32(dev, 0x4064ec, 0x0);
-        nv_wr32(dev, 0x4064fc, 0x22a);
-}
-
-static void
-nve0_graph_generate_unk70xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x407040, 0x0);
-}
-
-static void
-nve0_graph_generate_unk78xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x407804, 0x23);
-        nv_wr32(dev, 0x40780c, 0xa418820);
-        nv_wr32(dev, 0x407810, 0x62080e6);
-        nv_wr32(dev, 0x407814, 0x20398a4);
-        nv_wr32(dev, 0x407818, 0xe629062);
-        nv_wr32(dev, 0x40781c, 0xa418820);
-        nv_wr32(dev, 0x407820, 0xe6);
-        nv_wr32(dev, 0x4078bc, 0x103);
-}
-
-static void
-nve0_graph_generate_unk80xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x408000, 0x0);
-        nv_wr32(dev, 0x408004, 0x0);
-        nv_wr32(dev, 0x408008, 0x30);
-        nv_wr32(dev, 0x40800c, 0x0);
-        nv_wr32(dev, 0x408010, 0x0);
-        nv_wr32(dev, 0x408014, 0x69);
-        nv_wr32(dev, 0x408018, 0xe100e100);
-        nv_wr32(dev, 0x408064, 0x0);
-}
-
-static void
-nve0_graph_generate_unk88xx(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x408800, 0x2802a3c);
-        nv_wr32(dev, 0x408804, 0x40);
-        nv_wr32(dev, 0x408808, 0x1043e005);
-        nv_wr32(dev, 0x408840, 0xb);
-        nv_wr32(dev, 0x408900, 0x3080b801);
-        nv_wr32(dev, 0x408904, 0x62000001);
-        nv_wr32(dev, 0x408908, 0xc8102f);
-        nv_wr32(dev, 0x408980, 0x11d);
-}
-
-static void
-nve0_graph_generate_gpc(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x418380, 0x16);
-        nv_wr32(dev, 0x418400, 0x38004e00);
-        nv_wr32(dev, 0x418404, 0x71e0ffff);
-        nv_wr32(dev, 0x41840c, 0x1008);
-        nv_wr32(dev, 0x418410, 0xfff0fff);
-        nv_wr32(dev, 0x418414, 0x2200fff);
-        nv_wr32(dev, 0x418450, 0x0);
-        nv_wr32(dev, 0x418454, 0x0);
-        nv_wr32(dev, 0x418458, 0x0);
-        nv_wr32(dev, 0x41845c, 0x0);
-        nv_wr32(dev, 0x418460, 0x0);
-        nv_wr32(dev, 0x418464, 0x0);
-        nv_wr32(dev, 0x418468, 0x1);
-        nv_wr32(dev, 0x41846c, 0x0);
-        nv_wr32(dev, 0x418470, 0x0);
-        nv_wr32(dev, 0x418600, 0x1f);
-        nv_wr32(dev, 0x418684, 0xf);
-        nv_wr32(dev, 0x418700, 0x2);
-        nv_wr32(dev, 0x418704, 0x80);
-        nv_wr32(dev, 0x418708, 0x0);
-        nv_wr32(dev, 0x41870c, 0x0);
-        nv_wr32(dev, 0x418710, 0x0);
-        nv_wr32(dev, 0x418800, 0x7006860a);
-        nv_wr32(dev, 0x418808, 0x0);
-        nv_wr32(dev, 0x41880c, 0x0);
-        nv_wr32(dev, 0x418810, 0x0);
-        nv_wr32(dev, 0x418828, 0x44);
-        nv_wr32(dev, 0x418830, 0x10000001);
-        nv_wr32(dev, 0x4188d8, 0x8);
-        nv_wr32(dev, 0x4188e0, 0x1000000);
-        nv_wr32(dev, 0x4188e8, 0x0);
-        nv_wr32(dev, 0x4188ec, 0x0);
-        nv_wr32(dev, 0x4188f0, 0x0);
-        nv_wr32(dev, 0x4188f4, 0x0);
-        nv_wr32(dev, 0x4188f8, 0x0);
-        nv_wr32(dev, 0x4188fc, 0x20100018);
-        nv_wr32(dev, 0x41891c, 0xff00ff);
-        nv_wr32(dev, 0x418924, 0x0);
-        nv_wr32(dev, 0x418928, 0xffff00);
-        nv_wr32(dev, 0x41892c, 0xff00);
-        nv_wr32(dev, 0x418a00, 0x0);
-        nv_wr32(dev, 0x418a04, 0x0);
-        nv_wr32(dev, 0x418a08, 0x0);
-        nv_wr32(dev, 0x418a0c, 0x10000);
-        nv_wr32(dev, 0x418a10, 0x0);
-        nv_wr32(dev, 0x418a14, 0x0);
-        nv_wr32(dev, 0x418a18, 0x0);
-        nv_wr32(dev, 0x418a20, 0x0);
-        nv_wr32(dev, 0x418a24, 0x0);
-        nv_wr32(dev, 0x418a28, 0x0);
-        nv_wr32(dev, 0x418a2c, 0x10000);
-        nv_wr32(dev, 0x418a30, 0x0);
-        nv_wr32(dev, 0x418a34, 0x0);
-        nv_wr32(dev, 0x418a38, 0x0);
-        nv_wr32(dev, 0x418a40, 0x0);
-        nv_wr32(dev, 0x418a44, 0x0);
-        nv_wr32(dev, 0x418a48, 0x0);
-        nv_wr32(dev, 0x418a4c, 0x10000);
-        nv_wr32(dev, 0x418a50, 0x0);
-        nv_wr32(dev, 0x418a54, 0x0);
-        nv_wr32(dev, 0x418a58, 0x0);
-        nv_wr32(dev, 0x418a60, 0x0);
-        nv_wr32(dev, 0x418a64, 0x0);
-        nv_wr32(dev, 0x418a68, 0x0);
-        nv_wr32(dev, 0x418a6c, 0x10000);
-        nv_wr32(dev, 0x418a70, 0x0);
-        nv_wr32(dev, 0x418a74, 0x0);
-        nv_wr32(dev, 0x418a78, 0x0);
-        nv_wr32(dev, 0x418a80, 0x0);
-        nv_wr32(dev, 0x418a84, 0x0);
-        nv_wr32(dev, 0x418a88, 0x0);
-        nv_wr32(dev, 0x418a8c, 0x10000);
-        nv_wr32(dev, 0x418a90, 0x0);
-        nv_wr32(dev, 0x418a94, 0x0);
-        nv_wr32(dev, 0x418a98, 0x0);
-        nv_wr32(dev, 0x418aa0, 0x0);
-        nv_wr32(dev, 0x418aa4, 0x0);
-        nv_wr32(dev, 0x418aa8, 0x0);
-        nv_wr32(dev, 0x418aac, 0x10000);
-        nv_wr32(dev, 0x418ab0, 0x0);
-        nv_wr32(dev, 0x418ab4, 0x0);
-        nv_wr32(dev, 0x418ab8, 0x0);
-        nv_wr32(dev, 0x418ac0, 0x0);
-        nv_wr32(dev, 0x418ac4, 0x0);
-        nv_wr32(dev, 0x418ac8, 0x0);
-        nv_wr32(dev, 0x418acc, 0x10000);
-        nv_wr32(dev, 0x418ad0, 0x0);
-        nv_wr32(dev, 0x418ad4, 0x0);
-        nv_wr32(dev, 0x418ad8, 0x0);
-        nv_wr32(dev, 0x418ae0, 0x0);
-        nv_wr32(dev, 0x418ae4, 0x0);
-        nv_wr32(dev, 0x418ae8, 0x0);
-        nv_wr32(dev, 0x418aec, 0x10000);
-        nv_wr32(dev, 0x418af0, 0x0);
-        nv_wr32(dev, 0x418af4, 0x0);
-        nv_wr32(dev, 0x418af8, 0x0);
-        nv_wr32(dev, 0x418b00, 0x6);
-        nv_wr32(dev, 0x418b08, 0xa418820);
-        nv_wr32(dev, 0x418b0c, 0x62080e6);
-        nv_wr32(dev, 0x418b10, 0x20398a4);
-        nv_wr32(dev, 0x418b14, 0xe629062);
-        nv_wr32(dev, 0x418b18, 0xa418820);
-        nv_wr32(dev, 0x418b1c, 0xe6);
-        nv_wr32(dev, 0x418bb8, 0x103);
-        nv_wr32(dev, 0x418c08, 0x1);
-        nv_wr32(dev, 0x418c10, 0x0);
-        nv_wr32(dev, 0x418c14, 0x0);
-        nv_wr32(dev, 0x418c18, 0x0);
-        nv_wr32(dev, 0x418c1c, 0x0);
-        nv_wr32(dev, 0x418c20, 0x0);
-        nv_wr32(dev, 0x418c24, 0x0);
-        nv_wr32(dev, 0x418c28, 0x0);
-        nv_wr32(dev, 0x418c2c, 0x0);
-        nv_wr32(dev, 0x418c40, 0xffffffff);
-        nv_wr32(dev, 0x418c6c, 0x1);
-        nv_wr32(dev, 0x418c80, 0x20200004);
-        nv_wr32(dev, 0x418c8c, 0x1);
-        nv_wr32(dev, 0x419000, 0x780);
-        nv_wr32(dev, 0x419004, 0x0);
-        nv_wr32(dev, 0x419008, 0x0);
-        nv_wr32(dev, 0x419014, 0x4);
-}
-
-static void
-nve0_graph_generate_tpc(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x419848, 0x0);
-        nv_wr32(dev, 0x419864, 0x129);
-        nv_wr32(dev, 0x419888, 0x0);
-        nv_wr32(dev, 0x419a00, 0xf0);
-        nv_wr32(dev, 0x419a04, 0x1);
-        nv_wr32(dev, 0x419a08, 0x21);
-        nv_wr32(dev, 0x419a0c, 0x20000);
-        nv_wr32(dev, 0x419a10, 0x0);
-        nv_wr32(dev, 0x419a14, 0x200);
-        nv_wr32(dev, 0x419a1c, 0xc000);
-        nv_wr32(dev, 0x419a20, 0x800);
-        nv_wr32(dev, 0x419a30, 0x1);
-        nv_wr32(dev, 0x419ac4, 0x37f440);
-        nv_wr32(dev, 0x419c00, 0xa);
-        nv_wr32(dev, 0x419c04, 0x80000006);
-        nv_wr32(dev, 0x419c08, 0x2);
-        nv_wr32(dev, 0x419c20, 0x0);
-        nv_wr32(dev, 0x419c24, 0x84210);
-        nv_wr32(dev, 0x419c28, 0x3efbefbe);
-        nv_wr32(dev, 0x419ce8, 0x0);
-        nv_wr32(dev, 0x419cf4, 0x3203);
-        nv_wr32(dev, 0x419e04, 0x0);
-        nv_wr32(dev, 0x419e08, 0x0);
-        nv_wr32(dev, 0x419e0c, 0x0);
-        nv_wr32(dev, 0x419e10, 0x402);
-        nv_wr32(dev, 0x419e44, 0x13eff2);
-        nv_wr32(dev, 0x419e48, 0x0);
-        nv_wr32(dev, 0x419e4c, 0x7f);
-        nv_wr32(dev, 0x419e50, 0x0);
-        nv_wr32(dev, 0x419e54, 0x0);
-        nv_wr32(dev, 0x419e58, 0x0);
-        nv_wr32(dev, 0x419e5c, 0x0);
-        nv_wr32(dev, 0x419e60, 0x0);
-        nv_wr32(dev, 0x419e64, 0x0);
-        nv_wr32(dev, 0x419e68, 0x0);
-        nv_wr32(dev, 0x419e6c, 0x0);
-        nv_wr32(dev, 0x419e70, 0x0);
-        nv_wr32(dev, 0x419e74, 0x0);
-        nv_wr32(dev, 0x419e78, 0x0);
-        nv_wr32(dev, 0x419e7c, 0x0);
-        nv_wr32(dev, 0x419e80, 0x0);
-        nv_wr32(dev, 0x419e84, 0x0);
-        nv_wr32(dev, 0x419e88, 0x0);
-        nv_wr32(dev, 0x419e8c, 0x0);
-        nv_wr32(dev, 0x419e90, 0x0);
-        nv_wr32(dev, 0x419e94, 0x0);
-        nv_wr32(dev, 0x419e98, 0x0);
-        nv_wr32(dev, 0x419eac, 0x1fcf);
-        nv_wr32(dev, 0x419eb0, 0xd3f);
-        nv_wr32(dev, 0x419ec8, 0x1304f);
-        nv_wr32(dev, 0x419f30, 0x0);
-        nv_wr32(dev, 0x419f34, 0x0);
-        nv_wr32(dev, 0x419f38, 0x0);
-        nv_wr32(dev, 0x419f3c, 0x0);
-        nv_wr32(dev, 0x419f40, 0x0);
-        nv_wr32(dev, 0x419f44, 0x0);
-        nv_wr32(dev, 0x419f48, 0x0);
-        nv_wr32(dev, 0x419f4c, 0x0);
-        nv_wr32(dev, 0x419f58, 0x0);
-        nv_wr32(dev, 0x419f78, 0xb);
-}
-
-static void
-nve0_graph_generate_tpcunk(struct drm_device *dev)
-{
-        nv_wr32(dev, 0x41be24, 0x6);
-        nv_wr32(dev, 0x41bec0, 0x12180000);
-        nv_wr32(dev, 0x41bec4, 0x37f7f);
-        nv_wr32(dev, 0x41bee4, 0x6480430);
-        nv_wr32(dev, 0x41bf00, 0xa418820);
-        nv_wr32(dev, 0x41bf04, 0x62080e6);
-        nv_wr32(dev, 0x41bf08, 0x20398a4);
-        nv_wr32(dev, 0x41bf0c, 0xe629062);
-        nv_wr32(dev, 0x41bf10, 0xa418820);
-        nv_wr32(dev, 0x41bf14, 0xe6);
-        nv_wr32(dev, 0x41bfd0, 0x900103);
-        nv_wr32(dev, 0x41bfe0, 0x400001);
-        nv_wr32(dev, 0x41bfe4, 0x0);
-}
-
-int
-nve0_grctx_generate(struct nouveau_channel *chan)
-{
-        struct nve0_graph_priv *priv = nv_engine(chan->dev, NVOBJ_ENGINE_GR);
-        struct nve0_graph_chan *grch = chan->engctx[NVOBJ_ENGINE_GR];
-        struct drm_device *dev = chan->dev;
-        u32 data[6] = {}, data2[2] = {}, tmp;
-        u32 tpc_set = 0, tpc_mask = 0;
-        u8 tpcnr[GPC_MAX], a, b;
-        u8 shift, ntpcv;
-        int i, gpc, tpc, id;
-
-        nv_mask(dev, 0x000260, 0x00000001, 0x00000000);
-        nv_wr32(dev, 0x400204, 0x00000000);
-        nv_wr32(dev, 0x400208, 0x00000000);
-
-        nve0_graph_generate_unk40xx(dev);
-        nve0_graph_generate_unk44xx(dev);
-        nve0_graph_generate_unk46xx(dev);
-        nve0_graph_generate_unk47xx(dev);
-        nve0_graph_generate_unk58xx(dev);
-        nve0_graph_generate_unk60xx(dev);
-        nve0_graph_generate_unk64xx(dev);
-        nve0_graph_generate_unk70xx(dev);
-        nve0_graph_generate_unk78xx(dev);
-        nve0_graph_generate_unk80xx(dev);
-        nve0_graph_generate_unk88xx(dev);
-        nve0_graph_generate_gpc(dev);
-        nve0_graph_generate_tpc(dev);
-        nve0_graph_generate_tpcunk(dev);
-
-        nv_wr32(dev, 0x404154, 0x0);
-
-        for (i = 0; i < grch->mmio_nr * 8; i += 8) {
-                u32 reg = nv_ro32(grch->mmio, i + 0);
-                u32 val = nv_ro32(grch->mmio, i + 4);
-                nv_wr32(dev, reg, val);
-        }
-
-        nv_wr32(dev, 0x418c6c, 0x1);
-        nv_wr32(dev, 0x41980c, 0x10);
-        nv_wr32(dev, 0x41be08, 0x4);
-        nv_wr32(dev, 0x4064c0, 0x801a00f0);
-        nv_wr32(dev, 0x405800, 0xf8000bf);
-        nv_wr32(dev, 0x419c00, 0xa);
-
-        for (tpc = 0, id = 0; tpc < 4; tpc++) {
-                for (gpc = 0; gpc < priv->gpc_nr; gpc++) {
-                        if (tpc < priv->tpc_nr[gpc]) {
-                                nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x0698), id);
-                                nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x04e8), id);
-                                nv_wr32(dev, GPC_UNIT(gpc, 0x0c10 + tpc * 4), id);
-                                nv_wr32(dev, TPC_UNIT(gpc, tpc, 0x0088), id++);
-                        }
-
-                        nv_wr32(dev, GPC_UNIT(gpc, 0x0c08), priv->tpc_nr[gpc]);
-                        nv_wr32(dev, GPC_UNIT(gpc, 0x0c8c), priv->tpc_nr[gpc]);
-                }
-        }
-
-        tmp = 0;
-        for (i = 0; i < priv->gpc_nr; i++)
-                tmp |= priv->tpc_nr[i] << (i * 4);
-        nv_wr32(dev, 0x406028, tmp);
-        nv_wr32(dev, 0x405870, tmp);
-
-        nv_wr32(dev, 0x40602c, 0x0);
-        nv_wr32(dev, 0x405874, 0x0);
-        nv_wr32(dev, 0x406030, 0x0);
-        nv_wr32(dev, 0x405878, 0x0);
-        nv_wr32(dev, 0x406034, 0x0);
-        nv_wr32(dev, 0x40587c, 0x0);
-
-        /* calculate first set of magics */
-        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
-
-        gpc = -1;
-        for (tpc = 0; tpc < priv->tpc_total; tpc++) {
-                do {
-                        gpc = (gpc + 1) % priv->gpc_nr;
-                } while (!tpcnr[gpc]);
-                tpcnr[gpc]--;
-
-                data[tpc / 6] |= gpc << ((tpc % 6) * 5);
-        }
-
-        for (; tpc < 32; tpc++)
-                data[tpc / 6] |= 7 << ((tpc % 6) * 5);
-
-        /* and the second... */
-        shift = 0;
-        ntpcv = priv->tpc_total;
-        while (!(ntpcv & (1 << 4))) {
-                ntpcv <<= 1;
-                shift++;
-        }
-
-        data2[0]  = ntpcv << 16;
-        data2[0] |= shift << 21;
-        data2[0] |= (((1 << (0 + 5)) % ntpcv) << 24);
-        data2[0] |= priv->tpc_total << 8;
-        data2[0] |= priv->magic_not_rop_nr;
-        for (i = 1; i < 7; i++)
-                data2[1] |= ((1 << (i + 5)) % ntpcv) << ((i - 1) * 5);
-
-        /* and write it all the various parts of PGRAPH */
-        nv_wr32(dev, 0x418bb8, (priv->tpc_total << 8) | priv->magic_not_rop_nr);
-        for (i = 0; i < 6; i++)
-                nv_wr32(dev, 0x418b08 + (i * 4), data[i]);
-
-        nv_wr32(dev, 0x41bfd0, data2[0]);
-        nv_wr32(dev, 0x41bfe4, data2[1]);
-        for (i = 0; i < 6; i++)
-                nv_wr32(dev, 0x41bf00 + (i * 4), data[i]);
-
-        nv_wr32(dev, 0x4078bc, (priv->tpc_total << 8) | priv->magic_not_rop_nr);
-        for (i = 0; i < 6; i++)
-                nv_wr32(dev, 0x40780c + (i * 4), data[i]);
-
-
-        memcpy(tpcnr, priv->tpc_nr, sizeof(priv->tpc_nr));
-        for (gpc = 0; gpc < priv->gpc_nr; gpc++)
-                tpc_mask |= ((1 << priv->tpc_nr[gpc]) - 1) << (gpc * 8);
-
-        for (i = 0, gpc = -1, b = -1; i < 32; i++) {
-                a = (i * (priv->tpc_total - 1)) / 32;
-                if (a != b) {
-                        b = a;
-                        do {
-                                gpc = (gpc + 1) % priv->gpc_nr;
-                        } while (!tpcnr[gpc]);
-                        tpc = priv->tpc_nr[gpc] - tpcnr[gpc]--;
-
-                        tpc_set |= 1 << ((gpc * 8) + tpc);
-                }
-
-                nv_wr32(dev, 0x406800 + (i * 0x20), tpc_set);
-                nv_wr32(dev, 0x406c00 + (i * 0x20), tpc_set ^ tpc_mask);
-        }
-
-        for (i = 0; i < 8; i++)
-                nv_wr32(dev, 0x4064d0 + (i * 0x04), 0x00000000);
-
-        nv_wr32(dev, 0x405b00, 0x201);
-        nv_wr32(dev, 0x408850, 0x2);
-        nv_wr32(dev, 0x408958, 0x2);
-        nv_wr32(dev, 0x419f78, 0xa);
-
-        nve0_grctx_generate_icmd(dev);
-        nve0_grctx_generate_a097(dev);
-        nve0_grctx_generate_902d(dev);
-
-        nv_mask(dev, 0x000260, 0x00000001, 0x00000001);
-        nv_wr32(dev, 0x418800, 0x7026860a); //XXX
-        nv_wr32(dev, 0x41be10, 0x00bb8bc7); //XXX
-        return 0;
-}
diff --git a/drivers/gpu/drm/udl/udl_connector.c b/drivers/gpu/drm/udl/udl_connector.c
index 2d98ff92f3ba..d568aa4b10d1 100644
--- a/drivers/gpu/drm/udl/udl_connector.c
+++ b/drivers/gpu/drm/udl/udl_connector.c
@@ -66,6 +66,13 @@ static int udl_get_modes(struct drm_connector *connector)
 static int udl_mode_valid(struct drm_connector *connector,
                           struct drm_display_mode *mode)
 {
+        struct udl_device *udl = connector->dev->dev_private;
+        if (!udl->sku_pixel_limit)
+                return 0;
+
+        if (mode->vdisplay * mode->hdisplay > udl->sku_pixel_limit)
+                return MODE_VIRTUAL_Y;
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
index f2fb8f15e2f1..7e0743358dff 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fence.c
@@ -1018,7 +1018,7 @@ int vmw_event_fence_action_create(struct drm_file *file_priv,
         }
 
 
-        event = kzalloc(sizeof(event->event), GFP_KERNEL);
+        event = kzalloc(sizeof(*event), GFP_KERNEL);
         if (unlikely(event == NULL)) {
                 DRM_ERROR("Failed to allocate an event.\n");
                 ret = -ENOMEM;
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index b64502dfa9f4..e89daf1b21b4 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -266,7 +266,7 @@ static void swap_pci_ref(struct pci_dev **from, struct pci_dev *to)
 
 static int iommu_init_device(struct device *dev)
 {
-        struct pci_dev *dma_pdev, *pdev = to_pci_dev(dev);
+        struct pci_dev *dma_pdev = NULL, *pdev = to_pci_dev(dev);
         struct iommu_dev_data *dev_data;
         struct iommu_group *group;
         u16 alias;
@@ -293,7 +293,9 @@ static int iommu_init_device(struct device *dev)
                 dev_data->alias_data = alias_data;
 
                 dma_pdev = pci_get_bus_and_slot(alias >> 8, alias & 0xff);
-        } else
+        }
+
+        if (dma_pdev == NULL)
                 dma_pdev = pci_dev_get(pdev);
 
         /* Account for quirked devices */
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index d8abb90a6c2f..034233eefc82 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -1555,6 +1555,7 @@ static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
                            unsigned long arg)
 {
         struct multipath *m = ti->private;
+        struct pgpath *pgpath;
         struct block_device *bdev;
         fmode_t mode;
         unsigned long flags;
@@ -1570,12 +1571,14 @@ again:
         if (!m->current_pgpath)
                 __choose_pgpath(m, 0);
 
-        if (m->current_pgpath) {
-                bdev = m->current_pgpath->path.dev->bdev;
-                mode = m->current_pgpath->path.dev->mode;
+        pgpath = m->current_pgpath;
+
+        if (pgpath) {
+                bdev = pgpath->path.dev->bdev;
+                mode = pgpath->path.dev->mode;
         }
 
-        if (m->queue_io)
+        if ((pgpath && m->queue_io) || (!pgpath && m->queue_if_no_path))
                 r = -EAGAIN;
         else if (!bdev)
                 r = -EIO;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index f90069029aae..100368eb7991 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1212,6 +1212,41 @@ struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector)
         return &t->targets[(KEYS_PER_NODE * n) + k];
 }
 
+static int count_device(struct dm_target *ti, struct dm_dev *dev,
+                        sector_t start, sector_t len, void *data)
+{
+        unsigned *num_devices = data;
+
+        (*num_devices)++;
+
+        return 0;
+}
+
+/*
+ * Check whether a table has no data devices attached using each
+ * target's iterate_devices method.
+ * Returns false if the result is unknown because a target doesn't
+ * support iterate_devices.
+ */
+bool dm_table_has_no_data_devices(struct dm_table *table)
+{
+        struct dm_target *uninitialized_var(ti);
+        unsigned i = 0, num_devices = 0;
+
+        while (i < dm_table_get_num_targets(table)) {
+                ti = dm_table_get_target(table, i++);
+
+                if (!ti->type->iterate_devices)
+                        return false;
+
+                ti->type->iterate_devices(ti, count_device, &num_devices);
+                if (num_devices)
+                        return false;
+        }
+
+        return true;
+}
+
 /*
  * Establish the new table's queue_limits and validate them.
  */
@@ -1354,17 +1389,25 @@ static int device_is_nonrot(struct dm_target *ti, struct dm_dev *dev,
         return q && blk_queue_nonrot(q);
 }
 
-static bool dm_table_is_nonrot(struct dm_table *t)
+static int device_is_not_random(struct dm_target *ti, struct dm_dev *dev,
+                             sector_t start, sector_t len, void *data)
+{
+        struct request_queue *q = bdev_get_queue(dev->bdev);
+
+        return q && !blk_queue_add_random(q);
+}
+
+static bool dm_table_all_devices_attribute(struct dm_table *t,
+                                           iterate_devices_callout_fn func)
 {
         struct dm_target *ti;
         unsigned i = 0;
 
-        /* Ensure that all underlying device are non-rotational. */
         while (i < dm_table_get_num_targets(t)) {
                 ti = dm_table_get_target(t, i++);
 
                 if (!ti->type->iterate_devices ||
-                    !ti->type->iterate_devices(ti, device_is_nonrot, NULL))
+                    !ti->type->iterate_devices(ti, func, NULL))
                         return 0;
         }
 
@@ -1396,7 +1439,8 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
         if (!dm_table_discard_zeroes_data(t))
                 q->limits.discard_zeroes_data = 0;
 
-        if (dm_table_is_nonrot(t))
+        /* Ensure that all underlying devices are non-rotational. */
+        if (dm_table_all_devices_attribute(t, device_is_nonrot))
                 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);
         else
                 queue_flag_clear_unlocked(QUEUE_FLAG_NONROT, q);
@@ -1404,6 +1448,15 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
         dm_table_set_integrity(t);
 
         /*
+         * Determine whether or not this queue's I/O timings contribute
+         * to the entropy pool, Only request-based targets use this.
+         * Clear QUEUE_FLAG_ADD_RANDOM if any underlying device does not
+         * have it set.
+         */
+        if (blk_queue_add_random(q) && dm_table_all_devices_attribute(t, device_is_not_random))
+                queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, q);
+
+        /*
          * QUEUE_FLAG_STACKABLE must be set after all queue settings are
          * visible to other CPUs because, once the flag is set, incoming bios
          * are processed by request-based dm, which refers to the queue
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index af1fc3b2c2ad..c29410af1e22 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -509,9 +509,9 @@ enum pool_mode {
 struct pool_features {
         enum pool_mode mode;
 
-        unsigned zero_new_blocks:1;
-        unsigned discard_enabled:1;
-        unsigned discard_passdown:1;
+        bool zero_new_blocks:1;
+        bool discard_enabled:1;
+        bool discard_passdown:1;
 };
 
 struct thin_c;
@@ -580,7 +580,8 @@ struct pool_c {
         struct dm_target_callbacks callbacks;
 
         dm_block_t low_water_blocks;
-        struct pool_features pf;
+        struct pool_features requested_pf; /* Features requested during table load */
+        struct pool_features adjusted_pf;  /* Features used after adjusting for constituent devices */
 };
 
 /*
@@ -1839,6 +1840,47 @@ static void __requeue_bios(struct pool *pool)
 /*----------------------------------------------------------------
  * Binding of control targets to a pool object
  *--------------------------------------------------------------*/
+static bool data_dev_supports_discard(struct pool_c *pt)
+{
+        struct request_queue *q = bdev_get_queue(pt->data_dev->bdev);
+
+        return q && blk_queue_discard(q);
+}
+
+/*
+ * If discard_passdown was enabled verify that the data device
+ * supports discards.  Disable discard_passdown if not.
+ */
+static void disable_passdown_if_not_supported(struct pool_c *pt)
+{
+        struct pool *pool = pt->pool;
+        struct block_device *data_bdev = pt->data_dev->bdev;
+        struct queue_limits *data_limits = &bdev_get_queue(data_bdev)->limits;
+        sector_t block_size = pool->sectors_per_block << SECTOR_SHIFT;
+        const char *reason = NULL;
+        char buf[BDEVNAME_SIZE];
+
+        if (!pt->adjusted_pf.discard_passdown)
+                return;
+
+        if (!data_dev_supports_discard(pt))
+                reason = "discard unsupported";
+
+        else if (data_limits->max_discard_sectors < pool->sectors_per_block)
+                reason = "max discard sectors smaller than a block";
+
+        else if (data_limits->discard_granularity > block_size)
+                reason = "discard granularity larger than a block";
+
+        else if (block_size & (data_limits->discard_granularity - 1))
+                reason = "discard granularity not a factor of block size";
+
+        if (reason) {
+                DMWARN("Data device (%s) %s: Disabling discard passdown.", bdevname(data_bdev, buf), reason);
+                pt->adjusted_pf.discard_passdown = false;
+        }
+}
+
 static int bind_control_target(struct pool *pool, struct dm_target *ti)
 {
         struct pool_c *pt = ti->private;
@@ -1847,31 +1889,16 @@ static int bind_control_target(struct pool *pool, struct dm_target *ti)
          * We want to make sure that degraded pools are never upgraded.
          */
         enum pool_mode old_mode = pool->pf.mode;
-        enum pool_mode new_mode = pt->pf.mode;
+        enum pool_mode new_mode = pt->adjusted_pf.mode;
 
         if (old_mode > new_mode)
                 new_mode = old_mode;
 
         pool->ti = ti;
         pool->low_water_blocks = pt->low_water_blocks;
-        pool->pf = pt->pf;
-        set_pool_mode(pool, new_mode);
+        pool->pf = pt->adjusted_pf;
 
-        /*
-         * If discard_passdown was enabled verify that the data device
-         * supports discards.  Disable discard_passdown if not; otherwise
-         * -EOPNOTSUPP will be returned.
-         */
-        /* FIXME: pull this out into a sep fn. */
-        if (pt->pf.discard_passdown) {
-                struct request_queue *q = bdev_get_queue(pt->data_dev->bdev);
-                if (!q || !blk_queue_discard(q)) {
-                        char buf[BDEVNAME_SIZE];
-                        DMWARN("Discard unsupported by data device (%s): Disabling discard passdown.",
-                               bdevname(pt->data_dev->bdev, buf));
-                        pool->pf.discard_passdown = 0;
-                }
-        }
+        set_pool_mode(pool, new_mode);
 
         return 0;
 }
@@ -1889,9 +1916,9 @@ static void unbind_control_target(struct pool *pool, struct dm_target *ti)
 static void pool_features_init(struct pool_features *pf)
 {
         pf->mode = PM_WRITE;
-        pf->zero_new_blocks = 1;
-        pf->discard_enabled = 1;
-        pf->discard_passdown = 1;
+        pf->zero_new_blocks = true;
+        pf->discard_enabled = true;
+        pf->discard_passdown = true;
 }
 
 static void __pool_destroy(struct pool *pool)
@@ -2119,13 +2146,13 @@ static int parse_pool_features(struct dm_arg_set *as, struct pool_features *pf,
                 argc--;
 
                 if (!strcasecmp(arg_name, "skip_block_zeroing"))
-                        pf->zero_new_blocks = 0;
+                        pf->zero_new_blocks = false;
 
                 else if (!strcasecmp(arg_name, "ignore_discard"))
-                        pf->discard_enabled = 0;
+                        pf->discard_enabled = false;
 
                 else if (!strcasecmp(arg_name, "no_discard_passdown"))
-                        pf->discard_passdown = 0;
+                        pf->discard_passdown = false;
 
                 else if (!strcasecmp(arg_name, "read_only"))
                         pf->mode = PM_READ_ONLY;
@@ -2259,8 +2286,9 @@ static int pool_ctr(struct dm_target *ti, unsigned argc, char **argv)
         pt->metadata_dev = metadata_dev;
         pt->data_dev = data_dev;
         pt->low_water_blocks = low_water_blocks;
-        pt->pf = pf;
+        pt->adjusted_pf = pt->requested_pf = pf;
         ti->num_flush_requests = 1;
+
         /*
          * Only need to enable discards if the pool should pass
          * them down to the data device.  The thin device's discard
@@ -2268,12 +2296,14 @@ static int pool_ctr(struct dm_target *ti, unsigned argc, char **argv)
          */
         if (pf.discard_enabled && pf.discard_passdown) {
                 ti->num_discard_requests = 1;
+
                 /*
                  * Setting 'discards_supported' circumvents the normal
                  * stacking of discard limits (this keeps the pool and
                  * thin devices' discard limits consistent).
                  */
                 ti->discards_supported = true;
+                ti->discard_zeroes_data_unsupported = true;
         }
         ti->private = pt;
 
@@ -2703,7 +2733,7 @@ static int pool_status(struct dm_target *ti, status_type_t type,
                        format_dev_t(buf2, pt->data_dev->bdev->bd_dev),
                        (unsigned long)pool->sectors_per_block,
                        (unsigned long long)pt->low_water_blocks);
-                emit_flags(&pt->pf, result, sz, maxlen);
+                emit_flags(&pt->requested_pf, result, sz, maxlen);
                 break;
         }
 
@@ -2732,20 +2762,21 @@ static int pool_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
         return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
 }
 
-static void set_discard_limits(struct pool *pool, struct queue_limits *limits)
+static void set_discard_limits(struct pool_c *pt, struct queue_limits *limits)
 {
-        /*
-         * FIXME: these limits may be incompatible with the pool's data device
-         */
+        struct pool *pool = pt->pool;
+        struct queue_limits *data_limits;
+
         limits->max_discard_sectors = pool->sectors_per_block;
 
         /*
-         * This is just a hint, and not enforced.  We have to cope with
-         * bios that cover a block partially.  A discard that spans a block
-         * boundary is not sent to this target.
+         * discard_granularity is just a hint, and not enforced.
          */
-        limits->discard_granularity = pool->sectors_per_block << SECTOR_SHIFT;
-        limits->discard_zeroes_data = pool->pf.zero_new_blocks;
+        if (pt->adjusted_pf.discard_passdown) {
+                data_limits = &bdev_get_queue(pt->data_dev->bdev)->limits;
+                limits->discard_granularity = data_limits->discard_granularity;
+        } else
+                limits->discard_granularity = pool->sectors_per_block << SECTOR_SHIFT;
 }
 
 static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits)
@@ -2755,15 +2786,25 @@ static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits)
 
         blk_limits_io_min(limits, 0);
         blk_limits_io_opt(limits, pool->sectors_per_block << SECTOR_SHIFT);
-        if (pool->pf.discard_enabled)
-                set_discard_limits(pool, limits);
+
+        /*
+         * pt->adjusted_pf is a staging area for the actual features to use.
+         * They get transferred to the live pool in bind_control_target()
+         * called from pool_preresume().
+         */
+        if (!pt->adjusted_pf.discard_enabled)
+                return;
+
+        disable_passdown_if_not_supported(pt);
+
+        set_discard_limits(pt, limits);
 }
 
 static struct target_type pool_target = {
         .name = "thin-pool",
         .features = DM_TARGET_SINGLETON | DM_TARGET_ALWAYS_WRITEABLE |
                     DM_TARGET_IMMUTABLE,
-        .version = {1, 3, 0},
+        .version = {1, 4, 0},
         .module = THIS_MODULE,
         .ctr = pool_ctr,
         .dtr = pool_dtr,
@@ -3042,19 +3083,19 @@ static int thin_iterate_devices(struct dm_target *ti,
         return 0;
 }
 
+/*
+ * A thin device always inherits its queue limits from its pool.
+ */
 static void thin_io_hints(struct dm_target *ti, struct queue_limits *limits)
 {
         struct thin_c *tc = ti->private;
-        struct pool *pool = tc->pool;
 
-        blk_limits_io_min(limits, 0);
-        blk_limits_io_opt(limits, pool->sectors_per_block << SECTOR_SHIFT);
-        set_discard_limits(pool, limits);
+        *limits = bdev_get_queue(tc->pool_dev->bdev)->limits;
 }
 
 static struct target_type thin_target = {
         .name = "thin",
-        .version = {1, 3, 0},
+        .version = {1, 4, 0},
         .module = THIS_MODULE,
         .ctr = thin_ctr,
         .dtr = thin_dtr,
diff --git a/drivers/md/dm-verity.c b/drivers/md/dm-verity.c
index 254d19268ad2..892ae2766aa6 100644
--- a/drivers/md/dm-verity.c
+++ b/drivers/md/dm-verity.c
@@ -718,8 +718,8 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv)
         v->hash_dev_block_bits = ffs(num) - 1;
 
         if (sscanf(argv[5], "%llu%c", &num_ll, &dummy) != 1 ||
-            num_ll << (v->data_dev_block_bits - SECTOR_SHIFT) !=
-            (sector_t)num_ll << (v->data_dev_block_bits - SECTOR_SHIFT)) {
+            (sector_t)(num_ll << (v->data_dev_block_bits - SECTOR_SHIFT))
+            >> (v->data_dev_block_bits - SECTOR_SHIFT) != num_ll) {
                 ti->error = "Invalid data blocks";
                 r = -EINVAL;
                 goto bad;
@@ -733,8 +733,8 @@ static int verity_ctr(struct dm_target *ti, unsigned argc, char **argv)
         }
 
         if (sscanf(argv[6], "%llu%c", &num_ll, &dummy) != 1 ||
-            num_ll << (v->hash_dev_block_bits - SECTOR_SHIFT) !=
-            (sector_t)num_ll << (v->hash_dev_block_bits - SECTOR_SHIFT)) {
+            (sector_t)(num_ll << (v->hash_dev_block_bits - SECTOR_SHIFT))
+            >> (v->hash_dev_block_bits - SECTOR_SHIFT) != num_ll) {
                 ti->error = "Invalid hash start";
                 r = -EINVAL;
                 goto bad;
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 4e09b6ff5b49..67ffa391edcf 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -865,10 +865,14 @@ static void dm_done(struct request *clone, int error, bool mapped)
 {
         int r = error;
         struct dm_rq_target_io *tio = clone->end_io_data;
-        dm_request_endio_fn rq_end_io = tio->ti->type->rq_end_io;
+        dm_request_endio_fn rq_end_io = NULL;
 
-        if (mapped && rq_end_io)
-                r = rq_end_io(tio->ti, clone, error, &tio->info);
+        if (tio->ti) {
+                rq_end_io = tio->ti->type->rq_end_io;
+
+                if (mapped && rq_end_io)
+                        r = rq_end_io(tio->ti, clone, error, &tio->info);
+        }
 
         if (r <= 0)
                 /* The target wants to complete the I/O */
@@ -1588,15 +1592,6 @@ static int map_request(struct dm_target *ti, struct request *clone,
         int r, requeued = 0;
         struct dm_rq_target_io *tio = clone->end_io_data;
 
-        /*
-         * Hold the md reference here for the in-flight I/O.
-         * We can't rely on the reference count by device opener,
-         * because the device may be closed during the request completion
-         * when all bios are completed.
-         * See the comment in rq_completed() too.
-         */
-        dm_get(md);
-
         tio->ti = ti;
         r = ti->type->map_rq(ti, clone, &tio->info);
         switch (r) {
@@ -1628,6 +1623,26 @@ static int map_request(struct dm_target *ti, struct request *clone,
         return requeued;
 }
 
+static struct request *dm_start_request(struct mapped_device *md, struct request *orig)
+{
+        struct request *clone;
+
+        blk_start_request(orig);
+        clone = orig->special;
+        atomic_inc(&md->pending[rq_data_dir(clone)]);
+
+        /*
+         * Hold the md reference here for the in-flight I/O.
+         * We can't rely on the reference count by device opener,
+         * because the device may be closed during the request completion
+         * when all bios are completed.
+         * See the comment in rq_completed() too.
+         */
+        dm_get(md);
+
+        return clone;
+}
+
 /*
  * q->request_fn for request-based dm.
  * Called with the queue lock held.
@@ -1657,14 +1672,21 @@ static void dm_request_fn(struct request_queue *q)
                         pos = blk_rq_pos(rq);
 
                 ti = dm_table_find_target(map, pos);
-                BUG_ON(!dm_target_is_valid(ti));
+                if (!dm_target_is_valid(ti)) {
+                        /*
+                         * Must perform setup, that dm_done() requires,
+                         * before calling dm_kill_unmapped_request
+                         */
+                        DMERR_LIMIT("request attempted access beyond the end of device");
+                        clone = dm_start_request(md, rq);
+                        dm_kill_unmapped_request(clone, -EIO);
+                        continue;
+                }
 
                 if (ti->type->busy && ti->type->busy(ti))
                         goto delay_and_out;
 
-                blk_start_request(rq);
-                clone = rq->special;
-                atomic_inc(&md->pending[rq_data_dir(clone)]);
+                clone = dm_start_request(md, rq);
 
                 spin_unlock(q->queue_lock);
                 if (map_request(ti, clone, md))
@@ -1684,8 +1706,6 @@ delay_and_out:
         blk_delay_queue(q, HZ / 10);
 out:
         dm_table_put(map);
-
-        return;
 }
 
 int dm_underlying_device_busy(struct request_queue *q)
@@ -2409,7 +2429,7 @@ static void dm_queue_flush(struct mapped_device *md)
  */
 struct dm_table *dm_swap_table(struct mapped_device *md, struct dm_table *table)
 {
-        struct dm_table *map = ERR_PTR(-EINVAL);
+        struct dm_table *live_map, *map = ERR_PTR(-EINVAL);
         struct queue_limits limits;
         int r;
 
@@ -2419,6 +2439,19 @@ struct dm_table *dm_swap_table(struct mapped_device *md, struct dm_table *table)
         if (!dm_suspended_md(md))
                 goto out;
 
+        /*
+         * If the new table has no data devices, retain the existing limits.
+         * This helps multipath with queue_if_no_path if all paths disappear,
+         * then new I/O is queued based on these limits, and then some paths
+         * reappear.
+         */
+        if (dm_table_has_no_data_devices(table)) {
+                live_map = dm_get_live_table(md);
+                if (live_map)
+                        limits = md->queue->limits;
+                dm_table_put(live_map);
+        }
+
         r = dm_calculate_queue_limits(table, &limits);
         if (r) {
                 map = ERR_PTR(r);
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 52eef493d266..6a99fefaa743 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -54,6 +54,7 @@ void dm_table_event_callback(struct dm_table *t,
                              void (*fn)(void *), void *context);
 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index);
 struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector);
+bool dm_table_has_no_data_devices(struct dm_table *table);
 int dm_calculate_queue_limits(struct dm_table *table,
                               struct queue_limits *limits);
 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 1c2eb38f3c51..0138a727c1f3 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1512,14 +1512,16 @@ static int _enough(struct r10conf *conf, struct geom *geo, int ignore)
         do {
                 int n = conf->copies;
                 int cnt = 0;
+                int this = first;
                 while (n--) {
-                        if (conf->mirrors[first].rdev &&
-                            first != ignore)
+                        if (conf->mirrors[this].rdev &&
+                            this != ignore)
                                 cnt++;
-                        first = (first+1) % geo->raid_disks;
+                        this = (this+1) % geo->raid_disks;
                 }
                 if (cnt == 0)
                         return 0;
+                first = (first + geo->near_copies) % geo->raid_disks;
         } while (first != 0);
         return 1;
 }
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 7031b865b3a0..0689173fd9f5 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -1591,6 +1591,7 @@ static int resize_stripes(struct r5conf *conf, int newsize)
                 #ifdef CONFIG_MULTICORE_RAID456
                 init_waitqueue_head(&nsh->ops.wait_for_ops);
                 #endif
+                spin_lock_init(&nsh->stripe_lock);
 
                 list_add(&nsh->lru, &newstripes);
         }
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index f2f482bec573..a6e74514e662 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -1123,6 +1123,33 @@ static unsigned long mtdchar_get_unmapped_area(struct file *file,
 }
 #endif
 
+static inline unsigned long get_vm_size(struct vm_area_struct *vma)
+{
+        return vma->vm_end - vma->vm_start;
+}
+
+static inline resource_size_t get_vm_offset(struct vm_area_struct *vma)
+{
+        return (resource_size_t) vma->vm_pgoff << PAGE_SHIFT;
+}
+
+/*
+ * Set a new vm offset.
+ *
+ * Verify that the incoming offset really works as a page offset,
+ * and that the offset and size fit in a resource_size_t.
+ */
+static inline int set_vm_offset(struct vm_area_struct *vma, resource_size_t off)
+{
+        pgoff_t pgoff = off >> PAGE_SHIFT;
+        if (off != (resource_size_t) pgoff << PAGE_SHIFT)
+                return -EINVAL;
+        if (off + get_vm_size(vma) - 1 < off)
+                return -EINVAL;
+        vma->vm_pgoff = pgoff;
+        return 0;
+}
+
 /*
  * set up a mapping for shared memory segments
  */
@@ -1132,20 +1159,29 @@ static int mtdchar_mmap(struct file *file, struct vm_area_struct *vma)
         struct mtd_file_info *mfi = file->private_data;
         struct mtd_info *mtd = mfi->mtd;
         struct map_info *map = mtd->priv;
-        unsigned long start;
-        unsigned long off;
-        u32 len;
+        resource_size_t start, off;
+        unsigned long len, vma_len;
 
         if (mtd->type == MTD_RAM || mtd->type == MTD_ROM) {
-                off = vma->vm_pgoff << PAGE_SHIFT;
+                off = get_vm_offset(vma);
                 start = map->phys;
                 len = PAGE_ALIGN((start & ~PAGE_MASK) + map->size);
                 start &= PAGE_MASK;
-                if ((vma->vm_end - vma->vm_start + off) > len)
+                vma_len = get_vm_size(vma);
+
+                /* Overflow in off+len? */
+                if (vma_len + off < off)
+                        return -EINVAL;
+                /* Does it fit in the mapping? */
+                if (vma_len + off > len)
                         return -EINVAL;
 
                 off += start;
-                vma->vm_pgoff = off >> PAGE_SHIFT;
+                /* Did that overflow? */
+                if (off < start)
+                        return -EINVAL;
+                if (set_vm_offset(vma, off) < 0)
+                        return -EINVAL;
                 vma->vm_flags |= VM_IO | VM_RESERVED;
 
 #ifdef pgprot_noncached
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index 79cebd8525ce..e48312f2305d 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -8564,7 +8564,7 @@ bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         return 0;
 
 error:
-        iounmap(bp->regview);
+        pci_iounmap(pdev, bp->regview);
         pci_release_regions(pdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
diff --git a/drivers/net/ethernet/octeon/octeon_mgmt.c b/drivers/net/ethernet/octeon/octeon_mgmt.c
index c42bbb16cdae..a688a2ddcfd6 100644
--- a/drivers/net/ethernet/octeon/octeon_mgmt.c
+++ b/drivers/net/ethernet/octeon/octeon_mgmt.c
@@ -722,10 +722,8 @@ static int octeon_mgmt_init_phy(struct net_device *netdev)
                                    octeon_mgmt_adjust_link, 0,
                                    PHY_INTERFACE_MODE_MII);
 
-        if (IS_ERR(p->phydev)) {
-                p->phydev = NULL;
+        if (!p->phydev)
                 return -1;
-        }
 
         phy_start_aneg(p->phydev);
 
diff --git a/drivers/net/ethernet/pasemi/pasemi_mac.c b/drivers/net/ethernet/pasemi/pasemi_mac.c
index e559dfa06d6a..6fa74d530e44 100644
--- a/drivers/net/ethernet/pasemi/pasemi_mac.c
+++ b/drivers/net/ethernet/pasemi/pasemi_mac.c
@@ -1101,9 +1101,9 @@ static int pasemi_mac_phy_init(struct net_device *dev)
         phydev = of_phy_connect(dev, phy_dn, &pasemi_adjust_link, 0,
                                 PHY_INTERFACE_MODE_SGMII);
 
-        if (IS_ERR(phydev)) {
+        if (!phydev) {
                 printk(KERN_ERR "%s: Could not attach to phy\n", dev->name);
-                return PTR_ERR(phydev);
+                return -ENODEV;
         }
 
         mac->phydev = phydev;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
index b8ead696141e..2a179d087207 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
@@ -15,7 +15,7 @@ qlcnic_poll_rsp(struct qlcnic_adapter *adapter)
 
         do {
                 /* give atleast 1ms for firmware to respond */
-                msleep(1);
+                mdelay(1);
 
                 if (++timeout > QLCNIC_OS_CRB_RETRY_COUNT)
                         return QLCNIC_CDRP_RSP_TIMEOUT;
@@ -601,7 +601,7 @@ void qlcnic_fw_destroy_ctx(struct qlcnic_adapter *adapter)
                 qlcnic_fw_cmd_destroy_tx_ctx(adapter);
 
                 /* Allow dma queues to drain after context reset */
-                msleep(20);
+                mdelay(20);
         }
 }
 
diff --git a/drivers/net/phy/bcm87xx.c b/drivers/net/phy/bcm87xx.c
index 2346b38b9837..799789518e87 100644
--- a/drivers/net/phy/bcm87xx.c
+++ b/drivers/net/phy/bcm87xx.c
@@ -229,3 +229,5 @@ static void __exit bcm87xx_exit(void)
                 ARRAY_SIZE(bcm87xx_driver));
 }
 module_exit(bcm87xx_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/phy/micrel.c b/drivers/net/phy/micrel.c
index cf287e0eb408..2165d5fdb8c0 100644
--- a/drivers/net/phy/micrel.c
+++ b/drivers/net/phy/micrel.c
@@ -21,6 +21,12 @@
 #include <linux/phy.h>
 #include <linux/micrel_phy.h>
 
+/* Operation Mode Strap Override */
+#define MII_KSZPHY_OMSO                         0x16
+#define KSZPHY_OMSO_B_CAST_OFF                  (1 << 9)
+#define KSZPHY_OMSO_RMII_OVERRIDE               (1 << 1)
+#define KSZPHY_OMSO_MII_OVERRIDE                (1 << 0)
+
 /* general Interrupt control/status reg in vendor specific block. */
 #define MII_KSZPHY_INTCS                        0x1B
 #define KSZPHY_INTCS_JABBER                     (1 << 15)
@@ -101,6 +107,13 @@ static int kszphy_config_init(struct phy_device *phydev)
         return 0;
 }
 
+static int ksz8021_config_init(struct phy_device *phydev)
+{
+        const u16 val = KSZPHY_OMSO_B_CAST_OFF | KSZPHY_OMSO_RMII_OVERRIDE;
+        phy_write(phydev, MII_KSZPHY_OMSO, val);
+        return 0;
+}
+
 static int ks8051_config_init(struct phy_device *phydev)
 {
         int regval;
@@ -128,9 +141,22 @@ static struct phy_driver ksphy_driver[] = {
         .config_intr    = ks8737_config_intr,
         .driver         = { .owner = THIS_MODULE,},
 }, {
-        .phy_id         = PHY_ID_KS8041,
+        .phy_id         = PHY_ID_KSZ8021,
+        .phy_id_mask    = 0x00ffffff,
+        .name           = "Micrel KSZ8021",
+        .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause |
+                           SUPPORTED_Asym_Pause),
+        .flags          = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
+        .config_init    = ksz8021_config_init,
+        .config_aneg    = genphy_config_aneg,
+        .read_status    = genphy_read_status,
+        .ack_interrupt  = kszphy_ack_interrupt,
+        .config_intr    = kszphy_config_intr,
+        .driver         = { .owner = THIS_MODULE,},
+}, {
+        .phy_id         = PHY_ID_KSZ8041,
         .phy_id_mask    = 0x00fffff0,
-        .name           = "Micrel KS8041",
+        .name           = "Micrel KSZ8041",
         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
                                 | SUPPORTED_Asym_Pause),
         .flags          = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
@@ -141,9 +167,9 @@ static struct phy_driver ksphy_driver[] = {
         .config_intr    = kszphy_config_intr,
         .driver         = { .owner = THIS_MODULE,},
 }, {
-        .phy_id         = PHY_ID_KS8051,
+        .phy_id         = PHY_ID_KSZ8051,
         .phy_id_mask    = 0x00fffff0,
-        .name           = "Micrel KS8051",
+        .name           = "Micrel KSZ8051",
         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause
                                 | SUPPORTED_Asym_Pause),
         .flags          = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
@@ -154,8 +180,8 @@ static struct phy_driver ksphy_driver[] = {
         .config_intr    = kszphy_config_intr,
         .driver         = { .owner = THIS_MODULE,},
 }, {
-        .phy_id         = PHY_ID_KS8001,
-        .name           = "Micrel KS8001 or KS8721",
+        .phy_id         = PHY_ID_KSZ8001,
+        .name           = "Micrel KSZ8001 or KS8721",
         .phy_id_mask    = 0x00ffffff,
         .features       = (PHY_BASIC_FEATURES | SUPPORTED_Pause),
         .flags          = PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
@@ -201,10 +227,11 @@ MODULE_LICENSE("GPL");
 
 static struct mdio_device_id __maybe_unused micrel_tbl[] = {
         { PHY_ID_KSZ9021, 0x000ffffe },
-        { PHY_ID_KS8001, 0x00ffffff },
+        { PHY_ID_KSZ8001, 0x00ffffff },
         { PHY_ID_KS8737, 0x00fffff0 },
-        { PHY_ID_KS8041, 0x00fffff0 },
-        { PHY_ID_KS8051, 0x00fffff0 },
+        { PHY_ID_KSZ8021, 0x00ffffff },
+        { PHY_ID_KSZ8041, 0x00fffff0 },
+        { PHY_ID_KSZ8051, 0x00fffff0 },
         { }
 };
 
diff --git a/drivers/net/phy/smsc.c b/drivers/net/phy/smsc.c
index 6d6192316b30..88e3991464e7 100644
--- a/drivers/net/phy/smsc.c
+++ b/drivers/net/phy/smsc.c
@@ -56,6 +56,32 @@ static int smsc_phy_config_init(struct phy_device *phydev)
         return smsc_phy_ack_interrupt (phydev);
 }
 
+static int lan87xx_config_init(struct phy_device *phydev)
+{
+        /*
+         * Make sure the EDPWRDOWN bit is NOT set. Setting this bit on
+         * LAN8710/LAN8720 PHY causes the PHY to misbehave, likely due
+         * to a bug on the chip.
+         *
+         * When the system is powered on with the network cable being
+         * disconnected all the way until after ifconfig ethX up is
+         * issued for the LAN port with this PHY, connecting the cable
+         * afterwards does not cause LINK change detection, while the
+         * expected behavior is the Link UP being detected.
+         */
+        int rc = phy_read(phydev, MII_LAN83C185_CTRL_STATUS);
+        if (rc < 0)
+                return rc;
+
+        rc &= ~MII_LAN83C185_EDPWRDOWN;
+
+        rc = phy_write(phydev, MII_LAN83C185_CTRL_STATUS, rc);
+        if (rc < 0)
+                return rc;
+
+        return smsc_phy_ack_interrupt(phydev);
+}
+
 static int lan911x_config_init(struct phy_device *phydev)
 {
         return smsc_phy_ack_interrupt(phydev);
@@ -162,7 +188,7 @@ static struct phy_driver smsc_phy_driver[] = {
         /* basic functions */
         .config_aneg    = genphy_config_aneg,
         .read_status    = genphy_read_status,
-        .config_init    = smsc_phy_config_init,
+        .config_init    = lan87xx_config_init,
 
         /* IRQ related */
         .ack_interrupt  = smsc_phy_ack_interrupt,
diff --git a/drivers/net/ppp/pppoe.c b/drivers/net/ppp/pppoe.c
index cbf7047decc0..20f31d0d1536 100644
--- a/drivers/net/ppp/pppoe.c
+++ b/drivers/net/ppp/pppoe.c
@@ -570,7 +570,7 @@ static int pppoe_release(struct socket *sock)
 
         po = pppox_sk(sk);
 
-        if (sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND)) {
+        if (sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND | PPPOX_ZOMBIE)) {
                 dev_put(po->pppoe_dev);
                 po->pppoe_dev = NULL;
         }
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index 341b65dbbcd3..f8cd61f449a4 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -848,7 +848,7 @@ static struct netpoll_info *team_netpoll_info(struct team *team)
 }
 #endif
 
-static void __team_port_change_check(struct team_port *port, bool linkup);
+static void __team_port_change_port_added(struct team_port *port, bool linkup);
 
 static int team_port_add(struct team *team, struct net_device *port_dev)
 {
@@ -948,7 +948,7 @@ static int team_port_add(struct team *team, struct net_device *port_dev)
         team_port_enable(team, port);
         list_add_tail_rcu(&port->list, &team->port_list);
         __team_compute_features(team);
-        __team_port_change_check(port, !!netif_carrier_ok(port_dev));
+        __team_port_change_port_added(port, !!netif_carrier_ok(port_dev));
         __team_options_change_check(team);
 
         netdev_info(dev, "Port device %s added\n", portname);
@@ -983,6 +983,8 @@ err_set_mtu:
         return err;
 }
 
+static void __team_port_change_port_removed(struct team_port *port);
+
 static int team_port_del(struct team *team, struct net_device *port_dev)
 {
         struct net_device *dev = team->dev;
@@ -999,8 +1001,7 @@ static int team_port_del(struct team *team, struct net_device *port_dev)
         __team_option_inst_mark_removed_port(team, port);
         __team_options_change_check(team);
         __team_option_inst_del_port(team, port);
-        port->removed = true;
-        __team_port_change_check(port, false);
+        __team_port_change_port_removed(port);
         team_port_disable(team, port);
         list_del_rcu(&port->list);
         netdev_rx_handler_unregister(port_dev);
@@ -1652,8 +1653,8 @@ static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
 
         hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
                           &team_nl_family, 0, TEAM_CMD_NOOP);
-        if (IS_ERR(hdr)) {
-                err = PTR_ERR(hdr);
+        if (!hdr) {
+                err = -EMSGSIZE;
                 goto err_msg_put;
         }
 
@@ -1847,8 +1848,8 @@ start_again:
 
         hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags | NLM_F_MULTI,
                           TEAM_CMD_OPTIONS_GET);
-        if (IS_ERR(hdr))
-                return PTR_ERR(hdr);
+        if (!hdr)
+                return -EMSGSIZE;
 
         if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex))
                 goto nla_put_failure;
@@ -2067,8 +2068,8 @@ static int team_nl_fill_port_list_get(struct sk_buff *skb,
 
         hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
                           TEAM_CMD_PORT_LIST_GET);
-        if (IS_ERR(hdr))
-                return PTR_ERR(hdr);
+        if (!hdr)
+                return -EMSGSIZE;
 
         if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex))
                 goto nla_put_failure;
@@ -2251,13 +2252,11 @@ static void __team_options_change_check(struct team *team)
 }
 
 /* rtnl lock is held */
-static void __team_port_change_check(struct team_port *port, bool linkup)
+
+static void __team_port_change_send(struct team_port *port, bool linkup)
 {
         int err;
 
-        if (!port->removed && port->state.linkup == linkup)
-                return;
-
         port->changed = true;
         port->state.linkup = linkup;
         team_refresh_port_linkup(port);
@@ -2282,6 +2281,23 @@ send_event:
 
 }
 
+static void __team_port_change_check(struct team_port *port, bool linkup)
+{
+        if (port->state.linkup != linkup)
+                __team_port_change_send(port, linkup);
+}
+
+static void __team_port_change_port_added(struct team_port *port, bool linkup)
+{
+        __team_port_change_send(port, linkup);
+}
+
+static void __team_port_change_port_removed(struct team_port *port)
+{
+        port->removed = true;
+        __team_port_change_send(port, false);
+}
+
 static void team_port_change_check(struct team_port *port, bool linkup)
 {
         struct team *team = port->team;
diff --git a/drivers/net/usb/smsc75xx.c b/drivers/net/usb/smsc75xx.c
index f5ab6e613ec8..376143e8a1aa 100644
--- a/drivers/net/usb/smsc75xx.c
+++ b/drivers/net/usb/smsc75xx.c
@@ -1253,6 +1253,7 @@ static struct usb_driver smsc75xx_driver = {
         .probe          = usbnet_probe,
         .suspend        = usbnet_suspend,
         .resume         = usbnet_resume,
+        .reset_resume   = usbnet_resume,
         .disconnect     = usbnet_disconnect,
         .disable_hub_initiated_lpm = 1,
 };
diff --git a/drivers/net/wireless/iwlwifi/pcie/trans.c b/drivers/net/wireless/iwlwifi/pcie/trans.c
index 1e86ea2266d4..dbeebef562d5 100644
--- a/drivers/net/wireless/iwlwifi/pcie/trans.c
+++ b/drivers/net/wireless/iwlwifi/pcie/trans.c
@@ -1442,6 +1442,7 @@ static int iwl_trans_pcie_start_hw(struct iwl_trans *trans)
         return err;
 
 err_free_irq:
+        trans_pcie->irq_requested = false;
         free_irq(trans_pcie->irq, trans);
 error:
         iwl_free_isr_ict(trans);
diff --git a/drivers/sh/pfc/pinctrl.c b/drivers/sh/pfc/pinctrl.c
index a3ac39b79192..0646bf6e7889 100644
--- a/drivers/sh/pfc/pinctrl.c
+++ b/drivers/sh/pfc/pinctrl.c
@@ -208,6 +208,8 @@ static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
 
                 break;
         case PINMUX_TYPE_GPIO:
+        case PINMUX_TYPE_INPUT:
+        case PINMUX_TYPE_OUTPUT:
                 break;
         default:
                 pr_err("Unsupported mux type (%d), bailing...\n", pinmux_type);
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index d95696584762..3440812b4a84 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -624,7 +624,7 @@ static ssize_t usb_device_read(struct file *file, char __user *buf,
         /* print devices for all busses */
         list_for_each_entry(bus, &usb_bus_list, bus_list) {
                 /* recurse through all children of the root hub */
-                if (!bus->root_hub)
+                if (!bus_to_hcd(bus)->rh_registered)
                         continue;
                 usb_lock_device(bus->root_hub);
                 ret = usb_device_dump(&buf, &nbytes, &skip_bytes, ppos,
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index bc84106ac057..75ba2091f9b4 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1011,10 +1011,7 @@ static int register_root_hub(struct usb_hcd *hcd)
         if (retval) {
                 dev_err (parent_dev, "can't register root hub for %s, %d\n",
                                 dev_name(&usb_dev->dev), retval);
-        }
-        mutex_unlock(&usb_bus_list_lock);
-
-        if (retval == 0) {
+        } else {
                 spin_lock_irq (&hcd_root_hub_lock);
                 hcd->rh_registered = 1;
                 spin_unlock_irq (&hcd_root_hub_lock);
@@ -1023,6 +1020,7 @@ static int register_root_hub(struct usb_hcd *hcd)
                 if (HCD_DEAD(hcd))
                         usb_hc_died (hcd);      /* This time clean up */
         }
+        mutex_unlock(&usb_bus_list_lock);
 
         return retval;
 }
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index aaa8d2bce217..0bf72f943b00 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -467,7 +467,8 @@ static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
         /* From the GPIO notifying the over-current situation, find
          * out the corresponding port */
         at91_for_each_port(port) {
-                if (gpio_to_irq(pdata->overcurrent_pin[port]) == irq) {
+                if (gpio_is_valid(pdata->overcurrent_pin[port]) &&
+                                gpio_to_irq(pdata->overcurrent_pin[port]) == irq) {
                         gpio = pdata->overcurrent_pin[port];
                         break;
                 }
diff --git a/drivers/vfio/pci/vfio_pci_intrs.c b/drivers/vfio/pci/vfio_pci_intrs.c
index 211a4920b88a..d8dedc7d3910 100644
--- a/drivers/vfio/pci/vfio_pci_intrs.c
+++ b/drivers/vfio/pci/vfio_pci_intrs.c
@@ -76,9 +76,24 @@ static int virqfd_wakeup(wait_queue_t *wait, unsigned mode, int sync, void *key)
                         schedule_work(&virqfd->inject);
         }
 
-        if (flags & POLLHUP)
-                /* The eventfd is closing, detach from VFIO */
-                virqfd_deactivate(virqfd);
+        if (flags & POLLHUP) {
+                unsigned long flags;
+                spin_lock_irqsave(&virqfd->vdev->irqlock, flags);
+
+                /*
+                 * The eventfd is closing, if the virqfd has not yet been
+                 * queued for release, as determined by testing whether the
+                 * vdev pointer to it is still valid, queue it now.  As
+                 * with kvm irqfds, we know we won't race against the virqfd
+                 * going away because we hold wqh->lock to get here.
+                 */
+                if (*(virqfd->pvirqfd) == virqfd) {
+                        *(virqfd->pvirqfd) = NULL;
+                        virqfd_deactivate(virqfd);
+                }
+
+                spin_unlock_irqrestore(&virqfd->vdev->irqlock, flags);
+        }
 
         return 0;
 }
@@ -93,7 +108,6 @@ static void virqfd_ptable_queue_proc(struct file *file,
 static void virqfd_shutdown(struct work_struct *work)
 {
         struct virqfd *virqfd = container_of(work, struct virqfd, shutdown);
-        struct virqfd **pvirqfd = virqfd->pvirqfd;
         u64 cnt;
 
         eventfd_ctx_remove_wait_queue(virqfd->eventfd, &virqfd->wait, &cnt);
@@ -101,7 +115,6 @@ static void virqfd_shutdown(struct work_struct *work)
         eventfd_ctx_put(virqfd->eventfd);
 
         kfree(virqfd);
-        *pvirqfd = NULL;
 }
 
 static void virqfd_inject(struct work_struct *work)
@@ -122,15 +135,11 @@ static int virqfd_enable(struct vfio_pci_device *vdev,
         int ret = 0;
         unsigned int events;
 
-        if (*pvirqfd)
-                return -EBUSY;
-
         virqfd = kzalloc(sizeof(*virqfd), GFP_KERNEL);
         if (!virqfd)
                 return -ENOMEM;
 
         virqfd->pvirqfd = pvirqfd;
-        *pvirqfd = virqfd;
         virqfd->vdev = vdev;
         virqfd->handler = handler;
         virqfd->thread = thread;
@@ -154,6 +163,23 @@ static int virqfd_enable(struct vfio_pci_device *vdev,
         virqfd->eventfd = ctx;
 
         /*
+         * virqfds can be released by closing the eventfd or directly
+         * through ioctl.  These are both done through a workqueue, so
+         * we update the pointer to the virqfd under lock to avoid
+         * pushing multiple jobs to release the same virqfd.
+         */
+        spin_lock_irq(&vdev->irqlock);
+
+        if (*pvirqfd) {
+                spin_unlock_irq(&vdev->irqlock);
+                ret = -EBUSY;
+                goto fail;
+        }
+        *pvirqfd = virqfd;
+
+        spin_unlock_irq(&vdev->irqlock);
+
+        /*
          * Install our own custom wake-up handling so we are notified via
          * a callback whenever someone signals the underlying eventfd.
          */
@@ -187,19 +213,29 @@ fail:
                 fput(file);
 
         kfree(virqfd);
-        *pvirqfd = NULL;
 
         return ret;
 }
 
-static void virqfd_disable(struct virqfd *virqfd)
+static void virqfd_disable(struct vfio_pci_device *vdev,
+                           struct virqfd **pvirqfd)
 {
-        if (!virqfd)
-                return;
+        unsigned long flags;
+
+        spin_lock_irqsave(&vdev->irqlock, flags);
+
+        if (*pvirqfd) {
+                virqfd_deactivate(*pvirqfd);
+                *pvirqfd = NULL;
+        }
 
-        virqfd_deactivate(virqfd);
+        spin_unlock_irqrestore(&vdev->irqlock, flags);
 
-        /* Block until we know all outstanding shutdown jobs have completed. */
+        /*
+         * Block until we know all outstanding shutdown jobs have completed.
+         * Even if we don't queue the job, flush the wq to be sure it's
+         * been released.
+         */
         flush_workqueue(vfio_irqfd_cleanup_wq);
 }
 
@@ -392,8 +428,8 @@ static int vfio_intx_set_signal(struct vfio_pci_device *vdev, int fd)
 static void vfio_intx_disable(struct vfio_pci_device *vdev)
 {
         vfio_intx_set_signal(vdev, -1);
-        virqfd_disable(vdev->ctx[0].unmask);
-        virqfd_disable(vdev->ctx[0].mask);
+        virqfd_disable(vdev, &vdev->ctx[0].unmask);
+        virqfd_disable(vdev, &vdev->ctx[0].mask);
         vdev->irq_type = VFIO_PCI_NUM_IRQS;
         vdev->num_ctx = 0;
         kfree(vdev->ctx);
@@ -539,8 +575,8 @@ static void vfio_msi_disable(struct vfio_pci_device *vdev, bool msix)
         vfio_msi_set_block(vdev, 0, vdev->num_ctx, NULL, msix);
 
         for (i = 0; i < vdev->num_ctx; i++) {
-                virqfd_disable(vdev->ctx[i].unmask);
-                virqfd_disable(vdev->ctx[i].mask);
+                virqfd_disable(vdev, &vdev->ctx[i].unmask);
+                virqfd_disable(vdev, &vdev->ctx[i].mask);
         }
 
         if (msix) {
@@ -577,7 +613,7 @@ static int vfio_pci_set_intx_unmask(struct vfio_pci_device *vdev,
                                              vfio_send_intx_eventfd, NULL,
                                              &vdev->ctx[0].unmask, fd);
 
-                virqfd_disable(vdev->ctx[0].unmask);
+                virqfd_disable(vdev, &vdev->ctx[0].unmask);
         }
 
         return 0;
diff --git a/fs/dcache.c b/fs/dcache.c
index 16521a9f2038..693f95bf1cae 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1134,6 +1134,8 @@ positive:
         return 1;
 
 rename_retry:
+        if (locked)
+                goto again;
         locked = 1;
         write_seqlock(&rename_lock);
         goto again;
@@ -1141,7 +1143,7 @@ rename_retry:
 EXPORT_SYMBOL(have_submounts);
 
 /*
- * Search the dentry child list for the specified parent,
+ * Search the dentry child list of the specified parent,
  * and move any unused dentries to the end of the unused
  * list for prune_dcache(). We descend to the next level
  * whenever the d_subdirs list is non-empty and continue
@@ -1236,6 +1238,8 @@ out:
 rename_retry:
         if (found)
                 return found;
+        if (locked)
+                goto again;
         locked = 1;
         write_seqlock(&rename_lock);
         goto again;
@@ -3035,6 +3039,8 @@ resume:
         return;
 
 rename_retry:
+        if (locked)
+                goto again;
         locked = 1;
         write_seqlock(&rename_lock);
         goto again;
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index fb1a2bedbe97..8d80c990dffd 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -289,7 +289,6 @@ static void nlmsvc_free_block(struct kref *kref)
         dprintk("lockd: freeing block %p...\n", block);
 
         /* Remove block from file's list of blocks */
-        mutex_lock(&file->f_mutex);
         list_del_init(&block->b_flist);
         mutex_unlock(&file->f_mutex);
 
@@ -303,7 +302,7 @@ static void nlmsvc_free_block(struct kref *kref)
 static void nlmsvc_release_block(struct nlm_block *block)
 {
         if (block != NULL)
-                kref_put(&block->b_count, nlmsvc_free_block);
+                kref_put_mutex(&block->b_count, nlmsvc_free_block, &block->b_file->f_mutex);
 }
 
 /*
diff --git a/fs/namespace.c b/fs/namespace.c
index 4d31f73e2561..7bdf7907413f 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1886,8 +1886,14 @@ static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
                 return err;
 
         err = -EINVAL;
-        if (!(mnt_flags & MNT_SHRINKABLE) && !check_mnt(real_mount(path->mnt)))
-                goto unlock;
+        if (unlikely(!check_mnt(real_mount(path->mnt)))) {
+                /* that's acceptable only for automounts done in private ns */
+                if (!(mnt_flags & MNT_SHRINKABLE))
+                        goto unlock;
+                /* ... and for those we'd better have mountpoint still alive */
+                if (!real_mount(path->mnt)->mnt_ns)
+                        goto unlock;
+        }
 
         /* Refuse the same filesystem on the same mount point */
         err = -EBUSY;
diff --git a/include/asm-generic/unistd.h b/include/asm-generic/unistd.h
index 991ef01cd77e..3748ec92dcbc 100644
--- a/include/asm-generic/unistd.h
+++ b/include/asm-generic/unistd.h
@@ -691,9 +691,11 @@ __SC_COMP(__NR_process_vm_readv, sys_process_vm_readv, \
 #define __NR_process_vm_writev 271
 __SC_COMP(__NR_process_vm_writev, sys_process_vm_writev, \
           compat_sys_process_vm_writev)
+#define __NR_kcmp 272
+__SYSCALL(__NR_kcmp, sys_kcmp)
 
 #undef __NR_syscalls
-#define __NR_syscalls 272
+#define __NR_syscalls 273
 
 /*
  * All syscalls below here should go away really,
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 7e83370e6fd2..f3b99e1c1042 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -256,72 +256,78 @@ static inline void iommu_set_fault_handler(struct iommu_domain *domain,
 {
 }
 
-int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
+static inline int iommu_attach_group(struct iommu_domain *domain,
+                                     struct iommu_group *group)
 {
         return -ENODEV;
 }
 
-void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
+static inline void iommu_detach_group(struct iommu_domain *domain,
+                                      struct iommu_group *group)
 {
 }
 
-struct iommu_group *iommu_group_alloc(void)
+static inline struct iommu_group *iommu_group_alloc(void)
 {
         return ERR_PTR(-ENODEV);
 }
 
-void *iommu_group_get_iommudata(struct iommu_group *group)
+static inline void *iommu_group_get_iommudata(struct iommu_group *group)
 {
         return NULL;
 }
 
-void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
-                               void (*release)(void *iommu_data))
+static inline void iommu_group_set_iommudata(struct iommu_group *group,
+                                             void *iommu_data,
+                                             void (*release)(void *iommu_data))
 {
 }
 
-int iommu_group_set_name(struct iommu_group *group, const char *name)
+static inline int iommu_group_set_name(struct iommu_group *group,
+                                       const char *name)
 {
         return -ENODEV;
 }
 
-int iommu_group_add_device(struct iommu_group *group, struct device *dev)
+static inline int iommu_group_add_device(struct iommu_group *group,
+                                         struct device *dev)
 {
         return -ENODEV;
 }
 
-void iommu_group_remove_device(struct device *dev)
+static inline void iommu_group_remove_device(struct device *dev)
 {
 }
 
-int iommu_group_for_each_dev(struct iommu_group *group, void *data,
-                             int (*fn)(struct device *, void *))
+static inline int iommu_group_for_each_dev(struct iommu_group *group,
+                                           void *data,
+                                           int (*fn)(struct device *, void *))
 {
         return -ENODEV;
 }
 
-struct iommu_group *iommu_group_get(struct device *dev)
+static inline struct iommu_group *iommu_group_get(struct device *dev)
 {
         return NULL;
 }
 
-void iommu_group_put(struct iommu_group *group)
+static inline void iommu_group_put(struct iommu_group *group)
 {
 }
 
-int iommu_group_register_notifier(struct iommu_group *group,
-                                  struct notifier_block *nb)
+static inline int iommu_group_register_notifier(struct iommu_group *group,
+                                                struct notifier_block *nb)
 {
         return -ENODEV;
 }
 
-int iommu_group_unregister_notifier(struct iommu_group *group,
-                                    struct notifier_block *nb)
+static inline int iommu_group_unregister_notifier(struct iommu_group *group,
+                                                  struct notifier_block *nb)
 {
         return 0;
 }
 
-int iommu_group_id(struct iommu_group *group)
+static inline int iommu_group_id(struct iommu_group *group)
 {
         return -ENODEV;
 }
diff --git a/include/linux/micrel_phy.h b/include/linux/micrel_phy.h
index 61f0905bdc48..de201203bc7c 100644
--- a/include/linux/micrel_phy.h
+++ b/include/linux/micrel_phy.h
@@ -1,3 +1,15 @@
+/*
+ * include/linux/micrel_phy.h
+ *
+ * Micrel PHY IDs
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
 #ifndef _MICREL_PHY_H
 #define _MICREL_PHY_H
 
@@ -5,10 +17,11 @@
 
 #define PHY_ID_KSZ9021          0x00221610
 #define PHY_ID_KS8737           0x00221720
-#define PHY_ID_KS8041           0x00221510
-#define PHY_ID_KS8051           0x00221550
+#define PHY_ID_KSZ8021          0x00221555
+#define PHY_ID_KSZ8041          0x00221510
+#define PHY_ID_KSZ8051          0x00221550
 /* both for ks8001 Rev. A/B, and for ks8721 Rev 3. */
-#define PHY_ID_KS8001           0x0022161A
+#define PHY_ID_KSZ8001          0x0022161A
 
 /* struct phy_device dev_flags definitions */
 #define MICREL_PHY_50MHZ_CLK    0x00000001
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 9490a00529f4..c25cccaa555a 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -35,8 +35,10 @@ struct nvme_bar {
         __u64                   acq;    /* Admin CQ Base Address */
 };
 
+#define NVME_CAP_MQES(cap)      ((cap) & 0xffff)
 #define NVME_CAP_TIMEOUT(cap)   (((cap) >> 24) & 0xff)
 #define NVME_CAP_STRIDE(cap)    (((cap) >> 32) & 0xf)
+#define NVME_CAP_MPSMIN(cap)    (((cap) >> 48) & 0xf)
 
 enum {
         NVME_CC_ENABLE          = 1 << 0,
diff --git a/include/linux/security.h b/include/linux/security.h
index 3dea6a9d568f..d143b8e01954 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -118,6 +118,7 @@ void reset_security_ops(void);
 extern unsigned long mmap_min_addr;
 extern unsigned long dac_mmap_min_addr;
 #else
+#define mmap_min_addr           0UL
 #define dac_mmap_min_addr       0UL
 #endif
 
diff --git a/lib/flex_proportions.c b/lib/flex_proportions.c
index c785554f9523..ebf3bac460b0 100644
--- a/lib/flex_proportions.c
+++ b/lib/flex_proportions.c
@@ -62,7 +62,7 @@ void fprop_global_destroy(struct fprop_global *p)
  */
 bool fprop_new_period(struct fprop_global *p, int periods)
 {
-        u64 events;
+        s64 events;
         unsigned long flags;
 
         local_irq_save(flags);
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 57c4b9309015..141dbb695097 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1811,7 +1811,6 @@ static void __collapse_huge_page_copy(pte_t *pte, struct page *page,
                         src_page = pte_page(pteval);
                         copy_user_highpage(page, src_page, address, vma);
                         VM_BUG_ON(page_mapcount(src_page) != 1);
-                        VM_BUG_ON(page_count(src_page) != 2);
                         release_pte_page(src_page);
                         /*
                          * ptl mostly unnecessary, but preempt has to
diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index e877af8bdd1e..469daabd90c7 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -642,7 +642,8 @@ batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
         struct batadv_neigh_node *router = NULL;
         struct batadv_orig_node *orig_node_tmp;
         struct hlist_node *node;
-        uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
+        int if_num;
+        uint8_t sum_orig, sum_neigh;
         uint8_t *neigh_addr;
 
         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
@@ -727,17 +728,17 @@ batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
         if (router && (neigh_node->tq_avg == router->tq_avg)) {
                 orig_node_tmp = router->orig_node;
                 spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
-                bcast_own_sum_orig =
-                        orig_node_tmp->bcast_own_sum[if_incoming->if_num];
+                if_num = router->if_incoming->if_num;
+                sum_orig = orig_node_tmp->bcast_own_sum[if_num];
                 spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
 
                 orig_node_tmp = neigh_node->orig_node;
                 spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
-                bcast_own_sum_neigh =
-                        orig_node_tmp->bcast_own_sum[if_incoming->if_num];
+                if_num = neigh_node->if_incoming->if_num;
+                sum_neigh = orig_node_tmp->bcast_own_sum[if_num];
                 spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
 
-                if (bcast_own_sum_orig >= bcast_own_sum_neigh)
+                if (sum_orig >= sum_neigh)
                         goto update_tt;
         }
 
diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c
index 109ea2aae96c..21c53577c8d6 100644
--- a/net/batman-adv/soft-interface.c
+++ b/net/batman-adv/soft-interface.c
@@ -100,18 +100,21 @@ static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
 {
         struct batadv_priv *bat_priv = netdev_priv(dev);
         struct sockaddr *addr = p;
+        uint8_t old_addr[ETH_ALEN];
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
+        memcpy(old_addr, dev->dev_addr, ETH_ALEN);
+        memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
+
         /* only modify transtable if it has been initialized before */
         if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) {
-                batadv_tt_local_remove(bat_priv, dev->dev_addr,
+                batadv_tt_local_remove(bat_priv, old_addr,
                                        "mac address changed", false);
                 batadv_tt_local_add(dev, addr->sa_data, BATADV_NULL_IFINDEX);
         }
 
-        memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
         dev->addr_assign_type &= ~NET_ADDR_RANDOM;
         return 0;
 }
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index d4de5db18d5a..0b997c8f9655 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -734,6 +734,8 @@ static int hci_dev_do_close(struct hci_dev *hdev)
 
         cancel_work_sync(&hdev->le_scan);
 
+        cancel_delayed_work(&hdev->power_off);
+
         hci_req_cancel(hdev, ENODEV);
         hci_req_lock(hdev);
 
diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
index 4ea1710a4783..38c00f142203 100644
--- a/net/bluetooth/l2cap_core.c
+++ b/net/bluetooth/l2cap_core.c
@@ -1008,7 +1008,7 @@ static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *c
         if (!conn)
                 return;
 
-        if (chan->mode == L2CAP_MODE_ERTM) {
+        if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) {
                 __clear_retrans_timer(chan);
                 __clear_monitor_timer(chan);
                 __clear_ack_timer(chan);
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index ad6613d17ca6..eba022de3c20 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -2875,6 +2875,22 @@ int mgmt_powered(struct hci_dev *hdev, u8 powered)
                 if (scan)
                         hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
 
+                if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
+                        u8 ssp = 1;
+
+                        hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, 1, &ssp);
+                }
+
+                if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
+                        struct hci_cp_write_le_host_supported cp;
+
+                        cp.le = 1;
+                        cp.simul = !!(hdev->features[6] & LMP_SIMUL_LE_BR);
+
+                        hci_send_cmd(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED,
+                                     sizeof(cp), &cp);
+                }
+
                 update_class(hdev);
                 update_name(hdev, hdev->dev_name);
                 update_eir(hdev);
diff --git a/net/ceph/messenger.c b/net/ceph/messenger.c
index 24c5eea8c45b..159aa8bef9e7 100644
--- a/net/ceph/messenger.c
+++ b/net/ceph/messenger.c
@@ -1073,16 +1073,13 @@ static int write_partial_msg_pages(struct ceph_connection *con)
                         BUG_ON(kaddr == NULL);
                         base = kaddr + con->out_msg_pos.page_pos + bio_offset;
                         crc = crc32c(crc, base, len);
+                        kunmap(page);
                         msg->footer.data_crc = cpu_to_le32(crc);
                         con->out_msg_pos.did_page_crc = true;
                 }
                 ret = ceph_tcp_sendpage(con->sock, page,
                                       con->out_msg_pos.page_pos + bio_offset,
                                       len, 1);
-
-                if (do_datacrc)
-                        kunmap(page);
-
                 if (ret <= 0)
                         goto out;
 
diff --git a/net/core/sock.c b/net/core/sock.c
index 305792076121..a6000fbad294 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -691,7 +691,8 @@ set_rcvbuf:
 
         case SO_KEEPALIVE:
 #ifdef CONFIG_INET
-                if (sk->sk_protocol == IPPROTO_TCP)
+                if (sk->sk_protocol == IPPROTO_TCP &&
+                    sk->sk_type == SOCK_STREAM)
                         tcp_set_keepalive(sk, valbool);
 #endif
                 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c
index e1e0a4e8fd34..c7527f6b9ad9 100644
--- a/net/ipv4/inetpeer.c
+++ b/net/ipv4/inetpeer.c
@@ -510,7 +510,10 @@ relookup:
                                         secure_ipv6_id(daddr->addr.a6));
                 p->metrics[RTAX_LOCK-1] = INETPEER_METRICS_NEW;
                 p->rate_tokens = 0;
-                p->rate_last = 0;
+                /* 60*HZ is arbitrary, but chosen enough high so that the first
+                 * calculation of tokens is at its maximum.
+                 */
+                p->rate_last = jiffies - 60*HZ;
                 INIT_LIST_HEAD(&p->gc_list);
 
                 /* Link the node. */
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index ff0f071969ea..d23c6571ba1c 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -131,18 +131,20 @@ found:
  *      0 - deliver
  *      1 - block
  */
-static __inline__ int icmp_filter(struct sock *sk, struct sk_buff *skb)
+static int icmp_filter(const struct sock *sk, const struct sk_buff *skb)
 {
-        int type;
+        struct icmphdr _hdr;
+        const struct icmphdr *hdr;
 
-        if (!pskb_may_pull(skb, sizeof(struct icmphdr)))
+        hdr = skb_header_pointer(skb, skb_transport_offset(skb),
+                                 sizeof(_hdr), &_hdr);
+        if (!hdr)
                 return 1;
 
-        type = icmp_hdr(skb)->type;
-        if (type < 32) {
+        if (hdr->type < 32) {
                 __u32 data = raw_sk(sk)->filter.data;
 
-                return ((1 << type) & data) != 0;
+                return ((1U << hdr->type) & data) != 0;
         }
 
         /* Do not block unknown ICMP types */
diff --git a/net/ipv6/mip6.c b/net/ipv6/mip6.c
index 5b087c31d87b..0f9bdc5ee9f3 100644
--- a/net/ipv6/mip6.c
+++ b/net/ipv6/mip6.c
@@ -86,28 +86,30 @@ static int mip6_mh_len(int type)
 
 static int mip6_mh_filter(struct sock *sk, struct sk_buff *skb)
 {
-        struct ip6_mh *mh;
+        struct ip6_mh _hdr;
+        const struct ip6_mh *mh;
 
-        if (!pskb_may_pull(skb, (skb_transport_offset(skb)) + 8) ||
-            !pskb_may_pull(skb, (skb_transport_offset(skb) +
-                                 ((skb_transport_header(skb)[1] + 1) << 3))))
+        mh = skb_header_pointer(skb, skb_transport_offset(skb),
+                                sizeof(_hdr), &_hdr);
+        if (!mh)
                 return -1;
 
-        mh = (struct ip6_mh *)skb_transport_header(skb);
+        if (((mh->ip6mh_hdrlen + 1) << 3) > skb->len)
+                return -1;
 
         if (mh->ip6mh_hdrlen < mip6_mh_len(mh->ip6mh_type)) {
                 LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH message too short: %d vs >=%d\n",
                                mh->ip6mh_hdrlen, mip6_mh_len(mh->ip6mh_type));
-                mip6_param_prob(skb, 0, ((&mh->ip6mh_hdrlen) -
-                                         skb_network_header(skb)));
+                mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_hdrlen) +
+                                skb_network_header_len(skb));
                 return -1;
         }
 
         if (mh->ip6mh_proto != IPPROTO_NONE) {
                 LIMIT_NETDEBUG(KERN_DEBUG "mip6: MH invalid payload proto = %d\n",
                                mh->ip6mh_proto);
-                mip6_param_prob(skb, 0, ((&mh->ip6mh_proto) -
-                                         skb_network_header(skb)));
+                mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_proto) +
+                                skb_network_header_len(skb));
                 return -1;
         }
 
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index ef0579d5bca6..4a5f78b50495 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -107,21 +107,20 @@ found:
  *      0 - deliver
  *      1 - block
  */
-static __inline__ int icmpv6_filter(struct sock *sk, struct sk_buff *skb)
+static int icmpv6_filter(const struct sock *sk, const struct sk_buff *skb)
 {
-        struct icmp6hdr *icmph;
-        struct raw6_sock *rp = raw6_sk(sk);
-
-        if (pskb_may_pull(skb, sizeof(struct icmp6hdr))) {
-                __u32 *data = &rp->filter.data[0];
-                int bit_nr;
+        struct icmp6hdr *_hdr;
+        const struct icmp6hdr *hdr;
 
-                icmph = (struct icmp6hdr *) skb->data;
-                bit_nr = icmph->icmp6_type;
+        hdr = skb_header_pointer(skb, skb_transport_offset(skb),
+                                 sizeof(_hdr), &_hdr);
+        if (hdr) {
+                const __u32 *data = &raw6_sk(sk)->filter.data[0];
+                unsigned int type = hdr->icmp6_type;
 
-                return (data[bit_nr >> 5] & (1 << (bit_nr & 31))) != 0;
+                return (data[type >> 5] & (1U << (type & 31))) != 0;
         }
-        return 0;
+        return 1;
 }
 
 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
diff --git a/net/l2tp/l2tp_netlink.c b/net/l2tp/l2tp_netlink.c
index d71cd9229a47..6f936358d664 100644
--- a/net/l2tp/l2tp_netlink.c
+++ b/net/l2tp/l2tp_netlink.c
@@ -80,8 +80,8 @@ static int l2tp_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
 
         hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
                           &l2tp_nl_family, 0, L2TP_CMD_NOOP);
-        if (IS_ERR(hdr)) {
-                ret = PTR_ERR(hdr);
+        if (!hdr) {
+                ret = -EMSGSIZE;
                 goto err_out;
         }
 
@@ -250,8 +250,8 @@ static int l2tp_nl_tunnel_send(struct sk_buff *skb, u32 pid, u32 seq, int flags,
 
         hdr = genlmsg_put(skb, pid, seq, &l2tp_nl_family, flags,
                           L2TP_CMD_TUNNEL_GET);
-        if (IS_ERR(hdr))
-                return PTR_ERR(hdr);
+        if (!hdr)
+                return -EMSGSIZE;
 
         if (nla_put_u8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version) ||
             nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) ||
@@ -617,8 +617,8 @@ static int l2tp_nl_session_send(struct sk_buff *skb, u32 pid, u32 seq, int flags
         sk = tunnel->sock;
 
         hdr = genlmsg_put(skb, pid, seq, &l2tp_nl_family, flags, L2TP_CMD_SESSION_GET);
-        if (IS_ERR(hdr))
-                return PTR_ERR(hdr);
+        if (!hdr)
+                return -EMSGSIZE;
 
         if (nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) ||
             nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) ||
diff --git a/net/netfilter/xt_limit.c b/net/netfilter/xt_limit.c
index 5c22ce8ab309..a4c1e4528cac 100644
--- a/net/netfilter/xt_limit.c
+++ b/net/netfilter/xt_limit.c
@@ -117,11 +117,11 @@ static int limit_mt_check(const struct xt_mtchk_param *par)
 
         /* For SMP, we only want to use one set of state. */
         r->master = priv;
+        /* User avg in seconds * XT_LIMIT_SCALE: convert to jiffies *
+           128. */
+        priv->prev = jiffies;
+        priv->credit = user2credits(r->avg * r->burst); /* Credits full. */
         if (r->cost == 0) {
-                /* User avg in seconds * XT_LIMIT_SCALE: convert to jiffies *
-                   128. */
-                priv->prev = jiffies;
-                priv->credit = user2credits(r->avg * r->burst); /* Credits full. */
                 r->credit_cap = priv->credit; /* Credits full. */
                 r->cost = user2credits(r->avg);
         }
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 2ded3c7fad06..72d170ca3406 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -350,6 +350,9 @@ static void reg_regdb_search(struct work_struct *work)
         struct reg_regdb_search_request *request;
         const struct ieee80211_regdomain *curdom, *regdom;
         int i, r;
+        bool set_reg = false;
+
+        mutex_lock(&cfg80211_mutex);
 
         mutex_lock(&reg_regdb_search_mutex);
         while (!list_empty(&reg_regdb_search_list)) {
@@ -365,9 +368,7 @@ static void reg_regdb_search(struct work_struct *work)
                                 r = reg_copy_regd(&regdom, curdom);
                                 if (r)
                                         break;
-                                mutex_lock(&cfg80211_mutex);
-                                set_regdom(regdom);
-                                mutex_unlock(&cfg80211_mutex);
+                                set_reg = true;
                                 break;
                         }
                 }
@@ -375,6 +376,11 @@ static void reg_regdb_search(struct work_struct *work)
                 kfree(request);
         }
         mutex_unlock(&reg_regdb_search_mutex);
+
+        if (set_reg)
+                set_regdom(regdom);
+
+        mutex_unlock(&cfg80211_mutex);
 }
 
 static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
diff --git a/scripts/checksyscalls.sh b/scripts/checksyscalls.sh
index d24810fc6af6..fd8fa9aa7c4e 100755
--- a/scripts/checksyscalls.sh
+++ b/scripts/checksyscalls.sh
@@ -200,7 +200,7 @@ EOF
 syscall_list() {
     grep '^[0-9]' "$1" | sort -n | (
         while read nr abi name entry ; do
-            echo <<EOF
+            cat <<EOF
 #if !defined(__NR_${name}) && !defined(__IGNORE_${name})
 #warning syscall ${name} not implemented
 #endif
diff --git a/sound/soc/codecs/wm2000.c b/sound/soc/codecs/wm2000.c
index 3fd5b29dc933..a3acb7a85f6a 100644
--- a/sound/soc/codecs/wm2000.c
+++ b/sound/soc/codecs/wm2000.c
@@ -702,7 +702,7 @@ static bool wm2000_readable_reg(struct device *dev, unsigned int reg)
 }
 
 static const struct regmap_config wm2000_regmap = {
-        .reg_bits = 8,
+        .reg_bits = 16,
         .val_bits = 8,
 
         .max_register = WM2000_REG_IF_CTL,
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index d6e2bb49c59c..060dccb9ec75 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -197,7 +197,13 @@ static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
                         /* no data provider, so send silence */
                         unsigned int offs = 0;
                         for (i = 0; i < ctx->packets; ++i) {
-                                int counts = ctx->packet_size[i];
+                                int counts;
+
+                                if (ctx->packet_size[i])
+                                        counts = ctx->packet_size[i];
+                                else
+                                        counts = snd_usb_endpoint_next_packet_size(ep);
+
                                 urb->iso_frame_desc[i].offset = offs * ep->stride;
                                 urb->iso_frame_desc[i].length = counts * ep->stride;
                                 offs += counts;