xenodm starts on VGA display only

Next Topic
 
classic Classic list List threaded Threaded
8 messages Options
Reply | Threaded
Open this post in threaded view
|

xenodm starts on VGA display only

Claudiu Tănăselia
Hello,

I've installed OpenBSD 6.8 on an iMac G3 (Summer 2000 edition) and there was nothing unusual during install or post-install stage, I was able to install and boot OpenBSD without an issue.

However, when X (xenodm) starts, it ignores the built-in display. The built-in display goes dark and if a second display is plugged-in via VGA port, then that display is usable, however not the built-in display. Is this a bug or a feature? xrandr only shows 1 monitor, even when the second VGA monitor is plugged it.

dmesg is available here: https://pastebin.com/TsEBjZNi

Can the internal display be used with X on OpenBSD?

Thank you,
Claudiu.

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

George Koehler-2
On Wed, 24 Mar 2021 23:03:14 +0200
Claudiu Tănăselia <[hidden email]> wrote:

> Hello,
>
> I've installed OpenBSD 6.8 on an iMac G3 (Summer 2000 edition) and there was nothing unusual during install or post-install stage, I was able to install and boot OpenBSD without an issue.
>
> However, when X (xenodm) starts, it ignores the built-in display. The built-in display goes dark and if a second display is plugged-in via VGA port, then that display is usable, however not the built-in display. Is this a bug or a feature? xrandr only shows 1 monitor, even when the second VGA monitor is plugged it.

That's a bug.  Last year I put OpenBSD on an iMac G3 PowerMac2,1 from
1999, and xenodm turned off the display, so I needed to disable X.
I didn't think to try the VGA port.  (If I recall, this iMac has the
VGA port hiding under a plastic cover.)  I recall that Xorg in OpenBSD
did work several years ago, but I don't know when the bug was added.

> dmesg is available here: https://pastebin.com/TsEBjZNi

Your iMac (like mine) has an ATI Rage 128, which is too old for the
radeondrm kernel driver.  The kernel uses vgafb(4), the framebuffer
mapped by Open Firmware, and Xorg uses the old r128(4) ums driver.
The VGA port should mirror the internal display; the hardware (if I
recall) can't put different images on the 2 displays.

> Can the internal display be used with X on OpenBSD?

I now can't power on my iMac, so I won't be able to find my a way to
use the internal display in X.  (My iMac's display was blinking or
flickering, then the iMac lost power a few times, now it makes no
noise when I press the power button.  After searching the internet, I
suspect that the display might have a bad "flyback transformer".)

--George

> Thank you,
> Claudiu.
>


--
George Koehler <[hidden email]>

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

Matthieu Herrb-3
In reply to this post by Claudiu Tănăselia
On Wed, Mar 24, 2021 at 11:03:14PM +0200, Claudiu Tănăselia wrote:
> Hello,
>
> I've installed OpenBSD 6.8 on an iMac G3 (Summer 2000 edition) and there was nothing unusual during install or post-install stage, I was able to install and boot OpenBSD without an issue.
>
> However, when X (xenodm) starts, it ignores the built-in display. The built-in display goes dark and if a second display is plugged-in via VGA port, then that display is usable, however not the built-in display. Is this a bug or a feature? xrandr only shows 1 monitor, even when the second VGA monitor is plugged it.
>
> dmesg is available here: https://pastebin.com/TsEBjZNi
>

Hi,

This is probably a bug, but I don't know what is causing it. We would
need to see the contents of /var/log/Xorg.0.log to --maybe-- get some
clues on what is happening.

Also the xf86-video-r128 driver is lagging behind upstream versions
for a mumber of years now. Initially I didn't upgrade it because
upstream version where breaking on my macppc G4. I don't think I'v
tried more "recent" ones like 6.11 or 6.12 though. If I find time for
this, I may be able to send an update patch during the week end.

--
Matthieu Herrb

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

Claudiu Tănăselia
Hi,

Thank you for your replies! Here's my /var/log/Xorg.0.log: https://pastebin.com/6RWberfW
Let me know if I can offer you any more clues about this situation.

Kind regards,
Claudiu.

On Thu, Mar 25, 2021, at 08:57, Matthieu Herrb wrote:

> On Wed, Mar 24, 2021 at 11:03:14PM +0200, Claudiu Tănăselia wrote:
> > Hello,
> >
> > I've installed OpenBSD 6.8 on an iMac G3 (Summer 2000 edition) and there was nothing unusual during install or post-install stage, I was able to install and boot OpenBSD without an issue.
> >
> > However, when X (xenodm) starts, it ignores the built-in display. The built-in display goes dark and if a second display is plugged-in via VGA port, then that display is usable, however not the built-in display. Is this a bug or a feature? xrandr only shows 1 monitor, even when the second VGA monitor is plugged it.
> >
> > dmesg is available here: https://pastebin.com/TsEBjZNi
> >
>
> Hi,
>
> This is probably a bug, but I don't know what is causing it. We would
> need to see the contents of /var/log/Xorg.0.log to --maybe-- get some
> clues on what is happening.
>
> Also the xf86-video-r128 driver is lagging behind upstream versions
> for a mumber of years now. Initially I didn't upgrade it because
> upstream version where breaking on my macppc G4. I don't think I'v
> tried more "recent" ones like 6.11 or 6.12 though. If I find time for
> this, I may be able to send an update patch during the week end.
>
> --
> Matthieu Herrb
>

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

Matthieu Herrb-3
On Thu, Mar 25, 2021 at 05:24:09PM +0200, Claudiu Tănăselia wrote:

> Hi,
>
> Thank you for your replies! Here's my /var/log/Xorg.0.log: https://pastebin.com/6RWberfW
> Let me know if I can offer you any more clues about this situation.
>
> Kind regards,
> Claudiu.
>
> On Thu, Mar 25, 2021, at 08:57, Matthieu Herrb wrote:
> > On Wed, Mar 24, 2021 at 11:03:14PM +0200, Claudiu Tănăselia wrote:
> > > Hello,
> > >
> > > I've installed OpenBSD 6.8 on an iMac G3 (Summer 2000 edition) and there was nothing unusual during install or post-install stage, I was able to install and boot OpenBSD without an issue.
> > >
> > > However, when X (xenodm) starts, it ignores the built-in display. The built-in display goes dark and if a second display is plugged-in via VGA port, then that display is usable, however not the built-in display. Is this a bug or a feature? xrandr only shows 1 monitor, even when the second VGA monitor is plugged it.
> > >
> > > dmesg is available here: https://pastebin.com/TsEBjZNi
> > >
> >
> > Hi,
> >
> > This is probably a bug, but I don't know what is causing it. We would
> > need to see the contents of /var/log/Xorg.0.log to --maybe-- get some
> > clues on what is happening.
> >
> > Also the xf86-video-r128 driver is lagging behind upstream versions
> > for a mumber of years now. Initially I didn't upgrade it because
> > upstream version where breaking on my macppc G4. I don't think I'v
> > tried more "recent" ones like 6.11 or 6.12 though. If I find time for
> > this, I may be able to send an update patch during the week end.
> >

Here's a patch to update x86-video-r128 to 6.12.0. It add xrandr
support, but on my G4, lacking BIOS support only the output active
while booting is detected.

To try it :

cd /usr/xenocara/driver/xf86-video-r128
patch -p0 -E < /path/to/this/patch
make -f Makefile.bsd-wrapper obj
make -f Makefile.bsd-wrapper
doas make -f Makefile.bsd-wrapper install

doas rcctl restart xenodm

Index: ChangeLog
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/ChangeLog,v
retrieving revision 1.5
diff -u -p -u -r1.5 ChangeLog
--- ChangeLog 23 Nov 2012 20:47:03 -0000 1.5
+++ ChangeLog 25 Mar 2021 21:03:14 -0000
@@ -1,3 +1,1253 @@
+commit 38216bdc81321a8bb70a4c7ce226194537cc63d6
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Oct 22 21:01:12 2018 -0700
+
+    Version bumped to 6.12.0
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 0dc8f6d099e74a61a280e8cd8b7b93b229f95c7f
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Oct 22 20:58:43 2018 -0700
+
+    Remove Dac6Bit option from man page
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 3c292d8f90eae03e6e6806a68a4f749bb39db9ba
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Oct 22 20:46:20 2018 -0700
+
+    Fix for build failure when --disable-dri option is specified
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 9d62b878ce40d9b5f7887c63a4e2498a52253c36
+Author: Helmut Grohne <[hidden email]>
+Date:   Mon Oct 22 19:06:15 2018 -0700
+
+    Another fix for cross build failure
+    
+    While commit 11b230b removed most usage of AC_CHECK_FILE, one more of
+    it was left in the compilation build script. This will hopefully fix
+    the cross build failure for good.
+    
+    Signed-off-by: Helmut Grohne <[hidden email]>
+
+commit 1b17c78941762c38e3ea37e0b259270286c18455
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Aug 4 13:38:53 2018 -0700
+
+    Version bumped to 6.11.102
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit b93302435030a8dc878ea330eafd5d8b87f0df03
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 13:11:42 2018 -0700
+
+    Consolidate acquisition of many options into two functions
+    
+    Move acquiring of the option settings into r128AcquireOption and
+    r128UMSOption functions.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit d82464bce67d9f7286c10fcb6c0a72d8e2fa6501
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 12:59:30 2018 -0700
+
+    Rename R128UMSOption to r128UMSOption
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 1fe5b0c0ab444d7c902a1d348ae4d982cf5c1790
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 12:47:54 2018 -0700
+
+    Version bumped to 6.11.101
+    
+    Performed DRI1 and EXA / XAA initialization code refactoring.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit fb625410051dcf2e0bbd3bbcefe83dbc53f9a33c
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 12:41:31 2018 -0700
+
+    Hold off enabling acceleration until EXA / XAA are fully initialized
+    
+    The turn on timing is premature. Wait until completion of the
+    initialization process.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit b395a05428831faf7a0502b52c78c99a8a4d6a8e
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 12:38:39 2018 -0700
+
+    Consolidate EXA initialization code into R128EXAInit
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 78b21efdce6f1231b0c9c8a4e801ee476acd5dc4
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 10:44:15 2018 -0700
+
+    Deprecate R128VerboseInitEXA
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 370dc01505718dc07d444b4534794d0b988d27ad
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 10:43:18 2018 -0700
+
+    Deprecate R128AccelInit
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 4685a918ff68e4a9e20df31c37028626b96743cb
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 10:42:03 2018 -0700
+
+    Deprecate R128EXAAccelInit
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit d9c7c8306bb8ff4812707bd8a533da4b0b917c1b
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Aug 2 10:22:29 2018 -0700
+
+    Consolidate frame buffer initialization code
+    
+    The previous implementation had duplicated code depending on which
+    standard is being used (i.e., DRI1 and / or EXA).
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit ec61d090f8286703a6557a6917976cffb141dc92
+Author: Kevin Brace <[hidden email]>
+Date:   Fri Jul 27 16:52:03 2018 -0700
+
+    Prevent disabling of EXA inside R128ScreenInit
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 641d3d42b7214d01addfd21efb692531849b4603
+Author: Kevin Brace <[hidden email]>
+Date:   Fri Jul 27 11:22:49 2018 -0700
+
+    Version bumped to 6.11.100
+    
+    Performed code refactoring and made tweaks to initialization behavior.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 7dbb89d6fd11d3521b8a0085f4d9640910081bf2
+Author: Kevin Brace <[hidden email]>
+Date:   Fri Jul 27 11:08:29 2018 -0700
+
+    Move loading of EXA and XAA modules into R128PreInitAccel
+    
+    Moving them away from R128ScreenInit callback function. This is how
+    other DDXs do it.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit c4c05c95ae9f1b02fcbc9f6ee431d466c1c0b519
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 26 19:58:06 2018 -0700
+
+    Move RAMDAC module initialization into R128LegacyMS
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit f54469efcad4a68d86abbd55b79f4660667a5fff
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 26 19:43:27 2018 -0700
+
+    Delete OPTION_DISPLAY option enumeration
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 2a903d7c00d67716815b68fb492b4d40e2f5684d
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 26 19:41:06 2018 -0700
+
+    Delete USE_CRT_ONLY conditional compilation directive
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit b5f0862bbbe604605be19621ba22d60aeb68d4b9
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 26 19:36:22 2018 -0700
+
+    Move many DDX UMS options into R128UMSOption
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 0ef4fbad35a1e6d20cf72c7702ffd7ebf215cdb9
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 26 13:38:16 2018 -0700
+
+    Remove OPTION_DAC_8BIT option
+    
+    It is no longer used.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 4e3638c612831dea400be7d0d85d4d1ea9f9a4c2
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 26 10:11:59 2018 -0700
+
+    Evaluate software cursor option inside R128PreInit
+    
+    Since SWCursor option is referenced only once, it should be handled
+    inside R128PreInit callback function rather than R128ScreenInit
+    callback function.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 15d245de2814128b04dea2b640c4ba0b12926f24
+Author: Kevin Brace <[hidden email]>
+Date:   Wed Jul 25 20:19:06 2018 -0700
+
+    Evaluate EXA related options inside R128PreInit
+    
+    Since AccelMethod and RenderAccel options are referenced only once,
+    it should be handled inside R128PreInit callback function rather
+    than R128ScreenInit callback function.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 680aeee6730aa5b00bbc457b199b7643a6b0a1cb
+Author: Kevin Brace <[hidden email]>
+Date:   Wed Jul 25 19:50:40 2018 -0700
+
+    Evaluate NoAccel option inside R128PreInit
+    
+    Since NoAccel option is referenced only once, it should be handled
+    inside R128PreInit callback function rather than R128ScreenInit
+    callback function.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 23012b520e16fe2687e50c635e6c0a1f9d740c4e
+Author: Kevin Brace <[hidden email]>
+Date:   Tue Jul 24 13:39:57 2018 -0700
+
+    Separate EXA and XAA initialization
+    
+    Starting the process of separating legacy XAA and newer EXA
+    initialization code.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit fbbbcc0d33eb95869bcd0df26f3351f1531711db
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jul 21 06:15:39 2018 -0700
+
+    Version bumped to 6.11.99
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 321b8997ef72507ac70b5531789ff08ca9d40ce8
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 19 12:02:44 2018 -0700
+
+    Version bumped to 6.11.0
+    
+    Added a temporary fix for some RAGE 128 Pro models misidentifying
+    VGA as DVI and not able to automatically select the proper screen
+    resolution via the use of EDID (Extended Display Identification).
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 1f424303840091a3b96e0a3830a966316c5e4e7f
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 19 09:46:23 2018 -0700
+
+    Reorganize r128_exa.c
+    
+    Stop the use of #include to include r128_exa_render.c inside
+    r128_exa.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 3acc004c6bfc17aca397ff2cc8c0b1a0e2d4ee63
+Author: Dylan Aïssi <[hidden email]>
+Date:   Wed Jul 18 07:25:45 2018 -0700
+
+    Fix typo: Initalizing --> Initializing
+    
+    Signed-off-by: Dylan Aïssi <[hidden email]>
+
+commit 11b230ba61c00c69b23c5be592cf88492113355e
+Author: Helmut Grohne <[hidden email]>
+Date:   Wed Jul 18 07:04:27 2018 -0700
+
+    Fix for cross build failure
+    
+    configure.ac fails to cross build from source, because it abuses
+    AC_CHECK_FILE for finding headers. AC_CHECK_FILE is supposed to find
+    files on the host system. You cannot usually expect the host system
+    to have headers, so this use is incorrect. It happens to also break
+    cross compilation.
+    
+    Signed-off-by: Helmut Grohne <[hidden email]>
+
+commit d87d1aac04415d74ab32e820e9e351432c66cfdb
+Author: Kevin Brace <[hidden email]>
+Date:   Fri Jul 13 07:18:18 2018 -0700
+
+    Fix for some RAGE 128 Pro causing out of range display error
+    
+    Due to faulty assumptions made by commit 2072d9a, many RAGE 128 Pro
+    VGA display will be detected as DVI, and causes out of range display
+    error with the attached monitor. While this commit is less than
+    perfect and only works on x86 platform, it avoids causing out of
+    range display error. With this fix, there is no longer the need to
+    specify the supported frequency range of the monitor inside xorg.conf.
+    The code was tested on RAGE 128 Pro Ultra 16 MB AGP.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit c857cc319809790a5414ee75fc299d835fe964a7
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jul 12 16:11:07 2018 -0700
+
+    Convert tabs to white spaces for r128_output.c
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 0a6d7d93acf57bfd8c0005b4a08e6cd054d7a76d
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 30 23:55:19 2018 -0500
+
+    Using __func__ string for debug message function identification
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 09f14ae89073c31118b747b8cd3663d4da9aa170
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 30 22:56:27 2018 -0500
+
+    Remove compilation warnings related to debug messages
+    
+    The variable sizes were not matching the intended print format.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 951af95a6ddb07b13304632eb4faf8b1256399a7
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 30 22:07:08 2018 -0500
+
+    Deprecate R128TRACE macro when generating debug messages
+    
+    Deprecating R128TRACE macro in favor of DEBUG macro used inside
+    OpenChrome DDX.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 16822a6a31731cb457ab35b79e5cd6f04c060625
+Author: Kevin Brace <[hidden email]>
+Date:   Tue Jun 26 17:40:11 2018 -0500
+
+    Move the location R128PreInitDRI is called
+    
+    Merge it into R128LegacyMS function.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit c4c878d2ccb75fa75afe46e0e50ee9975c5c57fc
+Author: Stefan Dirsch <[hidden email]>
+Date:   Mon Jun 25 15:57:02 2018 +0200
+
+    Include <stdint.h> in order to declare uint32_t
+    
+    Apparently this is needed in src/atipcirename.h since xorg-server
+    1.20 in order to still build this driver.
+    
+    Signed-off-by: Stefan Dirsch <[hidden email]>
+    Reviewed-by: Emil Velikov <[hidden email]>
+
+commit 6f18a15d237b5a6f4ee9d61634ff9bae827398bd
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 20:20:06 2018 -0500
+
+    Move R128InitDDA2Registers to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 0be9774d038322a779c34a02461342794090cd58
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 20:20:05 2018 -0500
+
+    Move R128InitDDARegisters to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 732ab99127538b701f71c43086c617b39d9522aa
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 20:20:04 2018 -0500
+
+    Move R128RestorePLL2Registers to r128_crtc.c
+    
+    r128_crtc.c is the more logical place this function should be located.
+    R128PLL2WaitForReadUpdateComplete and R128PLL2WriteUpdate functions were
+    moved as well.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 9cf18d3f147e38c2c560c5904a71c993ca50a25e
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 20:20:03 2018 -0500
+
+    Move R128RestorePLLRegisters to r128_crtc.c
+    
+    r128_crtc.c is the more logical place this function should be located.
+    R128PLLWaitForReadUpdateComplete and R128PLLWriteUpdate functions were
+    moved as well.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit b4edfdf93e2d73e149ff550dfc19de3de145fb71
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 12:39:33 2018 -0500
+
+    Move R128RestoreDACRegisters to r128_output.c
+    
+    r128_output.c is the more logical place this function should be located.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 61a116603e57e48714fd3e62310f3df79a9fecc3
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 12:39:32 2018 -0500
+
+    Move R128InitDACRegisters to r128_output.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_output.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 6713ef02c5ee44f9c519f99934a595e5a5ac378c
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 12:39:31 2018 -0500
+
+    Move R128RestoreCrtc2Registers to r128_crtc.c
+    
+    r128_crtc.c is the more logical place this function should be located.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit dc218b45075ff1ffe497e25b34c528c5259ef398
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 17 12:39:30 2018 -0500
+
+    Move R128RestoreCrtcRegisters to r128_crtc.c
+    
+    r128_crtc.c is the more logical place this function should be located.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit e9564ed077af772dc3f82f15ac4c507ee1c16415
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 16 10:24:37 2018 -0500
+
+    Move R128InitPLL2Registers to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 07796aa604200a323edeb79d65d16945b60cbc63
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 16 10:24:36 2018 -0500
+
+    Move R128InitPLLRegisters to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit c63eb246927f263b20966a76d80efd9acf9713af
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 16 10:24:35 2018 -0500
+
+    Convert R128Div to an inline function
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 5c494ca862257f1ce839febc8eda68a26353e544
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 16 10:24:34 2018 -0500
+
+    Move R128InitCrtc2Base to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 4e3da789346add1ce4505eb06a7e2c18daa2e843
+Author: Kevin Brace <[hidden email]>
+Date:   Sat Jun 16 10:24:33 2018 -0500
+
+    Move R128InitCrtcBase to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 7d0526f74f85f4286396cd6b761a0b908d2936df
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jun 7 16:38:54 2018 -0500
+
+    Move R128InitCrtc2Registers to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 1f4d3e04e51d4665a99ea567a19b43bb351ae631
+Author: Kevin Brace <[hidden email]>
+Date:   Thu Jun 7 16:38:22 2018 -0500
+
+    Move R128InitCrtcRegisters to r128_crtc.c
+    
+    It does not make sense for this function to be inside r128_driver.c
+    since it is only called from a function inside r128_crtc.c.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 80158cdedb8b0c2320c917aefd10e90869b00ef8
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Jun 4 19:45:40 2018 -0500
+
+    Move existing mode setting initialization code into R128LegacyMS
+    
+    In preparation of adding a new mode setting code path.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 6572c6cd14e60994e5cd1dc2f8fcc6f88c895c36
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Jun 4 19:45:20 2018 -0500
+
+    Move the location xf86CrtcConfigInit is called inside R128PreInit
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 656f5c276a2a18204d923eabcc1d0d98144505f8
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Jun 4 19:44:59 2018 -0500
+
+    Refactor R128PreInitWeight
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 73cbe46437a9a5affcdd9d605421ceff38616a6a
+Author: Kevin Brace <[hidden email]>
+Date:   Mon Jun 4 19:44:39 2018 -0500
+
+    Remove R128ProbeDDC
+    
+    This removes a VBE (VESA BIOS Extension) related call when probing.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 600c2f47f0edc30adb67b58121be5c4d587ddff4
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 3 01:43:40 2018 -0500
+
+    Move R128PreInitVisual and R128PreInitGamma calls
+    
+    This is similar to how the sample code for PreInit callback function
+    shown in XFree86 DDX Design (ddxDesign.pdf) design guide does it.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 237cfee9d77d8adca0ad00661e6dc99caa28ad26
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 3 01:43:39 2018 -0500
+
+    Move the assignment to monitor field of ScrnInfoRec record
+    
+    This is similar to how the sample code for PreInit callback function
+    shown in XFree86 DDX Design (ddxDesign.pdf) design guide does it.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 3c2a02971b423359747d328e1ce16e6f4f800d9a
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 3 01:43:38 2018 -0500
+
+    Move assignment of color depth variables away from R128PreInitVisual
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 56ff44e0afd4d11d9a9daa4efd3031733b14d464
+Author: Kevin Brace <[hidden email]>
+Date:   Sun Jun 3 01:43:37 2018 -0500
+
+    Move the location where R128PreInitGamma is called
+    
+    This is similar to how the sample code for PreInit callback function
+    shown in XFree86 DDX Design (ddxDesign.pdf) design guide does it.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+
+commit 71d49f8697906eb0a9a7e4b5956203abef672da7
+Author: Emil Velikov <[hidden email]>
+Date:   Mon Jul 17 13:29:14 2017 +0100
+
+    xf86-video-r128: remove the GlxSetVisualConfigs stub and friends
+    
+    The function was an empty since 2008 at least. Remove it alongside the
+    unused GLX visuals code.
+    
+    With this all the GL/GLX dependencies in the driver are gone.
+    
+    Cc: Adam Jackson <[hidden email]>
+    Cc: Connor Behan <[hidden email]>
+    Signed-off-by: Emil Velikov <[hidden email]>
+    Tested-by: Connor Behan <[hidden email]>
+
+commit 07273966d12c2693302b13c57c5f3abe8896e11c
+Author: Mihail Konev <[hidden email]>
+Date:   Thu Jan 26 14:00:22 2017 +1000
+
+    autogen: add default patch prefix
+    
+    Signed-off-by: Mihail Konev <[hidden email]>
+
+commit b4c89cbe61828abe5e561a886db3c2e0e9ece2ef
+Author: Emil Velikov <[hidden email]>
+Date:   Mon Mar 9 12:00:52 2015 +0000
+
+    autogen.sh: use quoted string variables
+    
+    Place quotes around the $srcdir, $ORIGDIR and $0 variables to prevent
+    fall-outs, when they contain space.
+    
+    Signed-off-by: Emil Velikov <[hidden email]>
+    Reviewed-by: Peter Hutterer <[hidden email]>
+    Signed-off-by: Peter Hutterer <[hidden email]>
+
+commit 96940667038cdba4775fb810da2d77290c9eda62
+Author: Peter Hutterer <[hidden email]>
+Date:   Tue Jan 24 10:32:07 2017 +1000
+
+    autogen.sh: use exec instead of waiting for configure to finish
+    
+    Syncs the invocation of configure with the one from the server.
+    
+    Signed-off-by: Peter Hutterer <[hidden email]>
+    Reviewed-by: Emil Velikov <[hidden email]>
+
+commit 5129d4dbc57e3a00144b6ccc23ca4c6ede9b6509
+Author: Colin Walters <[hidden email]>
+Date:   Wed Jan 4 17:37:06 2012 -0500
+
+    autogen.sh: Implement GNOME Build API
+    
+    http://people.gnome.org/~walters/docs/build-api.txt
+    
+    Signed-off-by: Adam Jackson <[hidden email]>
+
+commit bb4015a6b9394766d92186b4b71bbd49fa207532
+Author: Peter Hutterer <[hidden email]>
+Date:   Thu Jan 26 11:19:23 2017 +1000
+
+    configure: Drop AM_MAINTAINER_MODE
+    
+    Signed-off-by: Peter Hutterer <[hidden email]>
+
+commit b93b78f41154d24371acb1081c423351e8f370fd
+Author: Matt Turner <[hidden email]>
+Date:   Tue Jan 17 14:43:12 2017 -0800
+
+    xf86-video-r128 6.10.2
+    
+    Signed-off-by: Matt Turner <[hidden email]>
+
+commit 5ab23b3a8ef18ab9ff96ac8be174380d36e185e5
+Author: Adam Jackson <[hidden email]>
+Date:   Tue Jul 19 10:03:56 2016 -0400
+
+    Adapt Block/WakeupHandler signature for ABI 23
+    
+    Signed-off-by: Adam Jackson <[hidden email]>
+
+commit a589dd6baf7fa26f8ea7008ba6bd533a5ba3e76e
+Author: Connor Behan <[hidden email]>
+Date:   Wed Apr 13 12:41:00 2016 -0400
+
+    Remove gatos advertisement
+    
+    There are many current working ways to use a TV tuner with Linux. This
+    is not one of them.
+    Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=94915
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit 3328547c840664896c12d0fd2db8f63e3a398a62
+Author: Kevin Brace <[hidden email]>
+Date:   Wed Mar 16 18:59:23 2016 -0700
+
+    xextproto 7.1 support update to the source code
+    
+    While the compilation script was updated, for some reason, the source
+    code did not get the update.
+    
+    Signed-off-by: Kevin Brace <[hidden email]>
+    Reviewed-by: Connor Behan <[hidden email]>
+
+commit d3f3c9549119629ddd9447a0f9b699a909b916d5
+Author: Connor Behan <[hidden email]>
+Date:   Thu Jan 21 22:12:25 2016 -0500
+
+    Bump to version 6.10.1
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Tested-by: Christopher Chavez <[hidden email]>
+
+commit 562681414f38c6925da01b3fec0802f532cd9e53
+Author: Connor Behan <[hidden email]>
+Date:   Sun Jan 17 16:45:31 2016 -0500
+
+    Assume CRT in the absence of other monitors
+    
+    This patch is still untested, but it sounds like a lot of people need
+    it. Assuming that there are no monitors when DDC fails (which causes X
+    to abort with UMS) does not make sense. Some people will always have DDC
+    fail. For example, the pins are not connected on an iMac G3. For another
+    example, some RAGE128TF cards are known to lie that there is no VGA port
+    in the connector table.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit d6dd6c9ad5ba8e4950c9398d93298fea48745263
+Author: Connor Behan <[hidden email]>
+Date:   Thu Jul 2 18:20:58 2015 -0400
+
+    Really fix bitmasks for DDC
+    
+    For DDC, there is actually no difference between Pro2 cards and other
+    VGA desktop cards. Mobility / dualhead cards are the only ones that
+    differ.
+    Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=91113
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Tested-by: Kevin Brace <[hidden email]>
+
+commit 0b0f74ac7db42c772c8dda0167154bbdcb904d4f
+Author: Connor Behan <[hidden email]>
+Date:   Fri May 1 19:43:42 2015 -0400
+
+    Bump to version 6.10.0
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit d05022a1c398787d3f21d023a8251cb128ba9f9f
+Author: Connor Behan <[hidden email]>
+Date:   Mon Mar 23 21:57:10 2015 -0400
+
+    Update bitmasks for DDC
+    
+    A RAGE128TR chipset with a VGA port uses different i2c clock bits than
+    the VGA cards previously tested. It seems reasonable to assume that
+    other Pro2 cards are set up this way as well. In case this is incorrect,
+    a newly added xf86I2CProbeAddress() should still allow a monitor to be
+    detected.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Tested-by: Tobias Powalowski <[hidden email]>
+
+commit b9c9779398828d4a1491e32f731aad6f79653976
+Author: Connor Behan <[hidden email]>
+Date:   Mon Mar 23 21:51:45 2015 -0400
+
+    Look for VGA ports in the VBIOS
+    
+    It appears that not all r128 chipsets marked as DFP capable have DVI
+    ports. Some have VGA which we should detect. The old driver "detected"
+    this by attempting a DVI based probe for monitors. Anything that failed
+    this was assumed to be VGA.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Tested-by: Tobias Powalowski <[hidden email]>
+
+commit cd72de385b5600229226c3a7248a89569b452136
+Author: Connor Behan <[hidden email]>
+Date:   Mon Mar 23 21:47:52 2015 -0400
+
+    Fix allocation of private entity
+    
+    In the past, pR128Ent was only used for Xinerama-style dualhead and
+    therefore only allocated for cards with two outputs. However, recent
+    patches have repurposed pR128Ent as a general struct for things that are
+    card-specific instead of instance-specific. It therefore needs to be
+    allocated for all cards.
+    Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=89236
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Tested-by: Tobias Powalowski <[hidden email]>
+
+commit 8c7daa148796a037ae2518154345719a735833c3
+Author: Connor Behan <[hidden email]>
+Date:   Wed Mar 4 00:31:33 2015 -0500
+
+    Restore PLL0 as well as PLL3
+    
+    Apparently, the text mode driver can use either register to store the
+    pixel clock. The assumption made previously was apparently corrupting
+    the console on PowerPC systems. Thanks to Michael Lorenz for the patch.
+    Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=32606
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit bfff401440c5bb72fb1ce90c804f3a5623d733b0
+Author: Connor Behan <[hidden email]>
+Date:   Mon Mar 2 16:15:16 2015 -0500
+
+    Make it easier to find EXA
+    
+    As of commit e31564e1a21e73f4d20d6471da4fc7a9b63e4062, the xserver is
+    more picky about the order in which headers are included. We need to
+    account for this in order for the compile time exa.h check to succeed.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit e13dd1d338e4501c9d98c86c60806cc3d6801ea8
+Author: Connor Behan <[hidden email]>
+Date:   Mon Mar 2 15:21:17 2015 -0500
+
+    Include dpmsconst header
+    
+    Fixes the build on some systems. Thank-you to Andrew Randrianasulu for
+    the patch.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit 86533afa3dd9a3567330f157d03cd8188f89cc72
+Author: Connor Behan <[hidden email]>
+Date:   Mon Mar 2 15:18:19 2015 -0500
+
+    Typo fix
+    
+    This only affects XAA builds but still. Thank-you to Andrew
+    Randrianasulu for the patch.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit fcee44e469b22934a04bd3ee19ed101aaa176a54
+Author: Connor Behan <[hidden email]>
+Date:   Sat Aug 23 01:24:42 2014 -0400
+
+    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 <[hidden email]>
+
+commit 089c81ed6b6efc4610e0c5e5fcb36dfd58b83439
+Author: Connor Behan <[hidden email]>
+Date:   Sat Aug 23 01:19:25 2014 -0400
+
+    Fix whitespace near panel code
+    
+    This has been bugging me.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit 0519b7b3aac61dfd57cbf3bb0da561ca9bd079cb
+Author: Connor Behan <[hidden email]>
+Date:   Sat Aug 23 01:13:18 2014 -0400
+
+    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 <[hidden email]>
+
+commit d49c3431e92a6120b054959ce6910e8decf61c67
+Author: Connor Behan <[hidden email]>
+Date:   Fri Jul 25 13:39:08 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 6140081f0e8f41cf85b8e86f7a9474c20be9a2e9
+Author: Connor Behan <[hidden email]>
+Date:   Wed Aug 6 15:51:33 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 2072d9aa1a144e699f020a7f9e6a870e410bc9d7
+Author: Connor Behan <[hidden email]>
+Date:   Wed Aug 6 15:41:02 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 6dc5e9ab12dc31ae5de24f1d5c10c4fe80e7fe07
+Author: Connor Behan <[hidden email]>
+Date:   Thu Jul 24 00:01:46 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 48e9b2359e8ab07095e1cb024e61b223a67cbc1a
+Author: Connor Behan <[hidden email]>
+Date:   Thu Jul 24 00:00:24 2014 -0700
+
+    Unify allocators
+    
+    RandR and Xv were using almost the same code to grab offscreen memory
+    from EXA and XAA.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 0d901460b375599c727928634d5f1067d2279844
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 16 17:47:44 2014 -0700
+
+    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 <[hidden email]>
+
+commit b632e89b923179b16d0d38128209427f666b963c
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 16 02:20:18 2014 -0700
+
+    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 <[hidden email]>
+
+commit 866d0ad5295a7ca819b990f607d3e68582144b3b
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 16 17:39:59 2014 -0700
+
+    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 <[hidden email]>
+
+commit d05123eab19705d23310d06a299e61093abbe6cc
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 16 17:23:37 2014 -0700
+
+    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 <[hidden email]>
+
+commit c95ce4251921f09101911ca5c4ff3940c38cc6b5
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 16 01:29:19 2014 -0700
+
+    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 <[hidden email]>
+
+commit e9ea36390ea0478c4b867df3bffdf2b122e0cb15
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 16 00:57:18 2014 -0700
+
+    Change register name
+    
+    Surely this is a typo.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit 3bbce42414abea6c9977ff2b023ce3210d78f008
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 9 11:40:35 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit de7fa61b06c887df7a89154bf0f07703a665263a
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 9 11:37:12 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 4c6457e1893e16546c03ca85a2fa7378b6c927f3
+Author: Connor Behan <[hidden email]>
+Date:   Mon Jul 7 18:49:15 2014 -0700
+
+    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 <[hidden email]>
+
+commit 539320429ff1cf8918862da3f950c8740ba63ec4
+Author: Connor Behan <[hidden email]>
+Date:   Fri Jul 4 12:44:30 2014 -0700
+
+    Only enable CRTCs for DPMSModeOn
+    
+    This was suggested as a power saving tip.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 3ed5035074540785f820906529fcce3148e0b387
+Author: Connor Behan <[hidden email]>
+Date:   Wed Jul 2 02:18:48 2014 -0700
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 4efc87f41d770c753ddf7f54fe334b6dbd7daf79
+Author: Connor Behan <[hidden email]>
+Date:   Mon Apr 28 21:26:44 2014 -0700
+
+    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 <[hidden email]>
+
+commit 5ef5812a7a272aa08543cfd9b633f33c35e34dbd
+Author: Connor Behan <[hidden email]>
+Date:   Tue Mar 4 01:43:00 2014 -0800
+
+    Remove overuse of COMPOSITE_SETUP()
+    
+    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 <[hidden email]>
+    Reviewed-by: Michel Dänzer <[hidden email]>
+
+commit 9eb693640136bc8bcbe706d642519b4eb23286d4
+Author: Connor Behan <[hidden email]>
+Date:   Wed Nov 27 18:14:43 2013 -0800
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit 35dc7faf9f87332f51ff0a6aa866a56eb017a950
+Author: Connor Behan <[hidden email]>
+Date:   Thu Nov 21 22:09:57 2013 -0800
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit d757fe10b9ce9493ef3cf854bc03088366aa7256
+Author: Connor Behan <[hidden email]>
+Date:   Fri Nov 22 22:55:59 2013 -0800
+
+    Drop dependence on xf86PciInfo.h
+    
+    It is about time we stop using this deprecated file and include pciids
+    locally.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit d5da29d2ff94c80c8edefd6ccf5fd05fc6018870
+Author: Tormod Volden <[hidden email]>
+Date:   Fri Oct 25 20:31:05 2013 +0200
+
+    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 <[hidden email]>
+    Reviewed-by: Alex Deucher <[hidden email]>
+
+commit ccdfcf5c05ccade823c9734212dcb865d8958cbb
+Author: Tormod Volden <[hidden email]>
+Date:   Wed Oct 2 20:36:38 2013 +0200
+
+    r128: bump to version 6.9.2
+    
+    Signed-off-by: Tormod Volden <[hidden email]>
+
+commit 255cf857af35e4024486cbc2693872d020f09a29
+Author: Connor Behan <[hidden email]>
+Date:   Mon Sep 30 23:24:54 2013 -0700
+
+    Specify NULL for the platform probe function
+    
+    Apparently this has been required by the ABI since server 1.13.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit a98077959a65dfda1db900373969bd08479d3e43
+Author: Connor Behan <[hidden email]>
+Date:   Mon Sep 30 21:12:20 2013 -0700
+
+    Minor spacing changes
+    
+    A log message needed a space added, two source files needed whitespace
+    removed.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit aca6aa127f43deeed42c4d3bef8d1e6a735b4c50
+Author: Connor Behan <[hidden email]>
+Date:   Fri Mar 8 01:02:22 2013 -0800
+
+    Swap pixmap bytes for a solid picture on big endian host
+    
+    Some PowerPC users were reporting color errors that only happened with
+    EXA+DRI. This implements a recent bugfix in the Radeon driver which will
+    solve at least one of these problems.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
+commit 24f28a78fdcd056357f137650ca7f0f01c257d97
+Author: Connor Behan <[hidden email]>
+Date:   Wed Dec 19 10:41:14 2012 -0800
+
+    Remove call to obsolete miInitializeBackingStore()
+    
+    Definition was deleted from Xorg during 1.14 merge window, but has been
+    a no-op since 1.10 merge window.
+    
+    Signed-off-by: Connor Behan <[hidden email]>
+
 commit ef4467b4aac70b9a8a1ef1194eb02d7551be2602
 Author: Dave Airlie <[hidden email]>
 Date:   Fri Sep 28 11:25:17 2012 +1000
