summaryrefslogtreecommitdiff
path: root/linux-core/drm_vm.c
AgeCommit message (Collapse)Author
2008-10-06drm/radeon: fixup clean flag handlingDave Airlie
2008-08-26drm: add memory clean flag.Dave Airlie
When the mapping is clean this flag will be set. This can be used by a driver to save migrating and allocating pages for an object that will first be used in VRAM.
2008-08-14Merge branch 'radeon-gem-cs' into modesetting-gemDave Airlie
Conflicts: libdrm/xf86drm.c linux-core/Makefile.kernel linux-core/drmP.h linux-core/drm_compat.h linux-core/drm_drv.c linux-core/drm_stub.c linux-core/drm_vm.c shared-core/i915_dma.c shared-core/r300_cmdbuf.c shared-core/radeon_drv.h
2008-08-11drm_vm: fix for build on 2.6.22Dave Airlie
thanks to malc0 for pointing it out
2008-07-31drm: userspace rip out TTM APIDave Airlie
2008-07-31drm: add fault handler support so as to be more like possible upstreamDave Airlie
2008-07-31drm: add fault handler support so as to be more like possible upstreamDave Airlie
(cherry picked from commit 10d5b037b85706037df89bf0275436797e4eb559)
2008-05-07drm: nopage compat fixup for drm_vmDave Airlie
The kernel has removed nopage so move the old nopage codepaths into a compat vm file and switch to using the fault paths. nopfn is on its way out in the future also, so we should switch to using fault for that path as well soon
2008-04-23Fixed unlock check on EAGAINJakob Bornecrantz
2008-04-14Unlock the BO mutex while waiting for idle, unmapped, unfenced.Thomas Hellstrom
Move unfenced checking into idle checking. Never time out while waiting for software events like unmapped or unfenced.
2008-04-14Fix up buffer manager locking.Thomas Hellstrom
2008-03-05drm: Fix for non-coherent DMA PowerPCBenjamin Herrenschmidt
This patch fixes bits of the DRM so to make the radeon DRI work on non-cache coherent PCI DMA variants of the PowerPC processors. It moves the few places that needs change to wrappers to that other architectures with similar issues can easily add their own changes to those wrappers, at least until we have more useful generic kernel API. Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2008-03-06drm: reorganise minor number handling using code from modesetting branchDave Airlie
Rip out the whole head thing and replace it with an idr and drm_minor structure.
2008-01-03drm: cleanup DRM_DEBUG() parametersMárton Németh
As DRM_DEBUG macro already prints out the __FUNCTION__ string (see drivers/char/drm/drmP.h), it is not worth doing this again. At some other places the ending "\n" was added. airlied:- I cleaned up a few that this patch missed also
2007-12-21Rename inappropriately named 'mask' fields to 'proposed_flags' instead.Keith Packard
Flags pending validation were stored in a misleadingly named field, 'mask'. As 'mask' is already used to indicate pieces of a flags field which are changing, it seems better to use a name reflecting the actual purpose of this field. I chose 'proposed_flags' as they may not actually end up in 'flags', and in an case will be modified when they are moved over. This affects the API, but not ABI of the user-mode interface.
2007-11-22drm: major whitespace/coding style realignment with kernelDave Airlie
2007-11-05drm: more kernel coding style cleanupsDave Airlie
2007-10-21Remove the need for the hardware lock in the buffer manager.Thomas Hellstrom
Add interface entry cleaning a memory type without touching NO_EVICT buffers.
2007-07-20Replace filp in ioctl arguments with drm_file *file_priv.Eric Anholt
As a fallout, replace filp storage with file_priv storage for "unique identifier of a client" all over the DRM. There is a 1:1 mapping, so this should be a noop. This could be a minor performance improvement, as everything on Linux dereferenced filp to get file_priv anyway, while only the mmap ioctls went the other direction.
2007-07-16drm: detypedef ttm/bo/fence codeDave Airlie
2007-07-16drm: remove drmP.h internal typedefsDave Airlie
2007-07-16drm: detypedef drm.h and fixup all problemsDave Airlie
2007-06-29Fence object reference / dereference cleanup.Thomas Hellstrom
Buffer object dereference cleanup. Add a struct drm_device member to fence objects: This can simplify code, particularly in drivers.
2007-05-26drm: cleanup use of Linux list handling macrosDave Airlie
This makes the drms use of the list handling macros a lot cleaner and more along the lines of how they should be used.
2007-04-26linux: minor indent.George Sapountzis
2007-04-26drm: nopfn warning on 64-bitDave Airlie
2007-04-03Make sure CMA (Can't map aperture) pages are mapped uncached.Thomas Hellstrom
(Should really make this write-combined using PATs, at some point).
2007-03-24vm: cleanup drm_vm.c along lines of cleanups queued for kernelDave Airlie
2007-03-23cleanup more whitespace from ttm mergeDave Airlie
2007-02-26Fix build for 2.6.21-rc1.Thomas Hellstrom
The vm subsystem of 2.6.21 is fully compatible with the buffer object vm code.
2007-02-14Set the drm bus map type for each buffer object memory type.Thomas Hellstrom
2007-02-14Rework buffer object vm code to use nopfn() for kernels >= 2.6.19.Thomas Hellstrom
2007-02-10Various bugfixes.Thomas Hellstrom
2007-02-09Fix evict_mutex locking range.Thomas Hellstrom
Implement unmappable buffers. (fault moves them to mappable when needed). Various bugfixes.
2007-02-08Fix mm_block leak.Thomas Hellstrom
Some other minor fixes.
2007-02-08Simplify external ttm page allocation.Thomas Hellstrom
Implement a memcpy fallback for copying between buffers.
2007-02-07Fix a stray unlock_kernel() in drm_vm.cThomas Hellstrom
Add a file for memory move helpers, drm_bo_move.c Implement generic memory move. Cached, no_move and unmapped memory temporarily broken.
2007-02-06Simplify pci map vs no pci map choice.Thomas Hellstrom
2007-02-02Make also later kernels work with buffer object vmThomas Hellstrom
and clean up some function names.
2007-02-02Make vm handle buffer objects instead of ttm objects.Thomas Hellstrom
Remove ttm objects. Make vm aware of PCI memory type buffer objects. (Only works for pre 2.6.16 kernels for now).
2007-02-01Fix missing ttm_open_vma call from previous commit.Thomas Hellstrom
Honour the ttm backend cant-use-aperture flag.
2007-02-01Protect drm_mmap against disappearing maps.Thomas Hellstrom
The map lists and hash tables are protected using dev->struct_mutex, but drm_mmap strangely never locked this mutex.
2007-01-08drm: remove drm_follow_page, and drm_ioremap and ioremapfreeChristoph Hellwig
This comes from the Re: [patch] paravirt: isolate module ops on lkml It needs some testing, please report any regressions caused. Signed-off-by: Dave Airlie <airlied@linux.ie>
2007-01-01make build against 2.6.20 hopefullyDave Airlie
2006-12-27Proper allocation of AGP pages for ttms.Thomas Hellstrom
2006-12-19Security fix. Zero pages before they are handed to user space.Thomas Hellstrom
TTM pages were not cleared when allocated and handed to user space. Sensitive information may leak.
2006-12-19drm: remove all 2.4 support for drm development tree.Dave Airlie
Bye bye 2.4 you served us well..
2006-12-19[SPARC]: Respect vm_page_prot in io_remap_page_range().Dave Airlie
Make sure the callers do a pgprot_noncached() on vma->vm_page_prot. Pointed out by Hugh Dickens. Signed-off-by: David S. Miller <davem@davemloft.net>
2006-12-19[PATCH] mm: incorrect VM_FAULT_OOM returns from driversDave Airlie
Some drivers are returning OOM when it is not in response to a memory shortage. Signed-off-by: Nick Piggin <npiggin@suse.de>
2006-10-30Bugzilla Bug #8819Thomas Hellstrom
Build fixes for powerpc. Reported by Katerina Barone-Adesi
' href='#n691'>691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
/*
 * 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"

#define IS_G80 ((dev_priv->chipset & 0xf0) == 0x50)

static void
nv50_graph_init_reset(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	uint32_t pmc_e = NV_PMC_ENABLE_PGRAPH | (1 << 21);

	DRM_DEBUG("\n");

	NV_WRITE(NV03_PMC_ENABLE, NV_READ(NV03_PMC_ENABLE) & ~pmc_e);
	NV_WRITE(NV03_PMC_ENABLE, NV_READ(NV03_PMC_ENABLE) |  pmc_e);
}

static void
nv50_graph_init_intr(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;

	DRM_DEBUG("\n");
	NV_WRITE(NV03_PGRAPH_INTR, 0xffffffff);
	NV_WRITE(0x400138, 0xffffffff);
	NV_WRITE(NV40_PGRAPH_INTR_EN, 0xffffffff);
}

static void
nv50_graph_init_regs__nv(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;

	DRM_DEBUG("\n");

	NV_WRITE(0x400804, 0xc0000000);
	NV_WRITE(0x406800, 0xc0000000);
	NV_WRITE(0x400c04, 0xc0000000);
	NV_WRITE(0x401804, 0xc0000000);
	NV_WRITE(0x405018, 0xc0000000);
	NV_WRITE(0x402000, 0xc0000000);

	NV_WRITE(0x400108, 0xffffffff);

	NV_WRITE(0x400824, 0x00004000);
	NV_WRITE(0x400500, 0x00010001);
}

static void
nv50_graph_init_regs(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;

	DRM_DEBUG("\n");

	NV_WRITE(NV04_PGRAPH_DEBUG_3, (1<<2) /* HW_CONTEXT_SWITCH_ENABLED */);
}

