aboutsummaryrefslogtreecommitdiffstats
path: root/main
diff options
context:
space:
mode:
authorNatanael Copa <ncopa@alpinelinux.org>2015-03-17 09:17:24 +0000
committerNatanael Copa <ncopa@alpinelinux.org>2015-03-17 11:01:25 +0000
commit94dcde212867ffcb3ee91b54fd3dedf51c184a7f (patch)
tree1dd929e26fff8d7c718bd90441b15fc103dc1b2f /main
parentd50d348d94c23461442acf84c754e96476549b4a (diff)
downloadaports-94dcde212867ffcb3ee91b54fd3dedf51c184a7f.tar.bz2
aports-94dcde212867ffcb3ee91b54fd3dedf51c184a7f.tar.xz
main/xf86-video-r128: rebuild against xorg-server 1.17
Diffstat (limited to 'main')
-rw-r--r--main/xf86-video-r128/APKBUILD21
-rw-r--r--main/xf86-video-r128/git-fixes.patch8804
2 files changed, 8820 insertions, 5 deletions
diff --git a/main/xf86-video-r128/APKBUILD b/main/xf86-video-r128/APKBUILD
index 233d2f2092..495b36dc21 100644
--- a/main/xf86-video-r128/APKBUILD
+++ b/main/xf86-video-r128/APKBUILD
@@ -1,7 +1,7 @@
# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
pkgname=xf86-video-r128
pkgver=6.9.2
-pkgrel=2
+pkgrel=3
pkgdesc="ATI Rage128 video driver"
url="http://xorg.freedesktop.org/"
arch="all"
@@ -11,15 +11,23 @@ depends=
makedepends="pkgconfig xorg-server-dev libxi-dev fontsproto randrproto
videoproto renderproto xineramaproto libdrm-dev xf86driproto glproto
mesa-dev expat-dev
+ util-macros autoconf automake libtool
"
-source="http://xorg.freedesktop.org/releases/individual/driver/$pkgname-$pkgver.tar.bz2"
+source="http://xorg.freedesktop.org/releases/individual/driver/$pkgname-$pkgver.tar.bz2
+ git-fixes.patch"
_builddir="$srcdir/$pkgname-$pkgver"
prepare() {
cd "$_builddir"
update_config_sub || return 1
+ for i in $source; do
+ case $i in
+ *.patch) msg $i; patch -p1 -i "$srcdir"/$i || return 1;;
+ esac
+ done
+ autoreconf -fi || return 1
}
build() {
@@ -40,6 +48,9 @@ package() {
rm "$pkgdir"/usr/lib/xorg/modules/*/*.la || return 1
install -Dm644 COPYING "$pkgdir"/usr/share/licenses/$pkgname/COPYING
}
-md5sums="2e906d856a1c477bde000254b142445c xf86-video-r128-6.9.2.tar.bz2"
-sha256sums="8b2d295f1842d07304a75da1cfb9bf139b320a6539970eaf8d5ecc010cd36ee0 xf86-video-r128-6.9.2.tar.bz2"
-sha512sums="7f8dc174ff8cff6d109a62610b255c3f3a99e6fbdc38373da3efb88a960a25fe3124dbdb6a9379de6b45edaedb3aae44a183a5604f80bbb488dbb98faebc2fb3 xf86-video-r128-6.9.2.tar.bz2"
+md5sums="2e906d856a1c477bde000254b142445c xf86-video-r128-6.9.2.tar.bz2
+4f1b508b64dd0435f1ab85c043bd531d git-fixes.patch"
+sha256sums="8b2d295f1842d07304a75da1cfb9bf139b320a6539970eaf8d5ecc010cd36ee0 xf86-video-r128-6.9.2.tar.bz2
+2139a1d3b12950f452b72f4d9b916143814789df5080cee03a1e0955421b1808 git-fixes.patch"
+sha512sums="7f8dc174ff8cff6d109a62610b255c3f3a99e6fbdc38373da3efb88a960a25fe3124dbdb6a9379de6b45edaedb3aae44a183a5604f80bbb488dbb98faebc2fb3 xf86-video-r128-6.9.2.tar.bz2
+00836925ffd54a7e51b4e9e4e29fddc6d5bf587ed456e758f44681a7f89b0d6a4b46b166ff22627407fc3d97d49ed4e2d313d4ec67990b9f249f8ee734ccd4e5 git-fixes.patch"
diff --git a/main/xf86-video-r128/git-fixes.patch b/main/xf86-video-r128/git-fixes.patch
new file mode 100644
index 0000000000..c37227d9c9
--- /dev/null
+++ b/main/xf86-video-r128/git-fixes.patch
@@ -0,0 +1,8804 @@
+From d5da29d2ff94c80c8edefd6ccf5fd05fc6018870 Mon Sep 17 00:00:00 2001
+From: Tormod Volden <debian.tormod@gmail.com>
+Date: Fri, 25 Oct 2013 20:31:05 +0200
+Subject: Do not use int10 or VBE on powerpc
+
+VBE was already skipped in the normal path, but not when setting
+the PROBE_DETECT flag.
+
+Should avoid bus error seen in
+http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=622606 and
+http://lists.x.org/archives/xorg/2012-February/053969.html
+
+Signed-off-by: Tormod Volden <debian.tormod@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128_driver.c | 7 +++++--
+ 1 file changed, 5 insertions(+), 2 deletions(-)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 72d9e3c..6acdf2d 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -1758,8 +1758,8 @@ static Bool R128PreInitCursor(ScrnInfoPtr pScrn)
+ static Bool R128PreInitInt10(ScrnInfoPtr pScrn, xf86Int10InfoPtr *ppInt10)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+-#if 1 && !defined(__alpha__)
+- /* int10 is broken on some Alphas */
++#if !defined(__powerpc__) && !defined(__alpha__)
++ /* int10 is broken on some Alphas and powerpc */
+ if (xf86LoadSubModule(pScrn, "int10")) {
+ xf86DrvMsg(pScrn->scrnIndex,X_INFO,"initializing int10\n");
+ *ppInt10 = xf86InitInt10(info->pEnt->index);
+@@ -1890,11 +1890,14 @@ static void
+ R128ProbeDDC(ScrnInfoPtr pScrn, int indx)
+ {
+ vbeInfoPtr pVbe;
++
++#if !defined(__powerpc__) && !defined(__alpha__) && !defined(__sparc__)
+ if (xf86LoadSubModule(pScrn, "vbe")) {
+ pVbe = VBEInit(NULL,indx);
+ ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
+ vbeFree(pVbe);
+ }
++#endif
+ }
+
+ /* R128PreInit is called once at server startup. */
+--
+2.2.2
+
+
+From d757fe10b9ce9493ef3cf854bc03088366aa7256 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Fri, 22 Nov 2013 22:55:59 -0800
+Subject: Drop dependence on xf86PciInfo.h
+
+It is about time we stop using this deprecated file and include pciids
+locally.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128_dri.c | 1 -
+ src/r128_driver.c | 1 -
+ src/r128_probe.c | 2 --
+ src/r128_probe.h | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 50 insertions(+), 4 deletions(-)
+
+diff --git a/src/r128_dri.c b/src/r128_dri.c
+index 67e8d1d..ff7bbc2 100644
+--- a/src/r128_dri.c
++++ b/src/r128_dri.c
+@@ -53,7 +53,6 @@
+
+ /* X and server generic header files */
+ #include "xf86.h"
+-#include "xf86PciInfo.h"
+ #include "windowstr.h"
+
+ #include "shadowfb.h"
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 6acdf2d..04a4537 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -84,7 +84,6 @@
+ /* X and server generic header files */
+ #include "xf86.h"
+ #include "xf86_OSproc.h"
+-#include "xf86PciInfo.h"
+ #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86RAC.h"
+ #include "xf86Resources.h"
+diff --git a/src/r128_probe.c b/src/r128_probe.c
+index 7f1fbda..12e0c1c 100644
+--- a/src/r128_probe.c
++++ b/src/r128_probe.c
+@@ -43,8 +43,6 @@
+ #include "atipcirename.h"
+
+ #include "xf86.h"
+-#include "xf86PciInfo.h"
+-
+
+ #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86Resources.h"
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index 41fc0e4..7b55e71 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -38,6 +38,56 @@
+
+ #include "xf86str.h"
+
++/* Chip definitions */
++#define PCI_VENDOR_ATI 0x1002
++#define PCI_CHIP_RAGE128LE 0x4C45
++#define PCI_CHIP_RAGE128LF 0x4C46
++#define PCI_CHIP_RAGE128MF 0x4D46
++#define PCI_CHIP_RAGE128ML 0x4D4C
++#define PCI_CHIP_RAGE128PA 0x5041
++#define PCI_CHIP_RAGE128PB 0x5042
++#define PCI_CHIP_RAGE128PC 0x5043
++#define PCI_CHIP_RAGE128PD 0x5044
++#define PCI_CHIP_RAGE128PE 0x5045
++#define PCI_CHIP_RAGE128PF 0x5046
++#define PCI_CHIP_RAGE128PG 0x5047
++#define PCI_CHIP_RAGE128PH 0x5048
++#define PCI_CHIP_RAGE128PI 0x5049
++#define PCI_CHIP_RAGE128PJ 0x504A
++#define PCI_CHIP_RAGE128PK 0x504B
++#define PCI_CHIP_RAGE128PL 0x504C
++#define PCI_CHIP_RAGE128PM 0x504D
++#define PCI_CHIP_RAGE128PN 0x504E
++#define PCI_CHIP_RAGE128PO 0x504F
++#define PCI_CHIP_RAGE128PP 0x5050
++#define PCI_CHIP_RAGE128PQ 0x5051
++#define PCI_CHIP_RAGE128PR 0x5052
++#define PCI_CHIP_RAGE128PS 0x5053
++#define PCI_CHIP_RAGE128PT 0x5054
++#define PCI_CHIP_RAGE128PU 0x5055
++#define PCI_CHIP_RAGE128PV 0x5056
++#define PCI_CHIP_RAGE128PW 0x5057
++#define PCI_CHIP_RAGE128PX 0x5058
++#define PCI_CHIP_RAGE128RE 0x5245
++#define PCI_CHIP_RAGE128RF 0x5246
++#define PCI_CHIP_RAGE128RG 0x5247
++#define PCI_CHIP_RAGE128RK 0x524B
++#define PCI_CHIP_RAGE128RL 0x524C
++#define PCI_CHIP_RAGE128SE 0x5345
++#define PCI_CHIP_RAGE128SF 0x5346
++#define PCI_CHIP_RAGE128SG 0x5347
++#define PCI_CHIP_RAGE128SH 0x5348
++#define PCI_CHIP_RAGE128SK 0x534B
++#define PCI_CHIP_RAGE128SL 0x534C
++#define PCI_CHIP_RAGE128SM 0x534D
++#define PCI_CHIP_RAGE128SN 0x534E
++#define PCI_CHIP_RAGE128TF 0x5446
++#define PCI_CHIP_RAGE128TL 0x544C
++#define PCI_CHIP_RAGE128TR 0x5452
++#define PCI_CHIP_RAGE128TS 0x5453
++#define PCI_CHIP_RAGE128TT 0x5454
++#define PCI_CHIP_RAGE128TU 0x5455
++
+ extern DriverRec R128;
+
+ typedef struct
+--
+2.2.2
+
+
+From 35dc7faf9f87332f51ff0a6aa866a56eb017a950 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Thu, 21 Nov 2013 22:09:57 -0800
+Subject: Do not disable gouraud shading for a render op
+
+The EXA Composite hooks should not overwrite any register values
+expected by DRI. Initial testing of the EXA support revealed that
+R128_WINDOW_XY_OFFSET is one register where we have to be careful.
+However, it was mostly tested using glxgears which does not stress the
+driver very much. Going through the various 3D screensavers one by one
+reveals a bug where certain models turn green if compositing is enabled.
+
+It seems that if we slightly alter the values passed to R128_SETUP_CNTL
+and R128_PM4_VC_FPU_SETUP, the 3D driver will be happy and compositing
+will still work. The proper way would be to constantly save and restore
+register values but this showed poor performance when dragging 3D
+windows across the screen.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128_exa_render.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/src/r128_exa_render.c b/src/r128_exa_render.c
+index f00536e..cb9f929 100644
+--- a/src/r128_exa_render.c
++++ b/src/r128_exa_render.c
+@@ -350,7 +350,7 @@ do { \
+ R128_TEX_MAP_ALPHA_IN_TEXTURE | \
+ R128_TEX_CACHE_LINE_SIZE_4QW); \
+ OUT_RING_REG(R128_SETUP_CNTL, \
+- R128_COLOR_SOLID_COLOR | \
++ R128_COLOR_GOURAUD | \
+ R128_PRIM_TYPE_TRI | \
+ R128_TEXTURE_ST_MULT_W | \
+ R128_STARTING_VERTEX_1 | \
+@@ -358,9 +358,9 @@ do { \
+ R128_SUB_PIX_4BITS); \
+ OUT_RING_REG(R128_PM4_VC_FPU_SETUP, \
+ R128_FRONT_DIR_CCW | \
+- R128_BACKFACE_CULL | \
++ R128_BACKFACE_SOLID | \
+ R128_FRONTFACE_SOLID | \
+- R128_FPU_COLOR_SOLID | \
++ R128_FPU_COLOR_GOURAUD | \
+ R128_FPU_SUB_PIX_4BITS | \
+ R128_FPU_MODE_3D | \
+ R128_TRAP_BITS_DISABLE | \
+--
+2.2.2
+
+
+From 9eb693640136bc8bcbe706d642519b4eb23286d4 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 27 Nov 2013 18:14:43 -0800
+Subject: Only declare PCITAG if we need it
+
+If libpciaccess is available, we do not need to declare the deprecated
+PciTag member because it will not be used.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128.h | 2 ++
+ src/r128_driver.c | 7 ++++---
+ 2 files changed, 6 insertions(+), 3 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index 90071b4..ee0b1d4 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -301,7 +301,9 @@ struct r128_2d_state {
+ typedef struct {
+ EntityInfoPtr pEnt;
+ pciVideoPtr PciInfo;
++#ifndef XSERVER_LIBPCIACCESS
+ PCITAG PciTag;
++#endif
+ int Chipset;
+ Bool Primary;
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 04a4537..0a0b82b 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -1957,9 +1957,6 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ }
+
+ info->PciInfo = xf86GetPciInfoForEntity(info->pEnt->index);
+- info->PciTag = pciTag(PCI_DEV_BUS(info->PciInfo),
+- PCI_DEV_DEV(info->PciInfo),
+- PCI_DEV_FUNC(info->PciInfo));
+
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "PCI bus %d card %d func %d\n",
+@@ -1968,6 +1965,10 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ PCI_DEV_FUNC(info->PciInfo));
+
+ #ifndef XSERVER_LIBPCIACCESS
++ info->PciTag = pciTag(PCI_DEV_BUS(info->PciInfo),
++ PCI_DEV_DEV(info->PciInfo),
++ PCI_DEV_FUNC(info->PciInfo));
++
+ if (xf86RegisterResources(info->pEnt->index, 0, ResNone)) goto fail;
+ if (xf86SetOperatingState(resVga, info->pEnt->index, ResUnusedOpr)) goto fail;
+
+--
+2.2.2
+
+
+From 5ef5812a7a272aa08543cfd9b633f33c35e34dbd Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Tue, 4 Mar 2014 01:43:00 -0800
+Subject: Remove overuse of COMPOSITE_SETUP()
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+COMPOSITE_SETUP() involves expensive register writes so
+R128EnterServer() should call it once when there are 3D windows and 0
+times when there are no 3D windows.
+
+Instead the code was calling it once when there were no 3D windows and
+arbitrarily many times when there were 3D windows.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Michel Dänzer <michel.daenzer@amd.com>
+---
+ src/r128_dri.c | 6 +++++-
+ src/r128_exa_render.c | 7 +------
+ 2 files changed, 6 insertions(+), 7 deletions(-)
+
+diff --git a/src/r128_dri.c b/src/r128_dri.c
+index ff7bbc2..2c905a4 100644
+--- a/src/r128_dri.c
++++ b/src/r128_dri.c
+@@ -308,7 +308,11 @@ static void R128EnterServer(ScreenPtr pScreen)
+ #endif
+ #ifdef USE_EXA
+ if (info->ExaDriver) exaMarkSync(pScreen);
+- info->state_2d.composite_setup = FALSE;
++ /* EXA and DRI are fighting over control of the texture hardware.
++ * That means we need to setup compositing when the server wakes
++ * up if a 3D app is running.
++ */
++ if (info->have3DWindows) info->state_2d.composite_setup = FALSE;
+ #endif
+ }
+
+diff --git a/src/r128_exa_render.c b/src/r128_exa_render.c
+index cb9f929..f00daf7 100644
+--- a/src/r128_exa_render.c
++++ b/src/r128_exa_render.c
+@@ -458,12 +458,7 @@ R128CCEPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
+
+ if (!info->state_2d.composite_setup) {
+ COMPOSITE_SETUP();
+- /* DRI and EXA are fighting over control of the texture hardware.
+- * That means we need to set up the compositing hardware every time
+- * while a 3D app is running and once after it closes.
+- */
+- if (!info->have3DWindows)
+- info->state_2d.composite_setup = TRUE;
++ info->state_2d.composite_setup = TRUE;
+ }
+
+ /* We cannot guarantee that this register will stay zero - DRI needs it too. */
+--
+2.2.2
+
+
+From 4efc87f41d770c753ddf7f54fe334b6dbd7daf79 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Mon, 28 Apr 2014 21:26:44 -0700
+Subject: Fix ScreenInit with noAccel
+
+Now that EXA is on by default, we must remember to turn it off again if
+acceleration is disabled.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_driver.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 0a0b82b..f425c3b 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -2314,6 +2314,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ miSetPixmapDepths ();
+
+ noAccel = xf86ReturnOptValBool(info->Options, OPTION_NOACCEL, FALSE);
++ if (noAccel) info->useEXA = FALSE;
+
+ #ifdef R128DRI
+ /* Setup DRI after visuals have been
+--
+2.2.2
+
+
+From 3ed5035074540785f820906529fcce3148e0b387 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 2 Jul 2014 02:18:48 -0700
+Subject: Port to RandR
+
+This rearranges the r128 code to use the Crtc and Output interfaces
+which should make the driver easier to maintain in the long run. User
+visible changes include DDC detection working in more cases and the
+ability to have multiple monitors with DRI.
+
+Some choices have been made to conserve memory. Modes can be switched up
+to the highest resolution in xorg.conf. If this is 1024x768 for example,
+the front buffer will be 1024x768 instead of 1024x1024. This means 90
+and 270 degree rotations will not work. However, scalings, reflection
+and 180 degree rotations can be set with the xrandr client program.
+Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=75629
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ configure.ac | 2 +-
+ src/Makefile.am | 3 +-
+ src/r128.h | 48 +-
+ src/r128_crtc.c | 476 ++++++++++++++++++++
+ src/r128_cursor.c | 294 ++++++------
+ src/r128_driver.c | 1287 +++++++++++------------------------------------------
+ src/r128_output.c | 465 +++++++++++++++++++
+ src/r128_probe.c | 1 -
+ src/r128_probe.h | 79 ++++
+ src/r128_video.c | 17 +-
+ 10 files changed, 1479 insertions(+), 1193 deletions(-)
+ create mode 100644 src/r128_crtc.c
+ create mode 100644 src/r128_output.c
+
+diff --git a/configure.ac b/configure.ac
+index 56554ec..3cc3113 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -76,7 +76,7 @@ XORG_DRIVER_CHECK_EXT(XF86MISC, xf86miscproto)
+ XORG_DRIVER_CHECK_EXT(DPMSExtension, xextproto)
+
+ # Obtain compiler/linker options for the driver dependencies
+-PKG_CHECK_MODULES(XORG, [xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES])
++PKG_CHECK_MODULES(XORG, [xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES])
+ PKG_CHECK_MODULES(XEXT, [xextproto >= 7.0.99.1],
+ HAVE_XEXTPROTO_71="yes"; AC_DEFINE(HAVE_XEXTPROTO_71, 1, [xextproto 7.1 available]),
+ HAVE_XEXTPROTO_71="no")
+diff --git a/src/Makefile.am b/src/Makefile.am
+index 23e6c49..e4618ea 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -41,7 +41,8 @@ r128_drv_la_LDFLAGS = -module -avoid-version
+ r128_drv_ladir = @moduledir@/drivers
+ r128_drv_la_SOURCES = \
+ r128_accel.c r128_cursor.c r128_dga.c r128_driver.c \
+- r128_video.c r128_misc.c r128_probe.c $(R128_EXA_SRCS) $(R128_DRI_SRCS)
++ r128_video.c r128_misc.c r128_crtc.c r128_output.c r128_probe.c \
++ $(R128_EXA_SRCS) $(R128_DRI_SRCS)
+
+ EXTRA_DIST = \
+ compat-api.h \
+diff --git a/src/r128.h b/src/r128.h
+index ee0b1d4..fe757f8 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -74,6 +74,7 @@
+ #endif
+
+ #include "fb.h"
++#include "xf86Crtc.h"
+
+ #include "compat-api.h"
+ #include "atipcirename.h"
+@@ -260,16 +261,6 @@ typedef struct {
+ DisplayModePtr mode;
+ } R128FBLayout;
+
+-typedef enum
+-{
+- MT_NONE,
+- MT_CRT,
+- MT_LCD,
+- MT_DFP,
+- MT_CTV,
+- MT_STV
+-} R128MonitorType;
+-
+ #ifdef USE_EXA
+ struct r128_2d_state {
+ Bool in_use;
+@@ -523,10 +514,10 @@ typedef struct {
+
+ Bool isDFP;
+ Bool isPro2;
+- I2CBusPtr pI2CBus;
+- CARD32 DDCReg;
++ Bool DDC;
+
+ Bool VGAAccess;
++ R128BIOSConnector BiosConnector[R128_MAX_BIOS_CONNECTOR];
+
+ /****** Added for dualhead support *******************/
+ BOOL HasCRTC2; /* M3/M4 */
+@@ -562,6 +553,39 @@ extern int R128MinBits(int val);
+
+ extern void R128InitVideo(ScreenPtr pScreen);
+
++extern void R128InitCommonRegisters(R128SavePtr save, R128InfoPtr info);
++extern void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
++extern Bool R128InitCrtcBase(xf86CrtcPtr crtc, R128SavePtr save, int x, int y);
++extern Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
++extern void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, double dot_clock);
++extern Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, R128InfoPtr info, DisplayModePtr mode);
++extern Bool R128InitCrtc2Base(xf86CrtcPtr crtc, R128SavePtr save, int x, int y);
++extern Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
++extern void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, double dot_clock);
++extern Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, R128InfoPtr info, DisplayModePtr mode);
++extern void R128RestoreCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreDDARegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestorePLL2Registers(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr restore);
++
++extern void r128_crtc_set_cursor_colors(xf86CrtcPtr crtc, int bg, int fg);
++extern void r128_crtc_set_cursor_position(xf86CrtcPtr crtc, int x, int y);
++extern void r128_crtc_show_cursor(xf86CrtcPtr crtc);
++extern void r128_crtc_hide_cursor(xf86CrtcPtr crtc);
++extern void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *src);
++
++extern Bool R128SetupConnectors(ScrnInfoPtr pScrn);
++extern Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask);
++extern void R128Blank(ScrnInfoPtr pScrn);
++extern void R128Unblank(ScrnInfoPtr pScrn);
++extern void R128DPMSSetOn(xf86OutputPtr output);
++extern void R128DPMSSetOff(xf86OutputPtr output);
++extern DisplayModePtr R128ProbeOutputModes(xf86OutputPtr output);
++
+ #ifdef R128DRI
+ extern Bool R128DRIScreenInit(ScreenPtr pScreen);
+ extern void R128DRICloseScreen(ScreenPtr pScreen);
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+new file mode 100644
+index 0000000..35e1fee
+--- /dev/null
++++ b/src/r128_crtc.c
+@@ -0,0 +1,476 @@
++/*
++ * Copyright 2000 ATI Technologies Inc., Markham, Ontario, and
++ * VA Linux Systems Inc., Fremont, California.
++ *
++ * 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 on 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
++ * NON-INFRINGEMENT. IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
++ * THEIR 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.
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include <string.h>
++#include <stdio.h>
++
++#include "xf86.h"
++#include "xf86Modes.h"
++
++#include "r128.h"
++#include "r128_probe.h"
++#include "r128_reg.h"
++
++static void r128_crtc_load_lut(xf86CrtcPtr crtc);
++
++static void r128_crtc_dpms(xf86CrtcPtr crtc, int mode)
++{
++ int mask;
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ /* XXX: The HSYNC and VSYNC bits for CRTC2 don't exist on the r128? */
++ mask = r128_crtc->crtc_id ? R128_CRTC2_DISP_DIS : (R128_CRTC_DISPLAY_DIS | R128_CRTC_HSYNC_DIS | R128_CRTC_VSYNC_DIS);
++
++ switch (mode) {
++ case DPMSModeOn:
++ if (r128_crtc->crtc_id) {
++ OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~mask);
++ } else {
++ OUTREGP(R128_CRTC_EXT_CNTL, 0, ~mask);
++ }
++ break;
++ case DPMSModeStandby:
++ if (r128_crtc->crtc_id) {
++ OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_DISP_DIS, ~mask);
++ } else {
++ OUTREGP(R128_CRTC_EXT_CNTL, (R128_CRTC_DISPLAY_DIS | R128_CRTC_HSYNC_DIS), ~mask);
++ }
++ break;
++ case DPMSModeSuspend:
++ if (r128_crtc->crtc_id) {
++ OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_DISP_DIS, ~mask);
++ } else {
++ OUTREGP(R128_CRTC_EXT_CNTL, (R128_CRTC_DISPLAY_DIS | R128_CRTC_VSYNC_DIS), ~mask);
++ }
++ break;
++ case DPMSModeOff:
++ if (r128_crtc->crtc_id) {
++ OUTREGP(R128_CRTC2_GEN_CNTL, mask, ~mask);
++ } else {
++ OUTREGP(R128_CRTC_EXT_CNTL, mask, ~mask);
++ }
++ break;
++ }
++
++ if (mode != DPMSModeOff)
++ r128_crtc_load_lut(crtc);
++}
++
++void r128_crtc_load_lut(xf86CrtcPtr crtc)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ int i;
++
++ if (!crtc->enabled)
++ return;
++
++ PAL_SELECT(r128_crtc->crtc_id);
++
++ for (i = 0; i < 256; i++) {
++ OUTPAL(i, r128_crtc->lut_r[i], r128_crtc->lut_g[i], r128_crtc->lut_b[i]);
++ }
++}
++
++static Bool r128_crtc_mode_fixup(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayModePtr adjusted_mode)
++{
++ return TRUE;
++}
++
++static void r128_crtc_mode_prepare(xf86CrtcPtr crtc)
++{
++ r128_crtc_dpms(crtc, DPMSModeOff);
++}
++
++static void r128_crtc_mode_set(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayModePtr adjusted_mode, int x, int y)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ R128InfoPtr info = R128PTR(pScrn);
++ R128OutputType otype = OUTPUT_NONE;
++
++ double dot_clock = adjusted_mode->Clock / 1000.0;
++ int i;
++
++ if (r128_crtc->cursor_offset) r128_crtc_hide_cursor(crtc);
++ xf86PrintModeline(pScrn->scrnIndex, adjusted_mode);
++ R128InitCommonRegisters(&info->ModeReg, info);
++
++ for (i = 0; i < xf86_config->num_output; i++) {
++ xf86OutputPtr output = xf86_config->output[i];
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
++ if (output->crtc == crtc)
++ otype = r128_output->type;
++ }
++
++ switch (r128_crtc->crtc_id) {
++ case 0:
++ R128InitCrtcRegisters(pScrn, &info->ModeReg, adjusted_mode, info);
++ R128InitCrtcBase(crtc, &info->ModeReg, x, y);
++ if (dot_clock) {
++ R128InitPLLRegisters(pScrn, &info->ModeReg, &info->pll, dot_clock);
++ R128InitDDARegisters(pScrn, &info->ModeReg, &info->pll, info, adjusted_mode);
++ } else {
++ info->ModeReg.ppll_ref_div = info->SavedReg.ppll_ref_div;
++ info->ModeReg.ppll_div_3 = info->SavedReg.ppll_div_3;
++ info->ModeReg.htotal_cntl = info->SavedReg.htotal_cntl;
++ info->ModeReg.dda_config = info->SavedReg.dda_config;
++ info->ModeReg.dda_on_off = info->SavedReg.dda_on_off;
++ }
++ break;
++ case 1:
++ R128InitCrtc2Registers(pScrn, &info->ModeReg, adjusted_mode, info);
++ R128InitCrtc2Base(crtc, &info->ModeReg, x, y);
++ if (dot_clock) {
++ R128InitPLL2Registers(pScrn, &info->ModeReg, &info->pll, dot_clock);
++ R128InitDDA2Registers(pScrn, &info->ModeReg, &info->pll, info, adjusted_mode);
++ }
++ break;
++ }
++
++ if (otype == OUTPUT_DVI || otype == OUTPUT_LVDS)
++ R128InitFPRegisters(&info->SavedReg, &info->ModeReg, adjusted_mode, info);
++ R128RestoreCommonRegisters(pScrn, &info->ModeReg);
++
++ switch (r128_crtc->crtc_id) {
++ case 0:
++ R128RestoreDDARegisters(pScrn, &info->ModeReg);
++ R128RestoreCrtcRegisters(pScrn, &info->ModeReg);
++ R128RestorePLLRegisters(pScrn, &info->ModeReg);
++ break;
++ case 1:
++ R128RestoreDDA2Registers(pScrn, &info->ModeReg);
++ R128RestoreCrtc2Registers(pScrn, &info->ModeReg);
++ R128RestorePLL2Registers(pScrn, &info->ModeReg);
++ break;
++ }
++
++ if (otype == OUTPUT_DVI || otype == OUTPUT_LVDS)
++ R128RestoreFPRegisters(pScrn, &info->ModeReg);
++
++ /* XXX: InitFPRegisters looks similar to radeon's InitRMXRegisters so
++ * maybe it should be called from mode_set in the output code.
++ */
++ if (r128_crtc->cursor_offset) r128_crtc_show_cursor(crtc);
++}
++
++static void r128_crtc_mode_commit(xf86CrtcPtr crtc)
++{
++ r128_crtc_dpms(crtc, DPMSModeOn);
++}
++
++static void r128_crtc_gamma_set(xf86CrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue, int size)
++{
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ int i;
++
++ for (i = 0; i < 256; i++) {
++ r128_crtc->lut_r[i] = red[i] >> 8;
++ r128_crtc->lut_g[i] = green[i] >> 8;
++ r128_crtc->lut_b[i] = blue[i] >> 8;
++ }
++
++ r128_crtc_load_lut(crtc);
++}
++
++static Bool r128_crtc_lock(xf86CrtcPtr crtc)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++
++#ifdef HAVE_XAA_H
++ if (info->accel) info->accel->Sync(pScrn);
++#endif
++#ifdef USE_EXA
++ if (info->ExaDriver) exaWaitSync(pScreen);
++#endif
++
++ return FALSE;
++}
++
++static void r128_crtc_unlock(xf86CrtcPtr crtc)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++
++#ifdef HAVE_XAA_H
++ if (info->accel) info->accel->Sync(pScrn);
++#endif
++#ifdef USE_EXA
++ if (info->ExaDriver) exaWaitSync(pScreen);
++#endif
++}
++
++#ifdef HAVE_XAA_H
++static FBLinearPtr r128_xf86AllocateOffscreenLinear(ScreenPtr pScreen, int length, int granularity,
++ MoveLinearCallbackProcPtr moveCB,
++ RemoveLinearCallbackProcPtr removeCB,
++ pointer privData)
++{
++ FBLinearPtr linear;
++ int max_size;
++
++ linear = xf86AllocateOffscreenLinear(pScreen, length, granularity, moveCB, removeCB, privData);
++ if (linear != NULL) return linear;
++
++ /* The above allocation did not succeed, so purge unlocked stuff and try again. */
++ xf86QueryLargestOffscreenLinear(pScreen, &max_size, granularity, PRIORITY_EXTREME);
++
++ if (max_size < length) return NULL;
++ xf86PurgeUnlockedOffscreenAreas(pScreen);
++
++ linear = xf86AllocateOffscreenLinear(pScreen, length, granularity, moveCB, removeCB, privData);
++ return linear;
++}
++#endif
++
++static void *r128_crtc_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ unsigned long rotate_offset = 0;
++ unsigned long rotate_pitch;
++ int cpp = pScrn->bitsPerPixel / 8;
++ int align = 4096;
++ int size;
++
++ rotate_pitch = pScrn->displayWidth * cpp;
++ size = rotate_pitch * height;
++
++#ifdef USE_EXA
++ if (info->ExaDriver) {
++ assert(r128_crtc->rotate_mem_exa == NULL);
++ r128_crtc->rotate_mem_exa = exaOffscreenAlloc(pScreen, size, align, TRUE, NULL, NULL);
++
++ if (r128_crtc->rotate_mem_exa == NULL) {
++ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
++ "Couldn't allocate shadow memory for rotated CRTC\n");
++ return NULL;
++ }
++
++ rotate_offset = r128_crtc->rotate_mem_exa->offset;
++ }
++#endif
++#ifdef HAVE_XAA_H
++ if (info->accel) {
++ size = (size + cpp - 1) / cpp;
++ align = (align + cpp - 1) / cpp;
++
++ assert(r128_crtc->rotate_mem_xaa == NULL);
++ r128_crtc->rotate_mem_xaa = r128_xf86AllocateOffscreenLinear(pScreen, size, align, NULL, NULL, NULL);
++
++ if (r128_crtc->rotate_mem_exa == NULL) {
++ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
++ "Couldn't allocate shadow memory for rotated CRTC\n");
++ return NULL;
++ }
++
++ rotate_offset = r128_crtc->rotate_mem_xaa->offset * cpp;
++ }
++#endif
++
++ /* If allocations failed or if there was no accel. */
++ if (rotate_offset == 0)
++ return NULL;
++
++ return info->FB + rotate_offset;
++}
++
++static PixmapPtr r128_crtc_shadow_create(xf86CrtcPtr crtc, void *data, int width, int height)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ PixmapPtr rotate_pixmap;
++ unsigned long rotate_pitch;
++ int cpp = pScrn->bitsPerPixel / 8;
++
++ if (!data) data = r128_crtc_shadow_allocate(crtc, width, height);
++
++ rotate_pitch = pScrn->displayWidth * cpp;
++ rotate_pixmap = GetScratchPixmapHeader(xf86ScrnToScreen(pScrn),
++ width, height,
++ pScrn->depth,
++ pScrn->bitsPerPixel,
++ rotate_pitch,
++ data);
++
++ if (rotate_pixmap == NULL) {
++ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
++ "Couldn't allocate shadow memory for rotated CRTC\n");
++ return NULL;
++ }
++
++ return rotate_pixmap;
++}
++
++static void r128_crtc_shadow_destroy(xf86CrtcPtr crtc, PixmapPtr rotate_pixmap, void *data)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ if (rotate_pixmap) FreeScratchPixmapHeader(rotate_pixmap);
++
++ if (data) {
++#ifdef USE_EXA
++ if (info->ExaDriver && r128_crtc->rotate_mem_exa != NULL) {
++ exaOffscreenFree(pScreen, r128_crtc->rotate_mem_exa);
++ r128_crtc->rotate_mem_exa = NULL;
++ }
++#endif
++#ifdef HAVE_XAA_H
++ if (info->accel) {
++ xf86FreeOffscreenLinear(r128_crtc->rotate_mem_xaa);
++ r128_crtc->rotate_mem_xaa = NULL;
++ }
++#endif
++ }
++}
++
++static const xf86CrtcFuncsRec r128_crtc_funcs = {
++ .dpms = r128_crtc_dpms,
++ .save = NULL,
++ .restore = NULL,
++ .mode_fixup = r128_crtc_mode_fixup,
++ .prepare = r128_crtc_mode_prepare,
++ .mode_set = r128_crtc_mode_set,
++ .commit = r128_crtc_mode_commit,
++ .gamma_set = r128_crtc_gamma_set,
++ .lock = r128_crtc_lock,
++ .unlock = r128_crtc_unlock,
++ .shadow_create = r128_crtc_shadow_create,
++ .shadow_allocate = r128_crtc_shadow_allocate,
++ .shadow_destroy = r128_crtc_shadow_destroy,
++ .set_cursor_colors = r128_crtc_set_cursor_colors,
++ .set_cursor_position = r128_crtc_set_cursor_position,
++ .show_cursor = r128_crtc_show_cursor,
++ .hide_cursor = r128_crtc_hide_cursor,
++ .load_cursor_image = r128_crtc_load_cursor_image,
++ .destroy = NULL,
++};
++
++Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask)
++{
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++
++ if (mask & 1) {
++ if (pR128Ent->Controller[0])
++ return TRUE;
++
++ pR128Ent->pCrtc[0] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
++ if (!pR128Ent->pCrtc[0])
++ return FALSE;
++
++ pR128Ent->Controller[0] = xnfcalloc(sizeof(R128CrtcPrivateRec), 1);
++ if (!pR128Ent->Controller[0])
++ return FALSE;
++
++ pR128Ent->pCrtc[0]->driver_private = pR128Ent->Controller[0];
++ pR128Ent->Controller[0]->crtc_id = 0;
++ }
++
++ if (mask & 2) {
++ if (!info->HasCRTC2)
++ return TRUE;
++
++ pR128Ent->pCrtc[1] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
++ if (!pR128Ent->pCrtc[1])
++ return FALSE;
++
++ pR128Ent->Controller[1] = xnfcalloc(sizeof(R128CrtcPrivateRec), 1);
++ if (!pR128Ent->Controller[1]) {
++ free(pR128Ent->Controller[0]);
++ return FALSE;
++ }
++
++ pR128Ent->pCrtc[1]->driver_private = pR128Ent->Controller[1];
++ pR128Ent->Controller[1]->crtc_id = 1;
++ }
++
++ return TRUE;
++}
++
++void R128Blank(ScrnInfoPtr pScrn)
++{
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ xf86OutputPtr output;
++ xf86CrtcPtr crtc;
++ int o, c;
++
++ for (c = 0; c < xf86_config->num_crtc; c++) {
++ crtc = xf86_config->crtc[c];
++ for (o = 0; o < xf86_config->num_output; o++) {
++ output = xf86_config->output[o];
++ if (output->crtc != crtc)
++ continue;
++
++ output->funcs->dpms(output, DPMSModeOff);
++ }
++ crtc->funcs->dpms(crtc, DPMSModeOff);
++ }
++}
++
++void R128Unblank(ScrnInfoPtr pScrn)
++{
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ xf86OutputPtr output;
++ xf86CrtcPtr crtc;
++ int o, c;
++
++ for (c = 0; c < xf86_config->num_crtc; c++) {
++ crtc = xf86_config->crtc[c];
++ if (!crtc->enabled)
++ continue;
++ crtc->funcs->dpms(crtc, DPMSModeOn);
++ for (o = 0; o < xf86_config->num_output; o++) {
++ output = xf86_config->output[o];
++ if (output->crtc != crtc)
++ continue;
++
++ output->funcs->dpms(output, DPMSModeOn);
++ }
++ }
++}
+diff --git a/src/r128_cursor.c b/src/r128_cursor.c
+index b76913c..ad6752f 100644
+--- a/src/r128_cursor.c
++++ b/src/r128_cursor.c
+@@ -59,6 +59,9 @@
+ #include "exa.h"
+ #endif
+
++#define CURSOR_WIDTH 64
++#define CURSOR_HEIGHT 64
++
+ #if X_BYTE_ORDER == X_BIG_ENDIAN
+ #define P_SWAP32( a , b ) \
+ ((char *)a)[0] = ((char *)b)[3]; \
+@@ -73,84 +76,121 @@
+ ((char *)a)[3] = ((char *)b)[2]
+ #endif
+
++void r128_crtc_show_cursor(xf86CrtcPtr crtc)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ int crtc_id = r128_crtc->crtc_id;
++
++ switch (crtc_id) {
++ case 0:
++ OUTREGP(R128_CRTC_GEN_CNTL, R128_CRTC_CUR_EN, ~R128_CRTC_CUR_EN);
++ break;
++ case 1:
++ OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_CUR_EN, ~R128_CRTC2_CUR_EN);
++ break;
++ default:
++ return;
++ }
++}
+
+-/* Set cursor foreground and background colors. */
+-static void R128SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
++void r128_crtc_hide_cursor(xf86CrtcPtr crtc)
+ {
+- R128InfoPtr info = R128PTR(pScrn);
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
++ int crtc_id = r128_crtc->crtc_id;
+
+- if(info->IsSecondary)
+- {
++ switch (crtc_id) {
++ case 0:
++ OUTREGP(R128_CRTC_GEN_CNTL, 0, ~R128_CRTC_CUR_EN);
++ break;
++ case 1:
++ OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~R128_CRTC2_CUR_EN);
++ break;
++ default:
++ return;
++ }
++}
++
++void r128_crtc_set_cursor_colors(xf86CrtcPtr crtc, int bg, int fg)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ int crtc_id = r128_crtc->crtc_id;
++
++ switch (crtc_id) {
++ case 0:
++ OUTREG(R128_CUR_CLR0, bg);
++ OUTREG(R128_CUR_CLR1, fg);
++ break;
++ case 1:
+ OUTREG(R128_CUR2_CLR0, bg);
+ OUTREG(R128_CUR2_CLR1, fg);
+- }
+- else
+- {
+- OUTREG(R128_CUR_CLR0, bg);
+- OUTREG(R128_CUR_CLR1, fg);
++ break;
++ default:
++ return;
+ }
+ }
+
+-/* Set cursor position to (x,y) with offset into cursor bitmap at
+- (xorigin,yorigin). */
+-static void R128SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
++void r128_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
+ {
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+- xf86CursorInfoPtr cursor = info->cursor;
+- int xorigin = 0;
+- int yorigin = 0;
+- int total_y = pScrn->frameY1 - pScrn->frameY0;
+-
+- if (x < 0) xorigin = -x;
+- if (y < 0) yorigin = -y;
+- if (y > total_y) y = total_y;
+- if (info->Flags & V_DBLSCAN) y *= 2;
+- if (xorigin >= cursor->MaxWidth) xorigin = cursor->MaxWidth - 1;
+- if (yorigin >= cursor->MaxHeight) yorigin = cursor->MaxHeight - 1;
+-
+- if(!info->IsSecondary)
+- {
+- OUTREG(R128_CUR_HORZ_VERT_OFF, R128_CUR_LOCK | (xorigin << 16) | yorigin);
+- OUTREG(R128_CUR_HORZ_VERT_POSN, (R128_CUR_LOCK
+- | ((xorigin ? 0 : x) << 16)
+- | (yorigin ? 0 : y)));
+- OUTREG(R128_CUR_OFFSET, info->cursor_start + yorigin * 16);
+- }
+- else
+- {
+- OUTREG(R128_CUR2_HORZ_VERT_OFF, (R128_CUR2_LOCK
+- | (xorigin << 16)
+- | yorigin));
+- OUTREG(R128_CUR2_HORZ_VERT_POSN, (R128_CUR2_LOCK
+- | ((xorigin ? 0 : x) << 16)
+- | (yorigin ? 0 : y)));
+- OUTREG(R128_CUR2_OFFSET,
+- info->cursor_start + pScrn->fbOffset + yorigin * 16);
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ unsigned char *R128MMIO = info->MMIO;
++ int crtc_id = r128_crtc->crtc_id;
++
++ int xorigin = 0, yorigin = 0;
++ DisplayModePtr mode = &crtc->mode;
++
++ if (x < 0) xorigin = -x + 1;
++ if (y < 0) yorigin = -y + 1;
++ if (xorigin >= CURSOR_WIDTH) xorigin = CURSOR_WIDTH - 1;
++ if (yorigin >= CURSOR_HEIGHT) yorigin = CURSOR_HEIGHT - 1;
++
++ if (mode->Flags & V_INTERLACE)
++ y /= 2;
++ else if (mode->Flags & V_DBLSCAN)
++ y *= 2;
++
++ if(crtc_id == 0) {
++ OUTREG(R128_CUR_HORZ_VERT_OFF, (R128_CUR_LOCK | (xorigin << 16) | yorigin));
++ OUTREG(R128_CUR_HORZ_VERT_POSN, (R128_CUR_LOCK | ((xorigin ? 0 : x) << 16) | (yorigin ? 0 : y)));
++ OUTREG(R128_CUR_OFFSET, r128_crtc->cursor_offset + pScrn->fbOffset + yorigin * 16);
++ } else if (crtc_id == 1) {
++ OUTREG(R128_CUR2_HORZ_VERT_OFF, (R128_CUR2_LOCK | (xorigin << 16) | yorigin));
++ OUTREG(R128_CUR2_HORZ_VERT_POSN, (R128_CUR2_LOCK | ((xorigin ? 0 : x) << 16) | (yorigin ? 0 : y)));
++ OUTREG(R128_CUR2_OFFSET, r128_crtc->cursor_offset + pScrn->fbOffset + yorigin * 16);
+ }
+ }
+
+-/* Copy cursor image from `image' to video memory. R128SetCursorPosition
+- will be called after this, so we can ignore xorigin and yorigin. */
+-static void R128LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *image)
++void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *src)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++ int crtc_id = r128_crtc->crtc_id;
++
++
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 *s = (pointer)image;
+- CARD32 *d = (pointer)((CARD8*)info->FB + info->cursor_start);
++ CARD32 *s = (pointer)src;
++ CARD32 *d = (pointer)(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset);
++ CARD32 save1 = 0;
++ CARD32 save2 = 0;
+ int y;
+- CARD32 save;
+
+- if(!info->IsSecondary)
+- {
+- save = INREG(R128_CRTC_GEN_CNTL);
+- OUTREG(R128_CRTC_GEN_CNTL, save & (CARD32)~R128_CRTC_CUR_EN);
+- }
+- else
+- {
+- save = INREG(R128_CRTC2_GEN_CNTL);
+- OUTREG(R128_CRTC2_GEN_CNTL, save & (CARD32)~R128_CRTC2_CUR_EN);
++ if (crtc_id == 0) {
++ save1 = INREG(R128_CRTC_GEN_CNTL);
++ OUTREG(R128_CRTC_GEN_CNTL, save1 & (CARD32)~R128_CRTC_CUR_EN);
++ } else if (crtc_id == 1) {
++ save2 = INREG(R128_CRTC2_GEN_CNTL);
++ OUTREG(R128_CRTC2_GEN_CNTL, save2 & (CARD32)~R128_CRTC2_CUR_EN);
+ }
+
+ #if X_BYTE_ORDER == X_BIG_ENDIAN
+@@ -197,59 +237,10 @@ static void R128LoadCursorImage(ScrnInfoPtr pScrn, unsigned char *image)
+ }
+ #endif
+
+- /* Set the area after the cursor to be all transparent so that we
+- won't display corrupted cursors on the screen */
+- for (y = 0; y < 64; y++) {
+- *d++ = 0xffffffff; /* The AND bits */
+- *d++ = 0xffffffff;
+- *d++ = 0x00000000; /* The XOR bits */
+- *d++ = 0x00000000;
+- }
+-
+-
+- if(!info->IsSecondary)
+- OUTREG(R128_CRTC_GEN_CNTL, save);
++ if (crtc_id == 0)
++ OUTREG(R128_CRTC_GEN_CNTL, save1);
+ else
+- OUTREG(R128_CRTC2_GEN_CNTL, save);
+-
+-}
+-
+-/* Hide hardware cursor. */
+-static void R128HideCursor(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+-
+- if(info->IsSecondary)
+- OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~R128_CRTC2_CUR_EN);
+- else
+- OUTREGP(R128_CRTC_GEN_CNTL, 0, ~R128_CRTC_CUR_EN);
+-}
+-
+-/* Show hardware cursor. */
+-static void R128ShowCursor(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+-
+- if(info->IsSecondary)
+- {
+- OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_CUR_EN,
+- ~R128_CRTC2_CUR_EN);
+- }
+- else
+- {
+- OUTREGP(R128_CRTC_GEN_CNTL, R128_CRTC_CUR_EN, ~R128_CRTC_CUR_EN);
+- }
+-}
+-
+-/* Determine if hardware cursor is in use. */
+-static Bool R128UseHWCursor(ScreenPtr pScreen, CursorPtr pCurs)
+-{
+- ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- return info->cursor_start ? TRUE : FALSE;
++ OUTREG(R128_CRTC2_GEN_CNTL, save2);
+ }
+
+ /* Initialize hardware cursor support. */
+@@ -257,77 +248,72 @@ Bool R128CursorInit(ScreenPtr pScreen)
+ {
+ ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+ R128InfoPtr info = R128PTR(pScrn);
+- xf86CursorInfoPtr cursor;
+ FBAreaPtr fbarea = NULL;
+ #ifdef USE_EXA
+ ExaOffscreenArea* osArea = NULL;
+ #else
+ void* osArea = NULL;
+ #endif
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ CARD32 cursor_offset = 0;
++ int cpp = info->CurrentLayout.pixel_bytes;
+ int width;
++ int width_bytes;
+ int height;
+ int size;
++ int size_bytes;
++ int c;
+
+- int cpp = info->CurrentLayout.pixel_bytes;
+-
+- if (!(cursor = info->cursor = xf86CreateCursorInfoRec())) return FALSE;
+-
+- cursor->MaxWidth = 64;
+- cursor->MaxHeight = 64;
+- cursor->Flags = (HARDWARE_CURSOR_TRUECOLOR_AT_8BPP
+- | HARDWARE_CURSOR_SHOW_TRANSPARENT
+- | HARDWARE_CURSOR_UPDATE_UNHIDDEN
+-#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+- | HARDWARE_CURSOR_BIT_ORDER_MSBFIRST
+-#endif
+- | HARDWARE_CURSOR_INVERT_MASK
+- | HARDWARE_CURSOR_AND_SOURCE_WITH_MASK
+- | HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64
+- | HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK);
+-
+- cursor->SetCursorColors = R128SetCursorColors;
+- cursor->SetCursorPosition = R128SetCursorPosition;
+- cursor->LoadCursorImage = R128LoadCursorImage;
+- cursor->HideCursor = R128HideCursor;
+- cursor->ShowCursor = R128ShowCursor;
+- cursor->UseHWCursor = R128UseHWCursor;
+-
+- size = (cursor->MaxWidth/4) * cursor->MaxHeight;
++ size = CURSOR_WIDTH * CURSOR_HEIGHT / 4;
++ size_bytes = size * 2;
+ width = pScrn->displayWidth;
+- height = (size*2 + 1023) / pScrn->displayWidth;
++ width_bytes = width * (pScrn->bitsPerPixel / 8);
++ height = ((size_bytes * xf86_config->num_crtc) + width_bytes - 1) / width_bytes;
+
+ if(!info->useEXA) {
+ fbarea = xf86AllocateOffscreenArea(pScreen, width, height,
+ 16, NULL, NULL, NULL);
+
+- if (fbarea) {
+- info->cursor_start = R128_ALIGN((fbarea->box.x1
+- + width * fbarea->box.y1)
+- * cpp, 16);
+- info->cursor_end = info->cursor_start + size;
+- }
++ if (fbarea)
++ cursor_offset = R128_ALIGN((fbarea->box.x1 + width * fbarea->box.y1) * cpp, 16);
+ }
+ #ifdef USE_EXA
+ else {
+ osArea = exaOffscreenAlloc(pScreen, width * height, 16,
+ TRUE, NULL, NULL);
+
+- if (osArea) {
+- info->cursor_start = osArea->offset;
+- info->cursor_end = osArea->offset + osArea->size;
+- }
++ if (osArea)
++ cursor_offset = osArea->offset;
+ }
+ #endif
+
+ if ((!info->useEXA && !fbarea) || (info->useEXA && !osArea)) {
+- info->cursor_start = 0;
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Hardware cursor disabled"
+ " due to insufficient offscreen memory\n");
++ return FALSE;
++ } else {
++ for (c = 0; c < xf86_config->num_crtc; c++) {
++ xf86CrtcPtr crtc = xf86_config->crtc[c];
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ r128_crtc->cursor_offset = cursor_offset + (c * size);
++ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
++ "Will use %d kb for hardware cursor %d at offset 0x%08x\n",
++ (size_bytes * xf86_config->num_crtc) / 1024, c,
++ (unsigned int)r128_crtc->cursor_offset);
++ }
+ }
+
+- R128TRACE(("R128CursorInit (0x%08x-0x%08x)\n",
+- info->cursor_start, info->cursor_end));
+-
+- return xf86InitCursor(pScreen, cursor);
++ return xf86_cursors_init(pScreen, CURSOR_WIDTH, CURSOR_HEIGHT,
++ (HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
++ HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
++ HARDWARE_CURSOR_SHOW_TRANSPARENT |
++ HARDWARE_CURSOR_UPDATE_UNHIDDEN |
++#if X_BYTE_ORDER == X_LITTLE_ENDIAN
++ HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
++#endif
++ HARDWARE_CURSOR_INVERT_MASK |
++ HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK |
++ HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64));
+ }
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index f425c3b..9205328 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -84,6 +84,7 @@
+ /* X and server generic header files */
+ #include "xf86.h"
+ #include "xf86_OSproc.h"
++#include "xf86RandR12.h"
+ #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86RAC.h"
+ #include "xf86Resources.h"
+@@ -119,11 +120,6 @@ static Bool R128CloseScreen(CLOSE_SCREEN_ARGS_DECL);
+ static Bool R128SaveScreen(ScreenPtr pScreen, int mode);
+ static void R128Save(ScrnInfoPtr pScrn);
+ static void R128Restore(ScrnInfoPtr pScrn);
+-static Bool R128ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
+-static void R128DisplayPowerManagementSet(ScrnInfoPtr pScrn,
+- int PowerManagementMode, int flags);
+-static void R128DisplayPowerManagementSetLCD(ScrnInfoPtr pScrn,
+- int PowerManagementMode, int flags);
+
+ typedef enum {
+ OPTION_NOACCEL,
+@@ -258,6 +254,7 @@ static Bool R128MapMMIO(ScrnInfoPtr pScrn)
+ info->PciTag,
+ info->MMIOAddr,
+ R128_MMIOSIZE);
++ if (!info->MMIO) return FALSE;
+ #else
+ int err = pci_device_map_range(info->PciInfo,
+ info->MMIOAddr,
+@@ -274,7 +271,6 @@ static Bool R128MapMMIO(ScrnInfoPtr pScrn)
+ #endif
+ }
+
+- if (!info->MMIO) return FALSE;
+ return TRUE;
+ }
+
+@@ -402,78 +398,6 @@ void R128WaitForVerticalSync(ScrnInfoPtr pScrn)
+ }
+ }
+
+-/* Blank screen. */
+-static void R128Blank(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+-
+- if(!info->IsSecondary)
+- {
+- switch(info->DisplayType)
+- {
+- case MT_LCD:
+- OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_DISPLAY_DIS,
+- ~R128_LVDS_DISPLAY_DIS);
+- break;
+- case MT_CRT:
+- OUTREGP(R128_CRTC_EXT_CNTL, R128_CRTC_DISPLAY_DIS, ~R128_CRTC_DISPLAY_DIS);
+- break;
+- case MT_DFP:
+- OUTREGP(R128_FP_GEN_CNTL, R128_FP_BLANK_DIS, ~R128_FP_BLANK_DIS);
+- break;
+- case MT_NONE:
+- default:
+- break;
+- }
+- }
+- else
+- {
+- OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_DISP_DIS, ~R128_CRTC2_DISP_DIS);
+- }
+-}
+-
+-/* Unblank screen. */
+-static void R128Unblank(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+-
+- if(!info->IsSecondary)
+- {
+- switch(info->DisplayType)
+- {
+- case MT_LCD:
+- OUTREGP(R128_LVDS_GEN_CNTL, 0,
+- ~R128_LVDS_DISPLAY_DIS);
+- break;
+- case MT_CRT:
+- OUTREGP(R128_CRTC_EXT_CNTL, 0, ~R128_CRTC_DISPLAY_DIS);
+- break;
+- case MT_DFP:
+- OUTREGP(R128_FP_GEN_CNTL, 0, ~R128_FP_BLANK_DIS);
+- break;
+- case MT_NONE:
+- default:
+- break;
+- }
+- }
+- else
+- {
+- switch(info->DisplayType)
+- {
+- case MT_LCD:
+- case MT_DFP:
+- case MT_CRT:
+- OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~R128_CRTC2_DISP_DIS);
+- break;
+- case MT_NONE:
+- default:
+- break;
+- }
+- }
+-}
+-
+ /* Compute log base 2 of val. */
+ int R128MinBits(int val)
+ {
+@@ -1058,9 +982,9 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "Option \"Display\" ignored "
+ "(framebuffer device determines display type)\n");
+- else if (info->IsPrimary || info->IsSecondary)
++ else if (!Display)
+ info->BIOSDisplay = R128_DUALHEAD;
+- else if (!Display || !xf86NameCmp(Display, "FP"))
++ else if (!xf86NameCmp(Display, "FP"))
+ info->BIOSDisplay = R128_BIOS_DISPLAY_FP;
+ else if (!xf86NameCmp(Display, "BIOS"))
+ info->BIOSDisplay = INREG8(R128_BIOS_5_SCRATCH);
+@@ -1079,9 +1003,6 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ info->BIOSDisplay = R128_BIOS_DISPLAY_CRT;
+ }
+
+- R128MMIO = NULL;
+- R128UnmapMMIO(pScrn);
+-
+ /* RAM */
+ switch (info->MemCntl & 0x3) {
+ case 0: /* SDR SGRAM 1:1 */
+@@ -1256,6 +1177,7 @@ static Bool R128PreInitDDC(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ #endif
+
+ if (!xf86LoadSubModule(pScrn, "ddc")) return FALSE;
++ if (!xf86LoadSubModule(pScrn, "i2c")) return FALSE;
+
+ #if defined(__powerpc__) || defined(__alpha__) || defined(__sparc__)
+ /* Int10 is broken on PPC and some Alphas */
+@@ -1281,468 +1203,6 @@ static Bool R128PreInitGamma(ScrnInfoPtr pScrn)
+ return TRUE;
+ }
+
+-static void
+-R128I2CGetBits(I2CBusPtr b, int *Clock, int *data)
+-{
+- ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex];
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned long val;
+- unsigned char *R128MMIO = info->MMIO;
+-
+- /* Get the result. */
+- val = INREG(info->DDCReg);
+- *Clock = (val & R128_GPIO_MONID_Y_3) != 0;
+- *data = (val & R128_GPIO_MONID_Y_0) != 0;
+-
+-}
+-
+-static void
+-R128I2CPutBits(I2CBusPtr b, int Clock, int data)
+-{
+- ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex];
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned long val;
+- unsigned char *R128MMIO = info->MMIO;
+-
+- val = INREG(info->DDCReg)
+- & ~(CARD32)(R128_GPIO_MONID_EN_0 | R128_GPIO_MONID_EN_3);
+- val |= (Clock ? 0:R128_GPIO_MONID_EN_3);
+- val |= (data ? 0:R128_GPIO_MONID_EN_0);
+- OUTREG(info->DDCReg, val);
+-}
+-
+-
+-static Bool
+-R128I2cInit(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- if ( !xf86LoadSubModule(pScrn, "i2c") ) {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "Failed to load i2c module\n");
+- return FALSE;
+- }
+-
+- info->pI2CBus = xf86CreateI2CBusRec();
+- if(!info->pI2CBus) return FALSE;
+-
+- info->pI2CBus->BusName = "DDC";
+- info->pI2CBus->scrnIndex = pScrn->scrnIndex;
+- info->DDCReg = R128_GPIO_MONID;
+- info->pI2CBus->I2CPutBits = R128I2CPutBits;
+- info->pI2CBus->I2CGetBits = R128I2CGetBits;
+- info->pI2CBus->AcknTimeout = 5;
+-
+- if (!xf86I2CBusInit(info->pI2CBus)) {
+- return FALSE;
+- }
+- return TRUE;
+-}
+-
+-/* return TRUE is a DFP is indeed connected to a DVI port */
+-static Bool R128GetDFPInfo(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- int i;
+- xf86MonPtr MonInfo = NULL;
+- xf86MonPtr ddc;
+- unsigned char *R128MMIO = info->MMIO;
+-
+- if(!R128I2cInit(pScrn)){
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "I2C initialization failed!\n");
+- }
+-
+- OUTREG(info->DDCReg, (INREG(info->DDCReg)
+- | R128_GPIO_MONID_MASK_0 | R128_GPIO_MONID_MASK_3));
+-
+- OUTREG(info->DDCReg, INREG(info->DDCReg)
+- & ~(CARD32)(R128_GPIO_MONID_A_0 | R128_GPIO_MONID_A_3));
+-
+- MonInfo = xf86DoEDID_DDC2(XF86_SCRN_ARG(pScrn), info->pI2CBus);
+- if(!MonInfo) {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "No DFP detected\n");
+- return FALSE;
+- }
+- xf86SetDDCproperties(pScrn, MonInfo);
+- ddc = pScrn->monitor->DDC;
+-
+- for(i=0; i<4; i++)
+- {
+- if((ddc->det_mon[i].type == 0) &&
+- (ddc->det_mon[i].section.d_timings.h_active > 0) &&
+- (ddc->det_mon[i].section.d_timings.v_active > 0))
+- {
+- info->PanelXRes =
+- ddc->det_mon[i].section.d_timings.h_active;
+- info->PanelYRes =
+- ddc->det_mon[i].section.d_timings.v_active;
+-
+- info->HOverPlus =
+- ddc->det_mon[i].section.d_timings.h_sync_off;
+- info->HSyncWidth =
+- ddc->det_mon[i].section.d_timings.h_sync_width;
+- info->HBlank =
+- ddc->det_mon[i].section.d_timings.h_blanking;
+- info->VOverPlus =
+- ddc->det_mon[i].section.d_timings.v_sync_off;
+- info->VSyncWidth =
+- ddc->det_mon[i].section.d_timings.v_sync_width;
+- info->VBlank =
+- ddc->det_mon[i].section.d_timings.v_blanking;
+- }
+- }
+- return TRUE;
+-}
+-
+-
+-static void R128SetSyncRangeFromEdid(ScrnInfoPtr pScrn, int flag)
+-{
+- int i;
+- xf86MonPtr ddc = pScrn->monitor->DDC;
+- if(flag) /*HSync*/
+- {
+- for(i=0; i<4; i++)
+- {
+- if(ddc->det_mon[i].type == DS_RANGES)
+- {
+- pScrn->monitor->nHsync = 1;
+- pScrn->monitor->hsync[0].lo =
+- ddc->det_mon[i].section.ranges.min_h;
+- pScrn->monitor->hsync[0].hi =
+- ddc->det_mon[i].section.ranges.max_h;
+- return;
+- }
+- }
+- /*if no sync ranges detected in detailed timing table,
+- let's try to derive them from supported VESA modes
+- Are we doing too much here!!!?
+- **/
+- i = 0;
+- if(ddc->timings1.t1 & 0x02) /*800x600@56*/
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 35.2;
+- i++;
+- }
+- if(ddc->timings1.t1 & 0x04) /*640x480@75*/
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 37.5;
+- i++;
+- }
+- if((ddc->timings1.t1 & 0x08) || (ddc->timings1.t1 & 0x01))
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 37.9;
+- i++;
+- }
+- if(ddc->timings1.t2 & 0x40)
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 46.9;
+- i++;
+- }
+- if((ddc->timings1.t2 & 0x80) || (ddc->timings1.t2 & 0x08))
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 48.1;
+- i++;
+- }
+- if(ddc->timings1.t2 & 0x04)
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 56.5;
+- i++;
+- }
+- if(ddc->timings1.t2 & 0x02)
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 60.0;
+- i++;
+- }
+- if(ddc->timings1.t2 & 0x01)
+- {
+- pScrn->monitor->hsync[i].lo =
+- pScrn->monitor->hsync[i].hi = 64.0;
+- i++;
+- }
+- pScrn->monitor->nHsync = i;
+- }
+- else /*Vrefresh*/
+- {
+- for(i=0; i<4; i++)
+- {
+- if(ddc->det_mon[i].type == DS_RANGES)
+- {
+- pScrn->monitor->nVrefresh = 1;
+- pScrn->monitor->vrefresh[0].lo =
+- ddc->det_mon[i].section.ranges.min_v;
+- pScrn->monitor->vrefresh[0].hi =
+- ddc->det_mon[i].section.ranges.max_v;
+- return;
+- }
+- }
+- i = 0;
+- if(ddc->timings1.t1 & 0x02) /*800x600@56*/
+- {
+- pScrn->monitor->vrefresh[i].lo =
+- pScrn->monitor->vrefresh[i].hi = 56;
+- i++;
+- }
+- if((ddc->timings1.t1 & 0x01) || (ddc->timings1.t2 & 0x08))
+- {
+- pScrn->monitor->vrefresh[i].lo =
+- pScrn->monitor->vrefresh[i].hi = 60;
+- i++;
+- }
+- if(ddc->timings1.t2 & 0x04)
+- {
+- pScrn->monitor->vrefresh[i].lo =
+- pScrn->monitor->vrefresh[i].hi = 70;
+- i++;
+- }
+- if((ddc->timings1.t1 & 0x08) || (ddc->timings1.t2 & 0x80))
+- {
+- pScrn->monitor->vrefresh[i].lo =
+- pScrn->monitor->vrefresh[i].hi = 72;
+- i++;
+- }
+- if((ddc->timings1.t1 & 0x04) || (ddc->timings1.t2 & 0x40)
+- || (ddc->timings1.t2 & 0x02) || (ddc->timings1.t2 & 0x01))
+- {
+- pScrn->monitor->vrefresh[i].lo =
+- pScrn->monitor->vrefresh[i].hi = 75;
+- i++;
+- }
+- pScrn->monitor->nVrefresh = i;
+- }
+-}
+-
+-/***********
+- free's xf86ValidateModes routine deosn't work well with DFPs
+- here is our own validation routine. All modes between
+- 640<=XRes<=MaxRes and 480<=YRes<=MaxYRes will be permitted.
+- NOTE: RageProII doesn't support rmx, can only work with the
+- standard modes the monitor can support (scale).
+-************/
+-
+-static int R128ValidateFPModes(ScrnInfoPtr pScrn)
+-{
+- int i, j, count=0, width, height;
+- R128InfoPtr info = R128PTR(pScrn);
+- DisplayModePtr last = NULL, new = NULL, first = NULL;
+- xf86MonPtr ddc;
+-
+- /* Free any allocated modes during configuration. We don't need them*/
+- while (pScrn->modes)
+- {
+- xf86DeleteMode(&pScrn->modes, pScrn->modes);
+- }
+- while (pScrn->modePool)
+- {
+- xf86DeleteMode(&pScrn->modePool, pScrn->modePool);
+- }
+-
+- pScrn->virtualX = pScrn->display->virtualX;
+- pScrn->virtualY = pScrn->display->virtualY;
+-
+- /* If no mode specified in config, we use native resolution*/
+- if(!pScrn->display->modes[0])
+- {
+- pScrn->display->modes[0] = xnfalloc(16);
+- sprintf(pScrn->display->modes[0], "%dx%d",
+- info->PanelXRes, info->PanelYRes);
+- }
+-
+- for(i=0; pScrn->display->modes[i] != NULL; i++)
+- {
+- if (sscanf(pScrn->display->modes[i], "%dx%d", &width, &height) == 2)
+- {
+-
+- if(width < 640 || width > info->PanelXRes ||
+- height < 480 || height > info->PanelYRes)
+- {
+- xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+- "Mode %s is out of range.\n"
+- "Valid mode should be between 640x480-%dx%d\n",
+- pScrn->display->modes[i], info->PanelXRes, info->PanelYRes);
+- continue;
+- }
+-
+- new = xnfcalloc(1, sizeof(DisplayModeRec));
+- new->prev = last;
+- new->name = xnfalloc(strlen(pScrn->display->modes[i]) + 1);
+- strcpy(new->name, pScrn->display->modes[i]);
+- new->HDisplay = new->CrtcHDisplay = width;
+- new->VDisplay = new->CrtcVDisplay = height;
+-
+- ddc = pScrn->monitor->DDC;
+- for(j=0; j<DET_TIMINGS; j++)
+- {
+- /*We use native mode clock only*/
+- if(ddc->det_mon[j].type == 0){
+- new->Clock = ddc->det_mon[j].section.d_timings.clock / 1000;
+- break;
+- }
+- }
+-
+- if(new->prev) new->prev->next = new;
+- last = new;
+- if(!first) first = new;
+- pScrn->display->virtualX =
+- pScrn->virtualX = MAX(pScrn->virtualX, width);
+- pScrn->display->virtualY =
+- pScrn->virtualY = MAX(pScrn->virtualY, height);
+- count++;
+- }
+- else
+- {
+- xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+- "Mode name %s is invalid\n", pScrn->display->modes[i]);
+- continue;
+- }
+- }
+-
+- if(last)
+- {
+- last->next = first;
+- first->prev = last;
+- pScrn->modes = first;
+-
+- /*FIXME: May need to validate line pitch here*/
+- {
+- int dummy = 0;
+- switch(pScrn->depth / 8)
+- {
+- case 1:
+- dummy = 128 - pScrn->virtualX % 128;
+- break;
+- case 2:
+- dummy = 32 - pScrn->virtualX % 32;
+- break;
+- case 3:
+- case 4:
+- dummy = 16 - pScrn->virtualX % 16;
+- }
+- pScrn->displayWidth = pScrn->virtualX + dummy;
+- }
+-
+- }
+-
+- return count;
+-}
+-
+-
+-/* This is called by R128PreInit to validate modes and compute parameters
+- for all of the valid modes. */
+-static Bool R128PreInitModes(ScrnInfoPtr pScrn)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- ClockRangePtr clockRanges;
+- int modesFound;
+-
+- if(info->isDFP) {
+- R128MapMem(pScrn);
+- info->BIOSDisplay = R128_BIOS_DISPLAY_FP;
+- /* validate if DFP really connected. */
+- if(!R128GetDFPInfo(pScrn)) {
+- info->isDFP = FALSE;
+- info->BIOSDisplay = R128_BIOS_DISPLAY_CRT;
+- } else if(!info->isPro2) {
+- /* RageProII doesn't support rmx, we can't use native-mode
+- stretching for other non-native modes. It will rely on
+- whatever VESA modes monitor can support. */
+- modesFound = R128ValidateFPModes(pScrn);
+- if(modesFound < 1) {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "No valid mode found for this DFP/LCD\n");
+- R128UnmapMem(pScrn);
+- return FALSE;
+-
+- }
+- }
+- R128UnmapMem(pScrn);
+- }
+-
+- if(!info->isDFP || info->isPro2) {
+- /* Get mode information */
+- pScrn->progClock = TRUE;
+- clockRanges = xnfcalloc(sizeof(*clockRanges), 1);
+- clockRanges->next = NULL;
+- clockRanges->minClock = info->pll.min_pll_freq;
+- clockRanges->maxClock = info->pll.max_pll_freq * 10;
+- clockRanges->clockIndex = -1;
+- if (info->HasPanelRegs || info->isDFP) {
+- clockRanges->interlaceAllowed = FALSE;
+- clockRanges->doubleScanAllowed = FALSE;
+- } else {
+- clockRanges->interlaceAllowed = TRUE;
+- clockRanges->doubleScanAllowed = TRUE;
+- }
+-
+- if(pScrn->monitor->DDC) {
+- /*if we still don't know sync range yet, let's try EDID.
+- Note that, since we can have dual heads, the Xconfigurator
+- may not be able to probe both monitors correctly through
+- vbe probe function (R128ProbeDDC). Here we provide an
+- additional way to auto-detect sync ranges if they haven't
+- been added to XF86Config manually.
+- **/
+- if(pScrn->monitor->nHsync <= 0)
+- R128SetSyncRangeFromEdid(pScrn, 1);
+- if(pScrn->monitor->nVrefresh <= 0)
+- R128SetSyncRangeFromEdid(pScrn, 0);
+- }
+-
+- modesFound = xf86ValidateModes(pScrn,
+- pScrn->monitor->Modes,
+- pScrn->display->modes,
+- clockRanges,
+- NULL, /* linePitches */
+- 8 * 64, /* minPitch */
+- 8 * 1024, /* maxPitch */
+-/*
+- * ATI docs say pitchInc must be 8 * 64, but this doesn't permit a pitch of
+- * 800 bytes, which is known to work on the Rage128 LF on clamshell iBooks
+- */
+- 8 * 32, /* pitchInc */
+- 128, /* minHeight */
+- 2048, /* maxHeight */
+- pScrn->display->virtualX,
+- pScrn->display->virtualY,
+- info->FbMapSize,
+- LOOKUP_BEST_REFRESH);
+-
+- if (modesFound < 1 && info->FBDev) {
+- fbdevHWUseBuildinMode(pScrn);
+- pScrn->displayWidth = fbdevHWGetLineLength(pScrn)/(pScrn->bitsPerPixel/8);
+- modesFound = 1;
+- }
+-
+- if (modesFound == -1) return FALSE;
+- xf86PruneDriverModes(pScrn);
+- if (!modesFound || !pScrn->modes) {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
+- return FALSE;
+- }
+- xf86SetCrtcForModes(pScrn, 0);
+- }
+- /* Set DPI */
+- pScrn->currentMode = pScrn->modes;
+- xf86PrintModes(pScrn);
+-
+- xf86SetDpi(pScrn, 0, 0);
+-
+- /* Get ScreenInit function */
+- if (!xf86LoadSubModule(pScrn, "fb")) return FALSE;
+-
+- info->CurrentLayout.displayWidth = pScrn->displayWidth;
+- info->CurrentLayout.mode = pScrn->currentMode;
+-
+- return TRUE;
+-}
+-
+ /* This is called by R128PreInit to initialize the hardware cursor. */
+ static Bool R128PreInitCursor(ScrnInfoPtr pScrn)
+ {
+@@ -1885,6 +1345,43 @@ static Bool R128PreInitDRI(ScrnInfoPtr pScrn)
+ }
+ #endif
+
++static Bool R128PreInitControllers(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
++{
++ R128InfoPtr info = R128PTR(pScrn);
++ xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
++ int i;
++ int mask;
++ int found = 0;
++
++ if (info->IsPrimary)
++ mask = 1;
++ else if (info->IsSecondary)
++ mask = 2;
++ else
++ mask = 3;
++
++ if (!R128GetBIOSParameters(pScrn, pInt10))
++ return FALSE;
++
++ if (!R128GetPLLParameters(pScrn))
++ return FALSE;
++
++ if (!R128AllocateControllers(pScrn, mask))
++ return FALSE;
++
++ if (!R128SetupConnectors(pScrn))
++ return FALSE;
++
++ for (i = 0; i < config->num_output; i++) {
++ xf86OutputPtr output = config->output[i];
++
++ output->status = (*output->funcs->detect) (output);
++ if (output->status == XF86OutputStatusConnected)
++ found++;
++ }
++ return !!found;
++}
++
+ static void
+ R128ProbeDDC(ScrnInfoPtr pScrn, int indx)
+ {
+@@ -1899,6 +1396,17 @@ R128ProbeDDC(ScrnInfoPtr pScrn, int indx)
+ #endif
+ }
+
++static Bool R128CRTCResize(ScrnInfoPtr pScrn, int width, int height)
++{
++ pScrn->virtualX = width;
++ pScrn->virtualY = height;
++ return TRUE;
++}
++
++static const xf86CrtcConfigFuncsRec R128CRTCResizeFuncs = {
++ R128CRTCResize
++};
++
+ /* R128PreInit is called once at server startup. */
+ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ {
+@@ -1976,6 +1484,9 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ #endif
+ pScrn->monitor = pScrn->confScreen->monitor;
+
++ /* Allocate an xf86CrtcConfig */
++ xf86CrtcConfigInit(pScrn, &R128CRTCResizeFuncs);
++
+ if (!R128PreInitVisual(pScrn)) goto fail;
+
+ /* We can't do this until we have a
+@@ -2016,8 +1527,6 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ "module load skipped\n");
+ #endif
+
+-
+-
+ if (!R128PreInitWeight(pScrn)) goto fail;
+
+ if(xf86GetOptValInteger(info->Options, OPTION_VIDEO_KEY, &(info->videoKey))) {
+@@ -2053,20 +1562,30 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ }
+
+ if (!info->FBDev)
+- if (!R128PreInitInt10(pScrn, &pInt10)) goto fail;
+-
+- if (!R128PreInitConfig(pScrn)) goto fail;
++ if (!R128PreInitInt10(pScrn, &pInt10)) goto fail;
+
+- if (!R128GetBIOSParameters(pScrn, pInt10)) goto fail;
++ if (!R128PreInitConfig(pScrn)) goto fail;
+
+- if (!R128GetPLLParameters(pScrn)) goto fail;
++ xf86CrtcSetSizeRange(pScrn, 320, 200, 4096, 4096);
+
+ /* Don't fail on this one */
+- R128PreInitDDC(pScrn, pInt10);
++ info->DDC = R128PreInitDDC(pScrn, pInt10);
+
+- if (!R128PreInitGamma(pScrn)) goto fail;
++ if (!R128PreInitControllers(pScrn, pInt10)) goto fail;
++
++ if (!xf86InitialConfiguration(pScrn, TRUE)) {
++ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes.\n");
++ goto fail;
++ }
++ pScrn->displayWidth = (pScrn->virtualX + 63) & ~63;
+
+- if (!R128PreInitModes(pScrn)) goto fail;
++ /* Set display resolution */
++ xf86SetDpi(pScrn, 0, 0);
++
++ /* Get ScreenInit function */
++ if (!xf86LoadSubModule(pScrn, "fb")) return FALSE;
++
++ if (!R128PreInitGamma(pScrn)) goto fail;
+
+ if (!R128PreInitCursor(pScrn)) goto fail;
+
+@@ -2074,6 +1593,18 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ if (!R128PreInitDRI(pScrn)) goto fail;
+ #endif
+
++ info->CurrentLayout.displayWidth = pScrn->displayWidth;
++
++ if (!xf86RandR12PreInit(pScrn)) {
++ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "RandR initialization failure\n");
++ goto fail;
++ }
++
++ if (pScrn->modes == NULL) {
++ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
++ goto fail;
++ }
++
+ /* Free the video bios (if applicable) */
+ if (info->VBIOS) {
+ free(info->VBIOS);
+@@ -2084,6 +1615,9 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ if (pInt10)
+ xf86FreeInt10(pInt10);
+
++ if (info->MMIO) R128UnmapMMIO(pScrn);
++ info->MMIO = NULL;
++
+ xf86DrvMsg(pScrn->scrnIndex, X_NOTICE,
+ "For information on using the multimedia capabilities\n\tof this"
+ " adapter, please see http://gatos.sf.net.\n");
+@@ -2116,56 +1650,66 @@ static void R128LoadPalette(ScrnInfoPtr pScrn, int numColors,
+ int *indices, LOCO *colors, VisualPtr pVisual)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+- int i, j;
+- int idx;
+- unsigned char r, g, b;
+-
+- /* If the second monitor is connected, we also
+- need to deal with the secondary palette*/
+- if (info->IsSecondary) j = 1;
+- else j = 0;
+-
+- PAL_SELECT(j);
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ int i, j;
++ int c, index;
++ CARD16 lut_r[256], lut_g[256], lut_b[256];
++
++ for (c = 0; c < xf86_config->num_crtc; c++) {
++ xf86CrtcPtr crtc = xf86_config->crtc[c];
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ for (i = 0 ; i < 256; i++) {
++ lut_r[i] = r128_crtc->lut_r[i] << 8;
++ lut_g[i] = r128_crtc->lut_g[i] << 8;
++ lut_b[i] = r128_crtc->lut_b[i] << 8;
++ }
+
++ switch (info->CurrentLayout.depth) {
++ case 15:
++ for (i = 0; i < numColors; i++) {
++ index = indices[i];
++ for (j = 0; j < 8; j++) {
++ lut_r[index * 8 + j] = colors[index].red << 8;
++ lut_g[index * 8 + j] = colors[index].green << 8;
++ lut_b[index * 8 + j] = colors[index].blue << 8;
++ }
++ }
++ case 16:
++ for (i = 0; i < numColors; i++) {
++ index = indices[i];
++
++ /* XXX: The old version of R128LoadPalette did not do this and
++ * the old version of RADEONLoadPalette has a comment asking why.
++ */
++ if (i <= 31) {
++ for (j = 0; j < 8; j++) {
++ lut_r[index * 8 + j] = colors[index].red << 8;
++ lut_b[index * 8 + j] = colors[index].blue << 8;
++ }
++ }
+
+- /* Select palette 0 (main CRTC) if using FP-enabled chip */
+- /*if (info->HasPanelRegs || info->isDFP) PAL_SELECT(0);*/
++ for (j = 0; j < 4; j++) {
++ lut_g[index * 4 + j] = colors[index].green << 8;
++ }
++ }
++ default:
++ for (i = 0; i < numColors; i++) {
++ index = indices[i];
++ lut_r[index] = colors[index].red << 8;
++ lut_g[index] = colors[index].green << 8;
++ lut_b[index] = colors[index].blue << 8;
++ }
++ break;
++ }
+
+- if (info->CurrentLayout.depth == 15) {
+- /* 15bpp mode. This sends 32 values. */
+- for (i = 0; i < numColors; i++) {
+- idx = indices[i];
+- r = colors[idx].red;
+- g = colors[idx].green;
+- b = colors[idx].blue;
+- OUTPAL(idx * 8, r, g, b);
+- }
+- }
+- else if (info->CurrentLayout.depth == 16) {
+- /* 16bpp mode. This sends 64 values. */
+- /* There are twice as many green values as
+- there are values for red and blue. So,
+- we take each red and blue pair, and
+- combine it with each of the two green
+- values. */
+- for (i = 0; i < numColors; i++) {
+- idx = indices[i];
+- r = colors[idx / 2].red;
+- g = colors[idx].green;
+- b = colors[idx / 2].blue;
+- OUTPAL(idx * 4, r, g, b);
+- }
+- }
+- else {
+- /* 8bpp mode. This sends 256 values. */
+- for (i = 0; i < numColors; i++) {
+- idx = indices[i];
+- r = colors[idx].red;
+- b = colors[idx].blue;
+- g = colors[idx].green;
+- OUTPAL(idx, r, g, b);
+- }
++ /* Make the change through RandR */
++#ifdef RANDR_12_INTERFACE
++ if (crtc->randr_crtc)
++ RRCrtcGammaSet(crtc->randr_crtc, lut_r, lut_g, lut_b);
++ else
++#endif
++ crtc->funcs->gamma_set(crtc, lut_r, lut_g, lut_b, 256);
+ }
+ }
+
+@@ -2296,14 +1840,6 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ info->PaletteSavedOnVT = FALSE;
+
+ R128Save(pScrn);
+- if (info->FBDev) {
+- if (!fbdevHWModeInit(pScrn, pScrn->currentMode)) return FALSE;
+- } else {
+- if (!R128ModeInit(pScrn, pScrn->currentMode)) return FALSE;
+- }
+-
+- R128SaveScreen(pScreen, SCREEN_SAVER_ON);
+- pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
+
+ /* Visual setup */
+ miClearVisualTypes();
+@@ -2701,6 +2237,19 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ #endif
+ }
+
++ pScrn->vtSema = TRUE;
++ /* xf86CrtcRotate accesses pScrn->pScreen */
++ pScrn->pScreen = pScreen;
++
++ if (info->FBDev) {
++ if (!fbdevHWModeInit(pScrn, pScrn->currentMode)) return FALSE;
++ } else {
++ if (!xf86SetDesiredModes(pScrn)) return FALSE;
++ }
++
++ R128SaveScreen(pScreen, SCREEN_SAVER_ON);
++ //pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
++
+ /* DGA setup */
+ R128DGAInit(pScreen);
+
+@@ -2737,28 +2286,11 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using software cursor\n");
+ }
+
+- /* Colormap setup */
+- if (!miCreateDefColormap(pScreen)) return FALSE;
+- if (!xf86HandleColormaps(pScreen, 256, info->dac6bits ? 6 : 8,
+- (info->FBDev ? fbdevHWLoadPaletteWeak() :
+- R128LoadPalette), NULL,
+- CMAP_PALETTED_TRUECOLOR
+- | CMAP_RELOAD_ON_MODE_SWITCH
+-#if 0 /* This option messes up text mode! (eich@suse.de) */
+- | CMAP_LOAD_EVEN_IF_OFFSCREEN
+-#endif
+- )) return FALSE;
+-
+ /* DPMS setup - FIXME: also for mirror mode in non-fbdev case? - Michel */
+ if (info->FBDev)
+ xf86DPMSInit(pScreen, fbdevHWDPMSSetWeak(), 0);
+-
+- else {
+- if (info->DisplayType == MT_LCD)
+- xf86DPMSInit(pScreen, R128DisplayPowerManagementSetLCD, 0);
+- else
+- xf86DPMSInit(pScreen, R128DisplayPowerManagementSet, 0);
+- }
++ else
++ xf86DPMSInit(pScreen, xf86DPMSSet, 0);
+
+ if (!info->IsSecondary)
+ R128InitVideo(pScreen);
+@@ -2793,11 +2325,25 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ info->BlockHandler = pScreen->BlockHandler;
+ pScreen->BlockHandler = R128BlockHandler;
+
++ if (!xf86CrtcScreenInit(pScreen)) return FALSE;
++
++ /* Colormap setup */
++ if (!miCreateDefColormap(pScreen)) return FALSE;
++ if (!xf86HandleColormaps(pScreen, 256, info->dac6bits ? 6 : 8,
++ (info->FBDev ? fbdevHWLoadPaletteWeak() :
++ R128LoadPalette), NULL,
++ CMAP_PALETTED_TRUECOLOR
++ | CMAP_RELOAD_ON_MODE_SWITCH
++#if 0 /* This option messes up text mode! (eich@suse.de) */
++ | CMAP_LOAD_EVEN_IF_OFFSCREEN
++#endif
++ )) return FALSE;
++
+ return TRUE;
+ }
+
+ /* Write common registers (initialized to 0). */
+-static void R128RestoreCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestoreCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -2821,7 +2367,7 @@ static void R128RestoreCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ }
+
+ /* Write CRTC registers. */
+-static void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -2844,7 +2390,7 @@ static void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ }
+
+ /* Write CRTC2 registers. */
+-static void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn,
++void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn,
+ R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+@@ -2863,7 +2409,7 @@ static void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn,
+ }
+
+ /* Write flat panel registers */
+-static void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -2936,7 +2482,7 @@ static void R128PLL2WriteUpdate(ScrnInfoPtr pScrn)
+ }
+
+ /* Write PLL registers. */
+-static void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -2999,7 +2545,7 @@ static void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ }
+
+ /* Write PLL2 registers. */
+-static void R128RestorePLL2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestorePLL2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -3068,7 +2614,7 @@ static void R128RestorePLL2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+ }
+
+ /* Write DDA registers. */
+-static void R128RestoreDDARegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestoreDDARegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -3078,7 +2624,7 @@ static void R128RestoreDDARegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ }
+
+ /* Write DDA registers. */
+-static void R128RestoreDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
++void R128RestoreDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -3087,126 +2633,6 @@ static void R128RestoreDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+ OUTREG(R128_DDA2_ON_OFF, restore->dda2_on_off);
+ }
+
+-/* Write palette data. */
+-static void R128RestorePalette(ScrnInfoPtr pScrn, R128SavePtr restore)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+- int i;
+-
+- if (!restore->palette_valid) return;
+-
+- PAL_SELECT(1);
+- OUTPAL_START(0);
+- for (i = 0; i < 256; i++) {
+- R128WaitForFifo(pScrn, 32); /* delay */
+- OUTPAL_NEXT_CARD32(restore->palette2[i]);
+- }
+-
+- PAL_SELECT(0);
+- OUTPAL_START(0);
+- for (i = 0; i < 256; i++) {
+- R128WaitForFifo(pScrn, 32); /* delay */
+- OUTPAL_NEXT_CARD32(restore->palette[i]);
+- }
+-
+-}
+-
+-/* Write out state to define a new video mode. */
+-static void R128RestoreMode(ScrnInfoPtr pScrn, R128SavePtr restore)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
+- static R128SaveRec restore0;
+-
+- R128TRACE(("R128RestoreMode(%p)\n", restore));
+- if(!info->HasCRTC2)
+- {
+- R128RestoreCommonRegisters(pScrn, restore);
+- R128RestoreDDARegisters(pScrn, restore);
+- R128RestoreCrtcRegisters(pScrn, restore);
+- if((info->DisplayType == MT_DFP) ||
+- (info->DisplayType == MT_LCD))
+- {
+- R128RestoreFPRegisters(pScrn, restore);
+- }
+- R128RestorePLLRegisters(pScrn, restore);
+- return;
+- }
+-
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
+-
+-
+- /*****
+- When changing mode with Dual-head card (VE/M6), care must
+- be taken for the special order in setting registers. CRTC2 has
+- to be set before changing CRTC_EXT register.
+- In the dual-head setup, X server calls this routine twice with
+- primary and secondary pScrn pointers respectively. The calls
+- can come with different order. Regardless the order of X server issuing
+- the calls, we have to ensure we set registers in the right order!!!
+- Otherwise we may get a blank screen.
+- *****/
+-
+- if(info->IsSecondary)
+- {
+- if (!pR128Ent->RestorePrimary && !info->SwitchingMode)
+- R128RestoreCommonRegisters(pScrn, restore);
+- R128RestoreDDA2Registers(pScrn, restore);
+- R128RestoreCrtc2Registers(pScrn, restore);
+- R128RestorePLL2Registers(pScrn, restore);
+-
+- if(info->SwitchingMode) return;
+-
+- pR128Ent->IsSecondaryRestored = TRUE;
+-
+- if(pR128Ent->RestorePrimary)
+- {
+- R128InfoPtr info0 = R128PTR(pR128Ent->pPrimaryScrn);
+- pR128Ent->RestorePrimary = FALSE;
+-
+- R128RestoreCrtcRegisters(pScrn, &restore0);
+- if((info0->DisplayType == MT_DFP) ||
+- (info0->DisplayType == MT_LCD))
+- {
+- R128RestoreFPRegisters(pScrn, &restore0);
+- }
+-
+- R128RestorePLLRegisters(pScrn, &restore0);
+- pR128Ent->IsSecondaryRestored = FALSE;
+-
+- }
+- }
+- else
+- {
+- if (!pR128Ent->IsSecondaryRestored)
+- R128RestoreCommonRegisters(pScrn, restore);
+- R128RestoreDDARegisters(pScrn, restore);
+- if(!pR128Ent->HasSecondary || pR128Ent->IsSecondaryRestored
+- || info->SwitchingMode)
+- {
+- pR128Ent->IsSecondaryRestored = FALSE;
+- R128RestoreCrtcRegisters(pScrn, restore);
+- if((info->DisplayType == MT_DFP) ||
+- (info->DisplayType == MT_LCD))
+- {
+- R128RestoreFPRegisters(pScrn, restore);
+- }
+- R128RestorePLLRegisters(pScrn, restore);
+- }
+- else
+- {
+- memcpy(&restore0, restore, sizeof(restore0));
+- pR128Ent->RestorePrimary = TRUE;
+- }
+- }
+-
+- R128RestorePalette(pScrn, restore);
+-}
+-
+ /* Read common registers. */
+ static void R128SaveCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr save)
+ {
+@@ -3450,9 +2876,19 @@ static void R128Restore(ScrnInfoPtr pScrn)
+ OUTREG(R128_CLOCK_CNTL_INDEX, restore->clock_cntl_index);
+ OUTREG(R128_GEN_RESET_CNTL, restore->gen_reset_cntl);
+ OUTREG(R128_DP_DATATYPE, restore->dp_datatype);
++
++ R128RestoreCommonRegisters(pScrn, restore);
++ if (info->HasCRTC2) {
++ R128RestoreDDA2Registers(pScrn, restore);
++ R128RestoreCrtc2Registers(pScrn, restore);
++ R128RestorePLL2Registers(pScrn, restore);
++ }
++ R128RestoreDDARegisters(pScrn, restore);
++ R128RestoreCrtcRegisters(pScrn, restore);
++ R128RestorePLLRegisters(pScrn, restore);
++ R128RestoreFPRegisters(pScrn, restore);
+ }
+
+- R128RestoreMode(pScrn, restore);
+ #ifdef WITH_VGAHW
+ if (info->VGAAccess) {
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+@@ -3492,7 +2928,7 @@ static void R128Restore(ScrnInfoPtr pScrn)
+ }
+
+ /* Define common registers for requested video mode. */
+-static void R128InitCommonRegisters(R128SavePtr save, R128InfoPtr info)
++void R128InitCommonRegisters(R128SavePtr save, R128InfoPtr info)
+ {
+ save->ovr_clr = 0;
+ save->ovr_wid_left_right = 0;
+@@ -3518,8 +2954,64 @@ static void R128InitCommonRegisters(R128SavePtr save, R128InfoPtr info)
+ save->bus_cntl |= R128_BUS_RD_DISCARD_EN | R128_BUS_RD_ABORT_EN;
+ }
+
++Bool R128InitCrtcBase(xf86CrtcPtr crtc, R128SavePtr save, int x, int y)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ int offset = y * info->CurrentLayout.displayWidth + x;
++ int Base = pScrn->fbOffset;
++
++ switch (info->CurrentLayout.pixel_code) {
++ case 15:
++ case 16: offset *= 2; break;
++ case 24: offset *= 3; break;
++ case 32: offset *= 4; break;
++ }
++ Base += offset;
++
++ if (crtc->rotatedData != NULL)
++ Base = pScrn->fbOffset + (char *)crtc->rotatedData - (char *)info->FB;
++
++ Base &= ~7; /* 3 lower bits are always 0 */
++ if (info->CurrentLayout.pixel_code == 24)
++ Base += 8 * (Base % 3); /* Must be multiple of 8 and 3 */
++
++ save->crtc_offset = Base;
++ save->crtc_offset_cntl = 0;
++
++ return TRUE;
++}
++
++Bool R128InitCrtc2Base(xf86CrtcPtr crtc, R128SavePtr save, int x, int y)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ int offset = y * info->CurrentLayout.displayWidth + x;
++ int Base = pScrn->fbOffset;
++
++ switch (info->CurrentLayout.pixel_code) {
++ case 15:
++ case 16: offset *= 2; break;
++ case 24: offset *= 3; break;
++ case 32: offset *= 4; break;
++ }
++ Base += offset;
++
++ if (crtc->rotatedData != NULL)
++ Base = pScrn->fbOffset + (char *)crtc->rotatedData - (char *)info->FB;
++
++ Base &= ~7; /* 3 lower bits are always 0 */
++ if (info->CurrentLayout.pixel_code == 24)
++ Base += 8 * (Base % 3); /* Must be multiple of 8 and 3 */
++
++ save->crtc2_offset = Base;
++ save->crtc2_offset_cntl = 0;
++
++ return TRUE;
++}
++
+ /* Define CRTC registers for requested video mode. */
+-static Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
++Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ DisplayModePtr mode, R128InfoPtr info)
+ {
+ int format;
+@@ -3633,8 +3125,6 @@ static Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ | ((mode->Flags & V_NVSYNC)
+ ? R128_CRTC_V_SYNC_POL
+ : 0));
+- save->crtc_offset = 0;
+- save->crtc_offset_cntl = 0;
+ save->crtc_pitch = info->CurrentLayout.displayWidth / 8;
+
+ R128TRACE(("Pitch = %d bytes (virtualX = %d, displayWidth = %d)\n",
+@@ -3654,7 +3144,7 @@ static Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define CRTC2 registers for requested video mode. */
+-static Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
++Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ DisplayModePtr mode, R128InfoPtr info)
+ {
+ int format;
+@@ -3727,10 +3217,6 @@ static Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ | ((mode->Flags & V_NVSYNC)
+ ? R128_CRTC2_V_SYNC_POL
+ : 0));
+-
+- save->crtc2_offset = 0;
+- save->crtc2_offset_cntl = 0;
+-
+ save->crtc2_pitch = info->CurrentLayout.displayWidth / 8;
+
+ R128TRACE(("Pitch = %d bytes (virtualX = %d, displayWidth = %d)\n",
+@@ -3740,7 +3226,7 @@ static Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define CRTC registers for requested video mode. */
+-static void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
++void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
+ DisplayModePtr mode, R128InfoPtr info)
+ {
+ int xres = mode->CrtcHDisplay;
+@@ -3853,7 +3339,7 @@ static void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
+ }
+
+ /* Define PLL registers for requested video mode. */
+-static void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
++void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ R128PLLPtr pll, double dot_clock)
+ {
+ unsigned long freq = dot_clock * 100;
+@@ -3905,7 +3391,7 @@ static void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define PLL2 registers for requested video mode. */
+-static void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
++void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ R128PLLPtr pll, double dot_clock)
+ {
+ unsigned long freq = dot_clock * 100;
+@@ -3957,7 +3443,7 @@ static void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define DDA registers for requested video mode. */
+-static Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
++Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ R128PLLPtr pll, R128InfoPtr info,
+ DisplayModePtr mode)
+ {
+@@ -4026,7 +3512,7 @@ static Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define DDA2 registers for requested video mode. */
+-static Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
++Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ R128PLLPtr pll, R128InfoPtr info,
+ DisplayModePtr mode)
+ {
+@@ -4106,122 +3592,6 @@ static void R128InitPalette(R128SavePtr save)
+ }
+ #endif
+
+-/* Define registers for a requested video mode. */
+-static Bool R128Init(ScrnInfoPtr pScrn, DisplayModePtr mode, R128SavePtr save)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- double dot_clock = mode->Clock/1000.0;
+-
+-#if R128_DEBUG
+- ErrorF("%-12.12s %7.2f %4d %4d %4d %4d %4d %4d %4d %4d (%d,%d)",
+- mode->name,
+- dot_clock,
+-
+- mode->HDisplay,
+- mode->HSyncStart,
+- mode->HSyncEnd,
+- mode->HTotal,
+-
+- mode->VDisplay,
+- mode->VSyncStart,
+- mode->VSyncEnd,
+- mode->VTotal,
+- pScrn->depth,
+- pScrn->bitsPerPixel);
+- if (mode->Flags & V_DBLSCAN) ErrorF(" D");
+- if (mode->Flags & V_CSYNC) ErrorF(" C");
+- if (mode->Flags & V_INTERLACE) ErrorF(" I");
+- if (mode->Flags & V_PHSYNC) ErrorF(" +H");
+- if (mode->Flags & V_NHSYNC) ErrorF(" -H");
+- if (mode->Flags & V_PVSYNC) ErrorF(" +V");
+- if (mode->Flags & V_NVSYNC) ErrorF(" -V");
+- ErrorF("\n");
+- ErrorF("%-12.12s %7.2f %4d %4d %4d %4d %4d %4d %4d %4d (%d,%d)",
+- mode->name,
+- dot_clock,
+-
+- mode->CrtcHDisplay,
+- mode->CrtcHSyncStart,
+- mode->CrtcHSyncEnd,
+- mode->CrtcHTotal,
+-
+- mode->CrtcVDisplay,
+- mode->CrtcVSyncStart,
+- mode->CrtcVSyncEnd,
+- mode->CrtcVTotal,
+- pScrn->depth,
+- pScrn->bitsPerPixel);
+- if (mode->Flags & V_DBLSCAN) ErrorF(" D");
+- if (mode->Flags & V_CSYNC) ErrorF(" C");
+- if (mode->Flags & V_INTERLACE) ErrorF(" I");
+- if (mode->Flags & V_PHSYNC) ErrorF(" +H");
+- if (mode->Flags & V_NHSYNC) ErrorF(" -H");
+- if (mode->Flags & V_PVSYNC) ErrorF(" +V");
+- if (mode->Flags & V_NVSYNC) ErrorF(" -V");
+- ErrorF("\n");
+-#endif
+-
+- info->Flags = mode->Flags;
+-
+- if(info->IsSecondary)
+- {
+- if (!R128InitCrtc2Registers(pScrn, save,
+- pScrn->currentMode,info))
+- return FALSE;
+- R128InitPLL2Registers(pScrn, save, &info->pll, dot_clock);
+- if (!R128InitDDA2Registers(pScrn, save, &info->pll, info, mode))
+- return FALSE;
+- }
+- else
+- {
+- R128InitCommonRegisters(save, info);
+- if(!R128InitCrtcRegisters(pScrn, save, mode, info))
+- return FALSE;
+- if(dot_clock)
+- {
+- R128InitPLLRegisters(pScrn, save, &info->pll, dot_clock);
+- if (!R128InitDDARegisters(pScrn, save, &info->pll, info, mode))
+- return FALSE;
+- }
+- else
+- {
+- save->ppll_ref_div = info->SavedReg.ppll_ref_div;
+- save->ppll_div_3 = info->SavedReg.ppll_div_3;
+- save->htotal_cntl = info->SavedReg.htotal_cntl;
+- save->dda_config = info->SavedReg.dda_config;
+- save->dda_on_off = info->SavedReg.dda_on_off;
+- }
+- /* not used for now */
+- /*if (!info->PaletteSavedOnVT) RADEONInitPalette(save);*/
+- }
+-
+- if (((info->DisplayType == MT_DFP) ||
+- (info->DisplayType == MT_LCD)))
+- {
+- R128InitFPRegisters(&info->SavedReg, save, mode, info);
+- }
+-
+- R128TRACE(("R128Init returns %p\n", save));
+- return TRUE;
+-}
+-
+-/* Initialize a new mode. */
+-static Bool R128ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- if (!R128Init(pScrn, mode, &info->ModeReg)) return FALSE;
+- /* FIXME? DRILock/DRIUnlock here? */
+- pScrn->vtSema = TRUE;
+- R128Blank(pScrn);
+- R128RestoreMode(pScrn, &info->ModeReg);
+- R128Unblank(pScrn);
+-
+- info->CurrentLayout.mode = mode;
+-
+- return TRUE;
+-}
+-
+ static Bool R128SaveScreen(ScreenPtr pScreen, int mode)
+ {
+ ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+@@ -4252,7 +3622,7 @@ Bool R128SwitchMode(SWITCH_MODE_ARGS_DECL)
+ Bool ret;
+
+ info->SwitchingMode = TRUE;
+- ret = R128ModeInit(pScrn, mode);
++ ret = xf86SetSingleMode(pScrn, mode, RR_Rotate_0);
+ info->SwitchingMode = FALSE;
+ return ret;
+ }
+@@ -4379,10 +3749,16 @@ Bool R128EnterVT(VT_FUNC_ARGS_DECL)
+ R128InfoPtr info = R128PTR(pScrn);
+
+ R128TRACE(("R128EnterVT\n"));
++
++ pScrn->vtSema = TRUE;
+ if (info->FBDev) {
+ if (!fbdevHWEnterVT(VT_FUNC_ARGS)) return FALSE;
+- } else
+- if (!R128ModeInit(pScrn, pScrn->currentMode)) return FALSE;
++ } else {
++ if (!xf86SetDesiredModes(pScrn)) return FALSE;
++ }
++
++ //if (!R128ModeInit(pScrn, pScrn->currentMode)) return FALSE;
++
+ if (info->accelOn)
+ R128EngineInit(pScrn);
+
+@@ -4399,7 +3775,7 @@ Bool R128EnterVT(VT_FUNC_ARGS_DECL)
+ #endif
+
+ info->PaletteSavedOnVT = FALSE;
+- pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
++ //pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
+
+ return TRUE;
+ }
+@@ -4504,130 +3880,3 @@ void R128FreeScreen(FREE_SCREEN_ARGS_DECL)
+ #endif
+ R128FreeRec(pScrn);
+ }
+-
+-/* Sets VESA Display Power Management Signaling (DPMS) Mode. */
+-static void R128DisplayPowerManagementSet(ScrnInfoPtr pScrn,
+- int PowerManagementMode, int flags)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+- int mask = (R128_CRTC_DISPLAY_DIS
+- | R128_CRTC_HSYNC_DIS
+- | R128_CRTC_VSYNC_DIS);
+- int mask2 = R128_CRTC2_DISP_DIS;
+-
+- switch (PowerManagementMode) {
+- case DPMSModeOn:
+- /* Screen: On; HSync: On, VSync: On */
+- if (info->IsSecondary)
+- OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~mask2);
+- else
+- OUTREGP(R128_CRTC_EXT_CNTL, 0, ~mask);
+- break;
+- case DPMSModeStandby:
+- /* Screen: Off; HSync: Off, VSync: On */
+- if (info->IsSecondary)
+- OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_DISP_DIS, ~mask2);
+- else
+- OUTREGP(R128_CRTC_EXT_CNTL,
+- R128_CRTC_DISPLAY_DIS | R128_CRTC_HSYNC_DIS, ~mask);
+- break;
+- case DPMSModeSuspend:
+- /* Screen: Off; HSync: On, VSync: Off */
+- if (info->IsSecondary)
+- OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_DISP_DIS, ~mask2);
+- else
+- OUTREGP(R128_CRTC_EXT_CNTL,
+- R128_CRTC_DISPLAY_DIS | R128_CRTC_VSYNC_DIS, ~mask);
+- break;
+- case DPMSModeOff:
+- /* Screen: Off; HSync: Off, VSync: Off */
+- if (info->IsSecondary)
+- OUTREGP(R128_CRTC2_GEN_CNTL, mask2, ~mask2);
+- else
+- OUTREGP(R128_CRTC_EXT_CNTL, mask, ~mask);
+- break;
+- }
+- if(info->isDFP) {
+- switch (PowerManagementMode) {
+- case DPMSModeOn:
+- OUTREG(R128_FP_GEN_CNTL, INREG(R128_FP_GEN_CNTL) | (R128_FP_FPON | R128_FP_TDMS_EN));
+- break;
+- case DPMSModeStandby:
+- case DPMSModeSuspend:
+- case DPMSModeOff:
+- OUTREG(R128_FP_GEN_CNTL, INREG(R128_FP_GEN_CNTL) & ~(R128_FP_FPON | R128_FP_TDMS_EN));
+- break;
+- }
+- }
+-}
+-
+-static int r128_set_backlight_enable(ScrnInfoPtr pScrn, int on);
+-
+-static void R128DisplayPowerManagementSetLCD(ScrnInfoPtr pScrn,
+- int PowerManagementMode, int flags)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+- int mask = R128_LVDS_DISPLAY_DIS;
+-
+- switch (PowerManagementMode) {
+- case DPMSModeOn:
+- /* Screen: On; HSync: On, VSync: On */
+- OUTREGP(R128_LVDS_GEN_CNTL, 0, ~mask);
+- r128_set_backlight_enable(pScrn, 1);
+- break;
+- case DPMSModeStandby:
+- /* Fall through */
+- case DPMSModeSuspend:
+- /* Fall through */
+- break;
+- case DPMSModeOff:
+- /* Screen: Off; HSync: Off, VSync: Off */
+- OUTREGP(R128_LVDS_GEN_CNTL, mask, ~mask);
+- r128_set_backlight_enable(pScrn, 0);
+- break;
+- }
+-}
+-
+-static int r128_set_backlight_enable(ScrnInfoPtr pScrn, int on)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- unsigned char *R128MMIO = info->MMIO;
+- unsigned int lvds_gen_cntl = INREG(R128_LVDS_GEN_CNTL);
+-
+- lvds_gen_cntl |= (/*R128_LVDS_BL_MOD_EN |*/ R128_LVDS_BLON);
+- if (on) {
+- lvds_gen_cntl |= R128_LVDS_DIGON;
+- if (!(lvds_gen_cntl & R128_LVDS_ON)) {
+- lvds_gen_cntl &= ~R128_LVDS_BLON;
+- OUTREG(R128_LVDS_GEN_CNTL, lvds_gen_cntl);
+- (void)INREG(R128_LVDS_GEN_CNTL);
+- usleep(10000);
+- lvds_gen_cntl |= R128_LVDS_BLON;
+- OUTREG(R128_LVDS_GEN_CNTL, lvds_gen_cntl);
+- }
+-#if 0
+- lvds_gen_cntl &= ~R128_LVDS_BL_MOD_LEVEL_MASK;
+- lvds_gen_cntl |= (0xFF /* backlight_conv[level] */ <<
+- R128_LVDS_BL_MOD_LEVEL_SHIFT);
+-#endif
+- lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_EN);
+- lvds_gen_cntl &= ~R128_LVDS_DISPLAY_DIS;
+- } else {
+-#if 0
+- lvds_gen_cntl &= ~R128_LVDS_BL_MOD_LEVEL_MASK;
+- lvds_gen_cntl |= (0xFF /* backlight_conv[0] */ <<
+- R128_LVDS_BL_MOD_LEVEL_SHIFT);
+-#endif
+- lvds_gen_cntl |= R128_LVDS_DISPLAY_DIS;
+- OUTREG(R128_LVDS_GEN_CNTL, lvds_gen_cntl);
+- usleep(10);
+- lvds_gen_cntl &= ~(R128_LVDS_ON | R128_LVDS_EN | R128_LVDS_BLON
+- | R128_LVDS_DIGON);
+- }
+-
+- OUTREG(R128_LVDS_GEN_CNTL, lvds_gen_cntl);
+-
+- return 0;
+-}
+diff --git a/src/r128_output.c b/src/r128_output.c
+new file mode 100644
+index 0000000..89a2958
+--- /dev/null
++++ b/src/r128_output.c
+@@ -0,0 +1,465 @@
++/*
++ * Copyright 2000 ATI Technologies Inc., Markham, Ontario, and
++ * VA Linux Systems Inc., Fremont, California.
++ *
++ * 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 on 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
++ * NON-INFRINGEMENT. IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
++ * THEIR 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.
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include <string.h>
++#include <stdio.h>
++
++#include "xf86.h"
++#include "xf86Modes.h"
++
++#include "r128.h"
++#include "r128_probe.h"
++#include "r128_reg.h"
++
++static void R128ConnectorFindMonitor(ScrnInfoPtr pScrn, xf86OutputPtr output);
++
++static void r128_dpms(xf86OutputPtr output, int mode)
++{
++ switch(mode) {
++ case DPMSModeOn:
++ R128DPMSSetOn(output);
++ break;
++ case DPMSModeStandby:
++ case DPMSModeSuspend:
++ case DPMSModeOff:
++ R128DPMSSetOff(output);
++ break;
++ }
++}
++
++static void r128_save(xf86OutputPtr output)
++{
++}
++
++static void r128_restore(xf86OutputPtr output)
++{
++}
++
++static int r128_mode_valid(xf86OutputPtr output, DisplayModePtr mode)
++{
++ return MODE_OK;
++}
++
++static Bool r128_mode_fixup(xf86OutputPtr output, DisplayModePtr mode, DisplayModePtr adjusted_mode)
++{
++ return TRUE;
++}
++
++static void r128_mode_prepare(xf86OutputPtr output)
++{
++ r128_dpms(output, DPMSModeOff);
++}
++
++static void r128_mode_set(xf86OutputPtr output, DisplayModePtr mode, DisplayModePtr adjusted_mode)
++{
++}
++
++static void r128_mode_commit(xf86OutputPtr output)
++{
++ r128_dpms(output, DPMSModeOn);
++}
++
++static xf86OutputStatus r128_detect(xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
++ r128_output->MonType = MT_UNKNOWN;
++ R128ConnectorFindMonitor(pScrn, output);
++
++ if (r128_output->MonType == MT_UNKNOWN) {
++ output->subpixel_order = SubPixelUnknown;
++ return XF86OutputStatusUnknown;
++ } else if (r128_output->MonType == MT_NONE) {
++ output->subpixel_order = SubPixelUnknown;
++ return XF86OutputStatusDisconnected;
++ } else {
++ switch(r128_output->MonType) {
++ case MT_LCD:
++ case MT_DFP:
++ output->subpixel_order = SubPixelHorizontalRGB;
++ break;
++ default:
++ output->subpixel_order = SubPixelNone;
++ break;
++ }
++
++ return XF86OutputStatusConnected;
++ }
++}
++
++static DisplayModePtr r128_get_modes(xf86OutputPtr output)
++{
++ DisplayModePtr modes;
++ modes = R128ProbeOutputModes(output);
++ return modes;
++}
++
++static void r128_destroy(xf86OutputPtr output)
++{
++ if (output->driver_private)
++ free(output->driver_private);
++}
++
++static const xf86OutputFuncsRec r128_output_funcs = {
++ .dpms = r128_dpms,
++ .save = r128_save,
++ .restore = r128_restore,
++ .mode_valid = r128_mode_valid,
++ .mode_fixup = r128_mode_fixup,
++ .prepare = r128_mode_prepare,
++ .mode_set = r128_mode_set,
++ .commit = r128_mode_commit,
++ .detect = r128_detect,
++ .get_modes = r128_get_modes,
++ .destroy = r128_destroy,
++};
++
++void R128DPMSSetOn(xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ R128OutputPrivatePtr r128_output = output->driver_private;
++ R128MonitorType MonType = r128_output->MonType;
++
++ switch(MonType) {
++ case MT_LCD:
++ OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_BLON, ~R128_LVDS_BLON);
++ usleep(info->PanelPwrDly * 1000);
++ OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_ON, ~R128_LVDS_ON);
++ break;
++ case MT_DFP:
++ OUTREGP(R128_FP_GEN_CNTL, (R128_FP_FPON | R128_FP_TDMS_EN), ~(R128_FP_FPON | R128_FP_TDMS_EN));
++ break;
++ default:
++ break;
++ }
++}
++
++void R128DPMSSetOff(xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ R128OutputPrivatePtr r128_output = output->driver_private;
++ R128MonitorType MonType = r128_output->MonType;
++
++ switch(MonType) {
++ case MT_LCD:
++ OUTREGP(R128_LVDS_GEN_CNTL, 0, ~(R128_LVDS_BLON | R128_LVDS_ON));
++ break;
++ case MT_DFP:
++ OUTREGP(R128_FP_GEN_CNTL, 0, ~(R128_FP_FPON | R128_FP_TDMS_EN));
++ break;
++ default:
++ break;
++ }
++}
++
++static R128MonitorType R128DisplayDDCConnected(xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
++ R128MonitorType MonType = MT_NONE;
++ xf86MonPtr *MonInfo = &output->MonInfo;
++ CARD32 mask1, mask2;
++
++ if (r128_output->type == OUTPUT_LVDS) {
++ return MT_LCD;
++ } else if (r128_output->type == OUTPUT_VGA) {
++ mask1 = R128_GPIO_MONID_MASK_1 | R128_GPIO_MONID_MASK_3;
++ mask2 = R128_GPIO_MONID_A_1 | R128_GPIO_MONID_A_3;
++ } else {
++ mask1 = R128_GPIO_MONID_MASK_0 | R128_GPIO_MONID_MASK_3;
++ mask2 = R128_GPIO_MONID_A_0 | R128_GPIO_MONID_A_3;
++ }
++
++ if (r128_output->pI2CBus) {
++ R128I2CBusPtr pR128I2CBus = &(r128_output->ddc_i2c);
++
++ /* XXX: Radeon does something here to appease old monitors. */
++ OUTREG(pR128I2CBus->ddc_reg, INREG(pR128I2CBus->ddc_reg) | mask1);
++ OUTREG(pR128I2CBus->ddc_reg, INREG(pR128I2CBus->ddc_reg) & ~mask2);
++ *MonInfo = xf86DoEDID_DDC2(XF86_SCRN_ARG(pScrn), r128_output->pI2CBus);
++ } else {
++ xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "DDC2/I2C is not properly initialized\n");
++ return MT_NONE;
++ }
++
++ if (*MonInfo) {
++ if (r128_output->type == OUTPUT_VGA) {
++ MonType = MT_CRT;
++ } else {
++ if ((*MonInfo)->rawData[0x14] & 0x80)
++ MonType = MT_DFP;
++ else
++ MonType = MT_CRT;
++ }
++ }
++
++ return MonType;
++}
++
++static void R128ConnectorFindMonitor(ScrnInfoPtr pScrn, xf86OutputPtr output)
++{
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
++ /* XXX: We should figure out how the DAC and BIOS scratch registers work
++ * to handle the non-DDC case. */
++ if (r128_output->MonType == MT_UNKNOWN)
++ r128_output->MonType = R128DisplayDDCConnected(output);
++}
++
++DisplayModePtr R128ProbeOutputModes(xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128OutputPrivatePtr r128_output = output->driver_private;
++ DisplayModePtr modes = NULL;
++ DisplayModePtr mode;
++ xf86MonPtr edid_mon;
++
++ if (r128_output->pI2CBus) {
++ edid_mon = xf86OutputGetEDID(output, r128_output->pI2CBus);
++ xf86OutputSetEDID(output, edid_mon);
++ modes = xf86OutputGetEDIDModes(output);
++ }
++
++ /* Letting this function return NULL would be a bad idea. With old cards
++ * like r128, users often specify a small resolution in order to get DRI.
++ * If the X server has to guess modes, the list it comes up with includes
++ * high resolutions.
++ */
++ if (!modes)
++ modes = xf86GetDefaultModes();
++
++ for (mode = modes; mode != NULL; mode = mode->next) {
++ xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
++ if (mode->status == MODE_OK)
++ mode->status = R128ValidMode(XF86_SCRN_ARG(pScrn), mode, TRUE, MODECHECK_FINAL);
++ }
++
++ xf86ValidateModesUserConfig(pScrn, modes);
++ xf86PruneInvalidModes(pScrn, &modes, FALSE);
++
++ return modes;
++}
++
++static xf86OutputPtr R128OutputCreate(ScrnInfoPtr pScrn, const char *name, int i)
++{
++ char buf[32];
++ sprintf(buf, name, i);
++ return xf86OutputCreate(pScrn, &r128_output_funcs, buf);
++}
++
++static void R128I2CGetBits(I2CBusPtr b, int *Clock, int *data)
++{
++ ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex];
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned long val;
++ unsigned char *R128MMIO = info->MMIO;
++ R128I2CBusPtr pR128I2CBus = b->DriverPrivate.ptr;
++
++ /* Get the result. */
++ val = INREG(pR128I2CBus->ddc_reg);
++ *Clock = (val & pR128I2CBus->get_clk_mask) != 0;
++ *data = (val & pR128I2CBus->get_data_mask) != 0;
++}
++
++static void R128I2CPutBits(I2CBusPtr b, int Clock, int data)
++{
++ ScrnInfoPtr pScrn = xf86Screens[b->scrnIndex];
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned long val;
++ unsigned char *R128MMIO = info->MMIO;
++ R128I2CBusPtr pR128I2CBus = b->DriverPrivate.ptr;
++
++ val = INREG(pR128I2CBus->ddc_reg)
++ & ~(CARD32)(pR128I2CBus->put_clk_mask | pR128I2CBus->put_data_mask);
++ val |= (Clock ? 0 : pR128I2CBus->put_clk_mask);
++ val |= (data ? 0 : pR128I2CBus->put_data_mask);
++ OUTREG(pR128I2CBus->ddc_reg, val);
++}
++
++static Bool R128I2CInit(xf86OutputPtr output, I2CBusPtr *bus_ptr, char *name)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128OutputPrivatePtr r128_output = output->driver_private;
++ R128I2CBusPtr pR128I2CBus = &(r128_output->ddc_i2c);
++ I2CBusPtr pI2CBus;
++
++ pI2CBus = xf86CreateI2CBusRec();
++ if(!pI2CBus) return FALSE;
++
++ pI2CBus->BusName = name;
++ pI2CBus->scrnIndex = pScrn->scrnIndex;
++ pI2CBus->I2CPutBits = R128I2CPutBits;
++ pI2CBus->I2CGetBits = R128I2CGetBits;
++ pI2CBus->AcknTimeout = 5;
++
++ pI2CBus->DriverPrivate.ptr = (pointer)pR128I2CBus;
++ if (!xf86I2CBusInit(pI2CBus)) return FALSE;
++
++ *bus_ptr = pI2CBus;
++ return TRUE;
++}
++
++void R128SetOutputType(ScrnInfoPtr pScrn, R128OutputPrivatePtr r128_output)
++{
++ R128OutputType output = OUTPUT_NONE;
++
++ switch (r128_output->ConnectorType) {
++ case CONNECTOR_VGA:
++ output = OUTPUT_VGA;
++ break;
++ case CONNECTOR_LVDS:
++ output = OUTPUT_LVDS;
++ break;
++ case CONNECTOR_DVI_D:
++ case CONNECTOR_DVI_I:
++ case CONNECTOR_DVI_A:
++ output = OUTPUT_DVI;
++ break;
++ default:
++ output = OUTPUT_NONE;
++ }
++
++ r128_output->type = output;
++}
++
++void R128SetupGenericConnectors(ScrnInfoPtr pScrn)
++{
++ R128InfoPtr info = R128PTR(pScrn);
++
++ if (!info->HasCRTC2 && !info->isDFP) {
++ info->BiosConnector[0].ConnectorType = CONNECTOR_VGA;
++ info->BiosConnector[0].valid = TRUE;
++ return;
++ } else if (!info->HasCRTC2) {
++ info->BiosConnector[0].ConnectorType = CONNECTOR_DVI_D;
++ info->BiosConnector[0].valid = TRUE;
++ return;
++ }
++
++ info->BiosConnector[0].ConnectorType = CONNECTOR_LVDS;
++ info->BiosConnector[0].valid = TRUE;
++
++ info->BiosConnector[1].ConnectorType = CONNECTOR_VGA;
++ info->BiosConnector[1].valid = TRUE;
++}
++
++Bool R128SetupConnectors(ScrnInfoPtr pScrn)
++{
++ R128InfoPtr info = R128PTR(pScrn);
++ xf86OutputPtr output;
++ int num_vga = 0;
++ int num_dvi = 0;
++ int i;
++
++ for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
++ info->BiosConnector[i].valid = FALSE;
++ info->BiosConnector[i].ConnectorType = CONNECTOR_NONE;
++ }
++
++ /* XXX: Can we make R128GetConnectorInfoFromBIOS()? */
++ R128SetupGenericConnectors(pScrn);
++
++ for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
++ if (info->BiosConnector[i].valid) {
++ if ((info->BiosConnector[i].ConnectorType == CONNECTOR_DVI_D) ||
++ (info->BiosConnector[i].ConnectorType == CONNECTOR_DVI_I) ||
++ (info->BiosConnector[i].ConnectorType == CONNECTOR_DVI_A)) {
++ num_dvi++;
++ } else if (info->BiosConnector[i].ConnectorType == CONNECTOR_VGA) {
++ num_vga++;
++ }
++ }
++ }
++
++ for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
++ if (info->BiosConnector[i].valid) {
++ R128I2CBusRec i2c;
++ R128OutputPrivatePtr r128_output;
++ R128ConnectorType conntype = info->BiosConnector[i].ConnectorType;
++
++ if (conntype == CONNECTOR_NONE)
++ continue;
++
++ r128_output = xnfcalloc(sizeof(R128OutputPrivateRec), 1);
++ if (!r128_output) return FALSE;
++
++ r128_output->MonType = MT_UNKNOWN;
++ r128_output->ConnectorType = conntype;
++ r128_output->num = i;
++
++ if (conntype == CONNECTOR_LVDS) {
++ output = R128OutputCreate(pScrn, "LVDS", 0);
++ } else if (conntype == CONNECTOR_VGA) {
++ output = R128OutputCreate(pScrn, "VGA-%d", --num_vga);
++ } else {
++ output = R128OutputCreate(pScrn, "DVI-%d", --num_dvi);
++ }
++
++ if (!output) return FALSE;
++ output->interlaceAllowed = TRUE;
++ output->doubleScanAllowed = TRUE;
++ output->driver_private = r128_output;
++ output->possible_clones = 0;
++ if (conntype == CONNECTOR_LVDS || !info->HasCRTC2)
++ output->possible_crtcs = 1;
++ else
++ output->possible_crtcs = 2;
++
++ if (conntype != CONNECTOR_LVDS && info->DDC) {
++ i2c.ddc_reg = R128_GPIO_MONID;
++ i2c.put_clk_mask = R128_GPIO_MONID_EN_3;
++ i2c.get_clk_mask = R128_GPIO_MONID_Y_3;
++ if (conntype == CONNECTOR_VGA) {
++ i2c.put_data_mask = R128_GPIO_MONID_EN_1;
++ i2c.get_data_mask = R128_GPIO_MONID_Y_1;
++ } else {
++ i2c.put_data_mask = R128_GPIO_MONID_EN_0;
++ i2c.get_data_mask = R128_GPIO_MONID_Y_0;
++ }
++ r128_output->ddc_i2c = i2c;
++ R128I2CInit(output, &r128_output->pI2CBus, output->name);
++ }
++
++ R128SetOutputType(pScrn, r128_output);
++ }
++ }
++
++ return TRUE;
++}
+diff --git a/src/r128_probe.c b/src/r128_probe.c
+index 12e0c1c..e623bc9 100644
+--- a/src/r128_probe.c
++++ b/src/r128_probe.c
+@@ -48,7 +48,6 @@
+ #include "xf86Resources.h"
+ #endif
+
+-#include "compat-api.h"
+ #include "r128_probe.h"
+
+ #ifndef XSERVER_LIBPCIACCESS
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index 7b55e71..f521a13 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -37,6 +37,15 @@
+ #define _R128_PROBE_H_ 1
+
+ #include "xf86str.h"
++#include "xf86DDC.h"
++#include "randrstr.h"
++#include "xf86Crtc.h"
++
++#include "compat-api.h"
++
++#ifdef USE_EXA
++#include "exa.h"
++#endif
+
+ /* Chip definitions */
+ #define PCI_VENDOR_ATI 0x1002
+@@ -90,6 +99,73 @@
+
+ extern DriverRec R128;
+
++typedef enum
++{
++ MT_UNKNOWN = -1,
++ MT_NONE = 0,
++ MT_CRT = 1,
++ MT_LCD = 2,
++ MT_DFP = 3,
++ MT_CTV = 4,
++ MT_STV = 5
++} R128MonitorType;
++
++typedef enum
++{
++ CONNECTOR_NONE,
++ CONNECTOR_VGA,
++ CONNECTOR_DVI_I,
++ CONNECTOR_DVI_D,
++ CONNECTOR_DVI_A,
++ CONNECTOR_LVDS
++} R128ConnectorType;
++
++typedef enum
++{
++ OUTPUT_NONE,
++ OUTPUT_VGA,
++ OUTPUT_DVI,
++ OUTPUT_LVDS
++} R128OutputType;
++
++typedef struct {
++ CARD32 ddc_reg;
++ CARD32 put_clk_mask;
++ CARD32 put_data_mask;
++ CARD32 get_clk_mask;
++ CARD32 get_data_mask;
++} R128I2CBusRec, *R128I2CBusPtr;
++
++typedef struct _R128CrtcPrivateRec {
++#ifdef HAVE_XAA_H
++ FBLinearPtr rotate_mem_xaa;
++#endif
++#ifdef USE_EXA
++ ExaOffscreenArea *rotate_mem_exa;
++#endif
++ int crtc_id;
++ CARD32 cursor_offset;
++ /* Lookup table values to be set when the CRTC is enabled */
++ CARD8 lut_r[256], lut_g[256], lut_b[256];
++} R128CrtcPrivateRec, *R128CrtcPrivatePtr;
++
++typedef struct {
++ R128ConnectorType ConnectorType;
++ Bool valid;
++} R128BIOSConnector;
++
++typedef struct _R128OutputPrivateRec {
++ int num;
++ R128OutputType type;
++ R128ConnectorType ConnectorType;
++ R128MonitorType MonType;
++ I2CBusPtr pI2CBus;
++ R128I2CBusRec ddc_i2c;
++} R128OutputPrivateRec, *R128OutputPrivatePtr;
++
++#define R128_MAX_CRTC 2
++#define R128_MAX_BIOS_CONNECTOR 2
++
+ typedef struct
+ {
+ Bool IsDRIEnabled;
+@@ -101,6 +177,9 @@ typedef struct
+ Bool IsSecondaryRestored;
+ Bool RestorePrimary;
+
++ xf86CrtcPtr pCrtc[R128_MAX_CRTC];
++ R128CrtcPrivatePtr Controller[R128_MAX_CRTC];
++
+ ScrnInfoPtr pSecondaryScrn;
+ ScrnInfoPtr pPrimaryScrn;
+ } R128EntRec, *R128EntPtr;
+diff --git a/src/r128_video.c b/src/r128_video.c
+index dccaa42..6439a24 100644
+--- a/src/r128_video.c
++++ b/src/r128_video.c
+@@ -226,7 +226,7 @@ R128SetupImageVideo(ScreenPtr pScreen)
+ return NULL;
+
+ adapt->type = XvWindowMask | XvInputMask | XvImageMask;
+- adapt->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
++ adapt->flags = VIDEO_OVERLAID_IMAGES /*| VIDEO_CLIP_TO_VIEWPORT*/;
+ adapt->name = "ATI Rage128 Video Overlay";
+ adapt->nEncodings = 1;
+ adapt->pEncodings = &DummyEncoding;
+@@ -849,6 +849,13 @@ R128PutImage(
+ int top, left, npixels, nlines;
+ BoxRec dstBox;
+ CARD32 tmp;
++
++ /* Currently, the video is only visible on the first monitor.
++ * In the future we could try to make this smarter, or just implement
++ * textured video. */
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ xf86CrtcPtr crtc = xf86_config->crtc[0];
++
+ #if X_BYTE_ORDER == X_BIG_ENDIAN
+ unsigned char *R128MMIO = info->MMIO;
+ CARD32 config_cntl = INREG(R128_CONFIG_CNTL);
+@@ -893,10 +900,10 @@ R128PutImage(
+ clipBoxes, width, height))
+ return Success;
+
+- dstBox.x1 -= pScrn->frameX0;
+- dstBox.x2 -= pScrn->frameX0;
+- dstBox.y1 -= pScrn->frameY0;
+- dstBox.y2 -= pScrn->frameY0;
++ dstBox.x1 -= crtc->x;
++ dstBox.x2 -= crtc->x;
++ dstBox.y1 -= crtc->y;
++ dstBox.y2 -= crtc->y;
+
+ switch(id) {
+ case FOURCC_YV12:
+--
+2.2.2
+
+
+From 539320429ff1cf8918862da3f950c8740ba63ec4 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Fri, 4 Jul 2014 12:44:30 -0700
+Subject: Only enable CRTCs for DPMSModeOn
+
+This was suggested as a power saving tip.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128_crtc.c | 14 ++++++++++++++
+ 1 file changed, 14 insertions(+)
+
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+index 35e1fee..8a6ec44 100644
+--- a/src/r128_crtc.c
++++ b/src/r128_crtc.c
+@@ -84,6 +84,20 @@ static void r128_crtc_dpms(xf86CrtcPtr crtc, int mode)
+ break;
+ }
+
++ if (mode != DPMSModeOn) {
++ if (r128_crtc->crtc_id) {
++ OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~R128_CRTC2_EN);
++ } else {
++ OUTREGP(R128_CRTC_GEN_CNTL, 0, ~R128_CRTC_EN);
++ }
++ } else {
++ if (r128_crtc->crtc_id) {
++ OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_EN, ~R128_CRTC2_EN);
++ } else {
++ OUTREGP(R128_CRTC_GEN_CNTL, R128_CRTC_EN, ~R128_CRTC_EN);
++ }
++ }
++
+ if (mode != DPMSModeOff)
+ r128_crtc_load_lut(crtc);
+ }
+--
+2.2.2
+
+
+From 4c6457e1893e16546c03ca85a2fa7378b6c927f3 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Mon, 7 Jul 2014 18:49:15 -0700
+Subject: Map and unmap the MMIO better
+
+Now that the MMIO stays mapped during several function calls, we need to
+remember to unmap it if any of them fail. This also fixes a PowerPC code
+path that was not updated to work with the longer lived MMIO.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_driver.c | 11 +++++------
+ 1 file changed, 5 insertions(+), 6 deletions(-)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 9205328..e7833ed 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -641,15 +641,10 @@ static Bool R128GetPLLParameters(ScrnInfoPtr pScrn)
+ pll->min_pll_freq = 12500;
+ pll->max_pll_freq = 25000;
+
+- /* need to memory map the io to use INPLL since it
+- has not been done yet at this point in the startup */
+- R128MapMMIO(pScrn);
+ x_mpll_ref_fb_div = INPLL(pScrn, R128_X_MPLL_REF_FB_DIV);
+ xclk_cntl = INPLL(pScrn, R128_XCLK_CNTL) & 0x7;
+ pll->reference_div =
+ INPLL(pScrn,R128_PPLL_REF_DIV) & R128_PPLL_REF_DIV_MASK;
+- /* unmap it again */
+- R128UnmapMMIO(pScrn);
+
+ Nx = (x_mpll_ref_fb_div & 0x00FF00) >> 8;
+ M = (x_mpll_ref_fb_div & 0x0000FF);
+@@ -959,7 +954,7 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+
+ /* Read registers used to determine options */
+ from = X_PROBED;
+- R128MapMMIO(pScrn);
++ if (!R128MapMMIO(pScrn)) return FALSE;
+ R128MMIO = info->MMIO;
+
+ if (info->FBDev)
+@@ -1641,6 +1636,10 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ if (info->VGAAccess)
+ vgaHWFreeHWRec(pScrn);
+ #endif
++
++ if (info->MMIO) R128UnmapMMIO(pScrn);
++ info->MMIO = NULL;
++
+ R128FreeRec(pScrn);
+ return FALSE;
+ }
+--
+2.2.2
+
+
+From de7fa61b06c887df7a89154bf0f07703a665263a Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 9 Jul 2014 11:37:12 -0700
+Subject: Split up output register functions
+
+The old code was writing registers more often than it needed to. TMDS
+writes were triggered by changing the mode for an LVDS panel and RMX
+writes were triggered by changing the mode for the second crtc. This
+splits TMDS, LVDS, DAC and RMX calls into their own functions.
+
+Also note that routing bits have been specified. R128_FP_SEL_CRTC2 and
+R128_LVDS_SEL_CRTC2 are always unset to make the panels use the first
+crtc. R128_DAC_CRT_SEL_CRTC2 is unset unless LVDS is already using the
+first crtc.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128.h | 8 +-
+ src/r128_crtc.c | 20 -----
+ src/r128_driver.c | 217 ++++++++++++++++++++++++++++++------------------------
+ src/r128_output.c | 30 +++++++-
+ src/r128_probe.h | 2 +
+ 5 files changed, 157 insertions(+), 120 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index fe757f8..d01b5c1 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -554,7 +554,10 @@ extern int R128MinBits(int val);
+ extern void R128InitVideo(ScreenPtr pScreen);
+
+ extern void R128InitCommonRegisters(R128SavePtr save, R128InfoPtr info);
+-extern void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
++extern void R128InitDACRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output);
++extern void R128InitRMXRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output, DisplayModePtr mode);
++extern void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output);
++extern void R128InitLVDSRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output);
+ extern Bool R128InitCrtcBase(xf86CrtcPtr crtc, R128SavePtr save, int x, int y);
+ extern Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
+ extern void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, double dot_clock);
+@@ -564,7 +567,10 @@ extern Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save, D
+ extern void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, double dot_clock);
+ extern Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, R128InfoPtr info, DisplayModePtr mode);
+ extern void R128RestoreCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreDACRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreRMXRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+ extern void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
++extern void R128RestoreLVDSRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+ extern void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+ extern void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+ extern void R128RestoreDDARegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+index 8a6ec44..9c3d0a9 100644
+--- a/src/r128_crtc.c
++++ b/src/r128_crtc.c
+@@ -133,26 +133,14 @@ static void r128_crtc_mode_prepare(xf86CrtcPtr crtc)
+ static void r128_crtc_mode_set(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayModePtr adjusted_mode, int x, int y)
+ {
+ ScrnInfoPtr pScrn = crtc->scrn;
+- xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+ R128InfoPtr info = R128PTR(pScrn);
+- R128OutputType otype = OUTPUT_NONE;
+-
+ double dot_clock = adjusted_mode->Clock / 1000.0;
+- int i;
+
+ if (r128_crtc->cursor_offset) r128_crtc_hide_cursor(crtc);
+ xf86PrintModeline(pScrn->scrnIndex, adjusted_mode);
+ R128InitCommonRegisters(&info->ModeReg, info);
+
+- for (i = 0; i < xf86_config->num_output; i++) {
+- xf86OutputPtr output = xf86_config->output[i];
+- R128OutputPrivatePtr r128_output = output->driver_private;
+-
+- if (output->crtc == crtc)
+- otype = r128_output->type;
+- }
+-
+ switch (r128_crtc->crtc_id) {
+ case 0:
+ R128InitCrtcRegisters(pScrn, &info->ModeReg, adjusted_mode, info);
+@@ -178,8 +166,6 @@ static void r128_crtc_mode_set(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayMod
+ break;
+ }
+
+- if (otype == OUTPUT_DVI || otype == OUTPUT_LVDS)
+- R128InitFPRegisters(&info->SavedReg, &info->ModeReg, adjusted_mode, info);
+ R128RestoreCommonRegisters(pScrn, &info->ModeReg);
+
+ switch (r128_crtc->crtc_id) {
+@@ -195,12 +181,6 @@ static void r128_crtc_mode_set(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayMod
+ break;
+ }
+
+- if (otype == OUTPUT_DVI || otype == OUTPUT_LVDS)
+- R128RestoreFPRegisters(pScrn, &info->ModeReg);
+-
+- /* XXX: InitFPRegisters looks similar to radeon's InitRMXRegisters so
+- * maybe it should be called from mode_set in the output code.
+- */
+ if (r128_crtc->cursor_offset) r128_crtc_show_cursor(crtc);
+ }
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index e7833ed..8e15b0c 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -2376,9 +2376,6 @@ void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ OUTREGP(R128_CRTC_EXT_CNTL, restore->crtc_ext_cntl,
+ R128_CRTC_VSYNC_DIS | R128_CRTC_HSYNC_DIS | R128_CRTC_DISPLAY_DIS);
+
+- OUTREGP(R128_DAC_CNTL, restore->dac_cntl,
+- R128_DAC_RANGE_CNTL | R128_DAC_BLANKING);
+-
+ OUTREG(R128_CRTC_H_TOTAL_DISP, restore->crtc_h_total_disp);
+ OUTREG(R128_CRTC_H_SYNC_STRT_WID, restore->crtc_h_sync_strt_wid);
+ OUTREG(R128_CRTC_V_TOTAL_DISP, restore->crtc_v_total_disp);
+@@ -2389,8 +2386,7 @@ void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ }
+
+ /* Write CRTC2 registers. */
+-void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn,
+- R128SavePtr restore)
++void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+@@ -2407,26 +2403,48 @@ void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn,
+ OUTREG(R128_CRTC2_PITCH, restore->crtc2_pitch);
+ }
+
+-/* Write flat panel registers */
+-void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++/* Write DAC registers */
++void R128RestoreDACRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++{
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++
++ OUTREGP(R128_DAC_CNTL, restore->dac_cntl,
++ R128_DAC_RANGE_CNTL | R128_DAC_BLANKING);
++}
++
++/* Write RMX registers */
++void R128RestoreRMXRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 tmp;
+
+- if (info->BIOSDisplay != R128_DUALHEAD)
+- OUTREG(R128_CRTC2_GEN_CNTL, restore->crtc2_gen_cntl);
+ OUTREG(R128_FP_HORZ_STRETCH, restore->fp_horz_stretch);
+ OUTREG(R128_FP_VERT_STRETCH, restore->fp_vert_stretch);
+ OUTREG(R128_FP_CRTC_H_TOTAL_DISP, restore->fp_crtc_h_total_disp);
+ OUTREG(R128_FP_CRTC_V_TOTAL_DISP, restore->fp_crtc_v_total_disp);
+ OUTREG(R128_FP_H_SYNC_STRT_WID, restore->fp_h_sync_strt_wid);
+ OUTREG(R128_FP_V_SYNC_STRT_WID, restore->fp_v_sync_strt_wid);
+- OUTREG(R128_TMDS_CRC, restore->tmds_crc);
+- OUTREG(R128_FP_PANEL_CNTL, restore->fp_panel_cntl);
++}
++
++/* Write flat panel registers */
++void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++{
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++
++ OUTREG(R128_TMDS_CRC, restore->tmds_crc);
++ OUTREG(R128_TMDS_TRANSMITTER_CNTL, restore->tmds_transmitter_cntl);
++ OUTREG(R128_FP_PANEL_CNTL, restore->fp_panel_cntl);
+ OUTREG(R128_FP_GEN_CNTL, restore->fp_gen_cntl & ~(CARD32)R128_FP_BLANK_DIS);
++}
+
+- if(info->isDFP) return;
++/* Write LVDS registers */
++void R128RestoreLVDSRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
++{
++ R128InfoPtr info = R128PTR(pScrn);
++ unsigned char *R128MMIO = info->MMIO;
++ CARD32 tmp;
+
+ tmp = INREG(R128_LVDS_GEN_CNTL);
+ if ((tmp & (R128_LVDS_ON | R128_LVDS_BLON)) ==
+@@ -2885,7 +2903,10 @@ static void R128Restore(ScrnInfoPtr pScrn)
+ R128RestoreDDARegisters(pScrn, restore);
+ R128RestoreCrtcRegisters(pScrn, restore);
+ R128RestorePLLRegisters(pScrn, restore);
++ R128RestoreDACRegisters(pScrn, restore);
++ R128RestoreRMXRegisters(pScrn, restore);
+ R128RestoreFPRegisters(pScrn, restore);
++ R128RestoreLVDSRegisters(pScrn, restore);
+ }
+
+ #ifdef WITH_VGAHW
+@@ -3058,21 +3079,14 @@ Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ if((info->DisplayType == MT_DFP) ||
+ (info->DisplayType == MT_LCD))
+ {
+- save->crtc_ext_cntl = R128_VGA_ATI_LINEAR |
+- R128_XCRT_CNT_EN;
+ save->crtc_gen_cntl &= ~(R128_CRTC_DBL_SCAN_EN |
+ R128_CRTC_INTERLACE_EN);
+ }
+- else
+- save->crtc_ext_cntl = R128_VGA_ATI_LINEAR |
++
++ save->crtc_ext_cntl = R128_VGA_ATI_LINEAR |
+ R128_XCRT_CNT_EN |
+ R128_CRTC_CRT_ON;
+
+- save->dac_cntl = (R128_DAC_MASK_ALL
+- | R128_DAC_VGA_ADR_EN
+- | (info->dac6bits ? 0 : R128_DAC_8BIT_EN));
+-
+-
+ if(info->isDFP && !info->isPro2)
+ {
+ if(info->PanelXRes < mode->CrtcHDisplay)
+@@ -3224,36 +3238,50 @@ Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ return TRUE;
+ }
+
+-/* Define CRTC registers for requested video mode. */
+-void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
+- DisplayModePtr mode, R128InfoPtr info)
++/* Define DAC registers for the requested video mode. */
++void R128InitDACRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ xf86CrtcPtr crtc = output->crtc;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ save->dac_cntl = (R128_DAC_MASK_ALL | R128_DAC_VGA_ADR_EN |
++ (!r128_crtc->crtc_id ? 0 : R128_DAC_CRT_SEL_CRTC2) |
++ (info->dac6bits ? 0 : R128_DAC_8BIT_EN));
++}
++
++/* Define RMX registers for the requested video mode. */
++void R128InitRMXRegisters(R128SavePtr orig, R128SavePtr save,
++ xf86OutputPtr output, DisplayModePtr mode)
+ {
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
+ int xres = mode->CrtcHDisplay;
+ int yres = mode->CrtcVDisplay;
+ float Hratio, Vratio;
+
+- if (info->BIOSDisplay == R128_BIOS_DISPLAY_CRT) {
+- save->crtc_ext_cntl |= R128_CRTC_CRT_ON;
+- save->crtc2_gen_cntl = 0;
+- save->fp_gen_cntl = orig->fp_gen_cntl;
+- save->fp_gen_cntl &= ~(R128_FP_FPON |
+- R128_FP_CRTC_USE_SHADOW_VEND |
+- R128_FP_CRTC_HORZ_DIV2_EN |
+- R128_FP_CRTC_HOR_CRT_DIV2_DIS |
+- R128_FP_USE_SHADOW_EN);
+- save->fp_gen_cntl |= (R128_FP_SEL_CRTC2 |
+- R128_FP_CRTC_DONT_SHADOW_VPAR);
+- save->fp_panel_cntl = orig->fp_panel_cntl & (CARD32)~R128_FP_DIGON;
+- save->lvds_gen_cntl = orig->lvds_gen_cntl &
+- (CARD32)~(R128_LVDS_ON | R128_LVDS_BLON);
++ save->fp_crtc_h_total_disp = save->crtc_h_total_disp;
++ save->fp_crtc_v_total_disp = save->crtc_v_total_disp;
++ save->fp_h_sync_strt_wid = save->crtc_h_sync_strt_wid;
++ save->fp_v_sync_strt_wid = save->crtc_v_sync_strt_wid;
++
++ if (r128_output->type != OUTPUT_DVI && r128_output->type != OUTPUT_LVDS)
+ return;
+- }
+
+- if (xres > info->PanelXRes) xres = info->PanelXRes;
+- if (yres > info->PanelYRes) yres = info->PanelYRes;
++ if (r128_output->PanelXRes == 0 || r128_output->PanelYRes == 0) {
++ xres = r128_output->PanelXRes;
++ yres = r128_output->PanelYRes;
++
++ Hratio = 1.0;
++ Vratio = 1.0;
++ } else {
++ if (xres > r128_output->PanelXRes) xres = r128_output->PanelXRes;
++ if (yres > r128_output->PanelYRes) yres = r128_output->PanelYRes;
+
+- Hratio = (float)xres/(float)info->PanelXRes;
+- Vratio = (float)yres/(float)info->PanelYRes;
++ Hratio = (float)xres/(float)r128_output->PanelXRes;
++ Vratio = (float)yres/(float)r128_output->PanelYRes;
++ }
+
+ save->fp_horz_stretch =
+ (((((int)(Hratio * R128_HORZ_STRETCH_RATIO_MAX + 0.5))
+@@ -3263,7 +3291,7 @@ void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
+ R128_HORZ_STRETCH_RESERVED)));
+ save->fp_horz_stretch &= ~R128_HORZ_AUTO_RATIO_FIX_EN;
+ save->fp_horz_stretch &= ~R128_AUTO_HORZ_RATIO;
+- if (xres == info->PanelXRes)
++ if (xres == r128_output->PanelXRes)
+ save->fp_horz_stretch &= ~(R128_HORZ_STRETCH_BLEND | R128_HORZ_STRETCH_ENABLE);
+ else
+ save->fp_horz_stretch |= (R128_HORZ_STRETCH_BLEND | R128_HORZ_STRETCH_ENABLE);
+@@ -3274,67 +3302,60 @@ void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
+ (orig->fp_vert_stretch & (R128_VERT_PANEL_SIZE |
+ R128_VERT_STRETCH_RESERVED)));
+ save->fp_vert_stretch &= ~R128_VERT_AUTO_RATIO_EN;
+- if (yres == info->PanelYRes)
++ if (yres == r128_output->PanelYRes)
+ save->fp_vert_stretch &= ~(R128_VERT_STRETCH_ENABLE | R128_VERT_STRETCH_BLEND);
+ else
+ save->fp_vert_stretch |= (R128_VERT_STRETCH_ENABLE | R128_VERT_STRETCH_BLEND);
++}
+
+- save->fp_gen_cntl = (orig->fp_gen_cntl &
+- (CARD32)~(R128_FP_SEL_CRTC2 |
+- R128_FP_CRTC_USE_SHADOW_VEND |
+- R128_FP_CRTC_HORZ_DIV2_EN |
+- R128_FP_CRTC_HOR_CRT_DIV2_DIS |
+- R128_FP_USE_SHADOW_EN));
+-
+- save->fp_panel_cntl = orig->fp_panel_cntl;
+- save->lvds_gen_cntl = orig->lvds_gen_cntl;
+- save->tmds_crc = orig->tmds_crc;
+-
+- /* Disable CRT output by disabling CRT output and setting the CRT
+- DAC to use CRTC2, which we set to 0's. In the future, we will
+- want to use the dual CRTC capabilities of the R128 to allow both
+- the flat panel and external CRT to either simultaneously display
+- the same image or display two different images. */
+-
+-
+- if(!info->isDFP){
+- if (info->BIOSDisplay == R128_BIOS_DISPLAY_FP_CRT) {
+- save->crtc_ext_cntl |= R128_CRTC_CRT_ON;
+- } else if (info->BIOSDisplay == R128_DUALHEAD) {
+- save->crtc_ext_cntl |= R128_CRTC_CRT_ON;
+- save->dac_cntl |= R128_DAC_CRT_SEL_CRTC2;
+- save->dac_cntl |= R128_DAC_PALETTE2_SNOOP_EN;
+- } else {
+- save->crtc_ext_cntl &= ~R128_CRTC_CRT_ON;
+- save->dac_cntl |= R128_DAC_CRT_SEL_CRTC2;
+- save->crtc2_gen_cntl = 0;
+- }
+- }
++/* Define flat panel registers for the requested video mode. */
++void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output)
++{
++ xf86CrtcPtr crtc = output->crtc;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+
+ /* WARNING: Be careful about turning on the flat panel */
+- if(info->isDFP){
+- save->fp_gen_cntl = orig->fp_gen_cntl;
+-
+- save->fp_gen_cntl &= ~(R128_FP_CRTC_USE_SHADOW_VEND |
+- R128_FP_CRTC_USE_SHADOW_ROWCUR |
+- R128_FP_CRTC_HORZ_DIV2_EN |
+- R128_FP_CRTC_HOR_CRT_DIV2_DIS |
+- R128_FP_CRT_SYNC_SEL |
+- R128_FP_USE_SHADOW_EN);
+-
+- save->fp_panel_cntl |= (R128_FP_DIGON | R128_FP_BLON);
+- save->fp_gen_cntl |= (R128_FP_FPON | R128_FP_TDMS_EN |
+- R128_FP_CRTC_DONT_SHADOW_VPAR | R128_FP_CRTC_DONT_SHADOW_HEND);
+- save->tmds_transmitter_cntl = (orig->tmds_transmitter_cntl
+- & ~(CARD32)R128_TMDS_PLLRST) | R128_TMDS_PLLEN;
+- }
++ save->fp_gen_cntl = orig->fp_gen_cntl;
++ save->fp_panel_cntl = orig->fp_panel_cntl;
++ save->tmds_transmitter_cntl = orig->tmds_transmitter_cntl;
++ save->tmds_crc = orig->tmds_crc;
++
++ if (r128_crtc->crtc_id)
++ save->fp_gen_cntl |= R128_FP_SEL_CRTC2;
+ else
+- save->lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_BLON);
++ save->fp_gen_cntl &= ~R128_FP_SEL_CRTC2;
+
+- save->fp_crtc_h_total_disp = save->crtc_h_total_disp;
+- save->fp_crtc_v_total_disp = save->crtc_v_total_disp;
+- save->fp_h_sync_strt_wid = save->crtc_h_sync_strt_wid;
+- save->fp_v_sync_strt_wid = save->crtc_v_sync_strt_wid;
++ save->fp_gen_cntl &= ~(R128_FP_CRTC_USE_SHADOW_VEND |
++ R128_FP_CRTC_USE_SHADOW_ROWCUR |
++ R128_FP_CRTC_HORZ_DIV2_EN |
++ R128_FP_CRTC_HOR_CRT_DIV2_DIS |
++ R128_FP_CRT_SYNC_SEL |
++ R128_FP_USE_SHADOW_EN);
++
++ save->fp_gen_cntl |= (R128_FP_FPON |
++ R128_FP_TDMS_EN |
++ R128_FP_CRTC_DONT_SHADOW_VPAR |
++ R128_FP_CRTC_DONT_SHADOW_HEND);
++
++ save->fp_panel_cntl |= (R128_FP_DIGON | R128_FP_BLON);
++ save->tmds_transmitter_cntl &= ~R128_TMDS_PLLRST;
++ save->tmds_transmitter_cntl |= R128_TMDS_PLLEN;
++}
++
++/* Define LVDS registers for the requested video mode. */
++void R128InitLVDSRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output)
++{
++ xf86CrtcPtr crtc = output->crtc;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ save->lvds_gen_cntl = orig->lvds_gen_cntl;
++
++ if (r128_crtc->crtc_id)
++ save->lvds_gen_cntl |= R128_LVDS_SEL_CRTC2;
++ else
++ save->lvds_gen_cntl &= ~R128_LVDS_SEL_CRTC2;
++
++ save->lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_BLON);
+ }
+
+ /* Define PLL registers for requested video mode. */
+diff --git a/src/r128_output.c b/src/r128_output.c
+index 89a2958..4638067 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -81,6 +81,31 @@ static void r128_mode_prepare(xf86OutputPtr output)
+
+ static void r128_mode_set(xf86OutputPtr output, DisplayModePtr mode, DisplayModePtr adjusted_mode)
+ {
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ R128OutputPrivatePtr r128_output = output->driver_private;
++ xf86CrtcPtr crtc = output->crtc;
++ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
++
++ if (r128_crtc->crtc_id == 0)
++ R128InitRMXRegisters(&info->SavedReg, &info->ModeReg, output, adjusted_mode);
++
++ if (r128_output->type == OUTPUT_DVI)
++ R128InitFPRegisters(&info->SavedReg, &info->ModeReg, output);
++ else if (r128_output->type == OUTPUT_LVDS)
++ R128InitLVDSRegisters(&info->SavedReg, &info->ModeReg, output);
++ else if (r128_output->type == OUTPUT_VGA)
++ R128InitDACRegisters(&info->SavedReg, &info->ModeReg, output);
++
++ if (r128_crtc->crtc_id == 0)
++ R128RestoreRMXRegisters(pScrn, &info->ModeReg);
++
++ if (r128_output->type == OUTPUT_DVI)
++ R128RestoreFPRegisters(pScrn, &info->ModeReg);
++ else if (r128_output->type == OUTPUT_LVDS)
++ R128RestoreLVDSRegisters(pScrn, &info->ModeReg);
++ else if (r128_output->type == OUTPUT_VGA)
++ R128RestoreDACRegisters(pScrn, &info->ModeReg);
+ }
+
+ static void r128_mode_commit(xf86OutputPtr output)
+@@ -455,7 +480,10 @@ Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+ }
+ r128_output->ddc_i2c = i2c;
+ R128I2CInit(output, &r128_output->pI2CBus, output->name);
+- }
++ } else if (conntype == CONNECTOR_LVDS) {
++ r128_output->PanelXRes = info->PanelXRes;
++ r128_output->PanelYRes = info->PanelYRes;
++ }
+
+ R128SetOutputType(pScrn, r128_output);
+ }
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index f521a13..95988ec 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -161,6 +161,8 @@ typedef struct _R128OutputPrivateRec {
+ R128MonitorType MonType;
+ I2CBusPtr pI2CBus;
+ R128I2CBusRec ddc_i2c;
++ int PanelXRes;
++ int PanelYRes;
+ } R128OutputPrivateRec, *R128OutputPrivatePtr;
+
+ #define R128_MAX_CRTC 2
+--
+2.2.2
+
+
+From 3bbce42414abea6c9977ff2b023ce3210d78f008 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 9 Jul 2014 11:40:35 -0700
+Subject: Move display enabling code to DPMS
+
+This ensures that DAC, TMDS and LVDS enable bits are properly saved and
+only set in the dpms hook.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128_driver.c | 10 ++--------
+ src/r128_output.c | 18 ++++++++++++++++--
+ 2 files changed, 18 insertions(+), 10 deletions(-)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 8e15b0c..4c03060 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -3083,9 +3083,7 @@ Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ R128_CRTC_INTERLACE_EN);
+ }
+
+- save->crtc_ext_cntl = R128_VGA_ATI_LINEAR |
+- R128_XCRT_CNT_EN |
+- R128_CRTC_CRT_ON;
++ save->crtc_ext_cntl |= R128_VGA_ATI_LINEAR | R128_XCRT_CNT_EN;
+
+ if(info->isDFP && !info->isPro2)
+ {
+@@ -3332,9 +3330,7 @@ void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr outpu
+ R128_FP_CRT_SYNC_SEL |
+ R128_FP_USE_SHADOW_EN);
+
+- save->fp_gen_cntl |= (R128_FP_FPON |
+- R128_FP_TDMS_EN |
+- R128_FP_CRTC_DONT_SHADOW_VPAR |
++ save->fp_gen_cntl |= (R128_FP_CRTC_DONT_SHADOW_VPAR |
+ R128_FP_CRTC_DONT_SHADOW_HEND);
+
+ save->fp_panel_cntl |= (R128_FP_DIGON | R128_FP_BLON);
+@@ -3354,8 +3350,6 @@ void R128InitLVDSRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr out
+ save->lvds_gen_cntl |= R128_LVDS_SEL_CRTC2;
+ else
+ save->lvds_gen_cntl &= ~R128_LVDS_SEL_CRTC2;
+-
+- save->lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_BLON);
+ }
+
+ /* Define PLL registers for requested video mode. */
+diff --git a/src/r128_output.c b/src/r128_output.c
+index 4638067..79c80bf 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -176,15 +176,22 @@ void R128DPMSSetOn(xf86OutputPtr output)
+ unsigned char *R128MMIO = info->MMIO;
+ R128OutputPrivatePtr r128_output = output->driver_private;
+ R128MonitorType MonType = r128_output->MonType;
++ R128SavePtr save = &info->ModeReg;
+
+ switch(MonType) {
+ case MT_LCD:
+ OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_BLON, ~R128_LVDS_BLON);
+ usleep(info->PanelPwrDly * 1000);
+ OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_ON, ~R128_LVDS_ON);
++ save->lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_BLON);
+ break;
+ case MT_DFP:
+- OUTREGP(R128_FP_GEN_CNTL, (R128_FP_FPON | R128_FP_TDMS_EN), ~(R128_FP_FPON | R128_FP_TDMS_EN));
++ OUTREGP(R128_FP_GEN_CNTL, (R128_FP_FPON | R128_FP_TDMS_EN), ~(R128_FP_FPON | R128_FP_TDMS_EN));
++ save->fp_gen_cntl |= (R128_FP_FPON | R128_FP_TDMS_EN);
++ break;
++ case MT_CRT:
++ OUTREGP(R128_CRTC_EXT_CNTL, R128_CRTC_CRT_ON, ~R128_CRTC_CRT_ON);
++ save->crtc_ext_cntl |= R128_CRTC_CRT_ON;
+ break;
+ default:
+ break;
+@@ -198,13 +205,20 @@ void R128DPMSSetOff(xf86OutputPtr output)
+ unsigned char *R128MMIO = info->MMIO;
+ R128OutputPrivatePtr r128_output = output->driver_private;
+ R128MonitorType MonType = r128_output->MonType;
++ R128SavePtr save = &info->ModeReg;
+
+ switch(MonType) {
+ case MT_LCD:
+ OUTREGP(R128_LVDS_GEN_CNTL, 0, ~(R128_LVDS_BLON | R128_LVDS_ON));
++ save->lvds_gen_cntl &= ~(R128_LVDS_BLON | R128_LVDS_ON);
+ break;
+ case MT_DFP:
+- OUTREGP(R128_FP_GEN_CNTL, 0, ~(R128_FP_FPON | R128_FP_TDMS_EN));
++ OUTREGP(R128_FP_GEN_CNTL, 0, ~(R128_FP_FPON | R128_FP_TDMS_EN));
++ save->fp_gen_cntl &= ~(R128_FP_FPON | R128_FP_TDMS_EN);
++ break;
++ case MT_CRT:
++ OUTREGP(R128_CRTC_EXT_CNTL, 0, ~(R128_CRTC_CRT_ON));
++ save->crtc_ext_cntl &= ~(R128_CRTC_CRT_ON);
+ break;
+ default:
+ break;
+--
+2.2.2
+
+
+From e9ea36390ea0478c4b867df3bffdf2b122e0cb15 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 16 Jul 2014 00:57:18 -0700
+Subject: Change register name
+
+Surely this is a typo.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_output.c | 8 ++++----
+ src/r128_reg.h | 2 +-
+ 2 files changed, 5 insertions(+), 5 deletions(-)
+
+diff --git a/src/r128_output.c b/src/r128_output.c
+index 79c80bf..d7a1c55 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -186,8 +186,8 @@ void R128DPMSSetOn(xf86OutputPtr output)
+ save->lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_BLON);
+ break;
+ case MT_DFP:
+- OUTREGP(R128_FP_GEN_CNTL, (R128_FP_FPON | R128_FP_TDMS_EN), ~(R128_FP_FPON | R128_FP_TDMS_EN));
+- save->fp_gen_cntl |= (R128_FP_FPON | R128_FP_TDMS_EN);
++ OUTREGP(R128_FP_GEN_CNTL, (R128_FP_FPON | R128_FP_TMDS_EN), ~(R128_FP_FPON | R128_FP_TMDS_EN));
++ save->fp_gen_cntl |= (R128_FP_FPON | R128_FP_TMDS_EN);
+ break;
+ case MT_CRT:
+ OUTREGP(R128_CRTC_EXT_CNTL, R128_CRTC_CRT_ON, ~R128_CRTC_CRT_ON);
+@@ -213,8 +213,8 @@ void R128DPMSSetOff(xf86OutputPtr output)
+ save->lvds_gen_cntl &= ~(R128_LVDS_BLON | R128_LVDS_ON);
+ break;
+ case MT_DFP:
+- OUTREGP(R128_FP_GEN_CNTL, 0, ~(R128_FP_FPON | R128_FP_TDMS_EN));
+- save->fp_gen_cntl &= ~(R128_FP_FPON | R128_FP_TDMS_EN);
++ OUTREGP(R128_FP_GEN_CNTL, 0, ~(R128_FP_FPON | R128_FP_TMDS_EN));
++ save->fp_gen_cntl &= ~(R128_FP_FPON | R128_FP_TMDS_EN);
+ break;
+ case MT_CRT:
+ OUTREGP(R128_CRTC_EXT_CNTL, 0, ~(R128_CRTC_CRT_ON));
+diff --git a/src/r128_reg.h b/src/r128_reg.h
+index dac22e6..9ba0de5 100644
+--- a/src/r128_reg.h
++++ b/src/r128_reg.h
+@@ -599,7 +599,7 @@
+ #define R128_FP_GEN_CNTL 0x0284
+ # define R128_FP_FPON (1 << 0)
+ # define R128_FP_BLANK_DIS (1 << 1)
+-# define R128_FP_TDMS_EN (1 << 2)
++# define R128_FP_TMDS_EN (1 << 2)
+ # define R128_FP_DETECT_SENSE (1 << 8)
+ # define R128_FP_SEL_CRTC2 (1 << 13)
+ # define R128_FP_CRTC_DONT_SHADOW_VPAR (1 << 16)
+--
+2.2.2
+
+
+From c95ce4251921f09101911ca5c4ff3940c38cc6b5 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 16 Jul 2014 01:29:19 -0700
+Subject: Get entity without code duplication
+
+This fixes the parts of the code that were not using the helper function
+to find the entity.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_accel.c | 8 ++------
+ src/r128_driver.c | 34 ++++++----------------------------
+ 2 files changed, 8 insertions(+), 34 deletions(-)
+
+diff --git a/src/r128_accel.c b/src/r128_accel.c
+index 7ffd15f..4d666c7 100644
+--- a/src/r128_accel.c
++++ b/src/r128_accel.c
+@@ -1853,12 +1853,8 @@ static void R128MMIOAccelInit(ScrnInfoPtr pScrn, XAAInfoRecPtr a)
+
+ if(xf86IsEntityShared(pScrn->entityList[0]))
+ {
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
+-
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
++
+ /*if there are more than one devices sharing this entity, we
+ have to assign this call back, otherwise the XAA will be
+ disabled */
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 4c03060..c62a1af 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -241,9 +241,7 @@ static Bool R128MapMMIO(ScrnInfoPtr pScrn)
+ /* If the primary screen has already mapped the MMIO region,
+ use its pointer instead of mapping it a second time. */
+ if (info->IsSecondary) {
+- DevUnion* pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- R128EntPtr pR128Ent = pPriv->ptr;
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ R128InfoPtr info0 = R128PTR(pR128Ent->pPrimaryScrn);
+ info->MMIO=info0->MMIO;
+ if (info->MMIO) return TRUE;
+@@ -482,11 +480,7 @@ static Bool R128GetBIOSParameters(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+
+ if(info->DisplayType > MT_NONE)
+ {
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ pR128Ent->HasSecondary = TRUE;
+
+ }
+@@ -506,11 +500,7 @@ static Bool R128GetBIOSParameters(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ If something on CRT port, treat it as primary*/
+ if(xf86IsEntityShared(pScrn->entityList[0]))
+ {
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ pR128Ent->BypassSecondary = TRUE;
+ }
+
+@@ -1427,24 +1417,16 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ {
+ if(xf86IsPrimInitDone(pScrn->entityList[0]))
+ {
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ info->IsSecondary = TRUE;
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
+ if(pR128Ent->BypassSecondary) return FALSE;
+ pR128Ent->pSecondaryScrn = pScrn;
+ }
+ else
+ {
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ info->IsPrimary = TRUE;
+ xf86SetPrimInitDone(pScrn->entityList[0]);
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
+ pR128Ent->pPrimaryScrn = pScrn;
+ pR128Ent->IsDRIEnabled = FALSE;
+ pR128Ent->BypassSecondary = FALSE;
+@@ -1894,11 +1876,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ R128DRIScreenInit(pScreen);
+ if(xf86IsEntityShared(pScrn->entityList[0]))
+ {
+- DevUnion* pPriv;
+- R128EntPtr pR128Ent;
+- pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
+- getR128EntityIndex());
+- pR128Ent = pPriv->ptr;
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ pR128Ent->IsDRIEnabled = info->directRenderingEnabled;
+ }
+ }
+--
+2.2.2
+
+
+From d05123eab19705d23310d06a299e61093abbe6cc Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 16 Jul 2014 17:23:37 -0700
+Subject: Cleanup entity struct
+
+This moves HasCRTC2 into the entity to make it more similar to radeon.
+It also removes IsDRIEnabled for being dead code.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128.h | 1 -
+ src/r128_crtc.c | 3 +--
+ src/r128_driver.c | 21 ++++++++-------------
+ src/r128_output.c | 12 +++++++-----
+ src/r128_probe.c | 1 -
+ src/r128_probe.h | 3 +--
+ 6 files changed, 17 insertions(+), 24 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index d01b5c1..0308130 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -520,7 +520,6 @@ typedef struct {
+ R128BIOSConnector BiosConnector[R128_MAX_BIOS_CONNECTOR];
+
+ /****** Added for dualhead support *******************/
+- BOOL HasCRTC2; /* M3/M4 */
+ BOOL IsSecondary; /* second Screen */
+ BOOL IsPrimary; /* primary Screen */
+ BOOL UseCRT; /* force use CRT port as primary */
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+index 9c3d0a9..e48e4d5 100644
+--- a/src/r128_crtc.c
++++ b/src/r128_crtc.c
+@@ -388,7 +388,6 @@ static const xf86CrtcFuncsRec r128_crtc_funcs = {
+ Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask)
+ {
+ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- R128InfoPtr info = R128PTR(pScrn);
+
+ if (mask & 1) {
+ if (pR128Ent->Controller[0])
+@@ -407,7 +406,7 @@ Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask)
+ }
+
+ if (mask & 2) {
+- if (!info->HasCRTC2)
++ if (!pR128Ent->HasCRTC2)
+ return TRUE;
+
+ pR128Ent->pCrtc[1] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index c62a1af..3cd3773 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -469,8 +469,9 @@ static Bool R128GetBIOSParameters(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Video BIOS not found!\n");
+ }
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+- if(info->HasCRTC2)
++ if(pR128Ent->HasCRTC2)
+ {
+ if(info->IsSecondary)
+ {
+@@ -480,7 +481,6 @@ static Bool R128GetBIOSParameters(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+
+ if(info->DisplayType > MT_NONE)
+ {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ pR128Ent->HasSecondary = TRUE;
+
+ }
+@@ -771,6 +771,7 @@ static Bool R128PreInitWeight(ScrnInfoPtr pScrn)
+ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+ EntityInfoPtr pEnt = info->pEnt;
+ GDevPtr dev = pEnt->device;
+@@ -865,7 +866,7 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ } else {
+ info->isDFP = FALSE;
+ info->isPro2 = FALSE;
+- info->HasCRTC2 = FALSE;
++ pR128Ent->HasCRTC2 = FALSE;
+ switch (info->Chipset) {
+ /* R128 Pro and Pro2 can have DFP, we will deal with it.
+ No support for dual-head/xinerama yet.
+@@ -918,7 +919,7 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ case PCI_CHIP_RAGE128ML:
+ info->HasPanelRegs = TRUE;
+ /* which chips support dualhead? */
+- info->HasCRTC2 = TRUE;
++ pR128Ent->HasCRTC2 = TRUE;
+ break;
+ case PCI_CHIP_RAGE128RE:
+ case PCI_CHIP_RAGE128RF:
+@@ -1428,7 +1429,6 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ info->IsPrimary = TRUE;
+ xf86SetPrimInitDone(pScrn->entityList[0]);
+ pR128Ent->pPrimaryScrn = pScrn;
+- pR128Ent->IsDRIEnabled = FALSE;
+ pR128Ent->BypassSecondary = FALSE;
+ pR128Ent->HasSecondary = FALSE;
+ pR128Ent->RestorePrimary = FALSE;
+@@ -1872,13 +1872,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ "section in your XFConfig file.\n");
+ }
+ else
+- info->directRenderingEnabled =
+- R128DRIScreenInit(pScreen);
+- if(xf86IsEntityShared(pScrn->entityList[0]))
+- {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- pR128Ent->IsDRIEnabled = info->directRenderingEnabled;
+- }
++ info->directRenderingEnabled = R128DRIScreenInit(pScreen);
+ }
+ }
+ }
+@@ -2854,6 +2848,7 @@ static void R128Save(ScrnInfoPtr pScrn)
+ static void R128Restore(ScrnInfoPtr pScrn)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+ R128SavePtr restore = &info->SavedReg;
+
+@@ -2873,7 +2868,7 @@ static void R128Restore(ScrnInfoPtr pScrn)
+ OUTREG(R128_DP_DATATYPE, restore->dp_datatype);
+
+ R128RestoreCommonRegisters(pScrn, restore);
+- if (info->HasCRTC2) {
++ if (pR128Ent->HasCRTC2) {
+ R128RestoreDDA2Registers(pScrn, restore);
+ R128RestoreCrtc2Registers(pScrn, restore);
+ R128RestorePLL2Registers(pScrn, restore);
+diff --git a/src/r128_output.c b/src/r128_output.c
+index d7a1c55..e5306d6 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -400,13 +400,14 @@ void R128SetOutputType(ScrnInfoPtr pScrn, R128OutputPrivatePtr r128_output)
+
+ void R128SetupGenericConnectors(ScrnInfoPtr pScrn)
+ {
+- R128InfoPtr info = R128PTR(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+- if (!info->HasCRTC2 && !info->isDFP) {
++ if (!pR128Ent->HasCRTC2 && !info->isDFP) {
+ info->BiosConnector[0].ConnectorType = CONNECTOR_VGA;
+ info->BiosConnector[0].valid = TRUE;
+ return;
+- } else if (!info->HasCRTC2) {
++ } else if (!pR128Ent->HasCRTC2) {
+ info->BiosConnector[0].ConnectorType = CONNECTOR_DVI_D;
+ info->BiosConnector[0].valid = TRUE;
+ return;
+@@ -421,7 +422,8 @@ void R128SetupGenericConnectors(ScrnInfoPtr pScrn)
+
+ Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+ {
+- R128InfoPtr info = R128PTR(pScrn);
++ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ xf86OutputPtr output;
+ int num_vga = 0;
+ int num_dvi = 0;
+@@ -476,7 +478,7 @@ Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+ output->doubleScanAllowed = TRUE;
+ output->driver_private = r128_output;
+ output->possible_clones = 0;
+- if (conntype == CONNECTOR_LVDS || !info->HasCRTC2)
++ if (conntype == CONNECTOR_LVDS || !pR128Ent->HasCRTC2)
+ output->possible_crtcs = 1;
+ else
+ output->possible_crtcs = 2;
+diff --git a/src/r128_probe.c b/src/r128_probe.c
+index e623bc9..348d15b 100644
+--- a/src/r128_probe.c
++++ b/src/r128_probe.c
+@@ -288,7 +288,6 @@ r128_get_scrninfo(int entity_num)
+ R128EntPtr pR128Ent;
+ pPriv->ptr = xnfcalloc(sizeof(R128EntRec), 1);
+ pR128Ent = pPriv->ptr;
+- pR128Ent->IsDRIEnabled = FALSE;
+ pR128Ent->BypassSecondary = FALSE;
+ pR128Ent->HasSecondary = FALSE;
+ pR128Ent->IsSecondaryRestored = FALSE;
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index 95988ec..426840a 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -170,9 +170,8 @@ typedef struct _R128OutputPrivateRec {
+
+ typedef struct
+ {
+- Bool IsDRIEnabled;
+-
+ Bool HasSecondary;
++ Bool HasCRTC2;
+ Bool BypassSecondary;
+ /*These two registers are used to make sure the CRTC2 is
+ retored before CRTC_EXT, otherwise it could lead to blank screen.*/
+--
+2.2.2
+
+
+From 866d0ad5295a7ca819b990f607d3e68582144b3b Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 16 Jul 2014 17:39:59 -0700
+Subject: Cleanup info struct
+
+This removes some dead code from info. It also fixes some indentation
+errors that were likely caused by sed.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128.h | 35 +++++++++++------------------------
+ src/r128_dri.c | 6 ------
+ src/r128_driver.c | 13 -------------
+ 3 files changed, 11 insertions(+), 43 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index 0308130..b9fcc0a 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -296,7 +296,6 @@ typedef struct {
+ PCITAG PciTag;
+ #endif
+ int Chipset;
+- Bool Primary;
+
+ Bool FBDev;
+
+@@ -306,27 +305,20 @@ typedef struct {
+
+ void *MMIO; /* Map of MMIO region */
+ void *FB; /* Map of frame buffer */
++ CARD8 *VBIOS; /* Video BIOS for mode validation on FPs */
++ int FPBIOSstart; /* Start of the flat panel info */
+
+ CARD32 MemCntl;
+ CARD32 BusCntl;
+ unsigned long FbMapSize; /* Size of frame buffer, in bytes */
+- int Flags; /* Saved copy of mode flags */
+
+ CARD8 BIOSDisplay; /* Device the BIOS is set to display to */
+
+ Bool HasPanelRegs; /* Current chip can connect to a FP */
+- CARD8 *VBIOS; /* Video BIOS for mode validation on FPs */
+- int FPBIOSstart; /* Start of the flat panel info */
+
+ /* Computed values for FPs */
+ int PanelXRes;
+ int PanelYRes;
+- int HOverPlus;
+- int HSyncWidth;
+- int HBlank;
+- int VOverPlus;
+- int VSyncWidth;
+- int VBlank;
+ int PanelPwrDly;
+
+ R128PLLRec pll;
+@@ -343,7 +335,6 @@ typedef struct {
+ XAAInfoRecPtr accel;
+ #endif
+ Bool accelOn;
+-
+ Bool useEXA;
+ Bool RenderAccel;
+ #ifdef USE_EXA
+@@ -352,10 +343,6 @@ typedef struct {
+ struct r128_2d_state state_2d;
+ #endif
+
+- xf86CursorInfoPtr cursor;
+- unsigned long cursor_start;
+- unsigned long cursor_end;
+-
+ /*
+ * XAAForceTransBlit is used to change the behavior of the XAA
+ * SetupForScreenToScreenCopy function, to make it DGA-friendly.
+@@ -405,19 +392,19 @@ typedef struct {
+ Bool directRenderingEnabled;
+ DRIInfoPtr pDRIInfo;
+ int drmFD;
+- drm_context_t drmCtx;
++ drm_context_t drmCtx;
+ int numVisualConfigs;
+ __GLXvisualConfig *pVisualConfigs;
+ R128ConfigPrivPtr pVisualConfigsPriv;
+
+- drm_handle_t fbHandle;
++ drm_handle_t fbHandle;
+
+ drmSize registerSize;
+- drm_handle_t registerHandle;
++ drm_handle_t registerHandle;
+
+ Bool IsPCI; /* Current card is a PCI card */
+ drmSize pciSize;
+- drm_handle_t pciMemHandle;
++ drm_handle_t pciMemHandle;
+ drmAddress PCI; /* Map */
+
+ Bool allowPageFlip; /* Enable 3d page flipping */
+@@ -425,7 +412,7 @@ typedef struct {
+ int drmMinor;
+
+ drmSize agpSize;
+- drm_handle_t agpMemHandle; /* Handle from drmAgpAlloc */
++ drm_handle_t agpMemHandle; /* Handle from drmAgpAlloc */
+ unsigned long agpOffset;
+ drmAddress AGP; /* Map */
+ int agpMode;
+@@ -438,20 +425,20 @@ typedef struct {
+
+ /* CCE ring buffer data */
+ unsigned long ringStart; /* Offset into AGP space */
+- drm_handle_t ringHandle; /* Handle from drmAddMap */
++ drm_handle_t ringHandle; /* Handle from drmAddMap */
+ drmSize ringMapSize; /* Size of map */
+ int ringSize; /* Size of ring (in MB) */
+ drmAddress ring; /* Map */
+ int ringSizeLog2QW;
+
+ unsigned long ringReadOffset; /* Offset into AGP space */
+- drm_handle_t ringReadPtrHandle; /* Handle from drmAddMap */
++ drm_handle_t ringReadPtrHandle;/* Handle from drmAddMap */
+ drmSize ringReadMapSize; /* Size of map */
+ drmAddress ringReadPtr; /* Map */
+
+ /* CCE vertex/indirect buffer data */
+ unsigned long bufStart; /* Offset into AGP space */
+- drm_handle_t bufHandle; /* Handle from drmAddMap */
++ drm_handle_t bufHandle; /* Handle from drmAddMap */
+ drmSize bufMapSize; /* Size of map */
+ int bufSize; /* Size of buffers (in MB) */
+ drmAddress buf; /* Map */
+@@ -460,7 +447,7 @@ typedef struct {
+
+ /* CCE AGP Texture data */
+ unsigned long agpTexStart; /* Offset into AGP space */
+- drm_handle_t agpTexHandle; /* Handle from drmAddMap */
++ drm_handle_t agpTexHandle; /* Handle from drmAddMap */
+ drmSize agpTexMapSize; /* Size of map */
+ int agpTexSize; /* Size of AGP tex space (in MB) */
+ drmAddress agpTex; /* Map */
+diff --git a/src/r128_dri.c b/src/r128_dri.c
+index 2c905a4..f924331 100644
+--- a/src/r128_dri.c
++++ b/src/r128_dri.c
+@@ -1525,9 +1525,6 @@ static void R128DRITransitionTo3d(ScreenPtr pScreen)
+ R128EnablePageFlip(pScreen);
+
+ info->have3DWindows = 1;
+-
+- if (info->cursor_start)
+- xf86ForceHWCursor(pScreen, TRUE);
+ }
+
+ static void R128DRITransitionTo2d(ScreenPtr pScreen)
+@@ -1550,7 +1547,4 @@ static void R128DRITransitionTo2d(ScreenPtr pScreen)
+ }
+
+ info->have3DWindows = 0;
+-
+- if (info->cursor_start)
+- xf86ForceHWCursor(pScreen, FALSE);
+ }
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 3cd3773..d17951d 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -2238,9 +2238,6 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ if (R128CursorInit(pScreen)) {
+ int width, height;
+
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+- "Using hardware cursor (scanline %ld)\n",
+- info->cursor_start / pScrn->displayWidth);
+ if (xf86QueryLargestOffscreenArea(pScreen, &width, &height,
+ 0, 0, 0)) {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+@@ -2253,7 +2250,6 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using software cursor\n");
+ }
+ } else {
+- info->cursor_start = 0;
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using software cursor\n");
+ }
+
+@@ -3064,12 +3060,6 @@ Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ mode->HDisplay = mode->CrtcHDisplay = info->PanelXRes;
+ if(info->PanelYRes < mode->CrtcVDisplay)
+ mode->VDisplay = mode->CrtcVDisplay = info->PanelYRes;
+- mode->CrtcHTotal = mode->CrtcHDisplay + info->HBlank;
+- mode->CrtcHSyncStart = mode->CrtcHDisplay + info->HOverPlus;
+- mode->CrtcHSyncEnd = mode->CrtcHSyncStart + info->HSyncWidth;
+- mode->CrtcVTotal = mode->CrtcVDisplay + info->VBlank;
+- mode->CrtcVSyncStart = mode->CrtcVDisplay + info->VOverPlus;
+- mode->CrtcVSyncEnd = mode->CrtcVSyncStart + info->VSyncWidth;
+ }
+
+ save->crtc_h_total_disp = ((((mode->CrtcHTotal / 8) - 1) & 0xffff)
+@@ -3834,9 +3824,6 @@ static Bool R128CloseScreen(CLOSE_SCREEN_ARGS_DECL)
+ if (info->scratch_save) free(info->scratch_save);
+ info->scratch_save = NULL;
+
+- if (info->cursor) xf86DestroyCursorInfoRec(info->cursor);
+- info->cursor = NULL;
+-
+ if (info->DGAModes) free(info->DGAModes);
+ info->DGAModes = NULL;
+
+--
+2.2.2
+
+
+From b632e89b923179b16d0d38128209427f666b963c Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 16 Jul 2014 02:20:18 -0700
+Subject: Remove pointless output
+
+This removes a debug line to fix a compiler warning and make the
+crtc1 and crtc2 code more symmetric. The number of bits per pixel is
+easy to find out anyway.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_driver.c | 14 ++++++--------
+ 1 file changed, 6 insertions(+), 8 deletions(-)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index d17951d..6cd669a 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -3126,22 +3126,20 @@ Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ int hsync_wid;
+ int hsync_fudge;
+ int vsync_wid;
+- int bytpp;
+ int hsync_fudge_default[] = { 0x00, 0x12, 0x09, 0x09, 0x06, 0x05 };
+
+ switch (info->CurrentLayout.pixel_code) {
+- case 4: format = 1; bytpp = 0; break;
+- case 8: format = 2; bytpp = 1; break;
+- case 15: format = 3; bytpp = 2; break; /* 555 */
+- case 16: format = 4; bytpp = 2; break; /* 565 */
+- case 24: format = 5; bytpp = 3; break; /* RGB */
+- case 32: format = 6; bytpp = 4; break; /* xRGB */
++ case 4: format = 1; break;
++ case 8: format = 2; break;
++ case 15: format = 3; break; /* 555 */
++ case 16: format = 4; break; /* 565 */
++ case 24: format = 5; break; /* RGB */
++ case 32: format = 6; break; /* xRGB */
+ default:
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+ "Unsupported pixel depth (%d)\n", info->CurrentLayout.bitsPerPixel);
+ return FALSE;
+ }
+- R128TRACE(("Format = %d (%d bytes per pixel)\n", format, bytpp));
+
+ hsync_fudge = hsync_fudge_default[format-1];
+
+--
+2.2.2
+
+
+From 0d901460b375599c727928634d5f1067d2279844 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 16 Jul 2014 17:47:44 -0700
+Subject: Use standard integers
+
+To fix another warning, we need to be consistent about when we use
+CARD32 an when we use uint32_t. Xorg developers have decided on the
+latter as a convention.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128.h | 168 +++++++++++++++++++++++++-------------------------
+ src/r128_accel.c | 20 +++---
+ src/r128_crtc.c | 2 +-
+ src/r128_cursor.c | 14 ++---
+ src/r128_dga.c | 6 +-
+ src/r128_dri.c | 14 ++---
+ src/r128_driver.c | 14 ++---
+ src/r128_exa_render.c | 8 +--
+ src/r128_output.c | 4 +-
+ src/r128_probe.h | 14 ++---
+ src/r128_reg.h | 12 ++--
+ src/r128_video.c | 14 ++---
+ 12 files changed, 145 insertions(+), 145 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index b9fcc0a..f361c2a 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -151,105 +151,105 @@ typedef struct { /* All values in XCLKS */
+
+ typedef struct {
+ /* Common registers */
+- CARD32 ovr_clr;
+- CARD32 ovr_wid_left_right;
+- CARD32 ovr_wid_top_bottom;
+- CARD32 ov0_scale_cntl;
+- CARD32 mpp_tb_config;
+- CARD32 mpp_gp_config;
+- CARD32 subpic_cntl;
+- CARD32 viph_control;
+- CARD32 i2c_cntl_1;
+- CARD32 gen_int_cntl;
+- CARD32 cap0_trig_cntl;
+- CARD32 cap1_trig_cntl;
+- CARD32 bus_cntl;
+- CARD32 config_cntl;
++ uint32_t ovr_clr;
++ uint32_t ovr_wid_left_right;
++ uint32_t ovr_wid_top_bottom;
++ uint32_t ov0_scale_cntl;
++ uint32_t mpp_tb_config;
++ uint32_t mpp_gp_config;
++ uint32_t subpic_cntl;
++ uint32_t viph_control;
++ uint32_t i2c_cntl_1;
++ uint32_t gen_int_cntl;
++ uint32_t cap0_trig_cntl;
++ uint32_t cap1_trig_cntl;
++ uint32_t bus_cntl;
++ uint32_t config_cntl;
+
+ /* Other registers to save for VT switches */
+- CARD32 dp_datatype;
+- CARD32 gen_reset_cntl;
+- CARD32 clock_cntl_index;
+- CARD32 amcgpio_en_reg;
+- CARD32 amcgpio_mask;
++ uint32_t dp_datatype;
++ uint32_t gen_reset_cntl;
++ uint32_t clock_cntl_index;
++ uint32_t amcgpio_en_reg;
++ uint32_t amcgpio_mask;
+
+ /* CRTC registers */
+- CARD32 crtc_gen_cntl;
+- CARD32 crtc_ext_cntl;
+- CARD32 dac_cntl;
+- CARD32 crtc_h_total_disp;
+- CARD32 crtc_h_sync_strt_wid;
+- CARD32 crtc_v_total_disp;
+- CARD32 crtc_v_sync_strt_wid;
+- CARD32 crtc_offset;
+- CARD32 crtc_offset_cntl;
+- CARD32 crtc_pitch;
++ uint32_t crtc_gen_cntl;
++ uint32_t crtc_ext_cntl;
++ uint32_t dac_cntl;
++ uint32_t crtc_h_total_disp;
++ uint32_t crtc_h_sync_strt_wid;
++ uint32_t crtc_v_total_disp;
++ uint32_t crtc_v_sync_strt_wid;
++ uint32_t crtc_offset;
++ uint32_t crtc_offset_cntl;
++ uint32_t crtc_pitch;
+
+ /* CRTC2 registers */
+- CARD32 crtc2_gen_cntl;
+- CARD32 crtc2_h_total_disp;
+- CARD32 crtc2_h_sync_strt_wid;
+- CARD32 crtc2_v_total_disp;
+- CARD32 crtc2_v_sync_strt_wid;
+- CARD32 crtc2_offset;
+- CARD32 crtc2_offset_cntl;
+- CARD32 crtc2_pitch;
++ uint32_t crtc2_gen_cntl;
++ uint32_t crtc2_h_total_disp;
++ uint32_t crtc2_h_sync_strt_wid;
++ uint32_t crtc2_v_total_disp;
++ uint32_t crtc2_v_sync_strt_wid;
++ uint32_t crtc2_offset;
++ uint32_t crtc2_offset_cntl;
++ uint32_t crtc2_pitch;
+
+ /* Flat panel registers */
+- CARD32 fp_crtc_h_total_disp;
+- CARD32 fp_crtc_v_total_disp;
+- CARD32 fp_gen_cntl;
+- CARD32 fp_h_sync_strt_wid;
+- CARD32 fp_horz_stretch;
+- CARD32 fp_panel_cntl;
+- CARD32 fp_v_sync_strt_wid;
+- CARD32 fp_vert_stretch;
+- CARD32 lvds_gen_cntl;
+- CARD32 tmds_crc;
+- CARD32 tmds_transmitter_cntl;
++ uint32_t fp_crtc_h_total_disp;
++ uint32_t fp_crtc_v_total_disp;
++ uint32_t fp_gen_cntl;
++ uint32_t fp_h_sync_strt_wid;
++ uint32_t fp_horz_stretch;
++ uint32_t fp_panel_cntl;
++ uint32_t fp_v_sync_strt_wid;
++ uint32_t fp_vert_stretch;
++ uint32_t lvds_gen_cntl;
++ uint32_t tmds_crc;
++ uint32_t tmds_transmitter_cntl;
+
+ /* Computed values for PLL */
+- CARD32 dot_clock_freq;
+- CARD32 pll_output_freq;
++ uint32_t dot_clock_freq;
++ uint32_t pll_output_freq;
+ int feedback_div;
+ int post_div;
+
+ /* PLL registers */
+- CARD32 ppll_ref_div;
+- CARD32 ppll_div_3;
+- CARD32 htotal_cntl;
++ uint32_t ppll_ref_div;
++ uint32_t ppll_div_3;
++ uint32_t htotal_cntl;
+
+ /* Computed values for PLL2 */
+- CARD32 dot_clock_freq_2;
+- CARD32 pll_output_freq_2;
++ uint32_t dot_clock_freq_2;
++ uint32_t pll_output_freq_2;
+ int feedback_div_2;
+ int post_div_2;
+
+ /* PLL2 registers */
+- CARD32 p2pll_ref_div;
+- CARD32 p2pll_div_0;
+- CARD32 htotal_cntl2;
++ uint32_t p2pll_ref_div;
++ uint32_t p2pll_div_0;
++ uint32_t htotal_cntl2;
+
+ /* DDA register */
+- CARD32 dda_config;
+- CARD32 dda_on_off;
++ uint32_t dda_config;
++ uint32_t dda_on_off;
+
+ /* DDA2 register */
+- CARD32 dda2_config;
+- CARD32 dda2_on_off;
++ uint32_t dda2_config;
++ uint32_t dda2_on_off;
+
+ /* Pallet */
+ Bool palette_valid;
+- CARD32 palette[256];
+- CARD32 palette2[256];
++ uint32_t palette[256];
++ uint32_t palette2[256];
+ } R128SaveRec, *R128SavePtr;
+
+ typedef struct {
+- CARD16 reference_freq;
+- CARD16 reference_div;
++ uint16_t reference_freq;
++ uint16_t reference_div;
+ unsigned min_pll_freq;
+ unsigned max_pll_freq;
+- CARD16 xclk;
++ uint16_t xclk;
+ } R128PLLRec, *R128PLLPtr;
+
+ typedef struct {
+@@ -305,14 +305,14 @@ typedef struct {
+
+ void *MMIO; /* Map of MMIO region */
+ void *FB; /* Map of frame buffer */
+- CARD8 *VBIOS; /* Video BIOS for mode validation on FPs */
++ uint8_t *VBIOS; /* Video BIOS for mode validation on FPs */
+ int FPBIOSstart; /* Start of the flat panel info */
+
+- CARD32 MemCntl;
+- CARD32 BusCntl;
++ uint32_t MemCntl;
++ uint32_t BusCntl;
+ unsigned long FbMapSize; /* Size of frame buffer, in bytes */
+
+- CARD8 BIOSDisplay; /* Device the BIOS is set to display to */
++ uint8_t BIOSDisplay; /* Device the BIOS is set to display to */
+
+ Bool HasPanelRegs; /* Current chip can connect to a FP */
+
+@@ -356,7 +356,7 @@ typedef struct {
+ /* Computed values for Rage 128 */
+ int pitch;
+ int datatype;
+- CARD32 dp_gui_master_cntl;
++ uint32_t dp_gui_master_cntl;
+
+ /* Saved values for ScreenToScreenCopy */
+ int xdir;
+@@ -477,18 +477,18 @@ typedef struct {
+ int log2TexGran;
+
+ /* Saved scissor values */
+- CARD32 sc_left;
+- CARD32 sc_right;
+- CARD32 sc_top;
+- CARD32 sc_bottom;
++ uint32_t sc_left;
++ uint32_t sc_right;
++ uint32_t sc_top;
++ uint32_t sc_bottom;
+
+- CARD32 re_top_left;
+- CARD32 re_width_height;
++ uint32_t re_top_left;
++ uint32_t re_width_height;
+
+- CARD32 aux_sc_cntl;
++ uint32_t aux_sc_cntl;
+
+ int irq;
+- CARD32 gen_int_cntl;
++ uint32_t gen_int_cntl;
+
+ Bool DMAForXv;
+ #endif
+@@ -643,7 +643,7 @@ extern void R128DoPrepareCopy(ScrnInfoPtr pScrn, uint32_t src_pitch_offset,
+
+ #define R128_VERBOSE 0
+
+-#define RING_LOCALS CARD32 *__head; int __count;
++#define RING_LOCALS uint32_t *__head; int __count;
+
+ #define R128CCE_REFRESH(pScrn, info) \
+ do { \
+@@ -684,12 +684,12 @@ do { \
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO, \
+ "ADVANCE_RING() used: %d+%d=%d/%d\n", \
+ info->indirectBuffer->used - info->indirectStart, \
+- __count * (int)sizeof(CARD32), \
++ __count * (int)sizeof(uint32_t), \
+ info->indirectBuffer->used - info->indirectStart + \
+- __count * (int)sizeof(CARD32), \
++ __count * (int)sizeof(uint32_t), \
+ info->indirectBuffer->total - info->indirectStart ); \
+ } \
+- info->indirectBuffer->used += __count * (int)sizeof(CARD32); \
++ info->indirectBuffer->used += __count * (int)sizeof(uint32_t); \
+ } while (0)
+
+ #define OUT_RING( x ) do { \
+diff --git a/src/r128_accel.c b/src/r128_accel.c
+index 4d666c7..99bfb20 100644
+--- a/src/r128_accel.c
++++ b/src/r128_accel.c
+@@ -145,9 +145,9 @@ void R128EngineReset(ScrnInfoPtr pScrn)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 clock_cntl_index;
+- CARD32 mclk_cntl;
+- CARD32 gen_reset_cntl;
++ uint32_t clock_cntl_index;
++ uint32_t mclk_cntl;
++ uint32_t gen_reset_cntl;
+
+ R128EngineFlush(pScrn);
+
+@@ -161,7 +161,7 @@ void R128EngineReset(ScrnInfoPtr pScrn)
+ OUTREG(R128_GEN_RESET_CNTL, gen_reset_cntl | R128_SOFT_RESET_GUI);
+ INREG(R128_GEN_RESET_CNTL);
+ OUTREG(R128_GEN_RESET_CNTL,
+- gen_reset_cntl & (CARD32)(~R128_SOFT_RESET_GUI));
++ gen_reset_cntl & (uint32_t)(~R128_SOFT_RESET_GUI));
+ INREG(R128_GEN_RESET_CNTL);
+
+ OUTPLL(R128_MCLK_CNTL, mclk_cntl);
+@@ -450,7 +450,7 @@ static void R128SetupForDashedLine(ScrnInfoPtr pScrn,
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 pat = *(CARD32 *)(pointer)pattern;
++ uint32_t pat = *(uint32_t *)(pointer)pattern;
+
+ #if X_BYTE_ORDER == X_LITTLE_ENDIAN
+ # define PAT_SHIFT(pat,n) pat << n
+@@ -847,10 +847,10 @@ static void R128SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 *p = (pointer)info->scratch_buffer[bufno];
++ uint32_t *p = (pointer)info->scratch_buffer[bufno];
+ int i;
+ int left = info->scanline_words;
+- volatile CARD32 *d;
++ volatile uint32_t *d;
+
+ if (info->scanline_direct) return;
+ --info->scanline_h;
+@@ -977,10 +977,10 @@ static void R128SubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 *p = (pointer)info->scratch_buffer[bufno];
++ uint32_t *p = (pointer)info->scratch_buffer[bufno];
+ int i;
+ int left = info->scanline_words;
+- volatile CARD32 *d;
++ volatile uint32_t *d;
+
+ if (info->scanline_direct) return;
+ --info->scanline_h;
+@@ -1438,7 +1438,7 @@ static void R128CCESetupForDashedLine(ScrnInfoPtr pScrn,
+ int length, unsigned char *pattern)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+- CARD32 pat = *(CARD32 *)(pointer)pattern;
++ uint32_t pat = *(uint32_t *)(pointer)pattern;
+ RING_LOCALS;
+
+ R128CCE_REFRESH( pScrn, info );
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+index e48e4d5..5f076cd 100644
+--- a/src/r128_crtc.c
++++ b/src/r128_crtc.c
+@@ -189,7 +189,7 @@ static void r128_crtc_mode_commit(xf86CrtcPtr crtc)
+ r128_crtc_dpms(crtc, DPMSModeOn);
+ }
+
+-static void r128_crtc_gamma_set(xf86CrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue, int size)
++static void r128_crtc_gamma_set(xf86CrtcPtr crtc, uint16_t *red, uint16_t *green, uint16_t *blue, int size)
+ {
+ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+ int i;
+diff --git a/src/r128_cursor.c b/src/r128_cursor.c
+index ad6752f..d42bea6 100644
+--- a/src/r128_cursor.c
++++ b/src/r128_cursor.c
+@@ -179,18 +179,18 @@ void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *src)
+
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 *s = (pointer)src;
+- CARD32 *d = (pointer)(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset);
+- CARD32 save1 = 0;
+- CARD32 save2 = 0;
++ uint32_t *s = (pointer)src;
++ uint32_t *d = (pointer)(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset);
++ uint32_t save1 = 0;
++ uint32_t save2 = 0;
+ int y;
+
+ if (crtc_id == 0) {
+ save1 = INREG(R128_CRTC_GEN_CNTL);
+- OUTREG(R128_CRTC_GEN_CNTL, save1 & (CARD32)~R128_CRTC_CUR_EN);
++ OUTREG(R128_CRTC_GEN_CNTL, save1 & (uint32_t)~R128_CRTC_CUR_EN);
+ } else if (crtc_id == 1) {
+ save2 = INREG(R128_CRTC2_GEN_CNTL);
+- OUTREG(R128_CRTC2_GEN_CNTL, save2 & (CARD32)~R128_CRTC2_CUR_EN);
++ OUTREG(R128_CRTC2_GEN_CNTL, save2 & (uint32_t)~R128_CRTC2_CUR_EN);
+ }
+
+ #if X_BYTE_ORDER == X_BIG_ENDIAN
+@@ -255,7 +255,7 @@ Bool R128CursorInit(ScreenPtr pScreen)
+ void* osArea = NULL;
+ #endif
+ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+- CARD32 cursor_offset = 0;
++ uint32_t cursor_offset = 0;
+ int cpp = info->CurrentLayout.pixel_bytes;
+ int width;
+ int width_bytes;
+diff --git a/src/r128_dga.c b/src/r128_dga.c
+index d7fee02..bb4a1a6 100644
+--- a/src/r128_dga.c
++++ b/src/r128_dga.c
+@@ -332,7 +332,7 @@ R128_FillRect (
+ ){
+ R128InfoPtr info = R128PTR(pScrn);
+
+- (*info->accel->SetupForSolidFill)(pScrn, color, GXcopy, (CARD32)(~0));
++ (*info->accel->SetupForSolidFill)(pScrn, color, GXcopy, (uint32_t)(~0));
+ (*info->accel->SubsequentSolidFillRect)(pScrn, x, y, w, h);
+
+ if (pScrn->bitsPerPixel == info->CurrentLayout.bitsPerPixel)
+@@ -351,7 +351,7 @@ R128_BlitRect(
+ int ydir = (srcy < dsty) ? -1 : 1;
+
+ (*info->accel->SetupForScreenToScreenCopy)(
+- pScrn, xdir, ydir, GXcopy, (CARD32)(~0), -1);
++ pScrn, xdir, ydir, GXcopy, (uint32_t)(~0), -1);
+ (*info->accel->SubsequentScreenToScreenCopy)(
+ pScrn, srcx, srcy, dstx, dsty, w, h);
+
+@@ -375,7 +375,7 @@ R128_BlitTransRect(
+ info->XAAForceTransBlit = TRUE;
+
+ (*info->accel->SetupForScreenToScreenCopy)(
+- pScrn, xdir, ydir, GXcopy, (CARD32)(~0), color);
++ pScrn, xdir, ydir, GXcopy, (uint32_t)(~0), color);
+
+ info->XAAForceTransBlit = FALSE;
+
+diff --git a/src/r128_dri.c b/src/r128_dri.c
+index f924331..467cd88 100644
+--- a/src/r128_dri.c
++++ b/src/r128_dri.c
+@@ -397,7 +397,7 @@ static void R128DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 indx)
+ pboxSave = pbox = REGION_RECTS(prgn);
+ nboxSave = nbox = REGION_NUM_RECTS(prgn);
+
+- (*info->accel->SetupForSolidFill)(pScrn, 0, GXcopy, (CARD32)(-1));
++ (*info->accel->SetupForSolidFill)(pScrn, 0, GXcopy, (uint32_t)(-1));
+ for (; nbox; nbox--, pbox++) {
+ (*info->accel->SubsequentSolidFillRect)(pScrn,
+ pbox->x1 + info->fbX,
+@@ -415,7 +415,7 @@ static void R128DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 indx)
+ nbox = nboxSave;
+
+ /* FIXME: this needs to consider depth tiling. */
+- (*info->accel->SetupForSolidFill)(pScrn, depth, GXcopy, (CARD32)(-1));
++ (*info->accel->SetupForSolidFill)(pScrn, depth, GXcopy, (uint32_t)(-1));
+ for (; nbox; nbox--, pbox++)
+ (*info->accel->SubsequentSolidFillRect)(pScrn,
+ pbox->x1 + info->depthX,
+@@ -647,7 +647,7 @@ static Bool R128DRIAgpInit(R128InfoPtr info, ScreenPtr pScreen)
+ static Bool R128DRIPciInit(R128InfoPtr info, ScreenPtr pScreen)
+ {
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 chunk;
++ uint32_t chunk;
+ int ret;
+ int flags;
+
+@@ -1413,12 +1413,12 @@ static void R128DRIRefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
+ if (!info->useEXA) {
+ (*info->accel->SetupForScreenToScreenCopy)(pScrn,
+ 1, 1, GXcopy,
+- (CARD32)(-1), -1);
++ (uint32_t)(-1), -1);
+ }
+ #endif
+ #ifdef USE_EXA
+ if (info->useEXA) {
+- CARD32 src_pitch_offset, dst_pitch_offset, datatype;
++ uint32_t src_pitch_offset, dst_pitch_offset, datatype;
+
+ R128GetPixmapOffsetPitch(pPix, &src_pitch_offset);
+ dst_pitch_offset = src_pitch_offset + (info->backOffset >> 5);
+@@ -1465,7 +1465,7 @@ static void R128EnablePageFlip(ScreenPtr pScreen)
+ if (!info->useEXA) {
+ (*info->accel->SetupForScreenToScreenCopy)(pScrn,
+ 1, 1, GXcopy,
+- (CARD32)(-1), -1);
++ (uint32_t)(-1), -1);
+
+ (*info->accel->SubsequentScreenToScreenCopy)(pScrn,
+ 0,
+@@ -1478,7 +1478,7 @@ static void R128EnablePageFlip(ScreenPtr pScreen)
+ #endif
+ #ifdef USE_EXA
+ if (info->useEXA) {
+- CARD32 src_pitch_offset, dst_pitch_offset, datatype;
++ uint32_t src_pitch_offset, dst_pitch_offset, datatype;
+
+ R128GetPixmapOffsetPitch(pPix, &src_pitch_offset);
+ dst_pitch_offset = src_pitch_offset + (info->backOffset >> 5);
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 6cd669a..c541bfa 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -657,8 +657,8 @@ static Bool R128GetPLLParameters(ScrnInfoPtr pScrn)
+ pll->max_pll_freq = 25000;
+ pll->xclk = 10300;
+ } else {
+- CARD16 bios_header = R128_BIOS16(0x48);
+- CARD16 pll_info_block = R128_BIOS16(bios_header + 0x30);
++ uint16_t bios_header = R128_BIOS16(0x48);
++ uint16_t pll_info_block = R128_BIOS16(bios_header + 0x30);
+ R128TRACE(("Header at 0x%04x; PLL Information at 0x%04x\n",
+ bios_header, pll_info_block));
+
+@@ -1634,7 +1634,7 @@ static void R128LoadPalette(ScrnInfoPtr pScrn, int numColors,
+ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+ int i, j;
+ int c, index;
+- CARD16 lut_r[256], lut_g[256], lut_b[256];
++ uint16_t lut_r[256], lut_g[256], lut_b[256];
+
+ for (c = 0; c < xf86_config->num_crtc; c++) {
+ xf86CrtcPtr crtc = xf86_config->crtc[c];
+@@ -2404,7 +2404,7 @@ void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ OUTREG(R128_TMDS_CRC, restore->tmds_crc);
+ OUTREG(R128_TMDS_TRANSMITTER_CNTL, restore->tmds_transmitter_cntl);
+ OUTREG(R128_FP_PANEL_CNTL, restore->fp_panel_cntl);
+- OUTREG(R128_FP_GEN_CNTL, restore->fp_gen_cntl & ~(CARD32)R128_FP_BLANK_DIS);
++ OUTREG(R128_FP_GEN_CNTL, restore->fp_gen_cntl & ~(uint32_t)R128_FP_BLANK_DIS);
+ }
+
+ /* Write LVDS registers */
+@@ -2412,7 +2412,7 @@ void R128RestoreLVDSRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 tmp;
++ uint32_t tmp;
+
+ tmp = INREG(R128_LVDS_GEN_CNTL);
+ if ((tmp & (R128_LVDS_ON | R128_LVDS_BLON)) ==
+@@ -2421,7 +2421,7 @@ void R128RestoreLVDSRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ } else {
+ if (restore->lvds_gen_cntl & (R128_LVDS_ON | R128_LVDS_BLON)) {
+ OUTREG(R128_LVDS_GEN_CNTL,
+- restore->lvds_gen_cntl & (CARD32)~R128_LVDS_BLON);
++ restore->lvds_gen_cntl & (uint32_t)~R128_LVDS_BLON);
+ usleep(R128PTR(pScrn)->PanelPwrDly * 1000);
+ OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
+ } else {
+@@ -3643,7 +3643,7 @@ ModeStatus R128ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
+ if (R128_BIOS16(j+5)) j = R128_BIOS16(j+5);
+ else j += 9;
+
+- mode->Clock = (CARD32)R128_BIOS16(j) * 10;
++ mode->Clock = (uint32_t)R128_BIOS16(j) * 10;
+
+ mode->HDisplay = mode->CrtcHDisplay =
+ ((R128_BIOS16(j+10) & 0x01ff)+1)*8;
+diff --git a/src/r128_exa_render.c b/src/r128_exa_render.c
+index f00daf7..c0d3688 100644
+--- a/src/r128_exa_render.c
++++ b/src/r128_exa_render.c
+@@ -40,8 +40,8 @@
+ static struct {
+ Bool dst_alpha;
+ Bool src_alpha;
+- CARD32 sblend;
+- CARD32 dblend;
++ uint32_t sblend;
++ uint32_t dblend;
+ } R128BlendOp[] = {
+ /* Clear */
+ {0, 0, R128_ALPHA_BLEND_ZERO , R128_ALPHA_BLEND_ZERO},
+@@ -582,9 +582,9 @@ R128CCEPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
+ return TRUE;
+ }
+
+-typedef union { float f; CARD32 i; } fi_type;
++typedef union { float f; uint32_t i; } fi_type;
+
+-static inline CARD32
++static inline uint32_t
+ R128FloatAsInt(float val)
+ {
+ fi_type fi;
+diff --git a/src/r128_output.c b/src/r128_output.c
+index e5306d6..7bb2e2a 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -234,7 +234,7 @@ static R128MonitorType R128DisplayDDCConnected(xf86OutputPtr output)
+
+ R128MonitorType MonType = MT_NONE;
+ xf86MonPtr *MonInfo = &output->MonInfo;
+- CARD32 mask1, mask2;
++ uint32_t mask1, mask2;
+
+ if (r128_output->type == OUTPUT_LVDS) {
+ return MT_LCD;
+@@ -346,7 +346,7 @@ static void R128I2CPutBits(I2CBusPtr b, int Clock, int data)
+ R128I2CBusPtr pR128I2CBus = b->DriverPrivate.ptr;
+
+ val = INREG(pR128I2CBus->ddc_reg)
+- & ~(CARD32)(pR128I2CBus->put_clk_mask | pR128I2CBus->put_data_mask);
++ & ~(uint32_t)(pR128I2CBus->put_clk_mask | pR128I2CBus->put_data_mask);
+ val |= (Clock ? 0 : pR128I2CBus->put_clk_mask);
+ val |= (data ? 0 : pR128I2CBus->put_data_mask);
+ OUTREG(pR128I2CBus->ddc_reg, val);
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index 426840a..40fe82b 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -129,11 +129,11 @@ typedef enum
+ } R128OutputType;
+
+ typedef struct {
+- CARD32 ddc_reg;
+- CARD32 put_clk_mask;
+- CARD32 put_data_mask;
+- CARD32 get_clk_mask;
+- CARD32 get_data_mask;
++ uint32_t ddc_reg;
++ uint32_t put_clk_mask;
++ uint32_t put_data_mask;
++ uint32_t get_clk_mask;
++ uint32_t get_data_mask;
+ } R128I2CBusRec, *R128I2CBusPtr;
+
+ typedef struct _R128CrtcPrivateRec {
+@@ -144,9 +144,9 @@ typedef struct _R128CrtcPrivateRec {
+ ExaOffscreenArea *rotate_mem_exa;
+ #endif
+ int crtc_id;
+- CARD32 cursor_offset;
++ uint32_t cursor_offset;
+ /* Lookup table values to be set when the CRTC is enabled */
+- CARD8 lut_r[256], lut_g[256], lut_b[256];
++ uint8_t lut_r[256], lut_g[256], lut_b[256];
+ } R128CrtcPrivateRec, *R128CrtcPrivatePtr;
+
+ typedef struct {
+diff --git a/src/r128_reg.h b/src/r128_reg.h
+index 9ba0de5..eee5fb1 100644
+--- a/src/r128_reg.h
++++ b/src/r128_reg.h
+@@ -57,12 +57,12 @@
+ #define OUTREG16(addr, val) MMIO_OUT16(R128MMIO, addr, val)
+ #define OUTREG(addr, val) MMIO_OUT32(R128MMIO, addr, val)
+
+-#define ADDRREG(addr) ((volatile CARD32 *)(pointer)(R128MMIO + (addr)))
++#define ADDRREG(addr) ((volatile uint32_t *)(pointer)(R128MMIO + (addr)))
+
+
+ #define OUTREGP(addr, val, mask) \
+ do { \
+- CARD32 tmp = INREG(addr); \
++ uint32_t tmp = INREG(addr); \
+ tmp &= (mask); \
+ tmp |= ((val) & ~(mask)); \
+ OUTREG(addr, tmp); \
+@@ -78,7 +78,7 @@
+
+ #define OUTPLLP(pScrn, addr, val, mask) \
+ do { \
+- CARD32 tmp = INPLL(pScrn, addr); \
++ uint32_t tmp = INPLL(pScrn, addr); \
+ tmp &= (mask); \
+ tmp |= ((val) & ~(mask)); \
+ OUTPLL(addr, tmp); \
+@@ -94,7 +94,7 @@
+ OUTREG(R128_PALETTE_DATA, ((r) << 16) | ((g) << 8) | (b)); \
+ } while (0)
+
+-#define OUTPAL_NEXT_CARD32(v) \
++#define OUTPAL_NEXT_uint32_t(v) \
+ do { \
+ OUTREG(R128_PALETTE_DATA, (v & 0x00ffffff)); \
+ } while (0)
+@@ -114,12 +114,12 @@
+
+ #define PAL_SELECT(idx) \
+ do { \
+- CARD32 tmp = INREG(R128_DAC_CNTL); \
++ uint32_t tmp = INREG(R128_DAC_CNTL); \
+ if (idx) { \
+ OUTREG(R128_DAC_CNTL, tmp | R128_DAC_PALETTE_ACC_CTL); \
+ } else { \
+ OUTREG(R128_DAC_CNTL, tmp & \
+- (CARD32)~R128_DAC_PALETTE_ACC_CTL); \
++ (uint32_t)~R128_DAC_PALETTE_ACC_CTL); \
+ } \
+ } while (0)
+
+diff --git a/src/r128_video.c b/src/r128_video.c
+index 6439a24..bcf36fc 100644
+--- a/src/r128_video.c
++++ b/src/r128_video.c
+@@ -59,8 +59,8 @@ typedef struct {
+ void* BufferHandle;
+ int videoOffset;
+ RegionRec clip;
+- CARD32 colorKey;
+- CARD32 videoStatus;
++ uint32_t colorKey;
++ uint32_t videoStatus;
+ Time offTime;
+ Time freeTime;
+ int ecp_div;
+@@ -405,7 +405,7 @@ R128DMA(
+ #define BUFSIZE (R128_BUFFER_SIZE - R128_HOSTDATA_BLIT_OFFSET)
+ #define MAXPASSES (MAXHEIGHT/(BUFSIZE/(MAXWIDTH*2))+1)
+
+- unsigned char *fb = (CARD8*)info->FB;
++ unsigned char *fb = (uint8_t*)info->FB;
+ unsigned char *buf;
+ int err=-1, i, idx, offset, hpass, passes, srcpassbytes, dstpassbytes;
+ int sizes[MAXPASSES], list[MAXPASSES];
+@@ -572,7 +572,7 @@ R128CopyData420(
+ }
+
+
+-static CARD32
++static uint32_t
+ R128AllocateMemory(
+ ScrnInfoPtr pScrn,
+ void **mem_struct,
+@@ -841,14 +841,14 @@ R128PutImage(
+ ){
+ R128InfoPtr info = R128PTR(pScrn);
+ R128PortPrivPtr pPriv = (R128PortPrivPtr)data;
+- unsigned char *fb = (CARD8*)info->FB;
++ unsigned char *fb = (uint8_t*)info->FB;
+ INT32 xa, xb, ya, yb;
+ int new_size, offset, s1offset, s2offset, s3offset;
+ int srcPitch, srcPitch2, dstPitch;
+ int d1line, d2line, d3line, d1offset, d2offset, d3offset;
+ int top, left, npixels, nlines;
+ BoxRec dstBox;
+- CARD32 tmp;
++ uint32_t tmp;
+
+ /* Currently, the video is only visible on the first monitor.
+ * In the future we could try to make this smarter, or just implement
+@@ -858,7 +858,7 @@ R128PutImage(
+
+ #if X_BYTE_ORDER == X_BIG_ENDIAN
+ unsigned char *R128MMIO = info->MMIO;
+- CARD32 config_cntl = INREG(R128_CONFIG_CNTL);
++ uint32_t config_cntl = INREG(R128_CONFIG_CNTL);
+
+ /* We need to disable byte swapping, or the data gets mangled */
+ OUTREG(R128_CONFIG_CNTL, config_cntl &
+--
+2.2.2
+
+
+From 48e9b2359e8ab07095e1cb024e61b223a67cbc1a Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Thu, 24 Jul 2014 00:00:24 -0700
+Subject: Unify allocators
+
+RandR and Xv were using almost the same code to grab offscreen memory
+from EXA and XAA.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128.h | 1 +
+ src/r128_crtc.c | 72 ++++----------------------------------
+ src/r128_probe.h | 7 +---
+ src/r128_video.c | 103 ++++++++++++++++++++++++++++---------------------------
+ 4 files changed, 62 insertions(+), 121 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index f361c2a..6df1b51 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -570,6 +570,7 @@ extern void r128_crtc_show_cursor(xf86CrtcPtr crtc);
+ extern void r128_crtc_hide_cursor(xf86CrtcPtr crtc);
+ extern void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *src);
+
++extern uint32_t R128AllocateMemory(ScrnInfoPtr pScrn, void **mem_struct, int size, int align, Bool need_accel);
+ extern Bool R128SetupConnectors(ScrnInfoPtr pScrn);
+ extern Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask);
+ extern void R128Blank(ScrnInfoPtr pScrn);
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+index 5f076cd..92a6c30 100644
+--- a/src/r128_crtc.c
++++ b/src/r128_crtc.c
+@@ -233,33 +233,9 @@ static void r128_crtc_unlock(xf86CrtcPtr crtc)
+ #endif
+ }
+
+-#ifdef HAVE_XAA_H
+-static FBLinearPtr r128_xf86AllocateOffscreenLinear(ScreenPtr pScreen, int length, int granularity,
+- MoveLinearCallbackProcPtr moveCB,
+- RemoveLinearCallbackProcPtr removeCB,
+- pointer privData)
+-{
+- FBLinearPtr linear;
+- int max_size;
+-
+- linear = xf86AllocateOffscreenLinear(pScreen, length, granularity, moveCB, removeCB, privData);
+- if (linear != NULL) return linear;
+-
+- /* The above allocation did not succeed, so purge unlocked stuff and try again. */
+- xf86QueryLargestOffscreenLinear(pScreen, &max_size, granularity, PRIORITY_EXTREME);
+-
+- if (max_size < length) return NULL;
+- xf86PurgeUnlockedOffscreenAreas(pScreen);
+-
+- linear = xf86AllocateOffscreenLinear(pScreen, length, granularity, moveCB, removeCB, privData);
+- return linear;
+-}
+-#endif
+-
+ static void *r128_crtc_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
+ {
+ ScrnInfoPtr pScrn = crtc->scrn;
+- ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
+ R128InfoPtr info = R128PTR(pScrn);
+
+ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+@@ -271,38 +247,7 @@ static void *r128_crtc_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
+
+ rotate_pitch = pScrn->displayWidth * cpp;
+ size = rotate_pitch * height;
+-
+-#ifdef USE_EXA
+- if (info->ExaDriver) {
+- assert(r128_crtc->rotate_mem_exa == NULL);
+- r128_crtc->rotate_mem_exa = exaOffscreenAlloc(pScreen, size, align, TRUE, NULL, NULL);
+-
+- if (r128_crtc->rotate_mem_exa == NULL) {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "Couldn't allocate shadow memory for rotated CRTC\n");
+- return NULL;
+- }
+-
+- rotate_offset = r128_crtc->rotate_mem_exa->offset;
+- }
+-#endif
+-#ifdef HAVE_XAA_H
+- if (info->accel) {
+- size = (size + cpp - 1) / cpp;
+- align = (align + cpp - 1) / cpp;
+-
+- assert(r128_crtc->rotate_mem_xaa == NULL);
+- r128_crtc->rotate_mem_xaa = r128_xf86AllocateOffscreenLinear(pScreen, size, align, NULL, NULL, NULL);
+-
+- if (r128_crtc->rotate_mem_exa == NULL) {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "Couldn't allocate shadow memory for rotated CRTC\n");
+- return NULL;
+- }
+-
+- rotate_offset = r128_crtc->rotate_mem_xaa->offset * cpp;
+- }
+-#endif
++ rotate_offset = R128AllocateMemory(pScrn, &(r128_crtc->rotate_mem), size, align, TRUE);
+
+ /* If allocations failed or if there was no accel. */
+ if (rotate_offset == 0)
+@@ -347,19 +292,16 @@ static void r128_crtc_shadow_destroy(xf86CrtcPtr crtc, PixmapPtr rotate_pixmap,
+
+ if (rotate_pixmap) FreeScratchPixmapHeader(rotate_pixmap);
+
+- if (data) {
++ if (data && r128_crtc->rotate_mem != NULL) {
+ #ifdef USE_EXA
+- if (info->ExaDriver && r128_crtc->rotate_mem_exa != NULL) {
+- exaOffscreenFree(pScreen, r128_crtc->rotate_mem_exa);
+- r128_crtc->rotate_mem_exa = NULL;
+- }
++ if (info->ExaDriver)
++ exaOffscreenFree(pScreen, (ExaOffscreenArea *) r128_crtc->rotate_mem);
+ #endif
+ #ifdef HAVE_XAA_H
+- if (info->accel) {
+- xf86FreeOffscreenLinear(r128_crtc->rotate_mem_xaa);
+- r128_crtc->rotate_mem_xaa = NULL;
+- }
++ if (info->accel)
++ xf86FreeOffscreenLinear((FBLinearPtr) r128_crtc->rotate_mem);
+ #endif
++ r128_crtc->rotate_mem = NULL;
+ }
+ }
+
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index 40fe82b..433463b 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -137,12 +137,7 @@ typedef struct {
+ } R128I2CBusRec, *R128I2CBusPtr;
+
+ typedef struct _R128CrtcPrivateRec {
+-#ifdef HAVE_XAA_H
+- FBLinearPtr rotate_mem_xaa;
+-#endif
+-#ifdef USE_EXA
+- ExaOffscreenArea *rotate_mem_exa;
+-#endif
++ void *rotate_mem;
+ int crtc_id;
+ uint32_t cursor_offset;
+ /* Lookup table values to be set when the CRTC is enabled */
+diff --git a/src/r128_video.c b/src/r128_video.c
+index bcf36fc..b0059b5 100644
+--- a/src/r128_video.c
++++ b/src/r128_video.c
+@@ -572,76 +572,78 @@ R128CopyData420(
+ }
+
+
+-static uint32_t
++uint32_t
+ R128AllocateMemory(
+ ScrnInfoPtr pScrn,
+ void **mem_struct,
+- int size
++ int size,
++ int align,
++ Bool need_accel
+ ){
+ R128InfoPtr info = R128PTR(pScrn);
+ ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
+- int offset = 0;
++ Bool do_linear = !need_accel;
++ uint32_t offset = 0;
+
+- if(!info->useEXA) {
++#ifdef HAVE_XAA_H
++ if (!info->accel && need_accel)
++ do_linear = FALSE;
++ else
++ do_linear = TRUE;
++#endif
++#ifdef USE_EXA
++ if (info->ExaDriver) {
++ ExaOffscreenArea *area = *mem_struct;
++
++ if (area != NULL) {
++ if (area->size >= size) return area->offset;
++
++ exaOffscreenFree(pScreen, area);
++ }
++
++ area = exaOffscreenAlloc(pScreen, size, align, TRUE, NULL, NULL);
++ *mem_struct = area;
++
++ if (area == NULL) return 0;
++ offset = area->offset;
++ }
++#endif
++ if (!info->useEXA && do_linear) {
+ FBLinearPtr linear = *mem_struct;
+ int cpp = info->CurrentLayout.pixel_bytes;
+
+- /* XAA allocates in units of pixels at the screen bpp, so adjust size appropriately. */
+- size = (size + cpp - 1) / cpp;
++ /* XAA allocates in units of pixels at the screen bpp, so adjust size appropriately. */
++ size = (size + cpp - 1) / cpp;
++ align = (align + cpp - 1) / cpp;
+
+ if(linear) {
+- if(linear->size >= size)
+- return linear->offset * cpp;
++ if(linear->size >= size)
++ return linear->offset * cpp;
+
+- if(xf86ResizeOffscreenLinear(linear, size))
+- return linear->offset * cpp;
++ if(xf86ResizeOffscreenLinear(linear, size))
++ return linear->offset * cpp;
+
+- xf86FreeOffscreenLinear(linear);
++ xf86FreeOffscreenLinear(linear);
+ }
+
+-
+- linear = xf86AllocateOffscreenLinear(pScreen, size, 8,
+- NULL, NULL, NULL);
++ linear = xf86AllocateOffscreenLinear(pScreen, size, align, NULL, NULL, NULL);
+ *mem_struct = linear;
+
+ if(!linear) {
+- int max_size;
+-
+- xf86QueryLargestOffscreenLinear(pScreen, &max_size, 8,
+- PRIORITY_EXTREME);
++ int max_size;
+
+- if(max_size < size)
+- return 0;
++ xf86QueryLargestOffscreenLinear(pScreen, &max_size, align, PRIORITY_EXTREME);
++ if(max_size < size) return 0;
+
+- xf86PurgeUnlockedOffscreenAreas(pScreen);
+- linear = xf86AllocateOffscreenLinear(pScreen, size, 8,
+- NULL, NULL, NULL);
++ xf86PurgeUnlockedOffscreenAreas(pScreen);
++ linear = xf86AllocateOffscreenLinear(pScreen, size, align, NULL, NULL, NULL);
+
+- if(!linear) return 0;
++ *mem_struct = linear;
++ if(!linear) return 0;
+ }
+
+- offset = linear->offset * cpp;
++ offset = linear->offset * cpp;
+ }
+-#ifdef USE_EXA
+- else {
+- /* EXA support based on mga driver */
+- ExaOffscreenArea *area = *mem_struct;
+-
+- if(area) {
+- if(area->size >= size)
+- return area->offset;
+-
+- exaOffscreenFree(pScrn->pScreen, area);
+- }
+-
+- area = exaOffscreenAlloc(pScrn->pScreen, size, 64, TRUE, NULL, NULL);
+- *mem_struct = area;
+-
+- if(!area) return 0;
+-
+- offset = area->offset;
+- }
+-#endif
+
+ return offset;
+ }
+@@ -929,11 +931,12 @@ R128PutImage(
+ break;
+ }
+
+- if(!(pPriv->videoOffset = R128AllocateMemory(pScrn, &(pPriv->BufferHandle),
+- pPriv->doubleBuffer ? (new_size << 1) : new_size)))
+- {
+- return BadAlloc;
+- }
++ pPriv->videoOffset = R128AllocateMemory(pScrn, &(pPriv->BufferHandle),
++ pPriv->doubleBuffer ? (new_size << 1) : new_size,
++ 64, FALSE);
++
++ if (pPriv->videoOffset == 0)
++ return BadAlloc;
+
+ pPriv->currentBuffer ^= 1;
+
+--
+2.2.2
+
+
+From 6dc5e9ab12dc31ae5de24f1d5c10c4fe80e7fe07 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Thu, 24 Jul 2014 00:01:46 -0700
+Subject: Unify byte swappers
+
+The cursor loading function was using a lot of code to swap bytes for
+big endian systems. For awhile now, the solid picture support for EXA
+has had a more optimized function that does the same thing.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128_cursor.c | 67 +++++++------------------------------------------------
+ 1 file changed, 8 insertions(+), 59 deletions(-)
+
+diff --git a/src/r128_cursor.c b/src/r128_cursor.c
+index d42bea6..048e6c1 100644
+--- a/src/r128_cursor.c
++++ b/src/r128_cursor.c
+@@ -62,20 +62,6 @@
+ #define CURSOR_WIDTH 64
+ #define CURSOR_HEIGHT 64
+
+-#if X_BYTE_ORDER == X_BIG_ENDIAN
+-#define P_SWAP32( a , b ) \
+- ((char *)a)[0] = ((char *)b)[3]; \
+- ((char *)a)[1] = ((char *)b)[2]; \
+- ((char *)a)[2] = ((char *)b)[1]; \
+- ((char *)a)[3] = ((char *)b)[0]
+-
+-#define P_SWAP16( a , b ) \
+- ((char *)a)[0] = ((char *)b)[1]; \
+- ((char *)a)[1] = ((char *)b)[0]; \
+- ((char *)a)[2] = ((char *)b)[3]; \
+- ((char *)a)[3] = ((char *)b)[2]
+-#endif
+-
+ void r128_crtc_show_cursor(xf86CrtcPtr crtc)
+ {
+ ScrnInfoPtr pScrn = crtc->scrn;
+@@ -176,14 +162,10 @@ void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *src)
+ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+ int crtc_id = r128_crtc->crtc_id;
+
+-
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+- uint32_t *s = (pointer)src;
+- uint32_t *d = (pointer)(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset);
+ uint32_t save1 = 0;
+ uint32_t save2 = 0;
+- int y;
+
+ if (crtc_id == 0) {
+ save1 = INREG(R128_CRTC_GEN_CNTL);
+@@ -194,48 +176,15 @@ void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *src)
+ }
+
+ #if X_BYTE_ORDER == X_BIG_ENDIAN
+- switch(info->CurrentLayout.pixel_bytes) {
+- case 4:
+- case 3:
+- for (y = 0; y < 64; y++) {
+- P_SWAP32(d,s);
+- d++; s++;
+- P_SWAP32(d,s);
+- d++; s++;
+- P_SWAP32(d,s);
+- d++; s++;
+- P_SWAP32(d,s);
+- d++; s++;
+- }
+- break;
+- case 2:
+- for (y = 0; y < 64; y++) {
+- P_SWAP16(d,s);
+- d++; s++;
+- P_SWAP16(d,s);
+- d++; s++;
+- P_SWAP16(d,s);
+- d++; s++;
+- P_SWAP16(d,s);
+- d++; s++;
+- }
+- break;
+- default:
+- for (y = 0; y < 64; y++) {
+- *d++ = *s++;
+- *d++ = *s++;
+- *d++ = *s++;
+- *d++ = *s++;
+- }
+- }
+-#else
+- for (y = 0; y < 64; y++) {
+- *d++ = *s++;
+- *d++ = *s++;
+- *d++ = *s++;
+- *d++ = *s++;
+- }
++ if (info->CurrentLayout.pixel_bytes == 4 || info->CurrentLayout.pixel_bytes == 3)
++ R128CopySwap(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset, src,
++ CURSOR_WIDTH * CURSOR_HEIGHT / 4, APER_0_BIG_ENDIAN_32BPP_SWAP);
++ else if (info->CurrentLayout.pixel_bytes == 2)
++ R128CopySwap(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset, src,
++ CURSOR_WIDTH * CURSOR_HEIGHT / 4, APER_0_BIG_ENDIAN_16BPP_SWAP);
++ else
+ #endif
++ memcpy(info->FB + r128_crtc->cursor_offset + pScrn->fbOffset, src, CURSOR_WIDTH * CURSOR_HEIGHT / 4);
+
+ if (crtc_id == 0)
+ OUTREG(R128_CRTC_GEN_CNTL, save1);
+--
+2.2.2
+
+
+From 2072d9aa1a144e699f020a7f9e6a870e410bc9d7 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 6 Aug 2014 15:41:02 -0700
+Subject: Improve handling of monitor and output types
+
+Checking for OUTPUT_DVI is not the same as checking for MT_DFP. There
+might be r128 cards with a DVI-I connector. These have the capability of
+driving an MT_CRT so we now check the monitor type before programming
+DAC or TMDS registers.
+
+This patch also removes R128ConnectorType and R128BIOSConnector because
+they were not doing much. These data structures are more useful for the
+radeon driver where there is a much wider range of cards.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/r128.h | 1 -
+ src/r128_driver.c | 2 +-
+ src/r128_output.c | 160 ++++++++++++++++++++----------------------------------
+ src/r128_probe.h | 16 ------
+ 4 files changed, 60 insertions(+), 119 deletions(-)
+
+diff --git a/src/r128.h b/src/r128.h
+index 6df1b51..d8748b7 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -504,7 +504,6 @@ typedef struct {
+ Bool DDC;
+
+ Bool VGAAccess;
+- R128BIOSConnector BiosConnector[R128_MAX_BIOS_CONNECTOR];
+
+ /****** Added for dualhead support *******************/
+ BOOL IsSecondary; /* second Screen */
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index c541bfa..ce38b4e 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -3225,7 +3225,7 @@ void R128InitRMXRegisters(R128SavePtr orig, R128SavePtr save,
+ save->fp_h_sync_strt_wid = save->crtc_h_sync_strt_wid;
+ save->fp_v_sync_strt_wid = save->crtc_v_sync_strt_wid;
+
+- if (r128_output->type != OUTPUT_DVI && r128_output->type != OUTPUT_LVDS)
++ if (r128_output->MonType != MT_DFP && r128_output->MonType != MT_LCD)
+ return;
+
+ if (r128_output->PanelXRes == 0 || r128_output->PanelYRes == 0) {
+diff --git a/src/r128_output.c b/src/r128_output.c
+index 7bb2e2a..757ef9b 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -90,21 +90,21 @@ static void r128_mode_set(xf86OutputPtr output, DisplayModePtr mode, DisplayMode
+ if (r128_crtc->crtc_id == 0)
+ R128InitRMXRegisters(&info->SavedReg, &info->ModeReg, output, adjusted_mode);
+
+- if (r128_output->type == OUTPUT_DVI)
++ if (r128_output->MonType == MT_DFP)
+ R128InitFPRegisters(&info->SavedReg, &info->ModeReg, output);
+- else if (r128_output->type == OUTPUT_LVDS)
++ else if (r128_output->MonType == MT_LCD)
+ R128InitLVDSRegisters(&info->SavedReg, &info->ModeReg, output);
+- else if (r128_output->type == OUTPUT_VGA)
++ else if (r128_output->MonType == MT_CRT)
+ R128InitDACRegisters(&info->SavedReg, &info->ModeReg, output);
+
+ if (r128_crtc->crtc_id == 0)
+ R128RestoreRMXRegisters(pScrn, &info->ModeReg);
+
+- if (r128_output->type == OUTPUT_DVI)
++ if (r128_output->MonType == MT_DFP)
+ R128RestoreFPRegisters(pScrn, &info->ModeReg);
+- else if (r128_output->type == OUTPUT_LVDS)
++ else if (r128_output->MonType == MT_LCD)
+ R128RestoreLVDSRegisters(pScrn, &info->ModeReg);
+- else if (r128_output->type == OUTPUT_VGA)
++ else if (r128_output->MonType == MT_CRT)
+ R128RestoreDACRegisters(pScrn, &info->ModeReg);
+ }
+
+@@ -375,133 +375,91 @@ static Bool R128I2CInit(xf86OutputPtr output, I2CBusPtr *bus_ptr, char *name)
+ return TRUE;
+ }
+
+-void R128SetOutputType(ScrnInfoPtr pScrn, R128OutputPrivatePtr r128_output)
+-{
+- R128OutputType output = OUTPUT_NONE;
+-
+- switch (r128_output->ConnectorType) {
+- case CONNECTOR_VGA:
+- output = OUTPUT_VGA;
+- break;
+- case CONNECTOR_LVDS:
+- output = OUTPUT_LVDS;
+- break;
+- case CONNECTOR_DVI_D:
+- case CONNECTOR_DVI_I:
+- case CONNECTOR_DVI_A:
+- output = OUTPUT_DVI;
+- break;
+- default:
+- output = OUTPUT_NONE;
+- }
+-
+- r128_output->type = output;
+-}
+-
+-void R128SetupGenericConnectors(ScrnInfoPtr pScrn)
++void R128SetupGenericConnectors(ScrnInfoPtr pScrn, R128OutputType *otypes)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+ if (!pR128Ent->HasCRTC2 && !info->isDFP) {
+- info->BiosConnector[0].ConnectorType = CONNECTOR_VGA;
+- info->BiosConnector[0].valid = TRUE;
++ otypes[0] = OUTPUT_VGA;
+ return;
+ } else if (!pR128Ent->HasCRTC2) {
+- info->BiosConnector[0].ConnectorType = CONNECTOR_DVI_D;
+- info->BiosConnector[0].valid = TRUE;
++ otypes[0] = OUTPUT_DVI;
+ return;
+ }
+
+- info->BiosConnector[0].ConnectorType = CONNECTOR_LVDS;
+- info->BiosConnector[0].valid = TRUE;
+-
+- info->BiosConnector[1].ConnectorType = CONNECTOR_VGA;
+- info->BiosConnector[1].valid = TRUE;
++ otypes[0] = OUTPUT_LVDS;
++ otypes[1] = OUTPUT_VGA;
+ }
+
+ Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- xf86OutputPtr output;
++
++ R128OutputType otypes[R128_MAX_BIOS_CONNECTOR];
++ xf86OutputPtr output;
+ int num_vga = 0;
+ int num_dvi = 0;
+ int i;
+
+- for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
+- info->BiosConnector[i].valid = FALSE;
+- info->BiosConnector[i].ConnectorType = CONNECTOR_NONE;
+- }
+-
+ /* XXX: Can we make R128GetConnectorInfoFromBIOS()? */
+- R128SetupGenericConnectors(pScrn);
++ R128SetupGenericConnectors(pScrn, otypes);
+
+ for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
+- if (info->BiosConnector[i].valid) {
+- if ((info->BiosConnector[i].ConnectorType == CONNECTOR_DVI_D) ||
+- (info->BiosConnector[i].ConnectorType == CONNECTOR_DVI_I) ||
+- (info->BiosConnector[i].ConnectorType == CONNECTOR_DVI_A)) {
+- num_dvi++;
+- } else if (info->BiosConnector[i].ConnectorType == CONNECTOR_VGA) {
+- num_vga++;
+- }
+- }
++ if (otypes[i] == OUTPUT_VGA)
++ num_vga++;
++ else if (otypes[i] == OUTPUT_DVI)
++ num_dvi++;
+ }
+
+ for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
+- if (info->BiosConnector[i].valid) {
+- R128I2CBusRec i2c;
+- R128OutputPrivatePtr r128_output;
+- R128ConnectorType conntype = info->BiosConnector[i].ConnectorType;
++ if (otypes[i] == OUTPUT_NONE) continue;
+
+- if (conntype == CONNECTOR_NONE)
+- continue;
++ R128I2CBusRec i2c;
++ R128OutputPrivatePtr r128_output;
+
+- r128_output = xnfcalloc(sizeof(R128OutputPrivateRec), 1);
+- if (!r128_output) return FALSE;
++ r128_output = xnfcalloc(sizeof(R128OutputPrivateRec), 1);
++ if (!r128_output) return FALSE;
+
+- r128_output->MonType = MT_UNKNOWN;
+- r128_output->ConnectorType = conntype;
+- r128_output->num = i;
++ r128_output->MonType = MT_UNKNOWN;
++ r128_output->type = otypes[i];
++ r128_output->num = i;
+
+- if (conntype == CONNECTOR_LVDS) {
+- output = R128OutputCreate(pScrn, "LVDS", 0);
+- } else if (conntype == CONNECTOR_VGA) {
+- output = R128OutputCreate(pScrn, "VGA-%d", --num_vga);
+- } else {
+- output = R128OutputCreate(pScrn, "DVI-%d", --num_dvi);
+- }
++ if (otypes[i] == OUTPUT_LVDS) {
++ output = R128OutputCreate(pScrn, "LVDS", 0);
++ } else if (otypes[i] == OUTPUT_VGA) {
++ output = R128OutputCreate(pScrn, "VGA-%d", --num_vga);
++ } else {
++ output = R128OutputCreate(pScrn, "DVI-%d", --num_dvi);
++ }
+
+- if (!output) return FALSE;
+- output->interlaceAllowed = TRUE;
+- output->doubleScanAllowed = TRUE;
+- output->driver_private = r128_output;
+- output->possible_clones = 0;
+- if (conntype == CONNECTOR_LVDS || !pR128Ent->HasCRTC2)
+- output->possible_crtcs = 1;
+- else
+- output->possible_crtcs = 2;
+-
+- if (conntype != CONNECTOR_LVDS && info->DDC) {
+- i2c.ddc_reg = R128_GPIO_MONID;
+- i2c.put_clk_mask = R128_GPIO_MONID_EN_3;
+- i2c.get_clk_mask = R128_GPIO_MONID_Y_3;
+- if (conntype == CONNECTOR_VGA) {
+- i2c.put_data_mask = R128_GPIO_MONID_EN_1;
+- i2c.get_data_mask = R128_GPIO_MONID_Y_1;
+- } else {
+- i2c.put_data_mask = R128_GPIO_MONID_EN_0;
+- i2c.get_data_mask = R128_GPIO_MONID_Y_0;
+- }
+- r128_output->ddc_i2c = i2c;
+- R128I2CInit(output, &r128_output->pI2CBus, output->name);
+- } else if (conntype == CONNECTOR_LVDS) {
+- r128_output->PanelXRes = info->PanelXRes;
+- r128_output->PanelYRes = info->PanelYRes;
++ if (!output) return FALSE;
++ output->interlaceAllowed = TRUE;
++ output->doubleScanAllowed = TRUE;
++ output->driver_private = r128_output;
++ output->possible_clones = 0;
++ if (otypes[i] == OUTPUT_LVDS || !pR128Ent->HasCRTC2)
++ output->possible_crtcs = 1;
++ else
++ output->possible_crtcs = 2;
++
++ if (otypes[i] != OUTPUT_LVDS && info->DDC) {
++ i2c.ddc_reg = R128_GPIO_MONID;
++ i2c.put_clk_mask = R128_GPIO_MONID_EN_3;
++ i2c.get_clk_mask = R128_GPIO_MONID_Y_3;
++ if (otypes[i] == OUTPUT_VGA) {
++ i2c.put_data_mask = R128_GPIO_MONID_EN_1;
++ i2c.get_data_mask = R128_GPIO_MONID_Y_1;
++ } else {
++ i2c.put_data_mask = R128_GPIO_MONID_EN_0;
++ i2c.get_data_mask = R128_GPIO_MONID_Y_0;
+ }
+-
+- R128SetOutputType(pScrn, r128_output);
++ r128_output->ddc_i2c = i2c;
++ R128I2CInit(output, &r128_output->pI2CBus, output->name);
++ } else if (otypes[i] == OUTPUT_LVDS) {
++ r128_output->PanelXRes = info->PanelXRes;
++ r128_output->PanelYRes = info->PanelYRes;
+ }
+ }
+
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index 433463b..fef210d 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -112,16 +112,6 @@ typedef enum
+
+ typedef enum
+ {
+- CONNECTOR_NONE,
+- CONNECTOR_VGA,
+- CONNECTOR_DVI_I,
+- CONNECTOR_DVI_D,
+- CONNECTOR_DVI_A,
+- CONNECTOR_LVDS
+-} R128ConnectorType;
+-
+-typedef enum
+-{
+ OUTPUT_NONE,
+ OUTPUT_VGA,
+ OUTPUT_DVI,
+@@ -144,15 +134,9 @@ typedef struct _R128CrtcPrivateRec {
+ uint8_t lut_r[256], lut_g[256], lut_b[256];
+ } R128CrtcPrivateRec, *R128CrtcPrivatePtr;
+
+-typedef struct {
+- R128ConnectorType ConnectorType;
+- Bool valid;
+-} R128BIOSConnector;
+-
+ typedef struct _R128OutputPrivateRec {
+ int num;
+ R128OutputType type;
+- R128ConnectorType ConnectorType;
+ R128MonitorType MonType;
+ I2CBusPtr pI2CBus;
+ R128I2CBusRec ddc_i2c;
+--
+2.2.2
+
+
+From 6140081f0e8f41cf85b8e86f7a9474c20be9a2e9 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Wed, 6 Aug 2014 15:51:33 -0700
+Subject: Remove custom dualhead code
+
+There are probably no reasons left to use Xinerama over xrandr. This
+removes the screen based dualhead code and the BIOS Display option in
+xorg.conf. Additionally, R128ValidMode() is wrapped so that it can be
+aware of multiple displays.
+
+Even though some Crtc functions refer to them, PanelXRes and PanelYRes
+should be properties of the Output. If this change to the code seems
+awkward, see http://marc.info/?t=107222330700001 for more information.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ man/r128.man | 18 --
+ src/r128.h | 42 ++--
+ src/r128_accel.c | 18 +-
+ src/r128_crtc.c | 62 +++--
+ src/r128_driver.c | 701 ++++++++++++++++++++----------------------------------
+ src/r128_output.c | 10 +-
+ src/r128_probe.c | 1 -
+ src/r128_probe.h | 4 +-
+ src/r128_video.c | 11 +-
+ 9 files changed, 326 insertions(+), 541 deletions(-)
+
+diff --git a/man/r128.man b/man/r128.man
+index d490f93..bd58e0d 100644
+--- a/man/r128.man
++++ b/man/r128.man
+@@ -88,24 +88,6 @@ are used. The default is
+ This overrides the default pixel value for the YUV video overlay key.
+ The default value is
+ .B undefined.
+-.TP
+-.BI "Option \*qDisplay\*q \*q" string \*q
+-Select display mode for devices which support flat panels. Supported modes are:
+-
+-.B \*qFP\*q
+-- use flat panel;
+-
+-.B \*qCRT\*q
+-- use cathode ray tube;
+-
+-.B \*qMirror\*q
+-- use both FP and CRT;
+-
+-.B \*qBIOS\*q
+-- use mode as configured in the BIOS.
+-
+-The default is
+-.B FP.
+
+ .PP
+ The following
+diff --git a/src/r128.h b/src/r128.h
+index d8748b7..3b1e631 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -136,6 +136,14 @@
+ #define R128_ALIGN(x,bytes) (((x) + ((bytes) - 1)) & ~((bytes) - 1))
+ #define R128PTR(pScrn) ((R128InfoPtr)(pScrn)->driverPrivate)
+
++#define R128_BIOS8(v) ((info->VBIOS[(v)]))
++#define R128_BIOS16(v) ((info->VBIOS[(v)]) | \
++ (info->VBIOS[(v) + 1] << 8))
++#define R128_BIOS32(v) ((info->VBIOS[(v)]) | \
++ (info->VBIOS[(v) + 1] << 8) | \
++ (info->VBIOS[(v) + 2] << 16) | \
++ (info->VBIOS[(v) + 3] << 24))
++
+ typedef struct { /* All values in XCLKS */
+ int ML; /* Memory Read Latency */
+ int MB; /* Memory Burst Length */
+@@ -311,16 +319,8 @@ typedef struct {
+ uint32_t MemCntl;
+ uint32_t BusCntl;
+ unsigned long FbMapSize; /* Size of frame buffer, in bytes */
+-
+- uint8_t BIOSDisplay; /* Device the BIOS is set to display to */
+-
+ Bool HasPanelRegs; /* Current chip can connect to a FP */
+
+- /* Computed values for FPs */
+- int PanelXRes;
+- int PanelYRes;
+- int PanelPwrDly;
+-
+ R128PLLRec pll;
+ R128RAMPtr ram;
+
+@@ -501,17 +501,10 @@ typedef struct {
+
+ Bool isDFP;
+ Bool isPro2;
++ Bool SwitchingMode;
+ Bool DDC;
+
+ Bool VGAAccess;
+-
+- /****** Added for dualhead support *******************/
+- BOOL IsSecondary; /* second Screen */
+- BOOL IsPrimary; /* primary Screen */
+- BOOL UseCRT; /* force use CRT port as primary */
+- BOOL SwitchingMode;
+- R128MonitorType DisplayType; /* Monitor connected on*/
+-
+ } R128InfoRec, *R128InfoPtr;
+
+ #define R128WaitForFifo(pScrn, entries) \
+@@ -535,6 +528,7 @@ extern Bool R128CursorInit(ScreenPtr pScreen);
+ extern Bool R128DGAInit(ScreenPtr pScreen);
+
+ extern int R128MinBits(int val);
++extern xf86OutputPtr R128FirstOutput(xf86CrtcPtr crtc);
+
+ extern void R128InitVideo(ScreenPtr pScreen);
+
+@@ -544,13 +538,13 @@ extern void R128InitRMXRegisters(R128SavePtr orig, R128SavePtr save, xf86
+ extern void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output);
+ extern void R128InitLVDSRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr output);
+ extern Bool R128InitCrtcBase(xf86CrtcPtr crtc, R128SavePtr save, int x, int y);
+-extern Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
+-extern void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, double dot_clock);
+-extern Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, R128InfoPtr info, DisplayModePtr mode);
++extern Bool R128InitCrtcRegisters(xf86CrtcPtr crtc, R128SavePtr save, DisplayModePtr mode);
++extern void R128InitPLLRegisters(xf86CrtcPtr crtc, R128SavePtr save, R128PLLPtr pll, double dot_clock);
++extern Bool R128InitDDARegisters(xf86CrtcPtr crtc, R128SavePtr save, R128PLLPtr pll, DisplayModePtr mode);
+ extern Bool R128InitCrtc2Base(xf86CrtcPtr crtc, R128SavePtr save, int x, int y);
+-extern Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save, DisplayModePtr mode, R128InfoPtr info);
+-extern void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, double dot_clock);
+-extern Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save, R128PLLPtr pll, R128InfoPtr info, DisplayModePtr mode);
++extern Bool R128InitCrtc2Registers(xf86CrtcPtr crtc, R128SavePtr save, DisplayModePtr mode);
++extern void R128InitPLL2Registers(xf86CrtcPtr crtc, R128SavePtr save, R128PLLPtr pll, double dot_clock);
++extern Bool R128InitDDA2Registers(xf86CrtcPtr crtc, R128SavePtr save, R128PLLPtr pll, DisplayModePtr mode);
+ extern void R128RestoreCommonRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+ extern void R128RestoreDACRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+ extern void R128RestoreRMXRegisters(ScrnInfoPtr pScrn, R128SavePtr restore);
+@@ -571,11 +565,13 @@ extern void r128_crtc_load_cursor_image(xf86CrtcPtr crtc, unsigned char *
+
+ extern uint32_t R128AllocateMemory(ScrnInfoPtr pScrn, void **mem_struct, int size, int align, Bool need_accel);
+ extern Bool R128SetupConnectors(ScrnInfoPtr pScrn);
+-extern Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask);
++extern Bool R128AllocateControllers(ScrnInfoPtr pScrn);
++extern void R128GetPanelInfoFromBIOS(xf86OutputPtr output);
+ extern void R128Blank(ScrnInfoPtr pScrn);
+ extern void R128Unblank(ScrnInfoPtr pScrn);
+ extern void R128DPMSSetOn(xf86OutputPtr output);
+ extern void R128DPMSSetOff(xf86OutputPtr output);
++extern ModeStatus R128DoValidMode(xf86OutputPtr output, DisplayModePtr mode, int flags);
+ extern DisplayModePtr R128ProbeOutputModes(xf86OutputPtr output);
+
+ #ifdef R128DRI
+diff --git a/src/r128_accel.c b/src/r128_accel.c
+index 99bfb20..fa58327 100644
+--- a/src/r128_accel.c
++++ b/src/r128_accel.c
+@@ -1746,7 +1746,7 @@ static void R128CCEAccelInit(ScrnInfoPtr pScrn, XAAInfoRecPtr a)
+ | HARDWARE_PATTERN_SCREEN_ORIGIN
+ | BIT_ORDER_IN_BYTE_LSBFIRST);
+
+- if(!info->IsSecondary && xf86IsEntityShared(pScrn->entityList[0]))
++ if (xf86IsEntityShared(info->pEnt->index))
+ a->RestoreAccelState = R128RestoreCCEAccelState;
+
+ }
+@@ -1851,15 +1851,13 @@ static void R128MMIOAccelInit(ScrnInfoPtr pScrn, XAAInfoRecPtr a)
+ | LEFT_EDGE_CLIPPING_NEGATIVE_X
+ | SCANLINE_PAD_DWORD;
+
+- if(xf86IsEntityShared(pScrn->entityList[0]))
+- {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+-
+- /*if there are more than one devices sharing this entity, we
+- have to assign this call back, otherwise the XAA will be
+- disabled */
+- if(pR128Ent->HasSecondary || pR128Ent->BypassSecondary)
+- a->RestoreAccelState = R128RestoreAccelState;
++ if (xf86IsEntityShared(info->pEnt-index)) {
++ /* If there are more than one devices sharing this entity, we
++ * have to assign this call back, otherwise the XAA will be
++ * disabled.
++ */
++ if (xf86GetNumEntityInstances(info->pEnt->index) > 1)
++ a->RestoreAccelState = R128RestoreAccelState;
+ }
+
+ }
+diff --git a/src/r128_crtc.c b/src/r128_crtc.c
+index 92a6c30..26d4414 100644
+--- a/src/r128_crtc.c
++++ b/src/r128_crtc.c
+@@ -143,11 +143,11 @@ static void r128_crtc_mode_set(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayMod
+
+ switch (r128_crtc->crtc_id) {
+ case 0:
+- R128InitCrtcRegisters(pScrn, &info->ModeReg, adjusted_mode, info);
++ R128InitCrtcRegisters(crtc, &info->ModeReg, adjusted_mode);
+ R128InitCrtcBase(crtc, &info->ModeReg, x, y);
+ if (dot_clock) {
+- R128InitPLLRegisters(pScrn, &info->ModeReg, &info->pll, dot_clock);
+- R128InitDDARegisters(pScrn, &info->ModeReg, &info->pll, info, adjusted_mode);
++ R128InitPLLRegisters(crtc, &info->ModeReg, &info->pll, dot_clock);
++ R128InitDDARegisters(crtc, &info->ModeReg, &info->pll, adjusted_mode);
+ } else {
+ info->ModeReg.ppll_ref_div = info->SavedReg.ppll_ref_div;
+ info->ModeReg.ppll_div_3 = info->SavedReg.ppll_div_3;
+@@ -157,11 +157,11 @@ static void r128_crtc_mode_set(xf86CrtcPtr crtc, DisplayModePtr mode, DisplayMod
+ }
+ break;
+ case 1:
+- R128InitCrtc2Registers(pScrn, &info->ModeReg, adjusted_mode, info);
++ R128InitCrtc2Registers(crtc, &info->ModeReg, adjusted_mode);
+ R128InitCrtc2Base(crtc, &info->ModeReg, x, y);
+ if (dot_clock) {
+- R128InitPLL2Registers(pScrn, &info->ModeReg, &info->pll, dot_clock);
+- R128InitDDA2Registers(pScrn, &info->ModeReg, &info->pll, info, adjusted_mode);
++ R128InitPLL2Registers(crtc, &info->ModeReg, &info->pll, dot_clock);
++ R128InitDDA2Registers(crtc, &info->ModeReg, &info->pll, adjusted_mode);
+ }
+ break;
+ }
+@@ -327,44 +327,40 @@ static const xf86CrtcFuncsRec r128_crtc_funcs = {
+ .destroy = NULL,
+ };
+
+-Bool R128AllocateControllers(ScrnInfoPtr pScrn, int mask)
++Bool R128AllocateControllers(ScrnInfoPtr pScrn)
+ {
+ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+- if (mask & 1) {
+- if (pR128Ent->Controller[0])
+- return TRUE;
++ if (pR128Ent->Controller[0])
++ return TRUE;
+
+- pR128Ent->pCrtc[0] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
+- if (!pR128Ent->pCrtc[0])
+- return FALSE;
++ pR128Ent->pCrtc[0] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
++ if (!pR128Ent->pCrtc[0])
++ return FALSE;
+
+- pR128Ent->Controller[0] = xnfcalloc(sizeof(R128CrtcPrivateRec), 1);
+- if (!pR128Ent->Controller[0])
+- return FALSE;
++ pR128Ent->Controller[0] = xnfcalloc(sizeof(R128CrtcPrivateRec), 1);
++ if (!pR128Ent->Controller[0])
++ return FALSE;
+
+- pR128Ent->pCrtc[0]->driver_private = pR128Ent->Controller[0];
+- pR128Ent->Controller[0]->crtc_id = 0;
+- }
+-
+- if (mask & 2) {
+- if (!pR128Ent->HasCRTC2)
+- return TRUE;
++ pR128Ent->pCrtc[0]->driver_private = pR128Ent->Controller[0];
++ pR128Ent->Controller[0]->crtc_id = 0;
+
+- pR128Ent->pCrtc[1] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
+- if (!pR128Ent->pCrtc[1])
+- return FALSE;
++ if (!pR128Ent->HasCRTC2)
++ return TRUE;
+
+- pR128Ent->Controller[1] = xnfcalloc(sizeof(R128CrtcPrivateRec), 1);
+- if (!pR128Ent->Controller[1]) {
+- free(pR128Ent->Controller[0]);
+- return FALSE;
+- }
++ pR128Ent->pCrtc[1] = xf86CrtcCreate(pScrn, &r128_crtc_funcs);
++ if (!pR128Ent->pCrtc[1])
++ return FALSE;
+
+- pR128Ent->pCrtc[1]->driver_private = pR128Ent->Controller[1];
+- pR128Ent->Controller[1]->crtc_id = 1;
++ pR128Ent->Controller[1] = xnfcalloc(sizeof(R128CrtcPrivateRec), 1);
++ if (!pR128Ent->Controller[1]) {
++ free(pR128Ent->Controller[0]);
++ return FALSE;
+ }
+
++ pR128Ent->pCrtc[1]->driver_private = pR128Ent->Controller[1];
++ pR128Ent->Controller[1]->crtc_id = 1;
++
+ return TRUE;
+ }
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index ce38b4e..0a8d802 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -171,7 +171,6 @@ static const OptionInfoRec R128Options[] = {
+ { OPTION_BUFFER_SIZE, "BufferSize", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_PAGE_FLIP, "EnablePageFlip", OPTV_BOOLEAN, {0}, FALSE },
+ #endif
+- { OPTION_DISPLAY, "Display", OPTV_STRING, {0}, FALSE },
+ { OPTION_PANEL_WIDTH, "PanelWidth", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_PANEL_HEIGHT, "PanelHeight", OPTV_INTEGER, {0}, FALSE },
+ { OPTION_PROG_FP_REGS, "ProgramFPRegs", OPTV_BOOLEAN, {0}, FALSE },
+@@ -238,14 +237,6 @@ static Bool R128MapMMIO(ScrnInfoPtr pScrn)
+ if (info->FBDev) {
+ info->MMIO = fbdevHWMapMMIO(pScrn);
+ } else {
+- /* If the primary screen has already mapped the MMIO region,
+- use its pointer instead of mapping it a second time. */
+- if (info->IsSecondary) {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- R128InfoPtr info0 = R128PTR(pR128Ent->pPrimaryScrn);
+- info->MMIO=info0->MMIO;
+- if (info->MMIO) return TRUE;
+- }
+ #ifndef XSERVER_LIBPCIACCESS
+ info->MMIO = xf86MapPciMem(pScrn->scrnIndex,
+ VIDMEM_MMIO | VIDMEM_READSIDEEFFECT,
+@@ -412,20 +403,26 @@ static int R128Div(int n, int d)
+ return (n + (d / 2)) / d;
+ }
+
+-/* Read the Video BIOS block and the FP registers (if applicable). */
++/* Finds the first output using a given crtc. */
++xf86OutputPtr R128FirstOutput(xf86CrtcPtr crtc)
++{
++ ScrnInfoPtr pScrn = crtc->scrn;
++ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
++ xf86OutputPtr output = xf86_config->output[0];
++ int o;
++
++ for (o = 0; o < xf86_config->num_output; o++) {
++ output = xf86_config->output[o];
++ if (output->crtc == crtc) break;
++ }
++
++ return output;
++}
++
++/* Read the Video BIOS block. */
+ static Bool R128GetBIOSParameters(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
+- int i;
+- int FPHeader = 0;
+-
+-#define R128_BIOS8(v) (info->VBIOS[v])
+-#define R128_BIOS16(v) (info->VBIOS[v] | \
+- (info->VBIOS[(v) + 1] << 8))
+-#define R128_BIOS32(v) (info->VBIOS[v] | \
+- (info->VBIOS[(v) + 1] << 8) | \
+- (info->VBIOS[(v) + 2] << 16) | \
+- (info->VBIOS[(v) + 3] << 24))
+
+ #ifdef XSERVER_LIBPCIACCESS
+ int size = info->PciInfo->rom_size > R128_VBIOS_SIZE ? info->PciInfo->rom_size : R128_VBIOS_SIZE;
+@@ -469,143 +466,103 @@ static Bool R128GetBIOSParameters(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Video BIOS not found!\n");
+ }
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+-
+- if(pR128Ent->HasCRTC2)
+- {
+- if(info->IsSecondary)
+- {
+- /* there may be a way to detect this, for now, just assume
+- second head is CRT */
+- info->DisplayType = MT_CRT;
+-
+- if(info->DisplayType > MT_NONE)
+- {
+- pR128Ent->HasSecondary = TRUE;
+-
+- }
+- else return FALSE;
+-
+- }
+- else
+- {
+- /* really need some sort of detection here */
+- if (info->HasPanelRegs) {
+- info->DisplayType = MT_LCD;
+- } else if (info->isDFP) {
+- info->DisplayType = MT_DFP;
+- } else
+- {
+- /*DVI port has no monitor connected, try CRT port.
+- If something on CRT port, treat it as primary*/
+- if(xf86IsEntityShared(pScrn->entityList[0]))
+- {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- pR128Ent->BypassSecondary = TRUE;
+- }
+-
+- info->DisplayType = MT_CRT;
+-#if 0
+- {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "No monitor detected!!!\n");
+- return FALSE;
+- }
+-#endif
+- }
+- }
+- }
+- else
+- {
+- /*Regular Radeon ASIC, only one CRTC, but it could be
+- used for DFP with a DVI output, like AIW board*/
+- if(info->isDFP) info->DisplayType = MT_DFP;
+- else info->DisplayType = MT_CRT;
+- }
+-
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%s Display == Type %d\n",
+- (info->IsSecondary ? "Secondary" : "Primary"),
+- info->DisplayType);
+-
+-
+- if (info->VBIOS && info->DisplayType == MT_LCD) {
+- info->FPBIOSstart = 0;
+-
+- /* FIXME: There should be direct access to the start of the FP info
+- tables, but until we find out where that offset is stored, we
+- must search for the ATI signature string: "M3 ". */
+- for (i = 4; i < R128_VBIOS_SIZE-8; i++) {
+- if (R128_BIOS8(i) == 'M' &&
+- R128_BIOS8(i+1) == '3' &&
+- R128_BIOS8(i+2) == ' ' &&
+- R128_BIOS8(i+3) == ' ' &&
+- R128_BIOS8(i+4) == ' ' &&
+- R128_BIOS8(i+5) == ' ' &&
+- R128_BIOS8(i+6) == ' ' &&
+- R128_BIOS8(i+7) == ' ') {
+- FPHeader = i-2;
+- break;
+- }
+- }
+
+- if (!FPHeader) return TRUE;
++ return TRUE;
++}
+
+- /* Assume that only one panel is attached and supported */
+- for (i = FPHeader+20; i < FPHeader+84; i += 2) {
+- if (R128_BIOS16(i) != 0) {
+- info->FPBIOSstart = R128_BIOS16(i);
+- break;
+- }
+- }
+- if (!info->FPBIOSstart) return TRUE;
+-
+- if (!info->PanelXRes)
+- info->PanelXRes = R128_BIOS16(info->FPBIOSstart+25);
+- if (!info->PanelYRes)
+- info->PanelYRes = R128_BIOS16(info->FPBIOSstart+27);
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel size: %dx%d\n",
+- info->PanelXRes, info->PanelYRes);
+-
+- info->PanelPwrDly = R128_BIOS8(info->FPBIOSstart+56);
+-
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel ID: ");
+- for (i = 1; i <= 24; i++)
+- ErrorF("%c", R128_BIOS8(info->FPBIOSstart+i));
+- ErrorF("\n");
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel Type: ");
+- i = R128_BIOS16(info->FPBIOSstart+29);
+- if (i & 1) ErrorF("Color, ");
+- else ErrorF("Monochrome, ");
+- if (i & 2) ErrorF("Dual(split), ");
+- else ErrorF("Single, ");
+- switch ((i >> 2) & 0x3f) {
+- case 0: ErrorF("STN"); break;
+- case 1: ErrorF("TFT"); break;
+- case 2: ErrorF("Active STN"); break;
+- case 3: ErrorF("EL"); break;
+- case 4: ErrorF("Plasma"); break;
+- default: ErrorF("UNKNOWN"); break;
+- }
+- ErrorF("\n");
+- if (R128_BIOS8(info->FPBIOSstart+61) & 1) {
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel Interface: LVDS\n");
+- } else {
+- /* FIXME: Add Non-LVDS flat pael support */
+- xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+- "Non-LVDS panel interface detected! "
+- "This support is untested and may not "
+- "function properly\n");
+- }
++/* Read the FP parameters if an LVDS panel is expected. */
++void R128GetPanelInfoFromBIOS(xf86OutputPtr output)
++{
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ R128OutputPrivatePtr r128_output = output->driver_private;
++ int FPHeader = 0;
++ int i;
++
++ if (!info->VBIOS) return;
++ info->FPBIOSstart = 0;
++
++ /* FIXME: There should be direct access to the start of the FP info
++ * tables, but until we find out where that offset is stored, we
++ * must search for the ATI signature string: "M3 ".
++ */
++ for (i = 4; i < R128_VBIOS_SIZE - 8; i++) {
++ if (R128_BIOS8(i) == 'M' &&
++ R128_BIOS8(i + 1) == '3' &&
++ R128_BIOS8(i + 2) == ' ' &&
++ R128_BIOS8(i + 3) == ' ' &&
++ R128_BIOS8(i + 4) == ' ' &&
++ R128_BIOS8(i + 5) == ' ' &&
++ R128_BIOS8(i + 6) == ' ' &&
++ R128_BIOS8(i + 7) == ' ') {
++ FPHeader = i - 2;
++ break;
++ }
++ }
++
++ if (!FPHeader) return;
++
++ /* Assume that only one panel is attached and supported */
++ for (i = FPHeader+20; i < FPHeader+84; i += 2) {
++ if (R128_BIOS16(i) != 0) {
++ info->FPBIOSstart = R128_BIOS16(i);
++ break;
++ }
+ }
+
+- if (!info->PanelXRes || !info->PanelYRes) {
++ if (!info->FPBIOSstart) return;
++ xf86GetOptValInteger(info->Options, OPTION_PANEL_WIDTH, &(r128_output->PanelXRes));
++ xf86GetOptValInteger(info->Options, OPTION_PANEL_HEIGHT, &(r128_output->PanelYRes));
++
++ if (!r128_output->PanelXRes)
++ r128_output->PanelXRes = R128_BIOS16(info->FPBIOSstart + 25);
++ if (!r128_output->PanelYRes)
++ r128_output->PanelYRes = R128_BIOS16(info->FPBIOSstart + 27);
++ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel size: %dx%d\n",
++ r128_output->PanelXRes, r128_output->PanelYRes);
++
++ r128_output->PanelPwrDly = R128_BIOS8(info->FPBIOSstart + 56);
++
++ if (!r128_output->PanelXRes || !r128_output->PanelYRes) {
+ info->HasPanelRegs = FALSE;
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "Can't determine panel dimensions, and none specified.\n"
+ "\tDisabling programming of FP registers.\n");
+ }
+
+- return TRUE;
++ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel ID: ");
++ for (i = 1; i <= 24; i++)
++ ErrorF("%c", R128_BIOS8(info->FPBIOSstart + i));
++
++ ErrorF("\n");
++
++ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel Type: ");
++ i = R128_BIOS16(info->FPBIOSstart + 29);
++ if (i & 1) ErrorF("Color, ");
++ else ErrorF("Monochrome, ");
++ if (i & 2) ErrorF("Dual(split), ");
++ else ErrorF("Single, ");
++
++ switch ((i >> 2) & 0x3f) {
++ case 0: ErrorF("STN"); break;
++ case 1: ErrorF("TFT"); break;
++ case 2: ErrorF("Active STN"); break;
++ case 3: ErrorF("EL"); break;
++ case 4: ErrorF("Plasma"); break;
++ default: ErrorF("UNKNOWN"); break;
++ }
++
++ ErrorF("\n");
++
++ if (R128_BIOS8(info->FPBIOSstart + 61) & 1) {
++ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Panel Interface: LVDS\n");
++ } else {
++ /* FIXME: Add Non-LVDS flat pael support */
++ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
++ "Non-LVDS panel interface detected! "
++ "This support is untested and may not "
++ "function properly\n");
++ }
+ }
+
+ /* Read PLL parameters from BIOS block. Default to typical values if there
+@@ -956,39 +913,6 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ info->MemCntl = INREG(R128_MEM_CNTL);
+ info->BusCntl = INREG(R128_BUS_CNTL);
+
+- /* On non-flat panel systems, the default is to display to the CRT,
+- and on flat panel systems, the default is to display to the flat
+- panel unless the user explicity chooses otherwise using the "Display"
+- config file setting. BIOS_5_SCRATCH holds the display device on flat
+- panel systems only. */
+- if (info->HasPanelRegs) {
+- char *Display = xf86GetOptValString(info->Options, OPTION_DISPLAY);
+-
+- if (info->FBDev)
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+- "Option \"Display\" ignored "
+- "(framebuffer device determines display type)\n");
+- else if (!Display)
+- info->BIOSDisplay = R128_DUALHEAD;
+- else if (!xf86NameCmp(Display, "FP"))
+- info->BIOSDisplay = R128_BIOS_DISPLAY_FP;
+- else if (!xf86NameCmp(Display, "BIOS"))
+- info->BIOSDisplay = INREG8(R128_BIOS_5_SCRATCH);
+- else if (!xf86NameCmp(Display, "Mirror"))
+- info->BIOSDisplay = R128_BIOS_DISPLAY_FP_CRT;
+- else if (!xf86NameCmp(Display, "CRT"))
+- info->BIOSDisplay = R128_BIOS_DISPLAY_CRT;
+- else {
+- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+- "Unsupported type \"%s\" specified for Option \"Display\".\n"
+- "\tSupported types are: "
+- "\"BIOS\", \"Mirror\", \"CRT\" and \"FP\"\n", Display);
+- return FALSE;
+- }
+- } else {
+- info->BIOSDisplay = R128_BIOS_DISPLAY_CRT;
+- }
+-
+ /* RAM */
+ switch (info->MemCntl & 0x3) {
+ case 0: /* SDR SGRAM 1:1 */
+@@ -1027,62 +951,9 @@ static Bool R128PreInitConfig(ScrnInfoPtr pScrn)
+ xf86DrvMsg(pScrn->scrnIndex, from,
+ "VideoRAM: %d kByte (%s)\n", pScrn->videoRam, info->ram->name);
+
+- if (info->IsPrimary) {
+- pScrn->videoRam /= 2;
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+- "Using %dk of videoram for primary head\n",
+- pScrn->videoRam);
+- }
+-
+- if (info->IsSecondary) {
+- pScrn->videoRam /= 2;
+- info->LinearAddr += pScrn->videoRam * 1024;
+- xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+- "Using %dk of videoram for secondary head\n",
+- pScrn->videoRam);
+- }
+-
+ pScrn->videoRam &= ~1023;
+ info->FbMapSize = pScrn->videoRam * 1024;
+
+-
+- /* Flat panel (part 2) */
+- switch (info->BIOSDisplay) {
+- case R128_DUALHEAD:
+- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+- "Dual display\n");
+- break;
+- case R128_BIOS_DISPLAY_FP:
+- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+- "Using flat panel for display\n");
+- break;
+- case R128_BIOS_DISPLAY_CRT:
+- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+- "Using external CRT for display\n");
+- break;
+- case R128_BIOS_DISPLAY_FP_CRT:
+- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+- "Using both flat panel and external CRT "
+- "for display\n");
+- break;
+- }
+-
+- if (info->HasPanelRegs) {
+- /* Panel width/height overrides */
+- info->PanelXRes = 0;
+- info->PanelYRes = 0;
+- if (xf86GetOptValInteger(info->Options,
+- OPTION_PANEL_WIDTH, &(info->PanelXRes))) {
+- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+- "Flat panel width: %d\n", info->PanelXRes);
+- }
+- if (xf86GetOptValInteger(info->Options,
+- OPTION_PANEL_HEIGHT, &(info->PanelYRes))) {
+- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+- "Flat panel height: %d\n", info->PanelYRes);
+- }
+- }
+-
+ #ifdef R128DRI
+ /* DMA for Xv */
+ info->DMAForXv = xf86ReturnOptValBool(info->Options, OPTION_XV_DMA, FALSE);
+@@ -1333,18 +1204,9 @@ static Bool R128PreInitDRI(ScrnInfoPtr pScrn)
+
+ static Bool R128PreInitControllers(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ {
+- R128InfoPtr info = R128PTR(pScrn);
+ xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+- int i;
+- int mask;
+ int found = 0;
+-
+- if (info->IsPrimary)
+- mask = 1;
+- else if (info->IsSecondary)
+- mask = 2;
+- else
+- mask = 3;
++ int i;
+
+ if (!R128GetBIOSParameters(pScrn, pInt10))
+ return FALSE;
+@@ -1352,7 +1214,7 @@ static Bool R128PreInitControllers(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+ if (!R128GetPLLParameters(pScrn))
+ return FALSE;
+
+- if (!R128AllocateControllers(pScrn, mask))
++ if (!R128AllocateControllers(pScrn))
+ return FALSE;
+
+ if (!R128SetupConnectors(pScrn))
+@@ -1405,43 +1267,19 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+
+ if (!R128GetRec(pScrn)) return FALSE;
+
+- info = R128PTR(pScrn);
+-
+- info->IsSecondary = FALSE;
+- info->IsPrimary = FALSE;
++ info = R128PTR(pScrn);
+ info->SwitchingMode = FALSE;
++ info->MMIO = NULL;
+
+- info->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
++ info->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+ if (info->pEnt->location.type != BUS_PCI) goto fail;
+
+- if(xf86IsEntityShared(pScrn->entityList[0]))
+- {
+- if(xf86IsPrimInitDone(pScrn->entityList[0]))
+- {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- info->IsSecondary = TRUE;
+- if(pR128Ent->BypassSecondary) return FALSE;
+- pR128Ent->pSecondaryScrn = pScrn;
+- }
+- else
+- {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- info->IsPrimary = TRUE;
+- xf86SetPrimInitDone(pScrn->entityList[0]);
+- pR128Ent->pPrimaryScrn = pScrn;
+- pR128Ent->BypassSecondary = FALSE;
+- pR128Ent->HasSecondary = FALSE;
+- pR128Ent->RestorePrimary = FALSE;
+- pR128Ent->IsSecondaryRestored = FALSE;
+- }
+- }
+-
+ if (flags & PROBE_DETECT) {
+ R128ProbeDDC(pScrn, info->pEnt->index);
+ return TRUE;
+ }
+
+- info->PciInfo = xf86GetPciInfoForEntity(info->pEnt->index);
++ info->PciInfo = xf86GetPciInfoForEntity(info->pEnt->index);
+
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "PCI bus %d card %d func %d\n",
+@@ -1450,16 +1288,16 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
+ PCI_DEV_FUNC(info->PciInfo));
+
+ #ifndef XSERVER_LIBPCIACCESS
+- info->PciTag = pciTag(PCI_DEV_BUS(info->PciInfo),
++ info->PciTag = pciTag(PCI_DEV_BUS(info->PciInfo),
+ PCI_DEV_DEV(info->PciInfo),
+ PCI_DEV_FUNC(info->PciInfo));
+
+ if (xf86RegisterResources(info->pEnt->index, 0, ResNone)) goto fail;
+ if (xf86SetOperatingState(resVga, info->pEnt->index, ResUnusedOpr)) goto fail;
+
+- pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_VIEWPORT | RAC_CURSOR;
++ pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_VIEWPORT | RAC_CURSOR;
+ #endif
+- pScrn->monitor = pScrn->confScreen->monitor;
++ pScrn->monitor = pScrn->confScreen->monitor;
+
+ /* Allocate an xf86CrtcConfig */
+ xf86CrtcConfigInit(pScrn, &R128CRTCResizeFuncs);
+@@ -1810,7 +1648,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+
+ if (!R128MapMem(pScrn)) return FALSE;
+ pScrn->fbOffset = 0;
+- if(info->IsSecondary) pScrn->fbOffset = pScrn->videoRam * 1024;
++ //if(info->IsSecondary) pScrn->fbOffset = pScrn->videoRam * 1024;
+ #ifdef R128DRI
+ info->fbX = 0;
+ info->fbY = 0;
+@@ -1857,23 +1695,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ info->CurrentLayout.pixel_bytes * 3 + 1023) / 1024);
+ info->directRenderingEnabled = FALSE;
+ } else {
+- if(info->IsSecondary)
+- info->directRenderingEnabled = FALSE;
+- else
+- {
+- /* Xinerama has sync problem with DRI, disable it for now */
+- if(xf86IsEntityShared(pScrn->entityList[0]))
+- {
+- info->directRenderingEnabled = FALSE;
+- xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+- "Direct Rendering Disabled -- "
+- "Dual-head configuration is not working with DRI "
+- "at present.\nPlease use only one Device/Screen "
+- "section in your XFConfig file.\n");
+- }
+- else
+- info->directRenderingEnabled = R128DRIScreenInit(pScreen);
+- }
++ info->directRenderingEnabled = R128DRIScreenInit(pScreen);
+ }
+ }
+ #endif
+@@ -2259,8 +2081,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ else
+ xf86DPMSInit(pScreen, xf86DPMSSet, 0);
+
+- if (!info->IsSecondary)
+- R128InitVideo(pScreen);
++ R128InitVideo(pScreen);
+
+ /* Provide SaveScreen */
+ pScreen->SaveScreen = R128SaveScreen;
+@@ -2411,9 +2232,13 @@ void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ void R128RestoreLVDSRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+ uint32_t tmp;
+
++ xf86OutputPtr output = R128FirstOutput(pR128Ent->pCrtc[0]);
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
+ tmp = INREG(R128_LVDS_GEN_CNTL);
+ if ((tmp & (R128_LVDS_ON | R128_LVDS_BLON)) ==
+ (restore->lvds_gen_cntl & (R128_LVDS_ON | R128_LVDS_BLON))) {
+@@ -2422,11 +2247,11 @@ void R128RestoreLVDSRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+ if (restore->lvds_gen_cntl & (R128_LVDS_ON | R128_LVDS_BLON)) {
+ OUTREG(R128_LVDS_GEN_CNTL,
+ restore->lvds_gen_cntl & (uint32_t)~R128_LVDS_BLON);
+- usleep(R128PTR(pScrn)->PanelPwrDly * 1000);
++ usleep(r128_output->PanelPwrDly * 1000);
+ OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
+ } else {
+ OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl | R128_LVDS_BLON);
+- usleep(R128PTR(pScrn)->PanelPwrDly * 1000);
++ usleep(r128_output->PanelPwrDly * 1000);
+ OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
+ }
+ }
+@@ -2664,8 +2489,6 @@ static void R128SaveFPRegisters(ScrnInfoPtr pScrn, R128SavePtr save)
+ R128InfoPtr info = R128PTR(pScrn);
+ unsigned char *R128MMIO = info->MMIO;
+
+- if (info->BIOSDisplay != R128_DUALHEAD)
+- save->crtc2_gen_cntl = INREG(R128_CRTC2_GEN_CNTL);
+ save->fp_crtc_h_total_disp = INREG(R128_FP_CRTC_H_TOTAL_DISP);
+ save->fp_crtc_v_total_disp = INREG(R128_FP_CRTC_V_TOTAL_DISP);
+ save->fp_gen_cntl = INREG(R128_FP_GEN_CNTL);
+@@ -2769,28 +2592,23 @@ static void R128SavePalette(ScrnInfoPtr pScrn, R128SavePtr save)
+ static void R128SaveMode(ScrnInfoPtr pScrn, R128SavePtr save)
+ {
+ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+ R128TRACE(("R128SaveMode(%p)\n", save));
+
+- if(info->IsSecondary)
+- {
++ R128SaveCommonRegisters(pScrn, save);
++ R128SaveCrtcRegisters(pScrn, save);
++ R128SavePLLRegisters(pScrn, save);
++ R128SaveDDARegisters(pScrn, save);
++ if (pR128Ent->HasCRTC2) {
+ R128SaveCrtc2Registers(pScrn, save);
+ R128SavePLL2Registers(pScrn, save);
+ R128SaveDDA2Registers(pScrn, save);
+ }
+- else
+- {
+- R128SaveCommonRegisters(pScrn, save);
+- R128SaveCrtcRegisters(pScrn, save);
+- if((info->DisplayType == MT_DFP) ||
+- (info->DisplayType == MT_LCD))
+- {
+- R128SaveFPRegisters(pScrn, save);
+- }
+- R128SavePLLRegisters(pScrn, save);
+- R128SaveDDARegisters(pScrn, save);
+- R128SavePalette(pScrn, save);
++ if (info->HasPanelRegs) {
++ R128SaveFPRegisters(pScrn, save);
+ }
++ R128SavePalette(pScrn, save);
+
+ R128TRACE(("R128SaveMode returns %p\n", save));
+ }
+@@ -2808,36 +2626,33 @@ static void R128Save(ScrnInfoPtr pScrn)
+ return;
+ }
+
+- if (!info->IsSecondary) {
+ #ifdef WITH_VGAHW
+- if (info->VGAAccess) {
+- vgaHWPtr hwp = VGAHWPTR(pScrn);
++ if (info->VGAAccess) {
++ vgaHWPtr hwp = VGAHWPTR(pScrn);
+
+- vgaHWUnlock(hwp);
++ vgaHWUnlock(hwp);
+ # if defined(__powerpc__)
+- /* temporary hack to prevent crashing on PowerMacs when trying to
+- * read VGA fonts and colormap, will find a better solution
+- * in the future. TODO: Check if there's actually some VGA stuff
+- * setup in the card at all !!
+- */
+- vgaHWSave(pScrn, &hwp->SavedReg, VGA_SR_MODE); /* Save mode only */
++ /* temporary hack to prevent crashing on PowerMacs when trying to
++ * read VGA fonts and colormap, will find a better solution
++ * in the future. TODO: Check if there's actually some VGA stuff
++ * setup in the card at all !!
++ */
++ vgaHWSave(pScrn, &hwp->SavedReg, VGA_SR_MODE); /* Save mode only */
+ # else
+- /* Save mode * & fonts & cmap */
+- vgaHWSave(pScrn, &hwp->SavedReg, VGA_SR_MODE | VGA_SR_FONTS);
++ /* Save mode * & fonts & cmap */
++ vgaHWSave(pScrn, &hwp->SavedReg, VGA_SR_MODE | VGA_SR_FONTS);
+ # endif
+- vgaHWLock(hwp);
+- }
++ vgaHWLock(hwp);
++ }
+ #endif
+
+- save->dp_datatype = INREG(R128_DP_DATATYPE);
+- save->gen_reset_cntl = INREG(R128_GEN_RESET_CNTL);
+- save->clock_cntl_index = INREG(R128_CLOCK_CNTL_INDEX);
+- save->amcgpio_en_reg = INREG(R128_AMCGPIO_EN_REG);
+- save->amcgpio_mask = INREG(R128_AMCGPIO_MASK);
+- }
++ save->dp_datatype = INREG(R128_DP_DATATYPE);
++ save->gen_reset_cntl = INREG(R128_GEN_RESET_CNTL);
++ save->clock_cntl_index = INREG(R128_CLOCK_CNTL_INDEX);
++ save->amcgpio_en_reg = INREG(R128_AMCGPIO_EN_REG);
++ save->amcgpio_mask = INREG(R128_AMCGPIO_MASK);
+
+ R128SaveMode(pScrn, save);
+-
+ }
+
+ /* Restore the original (text) mode. */
+@@ -2856,59 +2671,39 @@ static void R128Restore(ScrnInfoPtr pScrn)
+
+ R128Blank(pScrn);
+
+- if (!info->IsSecondary) {
+- OUTREG(R128_AMCGPIO_MASK, restore->amcgpio_mask);
+- OUTREG(R128_AMCGPIO_EN_REG, restore->amcgpio_en_reg);
+- OUTREG(R128_CLOCK_CNTL_INDEX, restore->clock_cntl_index);
+- OUTREG(R128_GEN_RESET_CNTL, restore->gen_reset_cntl);
+- OUTREG(R128_DP_DATATYPE, restore->dp_datatype);
+-
+- R128RestoreCommonRegisters(pScrn, restore);
+- if (pR128Ent->HasCRTC2) {
+- R128RestoreDDA2Registers(pScrn, restore);
+- R128RestoreCrtc2Registers(pScrn, restore);
+- R128RestorePLL2Registers(pScrn, restore);
+- }
+- R128RestoreDDARegisters(pScrn, restore);
+- R128RestoreCrtcRegisters(pScrn, restore);
+- R128RestorePLLRegisters(pScrn, restore);
+- R128RestoreDACRegisters(pScrn, restore);
+- R128RestoreRMXRegisters(pScrn, restore);
+- R128RestoreFPRegisters(pScrn, restore);
+- R128RestoreLVDSRegisters(pScrn, restore);
+- }
++ OUTREG(R128_AMCGPIO_MASK, restore->amcgpio_mask);
++ OUTREG(R128_AMCGPIO_EN_REG, restore->amcgpio_en_reg);
++ OUTREG(R128_CLOCK_CNTL_INDEX, restore->clock_cntl_index);
++ OUTREG(R128_GEN_RESET_CNTL, restore->gen_reset_cntl);
++ OUTREG(R128_DP_DATATYPE, restore->dp_datatype);
++
++ R128RestoreCommonRegisters(pScrn, restore);
++ if (pR128Ent->HasCRTC2) {
++ R128RestoreDDA2Registers(pScrn, restore);
++ R128RestoreCrtc2Registers(pScrn, restore);
++ R128RestorePLL2Registers(pScrn, restore);
++ }
++ R128RestoreDDARegisters(pScrn, restore);
++ R128RestoreCrtcRegisters(pScrn, restore);
++ R128RestorePLLRegisters(pScrn, restore);
++ R128RestoreDACRegisters(pScrn, restore);
++ R128RestoreRMXRegisters(pScrn, restore);
++ R128RestoreFPRegisters(pScrn, restore);
++ R128RestoreLVDSRegisters(pScrn, restore);
+
+ #ifdef WITH_VGAHW
+ if (info->VGAAccess) {
+ vgaHWPtr hwp = VGAHWPTR(pScrn);
+- if (!info->IsSecondary) {
+- vgaHWUnlock(hwp);
++ vgaHWUnlock(hwp);
+ # if defined(__powerpc__)
+- /* Temporary hack to prevent crashing on PowerMacs when trying to
+- * write VGA fonts, will find a better solution in the future
+- */
+- vgaHWRestore(pScrn, &hwp->SavedReg, VGA_SR_MODE );
++ /* Temporary hack to prevent crashing on PowerMacs when trying to
++ * write VGA fonts, will find a better solution in the future
++ */
++ vgaHWRestore(pScrn, &hwp->SavedReg, VGA_SR_MODE );
+ # else
+- vgaHWRestore(pScrn, &hwp->SavedReg, VGA_SR_MODE | VGA_SR_FONTS );
++ vgaHWRestore(pScrn, &hwp->SavedReg, VGA_SR_MODE | VGA_SR_FONTS );
+ # endif
+- vgaHWLock(hwp);
+- } else {
+- R128EntPtr pR128Ent = R128EntPriv(pScrn);
+- ScrnInfoPtr pScrn0 = pR128Ent->pPrimaryScrn;
+- R128InfoPtr info0 = R128PTR(pScrn0);
+- vgaHWPtr hwp0;
+-
+- if (info0->VGAAccess) {
+- hwp0 = VGAHWPTR(pScrn0);
+- vgaHWUnlock(hwp0);
+-#if defined(__powerpc__)
+- vgaHWRestore(pScrn0, &hwp0->SavedReg, VGA_SR_MODE);
+-#else
+- vgaHWRestore(pScrn0, &hwp0->SavedReg, VGA_SR_MODE | VGA_SR_FONTS );
+-#endif
+- vgaHWLock(hwp0);
+- }
+- }
++ vgaHWLock(hwp);
+ }
+ #endif
+
+@@ -3000,9 +2795,13 @@ Bool R128InitCrtc2Base(xf86CrtcPtr crtc, R128SavePtr save, int x, int y)
+ }
+
+ /* Define CRTC registers for requested video mode. */
+-Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+- DisplayModePtr mode, R128InfoPtr info)
++Bool R128InitCrtcRegisters(xf86CrtcPtr crtc, R128SavePtr save, DisplayModePtr mode)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ xf86OutputPtr output = R128FirstOutput(crtc);
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
+ int format;
+ int hsync_start;
+ int hsync_wid;
+@@ -3026,8 +2825,7 @@ Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ return FALSE;
+ }
+
+- if ((info->DisplayType == MT_DFP) ||
+- (info->DisplayType == MT_LCD))
++ if (r128_output->MonType == MT_LCD || r128_output->MonType == MT_DFP)
+ hsync_fudge = hsync_fudge_fp[format-1];
+ else
+ hsync_fudge = hsync_fudge_default[format-1];
+@@ -3045,21 +2843,16 @@ Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ ? R128_CRTC_CSYNC_EN
+ : 0));
+
+- if((info->DisplayType == MT_DFP) ||
+- (info->DisplayType == MT_LCD))
+- {
+- save->crtc_gen_cntl &= ~(R128_CRTC_DBL_SCAN_EN |
+- R128_CRTC_INTERLACE_EN);
+- }
++ if (r128_output->MonType == MT_LCD || r128_output->MonType == MT_DFP)
++ save->crtc_gen_cntl &= ~(R128_CRTC_DBL_SCAN_EN | R128_CRTC_INTERLACE_EN);
+
+ save->crtc_ext_cntl |= R128_VGA_ATI_LINEAR | R128_XCRT_CNT_EN;
+
+- if(info->isDFP && !info->isPro2)
+- {
+- if(info->PanelXRes < mode->CrtcHDisplay)
+- mode->HDisplay = mode->CrtcHDisplay = info->PanelXRes;
+- if(info->PanelYRes < mode->CrtcVDisplay)
+- mode->VDisplay = mode->CrtcVDisplay = info->PanelYRes;
++ if (info->isDFP && !info->isPro2) {
++ if (r128_output->PanelXRes < mode->CrtcHDisplay)
++ mode->HDisplay = mode->CrtcHDisplay = r128_output->PanelXRes;
++ if (r128_output->PanelYRes < mode->CrtcVDisplay)
++ mode->VDisplay = mode->CrtcVDisplay = r128_output->PanelYRes;
+ }
+
+ save->crtc_h_total_disp = ((((mode->CrtcHTotal / 8) - 1) & 0xffff)
+@@ -3118,9 +2911,11 @@ Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define CRTC2 registers for requested video mode. */
+-Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+- DisplayModePtr mode, R128InfoPtr info)
++Bool R128InitCrtc2Registers(xf86CrtcPtr crtc, R128SavePtr save, DisplayModePtr mode)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++
+ int format;
+ int hsync_start;
+ int hsync_wid;
+@@ -3314,9 +3109,10 @@ void R128InitLVDSRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr out
+ }
+
+ /* Define PLL registers for requested video mode. */
+-void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
++void R128InitPLLRegisters(xf86CrtcPtr crtc, R128SavePtr save,
+ R128PLLPtr pll, double dot_clock)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
+ unsigned long freq = dot_clock * 100;
+ struct {
+ int divider;
+@@ -3366,9 +3162,10 @@ void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define PLL2 registers for requested video mode. */
+-void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
++void R128InitPLL2Registers(xf86CrtcPtr crtc, R128SavePtr save,
+ R128PLLPtr pll, double dot_clock)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
+ unsigned long freq = dot_clock * 100;
+ struct {
+ int divider;
+@@ -3418,10 +3215,14 @@ void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define DDA registers for requested video mode. */
+-Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+- R128PLLPtr pll, R128InfoPtr info,
+- DisplayModePtr mode)
++Bool R128InitDDARegisters(xf86CrtcPtr crtc, R128SavePtr save,
++ R128PLLPtr pll, DisplayModePtr mode)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ xf86OutputPtr output = R128FirstOutput(crtc);
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
+ int DisplayFifoWidth = 128;
+ int DisplayFifoDepth = 32;
+ int XclkFreq;
+@@ -3437,10 +3238,10 @@ Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ VclkFreq = R128Div(pll->reference_freq * save->feedback_div,
+ pll->reference_div * save->post_div);
+
+- if(info->isDFP && !info->isPro2){
+- if(info->PanelXRes != mode->CrtcHDisplay)
+- VclkFreq = (VclkFreq * mode->CrtcHDisplay)/info->PanelXRes;
+- }
++ if (info->isDFP && !info->isPro2) {
++ if (r128_output->PanelXRes != mode->CrtcHDisplay)
++ VclkFreq = (VclkFreq * mode->CrtcHDisplay) / r128_output->PanelXRes;
++ }
+
+ XclksPerTransfer = R128Div(XclkFreq * DisplayFifoWidth,
+ VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
+@@ -3487,10 +3288,14 @@ Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
+ }
+
+ /* Define DDA2 registers for requested video mode. */
+-Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+- R128PLLPtr pll, R128InfoPtr info,
+- DisplayModePtr mode)
++Bool R128InitDDA2Registers(xf86CrtcPtr crtc, R128SavePtr save,
++ R128PLLPtr pll, DisplayModePtr mode)
+ {
++ ScrnInfoPtr pScrn = crtc->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ xf86OutputPtr output = R128FirstOutput(crtc);
++ R128OutputPrivatePtr r128_output = output->driver_private;
++
+ int DisplayFifoWidth = 128;
+ int DisplayFifoDepth = 32;
+ int XclkFreq;
+@@ -3506,10 +3311,10 @@ Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
+ VclkFreq = R128Div(pll->reference_freq * save->feedback_div_2,
+ pll->reference_div * save->post_div_2);
+
+- if(info->isDFP && !info->isPro2){
+- if(info->PanelXRes != mode->CrtcHDisplay)
+- VclkFreq = (VclkFreq * mode->CrtcHDisplay)/info->PanelXRes;
+- }
++ if (info->isDFP && !info->isPro2) {
++ if (r128_output->PanelXRes != mode->CrtcHDisplay)
++ VclkFreq = (VclkFreq * mode->CrtcHDisplay) / r128_output->PanelXRes;
++ }
+
+ XclksPerTransfer = R128Div(XclkFreq * DisplayFifoWidth,
+ VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
+@@ -3602,42 +3407,40 @@ Bool R128SwitchMode(SWITCH_MODE_ARGS_DECL)
+ return ret;
+ }
+
+-/* Used to disallow modes that are not supported by the hardware. */
+-ModeStatus R128ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
+- Bool verbose, int flags)
++ModeStatus R128DoValidMode(xf86OutputPtr output, DisplayModePtr mode, int flags)
+ {
+- SCRN_INFO_PTR(arg);
+- R128InfoPtr info = R128PTR(pScrn);
++ ScrnInfoPtr pScrn = output->scrn;
++ R128InfoPtr info = R128PTR(pScrn);
++ R128OutputPrivatePtr r128_output = output->driver_private;
+
+- if (info->BIOSDisplay == R128_BIOS_DISPLAY_CRT)
+- return MODE_OK;
++ if (r128_output->MonType == MT_CRT)
++ return MODE_OK;
+
+- if(info->isDFP) {
+- if(info->PanelXRes < mode->CrtcHDisplay ||
+- info->PanelYRes < mode->CrtcVDisplay)
++ if (info->isDFP) {
++ if (r128_output->PanelXRes < mode->CrtcHDisplay ||
++ r128_output->PanelYRes < mode->CrtcVDisplay)
+ return MODE_NOMODE;
+ else
+ return MODE_OK;
+ }
+
+- if (info->DisplayType == MT_LCD) {
++ if (r128_output->MonType == MT_LCD) {
+ if (mode->Flags & V_INTERLACE) return MODE_NO_INTERLACE;
+ if (mode->Flags & V_DBLSCAN) return MODE_NO_DBLESCAN;
+ }
+
+- if (info->DisplayType == MT_LCD &&
+- info->VBIOS) {
++ if (r128_output->MonType == MT_LCD && info->VBIOS) {
+ int i;
+- for (i = info->FPBIOSstart+64; R128_BIOS16(i) != 0; i += 2) {
++ for (i = info->FPBIOSstart + 64; R128_BIOS16(i) != 0; i += 2) {
+ int j = R128_BIOS16(i);
+
+ if (mode->CrtcHDisplay == R128_BIOS16(j) &&
+- mode->CrtcVDisplay == R128_BIOS16(j+2)) {
++ mode->CrtcVDisplay == R128_BIOS16(j + 2)) {
+ if ((flags & MODECHECK_FINAL) == MODECHECK_FINAL) {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "Modifying mode according to VBIOS: %ix%i [pclk %.1f MHz] for FP to: ",
+- mode->CrtcHDisplay,mode->CrtcVDisplay,
+- (float)mode->Clock/1000);
++ mode->CrtcHDisplay, mode->CrtcVDisplay,
++ (float)mode->Clock / 1000);
+
+ /* Assume we are using expanded mode */
+ if (R128_BIOS16(j+5)) j = R128_BIOS16(j+5);
+@@ -3646,25 +3449,25 @@ ModeStatus R128ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
+ mode->Clock = (uint32_t)R128_BIOS16(j) * 10;
+
+ mode->HDisplay = mode->CrtcHDisplay =
+- ((R128_BIOS16(j+10) & 0x01ff)+1)*8;
++ ((R128_BIOS16(j + 10) & 0x01ff) + 1) * 8;
+ mode->HSyncStart = mode->CrtcHSyncStart =
+- ((R128_BIOS16(j+12) & 0x01ff)+1)*8;
++ ((R128_BIOS16(j + 12) & 0x01ff) + 1) * 8;
+ mode->HSyncEnd = mode->CrtcHSyncEnd =
+- mode->CrtcHSyncStart + (R128_BIOS8(j+14) & 0x1f);
++ mode->CrtcHSyncStart + (R128_BIOS8(j + 14) & 0x1f);
+ mode->HTotal = mode->CrtcHTotal =
+- ((R128_BIOS16(j+8) & 0x01ff)+1)*8;
++ ((R128_BIOS16(j + 8) & 0x01ff) + 1) * 8;
+
+ mode->VDisplay = mode->CrtcVDisplay =
+- (R128_BIOS16(j+17) & 0x07ff)+1;
++ (R128_BIOS16(j + 17) & 0x07ff) + 1;
+ mode->VSyncStart = mode->CrtcVSyncStart =
+- (R128_BIOS16(j+19) & 0x07ff)+1;
++ (R128_BIOS16(j + 19) & 0x07ff) + 1;
+ mode->VSyncEnd = mode->CrtcVSyncEnd =
+- mode->CrtcVSyncStart + ((R128_BIOS16(j+19) >> 11) & 0x1f);
++ mode->CrtcVSyncStart + ((R128_BIOS16(j + 19) >> 11) & 0x1f);
+ mode->VTotal = mode->CrtcVTotal =
+- (R128_BIOS16(j+15) & 0x07ff)+1;
++ (R128_BIOS16(j + 15) & 0x07ff) + 1;
+ xf86ErrorF("%ix%i [pclk %.1f MHz]\n",
+ mode->CrtcHDisplay,mode->CrtcVDisplay,
+- (float)mode->Clock/1000);
++ (float)mode->Clock/ 1000);
+ }
+ return MODE_OK;
+ }
+@@ -3680,6 +3483,17 @@ ModeStatus R128ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
+ return MODE_OK;
+ }
+
++/* Used to disallow modes that are not supported by the hardware. */
++ModeStatus R128ValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
++ Bool verbose, int flags)
++{
++ SCRN_INFO_PTR(arg);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
++ xf86OutputPtr output = R128FirstOutput(pR128Ent->pCrtc[0]);
++
++ return R128DoValidMode(output, mode, flags);
++}
++
+ /* Adjust viewport into virtual desktop such that (0,0) in viewport space
+ is (x,y) in virtual space. */
+ void R128AdjustFrame(ADJUST_FRAME_ARGS_DECL)
+@@ -3706,14 +3520,7 @@ void R128AdjustFrame(ADJUST_FRAME_ARGS_DECL)
+ if (info->CurrentLayout.pixel_code == 24)
+ Base += 8 * (Base % 3); /* Must be multiple of 8 and 3 */
+
+- if(info->IsSecondary)
+- {
+- Base += pScrn->fbOffset;
+- OUTREG(R128_CRTC2_OFFSET, Base);
+- }
+- else
+ OUTREG(R128_CRTC_OFFSET, Base);
+-
+ }
+
+ /* Called when VT switching back to the X server. Reinitialize the video
+diff --git a/src/r128_output.c b/src/r128_output.c
+index 757ef9b..8ef6d45 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -181,7 +181,7 @@ void R128DPMSSetOn(xf86OutputPtr output)
+ switch(MonType) {
+ case MT_LCD:
+ OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_BLON, ~R128_LVDS_BLON);
+- usleep(info->PanelPwrDly * 1000);
++ usleep(r128_output->PanelPwrDly * 1000);
+ OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_ON, ~R128_LVDS_ON);
+ save->lvds_gen_cntl |= (R128_LVDS_ON | R128_LVDS_BLON);
+ break;
+@@ -307,7 +307,7 @@ DisplayModePtr R128ProbeOutputModes(xf86OutputPtr output)
+ for (mode = modes; mode != NULL; mode = mode->next) {
+ xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
+ if (mode->status == MODE_OK)
+- mode->status = R128ValidMode(XF86_SCRN_ARG(pScrn), mode, TRUE, MODECHECK_FINAL);
++ mode->status = R128DoValidMode(output, mode, MODECHECK_FINAL);
+ }
+
+ xf86ValidateModesUserConfig(pScrn, modes);
+@@ -457,10 +457,10 @@ Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+ }
+ r128_output->ddc_i2c = i2c;
+ R128I2CInit(output, &r128_output->pI2CBus, output->name);
+- } else if (otypes[i] == OUTPUT_LVDS) {
+- r128_output->PanelXRes = info->PanelXRes;
+- r128_output->PanelYRes = info->PanelYRes;
+ }
++
++ if (otypes[i] != OUTPUT_VGA)
++ R128GetPanelInfoFromBIOS(output);
+ }
+
+ return TRUE;
+diff --git a/src/r128_probe.c b/src/r128_probe.c
+index 348d15b..9771d52 100644
+--- a/src/r128_probe.c
++++ b/src/r128_probe.c
+@@ -288,7 +288,6 @@ r128_get_scrninfo(int entity_num)
+ R128EntPtr pR128Ent;
+ pPriv->ptr = xnfcalloc(sizeof(R128EntRec), 1);
+ pR128Ent = pPriv->ptr;
+- pR128Ent->BypassSecondary = FALSE;
+ pR128Ent->HasSecondary = FALSE;
+ pR128Ent->IsSecondaryRestored = FALSE;
+ }
+diff --git a/src/r128_probe.h b/src/r128_probe.h
+index fef210d..0b54d21 100644
+--- a/src/r128_probe.h
++++ b/src/r128_probe.h
+@@ -142,6 +142,7 @@ typedef struct _R128OutputPrivateRec {
+ R128I2CBusRec ddc_i2c;
+ int PanelXRes;
+ int PanelYRes;
++ int PanelPwrDly;
+ } R128OutputPrivateRec, *R128OutputPrivatePtr;
+
+ #define R128_MAX_CRTC 2
+@@ -151,7 +152,6 @@ typedef struct
+ {
+ Bool HasSecondary;
+ Bool HasCRTC2;
+- Bool BypassSecondary;
+ /*These two registers are used to make sure the CRTC2 is
+ retored before CRTC_EXT, otherwise it could lead to blank screen.*/
+ Bool IsSecondaryRestored;
+@@ -160,7 +160,7 @@ typedef struct
+ xf86CrtcPtr pCrtc[R128_MAX_CRTC];
+ R128CrtcPrivatePtr Controller[R128_MAX_CRTC];
+
+- ScrnInfoPtr pSecondaryScrn;
++ ScrnInfoPtr pSecondaryScrn;
+ ScrnInfoPtr pPrimaryScrn;
+ } R128EntRec, *R128EntPtr;
+
+diff --git a/src/r128_video.c b/src/r128_video.c
+index b0059b5..dc1f25b 100644
+--- a/src/r128_video.c
++++ b/src/r128_video.c
+@@ -661,8 +661,12 @@ R128DisplayVideo422(
+ short drw_w, short drw_h
+ ){
+ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
++ xf86OutputPtr output = R128FirstOutput(pR128Ent->pCrtc[0]);
++ R128OutputPrivatePtr r128_output = output->driver_private;
+ unsigned char *R128MMIO = info->MMIO;
+ R128PortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
++
+ int v_inc, h_inc, step_by, tmp, v_inc_shift;
+ int p1_h_accum_init, p23_h_accum_init;
+ int p1_v_accum_init;
+@@ -678,7 +682,7 @@ R128DisplayVideo422(
+
+ rmx_active = INREG(R128_FP_VERT_STRETCH) & R128_VERT_STRETCH_ENABLE;
+ if (rmx_active) {
+- v_inc = ((src_h * pScrn->currentMode->CrtcVDisplay / info->PanelYRes) << v_inc_shift) / drw_h;
++ v_inc = ((src_h * pScrn->currentMode->CrtcVDisplay / r128_output->PanelYRes) << v_inc_shift) / drw_h;
+ } else {
+ v_inc = (src_h << v_inc_shift) / drw_h;
+ }
+@@ -747,6 +751,9 @@ R128DisplayVideo420(
+ short drw_w, short drw_h
+ ){
+ R128InfoPtr info = R128PTR(pScrn);
++ R128EntPtr pR128Ent = R128EntPriv(pScrn);
++ xf86OutputPtr output = R128FirstOutput(pR128Ent->pCrtc[0]);
++ R128OutputPrivatePtr r128_output = output->driver_private;
+ unsigned char *R128MMIO = info->MMIO;
+ R128PortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
+ int v_inc, h_inc, step_by, tmp, leftUV, v_inc_shift;
+@@ -762,7 +769,7 @@ R128DisplayVideo420(
+
+ rmx_active = INREG(R128_FP_VERT_STRETCH) & R128_VERT_STRETCH_ENABLE;
+ if (rmx_active) {
+- v_inc = ((src_h * pScrn->currentMode->CrtcVDisplay / info->PanelYRes) << v_inc_shift) / drw_h;
++ v_inc = ((src_h * pScrn->currentMode->CrtcVDisplay / r128_output->PanelYRes) << v_inc_shift) / drw_h;
+ } else {
+ v_inc = (src_h << v_inc_shift) / drw_h;
+ }
+--
+2.2.2
+
+
+From d49c3431e92a6120b054959ce6910e8decf61c67 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Fri, 25 Jul 2014 13:39:08 -0700
+Subject: Remove custom DGA code
+
+I have yet to see a use for the DGA code included in the driver.
+According to radeon commits, it should be safe to replace it with DiDGA.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
+---
+ src/Makefile.am | 2 +-
+ src/r128.h | 13 --
+ src/r128_accel.c | 4 +-
+ src/r128_dga.c | 408 ------------------------------------------------------
+ src/r128_driver.c | 7 +-
+ 5 files changed, 6 insertions(+), 428 deletions(-)
+ delete mode 100644 src/r128_dga.c
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index e4618ea..05fbe6c 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -40,7 +40,7 @@ r128_drv_la_LTLIBRARIES = r128_drv.la
+ r128_drv_la_LDFLAGS = -module -avoid-version
+ r128_drv_ladir = @moduledir@/drivers
+ r128_drv_la_SOURCES = \
+- r128_accel.c r128_cursor.c r128_dga.c r128_driver.c \
++ r128_accel.c r128_cursor.c r128_driver.c \
+ r128_video.c r128_misc.c r128_crtc.c r128_output.c r128_probe.c \
+ $(R128_EXA_SRCS) $(R128_DRI_SRCS)
+
+diff --git a/src/r128.h b/src/r128.h
+index 3b1e631..19124bf 100644
+--- a/src/r128.h
++++ b/src/r128.h
+@@ -343,12 +343,6 @@ typedef struct {
+ struct r128_2d_state state_2d;
+ #endif
+
+- /*
+- * XAAForceTransBlit is used to change the behavior of the XAA
+- * SetupForScreenToScreenCopy function, to make it DGA-friendly.
+- */
+- Bool XAAForceTransBlit;
+-
+ int fifo_slots; /* Free slots in the FIFO (64 max) */
+ int pix24bpp; /* Depth of pixmap for 24bpp framebuffer */
+ Bool dac6bits; /* Use 6 bit DAC? */
+@@ -381,12 +375,6 @@ typedef struct {
+ int scanline_direct;
+ int scanline_bpp; /* Only used for ImageWrite */
+
+- DGAModePtr DGAModes;
+- int numDGAModes;
+- Bool DGAactive;
+- int DGAViewportStatus;
+- DGAFunctionRec DGAFuncs;
+-
+ R128FBLayout CurrentLayout;
+ #ifdef R128DRI
+ Bool directRenderingEnabled;
+@@ -525,7 +513,6 @@ extern void R128WaitForVerticalSync(ScrnInfoPtr pScrn);
+ extern Bool R128AccelInit(ScreenPtr pScreen);
+ extern void R128EngineInit(ScrnInfoPtr pScrn);
+ extern Bool R128CursorInit(ScreenPtr pScreen);
+-extern Bool R128DGAInit(ScreenPtr pScreen);
+
+ extern int R128MinBits(int val);
+ extern xf86OutputPtr R128FirstOutput(xf86CrtcPtr crtc);
+diff --git a/src/r128_accel.c b/src/r128_accel.c
+index fa58327..c88e8f9 100644
+--- a/src/r128_accel.c
++++ b/src/r128_accel.c
+@@ -590,7 +590,7 @@ static void R128SetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+ ? R128_DST_Y_TOP_TO_BOTTOM
+ : 0)));
+
+- if ((trans_color != -1) || (info->XAAForceTransBlit == TRUE)) {
++ if (trans_color != -1) {
+ /* Set up for transparency */
+ R128WaitForFifo(pScrn, 3);
+ OUTREG(R128_CLR_CMP_CLR_SRC, trans_color);
+@@ -1182,7 +1182,7 @@ static void R128CCESetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+
+ ADVANCE_RING();
+
+- if ((trans_color != -1) || (info->XAAForceTransBlit == TRUE)) {
++ if (trans_color != -1) {
+ BEGIN_RING( 6 );
+
+ OUT_RING_REG( R128_CLR_CMP_CLR_SRC, trans_color );
+diff --git a/src/r128_dga.c b/src/r128_dga.c
+deleted file mode 100644
+index bb4a1a6..0000000
+--- a/src/r128_dga.c
++++ /dev/null
+@@ -1,408 +0,0 @@
+-/*
+- * Authors:
+- * Ove Kåven <ovek@transgaming.com>,
+- * borrowing some code from the Chips and MGA drivers.
+- */
+-
+-#ifdef HAVE_CONFIG_H
+-#include "config.h"
+-#endif
+-
+-#include <string.h>
+-
+- /* Driver data structures */
+-#include "r128.h"
+-#include "r128_probe.h"
+-
+- /* X and server generic header files */
+-#include "xf86.h"
+-
+- /* DGA support */
+-#include "dgaproc.h"
+-
+-#ifdef R128DRI
+-#include "r128_common.h"
+-#endif
+-
+-static Bool R128_OpenFramebuffer(ScrnInfoPtr, char **, unsigned char **,
+- int *, int *, int *);
+-static Bool R128_SetMode(ScrnInfoPtr, DGAModePtr);
+-static int R128_GetViewport(ScrnInfoPtr);
+-static void R128_SetViewport(ScrnInfoPtr, int, int, int);
+-#ifdef HAVE_XAA_H
+-static void R128_FillRect(ScrnInfoPtr, int, int, int, int, unsigned long);
+-static void R128_BlitRect(ScrnInfoPtr, int, int, int, int, int, int);
+-static void R128_BlitTransRect(ScrnInfoPtr, int, int, int, int, int, int,
+- unsigned long);
+-#endif
+-
+-static DGAModePtr R128SetupDGAMode(ScrnInfoPtr pScrn,
+- DGAModePtr modes,
+- int *num,
+- int bitsPerPixel,
+- int depth,
+- Bool pixmap,
+- int secondPitch,
+- unsigned long red,
+- unsigned long green,
+- unsigned long blue,
+- short visualClass)
+-{
+- R128InfoPtr info = R128PTR(pScrn);
+- DGAModePtr newmodes = NULL;
+- DGAModePtr currentMode;
+- DisplayModePtr pMode;
+- DisplayModePtr firstMode;
+- unsigned int size;
+- int pitch;
+- int Bpp = bitsPerPixel >> 3;
+-
+-SECOND_PASS:
+-
+- pMode = firstMode = pScrn->modes;
+-
+- while (1) {
+- pitch = pScrn->displayWidth;
+- size = pitch * Bpp * pMode->VDisplay;
+-
+- if ((!secondPitch || (pitch != secondPitch)) &&
+- (size <= info->FbMapSize)) {
+-
+- if (secondPitch)
+- pitch = secondPitch;
+-
+- if (!(newmodes = realloc(modes, (*num + 1) * sizeof(DGAModeRec))))
+- break;
+-
+- modes = newmodes;
+- currentMode = modes + *num;
+-
+- currentMode->mode = pMode;
+- currentMode->flags = DGA_CONCURRENT_ACCESS;
+-
+- if (pixmap)
+- currentMode->flags |= DGA_PIXMAP_AVAILABLE;
+-
+-#ifdef HAVE_XAA_H
+- if (info->accel) {
+- if (info->accel->SetupForSolidFill &&
+- info->accel->SubsequentSolidFillRect)
+- currentMode->flags |= DGA_FILL_RECT;
+- if (info->accel->SetupForScreenToScreenCopy &&
+- info->accel->SubsequentScreenToScreenCopy)
+- currentMode->flags |= DGA_BLIT_RECT | DGA_BLIT_RECT_TRANS;
+- if (currentMode->flags &
+- (DGA_PIXMAP_AVAILABLE | DGA_FILL_RECT |
+- DGA_BLIT_RECT | DGA_BLIT_RECT_TRANS))
+- currentMode->flags &= ~DGA_CONCURRENT_ACCESS;
+- }
+-#endif
+- if (pMode->Flags & V_DBLSCAN)
+- currentMode->flags |= DGA_DOUBLESCAN;
+- if (pMode->Flags & V_INTERLACE)
+- currentMode->flags |= DGA_INTERLACED;
+-
+- currentMode->byteOrder = pScrn->imageByteOrder;
+- currentMode->depth = depth;
+- currentMode->bitsPerPixel = bitsPerPixel;
+- currentMode->red_mask = red;
+- currentMode->green_mask = green;
+- currentMode->blue_mask = blue;
+- currentMode->visualClass = visualClass;
+- currentMode->viewportWidth = pMode->HDisplay;
+- currentMode->viewportHeight = pMode->VDisplay;
+- currentMode->xViewportStep = 8;
+- currentMode->yViewportStep = 1;
+- currentMode->viewportFlags = DGA_FLIP_RETRACE;
+- currentMode->offset = 0;
+- currentMode->address = (unsigned char*)info->LinearAddr;
+- currentMode->bytesPerScanline = pitch * Bpp;
+- currentMode->imageWidth = pitch;
+- currentMode->imageHeight = (info->FbMapSize
+- / currentMode->bytesPerScanline);
+- currentMode->pixmapWidth = currentMode->imageWidth;
+- currentMode->pixmapHeight = currentMode->imageHeight;
+- currentMode->maxViewportX = (currentMode->imageWidth
+- - currentMode->viewportWidth);
+- /* this might need to get clamped to some maximum */
+- currentMode->maxViewportY = (currentMode->imageHeight
+- - currentMode->viewportHeight);
+- (*num)++;
+- }
+-
+- pMode = pMode->next;
+- if (pMode == firstMode)
+- break;
+- }
+-
+- if (secondPitch) {
+- secondPitch = 0;
+- goto SECOND_PASS;
+- }
+-
+- return modes;
+-}
+-
+-Bool
+-R128DGAInit(ScreenPtr pScreen)
+-{
+- ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+- R128InfoPtr info = R128PTR(pScrn);
+- DGAModePtr modes = NULL;
+- int num = 0;
+-
+- /* 8 */
+- modes = R128SetupDGAMode (pScrn, modes, &num, 8, 8,
+- (pScrn->bitsPerPixel == 8),
+- (pScrn->bitsPerPixel != 8) ? 0 : pScrn->displayWidth,
+- 0, 0, 0, PseudoColor);
+-
+- /* 15 */
+- modes = R128SetupDGAMode (pScrn, modes, &num, 16, 15,
+- (pScrn->bitsPerPixel == 16),
+- (pScrn->depth != 15) ? 0 : pScrn->displayWidth,
+- 0x7c00, 0x03e0, 0x001f, TrueColor);
+-
+- modes = R128SetupDGAMode (pScrn, modes, &num, 16, 15,
+- (pScrn->bitsPerPixel == 16),
+- (pScrn->depth != 15) ? 0 : pScrn->displayWidth,
+- 0x7c00, 0x03e0, 0x001f, DirectColor);
+-
+- /* 16 */
+- modes = R128SetupDGAMode (pScrn, modes, &num, 16, 16,
+- (pScrn->bitsPerPixel == 16),
+- (pScrn->depth != 16) ? 0 : pScrn->displayWidth,
+- 0xf800, 0x07e0, 0x001f, TrueColor);
+-
+- modes = R128SetupDGAMode (pScrn, modes, &num, 16, 16,
+- (pScrn->bitsPerPixel == 16),
+- (pScrn->depth != 16) ? 0 : pScrn->displayWidth,
+- 0xf800, 0x07e0, 0x001f, DirectColor);
+-
+- /* 24 */
+- modes = R128SetupDGAMode (pScrn, modes, &num, 24, 24,
+- (pScrn->bitsPerPixel == 24),
+- (pScrn->bitsPerPixel != 24) ? 0 : pScrn->displayWidth,
+- 0xff0000, 0x00ff00, 0x0000ff, TrueColor);
+-
+- modes = R128SetupDGAMode (pScrn, modes, &num, 24, 24,
+- (pScrn->bitsPerPixel == 24),
+- (pScrn->bitsPerPixel != 24) ? 0 : pScrn->displayWidth,
+- 0xff0000, 0x00ff00, 0x0000ff, DirectColor);
+-
+- /* 32 */
+- modes = R128SetupDGAMode (pScrn, modes, &num, 32, 24,
+- (pScrn->bitsPerPixel == 32),
+- (pScrn->bitsPerPixel != 32) ? 0 : pScrn->displayWidth,
+- 0xff0000, 0x00ff00, 0x0000ff, TrueColor);
+-
+- modes = R128SetupDGAMode (pScrn, modes, &num, 32, 24,
+- (pScrn->bitsPerPixel == 32),
+- (pScrn->bitsPerPixel != 32) ? 0 : pScrn->displayWidth,
+- 0xff0000, 0x00ff00, 0x0000ff, DirectColor);
+-
+- info->numDGAModes = num;
+- info->DGAModes = modes;
+-
+- info->DGAFuncs.OpenFramebuffer = R128_OpenFramebuffer;
+- info->DGAFuncs.CloseFramebuffer = NULL;
+- info->DGAFuncs.SetMode = R128_SetMode;
+- info->DGAFuncs.SetViewport = R128_SetViewport;
+- info->DGAFuncs.GetViewport = R128_GetViewport;
+-
+- info->DGAFuncs.Sync = NULL;
+- info->DGAFuncs.FillRect = NULL;
+- info->DGAFuncs.BlitRect = NULL;
+- info->DGAFuncs.BlitTransRect = NULL;
+-
+-#ifdef HAVE_XAA_H
+- if (info->accel) {
+- info->DGAFuncs.Sync = info->accel->Sync;
+- if (info->accel->SetupForSolidFill &&
+- info->accel->SubsequentSolidFillRect)
+- info->DGAFuncs.FillRect = R128_FillRect;
+- if (info->accel->SetupForScreenToScreenCopy &&
+- info->accel->SubsequentScreenToScreenCopy) {
+- info->DGAFuncs.BlitRect = R128_BlitRect;
+- info->DGAFuncs.BlitTransRect = R128_BlitTransRect;
+- }
+- }
+-#endif
+-
+- return DGAInit(pScreen, &(info->DGAFuncs), modes, num);
+-}
+-
+-
+-static Bool
+-R128_SetMode(
+- ScrnInfoPtr pScrn,
+- DGAModePtr pMode
+-){
+- static R128FBLayout SavedLayouts[MAXSCREENS];
+- int indx = pScrn->pScreen->myNum;
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- if(!pMode) { /* restore the original mode */
+- /* put the ScreenParameters back */
+- if(info->DGAactive)
+- memcpy(&info->CurrentLayout, &SavedLayouts[indx], sizeof(R128FBLayout));
+-
+- pScrn->currentMode = info->CurrentLayout.mode;
+-
+- pScrn->SwitchMode(SWITCH_MODE_ARGS(pScrn, pScrn->currentMode));
+-#ifdef R128DRI
+- if (info->directRenderingEnabled) {
+- R128CCE_STOP(pScrn, info);
+- }
+-#endif
+- if (info->accelOn)
+- R128EngineInit(pScrn);
+-#ifdef R128DRI
+- if (info->directRenderingEnabled) {
+- R128CCE_START(pScrn, info);
+- }
+-#endif
+- pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, 0, 0));
+- info->DGAactive = FALSE;
+- } else {
+- if(!info->DGAactive) { /* save the old parameters */
+- memcpy(&SavedLayouts[indx], &info->CurrentLayout, sizeof(R128FBLayout));
+- info->DGAactive = TRUE;
+- }
+-
+- info->CurrentLayout.bitsPerPixel = pMode->bitsPerPixel;
+- info->CurrentLayout.depth = pMode->depth;
+- info->CurrentLayout.displayWidth = pMode->bytesPerScanline /
+- (pMode->bitsPerPixel >> 3);
+- info->CurrentLayout.pixel_bytes = pMode->bitsPerPixel / 8;
+- info->CurrentLayout.pixel_code = (pMode->bitsPerPixel != 16
+- ? pMode->bitsPerPixel
+- : pMode->depth);
+- /* R128ModeInit() will set the mode field */
+-
+- pScrn->SwitchMode(SWITCH_MODE_ARGS(pScrn, pMode->mode));
+-
+-#ifdef R128DRI
+- if (info->directRenderingEnabled) {
+- R128CCE_STOP(pScrn, info);
+- }
+-#endif
+- if (info->accelOn)
+- R128EngineInit(pScrn);
+-#ifdef R128DRI
+- if (info->directRenderingEnabled) {
+- R128CCE_START(pScrn, info);
+- }
+-#endif
+- }
+-
+- return TRUE;
+-}
+-
+-
+-
+-static int
+-R128_GetViewport(
+- ScrnInfoPtr pScrn
+-){
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- return info->DGAViewportStatus;
+-}
+-
+-
+-static void
+-R128_SetViewport(
+- ScrnInfoPtr pScrn,
+- int x, int y,
+- int flags
+-){
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, x, y));
+- info->DGAViewportStatus = 0; /* FIXME */
+-}
+-
+-#ifdef HAVE_XAA_H
+-static void
+-R128_FillRect (
+- ScrnInfoPtr pScrn,
+- int x, int y, int w, int h,
+- unsigned long color
+-){
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- (*info->accel->SetupForSolidFill)(pScrn, color, GXcopy, (uint32_t)(~0));
+- (*info->accel->SubsequentSolidFillRect)(pScrn, x, y, w, h);
+-
+- if (pScrn->bitsPerPixel == info->CurrentLayout.bitsPerPixel)
+- SET_SYNC_FLAG(info->accel);
+-}
+-
+-static void
+-R128_BlitRect(
+- ScrnInfoPtr pScrn,
+- int srcx, int srcy,
+- int w, int h,
+- int dstx, int dsty
+-){
+- R128InfoPtr info = R128PTR(pScrn);
+- int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+- int ydir = (srcy < dsty) ? -1 : 1;
+-
+- (*info->accel->SetupForScreenToScreenCopy)(
+- pScrn, xdir, ydir, GXcopy, (uint32_t)(~0), -1);
+- (*info->accel->SubsequentScreenToScreenCopy)(
+- pScrn, srcx, srcy, dstx, dsty, w, h);
+-
+- if (pScrn->bitsPerPixel == info->CurrentLayout.bitsPerPixel)
+- SET_SYNC_FLAG(info->accel);
+-}
+-
+-
+-static void
+-R128_BlitTransRect(
+- ScrnInfoPtr pScrn,
+- int srcx, int srcy,
+- int w, int h,
+- int dstx, int dsty,
+- unsigned long color
+-){
+- R128InfoPtr info = R128PTR(pScrn);
+- int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+- int ydir = (srcy < dsty) ? -1 : 1;
+-
+- info->XAAForceTransBlit = TRUE;
+-
+- (*info->accel->SetupForScreenToScreenCopy)(
+- pScrn, xdir, ydir, GXcopy, (uint32_t)(~0), color);
+-
+- info->XAAForceTransBlit = FALSE;
+-
+- (*info->accel->SubsequentScreenToScreenCopy)(
+- pScrn, srcx, srcy, dstx, dsty, w, h);
+-
+- if (pScrn->bitsPerPixel == info->CurrentLayout.bitsPerPixel)
+- SET_SYNC_FLAG(info->accel);
+-}
+-#endif
+-
+-static Bool
+-R128_OpenFramebuffer(
+- ScrnInfoPtr pScrn,
+- char **name,
+- unsigned char **mem,
+- int *size,
+- int *offset,
+- int *flags
+-){
+- R128InfoPtr info = R128PTR(pScrn);
+-
+- *name = NULL; /* no special device */
+- *mem = (unsigned char*)info->LinearAddr;
+- *size = info->FbMapSize;
+- *offset = 0;
+- *flags = /* DGA_NEED_ROOT */ 0; /* don't need root, just /dev/mem access */
+-
+- return TRUE;
+-}
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 0a8d802..2cbfc81 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -2044,7 +2044,9 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
+ //pScrn->AdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
+
+ /* DGA setup */
+- R128DGAInit(pScreen);
++#ifdef XFreeXDGA
++ xf86DiDGAInit(pScreen, info->LinearAddr + pScrn->fbOffset);
++#endif
+
+ /* Backing store setup */
+ xf86SetBackingStore(pScreen);
+@@ -3629,9 +3631,6 @@ static Bool R128CloseScreen(CLOSE_SCREEN_ARGS_DECL)
+ if (info->scratch_save) free(info->scratch_save);
+ info->scratch_save = NULL;
+
+- if (info->DGAModes) free(info->DGAModes);
+- info->DGAModes = NULL;
+-
+ if (info->adaptor) {
+ free(info->adaptor->pPortPrivates[0].ptr);
+ xf86XVFreeVideoAdaptorRec(info->adaptor);
+--
+2.2.2
+
+
+From 0519b7b3aac61dfd57cbf3bb0da561ca9bd079cb Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Sat, 23 Aug 2014 01:13:18 -0400
+Subject: Improve panel code
+
+Since the driver uses PanelXRes and PanelYRes to calculate stretch
+ratios, it should try harder to set them. For LVDS, we need to move the
+xorg.conf check so that it executes before the BIOS check. For DVI, we
+should read them from the mode that the X server has identified as being
+the native one. Even then, PanelXRes and PanelYRes are not guaranteed to
+be positive, so the driver should verify this before dividing by them.
+
+Another problem with the old panel code was that PanelPwrDly had no sane
+default. It was also missing the check for Rage Pro 2 which lacks RMX.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_driver.c | 27 +++++++--------------------
+ src/r128_output.c | 13 ++++++++++---
+ src/r128_video.c | 10 ++++++----
+ 3 files changed, 23 insertions(+), 27 deletions(-)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 2cbfc81..98b0644 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -479,6 +479,10 @@ void R128GetPanelInfoFromBIOS(xf86OutputPtr output)
+ int FPHeader = 0;
+ int i;
+
++ r128_output->PanelPwrDly = 200;
++ xf86GetOptValInteger(info->Options, OPTION_PANEL_WIDTH, &(r128_output->PanelXRes));
++ xf86GetOptValInteger(info->Options, OPTION_PANEL_HEIGHT, &(r128_output->PanelYRes));
++
+ if (!info->VBIOS) return;
+ info->FPBIOSstart = 0;
+
+@@ -511,8 +515,6 @@ void R128GetPanelInfoFromBIOS(xf86OutputPtr output)
+ }
+
+ if (!info->FPBIOSstart) return;
+- xf86GetOptValInteger(info->Options, OPTION_PANEL_WIDTH, &(r128_output->PanelXRes));
+- xf86GetOptValInteger(info->Options, OPTION_PANEL_HEIGHT, &(r128_output->PanelYRes));
+
+ if (!r128_output->PanelXRes)
+ r128_output->PanelXRes = R128_BIOS16(info->FPBIOSstart + 25);
+@@ -2850,13 +2852,6 @@ Bool R128InitCrtcRegisters(xf86CrtcPtr crtc, R128SavePtr save, DisplayModePtr mo
+
+ save->crtc_ext_cntl |= R128_VGA_ATI_LINEAR | R128_XCRT_CNT_EN;
+
+- if (info->isDFP && !info->isPro2) {
+- if (r128_output->PanelXRes < mode->CrtcHDisplay)
+- mode->HDisplay = mode->CrtcHDisplay = r128_output->PanelXRes;
+- if (r128_output->PanelYRes < mode->CrtcVDisplay)
+- mode->VDisplay = mode->CrtcVDisplay = r128_output->PanelYRes;
+- }
+-
+ save->crtc_h_total_disp = ((((mode->CrtcHTotal / 8) - 1) & 0xffff)
+ | (((mode->CrtcHDisplay / 8) - 1) << 16));
+
+@@ -3240,7 +3235,7 @@ Bool R128InitDDARegisters(xf86CrtcPtr crtc, R128SavePtr save,
+ VclkFreq = R128Div(pll->reference_freq * save->feedback_div,
+ pll->reference_div * save->post_div);
+
+- if (info->isDFP && !info->isPro2) {
++ if (info->isDFP && !info->isPro2 && r128_output->PanelXRes > 0) {
+ if (r128_output->PanelXRes != mode->CrtcHDisplay)
+ VclkFreq = (VclkFreq * mode->CrtcHDisplay) / r128_output->PanelXRes;
+ }
+@@ -3313,7 +3308,7 @@ Bool R128InitDDA2Registers(xf86CrtcPtr crtc, R128SavePtr save,
+ VclkFreq = R128Div(pll->reference_freq * save->feedback_div_2,
+ pll->reference_div * save->post_div_2);
+
+- if (info->isDFP && !info->isPro2) {
++ if (info->isDFP && !info->isPro2 && r128_output->PanelXRes > 0) {
+ if (r128_output->PanelXRes != mode->CrtcHDisplay)
+ VclkFreq = (VclkFreq * mode->CrtcHDisplay) / r128_output->PanelXRes;
+ }
+@@ -3418,15 +3413,7 @@ ModeStatus R128DoValidMode(xf86OutputPtr output, DisplayModePtr mode, int flags)
+ if (r128_output->MonType == MT_CRT)
+ return MODE_OK;
+
+- if (info->isDFP) {
+- if (r128_output->PanelXRes < mode->CrtcHDisplay ||
+- r128_output->PanelYRes < mode->CrtcVDisplay)
+- return MODE_NOMODE;
+- else
+- return MODE_OK;
+- }
+-
+- if (r128_output->MonType == MT_LCD) {
++ if (r128_output->MonType == MT_DFP || r128_output->MonType == MT_LCD) {
+ if (mode->Flags & V_INTERLACE) return MODE_NO_INTERLACE;
+ if (mode->Flags & V_DBLSCAN) return MODE_NO_DBLESCAN;
+ }
+diff --git a/src/r128_output.c b/src/r128_output.c
+index 8ef6d45..6c35e78 100644
+--- a/src/r128_output.c
++++ b/src/r128_output.c
+@@ -87,7 +87,7 @@ static void r128_mode_set(xf86OutputPtr output, DisplayModePtr mode, DisplayMode
+ xf86CrtcPtr crtc = output->crtc;
+ R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+
+- if (r128_crtc->crtc_id == 0)
++ if (r128_crtc->crtc_id == 0 && !info->isPro2)
+ R128InitRMXRegisters(&info->SavedReg, &info->ModeReg, output, adjusted_mode);
+
+ if (r128_output->MonType == MT_DFP)
+@@ -97,7 +97,7 @@ static void r128_mode_set(xf86OutputPtr output, DisplayModePtr mode, DisplayMode
+ else if (r128_output->MonType == MT_CRT)
+ R128InitDACRegisters(&info->SavedReg, &info->ModeReg, output);
+
+- if (r128_crtc->crtc_id == 0)
++ if (r128_crtc->crtc_id == 0 && !info->isPro2)
+ R128RestoreRMXRegisters(pScrn, &info->ModeReg);
+
+ if (r128_output->MonType == MT_DFP)
+@@ -305,6 +305,13 @@ DisplayModePtr R128ProbeOutputModes(xf86OutputPtr output)
+ modes = xf86GetDefaultModes();
+
+ for (mode = modes; mode != NULL; mode = mode->next) {
++ if (r128_output->type == OUTPUT_DVI) {
++ if (mode->type & (M_T_DRIVER | M_T_PREFERRED)) {
++ r128_output->PanelXRes = mode->HDisplay;
++ r128_output->PanelYRes = mode->VDisplay;
++ }
++ }
++
+ xf86SetModeCrtc(mode, INTERLACE_HALVE_V);
+ if (mode->status == MODE_OK)
+ mode->status = R128DoValidMode(output, mode, MODECHECK_FINAL);
+@@ -459,7 +466,7 @@ Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+ R128I2CInit(output, &r128_output->pI2CBus, output->name);
+ }
+
+- if (otypes[i] != OUTPUT_VGA)
++ if (otypes[i] == OUTPUT_LVDS)
+ R128GetPanelInfoFromBIOS(output);
+ }
+
+diff --git a/src/r128_video.c b/src/r128_video.c
+index dc1f25b..9da56ff 100644
+--- a/src/r128_video.c
++++ b/src/r128_video.c
+@@ -670,7 +670,7 @@ R128DisplayVideo422(
+ int v_inc, h_inc, step_by, tmp, v_inc_shift;
+ int p1_h_accum_init, p23_h_accum_init;
+ int p1_v_accum_init;
+- Bool rmx_active;
++ Bool rmx_active = FALSE;
+
+ R128ECP(pScrn, pPriv);
+
+@@ -680,7 +680,8 @@ R128DisplayVideo422(
+ if (pScrn->currentMode->Flags & V_DBLSCAN)
+ v_inc_shift--;
+
+- rmx_active = INREG(R128_FP_VERT_STRETCH) & R128_VERT_STRETCH_ENABLE;
++ if (r128_output->PanelYRes > 0)
++ rmx_active = INREG(R128_FP_VERT_STRETCH) & R128_VERT_STRETCH_ENABLE;
+ if (rmx_active) {
+ v_inc = ((src_h * pScrn->currentMode->CrtcVDisplay / r128_output->PanelYRes) << v_inc_shift) / drw_h;
+ } else {
+@@ -759,7 +760,7 @@ R128DisplayVideo420(
+ int v_inc, h_inc, step_by, tmp, leftUV, v_inc_shift;
+ int p1_h_accum_init, p23_h_accum_init;
+ int p1_v_accum_init, p23_v_accum_init;
+- Bool rmx_active;
++ Bool rmx_active = FALSE;
+
+ v_inc_shift = 20;
+ if (pScrn->currentMode->Flags & V_INTERLACE)
+@@ -767,7 +768,8 @@ R128DisplayVideo420(
+ if (pScrn->currentMode->Flags & V_DBLSCAN)
+ v_inc_shift--;
+
+- rmx_active = INREG(R128_FP_VERT_STRETCH) & R128_VERT_STRETCH_ENABLE;
++ if (r128_output->PanelYRes > 0)
++ rmx_active = INREG(R128_FP_VERT_STRETCH) & R128_VERT_STRETCH_ENABLE;
+ if (rmx_active) {
+ v_inc = ((src_h * pScrn->currentMode->CrtcVDisplay / r128_output->PanelYRes) << v_inc_shift) / drw_h;
+ } else {
+--
+2.2.2
+
+
+From 089c81ed6b6efc4610e0c5e5fcb36dfd58b83439 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Sat, 23 Aug 2014 01:19:25 -0400
+Subject: Fix whitespace near panel code
+
+This has been bugging me.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_driver.c | 10 +++++-----
+ src/r128_video.c | 24 ++++++++++++------------
+ 2 files changed, 17 insertions(+), 17 deletions(-)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index 98b0644..f00fa1d 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -507,7 +507,7 @@ void R128GetPanelInfoFromBIOS(xf86OutputPtr output)
+ if (!FPHeader) return;
+
+ /* Assume that only one panel is attached and supported */
+- for (i = FPHeader+20; i < FPHeader+84; i += 2) {
++ for (i = FPHeader + 20; i < FPHeader + 84; i += 2) {
+ if (R128_BIOS16(i) != 0) {
+ info->FPBIOSstart = R128_BIOS16(i);
+ break;
+@@ -3409,6 +3409,7 @@ ModeStatus R128DoValidMode(xf86OutputPtr output, DisplayModePtr mode, int flags)
+ ScrnInfoPtr pScrn = output->scrn;
+ R128InfoPtr info = R128PTR(pScrn);
+ R128OutputPrivatePtr r128_output = output->driver_private;
++ int i, j;
+
+ if (r128_output->MonType == MT_CRT)
+ return MODE_OK;
+@@ -3419,9 +3420,8 @@ ModeStatus R128DoValidMode(xf86OutputPtr output, DisplayModePtr mode, int flags)
+ }
+
+ if (r128_output->MonType == MT_LCD && info->VBIOS) {
+- int i;
+ for (i = info->FPBIOSstart + 64; R128_BIOS16(i) != 0; i += 2) {
+- int j = R128_BIOS16(i);
++ j = R128_BIOS16(i);
+
+ if (mode->CrtcHDisplay == R128_BIOS16(j) &&
+ mode->CrtcVDisplay == R128_BIOS16(j + 2)) {
+@@ -3432,8 +3432,8 @@ ModeStatus R128DoValidMode(xf86OutputPtr output, DisplayModePtr mode, int flags)
+ (float)mode->Clock / 1000);
+
+ /* Assume we are using expanded mode */
+- if (R128_BIOS16(j+5)) j = R128_BIOS16(j+5);
+- else j += 9;
++ if (R128_BIOS16(j + 5)) j = R128_BIOS16(j + 5);
++ else j += 9;
+
+ mode->Clock = (uint32_t)R128_BIOS16(j) * 10;
+
+diff --git a/src/r128_video.c b/src/r128_video.c
+index 9da56ff..cac4301 100644
+--- a/src/r128_video.c
++++ b/src/r128_video.c
+@@ -574,16 +574,16 @@ R128CopyData420(
+
+ uint32_t
+ R128AllocateMemory(
+- ScrnInfoPtr pScrn,
+- void **mem_struct,
+- int size,
+- int align,
+- Bool need_accel
++ ScrnInfoPtr pScrn,
++ void **mem_struct,
++ int size,
++ int align,
++ Bool need_accel
+ ){
+- R128InfoPtr info = R128PTR(pScrn);
+- ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
+- Bool do_linear = !need_accel;
+- uint32_t offset = 0;
++ R128InfoPtr info = R128PTR(pScrn);
++ ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
++ Bool do_linear = !need_accel;
++ uint32_t offset = 0;
+
+ #ifdef HAVE_XAA_H
+ if (!info->accel && need_accel)
+@@ -608,7 +608,7 @@ R128AllocateMemory(
+ offset = area->offset;
+ }
+ #endif
+- if (!info->useEXA && do_linear) {
++ if (!info->useEXA && do_linear) {
+ FBLinearPtr linear = *mem_struct;
+ int cpp = info->CurrentLayout.pixel_bytes;
+
+@@ -643,9 +643,9 @@ R128AllocateMemory(
+ }
+
+ offset = linear->offset * cpp;
+- }
++ }
+
+- return offset;
++ return offset;
+ }
+
+ static void
+--
+2.2.2
+
+
+From fcee44e469b22934a04bd3ee19ed101aaa176a54 Mon Sep 17 00:00:00 2001
+From: Connor Behan <connor.behan@gmail.com>
+Date: Sat, 23 Aug 2014 01:24:42 -0400
+Subject: Silence the non-debug warnings
+
+Some declarations of pScrn are only there for debugging purposes. This
+should make gcc quieter on most systems.
+
+Signed-off-by: Connor Behan <connor.behan@gmail.com>
+---
+ src/r128_driver.c | 4 ++++
+ src/r128_exa_render.c | 4 ++++
+ 2 files changed, 8 insertions(+)
+
+diff --git a/src/r128_driver.c b/src/r128_driver.c
+index f00fa1d..e4e43a6 100644
+--- a/src/r128_driver.c
++++ b/src/r128_driver.c
+@@ -3109,7 +3109,9 @@ void R128InitLVDSRegisters(R128SavePtr orig, R128SavePtr save, xf86OutputPtr out
+ void R128InitPLLRegisters(xf86CrtcPtr crtc, R128SavePtr save,
+ R128PLLPtr pll, double dot_clock)
+ {
++#if R128_DEBUG
+ ScrnInfoPtr pScrn = crtc->scrn;
++#endif
+ unsigned long freq = dot_clock * 100;
+ struct {
+ int divider;
+@@ -3162,7 +3164,9 @@ void R128InitPLLRegisters(xf86CrtcPtr crtc, R128SavePtr save,
+ void R128InitPLL2Registers(xf86CrtcPtr crtc, R128SavePtr save,
+ R128PLLPtr pll, double dot_clock)
+ {
++#if R128_DEBUG
+ ScrnInfoPtr pScrn = crtc->scrn;
++#endif
+ unsigned long freq = dot_clock * 100;
+ struct {
+ int divider;
+diff --git a/src/r128_exa_render.c b/src/r128_exa_render.c
+index c0d3688..b9601ee 100644
+--- a/src/r128_exa_render.c
++++ b/src/r128_exa_render.c
+@@ -157,8 +157,10 @@ R128GetDatatypePict2(uint32_t format, uint32_t *type)
+ static Bool
+ R128CheckCompositeTexture(PicturePtr pPict, PicturePtr pDstPict, int op)
+ {
++#if R128_DEBUG
+ ScreenPtr pScreen = pDstPict->pDrawable->pScreen;
+ ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
++#endif
+
+ unsigned int repeatType = pPict->repeat ? pPict->repeatType : RepeatNone;
+ uint32_t tmp1;
+@@ -198,8 +200,10 @@ R128CheckCompositeTexture(PicturePtr pPict, PicturePtr pDstPict, int op)
+ static Bool
+ R128CCECheckComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture)
+ {
++#if R128_DEBUG
+ ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;
+ ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
++#endif
+
+ PixmapPtr pSrcPixmap, pDstPixmap;
+ uint32_t tmp1;
+--
+2.2.2
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 01:19:01 +0000