Index: Makefile.in
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/Makefile.in,v
retrieving revision 1.6
diff -u -p -u -r1.6 Makefile.in
--- Makefile.in 4 Apr 2016 20:10:51 -0000 1.6
+++ Makefile.in 25 Mar 2021 21:03:14 -0000
@@ -72,8 +72,8 @@ host_triplet = @host@
 subdir = .
 DIST_COMMON = README $(am__configure_deps) $(srcdir)/Makefile.am \
  $(srcdir)/Makefile.in $(srcdir)/config.h.in \
- $(top_srcdir)/configure COPYING ChangeLog INSTALL config.guess \
- config.sub depcomp install-sh ltmain.sh missing
+ $(top_srcdir)/configure COPYING ChangeLog INSTALL compile \
+ config.guess config.sub depcomp install-sh ltmain.sh missing
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
@@ -300,6 +300,7 @@ pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
+runstatedir = @runstatedir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
Index: aclocal.m4
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/aclocal.m4,v
retrieving revision 1.8
diff -u -p -u -r1.8 aclocal.m4
--- aclocal.m4 11 Oct 2016 22:15:03 -0000 1.8
+++ aclocal.m4 25 Mar 2021 21:03:14 -0000
@@ -8606,32 +8606,63 @@ m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_L
 m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])])
 m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])])
 
-# pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
-# serial 1 (pkg-config-0.24)
-#
-# Copyright © 2004 Scott James Remnant <[hidden email]>.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
+# pkg.m4 - Macros to locate and utilise pkg-config.   -*- Autoconf -*-
+# serial 12 (pkg-config-0.29.2)
 
-# PKG_PROG_PKG_CONFIG([MIN-VERSION])
-# ----------------------------------
+dnl Copyright © 2004 Scott James Remnant <[hidden email]>.
+dnl Copyright © 2012-2015 Dan Nicholson <[hidden email]>
+dnl
+dnl This program is free software; you can redistribute it and/or modify
+dnl it under the terms of the GNU General Public License as published by
+dnl the Free Software Foundation; either version 2 of the License, or
+dnl (at your option) any later version.
+dnl
+dnl This program is distributed in the hope that it will be useful, but
+dnl WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+dnl General Public License for more details.
+dnl
+dnl You should have received a copy of the GNU General Public License
+dnl along with this program; if not, write to the Free Software
+dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+dnl 02111-1307, USA.
+dnl
+dnl As a special exception to the GNU General Public License, if you
+dnl distribute this file as part of a program that contains a
+dnl configuration script generated by Autoconf, you may include it under
+dnl the same distribution terms that you use for the rest of that
+dnl program.
+
+dnl PKG_PREREQ(MIN-VERSION)
+dnl -----------------------
+dnl Since: 0.29
+dnl
+dnl Verify that the version of the pkg-config macros are at least
+dnl MIN-VERSION. Unlike PKG_PROG_PKG_CONFIG, which checks the user's
+dnl installed version of pkg-config, this checks the developer's version
+dnl of pkg.m4 when generating configure.
+dnl
+dnl To ensure that this macro is defined, also add:
+dnl m4_ifndef([PKG_PREREQ],
+dnl     [m4_fatal([must install pkg-config 0.29 or later before running autoconf/autogen])])
+dnl
+dnl See the "Since" comment for each macro you use to see what version
+dnl of the macros you require.
+m4_defun([PKG_PREREQ],
+[m4_define([PKG_MACROS_VERSION], [0.29.2])
+m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1,
+    [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])])
+])dnl PKG_PREREQ
+
+dnl PKG_PROG_PKG_CONFIG([MIN-VERSION])
+dnl ----------------------------------
+dnl Since: 0.16
+dnl
+dnl Search for the pkg-config tool and set the PKG_CONFIG variable to
+dnl first found in the path. Checks that the version of pkg-config found
+dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is
+dnl used since that's the first version where most current features of
+dnl pkg-config existed.
 AC_DEFUN([PKG_PROG_PKG_CONFIG],
 [m4_pattern_forbid([^_?PKG_[A-Z_]+$])
 m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
@@ -8653,18 +8684,19 @@ if test -n "$PKG_CONFIG"; then
  PKG_CONFIG=""
  fi
 fi[]dnl
-])# PKG_PROG_PKG_CONFIG
+])dnl PKG_PROG_PKG_CONFIG
 
-# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
-#
-# Check to see whether a particular set of modules exists.  Similar
-# to PKG_CHECK_MODULES(), but does not set variables or print errors.
-#
-# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
-# only at the first occurence in configure.ac, so if the first place
-# it's called might be skipped (such as if it is within an "if", you
-# have to call PKG_CHECK_EXISTS manually
-# --------------------------------------------------------------
+dnl PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl -------------------------------------------------------------------
+dnl Since: 0.18
+dnl
+dnl Check to see whether a particular set of modules exists. Similar to
+dnl PKG_CHECK_MODULES(), but does not set variables or print errors.
+dnl
+dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+dnl only at the first occurence in configure.ac, so if the first place
+dnl it's called might be skipped (such as if it is within an "if", you
+dnl have to call PKG_CHECK_EXISTS manually
 AC_DEFUN([PKG_CHECK_EXISTS],
 [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
 if test -n "$PKG_CONFIG" && \
@@ -8674,8 +8706,10 @@ m4_ifvaln([$3], [else
   $3])dnl
 fi])
 
-# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
-# ---------------------------------------------
+dnl _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
+dnl ---------------------------------------------
+dnl Internal wrapper calling pkg-config via PKG_CONFIG and setting
+dnl pkg_failed based on the result.
 m4_define([_PKG_CONFIG],
 [if test -n "$$1"; then
     pkg_cv_[]$1="$$1"
@@ -8687,10 +8721,11 @@ m4_define([_PKG_CONFIG],
  else
     pkg_failed=untried
 fi[]dnl
-])# _PKG_CONFIG
+])dnl _PKG_CONFIG
 
-# _PKG_SHORT_ERRORS_SUPPORTED
-# -----------------------------
+dnl _PKG_SHORT_ERRORS_SUPPORTED
+dnl ---------------------------
+dnl Internal check to see if pkg-config supports short errors.
 AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
 [AC_REQUIRE([PKG_PROG_PKG_CONFIG])
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -8698,26 +8733,24 @@ if $PKG_CONFIG --atleast-pkgconfig-versi
 else
         _pkg_short_errors_supported=no
 fi[]dnl
-])# _PKG_SHORT_ERRORS_SUPPORTED
+])dnl _PKG_SHORT_ERRORS_SUPPORTED
 
 
-# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
-# [ACTION-IF-NOT-FOUND])
-#
-#
-# Note that if there is a possibility the first call to
-# PKG_CHECK_MODULES might not happen, you should be sure to include an
-# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
-#
-#
-# --------------------------------------------------------------
+dnl PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+dnl   [ACTION-IF-NOT-FOUND])
+dnl --------------------------------------------------------------
+dnl Since: 0.4.0
+dnl
+dnl Note that if there is a possibility the first call to
+dnl PKG_CHECK_MODULES might not happen, you should be sure to include an
+dnl explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
 AC_DEFUN([PKG_CHECK_MODULES],
 [AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
 AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
 AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
 
 pkg_failed=no
-AC_MSG_CHECKING([for $1])
+AC_MSG_CHECKING([for $2])
 
 _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
 _PKG_CONFIG([$1][_LIBS], [libs], [$2])
@@ -8727,11 +8760,11 @@ and $1[]_LIBS to avoid the need to call
 See the pkg-config man page for more details.])
 
 if test $pkg_failed = yes; then
-   AC_MSG_RESULT([no])
+        AC_MSG_RESULT([no])
         _PKG_SHORT_ERRORS_SUPPORTED
         if test $_pkg_short_errors_supported = yes; then
         $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
-        else
+        else
         $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
         fi
  # Put the nasty error message in config.log where it belongs
@@ -8748,7 +8781,7 @@ installed software in a non-standard pre
 _PKG_TEXT])[]dnl
         ])
 elif test $pkg_failed = untried; then
-     AC_MSG_RESULT([no])
+        AC_MSG_RESULT([no])
  m4_default([$4], [AC_MSG_FAILURE(
 [The pkg-config script could not be found or is too old.  Make sure it
 is in your PATH or set the PKG_CONFIG environment variable to the full
@@ -8764,16 +8797,40 @@ else
         AC_MSG_RESULT([yes])
  $3
 fi[]dnl
-])# PKG_CHECK_MODULES
+])dnl PKG_CHECK_MODULES
 
 
-# PKG_INSTALLDIR(DIRECTORY)
-# -------------------------
-# Substitutes the variable pkgconfigdir as the location where a module
-# should install pkg-config .pc files. By default the directory is
-# $libdir/pkgconfig, but the default can be changed by passing
-# DIRECTORY. The user can override through the --with-pkgconfigdir
-# parameter.
+dnl PKG_CHECK_MODULES_STATIC(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+dnl   [ACTION-IF-NOT-FOUND])
+dnl ---------------------------------------------------------------------
+dnl Since: 0.29
+dnl
+dnl Checks for existence of MODULES and gathers its build flags with
+dnl static libraries enabled. Sets VARIABLE-PREFIX_CFLAGS from --cflags
+dnl and VARIABLE-PREFIX_LIBS from --libs.
+dnl
+dnl Note that if there is a possibility the first call to
+dnl PKG_CHECK_MODULES_STATIC might not happen, you should be sure to
+dnl include an explicit call to PKG_PROG_PKG_CONFIG in your
+dnl configure.ac.
+AC_DEFUN([PKG_CHECK_MODULES_STATIC],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+_save_PKG_CONFIG=$PKG_CONFIG
+PKG_CONFIG="$PKG_CONFIG --static"
+PKG_CHECK_MODULES($@)
+PKG_CONFIG=$_save_PKG_CONFIG[]dnl
+])dnl PKG_CHECK_MODULES_STATIC
+
+
+dnl PKG_INSTALLDIR([DIRECTORY])
+dnl -------------------------
+dnl Since: 0.27
+dnl
+dnl Substitutes the variable pkgconfigdir as the location where a module
+dnl should install pkg-config .pc files. By default the directory is
+dnl $libdir/pkgconfig, but the default can be changed by passing
+dnl DIRECTORY. The user can override through the --with-pkgconfigdir
+dnl parameter.
 AC_DEFUN([PKG_INSTALLDIR],
 [m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
 m4_pushdef([pkg_description],
@@ -8784,16 +8841,18 @@ AC_ARG_WITH([pkgconfigdir],
 AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
 m4_popdef([pkg_default])
 m4_popdef([pkg_description])
-]) dnl PKG_INSTALLDIR
+])dnl PKG_INSTALLDIR
 
 
-# PKG_NOARCH_INSTALLDIR(DIRECTORY)
-# -------------------------
-# Substitutes the variable noarch_pkgconfigdir as the location where a
-# module should install arch-independent pkg-config .pc files. By
-# default the directory is $datadir/pkgconfig, but the default can be
-# changed by passing DIRECTORY. The user can override through the
-# --with-noarch-pkgconfigdir parameter.
+dnl PKG_NOARCH_INSTALLDIR([DIRECTORY])
+dnl --------------------------------
+dnl Since: 0.27
+dnl
+dnl Substitutes the variable noarch_pkgconfigdir as the location where a
+dnl module should install arch-independent pkg-config .pc files. By
+dnl default the directory is $datadir/pkgconfig, but the default can be
+dnl changed by passing DIRECTORY. The user can override through the
+dnl --with-noarch-pkgconfigdir parameter.
 AC_DEFUN([PKG_NOARCH_INSTALLDIR],
 [m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
 m4_pushdef([pkg_description],
@@ -8804,7 +8863,24 @@ AC_ARG_WITH([noarch-pkgconfigdir],
 AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
 m4_popdef([pkg_default])
 m4_popdef([pkg_description])
-]) dnl PKG_NOARCH_INSTALLDIR
+])dnl PKG_NOARCH_INSTALLDIR
+
+
+dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
+dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl -------------------------------------------
+dnl Since: 0.28
+dnl
+dnl Retrieves the value of the pkg-config variable for the given module.
+AC_DEFUN([PKG_CHECK_VAR],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
+
+_PKG_CONFIG([$1], [variable="][$3]["], [$2])
+AS_VAR_COPY([$1], [pkg_cv_][$1])
+
+AS_VAR_IF([$1], [""], [$5], [$4])dnl
+])dnl PKG_CHECK_VAR
 
 # Copyright (C) 2002-2012 Free Software Foundation, Inc.
 #
@@ -9829,7 +9905,7 @@ AC_SUBST([am__untar])
 
 dnl xorg-macros.m4.  Generated from xorg-macros.m4.in xorgversion.m4 by configure.
 dnl
-dnl Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
+dnl Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
 dnl
 dnl Permission is hereby granted, free of charge, to any person obtaining a
 dnl copy of this software and associated documentation files (the "Software"),
@@ -9866,7 +9942,7 @@ dnl DEALINGS IN THE SOFTWARE.
 # See the "minimum version" comment for each macro you use to see what
 # version you require.
 m4_defun([XORG_MACROS_VERSION],[
-m4_define([vers_have], [1.19.0])
+m4_define([vers_have], [1.19.2])
 m4_define([maj_have], m4_substr(vers_have, 0, m4_index(vers_have, [.])))
 m4_define([maj_needed], m4_substr([$1], 0, m4_index([$1], [.])))
 m4_if(m4_cmp(maj_have, maj_needed), 0,,
@@ -9944,6 +10020,17 @@ AC_DEFUN([XORG_MANPAGE_SECTIONS],[
 AC_REQUIRE([AC_CANONICAL_HOST])
 AC_REQUIRE([AC_PROG_SED])
 
+case $host_os in
+    solaris*)
+        # Solaris 2.0 - 11.3 use SysV man page section numbers, so we
+        # check for a man page file found in later versions that use
+        # traditional section numbers instead
+        AC_CHECK_FILE([/usr/share/man/man7/attributes.7],
+                [SYSV_MAN_SECTIONS=false], [SYSV_MAN_SECTIONS=true])
+        ;;
+    *) SYSV_MAN_SECTIONS=false ;;
+esac
+
 if test x$APP_MAN_SUFFIX = x    ; then
     APP_MAN_SUFFIX=1
 fi
@@ -9959,9 +10046,9 @@ if test x$LIB_MAN_DIR = x    ; then
 fi
 
 if test x$FILE_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) FILE_MAN_SUFFIX=4  ;;
- *) FILE_MAN_SUFFIX=5  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) FILE_MAN_SUFFIX=4  ;;
+ *) FILE_MAN_SUFFIX=5  ;;
     esac
 fi
 if test x$FILE_MAN_DIR = x    ; then
@@ -9969,9 +10056,9 @@ if test x$FILE_MAN_DIR = x    ; then
 fi
 
 if test x$MISC_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) MISC_MAN_SUFFIX=5  ;;
- *) MISC_MAN_SUFFIX=7  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) MISC_MAN_SUFFIX=5  ;;
+ *) MISC_MAN_SUFFIX=7  ;;
     esac
 fi
 if test x$MISC_MAN_DIR = x    ; then
@@ -9979,9 +10066,9 @@ if test x$MISC_MAN_DIR = x    ; then
 fi
 
 if test x$DRIVER_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) DRIVER_MAN_SUFFIX=7  ;;
- *) DRIVER_MAN_SUFFIX=4  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) DRIVER_MAN_SUFFIX=7  ;;
+ *) DRIVER_MAN_SUFFIX=4  ;;
     esac
 fi
 if test x$DRIVER_MAN_DIR = x    ; then
@@ -9989,9 +10076,9 @@ if test x$DRIVER_MAN_DIR = x    ; then
 fi
 
 if test x$ADMIN_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) ADMIN_MAN_SUFFIX=1m ;;
- *) ADMIN_MAN_SUFFIX=8  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) ADMIN_MAN_SUFFIX=1m ;;
+ *) ADMIN_MAN_SUFFIX=8  ;;
     esac
 fi
 if test x$ADMIN_MAN_DIR = x    ; then
@@ -10252,13 +10339,24 @@ m4_ifval([$1],
 fi])
 
 # Test for the ability of xmlto to generate a text target
+#
+# NOTE: xmlto 0.0.27 or higher return a non-zero return code in the
+# following test for empty XML docbook files.
+# For compatibility reasons use the following empty XML docbook file and if
+# it fails try it again with a non-empty XML file.
 have_xmlto_text=no
 cat > conftest.xml << "EOF"
 EOF
 AS_IF([test "$have_xmlto" = yes],
       [AS_IF([$XMLTO --skip-validation txt conftest.xml >/dev/null 2>&1],
              [have_xmlto_text=yes],
-             [AC_MSG_WARN([xmlto cannot generate text format, this format skipped])])])
+             [# Try it again with a non-empty XML file.
+              cat > conftest.xml << "EOF"
+<x></x>
+EOF
+              AS_IF([$XMLTO --skip-validation txt conftest.xml >/dev/null 2>&1],
+                    [have_xmlto_text=yes],
+                    [AC_MSG_WARN([xmlto cannot generate text format, this format skipped])])])])
 rm -f conftest.xml
 AM_CONDITIONAL([HAVE_XMLTO_TEXT], [test $have_xmlto_text = yes])
 AM_CONDITIONAL([HAVE_XMLTO], [test "$have_xmlto" = yes])
@@ -11654,8 +11752,9 @@ AC_REQUIRE([PKG_PROG_PKG_CONFIG])
 macros_datadir=`$PKG_CONFIG --print-errors --variable=pkgdatadir xorg-macros`
 INSTALL_CMD="(cp -f "$macros_datadir/INSTALL" \$(top_srcdir)/.INSTALL.tmp && \
 mv \$(top_srcdir)/.INSTALL.tmp \$(top_srcdir)/INSTALL) \
-|| (rm -f \$(top_srcdir)/.INSTALL.tmp; touch \$(top_srcdir)/INSTALL; \
-echo 'util-macros \"pkgdatadir\" from xorg-macros.pc not found: installing possibly empty INSTALL.' >&2)"
+|| (rm -f \$(top_srcdir)/.INSTALL.tmp; test -e \$(top_srcdir)/INSTALL || ( \
+touch \$(top_srcdir)/INSTALL; \
+echo 'failed to copy INSTALL from util-macros: installing empty INSTALL.' >&2))"
 AC_SUBST([INSTALL_CMD])
 ]) # XORG_INSTALL
 dnl Copyright 2005 Red Hat, Inc
@@ -11716,10 +11815,11 @@ AC_DEFUN([XORG_RELEASE_VERSION],[
 #
 #
 AC_DEFUN([XORG_CHANGELOG], [
-CHANGELOG_CMD="(GIT_DIR=\$(top_srcdir)/.git git log > \$(top_srcdir)/.changelog.tmp && \
+CHANGELOG_CMD="((GIT_DIR=\$(top_srcdir)/.git git log > \$(top_srcdir)/.changelog.tmp) 2>/dev/null && \
 mv \$(top_srcdir)/.changelog.tmp \$(top_srcdir)/ChangeLog) \
-|| (rm -f \$(top_srcdir)/.changelog.tmp; touch \$(top_srcdir)/ChangeLog; \
-echo 'git directory not found: installing possibly empty changelog.' >&2)"
+|| (rm -f \$(top_srcdir)/.changelog.tmp; test -e \$(top_srcdir)/ChangeLog || ( \
+touch \$(top_srcdir)/ChangeLog; \
+echo 'git failed to create ChangeLog: installing empty ChangeLog.' >&2))"
 AC_SUBST([CHANGELOG_CMD])
 ]) # XORG_CHANGELOG
 
Index: configure
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/configure,v
retrieving revision 1.8
diff -u -p -u -r1.8 configure
--- configure 11 Oct 2016 22:15:03 -0000 1.8
+++ configure 25 Mar 2021 21:03:14 -0000
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for xf86-video-r128 6.9.1.
+# Generated by GNU Autoconf 2.69 for xf86-video-r128 6.12.0.
 #
 # Report bugs to <https://bugs.freedesktop.org/enter_bug.cgi?product=xorg>.
 #
@@ -591,8 +591,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='xf86-video-r128'
 PACKAGE_TARNAME='xf86-video-r128'
-PACKAGE_VERSION='6.9.1'
-PACKAGE_STRING='xf86-video-r128 6.9.1'
+PACKAGE_VERSION='6.12.0'
+PACKAGE_STRING='xf86-video-r128 6.12.0'
 PACKAGE_BUGREPORT='https://bugs.freedesktop.org/enter_bug.cgi?product=xorg'
 PACKAGE_URL=''
 
@@ -775,6 +775,7 @@ infodir
 docdir
 oldincludedir
 includedir
+runstatedir
 localstatedir
 sharedstatedir
 sysconfdir
@@ -872,6 +873,7 @@ datadir='${datarootdir}'
 sysconfdir='${prefix}/etc'
 sharedstatedir='${prefix}/com'
 localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
 includedir='${prefix}/include'
 oldincludedir='/usr/include'
 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
@@ -1124,6 +1126,15 @@ do
   | -silent | --silent | --silen | --sile | --sil)
     silent=yes ;;
 
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
     ac_prev=sbindir ;;
   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
@@ -1261,7 +1272,7 @@ fi
 for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
  datadir sysconfdir sharedstatedir localstatedir includedir \
  oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
- libdir localedir mandir
+ libdir localedir mandir runstatedir
 do
   eval ac_val=\$$ac_var
   # Remove trailing slashes.
@@ -1374,7 +1385,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures xf86-video-r128 6.9.1 to adapt to many kinds of systems.
+\`configure' configures xf86-video-r128 6.12.0 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1414,6 +1425,7 @@ Fine tuning of the installation director
   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
   --libdir=DIR            object code libraries [EPREFIX/lib]
   --includedir=DIR        C header files [PREFIX/include]
   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
@@ -1444,7 +1456,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of xf86-video-r128 6.9.1:";;
+     short | recursive ) echo "Configuration of xf86-video-r128 6.12.0:";;
    esac
   cat <<\_ACEOF
 
@@ -1580,7 +1592,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-xf86-video-r128 configure 6.9.1
+xf86-video-r128 configure 6.12.0
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -1995,7 +2007,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by xf86-video-r128 $as_me 6.9.1, which was
+It was created by xf86-video-r128 $as_me 6.12.0, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -2824,7 +2836,7 @@ fi
 
 # Define the identity of the package.
  PACKAGE='xf86-video-r128'
- VERSION='6.9.1'
+ VERSION='6.12.0'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -10468,10 +10480,11 @@ _ACEOF
 
 
 
-CHANGELOG_CMD="(GIT_DIR=\$(top_srcdir)/.git git log > \$(top_srcdir)/.changelog.tmp && \
+CHANGELOG_CMD="((GIT_DIR=\$(top_srcdir)/.git git log > \$(top_srcdir)/.changelog.tmp) 2>/dev/null && \
 mv \$(top_srcdir)/.changelog.tmp \$(top_srcdir)/ChangeLog) \
-|| (rm -f \$(top_srcdir)/.changelog.tmp; touch \$(top_srcdir)/ChangeLog; \
-echo 'git directory not found: installing possibly empty changelog.' >&2)"
+|| (rm -f \$(top_srcdir)/.changelog.tmp; test -e \$(top_srcdir)/ChangeLog || ( \
+touch \$(top_srcdir)/ChangeLog; \
+echo 'git failed to create ChangeLog: installing empty ChangeLog.' >&2))"
 
 
 
@@ -10479,13 +10492,44 @@ echo 'git directory not found: installin
 macros_datadir=`$PKG_CONFIG --print-errors --variable=pkgdatadir xorg-macros`
 INSTALL_CMD="(cp -f "$macros_datadir/INSTALL" \$(top_srcdir)/.INSTALL.tmp && \
 mv \$(top_srcdir)/.INSTALL.tmp \$(top_srcdir)/INSTALL) \
-|| (rm -f \$(top_srcdir)/.INSTALL.tmp; touch \$(top_srcdir)/INSTALL; \
-echo 'util-macros \"pkgdatadir\" from xorg-macros.pc not found: installing possibly empty INSTALL.' >&2)"
+|| (rm -f \$(top_srcdir)/.INSTALL.tmp; test -e \$(top_srcdir)/INSTALL || ( \
+touch \$(top_srcdir)/INSTALL; \
+echo 'failed to copy INSTALL from util-macros: installing empty INSTALL.' >&2))"
+
 
 
 
 
 
+case $host_os in
+    solaris*)
+        # Solaris 2.0 - 11.3 use SysV man page section numbers, so we
+        # check for a man page file found in later versions that use
+        # traditional section numbers instead
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for /usr/share/man/man7/attributes.7" >&5
+$as_echo_n "checking for /usr/share/man/man7/attributes.7... " >&6; }
+if ${ac_cv_file__usr_share_man_man7_attributes_7+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  test "$cross_compiling" = yes &&
+  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
+if test -r "/usr/share/man/man7/attributes.7"; then
+  ac_cv_file__usr_share_man_man7_attributes_7=yes
+else
+  ac_cv_file__usr_share_man_man7_attributes_7=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_file__usr_share_man_man7_attributes_7" >&5
+$as_echo "$ac_cv_file__usr_share_man_man7_attributes_7" >&6; }
+if test "x$ac_cv_file__usr_share_man_man7_attributes_7" = xyes; then :
+  SYSV_MAN_SECTIONS=false
+else
+  SYSV_MAN_SECTIONS=true
+fi
+
+        ;;
+    *) SYSV_MAN_SECTIONS=false ;;
+esac
 
 if test x$APP_MAN_SUFFIX = x    ; then
     APP_MAN_SUFFIX=1
@@ -10502,9 +10546,9 @@ if test x$LIB_MAN_DIR = x    ; then
 fi
 
 if test x$FILE_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) FILE_MAN_SUFFIX=4  ;;
- *) FILE_MAN_SUFFIX=5  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) FILE_MAN_SUFFIX=4  ;;
+ *) FILE_MAN_SUFFIX=5  ;;
     esac
 fi
 if test x$FILE_MAN_DIR = x    ; then
@@ -10512,9 +10556,9 @@ if test x$FILE_MAN_DIR = x    ; then
 fi
 
 if test x$MISC_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) MISC_MAN_SUFFIX=5  ;;
- *) MISC_MAN_SUFFIX=7  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) MISC_MAN_SUFFIX=5  ;;
+ *) MISC_MAN_SUFFIX=7  ;;
     esac
 fi
 if test x$MISC_MAN_DIR = x    ; then
@@ -10522,9 +10566,9 @@ if test x$MISC_MAN_DIR = x    ; then
 fi
 
 if test x$DRIVER_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) DRIVER_MAN_SUFFIX=7  ;;
- *) DRIVER_MAN_SUFFIX=4  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) DRIVER_MAN_SUFFIX=7  ;;
+ *) DRIVER_MAN_SUFFIX=4  ;;
     esac
 fi
 if test x$DRIVER_MAN_DIR = x    ; then
@@ -10532,9 +10576,9 @@ if test x$DRIVER_MAN_DIR = x    ; then
 fi
 
 if test x$ADMIN_MAN_SUFFIX = x    ; then
-    case $host_os in
- solaris*) ADMIN_MAN_SUFFIX=1m ;;
- *) ADMIN_MAN_SUFFIX=8  ;;
+    case $SYSV_MAN_SECTIONS in
+ true) ADMIN_MAN_SUFFIX=1m ;;
+ *) ADMIN_MAN_SUFFIX=8  ;;
     esac
 fi
 if test x$ADMIN_MAN_DIR = x    ; then
@@ -10614,30 +10658,6 @@ AM_BACKSLASH='\'
 
 
 
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
-$as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
-    # Check whether --enable-maintainer-mode was given.
-if test "${enable_maintainer_mode+set}" = set; then :
-  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
-else
-  USE_MAINTAINER_MODE=no
-fi
-
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
-$as_echo "$USE_MAINTAINER_MODE" >&6; }
-   if test $USE_MAINTAINER_MODE = yes; then
-  MAINTAINER_MODE_TRUE=
-  MAINTAINER_MODE_FALSE='#'
-else
-  MAINTAINER_MODE_TRUE='#'
-  MAINTAINER_MODE_FALSE=
-fi
-
-  MAINT=$MAINTAINER_MODE_TRUE
-
-
-
 # Initialize libtool
 # Check whether --enable-static was given.
 if test "${enable_static+set}" = set; then :
@@ -17962,19 +17982,19 @@ $as_echo "$_EXT_CHECK" >&6; }
 # Obtain compiler/linker options for the driver dependencies
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XORG" >&5
-$as_echo_n "checking for XORG... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES" >&5
+$as_echo_n "checking for xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES... " >&6; }
 
 if test -n "$XORG_CFLAGS"; then
     pkg_cv_XORG_CFLAGS="$XORG_CFLAGS"
  elif test -n "$PKG_CONFIG"; then
     if test -n "$PKG_CONFIG" && \
-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xorg-server >= 1.2 xproto fontsproto \$REQUIRED_MODULES\""; } >&5
-  ($PKG_CONFIG --exists --print-errors "xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES") 2>&5
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xorg-server >= 1.3 xproto fontsproto \$REQUIRED_MODULES\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES") 2>&5
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
-  pkg_cv_XORG_CFLAGS=`$PKG_CONFIG --cflags "xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES" 2>/dev/null`
+  pkg_cv_XORG_CFLAGS=`$PKG_CONFIG --cflags "xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES" 2>/dev/null`
       test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
@@ -17986,12 +18006,12 @@ if test -n "$XORG_LIBS"; then
     pkg_cv_XORG_LIBS="$XORG_LIBS"
  elif test -n "$PKG_CONFIG"; then
     if test -n "$PKG_CONFIG" && \
-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xorg-server >= 1.2 xproto fontsproto \$REQUIRED_MODULES\""; } >&5
-  ($PKG_CONFIG --exists --print-errors "xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES") 2>&5
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"xorg-server >= 1.3 xproto fontsproto \$REQUIRED_MODULES\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES") 2>&5
   ac_status=$?
   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
-  pkg_cv_XORG_LIBS=`$PKG_CONFIG --libs "xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES" 2>/dev/null`
+  pkg_cv_XORG_LIBS=`$PKG_CONFIG --libs "xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES" 2>/dev/null`
       test "x$?" != "x0" && pkg_failed=yes
 else
   pkg_failed=yes
@@ -18003,7 +18023,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -18012,14 +18032,14 @@ else
         _pkg_short_errors_supported=no
 fi
         if test $_pkg_short_errors_supported = yes; then
-        XORG_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES" 2>&1`
+        XORG_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES" 2>&1`
         else
-        XORG_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES" 2>&1`
+        XORG_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES" 2>&1`
         fi
  # Put the nasty error message in config.log where it belongs
  echo "$XORG_PKG_ERRORS" >&5
 
- as_fn_error $? "Package requirements (xorg-server >= 1.2 xproto fontsproto $REQUIRED_MODULES) were not met:
+ as_fn_error $? "Package requirements (xorg-server >= 1.3 xproto fontsproto $REQUIRED_MODULES) were not met:
 
 $XORG_PKG_ERRORS
 
@@ -18030,7 +18050,7 @@ Alternatively, you may set the environme
 and XORG_LIBS to avoid the need to call pkg-config.
 See the pkg-config man page for more details." "$LINENO" 5
 elif test $pkg_failed = untried; then
-     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
@@ -18053,8 +18073,8 @@ $as_echo "yes" >&6; }
 fi
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XEXT" >&5
-$as_echo_n "checking for XEXT... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for xextproto >= 7.0.99.1" >&5
+$as_echo_n "checking for xextproto >= 7.0.99.1... " >&6; }
 
 if test -n "$XEXT_CFLAGS"; then
     pkg_cv_XEXT_CFLAGS="$XEXT_CFLAGS"