static uint32_t nv84_ctx_voodoo[] = {
	0x0070008e, 0x0070009c, 0x00200020, 0x00600008, 0x0050004c, 0x00400e89,
	0x00200000, 0x00600007, 0x00300000, 0x00c000ff, 0x00200000, 0x008000ff,
	0x00700009, 0x0041634d, 0x00402944, 0x00402905, 0x0040290d, 0x00413e06,
	0x00600005, 0x004015c5, 0x00600011, 0x0040270b, 0x004021c5, 0x00700000,
	0x00700081, 0x00600004, 0x0050004a, 0x00216f40, 0x00600007, 0x00c02801,
	0x0020002e, 0x00800001, 0x005000cb, 0x0090ffff, 0x0091ffff, 0x00200020,
	0x00600008, 0x0050004c, 0x00600009, 0x00413e45, 0x0041594d, 0x0070009d,
	0x00402dcf, 0x0070009f, 0x0050009f, 0x00402ac0, 0x00200200, 0x00600008,
	0x00402a4f, 0x00402ac0, 0x004030cc, 0x00700081, 0x00200000, 0x00600006,
	0x00700000, 0x00111bfc, 0x00700083, 0x00300000, 0x00216f40, 0x00600007,
	0x00c00b01, 0x0020001e, 0x00800001, 0x005000cb, 0x00c000ff, 0x00700080,
	0x00700083, 0x00200047, 0x00600006, 0x0011020a, 0x00200480, 0x00600007,
	0x00300000, 0x00c000ff, 0x00c800ff, 0x00414907, 0x00202916, 0x008000ff,
	0x0040508c, 0x005000cb, 0x00a0023f, 0x00200040, 0x00600006, 0x0070000f,
	0x00170202, 0x0011020a, 0x00200032, 0x0010020d, 0x001c0242, 0x00120302,
	0x00140402, 0x00180500, 0x00130509, 0x00150550, 0x00110605, 0x0020000f,
	0x00100607, 0x00110700, 0x00110900, 0x00120902, 0x00110a00, 0x00160b02,
	0x00120b28, 0x00140b2b, 0x00110c01, 0x00111400, 0x00111405, 0x00111407,
	0x00111409, 0x0011140b, 0x002000cb, 0x00101500, 0x0040790f, 0x0040794b,
	0x00214d40, 0x00600007, 0x0020043e, 0x008800ff, 0x0070008f, 0x0040798c,
	0x005000cb, 0x00000000, 0x0020002b, 0x00101a05, 0x00131c00, 0x00121c04,
	0x00141c20, 0x00111c25, 0x00131c40, 0x00121c44, 0x00141c60, 0x00111c65,
	0x00131c80, 0x00121c84, 0x00141ca0, 0x00111ca5, 0x00131cc0, 0x00121cc4,
	0x00141ce0, 0x00111ce5, 0x00131f00, 0x00191f40, 0x0040a1e0, 0x002001ed,
	0x00600006, 0x00200044, 0x00102080, 0x001120c6, 0x001520c9, 0x001920d0,
	0x00122100, 0x00122103, 0x00162200, 0x00122207, 0x00112280, 0x00112300,
	0x00112302, 0x00122380, 0x0011238b, 0x00112394, 0x0011239c, 0x0040bee1,
	0x00200254, 0x00600006, 0x00200044, 0x00102480, 0x0040af0f, 0x0040af4b,
	0x00214d40, 0x00600007, 0x0020043e, 0x008800ff, 0x0070008f, 0x0040af8c,
	0x005000cb, 0x00000000, 0x001124c6, 0x001524c9, 0x001924d0, 0x00122500,
	0x00122503, 0x00162600, 0x00122607, 0x00112680, 0x00112700, 0x00112702,
	0x00122780, 0x0011278b, 0x00112794, 0x0011279c, 0x0040d1e2, 0x002002bb,
	0x00600006, 0x00200044, 0x00102880, 0x001128c6, 0x001528c9, 0x001928d0,
	0x00122900, 0x00122903, 0x00162a00, 0x00122a07, 0x00112a80, 0x00112b00,
	0x00112b02, 0x00122b80, 0x00112b8b, 0x00112b94, 0x00112b9c, 0x0040eee3,
	0x00200322, 0x00600006, 0x00200044, 0x00102c80, 0x0040df0f, 0x0040df4b,
	0x00214d40, 0x00600007, 0x0020043e, 0x008800ff, 0x0070008f, 0x0040df8c,
	0x005000cb, 0x00000000, 0x00112cc6, 0x00152cc9, 0x00192cd0, 0x00122d00,
	0x00122d03, 0x00162e00, 0x00122e07, 0x00112e80, 0x00112f00, 0x00112f02,
	0x00122f80, 0x00112f8b, 0x00112f94, 0x00112f9c, 0x004101e4, 0x00200389,
	0x00600006, 0x00200044, 0x00103080, 0x001130c6, 0x001530c9, 0x001930d0,
	0x00123100, 0x00123103, 0x00163200, 0x00123207, 0x00113280, 0x00113300,
	0x00113302, 0x00123380, 0x0011338b, 0x00113394, 0x0011339c, 0x00411ee5,
	0x002003f0, 0x00600006, 0x00200044, 0x00103480, 0x00410f0f, 0x00410f4b,
	0x00214d40, 0x00600007, 0x0020043e, 0x008800ff, 0x0070008f, 0x00410f8c,
	0x005000cb, 0x00000000, 0x001134c6, 0x001534c9, 0x001934d0, 0x00123500,
	0x00123503, 0x00163600, 0x00123607, 0x00113680, 0x00113700, 0x00113702,
	0x00123780, 0x0011378b, 0x00113794, 0x0011379c, 0x00000000, 0x0041250f,
	0x005000cb, 0x00214d40, 0x00600007, 0x0020043e, 0x008800ff, 0x005000cb,
	0x00412887, 0x0060000a, 0x00000000, 0x00413700, 0x007000a0, 0x00700080,
	0x00200480, 0x00600007, 0x00200004, 0x00c000ff, 0x008000ff, 0x005000cb,
	0x00700000, 0x00200000, 0x00600006, 0x00111bfe, 0x0041594d, 0x00700000,
	0x00200000, 0x00600006, 0x00111bfe, 0x00700080, 0x0070001d, 0x0040114d,
	0x00700081, 0x00600004, 0x0050004a, 0x00414388, 0x0060000b, 0x00200000,
	0x00600006, 0x00700000, 0x0041590b, 0x00111bfd, 0x0040424d, 0x00202916,
	0x008000fd, 0x005000cb, 0x00c00002, 0x00200480, 0x00600007, 0x00200160,
	0x00800002, 0x005000cb, 0x00c01802, 0x002027b6, 0x00800002, 0x005000cb,
	0x00404e4d, 0x0060000b, 0x0041574d, 0x00700001, 0x005000cf, 0x00700003,
	0x00415e06, 0x00415f05, 0x0060000d, 0x00700005, 0x0070000d, 0x00700006,
	0x0070000b, 0x0070000e, 0x0070001c, 0x0060000c, ~0
};
 