@@ -18094,7 +18114,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -18112,7 +18132,7 @@ fi
 
  HAVE_XEXTPROTO_71="no"
 elif test $pkg_failed = untried; then
-     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
  HAVE_XEXTPROTO_71="no"
 else
@@ -18137,98 +18157,26 @@ sdkdir=`$PKG_CONFIG --variable=sdkdir xo
 # Checks for libraries.
 
 if test "$DRI" != no; then
- as_ac_File=`$as_echo "ac_cv_file_${sdkdir}/dri.h" | $as_tr_sh`
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${sdkdir}/dri.h" >&5
-$as_echo_n "checking for ${sdkdir}/dri.h... " >&6; }
-if eval \${$as_ac_File+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  test "$cross_compiling" = yes &&
-  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
-if test -r "${sdkdir}/dri.h"; then
-  eval "$as_ac_File=yes"
-else
-  eval "$as_ac_File=no"
-fi
-fi
-eval ac_res=\$$as_ac_File
-       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-if eval test \"x\$"$as_ac_File"\" = x"yes"; then :
-  have_dri_h="yes"
-else
-  have_dri_h="no"
-fi
-
- as_ac_File=`$as_echo "ac_cv_file_${sdkdir}/sarea.h" | $as_tr_sh`
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${sdkdir}/sarea.h" >&5
-$as_echo_n "checking for ${sdkdir}/sarea.h... " >&6; }
-if eval \${$as_ac_File+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  test "$cross_compiling" = yes &&
-  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
-if test -r "${sdkdir}/sarea.h"; then
-  eval "$as_ac_File=yes"
-else
-  eval "$as_ac_File=no"
-fi
-fi
-eval ac_res=\$$as_ac_File
-       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-if eval test \"x\$"$as_ac_File"\" = x"yes"; then :
-  have_sarea_h="yes"
-else
-  have_sarea_h="no"
-fi
-
- as_ac_File=`$as_echo "ac_cv_file_${sdkdir}/dristruct.h" | $as_tr_sh`
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${sdkdir}/dristruct.h" >&5
-$as_echo_n "checking for ${sdkdir}/dristruct.h... " >&6; }
-if eval \${$as_ac_File+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  test "$cross_compiling" = yes &&
-  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
-if test -r "${sdkdir}/dristruct.h"; then
-  eval "$as_ac_File=yes"
-else
-  eval "$as_ac_File=no"
-fi
-fi
-eval ac_res=\$$as_ac_File
-       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-if eval test \"x\$"$as_ac_File"\" = x"yes"; then :
-  have_dristruct_h="yes"
-else
-  have_dristruct_h="no"
-fi
-
- as_ac_File=`$as_echo "ac_cv_file_${sdkdir}/damage.h" | $as_tr_sh`
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${sdkdir}/damage.h" >&5
-$as_echo_n "checking for ${sdkdir}/damage.h... " >&6; }
-if eval \${$as_ac_File+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  test "$cross_compiling" = yes &&
-  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
-if test -r "${sdkdir}/damage.h"; then
-  eval "$as_ac_File=yes"
-else
-  eval "$as_ac_File=no"
-fi
-fi
-eval ac_res=\$$as_ac_File
-       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-if eval test \"x\$"$as_ac_File"\" = x"yes"; then :
-  have_damage_h="yes"
-else
-  have_damage_h="no"
-fi
-
+ if test -f "${sdkdir}/dri.h"; then
+ have_dri_h="yes"
+ else
+ have_dri_h="no"
+ fi
+ if test -f "${sdkdir}/sarea.h"; then
+ have_sarea_h="yes"
+ else
+ have_sarea_h="no"
+ fi
+ if test -f "${sdkdir}/dristruct.h"; then
+ have_dristruct_h="yes"
+ else
+ have_dristruct_h="no"
+ fi
+ if test -f "${sdkdir}/damage.h"; then
+ have_damage_h="yes"
+ else
+ have_damage_h="no"
+ fi
 fi
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include DRI support" >&5
@@ -18256,8 +18204,8 @@ fi
 if test "$DRI" = yes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DRI" >&5
-$as_echo_n "checking for DRI... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libdrm >= 2.2 xf86driproto" >&5
+$as_echo_n "checking for libdrm >= 2.2 xf86driproto... " >&6; }
 
 if test -n "$DRI_CFLAGS"; then
     pkg_cv_DRI_CFLAGS="$DRI_CFLAGS"
@@ -18297,7 +18245,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -18324,7 +18272,7 @@ Alternatively, you may set the environme
 and DRI_LIBS to avoid the need to call pkg-config.
 See the pkg-config man page for more details." "$LINENO" 5
 elif test $pkg_failed = untried; then
-     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
@@ -18361,29 +18309,11 @@ $as_echo_n "checking whether to enable E
 if test "x$EXA" = xyes; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
- as_ac_File=`$as_echo "ac_cv_file_${sdkdir}/exa.h" | $as_tr_sh`
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${sdkdir}/exa.h" >&5
-$as_echo_n "checking for ${sdkdir}/exa.h... " >&6; }
-if eval \${$as_ac_File+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  test "$cross_compiling" = yes &&
-  as_fn_error $? "cannot check for file existence when cross compiling" "$LINENO" 5
-if test -r "${sdkdir}/exa.h"; then
-  eval "$as_ac_File=yes"
-else
-  eval "$as_ac_File=no"
-fi
-fi
-eval ac_res=\$$as_ac_File
-       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-if eval test \"x\$"$as_ac_File"\" = x"yes"; then :
+        if test -f "${sdkdir}/exa.h"; then :
   have_exa_h="yes"
 else
   have_exa_h="no"
 fi
-
 else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
@@ -18397,7 +18327,7 @@ $as_echo_n "checking whether EXA version
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-#include <xorg-server.h>
+#include "xorg-server.h"
 #include "exa.h"
 #if EXA_VERSION_MAJOR < 2
 #error OLD EXA!
@@ -18491,8 +18421,8 @@ fi
 if test "x$XSERVER_LIBPCIACCESS" = xyes; then
 
 pkg_failed=no
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PCIACCESS" >&5
-$as_echo_n "checking for PCIACCESS... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pciaccess >= 0.8.0" >&5
+$as_echo_n "checking for pciaccess >= 0.8.0... " >&6; }
 
 if test -n "$PCIACCESS_CFLAGS"; then
     pkg_cv_PCIACCESS_CFLAGS="$PCIACCESS_CFLAGS"
@@ -18532,7 +18462,7 @@ fi
 
 
 if test $pkg_failed = yes; then
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
 
 if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
@@ -18559,7 +18489,7 @@ Alternatively, you may set the environme
 and PCIACCESS_LIBS to avoid the need to call pkg-config.
 See the pkg-config man page for more details." "$LINENO" 5
 elif test $pkg_failed = untried; then
-     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 $as_echo "no" >&6; }
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
@@ -18870,10 +18800,6 @@ if test -z "${am__fastdepCC_TRUE}" && te
   as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
-if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
-  as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
 if test -z "${HAVE_XEXTPROTO_71_TRUE}" && test -z "${HAVE_XEXTPROTO_71_FALSE}"; then
   as_fn_error $? "conditional \"HAVE_XEXTPROTO_71\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
@@ -19291,7 +19217,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by xf86-video-r128 $as_me 6.9.1, which was
+This file was extended by xf86-video-r128 $as_me 6.12.0, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -19357,7 +19283,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-xf86-video-r128 config.status 6.9.1
+xf86-video-r128 config.status 6.12.0
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
Index: configure.ac
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/configure.ac,v
retrieving revision 1.6
diff -u -p -u -r1.6 configure.ac
--- configure.ac 4 Apr 2016 20:09:20 -0000 1.6
+++ configure.ac 25 Mar 2021 21:03:14 -0000
@@ -23,7 +23,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([xf86-video-r128],
-        [6.9.1],
+        [6.12.0],
         [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
         [xf86-video-r128])
 AC_CONFIG_SRCDIR([Makefile.am])
@@ -39,8 +39,6 @@ m4_ifndef([XORG_MACROS_VERSION],
 XORG_MACROS_VERSION(1.8)
 XORG_DEFAULT_OPTIONS
 
-AM_MAINTAINER_MODE
-
 # Initialize libtool
 AC_DISABLE_STATIC
 AC_PROG_LIBTOOL
@@ -76,7 +74,7 @@ XORG_DRIVER_CHECK_EXT(XF86MISC, xf86misc
 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")
@@ -86,14 +84,26 @@ sdkdir=`$PKG_CONFIG --variable=sdkdir xo
 # Checks for libraries.
 
 if test "$DRI" != no; then
- AC_CHECK_FILE([${sdkdir}/dri.h],
-                      [have_dri_h="yes"], [have_dri_h="no"])
- AC_CHECK_FILE([${sdkdir}/sarea.h],
-                      [have_sarea_h="yes"], [have_sarea_h="no"])
- AC_CHECK_FILE([${sdkdir}/dristruct.h],
-                      [have_dristruct_h="yes"], [have_dristruct_h="no"])
- AC_CHECK_FILE([${sdkdir}/damage.h],
-                      [have_damage_h="yes"], [have_damage_h="no"])
+ if test -f "${sdkdir}/dri.h"; then
+ have_dri_h="yes"
+ else
+ have_dri_h="no"
+ fi
+ if test -f "${sdkdir}/sarea.h"; then
+ have_sarea_h="yes"
+ else
+ have_sarea_h="no"
+ fi
+ if test -f "${sdkdir}/dristruct.h"; then
+ have_dristruct_h="yes"
+ else
+ have_dristruct_h="no"
+ fi
+ if test -f "${sdkdir}/damage.h"; then
+ have_damage_h="yes"
+ else
+ have_damage_h="no"
+ fi
 fi
 
 AC_MSG_CHECKING([whether to include DRI support])
@@ -121,7 +131,7 @@ CPPFLAGS="$CPPFLAGS $XORG_CFLAGS"
 AC_MSG_CHECKING([whether to enable EXA support])
 if test "x$EXA" = xyes; then
         AC_MSG_RESULT(yes)
- AC_CHECK_FILE(${sdkdir}/exa.h, [have_exa_h="yes"], [have_exa_h="no"])
+        AS_IF([test -f "${sdkdir}/exa.h"], [have_exa_h="yes"], [have_exa_h="no"])
 else
         AC_MSG_RESULT(no)
 fi
@@ -131,7 +141,7 @@ CPPFLAGS="$CPPFLAGS $XORG_CFLAGS"
 if test "x$have_exa_h" = xyes; then
         AC_MSG_CHECKING([whether EXA version is at least 2.0.0])
         AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
-#include <xorg-server.h>
+#include "xorg-server.h"
 #include "exa.h"
 #if EXA_VERSION_MAJOR < 2
 #error OLD EXA!
Index: man/Makefile.in
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/man/Makefile.in,v
retrieving revision 1.7
diff -u -p -u -r1.7 Makefile.in
--- man/Makefile.in 4 Apr 2016 20:10:51 -0000 1.7
+++ man/Makefile.in 25 Mar 2021 21:03:14 -0000
@@ -271,6 +271,7 @@ pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
+runstatedir = @runstatedir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
Index: man/r128.man
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/man/r128.man,v
retrieving revision 1.4
diff -u -p -u -r1.4 r128.man
--- man/r128.man 23 Nov 2012 20:47:04 -0000 1.4
+++ man/r128.man 25 Mar 2021 21:03:14 -0000
@@ -78,34 +78,10 @@ stable.  EXA is a newer acceleration arc
 the Render and Composite extensions.  The default is
 .B XAA.
 .TP
-.BI "Option \*qDac6Bit\*q \*q" boolean \*q
-Enables or disables the use of 6 bits per color component when in 8 bpp
-mode (emulates VGA mode).  By default, all 8 bits per color component
-are used.  The default is
-.B off.
-.TP
 .BI "Option \*qVideoKey\*q \*q" integer \*q
 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
Index: src/Makefile.am
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/Makefile.am,v
retrieving revision 1.3
diff -u -p -u -r1.3 Makefile.am
--- src/Makefile.am 23 Nov 2012 20:47:04 -0000 1.3
+++ src/Makefile.am 25 Mar 2021 21:03:14 -0000
@@ -31,7 +31,9 @@ R128_DRI_SRCS = r128_dri.c
 endif
 
 if USE_EXA
-R128_EXA_SRCS = r128_exa.c
+R128_EXA_SRCS = \
+ r128_exa.c \
+ r128_exa_render.c
 endif
 
 AM_CFLAGS = @XORG_CFLAGS@ @DRI_CFLAGS@
@@ -40,18 +42,26 @@ 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_video.c r128_misc.c r128_probe.c $(R128_EXA_SRCS) $(R128_DRI_SRCS)
+ r128_accel.c \
+ r128_crtc.c \
+ r128_cursor.c \
+ r128_driver.c \
+ r128_misc.c \
+ r128_output.c \
+ r128_probe.c \
+ r128_video.c \
+ $(R128_EXA_SRCS) \
+ $(R128_DRI_SRCS)
 
 EXTRA_DIST = \
-        compat-api.h \
+ compat-api.h \
+ r128.h \
  r128_common.h \
  r128_dri.h \
  r128_dripriv.h \
- r128.h \
  r128_probe.h \
  r128_reg.h \
+ r128_rop.h \
  r128_sarea.h \
  r128_version.h \
- r128_exa_render.c \
  atipcirename.h
Index: src/Makefile.in
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/Makefile.in,v
retrieving revision 1.7
diff -u -p -u -r1.7 Makefile.in
--- src/Makefile.in 4 Apr 2016 20:10:51 -0000 1.7
+++ src/Makefile.in 25 Mar 2021 21:03:14 -0000
@@ -118,14 +118,14 @@ am__uninstall_files_from_dir = { \
 am__installdirs = "$(DESTDIR)$(r128_drv_ladir)"
 LTLIBRARIES = $(r128_drv_la_LTLIBRARIES)
 r128_drv_la_LIBADD =
-am__r128_drv_la_SOURCES_DIST = r128_accel.c r128_cursor.c r128_dga.c \
- r128_driver.c r128_video.c r128_misc.c r128_probe.c r128_exa.c \
- r128_dri.c
-@USE_EXA_TRUE@am__objects_1 = r128_exa.lo
+am__r128_drv_la_SOURCES_DIST = r128_accel.c r128_crtc.c r128_cursor.c \
+ r128_driver.c r128_misc.c r128_output.c r128_probe.c \
+ r128_video.c r128_exa.c r128_exa_render.c r128_dri.c
+@USE_EXA_TRUE@am__objects_1 = r128_exa.lo r128_exa_render.lo
 @DRI_TRUE@am__objects_2 = r128_dri.lo
-am_r128_drv_la_OBJECTS = r128_accel.lo r128_cursor.lo r128_dga.lo \
- r128_driver.lo r128_video.lo r128_misc.lo r128_probe.lo \
- $(am__objects_1) $(am__objects_2)
+am_r128_drv_la_OBJECTS = r128_accel.lo r128_crtc.lo r128_cursor.lo \
+ r128_driver.lo r128_misc.lo r128_output.lo r128_probe.lo \
+ r128_video.lo $(am__objects_1) $(am__objects_2)
 r128_drv_la_OBJECTS = $(am_r128_drv_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@@ -317,6 +317,7 @@ pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
+runstatedir = @runstatedir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
@@ -326,26 +327,37 @@ top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 @DRI_TRUE@R128_DRI_SRCS = r128_dri.c
-@USE_EXA_TRUE@R128_EXA_SRCS = r128_exa.c
+@USE_EXA_TRUE@R128_EXA_SRCS = \
+@USE_EXA_TRUE@ r128_exa.c \
+@USE_EXA_TRUE@ r128_exa_render.c
+
 AM_CFLAGS = @XORG_CFLAGS@ @DRI_CFLAGS@
 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_video.c r128_misc.c r128_probe.c $(R128_EXA_SRCS) $(R128_DRI_SRCS)
+ r128_accel.c \
+ r128_crtc.c \
+ r128_cursor.c \
+ r128_driver.c \
+ r128_misc.c \
+ r128_output.c \
+ r128_probe.c \
+ r128_video.c \
+ $(R128_EXA_SRCS) \
+ $(R128_DRI_SRCS)
 
 EXTRA_DIST = \
-        compat-api.h \
+ compat-api.h \
+ r128.h \
  r128_common.h \
  r128_dri.h \
  r128_dripriv.h \
- r128.h \
  r128_probe.h \
  r128_reg.h \
+ r128_rop.h \
  r128_sarea.h \
  r128_version.h \
- r128_exa_render.c \
  atipcirename.h
 
 all: all-am
@@ -426,12 +438,14 @@ distclean-compile:
  -rm -f *.tab.c
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_accel.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_crtc.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_cursor.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_dga.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_dri.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_driver.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_exa.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_exa_render.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_misc.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_output.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_probe.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/r128_video.Plo@am__quote@
 
Index: src/compat-api.h
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/compat-api.h,v
retrieving revision 1.2
diff -u -p -u -r1.2 compat-api.h
--- src/compat-api.h 18 Feb 2017 18:29:55 -0000 1.2
+++ src/compat-api.h 25 Mar 2021 21:03:14 -0000
@@ -48,8 +48,13 @@
 
 #define SCREEN_INIT_ARGS_DECL int i, ScreenPtr pScreen, int argc, char **argv
 
+#if ABI_VIDEODRV_VERSION >= SET_ABI_VERSION(23, 0)
+#define BLOCKHANDLER_ARGS_DECL ScreenPtr arg, pointer pTimeout
+#define BLOCKHANDLER_ARGS arg, pTimeout
+#else    
 #define BLOCKHANDLER_ARGS_DECL int arg, pointer blockData, pointer pTimeout, pointer pReadmask
 #define BLOCKHANDLER_ARGS arg, blockData, pTimeout, pReadmask
+#endif
 
 #define CLOSE_SCREEN_ARGS_DECL int scrnIndex, ScreenPtr pScreen
 #define CLOSE_SCREEN_ARGS scrnIndex, pScreen
Index: src/r128.h
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128.h,v
retrieving revision 1.5
diff -u -p -u -r1.5 r128.h
--- src/r128.h 23 Aug 2015 17:40:49 -0000 1.5
+++ src/r128.h 25 Mar 2021 21:03:14 -0000
@@ -70,10 +70,10 @@
 #define _XF86DRI_SERVER_
 #include "r128_dripriv.h"
 #include "dri.h"
-#include "GL/glxint.h"
 #endif
 
 #include "fb.h"
+#include "xf86Crtc.h"
 
 #include "compat-api.h"
 #include "atipcirename.h"
@@ -120,13 +120,14 @@
 #if R128_DEBUG
 #include "r128_version.h"
 
-#define R128TRACE(x)                                          \
-    do {                                                      \
- ErrorF("(**) %s(%d): ", R128_NAME, pScrn->scrnIndex); \
- ErrorF x;                                             \
-    } while (0);
+#endif
+
+#if R128_DEBUG
+#define DEBUG(x) x
+
 #else
-#define R128TRACE(x)
+#define DEBUG(x)
+
 #endif
 
 
@@ -135,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    */
@@ -150,105 +159,106 @@ typedef struct {        /* All values in
 
 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   ppll_div_0;
+    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 {
@@ -260,16 +270,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;
@@ -305,7 +305,6 @@ typedef struct {
     PCITAG            PciTag;
 #endif
     int               Chipset;
-    Bool              Primary;
 
     Bool              FBDev;
 
@@ -315,28 +314,13 @@ typedef struct {
 
     void              *MMIO;        /* Map of MMIO region                    */
     void              *FB;          /* Map of frame buffer                   */
+    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        */
-    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;
     R128RAMPtr        ram;
@@ -351,8 +335,9 @@ typedef struct {
 #ifdef HAVE_XAA_H
     XAAInfoRecPtr     accel;
 #endif
-    Bool              accelOn;
 
+    Bool              noAccel;
+    Bool              accelOn;
     Bool      useEXA;
     Bool      RenderAccel;
 #ifdef USE_EXA
@@ -361,24 +346,15 @@ 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.
-     */
-    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?                        */
+    Bool              swCursor;
 
  /* 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;
@@ -403,30 +379,21 @@ 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;
     DRIInfoPtr        pDRIInfo;
     int               drmFD;
-    drm_context_t        drmCtx;
-    int               numVisualConfigs;
-    __GLXvisualConfig *pVisualConfigs;
-    R128ConfigPrivPtr pVisualConfigsPriv;
+    drm_context_t     drmCtx;
 
-    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 */
@@ -434,7 +401,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;
@@ -447,20 +414,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 */
@@ -469,7 +436,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 */
@@ -499,18 +466,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
@@ -523,19 +490,10 @@ typedef struct {
 
     Bool              isDFP;
     Bool              isPro2;
-    I2CBusPtr         pI2CBus;
-    CARD32            DDCReg;
+    Bool              SwitchingMode;
+    Bool              DDC;
 
     Bool              VGAAccess;
-
-    /****** Added for dualhead support *******************/
-    BOOL              HasCRTC2;     /* M3/M4 */
-    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)                                      \
@@ -544,6 +502,12 @@ do {                                    
     info->fifo_slots -= entries;                                             \
 } while (0)
 
+/* Compute n/d with rounding. */
+static inline int R128Div(int n, int d)
+{
+    return (n + (d / 2)) / d;
+}
+
 extern R128EntPtr R128EntPriv(ScrnInfoPtr pScrn);
 extern void        R128WaitForFifoFunction(ScrnInfoPtr pScrn, int entries);
 extern void        R128WaitForIdle(ScrnInfoPtr pScrn);
@@ -553,15 +517,48 @@ extern void        R128EngineFlush(ScrnI
 extern unsigned    R128INPLL(ScrnInfoPtr pScrn, int addr);
 extern void        R128WaitForVerticalSync(ScrnInfoPtr pScrn);
 
-extern Bool        R128AccelInit(ScreenPtr pScreen);
+extern Bool R128XAAAccelInit(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);
 
 extern void        R128InitVideo(ScreenPtr pScreen);
 
+extern void        R128InitCommonRegisters(R128SavePtr save, R128InfoPtr info);
+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 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);
+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 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);
+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
 extern Bool        R128DRIScreenInit(ScreenPtr pScreen);
 extern void        R128DRICloseScreen(ScreenPtr pScreen);
@@ -604,13 +601,38 @@ extern void        R128CCEFlushIndirect(
 extern void        R128CCEReleaseIndirect(ScrnInfoPtr pScrn);
 extern void        R128CCEWaitForIdle(ScrnInfoPtr pScrn);
 extern int         R128CCEStop(ScrnInfoPtr pScrn);
+extern void   R128CopySwap(uint8_t *dst, uint8_t *src, unsigned int size, int swap);
 
 #ifdef USE_EXA
-extern Bool   R128EXAInit(ScreenPtr pScreen);
+extern Bool   R128EXAInit(ScreenPtr pScreen, int total);
 extern Bool   R128GetDatatypeBpp(int bpp, uint32_t *type);
 extern Bool   R128GetPixmapOffsetPitch(PixmapPtr pPix, uint32_t *pitch_offset);
 extern void   R128DoPrepareCopy(ScrnInfoPtr pScrn, uint32_t src_pitch_offset,
     uint32_t dst_pitch_offset, uint32_t datatype, int alu, Pixel planemask);
+extern void R128Done(PixmapPtr pPixmap);
+
+#ifdef R128DRI
+extern void EmitCCE2DState(ScrnInfoPtr pScrn);
+#endif
+
+#ifdef RENDER
+extern Bool R128CCECheckComposite(int op,
+                                    PicturePtr pSrcPicture,
+                                    PicturePtr pMaskPicture,
+                                    PicturePtr pDstPicture);
+extern Bool R128CCEPrepareComposite(int op,                                    PicturePtr pSrcPicture,
+                                    PicturePtr pMaskPicture,
+                                    PicturePtr pDstPicture,
+                                    PixmapPtr pSrc,
+                                    PixmapPtr pMask,
+                                    PixmapPtr pDst);
+extern void R128CCEComposite(PixmapPtr pDst,
+                                int srcX, int srcY,
+                                int maskX, int maskY,
+                                int dstX, int dstY,
+                                int w, int h);
+#define R128CCEDoneComposite R128Done
+#endif
 #endif
 
 
@@ -626,7 +648,7 @@ extern void   R128DoPrepareCopy(ScrnInf
 
 #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 { \
@@ -667,12 +689,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 { \
Index: src/r128_accel.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_accel.c,v
retrieving revision 1.4
diff -u -p -u -r1.4 r128_accel.c
--- src/r128_accel.c 23 Nov 2012 20:47:04 -0000 1.4
+++ src/r128_accel.c 25 Mar 2021 21:03:14 -0000
@@ -102,27 +102,7 @@
 #include "xf86.h"
 
 #ifdef HAVE_XAA_H
-static struct {
-    int rop;
-    int pattern;
-} R128_ROP[] = {
-    { R128_ROP3_ZERO, R128_ROP3_ZERO }, /* GXclear        */
-    { R128_ROP3_DSa,  R128_ROP3_DPa  }, /* Gxand          */
-    { R128_ROP3_SDna, R128_ROP3_PDna }, /* GXandReverse   */
-    { R128_ROP3_S,    R128_ROP3_P    }, /* GXcopy         */
-    { R128_ROP3_DSna, R128_ROP3_DPna }, /* GXandInverted  */
-    { R128_ROP3_D,    R128_ROP3_D    }, /* GXnoop         */
-    { R128_ROP3_DSx,  R128_ROP3_DPx  }, /* GXxor          */
-    { R128_ROP3_DSo,  R128_ROP3_DPo  }, /* GXor           */
-    { R128_ROP3_DSon, R128_ROP3_DPon }, /* GXnor          */
-    { R128_ROP3_DSxn, R128_ROP3_PDxn }, /* GXequiv        */
-    { R128_ROP3_Dn,   R128_ROP3_Dn   }, /* GXinvert       */
-    { R128_ROP3_SDno, R128_ROP3_PDno }, /* GXorReverse    */
-    { R128_ROP3_Sn,   R128_ROP3_Pn   }, /* GXcopyInverted */
-    { R128_ROP3_DSno, R128_ROP3_DPno }, /* GXorInverted   */
-    { R128_ROP3_DSan, R128_ROP3_DPan }, /* GXnand         */
-    { R128_ROP3_ONE,  R128_ROP3_ONE  }  /* GXset          */
-};
+#include "r128_rop.h"
 #endif
 
 extern int getR128EntityIndex(void);
@@ -145,9 +125,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 +141,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);
@@ -182,10 +162,13 @@ void R128WaitForFifoFunction(ScrnInfoPtr
     info->fifo_slots = INREG(R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK;
     if (info->fifo_slots >= entries) return;
  }
- R128TRACE(("FIFO timed out: %d entries, stat=0x%08x, probe=0x%08x\n",
-   INREG(R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK,
-   INREG(R128_GUI_STAT),
-   INREG(R128_GUI_PROBE)));
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                    "FIFO timed out: %lu entries, "
+                    "stat = 0x%08lx, probe = 0x%08lx\n",
+                    INREG(R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK,
+                    INREG(R128_GUI_STAT),
+                    INREG(R128_GUI_PROBE)));
  xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
    "FIFO timed out, resetting engine...\n");
  R128EngineReset(pScrn);
@@ -216,10 +199,13 @@ void R128WaitForIdle(ScrnInfoPtr pScrn)
  return;
     }
  }
- R128TRACE(("Idle timed out: %d entries, stat=0x%08x, probe=0x%08x\n",
-   INREG(R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK,
-   INREG(R128_GUI_STAT),
-   INREG(R128_GUI_PROBE)));
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Idle timed out: %lu entries, "
+                        "stat = 0x%08lx, probe = 0x%08lx\n",
+                        INREG(R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK,
+                        INREG(R128_GUI_STAT),
+                        INREG(R128_GUI_PROBE)));
  xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
    "Idle timed out, resetting engine...\n");
 #ifdef R128DRI
@@ -450,7 +436,7 @@ static void R128SetupForDashedLine(ScrnI
 {
     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
@@ -526,10 +512,13 @@ static void R128SubsequentSolidFillTrap(
     int           origdxL   = dxL;
     int           origdxR   = dxR;
 
-    R128TRACE(("Trap %d %d; L %d %d %d %d; R %d %d %d %d\n",
-       y, h,
-       left, dxL, dyL, eL,
-       right, dxR, dyR, eR));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Trap %d %d; "
+                        "L %d %d %d %d; "
+                        "R %d %d %d %d\n",
+                        y, h,
+                        left, dxL, dyL, eL,
+                        right, dxR, dyR, eR));
 
     if (dxL < 0)    dxL = -dxL; else flags |= (1 << 0) /* | (1 << 8) */;
     if (dxR < 0)    dxR = -dxR; else flags |= (1 << 6);
@@ -590,7 +579,7 @@ static void R128SetupForScreenToScreenCo
  ? 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);
@@ -680,7 +669,9 @@ static void R128SetupForColor8x8PatternF
     R128InfoPtr   info      = R128PTR(pScrn);
     unsigned char *R128MMIO = info->MMIO;
 
-    R128TRACE(("Color8x8 %d %d %d\n", trans_color, patx, paty));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Color8x8 %d %d %d\n",
+                        trans_color, patx, paty));
 
     R128WaitForFifo(pScrn, 2);
     OUTREG(R128_DP_GUI_MASTER_CNTL, (info->dp_gui_master_cntl
@@ -708,7 +699,9 @@ static void R128SubsequentColor8x8Patter
     R128InfoPtr   info      = R128PTR(pScrn);
     unsigned char *R128MMIO = info->MMIO;
 
-    R128TRACE(("Color8x8 %d,%d %d,%d %d %d\n", patx, paty, x, y, w, h));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Color8x8 %d,%d %d,%d %d %d\n",
+                        patx, paty, x, y, w, h));
     R128WaitForFifo(pScrn, 3);
     OUTREG(R128_SRC_Y_X, (paty << 16) | patx);
     OUTREG(R128_DST_Y_X, (y << 16) | x);
@@ -847,10 +840,10 @@ static void R128SubsequentColorExpandSca
 {
     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 +970,10 @@ static void R128SubsequentImageWriteScan
 {
     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;
@@ -1017,7 +1010,10 @@ void R128EngineInit(ScrnInfoPtr pScrn)
     R128InfoPtr   info      = R128PTR(pScrn);
     unsigned char *R128MMIO = info->MMIO;
 
-    R128TRACE(("EngineInit (%d/%d)\n", info->CurrentLayout.pixel_code, info->CurrentLayout.bitsPerPixel));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "EngineInit (%d/%d)\n",
+                        info->CurrentLayout.pixel_code,
+                        info->CurrentLayout.bitsPerPixel));
 
     OUTREG(R128_SCALE_3D_CNTL, 0);
     R128EngineReset(pScrn);
@@ -1029,13 +1025,16 @@ void R128EngineInit(ScrnInfoPtr pScrn)
     case 24: info->datatype = 5; break;
     case 32: info->datatype = 6; break;
     default:
- R128TRACE(("Unknown depth/bpp = %d/%d (code = %d)\n",
-   info->CurrentLayout.depth, info->CurrentLayout.bitsPerPixel,
-   info->CurrentLayout.pixel_code));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Unknown depth/bpp = %d/%d (code = %d)\n",
+                        info->CurrentLayout.depth,
+                        info->CurrentLayout.bitsPerPixel,
+                        info->CurrentLayout.pixel_code));
     }
     info->pitch = (info->CurrentLayout.displayWidth / 8) * (info->CurrentLayout.pixel_bytes == 3 ? 3 : 1);
 
-    R128TRACE(("Pitch for acceleration = %d\n", info->pitch));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Pitch for acceleration = %d\n", info->pitch));
 
     R128WaitForFifo(pScrn, 2);
     OUTREG(R128_DEFAULT_OFFSET, pScrn->fbOffset);
@@ -1182,7 +1181,7 @@ static void R128CCESetupForScreenToScree
 
     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 );
@@ -1438,7 +1437,7 @@ static void R128CCESetupForDashedLine(Sc
    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 );
@@ -1746,7 +1745,7 @@ static void R128CCEAccelInit(ScrnInfoPtr
    | 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,75 +1850,75 @@ static void R128MMIOAccelInit(ScrnInfoPt
   | LEFT_EDGE_CLIPPING_NEGATIVE_X
   | SCANLINE_PAD_DWORD;
 
-    if(xf86IsEntityShared(pScrn->entityList[0]))
-    {
-        DevUnion* pPriv;
-        R128EntPtr pR128Ent;
-        pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
-                getR128EntityIndex());
-        pR128Ent = pPriv->ptr;
-        
-        /*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;
     }
 
 }
 #endif
 
-/* Initialize XAA for supported acceleration and also initialize the
-   graphics hardware for acceleration. */
-Bool R128AccelInit(ScreenPtr pScreen)
+void R128CopySwap(uint8_t *dst, uint8_t *src, unsigned int size, int swap)
 {
-    ScrnInfoPtr   pScrn = xf86ScreenToScrn(pScreen);
-    R128InfoPtr   info  = R128PTR(pScrn);
+    switch(swap) {
+    case APER_0_BIG_ENDIAN_32BPP_SWAP:
+ {
+    unsigned int *d = (unsigned int *)dst;
+    unsigned int *s = (unsigned int *)src;
+    unsigned int nwords = size >> 2;
 
-#ifdef USE_EXA
-    if (info->useEXA) {
-        int errmaj = 0, errmin = 0;
-
-        info->exaReq.majorversion = EXA_VERSION_MAJOR;
-        info->exaReq.minorversion = EXA_VERSION_MINOR;
-
-        xf86DrvMsg(pScrn->scrnIndex,X_INFO,"Loading EXA module...\n");
-        if (!LoadSubModule(pScrn->module, "exa", NULL, NULL, NULL, &info->exaReq, &errmaj, &errmin)) {
-            LoaderErrorMsg(NULL, "exa", errmaj, errmin);
-            return FALSE;
-        }
-
- /* Don't init EXA here because it'll be taken care of in mm init */
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Allocating EXA driver...\n");
- info->ExaDriver = exaDriverAlloc();
- if (!info->ExaDriver) {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Could not allocate EXA driver...\n");
-    info->accelOn = FALSE;
+    for (; nwords > 0; --nwords, ++d, ++s)
+#ifdef __powerpc__
+ asm volatile("stwbrx %0,0,%1" : : "r" (*s), "r" (d));
+#else
+ *d = ((*s >> 24) & 0xff) | ((*s >> 8) & 0xff00)
+ | ((*s & 0xff00) << 8) | ((*s & 0xff) << 24);
+#endif
+    return;
  }
-
- return TRUE;
-    }
+    case APER_0_BIG_ENDIAN_16BPP_SWAP:
+ {
+    unsigned short *d = (unsigned short *)dst;
+    unsigned short *s = (unsigned short *)src;
+    unsigned int nwords = size >> 1;
+
+    for (; nwords > 0; --nwords, ++d, ++s)
+#ifdef __powerpc__
+ asm volatile("sthbrx %0,0,%1" : : "r" (*s), "r" (d));
+#else
+        *d = (*s >> 8) | (*s << 8);
 #endif
+    return;
+ }
+    }
+    if (src != dst)
+ memcpy(dst, src, size);
+}
 
-#ifndef HAVE_XAA_H
-    return FALSE;
-#else
+/* Initialize XAA for supported acceleration and also initialize the
+   graphics hardware for acceleration. */
+#ifdef HAVE_XAA_H
+Bool
+R128XAAAccelInit(ScreenPtr pScreen)
+{
+    ScrnInfoPtr   pScrn = xf86ScreenToScrn(pScreen);
+    R128InfoPtr   info  = R128PTR(pScrn);
     XAAInfoRecPtr a;
 
-    if (!info->useEXA) {
-        if (!xf86LoadSubModule(pScrn, "xaa")) return FALSE;
-    }
-
     if (!(a = info->accel = XAACreateInfoRec())) return FALSE;
 
 #ifdef R128DRI
     if (info->directRenderingEnabled)
- R128CCEAccelInit(pScrn, a);
+        R128CCEAccelInit(pScrn, a);
     else
 #endif
- R128MMIOAccelInit(pScrn, a);
+    R128MMIOAccelInit(pScrn, a);
 
     R128EngineInit(pScrn);
     return XAAInit(pScreen, a);
-#endif
 }
+#endif
Index: src/r128_crtc.c
===================================================================
RCS file: src/r128_crtc.c
diff -N src/r128_crtc.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/r128_crtc.c 25 Mar 2021 21:03:14 -0000
@@ -0,0 +1,1158 @@
+/*
+ * 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"
+
+#ifdef HAVE_XEXTPROTO_71
+#include "X11/extensions/dpmsconst.h"
+#else
+#define DPMS_SERVER
+#include "X11/extensions/dpms.h"
+#endif
+
+#include "r128.h"
+#include "r128_probe.h"
+#include "r128_reg.h"
+
+
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+
+/* Define CRTC registers for requested video mode. */
+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;
+    int    hsync_fudge;
+    int    vsync_wid;
+    int    hsync_fudge_default[] = { 0x00, 0x12, 0x09, 0x09, 0x06, 0x05 };
+    int    hsync_fudge_fp[]      = { 0x12, 0x11, 0x09, 0x09, 0x05, 0x05 };
+//   int    hsync_fudge_fp_crt[]  = { 0x12, 0x10, 0x08, 0x08, 0x04, 0x04 };
+
+    switch (info->CurrentLayout.pixel_code) {
+    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;
+    }
+
+    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];
+
+    save->crtc_gen_cntl = (R128_CRTC_EXT_DISP_EN
+              | R128_CRTC_EN
+              | (format << 8)
+              | ((mode->Flags & V_DBLSCAN)
+                 ? R128_CRTC_DBL_SCAN_EN
+                 : 0)
+              | ((mode->Flags & V_INTERLACE)
+                 ? R128_CRTC_INTERLACE_EN
+                 : 0)
+              | ((mode->Flags & V_CSYNC)
+                 ? R128_CRTC_CSYNC_EN
+                 : 0));
+
+    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;
+
+    save->crtc_h_total_disp = ((((mode->CrtcHTotal / 8) - 1) & 0xffff)
+                  | (((mode->CrtcHDisplay / 8) - 1) << 16));
+
+    hsync_wid = (mode->CrtcHSyncEnd - mode->CrtcHSyncStart) / 8;
+    if (!hsync_wid)       hsync_wid = 1;
+    if (hsync_wid > 0x3f) hsync_wid = 0x3f;
+
+    hsync_start = mode->CrtcHSyncStart - 8 + hsync_fudge;
+
+    save->crtc_h_sync_strt_wid = ((hsync_start & 0xfff)
+                 | (hsync_wid << 16)
+                 | ((mode->Flags & V_NHSYNC)
+                    ? R128_CRTC_H_SYNC_POL
+                    : 0));
+
+#if 1
+                /* This works for double scan mode. */
+    save->crtc_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
+                  | ((mode->CrtcVDisplay - 1) << 16));
+#else
+                /* This is what cce/nbmode.c example code
+                   does -- is this correct? */
+    save->crtc_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
+                  | ((mode->CrtcVDisplay
+                  * ((mode->Flags & V_DBLSCAN) ? 2 : 1) - 1)
+                 << 16));
+#endif
+
+    vsync_wid = mode->CrtcVSyncEnd - mode->CrtcVSyncStart;
+    if (!vsync_wid)       vsync_wid = 1;
+    if (vsync_wid > 0x1f) vsync_wid = 0x1f;
+
+    save->crtc_v_sync_strt_wid = (((mode->CrtcVSyncStart - 1) & 0xfff)
+                 | (vsync_wid << 16)
+                 | ((mode->Flags & V_NVSYNC)
+                    ? R128_CRTC_V_SYNC_POL
+                    : 0));
+    save->crtc_pitch       = info->CurrentLayout.displayWidth / 8;
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Pitch = %d bytes (virtualX = %d, "
+                        "displayWidth = %d)\n",
+                        save->crtc_pitch, pScrn->virtualX,
+                        info->CurrentLayout.displayWidth));
+
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    /* Change the endianness of the aperture */
+    switch (info->CurrentLayout.pixel_code) {
+    case 15:
+    case 16: save->config_cntl |= APER_0_BIG_ENDIAN_16BPP_SWAP; break;
+    case 32: save->config_cntl |= APER_0_BIG_ENDIAN_32BPP_SWAP; break;
+    default: break;
+    }
+#endif
+
+    return TRUE;
+}
+
+/* Define CRTC2 registers for requested video mode. */
+Bool R128InitCrtc2Registers(xf86CrtcPtr crtc, R128SavePtr save, DisplayModePtr mode)
+{
+    ScrnInfoPtr pScrn = crtc->scrn;
+    R128InfoPtr info  = R128PTR(pScrn);
+
+    int    format;
+    int    hsync_start;
+    int    hsync_wid;
+    int    hsync_fudge;
+    int    vsync_wid;
+    int    hsync_fudge_default[] = { 0x00, 0x12, 0x09, 0x09, 0x06, 0x05 };
+
+    switch (info->CurrentLayout.pixel_code) {
+    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;
+    }
+
+    hsync_fudge = hsync_fudge_default[format-1];
+
+    save->crtc2_gen_cntl = (R128_CRTC2_EN
+              | (format << 8)
+              | ((mode->Flags & V_DBLSCAN)
+                 ? R128_CRTC2_DBL_SCAN_EN
+                 : 0));
+/*
+    save->crtc2_gen_cntl &= ~R128_CRTC_EXT_DISP_EN;
+    save->crtc2_gen_cntl |= (1 << 21);
+*/
+    save->crtc2_h_total_disp = ((((mode->CrtcHTotal / 8) - 1) & 0xffff)
+                  | (((mode->CrtcHDisplay / 8) - 1) << 16));
+
+    hsync_wid = (mode->CrtcHSyncEnd - mode->CrtcHSyncStart) / 8;
+    if (!hsync_wid)       hsync_wid = 1;
+    if (hsync_wid > 0x3f) hsync_wid = 0x3f;
+
+    hsync_start = mode->CrtcHSyncStart - 8 + hsync_fudge;
+
+    save->crtc2_h_sync_strt_wid = ((hsync_start & 0xfff)
+                 | (hsync_wid << 16)
+                 | ((mode->Flags & V_NHSYNC)
+                    ? R128_CRTC2_H_SYNC_POL
+                    : 0));
+
+#if 1
+                /* This works for double scan mode. */
+    save->crtc2_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
+                  | ((mode->CrtcVDisplay - 1) << 16));
+#else
+                /* This is what cce/nbmode.c example code
+                   does -- is this correct? */
+    save->crtc2_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
+                  | ((mode->CrtcVDisplay
+                  * ((mode->Flags & V_DBLSCAN) ? 2 : 1) - 1)
+                 << 16));
+#endif
+
+    vsync_wid = mode->CrtcVSyncEnd - mode->CrtcVSyncStart;
+    if (!vsync_wid)       vsync_wid = 1;
+    if (vsync_wid > 0x1f) vsync_wid = 0x1f;
+
+    save->crtc2_v_sync_strt_wid = (((mode->CrtcVSyncStart - 1) & 0xfff)
+                 | (vsync_wid << 16)
+                 | ((mode->Flags & V_NVSYNC)
+                    ? R128_CRTC2_V_SYNC_POL
+                    : 0));
+    save->crtc2_pitch       = info->CurrentLayout.displayWidth / 8;
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Pitch = %d bytes (virtualX = %d, "
+                        "displayWidth = %d)\n",
+                        save->crtc2_pitch, pScrn->virtualX,
+                        info->CurrentLayout.displayWidth));
+    return TRUE;
+}
+
+/* Write CRTC registers. */
+void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+{
+    R128InfoPtr   info      = R128PTR(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+
+    OUTREG(R128_CRTC_GEN_CNTL,        restore->crtc_gen_cntl);
+
+    OUTREGP(R128_CRTC_EXT_CNTL, restore->crtc_ext_cntl,
+        R128_CRTC_VSYNC_DIS | R128_CRTC_HSYNC_DIS | R128_CRTC_DISPLAY_DIS);
+
+    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);
+    OUTREG(R128_CRTC_V_SYNC_STRT_WID, restore->crtc_v_sync_strt_wid);
+    OUTREG(R128_CRTC_OFFSET,          restore->crtc_offset);
+    OUTREG(R128_CRTC_OFFSET_CNTL,     restore->crtc_offset_cntl);
+    OUTREG(R128_CRTC_PITCH,           restore->crtc_pitch);
+}
+
+/* Write CRTC2 registers. */
+void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+{
+    R128InfoPtr info        = R128PTR(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+
+    OUTREGP(R128_CRTC2_GEN_CNTL, restore->crtc2_gen_cntl,
+        R128_CRTC2_DISP_DIS);
+
+    OUTREG(R128_CRTC2_H_TOTAL_DISP,    restore->crtc2_h_total_disp);
+    OUTREG(R128_CRTC2_H_SYNC_STRT_WID, restore->crtc2_h_sync_strt_wid);
+    OUTREG(R128_CRTC2_V_TOTAL_DISP,    restore->crtc2_v_total_disp);
+    OUTREG(R128_CRTC2_V_SYNC_STRT_WID, restore->crtc2_v_sync_strt_wid);
+    OUTREG(R128_CRTC2_OFFSET,          restore->crtc2_offset);
+    OUTREG(R128_CRTC2_OFFSET_CNTL,     restore->crtc2_offset_cntl);
+    OUTREG(R128_CRTC2_PITCH,           restore->crtc2_pitch);
+}
+
+static 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;
+}
+
+static 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 PLL registers for requested video mode. */
+static 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;
+    int bitvalue;
+    } *post_div,
+      post_divs[]   = {
+                /* From RAGE 128 VR/RAGE 128 GL Register
+                   Reference Manual (Technical Reference
+                   Manual P/N RRG-G04100-C Rev. 0.04), page
+                   3-17 (PLL_DIV_[3:0]).  */
+    {  1, 0 },              /* VCLK_SRC                 */
+    {  2, 1 },              /* VCLK_SRC/2               */
+    {  4, 2 },              /* VCLK_SRC/4               */
+    {  8, 3 },              /* VCLK_SRC/8               */
+
+    {  3, 4 },              /* VCLK_SRC/3               */
+                /* bitvalue = 5 is reserved */
+    {  6, 6 },              /* VCLK_SRC/6               */
+    { 12, 7 },              /* VCLK_SRC/12              */
+    {  0, 0 }
+    };
+
+    if (freq > pll->max_pll_freq)      freq = pll->max_pll_freq;
+    if (freq * 12 < pll->min_pll_freq) freq = pll->min_pll_freq / 12;
+
+    for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
+    save->pll_output_freq = post_div->divider * freq;
+    if (save->pll_output_freq >= pll->min_pll_freq
+        && save->pll_output_freq <= pll->max_pll_freq) break;
+    }
+
+    save->dot_clock_freq = freq;
+    save->feedback_div   = R128Div(pll->reference_div * save->pll_output_freq,
+                   pll->reference_freq);
+    save->post_div       = post_div->divider;
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "dc=%d, of=%d, fd=%d, pd=%d\n",
+                        save->dot_clock_freq,
+                        save->pll_output_freq,
+                        save->feedback_div,
+                        save->post_div));
+
+    save->ppll_ref_div   = pll->reference_div;
+    save->ppll_div_3     = (save->feedback_div | (post_div->bitvalue << 16));
+    save->htotal_cntl    = 0;
+
+}
+
+/* Define PLL2 registers for requested video mode. */
+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;
+    int bitvalue;
+    } *post_div,
+      post_divs[]   = {
+                /* From RAGE 128 VR/RAGE 128 GL Register
+                   Reference Manual (Technical Reference
+                   Manual P/N RRG-G04100-C Rev. 0.04), page
+                   3-17 (PLL_DIV_[3:0]).  */
+    {  1, 0 },              /* VCLK_SRC                 */
+    {  2, 1 },              /* VCLK_SRC/2               */
+    {  4, 2 },              /* VCLK_SRC/4               */
+    {  8, 3 },              /* VCLK_SRC/8               */
+
+    {  3, 4 },              /* VCLK_SRC/3               */
+                /* bitvalue = 5 is reserved */
+    {  6, 6 },              /* VCLK_SRC/6               */
+    { 12, 7 },              /* VCLK_SRC/12              */
+    {  0, 0 }
+    };
+
+    if (freq > pll->max_pll_freq)      freq = pll->max_pll_freq;
+    if (freq * 12 < pll->min_pll_freq) freq = pll->min_pll_freq / 12;
+
+    for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
+    save->pll_output_freq_2 = post_div->divider * freq;
+    if (save->pll_output_freq_2 >= pll->min_pll_freq
+        && save->pll_output_freq_2 <= pll->max_pll_freq) break;
+    }
+
+    save->dot_clock_freq_2 = freq;
+    save->feedback_div_2   = R128Div(pll->reference_div
+                     * save->pll_output_freq_2,
+                     pll->reference_freq);
+    save->post_div_2       = post_div->divider;
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "dc=%d, of=%d, fd=%d, pd=%d\n",
+                        save->dot_clock_freq_2,
+                        save->pll_output_freq_2,
+                        save->feedback_div_2,
+                        save->post_div_2));
+
+    save->p2pll_ref_div   = pll->reference_div;
+    save->p2pll_div_0    = (save->feedback_div_2 | (post_div->bitvalue<<16));
+    save->htotal_cntl2    = 0;
+}
+
+static void R128PLLWaitForReadUpdateComplete(ScrnInfoPtr pScrn)
+{
+    while (INPLL(pScrn, R128_PPLL_REF_DIV) & R128_PPLL_ATOMIC_UPDATE_R);
+}
+
+static void R128PLLWriteUpdate(ScrnInfoPtr pScrn)
+{
+    R128InfoPtr   info      = R128PTR(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+
+    while (INPLL(pScrn, R128_PPLL_REF_DIV) & R128_PPLL_ATOMIC_UPDATE_R);
+
+    OUTPLLP(pScrn, R128_PPLL_REF_DIV, R128_PPLL_ATOMIC_UPDATE_W,
+        ~R128_PPLL_ATOMIC_UPDATE_W);
+
+}
+
+static void R128PLL2WaitForReadUpdateComplete(ScrnInfoPtr pScrn)
+{
+    while (INPLL(pScrn, R128_P2PLL_REF_DIV) & R128_P2PLL_ATOMIC_UPDATE_R);
+}
+
+static void R128PLL2WriteUpdate(ScrnInfoPtr pScrn)
+{
+    R128InfoPtr  info       = R128PTR(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+
+    while (INPLL(pScrn, R128_P2PLL_REF_DIV) & R128_P2PLL_ATOMIC_UPDATE_R);
+
+    OUTPLLP(pScrn, R128_P2PLL_REF_DIV,
+        R128_P2PLL_ATOMIC_UPDATE_W,
+        ~(R128_P2PLL_ATOMIC_UPDATE_W));
+}
+
+/* Write PLL registers. */
+void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+{
+    R128InfoPtr   info      = R128PTR(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+
+
+    OUTPLLP(pScrn, R128_VCLK_ECP_CNTL,
+        R128_VCLK_SRC_SEL_CPUCLK,
+        ~(R128_VCLK_SRC_SEL_MASK));
+
+    OUTPLLP(pScrn,
+        R128_PPLL_CNTL,
+        R128_PPLL_RESET
+        | R128_PPLL_ATOMIC_UPDATE_EN
+        | R128_PPLL_VGA_ATOMIC_UPDATE_EN,
+        ~(R128_PPLL_RESET
+          | R128_PPLL_ATOMIC_UPDATE_EN
+          | R128_PPLL_VGA_ATOMIC_UPDATE_EN));
+
+    OUTREGP(R128_CLOCK_CNTL_INDEX, R128_PLL_DIV_SEL, ~(R128_PLL_DIV_SEL));
+
+/*        R128PLLWaitForReadUpdateComplete(pScrn);*/
+    OUTPLLP(pScrn, R128_PPLL_REF_DIV,
+        restore->ppll_ref_div, ~R128_PPLL_REF_DIV_MASK);
+/*        R128PLLWriteUpdate(pScrn);
+
+        R128PLLWaitForReadUpdateComplete(pScrn);*/
+    OUTPLLP(pScrn, R128_PPLL_DIV_3,
+        restore->ppll_div_3, ~R128_PPLL_FB3_DIV_MASK);
+/*    R128PLLWriteUpdate(pScrn);*/
+    OUTPLLP(pScrn, R128_PPLL_DIV_3,
+        restore->ppll_div_3, ~R128_PPLL_POST3_DIV_MASK);
+
+    R128PLLWriteUpdate(pScrn);
+    R128PLLWaitForReadUpdateComplete(pScrn);
+
+    OUTPLLP(pScrn, R128_PPLL_DIV_0,
+        restore->ppll_div_0, ~R128_PPLL_FB0_DIV_MASK);
+/*    R128PLLWriteUpdate(pScrn);*/
+    OUTPLLP(pScrn, R128_PPLL_DIV_0,
+        restore->ppll_div_0, ~R128_PPLL_POST0_DIV_MASK);
+
+    R128PLLWriteUpdate(pScrn);
+    R128PLLWaitForReadUpdateComplete(pScrn);
+
+    OUTPLL(R128_HTOTAL_CNTL, restore->htotal_cntl);
+/*    R128PLLWriteUpdate(pScrn);*/
+
+    OUTPLLP(pScrn, R128_PPLL_CNTL, 0, ~(R128_PPLL_RESET
+                    | R128_PPLL_SLEEP
+                    | R128_PPLL_ATOMIC_UPDATE_EN
+                    | R128_PPLL_VGA_ATOMIC_UPDATE_EN));
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Wrote: 0x%08x 0x%08x 0x%08x (0x%08x)\n",
+                        restore->ppll_ref_div,
+                        restore->ppll_div_3,
+                        restore->htotal_cntl,
+                        INPLL(pScrn, R128_PPLL_CNTL)));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Wrote: rd=%d, fd=%d, pd=%d\n",
+                        restore->ppll_ref_div & R128_PPLL_REF_DIV_MASK,
+                        restore->ppll_div_3 & R128_PPLL_FB3_DIV_MASK,
+                        (restore->ppll_div_3 &
+                                R128_PPLL_POST3_DIV_MASK) >> 16));
+
+    usleep(5000); /* let the clock lock */
+
+    OUTPLLP(pScrn, R128_VCLK_ECP_CNTL,
+        R128_VCLK_SRC_SEL_PPLLCLK,
+        ~(R128_VCLK_SRC_SEL_MASK));
+
+}
+
+/* Write PLL2 registers. */
+void R128RestorePLL2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
+{
+    R128InfoPtr info        = R128PTR(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+
+    OUTPLLP(pScrn, R128_V2CLK_VCLKTV_CNTL,
+        R128_V2CLK_SRC_SEL_CPUCLK,
+        ~R128_V2CLK_SRC_SEL_MASK);
+
+    OUTPLLP(pScrn,
+        R128_P2PLL_CNTL,
+        R128_P2PLL_RESET
+        | R128_P2PLL_ATOMIC_UPDATE_EN
+        | R128_P2PLL_VGA_ATOMIC_UPDATE_EN,
+        ~(R128_P2PLL_RESET
+          | R128_P2PLL_ATOMIC_UPDATE_EN
+          | R128_P2PLL_VGA_ATOMIC_UPDATE_EN));
+
+#if 1
+    OUTREGP(R128_CLOCK_CNTL_INDEX, 0, R128_PLL2_DIV_SEL_MASK);
+#endif
+
+        /*R128PLL2WaitForReadUpdateComplete(pScrn);*/
+
+    OUTPLLP(pScrn, R128_P2PLL_REF_DIV, restore->p2pll_ref_div, ~R128_P2PLL_REF_DIV_MASK);
+
+/*        R128PLL2WriteUpdate(pScrn);
+    R128PLL2WaitForReadUpdateComplete(pScrn);*/
+
+    OUTPLLP(pScrn, R128_P2PLL_DIV_0,
+            restore->p2pll_div_0, ~R128_P2PLL_FB0_DIV_MASK);
+
+/*    R128PLL2WriteUpdate(pScrn);
+    R128PLL2WaitForReadUpdateComplete(pScrn);*/
+
+    OUTPLLP(pScrn, R128_P2PLL_DIV_0,
+            restore->p2pll_div_0, ~R128_P2PLL_POST0_DIV_MASK);
+
+    R128PLL2WriteUpdate(pScrn);
+    R128PLL2WaitForReadUpdateComplete(pScrn);
+
+    OUTPLL(R128_HTOTAL2_CNTL, restore->htotal_cntl2);
+
+/*        R128PLL2WriteUpdate(pScrn);*/
+
+    OUTPLLP(pScrn, R128_P2PLL_CNTL, 0, ~(R128_P2PLL_RESET
+                    | R128_P2PLL_SLEEP
+                    | R128_P2PLL_ATOMIC_UPDATE_EN
+                    | R128_P2PLL_VGA_ATOMIC_UPDATE_EN));
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Wrote: 0x%08x 0x%08x 0x%08x (0x%08x)\n",
+                        restore->p2pll_ref_div,
+                        restore->p2pll_div_0,
+                        restore->htotal_cntl2,
+                        INPLL(pScrn, R128_P2PLL_CNTL)));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Wrote: rd=%d, fd=%d, pd=%d\n",
+                        restore->p2pll_ref_div & R128_P2PLL_REF_DIV_MASK,
+                        restore->p2pll_div_0 & R128_P2PLL_FB0_DIV_MASK,
+                        (restore->p2pll_div_0 &
+                                R128_P2PLL_POST0_DIV_MASK) >>16));
+
+    usleep(5000); /* Let the clock to lock */
+
+    OUTPLLP(pScrn, R128_V2CLK_VCLKTV_CNTL,
+        R128_V2CLK_SRC_SEL_P2PLLCLK,
+        ~R128_V2CLK_SRC_SEL_MASK);
+
+}
+
+/* Define DDA registers for requested video 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;
+    int         VclkFreq;
+    int         XclksPerTransfer;
+    int         XclksPerTransferPrecise;
+    int         UseablePrecision;
+    int         Roff;
+    int         Ron;
+
+    XclkFreq = pll->xclk;
+
+    VclkFreq = R128Div(pll->reference_freq * save->feedback_div,
+               pll->reference_div * save->post_div);
+
+    if (info->isDFP && !info->isPro2 && r128_output->PanelXRes > 0) {
+        if (r128_output->PanelXRes != mode->CrtcHDisplay)
+            VclkFreq = (VclkFreq * mode->CrtcHDisplay) / r128_output->PanelXRes;
+    }
+
+    XclksPerTransfer = R128Div(XclkFreq * DisplayFifoWidth,
+                   VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
+
+    UseablePrecision = R128MinBits(XclksPerTransfer) + 1;
+
+    XclksPerTransferPrecise = R128Div((XclkFreq * DisplayFifoWidth)
+                      << (11 - UseablePrecision),
+                      VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
+
+    Roff  = XclksPerTransferPrecise * (DisplayFifoDepth - 4);
+
+    Ron   = (4 * info->ram->MB
+         + 3 * MAX(info->ram->Trcd - 2, 0)
+         + 2 * info->ram->Trp
+         + info->ram->Twr
+         + info->ram->CL
+         + info->ram->Tr2w
+         + XclksPerTransfer) << (11 - UseablePrecision);
+
+    if (Ron + info->ram->Rloop >= Roff) {
+    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+           "(Ron = %d) + (Rloop = %d) >= (Roff = %d)\n",
+           Ron, info->ram->Rloop, Roff);
+    return FALSE;
+    }
+
+    save->dda_config = (XclksPerTransferPrecise
+            | (UseablePrecision << 16)
+            | (info->ram->Rloop << 20));
+
+    save->dda_on_off = (Ron << 16) | Roff;
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "XclkFreq = %d; VclkFreq = %d; "
+                        "per = %d, %d (useable = %d)\n",
+                        XclkFreq,
+                        VclkFreq,
+                        XclksPerTransfer,
+                        XclksPerTransferPrecise,
+                        UseablePrecision));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Roff = %d, Ron = %d, Rloop = %d\n",
+                        Roff, Ron, info->ram->Rloop));
+
+    return TRUE;
+}
+
+/* Define DDA2 registers for requested video 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;
+    int         VclkFreq;
+    int         XclksPerTransfer;
+    int         XclksPerTransferPrecise;
+    int         UseablePrecision;
+    int         Roff;
+    int         Ron;
+
+    XclkFreq = pll->xclk;
+
+    VclkFreq = R128Div(pll->reference_freq * save->feedback_div_2,
+               pll->reference_div * save->post_div_2);
+
+    if (info->isDFP && !info->isPro2 && r128_output->PanelXRes > 0) {
+        if (r128_output->PanelXRes != mode->CrtcHDisplay)
+            VclkFreq = (VclkFreq * mode->CrtcHDisplay) / r128_output->PanelXRes;
+    }
+
+    XclksPerTransfer = R128Div(XclkFreq * DisplayFifoWidth,
+                   VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
+
+    UseablePrecision = R128MinBits(XclksPerTransfer) + 1;
+
+    XclksPerTransferPrecise = R128Div((XclkFreq * DisplayFifoWidth)
+                      << (11 - UseablePrecision),
+                      VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
+
+    Roff  = XclksPerTransferPrecise * (DisplayFifoDepth - 4);
+
+    Ron   = (4 * info->ram->MB
+         + 3 * MAX(info->ram->Trcd - 2, 0)
+         + 2 * info->ram->Trp
+         + info->ram->Twr
+         + info->ram->CL
+         + info->ram->Tr2w
+         + XclksPerTransfer) << (11 - UseablePrecision);
+
+
+    if (Ron + info->ram->Rloop >= Roff) {
+    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+           "(Ron = %d) + (Rloop = %d) >= (Roff = %d)\n",
+           Ron, info->ram->Rloop, Roff);
+    return FALSE;
+    }
+
+    save->dda2_config = (XclksPerTransferPrecise
+            | (UseablePrecision << 16)
+            | (info->ram->Rloop << 20));
+
+    /*save->dda2_on_off = (Ron << 16) | Roff;*/
+    /* shift most be 18 otherwise there's corruption on crtc2 */
+    save->dda2_on_off = (Ron << 18) | Roff;
+
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "XclkFreq = %d; VclkFreq = %d; "
+                        "per = %d, %d (useable = %d)\n",
+                        XclkFreq,
+                        VclkFreq,
+                        XclksPerTransfer,
+                        XclksPerTransferPrecise,
+                        UseablePrecision));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Roff = %d, Ron = %d, Rloop = %d\n",
+                        Roff, Ron, info->ram->Rloop));
+
+    return TRUE;
+}
+
+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 != 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);
+}
+
+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;
+    R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+    R128InfoPtr info = R128PTR(pScrn);
+    double dot_clock = adjusted_mode->Clock / 1000.0;
+
+    if (r128_crtc->cursor_offset) r128_crtc_hide_cursor(crtc);
+    xf86PrintModeline(pScrn->scrnIndex, adjusted_mode);
+    R128InitCommonRegisters(&info->ModeReg, info);
+
+    switch (r128_crtc->crtc_id) {
+    case 0:
+        R128InitCrtcRegisters(crtc, &info->ModeReg, adjusted_mode);
+ R128InitCrtcBase(crtc, &info->ModeReg, x, y);
+        if (dot_clock) {
+            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;
+            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(crtc, &info->ModeReg, adjusted_mode);
+ R128InitCrtc2Base(crtc, &info->ModeReg, x, y);
+        if (dot_clock) {
+            R128InitPLL2Registers(crtc, &info->ModeReg, &info->pll, dot_clock);
+            R128InitDDA2Registers(crtc, &info->ModeReg, &info->pll, adjusted_mode);
+        }
+        break;
+    }
+
+    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 (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, uint16_t *red, uint16_t *green, uint16_t *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
+}
+
+static void *r128_crtc_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
+{
+    ScrnInfoPtr   pScrn   = crtc->scrn;
+    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;
+    rotate_offset = R128AllocateMemory(pScrn, &(r128_crtc->rotate_mem), size, align, TRUE);
+
+    /* 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 && r128_crtc->rotate_mem != NULL) {
+#ifdef USE_EXA
+        if (info->ExaDriver)
+            exaOffscreenFree(pScreen, (ExaOffscreenArea *) r128_crtc->rotate_mem);
+#endif
+#ifdef HAVE_XAA_H
+        if (info->accel)
+            xf86FreeOffscreenLinear((FBLinearPtr) r128_crtc->rotate_mem);
+#endif
+        r128_crtc->rotate_mem = NULL;
+    }
+}
+
+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)
+{
+    R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+    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 (!pR128Ent->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);
+        }
+    }
+}
Index: src/r128_cursor.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_cursor.c,v
retrieving revision 1.3
diff -u -p -u -r1.3 r128_cursor.c
--- src/r128_cursor.c 23 Nov 2012 20:47:04 -0000 1.3
+++ src/r128_cursor.c 25 Mar 2021 21:03:14 -0000
@@ -59,197 +59,137 @@
 #include "exa.h"
 #endif
 
-#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
+#define CURSOR_WIDTH    64
+#define CURSOR_HEIGHT   64
 
-
-/* Set cursor foreground and background colors. */
-static void R128SetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
+void r128_crtc_show_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)
-    {
-        OUTREG(R128_CUR2_CLR0, bg);
-        OUTREG(R128_CUR2_CLR1, fg);
-    }
-    else
-    {
-     OUTREG(R128_CUR_CLR0, bg);
-     OUTREG(R128_CUR_CLR1, fg);
+    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 position to (x,y) with offset into cursor bitmap at
-   (xorigin,yorigin). */
-static void R128SetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
+void r128_crtc_hide_cursor(xf86CrtcPtr crtc)
 {
-    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;
+    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, 0, ~R128_CRTC_CUR_EN);
+        break;
+    case 1:
+        OUTREGP(R128_CRTC2_GEN_CNTL, 0, ~R128_CRTC2_CUR_EN);
+        break;
+    default:
+        return;
     }
 }
 
-/* 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_set_cursor_colors(xf86CrtcPtr crtc, int bg, int fg)
 {
-    R128InfoPtr   info      = R128PTR(pScrn);
+    ScrnInfoPtr pScrn = crtc->scrn;
+    R128CrtcPrivatePtr r128_crtc = crtc->driver_private;
+    R128InfoPtr info = R128PTR(pScrn);
     unsigned char *R128MMIO = info->MMIO;
-    CARD32        *s        = (pointer)image;
-    CARD32        *d        = (pointer)((CARD8*)info->FB + info->cursor_start);
-    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);
-    }
+    int crtc_id = r128_crtc->crtc_id;
 
-#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;
+    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);
+        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++;
+        return;
     }
-#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;
-    }
+void r128_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
+{
+    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(!info->IsSecondary)
-     OUTREG(R128_CRTC_GEN_CNTL, save);
-    else
-        OUTREG(R128_CRTC2_GEN_CNTL, save);
+    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;
 
-/* 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);
+    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);
+    }
 }
 
-/* Show hardware cursor. */
-static void R128ShowCursor(ScrnInfoPtr pScrn)
+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;
+    uint32_t      save1     = 0;
+    uint32_t      save2     = 0;
 
-    if(info->IsSecondary)
-    {
-         OUTREGP(R128_CRTC2_GEN_CNTL, R128_CRTC2_CUR_EN,
-               ~R128_CRTC2_CUR_EN);
+    if (crtc_id == 0) {
+ save1 = INREG(R128_CRTC_GEN_CNTL);
+ 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 & (uint32_t)~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);
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    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);
 
-    return info->cursor_start ? TRUE : FALSE;
+    if (crtc_id == 0)
+ OUTREG(R128_CRTC_GEN_CNTL, save1);
+    else
+        OUTREG(R128_CRTC2_GEN_CNTL, save2);
 }
 
 /* Initialize hardware cursor support. */
@@ -257,77 +197,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);
+    uint32_t              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");
-    }
-
-    R128TRACE(("R128CursorInit (0x%08x-0x%08x)\n",
-       info->cursor_start, info->cursor_end));
-
-    return xf86InitCursor(pScreen, cursor);
+        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);
+        }
+    }
+
+    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));
 }
Index: src/r128_dga.c
===================================================================
RCS file: src/r128_dga.c
diff -N src/r128_dga.c
--- src/r128_dga.c 8 Sep 2012 20:47:49 -0000 1.3
+++ /dev/null 1 Jan 1970 00:00:00 -0000
@@ -1,408 +0,0 @@
-/*
- * Authors:
- *   Ove Kåven <[hidden email]>,
- *    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, (CARD32)(~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, (CARD32)(~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, (CARD32)(~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;
-}
Index: src/r128_dri.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_dri.c,v
retrieving revision 1.4
diff -u -p -u -r1.4 r128_dri.c
--- src/r128_dri.c 23 Nov 2012 20:47:04 -0000 1.4
+++ src/r128_dri.c 25 Mar 2021 21:03:14 -0000
@@ -53,13 +53,11 @@
 
  /* X and server generic header files */
 #include "xf86.h"
-#include "xf86PciInfo.h"
 #include "windowstr.h"
 
 #include "shadowfb.h"
- /* GLX/DRI/DRM definitions */
+ /* DRI/DRM definitions */
 #define _XF86DRI_SERVER_
-#include "GL/glxtokens.h"
 #include "sarea.h"
 
 static size_t r128_drm_page_size;
@@ -71,209 +69,6 @@ static void R128DRITransitionSingleToMul
 
 static void R128DRIRefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox);
 