static uint32_t nv86_ctx_voodoo[] = {
	0x0070008e, 0x0070009c, 0x00200020, 0x00600008, 0x0050004c, 0x00400e89,
	0x00200000, 0x00600007, 0x00300000, 0x00c000ff, 0x00200000, 0x008000ff,
	0x00700009, 0x0040dd4d, 0x00402944, 0x00402905, 0x0040290d, 0x0040b906,
	0x00600005, 0x004015c5, 0x00600011, 0x0040270b, 0x004021c5, 0x00700000,
	0x00700081, 0x00600004, 0x0050004a, 0x00216d80, 0x00600007, 0x00c02801,
	0x0020002e, 0x00800001, 0x005000cb, 0x0090ffff, 0x0091ffff, 0x00200020,
	0x00600008, 0x0050004c, 0x00600009, 0x0040b945, 0x0040d44d, 0x0070009d,
	0x00402dcf, 0x0070009f, 0x0050009f, 0x00402ac0, 0x00200200, 0x00600008,
	0x00402a4f, 0x00402ac0, 0x004030cc, 0x00700081, 0x00200000, 0x00600006,
	0x00700000, 0x00111bfc, 0x00700083, 0x00300000, 0x00216d80, 0x00600007,
	0x00c00b01, 0x0020001e, 0x00800001, 0x005000cb, 0x00c000ff, 0x00700080,
	0x00700083, 0x00200047, 0x00600006, 0x0011020a, 0x00200280, 0x00600007,
	0x00300000, 0x00c000ff, 0x00c800ff, 0x0040c407, 0x00202916, 0x008000ff,
	0x0040508c, 0x005000cb, 0x00a0023f, 0x00200040, 0x00600006, 0x0070000f,
	0x00170202, 0x0011020a, 0x00200032, 0x0010020d, 0x001c0242, 0x00120302,
	0x00140402, 0x00180500, 0x00130509, 0x00150550, 0x00110605, 0x0020000f,
	0x00100607, 0x00110700, 0x00110900, 0x00120902, 0x00110a00, 0x00160b02,
	0x00120b28, 0x00140b2b, 0x00110c01, 0x00111400, 0x00111405, 0x00111407,
	0x00111409, 0x0011140b, 0x002000cb, 0x00101500, 0x0040790f, 0x0040794b,
	0x00214b40, 0x00600007, 0x00200442, 0x008800ff, 0x0070008f, 0x0040798c,
	0x005000cb, 0x00000000, 0x0020002b, 0x00101a05, 0x00131c00, 0x00121c04,
	0x00141c20, 0x00111c25, 0x00131c40, 0x00121c44, 0x00141c60, 0x00111c65,
	0x00131f00, 0x00191f40, 0x004099e0, 0x002001d9, 0x00600006, 0x00200044,
	0x00102080, 0x001120c6, 0x001520c9, 0x001920d0, 0x00122100, 0x00122103,
	0x00162200, 0x00122207, 0x00112280, 0x00112300, 0x00112302, 0x00122380,
	0x0011238b, 0x00112394, 0x0011239c, 0x00000000, 0x0040a00f, 0x005000cb,
	0x00214b40, 0x00600007, 0x00200442, 0x008800ff, 0x005000cb, 0x0040a387,
	0x0060000a, 0x00000000, 0x0040b200, 0x007000a0, 0x00700080, 0x00200280,
	0x00600007, 0x00200004, 0x00c000ff, 0x008000ff, 0x005000cb, 0x00700000,
	0x00200000, 0x00600006, 0x00111bfe, 0x0040d44d, 0x00700000, 0x00200000,
	0x00600006, 0x00111bfe, 0x00700080, 0x0070001d, 0x0040114d, 0x00700081,
	0x00600004, 0x0050004a, 0x0040be88, 0x0060000b, 0x00200000, 0x00600006,
	0x00700000, 0x0040d40b, 0x00111bfd, 0x0040424d, 0x00202916, 0x008000fd,
	0x005000cb, 0x00c00002, 0x00200280, 0x00600007, 0x00200160, 0x00800002,
	0x005000cb, 0x00c01802, 0x002027b6, 0x00800002, 0x005000cb, 0x00404e4d,
	0x0060000b, 0x0040d24d, 0x00700001, 0x00700003, 0x0040d806, 0x0040d905,
	0x0060000d, 0x00700005, 0x0070000d, 0x00700006, 0x0070000b, 0x0070000e,
	0x0060000c, ~0
};

static int
nv50_graph_init_ctxctl(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	uint32_t *voodoo = NULL;

	DRM_DEBUG("\n");

	switch (dev_priv->chipset) {
	case 0x84:
		voodoo = nv84_ctx_voodoo;
		break;
	case 0x86:
		voodoo = nv86_ctx_voodoo;
		break;
	default:
		DRM_ERROR("no voodoo for chipset NV%02x\n", dev_priv->chipset);
		return -EINVAL;
	}

	NV_WRITE(NV40_PGRAPH_CTXCTL_UCODE_INDEX, 0);
	while (*voodoo != ~0) {
		NV_WRITE(NV40_PGRAPH_CTXCTL_UCODE_DATA, *voodoo);
		voodoo++;
	}

	NV_WRITE(0x400320, 4);
	NV_WRITE(NV40_PGRAPH_CTXCTL_CUR, 0);
	NV_WRITE(NV20_PGRAPH_CHANNEL_CTX_POINTER, 0);

	return 0;
}

int
nv50_graph_init(struct drm_device *dev)
{
	int ret;

	DRM_DEBUG("\n");

	nv50_graph_init_reset(dev);
	nv50_graph_init_intr(dev);
	nv50_graph_init_regs__nv(dev);
	nv50_graph_init_regs(dev);

	ret = nv50_graph_init_ctxctl(dev);
	if (ret)
		return ret;

	return 0;
}

void
nv50_graph_takedown(struct drm_device *dev)
{
	DRM_DEBUG("\n");
}