-/* Initialize the visual configs that are supported by the hardware.
-   These are combined with the visual configs that the indirect
-   rendering core supports, and the intersection is exported to the
-   client. */
-static Bool R128InitVisualConfigs(ScreenPtr pScreen)
-{
-    ScrnInfoPtr       pScrn            = xf86ScreenToScrn(pScreen);
-    R128InfoPtr       info             = R128PTR(pScrn);
-    int               numConfigs       = 0;
-    __GLXvisualConfig *pConfigs        = NULL;
-    R128ConfigPrivPtr pR128Configs     = NULL;
-    R128ConfigPrivPtr *pR128ConfigPtrs = NULL;
-    int               i, accum, stencil, db;
-
-    switch (info->CurrentLayout.pixel_code) {
-    case 8:  /* 8bpp mode is not support */
-    case 15: /* FIXME */
-    case 24: /* FIXME */
- xf86DrvMsg(pScreen->myNum, X_ERROR,
-   "[dri] R128DRIScreenInit failed (depth %d not supported).  "
-   "Disabling DRI.\n", info->CurrentLayout.pixel_code);
- return FALSE;
-
-#define R128_USE_ACCUM   1
-#define R128_USE_STENCIL 1
-#define R128_USE_DB      1
-
-    case 16:
- numConfigs = 1;
- if (R128_USE_ACCUM)   numConfigs *= 2;
- if (R128_USE_STENCIL) numConfigs *= 2;
- if (R128_USE_DB)      numConfigs *= 2;
-
- if (!(pConfigs
-      = (__GLXvisualConfig*)calloc(sizeof(__GLXvisualConfig),
-      numConfigs))) {
-    return FALSE;
- }
- if (!(pR128Configs
-      = (R128ConfigPrivPtr)calloc(sizeof(R128ConfigPrivRec),
-     numConfigs))) {
-    free(pConfigs);
-    return FALSE;
- }
- if (!(pR128ConfigPtrs
-      = (R128ConfigPrivPtr*)calloc(sizeof(R128ConfigPrivPtr),
-      numConfigs))) {
-    free(pConfigs);
-    free(pR128Configs);
-    return FALSE;
- }
-
- i = 0;
- for (db = 0; db <= R128_USE_DB; db++) {
-  for (accum = 0; accum <= R128_USE_ACCUM; accum++) {
-    for (stencil = 0; stencil <= R128_USE_STENCIL; stencil++) {
- pR128ConfigPtrs[i] = &pR128Configs[i];
-
- pConfigs[i].vid                = (VisualID)(-1);
- pConfigs[i].class              = -1;
- pConfigs[i].rgba               = TRUE;
- pConfigs[i].redSize            = 5;
- pConfigs[i].greenSize          = 6;
- pConfigs[i].blueSize           = 5;
- pConfigs[i].alphaSize          = 0;
- pConfigs[i].redMask            = 0x0000F800;
- pConfigs[i].greenMask          = 0x000007E0;
- pConfigs[i].blueMask           = 0x0000001F;
- pConfigs[i].alphaMask          = 0x00000000;
- if (accum) { /* Simulated in software */
-    pConfigs[i].accumRedSize   = 16;
-    pConfigs[i].accumGreenSize = 16;
-    pConfigs[i].accumBlueSize  = 16;
-    pConfigs[i].accumAlphaSize = 0;
- } else {
-    pConfigs[i].accumRedSize   = 0;
-    pConfigs[i].accumGreenSize = 0;
-    pConfigs[i].accumBlueSize  = 0;
-    pConfigs[i].accumAlphaSize = 0;
- }
- if (db)
-    pConfigs[i].doubleBuffer       = TRUE;
- else
-    pConfigs[i].doubleBuffer       = FALSE;
- pConfigs[i].stereo             = FALSE;
- pConfigs[i].bufferSize         = 16;
- pConfigs[i].depthSize          = 16;
- if (stencil)
-    pConfigs[i].stencilSize    = 8; /* Simulated in software */
- else
-    pConfigs[i].stencilSize    = 0;
- pConfigs[i].auxBuffers         = 0;
- pConfigs[i].level              = 0;
- if (accum || stencil) {
-   pConfigs[i].visualRating    = GLX_SLOW_CONFIG;
- } else {
-   pConfigs[i].visualRating    = GLX_NONE;
- }
- pConfigs[i].transparentPixel   = GLX_NONE;
- pConfigs[i].transparentRed     = 0;
- pConfigs[i].transparentGreen   = 0;
- pConfigs[i].transparentBlue    = 0;
- pConfigs[i].transparentAlpha   = 0;
- pConfigs[i].transparentIndex   = 0;
- i++;
-    }
-  }
- }
- break;
-
-    case 32:
- numConfigs = 1;
- if (R128_USE_ACCUM)   numConfigs *= 2;
- if (R128_USE_STENCIL) numConfigs *= 2;
- if (R128_USE_DB)      numConfigs *= 2;
-
- if (!(pConfigs
-      = (__GLXvisualConfig*)calloc(sizeof(__GLXvisualConfig),
-      numConfigs))) {
-    return FALSE;
- }
- if (!(pR128Configs
-      = (R128ConfigPrivPtr)calloc(sizeof(R128ConfigPrivRec),
-     numConfigs))) {
-    free(pConfigs);
-    return FALSE;
- }
- if (!(pR128ConfigPtrs
-      = (R128ConfigPrivPtr*)calloc(sizeof(R128ConfigPrivPtr),
-      numConfigs))) {
-    free(pConfigs);
-    free(pR128Configs);
-    return FALSE;
- }
-
- i = 0;
- for (db = 0; db <= R128_USE_DB; db++) {
-  for (accum = 0; accum <= R128_USE_ACCUM; accum++) {
-    for (stencil = 0; stencil <= R128_USE_STENCIL; stencil++) {
- pR128ConfigPtrs[i] = &pR128Configs[i];
-
- pConfigs[i].vid                = (VisualID)(-1);
- pConfigs[i].class              = -1;
- pConfigs[i].rgba               = TRUE;
- pConfigs[i].redSize            = 8;
- pConfigs[i].greenSize          = 8;
- pConfigs[i].blueSize           = 8;
- pConfigs[i].alphaSize          = 0;
- pConfigs[i].redMask            = 0x00FF0000;
- pConfigs[i].greenMask          = 0x0000FF00;
- pConfigs[i].blueMask           = 0x000000FF;
- pConfigs[i].alphaMask          = 0x00000000;
- if (accum) { /* Simulated in software */
-    pConfigs[i].accumRedSize   = 16;
-    pConfigs[i].accumGreenSize = 16;
-    pConfigs[i].accumBlueSize  = 16;
-    pConfigs[i].accumAlphaSize = 0;
- } else {
-    pConfigs[i].accumRedSize   = 0;
-    pConfigs[i].accumGreenSize = 0;
-    pConfigs[i].accumBlueSize  = 0;
-    pConfigs[i].accumAlphaSize = 0;
- }
- if (db)
-    pConfigs[i].doubleBuffer       = TRUE;
- else
-    pConfigs[i].doubleBuffer       = FALSE;
- pConfigs[i].stereo             = FALSE;
- pConfigs[i].bufferSize         = 24;
- if (stencil) {
-    pConfigs[i].depthSize      = 24;
-    pConfigs[i].stencilSize    = 8;
- } else {
-    pConfigs[i].depthSize      = 24;
-    pConfigs[i].stencilSize    = 0;
- }
- pConfigs[i].auxBuffers         = 0;
- pConfigs[i].level              = 0;
- if (accum) {
-   pConfigs[i].visualRating    = GLX_SLOW_CONFIG;
- } else {
-   pConfigs[i].visualRating    = GLX_NONE;
- }
- pConfigs[i].transparentPixel   = GLX_NONE;
- pConfigs[i].transparentRed     = 0;
- pConfigs[i].transparentGreen   = 0;
- pConfigs[i].transparentBlue    = 0;
- pConfigs[i].transparentAlpha   = 0;
- pConfigs[i].transparentIndex   = 0;
- i++;
-    }
-  }
- }
- break;
-    }
-
-    info->numVisualConfigs   = numConfigs;
-    info->pVisualConfigs     = pConfigs;
-    info->pVisualConfigsPriv = pR128Configs;
-    GlxSetVisualConfigs(numConfigs, pConfigs, (void**)pR128ConfigPtrs);
-    return TRUE;
-}
-
 /* Create the Rage 128-specific context information */
 static Bool R128CreateContext(ScreenPtr pScreen, VisualPtr visual,
       drm_context_t hwContext, void *pVisualConfigPriv,
@@ -309,7 +104,11 @@ static void R128EnterServer(ScreenPtr pS
 #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
 }
 
@@ -394,7 +193,7 @@ static void R128DRIInitBuffers(WindowPtr
     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,
@@ -412,7 +211,7 @@ static void R128DRIInitBuffers(WindowPtr
     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,
@@ -644,7 +443,7 @@ static Bool R128DRIAgpInit(R128InfoPtr i
 static Bool R128DRIPciInit(R128InfoPtr info, ScreenPtr pScreen)
 {
     unsigned char *R128MMIO = info->MMIO;
-    CARD32 chunk;
+    uint32_t chunk;
     int ret;
     int flags;
 
@@ -985,9 +784,8 @@ Bool R128DRIScreenInit(ScreenPtr pScreen
     int           major, minor, patch;
     drmVersionPtr version;
 
-    /* Check that the GLX, DRI, and DRM modules have been loaded by testing
+    /* Check that the DRI, and DRM modules have been loaded by testing
      * for known symbols in each module. */
-    if (!xf86LoaderCheckSymbol("GlxSetVisualConfigs")) return FALSE;
     if (!xf86LoaderCheckSymbol("drmAvailable"))        return FALSE;
     if (!xf86LoaderCheckSymbol("DRIQueryVersion")) {
       xf86DrvMsg(pScreen->myNum, X_ERROR,
@@ -1201,10 +999,6 @@ Bool R128DRIScreenInit(ScreenPtr pScreen
 
  /* FIXME: When are these mappings unmapped? */
 
-    if (!R128InitVisualConfigs(pScreen)) {
- R128DRICloseScreen(pScreen);
- return FALSE;
-    }
     xf86DrvMsg(pScrn->scrnIndex, X_INFO, "[dri] Visual configs initialized\n");
 
     return TRUE;
@@ -1367,14 +1161,6 @@ void R128DRICloseScreen(ScreenPtr pScree
  DRIDestroyInfoRec(info->pDRIInfo);
  info->pDRIInfo = NULL;
     }
-    if (info->pVisualConfigs) {
- free(info->pVisualConfigs);
- info->pVisualConfigs = NULL;
-    }
-    if (info->pVisualConfigsPriv) {
- free(info->pVisualConfigsPriv);
- info->pVisualConfigsPriv = NULL;
-    }
 }
 
 /* Use callbacks from dri.c to support pageflipping mode for a single
@@ -1410,12 +1196,12 @@ static void R128DRIRefreshArea(ScrnInfoP
     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);
@@ -1462,7 +1248,7 @@ static void R128EnablePageFlip(ScreenPtr
  if (!info->useEXA) {
     (*info->accel->SetupForScreenToScreenCopy)(pScrn,
    1, 1, GXcopy,
-   (CARD32)(-1), -1);
+   (uint32_t)(-1), -1);
 
     (*info->accel->SubsequentScreenToScreenCopy)(pScrn,
      0,
@@ -1475,7 +1261,7 @@ static void R128EnablePageFlip(ScreenPtr
 #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);
@@ -1522,9 +1308,6 @@ static void R128DRITransitionTo3d(Screen
     R128EnablePageFlip(pScreen);
 
     info->have3DWindows = 1;
-
-    if (info->cursor_start)
-        xf86ForceHWCursor(pScreen, TRUE);
 }
 
 static void R128DRITransitionTo2d(ScreenPtr pScreen)
@@ -1547,7 +1330,4 @@ static void R128DRITransitionTo2d(Screen
     }
 
     info->have3DWindows = 0;
-
-    if (info->cursor_start)
-        xf86ForceHWCursor(pScreen, FALSE);
 }
Index: src/r128_dripriv.h
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_dripriv.h,v
retrieving revision 1.1.1.1
diff -u -p -u -r1.1.1.1 r128_dripriv.h
--- src/r128_dripriv.h 12 Jul 2008 15:35:55 -0000 1.1.1.1
+++ src/r128_dripriv.h 25 Mar 2021 21:03:14 -0000
@@ -37,17 +37,7 @@
 #ifndef _R128_DRIPRIV_H_
 #define _R128_DRIPRIV_H_
 
-#include "GL/glxint.h"
-
 #define R128_MAX_DRAWABLES 256
-
-extern void GlxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
- void **configprivs);
-
-typedef struct {
-    /* Nothing here yet */
-    int dummy;
-} R128ConfigPrivRec, *R128ConfigPrivPtr;
 
 typedef struct {
     /* Nothing here yet */
Index: src/r128_driver.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_driver.c,v
retrieving revision 1.11
diff -u -p -u -r1.11 r128_driver.c
--- src/r128_driver.c 23 Aug 2015 17:40:49 -0000 1.11
+++ src/r128_driver.c 25 Mar 2021 21:03:14 -0000
@@ -84,7 +84,7 @@
  /* X and server generic header files */
 #include "xf86.h"
 #include "xf86_OSproc.h"
-#include "xf86PciInfo.h"
+#include "xf86RandR12.h"
 #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
 #include "xf86RAC.h"
 #include "xf86Resources.h"
@@ -109,28 +109,22 @@
 #endif
 
 
-#ifndef MAX
-#define MAX(a,b) ((a)>(b)?(a):(b))
-#endif
-
-#define USE_CRT_ONLY 0
-
- /* Forward definitions for driver functions */
 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,
-  OPTION_SW_CURSOR,
+  OPTION_FBDEV,
   OPTION_DAC_6BIT,
-  OPTION_DAC_8BIT,
+  OPTION_VGA_ACCESS,
+  OPTION_SHOW_CACHE,
+  OPTION_SW_CURSOR,
+  OPTION_VIDEO_KEY,
+  OPTION_PANEL_WIDTH,
+  OPTION_PANEL_HEIGHT,
+  OPTION_PROG_FP_REGS,
 #ifdef R128DRI
   OPTION_XV_DMA,
   OPTION_IS_PCI,
@@ -143,27 +137,21 @@ typedef enum {
   OPTION_BUFFER_SIZE,
   OPTION_PAGE_FLIP,
 #endif
-#if USE_CRT_ONLY
-  /* FIXME: Disable CRTOnly until it is tested */
-  OPTION_CRT,
-#endif
-  OPTION_DISPLAY,
-  OPTION_PANEL_WIDTH,
-  OPTION_PANEL_HEIGHT,
-  OPTION_PROG_FP_REGS,
-  OPTION_FBDEV,
-  OPTION_VIDEO_KEY,
-  OPTION_SHOW_CACHE,
-  OPTION_VGA_ACCESS,
   OPTION_ACCELMETHOD,
   OPTION_RENDERACCEL
 } R128Opts;
 
 static const OptionInfoRec R128Options[] = {
-  { OPTION_NOACCEL,      "NoAccel",          OPTV_BOOLEAN, {0}, FALSE },
-  { OPTION_SW_CURSOR,    "SWcursor",         OPTV_BOOLEAN, {0}, FALSE },
-  { OPTION_DAC_6BIT,     "Dac6Bit",          OPTV_BOOLEAN, {0}, FALSE },
-  { OPTION_DAC_8BIT,     "Dac8Bit",          OPTV_BOOLEAN, {0}, TRUE  },
+{ OPTION_NOACCEL,      "NoAccel",          OPTV_BOOLEAN, {0}, FALSE },
+{ OPTION_FBDEV,        "UseFBDev",         OPTV_BOOLEAN, {0}, FALSE },
+{ OPTION_DAC_6BIT,     "Dac6Bit",          OPTV_BOOLEAN, {0}, FALSE },
+{ OPTION_VGA_ACCESS,   "VGAAccess",        OPTV_BOOLEAN, {0}, TRUE  },
+{ OPTION_SHOW_CACHE,   "ShowCache",        OPTV_BOOLEAN, {0}, FALSE },
+{ OPTION_SW_CURSOR,    "SWcursor",         OPTV_BOOLEAN, {0}, FALSE },
+{ OPTION_VIDEO_KEY,    "VideoKey",         OPTV_INTEGER, {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 },
 #ifdef R128DRI
   { OPTION_XV_DMA,       "DMAForXv",         OPTV_BOOLEAN, {0}, FALSE },
   { OPTION_IS_PCI,       "ForcePCIMode",     OPTV_BOOLEAN, {0}, FALSE },
@@ -176,14 +164,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 },
-  { OPTION_FBDEV,        "UseFBDev",         OPTV_BOOLEAN, {0}, FALSE },
-  { OPTION_VIDEO_KEY,    "VideoKey",         OPTV_INTEGER, {0}, FALSE },
-  { OPTION_SHOW_CACHE,   "ShowCache",        OPTV_BOOLEAN, {0}, FALSE },
-  { OPTION_VGA_ACCESS,   "VGAAccess",        OPTV_BOOLEAN, {0}, TRUE  },
   { OPTION_ACCELMETHOD,  "AccelMethod",      OPTV_STRING,  {0}, FALSE },
   { OPTION_RENDERACCEL,  "RenderAccel",      OPTV_BOOLEAN, {0}, FALSE },
   { -1,                  NULL,               OPTV_NONE,    {0}, FALSE }
@@ -243,22 +223,13 @@ static Bool R128MapMMIO(ScrnInfoPtr pScr
     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) {
-            DevUnion* pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
-                                                   getR128EntityIndex());
-            R128EntPtr pR128Ent = pPriv->ptr;
-            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,
    info->PciTag,
    info->MMIOAddr,
    R128_MMIOSIZE);
+        if (!info->MMIO) return FALSE;
 #else
  int err = pci_device_map_range(info->PciInfo,
        info->MMIOAddr,
@@ -275,7 +246,6 @@ static Bool R128MapMMIO(ScrnInfoPtr pScr
 #endif
     }
 
-    if (!info->MMIO) return FALSE;
     return TRUE;
 }
 
@@ -403,78 +373,6 @@ void R128WaitForVerticalSync(ScrnInfoPtr
     }
 }
 
-/* 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)
 {
@@ -485,26 +383,26 @@ int R128MinBits(int val)
     return bits;
 }
 
-/* Compute n/d with rounding. */
-static int R128Div(int n, int d)
+/* Finds the first output using a given crtc. */
+xf86OutputPtr R128FirstOutput(xf86CrtcPtr crtc)
 {
-    return (n + (d / 2)) / d;
+    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 and the FP registers (if applicable). */
+/* 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;
@@ -549,150 +447,104 @@ static Bool R128GetBIOSParameters(ScrnIn
    "Video BIOS not found!\n");
     }
 
-        if(info->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)
-                 {
-                     DevUnion* pPriv;
-                     R128EntPtr pR128Ent;
-                     pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
-                         getR128EntityIndex());
-                     pR128Ent = pPriv->ptr;
-                     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]))
-                     {
-                         DevUnion* pPriv;
-                         R128EntPtr pR128Ent;
-                         pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
-                             getR128EntityIndex());
-                         pR128Ent = pPriv->ptr;
-                         pR128Ent->BypassSecondary = TRUE;
-                     }
+    return 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;
-    }
- }
+/* 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 (!FPHeader) return TRUE;
+    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;
+
+    /* 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;
+        }
+    }
 
- /* 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 (!FPHeader) return;
 
- 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");
- }
+    /* 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;
+
+    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
@@ -718,15 +570,10 @@ static Bool R128GetPLLParameters(ScrnInf
     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);
@@ -749,10 +596,11 @@ static Bool R128GetPLLParameters(ScrnInf
  pll->max_pll_freq   = 25000;
  pll->xclk           = 10300;
     } else {
- CARD16 bios_header    = R128_BIOS16(0x48);
- CARD16 pll_info_block = R128_BIOS16(bios_header + 0x30);
- R128TRACE(("Header at 0x%04x; PLL Information at 0x%04x\n",
-   bios_header, pll_info_block));
+ uint16_t bios_header    = R128_BIOS16(0x48);
+ uint16_t pll_info_block = R128_BIOS16(bios_header + 0x30);
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Header at 0x%04x; PLL Information at 0x%04x\n",
+                        bios_header, pll_info_block));
 
  pll->reference_freq = R128_BIOS16(pll_info_block + 0x0e);
  pll->reference_div  = R128_BIOS16(pll_info_block + 0x10);
@@ -776,8 +624,6 @@ static Bool R128GetPLLParameters(ScrnInf
 /* This is called by R128PreInit to set up the default visual. */
 static Bool R128PreInitVisual(ScrnInfoPtr pScrn)
 {
-    R128InfoPtr info          = R128PTR(pScrn);
-
     if (!xf86SetDepthBpp(pScrn, 0, 0, 0, (Support24bppFb
   | Support32bppFb
   | SupportConvert32to24
@@ -799,23 +645,6 @@ static Bool R128PreInitVisual(ScrnInfoPt
 
     xf86PrintDepthBpp(pScrn);
 
-    info->fifo_slots  = 0;
-    info->pix24bpp    = xf86GetBppFromDepth(pScrn, pScrn->depth);
-    info->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
-    info->CurrentLayout.depth        = pScrn->depth;
-    info->CurrentLayout.pixel_bytes  = pScrn->bitsPerPixel / 8;
-    info->CurrentLayout.pixel_code   = (pScrn->bitsPerPixel != 16
-       ? pScrn->bitsPerPixel
-       : pScrn->depth);
-
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Pixel depth = %d bits stored in %d byte%s (%d bpp pixmaps)\n",
-       pScrn->depth,
-       info->CurrentLayout.pixel_bytes,
-       info->CurrentLayout.pixel_bytes > 1 ? "s" : "",
-       info->pix24bpp);
-
-
     if (!xf86SetDefaultVisual(pScrn, -1)) return FALSE;
 
     if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) {
@@ -832,29 +661,33 @@ static Bool R128PreInitVisual(ScrnInfoPt
 static Bool R128PreInitWeight(ScrnInfoPtr pScrn)
 {
     R128InfoPtr info          = R128PTR(pScrn);
+    rgb defaultWeight = { 0, 0, 0 };
 
- /* Save flag for 6 bit DAC to use for
-   setting CRTC registers.  Otherwise use
-   an 8 bit DAC, even if xf86SetWeight sets
-   pScrn->rgbBits to some value other than
-   8. */
-    info->dac6bits = FALSE;
-    if (pScrn->depth > 8) {
- rgb defaultWeight = { 0, 0, 0 };
- if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight)) return FALSE;
+    /*
+     * Save flag for 6 bit DAC to use for setting CRTC registers.
+     * Otherwise use an 8 bit DAC, even if xf86SetWeight sets
+     * pScrn->rgbBits to some value other than 8.
+     */
+    if (pScrn->depth <= 8) {
+        if (info->dac6bits) {
+            pScrn->rgbBits = 6;
+        } else {
+            pScrn->rgbBits = 8;
+        }
     } else {
- pScrn->rgbBits = 8;
- if (xf86ReturnOptValBool(info->Options, OPTION_DAC_6BIT, FALSE)) {
-    pScrn->rgbBits = 6;
-    info->dac6bits = TRUE;
- }
+        info->dac6bits = FALSE;
+        pScrn->rgbBits = 8;
     }
+
+    if (pScrn->depth > 8) {
+        if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight)) return FALSE;
+    }
+
     xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Using %d bits per RGB (%d bit DAC)\n",
-       pScrn->rgbBits, info->dac6bits ? 6 : 8);
+               "Using %d bits per RGB (%d bit DAC)\n",
+               pScrn->rgbBits, info->dac6bits ? 6 : 8);
 
     return TRUE;
-
 }
 
 /* This is called by R128PreInit to handle config file overrides for things
@@ -863,6 +696,7 @@ static Bool R128PreInitWeight(ScrnInfoPt
 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;
@@ -957,7 +791,7 @@ static Bool R128PreInitConfig(ScrnInfoPt
     } 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.
@@ -1010,7 +844,7 @@ static Bool R128PreInitConfig(ScrnInfoPt
  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:
@@ -1036,7 +870,7 @@ static Bool R128PreInitConfig(ScrnInfoPt
 
  /* Read registers used to determine options */
     from                      = X_PROBED;
-    R128MapMMIO(pScrn);
+    if (!R128MapMMIO(pScrn)) return FALSE;
     R128MMIO                  = info->MMIO;
 
     if (info->FBDev)
@@ -1047,42 +881,6 @@ static Bool R128PreInitConfig(ScrnInfoPt
     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 (info->IsPrimary || info->IsSecondary)
-    info->BIOSDisplay = R128_DUALHEAD;
- else if (!Display || !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;
-    }
-
-    R128MMIO                  = NULL;
-    R128UnmapMMIO(pScrn);
-
  /* RAM */
     switch (info->MemCntl & 0x3) {
     case 0:                     /* SDR SGRAM 1:1 */
@@ -1121,75 +919,12 @@ static Bool R128PreInitConfig(ScrnInfoPt
     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);
-    if (info->DMAForXv) {
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
-   "Will try to use DMA for Xv image transfers\n");
-    }
-
- /* AGP/PCI */
-    if (xf86ReturnOptValBool(info->Options, OPTION_IS_PCI, FALSE)) {
- info->IsPCI = TRUE;
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Forced into PCI-only mode\n");
-    } else {
+    /* AGP/PCI */
+    if (!info->IsPCI) {
  switch (info->Chipset) {
  case PCI_CHIP_RAGE128LE:
  case PCI_CHIP_RAGE128RE:
@@ -1257,6 +992,7 @@ static Bool R128PreInitDDC(ScrnInfoPtr p
 #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 */
@@ -1282,618 +1018,409 @@ static Bool R128PreInitGamma(ScrnInfoPtr
     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)
+/* This is called by R128PreInit to initialize the hardware cursor. */
+static Bool R128PreInitCursor(ScrnInfoPtr pScrn)
 {
-    ScrnInfoPtr   pScrn       = xf86Screens[b->scrnIndex];
-    R128InfoPtr info = R128PTR(pScrn);
-    unsigned long val;
-    unsigned char *R128MMIO = info->MMIO;
+    R128InfoPtr   info = R128PTR(pScrn);
 
-    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);
+    if (!info->swCursor) {
+ if (!xf86LoadSubModule(pScrn, "ramdac")) return FALSE;
+    }
+    return TRUE;
 }
 
-
-static Bool
-R128I2cInit(ScrnInfoPtr pScrn)
+static Bool R128PreInitInt10(ScrnInfoPtr pScrn, xf86Int10InfoPtr *ppInt10)
 {
-    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 !defined(__powerpc__) && !defined(__alpha__)
+    R128InfoPtr   info = R128PTR(pScrn);
 
-    if (!xf86I2CBusInit(info->pI2CBus)) {
-        return FALSE;
+    /* 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);
     }
+#endif
     return TRUE;
 }
 
-/* return TRUE is a DFP is indeed connected to a DVI port */
-static Bool R128GetDFPInfo(ScrnInfoPtr pScrn)
+#ifdef R128DRI
+static Bool R128PreInitDRI(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");
-    }
+    R128InfoPtr   info = R128PTR(pScrn);
 
-    OUTREG(info->DDCReg, (INREG(info->DDCReg)
-           | R128_GPIO_MONID_MASK_0 | R128_GPIO_MONID_MASK_3));
+    info->agpMode        = R128_DEFAULT_AGP_MODE;
+    info->agpSize        = R128_DEFAULT_AGP_SIZE;
+    info->ringSize       = R128_DEFAULT_RING_SIZE;
+    info->bufSize        = R128_DEFAULT_BUFFER_SIZE;
+    info->agpTexSize     = R128_DEFAULT_AGP_TEX_SIZE;
 
-    OUTREG(info->DDCReg, INREG(info->DDCReg)
-           & ~(CARD32)(R128_GPIO_MONID_A_0 | R128_GPIO_MONID_A_3));
+    info->CCEusecTimeout = R128_DEFAULT_CCE_TIMEOUT;
 
-    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;
+    if (!info->IsPCI) {
+ if (xf86GetOptValInteger(info->Options,
+ OPTION_AGP_MODE, &(info->agpMode))) {
+    if (info->agpMode < 1 || info->agpMode > R128_AGP_MAX_MODE) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Illegal AGP Mode: %d\n", info->agpMode);
+ return FALSE;
+    }
+    xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+       "Using AGP %dx mode\n", info->agpMode);
+ }
 
-    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;
-}
+ if (xf86GetOptValInteger(info->Options,
+ OPTION_AGP_SIZE, (int *)&(info->agpSize))) {
+    switch (info->agpSize) {
+    case 4:
+    case 8:
+    case 16:
+    case 32:
+    case 64:
+    case 128:
+    case 256:
+ break;
+    default:
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Illegal AGP size: %d MB\n", info->agpSize);
+ return FALSE;
+    }
+ }
 
+ if (xf86GetOptValInteger(info->Options,
+ OPTION_RING_SIZE, &(info->ringSize))) {
+    if (info->ringSize < 1 || info->ringSize >= (int)info->agpSize) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Illegal ring buffer size: %d MB\n",
+   info->ringSize);
+ return FALSE;
+    }
+ }
 
-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;
-    }
-}
+ if (xf86GetOptValInteger(info->Options,
+ OPTION_BUFFER_SIZE, &(info->bufSize))) {
+    if (info->bufSize < 1 || info->bufSize >= (int)info->agpSize) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Illegal vertex/indirect buffers size: %d MB\n",
+   info->bufSize);
+ return FALSE;
+    }
+    if (info->bufSize > 2) {
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Illegal vertex/indirect buffers size: %d MB\n",
+   info->bufSize);
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Clamping vertex/indirect buffers size to 2 MB\n");
+ info->bufSize = 2;
+    }
+ }
 
-/***********
-   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).
-************/
+ if (info->ringSize + info->bufSize + info->agpTexSize >
+    (int)info->agpSize) {
+    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+       "Buffers are too big for requested AGP space\n");
+    return FALSE;
+ }
 
-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;
+ info->agpTexSize = info->agpSize - (info->ringSize + info->bufSize);
+    }
 
-    /* Free any allocated modes during configuration. We don't need them*/
-    while (pScrn->modes)
-    {
-    xf86DeleteMode(&pScrn->modes, pScrn->modes);
+    if (xf86GetOptValInteger(info->Options, OPTION_USEC_TIMEOUT,
+     &(info->CCEusecTimeout))) {
+ /* This option checked by the R128 DRM kernel module */
     }
-    while (pScrn->modePool)
-    {
-    xf86DeleteMode(&pScrn->modePool, pScrn->modePool);
+
+    if (!xf86LoadSubModule(pScrn, "shadowfb")) {
+ info->allowPageFlip = 0;
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+   "Couldn't load shadowfb module:\n");
+    } else {
+ info->allowPageFlip = xf86ReturnOptValBool(info->Options,
+   OPTION_PAGE_FLIP,
+   FALSE);
     }
 
-    pScrn->virtualX = pScrn->display->virtualX;
-    pScrn->virtualY = pScrn->display->virtualY;
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Page flipping %sabled\n",
+       info->allowPageFlip ? "en" : "dis");
 
-    /* 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);
-    }
+    return TRUE;
+}
+#endif
 
-    for(i=0; pScrn->display->modes[i] != NULL; i++)
-    {
-        if (sscanf(pScrn->display->modes[i], "%dx%d", &width, &height) == 2)
-        {
+static Bool R128PreInitControllers(ScrnInfoPtr pScrn, xf86Int10InfoPtr pInt10)
+{
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int found = 0;
+    int i;
 
-            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;
-            }
+    if (!R128GetBIOSParameters(pScrn, pInt10))
+        return FALSE;
 
-            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 (!R128GetPLLParameters(pScrn))
+        return FALSE;
 
-            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 (!R128AllocateControllers(pScrn))
+        return FALSE;
 
-   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;
-       }
+    if (!R128SetupConnectors(pScrn))
+        return FALSE;
 
-   }
+    for (i = 0; i < config->num_output; i++) {
+        xf86OutputPtr output = config->output[i];
 
-   return count;
+        output->status = (*output->funcs->detect) (output);
+        if (output->status == XF86OutputStatusConnected)
+            found++;
+    }
+    return !!found;
 }
 
-
-/* This is called by R128PreInit to validate modes and compute parameters
-   for all of the valid modes. */
-static Bool R128PreInitModes(ScrnInfoPtr pScrn)
+static void
+r128UMSOption(ScrnInfoPtr pScrn)
 {
-    R128InfoPtr   info = R128PTR(pScrn);
-    ClockRangePtr clockRanges;
-    int           modesFound;
+    R128InfoPtr      info = R128PTR(pScrn);
 
-    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;
+    info->dac6bits = xf86ReturnOptValBool(info->Options,
+                                            OPTION_DAC_6BIT, FALSE);
 
-            }
-        }
-        R128UnmapMem(pScrn);
+#if defined(__powerpc__) && defined(__linux__)
+    if (xf86ReturnOptValBool(info->Options, OPTION_FBDEV, TRUE))
+#else
+    if (xf86ReturnOptValBool(info->Options, OPTION_FBDEV, FALSE))
+#endif
+    {
+        info->FBDev = TRUE;
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "Using framebuffer device.\n");
     }
 
-    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;
-        }
+    /* By default, don't access VGA IOs on PowerPC or SPARC. */
+#if defined(__powerpc__) || defined(__sparc__) || !defined(WITH_VGAHW)
+    info->VGAAccess = FALSE;
+#else
+    info->VGAAccess = TRUE;
+#endif
 
-        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);
-        }
+#ifdef WITH_VGAHW
+    xf86GetOptValBool(info->Options, OPTION_VGA_ACCESS,
+                        &info->VGAAccess);
+    if (info->VGAAccess) {
+       if (!xf86LoadSubModule(pScrn, "vgahw"))
+           info->VGAAccess = FALSE;
+        else {
+            if (!vgaHWGetHWRec(pScrn))
+               info->VGAAccess = FALSE;
+       }
 
-        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 (!info->VGAAccess) {
+           xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+                       "Loading VGA module failed, trying to "
+                       "run without it.\n");
+       }
+    } else
+           xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                       "VGAAccess option set to FALSE, VGA "
+                       "module load skipped.\n");
+    if (info->VGAAccess) {
+        vgaHWSetStdFuncs(VGAHWPTR(pScrn));
+        vgaHWGetIOBase(VGAHWPTR(pScrn));
+    }
+#else
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                "VGAHW support not compiled, VGA "
+                "module load skipped.\n");
+#endif
 
-        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);
+    if (xf86ReturnOptValBool(info->Options,
+                                OPTION_SHOW_CACHE, FALSE)) {
+        info->showCache = TRUE;
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "ShowCache enabled.\n");
     }
- /* Set DPI */
-    pScrn->currentMode = pScrn->modes;
-    xf86PrintModes(pScrn);
 
-    xf86SetDpi(pScrn, 0, 0);
+    if (xf86ReturnOptValBool(info->Options,
+                                OPTION_SW_CURSOR, FALSE)) {
+        info->swCursor = TRUE;
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "Software cursor requested.\n");
+    }
 
- /* Get ScreenInit function */
-    if (!xf86LoadSubModule(pScrn, "fb")) return FALSE;
+    if(xf86GetOptValInteger(info->Options,
+                            OPTION_VIDEO_KEY, &info->videoKey)) {
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "Video key set to 0x%x.\n", info->videoKey);
+    } else {
+        info->videoKey = 0x1E;
+    }
 