static void
nv86_graph_init_ctxvals(struct drm_device *dev, struct nouveau_gpuobj_ref *ref)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_gpuobj *ctx = ref->gpuobj;

	INSTANCE_WR(ctx, 0x0/4, 0x1);
	INSTANCE_WR(ctx, 0x10C/4, 0x30);
	INSTANCE_WR(ctx, 0x1D4/4, 0x3);
	INSTANCE_WR(ctx, 0x1D8/4, 0x1000);
	INSTANCE_WR(ctx, 0x218/4, 0xFE0C);
	INSTANCE_WR(ctx, 0x22C/4, 0x1000);
	INSTANCE_WR(ctx, 0x258/4, 0x187);
	INSTANCE_WR(ctx, 0x26C/4, 0x1018);
	INSTANCE_WR(ctx, 0x270/4, 0xFF);
	INSTANCE_WR(ctx, 0x2AC/4, 0x4);
	INSTANCE_WR(ctx, 0x2B0/4, 0x44D00DF);
	INSTANCE_WR(ctx, 0x2B8/4, 0x600);
	INSTANCE_WR(ctx, 0x2D0/4, 0x1000000);
	INSTANCE_WR(ctx, 0x2D4/4, 0xFF);
	INSTANCE_WR(ctx, 0x2DC/4, 0x400);
	INSTANCE_WR(ctx, 0x2F4/4, 0x1);
	INSTANCE_WR(ctx, 0x2F8/4, 0x80);
	INSTANCE_WR(ctx, 0x2FC/4, 0x4);
	INSTANCE_WR(ctx, 0x318/4, 0x2);
	INSTANCE_WR(ctx, 0x31C/4, 0x1);
	INSTANCE_WR(ctx, 0x328/4, 0x1);
	INSTANCE_WR(ctx, 0x32C/4, 0x100);
	INSTANCE_WR(ctx, 0x344/4, 0x2);
	INSTANCE_WR(ctx, 0x348/4, 0x1);
	INSTANCE_WR(ctx, 0x34C/4, 0x1);
	INSTANCE_WR(ctx, 0x35C/4, 0x1);
	INSTANCE_WR(ctx, 0x360/4, 0x3FFFFF);
	INSTANCE_WR(ctx, 0x364/4, 0x1FFF);
	INSTANCE_WR(ctx, 0x36C/4, 0x1);
	INSTANCE_WR(ctx, 0x370/4, 0x1);
	INSTANCE_WR(ctx, 0x378/4, 0x1);
	INSTANCE_WR(ctx, 0x37C/4, 0x1);
	INSTANCE_WR(ctx, 0x380/4, 0x1);
	INSTANCE_WR(ctx, 0x384/4, 0x4);
	INSTANCE_WR(ctx, 0x388/4, 0x1);
	INSTANCE_WR(ctx, 0x38C/4, 0x1);
	INSTANCE_WR(ctx, 0x390/4, 0x1);
	INSTANCE_WR(ctx, 0x394/4, 0x7);
	INSTANCE_WR(ctx, 0x398/4, 0x1);
	INSTANCE_WR(ctx, 0x39C/4, 0x7);
	INSTANCE_WR(ctx, 0x3A0/4, 0x1);
	INSTANCE_WR(ctx, 0x3A4/4, 0x1);
	INSTANCE_WR(ctx, 0x3A8/4, 0x1);
	INSTANCE_WR(ctx, 0x3BC/4, 0x1);
	INSTANCE_WR(ctx, 0x3C0/4, 0x100);
	INSTANCE_WR(ctx, 0x3C8/4, 0x1);
	INSTANCE_WR(ctx, 0x3D4/4, 0x100);
	INSTANCE_WR(ctx, 0x3D8/4, 0x1);
	INSTANCE_WR(ctx, 0x3DC/4, 0x100);
	INSTANCE_WR(ctx, 0x3E4/4, 0x1);
	INSTANCE_WR(ctx, 0x3F0/4, 0x100);
	INSTANCE_WR(ctx, 0x404/4, 0x4);
	INSTANCE_WR(ctx, 0x408/4, 0x70);
	INSTANCE_WR(ctx, 0x40C/4, 0x80);
	INSTANCE_WR(ctx, 0x420/4, 0xC);
	INSTANCE_WR(ctx, 0x428/4, 0x8);
	INSTANCE_WR(ctx, 0x42C/4, 0x14);
	INSTANCE_WR(ctx, 0x434/4, 0x29);
	INSTANCE_WR(ctx, 0x438/4, 0x27);
	INSTANCE_WR(ctx, 0x43C/4, 0x26);
	INSTANCE_WR(ctx, 0x440/4, 0x8);
	INSTANCE_WR(ctx, 0x444/4, 0x4);
	INSTANCE_WR(ctx, 0x448/4, 0x27);
	INSTANCE_WR(ctx, 0x454/4, 0x1);
	INSTANCE_WR(ctx, 0x458/4, 0x2);
	INSTANCE_WR(ctx, 0x45C/4, 0x3);
	INSTANCE_WR(ctx, 0x460/4, 0x4);
	INSTANCE_WR(ctx, 0x464/4, 0x5);
	INSTANCE_WR(ctx, 0x468/4, 0x6);
	INSTANCE_WR(ctx, 0x46C/4, 0x7);
	INSTANCE_WR(ctx, 0x470/4, 0x1);
	INSTANCE_WR(ctx, 0x4B4/4, 0xCF);
	INSTANCE_WR(ctx, 0x4E4/4, 0x80);
	INSTANCE_WR(ctx, 0x4E8/4, 0x4);
	INSTANCE_WR(ctx, 0x4EC/4, 0x4);
	INSTANCE_WR(ctx, 0x4F0/4, 0x3);
	INSTANCE_WR(ctx, 0x4F4/4, 0x1);
	INSTANCE_WR(ctx, 0x500/4, 0x12);
	INSTANCE_WR(ctx, 0x504/4, 0x10);
	INSTANCE_WR(ctx, 0x508/4, 0xC);
	INSTANCE_WR(ctx, 0x50C/4, 0x1);
	INSTANCE_WR(ctx, 0x51C/4, 0x4);
	INSTANCE_WR(ctx, 0x520/4, 0x2);
	INSTANCE_WR(ctx, 0x524/4, 0x4);
	INSTANCE_WR(ctx, 0x530/4, 0x3FFFFF);
	INSTANCE_WR(ctx, 0x534/4, 0x1FFF);
	INSTANCE_WR(ctx, 0x55C/4, 0x4);
	INSTANCE_WR(ctx, 0x560/4, 0x14);
	INSTANCE_WR(ctx, 0x564/4, 0x1);
	INSTANCE_WR(ctx, 0x570/4, 0x2);
	INSTANCE_WR(ctx, 0x57C/4, 0x1);
	INSTANCE_WR(ctx, 0x584/4, 0x2);
	INSTANCE_WR(ctx, 0x588/4, 0x1000);
	INSTANCE_WR(ctx, 0x58C/4, 0xE00);
	INSTANCE_WR(ctx, 0x590/4, 0x1000);
	INSTANCE_WR(ctx, 0x594/4, 0x1E00);
	INSTANCE_WR(ctx, 0x59C/4, 0x1);
	INSTANCE_WR(ctx, 0x5A0/4, 0x1);
	INSTANCE_WR(ctx, 0x5A4/4, 0x1);
	INSTANCE_WR(ctx, 0x5A8/4, 0x1);
	INSTANCE_WR(ctx, 0x5AC/4, 0x1);
	INSTANCE_WR(ctx, 0x5BC/4, 0x200);
	INSTANCE_WR(ctx, 0x5C4/4, 0x1);
	INSTANCE_WR(ctx, 0x5C8/4, 0x70);
	INSTANCE_WR(ctx, 0x5CC/4, 0x80);
	INSTANCE_WR(ctx, 0x5D8/4, 0x1);
	INSTANCE_WR(ctx, 0x5DC/4, 0x70);
	INSTANCE_WR(ctx, 0x5E0/4, 0x80);
	INSTANCE_WR(ctx, 0x5F0/4, 0x1);
	INSTANCE_WR(ctx, 0x5F4/4, 0xCF);
	INSTANCE_WR(ctx, 0x5FC/4, 0x1);
	INSTANCE_WR(ctx, 0x60C/4, 0xCF);
	INSTANCE_WR(ctx, 0x614/4, 0x2);
	INSTANCE_WR(ctx, 0x61C/4, 0x1);
	INSTANCE_WR(ctx, 0x624/4, 0x1);
	INSTANCE_WR(ctx, 0x62C/4, 0xCF);
	INSTANCE_WR(ctx, 0x630/4, 0xCF);
	INSTANCE_WR(ctx, 0x634/4, 0x1);
	INSTANCE_WR(ctx, 0x63C/4, 0xF80);
	INSTANCE_WR(ctx, 0x684/4, 0x7F0080);
	INSTANCE_WR(ctx, 0x6C0/4, 0x7F0080);
	INSTANCE_WR(ctx, 0x6E4/4, 0x3B74F821);
	INSTANCE_WR(ctx, 0x6E8/4, 0x89058001);
	INSTANCE_WR(ctx, 0x6F0/4, 0x1000);
	INSTANCE_WR(ctx, 0x6F4/4, 0x1F);
	INSTANCE_WR(ctx, 0x6F8/4, 0x27C10FA);
	INSTANCE_WR(ctx, 0x6FC/4, 0x400000C0);
	INSTANCE_WR(ctx, 0x700/4, 0xB7892080);
	INSTANCE_WR(ctx, 0x70C/4, 0x3B74F821);
	INSTANCE_WR(ctx, 0x710/4, 0x89058001);
	INSTANCE_WR(ctx, 0x718/4, 0x1000);
	INSTANCE_WR(ctx, 0x71C/4, 0x1F);
	INSTANCE_WR(ctx, 0x720/4, 0x27C10FA);
	INSTANCE_WR(ctx, 0x724/4, 0x400000C0);
	INSTANCE_WR(ctx, 0x728/4, 0xB7892080);
	INSTANCE_WR(ctx, 0x734/4, 0x10040);
	INSTANCE_WR(ctx, 0x73C/4, 0x22);
	INSTANCE_WR(ctx, 0x748/4, 0x10040);
	INSTANCE_WR(ctx, 0x74C/4, 0x22);
	INSTANCE_WR(ctx, 0x764/4, 0x1800000);
	INSTANCE_WR(ctx, 0x768/4, 0x160000);
	INSTANCE_WR(ctx, 0x76C/4, 0x1800000);
	INSTANCE_WR(ctx, 0x77C/4, 0x3FFFF);
	INSTANCE_WR(ctx, 0x780/4, 0x8C0000);
	INSTANCE_WR(ctx, 0x7A4/4, 0x10401);
	INSTANCE_WR(ctx, 0x7AC/4, 0x78);
	INSTANCE_WR(ctx, 0x7B4/4, 0xBF);
	INSTANCE_WR(ctx, 0x7BC/4, 0x1210);
	INSTANCE_WR(ctx, 0x7C0/4, 0x8000080);
	INSTANCE_WR(ctx, 0x7E4/4, 0x1800000);
	INSTANCE_WR(ctx, 0x7E8/4, 0x160000);
	INSTANCE_WR(ctx, 0x7EC/4, 0x1800000);
	INSTANCE_WR(ctx, 0x7FC/4, 0x3FFFF);
	INSTANCE_WR(ctx, 0x800/4, 0x8C0000);
	INSTANCE_WR(ctx, 0x824/4, 0x10401);
	INSTANCE_WR(ctx, 0x82C/4, 0x78);
	INSTANCE_WR(ctx, 0x834/4, 0xBF);
	INSTANCE_WR(ctx, 0x83C/4, 0x1210);
	INSTANCE_WR(ctx, 0x840/4, 0x8000080);
	INSTANCE_WR(ctx, 0x868/4, 0x27070);
	INSTANCE_WR(ctx, 0x874/4, 0x3FFFFFF);
	INSTANCE_WR(ctx, 0x88C/4, 0x120407);
	INSTANCE_WR(ctx, 0x890/4, 0x5091507);
	INSTANCE_WR(ctx, 0x894/4, 0x5010202);
	INSTANCE_WR(ctx, 0x898/4, 0x30201);
	INSTANCE_WR(ctx, 0x8B4/4, 0x40);
	INSTANCE_WR(ctx, 0x8B8/4, 0xD0C0B0A);
	INSTANCE_WR(ctx, 0x8BC/4, 0x141210);
	INSTANCE_WR(ctx, 0x8C0/4, 0x1F0);
	INSTANCE_WR(ctx, 0x8C4/4, 0x1);
	INSTANCE_WR(ctx, 0x8C8/4, 0x3);
	INSTANCE_WR(ctx, 0x8D4/4, 0x39E00);
	INSTANCE_WR(ctx, 0x8D8/4, 0x100);
	INSTANCE_WR(ctx, 0x8DC/4, 0x3800);
	INSTANCE_WR(ctx, 0x8E0/4, 0x404040);
	INSTANCE_WR(ctx, 0x8E4/4, 0xFF0A);
	INSTANCE_WR(ctx, 0x8EC/4, 0x77F005);
	INSTANCE_WR(ctx, 0x8F0/4, 0x3F7FFF);
	INSTANCE_WR(ctx, 0x7BA0/4, 0x21);
	INSTANCE_WR(ctx, 0x7BC0/4, 0x1);
	INSTANCE_WR(ctx, 0x7BE0/4, 0x2);
	INSTANCE_WR(ctx, 0x7C00/4, 0x100);
	INSTANCE_WR(ctx, 0x7C20/4, 0x100);
	INSTANCE_WR(ctx, 0x7C40/4, 0x1);
	INSTANCE_WR(ctx, 0x7CA0/4, 0x1);
	INSTANCE_WR(ctx, 0x7CC0/4, 0x2);
	INSTANCE_WR(ctx, 0x7CE0/4, 0x100);
	INSTANCE_WR(ctx, 0x7D00/4, 0x100);
	INSTANCE_WR(ctx, 0x7D20/4, 0x1);
	INSTANCE_WR(ctx, 0x11640/4, 0x4);
	INSTANCE_WR(ctx, 0x11660/4, 0x4);
	INSTANCE_WR(ctx, 0x49FE0/4, 0x4);
	INSTANCE_WR(ctx, 0x4A000/4, 0x4);
	INSTANCE_WR(ctx, 0x4A020/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x4A040/4, 0x3);
	INSTANCE_WR(ctx, 0x4A080/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x4A0C0/4, 0x80C14);
	INSTANCE_WR(ctx, 0x4A0E0/4, 0x1);
	INSTANCE_WR(ctx, 0x4A100/4, 0x80C14);
	INSTANCE_WR(ctx, 0x4A160/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x4A180/4, 0x27);
	INSTANCE_WR(ctx, 0x4A1E0/4, 0x1);
	INSTANCE_WR(ctx, 0x51A20/4, 0x1);
	INSTANCE_WR(ctx, 0x51D00/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x51EA0/4, 0x4000000);
	INSTANCE_WR(ctx, 0x51EC0/4, 0x4000000);
	INSTANCE_WR(ctx, 0x51F00/4, 0x80);
	INSTANCE_WR(ctx, 0x51F80/4, 0x80);
	INSTANCE_WR(ctx, 0x51FC0/4, 0x3F);
	INSTANCE_WR(ctx, 0x52120/4, 0x2);
	INSTANCE_WR(ctx, 0x52140/4, 0x4000000);
	INSTANCE_WR(ctx, 0x52160/4, 0x4000000);
	INSTANCE_WR(ctx, 0x52280/4, 0x4);
	INSTANCE_WR(ctx, 0x52300/4, 0x4);
	INSTANCE_WR(ctx, 0x52540/4, 0x1);
	INSTANCE_WR(ctx, 0x52560/4, 0x1001);
	INSTANCE_WR(ctx, 0x52580/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x525A0/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x525C0/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x525E0/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x52A00/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52A20/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52A40/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52A60/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52A80/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52AA0/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52AC0/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52AE0/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52B00/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52B20/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52B40/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52B60/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52B80/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52BA0/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52BC0/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52BE0/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x52C00/4, 0x10);
	INSTANCE_WR(ctx, 0x52C60/4, 0x3);
	INSTANCE_WR(ctx, 0xA84/4, 0xF);
	INSTANCE_WR(ctx, 0xB24/4, 0x20);
	INSTANCE_WR(ctx, 0xD04/4, 0x1A);
	INSTANCE_WR(ctx, 0xEC4/4, 0x4);
	INSTANCE_WR(ctx, 0xEE4/4, 0x4);
	INSTANCE_WR(ctx, 0xF24/4, 0x4);
	INSTANCE_WR(ctx, 0xF44/4, 0x8);
	INSTANCE_WR(ctx, 0xF84/4, 0x7FF);
	INSTANCE_WR(ctx, 0x1124/4, 0xF);
	INSTANCE_WR(ctx, 0x3604/4, 0xF);
	INSTANCE_WR(ctx, 0x3644/4, 0x1);
	INSTANCE_WR(ctx, 0x41A4/4, 0xF);
	INSTANCE_WR(ctx, 0x14844/4, 0xF);
	INSTANCE_WR(ctx, 0x14AE4/4, 0x1);
	INSTANCE_WR(ctx, 0x14B04/4, 0x100);
	INSTANCE_WR(ctx, 0x14B24/4, 0x100);
	INSTANCE_WR(ctx, 0x14B44/4, 0x11);
	INSTANCE_WR(ctx, 0x14B84/4, 0x8);
	INSTANCE_WR(ctx, 0x14C44/4, 0x1);
	INSTANCE_WR(ctx, 0x14C84/4, 0x1);
	INSTANCE_WR(ctx, 0x14CA4/4, 0x1);
	INSTANCE_WR(ctx, 0x14CC4/4, 0x1);
	INSTANCE_WR(ctx, 0x14CE4/4, 0xCF);
	INSTANCE_WR(ctx, 0x14D04/4, 0x2);
	INSTANCE_WR(ctx, 0x14DE4/4, 0x1);
	INSTANCE_WR(ctx, 0x14E24/4, 0x1);
	INSTANCE_WR(ctx, 0x14E44/4, 0x1);
	INSTANCE_WR(ctx, 0x14E64/4, 0x1);
	INSTANCE_WR(ctx, 0x14F04/4, 0x4);
	INSTANCE_WR(ctx, 0x14F44/4, 0x1);
	INSTANCE_WR(ctx, 0x14F64/4, 0x15);
	INSTANCE_WR(ctx, 0x14FE4/4, 0x4444480);
	INSTANCE_WR(ctx, 0x15764/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x15804/4, 0x100);
	INSTANCE_WR(ctx, 0x15864/4, 0x10001);
	INSTANCE_WR(ctx, 0x158A4/4, 0x10001);
	INSTANCE_WR(ctx, 0x158C4/4, 0x1);
	INSTANCE_WR(ctx, 0x158E4/4, 0x10001);
	INSTANCE_WR(ctx, 0x15904/4, 0x1);
	INSTANCE_WR(ctx, 0x15924/4, 0x4);
	INSTANCE_WR(ctx, 0x15944/4, 0x2);
	INSTANCE_WR(ctx, 0x166C4/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x166E4/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x16784/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x16904/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x16924/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x15948/4, 0x3FFFFF);
	INSTANCE_WR(ctx, 0x159A8/4, 0x1FFF);
	INSTANCE_WR(ctx, 0x15B88/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x15C68/4, 0x4);
	INSTANCE_WR(ctx, 0x15C88/4, 0x1A);
	INSTANCE_WR(ctx, 0x15CE8/4, 0x1);
	INSTANCE_WR(ctx, 0x15F48/4, 0xFFFF00);
	INSTANCE_WR(ctx, 0x16028/4, 0xF);
	INSTANCE_WR(ctx, 0x16128/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x16148/4, 0x11);
	INSTANCE_WR(ctx, 0x16348/4, 0x4);
	INSTANCE_WR(ctx, 0x163E8/4, 0x2);
	INSTANCE_WR(ctx, 0x16408/4, 0x4000000);
	INSTANCE_WR(ctx, 0x16428/4, 0x4000000);
	INSTANCE_WR(ctx, 0x164A8/4, 0x5);
	INSTANCE_WR(ctx, 0x164C8/4, 0x52);
	INSTANCE_WR(ctx, 0x16568/4, 0x1);
	INSTANCE_WR(ctx, 0x16788/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x167A8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x167C8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x167E8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16808/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16828/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16848/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16868/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16888/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x168A8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x168C8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x168E8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16908/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16928/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16948/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16968/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16988/4, 0x10);
	INSTANCE_WR(ctx, 0x16E68/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x16E88/4, 0x5);
	INSTANCE_WR(ctx, 0x16EE8/4, 0x1);
	INSTANCE_WR(ctx, 0x16F28/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x16F48/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x16F68/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x16F88/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x16FA8/4, 0x3);
	INSTANCE_WR(ctx, 0x173A8/4, 0xFFFF00);
	INSTANCE_WR(ctx, 0x173C8/4, 0x1A);
	INSTANCE_WR(ctx, 0x17408/4, 0x3);
	INSTANCE_WR(ctx, 0x178E8/4, 0x102);
	INSTANCE_WR(ctx, 0x17928/4, 0x4);
	INSTANCE_WR(ctx, 0x17948/4, 0x4);
	INSTANCE_WR(ctx, 0x17968/4, 0x4);
	INSTANCE_WR(ctx, 0x17988/4, 0x4);
	INSTANCE_WR(ctx, 0x179A8/4, 0x4);
	INSTANCE_WR(ctx, 0x179C8/4, 0x4);
	INSTANCE_WR(ctx, 0x17A08/4, 0x7FF);
	INSTANCE_WR(ctx, 0x17A48/4, 0x102);
	INSTANCE_WR(ctx, 0x17B88/4, 0x4);
	INSTANCE_WR(ctx, 0x17BA8/4, 0x4);
	INSTANCE_WR(ctx, 0x17BC8/4, 0x4);
	INSTANCE_WR(ctx, 0x17BE8/4, 0x4);
	INSTANCE_WR(ctx, 0x18228/4, 0x80C14);
	INSTANCE_WR(ctx, 0x18288/4, 0x804);
	INSTANCE_WR(ctx, 0x182C8/4, 0x4);
	INSTANCE_WR(ctx, 0x182E8/4, 0x4);
	INSTANCE_WR(ctx, 0x18308/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x18348/4, 0x4);
	INSTANCE_WR(ctx, 0x18368/4, 0x4);
	INSTANCE_WR(ctx, 0x183A8/4, 0x10);
	INSTANCE_WR(ctx, 0x18448/4, 0x804);
	INSTANCE_WR(ctx, 0x18468/4, 0x1);
	INSTANCE_WR(ctx, 0x18488/4, 0x1A);
	INSTANCE_WR(ctx, 0x184A8/4, 0x7F);
	INSTANCE_WR(ctx, 0x184E8/4, 0x1);
	INSTANCE_WR(ctx, 0x18508/4, 0x80C14);
	INSTANCE_WR(ctx, 0x18548/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x18568/4, 0x4);
	INSTANCE_WR(ctx, 0x18588/4, 0x4);
	INSTANCE_WR(ctx, 0x185C8/4, 0x10);
	INSTANCE_WR(ctx, 0x18648/4, 0x1);
	INSTANCE_WR(ctx, 0x18668/4, 0x8100C12);
	INSTANCE_WR(ctx, 0x18748/4, 0x7FF);
	INSTANCE_WR(ctx, 0x18768/4, 0x80C14);
	INSTANCE_WR(ctx, 0x18E88/4, 0x1);
	INSTANCE_WR(ctx, 0x18EE8/4, 0x10);
	INSTANCE_WR(ctx, 0x19608/4, 0x88);
	INSTANCE_WR(ctx, 0x19628/4, 0x88);
	INSTANCE_WR(ctx, 0x19688/4, 0x4);
	INSTANCE_WR(ctx, 0x19968/4, 0x26);
	INSTANCE_WR(ctx, 0x199C8/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x19A48/4, 0x1A);
	INSTANCE_WR(ctx, 0x19A68/4, 0x10);
	INSTANCE_WR(ctx, 0x19F88/4, 0x52);
	INSTANCE_WR(ctx, 0x19FC8/4, 0x26);
	INSTANCE_WR(ctx, 0x1A008/4, 0x4);
	INSTANCE_WR(ctx, 0x1A028/4, 0x4);
	INSTANCE_WR(ctx, 0x1A068/4, 0x1A);
	INSTANCE_WR(ctx, 0x1A0C8/4, 0xFFFF00);
	INSTANCE_WR(ctx, 0x1A108/4, 0x4);
	INSTANCE_WR(ctx, 0x1A128/4, 0x4);
	INSTANCE_WR(ctx, 0x1A168/4, 0x80);
	INSTANCE_WR(ctx, 0x1A188/4, 0x4);
	INSTANCE_WR(ctx, 0x1A1A8/4, 0x80C14);
	INSTANCE_WR(ctx, 0x1A1E8/4, 0x7FF);
	INSTANCE_WR(ctx, 0x24A48/4, 0x4);
	INSTANCE_WR(ctx, 0x24A68/4, 0x4);
	INSTANCE_WR(ctx, 0x24AA8/4, 0x80);
	INSTANCE_WR(ctx, 0x24AC8/4, 0x4);
	INSTANCE_WR(ctx, 0x24AE8/4, 0x1);
	INSTANCE_WR(ctx, 0x24B28/4, 0x27);
	INSTANCE_WR(ctx, 0x24B68/4, 0x26);
	INSTANCE_WR(ctx, 0x24BE8/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24C08/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24C28/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24C48/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24C68/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24C88/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24CA8/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24CC8/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24CE8/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24D08/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24D28/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24D48/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24D68/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24D88/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24DA8/4, 0x4000000);
	INSTANCE_WR(ctx, 0x24DC8/4, 0x4000000);
	INSTANCE_WR(ctx, 0x25268/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x25288/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x252E8/4, 0x1FE21);
	INSTANCE_WR(ctx, 0xB0C/4, 0x2);
	INSTANCE_WR(ctx, 0xB4C/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0xCEC/4, 0x1);
	INSTANCE_WR(ctx, 0xD0C/4, 0x10);
	INSTANCE_WR(ctx, 0xD6C/4, 0x1);
	INSTANCE_WR(ctx, 0xE0C/4, 0x4);
	INSTANCE_WR(ctx, 0xE2C/4, 0x400);
	INSTANCE_WR(ctx, 0xE4C/4, 0x300);
	INSTANCE_WR(ctx, 0xE6C/4, 0x1001);
	INSTANCE_WR(ctx, 0xE8C/4, 0x15);
	INSTANCE_WR(ctx, 0xF4C/4, 0x2);
	INSTANCE_WR(ctx, 0x106C/4, 0x1);
	INSTANCE_WR(ctx, 0x108C/4, 0x10);
	INSTANCE_WR(ctx, 0x10CC/4, 0x1);
	INSTANCE_WR(ctx, 0x134C/4, 0x10);
	INSTANCE_WR(ctx, 0x156C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x158C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x15AC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x15CC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x15EC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x160C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x162C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x164C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x166C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x168C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16AC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16CC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x16EC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x170C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x172C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x174C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x1A8C/4, 0x10);
	INSTANCE_WR(ctx, 0x1ACC/4, 0x3F);
	INSTANCE_WR(ctx, 0x1BAC/4, 0x1);
	INSTANCE_WR(ctx, 0x1BEC/4, 0x1);
	INSTANCE_WR(ctx, 0x1C2C/4, 0x1);
	INSTANCE_WR(ctx, 0x1DCC/4, 0x11);
	INSTANCE_WR(ctx, 0x1ECC/4, 0xF);
	INSTANCE_WR(ctx, 0x1FCC/4, 0x11);
	INSTANCE_WR(ctx, 0x20AC/4, 0x1);
	INSTANCE_WR(ctx, 0x20CC/4, 0x1);
	INSTANCE_WR(ctx, 0x20EC/4, 0x1);
	INSTANCE_WR(ctx, 0x210C/4, 0x2);
	INSTANCE_WR(ctx, 0x212C/4, 0x1);
	INSTANCE_WR(ctx, 0x214C/4, 0x2);
	INSTANCE_WR(ctx, 0x216C/4, 0x1);
	INSTANCE_WR(ctx, 0x21AC/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0x21EC/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x24AC/4, 0x1);
	INSTANCE_WR(ctx, 0x24CC/4, 0x2);
	INSTANCE_WR(ctx, 0x24EC/4, 0x1);
	INSTANCE_WR(ctx, 0x250C/4, 0x1);
	INSTANCE_WR(ctx, 0x252C/4, 0x2);
	INSTANCE_WR(ctx, 0x254C/4, 0x1);
	INSTANCE_WR(ctx, 0x256C/4, 0x1);
	INSTANCE_WR(ctx, 0x25EC/4, 0x11);
	INSTANCE_WR(ctx, 0x260C/4, 0x1);
	INSTANCE_WR(ctx, 0x328C/4, 0x2);
	INSTANCE_WR(ctx, 0x32CC/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0x346C/4, 0x1);
	INSTANCE_WR(ctx, 0x348C/4, 0x10);
	INSTANCE_WR(ctx, 0x34EC/4, 0x1);
	INSTANCE_WR(ctx, 0x358C/4, 0x4);
	INSTANCE_WR(ctx, 0x35AC/4, 0x400);
	INSTANCE_WR(ctx, 0x35CC/4, 0x300);
	INSTANCE_WR(ctx, 0x35EC/4, 0x1001);
	INSTANCE_WR(ctx, 0x360C/4, 0x15);
	INSTANCE_WR(ctx, 0x36CC/4, 0x2);
	INSTANCE_WR(ctx, 0x37EC/4, 0x1);
	INSTANCE_WR(ctx, 0x380C/4, 0x10);
	INSTANCE_WR(ctx, 0x384C/4, 0x1);
	INSTANCE_WR(ctx, 0x3ACC/4, 0x10);
	INSTANCE_WR(ctx, 0x3CEC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3D0C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3D2C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3D4C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3D6C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3D8C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3DAC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3DCC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3DEC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3E0C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3E2C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3E4C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3E6C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3E8C/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3EAC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x3ECC/4, 0x3F800000);
	INSTANCE_WR(ctx, 0x420C/4, 0x10);
	INSTANCE_WR(ctx, 0x424C/4, 0x3F);
	INSTANCE_WR(ctx, 0x432C/4, 0x1);
	INSTANCE_WR(ctx, 0x436C/4, 0x1);
	INSTANCE_WR(ctx, 0x43AC/4, 0x1);
	INSTANCE_WR(ctx, 0x454C/4, 0x11);
	INSTANCE_WR(ctx, 0x464C/4, 0xF);
	INSTANCE_WR(ctx, 0x474C/4, 0x11);
	INSTANCE_WR(ctx, 0x482C/4, 0x1);
	INSTANCE_WR(ctx, 0x484C/4, 0x1);
	INSTANCE_WR(ctx, 0x486C/4, 0x1);
	INSTANCE_WR(ctx, 0x488C/4, 0x2);
	INSTANCE_WR(ctx, 0x48AC/4, 0x1);
	INSTANCE_WR(ctx, 0x48CC/4, 0x2);
	INSTANCE_WR(ctx, 0x48EC/4, 0x1);
	INSTANCE_WR(ctx, 0x492C/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0x496C/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x4C2C/4, 0x1);
	INSTANCE_WR(ctx, 0x4C4C/4, 0x2);
	INSTANCE_WR(ctx, 0x4C6C/4, 0x1);
	INSTANCE_WR(ctx, 0x4C8C/4, 0x1);
	INSTANCE_WR(ctx, 0x4CAC/4, 0x2);
	INSTANCE_WR(ctx, 0x4CCC/4, 0x1);
	INSTANCE_WR(ctx, 0x4CEC/4, 0x1);
	INSTANCE_WR(ctx, 0x4D6C/4, 0x11);
	INSTANCE_WR(ctx, 0x4D8C/4, 0x1);
	INSTANCE_WR(ctx, 0xA30/4, 0x4);
	INSTANCE_WR(ctx, 0xCF0/4, 0x4);
	INSTANCE_WR(ctx, 0xD10/4, 0x4);
	INSTANCE_WR(ctx, 0xD30/4, 0x608080);
	INSTANCE_WR(ctx, 0xDD0/4, 0x4);
	INSTANCE_WR(ctx, 0xE30/4, 0x4);
	INSTANCE_WR(ctx, 0xE50/4, 0x4);
	INSTANCE_WR(ctx, 0xE70/4, 0x80);
	INSTANCE_WR(ctx, 0xE90/4, 0x1E00);
	INSTANCE_WR(ctx, 0xEB0/4, 0x4);
	INSTANCE_WR(ctx, 0x1350/4, 0x4);
	INSTANCE_WR(ctx, 0x1370/4, 0x80);
	INSTANCE_WR(ctx, 0x1390/4, 0x4);
	INSTANCE_WR(ctx, 0x13B0/4, 0x3020100);
	INSTANCE_WR(ctx, 0x13D0/4, 0x3);
	INSTANCE_WR(ctx, 0x13F0/4, 0x1E00);
	INSTANCE_WR(ctx, 0x1410/4, 0x4);
	INSTANCE_WR(ctx, 0x14B0/4, 0x4);
	INSTANCE_WR(ctx, 0x14D0/4, 0x3);
	INSTANCE_WR(ctx, 0x1550/4, 0x4);
	INSTANCE_WR(ctx, 0x159F0/4, 0x4);
	INSTANCE_WR(ctx, 0x15A10/4, 0x3);
	INSTANCE_WR(ctx, 0x15C50/4, 0xF);
	INSTANCE_WR(ctx, 0x15DD0/4, 0x4);
	INSTANCE_WR(ctx, 0x15DF0/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x15E10/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x15E30/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x15E50/4, 0xFFFF);
	INSTANCE_WR(ctx, 0x15F70/4, 0x1);
	INSTANCE_WR(ctx, 0x15FF0/4, 0x1);
	INSTANCE_WR(ctx, 0x160B0/4, 0x1);
	INSTANCE_WR(ctx, 0x16250/4, 0x1);
	INSTANCE_WR(ctx, 0x16270/4, 0x1);
	INSTANCE_WR(ctx, 0x16290/4, 0x2);
	INSTANCE_WR(ctx, 0x162B0/4, 0x1);
	INSTANCE_WR(ctx, 0x162D0/4, 0x1);
	INSTANCE_WR(ctx, 0x162F0/4, 0x2);
	INSTANCE_WR(ctx, 0x16310/4, 0x1);
	INSTANCE_WR(ctx, 0x16350/4, 0x11);
	INSTANCE_WR(ctx, 0x16450/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x164B0/4, 0x4);
	INSTANCE_WR(ctx, 0x16530/4, 0x11);
	INSTANCE_WR(ctx, 0x16550/4, 0x1);
	INSTANCE_WR(ctx, 0x16590/4, 0xCF);
	INSTANCE_WR(ctx, 0x165B0/4, 0xCF);
	INSTANCE_WR(ctx, 0x165D0/4, 0xCF);
	INSTANCE_WR(ctx, 0x16730/4, 0x1);
	INSTANCE_WR(ctx, 0x16750/4, 0x1);
	INSTANCE_WR(ctx, 0x16770/4, 0x2);
	INSTANCE_WR(ctx, 0x16790/4, 0x1);
	INSTANCE_WR(ctx, 0x167B0/4, 0x1);
	INSTANCE_WR(ctx, 0x167D0/4, 0x2);
	INSTANCE_WR(ctx, 0x167F0/4, 0x1);
	INSTANCE_WR(ctx, 0x16830/4, 0x1);
	INSTANCE_WR(ctx, 0x16850/4, 0x1);
	INSTANCE_WR(ctx, 0x16870/4, 0x1);
	INSTANCE_WR(ctx, 0x16890/4, 0x1);
	INSTANCE_WR(ctx, 0x168B0/4, 0x1);
	INSTANCE_WR(ctx, 0x168D0/4, 0x1);
	INSTANCE_WR(ctx, 0x168F0/4, 0x1);
	INSTANCE_WR(ctx, 0x16910/4, 0x1);
	INSTANCE_WR(ctx, 0x16930/4, 0x11);
	INSTANCE_WR(ctx, 0x16A30/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x16A50/4, 0xF);
	INSTANCE_WR(ctx, 0x16B50/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0x16BB0/4, 0x11);
	INSTANCE_WR(ctx, 0x16BD0/4, 0x1);
	INSTANCE_WR(ctx, 0x16C50/4, 0x4);
	INSTANCE_WR(ctx, 0x16D10/4, 0x1);
	INSTANCE_WR(ctx, 0x16DB0/4, 0x11);
	INSTANCE_WR(ctx, 0x16EB0/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x16F30/4, 0x11);
	INSTANCE_WR(ctx, 0x16F50/4, 0x1);
	INSTANCE_WR(ctx, 0x16F90/4, 0x1);
	INSTANCE_WR(ctx, 0x16FD0/4, 0x1);
	INSTANCE_WR(ctx, 0x17010/4, 0x7FF);
	INSTANCE_WR(ctx, 0x17050/4, 0x1);
	INSTANCE_WR(ctx, 0x17090/4, 0x1);
	INSTANCE_WR(ctx, 0x175F0/4, 0x8);
	INSTANCE_WR(ctx, 0x17610/4, 0x8);
	INSTANCE_WR(ctx, 0x17630/4, 0x8);
	INSTANCE_WR(ctx, 0x17650/4, 0x8);
	INSTANCE_WR(ctx, 0x17670/4, 0x8);
	INSTANCE_WR(ctx, 0x17690/4, 0x8);
	INSTANCE_WR(ctx, 0x176B0/4, 0x8);
	INSTANCE_WR(ctx, 0x176D0/4, 0x8);
	INSTANCE_WR(ctx, 0x176F0/4, 0x11);
	INSTANCE_WR(ctx, 0x177F0/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x17810/4, 0x400);
	INSTANCE_WR(ctx, 0x17830/4, 0x400);
	INSTANCE_WR(ctx, 0x17850/4, 0x400);
	INSTANCE_WR(ctx, 0x17870/4, 0x400);
	INSTANCE_WR(ctx, 0x17890/4, 0x400);
	INSTANCE_WR(ctx, 0x178B0/4, 0x400);
	INSTANCE_WR(ctx, 0x178D0/4, 0x400);
	INSTANCE_WR(ctx, 0x178F0/4, 0x400);
	INSTANCE_WR(ctx, 0x17910/4, 0x300);
	INSTANCE_WR(ctx, 0x17930/4, 0x300);
	INSTANCE_WR(ctx, 0x17950/4, 0x300);
	INSTANCE_WR(ctx, 0x17970/4, 0x300);
	INSTANCE_WR(ctx, 0x17990/4, 0x300);
	INSTANCE_WR(ctx, 0x179B0/4, 0x300);
	INSTANCE_WR(ctx, 0x179D0/4, 0x300);
	INSTANCE_WR(ctx, 0x179F0/4, 0x300);
	INSTANCE_WR(ctx, 0x17A10/4, 0x1);
	INSTANCE_WR(ctx, 0x17A30/4, 0xF);
	INSTANCE_WR(ctx, 0x17B30/4, 0x20);
	INSTANCE_WR(ctx, 0x17B50/4, 0x11);
	INSTANCE_WR(ctx, 0x17B70/4, 0x100);
	INSTANCE_WR(ctx, 0x17BB0/4, 0x1);
	INSTANCE_WR(ctx, 0x17C10/4, 0x40);
	INSTANCE_WR(ctx, 0x17C30/4, 0x100);
	INSTANCE_WR(ctx, 0x17C70/4, 0x3);
	INSTANCE_WR(ctx, 0x17D10/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0x17D90/4, 0x2);
	INSTANCE_WR(ctx, 0x17DB0/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x17EF0/4, 0x1);
	INSTANCE_WR(ctx, 0x17F90/4, 0x4);
	INSTANCE_WR(ctx, 0x17FD0/4, 0x1);
	INSTANCE_WR(ctx, 0x17FF0/4, 0x400);
	INSTANCE_WR(ctx, 0x18010/4, 0x300);
	INSTANCE_WR(ctx, 0x18030/4, 0x1001);
	INSTANCE_WR(ctx, 0x180B0/4, 0x11);
	INSTANCE_WR(ctx, 0x181B0/4, 0xFAC6881);
	INSTANCE_WR(ctx, 0x181D0/4, 0xF);
	INSTANCE_WR(ctx, 0x184D0/4, 0x1FFE67);
	INSTANCE_WR(ctx, 0x18550/4, 0x11);
	INSTANCE_WR(ctx, 0x185B0/4, 0x4);
	INSTANCE_WR(ctx, 0x185F0/4, 0x1);
	INSTANCE_WR(ctx, 0x18610/4, 0x1);
	INSTANCE_WR(ctx, 0x18690/4, 0x1);
	INSTANCE_WR(ctx, 0x18730/4, 0x1);
	INSTANCE_WR(ctx, 0x18770/4, 0x1);
	INSTANCE_WR(ctx, 0x187F0/4, 0x2A712488);
	INSTANCE_WR(ctx, 0x18830/4, 0x4085C000);
	INSTANCE_WR(ctx, 0x18850/4, 0x40);
	INSTANCE_WR(ctx, 0x18870/4, 0x100);
	INSTANCE_WR(ctx, 0x18890/4, 0x10100);
	INSTANCE_WR(ctx, 0x188B0/4, 0x2800000);
	INSTANCE_WR(ctx, 0x18B10/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x18B30/4, 0x4E3BFDF);
	INSTANCE_WR(ctx, 0x18B50/4, 0x1);
	INSTANCE_WR(ctx, 0x18B90/4, 0xFFFF00);
	INSTANCE_WR(ctx, 0x18BB0/4, 0x1);
	INSTANCE_WR(ctx, 0x18C10/4, 0xFFFF00);
	INSTANCE_WR(ctx, 0x18D30/4, 0x1);
	INSTANCE_WR(ctx, 0x18D70/4, 0x1);
	INSTANCE_WR(ctx, 0x18D90/4, 0x30201000);
	INSTANCE_WR(ctx, 0x18DB0/4, 0x70605040);
	INSTANCE_WR(ctx, 0x18DD0/4, 0xB8A89888);
	INSTANCE_WR(ctx, 0x18DF0/4, 0xF8E8D8C8);
	INSTANCE_WR(ctx, 0x18E30/4, 0x1A);
}