-    info->CurrentLayout.displayWidth = pScrn->displayWidth;
-    info->CurrentLayout.mode = pScrn->currentMode;
+#ifdef R128DRI
+    /* DMA for Xv */
+    info->DMAForXv = xf86ReturnOptValBool(info->Options,
+                                            OPTION_XV_DMA, FALSE);
+    if (info->DMAForXv) {
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                   "Will try to use DMA for Xv image transfers.\n");
+    }
 
-    return TRUE;
-}
+    /* Force PCI Mode */
+    info->IsPCI = xf86ReturnOptValBool(info->Options,
+                                        OPTION_IS_PCI, FALSE);
+    if (info->IsPCI) {
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "Forced into PCI only mode.\n");
+    }
 
-/* This is called by R128PreInit to initialize the hardware cursor. */
-static Bool R128PreInitCursor(ScrnInfoPtr pScrn)
-{
-    R128InfoPtr   info = R128PTR(pScrn);
+    if (xf86ReturnOptValBool(info->Options, OPTION_CCE_PIO, FALSE)) {
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "Forcing CCE into PIO mode.\n");
+        info->CCEMode = R128_DEFAULT_CCE_PIO_MODE;
+    } else {
+        info->CCEMode = R128_DEFAULT_CCE_BM_MODE;
+    }
 
-    if (!xf86ReturnOptValBool(info->Options, OPTION_SW_CURSOR, FALSE)) {
- if (!xf86LoadSubModule(pScrn, "ramdac")) return FALSE;
+    if (xf86ReturnOptValBool(info->Options, OPTION_NO_SECURITY, FALSE)) {
+        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
+                    "WARNING!!! CCE Security checks disabled!!!\n");
+        info->CCESecure = FALSE;
+    } else {
+        info->CCESecure = TRUE;
     }
-    return TRUE;
+
+
+#endif
 }
 
-static Bool R128PreInitInt10(ScrnInfoPtr pScrn, xf86Int10InfoPtr *ppInt10)
+static void
+r128AcquireOption(ScrnInfoPtr pScrn)
 {
-    R128InfoPtr   info = R128PTR(pScrn);
-#if 1 && !defined(__alpha__) && !defined(__powerpc__)
-    /* int10 is broken on some Alphas */
-    if (xf86LoadSubModule(pScrn, "int10")) {
- xf86DrvMsg(pScrn->scrnIndex,X_INFO,"initializing int10\n");
- *ppInt10 = xf86InitInt10(info->pEnt->index);
+    R128InfoPtr      info = R128PTR(pScrn);
+#ifdef USE_EXA
+    char *optstr;
+#endif
+
+    if (xf86ReturnOptValBool(info->Options, OPTION_NOACCEL, FALSE)) {
+        info->noAccel = TRUE;
     }
+
+#ifdef USE_EXA
+    if (!info->noAccel) {
+        optstr = (char *) xf86GetOptValString(info->Options,
+                                                OPTION_ACCELMETHOD);
+        if (optstr) {
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "AccelMethod option found.\n");
+            if (xf86NameCmp(optstr, "EXA") == 0) {
+                info->useEXA = TRUE;
+                xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "AccelMethod is set to EXA, turning "
+                            "EXA on.\n");
+            }
+        }
+
+#ifdef RENDER
+        info->RenderAccel = xf86ReturnOptValBool(info->Options,
+                                                    OPTION_RENDERACCEL,
+                                                    TRUE);
+        if (info->RenderAccel)
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Acceleration of RENDER operations will be "
+                        "enabled upon successful loading of DRI and "
+                        "EXA.\n");
 #endif
-    return TRUE;
+    }
+#endif
+
+    r128UMSOption(pScrn);
 }
 
-#ifdef R128DRI
-static Bool R128PreInitDRI(ScrnInfoPtr pScrn)
+static Bool R128CRTCResize(ScrnInfoPtr pScrn, int width, int height)
 {
-    R128InfoPtr   info = R128PTR(pScrn);
+    pScrn->virtualX = width;
+    pScrn->virtualY = height;
+    return TRUE;
+}
 
-    if (xf86ReturnOptValBool(info->Options, OPTION_CCE_PIO, FALSE)) {
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Forcing CCE into PIO mode\n");
- info->CCEMode = R128_DEFAULT_CCE_PIO_MODE;
-    } else {
- info->CCEMode = R128_DEFAULT_CCE_BM_MODE;
-    }
+static const xf86CrtcConfigFuncsRec R128CRTCResizeFuncs = {
+    R128CRTCResize
+};
 
-    if (xf86ReturnOptValBool(info->Options, OPTION_NO_SECURITY, FALSE)) {
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
-   "WARNING!!!  CCE Security checks disabled!!! **********\n");
- info->CCESecure = FALSE;
+static Bool R128LegacyMS(ScrnInfoPtr pScrn)
+{
+    R128InfoPtr      info = R128PTR(pScrn);
+    xf86Int10InfoPtr pInt10 = NULL;
+    Bool ret = FALSE;
+
+    if (info->FBDev) {
+        /* check for linux framebuffer device */
+        if (!xf86LoadSubModule(pScrn, "fbdevhw")) goto exit;
+        if (!fbdevHWInit(pScrn, info->PciInfo, NULL)) goto exit;
+        pScrn->SwitchMode    = fbdevHWSwitchModeWeak();
+        pScrn->AdjustFrame   = fbdevHWAdjustFrameWeak();
+        pScrn->ValidMode     = fbdevHWValidModeWeak();
     } else {
- info->CCESecure = TRUE;
+        if (!R128PreInitInt10(pScrn, &pInt10)) goto exit;
     }
 
-    info->agpMode        = R128_DEFAULT_AGP_MODE;
-    info->agpSize        = R128_DEFAULT_AGP_SIZE;
-    info->ringSize       = R128_DEFAULT_RING_SIZE;
-    info->bufSize        = R128_DEFAULT_BUFFER_SIZE;
-    info->agpTexSize     = R128_DEFAULT_AGP_TEX_SIZE;
+    if (!R128PreInitConfig(pScrn)) goto freeInt10;
 
-    info->CCEusecTimeout = R128_DEFAULT_CCE_TIMEOUT;
+    xf86CrtcSetSizeRange(pScrn, 320, 200, 4096, 4096);
 
-    if (!info->IsPCI) {
- if (xf86GetOptValInteger(info->Options,
- OPTION_AGP_MODE, &(info->agpMode))) {
-    if (info->agpMode < 1 || info->agpMode > R128_AGP_MAX_MODE) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Illegal AGP Mode: %d\n", info->agpMode);
- return FALSE;
-    }
-    xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
-       "Using AGP %dx mode\n", info->agpMode);
- }
-
- if (xf86GetOptValInteger(info->Options,
- OPTION_AGP_SIZE, (int *)&(info->agpSize))) {
-    switch (info->agpSize) {
-    case 4:
-    case 8:
-    case 16:
-    case 32:
-    case 64:
-    case 128:
-    case 256:
- break;
-    default:
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Illegal AGP size: %d MB\n", info->agpSize);
- return FALSE;
-    }
- }
+    if (!R128PreInitCursor(pScrn)) goto freeInt10;
 
- if (xf86GetOptValInteger(info->Options,
- OPTION_RING_SIZE, &(info->ringSize))) {
-    if (info->ringSize < 1 || info->ringSize >= (int)info->agpSize) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Illegal ring buffer size: %d MB\n",
-   info->ringSize);
- return FALSE;
-    }
- }
+    /* Don't fail on this one */
+    info->DDC = R128PreInitDDC(pScrn, pInt10);
 
- if (xf86GetOptValInteger(info->Options,
- OPTION_BUFFER_SIZE, &(info->bufSize))) {
-    if (info->bufSize < 1 || info->bufSize >= (int)info->agpSize) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Illegal vertex/indirect buffers size: %d MB\n",
-   info->bufSize);
- return FALSE;
-    }
-    if (info->bufSize > 2) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Illegal vertex/indirect buffers size: %d MB\n",
-   info->bufSize);
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Clamping vertex/indirect buffers size to 2 MB\n");
- info->bufSize = 2;
-    }
- }
+    if (!R128PreInitControllers(pScrn, pInt10)) goto freeInt10;
 
- if (info->ringSize + info->bufSize + info->agpTexSize >
-    (int)info->agpSize) {
-    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-       "Buffers are too big for requested AGP space\n");
-    return FALSE;
- }
+#ifdef R128DRI
+    if (!R128PreInitDRI(pScrn)) goto freeInt10;
+#endif
 
- info->agpTexSize = info->agpSize - (info->ringSize + info->bufSize);
+    ret = TRUE;
+freeInt10:
+    /* Free int10 info */
+    if (pInt10) {
+        xf86FreeInt10(pInt10);
     }
 
-    if (xf86GetOptValInteger(info->Options, OPTION_USEC_TIMEOUT,
-     &(info->CCEusecTimeout))) {
- /* This option checked by the R128 DRM kernel module */
-    }
+exit:
+    return ret;
+}
 
-    if (!xf86LoadSubModule(pScrn, "shadowfb")) {
- info->allowPageFlip = 0;
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "Couldn't load shadowfb module:\n");
-    } else {
- info->allowPageFlip = xf86ReturnOptValBool(info->Options,
-   OPTION_PAGE_FLIP,
-   FALSE);
-    }
+static void
+R128PreInitAccel(ScrnInfoPtr pScrn)
+{
+    R128InfoPtr      info = R128PTR(pScrn);
+#ifdef USE_EXA
+    int errmaj, errmin;
+#endif
 
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Page flipping %sabled\n",
-       info->allowPageFlip ? "en" : "dis");
+    if (!info->noAccel) {
+        if (info->useEXA) {
+#ifdef USE_EXA
+            info->exaReq.majorversion = EXA_VERSION_MAJOR;
+            info->exaReq.minorversion = EXA_VERSION_MINOR;
 
-    return TRUE;
-}
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Loading EXA module...\n");
+            if (LoadSubModule(pScrn->module, "exa", NULL, NULL, NULL,
+                                &info->exaReq, &errmaj, &errmin)) {
+                xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Loading EXA module.\n");
+            } else {
+                LoaderErrorMsg(NULL, "exa", errmaj, errmin);
+            }
 #endif
+        }
 
-static void
-R128ProbeDDC(ScrnInfoPtr pScrn, int indx)
-{
-    vbeInfoPtr pVbe;
-    if (xf86LoadSubModule(pScrn, "vbe")) {
- pVbe = VBEInit(NULL,indx);
- ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
- vbeFree(pVbe);
+        if ((!info->useEXA) ||
+            ((info->useEXA) && (!info->accelOn))) {
+#ifdef HAVE_XAA_H
+            if (xf86LoadSubModule(pScrn, "xaa")) {
+                xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Loading XAA module.\n");
+            }
+#endif
+        }
     }
 }
 
@@ -1901,60 +1428,36 @@ R128ProbeDDC(ScrnInfoPtr pScrn, int indx
 Bool R128PreInit(ScrnInfoPtr pScrn, int flags)
 {
     R128InfoPtr      info;
-    xf86Int10InfoPtr pInt10 = NULL;
 
-    R128TRACE(("R128PreInit\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
+
+    if (flags & PROBE_DETECT) {
+        return TRUE;
+    }
+
+    pScrn->monitor = pScrn->confScreen->monitor;
+
+    if (!R128PreInitVisual(pScrn)) {
+        return FALSE;
+    }
+
+    if (!R128PreInitGamma(pScrn)) {
+        return FALSE;
+    }
 
     if (pScrn->numEntities != 1) return FALSE;
 
     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]))
-        {
-            DevUnion* pPriv;
-            R128EntPtr pR128Ent;
-            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;
-    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;
-            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",
@@ -1963,17 +1466,31 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int
        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;
 
-    if (!R128PreInitVisual(pScrn))    goto fail;
+    info->fifo_slots  = 0;
+    info->pix24bpp    = xf86GetBppFromDepth(pScrn, pScrn->depth);
+    info->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
+    info->CurrentLayout.depth        = pScrn->depth;
+    info->CurrentLayout.pixel_bytes  = pScrn->bitsPerPixel / 8;
+    info->CurrentLayout.pixel_code   = (pScrn->bitsPerPixel != 16
+                                       ? pScrn->bitsPerPixel
+                                       : pScrn->depth);
+
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+           "Pixel depth = %d bits stored in %d byte%s (%d bpp pixmaps)\n",
+           pScrn->depth,
+           info->CurrentLayout.pixel_bytes,
+           info->CurrentLayout.pixel_bytes > 1 ? "s" : "",
+           info->pix24bpp);
 
  /* We can't do this until we have a
    pScrn->display. */
@@ -1982,94 +1499,52 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int
     memcpy(info->Options, R128Options, sizeof(R128Options));
     xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, info->Options);
 
-    /* By default, don't do VGA IOs on ppc */
-#if defined(__powerpc__) || defined(__sparc__) || !defined(WITH_VGAHW)
-    info->VGAAccess = FALSE;
-#else
-    info->VGAAccess = TRUE;
-#endif
-
-#ifdef WITH_VGAHW
-    xf86GetOptValBool(info->Options, OPTION_VGA_ACCESS, &info->VGAAccess);
-    if (info->VGAAccess) {
-       if (!xf86LoadSubModule(pScrn, "vgahw"))
-           info->VGAAccess = FALSE;
-        else {
-            if (!vgaHWGetHWRec(pScrn))
-               info->VGAAccess = FALSE;
-       }
-       if (!info->VGAAccess)
-           xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Loading VGA module failed,"
-                      " trying to run without it\n");
-    } else
-           xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VGAAccess option set to FALSE,"
-                      " VGA module load skipped\n");
-    if (info->VGAAccess) {
- vgaHWSetStdFuncs(VGAHWPTR(pScrn));
-        vgaHWGetIOBase(VGAHWPTR(pScrn));
-    }
-#else
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VGAHW support not compiled, VGA "
-               "module load skipped\n");
-#endif
-
-
-
-    if (!R128PreInitWeight(pScrn))    goto fail;
+    info->noAccel = FALSE;
+    info->accelOn = FALSE;
 
-    if(xf86GetOptValInteger(info->Options, OPTION_VIDEO_KEY, &(info->videoKey))) {
-        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n",
-                                info->videoKey);
-    } else {
-        info->videoKey = 0x1E;
-    }
+    info->useEXA = FALSE;
+#ifdef USE_EXA
+#ifndef HAVE_XAA_H
+    info->useEXA = TRUE;
+#endif
+#endif
 
-    if (xf86ReturnOptValBool(info->Options, OPTION_SHOW_CACHE, FALSE)) {
-        info->showCache = TRUE;
-        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ShowCache enabled\n");
-    }
+    info->swCursor = FALSE;
 
-#if defined(__powerpc__) && defined(__linux__)
-    if (xf86ReturnOptValBool(info->Options, OPTION_FBDEV, TRUE))
-#else
-    if (xf86ReturnOptValBool(info->Options, OPTION_FBDEV, FALSE))
-#endif
-    {
- info->FBDev = TRUE;
- xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
-   "Using framebuffer device\n");
-    }
+    r128AcquireOption(pScrn);
 
-    if (info->FBDev) {
- /* check for linux framebuffer device */
- if (!xf86LoadSubModule(pScrn, "fbdevhw")) return FALSE;
- if (!fbdevHWInit(pScrn, info->PciInfo, NULL)) return FALSE;
- pScrn->SwitchMode    = fbdevHWSwitchModeWeak();
- pScrn->AdjustFrame   = fbdevHWAdjustFrameWeak();
- pScrn->ValidMode     = fbdevHWValidModeWeak();
-    }
+    if (!R128PreInitWeight(pScrn))    goto fail;
 
-    if (!info->FBDev)
- if (!R128PreInitInt10(pScrn, &pInt10)) goto fail;
+    /* Allocate an xf86CrtcConfig */
+    xf86CrtcConfigInit(pScrn, &R128CRTCResizeFuncs);
 
-    if (!R128PreInitConfig(pScrn))             goto fail;
+    R128LegacyMS(pScrn);
 
-    if (!R128GetBIOSParameters(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 (!R128GetPLLParameters(pScrn))          goto fail;
+    /* Set display resolution */
+    xf86SetDpi(pScrn, 0, 0);
 
-    /* Don't fail on this one */
-    R128PreInitDDC(pScrn, pInt10);
+    /* Get ScreenInit function */
+    if (!xf86LoadSubModule(pScrn, "fb")) return FALSE;
 
-    if (!R128PreInitGamma(pScrn))              goto fail;
+    R128PreInitAccel(pScrn);
 
-    if (!R128PreInitModes(pScrn))              goto fail;
+    info->CurrentLayout.displayWidth = pScrn->displayWidth;
 
-    if (!R128PreInitCursor(pScrn))             goto fail;
+    if (!xf86RandR12PreInit(pScrn)) {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "RandR initialization failure\n");
+        goto fail;
+    }
 
-#ifdef R128DRI
-    if (!R128PreInitDRI(pScrn))                goto fail;
-#endif
+    if (pScrn->modes == NULL) {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
+        goto fail;
+    }
 
  /* Free the video bios (if applicable) */
     if (info->VBIOS) {
@@ -2077,13 +1552,8 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int
  info->VBIOS = NULL;
     }
 
- /* Free int10 info */
-    if (pInt10)
- xf86FreeInt10(pInt10);
-
-    xf86DrvMsg(pScrn->scrnIndex, X_NOTICE,
- "For information on using the multimedia capabilities\n\tof this"
- " adapter, please see http://gatos.sf.net.\n");
+    if (info->MMIO) R128UnmapMMIO(pScrn);
+    info->MMIO = NULL;
 
     return TRUE;
 
@@ -2096,14 +1566,14 @@ Bool R128PreInit(ScrnInfoPtr pScrn, int
  info->VBIOS = NULL;
     }
 
- /* Free int10 info */
-    if (pInt10)
- xf86FreeInt10(pInt10);
-
 #ifdef WITH_VGAHW
     if (info->VGAAccess)
            vgaHWFreeHWRec(pScrn);
 #endif
+
+    if (info->MMIO) R128UnmapMMIO(pScrn);
+    info->MMIO = NULL;
+
     R128FreeRec(pScrn);
     return FALSE;
 }
@@ -2113,56 +1583,66 @@ static void R128LoadPalette(ScrnInfoPtr
     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);
-
-
-    /* Select palette 0 (main CRTC) if using FP-enabled chip */
-    /*if (info->HasPanelRegs || info->isDFP) PAL_SELECT(0);*/
-
-    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);
- }
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int i, j;
+    int c, index;
+    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];
+        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;
+                    }
+                }
+
+                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;
+        }
+
+        /* 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);
     }
 }
 
@@ -2187,51 +1667,6 @@ R128BlockHandler(BLOCKHANDLER_ARGS_DECL)
     }
 }
 
-#ifdef USE_EXA
-Bool R128VerboseInitEXA(ScreenPtr pScreen)
-{
-    ScrnInfoPtr pScrn  = xf86ScreenToScrn(pScreen);
-    R128InfoPtr info   = R128PTR(pScrn);
-
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Going to init EXA...\n");
-
-    if (R128EXAInit(pScreen)) {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "EXA Acceleration enabled\n");
- info->accelOn = TRUE;
-
- return TRUE;
-    } else {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "EXA Acceleration initialization failed\n");
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "EXA Acceleration disabled\n");
- info->accelOn = FALSE;
-
- return FALSE;
-    }
-}
-#endif
-
-void R128VerboseInitAccel(Bool noAccel, ScreenPtr pScreen)
-{
-    ScrnInfoPtr pScrn  = xf86ScreenToScrn(pScreen);
-    R128InfoPtr info   = R128PTR(pScrn);
-
-    if (!noAccel) {
- if (R128AccelInit(pScreen)) {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Acceleration enabled\n");
-    info->accelOn = TRUE;
- } else {
-    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-       "Acceleration initialization failed\n");
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Acceleration disabled\n");
-    info->accelOn = FALSE;
- }
-    } else {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Acceleration disabled\n");
- info->accelOn = FALSE;
-    }
-}
-
 /* Called at the start of each server generation. */
 Bool R128ScreenInit(SCREEN_INIT_ARGS_DECL)
 {
@@ -2239,40 +1674,22 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
     R128InfoPtr info   = R128PTR(pScrn);
     BoxRec      MemBox;
     int width_bytes = (pScrn->displayWidth *
-   info->CurrentLayout.pixel_bytes);
-    int         x1 = 0, x2 = 0, y1 = 0, y2 = 0;
-    Bool noAccel;
+                        info->CurrentLayout.pixel_bytes);
+    int scanlines;
+    int total = info->FbMapSize;
+    FBAreaPtr fbarea = NULL;
+#ifdef R128DRI
+    int cpp = info->CurrentLayout.pixel_bytes;
+    int x1 = 0, x2 = 0, y1 = 0, y2 = 0;
 #ifdef USE_EXA
     ExaOffscreenArea*     osArea = NULL;
-#else
-    void*  osArea = NULL;
-#endif
-    char *optstr;
-
-    R128TRACE(("R128ScreenInit %x %d\n", pScrn->memPhysBase, pScrn->fbOffset));
-    info->useEXA = FALSE;
-#ifdef USE_EXA
-#ifndef HAVE_XAA_H
-    info->useEXA = TRUE;
-#endif
-#endif
+#endif /* USE_EXA */
+#endif /* R128DRI */
 
-#ifdef USE_EXA
-    optstr = (char *)xf86GetOptValString(info->Options, OPTION_ACCELMETHOD);
-    if (optstr != NULL) {
- xf86DrvMsg(pScrn->scrnIndex, X_INFO, "AccelMethod option found\n");
- if (xf86NameCmp(optstr, "EXA") == 0) {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "AccelMethod is set to EXA, turning EXA on\n");
-    info->useEXA = TRUE;
- }
-    }
-#ifdef RENDER
-    info->RenderAccel = xf86ReturnOptValBool(info->Options, OPTION_RENDERACCEL, TRUE);
-    if (info->RenderAccel)
-        xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Acceleration of RENDER operations will be enabled"
-     "upon successful loading of DRI and EXA\n");
-#endif
-#endif
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s %lx %lx\n",
+                        __func__,
+                        pScrn->memPhysBase, pScrn->fbOffset));
 
 #ifdef R128DRI
  /* Turn off the CCE for now. */
@@ -2282,7 +1699,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
 
     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;
@@ -2293,14 +1710,6 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
     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();
@@ -2310,21 +1719,17 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
   pScrn->defaultVisual)) return FALSE;
     miSetPixmapDepths ();
 
-    noAccel = xf86ReturnOptValBool(info->Options, OPTION_NOACCEL, FALSE);
-
 #ifdef R128DRI
  /* Setup DRI after visuals have been
    established, but before fbScreenInit is
-   called.  fbScreenInit will eventually
-   call the driver's InitGLXVisuals call
-   back. */
+   called. */
     {
  /* FIXME: When we move to dynamic allocation of back and depth
    buffers, we will want to revisit the following check for 3
    times the virtual size of the screen below. */
  int maxy        = info->FbMapSize / width_bytes;
 
- if (noAccel) {
+        if (info->noAccel) {
     xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
        "Acceleration disabled, not initializing the DRI\n");
     info->directRenderingEnabled = FALSE;
@@ -2336,33 +1741,7 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
  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);
-                if(xf86IsEntityShared(pScrn->entityList[0]))
-                {
-                    DevUnion* pPriv;
-                    R128EntPtr pR128Ent;
-                    pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
-                        getR128EntityIndex());
-                    pR128Ent = pPriv->ptr;
-                    pR128Ent->IsDRIEnabled = info->directRenderingEnabled;
-                }
-            }
+            info->directRenderingEnabled = R128DRIScreenInit(pScreen);
  }
     }
 #endif
@@ -2397,11 +1776,8 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
  /* Memory manager setup */
 #ifdef R128DRI
     if (info->directRenderingEnabled) {
- FBAreaPtr fbarea = NULL;
- int cpp = info->CurrentLayout.pixel_bytes;
  int bufferSize = pScrn->virtualY * width_bytes;
- int l, total;
- int scanlines;
+ int l;
 
  switch (info->CCEMode) {
  case R128_DEFAULT_CCE_PIO_MODE:
@@ -2461,19 +1837,26 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
     info->textureSize = 0;
  }
 
- total = info->FbMapSize - info->textureSize;
- scanlines = total / width_bytes;
- if (scanlines > 8191) scanlines = 8191;
+        total = info->FbMapSize - info->textureSize;
+    }
+#endif /* R128DRI */
+
+    scanlines = total / width_bytes;
+    if (scanlines > 8191) scanlines = 8191;
 
- /* Recalculate the texture offset and size to accomodate any
- * rounding to a whole number of scanlines.
- */
- info->textureOffset = scanlines * width_bytes;
+#ifdef R128DRI
+    if (info->directRenderingEnabled)
+        /*
+         * Recalculate the texture offset and size to accomodate any
+         * rounding to a whole number of scanlines.
+         */
+        info->textureOffset = scanlines * width_bytes;
+#endif /* R128DRI */
 
- MemBox.x1 = 0;
- MemBox.y1 = 0;
- MemBox.x2 = pScrn->displayWidth;
- MemBox.y2 = scanlines;
+    MemBox.x1 = 0;
+    MemBox.y1 = 0;
+    MemBox.x2 = pScrn->displayWidth;
+    MemBox.y2 = scanlines;
 
  if (!info->useEXA) {
     if (!xf86InitFBManager(pScreen, &MemBox)) {
@@ -2504,28 +1887,45 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
  width, height);
         }
 
- R128VerboseInitAccel(noAccel, pScreen);
-    }
- }
+            if (!info->noAccel) {
+                if (R128XAAAccelInit(pScreen)) {
+                    info->accelOn = TRUE;
+                    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "XAA acceleration enabled.\n");
+                } else {
+                    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "Acceleration disabled.\n");
+                }
+            }
+        }
+    }
 #ifdef USE_EXA
- else {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Filling in EXA memory info\n");
-
-    R128VerboseInitAccel(noAccel, pScreen);
-    info->ExaDriver->offScreenBase = pScrn->virtualY * width_bytes;
-
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Filled in offs\n");
+    else {
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                    "Filling in EXA memory info\n");
 
-    /* Don't give EXA the true full memory size, because the
-       textureSize sized chunk on the end is handled by DRI */
-    info->ExaDriver->memorySize = total;
 
-    R128VerboseInitEXA(pScreen);
- }
+        /*
+         * Don't give EXA the true full memory size, because
+         * the textureSize sized chunk on the end is handled
+         * by DRI.
+         */
+        if (R128EXAInit(pScreen, total)) {
+            info->accelOn = TRUE;
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "EXA Acceleration enabled.\n");
+        } else {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                        "EXA Acceleration initialization "
+                        "failed.\n");
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Acceleration disabled.\n");
+        }
+    }
 #endif
 
+#ifdef R128DRI
+    if (info->directRenderingEnabled) {
  /* Allocate the shared back buffer */
  if(!info->useEXA) {
     fbarea = xf86AllocateOffscreenArea(pScreen,
@@ -2635,70 +2035,25 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
    "Reserved %d kb for textures at offset 0x%x\n",
    info->textureSize/1024, info->textureOffset);
     }
-    else
 #endif /* R128DRI */
-    {
- MemBox.x1 = 0;
- MemBox.y1 = 0;
- MemBox.x2 = pScrn->displayWidth;
- y2        = (info->FbMapSize
-     / (pScrn->displayWidth *
- info->CurrentLayout.pixel_bytes));
- /* The acceleration engine uses 14 bit
-   signed coordinates, so we can't have any
-   drawable caches beyond this region. */
- if (y2 > 8191) y2 = 8191;
- MemBox.y2 = y2;
-
- if (!info->useEXA) {
-    if (!xf86InitFBManager(pScreen, &MemBox)) {
-        xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-           "Memory manager initialization to (%d,%d) (%d,%d) failed\n",
-           MemBox.x1, MemBox.y1, MemBox.x2, MemBox.y2);
-        return FALSE;
-    } else {
-        int       width, height;
-        FBAreaPtr fbarea;
-
-        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-           "Memory manager initialized to (%d,%d) (%d,%d)\n",
-           MemBox.x1, MemBox.y1, MemBox.x2, MemBox.y2);
-        if ((fbarea = xf86AllocateOffscreenArea(pScreen, pScrn->displayWidth, 2, 0, NULL, NULL, NULL))) {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Reserved area from (%d,%d) to (%d,%d)\n",
-       fbarea->box.x1, fbarea->box.y1,
-       fbarea->box.x2, fbarea->box.y2);
-        } else {
-    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unable to reserve area\n");
-        }
-        if (xf86QueryLargestOffscreenArea(pScreen, &width, &height, 0, 0, 0)) {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Largest offscreen area available: %d x %d\n",
- width, height);
-        }
 
- R128VerboseInitAccel(noAccel, pScreen);
-    }
- }
-#ifdef USE_EXA
- else {
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Filling in EXA memory info\n");
-
-    R128VerboseInitAccel(noAccel, pScreen);
-    info->ExaDriver->offScreenBase = pScrn->virtualY * width_bytes;
-
-    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Filled in offs\n");
+    pScrn->vtSema = TRUE;
+    /* xf86CrtcRotate accesses pScrn->pScreen */
+    pScrn->pScreen = pScreen;
 
-    info->ExaDriver->memorySize = info->FbMapSize;
-    R128VerboseInitEXA(pScreen);
- }
-#endif
+    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);
+#ifdef XFreeXDGA
+    xf86DiDGAInit(pScreen, info->LinearAddr + pScrn->fbOffset);
+#endif
 
  /* Backing store setup */
     xf86SetBackingStore(pScreen);
@@ -2710,13 +2065,10 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
     miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
 
  /* Hardware cursor setup */
-    if (!xf86ReturnOptValBool(info->Options, OPTION_SW_CURSOR, FALSE)) {
+    if (!info->swCursor) {
  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,
@@ -2729,35 +2081,16 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
     xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using software cursor\n");
  }
     } else {
- info->cursor_start = 0;
  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! ([hidden email]) */
-     | 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
+        xf86DPMSInit(pScreen, xf86DPMSSet, 0);
 
-    else {
- if (info->DisplayType == MT_LCD)
-    xf86DPMSInit(pScreen, R128DisplayPowerManagementSetLCD, 0);
- else
-    xf86DPMSInit(pScreen, R128DisplayPowerManagementSet, 0);
-    }
-
-    if (!info->IsSecondary)
- R128InitVideo(pScreen);
+    R128InitVideo(pScreen);
 
  /* Provide SaveScreen */
     pScreen->SaveScreen  = R128SaveScreen;
@@ -2789,11 +2122,25 @@ Bool R128ScreenInit(SCREEN_INIT_ARGS_DEC
     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! ([hidden email]) */
+     | 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;
@@ -2816,255 +2163,63 @@ static void R128RestoreCommonRegisters(S
     OUTREG(R128_CONFIG_CNTL,          restore->config_cntl);
 }
 
-/* Write CRTC registers. */
-static void R128RestoreCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
-{
-    R128InfoPtr   info      = R128PTR(pScrn);
-    unsigned char *R128MMIO = info->MMIO;
-
-    OUTREG(R128_CRTC_GEN_CNTL,        restore->crtc_gen_cntl);
-
-    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);
-    OUTREG(R128_CRTC_V_SYNC_STRT_WID, restore->crtc_v_sync_strt_wid);
-    OUTREG(R128_CRTC_OFFSET,          restore->crtc_offset);
-    OUTREG(R128_CRTC_OFFSET_CNTL,     restore->crtc_offset_cntl);
-    OUTREG(R128_CRTC_PITCH,           restore->crtc_pitch);
-}
-
-/* Write CRTC2 registers. */
-static void R128RestoreCrtc2Registers(ScrnInfoPtr pScrn,
-       R128SavePtr restore)
-{
-    R128InfoPtr info        = R128PTR(pScrn);
-    unsigned char *R128MMIO = info->MMIO;
-
-    OUTREGP(R128_CRTC2_GEN_CNTL, restore->crtc2_gen_cntl,
-    R128_CRTC2_DISP_DIS);
-
-    OUTREG(R128_CRTC2_H_TOTAL_DISP,    restore->crtc2_h_total_disp);
-    OUTREG(R128_CRTC2_H_SYNC_STRT_WID, restore->crtc2_h_sync_strt_wid);
-    OUTREG(R128_CRTC2_V_TOTAL_DISP,    restore->crtc2_v_total_disp);
-    OUTREG(R128_CRTC2_V_SYNC_STRT_WID, restore->crtc2_v_sync_strt_wid);
-    OUTREG(R128_CRTC2_OFFSET,          restore->crtc2_offset);
-    OUTREG(R128_CRTC2_OFFSET_CNTL,     restore->crtc2_offset_cntl);
-    OUTREG(R128_CRTC2_PITCH,           restore->crtc2_pitch);
-}
-
-/* Write flat panel registers */
-static void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+/* 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);
-    OUTREG(R128_FP_GEN_CNTL, restore->fp_gen_cntl & ~(CARD32)R128_FP_BLANK_DIS);
-
-    if(info->isDFP) return;
-
-    tmp = INREG(R128_LVDS_GEN_CNTL);
-    if ((tmp & (R128_LVDS_ON | R128_LVDS_BLON)) ==
- (restore->lvds_gen_cntl & (R128_LVDS_ON | R128_LVDS_BLON))) {
- OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
-    } 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);
-    usleep(R128PTR(pScrn)->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);
-    OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
- }
-    }
-}
-
-static void R128PLLWaitForReadUpdateComplete(ScrnInfoPtr pScrn)
-{
-    while (INPLL(pScrn, R128_PPLL_REF_DIV) & R128_PPLL_ATOMIC_UPDATE_R);
 }
 
-static void R128PLLWriteUpdate(ScrnInfoPtr pScrn)
+/* Write flat panel registers */
+void R128RestoreFPRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
 {
     R128InfoPtr   info      = R128PTR(pScrn);
     unsigned char *R128MMIO = info->MMIO;
 
-    while (INPLL(pScrn, R128_PPLL_REF_DIV) & R128_PPLL_ATOMIC_UPDATE_R);
-
-    OUTPLLP(pScrn, R128_PPLL_REF_DIV, R128_PPLL_ATOMIC_UPDATE_W,
-    ~R128_PPLL_ATOMIC_UPDATE_W);
-
-}
-
-static void R128PLL2WaitForReadUpdateComplete(ScrnInfoPtr pScrn)
-{
-    while (INPLL(pScrn, R128_P2PLL_REF_DIV) & R128_P2PLL_ATOMIC_UPDATE_R);
-}
-
-static void R128PLL2WriteUpdate(ScrnInfoPtr pScrn)
-{
-    R128InfoPtr  info       = R128PTR(pScrn);
-    unsigned char *R128MMIO = info->MMIO;
-
-    while (INPLL(pScrn, R128_P2PLL_REF_DIV) & R128_P2PLL_ATOMIC_UPDATE_R);
-
-    OUTPLLP(pScrn, R128_P2PLL_REF_DIV,
-    R128_P2PLL_ATOMIC_UPDATE_W,
-    ~(R128_P2PLL_ATOMIC_UPDATE_W));
+    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 & ~(uint32_t)R128_FP_BLANK_DIS);
 }
 