int
nv50_graph_create_context(struct nouveau_channel *chan)
{
	struct drm_device *dev = chan->dev;
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_engine *engine = &dev_priv->Engine;
	struct nouveau_gpuobj *ramin = chan->ramin->gpuobj;
	int grctx_size = 0x60000, hdr;
	int ret;

	DRM_DEBUG("ch%d\n", chan->id);

	ret = nouveau_gpuobj_new_ref(dev, chan, NULL, 0, grctx_size, 0x1000,
				     NVOBJ_FLAG_ZERO_ALLOC |
				     NVOBJ_FLAG_ZERO_FREE, &chan->ramin_grctx);
	if (ret)
		return ret;

	hdr = IS_G80 ? 0x200 : 0x20;
	INSTANCE_WR(ramin, (hdr + 0x00)/4, 0x00190002);
	INSTANCE_WR(ramin, (hdr + 0x04)/4, chan->ramin_grctx->instance +
					   grctx_size - 1);
	INSTANCE_WR(ramin, (hdr + 0x08)/4, chan->ramin_grctx->instance);
	INSTANCE_WR(ramin, (hdr + 0x0c)/4, 0);
	INSTANCE_WR(ramin, (hdr + 0x10)/4, 0);
	INSTANCE_WR(ramin, (hdr + 0x14)/4, 0x00010000);

	switch (dev_priv->chipset) {
		case 0x86:
			nv86_graph_init_ctxvals(dev, chan->ramin_grctx);
			break;
		default:
			ret = engine->graph.load_context(chan);
			if (ret) {
				DRM_ERROR("Error hacking up initial context: %d\n", ret);
				return ret;
			}
			break;
	}

	INSTANCE_WR(chan->ramin_grctx->gpuobj, 0x00000/4,
		    chan->ramin->instance >> 12);
	INSTANCE_WR(chan->ramin_grctx->gpuobj, 0x0011c/4, 0x00000002);

	return 0;
}