-/* Write PLL registers. */
-static void R128RestorePLLRegisters(ScrnInfoPtr pScrn, R128SavePtr restore)
+/* Write LVDS registers */
+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;
 
-    OUTPLLP(pScrn, R128_VCLK_ECP_CNTL,
-    R128_VCLK_SRC_SEL_CPUCLK,
-    ~(R128_VCLK_SRC_SEL_MASK));
-
-    OUTPLLP(pScrn,
-    R128_PPLL_CNTL,
-    R128_PPLL_RESET
-    | R128_PPLL_ATOMIC_UPDATE_EN
-    | R128_PPLL_VGA_ATOMIC_UPDATE_EN,
-    ~(R128_PPLL_RESET
-      | R128_PPLL_ATOMIC_UPDATE_EN
-      | R128_PPLL_VGA_ATOMIC_UPDATE_EN));
-
-    OUTREGP(R128_CLOCK_CNTL_INDEX, R128_PLL_DIV_SEL, ~(R128_PLL_DIV_SEL));
-
-/*        R128PLLWaitForReadUpdateComplete(pScrn);*/
-    OUTPLLP(pScrn, R128_PPLL_REF_DIV,
-    restore->ppll_ref_div, ~R128_PPLL_REF_DIV_MASK);
-/*        R128PLLWriteUpdate(pScrn);
-
-        R128PLLWaitForReadUpdateComplete(pScrn);*/
-    OUTPLLP(pScrn, R128_PPLL_DIV_3,
-    restore->ppll_div_3, ~R128_PPLL_FB3_DIV_MASK);
-/*    R128PLLWriteUpdate(pScrn);*/
-    OUTPLLP(pScrn, R128_PPLL_DIV_3,
-    restore->ppll_div_3, ~R128_PPLL_POST3_DIV_MASK);
-
-    R128PLLWriteUpdate(pScrn);
-    R128PLLWaitForReadUpdateComplete(pScrn);
-
-    OUTPLL(R128_HTOTAL_CNTL, restore->htotal_cntl);
-/*    R128PLLWriteUpdate(pScrn);*/
-
-    OUTPLLP(pScrn, R128_PPLL_CNTL, 0, ~(R128_PPLL_RESET
- | R128_PPLL_SLEEP
- | R128_PPLL_ATOMIC_UPDATE_EN
- | R128_PPLL_VGA_ATOMIC_UPDATE_EN));
-
-    R128TRACE(("Wrote: 0x%08x 0x%08x 0x%08x (0x%08x)\n",
-       restore->ppll_ref_div,
-       restore->ppll_div_3,
-       restore->htotal_cntl,
-       INPLL(pScrn, R128_PPLL_CNTL)));
-    R128TRACE(("Wrote: rd=%d, fd=%d, pd=%d\n",
-       restore->ppll_ref_div & R128_PPLL_REF_DIV_MASK,
-       restore->ppll_div_3 & R128_PPLL_FB3_DIV_MASK,
-       (restore->ppll_div_3 & R128_PPLL_POST3_DIV_MASK) >> 16));
-
-    usleep(5000); /* let the clock lock */
-
-    OUTPLLP(pScrn, R128_VCLK_ECP_CNTL,
-    R128_VCLK_SRC_SEL_PPLLCLK,
-    ~(R128_VCLK_SRC_SEL_MASK));
-
-}
-
-/* Write PLL2 registers. */
-static void R128RestorePLL2Registers(ScrnInfoPtr pScrn, R128SavePtr restore)
-{
-    R128InfoPtr info        = R128PTR(pScrn);
-    unsigned char *R128MMIO = info->MMIO;
-
-    OUTPLLP(pScrn, R128_V2CLK_VCLKTV_CNTL,
-    R128_V2CLK_SRC_SEL_CPUCLK,
-    ~R128_V2CLK_SRC_SEL_MASK);
-    
-    OUTPLLP(pScrn,
-    R128_P2PLL_CNTL,
-    R128_P2PLL_RESET
-    | R128_P2PLL_ATOMIC_UPDATE_EN
-    | R128_P2PLL_VGA_ATOMIC_UPDATE_EN,
-    ~(R128_P2PLL_RESET
-      | R128_P2PLL_ATOMIC_UPDATE_EN
-      | R128_P2PLL_VGA_ATOMIC_UPDATE_EN));
-
-#if 1
-    OUTREGP(R128_CLOCK_CNTL_INDEX, 0, R128_PLL2_DIV_SEL_MASK);
-#endif
-  
-        /*R128PLL2WaitForReadUpdateComplete(pScrn);*/
-    
-    OUTPLLP(pScrn, R128_P2PLL_REF_DIV, restore->p2pll_ref_div, ~R128_P2PLL_REF_DIV_MASK);
-    
-/*        R128PLL2WriteUpdate(pScrn);  
-    R128PLL2WaitForReadUpdateComplete(pScrn);*/
-
-    OUTPLLP(pScrn, R128_P2PLL_DIV_0,
- restore->p2pll_div_0, ~R128_P2PLL_FB0_DIV_MASK);
-
-/*    R128PLL2WriteUpdate(pScrn);
-    R128PLL2WaitForReadUpdateComplete(pScrn);*/
-    
-    OUTPLLP(pScrn, R128_P2PLL_DIV_0,
- restore->p2pll_div_0, ~R128_P2PLL_POST0_DIV_MASK);
-
-    R128PLL2WriteUpdate(pScrn);
-    R128PLL2WaitForReadUpdateComplete(pScrn);
-    
-    OUTPLL(R128_HTOTAL2_CNTL, restore->htotal_cntl2);
-    
-/*        R128PLL2WriteUpdate(pScrn);*/
-    
-    OUTPLLP(pScrn, R128_P2PLL_CNTL, 0, ~(R128_P2PLL_RESET
- | R128_P2PLL_SLEEP
- | R128_P2PLL_ATOMIC_UPDATE_EN
- | R128_P2PLL_VGA_ATOMIC_UPDATE_EN));
-
-    R128TRACE(("Wrote: 0x%08x 0x%08x 0x%08x (0x%08x)\n",
-       restore->p2pll_ref_div,
-       restore->p2pll_div_0,
-       restore->htotal_cntl2,
-       INPLL(pScrn, R128_P2PLL_CNTL)));
-    R128TRACE(("Wrote: rd=%d, fd=%d, pd=%d\n",
-       restore->p2pll_ref_div & R128_P2PLL_REF_DIV_MASK,
-       restore->p2pll_div_0 & R128_P2PLL_FB0_DIV_MASK,
-       (restore->p2pll_div_0 & R128_P2PLL_POST0_DIV_MASK) >>16));
-
-    usleep(5000); /* Let the clock to lock */
-
-    OUTPLLP(pScrn, R128_V2CLK_VCLKTV_CNTL,
-    R128_V2CLK_SRC_SEL_P2PLLCLK,
-    ~R128_V2CLK_SRC_SEL_MASK);
-
+    tmp = INREG(R128_LVDS_GEN_CNTL);
+    if ((tmp & (R128_LVDS_ON | R128_LVDS_BLON)) ==
+ (restore->lvds_gen_cntl & (R128_LVDS_ON | R128_LVDS_BLON))) {
+ OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
+    } else {
+ 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(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(r128_output->PanelPwrDly * 1000);
+    OUTREG(R128_LVDS_GEN_CNTL, restore->lvds_gen_cntl);
+ }
+    }
 }
 
 /* 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;
@@ -3074,7 +2229,7 @@ static void R128RestoreDDARegisters(Scrn
 }
 
 /* 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;
@@ -3083,126 +2238,6 @@ static void R128RestoreDDA2Registers(Scr
     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)
 {
@@ -3249,8 +2284,6 @@ static void R128SaveFPRegisters(ScrnInfo
     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);
@@ -3285,16 +2318,20 @@ static void R128SavePLLRegisters(ScrnInf
 {
     save->ppll_ref_div         = INPLL(pScrn, R128_PPLL_REF_DIV);
     save->ppll_div_3           = INPLL(pScrn, R128_PPLL_DIV_3);
+    save->ppll_div_0           = INPLL(pScrn, R128_PPLL_DIV_0);
     save->htotal_cntl          = INPLL(pScrn, R128_HTOTAL_CNTL);
 
-    R128TRACE(("Read: 0x%08x 0x%08x 0x%08x\n",
-       save->ppll_ref_div,
-       save->ppll_div_3,
-       save->htotal_cntl));
-    R128TRACE(("Read: rd=%d, fd=%d, pd=%d\n",
-       save->ppll_ref_div & R128_PPLL_REF_DIV_MASK,
-       save->ppll_div_3 & R128_PPLL_FB3_DIV_MASK,
-       (save->ppll_div_3 & R128_PPLL_POST3_DIV_MASK) >> 16));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Read: 0x%08x 0x%08x 0x%08x\n",
+                        save->ppll_ref_div,
+                        save->ppll_div_3,
+                        save->htotal_cntl));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Read: rd=%d, fd=%d, pd=%d\n",
+                        save->ppll_ref_div & R128_PPLL_REF_DIV_MASK,
+                        save->ppll_div_3 & R128_PPLL_FB3_DIV_MASK,
+                        (save->ppll_div_3 &
+                                R128_PPLL_POST3_DIV_MASK) >> 16));
 }
 
 /* Read PLL2 registers. */
@@ -3304,14 +2341,17 @@ static void R128SavePLL2Registers(ScrnIn
     save->p2pll_div_0          = INPLL(pScrn, R128_P2PLL_DIV_0);
     save->htotal_cntl2         = INPLL(pScrn, R128_HTOTAL2_CNTL);
 
-    R128TRACE(("Read: 0x%08x 0x%08x 0x%08x\n",
-       save->p2pll_ref_div,
-       save->p2pll_div_0,
-       save->htotal_cntl2));
-    R128TRACE(("Read: rd=%d, fd=%d, pd=%d\n",
-       save->p2pll_ref_div & R128_P2PLL_REF_DIV_MASK,
-       save->p2pll_div_0 & R128_P2PLL_FB0_DIV_MASK,
-       (save->p2pll_div_0 & R128_P2PLL_POST0_DIV_MASK) >> 16));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Read: 0x%08x 0x%08x 0x%08x\n",
+                        save->p2pll_ref_div,
+                        save->p2pll_div_0,
+                        save->htotal_cntl2));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Read: rd=%d, fd=%d, pd=%d\n",
+                        save->p2pll_ref_div & R128_P2PLL_REF_DIV_MASK,
+                        save->p2pll_div_0 & R128_P2PLL_FB0_DIV_MASK,
+                        (save->p2pll_div_0 &
+                                R128_P2PLL_POST0_DIV_MASK) >> 16));
 }
 
 /* Read DDA registers. */
@@ -3354,30 +2394,27 @@ static void R128SavePalette(ScrnInfoPtr
 static void R128SaveMode(ScrnInfoPtr pScrn, R128SavePtr save)
 {
     R128InfoPtr   info      = R128PTR(pScrn);
+    R128EntPtr    pR128Ent  = R128EntPriv(pScrn);
 
-    R128TRACE(("R128SaveMode(%p)\n", save));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s(%p)\n", __func__, 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));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s returns %p\n", __func__, save));
 }
 
 /* Save everything needed to restore the original VC state. */
@@ -3387,52 +2424,52 @@ static void R128Save(ScrnInfoPtr pScrn)
     unsigned char *R128MMIO = info->MMIO;
     R128SavePtr   save      = &info->SavedReg;
 
-    R128TRACE(("R128Save\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
     if (info->FBDev) {
  fbdevHWSave(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. */
 static void R128Restore(ScrnInfoPtr pScrn)
 {
     R128InfoPtr   info      = R128PTR(pScrn);
+    R128EntPtr    pR128Ent  = R128EntPriv(pScrn);
     unsigned char *R128MMIO = info->MMIO;
     R128SavePtr   restore   = &info->SavedReg;
 
-    R128TRACE(("R128Restore\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
     if (info->FBDev) {
  fbdevHWRestore(pScrn);
  return;
@@ -3440,47 +2477,39 @@ static void R128Restore(ScrnInfoPtr pScr
 
     R128Blank(pScrn);
 
-    R128RestoreMode(pScrn, restore);
-
-    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);
 
 #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
 
@@ -3489,7 +2518,7 @@ static void R128Restore(ScrnInfoPtr pScr
 }
 
 /* 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;
@@ -3515,257 +2544,37 @@ static void R128InitCommonRegisters(R128
  save->bus_cntl |= R128_BUS_RD_DISCARD_EN | R128_BUS_RD_ABORT_EN;
 }
 
-/* Define CRTC registers for requested video mode. */
-static Bool R128InitCrtcRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
-  DisplayModePtr mode, R128InfoPtr info)
-{
-    int    format;
-    int    hsync_start;
-    int    hsync_wid;
-    int    hsync_fudge;
-    int    vsync_wid;
-    int    hsync_fudge_default[] = { 0x00, 0x12, 0x09, 0x09, 0x06, 0x05 };
-    int    hsync_fudge_fp[]      = { 0x12, 0x11, 0x09, 0x09, 0x05, 0x05 };
-//   int    hsync_fudge_fp_crt[]  = { 0x12, 0x10, 0x08, 0x08, 0x04, 0x04 };
-
-    switch (info->CurrentLayout.pixel_code) {
-    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;
-    }
-
-    if ((info->DisplayType == MT_DFP) ||
-        (info->DisplayType == MT_LCD))
- hsync_fudge = hsync_fudge_fp[format-1];
-    else              
-        hsync_fudge = hsync_fudge_default[format-1];
-
-    save->crtc_gen_cntl = (R128_CRTC_EXT_DISP_EN
-  | R128_CRTC_EN
-  | (format << 8)
-  | ((mode->Flags & V_DBLSCAN)
-     ? R128_CRTC_DBL_SCAN_EN
-     : 0)
-  | ((mode->Flags & V_INTERLACE)
-     ? R128_CRTC_INTERLACE_EN
-     : 0)
-  | ((mode->Flags & V_CSYNC)
-     ? R128_CRTC_CSYNC_EN
-     : 0));
-
-    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 |
-      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)
-            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)
-      | (((mode->CrtcHDisplay / 8) - 1) << 16));
-
-    hsync_wid = (mode->CrtcHSyncEnd - mode->CrtcHSyncStart) / 8;
-    if (!hsync_wid)       hsync_wid = 1;
-    if (hsync_wid > 0x3f) hsync_wid = 0x3f;
-
-    hsync_start = mode->CrtcHSyncStart - 8 + hsync_fudge;
-
-    save->crtc_h_sync_strt_wid = ((hsync_start & 0xfff)
- | (hsync_wid << 16)
- | ((mode->Flags & V_NHSYNC)
-    ? R128_CRTC_H_SYNC_POL
-    : 0));
-
-#if 1
- /* This works for double scan mode. */
-    save->crtc_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
-      | ((mode->CrtcVDisplay - 1) << 16));
-#else
- /* This is what cce/nbmode.c example code
-   does -- is this correct? */
-    save->crtc_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
-      | ((mode->CrtcVDisplay
-  * ((mode->Flags & V_DBLSCAN) ? 2 : 1) - 1)
- << 16));
-#endif
-
-    vsync_wid = mode->CrtcVSyncEnd - mode->CrtcVSyncStart;
-    if (!vsync_wid)       vsync_wid = 1;
-    if (vsync_wid > 0x1f) vsync_wid = 0x1f;
-
-    save->crtc_v_sync_strt_wid = (((mode->CrtcVSyncStart - 1) & 0xfff)
- | (vsync_wid << 16)
- | ((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",
-       save->crtc_pitch, pScrn->virtualX, info->CurrentLayout.displayWidth));
-
-#if X_BYTE_ORDER == X_BIG_ENDIAN
-    /* Change the endianness of the aperture */
-    switch (info->CurrentLayout.pixel_code) {
-    case 15:
-    case 16: save->config_cntl |= APER_0_BIG_ENDIAN_16BPP_SWAP; break;
-    case 32: save->config_cntl |= APER_0_BIG_ENDIAN_32BPP_SWAP; break;
-    default: break;
-    }
-#endif
-
-    return TRUE;
-}
-
-/* Define CRTC2 registers for requested video mode. */
-static Bool R128InitCrtc2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
-  DisplayModePtr mode, R128InfoPtr info)
-{
-    int    format;
-    int    hsync_start;
-    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 */
-    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];
-
-    save->crtc2_gen_cntl = (R128_CRTC2_EN
-  | (format << 8)
-  | ((mode->Flags & V_DBLSCAN)
-     ? R128_CRTC2_DBL_SCAN_EN
-     : 0));
-/*
-    save->crtc2_gen_cntl &= ~R128_CRTC_EXT_DISP_EN;
-    save->crtc2_gen_cntl |= (1 << 21);
-*/
-    save->crtc2_h_total_disp = ((((mode->CrtcHTotal / 8) - 1) & 0xffff)
-      | (((mode->CrtcHDisplay / 8) - 1) << 16));
-
-    hsync_wid = (mode->CrtcHSyncEnd - mode->CrtcHSyncStart) / 8;
-    if (!hsync_wid)       hsync_wid = 1;
-    if (hsync_wid > 0x3f) hsync_wid = 0x3f;
-
-    hsync_start = mode->CrtcHSyncStart - 8 + hsync_fudge;
-
-    save->crtc2_h_sync_strt_wid = ((hsync_start & 0xfff)
- | (hsync_wid << 16)
- | ((mode->Flags & V_NHSYNC)
-    ? R128_CRTC2_H_SYNC_POL
-    : 0));
-
-#if 1
- /* This works for double scan mode. */
-    save->crtc2_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
-      | ((mode->CrtcVDisplay - 1) << 16));
-#else
- /* This is what cce/nbmode.c example code
-   does -- is this correct? */
-    save->crtc2_v_total_disp = (((mode->CrtcVTotal - 1) & 0xffff)
-      | ((mode->CrtcVDisplay
-  * ((mode->Flags & V_DBLSCAN) ? 2 : 1) - 1)
- << 16));
-#endif
-
-    vsync_wid = mode->CrtcVSyncEnd - mode->CrtcVSyncStart;
-    if (!vsync_wid)       vsync_wid = 1;
-    if (vsync_wid > 0x1f) vsync_wid = 0x1f;
-
-    save->crtc2_v_sync_strt_wid = (((mode->CrtcVSyncStart - 1) & 0xfff)
- | (vsync_wid << 16)
- | ((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",
- save->crtc2_pitch, pScrn->virtualX,
- info->CurrentLayout.displayWidth));
-    return TRUE;
-}
-
-/* Define CRTC registers for requested video mode. */
-static void R128InitFPRegisters(R128SavePtr orig, R128SavePtr save,
- DisplayModePtr mode, R128InfoPtr info)
+/* 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->MonType != MT_DFP && r128_output->MonType != MT_LCD)
         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 = (float)xres/(float)info->PanelXRes;
-    Vratio = (float)yres/(float)info->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)r128_output->PanelXRes;
+        Vratio = (float)yres/(float)r128_output->PanelYRes;
+    }
 
     save->fp_horz_stretch =
  (((((int)(Hratio * R128_HORZ_STRETCH_RATIO_MAX + 0.5))
@@ -3775,7 +2584,7 @@ static void R128InitFPRegisters(R128Save
                                  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);
@@ -3786,312 +2595,56 @@ static void R128InitFPRegisters(R128Save
  (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            = 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;
 
-        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;
-    }
+    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_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;
-}
-
-/* Define PLL registers for requested video mode. */
-static void R128InitPLLRegisters(ScrnInfoPtr pScrn, R128SavePtr save,
- R128PLLPtr pll, double dot_clock)
-{
-    unsigned long freq = dot_clock * 100;
-    struct {
- int divider;
- int bitvalue;
-    } *post_div,
-      post_divs[]   = {
- /* From RAGE 128 VR/RAGE 128 GL Register
-   Reference Manual (Technical Reference
-   Manual P/N RRG-G04100-C Rev. 0.04), page
-   3-17 (PLL_DIV_[3:0]).  */
- {  1, 0 },              /* VCLK_SRC                 */
- {  2, 1 },              /* VCLK_SRC/2               */
- {  4, 2 },              /* VCLK_SRC/4               */
- {  8, 3 },              /* VCLK_SRC/8               */
-
- {  3, 4 },              /* VCLK_SRC/3               */
- /* bitvalue = 5 is reserved */
- {  6, 6 },              /* VCLK_SRC/6               */
- { 12, 7 },              /* VCLK_SRC/12              */
- {  0, 0 }
-    };
-
-    if (freq > pll->max_pll_freq)      freq = pll->max_pll_freq;
-    if (freq * 12 < pll->min_pll_freq) freq = pll->min_pll_freq / 12;
-
-    for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
- save->pll_output_freq = post_div->divider * freq;
- if (save->pll_output_freq >= pll->min_pll_freq
-    && save->pll_output_freq <= pll->max_pll_freq) break;
-    }
-
-    save->dot_clock_freq = freq;
-    save->feedback_div   = R128Div(pll->reference_div * save->pll_output_freq,
-   pll->reference_freq);
-    save->post_div       = post_div->divider;
-
-    R128TRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",
-       save->dot_clock_freq,
-       save->pll_output_freq,
-       save->feedback_div,
-       save->post_div));
-
-    save->ppll_ref_div   = pll->reference_div;
-    save->ppll_div_3     = (save->feedback_div | (post_div->bitvalue << 16));
-    save->htotal_cntl    = 0;
-
-}
-
-/* Define PLL2 registers for requested video mode. */
-static void R128InitPLL2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
-   R128PLLPtr pll, double dot_clock)
-{
-    unsigned long freq = dot_clock * 100;
-    struct {
- int divider;
- int bitvalue;
-    } *post_div,
-      post_divs[]   = {
- /* From RAGE 128 VR/RAGE 128 GL Register
-   Reference Manual (Technical Reference
-   Manual P/N RRG-G04100-C Rev. 0.04), page
-   3-17 (PLL_DIV_[3:0]).  */
- {  1, 0 },              /* VCLK_SRC                 */
- {  2, 1 },              /* VCLK_SRC/2               */
- {  4, 2 },              /* VCLK_SRC/4               */
- {  8, 3 },              /* VCLK_SRC/8               */
-
- {  3, 4 },              /* VCLK_SRC/3               */
- /* bitvalue = 5 is reserved */
- {  6, 6 },              /* VCLK_SRC/6               */
- { 12, 7 },              /* VCLK_SRC/12              */
- {  0, 0 }
-    };
-
-    if (freq > pll->max_pll_freq)      freq = pll->max_pll_freq;
-    if (freq * 12 < pll->min_pll_freq) freq = pll->min_pll_freq / 12;
-
-    for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
- save->pll_output_freq_2 = post_div->divider * freq;
- if (save->pll_output_freq_2 >= pll->min_pll_freq
-    && save->pll_output_freq_2 <= pll->max_pll_freq) break;
-    }
-
-    save->dot_clock_freq_2 = freq;
-    save->feedback_div_2   = R128Div(pll->reference_div
-     * save->pll_output_freq_2,
-     pll->reference_freq);
-    save->post_div_2       = post_div->divider;
-
-    R128TRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",
-       save->dot_clock_freq_2,
-       save->pll_output_freq_2,
-       save->feedback_div_2,
-       save->post_div_2));
-
-    save->p2pll_ref_div   = pll->reference_div;
-    save->p2pll_div_0    = (save->feedback_div_2 | (post_div->bitvalue<<16));
-    save->htotal_cntl2    = 0;
-}
-
-/* Define DDA registers for requested video mode. */
-static Bool R128InitDDARegisters(ScrnInfoPtr pScrn, R128SavePtr save,
- R128PLLPtr pll, R128InfoPtr info,
-                                 DisplayModePtr mode)
-{
-    int         DisplayFifoWidth = 128;
-    int         DisplayFifoDepth = 32;
-    int         XclkFreq;
-    int         VclkFreq;
-    int         XclksPerTransfer;
-    int         XclksPerTransferPrecise;
-    int         UseablePrecision;
-    int         Roff;
-    int         Ron;
-
-    XclkFreq = pll->xclk;
-
-    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;
- }
-
-    XclksPerTransfer = R128Div(XclkFreq * DisplayFifoWidth,
-       VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
-
-    UseablePrecision = R128MinBits(XclksPerTransfer) + 1;
-
-    XclksPerTransferPrecise = R128Div((XclkFreq * DisplayFifoWidth)
-      << (11 - UseablePrecision),
-      VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
-
-    Roff  = XclksPerTransferPrecise * (DisplayFifoDepth - 4);
-
-    Ron   = (4 * info->ram->MB
-     + 3 * MAX(info->ram->Trcd - 2, 0)
-     + 2 * info->ram->Trp
-     + info->ram->Twr
-     + info->ram->CL
-     + info->ram->Tr2w
-     + XclksPerTransfer) << (11 - UseablePrecision);
+        save->fp_gen_cntl       &=  ~R128_FP_SEL_CRTC2;
 
-    if (Ron + info->ram->Rloop >= Roff) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "(Ron = %d) + (Rloop = %d) >= (Roff = %d)\n",
-   Ron, info->ram->Rloop, Roff);
- return FALSE;
-    }
+    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->dda_config = (XclksPerTransferPrecise
- | (UseablePrecision << 16)
- | (info->ram->Rloop << 20));
-
-    save->dda_on_off = (Ron << 16) | Roff;
-
-    R128TRACE(("XclkFreq = %d; VclkFreq = %d; per = %d, %d (useable = %d)\n",
-       XclkFreq,
-       VclkFreq,
-       XclksPerTransfer,
-       XclksPerTransferPrecise,
-       UseablePrecision));
-    R128TRACE(("Roff = %d, Ron = %d, Rloop = %d\n",
-       Roff, Ron, info->ram->Rloop));
+    save->fp_gen_cntl           |=  (R128_FP_CRTC_DONT_SHADOW_VPAR |
+                                     R128_FP_CRTC_DONT_SHADOW_HEND);
 
-    return TRUE;
+    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 DDA2 registers for requested video mode. */
-static Bool R128InitDDA2Registers(ScrnInfoPtr pScrn, R128SavePtr save,
- R128PLLPtr pll, R128InfoPtr info,
-                                 DisplayModePtr mode)
-{
-    int         DisplayFifoWidth = 128;
-    int         DisplayFifoDepth = 32;
-    int         XclkFreq;
-    int         VclkFreq;
-    int         XclksPerTransfer;
-    int         XclksPerTransferPrecise;
-    int         UseablePrecision;
-    int         Roff;
-    int         Ron;
-
-    XclkFreq = pll->xclk;
-
-    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;
- }
-
-    XclksPerTransfer = R128Div(XclkFreq * DisplayFifoWidth,
-       VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
-
-    UseablePrecision = R128MinBits(XclksPerTransfer) + 1;
-
-    XclksPerTransferPrecise = R128Div((XclkFreq * DisplayFifoWidth)
-      << (11 - UseablePrecision),
-      VclkFreq * (info->CurrentLayout.pixel_bytes * 8));
-
-    Roff  = XclksPerTransferPrecise * (DisplayFifoDepth - 4);
-
-    Ron   = (4 * info->ram->MB
-     + 3 * MAX(info->ram->Trcd - 2, 0)
-     + 2 * info->ram->Trp
-     + info->ram->Twr
-     + info->ram->CL
-     + info->ram->Tr2w
-     + XclksPerTransfer) << (11 - UseablePrecision);
-
-
-    if (Ron + info->ram->Rloop >= Roff) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-   "(Ron = %d) + (Rloop = %d) >= (Roff = %d)\n",
-   Ron, info->ram->Rloop, Roff);
- return FALSE;
-    }
+/* 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->dda2_config = (XclksPerTransferPrecise
- | (UseablePrecision << 16)
- | (info->ram->Rloop << 20));
-
-    /*save->dda2_on_off = (Ron << 16) | Roff;*/
-    /* shift most be 18 otherwise there's corruption on crtc2 */
-    save->dda2_on_off = (Ron << 18) | Roff;
-
-    R128TRACE(("XclkFreq = %d; VclkFreq = %d; per = %d, %d (useable = %d)\n",
-       XclkFreq,
-       VclkFreq,
-       XclksPerTransfer,
-       XclksPerTransferPrecise,
-       UseablePrecision));
-    R128TRACE(("Roff = %d, Ron = %d, Rloop = %d\n",
-       Roff, Ron, info->ram->Rloop));
+    save->lvds_gen_cntl      =  orig->lvds_gen_cntl;
 
-    return TRUE;
+    if (r128_crtc->crtc_id)
+        save->lvds_gen_cntl |=  R128_LVDS_SEL_CRTC2;
+    else
+        save->lvds_gen_cntl &= ~R128_LVDS_SEL_CRTC2;
 }
 
 #if 0
@@ -4103,122 +2656,6 @@ static void R128InitPalette(R128SavePtr
 }
 #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);
@@ -4249,74 +2686,64 @@ Bool R128SwitchMode(SWITCH_MODE_ARGS_DEC
     Bool ret;
 
     info->SwitchingMode = TRUE;
-    ret = R128ModeInit(pScrn, mode);
+    ret = xf86SetSingleMode(pScrn, mode, RR_Rotate_0);
     info->SwitchingMode = FALSE;
     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);
-
-    if (info->BIOSDisplay == R128_BIOS_DISPLAY_CRT)
- return MODE_OK;
+    ScrnInfoPtr pScrn = output->scrn;
+    R128InfoPtr info  = R128PTR(pScrn);
+    R128OutputPrivatePtr r128_output = output->driver_private;
+    int i, j;
 
-    if(info->isDFP) {
-        if(info->PanelXRes < mode->CrtcHDisplay ||
-           info->PanelYRes < mode->CrtcVDisplay)
-            return MODE_NOMODE;
-        else
-            return MODE_OK;
-    }
+    if (r128_output->MonType == MT_CRT)
+        return MODE_OK;
 
-    if (info->DisplayType == 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;
     }
 