void
nv50_graph_destroy_context(struct nouveau_channel *chan)
{
	struct drm_device *dev = chan->dev;
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	int i, hdr;

	DRM_DEBUG("ch%d\n", chan->id);

	hdr = IS_G80 ? 0x200 : 0x20;
	for (i=hdr; i<hdr+24; i+=4)
		INSTANCE_WR(chan->ramin->gpuobj, i/4, 0);

	nouveau_gpuobj_ref_del(dev, &chan->ramin_grctx);
}

static int
nv50_graph_transfer_context(struct drm_device *dev, uint32_t inst, int save)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	uint32_t old_cp, tv = 20000;
	int i;

	DRM_DEBUG("inst=0x%08x, save=%d\n", inst, save);

	old_cp = NV_READ(NV20_PGRAPH_CHANNEL_CTX_POINTER);
	NV_WRITE(NV20_PGRAPH_CHANNEL_CTX_POINTER, inst);
	NV_WRITE(0x400824, NV_READ(0x400824) |
		 (save ? NV40_PGRAPH_CTXCTL_0310_XFER_SAVE :
			 NV40_PGRAPH_CTXCTL_0310_XFER_LOAD));
	NV_WRITE(NV40_PGRAPH_CTXCTL_0304, NV40_PGRAPH_CTXCTL_0304_XFER_CTX);

	for (i = 0; i < tv; i++) {
		if (NV_READ(NV40_PGRAPH_CTXCTL_030C) == 0)
			break;
	}
	NV_WRITE(NV20_PGRAPH_CHANNEL_CTX_POINTER, old_cp);

	if (i == tv) {
		DRM_ERROR("failed: inst=0x%08x save=%d\n", inst, save);
		DRM_ERROR("0x40030C = 0x%08x\n",
			  NV_READ(NV40_PGRAPH_CTXCTL_030C));
		return -EBUSY;
	}

	return 0;
}

int
nv50_graph_load_context(struct nouveau_channel *chan)
{
	struct drm_device *dev = chan->dev;
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	uint32_t inst = chan->ramin->instance >> 12;
	int ret; (void)ret;

	DRM_DEBUG("ch%d\n", chan->id);

#if 0
	if ((ret = nv50_graph_transfer_context(dev, inst, 0)))
		return ret;
#endif

	NV_WRITE(NV20_PGRAPH_CHANNEL_CTX_POINTER, inst);
	NV_WRITE(0x400320, 4);
	NV_WRITE(NV40_PGRAPH_CTXCTL_CUR, inst | (1<<31));

	return 0;
}

int
nv50_graph_save_context(struct nouveau_channel *chan)
{
	struct drm_device *dev = chan->dev;
	uint32_t inst = chan->ramin->instance >> 12;

	DRM_DEBUG("ch%d\n", chan->id);

	return nv50_graph_transfer_context(dev, inst, 1);
}