-    if (info->DisplayType == MT_LCD &&
- info->VBIOS) {
- int i;
- for (i = info->FPBIOSstart+64; R128_BIOS16(i) != 0; i += 2) {
-    int j = R128_BIOS16(i);
+    if (r128_output->MonType == MT_LCD && info->VBIOS) {
+ for (i = info->FPBIOSstart + 64; R128_BIOS16(i) != 0; i += 2) {
+    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);
-    else                  j += 9;
+    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;
+ ((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;
     }
@@ -4332,6 +2759,17 @@ ModeStatus R128ValidMode(SCRN_ARG_TYPE a
     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)
@@ -4358,14 +2796,7 @@ void R128AdjustFrame(ADJUST_FRAME_ARGS_D
     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
@@ -4375,11 +2806,18 @@ Bool R128EnterVT(VT_FUNC_ARGS_DECL)
     SCRN_INFO_PTR(arg);
     R128InfoPtr info  = R128PTR(pScrn);
 
-    R128TRACE(("R128EnterVT\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
+
+    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);
 
@@ -4396,7 +2834,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;
 }
@@ -4409,7 +2847,8 @@ void R128LeaveVT(VT_FUNC_ARGS_DECL)
     R128InfoPtr info  = R128PTR(pScrn);
     R128SavePtr save  = &info->ModeReg;
 
-    R128TRACE(("R128LeaveVT\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
 #ifdef R128DRI
     if (info->directRenderingEnabled) {
  DRILock(pScrn->pScreen, 0);
@@ -4437,7 +2876,8 @@ static Bool R128CloseScreen(CLOSE_SCREEN
     ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
     R128InfoPtr info  = R128PTR(pScrn);
 
-    R128TRACE(("R128CloseScreen\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
 
 #ifdef R128DRI
  /* Disable direct rendering */
@@ -4468,12 +2908,6 @@ static Bool R128CloseScreen(CLOSE_SCREEN
     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;
-
     if (info->adaptor) {
         free(info->adaptor->pPortPrivates[0].ptr);
  xf86XVFreeVideoAdaptorRec(info->adaptor);
@@ -4492,7 +2926,8 @@ void R128FreeScreen(FREE_SCREEN_ARGS_DEC
     SCRN_INFO_PTR(arg);
     R128InfoPtr   info      = R128PTR(pScrn);
 
-    R128TRACE(("R128FreeScreen\n"));
+    DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "%s\n", __func__));
     if (info == NULL)
  return;
 #ifdef WITH_VGAHW
@@ -4500,131 +2935,4 @@ void R128FreeScreen(FREE_SCREEN_ARGS_DEC
  vgaHWFreeHWRec(pScrn);
 #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;
 }
Index: src/r128_exa.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_exa.c,v
retrieving revision 1.1
diff -u -p -u -r1.1 r128_exa.c
--- src/r128_exa.c 23 Nov 2012 20:47:04 -0000 1.1
+++ src/r128_exa.c 25 Mar 2021 21:03:14 -0000
@@ -36,31 +36,10 @@
 #include "exa.h"
 
 #include "r128_reg.h"
+#include "r128_rop.h"
 
 #include "xf86.h"
 
-static struct {
-    int rop;
-    int pattern;
-} R128_ROP[] = {
-    { R128_ROP3_ZERO, R128_ROP3_ZERO }, /* GXclear        */
-    { R128_ROP3_DSa,  R128_ROP3_DPa  }, /* Gxand          */
-    { R128_ROP3_SDna, R128_ROP3_PDna }, /* GXandReverse   */
-    { R128_ROP3_S,    R128_ROP3_P    }, /* GXcopy         */
-    { R128_ROP3_DSna, R128_ROP3_DPna }, /* GXandInverted  */
-    { R128_ROP3_D,    R128_ROP3_D    }, /* GXnoop         */
-    { R128_ROP3_DSx,  R128_ROP3_DPx  }, /* GXxor          */
-    { R128_ROP3_DSo,  R128_ROP3_DPo  }, /* GXor           */
-    { R128_ROP3_DSon, R128_ROP3_DPon }, /* GXnor          */
-    { R128_ROP3_DSxn, R128_ROP3_PDxn }, /* GXequiv        */
-    { R128_ROP3_Dn,   R128_ROP3_Dn   }, /* GXinvert       */
-    { R128_ROP3_SDno, R128_ROP3_PDno }, /* GXorReverse    */
-    { R128_ROP3_Sn,   R128_ROP3_Pn   }, /* GXcopyInverted */
-    { R128_ROP3_DSno, R128_ROP3_DPno }, /* GXorInverted   */
-    { R128_ROP3_DSan, R128_ROP3_DPan }, /* GXnand         */
-    { R128_ROP3_ONE,  R128_ROP3_ONE  }  /* GXset          */
-};
-
 /* Assumes that depth 15 and 16 can be used as depth 16, which is okay since we
  * require src and dest datatypes to be equal.
  */
@@ -92,12 +71,14 @@ static Bool R128GetOffsetPitch(PixmapPtr
     R128InfoPtr   info      = R128PTR(pScrn);
 
     if (pitch > 16320 || pitch % info->ExaDriver->pixmapPitchAlign != 0) {
-        R128TRACE(("Bad pitch 0x%08x\n", pitch));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Bad pitch 0x%08x\n", pitch));
  return FALSE;
     }
 
     if (offset % info->ExaDriver->pixmapOffsetAlign != 0) {
-        R128TRACE(("Bad offset 0x%08x\n", offset));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Bad offset 0x%08x\n", offset));
  return FALSE;
     }
 
@@ -143,7 +124,7 @@ static void Emit2DState(ScrnInfoPtr pScr
 }
 
 #ifdef R128DRI
-static void EmitCCE2DState(ScrnInfoPtr pScrn)
+void EmitCCE2DState(ScrnInfoPtr pScrn)
 {
     R128InfoPtr   info      = R128PTR(pScrn);
     int has_src    = info->state_2d.src_pitch_offset;
@@ -182,11 +163,13 @@ R128PrepareSolid(PixmapPtr pPixmap, int
     uint32_t datatype, dst_pitch_offset;
 
     if (!R128GetDatatypeBpp(bpp, &datatype)) {
-        R128TRACE(("R128GetDatatypeBpp failed\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "R128GetDatatypeBpp failed\n"));
  return FALSE;
     }
     if (!R128GetPixmapOffsetPitch(pPixmap, &dst_pitch_offset)) {
-        R128TRACE(("R128GetPixmapOffsetPitch failed\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "R128GetPixmapOffsetPitch failed\n"));
  return FALSE;
     }
     if (info->state_2d.in_use) return FALSE;
@@ -281,15 +264,19 @@ R128PrepareCopy(PixmapPtr pSrcPixmap, Pi
     uint32_t datatype, src_pitch_offset, dst_pitch_offset;
 
     if (!R128GetDatatypeBpp(bpp, &datatype)) {
-        R128TRACE(("R128GetDatatypeBpp failed\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "R128GetDatatypeBpp failed\n"));
  return FALSE;
     }
     if (!R128GetPixmapOffsetPitch(pSrcPixmap, &src_pitch_offset)) {
-        R128TRACE(("R128GetPixmapOffsetPitch source failed\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "R128GetPixmapOffsetPitch source "
+                            "failed\n"));
  return FALSE;
     }
     if (!R128GetPixmapOffsetPitch(pDstPixmap, &dst_pitch_offset)) {
-        R128TRACE(("R128GetPixmapOffsetPitch dest failed\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "R128GetPixmapOffsetPitch dest failed\n"));
  return FALSE;
     }
     if (info->state_2d.in_use) return FALSE;
@@ -327,7 +314,7 @@ R128Sync(ScreenPtr pScreen, int marker)
     R128WaitForIdle(xf86ScreenToScrn(pScreen));
 }
 
-static void
+void
 R128Done(PixmapPtr pPixmap)
 {
     ScreenPtr     pScreen   = pPixmap->drawable.pScreen;
@@ -404,22 +391,29 @@ R128CCESync(ScreenPtr pScreen, int marke
     R128CCEWaitForIdle(xf86ScreenToScrn(pScreen));
 }
 
-#ifdef RENDER
-#include "r128_exa_render.c"
-#endif
-
 #endif
 
 Bool
-R128EXAInit(ScreenPtr pScreen)
+R128EXAInit(ScreenPtr pScreen, int total)
 {
     ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
     R128InfoPtr info  = R128PTR(pScrn);
 
+    info->ExaDriver = exaDriverAlloc();
+    if (!info->ExaDriver) {
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                    "Could not allocate EXA driver...\n");
+        return FALSE;
+    }
+
     info->ExaDriver->exa_major = EXA_VERSION_MAJOR;
     info->ExaDriver->exa_minor = EXA_VERSION_MINOR;
 
     info->ExaDriver->memoryBase = info->FB + pScrn->fbOffset;
+    info->ExaDriver->offScreenBase = pScrn->virtualY *
+                                        (pScrn->displayWidth *
+                                        info->CurrentLayout.pixel_bytes);
+    info->ExaDriver->memorySize = total;
     info->ExaDriver->flags = EXA_OFFSCREEN_PIXMAPS | EXA_OFFSCREEN_ALIGN_POT;
 
 #if EXA_VERSION_MAJOR > 2 || (EXA_VERSION_MAJOR == 2 && EXA_VERSION_MINOR >= 3)
@@ -476,7 +470,7 @@ R128EXAInit(ScreenPtr pScreen)
     }
 
     xf86DrvMsg(pScrn->scrnIndex, X_INFO,
-       "Initalizing 2D acceleration engine...\n");
+       "Initializing 2D acceleration engine...\n");
 
     R128EngineInit(pScrn);
 
Index: src/r128_exa_render.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_exa_render.c,v
retrieving revision 1.1
diff -u -p -u -r1.1 r128_exa_render.c
--- src/r128_exa_render.c 23 Nov 2012 20:47:04 -0000 1.1
+++ src/r128_exa_render.c 25 Mar 2021 21:03:14 -0000
@@ -34,14 +34,24 @@
 
 /* The following is based on the kdrive ATI driver. */
 
-#include <stdio.h>
-#include <string.h>
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if defined(R128DRI) && defined(RENDER)
+#include "xf86.h"
+#include "exa.h"
+
+#include "r128.h"
+#include "r128_reg.h"
+#include "r128_rop.h"
+
 
 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},
@@ -102,6 +112,17 @@ R128SolidPixmap(ScreenPtr pScreen, uint3
  return NULL;
     }
     info->ExaDriver->WaitMarker(pScreen, 0);
+
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    if (pScrn->bitsPerPixel == 32)
+ R128CopySwap(info->ExaDriver->memoryBase + exaGetPixmapOffset(pPix), (uint8_t*)&solid, 4,
+     APER_0_BIG_ENDIAN_32BPP_SWAP);
+    else if (pScrn->bitsPerPixel == 16)
+ R128CopySwap(info->ExaDriver->memoryBase + exaGetPixmapOffset(pPix), (uint8_t*)&solid, 4,
+     APER_0_BIG_ENDIAN_16BPP_SWAP);
+    else
+ /* Fall through for 8 bpp */
+#endif
     memcpy(info->ExaDriver->memoryBase + exaGetPixmapOffset(pPix), &solid, 4);
 
     return pPix;
@@ -146,8 +167,10 @@ R128GetDatatypePict2(uint32_t format, ui
 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;
@@ -159,66 +182,84 @@ R128CheckCompositeTexture(PicturePtr pPi
         int h = pPict->pDrawable->height;
 
         if (pPict->repeat && ((w & (w - 1)) != 0 || (h & (h - 1)) != 0)) {
-            R128TRACE(("NPOT repeat unsupported (%dx%d)\n", w, h));
+            DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "NPOT repeat unsupported (%dx%d)\n", w, h));
     return FALSE;
         }
     }
 
     if (pPict->filter != PictFilterNearest && pPict->filter != PictFilterBilinear) {
- R128TRACE(("Unsupported filter 0x%x\n", pPict->filter));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Unsupported filter 0x%x\n",
+                            pPict->filter));
  return FALSE;
     }
 
     /* The radeon driver has a long explanation about this part that I don't really understand */
     if (pPict->transform != 0 && repeatType == RepeatNone && PICT_FORMAT_A(pPict->format) == 0) {
  if (!(((op == PictOpSrc) || (op == PictOpClear)) && (PICT_FORMAT_A(pDstPict->format) == 0))) {
-    R128TRACE(("REPEAT_NONE unsupported for transformed xRGB source\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "REPEAT_NONE unsupported for "
+                            "transformed xRGB source\n"));
     return FALSE;
  }
     }
     if (!R128TransformAffineOrScaled(pPict->transform)) {
- R128TRACE(("Non-affine transforms not supported\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Non-affine transforms not supported\n"));
  return FALSE;
     }
 
     return TRUE;
 }
 
-static Bool
+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;
 
     /* Check for unsupported compositing operations. */
     if (op >= sizeof(R128BlendOp) / sizeof(R128BlendOp[0])) {
- R128TRACE(("Unsupported Composite op 0x%x\n", op));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Unsupported Composite op 0x%x\n", op));
  return FALSE;
     }
 
     pDstPixmap = R128GetDrawablePixmap(pDstPicture->pDrawable);
     if (pDstPixmap->drawable.width > 1024 || pDstPixmap->drawable.height > 1024) {
- R128TRACE(("Dest w/h too large (%d,%d).\n", pDstPixmap->drawable.width, pDstPixmap->drawable.height));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Dest w/h too large (%d,%d).\n",
+                            pDstPixmap->drawable.width,
+                            pDstPixmap->drawable.height));
  return FALSE;
     }
 
     if (pSrcPicture->pDrawable) {
         pSrcPixmap = R128GetDrawablePixmap(pSrcPicture->pDrawable);
         if (pSrcPixmap->drawable.width > 1024 || pSrcPixmap->drawable.height > 1024) {
-    R128TRACE(("Source w/h too large (%d,%d).\n", pSrcPixmap->drawable.width, pSrcPixmap->drawable.height));
+            DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "Source w/h too large (%d,%d).\n",
+                                pSrcPixmap->drawable.width,
+                                pSrcPixmap->drawable.height));
     return FALSE;
         }
     } else if (pSrcPicture->pSourcePict->type != SourcePictTypeSolidFill) {
-        R128TRACE(("Gradient pictures not supported yet\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Gradient pictures not supported yet\n"));
  return FALSE;
     }
 
     if (pDstPicture->format == PICT_a8) {
         if (R128BlendOp[op].src_alpha || R128BlendOp[op].dst_alpha || pMaskPicture != NULL) {
-    R128TRACE(("Alpha blending unsupported with A8 dst?\n"));
+            DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "Alpha blending unsupported with "
+                                "A8 dst?\n"));
     return FALSE;
  }
     } else {
@@ -231,16 +272,22 @@ R128CCECheckComposite(int op, PicturePtr
         if (pMaskPicture->pDrawable) {
     pMaskPixmap = R128GetDrawablePixmap(pMaskPicture->pDrawable);
             if (pMaskPixmap->drawable.width > 1024 || pMaskPixmap->drawable.height > 1024) {
-        R128TRACE(("Mask w/h too large (%d,%d).\n", pMaskPixmap->drawable.width, pMaskPixmap->drawable.height));
+                DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                    "Mask w/h too large (%d,%d).\n",
+                                    pMaskPixmap->drawable.width,
+                                    pMaskPixmap->drawable.height));
         return FALSE;
             }
  } else if (pMaskPicture->pSourcePict->type != SourcePictTypeSolidFill) {
-    R128TRACE(("Gradient pictures not supported yet\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Gradient pictures not supported yet\n"));
     return FALSE;
  }
 
  if (pMaskPicture->componentAlpha && R128BlendOp[op].src_alpha) {
-    R128TRACE(("Component alpha not supported with source alpha blending\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Component alpha not supported with "
+                            "source alpha blending\n"));
     return FALSE;
  }
 
@@ -269,7 +316,8 @@ R128TextureSetup(PicturePtr pPict, Pixma
 
     pitch = exaGetPixmapPitch(pPix);
     if ((pitch & (pitch - 1)) != 0) {
-        R128TRACE(("NPOT pitch 0x%x unsupported\n", pitch));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "NPOT pitch 0x%x unsupported\n", pitch));
  return FALSE;
     }
 
@@ -283,7 +331,8 @@ R128TextureSetup(PicturePtr pPict, Pixma
     } else if (pPict->filter == PictFilterNearest) {
  *tex_cntl_c |= R128_MIN_BLEND_NEAREST | R128_MAG_BLEND_NEAREST;
     } else {
- R128TRACE(("Bad filter 0x%x\n", pPict->filter));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Bad filter 0x%x\n", pPict->filter));
  return FALSE;
     }
 
@@ -301,7 +350,9 @@ R128TextureSetup(PicturePtr pPict, Pixma
     if (pPict->repeat && w == 1 && h == 1) {
         l2p = 0;
     } else if (pPict->repeat && l2p != l2w) {
-        R128TRACE(("Repeat not supported for pitch != width\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Repeat not supported for pitch != "
+                            "width\n"));
  return FALSE;
     }
 
@@ -339,7 +390,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 | \
@@ -347,9 +398,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 | \
@@ -364,7 +415,7 @@ do { \
     ADVANCE_RING(); \
 } while(0)
 
-static Bool
+Bool
 R128CCEPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
     PicturePtr pDstPicture, PixmapPtr pSrc, PixmapPtr pMask, PixmapPtr pDst)
 {
@@ -383,7 +434,8 @@ R128CCEPrepareComposite(int op, PictureP
 
     if (pDstPicture->format == PICT_a8) {
         if (R128BlendOp[op].dst_alpha) {
-    R128TRACE(("Can't dst alpha blend A8\n"));
+            DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "Can't dst alpha blend A8\n"));
     return FALSE;
         }
         dstDatatype = R128_DATATYPE_Y8;
@@ -394,7 +446,9 @@ R128CCEPrepareComposite(int op, PictureP
     if (!pSrc) {
  pSrc = R128SolidPixmap(pScreen, cpu_to_le32(pSrcPicture->pSourcePict->solidFill.color));
  if (!pSrc) {
-    R128TRACE(("Failed to create solid scratch pixmap\n"));
+        DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                            "Failed to create solid scratch "
+                            "pixmap\n"));
     return FALSE;
  }
  add_src = TRUE;
@@ -407,7 +461,9 @@ R128CCEPrepareComposite(int op, PictureP
         if (!pSrcPicture->pDrawable)
     pScreen->DestroyPixmap(pSrc);
  info->state_2d.has_mask = FALSE;
-        R128TRACE(("Failed to create solid scratch pixmap\n"));
+            DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                                "Failed to create "
+                                "solid scratch pixmap\n"));
         return FALSE;
     }
     add_msk = TRUE;
@@ -447,12 +503,7 @@ R128CCEPrepareComposite(int op, PictureP
 
     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. */
@@ -576,9 +627,9 @@ R128CCEPrepareComposite(int op, PictureP
     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;
@@ -609,7 +660,7 @@ do {       \
     OUT_RING(R128FloatAsInt((((float)(_srcY)) + 0.5) / (info->state_2d.heights[0]))); \
 } while (0)
 
-static void
+void
 R128CCEComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY, int dstX, int dstY, int w, int h)
 {
     ScreenPtr     pScreen   = pDst->drawable.pScreen;
@@ -692,4 +743,4 @@ R128CCEComposite(PixmapPtr pDst, int src
     ADVANCE_RING();
 }
 
-#define R128CCEDoneComposite R128Done
+#endif
Index: src/r128_output.c
===================================================================
RCS file: src/r128_output.c
diff -N src/r128_output.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/r128_output.c 25 Mar 2021 21:03:14 -0000
@@ -0,0 +1,537 @@
+/*
+ * 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"
+
+#ifdef HAVE_XEXTPROTO_71
+#include "X11/extensions/dpmsconst.h"
+#else
+#define DPMS_SERVER
+#include "X11/extensions/dpms.h"
+#endif
+
+#include "r128.h"
+#include "r128_probe.h"
+#include "r128_reg.h"
+
+static void R128ConnectorFindMonitor(ScrnInfoPtr pScrn, xf86OutputPtr output);
+
+/* 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));
+}
+
+/* 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);
+}
+
+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)
+{
+    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 && !info->isPro2)
+        R128InitRMXRegisters(&info->SavedReg, &info->ModeReg, output, adjusted_mode);
+
+    if (r128_output->MonType == MT_DFP)
+        R128InitFPRegisters(&info->SavedReg, &info->ModeReg, output);
+    else if (r128_output->MonType == MT_LCD)
+        R128InitLVDSRegisters(&info->SavedReg, &info->ModeReg, output);
+    else if (r128_output->MonType == MT_CRT)
+        R128InitDACRegisters(&info->SavedReg, &info->ModeReg, output);
+
+    if (r128_crtc->crtc_id == 0 && !info->isPro2)
+        R128RestoreRMXRegisters(pScrn, &info->ModeReg);
+
+    if (r128_output->MonType == MT_DFP)
+        R128RestoreFPRegisters(pScrn, &info->ModeReg);
+    else if (r128_output->MonType == MT_LCD)
+        R128RestoreLVDSRegisters(pScrn, &info->ModeReg);
+    else if (r128_output->MonType == MT_CRT)
+        R128RestoreDACRegisters(pScrn, &info->ModeReg);
+}
+
+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;
+    R128SavePtr save = &info->ModeReg;
+
+    switch(MonType) {
+    case MT_LCD:
+        OUTREGP(R128_LVDS_GEN_CNTL, R128_LVDS_BLON, ~R128_LVDS_BLON);
+        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;
+    case MT_DFP:
+        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);
+        save->crtc_ext_cntl |=      R128_CRTC_CRT_ON;
+        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;
+    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_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));
+        save->crtc_ext_cntl &=         ~(R128_CRTC_CRT_ON);
+        break;
+    default:
+        break;
+    }
+}
+
+static R128MonitorType R128DisplayDDCConnected(xf86OutputPtr output)
+{
+    ScrnInfoPtr pScrn = output->scrn;
+    R128InfoPtr info = R128PTR(pScrn);
+    R128EntPtr pR128Ent = R128EntPriv(pScrn);
+    unsigned char *R128MMIO = info->MMIO;
+    R128OutputPrivatePtr r128_output = output->driver_private;
+
+    R128MonitorType MonType = MT_CRT;
+    xf86MonPtr *MonInfo = &output->MonInfo;
+    uint32_t mask1, mask2;
+
+    if (r128_output->type == OUTPUT_LVDS) {
+        return MT_LCD;
+    } else if (r128_output->type == OUTPUT_VGA) {
+        mask1 = R128_GPIO_MONID_MASK_1 | (pR128Ent->HasCRTC2 ? R128_GPIO_MONID_MASK_3 : R128_GPIO_MONID_MASK_2);
+        mask2 = R128_GPIO_MONID_A_1    | (pR128Ent->HasCRTC2 ? R128_GPIO_MONID_A_3    : R128_GPIO_MONID_A_2);
+    } 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) {
+        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);
+    }
+
+    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)
+              & ~(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);
+}
+
+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 R128GetConnectorInfoFromBIOS(ScrnInfoPtr pScrn, R128OutputType *otypes)
+{
+    R128InfoPtr info = R128PTR(pScrn);
+    uint16_t bios_header, offset;
+    uint32_t i;
+
+    for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
+        otypes[i] = OUTPUT_NONE;
+    }
+
+    /* non-x86 platform */
+    if (!info->VBIOS) {
+        otypes[0] = OUTPUT_VGA;
+ return;
+    }
+
+    bios_header = R128_BIOS16(0x48);
+    offset = R128_BIOS16(bios_header + 0x40);
+    if (offset) {
+        otypes[0] = OUTPUT_LVDS;
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                    "Found FP table, assuming FP connector.\n");
+    } else {
+        bios_header = R128_BIOS16(0x48);
+        offset = R128_BIOS16(bios_header + 0x34);
+        if (offset) {
+            otypes[0] = OUTPUT_DVI;
+            xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                        "Found DVI table, assuming DVI connector.\n");
+        }
+    }
+
+    offset = R128_BIOS16(bios_header + 0x2e);
+    if (offset) {
+        if (otypes[0] == OUTPUT_NONE) {
+            otypes[0] = OUTPUT_VGA;
+        } else {
+            otypes[1] = OUTPUT_VGA;
+        }
+
+        xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+                    "Found CRT table, assuming VGA connector.\n");
+    }
+}
+
+Bool R128SetupConnectors(ScrnInfoPtr pScrn)
+{
+    R128InfoPtr info    = R128PTR(pScrn);
+    R128EntPtr pR128Ent = R128EntPriv(pScrn);
+
+    R128OutputType otypes[R128_MAX_BIOS_CONNECTOR];
+    xf86OutputPtr  output;
+    int num_vga = 0;
+    int num_dvi = 0;
+    int i;
+
+    R128GetConnectorInfoFromBIOS(pScrn, otypes);
+
+    for (i = 0; i < R128_MAX_BIOS_CONNECTOR; i++) {
+        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 (otypes[i] == OUTPUT_NONE) continue;
+
+        R128I2CBusRec i2c;
+        R128OutputPrivatePtr r128_output;
+
+        r128_output = xnfcalloc(sizeof(R128OutputPrivateRec), 1);
+        if (!r128_output) return FALSE;
+
+        r128_output->MonType = MT_UNKNOWN;
+        r128_output->type = otypes[i];
+        r128_output->num = i;
+
+        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 (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;
+            if (otypes[i] == OUTPUT_VGA && !pR128Ent->HasCRTC2) {
+                i2c.put_clk_mask = R128_GPIO_MONID_EN_2;
+                i2c.get_clk_mask = R128_GPIO_MONID_Y_2;
+            } else {
+                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;
+            }
+            r128_output->ddc_i2c = i2c;
+            R128I2CInit(output, &r128_output->pI2CBus, output->name);
+        }
+
+        if (otypes[i] == OUTPUT_LVDS)
+            R128GetPanelInfoFromBIOS(output);
+    }
+
+    return TRUE;
+}
Index: src/r128_probe.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_probe.c,v
retrieving revision 1.4
diff -u -p -u -r1.4 r128_probe.c
--- src/r128_probe.c 8 Sep 2012 20:47:49 -0000 1.4
+++ src/r128_probe.c 25 Mar 2021 21:03:14 -0000
@@ -43,14 +43,11 @@
 #include "atipcirename.h"
 
 #include "xf86.h"
-#include "xf86PciInfo.h"
-
 
 #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
 #include "xf86Resources.h"
 #endif
 
-#include "compat-api.h"
 #include "r128_probe.h"
 
 #ifndef XSERVER_LIBPCIACCESS
@@ -237,6 +234,7 @@ r128_get_scrninfo(int entity_num)
 {
     ScrnInfoPtr   pScrn = NULL;
     EntityInfoPtr pEnt;
+    DevUnion*     pPriv;
 
     pScrn = xf86ConfigPciEntity(pScrn, 0, entity_num, R128PciChipsets,
                                 NULL,
@@ -264,6 +262,20 @@ r128_get_scrninfo(int entity_num)
 
     pEnt = xf86GetEntityInfo(entity_num);
 
+    /* Allocate private entity used for convenience with one or two heads. */
+    if (gR128EntityIndex < 0) {
+        gR128EntityIndex = xf86AllocateEntityPrivateIndex();
+        pPriv = xf86GetEntityPrivate(pScrn->entityList[0], gR128EntityIndex);
+
+        if (!pPriv->ptr) {
+            R128EntPtr pR128Ent;
+            pPriv->ptr = xnfcalloc(sizeof(R128EntRec), 1);
+            pR128Ent = pPriv->ptr;
+            pR128Ent->HasSecondary = FALSE;
+            pR128Ent->IsSecondaryRestored = FALSE;
+        }
+    }
+
     /* mobility cards support Dual-Head, mark the entity as sharable*/
     if (pEnt->chipset == PCI_CHIP_RAGE128LE ||
         pEnt->chipset == PCI_CHIP_RAGE128LF ||
@@ -271,7 +283,6 @@ r128_get_scrninfo(int entity_num)
         pEnt->chipset == PCI_CHIP_RAGE128ML)
     {
         static int instance = 0;
-        DevUnion* pPriv;
 
         xf86SetEntitySharable(entity_num);
 
@@ -279,24 +290,6 @@ r128_get_scrninfo(int entity_num)
                                        pScrn->entityList[0],
                                        instance);
 
-        if (gR128EntityIndex < 0)
-        {
-            gR128EntityIndex = xf86AllocateEntityPrivateIndex();
-
-            pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
-                                         gR128EntityIndex);
-
-            if (!pPriv->ptr)
-            {
-                R128EntPtr pR128Ent;
-                pPriv->ptr = xnfcalloc(sizeof(R128EntRec), 1);
-                pR128Ent = pPriv->ptr;
-                pR128Ent->IsDRIEnabled = FALSE;
-                pR128Ent->BypassSecondary = FALSE;
-                pR128Ent->HasSecondary = FALSE;
-                pR128Ent->IsSecondaryRestored = FALSE;
-            }
-        }
         instance++;
     }
 
@@ -379,6 +372,9 @@ _X_EXPORT DriverRec R128 =
     NULL,
 #ifdef XSERVER_LIBPCIACCESS
     r128_device_match,
-    r128_pci_probe
+    r128_pci_probe,
+#endif
+#ifdef XSERVER_PLATFORM_BUS
+    NULL
 #endif
 };
Index: src/r128_probe.h
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_probe.h,v
retrieving revision 1.2
diff -u -p -u -r1.2 r128_probe.h
--- src/r128_probe.h 8 Sep 2012 20:47:49 -0000 1.2
+++ src/r128_probe.h 25 Mar 2021 21:03:14 -0000
@@ -37,21 +37,130 @@
 #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
+#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
+typedef enum
 {
-    Bool IsDRIEnabled;
+    MT_UNKNOWN = -1,
+    MT_NONE    = 0,
+    MT_CRT     = 1,
+    MT_LCD     = 2,
+    MT_DFP     = 3,
+    MT_CTV     = 4,
+    MT_STV     = 5
+} R128MonitorType;
+
+typedef enum
+{
+    OUTPUT_NONE,
+    OUTPUT_VGA,
+    OUTPUT_DVI,
+    OUTPUT_LVDS
+} R128OutputType;
+
+typedef struct {
+    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 {
+    void *rotate_mem;
+    int crtc_id;
+    uint32_t cursor_offset;
+    /* Lookup table values to be set when the CRTC is enabled */
+    uint8_t lut_r[256], lut_g[256], lut_b[256];
+} R128CrtcPrivateRec, *R128CrtcPrivatePtr;
+
+typedef struct _R128OutputPrivateRec {
+    int num;
+    R128OutputType type;
+    R128MonitorType MonType;
+    I2CBusPtr pI2CBus;
+    R128I2CBusRec ddc_i2c;
+    int PanelXRes;
+    int PanelYRes;
+    int PanelPwrDly;
+} R128OutputPrivateRec, *R128OutputPrivatePtr;
+
+#define R128_MAX_CRTC 2
+#define R128_MAX_BIOS_CONNECTOR 2
+
+typedef struct
+{
     Bool HasSecondary;
-    Bool BypassSecondary;
+    Bool HasCRTC2;
     /*These two registers are used to make sure the CRTC2 is
       retored before CRTC_EXT, otherwise it could lead to blank screen.*/
     Bool IsSecondaryRestored;
     Bool RestorePrimary;
 
-    ScrnInfoPtr pSecondaryScrn;    
+    xf86CrtcPtr pCrtc[R128_MAX_CRTC];
+    R128CrtcPrivatePtr Controller[R128_MAX_CRTC];
+
+    ScrnInfoPtr pSecondaryScrn;
     ScrnInfoPtr pPrimaryScrn;
 } R128EntRec, *R128EntPtr;
 
Index: src/r128_reg.h
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_reg.h,v
retrieving revision 1.1.1.1
diff -u -p -u -r1.1.1.1 r128_reg.h
--- src/r128_reg.h 12 Jul 2008 15:35:54 -0000 1.1.1.1
+++ src/r128_reg.h 25 Mar 2021 21:03:14 -0000
@@ -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)
 
@@ -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)
@@ -905,6 +905,8 @@
 #       define R128_PPLL_ATOMIC_UPDATE_EN     (1 << 16)
 #       define R128_PPLL_VGA_ATOMIC_UPDATE_EN (1 << 17)
 #define R128_PPLL_DIV_0                   0x0004 /* PLL */
+#       define R128_PPLL_FB0_DIV_MASK     0x07ff
+#       define R128_PPLL_POST0_DIV_MASK   0x00070000
 #define R128_PPLL_DIV_1                   0x0005 /* PLL */
 #define R128_PPLL_DIV_2                   0x0006 /* PLL */
 #define R128_PPLL_DIV_3                   0x0007 /* PLL */
Index: src/r128_rop.h
===================================================================
RCS file: src/r128_rop.h
diff -N src/r128_rop.h
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/r128_rop.h 25 Mar 2021 21:03:14 -0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright 1999, 2000 ATI Technologies Inc., Markham, Ontario,
+ *                      Precision Insight, Inc., Cedar Park, Texas, 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, PRECISION INSIGHT, 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.
+ */
+
+/*
+ * Authors:
+ *   Rickard E. Faith <[hidden email]>
+ *   Kevin E. Martin <[hidden email]>
+ *
+ */
+
+#ifndef _R128_ROP_H_
+#define _R128_ROP_H_
+
+#include "r128_reg.h"
+
+static struct {
+    int rop;
+    int pattern;
+} R128_ROP[] = {
+    { R128_ROP3_ZERO, R128_ROP3_ZERO }, /* GXclear        */
+    { R128_ROP3_DSa,  R128_ROP3_DPa  }, /* Gxand          */
+    { R128_ROP3_SDna, R128_ROP3_PDna }, /* GXandReverse   */
+    { R128_ROP3_S,    R128_ROP3_P    }, /* GXcopy         */
+    { R128_ROP3_DSna, R128_ROP3_DPna }, /* GXandInverted  */
+    { R128_ROP3_D,    R128_ROP3_D    }, /* GXnoop         */
+    { R128_ROP3_DSx,  R128_ROP3_DPx  }, /* GXxor          */
+    { R128_ROP3_DSo,  R128_ROP3_DPo  }, /* GXor           */
+    { R128_ROP3_DSon, R128_ROP3_DPon }, /* GXnor          */
+    { R128_ROP3_DSxn, R128_ROP3_PDxn }, /* GXequiv        */
+    { R128_ROP3_Dn,   R128_ROP3_Dn   }, /* GXinvert       */
+    { R128_ROP3_SDno, R128_ROP3_PDno }, /* GXorReverse    */
+    { R128_ROP3_Sn,   R128_ROP3_Pn   }, /* GXcopyInverted */
+    { R128_ROP3_DSno, R128_ROP3_DPno }, /* GXorInverted   */
+    { R128_ROP3_DSan, R128_ROP3_DPan }, /* GXnand         */
+    { R128_ROP3_ONE,  R128_ROP3_ONE  }  /* GXset          */
+};
+#endif
+
Index: src/r128_video.c
===================================================================
RCS file: /cvs/OpenBSD/xenocara/driver/xf86-video-r128/src/r128_video.c,v
retrieving revision 1.4
diff -u -p -u -r1.4 r128_video.c
--- src/r128_video.c 23 Nov 2012 20:47:04 -0000 1.4
+++ src/r128_video.c 25 Mar 2021 21:03:14 -0000
@@ -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;
@@ -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;
@@ -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,78 +572,80 @@ R128CopyData420(
 }
 
 
-static CARD32
+uint32_t
 R128AllocateMemory(
-   ScrnInfoPtr pScrn,
-   void **mem_struct,
-   int size
+    ScrnInfoPtr pScrn,
+    void **mem_struct,
+    int size,
+    int align,
+    Bool need_accel
 ){
-   R128InfoPtr info = R128PTR(pScrn);
-   ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-   int 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)
+        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(!info->useEXA) {
+        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;
-   }
-#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
+        offset = linear->offset * cpp;
+    }
 
-   return offset;
+    return offset;
 }
 
 static void
@@ -659,12 +661,16 @@ 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;
-    Bool rmx_active;
+    Bool rmx_active = FALSE;
 
     R128ECP(pScrn, pPriv);
 
@@ -673,10 +679,11 @@ R128DisplayVideo422(
         v_inc_shift++;
     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 / 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;
     }
@@ -745,22 +752,26 @@ 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;
     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)
         v_inc_shift++;
     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 / 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;
     }
@@ -841,17 +852,24 @@ 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
+    * 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);
+   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 &
@@ -893,10 +911,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:
@@ -922,11 +940,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;
 

--
Matthieu Herrb

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

Matthieu Herrb-3
On Thu, Mar 25, 2021 at 10:09:48PM +0100, Matthieu Herrb wrote:
>
> Here's a patch to update x86-video-r128 to 6.12.0. It add xrandr
> support, but on my G4, lacking BIOS support only the output active
> while booting is detected.

I've now committed this, so it will be in the next snapshots for wider
testing.

--
Matthieu Herrb

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

Giles Atkinson-2
In reply to this post by Claudiu Tănăselia
My experience (years old now) with a similar model was that the monitor mode must be set explicitely,
perhaps to 1024x768/60Hz.  The scan is fixed rate and if not in sync the screen stays dark.
If it will help I could turn it on and see what is there.

On 25 Mar 2021, at 15:24, Claudiu Tănăselia wrote:

> Hi,
>
> Thank you for your replies! Here's my /var/log/Xorg.0.log: https://pastebin.com/6RWberfW
> Let me know if I can offer you any more clues about this situation.
>
> Kind regards,
> Claudiu.
>
> On Thu, Mar 25, 2021, at 08:57, Matthieu Herrb wrote:
>> On Wed, Mar 24, 2021 at 11:03:14PM +0200, Claudiu Tănăselia wrote:
>>> Hello,
>>>
>>> I've installed OpenBSD 6.8 on an iMac G3 (Summer 2000 edition) and there was nothing unusual during install or post-install stage, I was able to install and boot OpenBSD without an issue.
>>>
>>> However, when X (xenodm) starts, it ignores the built-in display. The built-in display goes dark and if a second display is plugged-in via VGA port, then that display is usable, however not the built-in display. Is this a bug or a feature? xrandr only shows 1 monitor, even when the second VGA monitor is plugged it.
>>>
>>> dmesg is available here: https://pastebin.com/TsEBjZNi
>>>
>>
>> Hi,
>>
>> This is probably a bug, but I don't know what is causing it. We would
>> need to see the contents of /var/log/Xorg.0.log to --maybe-- get some
>> clues on what is happening.
>>
>> Also the xf86-video-r128 driver is lagging behind upstream versions
>> for a mumber of years now. Initially I didn't upgrade it because
>> upstream version where breaking on my macppc G4. I don't think I'v
>> tried more "recent" ones like 6.11 or 6.12 though. If I find time for
>> this, I may be able to send an update patch during the week end.
>>
>> --
>> Matthieu Herrb
>>
>

Reply | Threaded
Open this post in threaded view
|

Re: xenodm starts on VGA display only

George Koehler-2
In reply to this post by Matthieu Herrb-3
On Fri, 26 Mar 2021 19:26:02 +0100
Matthieu Herrb <[hidden email]> wrote:

> On Thu, Mar 25, 2021 at 10:09:48PM +0100, Matthieu Herrb wrote:
> >
> > Here's a patch to update x86-video-r128 to 6.12.0. It add xrandr
> > support, but on my G4, lacking BIOS support only the output active
> > while booting is detected.
>
> I've now committed this, so it will be in the next snapshots for wider
> testing.

I built xenocara myself and tried the new x86-video-r128 on a G4 Cube.
I got a good surprise: the resolution in X went up from 1024x768 (the
previous maximum in xrandr) to 1920x1080 (the true size of my display
on the VGA port).  In Xorg.0.log, the driver began to use EDID to
detect the modes of my display.

The Cube has 2 outputs: VGA port, and Apple Display Connector (ADC,
which looks like DVI, but is too big to fit a DVI plug).  I have no
ADC display, so I only tried VGA.  xrandr detected only VGA.

I don't know whether the driver works with iMac's internal display.

--George