Import version 0.60.6

author: Otavio Salvador <otavio@ossystems.com.br> 2010-06-01 19:45:54 -0300
committer: Otavio Salvador <otavio@ossystems.com.br> 2010-06-01 19:45:54 -0300
commit: c9ebd877197924bb97412019db498712f3b14d22 (patch)
tree: 4d3a09af0fb56ed88f4cf6f6064020efe28488e3
28 files changed, 14619 insertions, 0 deletions
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..ab0c7fd
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,19 @@
+Copyright (c) 2009 RDC Semiconductor Co.,Ltd
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation, and that the name of the authors not be used in
+advertising or publicity pertaining to distribution of the software without
+specific, written prior permission.  The authors makes no representations
+about the suitability of this software for any purpose.  It is provided
+"as is" without express or implied warranty.
+
+THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..5dc01a5
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,22 @@
+#  Copyright 2005 Adam Jackson.
+#
+#  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, sub
+#  license, and/or sell copies of the Software, and to permit persons to whom
+#  the Software is furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice (including the next
+#  paragraph) shall be included in all copies or substantial portions of the
+#  Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+#  ADAM JACKSON 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.
+
+AUTOMAKE_OPTIONS = foreign
+SUBDIRS = src
+\ No newline at end of file
diff --git a/autogen.sh b/autogen.sh
new file mode 100644
index 0000000..904cd67
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,12 @@
+#! /bin/sh
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd $srcdir
+
+autoreconf -v --install || exit 1
+cd $ORIGDIR || exit $?
+
+$srcdir/configure --enable-maintainer-mode "$@"
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..d61b761
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,77 @@
+#  Copyright 2005 Adam Jackson.
+#
+#  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, sub
+#  license, and/or sell copies of the Software, and to permit persons to whom
+#  the Software is furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice (including the next
+#  paragraph) shall be included in all copies or substantial portions of the
+#  Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+#  ADAM JACKSON 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.
+#
+# Process this file with autoconf to produce a configure script
+
+AC_PREREQ(2.57)
+AC_INIT([xf86-video-aip],
+        0.80,
+        [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
+        xf86-video-aip)
+
+AC_CONFIG_SRCDIR([Makefile.am])
+AM_CONFIG_HEADER([config.h])
+AC_CONFIG_AUX_DIR(.)
+
+AM_INIT_AUTOMAKE([dist-bzip2])
+
+AM_MAINTAINER_MODE
+
+# Checks for programs.
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+AC_PROG_CC
+
+AH_TOP([#include "xorg-server.h"])
+
+AC_ARG_WITH(xorg-module-dir,
+            AC_HELP_STRING([--with-xorg-module-dir=DIR],
+                           [Default xorg module directory [[default=$libdir/xorg/modules]]]),
+            [moduledir="$withval"],
+            [moduledir="$libdir/xorg/modules"])
+
+# Checks for extensions
+XORG_DRIVER_CHECK_EXT(RANDR, randrproto)
+XORG_DRIVER_CHECK_EXT(RENDER, renderproto)
+XORG_DRIVER_CHECK_EXT(XV, videoproto)
+XORG_DRIVER_CHECK_EXT(DPMSExtension, xextproto)
+
+# Checks for pkg-config packages
+PKG_CHECK_MODULES(XORG, [xorg-server xproto fontsproto $REQUIRED_MODULES])
+sdkdir=$(pkg-config --variable=sdkdir xorg-server)
+
+# Checks for libraries.
+
+# Checks for header files.
+AC_HEADER_STDC
+
+AC_SUBST([XORG_CFLAGS])
+AC_SUBST([moduledir])
+
+DRIVER_NAME=nv
+AC_SUBST([DRIVER_NAME])
+
+XORG_MANPAGE_SECTIONS
+XORG_RELEASE_VERSION
+
+AC_OUTPUT([
+	Makefile
+	src/Makefile
+])
diff --git a/src/CInt10.c b/src/CInt10.c
new file mode 100644
index 0000000..1510ce8
--- /dev/null
+++ b/src/CInt10.c
@@ -0,0 +1,4021 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#include <string.h>
+
+#ifndef XFree86Module
+#include "compiler.h"
+#else
+#include "xf86_ansic.h"
+#endif
+
+#include "typedef.h"
+#include "CInt10.h"
+#include "CInt10FunProto.h"
+#include "CInt10Tbl.h"
+
+
+/* Global for related IO address */
+USHORT Relocate_IOAddress;
+
+/*--------------------------------------------------------------------------
+;
+;       IO port function replace
+;
+;---------------------------------------------------------------------------*/
+__inline void OutPort(UCHAR Index,UCHAR Value)     
+{              
+
+    outb(Relocate_IOAddress+Index, Value);
+
+    return;                          
+}                                                                       
+
+__inline UCHAR InPort(UCHAR Index)                        
+{                                                                      
+    UCHAR bInVal = 0x0;    
+
+    bInVal = inb(Relocate_IOAddress+Index);
+    
+    return bInVal;                                                 
+}
+
+/*----------------------------------------------------------------------------
+;
+;       SetVBERerurnStatus
+;
+;       in:
+;           VBEReturnStatus = 
+;               VBEFunctionCallSuccessful   0x004F
+;               VBEFunctionCallFail         0x014F
+;               VBEFunctionCallNotSupported 0x024F
+;               VBEFunctionCallInvalid      0x034F
+;       out:
+;           pCBiosArguments->Eax
+;---------------------------------------------------------------------------*/
+void SetVBERerurnStatus(USHORT VBEReturnStatus, CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    pCBiosArguments->reg.x.AX = VBEReturnStatus;
+}
+
+/*----------------------------------------------------------------------------
+;
+;       SetTimingRegs
+;
+;       in: 
+;           bDisplayPath = display path
+;           pMODE_INFO = pointer to MODE_INFO
+;           pRRATE_TABLE = pointer to RRATE_TABLE
+;
+;---------------------------------------------------------------------------*/
+void SetTimingRegs(UCHAR ucDisplayPath, MODE_INFO *pModeInfo, RRATE_TABLE *pRRateTable)
+{
+    USHORT usHBorder = 0, usVBorder = 0;
+    USHORT usHtotal, usHDispEnd, usHBlankStart, usHBlankEnd, usHSyncStart, usHSyncEnd;
+    USHORT usVtotal, usVDispEnd, usVBlankStart, usVBlankEnd, usVSyncStart, usVSyncEnd;
+    ULONG  ulPixelClock;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter SetTimingRegs()==\n");
+
+    if (pRRateTable->Attribute & HB)
+    {
+        usHBorder = 8;
+    }
+
+    if (pRRateTable->Attribute & VB)
+    {
+        usVBorder = 8;
+    }
+
+    usHtotal =      pModeInfo->H_Size + usHBorder*2 + pRRateTable->H_Blank_Time;
+    usHDispEnd =    pModeInfo->H_Size;
+    usHBlankStart = pModeInfo->H_Size + usHBorder;
+    usHBlankEnd =   pModeInfo->H_Size + usHBorder + pRRateTable->H_Blank_Time;
+    usHSyncStart =  pRRateTable->H_Sync_Start;
+    usHSyncEnd =    pRRateTable->H_Sync_Start + pRRateTable->H_Sync_Time;
+
+    usVtotal =      pModeInfo->V_Size + usVBorder*2 + pRRateTable->V_Blank_Time;
+    usVDispEnd =    pModeInfo->V_Size;
+    usVBlankStart = pModeInfo->V_Size + usVBorder;
+    usVBlankEnd =   pModeInfo->V_Size + usVBorder + pRRateTable->V_Blank_Time;
+    usVSyncStart =  pRRateTable->V_Sync_Start;
+    usVSyncEnd =    pRRateTable->V_Sync_Start + pRRateTable->V_Sync_Time;
+
+    ulPixelClock =  pRRateTable->Clock;
+    
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "H total = %d\n", usHtotal);
+    SetHTotal(ucDisplayPath, usHtotal);
+    
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "H disp end = %d\n", usHDispEnd);
+    SetHDisplayEnd(ucDisplayPath, usHDispEnd);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "H blank start = %d\n", usHBlankStart);
+    SetHBlankingStart(ucDisplayPath, usHBlankStart);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "H blank end = %d\n", usHBlankEnd);
+    SetHBlankingEnd(ucDisplayPath, usHBlankEnd);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "H sync start = %d\n", usHSyncStart);
+    SetHSyncStart(ucDisplayPath, usHSyncStart);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "H sync end = %d\n", usHSyncEnd);
+    SetHSyncEnd(ucDisplayPath, usHSyncEnd);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "V total = %d\n", usVtotal);
+    SetVTotal(ucDisplayPath, usVtotal);
+    
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "V disp end = %d\n", usVDispEnd);
+    SetVDisplayEnd(ucDisplayPath, usVDispEnd);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "V blank start = %d\n", usVBlankStart);
+    SetVBlankingStart(ucDisplayPath, usVBlankStart);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "V blank end = %d\n", usVBlankEnd);
+    SetVBlankingEnd(ucDisplayPath, usVBlankEnd);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "V sync start = %d\n", usVSyncStart);
+    SetVSyncStart(ucDisplayPath, usVSyncStart);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "V sync end = %d\n", usVSyncEnd);
+    SetVSyncEnd(ucDisplayPath, usVSyncEnd);
+    
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "Pixel clock = %d\n", ulPixelClock);
+    SetPixelClock(ucDisplayPath, ulPixelClock);
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit SetTimingRegs()==\n");
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetHTotal()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = H total in pixel
+;
+;------------------------------------------------------------------*/
+void SetHTotal(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 40 pixels for setting HW */
+    Value -= 40;
+    
+    /* low-3-bits of H total has bug, HW will remove it. So the value have to align to 8*/
+    Value += 7;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(HTotal1, Value);
+    }
+    else
+    {
+        WriteRegToHW(HTotal2, Value);
+    }
+
+    return;
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetHDisplayEnd()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = H display end in pixel
+;
+;------------------------------------------------------------------*/
+void SetHDisplayEnd(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 8 pixels for setting HW */
+    Value -= 8;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(HDispEnd1, Value);
+    }
+    else
+    {
+        WriteRegToHW(HDispEnd2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetHBlankingStart()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = H blanking start in pixel
+;
+;------------------------------------------------------------------*/
+void SetHBlankingStart(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 8 pixels for setting HW */
+    Value -= 8;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(HBnkSt1, Value);
+    }
+    else
+    {
+        WriteRegToHW(HBnkSt2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetHBlankingEnd()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = H blanking end in pixel
+;
+;------------------------------------------------------------------*/
+void SetHBlankingEnd(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 8 pixels for setting HW */
+    Value -= 8;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(HBnkEnd1, Value);
+    }
+    else
+    {
+        WriteRegToHW(HBnkEnd2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetHSyncStart()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = H Sync start in pixel
+;
+;------------------------------------------------------------------*/
+void SetHSyncStart(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 0 pixels for setting HW */
+    Value -= 0;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(HSyncSt1, Value);
+    }
+    else
+    {
+        WriteRegToHW(HSyncSt2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetHSyncEnd()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = H Sync end in pixel
+;
+;------------------------------------------------------------------*/
+void SetHSyncEnd(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 0 pixels for setting HW */
+    Value -= 0;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(HSyncEnd1, Value);
+    }
+    else
+    {
+        WriteRegToHW(HSyncEnd2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetVTotal()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = V total
+;
+;------------------------------------------------------------------*/
+void SetVTotal(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 2 line for setting HW */
+    Value -= 2;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(VTotal1, Value);
+    }
+    else
+    {
+        WriteRegToHW(VTotal2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetVDisplayEnd()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = V display end
+;
+;------------------------------------------------------------------*/
+void SetVDisplayEnd(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 1 line for setting HW */
+    Value -= 1;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(VDispEnd1, Value);
+    }
+    else
+    {
+        WriteRegToHW(VDispEnd2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetVBlankingStart()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = V blanking start
+;
+;------------------------------------------------------------------*/
+void SetVBlankingStart(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 1 line for setting HW */
+    Value -= 1;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(VBnkSt1, Value);
+    }
+    else
+    {
+        WriteRegToHW(VBnkSt2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetVBlankingEnd()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = V blanking end
+;
+;------------------------------------------------------------------*/
+void SetVBlankingEnd(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 1 line for setting HW */
+    Value -= 1;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(VBnkEnd1, Value);
+    }
+    else
+    {
+        WriteRegToHW(VBnkEnd2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetVSyncStart()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = V sync start
+;
+;------------------------------------------------------------------*/
+void SetVSyncStart(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 1 line for setting HW */
+    Value -= 1;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(VSyncSt1, Value);
+    }
+    else
+    {
+        WriteRegToHW(VSyncSt2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetVSyncEnd()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = V sync end
+;
+;------------------------------------------------------------------*/
+void SetVSyncEnd(UCHAR DisplayPath, USHORT Value)
+{
+    /* Subtract the 1 line for setting HW */
+    Value -= 1;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(VSyncEnd1, Value);
+    }
+    else
+    {
+        WriteRegToHW(VSyncEnd2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetPixelClock()
+;
+;       in:
+;           DisplayPath = display path
+;           Clock = pixel clock in khz
+;
+;------------------------------------------------------------------*/
+void SetPixelClock(UCHAR bDisplayPath, ULONG dwClock)
+{
+    PLL_Info PLLInfo;
+    
+    PLLInfo = ClockToPLLF9003A(dwClock);
+    SetDPLL(bDisplayPath, PLLInfo);
+}
+/*-------------------------------------------------------------------
+;
+;       SetHSource()
+;
+;       in:
+;           DisplayPath = display path
+;           wValue = number of pixels of source data
+;
+;------------------------------------------------------------------*/
+void SetHSource(UCHAR bDisplayPath, USHORT wValue)
+{
+    wValue -= 1;
+    
+    if(bDisplayPath == DISP1)
+    {
+        WriteRegToHW(HSource1, wValue);
+    }
+    else
+    {
+        WriteRegToHW(HSource2, wValue);
+    }
+}
+
+
+/*-------------------------------------------------------------------
+;
+;       ClockToPLLF9003A()
+;
+;       in:
+;           Clock = pixel clock in khz
+;       return:
+;           PLL_Info = PLL value
+;
+;------------------------------------------------------------------*/
+PLL_Info ClockToPLLF9003A(ULONG Clock)
+{
+    ULONG MSCount, NSCount, RSCount, FCKVCO, FCKOUT;    /*defined in PLL module */
+    ULONG NearestClock = 0xFFFFFFFF;
+    PLL_Info PLLInfo;
+    
+    for (MSCount = 3; MSCount < 6; MSCount++)
+    {
+        for (NSCount = 1; NSCount < 256; NSCount++)
+        {
+            FCKVCO = PLLReferenceClock * NSCount / MSCount;
+            
+            if ( (MaxFCKVCO9003A >= FCKVCO) && (FCKVCO >= MinFCKVCO9003A) )
+            {
+                for (RSCount = 1; RSCount < 6; RSCount++)
+                {
+                    FCKOUT = FCKVCO >> RSCount;
+                    if ( Difference(FCKOUT, Clock) < Difference(NearestClock, Clock) )
+                    {
+                        NearestClock = FCKOUT;
+                        if (MSCount == 3)
+                            PLLInfo.MS = 0x00;
+                        if (MSCount == 4)
+                            PLLInfo.MS = BIT3;
+                        if (MSCount == 5)
+                            PLLInfo.MS = BIT4+BIT3;
+                        PLLInfo.NS = (UCHAR)NSCount;
+                        PLLInfo.RS = (UCHAR)RSCount-1;
+                    }
+                }
+            }
+        }
+
+    }
+
+    return PLLInfo;
+
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetDPLL() - set display PLL
+;
+;       in:
+;           DisplayPath = display path
+;           PLLInfo: PLL value
+;
+;------------------------------------------------------------------*/
+void SetDPLL(UCHAR DisplayPath, PLL_Info PLLInfo)
+{
+    UCHAR RetValue; 
+
+    if (DisplayPath == DISP1)
+    {
+        SetCRReg(0xC1, PLLInfo.MS, BIT4+BIT3);
+        SetCRReg(0xC0, PLLInfo.NS, 0xFF);
+        SetCRReg(0xCF, PLLInfo.RS, BIT2+BIT1+BIT0);
+    }
+    else
+    {
+        SetCRReg(0xBF, PLLInfo.MS, BIT4+BIT3);
+        SetCRReg(0xBE, PLLInfo.NS, 0xFF);
+        SetCRReg(0xCE, PLLInfo.RS, BIT2+BIT1+BIT0);
+    }
+
+    /* Fire the PLL setting */
+    RetValue = GetCRReg(0xBB);
+    SetCRReg(0xBB, RetValue, 0xFF);
+
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetPolarity()
+;
+;       in:
+;           DisplayPath = display path
+;           Value: bit1 = 1 for positive H sync
+;                       = 0 for negative H sync
+;                  bit2 = 1 for positive V sync
+;                       = 0 for negative V sync
+;------------------------------------------------------------------*/
+void SetPolarity(UCHAR DevicePort, UCHAR Value)
+{
+    Value ^= BIT2+BIT1; /* invert Bit[2:1] */
+    
+    switch (DevicePort)
+    {
+        case CRT_PORT:
+            OutPort(MISC_WRITE, ((Value<<5) & 0xC0) | (InPort(MISC_READ) & 0x3F));
+            break;
+        
+        case DVP1:
+        case DVP12:
+            SetSRReg(0x20, Value>>1, BIT1+BIT0);
+            break;
+
+        case DVP2:
+            SetSRReg(0x20, Value<<2, BIT4+BIT3);
+            break;
+    }
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetFIFO()
+;
+;       in:
+;           DisplayPath = display path
+;       out:
+;           none
+;------------------------------------------------------------------*/
+void SetFIFO(UCHAR DisplayPath)
+{
+    if (DisplayPath == DISP1)
+    {
+        SetCRReg(0xA7, 0x3F, 0xFF);
+        SetCRReg(0xA6, 0x3F, 0xFF);
+    }
+    else if (DisplayPath == DISP2)
+    {
+        SetCRReg(0x35, 0x3F, 0xFF);
+        SetCRReg(0x34, 0x3F, 0xFF);
+    }
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetPitch()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = Pitch in byte
+;
+;------------------------------------------------------------------*/
+void SetPitch(UCHAR DisplayPath, USHORT Value)
+{
+    /* adjust pitch in 8 byte alignment */
+    Value += 7;
+    Value >>= 3;
+
+    if(DisplayPath == DISP1)
+    {
+        WriteRegToHW(Pitch1, Value);
+    }
+    else
+    {
+        WriteRegToHW(Pitch2, Value);
+    }
+
+    return;
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       GetPitch()
+;
+;       in:
+;           DisplayPath = display path
+;       out:
+;           return pitch in byte
+;
+;------------------------------------------------------------------*/
+USHORT GetPitch(UCHAR DisplayPath)
+{
+    USHORT wPitch;
+    
+    if(DisplayPath == DISP1)
+    {
+        wPitch = ReadRegFromHW(Pitch1);
+    }
+    else
+    {
+        wPitch = ReadRegFromHW(Pitch2);
+    }
+
+    wPitch <<= 3;
+
+    return wPitch;
+}
+
+/*-------------------------------------------------------------------
+;
+;       GetVDisplayEnd()
+;
+;       in:
+;           DisplayPath = display path
+;       out:
+;           return V disp end
+;
+;------------------------------------------------------------------*/
+USHORT GetVDisplayEnd(UCHAR DisplayPath)
+{
+    USHORT  wDisplayEnd = 0x0;
+    
+    if(DisplayPath == DISP1)
+    {
+        wDisplayEnd = ReadRegFromHW(VDispEnd1);
+    }
+    else
+    {
+        wDisplayEnd = ReadRegFromHW(VDispEnd2);
+    }
+    
+    /* Add 1 for query value. */
+    wDisplayEnd += 1;
+
+    return  wDisplayEnd;
+}
+
+/*-------------------------------------------------------------------
+;
+;       SetColorDepth()
+;
+;       in:
+;           DisplayPath = display path
+;           Value = color depth (8/16/32)
+;
+;------------------------------------------------------------------*/
+void SetColorDepth(UCHAR DisplayPath, UCHAR Value)
+{
+    UCHAR bSetBit = 0x0;
+
+    switch(Value)
+    {
+        case 8:
+            bSetBit = (UCHAR)BIT0;
+            break;
+        case 16:
+            bSetBit = (UCHAR)BIT2;
+            break;
+        case 32:
+            bSetBit = (UCHAR)BIT3;
+            break;
+        default:
+            return;
+    }
+
+    if(DisplayPath == DISP1)
+    {
+        SetCRReg(0xA3, bSetBit, 0x0F);
+    }
+    else
+    {
+        /* Display2 would not support 8bit color depth */
+        if(Value == 8)
+            return;
+        
+        SetCRReg(0x33, bSetBit, 0x0F);
+    }
+    
+}
+
+/*-------------------------------------------------------------------
+;
+;       ConfigDigitalPort()
+;
+;       in:
+;           bDisplayPath = display path
+;
+;------------------------------------------------------------------*/
+void ConfigDigitalPort(UCHAR bDisplayPath)
+{
+    PORT_CONFIG *pDevicePortConfig;
+    UCHAR bDeviceIndex;
+    UCHAR bRegValue;
+
+    bDeviceIndex = Get_DEV_ID(bDisplayPath);
+
+    if(bDisplayPath == DISP1)
+    {
+        bRegValue = 0x3;
+    }
+    else
+    {
+        bRegValue = 0x4;
+    }
+
+    if (GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig))
+    {
+        switch(pDevicePortConfig->PortID)
+        {
+            case CRT_PORT:
+                SetSRReg(0x1F, bRegValue, BIT2);
+                break;
+                
+            case DVP1:
+                Set12BitDVP();
+                SetSRReg(0x1F, bRegValue, BIT0);
+                break;
+                
+            case DVP2:
+                Set12BitDVP();
+                SetSRReg(0x1F, bRegValue, BIT1);
+                break;
+                
+            case DVP12:
+                Set24BitDVP();
+                SetSRReg(0x1F, bRegValue, BIT0);
+                break;
+        }
+    }
+}
+
+/*----------------------------------------------------------------------------
+;
+;       LoadTiming
+;
+;       in: 
+;           bDisplayPath = display path
+;           wModeNum = mode no.
+;
+;---------------------------------------------------------------------------*/
+void LoadTiming(UCHAR bDisplayPath, USHORT wModeNum)
+{
+    UCHAR bDeviceIndex = Get_DEV_ID(bDisplayPath);
+
+    /* Obtain the display device */ 
+
+    switch(bDeviceIndex)
+    {
+       case CRT_ID:
+       case CRT2_ID:
+       case DVI_ID:
+       case DVI2_ID:
+            LoadVESATiming(bDisplayPath, wModeNum);
+            break;
+
+       case LCD_ID:
+       case LCD2_ID:
+            LoadLCDTiming(bDisplayPath, wModeNum);
+            break;
+    }
+
+}
+
+/*----------------------------------------------------------------------------
+;
+;       LoadVESATiming
+;
+;       in: 
+;           bDisplayPath = display path
+;           wModeNum = mode no.
+;
+;---------------------------------------------------------------------------*/
+void LoadVESATiming(UCHAR bDisplayPath, USHORT wModeNum)
+{
+    UCHAR bR_Rate_value = 0x0;
+    MODE_INFO *pModeInfo = NULL;
+    RRATE_TABLE *pRRateTable = NULL;
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter LoadVESATiming()==\n");
+    bR_Rate_value = Get_RRATE_ID(bDisplayPath);
+    
+    if(GetModePointerFromVESATable(wModeNum, bR_Rate_value, &pModeInfo, &pRRateTable))
+    {
+        SetTimingRegs(bDisplayPath, pModeInfo, pRRateTable);
+    }
+    else
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "Mode not found!!\n");
+        /*ASSERT(true); */
+    }
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit LoadVESATiming()==\n");
+}
+/*----------------------------------------------------------------------------
+;
+;       LoadLCDTiming
+;
+;       in: 
+;           bDisplayPath = display path
+;           wModeNum = mode no.
+;
+;---------------------------------------------------------------------------*/
+void LoadLCDTiming(UCHAR bDisplayPath, USHORT wModeNum)
+{
+    UCHAR bDeviceIndex = Get_DEV_ID(bDisplayPath);
+    MODE_INFO *pPanelModeInfo, *pUserModeInfo;
+    PANEL_TABLE *pPanelTable;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter LoadLCDTiming()==\n");
+
+    if(GetModePointerFromLCDTable(bDeviceIndex,  &pPanelModeInfo, &pPanelTable))
+    {
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "&pPanelTable->Timing = 0x%x\n", &pPanelTable->Timing);
+        SetTimingRegs(bDisplayPath, pPanelModeInfo, &pPanelTable->Timing);
+        Get_MODE_INFO(wModeNum, &pUserModeInfo);
+        SetScalingFactor(bDisplayPath, pUserModeInfo, pPanelModeInfo);
+    }
+    else
+    {
+        /*ASSERT(true); */
+    }
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit LoadLCDTiming()==\n");
+}
+/*----------------------------------------------------------------------------
+;
+;       SetScalingFactor
+;
+;       in: 
+;           pUserModeInfo = pointer to MODE_INFO of user mode
+;           pPanelModeInfo = pointer to LCD MODE_INFO of panel
+;
+;---------------------------------------------------------------------------*/
+void SetScalingFactor(UCHAR bDisplayPath, MODE_INFO *pUserModeInfo, MODE_INFO *pPanelModeInfo)
+{
+    ULONG dwScalingFactor;
+
+    USHORT usUserModeHSize, usUserModeVSize;
+    USHORT usPanelModeHSize, usPanelModeVSize;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter SetScalingFactor()==\n");
+    usUserModeHSize = pUserModeInfo->H_Size;
+
+    usUserModeVSize = pUserModeInfo->V_Size;
+
+    usPanelModeHSize = pPanelModeInfo->H_Size;
+
+    usPanelModeVSize = pPanelModeInfo->V_Size;
+
+
+    TurnOffHorScaler(bDisplayPath);
+
+    TurnOffVerScaler(bDisplayPath);
+
+    SetHSource(bDisplayPath, usUserModeHSize);
+
+
+    if (usPanelModeHSize > usUserModeHSize)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "Enable H scaler\n");
+        dwScalingFactor = ((ULONG)usUserModeHSize << 12) / usPanelModeHSize;
+        SetHorScalingFactor(bDisplayPath, dwScalingFactor);
+        TurnOnHorScaler(bDisplayPath);
+        TurnOnScaler(bDisplayPath);
+    }
+
+    if (usPanelModeVSize > usUserModeVSize)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "Enable V scaler\n");
+        dwScalingFactor = ((ULONG)usUserModeVSize << 11) / usPanelModeVSize;
+        SetVerScalingFactor(bDisplayPath, dwScalingFactor);
+        TurnOnVerScaler(bDisplayPath);
+        TurnOnScaler(bDisplayPath);
+    }
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit SetScalingFactor()==\n");
+}
+/*-------------------------------------------------------------------
+;
+;       SetHorScalingFactor()
+;
+;       in:
+;           DisplayPath = display path
+;           wValue = scaling factor
+;
+;------------------------------------------------------------------*/
+void SetHorScalingFactor(UCHAR bDisplayPath, USHORT wValue)
+{
+    if(bDisplayPath == DISP1)
+    {
+        WriteRegToHW(HScalingFactor1, wValue);
+    }
+    else
+    {
+        WriteRegToHW(HScalingFactor2, wValue);
+    }
+}
+/*-------------------------------------------------------------------
+;
+;       SetVerScalingFactor()
+;
+;       in:
+;           DisplayPath = display path
+;           wValue = scaling factor
+;
+;------------------------------------------------------------------*/
+void SetVerScalingFactor(UCHAR bDisplayPath, USHORT wValue)
+{
+    if(bDisplayPath == DISP1)
+    {
+        WriteRegToHW(VScalingFactor1, wValue);
+    }
+    else
+    {
+        WriteRegToHW(VScalingFactor2, wValue);
+    }
+}
+/*-------------------------------------------------------------------
+;
+;       isLCDFitMode() -
+;
+;   Input:
+;       bDeviceIndex = LCD/LCD2
+;       wModeNom = mode number
+;   return:
+;       true if wModeNom is LCD fit mode
+;
+;------------------------------------------------------------------*/
+CI_STATUS isLCDFitMode(UCHAR bDeviceIndex, USHORT wModeNum)
+{
+    MODE_INFO *pModeInfo;
+    
+    if (Get_MODE_INFO_From_LCD_Table(bDeviceIndex, &pModeInfo))
+    {
+        if ((wModeNum == pModeInfo->Mode_ID_8bpp) ||
+            (wModeNum == pModeInfo->Mode_ID_16bpp) ||
+            (wModeNum == pModeInfo->Mode_ID_32bpp))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else
+    {
+        return false;
+    }
+}
+/*----------------------------------------------------------------------------
+;
+;       GetModePointerFromVESATable
+;
+;       in: 
+;           wModeNum = mode no.
+;           bRRIndex = refresh rate index
+;       out:
+;           return = true, pModeInfo = pointer to MODE_INFO
+;                          pRRateTable = pointer to RRATE_TABLE
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS GetModePointerFromVESATable(USHORT wModeNum, UCHAR ucRRIndex, MODE_INFO **ppModeInfo, RRATE_TABLE **ppRRateTable)
+{
+    int iRRateTableIndex;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter GetModePointerFromVESATable()==\n");
+ 
+    /* Don't find out any fit mode table in the vesa table */
+    if(Get_MODE_INFO_From_VESA_Table(wModeNum, ppModeInfo))
+    {
+        /* Obtain the frequence table. */
+        *ppRRateTable = (RRATE_TABLE*)((int)(*ppModeInfo) + sizeof(MODE_INFO));
+
+        for(iRRateTableIndex = 0; iRRateTableIndex < (*ppModeInfo)->RRTableCount; iRRateTableIndex++, (*ppRRateTable)++)
+        {
+            xf86DrvMsgVerb(0, X_INFO, InternalLevel, "*ppRRateTable = 0x%x\n", *ppRRateTable);
+
+            if(((*ppRRateTable)->RRate_ID == ucRRIndex) && (!((*ppRRateTable)->Attribute & DISABLE)))
+            {
+                xf86DrvMsgVerb(0, X_INFO, InternalLevel, "*ppRRateTable = 0x%x\n", *ppRRateTable);
+                xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 GetModePointerFromVESATable()== return success\n");
+                return true;
+            }
+        }
+    }
+
+    /* Can't find any fresh rate be conformed */
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit2 GetModePointerFromVESATable()== return fail!!\n");
+    return false;
+}
+
+/*----------------------------------------------------------------------------
+;
+;       GetModePointerFromLCDTable
+;
+;       in: 
+;           bDeviceIndex = device index
+;       out:
+;           return = true, ppPanelInfo = pointer to PANEL_INFO
+;                          pPanelTable = pointerto PANEL_TABLE
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS GetModePointerFromLCDTable(UCHAR bDeviceIndex, MODE_INFO **ppModeInfo, PANEL_TABLE **ppPanelTable)
+{
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter GetModePointerFromLCDTable()==\n");
+    if (Get_MODE_INFO_From_LCD_Table(bDeviceIndex, ppModeInfo))
+    {
+        *ppPanelTable = (PANEL_TABLE*)((int)(*ppModeInfo) + sizeof(MODE_INFO));
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "*ppPanelTable = 0x%x\n", *ppPanelTable);
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 GetModePointerFromLCDTable()== return success\n");
+        return true;
+    }
+    else
+    {
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 GetModePointerFromLCDTable()== return fail\n");
+        return false;
+    }
+}
+/*----------------------------------------------------------------------------
+;
+;       Get_MODE_INFO
+;
+;       in: 
+;           wModeNum = mode no.
+;       out:
+;           return = true, pModeInfo = pointer to MODE_INFO
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS Get_MODE_INFO(USHORT wModeNum, MODE_INFO **ppModeInfo)
+{
+    if (Get_MODE_INFO_From_VESA_Table(wModeNum, ppModeInfo))
+    {
+        return true;
+    }
+    else if(isLCDFitMode(LCD_ID, wModeNum))
+    {
+        Get_MODE_INFO_From_LCD_Table(LCD_ID, ppModeInfo);
+        return true;
+    }
+    else if(isLCDFitMode(LCD2_ID, wModeNum))
+    {
+        Get_MODE_INFO_From_LCD_Table(LCD2_ID, ppModeInfo);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+/*----------------------------------------------------------------------------
+;
+;       Get_MODE_INFO_From_LCD_Table
+;
+;       in: 
+;           bDeviceIndex = device index.
+;       out:
+;           return = true, pModeInfo = pointer to PANEL_INFO
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS Get_MODE_INFO_From_LCD_Table(UCHAR bDeviceIndex, MODE_INFO **ppModeInfo)
+{
+    int i;
+    UCHAR bLCDTableIndex;
+     
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter Get_MODE_INFO_From_LCD_Table()==\n");
+
+    *ppModeInfo = pLCDTable;
+    
+    if (bDeviceIndex == LCD_ID)
+    {
+        bLCDTableIndex = Get_LCD_TABLE_INDEX();
+    }
+    else if (bDeviceIndex == LCD2_ID)
+    {
+        bLCDTableIndex = Get_LCD2_TABLE_INDEX();
+    }
+    else
+    {
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 Get_MODE_INFO_From_LCD_Table()== return fail!!\n");
+        return false;
+    }
+
+
+    if (bLCDTableIndex == 0)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "LCD Index = 0\n");
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 Get_MODE_INFO_From_LCD_Table()== return fail!!\n");
+        return false;
+    }
+
+    while ((*ppModeInfo)->H_Size != 0xFFFF)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "(*ppModeInfo)->H_Size = %d\n", (*ppModeInfo)->H_Size);
+
+        if (bLCDTableIndex == 1)
+        {
+            xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit3 Get_MODE_INFO_From_LCD_Table()== return success\n");
+            return true;
+        }
+        (*ppModeInfo) = (MODE_INFO*)((int)*ppModeInfo + sizeof(MODE_INFO) + sizeof(PANEL_TABLE));
+        bLCDTableIndex--;
+    }
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit4 Get_MODE_INFO_From_LCD_Table()== return fail!!\n");
+
+    return false;
+    
+}
+/*----------------------------------------------------------------------------
+;
+;       Get_MODE_INFO_From_VESA_Table
+;
+;       in: 
+;           wModeNum = mode no.
+;       out:
+;           return = true, pModeInfo = pointer to MODE_INFO
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+#if 0
+CI_STATUS Get_MODE_INFO_From_VESA_Table(USHORT wModeNum, MODE_INFO **ppModeInfo)
+{
+    int i;
+    VESA_TABLE *pVESATable = VESATable;
+    
+    for( i = 0; i < (sizeof(VESATable)/sizeof(VESA_TABLE)); i++, pVESATable++)
+    {
+        if((pVESATable->ModeInfo.Mode_ID_8bpp == wModeNum) || (pVESATable->ModeInfo.Mode_ID_16bpp == wModeNum)|| (pVESATable->ModeInfo.Mode_ID_32bpp == wModeNum))
+        {
+            *ppModeInfo = &(pVESATable->ModeInfo);
+            return true;
+        }
+    }
+    
+    return false;
+}
+#else
+CI_STATUS Get_MODE_INFO_From_VESA_Table(USHORT wModeNum, MODE_INFO **ppModeInfo)
+{
+    UCHAR ucColorDepth;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter Get_MODE_INFO_From_VESA_Table()==\n");
+
+    *ppModeInfo = pVESATable;
+
+    while((*ppModeInfo)->H_Size != 0xFFFF)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "*ppModeInfo = 0x%x\n", *ppModeInfo);
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "(*ppModeInfo)->H_Size = %d\n", (*ppModeInfo)->H_Size);
+
+        if (GetModeColorDepth(wModeNum, *ppModeInfo, &ucColorDepth))
+        {
+            xf86DrvMsgVerb(0, X_INFO, InfoLevel, "*ppModeInfo = 0x%x\n", *ppModeInfo);
+            xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 Get_MODE_INFO_From_VESA_Table()== return success\n");
+            return true;
+        }
+
+        *ppModeInfo = (MODE_INFO*)((*ppModeInfo)->RRTableCount * sizeof(RRATE_TABLE) + sizeof(MODE_INFO) + (void*)(*ppModeInfo));
+    }
+
+    *ppModeInfo = (MODE_INFO*)(&CInt10VESATable);
+
+    while((*ppModeInfo)->H_Size != 0xFFFF)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "*ppModeInfo = 0x%x\n", *ppModeInfo);
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "(*ppModeInfo)->H_Size = %d\n", (*ppModeInfo)->H_Size);
+
+        if (GetModeColorDepth(wModeNum, *ppModeInfo, &ucColorDepth))
+        {
+            xf86DrvMsgVerb(0, X_INFO, InfoLevel, "*ppModeInfo = 0x%x\n", *ppModeInfo);
+            xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 Get_MODE_INFO_From_VESA_Table()== return success\n");
+            return true;
+        }
+
+        *ppModeInfo = (MODE_INFO*)((*ppModeInfo)->RRTableCount * sizeof(RRATE_TABLE) + sizeof(MODE_INFO) + (void*)(*ppModeInfo));
+    }
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit2 Get_MODE_INFO_From_VESA_Table()== return fail!!\n");
+    return false;
+}
+#endif
+/*----------------------------------------------------------------------------
+;
+;       GetModeColorDepth
+;
+;       in: 
+;           wModeNum = mode no.
+;           pMODE_INFO = pointer to MODE_INFO
+;       out:
+;           return = true, *pbColorDepth = color depth
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS GetModeColorDepth(USHORT wModeNum, MODE_INFO *pModeInfo, UCHAR *pucColorDepth)
+{
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter GetModeColorDepth()==\n");
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->Mode_ID_8bpp = 0x%x\n", pModeInfo->Mode_ID_8bpp);
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->Mode_ID_16bpp = 0x%x\n", pModeInfo->Mode_ID_16bpp);
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->Mode_ID_32bpp = 0x%x\n", pModeInfo->Mode_ID_32bpp);
+#endif
+    if(pModeInfo->Mode_ID_8bpp == wModeNum)
+    {
+        *pucColorDepth = 8;
+#if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 GetModeColorDepth()== *pucColorDepth = %d\n", *pucColorDepth);
+#endif
+        return true;
+    }
+    else if(pModeInfo->Mode_ID_16bpp == wModeNum)
+    {
+        *pucColorDepth = 16;
+#if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 GetModeColorDepth()== *pucColorDepth = %d\n", *pucColorDepth);
+#endif
+        return true;
+    }
+    else if(pModeInfo->Mode_ID_32bpp == wModeNum)
+    {
+        *pucColorDepth = 32;
+#if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit3 GetModeColorDepth()== *pucColorDepth = %d\n", *pucColorDepth);
+#endif
+        return true;
+    }
+    else
+    {
+        *pucColorDepth = 0;
+#if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit4 GetModeColorDepth()== *pucColorDepth = %d\n", *pucColorDepth);
+#endif
+        return false;
+    }    
+}
+/*----------------------------------------------------------------------------
+;
+;       GetModePitch()
+;
+;       In:
+;           ModeNum = mode no
+;       Out:
+;           return = true, *pPitch = pitch in byte
+;                  = false, fail
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS GetModePitch(USHORT ModeNum, USHORT *pPitch)
+{
+    MODE_INFO *pModeInfo = NULL;
+    UCHAR ucColorDepth = 0;
+    
+    /* Don't find out any fit mode table in the vesa table */
+    if(!Get_MODE_INFO(ModeNum, &pModeInfo))
+    {
+        return false;
+    }
+    else
+    {
+        if(!GetModeColorDepth(ModeNum, pModeInfo, &ucColorDepth))
+        {
+            return false;
+        }
+        else
+        {
+            ucColorDepth = ucColorDepth >> 4;
+            *pPitch = ((pModeInfo->H_Size << ucColorDepth)+0x7)&0xFFF8;
+        }
+    }
+
+    return true;
+}
+/*----------------------------------------------------------------------------
+;
+;       ReadRegFromHW
+;
+;       in: 
+;           pRegOp = pointer to REG_OP table
+;       out:
+;           return = register value
+;
+;---------------------------------------------------------------------------*/
+USHORT ReadRegFromHW(REG_OP *pRegOp)
+{
+    USHORT wValue = 0x0;
+    UCHAR    btemp = 0x0, bMasktemp = 0x0;
+
+    while((pRegOp->RegGroup)!= NR)
+    {        
+        if(pRegOp->RegGroup == CR)
+        {
+            /*CR */
+            OutPort(COLOR_CRTC_INDEX,(pRegOp->RegIndex));
+            btemp = (UCHAR)InPort(COLOR_CRTC_DATA);
+        }
+        else
+        {
+            /*SR */
+            OutPort(SEQ_INDEX,(pRegOp->RegIndex));
+            btemp = (UCHAR)InPort(SEQ_DATA);
+        }
+        
+        bMasktemp = (pRegOp->RegMask);
+
+        /* Mask the bit that we need. */
+        btemp &= bMasktemp;
+
+        /* Shift all register into LSB. */
+        while(!(bMasktemp & BIT0))
+        {
+            bMasktemp = bMasktemp >> 1;
+            btemp = btemp >> 1;
+        }
+
+        /* Shift the register and add in the value. */
+        wValue |= (((USHORT)btemp) << (pRegOp->RegShiftBit));
+        
+        /* Next register. */
+        pRegOp++;
+
+    }
+
+    return wValue;
+}
+
+/*----------------------------------------------------------------------------
+;
+;       WriteRegToHW
+;
+;       in: 
+;           pRegOp = pointer to REG_OP table
+;           value = value to be written
+;
+;---------------------------------------------------------------------------*/
+void WriteRegToHW(REG_OP *pRegOp, USHORT value)
+{
+    UCHAR btemp, btemp1;
+    UCHAR bCount;
+    UCHAR bMasktemp;
+
+    while((pRegOp->RegGroup)!= NR)
+    {
+        btemp = 0x0; btemp1 = 0x0;
+        bCount = 0x0; bMasktemp = 0x0;
+    
+        bMasktemp = (pRegOp->RegMask);
+
+        /* Shift all register into LSB. */
+        while(!(bMasktemp & BIT0))
+        {
+            bMasktemp = bMasktemp >> 1;
+            bCount ++;
+        }
+    
+        /* Calculate the value that we need to set into register. */
+        btemp = value >> (pRegOp->RegShiftBit);
+        btemp &= (bMasktemp);
+
+        /* Shift the data bit into right position. */
+        if(!(pRegOp->RegMask & BIT0))
+        {
+            btemp = btemp << bCount;
+        }
+            
+        if(pRegOp->RegGroup == CR)
+        {
+            /*CR */
+            OutPort(COLOR_CRTC_INDEX,(pRegOp->RegIndex));
+            btemp1 = (UCHAR)InPort(COLOR_CRTC_DATA);
+            btemp1 &= ~(pRegOp->RegMask);
+            btemp1 |= btemp;
+            OutPort(COLOR_CRTC_DATA,btemp1);
+        }
+        else
+        {
+            /*SR */
+            OutPort(SEQ_INDEX,(pRegOp->RegIndex));
+            btemp1 = (UCHAR)InPort(SEQ_DATA);
+            btemp1 &= ~(pRegOp->RegMask);
+            btemp1 |= btemp;
+            OutPort(SEQ_DATA,btemp1);            
+        }
+
+        pRegOp++;
+        
+    }
+ 
+}
+
+/*----------------------------------------------------------------------------
+;
+;       UnLockCR0ToCR7
+;
+;       in: 
+;           none
+;       out:
+;           none
+;
+;---------------------------------------------------------------------------*/
+void UnLockCR0ToCR7()
+{
+    /* CR11[7] = 0 */
+    SetCRReg(0x11, 0x00, BIT7);
+}
+
+/*----------------------------------------------------------------------------
+;
+;       LockCR0ToCR7
+;
+;       in: 
+;           none
+;       out:
+;           none
+;
+;---------------------------------------------------------------------------*/
+void LockCR0ToCR7()
+{
+    /* CR11[7] = 1 */
+    SetCRReg(0x11, 0x80, BIT7);
+}
+
+/*----------------------------------------------------------------------------
+;
+;       CheckForModeAvailable
+;
+;       in: 
+;           ModeNum = mode no.
+;       out:
+;           return = true, if mode is available. Else, return false
+;
+;---------------------------------------------------------------------------*/
+CI_STATUS CheckForModeAvailable(USHORT ModeNum)
+{
+    MODE_INFO *pModeInfo = NULL;
+    return Get_MODE_INFO_From_VESA_Table(ModeNum, &pModeInfo);
+}
+/*--------------------------------------------------------------------
+;
+;       CheckForNewDeviceAvailable() - 
+;
+;     Input:
+;           bDeviceIndex = device index
+;    return:
+;           true if device is supported
+;--------------------------------------------------------------------*/
+CI_STATUS CheckForNewDeviceAvailable(UCHAR bDeviceIndex)
+{
+    PORT_CONFIG *pDevicePortConfig;
+    
+    return GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig);
+}
+
+void Display1TurnOnTX()
+{
+
+}
+
+void Display1TurnOffTX()
+{
+
+}
+
+void Display2TurnOnTX()
+{
+
+}
+
+void Display2TurnOffTX()
+{
+
+}
+
+/*----------------------------------------------------------------------------
+;
+;       TurnOnDigitalPort
+;
+;       in: 
+;           DisplayPath = device index
+;
+;---------------------------------------------------------------------------*/
+void TurnOnDigitalPort(UCHAR bDeviceIndex)
+{
+    PORT_CONFIG *pDevicePortConfig;
+
+    if (GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig))
+    {
+        switch(pDevicePortConfig->PortID)
+        {
+            case CRT_PORT:
+                TurnOnDAC();
+                TurnOnCRTPad();
+                break;
+                
+            case DVP1:
+                TurnOnDVP1Pad();
+                break;
+                
+            case DVP2:
+                TurnOnDVP2Pad();
+                break;
+                
+            case DVP12:
+                TurnOnDVP12Pad();
+                break;
+        }
+    }
+}       
+/*----------------------------------------------------------------------------
+;
+;       TurnOffDigitalPort
+;
+;       in: 
+;           bDeviceIndex = device index
+;
+;---------------------------------------------------------------------------*/
+void TurnOffDigitalPort(UCHAR bDeviceIndex)
+{
+    PORT_CONFIG *pDevicePortConfig;
+    
+    if (GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig))
+    
+    switch(pDevicePortConfig->PortID)
+    {
+        case CRT_PORT:
+            TurnOffCRTPad();
+//            TurnOffDAC();
+            break;
+            
+        case DVP1:
+            TurnOffDVP1Pad();
+            break;
+            
+        case DVP2:
+            TurnOffDVP2Pad();
+            break;
+            
+        case DVP12:
+            TurnOffDVP12Pad();
+            break;
+    }
+}       
+
+/*-----------------------------------------------------------------------------
+;
+;       GetPortConnectPath
+;
+;       in: 
+;           PortType = 0: CRT port, 1: DVP1, 2: DVP2, 3: 24-bit DVP1+2
+;       out:
+;           return = 0 if port connecting on display1
+;                  = 1 if port connecting on display2
+;
+;-----------------------------------------------------------------------------*/
+UCHAR GetPortConnectPath(UCHAR PortType)
+{
+    UCHAR SR1F, PortMask;
+
+    SR1F = GetSRReg(0x1F);
+    SR1F ^= 0x03;
+    
+    switch(PortType)
+    {
+        case CRT_PORT:
+            PortMask = BIT2;
+            break;
+            
+        case DVP1:
+        case DVP12:
+            PortMask = BIT0;
+            break;
+            
+        case DVP2:
+            PortMask = BIT1;
+            break;
+    }
+    
+    return ((SR1F & PortMask) ? 1 : 0);
+
+}
+
+/*----------------------------------------------------------------------------
+;
+;       TransDevIDtoBit
+;
+;       in: 
+;           DeviceIndex = device index
+;       out:
+;           return device bit
+;
+;---------------------------------------------------------------------------*/
+USHORT TransDevIDtoBit(UCHAR DeviceIndex)
+{
+    return (1 << (DeviceIndex - 1));
+}
+
+void TurnOnCRTPad()
+{
+    SetCRReg(0xA8, 0x00, BIT7);
+}
+
+void TurnOffCRTPad()
+{
+    SetCRReg(0xA8, 0x80, BIT7);
+}
+
+void TurnOnDVP1Pad()
+{
+    SetCRReg(0xA3, 0x80, BIT7);
+}
+
+void TurnOffDVP1Pad()
+{
+    SetCRReg(0xA3, 0x00, BIT7);
+}
+
+void TurnOnDVP2Pad()
+{
+    SetCRReg(0xA3, 0x40, BIT6);
+}
+
+void TurnOffDVP2Pad()
+{
+    SetCRReg(0xA3, 0x00, BIT6);
+}
+
+void TurnOnDVP12Pad()
+{
+    TurnOnDVP1Pad();
+    TurnOnDVP2Pad();
+}
+
+void TurnOffDVP12Pad()
+{
+    TurnOffDVP1Pad();
+    TurnOffDVP2Pad();
+}
+
+void TurnOnScaler(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+        SetSRReg(0x58, BIT0, BIT0);
+    else
+        SetSRReg(0x50, BIT0, BIT0);
+}
+
+void TurnOffScaler(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+        SetSRReg(0x58, 0, BIT0);
+    else
+        SetSRReg(0x50, 0, BIT0);
+}
+
+void TurnOnHorScaler(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+        SetSRReg(0x58, BIT2, BIT2);
+    else
+        SetSRReg(0x50, BIT2, BIT2);
+}
+
+void TurnOffHorScaler(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+        SetSRReg(0x58, 0, BIT2);
+    else
+        SetSRReg(0x50, 0, BIT2);
+}
+
+void TurnOnVerScaler(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+        SetSRReg(0x58, BIT1, BIT1);
+    else
+        SetSRReg(0x50, BIT1, BIT1);
+}
+
+void TurnOffVerScaler(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+        SetSRReg(0x58, 0, BIT1);
+    else
+        SetSRReg(0x50, 0, BIT1);
+}
+
+
+void Set12BitDVP()
+{
+    SetSRReg(0x1E, 0x00, BIT3);
+}
+
+void Set24BitDVP()
+{
+    SetSRReg(0x1E, 0x08, BIT3);
+}
+
+void TurnOnDAC()
+{
+    SetCRReg(0xDF, 0x00, BIT2);
+}
+void TurnOffDAC()
+{
+    SetCRReg(0xDF, 0x04, BIT2);
+}
+
+#if 0
+void Display1HWResetOn()
+{
+    SetCRReg(0x17, 0x00, BIT7);
+}
+void Display1HWResetOff()
+{
+    SetCRReg(0x17, 0x80, BIT7);
+}
+
+void Display2HWResetOn()
+{
+    SetCRReg(0x33, 0x00, BIT4);
+}
+void Display2HWResetOn()
+{
+    SetCRReg(0x33, 0x10, BIT4);
+}
+#endif
+
+/*----------------------------------------------------------------------------
+;
+;       SerialLoadTable
+;
+;       in: 
+;           pucDisplay1VESAModeInitRegs = pointer to start of table
+;           (ucI2Cport = I2C port)
+;           (ucI2CAddr = I2C address)
+;       out:
+;           *ppucTablePointer = table end + 1
+;
+;---------------------------------------------------------------------------*/
+void SerialLoadTable(UCHAR **ppucTablePointer, UCHAR ucI2Cport, UCHAR ucI2CAddr)
+{
+    UCHAR ucRegGroup;
+
+    while (**ppucTablePointer != 0xFF)
+    {
+        ucRegGroup = **ppucTablePointer;
+        (*ppucTablePointer)++;
+        if (ucRegGroup & BITS)
+        {
+            SerialLoadRegBits(ppucTablePointer, ucRegGroup, 0, 0);
+        }
+        else
+        {
+            SerialLoadReg(ppucTablePointer, ucRegGroup, 0, 0);
+        }
+    }
+    (*ppucTablePointer)++;
+}
+
+/*---------------------
+;
+;       SerialLoadRegBits 
+;
+;   in:
+;       pucDisplay1VESAModeInitRegs = pointer to start of table
+;       ucRegGroup = register group
+;       (ucI2Cport = I2C device address)
+;       (ucI2CAddr = I2C port)
+;   out:
+;       *ppucTablePointer = pointer to end of table +1
+;
+;----------------------*/
+void SerialLoadRegBits(UCHAR **ppucTablePointer, UCHAR ucRegGroup, UCHAR ucI2Cport, UCHAR ucI2CAddr)
+{
+    UCHAR ucRegIndex, ucRegValue, ucMask;
+    ucRegGroup &= 0x7F;
+
+    while (**ppucTablePointer != 0xFF)
+    {
+        ucRegIndex = **ppucTablePointer;
+        (*ppucTablePointer)++;
+
+        ucRegValue = **ppucTablePointer;
+        (*ppucTablePointer)++;
+
+        ucMask = **ppucTablePointer;
+        (*ppucTablePointer)++;
+
+        switch(ucRegGroup)
+        {
+            case SR:
+                SetSRReg(ucRegIndex, ucRegValue, ucMask);
+                break;
+
+            case CR:
+                SetCRReg(ucRegIndex, ucRegValue, ucMask);
+                break;
+                
+            case I2C:
+                break;
+        }
+    }
+    (*ppucTablePointer)++;
+}
+
+/*---------------------
+;
+;       SerialLoadReg 
+;
+;   in:
+;       pucDisplay1VESAModeInitRegs = pointer to start of table
+;       ucRegGroup = register group
+;       (ucI2Cport = I2C device address)
+;       (ucI2CAddr = I2C port)
+;   out:
+;       *ppucTablePointer = pointer to end of table +1
+;
+;----------------------*/
+void SerialLoadReg(UCHAR **ppucTablePointer, UCHAR ucRegGroup, UCHAR ucI2Cport, UCHAR ucI2CAddr)
+{
+    UCHAR ucRegIndex, ucRegValue;
+
+    while (**ppucTablePointer != 0xFF)
+    {
+        ucRegIndex = **ppucTablePointer;
+        (*ppucTablePointer)++;
+
+        ucRegValue = **ppucTablePointer;
+        (*ppucTablePointer)++;
+
+        switch(ucRegGroup)
+        {
+            case SR:
+                SetSRReg(ucRegIndex, ucRegValue, 0xFF);
+                break;
+
+            case CR:
+                SetCRReg(ucRegIndex, ucRegValue, 0xFF);
+                break;
+                
+            case GR:
+                SetGRReg(ucRegIndex, ucRegValue, 0xFF);
+                break;
+
+            case I2C:
+                break;
+        }
+    }
+    (*ppucTablePointer)++;
+}
+
+
+void LoadDisplay1VESAModeInitRegs()
+{
+    UCHAR *pucDisplay1VESAModeInitRegs = (UCHAR*)Display1VESAModeInitRegs;
+    
+    OutPort(MISC_WRITE, 0x2F);
+
+    UnLockCR0ToCR7();
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "&pucDisplay1VESAModeInitRegs = 0x%x\n", &pucDisplay1VESAModeInitRegs);
+    SerialLoadTable(&pucDisplay1VESAModeInitRegs, 0, 0);
+
+    ResetATTR();
+    
+    SetARReg(0x10, *pucDisplay1VESAModeInitRegs);
+    pucDisplay1VESAModeInitRegs++;
+    SetARReg(0x11, *pucDisplay1VESAModeInitRegs);
+    pucDisplay1VESAModeInitRegs++;
+    SetARReg(0x12, *pucDisplay1VESAModeInitRegs);
+    pucDisplay1VESAModeInitRegs++;
+    SetARReg(0x13, *pucDisplay1VESAModeInitRegs);
+    pucDisplay1VESAModeInitRegs++;
+    SetARReg(0x14, *pucDisplay1VESAModeInitRegs);
+    
+    EnableATTR();
+}
+
+void VESASetBIOSData(USHORT ModeNum)
+{
+    /* no need to implement */
+}
+
+/*----------------------------------------------------------------------------
+;
+;       DisableDisplayPathAndDevice
+;
+;       in: 
+;           bDisplayPath = display path
+;
+;---------------------------------------------------------------------------*/
+void DisableDisplayPathAndDevice(UCHAR bDisplayPath)
+{
+    UCHAR bDeviceIndex = Get_DEV_ID(bDisplayPath);
+
+    /* disable device */
+    ControlPwrSeqOff(bDeviceIndex);
+
+    /* turn off TX */
+
+    /* disable port */
+    TurnOffDigitalPort(bDeviceIndex);
+    
+    /* disable display path */
+    SequencerOff(bDisplayPath);
+}
+
+CI_STATUS GetDevicePortConfig(UCHAR bDeviceIndex, PORT_CONFIG **ppDevicePortConfig)
+{
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter GetDevicePortConfig()==\n");
+
+    *ppDevicePortConfig = pPortConfig;
+    
+    while(((*ppDevicePortConfig)->DevID != 0xFF) && ((*ppDevicePortConfig)->Attribute & Dev_SUPPORT))
+    {
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "(*ppDevicePortConfig)->DevID = %x\n", (*ppDevicePortConfig)->DevID);
+        
+        if (bDeviceIndex == (*ppDevicePortConfig)->DevID)
+        {
+            xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 GetDevicePortConfig()== return success\n");
+            return true;
+        }
+        (*ppDevicePortConfig)++;
+    }
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 GetDevicePortConfig()== return fail!!\n");
+    return false;
+}
+
+void PowerSequenceOn()
+{
+    /* check if power sequence already on */
+    if (!(GetSRReg(0x11) & BIT0))
+    {
+        /* Power Sequence Control Pad Output Enable */
+        SetSRReg(0x32, BIT1, BIT1);
+        
+        /* panel on */
+        SetSRReg(0x11, BIT0, BIT0);
+        
+        /* delay for power sequence done */
+        WaitPowerSequenceDone();
+    }
+}
+
+void PowerSequenceOff()
+{
+    /* check if power sequence already off */
+    if (GetSRReg(0x11) & BIT0)
+    {
+        /* panel off */
+        SetSRReg(0x11, 0, BIT0);
+        
+        /* wait power sequence done */
+        WaitPowerSequenceDone();
+        
+        /* Power Sequence Control Pad Output Disable */
+        SetSRReg(0x32, 0, BIT1);
+    }
+}
+
+void SequencerOn(UCHAR DisplayPath)
+{
+    if (DisplayPath == DISP1)
+        SetSRReg(0x01, 0, BIT5);
+    else
+        SetCRReg(0x33, 0, BIT0);
+}
+
+void SequencerOff(UCHAR bDisplayPath)
+{
+    if (bDisplayPath == DISP1)
+    {
+        if (!(GetSRReg(0x01) & BIT5))
+        {
+            LongWait();
+        }
+        SetSRReg(0x01, BIT5, BIT5);
+    }
+    else
+        SetCRReg(0x33, BIT0, BIT0);
+}
+
+void ControlPwrSeqOn(UCHAR bDeviceIndex)
+{
+    PORT_CONFIG *pDevicePortConfig;
+    /* check if LCD or LCD2 */
+    if ((TransDevIDtoBit(bDeviceIndex) & (B_LCD+B_LCD2)) && (GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig)))
+    {
+        if (pDevicePortConfig->Attribute & TX_PS)
+        {
+            if (pDevicePortConfig->TX_Enc_ID == TX_VT1636)
+            {
+/*                VT1636PowerSequenceOnOn();*/
+            }
+        }
+        else if ((pDevicePortConfig->PortID == DVP1) || (pDevicePortConfig->PortID == DVP12))
+        {
+            PowerSequenceOn();
+        }
+    }    
+}
+
+void ControlPwrSeqOff(UCHAR bDeviceIndex)
+{
+    PORT_CONFIG *pDevicePortConfig;
+    /* check if LCD or LCD2 */
+    if ((TransDevIDtoBit(bDeviceIndex) & (B_LCD+B_LCD2)) && (GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig)))
+    {
+        if (pDevicePortConfig->Attribute & TX_PS)
+        {
+            if (pDevicePortConfig->TX_Enc_ID == TX_VT1636)
+            {
+/*                VT1636PowerSequenceOnOff();*/
+            }
+        }
+        else if ((pDevicePortConfig->PortID == DVP1) || (pDevicePortConfig->PortID == DVP12))
+        {
+            PowerSequenceOff();
+        }
+    }    
+}
+/*----------------------------------------------------------------------------
+;
+;       LongWait() - wait V sync of display1
+;
+;        in: 
+;           none
+;       out:
+;           none
+;       
+;---------------------------------------------------------------------------*/
+void LongWait()
+{
+     while (GetIS1Reg() & BIT3);
+     
+     while (!(GetIS1Reg() & BIT3));
+}
+
+UCHAR Get_DEV_ID(UCHAR DisplayPath)
+{
+    return ((DisplayPath == DISP1) ? ReadScratch(IDX_IGA1_DEV_ID) : ReadScratch(IDX_IGA2_DEV_ID));
+}
+
+
+void Set_DEV_ID(UCHAR DeviceID, UCHAR DisplayPath)
+{
+    if (DisplayPath == DISP1)
+        WriteScratch(IDX_IGA1_DEV_ID, DeviceID);
+    else
+        WriteScratch(IDX_IGA2_DEV_ID, DeviceID);
+}
+
+
+UCHAR Get_NEW_DEV_ID(UCHAR DisplayPath)
+{
+    return ((DisplayPath == DISP1) ? ReadScratch(IDX_NEW_IGA1_DEV_ID) : ReadScratch(IDX_NEW_IGA2_DEV_ID));
+}
+
+void Set_NEW_DEV_ID(UCHAR DeviceID, UCHAR DisplayPath)
+{
+    if (DisplayPath == DISP1)
+        WriteScratch(IDX_NEW_IGA1_DEV_ID, DeviceID);
+    else
+        WriteScratch(IDX_NEW_IGA2_DEV_ID, DeviceID);
+}
+
+USHORT Get_LCD_H_SIZE()
+{
+    USHORT wValue;
+
+    wValue = (USHORT)ReadScratch(IDX_LCD_H_SIZE_OVERFLOW);
+    wValue <<= 8;
+    wValue |= (USHORT)ReadScratch(IDX_LCD_H_SIZE);
+    
+    return wValue;
+}
+
+USHORT Get_LCD_V_SIZE()
+{
+    USHORT wValue;
+
+    wValue = (USHORT)ReadScratch(IDX_LCD_V_SIZE_OVERFLOW);
+    wValue <<= 8;
+    wValue |= (USHORT)ReadScratch(IDX_LCD_V_SIZE);
+    
+    return wValue;
+}
+
+ULONG Get_LCD_SIZE()
+{
+    ULONG dwValue;
+
+    dwValue = (ULONG)Get_LCD_V_SIZE();
+    dwValue <<= 16;
+    dwValue |= (ULONG)Get_LCD_H_SIZE();
+    
+    return dwValue;
+}
+
+USHORT Get_LCD2_H_SIZE()
+{
+    USHORT wValue;
+
+    wValue = (USHORT)ReadScratch(IDX_LCD2_H_SIZE_OVERFLOW);
+    wValue <<= 8;
+    wValue |= (USHORT)ReadScratch(IDX_LCD2_H_SIZE);
+    
+    return wValue;
+}
+
+USHORT Get_LCD2_V_SIZE()
+{
+    USHORT wValue;
+
+    wValue = (USHORT)ReadScratch(IDX_LCD2_V_SIZE_OVERFLOW);
+    wValue <<= 8;
+    wValue |= (USHORT)ReadScratch(IDX_LCD2_V_SIZE);
+    
+    return wValue;
+}
+
+ULONG Get_LCD2_SIZE()
+{
+    ULONG dwValue;
+
+    dwValue = (ULONG)Get_LCD2_V_SIZE();
+    dwValue <<= 16;
+    dwValue |= (ULONG)Get_LCD2_H_SIZE();
+    
+    return dwValue;
+}
+
+UCHAR Get_RRATE_ID(UCHAR DisplayPath)
+{
+    return ((DisplayPath == DISP1) ? ReadScratch(IDX_IGA1_RRATE_ID) : ReadScratch(IDX_IGA2_RRATE_ID));
+}
+
+void Set_RRATE_ID(UCHAR RRateID, UCHAR DisplayPath)
+{
+    if (DisplayPath == DISP1)
+        WriteScratch(IDX_IGA1_RRATE_ID, RRateID);
+    else
+        WriteScratch(IDX_IGA2_RRATE_ID, RRateID);
+}
+
+UCHAR Get_LCD_TABLE_INDEX(void)
+{
+    return ReadScratch(IDX_LCD1_TABLE_INDEX);
+}
+
+UCHAR Get_LCD2_TABLE_INDEX(void)
+{
+    return ReadScratch(IDX_LCD2_TABLE_INDEX);
+}
+
+void Set_LCD_TABLE_INDEX(UCHAR bLCDIndex)
+{
+    WriteScratch(IDX_LCD1_TABLE_INDEX, bLCDIndex);
+}
+
+
+USHORT Get_VESA_MODE(UCHAR DisplayPath)
+{
+    UCHAR VESAMode, VESAModeOver;
+
+    if (DisplayPath == DISP1)
+    {
+        VESAMode = ReadScratch(IDX_IGA1_VESA_MODE);
+        VESAModeOver = ReadScratch(IDX_IGA1_VESA_MODE_OVERFLOW);
+    }
+    else
+    {
+        VESAMode = ReadScratch(IDX_IGA2_VESA_MODE);
+        VESAModeOver = ReadScratch(IDX_IGA2_VESA_MODE_OVERFLOW);
+    }
+    
+    return  ((USHORT)VESAModeOver) << 8 | (USHORT)VESAMode;
+}
+
+void Set_VESA_MODE(USHORT ModeNum, UCHAR DisplayPath)
+{
+    if (DisplayPath == DISP1)
+    {
+        WriteScratch(IDX_IGA1_VESA_MODE, (UCHAR)ModeNum);
+        WriteScratch(IDX_IGA1_VESA_MODE_OVERFLOW, (UCHAR)(ModeNum >> 8));
+    }
+    else
+    {
+        WriteScratch(IDX_IGA2_VESA_MODE, (UCHAR)ModeNum);
+        WriteScratch(IDX_IGA2_VESA_MODE_OVERFLOW, (UCHAR)(ModeNum >> 8));
+    }
+}
+
+void ResetATTR()
+{
+    InPort(COLOR_INPUT_STATUS1_READ);
+    InPort(MONO_INPUT_STATUS1_READ);
+}
+
+void EnableATTR()
+{
+    ResetATTR();
+    OutPort(ATTR_DATA_WRITE, 0x20);
+}
+
+/* Set Cr register value with Mask */
+void SetCRReg(UCHAR bRegIndex, UCHAR bRegValue, UCHAR bMask)
+{
+    UCHAR btemp = 0x0;
+    
+    if(bMask != 0xFF)
+    {
+        OutPort(COLOR_CRTC_INDEX,bRegIndex);
+        btemp = (UCHAR)InPort(COLOR_CRTC_DATA);
+        bRegValue &= bMask;
+        btemp &=~(bMask);
+        btemp |= bRegValue;
+        OutPort(COLOR_CRTC_DATA,btemp);
+    }
+    else
+    {
+        OutPort(COLOR_CRTC_INDEX,bRegIndex);
+        OutPort(COLOR_CRTC_DATA,bRegValue);
+    }
+
+    return;
+}
+
+/* Get Cr register value */
+UCHAR GetCRReg(UCHAR bRegIndex)
+{
+    UCHAR btemp = 0x0;
+    
+    OutPort(COLOR_CRTC_INDEX,bRegIndex);
+    btemp = (UCHAR)InPort(COLOR_CRTC_DATA);
+        
+    return btemp;
+}
+
+/* Set Sr register value with Mask */
+void SetSRReg(UCHAR bRegIndex, UCHAR bRegValue, UCHAR bMask)
+{
+    UCHAR btemp = 0x0;
+    
+    if(bMask != 0xFF)
+    {
+        OutPort(SEQ_INDEX,bRegIndex);
+        btemp = (UCHAR)InPort(SEQ_DATA);
+        bRegValue &= bMask;
+        btemp &=~(bMask);
+        btemp |= bRegValue;
+        OutPort(SEQ_DATA,btemp);
+    }
+    else
+    {
+        OutPort(SEQ_INDEX,bRegIndex);
+        OutPort(SEQ_DATA,bRegValue);
+    }
+
+    return;
+}
+
+/* Get Sr register value */
+UCHAR GetSRReg(UCHAR bRegIndex)
+{
+    UCHAR btemp = 0x0;
+    
+    OutPort(SEQ_INDEX,bRegIndex);
+    btemp = (UCHAR)InPort(SEQ_DATA);
+        
+    return btemp;
+}
+
+void SetARReg(UCHAR index,UCHAR value)
+{
+    OutPort(ATTR_DATA_WRITE,index);
+    OutPort(ATTR_DATA_WRITE,value);
+}
+
+UCHAR GetARReg(UCHAR index)
+{
+    UCHAR bTmp;
+    InPort(COLOR_INPUT_STATUS1_READ);
+    OutPort(ATTR_DATA_WRITE,index);
+    bTmp = (UCHAR)InPort(ATTR_DATA_READ);
+    InPort(COLOR_INPUT_STATUS1_READ);
+    OutPort(ATTR_DATA_WRITE,BIT5);
+    return bTmp;
+}
+
+/* Set Gr register value with Mask */
+void SetGRReg(UCHAR bRegIndex, UCHAR bRegValue, UCHAR bMask)
+{
+    UCHAR btemp = 0x0;
+    
+    if(bMask != 0xFF)
+    {
+        OutPort(GRAPH_INDEX,bRegIndex);
+        btemp = (UCHAR)InPort(GRAPH_DATA);
+        bRegValue &= bMask;
+        btemp &=~(bMask);
+        btemp |= bRegValue;
+        OutPort(GRAPH_DATA,btemp);
+    }
+    else
+    {
+        OutPort(GRAPH_INDEX,bRegIndex);
+        OutPort(GRAPH_DATA,bRegValue);
+    }
+
+    return;
+}
+
+void SetMSReg(UCHAR bRegValue)
+{
+    OutPort(MISC_WRITE,bRegValue);
+}
+
+UCHAR GetIS1Reg()
+{
+    return InPort(COLOR_INPUT_STATUS1_READ);
+}
+
+/* Clear frame buffer */
+void ClearFrameBuffer(UCHAR DisplayPath,ULONG *pFrameBufferBase, MODE_INFO *pModeInfo, UCHAR ucColorDepth)
+{
+    ULONG dwWidth = (ULONG)pModeInfo->H_Size, dwHeight = (ULONG)pModeInfo->V_Size, dwFactor  = 0;
+    ULONG i = 0;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter ClearFrameBuffer()==\n");
+    /* get display1/2 starting address */
+    
+    /* Check the color depth */
+    switch(ucColorDepth)
+    {
+        case 8:
+        case 16:
+        case 32:    
+          dwFactor = 32 / ucColorDepth;
+          break;
+          
+        default:
+            return;
+    }
+
+    /* Clear */
+    for(i = 0;i<((dwWidth*dwHeight)/dwFactor);i++)
+    {
+        *(pFrameBufferBase+i) = 0x00000000;
+    }
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit ClearFrameBuffer()==\n");
+    
+}
+
+ULONG Difference(ULONG Value1, ULONG Value2)
+{
+    if (Value1 > Value2)
+        return (Value1 - Value2);
+    else
+        return (Value2 - Value1);
+}
+
+/*----------------------------------------------------------------------------
+;
+;       ReadScratch()
+;
+;        in: 
+;           Index = scratch index
+;       out:
+;           return = scratch data aligned to LSB
+;       
+;---------------------------------------------------------------------------*/
+UCHAR ReadScratch(USHORT IndexMask)
+{
+    UCHAR Index = (UCHAR)(IndexMask >> 8);
+    UCHAR Mask = (UCHAR)IndexMask;
+    UCHAR RetValue;
+
+    RetValue = GetCRReg(Index);
+    RetValue &= Mask;
+    
+    RetValue = AlignDataToLSB(RetValue, Mask);
+
+    return RetValue;
+}
+
+/*----------------------------------------------------------------------------
+;
+;       WriteScratch()
+;
+;        in: 
+;           Index = scratch index
+;           Data = data to be written
+;       out:
+;           none
+;---------------------------------------------------------------------------*/
+void WriteScratch(USHORT IndexMask, UCHAR Data)
+{
+    UCHAR Index = (UCHAR)(IndexMask >> 8);
+    UCHAR Mask = (UCHAR)IndexMask;
+
+    Data = AlignDataToMask(Data, Mask);
+    Data &= Mask;
+    SetCRReg(Index, Data, Mask);
+}
+
+/*----------------------------------------------------------------------------
+;
+;       AlignDataToLSB()
+;
+;        in: 
+;           Data = data to be aligned
+;           Mask = mask of data
+;       out:
+;           return = aligned data
+;       
+;---------------------------------------------------------------------------*/
+UCHAR AlignDataToLSB(UCHAR bData, UCHAR bMask)
+{
+    bData &= bMask;
+    
+    while ((bMask & BIT0) == 0)
+    {
+        bData >>= 1;
+        bMask >>= 1;
+    }
+    
+    return bData;
+}
+
+/*----------------------------------------------------------------------------
+;
+;       AlignDataToMask()
+;
+;        in: 
+;           Data = data to be aligned
+;           Mask = mask of data
+;       out:
+;           return = aligned data
+;       
+;---------------------------------------------------------------------------*/
+UCHAR AlignDataToMask(UCHAR bData, UCHAR bMask)
+{
+    while ((bMask & BIT0) == 0)
+    {
+        bData <<= 1;
+        bMask >>= 1;
+    }
+    
+    return bData;
+}
+
+/*----------------------------------------------------------------------------
+;
+;       SetDPMS -
+;       Input:
+;           DPMSState =  DPMS_ON, DPMS_STANDBY, DPMS_SUSPEND, DPMS_OFF
+;           DisplayPath
+;       Output:
+;           none
+;
+;---------------------------------------------------------------------------*/
+void SetDPMS(UCHAR DPMSState, UCHAR DisplayPath)
+{
+    UCHAR RegValue;
+
+    if (DPMSState > DPMS__OFF)
+        RegValue = 3;
+    else if (DPMSState <= DPMS__SUSPEND)
+        RegValue = DPMSState;
+        
+    if (DisplayPath == DISP1)
+        SetCRReg(0xB6, RegValue, BIT1+BIT0);
+    else if (DisplayPath == DISP2)
+        SetCRReg(0x3E, RegValue, BIT1+BIT0);
+
+}
+/*----------------------------------------------------------------------------
+;
+;       DetectMonitor()
+;
+;        in: 
+;           none
+;       out:
+;           return = true if CRT connected
+;       
+;---------------------------------------------------------------------------*/
+CI_STATUS DetectMonitor()
+{
+    CI_STATUS ConnectStatus;
+
+    /* CRA9 = sense data = 0x80 */
+    SetCRReg(0xA9, 0x80, 0xFF);
+
+    /* CRA8[6] = 1, start DAC sense */
+    SetCRReg(0xA8, BIT6, BIT6);
+
+    /* wait H sync */
+    WaitDisplayPeriod();
+
+    /* ISR0[4] = 1, CRT attached */
+    ConnectStatus = ((InPort(INPUT_STATUS_0_READ) & BIT4) ? true : false);
+
+    SetCRReg(0xA8, 0x00, BIT6);
+
+    return ConnectStatus;
+}
+/*----------------------------------------------------------------------------
+;
+;       WaitDisplayPeriod() - wait H sync of display1
+;
+;        in: 
+;           none
+;       out:
+;           none
+;       
+;---------------------------------------------------------------------------*/
+void WaitDisplayPeriod()
+{
+     while ((InPort(COLOR_INPUT_STATUS1_READ)&BIT0) == 1);
+     
+     while ((InPort(COLOR_INPUT_STATUS1_READ)&BIT0) == 0);
+}
+
+/*----------------------------------------------------------------------------
+;
+;       WaitPowerSequenceDone() - SR32[2] = 1, power sequence on complete
+;                                         = 0, power sequence off complete
+;
+;       Input:
+;           none
+;       Output:
+;           none
+;
+;---------------------------------------------------------------------------*/
+void WaitPowerSequenceDone()
+{
+    UCHAR SR32;
+     
+    SR32 = GetSRReg(0x32);
+
+    /* loop while power sequence status not changed */
+    while(SR32 == GetSRReg(0x32));
+}
+/*--------------------------------------------------------------------
+;
+;       CheckForDSTNPanel() -
+;
+;   Input:
+;       bDeviceIndex = device index
+;   return:
+;       true if device is DSTN panel
+;
+;--------------------------------------------------------------------*/
+CI_STATUS CheckForDSTNPanel(UCHAR bDeviceIndex)
+{
+    PORT_CONFIG *pDevicePortConfig;
+    
+    if (GetDevicePortConfig(bDeviceIndex, &pDevicePortConfig))
+    {
+        if ((pDevicePortConfig->TX_Enc_ID == DSTN) && 
+            ((pDevicePortConfig->PortID == DVP1) || (pDevicePortConfig->PortID == DVP12)))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else
+    {
+        return false;
+    }
+}
+/*-------------------------------------------------------------------
+;
+;       GetVESAMEMSize()
+;   Input:
+;       none
+;   Output:
+;       return VESA Memory Size (Unit: MB)
+;
+;------------------------------------------------------------------*/
+USHORT GetVESAMEMSize()
+{
+    UCHAR bHWStrapping;
+    bHWStrapping = (GetCRReg(0xAA) & (BIT2+BIT1+BIT0));
+    
+    return (2 << (bHWStrapping+3));
+}
+
+void SetDeviceSupport()
+{
+    PORT_CONFIG *pDevicePortConfig = pPortConfig;
+    
+    if (GetDevicePortConfig(CRT_ID, &pDevicePortConfig))
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "CRT supported\n");
+        bCRTSUPPORT = true;
+    }
+    
+    if (GetDevicePortConfig(LCD_ID, &pDevicePortConfig))
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "LCD supported\n");
+        bLCDSUPPORT = true;
+    }
+
+    if (GetDevicePortConfig(DVI_ID, &pDevicePortConfig))
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "DVI supported\n");
+        bDVISUPPORT = true;
+    }
+    
+    if (GetDevicePortConfig(TV_ID, &pDevicePortConfig))
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "TV supported\n");
+        bTVSUPPORT = true;
+    }
+}
+
+CI_STATUS VBE_SetMode(CBIOS_Extension *pCBIOSExtension)
+{
+    USHORT    wModeNum = pCBIOSExtension->pCBiosArguments->reg.x.BX & 0x01FF;
+    USHORT    wPitch = 0;
+    MODE_INFO   *pModeInfo = NULL;
+    UCHAR    bColorDepth = 0;
+    UCHAR    bCurDeviceID, bNewDeviceID;
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry VBE_SetMode Mode number 0x%x== \n",wModeNum);
+#endif
+    if (wModeNum < 0x100)
+    {
+        SetVBERerurnStatus(VBEFunctionCallFail, pCBIOSExtension->pCBiosArguments);
+        return true;
+    }
+
+    bCurDeviceID = Get_DEV_ID(DISP1);
+    bNewDeviceID = Get_NEW_DEV_ID(DISP1);
+
+    if(!Get_MODE_INFO(wModeNum, &pModeInfo))
+    {
+        SetVBERerurnStatus(VBEFunctionCallFail, pCBIOSExtension->pCBiosArguments);
+    #if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 VBE_SetMode return 0x%x== \n",VBEFunctionCallFail);
+    #endif
+        return true;
+    }
+    /* update mode no */
+    Set_VESA_MODE(wModeNum, DISP1);
+    
+    /* cut data */
+    SequencerOff(DISP1);
+
+    /* disable scaler */
+    TurnOffScaler(DISP1);
+    
+    if (bCurDeviceID != bNewDeviceID)
+    {
+        /* control power sequence off */
+        ControlPwrSeqOff(bCurDeviceID);
+
+        /* turn off TX if necessary */
+
+        /* turn off digital port */
+        TurnOffDigitalPort(bCurDeviceID);
+
+        /* update scratch IDX_IGA1_DEV_ID */
+        Set_DEV_ID(bNewDeviceID, DISP1);
+    }
+
+    /* update BDA? */
+
+    /* load Display1 VESA Mode init registers */
+    LoadDisplay1VESAModeInitRegs();
+
+    /* load timing on display1 */
+    LoadTiming(DISP1, wModeNum);
+
+    /* set pitch */
+    GetModePitch(wModeNum, &wPitch);
+    SetPitch(DISP1, wPitch);
+
+    /* set color depth */
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, " /* set color depth */\n");
+    Get_MODE_INFO(wModeNum, &pModeInfo);
+    GetModeColorDepth(wModeNum, pModeInfo, &bColorDepth);
+    SetColorDepth(DISP1, bColorDepth);
+
+    /* load font */
+
+    /* load LUT */
+
+    /* clear FB */
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, " /* clear FB */\n");
+    if(!(pCBIOSExtension->pCBiosArguments->reg.x.BX & BIT15))
+    {
+        ClearFrameBuffer(DISP1,(ULONG*)(pCBIOSExtension->VideoVirtualAddress),pModeInfo,bColorDepth);
+    }
+
+    /* set FIFO */
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, " /* set FIFO */\n");
+    SetFIFO(DISP1);
+
+    /* config digital port */
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, " /* config difital port */\n");
+    ConfigDigitalPort(DISP1);
+
+    TurnOnDigitalPort(bNewDeviceID);
+
+    /* Turu on TX */
+
+    /* turn on power sequence if necessary */
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, " /* turn on power sequence if necessary */\n");
+    ControlPwrSeqOn(bNewDeviceID);
+
+    /* turn on sequencer */
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, " /* turn on sequencer */\n");
+    SequencerOn(DISP1);
+    
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBIOSExtension->pCBiosArguments);
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 VBE_SetMode return 0x%x== \n",VBEFunctionCallSuccessful);
+#endif
+    return true;
+}
+/*-------------------------------------------------------------------
+;
+;       VBE_SetGetScanLineLength()
+;
+;   Input1: set/get display2 pitch
+;       pCBiosArguments->AX = 0x4F06
+;                        BL = 0x00: Set Scan Line Length in Pixels
+;                             0x01: Get Scan Line Length
+;                             0x02: Set Scan Line Length in Bytes
+;                             0x03: Get Maximum Scan Line Length
+;                        CX = Desired Width in Pixels if BL = 00
+;                             Desired Width in Bytes if BL = 02
+;
+;   Input2: set/get display2 pitch
+;       pCBiosArguments->AX = 0x4F14
+;                        BL = 0x00: Set Scan Line Length in Pixels
+;                             0x01: Get Scan Line Length
+;                             0x02: Set Scan Line in Bytes
+;                             0x03: Get Maximum Scan Line Length
+;                        CX = Desired Width in Pixels if BL = 00
+;                             Desired Width in Bytes if BL = 02
+;
+;   Output:
+;       pCBiosArguments->AX = VBE Return Status 
+;                        BX = Bytes Per Scan Line
+;                        CX = Actual Pixels Pet Scan Line (truncated to nearest complete pixel)
+;                        DX = Maximum Number of Scan Lines 
+;
+;------------------------------------------------------------------*/
+CI_STATUS VBE_SetGetScanLineLength (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    USHORT    wModeNum;
+    MODE_INFO   *pModeInfo = NULL;
+    UCHAR    bColorDepth;
+    UCHAR    bDispalyPath;
+    ULONG   dwVESAMemSizeInBytes;
+    USHORT    wMaxPitchInBytes, wCurrentVDispEnd;
+    USHORT    VBEReturnStatus = VBEFunctionCallFail;
+    USHORT    wPitchToBeSet = pCBiosArguments->reg.x.CX; /* maybe in pixel or in byte */
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry VBE_SetGetScanLineLength== \n");
+#endif
+    if (pCBiosArguments->reg.x.AX == 0x4f06)
+    {
+        bDispalyPath = DISP1;
+    }
+    else if ((pCBiosArguments->reg.x.AX == 0x4f14) && ((pCBiosArguments->reg.lh.BH == 0x87)||(pCBiosArguments->reg.lh.BH == 0x08)))
+    {
+        bDispalyPath = DISP2;
+    }
+    else
+    {
+        SetVBERerurnStatus(VBEFunctionCallFail, pCBiosArguments);
+    #if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 VBE_SetGetScanLineLength return 0x%x== \n",VBEFunctionCallFail);
+    #endif
+        return true;
+    }
+    
+    if (pCBiosArguments->reg.lh.BL <=3)
+    {
+        wModeNum = Get_VESA_MODE(bDispalyPath);
+        
+        Get_MODE_INFO(wModeNum, &pModeInfo);
+        
+        if (GetModeColorDepth(wModeNum, pModeInfo, &bColorDepth))
+        {
+            VBEReturnStatus = VBEFunctionCallNotSupported;
+
+            dwVESAMemSizeInBytes = ((ULONG)GetVESAMEMSize()) << 20;
+            
+            wCurrentVDispEnd = GetVDisplayEnd(bDispalyPath);
+            
+            /* align pitch to 8-byte */
+            if (((ULONG)(dwVESAMemSizeInBytes / (ULONG)wCurrentVDispEnd) & 0xFFFF0000) == 0)
+            {
+                wMaxPitchInBytes = (USHORT)(dwVESAMemSizeInBytes / (ULONG)wCurrentVDispEnd) & 0xFFF8;
+            }
+            else
+            {
+                wMaxPitchInBytes = 0xFFF8;
+            }
+        #if CBIOS_DEBUG
+            xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==VBE_SetGetScanLineLength Color Depth = 0x%x== \n",bColorDepth);
+            xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==VBE_SetGetScanLineLength Mem Size = 0x%x== \n",dwVESAMemSizeInBytes);
+            xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==VBE_SetGetScanLineLength Current Disp End = 0x%x== \n",wCurrentVDispEnd);
+            xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==VBE_SetGetScanLineLength Max Pitch = 0x%x== \n",wMaxPitchInBytes);
+        #endif
+            if ((pCBiosArguments->reg.lh.BL == 0) || (pCBiosArguments->reg.lh.BL == 2))
+            {
+                if (pCBiosArguments->reg.lh.BL == 0)
+                {
+                    /* transform pitch size from pixels to bytes */
+                    wPitchToBeSet <<= (bColorDepth >> 4);
+                }
+                
+                if (wPitchToBeSet <= wMaxPitchInBytes)
+                {
+                    SetPitch(bDispalyPath, wPitchToBeSet);
+                }
+                else
+                {
+                    SetVBERerurnStatus(VBEReturnStatus, pCBiosArguments);
+                    return true;
+                }
+            }
+
+            if (pCBiosArguments->reg.lh.BL == 3)
+            {
+                /* get maximum pitch in bytes */
+                pCBiosArguments->reg.x.BX = wMaxPitchInBytes;
+            }
+            else
+            {
+                /* get current pitch in bytes */
+                pCBiosArguments->reg.x.BX =GetPitch(bDispalyPath);
+            }
+
+            /* get current pitch in pixels */
+            
+            pCBiosArguments->reg.x.CX = pCBiosArguments->reg.x.BX >> (bColorDepth >> 4);
+            pCBiosArguments->reg.x.DX = (dwVESAMemSizeInBytes / (USHORT)pCBiosArguments->reg.x.BX);
+        }
+    }
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 VBE_SetGetScanLineLength return 0x%x== \n",VBEReturnStatus);
+#endif
+    SetVBERerurnStatus(VBEReturnStatus, pCBiosArguments);
+    return true;
+}
+
+CI_STATUS OEM_QueryBiosInfo (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    USHORT    VBEReturnStatus = VBEFunctionCallFail;
+
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_QueryBiosInfo()== \n");
+#endif
+
+    /* bx[15:0] = version number */
+
+    /*-------------------EBX PART--------------------;
+    ;                                                ;
+    ;[31:24] : Branch version number
+    ;[23:8]  : Customer Index
+    ;[7:0]   : Release version number
+    */
+
+
+    /*-------------------ECX PART--------------------;
+    ;                                                ;
+    ; [31:18] : Reserved
+    ; [17:16] : DRAM bus width
+    ;           00 : 16bit
+    ;           01 : 32bit
+    ;           10 : 64bit
+    ;           11 : reserved
+    ; [15:4]  : memory size in 256k unit
+    ; [3:0]   : Memory data rate
+    ;          000 : DDR333
+    ;          001 : DDR400
+    ;          010 : DDR533
+    ;          011 : DDR667
+    ;          100 : DDR800
+    ;          xxx : Reserved
+    */
+
+
+    /*-------------------EDX PART--------------------;
+    ;                                                ;
+    ;        VGA BIOS Build TIME                     ;
+    ;[31:16] : Year
+    ;[15: 8] : Month
+    ;[ 7: 0] : Day
+    */
+
+
+
+    /*-------------------SI PART--------------------;
+    ;                                               ;
+    ; SI = supported device
+    */
+    pCBiosArguments->reg.x.SI = 0;
+    if(bCRTSUPPORT)
+    {
+        pCBiosArguments->reg.x.SI |= B_CRT;
+    }
+    if(bLCDSUPPORT)
+    {
+        pCBiosArguments->reg.x.SI |= B_LCD;
+    }
+    if(bTVSUPPORT)
+    {
+        pCBiosArguments->reg.x.SI |= B_TV;
+    }
+    if(bDVISUPPORT)
+    {
+        pCBiosArguments->reg.x.SI |= B_DVI;
+    }
+    
+    /*-------------------EAX PART--------------------;
+    ;                                                ;
+    */
+
+    VBEReturnStatus = VBEFunctionCallSuccessful;
+    SetVBERerurnStatus(VBEReturnStatus, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_QueryBiosInfo()== \n");
+#endif
+    return true;
+}
+CI_STATUS OEM_QueryBiosCaps (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    /* VBIOS not implemented */
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_QueryBiosCaps()== \n");
+#endif
+
+
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_QueryBiosCaps()== \n");
+#endif
+    return true;
+}
+
+CI_STATUS OEM_QueryExternalDeviceInfo (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_QueryExternalDeviceInfo()== \n");
+#endif
+
+    pCBiosArguments->reg.lh.BL = ReadScratch(IDX_SCRATCH_20);
+    pCBiosArguments->reg.ex.EBX <<= 16;
+
+    pCBiosArguments->reg.lh.BH = ReadScratch(IDX_SCRATCH_21);
+
+    pCBiosArguments->reg.lh.BL = ReadScratch(IDX_SCRATCH_22);
+
+    pCBiosArguments->reg.ex.ECX = BIT16;
+
+    pCBiosArguments->reg.x.DX = 0xFFFF;
+
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_QueryExternalDeviceInfo()== \n");
+#endif
+    return true;
+}
+
+CI_STATUS OEM_QueryDisplayPathInfo (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    UCHAR ScratchTempData;
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_QueryDisplayPathInfo()== \n");
+#endif
+    pCBiosArguments->reg.ex.EBX = 0;
+
+    pCBiosArguments->reg.lh.BL |= Get_NEW_DEV_ID(DISP1);
+
+    pCBiosArguments->reg.ex.EBX <<= 2;
+    ScratchTempData = GetSRReg(0x58);               /* First Display scaling control */
+    if (ScratchTempData & BIT0)
+    {
+        ScratchTempData &= (BIT2 + BIT1);             /* reserve H and V scaling control bits */
+        ScratchTempData >>= 1;
+        pCBiosArguments->reg.lh.BL |= ScratchTempData;
+    }
+    
+    pCBiosArguments->reg.ex.EBX <<= 4;
+    pCBiosArguments->reg.lh.BL |= Get_DEV_ID(DISP1);
+
+    pCBiosArguments->reg.ex.EBX <<= 7;
+    pCBiosArguments->reg.lh.BL |= Get_RRATE_ID(DISP1);
+    
+    pCBiosArguments->reg.ex.EBX <<= 9;   
+    pCBiosArguments->reg.x.BX |= Get_VESA_MODE(DISP1);
+    
+
+    pCBiosArguments->reg.ex.ECX = 0;
+
+    pCBiosArguments->reg.lh.CL |= Get_NEW_DEV_ID(DISP1);
+
+    pCBiosArguments->reg.ex.ECX <<= 2;
+    ScratchTempData = GetSRReg(0x50);               /* Second Display scaling control */
+    if (ScratchTempData & BIT0)
+    {
+        ScratchTempData &= (BIT2 + BIT1);             /* reserve H and V scaling control bits */
+        ScratchTempData >>= 1;
+        pCBiosArguments->reg.lh.BL |= ScratchTempData;
+    }
+    
+    pCBiosArguments->reg.ex.ECX <<= 4;
+    pCBiosArguments->reg.lh.CL |= Get_DEV_ID(DISP2);
+
+    pCBiosArguments->reg.ex.ECX <<= 7;
+    pCBiosArguments->reg.lh.CL |= Get_RRATE_ID(DISP2);
+    
+    pCBiosArguments->reg.ex.ECX <<= 9;   
+    pCBiosArguments->reg.x.CX |= Get_VESA_MODE(DISP2);
+    
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_QueryDisplayPathInfo()== \n");
+#endif
+    return true;
+
+}
+
+CI_STATUS OEM_QueryDeviceConnectStatus (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    UCHAR *pucPCIDataStruct = (UCHAR*)PCIDataStruct;
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_QueryDeviceConnectStatus()== \n");
+#endif
+    pCBiosArguments->reg.x.BX = 0;
+    
+    if (*(USHORT*)(pucPCIDataStruct + OFF_DID) == 0x2010)
+    {
+        if (GetSRReg(0x3c) & BIT0)
+        {
+            pCBiosArguments->reg.x.BX |= B_CRT;   
+        }
+    }
+    else
+    {
+        /* Detect Monitor From EDID */
+    }
+    
+    if (bLCDSUPPORT)
+    {
+        pCBiosArguments->reg.x.BX |= B_LCD;   
+    }
+
+    if (bDVISUPPORT)
+    {
+        if (*(USHORT*)(((UCHAR*)PCIDataStruct) + OFF_DID) == 0x2010)
+        {
+            if (GetSRReg(0x3c) & BIT1)
+            {
+                pCBiosArguments->reg.x.BX |= B_DVI;   
+            }
+        }
+        else
+        {
+            /* Query DVI Connect Status */
+        }
+    }
+
+    if (bTVSUPPORT)
+    {
+        /* TV DAC Sense */
+    }
+    
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_QueryDeviceConnectStatus()== \n");
+#endif
+    return true;
+}
+
+CI_STATUS OEM_QuerySupportedMode (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    MODE_INFO   *pModeInfo;
+    RRATE_TABLE *pRRateTable;
+    int RRateTableIndex = 0;
+    int ModeNumIndex;
+    USHORT wModeNum;
+    USHORT wSerialNumber;
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter OEM_QuerySupportedMode()== \n");
+#endif
+    wSerialNumber = pCBiosArguments->reg.x.CX;
+    pModeInfo     = (MODE_INFO*)pVESATable;
+    
+    while (pModeInfo->H_Size != 0xFFFF)
+    {
+#if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->H_Size = %d \n", pModeInfo->H_Size);
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->V_Size = %d \n", pModeInfo->V_Size);
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "sizeof(RRATE_TABLE) = %d \n", sizeof(RRATE_TABLE));
+#endif
+        for (ModeNumIndex = 0; ModeNumIndex < 3; ModeNumIndex++)
+        {
+            switch (ModeNumIndex)
+            {
+                case 0:
+                    wModeNum = pModeInfo->Mode_ID_8bpp;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "case 0: wModeNum = 0x%x \n", wModeNum);
+                    break;
+                case 1:
+                    wModeNum = pModeInfo->Mode_ID_16bpp;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "case 1: wModeNum = 0x%x \n", wModeNum);
+                    break;
+                case 2:
+                    wModeNum = pModeInfo->Mode_ID_32bpp;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "case 2: wModeNum = 0x%x \n", wModeNum);
+                    break;
+            }
+
+            pRRateTable = (RRATE_TABLE*)((int)pModeInfo + sizeof(MODE_INFO));
+
+            for (RRateTableIndex = 0; RRateTableIndex < pModeInfo->RRTableCount; RRateTableIndex++, pRRateTable++)
+            {
+
+                xf86DrvMsgVerb(0, X_INFO, 5, "pRRateTable = 0x%x \n", pRRateTable);
+
+                if ((pRRateTable->Attribute & DISABLE) == 0)
+                {
+                    if (wSerialNumber == 0)
+                    {
+                        /* BX = VESA mode number */
+                        pCBiosArguments->reg.x.BX = wModeNum;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "mode num = 0x%x \n", pCBiosArguments->reg.x.BX);
+
+                        /* CL = Color depth */
+                        GetModeColorDepth(wModeNum, pModeInfo, &pCBiosArguments->reg.lh.CL);
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "color depth = %d \n", pCBiosArguments->reg.lh.CL);
+                        
+                        /* CH = Refresh rate index */
+                        pCBiosArguments->reg.lh.CH = pRRateTable->RRate_ID;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "RRate ID = %d \n", pCBiosArguments->reg.lh.CH);
+                        
+                        /* EDX = mode resolution */
+                        pCBiosArguments->reg.ex.EDX = (((ULONG)pModeInfo->V_Size) << 16) | (ULONG)pModeInfo->H_Size;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "H x V = %d x %d \n", pCBiosArguments->reg.x.DX, pCBiosArguments->reg.ex.EDX>>16);
+                        
+                        /* ESI = attribute */
+                        pCBiosArguments->reg.x.SI = pRRateTable->Attribute;
+                        
+                        /* EDI = pixel clock */
+                        pCBiosArguments->reg.ex.EDI = pRRateTable->Clock;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "dot clk = %dkhz \n", pCBiosArguments->reg.ex.EDI);
+
+                        SetVBERerurnStatus (VBEFunctionCallSuccessful, pCBiosArguments);
+
+                    #if CBIOS_DEBUG
+                        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 OEM_QuerySupportedMode() return 0x%x== \n", VBEFunctionCallSuccessful);
+                    #endif
+                        return true;
+                    }
+                    else
+                    {
+                        wSerialNumber--;
+                    }
+                }
+            }
+        }
+        pModeInfo = (MODE_INFO*)((int)pModeInfo + sizeof(MODE_INFO) + pModeInfo->RRTableCount*sizeof(RRATE_TABLE));
+    }
+
+    pModeInfo = (MODE_INFO*)(&CInt10VESATable);
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "*pModeInfo = %X \n", *pModeInfo);
+    
+    while (pModeInfo->H_Size != 0xFFFF)
+    {
+#if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->H_Size = %d \n", pModeInfo->H_Size);
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "pModeInfo->V_Size = %d \n", pModeInfo->V_Size);
+        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "sizeof(RRATE_TABLE) = %d \n", sizeof(RRATE_TABLE));
+#endif
+        for (ModeNumIndex = 0; ModeNumIndex < 3; ModeNumIndex++)
+        {
+            switch (ModeNumIndex)
+            {
+                case 0:
+                    wModeNum = pModeInfo->Mode_ID_8bpp;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "case 0: wModeNum = 0x%x \n", wModeNum);
+                    break;
+                case 1:
+                    wModeNum = pModeInfo->Mode_ID_16bpp;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "case 1: wModeNum = 0x%x \n", wModeNum);
+                    break;
+                case 2:
+                    wModeNum = pModeInfo->Mode_ID_32bpp;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "case 2: wModeNum = 0x%x \n", wModeNum);
+                    break;
+            }
+
+            pRRateTable = (RRATE_TABLE*)((int)pModeInfo + sizeof(MODE_INFO));
+
+            for (RRateTableIndex = 0; RRateTableIndex < pModeInfo->RRTableCount; RRateTableIndex++, pRRateTable++)
+            {
+
+                xf86DrvMsgVerb(0, X_INFO, 5, "pRRateTable = 0x%x \n", pRRateTable);
+
+                if ((pRRateTable->Attribute & DISABLE) == 0)
+                {
+                    if (wSerialNumber == 0)
+                    {
+                        /* BX = VESA mode number */
+                        pCBiosArguments->reg.x.BX = wModeNum;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "mode num = 0x%x \n", pCBiosArguments->reg.x.BX);
+
+                        /* CL = Color depth */
+                        GetModeColorDepth(wModeNum, pModeInfo, &pCBiosArguments->reg.lh.CL);
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "color depth = %d \n", pCBiosArguments->reg.lh.CL);
+                        
+                        /* CH = Refresh rate index */
+                        pCBiosArguments->reg.lh.CH = pRRateTable->RRate_ID;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "RRate ID = %d \n", pCBiosArguments->reg.lh.CH);
+                        
+                        /* EDX = mode resolution */
+                        pCBiosArguments->reg.ex.EDX = (((ULONG)pModeInfo->V_Size) << 16) | (ULONG)pModeInfo->H_Size;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "H x V = %d x %d \n", pCBiosArguments->reg.x.DX, pCBiosArguments->reg.ex.EDX>>16);
+                        
+                        /* ESI = attribute */
+                        pCBiosArguments->reg.x.SI = pRRateTable->Attribute;
+                        
+                        /* EDI = pixel clock */
+                        pCBiosArguments->reg.ex.EDI = pRRateTable->Clock;
+                        xf86DrvMsgVerb(0, X_INFO, InternalLevel, "dot clk = %dkhz \n", pCBiosArguments->reg.ex.EDI);
+
+                        SetVBERerurnStatus (VBEFunctionCallSuccessful, pCBiosArguments);
+
+                    #if CBIOS_DEBUG
+                        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit1 OEM_QuerySupportedMode() return 0x%x== \n", VBEFunctionCallSuccessful);
+                    #endif
+                        return true;
+                    }
+                    else
+                    {
+                        wSerialNumber--;
+                    }
+                }
+            }
+        }
+        pModeInfo = (MODE_INFO*)((int)pModeInfo + sizeof(MODE_INFO) + pModeInfo->RRTableCount*sizeof(RRATE_TABLE));
+    }        
+
+    SetVBERerurnStatus (VBEFunctionCallFail, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "  Exit2 OEM_QuerySupportedMode() return 0x%x== \n", VBEFunctionCallFail);
+#endif    
+    return true;
+
+}
+
+CI_STATUS OEM_QueryLCDPanelSizeMode (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    MODE_INFO   *pModeInfo;
+    PANEL_TABLE *pPanelTable;
+    UCHAR        bColorDepth = pCBiosArguments->reg.lh.CL;
+    USHORT        wModeNum;
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter OEM_QueryLCDPanelSizeMode()== \n");
+#endif
+
+    SetVBERerurnStatus (VBEFunctionCallFail, pCBiosArguments);
+    
+    if (!bLCDSUPPORT)
+        return true;
+        
+    if (!GetModePointerFromLCDTable(LCD_ID, &pModeInfo, &pPanelTable))
+        return true;
+
+    switch (bColorDepth)
+    {
+        case 0:
+            wModeNum = pModeInfo->Mode_ID_8bpp;
+            pCBiosArguments->reg.lh.CL = 8;
+            break;
+        case 1:
+            wModeNum = pModeInfo->Mode_ID_16bpp;
+            pCBiosArguments->reg.lh.CL = 16;
+            break;
+        case 2:
+            wModeNum = pModeInfo->Mode_ID_32bpp;
+            pCBiosArguments->reg.lh.CL = 32;
+            break;
+        default:
+            SetVBERerurnStatus (VBEFunctionCallFail, pCBiosArguments);
+#if CBIOS_DEBUG
+            xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 OEM_QueryLCDPanelSizeMode() return 0x%x== \n", VBEFunctionCallFail);
+#endif    
+            return true;
+    }
+        
+    /* BX = VESA mode number */
+    pCBiosArguments->reg.x.BX = wModeNum;
+    
+    /* CH = Refresh rate index */
+    pCBiosArguments->reg.lh.CH = pPanelTable->Timing.RRate_ID;
+    
+    /* EDX = mode resolution */
+    pCBiosArguments->reg.ex.EDX = (ULONG)pModeInfo->H_Size  | ((ULONG)pModeInfo->V_Size) << 16;
+    
+    /* SI = attribute */
+    pCBiosArguments->reg.x.SI = pPanelTable->Timing.Attribute;
+    
+    /* EDI = pixel clock */
+    pCBiosArguments->reg.ex.EDI = pPanelTable->Timing.Clock;
+    
+    SetVBERerurnStatus (VBEFunctionCallSuccessful, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 OEM_QueryLCDPanelSizeMode() return 0x%x== \n", VBEFunctionCallSuccessful);
+#endif
+    return true;
+}
+
+CI_STATUS OEM_QueryLCDPWMLevel(CBIOS_ARGUMENTS *pCBiosArguments)
+{
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_QueryLCDPWMLevel()== \n");
+#endif
+    SetVBERerurnStatus (VBEFunctionCallFail, pCBiosArguments);
+    
+    if (!bLCDSUPPORT)
+        return true;
+
+    if ((GetSRReg(0x30)&0x03) == 0x03 )
+        pCBiosArguments->reg.lh.BL = GetSRReg(0x30);
+    else
+        pCBiosArguments->reg.lh.BL = 0;
+        
+    SetVBERerurnStatus (VBEFunctionCallSuccessful, pCBiosArguments);
+    
+    return true;
+}
+
+CI_STATUS OEM_QueryTVConfiguration (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_QueryTV2Configuration (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_QueryHDTVConfiguration (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_QueryHDTV2Configuration (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_QueryHDMIConfiguration (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_QueryHDMI2Configuration (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetActiveDisplayDevice (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    UCHAR bDeviceIndex1 = Get_DEV_ID(DISP1);
+    UCHAR bDeviceIndex2 = Get_DEV_ID(DISP2);
+    UCHAR bNewDeviceIndex1 = pCBiosArguments->reg.lh.CL & 0x0F;
+    UCHAR bNewDeviceIndex2 = (pCBiosArguments->reg.lh.CL >> 4) & 0x0F;
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_SetActiveDisplayDevice()== \n");
+#endif
+
+    /* check if new device is available */
+    if ((!CheckForNewDeviceAvailable(bNewDeviceIndex1)&& (bNewDeviceIndex1!=0)) || (!CheckForNewDeviceAvailable(bNewDeviceIndex2)&& (bNewDeviceIndex2!=0)))
+    {
+        SetVBERerurnStatus(VBEFunctionCallFail, pCBiosArguments);
+    #if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 OEM_SetActiveDisplayDevice() return 0x%x== \n", VBEFunctionCallFail);
+    #endif
+        return true;
+    }
+    
+    if(CheckForDSTNPanel(bNewDeviceIndex1) || CheckForDSTNPanel(bNewDeviceIndex2))
+    {
+        bNewDeviceIndex1 = 0;
+    }
+
+    if (bDeviceIndex1 != bNewDeviceIndex1)
+    {
+        if (bNewDeviceIndex1 == 0)
+        {
+            DisableDisplayPathAndDevice(DISP1);
+            Set_DEV_ID(bNewDeviceIndex1, DISP1);
+        }
+        Set_NEW_DEV_ID(bNewDeviceIndex1, DISP1);
+    }
+
+    if (bDeviceIndex2 != bNewDeviceIndex2)
+    {
+        if (bNewDeviceIndex2 == 0)
+        {
+            DisableDisplayPathAndDevice(DISP2);
+            Set_DEV_ID(bNewDeviceIndex2, DISP2);
+        }
+        Set_NEW_DEV_ID(bNewDeviceIndex2, DISP2);
+    }
+
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBiosArguments);
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 OEM_SetActiveDisplayDevice() return 0x%x== \n", VBEFunctionCallSuccessful);
+#endif
+    return true;
+}
+CI_STATUS OEM_SetVESAModeForDisplay2 (CBIOS_Extension *pCBIOSExtension)
+{
+    USHORT    wModeNum = pCBIOSExtension->pCBiosArguments->reg.x.CX & 0x01FF;
+    USHORT    wPitch = 0;
+    MODE_INFO   *pModeInfo = NULL;
+    UCHAR    bColorDepth = 0;
+    UCHAR    bCurDeviceID, bNewDeviceID;
+
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_SetVESAModeForDisplay2()== \n");
+#endif
+
+    if (wModeNum < 0x100)
+    {
+        SetVBERerurnStatus(VBEFunctionCallFail, pCBIOSExtension->pCBiosArguments);
+    #if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 OEM_SetVESAModeForDisplay2() return 0x%x== \n", VBEFunctionCallFail);
+    #endif
+        return true;
+    }
+    
+    bCurDeviceID = Get_DEV_ID(DISP2);
+    bNewDeviceID = Get_NEW_DEV_ID(DISP2);
+
+    /* check if mode is supported no matter which device is preferred */
+    if(!Get_MODE_INFO(wModeNum, &pModeInfo))
+    {
+        SetVBERerurnStatus(VBEFunctionCallFail, pCBIOSExtension->pCBiosArguments);
+    #if CBIOS_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 OEM_SetVESAModeForDisplay2() return 0x%x== \n", VBEFunctionCallFail);
+    #endif
+        return true;
+    }
+    /* update mode no */
+    Set_VESA_MODE(wModeNum, DISP2);
+    
+    /* cut data */
+    SequencerOff(DISP2);
+
+    /* disable scaler */
+    TurnOffScaler(DISP2);
+
+    if (bCurDeviceID != bNewDeviceID)
+    {
+        /* control power sequence off */
+        ControlPwrSeqOff(bCurDeviceID);
+
+        /* turn off TX if necessary */
+
+        /* turn off digital port */
+        TurnOffDigitalPort(bCurDeviceID);
+
+        /* update scratch IDX_IGA2_DEV_ID */
+        Set_DEV_ID(bNewDeviceID, DISP2);
+    }
+    
+    /* load Display2 VESA Mode init registers??*/
+    
+    /* load timing on display2 */
+    LoadTiming(DISP2, wModeNum);
+
+    /* set pitch */
+    GetModePitch(wModeNum, &wPitch);
+    SetPitch(DISP2, wPitch);
+
+    /* set color depth */
+    Get_MODE_INFO(wModeNum, &pModeInfo);
+    GetModeColorDepth(wModeNum, pModeInfo, &bColorDepth);
+    SetColorDepth(DISP2, bColorDepth);
+
+    /* load font */
+
+    /* load LUT */
+
+    /* clear FB */
+    if(!(pCBIOSExtension->pCBiosArguments->reg.x.CX & BIT15))
+    {
+        ClearFrameBuffer(DISP2,(ULONG*)(pCBIOSExtension->VideoVirtualAddress),pModeInfo,bColorDepth);
+    }
+
+    /* set FIFO */
+    SetFIFO(DISP2);
+
+    /* config digital port */
+    ConfigDigitalPort(DISP2);
+
+    TurnOnDigitalPort(bNewDeviceID);
+
+    /* Turu on TX */
+
+    /* turn on power sequence if necessary */
+    ControlPwrSeqOn(bNewDeviceID);
+    
+    SequencerOn(DISP2);
+    
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBIOSExtension->pCBiosArguments);
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit3 OEM_SetVESAModeForDisplay2() return 0x%x== \n", VBEFunctionCallSuccessful);
+#endif
+    return true;
+}
+
+CI_STATUS OEM_SetDevicePowerState (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    UCHAR display1DeviceID, display2DeviceID, TargetDevice, DMPSState;
+    USHORT VBEReturnStatus = VBEFunctionCallFail;
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_SetDevicePowerState()== \n");
+#endif
+
+    TargetDevice = pCBiosArguments->reg.lh.CL & 0x0F;
+    DMPSState = pCBiosArguments->reg.lh.CL & (BIT1+BIT0);
+    display1DeviceID = Get_DEV_ID(DISP1);
+    display2DeviceID = Get_DEV_ID(DISP2);
+
+    if (display1DeviceID == TargetDevice)
+    {
+        SetDPMS(DMPSState, DISP1);
+        VBEReturnStatus = VBEFunctionCallSuccessful;
+    }
+    else if (display2DeviceID == TargetDevice)
+    {
+        SetDPMS(DMPSState, DISP2);
+        VBEReturnStatus = VBEFunctionCallSuccessful;
+    }
+
+    SetVBERerurnStatus(VBEReturnStatus, pCBiosArguments);
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_SetDevicePowerState() return 0x%x== \n", VBEFunctionCallSuccessful);
+#endif
+    return true;
+}
+
+CI_STATUS OEM_SetRefreshRate (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    UCHAR bRRateID, bDisplayPath;
+    bRRateID = pCBiosArguments->reg.lh.CL & 0x7F;
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_SetRefreshRate()== \n");
+#endif
+
+    if ( pCBiosArguments->reg.x.BX == SetDisplay1RefreshRate)
+        bDisplayPath = DISP1;
+    else
+        bDisplayPath = DISP2;
+
+    Set_RRATE_ID(bRRateID, bDisplayPath);
+
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBiosArguments);
+    
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_SetRefreshRate() return 0x%x== \n", VBEFunctionCallSuccessful);
+#endif
+    return true;
+}
+
+CI_STATUS OEM_SetLCDPWMLevel (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    SetSRReg(0x2F,7,0xFF);
+    SetSRReg(0x30,pCBiosArguments->reg.lh.CL,0xFF);            
+    return true;
+}
+
+CI_STATUS OEM_SetTVType (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetTV2Type (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetTVConnectType (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetTV2ConnectType (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetHDTVConnectType (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetHDTV2ConnectType (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetHDMIType (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetHDMIOutputSignal (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+CI_STATUS OEM_SetHDMI2OutputSignal (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    return true;
+}
+
+CI_STATUS OEM_VideoPOST (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    UCHAR i = 0,btemp = 0x0,btemp1 = 0x0;
+    CI_STATUS bDDRII400 = true;
+    UCHAR *pucPOSTInItRegs = POSTInItRegs;
+    UCHAR *pucDDRII400Tbl = DDRII400Tbl;
+    UCHAR *pucDDRII533Tbl = DDRII533Tbl;
+    UCHAR *pucExtendRegs2 = ExtendRegs2;
+
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Entry OEM_VideoPOST()== \n");
+#endif
+
+    /* Enable VGA */
+    btemp = InPort(RIO_VGA_ENABLE); 
+    btemp |= 1;
+    OutPort(RIO_VGA_ENABLE,btemp);
+
+    /* Select 3D4 as CRTC I/O base & Add memory access */
+    btemp = InPort(MISC_READ); 
+    btemp |= 3;
+    OutPort(MISC_WRITE,btemp);
+    
+    /* Open write key */
+    SetCRReg(0x80, 0xA8, 0xFF);
+    
+    /* Clear Scratch pad */
+    for(i = 0x81;i < 0x9F;i++)
+    {
+        SetCRReg(i, 0x00, 0xFF);
+    }
+
+    /* Load DRAM timing */
+    /* Get HW Trapping */
+    btemp = GetCRReg(0xAB);
+    if((btemp & 0x3) == 0x3)
+    {
+        bDDRII400 = false;
+    }
+
+    if(bDDRII400)
+    {
+        /* Set memory PLL(Memory clock:200MHz NS:0x1B, MS:0x00, RS:0x02) */
+        SetCRReg(0xD9, 0x00, 0x80);
+        SetCRReg(0xD8, 0x9B, 0xFF);
+    }
+    else
+    {
+        /* Set memory PLL(Memory clock:266MHz NS:0x38, MS:0x00, RS:0x01) */
+        SetCRReg(0xD9, 0x80, 0x80);
+        SetCRReg(0xD8, 0x78, 0xFF);
+    }
+    
+    /* Fire memory PLL timing setting */
+    /* btemp = GetCRReg(0xBB); */
+    btemp = 0x00;
+    SetCRReg(0xBB, btemp, 0xFF);
+    
+    /* Open LCK PLL */
+    /* SetCRReg(0xB4, 0x01, 0x01); */
+
+    /* Load extend table */
+    SerialLoadTable(&pucPOSTInItRegs, 0, 0);
+
+    /* Write the default disp1 scratch pad as CRT */
+    Set_NEW_DEV_ID(0, DISP1);
+
+    if(bDDRII400)
+    {
+        /* Load DDRII400 timing table. */
+        SerialLoadTable(&pucDDRII400Tbl, 0, 0);
+    }
+    else
+    {
+        /* Load DDRII533 timing table. */
+        SerialLoadTable(&pucDDRII533Tbl, 0, 0);    
+    }
+
+    /* Wait for DDRII setting */
+    do{
+        btemp = GetCRReg(0x5D);
+        btemp &= 0x80;
+        btemp1 = GetCRReg(0x5E);
+        btemp1 &= 0x01;
+    }while((btemp != 0x80)||(btemp1 != 0x01));
+
+    /* Set the other registers */
+    SerialLoadTable(&pucExtendRegs2, 0, 0);
+    /* SetDCC */
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit OEM_VideoPOST()== \n");
+#endif
+    return true;
+}
+
+void* SearchString(char *pcKeyWord, UCHAR *from)
+{
+    int i, lenKeyWord;
+
+    lenKeyWord = strlen(pcKeyWord);
+    for(i = 0; i < BIOS_ROM_SIZE; i++)
+    {
+        if ((*pcKeyWord == *(from+i)) && !memcmp(pcKeyWord, from+i, lenKeyWord))
+        {
+            return from+i;
+        }
+    }
+
+    return NULL;
+}
+
+void ParseTable(char* pcKeyWord, UCHAR *from, UCHAR **pointer)
+{
+    *pointer = (UCHAR*)SearchString(pcKeyWord, from);
+    *pointer += strlen(pcKeyWord);
+}
+
+CI_STATUS OEM_CINT10DataInit (CBIOS_ARGUMENTS *pCBiosArguments)
+{
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "BIOS virtual = %x", pCBiosArguments->reg.ex.ECX);
+    
+    ParseTable("PCFG", (UCHAR*)pCBiosArguments->reg.ex.ECX, (UCHAR**)(&pPortConfig));
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "Port Config = %x", pPortConfig);
+    
+    ParseTable("VPIT", (UCHAR*)pCBiosArguments->reg.ex.ECX, (UCHAR**)(&pVESATable));
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "VESA Table = %x", pVESATable);
+    
+    ParseTable("LCDTBL", (UCHAR*)pCBiosArguments->reg.ex.ECX, (UCHAR**)(&pLCDTable));
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "LCD Table = %x", pLCDTable);
+
+    ParseTable("PCIR", (UCHAR*)pCBiosArguments->reg.ex.ECX, (UCHAR**)(&PCIDataStruct));
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "PCI Data Struct = %x", PCIDataStruct);
+
+    ParseTable("D1INIT", (UCHAR*)pCBiosArguments->reg.ex.ECX, (UCHAR**)(&Display1VESAModeInitRegs));
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "Display1 VESA Mode Init Regs = %x", Display1VESAModeInitRegs);
+
+    SetDeviceSupport();
+#if 0 
+    ParseTable("??????", &ExtendRegs);  // POST init table
+    ParseTable("??????", &ExtendRegs2); // POST init table
+    ParseTable("??????", &DDRII400Tbl); // DDR400 DRAM table   
+    ParseTable("??????", &DDRII533Tbl); // DDR533 DRAM table   
+#endif
+    SetVBERerurnStatus(VBEFunctionCallSuccessful, pCBiosArguments);
+}
+
+CI_STATUS CInt10(CBIOS_Extension *pCBIOSExtension)
+{
+    CI_STATUS CInt10_Status = false;
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter CInt10(EAX = %x, EBX = %x, ECX = %x, EDX = %x, ESI = %x, EDI = %x)==\n",
+                   pCBIOSExtension->pCBiosArguments->reg.ex.EAX, pCBIOSExtension->pCBiosArguments->reg.ex.EBX,
+                   pCBIOSExtension->pCBiosArguments->reg.ex.ECX, pCBIOSExtension->pCBiosArguments->reg.ex.EDX,
+                   pCBIOSExtension->pCBiosArguments->reg.ex.ESI, pCBIOSExtension->pCBiosArguments->reg.ex.EDI);
+#endif
+
+
+    /* Fill related IO address */
+    Relocate_IOAddress = pCBIOSExtension->IOAddress;
+
+    switch(pCBIOSExtension->pCBiosArguments->reg.x.AX)
+    {
+        case VBESetMode:
+            CInt10_Status = VBE_SetMode(pCBIOSExtension);
+            break;
+
+        case VBESetGetScanLineLength:
+            CInt10_Status = VBE_SetGetScanLineLength(pCBIOSExtension->pCBiosArguments);
+            break;
+            
+        case OEMFunction:
+            switch(pCBIOSExtension->pCBiosArguments->reg.x.BX)
+            {
+                case QueryBiosInfo:             /* 0000 */
+                    CInt10_Status = OEM_QueryBiosInfo(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryBiosCaps:             /* 0001 */
+                    CInt10_Status = OEM_QueryBiosCaps(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryExternalDeviceInfo:   /* 0100 */
+                    CInt10_Status = OEM_QueryExternalDeviceInfo(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryDisplayPathInfo:      /* 0200 */
+                    CInt10_Status = OEM_QueryDisplayPathInfo(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryDeviceConnectStatus:  /* 0201 */
+                    CInt10_Status = OEM_QueryDeviceConnectStatus(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QuerySupportedMode:        /* 0202 */
+                    CInt10_Status = OEM_QuerySupportedMode(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryLCDPanelSizeMode:        /* 0203 */
+                    CInt10_Status = OEM_QueryLCDPanelSizeMode(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryLCDPWMLevel:          /* 0301 */
+                    CInt10_Status = OEM_QueryLCDPWMLevel(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case QueryTVConfiguration:
+                    break;
+                case QueryTV2Configuration:
+                    break;
+                case QueryHDTVConfiguration:
+                    break;
+                case QueryHDTV2Configuration:
+                    break;
+                case QueryHDMIConfiguration:
+                    break;
+                case QueryHDMI2Configuration:
+                    break;
+                case QueryDisplay2Pitch:
+                case GetDisplay2MaxPitch:
+                    CInt10_Status = VBE_SetGetScanLineLength(pCBIOSExtension->pCBiosArguments);
+                    break;
+
+                case SetActiveDisplayDevice:    /* 8200 */
+                    CInt10_Status = OEM_SetActiveDisplayDevice(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case SetVESAModeForDisplay2:
+                    CInt10_Status = OEM_SetVESAModeForDisplay2(pCBIOSExtension);
+                    break;
+                case SetDevicePowerState:       /* 8203 */
+                    CInt10_Status = OEM_SetDevicePowerState(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case SetDisplay1RefreshRate:    /* 8301 */
+                case SetDisplay2RefreshRate:    /* 8381 */
+                    CInt10_Status = OEM_SetRefreshRate(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case SetLCDPWMLevel:            /* 8302 */
+                    CInt10_Status = OEM_SetLCDPWMLevel(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case SetTVType:
+                    break;
+                case SetTV2Type:
+                    break;
+                case SetTVConnectType:
+                    break;
+                case SetTV2ConnectType:
+                    break;
+                case SetHDTVConnectType:
+                    break;
+                case SetHDTV2ConnectType:
+                    break;
+                case SetHDMIType:
+                    break;
+                case SetHDMI2Type:
+                    break;
+                case SetHDMIOutputSignal:
+                    break;
+                case SetHDMI2OutputSignal:
+                    break;
+                case SetDisplay2PitchInPixels:
+                case SetDisplay2PitchInBytes:
+                    CInt10_Status = VBE_SetGetScanLineLength(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case SetVideoPOST:
+                    CInt10_Status = OEM_VideoPOST(pCBIOSExtension->pCBiosArguments);
+                    break;
+                case CINT10DataInit:
+                    CInt10_Status = OEM_CINT10DataInit(pCBIOSExtension->pCBiosArguments);
+                    break;
+                default:
+                    pCBIOSExtension->pCBiosArguments->reg.x.AX = 0x014F;
+                    break;
+            }
+            break;
+
+        default:
+            break;
+    }
+#if CBIOS_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit CInt10(EAX = %x, EBX = %x, ECX = %x, EDX = %x, ESI = %x, EDI = %x)== \n",
+                   pCBIOSExtension->pCBiosArguments->reg.ex.EAX, pCBIOSExtension->pCBiosArguments->reg.ex.EBX,
+                   pCBIOSExtension->pCBiosArguments->reg.ex.ECX, pCBIOSExtension->pCBiosArguments->reg.ex.EDX,
+                   pCBIOSExtension->pCBiosArguments->reg.ex.ESI, pCBIOSExtension->pCBiosArguments->reg.ex.EDI);
+#endif
+    
+    return CInt10_Status;
+} /* end CInt10() */
+
diff --git a/src/CInt10.h b/src/CInt10.h
new file mode 100644
index 0000000..9707f6f
--- /dev/null
+++ b/src/CInt10.h
@@ -0,0 +1,158 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+/* CBios Compile Flag */
+#define     CBIOS_DEBUG             1
+
+/* VBE return status */
+#define VBEFunctionCallSuccessful   0x004F
+#define VBEFunctionCallFail         0x014F
+#define VBEFunctionCallNotSupported 0x024F
+#define VBEFunctionCallInvalid      0x034F
+
+
+/* Function argument */
+#define VBESetMode                  0x4F02 
+#define VBESetGetScanLineLength     0x4F06
+#define OEMFunction                 0x4F14
+
+#define QueryBiosInfo               0x0000 
+#define QueryBiosCaps               0x0001
+#define QueryExternalDeviceInfo     0x0100
+#define QueryDisplayPathInfo        0x0200
+#define QueryDeviceConnectStatus    0x0201
+#define QuerySupportedMode          0x0202
+#define QueryLCDPanelSizeMode       0x0203
+#define QueryLCDPWMLevel            0x0301
+#define QueryTVConfiguration        0x0400
+#define QueryTV2Configuration       0x0480
+#define QueryHDTVConfiguration      0x0500
+#define QueryHDTV2Configuration     0x0580
+#define QueryHDMIConfiguration      0x0600
+#define QueryHDMI2Configuration     0x0680
+#define QueryDisplay2Pitch          0x0801
+#define GetDisplay2MaxPitch         0x0803
+
+
+#define SetActiveDisplayDevice      0x8200
+#define SetVESAModeForDisplay2      0x8202
+#define SetDevicePowerState         0x8203
+#define SetDisplay1RefreshRate      0x8301
+#define SetLCDPWMLevel              0x8302
+#define SetDisplay2RefreshRate      0x8381
+#define SetTVType                   0x8400
+#define SetTV2Type                  0x8480
+#define SetTVConnectType            0x8401
+#define SetTV2ConnectType           0x8481
+#define SetHDTVConnectType          0x8501
+#define SetHDTV2ConnectType         0x8581
+#define SetHDMIType                 0x8600
+#define SetHDMI2Type                0x8680
+#define SetHDMIOutputSignal         0x8601
+#define SetHDMI2OutputSignal        0x8681
+#define SetDisplay2PitchInPixels    0x8700
+#define SetDisplay2PitchInBytes     0x8782
+
+#define SetVideoPOST                0xF100
+#define CINT10DataInit              0xF101
+
+/* definitions only for RRATE_TABLE.Attribute */
+#define DISABLE              0x0001             // mode disable
+#define NHS                  0x0002             // 1= negative H sync
+#define PHS                  0
+#define NVS                  0x0004             // 1= negative V sync
+#define PVS                  0
+#define HB                   0x0008             // 1= 1-character-wide H border
+#define VB                   0x0010             // 1= 8-line-wide V border
+#define RBK                  0x0020             // 1= Reduced Blanking
+#define ROT                  0x0040             // rotation output format
+#define EN_DIT               0x0080             // enable dither for 18-bit panel
+#define MSB                  0x0100             // MSB panel
+#define _2_CH                0x0200             // 2 channel panel
+#define SW_PS                0x0400             // SW power sequence
+
+
+#define BIOS_ROM_SIZE           32*1024
+
+
+typedef enum _CINT10STATUS {
+    false = 0,
+    true = 1
+} CI_STATUS;
+
+typedef struct _CBIOS_ARGUMENTS {
+    union
+    {
+        struct EX
+        {
+            unsigned long   EAX;
+            unsigned long   EBX;
+            unsigned long   ECX;
+            unsigned long   EDX;
+            unsigned long   ESI;
+            unsigned long   EDI;
+        }ex;
+
+        struct X
+        {
+            unsigned short  AX;
+            unsigned short  dummy1;
+            unsigned short  BX;
+            unsigned short  dummy2;
+            unsigned short  CX;
+            unsigned short  dummy3;
+            unsigned short  DX;
+            unsigned short  dummy4;
+            unsigned short  SI;
+            unsigned short  dummy5;
+            unsigned short  DI;
+        }x;
+
+        struct LH
+        {
+            unsigned char   AL;
+            unsigned char   AH;
+            unsigned short  dummy6;
+            unsigned char   BL;
+            unsigned char   BH;
+            unsigned short  dummy7;
+            unsigned char   CL;
+            unsigned char   CH;
+            unsigned short  dummy8;
+            unsigned char   DL;
+            unsigned char   DH;
+            unsigned short  dummy9;
+        }lh;
+    }reg;
+
+} CBIOS_ARGUMENTS;
+
+typedef struct _CBIOS_Extension {
+
+    /* Cbios argument */
+    CBIOS_ARGUMENTS *pCBiosArguments;
+
+    /* Extension value */
+    unsigned long   VideoVirtualAddress;
+    unsigned short  IOAddress;
+}CBIOS_Extension;
+
+extern CI_STATUS CInt10(CBIOS_Extension *pCBIOSExtension);
+
diff --git a/src/CInt10FunProto.h b/src/CInt10FunProto.h
new file mode 100644
index 0000000..922e894
--- /dev/null
+++ b/src/CInt10FunProto.h
@@ -0,0 +1,151 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+/* internal functions prototype */
+void SetVBERerurnStatus(USHORT VBEReturnStatus, CBIOS_ARGUMENTS *pCBiosArguments);
+
+void SetTimingRegs(UCHAR ucDisplayPath, MODE_INFO *pModeInfo, RRATE_TABLE *pRRateTable);
+void SetHTotal(UCHAR DisplayPath, USHORT Value);
+void SetHDisplayEnd(UCHAR DisplayPath, USHORT Value);
+void SetHBlankingStart(UCHAR DisplayPath, USHORT Value);
+void SetHBlankingEnd(UCHAR DisplayPath, USHORT Value);
+void SetHSyncStart(UCHAR DisplayPath, USHORT Value);
+void SetHSyncEnd(UCHAR DisplayPath, USHORT Value);
+void SetVTotal(UCHAR DisplayPath, USHORT Value);
+void SetVDisplayEnd(UCHAR DisplayPath, USHORT Value);
+void SetVBlankingStart(UCHAR DisplayPath, USHORT Value);
+void SetVBlankingEnd(UCHAR DisplayPath, USHORT Value);
+void SetVSyncStart(UCHAR DisplayPath, USHORT Value);
+void SetVSyncEnd(UCHAR DisplayPath, USHORT Value);
+void SetPixelClock(UCHAR DisplayPath, ULONG Clock);
+void SetHSource(UCHAR bDisplayPath, USHORT wValue);
+PLL_Info ClockToPLLF9003A(ULONG Clock);
+void SetDPLL(UCHAR DisplayPath, PLL_Info PLLInfo);
+void SetPolarity(UCHAR DevicePort, UCHAR Value);
+void SetFIFO(UCHAR DisplayPath);
+void SetPitch(UCHAR DisplayPath, USHORT Value);
+USHORT GetPitch(UCHAR DisplayPath);
+USHORT GetVDisplayEnd(UCHAR DisplayPath);
+void SetColorDepth(UCHAR DisplayPath, UCHAR Value);
+void ConfigDigitalPort(UCHAR bDisplayPath);
+void LoadTiming(UCHAR DisplayPath, USHORT ModeNum);
+void LoadVESATiming(UCHAR bDisplayPath, USHORT wModeNum);
+void LoadLCDTiming(UCHAR bDisplayPath, USHORT wModeNum);
+void SetScalingFactor(UCHAR bDisplayPath, MODE_INFO *pUserModeInfo, MODE_INFO *pPanelModeInfo);
+void SetHorScalingFactor(UCHAR bDisplayPath, USHORT wValue);
+void SetVerScalingFactor(UCHAR bDisplayPath, USHORT wValue);
+CI_STATUS isLCDFitMode(UCHAR bDeviceIndex, USHORT wModeNum);
+CI_STATUS GetModePointerFromVESATable(USHORT wModeNum, UCHAR bRRIndex, MODE_INFO **ppModeInfo, RRATE_TABLE **ppRRateTable);
+CI_STATUS GetModePointerFromLCDTable(UCHAR bDeviceIndex, MODE_INFO **ppModeInfo, PANEL_TABLE **ppPanelTable);
+CI_STATUS Get_MODE_INFO(USHORT wModeNum, MODE_INFO **ppModeInfo);
+CI_STATUS Get_MODE_INFO_From_LCD_Table(UCHAR bDeviceIndex, MODE_INFO **ppModeInfo);
+CI_STATUS Get_MODE_INFO_From_VESA_Table(USHORT wModeNum, MODE_INFO **ppModeInfo);
+CI_STATUS GetModeColorDepth(USHORT wModeNum, MODE_INFO *pModeInfo, UCHAR *pbColorDepth);
+
+CI_STATUS GetModePitch(USHORT ModeNum, USHORT *pPitch);
+USHORT ReadRegFromHW(REG_OP *pRegOp);
+void WriteRegToHW(REG_OP *pRegOp, USHORT value);
+void UnLockCR0ToCR7();
+void LockCR0ToCR7();
+CI_STATUS CheckForModeAvailable(USHORT ModeNum);
+CI_STATUS CheckForNewDeviceAvailable(UCHAR bDeviceIndex);
+void Display1TurnOnTX();
+void Display1TurnOffTX();
+void Display2TurnOnTX();
+void Display2TurnOffTX();
+void TurnOnDigitalPort(UCHAR bDeviceIndex);
+void TurnOffDigitalPort(UCHAR bDeviceIndex);
+UCHAR GetPortConnectPath(UCHAR PortType);
+USHORT TransDevIDtoBit(UCHAR DeviceIndex);
+void TurnOnCRTPad();
+void TurnOffCRTPad();
+void TurnOnDVP1Pad();
+void TurnOffDVP1Pad();
+void TurnOnDVP2Pad();
+void TurnOffDVP2Pad();
+void TurnOnDVP12Pad();
+void TurnOffDVP12Pad();
+void TurnOnScaler(UCHAR bDisplayPath);
+void TurnOffScaler(UCHAR bDisplayPath);
+void TurnOnHorScaler(UCHAR bDisplayPath);
+void TurnOffHorScaler(UCHAR bDisplayPath);
+void TurnOnVerScaler(UCHAR bDisplayPath);
+void TurnOffVerScaler(UCHAR bDisplayPath);
+
+void Set12BitDVP();
+void Set24BitDVP();
+void TurnOnDAC();
+void TurnOffDAC();
+void SerialLoadTable(UCHAR **ppucDisplay1VESAModeInitRegs, UCHAR ucI2Cport, UCHAR ucI2CAddr);
+void SerialLoadRegBits(UCHAR **ppucDisplay1VESAModeInitRegs, UCHAR ucRegGroup, UCHAR ucI2Cport, UCHAR ucI2CAddr);
+void SerialLoadReg(UCHAR **ppucDisplay1VESAModeInitRegs, UCHAR ucRegGroup, UCHAR ucI2Cport, UCHAR ucI2CAddr);
+void LoadDisplay1VESAModeInitRegs();
+void VESASetBIOSData(USHORT ModeNum);
+void DisableDisplayPathAndDevice(UCHAR DisplayPath);
+CI_STATUS GetDevicePortConfig(UCHAR bDeviceIndex, PORT_CONFIG **ppPortConfig);
+void PowerSequenceOn();
+void PowerSequenceOff();
+void SequencerOn(UCHAR DisplayPath);
+void SequencerOff(UCHAR bDisplayPath);
+void ControlPwrSeqOn(UCHAR bDeviceIndex);
+void ControlPwrSeqOff(UCHAR bDeviceIndex);
+void LongWait();
+UCHAR Get_DEV_ID(UCHAR DisplayPath);
+void Set_DEV_ID(UCHAR DeviceID, UCHAR DisplayPath);
+UCHAR Get_NEW_DEV_ID(UCHAR DisplayPath);
+void Set_NEW_DEV_ID(UCHAR DeviceID, UCHAR DisplayPath);
+USHORT Get_LCD_H_SIZE();
+USHORT Get_LCD_V_SIZE();
+ULONG Get_LCD_SIZE();
+USHORT Get_LCD2_H_SIZE();
+USHORT Get_LCD2_V_SIZE();
+ULONG Get_LCD2_SIZE();
+UCHAR Get_RRATE_ID(UCHAR DisplayPath);
+void Set_RRATE_ID(UCHAR RRateID, UCHAR DisplayPath);
+UCHAR Get_LCD_TABLE_INDEX(void);
+UCHAR Get_LCD2_TABLE_INDEX(void);
+void Set_LCD_TABLE_INDEX(UCHAR bLCDIndex);
+USHORT Get_VESA_MODE(UCHAR DisplayPath);
+void Set_VESA_MODE(USHORT ModeNum, UCHAR DisplayPath);
+void ResetATTR();
+void EnableATTR();
+void SetCRReg(UCHAR bRegIndex, UCHAR bRegValue, UCHAR bMask);
+UCHAR GetCRReg(UCHAR bRegIndex);
+void SetSRReg(UCHAR bRegIndex, UCHAR bRegValue, UCHAR bMask);
+UCHAR GetSRReg(UCHAR bRegIndex);
+void SetARReg(UCHAR index,UCHAR value);
+UCHAR GetARReg(UCHAR index);
+void SetGRReg(UCHAR bRegIndex, UCHAR bRegValue, UCHAR bMask);
+void SetMSReg(UCHAR bRegValue);
+UCHAR GetIS1Reg();
+void ClearFrameBuffer(UCHAR DisplayPath,ULONG *pFrameBufferBase,MODE_INFO *pModeInfo, UCHAR bColorDepth);
+ULONG Difference(ULONG Value1, ULONG Value2);
+UCHAR ReadScratch(USHORT IndexMask);
+void WriteScratch(USHORT IndexMask, UCHAR Data);
+UCHAR AlignDataToLSB(UCHAR bData, UCHAR bMask);
+UCHAR AlignDataToMask(UCHAR bData, UCHAR bMask);
+void SetDPMS(UCHAR DPMSState, UCHAR DisplayPath);
+CI_STATUS DetectMonitor();
+void WaitDisplayPeriod();
+void WaitPowerSequenceDone();
+CI_STATUS CheckForDSTNPanel(UCHAR bDeviceIndex);
+USHORT GetVESAMEMSize();
+void SetDeviceSupport();
+
diff --git a/src/CInt10Tbl.h b/src/CInt10Tbl.h
new file mode 100644
index 0000000..d260474
--- /dev/null
+++ b/src/CInt10Tbl.h
@@ -0,0 +1,319 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+PORT_CONFIG *pPortConfig;
+MODE_INFO   *pLCDTable;
+MODE_INFO   *pVESATable;
+void *PCIDataStruct;
+
+bool bCRTSUPPORT = false;
+bool bLCDSUPPORT = false;
+bool bDVISUPPORT = false;
+bool bTVSUPPORT = false;
+
+/* common table for all VESA modes on display1 */
+void *Display1VESAModeInitRegs;
+
+/* table pointers for VBIOS POST */
+void *POSTInItRegs;
+void *DDRII400Tbl;
+void *DDRII533Tbl;
+void *ExtendRegs2;
+
+/* Display 1 registers table */
+/* Display 1 H total */
+REG_OP HTotal1[] = {
+            {CR, 0xFF, 0x00,3},                 /* [7:0] */
+            {CR, BIT0, 0xAC,11},                  /* [8] */
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 H DispEnd */
+REG_OP HDispEnd1[] = {
+            {SR, BIT6+BIT5+BIT4, 0x33,0},
+            {CR, 0xFF, 0x01,3},
+            {CR, BIT2, 0xAC,11},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 H BnkSt */
+REG_OP HBnkSt1[] = {
+            {SR, BIT2+BIT1+BIT0, 0x34,0},
+            {CR, 0xFF, 0x02,3},
+            {CR, BIT4, 0xAC,11},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 H BnkEnd */
+REG_OP HBnkEnd1[] = {
+            {SR, BIT6+BIT5+BIT4, 0x34,0},
+            {CR, 0x1F, 0x03,3},
+            {CR, BIT7, 0x05,8},
+            {CR, BIT0, 0xAD,9},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 H SyncSt */
+REG_OP HSyncSt1[] = {
+            {SR, BIT2+BIT1+BIT0, 0x35,0},
+            {CR, 0xFF, 0x04,3},
+            {CR, BIT6, 0xAC,11},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 H SyncEnd */
+REG_OP HSyncEnd1[] = {
+            {SR, BIT6+BIT5+BIT4, 0x35,0},
+            {CR, 0x1F, 0x05,3},
+            {CR, BIT2, 0xAD,8},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 V Total */
+REG_OP VTotal1[] = {
+            {CR, 0xFF, 0x06,0},
+            {CR, BIT0, 0x07,8},
+            {CR, BIT5, 0x07,9},
+            {CR, BIT0, 0xAE,10},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 V DispEnd */
+REG_OP VDispEnd1[] = {
+            {CR, 0xFF, 0x12,0},
+            {CR, BIT1, 0x07,8},
+            {CR, BIT6, 0x07,9},
+            {CR, BIT1, 0xAE,10},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 V BnkSt */
+REG_OP VBnkSt1[] = {
+            {CR, 0xFF, 0x15,0},
+            {CR, BIT3, 0x07,8},
+            {CR, BIT5, 0x09,9},
+            {CR, BIT2, 0xAE,10},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 V BnkEnd */
+REG_OP VBnkEnd1[] = {
+            {CR, 0xFF, 0x16,0},
+            {CR, BIT4, 0xAE,8},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 V SyncSt */
+REG_OP VSyncSt1[] = {
+             {CR, 0xFF, 0x10,0},
+             {CR, BIT2, 0x07,8},
+             {CR, BIT7, 0x07,9},
+             {CR, BIT3, 0xAE,10},
+             {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 V SyncEnd */
+REG_OP VSyncEnd1[] = {
+             {CR, BIT3+BIT2+BIT1+BIT0, 0x11,0},
+             {CR, BIT6+BIT5, 0xAE,4},
+             {NR,0x0,0x0,0x0}
+};
+
+/* Display 1 Pitch */
+REG_OP Pitch1[] = {
+             {CR, 0xFF, 0x13,0},
+             {CR, 0x3F, 0xB0,8},
+             {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 registers table */
+
+/* Display 2 H total */
+REG_OP HTotal2[] = {
+            {CR, 0xFF, 0x23,3},                 /* [7:0] */
+            {CR, BIT0, 0x29,11},                  /* [8] */
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 H DispEnd */
+REG_OP HDispEnd2[] = {
+            {SR, BIT6+BIT5+BIT4, 0x36,0},
+            {CR, 0xFF, 0x24,3},
+            {CR, BIT2, 0x29,11},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 H BnkSt */
+REG_OP HBnkSt2[] = {
+            {SR, BIT2+BIT1+BIT0, 0x37,0},
+            {CR, 0xFF, 0x25,3},
+            {CR, BIT4, 0x29,11},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 H BnkEnd */
+REG_OP HBnkEnd2[] = {
+            {SR, BIT6+BIT5+BIT4, 0x37,0},
+            {CR, 0x1F, 0x26,3},
+            {CR, BIT7, 0x28,8},
+            {CR, BIT0, 0x2A,9},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 H SyncSt */
+REG_OP HSyncSt2[] = {
+            {SR, BIT2+BIT1+BIT0, 0x38,0},
+            {CR, 0xFF, 0x27,3},
+            {CR, BIT6, 0x29,11},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 H SyncEnd */
+REG_OP HSyncEnd2[] = {
+            {SR, BIT6+BIT5+BIT4, 0x38,0},
+            {CR, 0x1F, 0x28,3},
+            {CR, BIT2, 0x2A,8},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 V Total */
+REG_OP VTotal2[] = {
+            {CR, 0xFF, 0x2B,0},
+            {CR, BIT0, 0x31,8},
+            {CR, BIT5, 0x31,9},
+            {CR, BIT0, 0x32,10},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 V DispEnd */
+REG_OP VDispEnd2[] = {
+            {CR, 0xFF, 0x2C,0},
+            {CR, BIT1, 0x31,8},
+            {CR, BIT6, 0x31,9},
+            {CR, BIT1, 0x32,10},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 V BnkSt */
+REG_OP VBnkSt2[] = {
+            {CR, 0xFF, 0x2D,0},
+            {CR, BIT3, 0x31,8},
+            {CR, BIT5, 0x29,9},
+            {CR, BIT2, 0x32,10},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 V VBnkEnd2 */
+REG_OP VBnkEnd2[] = {
+            {CR, 0xFF, 0x2E,0},
+            {CR, BIT4, 0x32,8},
+            {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 V SyncSt */
+REG_OP VSyncSt2[] = {
+             {CR, 0xFF, 0x2F,0},
+             {CR, BIT2, 0x31,8},
+             {CR, BIT7, 0x31,9},
+             {CR, BIT3, 0x32,10},
+             {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 V SyncEnd */
+REG_OP VSyncEnd2[] = {
+             {CR, BIT3+BIT2+BIT1+BIT0, 0x30,0},
+             {CR, BIT6+BIT5, 0x32,4},
+             {NR,0x0,0x0,0x0}
+};
+
+/* Display 2 Pitch */
+REG_OP Pitch2[] = {
+             {CR, 0xFF, 0x3A,0},
+             {CR, 0x3F, 0x3B,8},
+             {NR,0x0,0x0,0x0}
+};
+
+/*============================================================================= */
+REG_OP HSource1[] = {
+            {SR, 0xFF,                0x4B, 0},
+            {SR, BIT3+BIT2+BIT1+BIT0, 0x4C, 8},
+            {NR,0x0,0x0,0x0}
+};
+
+REG_OP HSource2[] = {
+            {SR, 0xFF,                0x4D, 0},
+            {SR, BIT3+BIT2+BIT1+BIT0, 0x4E, 8},
+            {NR,0x0,0x0,0x0}
+};
+
+REG_OP HScalingFactor1[] = {
+            {SR, 0xFF,                0x59, 0},
+            {SR, BIT3+BIT2+BIT1+BIT0, 0x5B, 8},
+            {NR,0x0,0x0,0x0}
+};
+        
+REG_OP VScalingFactor1[] = {
+            {SR, 0xFF,                0x5A, 0},
+            {SR, BIT6+BIT5+BIT4,      0x5B, 8},
+            {NR,0x0,0x0,0x0}
+};
+        
+REG_OP HScalingFactor2[] = {
+            {SR, 0xFF,                0x51, 0},
+            {SR, BIT3+BIT2+BIT1+BIT0, 0x53, 8},
+            {NR,0x0,0x0,0x0}
+};
+
+REG_OP VScalingFactor2[] = {
+            {SR, 0xFF,                0x52, 0},
+            {SR, BIT6+BIT5+BIT4,      0x53, 8},
+            {NR,0x0,0x0,0x0}
+};
+
+
+VESA_TABLE CInt10VESATable[] = {
+        {
+            {1280, 720, 0x147, 0x148, 0x149, 1},
+            {74250, RR60, PHS+PVS, 370, 1390, 40,  30,  725,  5}
+        },
+        {
+            {1280, 768, 0x144, 0x145, 0x146, 1},
+            { 79500, RR60, NHS+PVS, 384, 1344, 128,  30,  771,  7}
+        },
+        {
+            {1280, 960, 0x135, 0x136, 0x137, 1},
+            {108000, RR60, PHS+PVS, 520, 1376, 112, 40,  961,  3}
+        },
+        {
+            {1366, 768, 0x141, 0x142, 0x143, 1},
+            { 85860, RR60, NHS+PVS, 434, 1440, 144,  27,  769,  3}
+        },
+        {
+            {1400,1050, 0x138, 0x139, 0x13A, 1},
+            {121750, RR60, NHS+PVS, 464, 1488, 144, 39, 1053, 4}
+        },
+        {
+            {0xffff,1050, 0x138, 0x139, 0x13A, 1},
+            {121750, RR60, NHS+PVS, 464, 1488, 144, 39, 1053, 4}
+        }
+
+};
+
+
diff --git a/src/Makefile b/src/Makefile
new file mode 100644
index 0000000..1c3e0cb
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,533 @@
+# Makefile.in generated by automake 1.10 from Makefile.am.
+# src/Makefile.  Generated from Makefile.in by configure.
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+
+
+#  Copyright 2005 Adam Jackson.
+#
+#  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, sub
+#  license, and/or sell copies of the Software, and to permit persons to whom
+#  the Software is furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice (including the next
+#  paragraph) shall be included in all copies or substantial portions of the
+#  Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+#  ADAM JACKSON 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.
+
+
+pkgdatadir = $(datadir)/xf86-video-aip
+pkglibdir = $(libdir)/xf86-video-aip
+pkgincludedir = $(includedir)/xf86-video-aip
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = i686-pc-linux-gnu
+host_triplet = i686-pc-linux-gnu
+subdir = src
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
+am__installdirs = "$(DESTDIR)$(rdc_drv_ladir)"
+rdc_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
+LTLIBRARIES = $(rdc_drv_la_LTLIBRARIES)
+rdc_drv_la_LIBADD =
+am_rdc_drv_la_OBJECTS = rdc_2dtool.lo rdc_accel.lo rdc_cursor.lo \
+	rdc_driver.lo rdc_mode.lo rdc_tool.lo rdc_vgatool.lo \
+	rdc_video.lo rdc_extension.lo CInt10.lo
+rdc_drv_la_OBJECTS = $(am_rdc_drv_la_OBJECTS)
+rdc_drv_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(rdc_drv_la_LDFLAGS) $(LDFLAGS) -o $@
+DEFAULT_INCLUDES = -I. -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+SOURCES = $(rdc_drv_la_SOURCES)
+DIST_SOURCES = $(rdc_drv_la_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = aclocal -I /home/jason/Desktop/Xorg/compiled/1.6.0/share/aclocal
+ADMIN_MAN_DIR = $(mandir)/man$(ADMIN_MAN_SUFFIX)
+ADMIN_MAN_SUFFIX = 8
+AMTAR = ${SHELL} /home/jason/Desktop/Xorg/driver/TipCode/missing --run tar
+APP_MAN_DIR = $(mandir)/man$(APP_MAN_SUFFIX)
+APP_MAN_SUFFIX = 1
+AR = ar
+AUTOCONF = ${SHELL} /home/jason/Desktop/Xorg/driver/TipCode/missing --run autoconf
+AUTOHEADER = ${SHELL} /home/jason/Desktop/Xorg/driver/TipCode/missing --run autoheader
+AUTOMAKE = ${SHELL} /home/jason/Desktop/Xorg/driver/TipCode/missing --run automake-1.10
+AWK = gawk
+CC = gcc
+CCDEPMODE = depmode=gcc3
+CFLAGS = -g -O2
+CPP = gcc -E
+CPPFLAGS = 
+CXX = g++
+CXXCPP = g++ -E
+CXXDEPMODE = depmode=gcc3
+CXXFLAGS = -g -O2
+CYGPATH_W = echo
+DEFS = -DHAVE_CONFIG_H
+DEPDIR = .deps
+DRIVER_MAN_DIR = $(mandir)/man$(DRIVER_MAN_SUFFIX)
+DRIVER_MAN_SUFFIX = 4
+DRIVER_NAME = nv
+ECHO = echo
+ECHO_C = 
+ECHO_N = -n
+ECHO_T = 
+EGREP = /bin/grep -E
+EXEEXT = 
+F77 = gfortran
+FFLAGS = -g -O2
+FILE_MAN_DIR = $(mandir)/man$(FILE_MAN_SUFFIX)
+FILE_MAN_SUFFIX = 5
+GREP = /bin/grep
+INSTALL = /usr/bin/install -c
+INSTALL_DATA = ${INSTALL} -m 644
+INSTALL_PROGRAM = ${INSTALL}
+INSTALL_SCRIPT = ${INSTALL}
+INSTALL_STRIP_PROGRAM = $(install_sh) -c -s
+LDFLAGS = 
+LIBOBJS = 
+LIBS = 
+LIBTOOL = $(SHELL) $(top_builddir)/libtool
+LIB_MAN_DIR = $(mandir)/man$(LIB_MAN_SUFFIX)
+LIB_MAN_SUFFIX = 3
+LN_S = ln -s
+LTLIBOBJS = 
+MAINT = 
+MAKEINFO = ${SHELL} /home/jason/Desktop/Xorg/driver/TipCode/missing --run makeinfo
+MISC_MAN_DIR = $(mandir)/man$(MISC_MAN_SUFFIX)
+MISC_MAN_SUFFIX = 7
+MKDIR_P = /bin/mkdir -p
+OBJEXT = o
+PACKAGE = xf86-video-aip
+PACKAGE_BUGREPORT = https://bugs.freedesktop.org/enter_bug.cgi?product=xorg
+PACKAGE_NAME = xf86-video-aip
+PACKAGE_STRING = xf86-video-aip 0.80
+PACKAGE_TARNAME = xf86-video-aip
+PACKAGE_VERSION = 0.80
+PATH_SEPARATOR = :
+PKG_CONFIG = /usr/bin/pkg-config
+RANLIB = ranlib
+SED = /bin/sed
+SET_MAKE = 
+SHELL = /bin/sh
+STRIP = strip
+VERSION = 0.80
+XORG_CFLAGS = -I/home/jason/Desktop/Xorg/compiled/1.6.0//include/xorg -I/home/jason/Desktop/Xorg/compiled/1.6.0//include/pixman-1 -I/home/jason/Desktop/Xorg/compiled/1.6.0//include -I/home/jason/Desktop/Xorg/compiled/1.6.0/include  
+XORG_LIBS = -L/home/jason/Desktop/Xorg/compiled/1.6.0//lib -lpixman-1 -lpciaccess  
+abs_builddir = /home/jason/Desktop/Xorg/driver/TipCode/src
+abs_srcdir = /home/jason/Desktop/Xorg/driver/TipCode/src
+abs_top_builddir = /home/jason/Desktop/Xorg/driver/TipCode
+abs_top_srcdir = /home/jason/Desktop/Xorg/driver/TipCode
+ac_ct_CC = gcc
+ac_ct_CXX = g++
+ac_ct_F77 = gfortran
+am__include = include
+am__leading_dot = .
+am__quote = 
+am__tar = ${AMTAR} chof - "$$tardir"
+am__untar = ${AMTAR} xf -
+bindir = ${exec_prefix}/bin
+build = i686-pc-linux-gnu
+build_alias = 
+build_cpu = i686
+build_os = linux-gnu
+build_vendor = pc
+builddir = .
+datadir = ${datarootdir}
+datarootdir = ${prefix}/share
+docdir = ${datarootdir}/doc/${PACKAGE_TARNAME}
+dvidir = ${docdir}
+exec_prefix = ${prefix}
+host = i686-pc-linux-gnu
+host_alias = 
+host_cpu = i686
+host_os = linux-gnu
+host_vendor = pc
+htmldir = ${docdir}
+includedir = ${prefix}/include
+infodir = ${datarootdir}/info
+install_sh = $(SHELL) /home/jason/Desktop/Xorg/driver/TipCode/install-sh
+libdir = ${exec_prefix}/lib
+libexecdir = ${exec_prefix}/libexec
+localedir = ${datarootdir}/locale
+localstatedir = ${prefix}/var
+mandir = ${datarootdir}/man
+mkdir_p = /bin/mkdir -p
+moduledir = ${exec_prefix}/lib/xorg/modules
+oldincludedir = /usr/include
+pdfdir = ${docdir}
+prefix = /home/jason/Desktop/Xorg/compiled/1.6.0/
+program_transform_name = s,x,x,
+psdir = ${docdir}
+sbindir = ${exec_prefix}/sbin
+sharedstatedir = ${prefix}/com
+srcdir = .
+sysconfdir = ${prefix}/etc
+target_alias = 
+top_builddir = ..
+top_srcdir = ..
+
+# this is obnoxious:
+# -module lets us name the module exactly how we want
+# -avoid-version prevents gratuitous .0.0.0 version numbers on the end
+# _ladir passes a dummy rpath to libtool so the thing will actually link
+# TODO: -nostdlib/-Bstatic/-lgcc platform magic, not installing the .a, etc.
+AM_CFLAGS = -I/home/jason/Desktop/Xorg/compiled/1.6.0//include/xorg -I/home/jason/Desktop/Xorg/compiled/1.6.0//include/pixman-1 -I/home/jason/Desktop/Xorg/compiled/1.6.0//include -I/home/jason/Desktop/Xorg/compiled/1.6.0/include  
+rdc_drv_la_LTLIBRARIES = rdc_drv.la
+rdc_drv_la_LDFLAGS = -module -avoid-version 
+rdc_drv_ladir = ${exec_prefix}/lib/xorg/modules/drivers
+rdc_drv_la_SOURCES = \
+	rdc_2dtool.c 	\
+	rdc_accel.c 	\
+	rdc_cursor.c 	\
+	rdc_driver.c 	\
+	rdc_mode.c 	\
+	rdc_tool.c 	\
+	rdc_vgatool.c 	\
+	rdc_video.c	\
+	rdc_extension.c \
+	CInt10.c        
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  src/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+install-rdc_drv_laLTLIBRARIES: $(rdc_drv_la_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(rdc_drv_ladir)" || $(MKDIR_P) "$(DESTDIR)$(rdc_drv_ladir)"
+	@list='$(rdc_drv_la_LTLIBRARIES)'; for p in $$list; do \
+	  if test -f $$p; then \
+	    f=$(am__strip_dir) \
+	    echo " $(LIBTOOL) --mode=install $(rdc_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(rdc_drv_ladir)/$$f'"; \
+	    $(LIBTOOL) --mode=install $(rdc_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(rdc_drv_ladir)/$$f"; \
+	  else :; fi; \
+	done
+
+uninstall-rdc_drv_laLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(rdc_drv_la_LTLIBRARIES)'; for p in $$list; do \
+	  p=$(am__strip_dir) \
+	  echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(rdc_drv_ladir)/$$p'"; \
+	  $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(rdc_drv_ladir)/$$p"; \
+	done
+
+clean-rdc_drv_laLTLIBRARIES:
+	-test -z "$(rdc_drv_la_LTLIBRARIES)" || rm -f $(rdc_drv_la_LTLIBRARIES)
+	@list='$(rdc_drv_la_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+rdc_drv.la: $(rdc_drv_la_OBJECTS) $(rdc_drv_la_DEPENDENCIES) 
+	$(rdc_drv_la_LINK) -rpath $(rdc_drv_ladir) $(rdc_drv_la_OBJECTS) $(rdc_drv_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+include ./$(DEPDIR)/CInt10.Plo
+include ./$(DEPDIR)/rdc_2dtool.Plo
+include ./$(DEPDIR)/rdc_accel.Plo
+include ./$(DEPDIR)/rdc_cursor.Plo
+include ./$(DEPDIR)/rdc_driver.Plo
+include ./$(DEPDIR)/rdc_extension.Plo
+include ./$(DEPDIR)/rdc_mode.Plo
+include ./$(DEPDIR)/rdc_tool.Plo
+include ./$(DEPDIR)/rdc_vgatool.Plo
+include ./$(DEPDIR)/rdc_video.Plo
+
+.c.o:
+	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+#	source='$<' object='$@' libtool=no \
+#	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \
+#	$(COMPILE) -c $<
+
+.c.obj:
+	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+#	source='$<' object='$@' libtool=no \
+#	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \
+#	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+#	source='$<' object='$@' libtool=yes \
+#	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \
+#	$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	    $$tags $$unique; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+	for dir in "$(DESTDIR)$(rdc_drv_ladir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-rdc_drv_laLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-rdc_drv_laLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-info: install-info-am
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-ps: install-ps-am
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-rdc_drv_laLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-rdc_drv_laLTLIBRARIES ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-rdc_drv_laLTLIBRARIES install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags uninstall uninstall-am uninstall-rdc_drv_laLTLIBRARIES
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..514fd7f
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,43 @@
+#  Copyright 2005 Adam Jackson.
+#
+#  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, sub
+#  license, and/or sell copies of the Software, and to permit persons to whom
+#  the Software is furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice (including the next
+#  paragraph) shall be included in all copies or substantial portions of the
+#  Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+#  ADAM JACKSON 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.
+
+# this is obnoxious:
+# -module lets us name the module exactly how we want
+# -avoid-version prevents gratuitous .0.0.0 version numbers on the end
+# _ladir passes a dummy rpath to libtool so the thing will actually link
+# TODO: -nostdlib/-Bstatic/-lgcc platform magic, not installing the .a, etc.
+AM_CFLAGS = @XORG_CFLAGS@
+
+rdc_drv_la_LTLIBRARIES = rdc_drv.la
+rdc_drv_la_LDFLAGS = -module -avoid-version 
+rdc_drv_ladir = @moduledir@/drivers
+
+rdc_drv_la_SOURCES =	\
+	rdc_2dtool.c 	\
+	rdc_accel.c 	\
+	rdc_cursor.c 	\
+	rdc_driver.c 	\
+	rdc_mode.c 	\
+	rdc_tool.c 	\
+	rdc_vgatool.c 	\
+	rdc_video.c	\
+	rdc_extension.c \
+	CInt10.c        
+
diff --git a/src/Makefile.in b/src/Makefile.in
new file mode 100644
index 0000000..19db917
--- /dev/null
+++ b/src/Makefile.in
@@ -0,0 +1,533 @@
+# Makefile.in generated by automake 1.10 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+#  Copyright 2005 Adam Jackson.
+#
+#  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, sub
+#  license, and/or sell copies of the Software, and to permit persons to whom
+#  the Software is furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice (including the next
+#  paragraph) shall be included in all copies or substantial portions of the
+#  Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+#  ADAM JACKSON 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.
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
+am__installdirs = "$(DESTDIR)$(rdc_drv_ladir)"
+rdc_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
+LTLIBRARIES = $(rdc_drv_la_LTLIBRARIES)
+rdc_drv_la_LIBADD =
+am_rdc_drv_la_OBJECTS = rdc_2dtool.lo rdc_accel.lo rdc_cursor.lo \
+	rdc_driver.lo rdc_mode.lo rdc_tool.lo rdc_vgatool.lo \
+	rdc_video.lo rdc_extension.lo CInt10.lo
+rdc_drv_la_OBJECTS = $(am_rdc_drv_la_OBJECTS)
+rdc_drv_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(rdc_drv_la_LDFLAGS) $(LDFLAGS) -o $@
+DEFAULT_INCLUDES = -I. -I$(top_builddir)@am__isrc@
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+SOURCES = $(rdc_drv_la_SOURCES)
+DIST_SOURCES = $(rdc_drv_la_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ADMIN_MAN_DIR = @ADMIN_MAN_DIR@
+ADMIN_MAN_SUFFIX = @ADMIN_MAN_SUFFIX@
+AMTAR = @AMTAR@
+APP_MAN_DIR = @APP_MAN_DIR@
+APP_MAN_SUFFIX = @APP_MAN_SUFFIX@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DRIVER_MAN_DIR = @DRIVER_MAN_DIR@
+DRIVER_MAN_SUFFIX = @DRIVER_MAN_SUFFIX@
+DRIVER_NAME = @DRIVER_NAME@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+FILE_MAN_DIR = @FILE_MAN_DIR@
+FILE_MAN_SUFFIX = @FILE_MAN_SUFFIX@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIB_MAN_DIR = @LIB_MAN_DIR@
+LIB_MAN_SUFFIX = @LIB_MAN_SUFFIX@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MISC_MAN_DIR = @MISC_MAN_DIR@
+MISC_MAN_SUFFIX = @MISC_MAN_SUFFIX@
+MKDIR_P = @MKDIR_P@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_CONFIG = @PKG_CONFIG@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+XORG_CFLAGS = @XORG_CFLAGS@
+XORG_LIBS = @XORG_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+moduledir = @moduledir@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+
+# this is obnoxious:
+# -module lets us name the module exactly how we want
+# -avoid-version prevents gratuitous .0.0.0 version numbers on the end
+# _ladir passes a dummy rpath to libtool so the thing will actually link
+# TODO: -nostdlib/-Bstatic/-lgcc platform magic, not installing the .a, etc.
+AM_CFLAGS = @XORG_CFLAGS@
+rdc_drv_la_LTLIBRARIES = rdc_drv.la
+rdc_drv_la_LDFLAGS = -module -avoid-version 
+rdc_drv_ladir = @moduledir@/drivers
+rdc_drv_la_SOURCES = \
+	rdc_2dtool.c 	\
+	rdc_accel.c 	\
+	rdc_cursor.c 	\
+	rdc_driver.c 	\
+	rdc_mode.c 	\
+	rdc_tool.c 	\
+	rdc_vgatool.c 	\
+	rdc_video.c	\
+	rdc_extension.c \
+	CInt10.c        
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  src/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+install-rdc_drv_laLTLIBRARIES: $(rdc_drv_la_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(rdc_drv_ladir)" || $(MKDIR_P) "$(DESTDIR)$(rdc_drv_ladir)"
+	@list='$(rdc_drv_la_LTLIBRARIES)'; for p in $$list; do \
+	  if test -f $$p; then \
+	    f=$(am__strip_dir) \
+	    echo " $(LIBTOOL) --mode=install $(rdc_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(rdc_drv_ladir)/$$f'"; \
+	    $(LIBTOOL) --mode=install $(rdc_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(rdc_drv_ladir)/$$f"; \
+	  else :; fi; \
+	done
+
+uninstall-rdc_drv_laLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(rdc_drv_la_LTLIBRARIES)'; for p in $$list; do \
+	  p=$(am__strip_dir) \
+	  echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(rdc_drv_ladir)/$$p'"; \
+	  $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(rdc_drv_ladir)/$$p"; \
+	done
+
+clean-rdc_drv_laLTLIBRARIES:
+	-test -z "$(rdc_drv_la_LTLIBRARIES)" || rm -f $(rdc_drv_la_LTLIBRARIES)
+	@list='$(rdc_drv_la_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+rdc_drv.la: $(rdc_drv_la_OBJECTS) $(rdc_drv_la_DEPENDENCIES) 
+	$(rdc_drv_la_LINK) -rpath $(rdc_drv_ladir) $(rdc_drv_la_OBJECTS) $(rdc_drv_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CInt10.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_2dtool.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_accel.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_cursor.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_driver.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_extension.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_mode.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_tool.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_vgatool.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdc_video.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	    $$tags $$unique; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+	for dir in "$(DESTDIR)$(rdc_drv_ladir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-rdc_drv_laLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-rdc_drv_laLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-info: install-info-am
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-ps: install-ps-am
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-rdc_drv_laLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-rdc_drv_laLTLIBRARIES ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-rdc_drv_laLTLIBRARIES install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags uninstall uninstall-am uninstall-rdc_drv_laLTLIBRARIES
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/rdc.h b/src/rdc.h
new file mode 100644
index 0000000..05ce1ed
--- /dev/null
+++ b/src/rdc.h
@@ -0,0 +1,320 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+
+#if XSERVER_LIBPCIACCESS
+#include <pciaccess.h>
+#endif
+
+#define PCI_DEV_MAP_FLAG_WRITABLE       (1U<<0)
+#define PCI_DEV_MAP_FLAG_WRITE_COMBINE  (1U<<1)
+#define PCI_DEV_MAP_FLAG_CACHABLE       (1U<<2)
+
+#if XSERVER_LIBPCIACCESS
+#define RDC_MEMBASE(p,n)  (p)->regions[(n)].base_addr
+#define VENDOR_ID(p)      (p)->vendor_id
+#define DEVICE_ID(p)      (p)->device_id
+#define SUBVENDOR_ID(p)   (p)->subvendor_id
+#define SUBSYS_ID(p)      (p)->subdevice_id
+#define CHIP_REVISION(p)  (p)->revision
+#else
+#define RDC_MEMBASE(p,n)  (p)->memBase[n]
+#define VENDOR_ID(p)      (p)->vendor
+#define DEVICE_ID(p)      (p)->chipType
+#define SUBVENDOR_ID(p)   (p)->subsysVendor
+#define SUBSYS_ID(p)      (p)->subsysCard
+#define CHIP_REVISION(p)  (p)->chipRev
+#endif
+
+/* Compiler Options */
+#define     Accel_2D
+#define     Accel_2D_DEBUG          0
+
+/* #define MMIO_2D */
+#define     HWC
+#define     HWC_DEBUG               0
+
+/* Vendor & Device Info */
+#ifndef PCI_VENDOR_RDC
+#define     PCI_VENDOR_RDC          0x17F3
+#endif
+
+#ifndef PCI_VENDOR_RDC_M2010_A0
+#define     PCI_VENDOR_RDC_M2010_A0 0x25F0
+#endif
+
+#ifndef PCI_CHIP_M2010
+#define     PCI_CHIP_M2010          0x2010
+#endif
+
+#ifndef PCI_CHIP_M2010_A0
+#define     PCI_CHIP_M2010_A0       0x17F3
+#endif
+
+#ifndef PCI_CHIP_M2011
+#define     PCI_CHIP_M2011          0x2011
+#endif
+
+typedef enum _CHIP_ID {
+    VGALegacy,
+    M2010,
+    M2011
+} CHIP_ID;
+
+/* RDC REC Info */
+#define RDC_NAME                "RDC"
+#define RDC_DRIVER_NAME         "rdc"
+#define RDC_MAJOR_VERSION       0
+#define RDC_MINOR_VERSION       0
+#define RDC_PATCH_VERSION       6
+#define RDC_VERSION    \
+        ((RDC_MAJOR_VERSION << 20) | (RDC_MINOR_VERSION << 10) | RDC_PATCH_VERSION)
+
+/* Customized Info */
+#define DEFAULT_VIDEOMEM_SIZE   0x00800000
+#define DEFAULT_MMIO_SIZE       0x00020000
+#define DEFAULT_CMDQ_SIZE       0x00100000
+#define MIN_CMDQ_SIZE           0x00040000
+#define CMD_QUEUE_GUARD_BAND    0x00000020
+#define DEFAULT_HWC_NUM         0x00000002
+
+/* Data Type Definition */
+typedef INT32       LONG;
+typedef CARD8       UCHAR;
+typedef CARD16      USHORT;
+typedef CARD32      ULONG;
+
+/* Verberse level define */
+#define ErrorLevel             0    /* Report Error message */
+#define DefaultLevel           4    /* Driver entry function */
+#define InfoLevel              5    /* Report information    */
+#define InternalLevel          6    /* Driver interanl function entry     */
+
+
+#define BIT0                    0x00000001
+#define BIT1                    0x00000002
+#define BIT2                    0x00000004
+#define BIT3                    0x00000008
+#define BIT4                    0x00000010
+#define BIT5                    0x00000020
+#define BIT6                    0x00000040
+#define BIT7                    0x00000080
+#define BIT8                    0x00000100
+#define BIT9                    0x00000200
+#define BIT10                   0x00000400
+#define BIT11                   0x00000800
+#define BIT12                   0x00001000
+#define BIT13                   0x00002000
+#define BIT14                   0x00004000
+#define BIT15                   0x00008000
+#define BIT16                   0x00010000
+#define BIT17                   0x00020000
+#define BIT18                   0x00040000
+#define BIT19                   0x00080000
+#define BIT20                   0x00100000
+#define BIT21                   0x00200000
+#define BIT22                   0x00400000
+#define BIT23                   0x00800000
+#define BIT24                   0x01000000
+#define BIT25                   0x02000000
+#define BIT26                   0x04000000
+#define BIT27                   0x08000000
+#define BIT28                   0x10000000
+#define BIT29                   0x20000000
+#define BIT30                   0x40000000
+#define BIT31                   0x80000000
+
+#define BIOS_ROM_PATH_FILE      "//root//RDCVBIOS.ROM"
+#define BIOS_ROM_SIZE           32*1024
+#define BIOS_ROM_PHY_BASE       0xC0000
+
+
+
+/* Data Structure Definition */
+typedef struct _RDCRegRec {
+/*    UCHAR   ucScratch[0x1F];*/
+    UCHAR   ucPLLValue[3];
+    UCHAR   ucCRA3;
+    UCHAR   ucSR58;
+} RDCRegRec, *RDCRegPtr;
+
+typedef struct _VIDEOMODE {
+
+    int     ScreenWidth;
+    int     ScreenHeight;
+    int     bitsPerPixel;
+    int     Bpp;
+    int     ScreenPitch;
+        
+} VIDEOMODE, *PVIDEOMODE;
+
+typedef struct {
+
+    ULONG   ulCMDQSize;
+    ULONG   ulCMDQType;
+    
+    ULONG   ulCMDQOffsetAddr;
+    UCHAR   *pjCMDQVirtualAddr;
+    
+    UCHAR   *pjCmdQBasePort;
+    UCHAR   *pjWritePort;
+    UCHAR   *pjReadPort;
+    UCHAR   *pjEngStatePort;
+          
+    ULONG   ulCMDQMask;
+    ULONG   ulCurCMDQueueLen;
+                
+    ULONG   ulWritePointer;
+    ULONG   ulReadPointer;
+    
+    ULONG   ulReadPointer_OK;       /* for Eng_DBGChk */
+    
+} CMDQINFO, *PCMDQINFO;
+
+typedef struct {
+
+    ULONG   fg;
+    ULONG   bg;
+    UCHAR   *pjPatternVirtualAddr;
+    UCHAR   ucXorBitmap[64*64/8];
+    UCHAR   ucAndBitmap[64*64/8];
+        
+} MONOHWC, *PMONOHWC;
+
+typedef struct {
+
+    int     HWC_NUM;
+    int     HWC_NUM_Next;
+
+    ULONG   ulHWCOffsetAddr;
+    UCHAR   *pjHWCVirtualAddr;
+    
+    USHORT  cursortype;
+    USHORT  width;
+    USHORT  height;
+    USHORT  xhot;
+    USHORT  yhot;
+    USHORT  offset_x;
+    USHORT  offset_y;
+    int     iScreenOffset_x;
+    int     iScreenOffset_y;
+    MONOHWC MonoHWC;
+
+} HWCINFO, *PHWCINFO;
+
+typedef struct {
+    ULONG   ulHorMaxResolution;
+    ULONG   ulVerMaxResolution;
+} MONITORSIZE;
+
+typedef struct {
+    Bool    EnableHorScaler;
+    Bool    EnableVerScaler;
+    int     ulHorScalingFactor;
+    int     ulVerScalingFactor;
+} SCALER;
+
+typedef struct {
+    UCHAR       ucDeviceID;
+    UCHAR       ucDisplayPath;
+    MONITORSIZE MonitorSize;
+    SCALER      ScalerConfig;
+    /* current mode: uce pScrn->currentMode */
+} DEVICEINFO;
+
+typedef struct {
+    Bool    	bOverlayEnable;
+    int         iSrcWidth;
+    int         iSrcHeight;
+    int         iDstLeft;
+    int         iDstTop;
+    int         iDstWidth;
+    int         iDstHeight;
+} OVERLAY_STATUS;
+
+
+
+typedef struct _RDCRec {
+
+    EntityInfoPtr       pEnt;
+#if XSERVER_LIBPCIACCESS
+    struct pci_device   *PciInfo;
+#else
+    pciVideoPtr         PciInfo;
+    PCITAG              PciTag;
+#endif
+
+
+    OptionInfoPtr       Options;
+    DisplayModePtr      ModePtr;        /* duplicate of pScrn->currentMode, delete this one */
+    XAAInfoRecPtr       AccelInfoPtr;
+    xf86CursorInfoPtr   HWCInfoPtr;
+    
+    VIDEOMODE           VideoModeInfo;          /* duplicate of pScrn->currentMode, delete this one */
+    RDCRegRec           SavedReg;
+    CMDQINFO            CMDQInfo;
+    HWCINFO             HWCInfo;
+    OVERLAY_STATUS      OverlayStatus;
+    DEVICEINFO          DeviceInfo;
+    ULONG               ulCMDReg;
+    Bool                EnableClip;
+
+    /* adapter information */
+    UCHAR               jChipType;
+
+    ULONG               ENGCaps;
+    ULONG               FBPhysAddr;             /* Frame buffer physical address     */
+    UCHAR               *FBVirtualAddr;         /* Map of frame buffer               */
+    unsigned long       FbMapSize;
+    unsigned long       AvailableFBsize;
+    
+    ULONG               MMIOPhysAddr;           /* MMIO region physical address      */
+    UCHAR               *MMIOVirtualAddr;       /* Map of MMIO region                */
+    unsigned long       MMIOMapSize;
+    
+    UCHAR               *BIOSVirtualAddr;       /* BIOS virtual address              */
+    ULONG               ulROMType;              /* 0: no BIOS 1: VBIOS, 2: ROM file */
+
+    ULONG               MemoryBandwidth;        /* The unit is MB*/ 
+
+    IOADDRESS           IODBase;                /* Base of PIO memory area */
+    IOADDRESS           PIOOffset;
+    IOADDRESS           RelocateIO;
+
+    USHORT              usSupportDevice;
+
+    Bool                noAccel;
+    Bool                noHWC;
+    Bool                MMIO2D;
+    int                 DBGSelect;
+    
+    CloseScreenProcPtr  CloseScreen;
+} RDCRec, *RDCRecPtr;
+
+#define RDCPTR(p) ((RDCRecPtr)((p)->driverPrivate))
+#define MODE_PRIVATE_PTR(p) ((MODE_PRIVATE*)(p->Private))
+
+/* Include Files */
+#include "rdc_mode.h"
+#include "rdc_vgatool.h"
+#include "rdc_2dtool.h"
+#include "rdc_cursor.h"
+#include "CInt10.h"
+#include "rdc_video.h"
diff --git a/src/rdc_2dtool.c b/src/rdc_2dtool.c
new file mode 100644
index 0000000..16d9e26
--- /dev/null
+++ b/src/rdc_2dtool.c
@@ -0,0 +1,315 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+#ifdef Accel_2D
+
+/* Prototype type declaration */
+Bool    bInitCMDQInfo(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+Bool    bEnableCMDQ(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+Bool    bEnable2D(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+void    vDisable2D(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+void    vWaitEngIdle(ScrnInfoPtr pScrn, RDCRecPtr pRDC);    
+UCHAR   *pjRequestCMDQ(RDCRecPtr pRDC, ULONG   ulDataLen);
+
+Bool
+bInitCMDQInfo(ScrnInfoPtr pScrn, RDCRecPtr pRDC)
+{
+
+    ScreenPtr pScreen;
+    
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Init CMDQ Info== \n");
+    
+    pRDC->CMDQInfo.pjCmdQBasePort    = pRDC->MMIOVirtualAddr+ 0x8044; 
+    pRDC->CMDQInfo.pjWritePort       = pRDC->MMIOVirtualAddr+ 0x8048;
+    pRDC->CMDQInfo.pjReadPort        = pRDC->MMIOVirtualAddr+ 0x804C;
+    pRDC->CMDQInfo.pjEngStatePort    = pRDC->MMIOVirtualAddr+ 0x804C;
+
+    /* CMDQ mode Init */
+    if (!pRDC->MMIO2D) 
+    {
+        pRDC->CMDQInfo.ulCMDQType = VM_CMD_QUEUE;    
+       
+        pScreen = screenInfo.screens[pScrn->scrnIndex];
+        
+        pRDC->CMDQInfo.pjCMDQVirtualAddr = pRDC->FBVirtualAddr + pRDC->CMDQInfo.ulCMDQOffsetAddr;
+        pRDC->CMDQInfo.ulCurCMDQueueLen = pRDC->CMDQInfo.ulCMDQSize - CMD_QUEUE_GUARD_BAND;
+        pRDC->CMDQInfo.ulCMDQMask = pRDC->CMDQInfo.ulCMDQSize - 1 ; 
+    }
+    
+    /* MMIO mode init */  
+    if (pRDC->MMIO2D)
+    {        
+        pRDC->CMDQInfo.ulCMDQType = VM_CMD_MMIO;        
+    }
+       
+    return (TRUE);    
+}
+
+Bool
+bEnableCMDQ(ScrnInfoPtr pScrn, RDCRecPtr pRDC)
+{
+    ULONG ulVMCmdQBasePort = 0;
+    
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Entry Enable CMDQ== \n");
+
+    vWaitEngIdle(pScrn, pRDC);  
+
+    /* set DBG Select Info */
+    if (pRDC->DBGSelect)
+    {
+        *(ULONG *) (pRDC->MMIOVirtualAddr + 0x804C) = (ULONG) (pRDC->DBGSelect);                 
+    }
+    
+    /* set CMDQ base */
+    switch (pRDC->CMDQInfo.ulCMDQType)
+    {
+    case VM_CMD_QUEUE:
+        ulVMCmdQBasePort  = pRDC->CMDQInfo.ulCMDQOffsetAddr >> 3;
+ 
+        /* set CMDQ Threshold */
+        ulVMCmdQBasePort |= 0xF0000000;               
+
+        /* set CMDQ Size */
+        switch (pRDC->CMDQInfo.ulCMDQSize)
+        {
+        case CMD_QUEUE_SIZE_256K:
+            ulVMCmdQBasePort |= 0x00000000;   
+            break;
+
+        case CMD_QUEUE_SIZE_512K:
+            ulVMCmdQBasePort |= 0x04000000;   
+            break;
+      
+        case CMD_QUEUE_SIZE_1M:
+            ulVMCmdQBasePort |= 0x08000000;       
+            break;
+            
+        case CMD_QUEUE_SIZE_2M:
+            ulVMCmdQBasePort |= 0x0C000000;       
+            break;        
+            
+        default:
+            return(FALSE);
+            break;
+        }     
+                                 
+        *(ULONG *) (pRDC->CMDQInfo.pjCmdQBasePort) = ulVMCmdQBasePort;         
+        pRDC->CMDQInfo.ulWritePointer = *(ULONG *) (pRDC->CMDQInfo.pjWritePort) << 3;                 
+        break;
+        
+    case VM_CMD_MMIO:
+        /* set CMDQ Threshold */
+        ulVMCmdQBasePort |= 0xF0000000;               
+        ulVMCmdQBasePort |= 0x02000000;            /* MMIO mode */
+        *(ULONG *) (pRDC->CMDQInfo.pjCmdQBasePort) = ulVMCmdQBasePort;                                
+        break;
+        
+    default:
+        return (FALSE);
+        break;
+    }
+
+    return (TRUE);    
+}
+
+Bool
+bEnable2D(ScrnInfoPtr pScrn, RDCRecPtr pRDC)
+{
+
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Enable 2D== \n");
+    
+    SetIndexRegMask(CRTC_PORT, 0xA4, 0xFE, 0x01);        /* enable 2D */
+
+    SetIndexRegMask(CRTC_PORT, 0xA3, ~0x20, 0x20);       /* enable flip */    
+    *(ULONG *)MMIOREG_1ST_FLIP |=  0x80000000;
+
+    if (!bInitCMDQInfo(pScrn, pRDC))
+    {
+        vDisable2D(pScrn, pRDC);      
+        return (FALSE);
+    }
+        
+    if (!bEnableCMDQ(pScrn, pRDC))
+    {
+        vDisable2D(pScrn, pRDC);      
+        return (FALSE);
+    }
+            
+    return (TRUE);    
+}
+
+void
+vDisable2D(ScrnInfoPtr pScrn, RDCRecPtr pRDC)
+{
+   xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Engine Disable 2D== \n");
+
+    vWaitEngIdle(pScrn, pRDC);
+    vWaitEngIdle(pScrn, pRDC);
+    SetIndexRegMask(CRTC_PORT, 0xA4, 0xFE, 0x00);
+
+    SetIndexRegMask(CRTC_PORT, 0xA3, ~0x20, 0x00);       /* disable flip */
+    *(ULONG *)MMIOREG_1ST_FLIP &=  ~0x80000000;
+}
+
+
+void
+vWaitEngIdle(ScrnInfoPtr pScrn, RDCRecPtr pRDC)
+{
+    ULONG  ulEngState, ulEngState2;
+
+    xf86DrvMsgVerb(0, X_INFO, 10, "==Entry Wait Idle== \n");
+
+    do  /* wait engine idle */
+    {
+        ulEngState = *((volatile ULONG*)(pRDC->MMIOVirtualAddr + 0x804c));    
+        ulEngState2 = *((volatile ULONG*)(pRDC->MMIOVirtualAddr + 0x8048));        
+    } while ((ulEngState & 0x80000000) || 
+            ((ulEngState&0x3ffff) != (ulEngState2&0x3ffff)));
+            
+    xf86DrvMsgVerb(0, X_INFO, 10, "==Exit Wait Idle== \n");
+}    
+
+/* ULONG ulGetCMDQLength() */
+__inline ULONG ulGetCMDQLength(RDCRecPtr pRDC, ULONG ulWritePointer, ULONG ulCMDQMask)
+{
+    ULONG ulReadPointer, ulReadPointer2;
+
+    do {
+        ulReadPointer  = *((volatile ULONG *)(pRDC->CMDQInfo.pjReadPort)) & 0x0003FFFF;        
+        ulReadPointer2 = *((volatile ULONG *)(pRDC->CMDQInfo.pjReadPort)) & 0x0003FFFF;
+        ulReadPointer2 = *((volatile ULONG *)(pRDC->CMDQInfo.pjReadPort)) & 0x0003FFFF;
+        ulReadPointer2 = *((volatile ULONG *)(pRDC->CMDQInfo.pjReadPort)) & 0x0003FFFF;
+        ulReadPointer2 = *((volatile ULONG *)(pRDC->CMDQInfo.pjReadPort)) & 0x0003FFFF;
+        ulReadPointer2 = *((volatile ULONG *)(pRDC->CMDQInfo.pjReadPort)) & 0x0003FFFF;        
+     } while (ulReadPointer != ulReadPointer2);
+
+    return ((ulReadPointer << 3) - ulWritePointer - CMD_QUEUE_GUARD_BAND) & ulCMDQMask;
+}
+
+UCHAR *pjRequestCMDQ(
+RDCRecPtr pRDC, ULONG   ulDataLen)
+{
+    UCHAR   *pjBuffer;
+    ULONG   i, ulWritePointer, ulCMDQMask, ulCurCMDQLen, ulContinueCMDQLen;
+
+    ulWritePointer = pRDC->CMDQInfo.ulWritePointer;
+    ulContinueCMDQLen = pRDC->CMDQInfo.ulCMDQSize - ulWritePointer;
+    ulCMDQMask = pRDC->CMDQInfo.ulCMDQMask;        
+    
+    if (ulContinueCMDQLen >= ulDataLen)
+    {
+        /* Get CMDQ Buffer */                
+        if (pRDC->CMDQInfo.ulCurCMDQueueLen < ulDataLen)
+        {
+            do
+            {
+                ulCurCMDQLen = ulGetCMDQLength(pRDC, ulWritePointer, ulCMDQMask);
+            } while (ulCurCMDQLen < ulDataLen);
+            
+            pRDC->CMDQInfo.ulCurCMDQueueLen = ulCurCMDQLen;
+        }
+        
+        pjBuffer = pRDC->CMDQInfo.pjCMDQVirtualAddr + ulWritePointer;
+        pRDC->CMDQInfo.ulCurCMDQueueLen -= ulDataLen;            
+        pRDC->CMDQInfo.ulWritePointer = (ulWritePointer + ulDataLen) & ulCMDQMask;
+        return pjBuffer;            
+    }
+    else
+    {   
+
+        /* Fill NULL CMD to the last of the CMDQ */
+        if (pRDC->CMDQInfo.ulCurCMDQueueLen < ulContinueCMDQLen)
+        {
+            do
+            {
+                ulCurCMDQLen = ulGetCMDQLength(pRDC, ulWritePointer, ulCMDQMask);
+            } while (ulCurCMDQLen < ulContinueCMDQLen);
+            
+            pRDC->CMDQInfo.ulCurCMDQueueLen = ulCurCMDQLen;
+        }
+    
+        pjBuffer = pRDC->CMDQInfo.pjCMDQVirtualAddr + ulWritePointer;
+        
+        for (i = 0; i<ulContinueCMDQLen/8; i++, pjBuffer+=8)
+        {
+            *(ULONG *)pjBuffer = (ULONG) PKT_NULL_CMD;
+            *(ULONG *) (pjBuffer+4) = 0;
+        }
+        
+        pRDC->CMDQInfo.ulCurCMDQueueLen -= ulContinueCMDQLen;
+        pRDC->CMDQInfo.ulWritePointer = ulWritePointer = 0;
+            
+        /* Get CMDQ Buffer */    
+        if (pRDC->CMDQInfo.ulCurCMDQueueLen < ulDataLen)
+        {
+            do
+            {
+                ulCurCMDQLen = ulGetCMDQLength(pRDC, ulWritePointer, ulCMDQMask);
+            } while (ulCurCMDQLen < ulDataLen);
+
+            pRDC->CMDQInfo.ulCurCMDQueueLen = ulCurCMDQLen;
+        }
+
+        pRDC->CMDQInfo.ulCurCMDQueueLen -= ulDataLen;
+        pjBuffer = pRDC->CMDQInfo.pjCMDQVirtualAddr + ulWritePointer;
+        pRDC->CMDQInfo.ulWritePointer = (ulWritePointer + ulDataLen) & ulCMDQMask;
+        return pjBuffer;            
+    }
+   
+} /* end of pjRequestCmdQ() */
+
+#endif    /* end of Accel_2D */
diff --git a/src/rdc_2dtool.h b/src/rdc_2dtool.h
new file mode 100644
index 0000000..1763f2c
--- /dev/null
+++ b/src/rdc_2dtool.h
@@ -0,0 +1,496 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+
+/* Eng Capability Definition */
+#define    ENG_CAP_Sync                         0x00000001
+#define    ENG_CAP_ScreenToScreenCopy           0x00000002
+#define    ENG_CAP_SolidFill                    0x00000004
+#define    ENG_CAP_SolidLine                    0x00000008
+#define    ENG_CAP_DashedLine                   0x00000010
+#define    ENG_CAP_Mono8x8PatternFill           0x00000020
+#define    ENG_CAP_Color8x8PatternFill          0x00000040
+#define    ENG_CAP_CPUToScreenColorExpand       0x00000080
+#define    ENG_CAP_ScreenToScreenColorExpand    0x00000100
+#define    ENG_CAP_Clipping                     0x00000200    
+#define ENG_CAP_ALL (ENG_CAP_Sync | ENG_CAP_ScreenToScreenCopy | ENG_CAP_SolidFill |    \
+                     ENG_CAP_SolidLine | ENG_CAP_DashedLine |                \
+                     ENG_CAP_Mono8x8PatternFill | ENG_CAP_Color8x8PatternFill |        \
+                     ENG_CAP_Clipping);
+
+#define    ENG_CAP_VIDEO_DISP                   0x00000400
+#define    ENG_CAP_VIDEO_POS                    0x00000800
+#define    ENG_CAP_HWC_MMIO                     0x00001000
+
+/* CMDQ Definition */
+#define    VM_CMD_QUEUE             0
+#define    VM_CMD_MMIO              2
+
+#define    CMD_QUEUE_SIZE_256K      0x00040000
+#define    CMD_QUEUE_SIZE_512K      0x00080000
+#define    CMD_QUEUE_SIZE_1M        0x00100000
+#define    CMD_QUEUE_SIZE_2M        0x00200000
+#define    CMD_QUEUE_SIZE_4M        0x00400000
+
+/* CMD Type Info */
+#define    PKT_NULL_CMD             0x00009561
+
+#define    PKT_SINGLE_LENGTH        8
+#define    PKT_SINGLE_CMD_HEADER    0x00009562
+
+typedef struct  _PKT_SC
+{
+    ULONG    PKT_SC_dwHeader;
+    ULONG    PKT_SC_dwData[1];
+    
+} PKT_SC, *PPKT_SC;
+
+/* Eng Reg. Limitation */
+#define    MAX_SRC_X                0x7FF
+#define    MAX_SRC_Y                0x7FF
+#define    MAX_DST_X                0x7FF
+#define    MAX_DST_Y                0x7FF
+
+#define    MASK_SRC_PITCH           0x1FFF
+#define    MASK_DST_PITCH           0x1FFF
+#define    MASK_DST_HEIGHT          0x7FF
+#define    MASK_SRC_X               0xFFF
+#define    MASK_SRC_Y               0xFFF
+#define    MASK_DST_X               0xFFF
+#define    MASK_DST_Y               0xFFF
+#define    MASK_RECT_WIDTH          0x7FF
+#define    MASK_RECT_HEIGHT         0x7FF
+#define MASK_CLIP                   0xFFF
+#define MASK_1ST_FLIP_BASE          0x0FFFFFF8
+
+#define MASK_LINE_X                 0xFFF   
+#define MASK_LINE_Y                 0xFFF
+#define MASK_LINE_ERR               0x3FFFFF        
+#define MASK_LINE_WIDTH             0x7FF        
+#define MASK_LINE_K1                0x3FFFFF           
+#define MASK_LINE_K2                0x3FFFFF
+#define MASK_M2010LINE_X              0xFFF   
+#define MASK_M2010LINE_Y              0xFFF
+
+#define MAX_PATReg_Size             256
+
+/* Eng Reg. Definition */  
+/* MMIO Reg */
+#define MMIOREG_SRC_BASE    (pRDC->MMIOVirtualAddr + 0x8000)                
+#define MMIOREG_SRC_PITCH   (pRDC->MMIOVirtualAddr + 0x8004)
+#define MMIOREG_DST_BASE    (pRDC->MMIOVirtualAddr + 0x8008)
+#define MMIOREG_DST_PITCH   (pRDC->MMIOVirtualAddr + 0x800C)
+#define MMIOREG_DST_XY      (pRDC->MMIOVirtualAddr + 0x8010)
+#define MMIOREG_SRC_XY      (pRDC->MMIOVirtualAddr + 0x8014)
+#define MMIOREG_RECT_XY     (pRDC->MMIOVirtualAddr + 0x8018)
+#define MMIOREG_FG          (pRDC->MMIOVirtualAddr + 0x801C)
+#define MMIOREG_BG          (pRDC->MMIOVirtualAddr + 0x8020)
+#define MMIOREG_FG_SRC      (pRDC->MMIOVirtualAddr + 0x8024)
+#define MMIOREG_BG_SRC      (pRDC->MMIOVirtualAddr + 0x8028)
+#define MMIOREG_MONO1       (pRDC->MMIOVirtualAddr + 0x802C)
+#define MMIOREG_MONO2       (pRDC->MMIOVirtualAddr + 0x8030)
+#define MMIOREG_CLIP1       (pRDC->MMIOVirtualAddr + 0x8034)
+#define MMIOREG_CLIP2       (pRDC->MMIOVirtualAddr + 0x8038)
+#define MMIOREG_CMD         (pRDC->MMIOVirtualAddr + 0x803C)
+#define MMIOREG_1ST_FLIP    (pRDC->MMIOVirtualAddr + 0x8040)
+#define MMIOREG_PAT         (pRDC->MMIOVirtualAddr + 0x8100)    
+
+#define MMIOREG_LINE_XY     (pRDC->MMIOVirtualAddr + 0x8010)  
+#define MMIOREG_LINE_Err    (pRDC->MMIOVirtualAddr + 0x8014)  
+#define MMIOREG_LINE_WIDTH  (pRDC->MMIOVirtualAddr + 0x8018)  
+#define MMIOREG_LINE_K1     (pRDC->MMIOVirtualAddr + 0x8024)  
+#define MMIOREG_LINE_K2     (pRDC->MMIOVirtualAddr + 0x8028)  
+#define MMIOREG_LINE_STYLE1 (pRDC->MMIOVirtualAddr + 0x802C)  
+#define MMIOREG_LINE_STYLE2 (pRDC->MMIOVirtualAddr + 0x8030)  
+#define MMIOREG_LINE_XY2    (pRDC->MMIOVirtualAddr + 0x8014)
+#define MMIOREG_LINE_NUMBER (pRDC->MMIOVirtualAddr + 0x8018)  
+
+/* CMDQ Reg */
+#define CMDQREG_SRC_BASE    (0x00 << 24)                       
+#define CMDQREG_SRC_PITCH   (0x01 << 24)
+#define CMDQREG_DST_BASE    (0x02 << 24)
+#define CMDQREG_DST_PITCH   (0x03 << 24)
+#define CMDQREG_DST_XY      (0x04 << 24)
+#define CMDQREG_SRC_XY      (0x05 << 24)
+#define CMDQREG_RECT_XY     (0x06 << 24)
+#define CMDQREG_FG          (0x07 << 24)
+#define CMDQREG_BG          (0x08 << 24)
+#define CMDQREG_FG_SRC      (0x09 << 24)
+#define CMDQREG_BG_SRC      (0x0A << 24)
+#define CMDQREG_MONO1       (0x0B << 24)
+#define CMDQREG_MONO2       (0x0C << 24)
+#define CMDQREG_CLIP1       (0x0D << 24)
+#define CMDQREG_CLIP2       (0x0E << 24)
+#define CMDQREG_CMD         (0x0F << 24)
+#define CMDQREG_PAT         (0x40 << 24)
+
+#define CMDQREG_LINE_XY     (0x04 << 24)
+#define CMDQREG_LINE_Err    (0x05 << 24)  
+#define CMDQREG_LINE_WIDTH  (0x06 << 24)    
+#define CMDQREG_LINE_K1     (0x09 << 24) 
+#define CMDQREG_LINE_K2     (0x0A << 24)
+#define CMDQREG_LINE_STYLE1 (0x0B << 24) 
+#define CMDQREG_LINE_STYLE2 (0x0C << 24)
+#define CMDQREG_LINE_XY2    (0x05 << 24)
+#define CMDQREG_LINE_NUMBER (0x06 << 24)    
+
+/* CMD Reg. Definition */
+#define CMD_BITBLT              0x00000000
+#define CMD_LINEDRAW            0x00000001
+#define CMD_COLOREXP            0x00000002
+#define CMD_ENHCOLOREXP         0x00000003
+#define CMD_TRANSPARENTBLT      0x00000004
+#define CMD_MASK                0x00000007
+                  
+#define CMD_DISABLE_CLIP        0x00000000   
+#define CMD_ENABLE_CLIP         0x00000008
+
+#define CMD_COLOR_08            0x00000000
+#define CMD_COLOR_16            0x00000010
+#define CMD_COLOR_32            0x00000020
+
+#define CMD_SRC_SIQ             0x00000040
+
+#define CMD_TRANSPARENT         0x00000080
+
+#define CMD_PAT_FGCOLOR         0x00000000
+#define CMD_PAT_MONOMASK        0x00010000
+#define CMD_PAT_PATREG          0x00020000
+
+#define CMD_OPAQUE              0x00000000
+#define CMD_FONT_TRANSPARENT    0x00040000
+
+#define CMD_X_INC               0x00000000    
+#define CMD_X_DEC               0x00200000
+
+#define CMD_Y_INC               0x00000000    
+#define CMD_Y_DEC               0x00100000
+
+#define CMD_NT_LINE             0x00000000
+#define CMD_NORMAL_LINE         0x00400000
+
+#define CMD_DRAW_LAST_PIXEL     0x00000000
+#define CMD_NOT_DRAW_LAST_PIXEL 0x00800000
+
+#define CMD_DISABLE_LINE_STYLE  0x00000000
+#define CMD_ENABLE_LINE_STYLE   0x40000000
+
+#define CMD_RESET_STYLE_COUNTER 0x80000000
+#define CMD_NOT_RESET_STYLE_COUNTER 0x00000000
+
+#define BURST_FORCE_CMD         0x80000000
+
+/* Line */
+#define LINEPARAM_XM            0x00000001
+#define LINEPARAM_X_DEC         0x00000002
+#define LINEPARAM_Y_DEC         0x00000004
+
+typedef struct _LINEPARAM {
+    USHORT  dsLineX;
+    USHORT  dsLineY;
+    USHORT  dsLineWidth;
+    ULONG   dwErrorTerm;
+    ULONG   dwK1Term;
+    ULONG   dwK2Term;
+    ULONG   dwLineAttributes;    
+} LINEPARAM, *PLINEPARAM;
+
+typedef struct {
+    LONG    X1;
+    LONG    Y1;
+    LONG    X2;
+    LONG    Y2;    
+} _LINEInfo;
+
+/* Macro */
+/* MMIO 2D Macro */
+#define RDCSetupSRCBase_MMIO(base) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_SRC_BASE) = (ULONG) (base); \
+        } while (*(volatile ULONG *)(MMIOREG_SRC_BASE) != (ULONG) (base)); \
+      }
+#define RDCSetupSRCPitch_MMIO(pitch) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_SRC_PITCH) = (ULONG)(pitch << 16); \
+        } while (*(volatile ULONG *)(MMIOREG_SRC_PITCH) != (ULONG)(pitch << 16)); \
+      }
+#define RDCSetupDSTBase_MMIO(base) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_DST_BASE) = (ULONG)(base); \
+        } while (*(volatile ULONG *)(MMIOREG_DST_BASE) != (ULONG)(base)); \
+      }      
+#define RDCSetupDSTPitchHeight_MMIO(pitch, height) \
+      { \
+        ULONG dstpitch; \
+        dstpitch = (ULONG)((pitch << 16) + ((height) & MASK_DST_HEIGHT)); \
+        do { \
+           *(ULONG *)(MMIOREG_DST_PITCH) = dstpitch; \
+        } while (*(volatile ULONG *)(MMIOREG_DST_PITCH) != dstpitch); \
+      }      
+#define RDCSetupDSTXY_MMIO(x, y) \
+      { \
+        ULONG dstxy; \
+        dstxy = (ULONG)(((x & MASK_DST_X) << 16) + (y & MASK_DST_Y)); \
+        do { \
+           *(ULONG *)(MMIOREG_DST_XY) = dstxy; \
+        } while (*(volatile ULONG *)(MMIOREG_DST_XY) != dstxy); \
+      }           
+#define RDCSetupSRCXY_MMIO(x, y) \
+      { \
+        ULONG srcxy; \
+        srcxy = (ULONG)(((x & MASK_SRC_X) << 16) + (y & MASK_SRC_Y)); \
+        do { \
+           *(ULONG *)(MMIOREG_SRC_XY) = srcxy; \
+        } while (*(volatile ULONG *)(MMIOREG_SRC_XY) != srcxy); \
+      }             
+#define RDCSetupRECTXY_MMIO(x, y) \
+      { \
+        ULONG rectxy; \
+        rectxy = (ULONG)(((x & MASK_RECT_WIDTH) << 16) + (y & MASK_RECT_WIDTH)); \
+        do { \
+           *(ULONG *)(MMIOREG_RECT_XY) = rectxy; \
+        } while (*(volatile ULONG *)(MMIOREG_RECT_XY) != rectxy); \
+      }  
+#define RDCSetupFG_MMIO(color) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_FG) = (ULONG)(color); \
+        } while (*(volatile ULONG *)(MMIOREG_FG) != (ULONG)(color)); \
+      } 
+#define RDCSetupBG_MMIO(color) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_BG) = (ULONG)(color); \
+        } while (*(volatile ULONG *)(MMIOREG_BG) != (ULONG)(color)); \
+      }
+#define RDCSetupMONO1_MMIO(pat) \
+      { \
+        do { \
+          *(ULONG *)(MMIOREG_MONO1) = (ULONG)(pat); \
+        } while (*(volatile ULONG *)(MMIOREG_MONO1) != (ULONG)(pat)); \
+      } 
+#define RDCSetupMONO2_MMIO(pat) \
+      { \
+        do { \
+          *(ULONG *)(MMIOREG_MONO2) = (ULONG)(pat); \
+        } while (*(volatile ULONG *)(MMIOREG_MONO2) != (ULONG)(pat)); \
+      }
+#define RDCSetupCLIP1_MMIO(left, top) \
+      { \
+       ULONG clip1; \
+       clip1 = (ULONG)(((left & MASK_CLIP) << 16) + (top & MASK_CLIP)); \
+       do { \
+          *(ULONG *)(MMIOREG_CLIP1) = clip1; \
+       } while (*(volatile ULONG *)(MMIOREG_CLIP1) != clip1); \
+      } 
+#define RDCSetupCLIP2_MMIO(right, bottom) \
+      { \
+       ULONG clip2; \
+       clip2 = (ULONG)(((right & MASK_CLIP) << 16) + (bottom & MASK_CLIP)); \
+       do { \
+          *(ULONG *)(MMIOREG_CLIP2) = clip2; \
+       } while (*(volatile ULONG *)(MMIOREG_CLIP2) != clip2); \
+      }                                                                                               
+#define RDCSetupCMDReg_MMIO(reg) \
+      { \
+        *(ULONG *)(MMIOREG_CMD) = (ULONG)(reg);    \
+      }
+#define RDCSetupPatReg_MMIO(patreg, pat) \
+      { \
+       do { \
+          *(ULONG *)(MMIOREG_PAT + patreg*4) = (ULONG)(pat); \
+       } while (*(volatile ULONG *)(MMIOREG_PAT + patreg*4) != (ULONG)(pat)); \
+      }      
+                                
+/* Line CMD */
+#define RDCSetupLineXMErrTerm_MMIO(xm, err) \
+      { \
+        ULONG lineerr; \
+        lineerr = (ULONG)((xm << 24) + (err & MASK_LINE_ERR)); \
+        do { \
+           *(ULONG *)(MMIOREG_LINE_Err) = lineerr; \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_Err) != lineerr); \
+      }      
+#define RDCSetupLineWidth_MMIO(width) \
+      { \
+        ULONG linewidth; \
+        linewidth = (ULONG)((width & MASK_LINE_WIDTH) << 16); \
+        do { \
+          *(ULONG *)(MMIOREG_LINE_WIDTH) = linewidth; \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_WIDTH) != linewidth); \
+      }
+#define RDCSetupLineK1Term_MMIO(err) \
+      { \
+        do { \
+          *(ULONG *)(MMIOREG_LINE_K1) = (ULONG)(err & MASK_LINE_K1); \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_K1) != (ULONG)(err & MASK_LINE_K1)); \
+      }            
+#define RDCSetupLineK2Term_MMIO(err) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_LINE_K2) = (ULONG)(err & MASK_LINE_K2); \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_K2) != (ULONG)(err & MASK_LINE_K2)); \
+      }
+#define RDCSetupLineStyle1_MMIO(pat) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_LINE_STYLE1) = (ULONG)(pat); \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_STYLE1) != (ULONG)(pat)); \
+      } 
+#define RDCSetupLineStyle2_MMIO(pat) \
+      { \
+        do { \
+          *(ULONG *)(MMIOREG_LINE_STYLE2) = (ULONG)(pat); \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_STYLE2) != (ULONG)(pat)); \
+      }
+
+#define RDCSetupLineXY_MMIO(x, y) \
+      { \
+        ULONG linexy; \
+        linexy = (ULONG)(((x & MASK_M2010LINE_X) << 16) + (y & MASK_M2010LINE_Y)); \
+        do { \
+           *(ULONG *)(MMIOREG_LINE_XY) = linexy; \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_XY) != linexy); \
+      }
+#define RDCSetupLineXY2_MMIO(x, y) \
+      { \
+        ULONG linexy; \
+        linexy = (ULONG)(((x & MASK_M2010LINE_X) << 16) + (y & MASK_M2010LINE_Y)); \
+        do { \
+           *(ULONG *)(MMIOREG_LINE_XY2) = linexy; \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_XY2) != linexy); \
+      }
+#define RDCSetupLineNumber_MMIO(no) \
+      { \
+        do { \
+           *(ULONG *)(MMIOREG_LINE_NUMBER) = (ULONG) no; \
+        } while (*(volatile ULONG *)(MMIOREG_LINE_NUMBER) != (ULONG) no); \
+      }
+
+/* CMDQ Mode Macro */ 
+#define mUpdateWritePointer *(ULONG *) (pRDC->CMDQInfo.pjWritePort) = (pRDC->CMDQInfo.ulWritePointer >>3)
+
+/* General CMD */
+#define RDCSetupSRCBase(addr, base) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_SRC_BASE);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(base);                    \
+      }
+#define RDCSetupSRCPitch(addr, pitch) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_SRC_PITCH);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(pitch << 16);                    \
+      }
+#define RDCSetupDSTBase(addr, base) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_DST_BASE);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(base);                    \
+      }      
+#define RDCSetupDSTPitchHeight(addr, pitch, height) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_DST_PITCH);     \
+        addr->PKT_SC_dwData[0] = (ULONG)((pitch << 16) + ((height) & MASK_DST_HEIGHT));                    \
+      }      
+#define RDCSetupDSTXY(addr, x, y) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_DST_XY);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((x & MASK_DST_X) << 16) + (y & MASK_DST_Y));                    \
+      }           
+#define RDCSetupSRCXY(addr, x, y) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_SRC_XY);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((x & MASK_SRC_X) << 16) + (y & MASK_SRC_Y));                    \
+      }             
+#define RDCSetupRECTXY(addr, x, y) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_RECT_XY);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((x & MASK_RECT_WIDTH) << 16) + (y & MASK_RECT_WIDTH));                    \
+      }  
+#define RDCSetupFG(addr, color) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_FG);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(color);                    \
+      }
+#define RDCSetupBG(addr, color) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_BG);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(color);                    \
+      }
+#define RDCSetupMONO1(addr, pat) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_MONO1);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(pat);                \
+      }            
+#define RDCSetupMONO2(addr, pat) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_MONO2);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(pat);                \
+      }     
+#define RDCSetupCLIP1(addr, left, top) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_CLIP1);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((left & MASK_CLIP) << 16) + (top & MASK_CLIP));    \
+      }            
+#define RDCSetupCLIP2(addr, right, bottom) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_CLIP2);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((right & MASK_CLIP) << 16) + (bottom & MASK_CLIP));    \
+      }                                                                                                    
+#define RDCSetupCMDReg(addr, reg) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_CMD);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(reg);                    \
+      }
+#define RDCSetupPatReg(addr, patreg, pat) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + (CMDQREG_PAT + (patreg << 24)));     \
+        addr->PKT_SC_dwData[0] = (ULONG)(pat);                \
+      }    
+
+/* Line CMD */
+#define RDCSetupLineStyle1(addr, pat) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_STYLE1);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(pat);                \
+      }            
+#define RDCSetupLineStyle2(addr, pat) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_STYLE2);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(pat);                \
+      }     
+
+#define RDCSetupLineXY(addr, x, y) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_XY);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((x & MASK_M2010LINE_X) << 16) + (y & MASK_M2010LINE_Y));                    \
+      }
+#define RDCSetupLineXY2(addr, x, y) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_XY2);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(((x & MASK_M2010LINE_X) << 16) + (y & MASK_M2010LINE_Y));                    \
+      }
+#define RDCSetupLineNumber(addr, no) \
+      { \
+        addr->PKT_SC_dwHeader  = (ULONG)(PKT_SINGLE_CMD_HEADER + CMDQREG_LINE_NUMBER);     \
+        addr->PKT_SC_dwData[0] = (ULONG)(no);                    \
+      }
diff --git a/src/rdc_accel.c b/src/rdc_accel.c
new file mode 100644
index 0000000..d78b9ec
--- /dev/null
+++ b/src/rdc_accel.c
@@ -0,0 +1,1471 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+#ifdef Accel_2D
+/* ROP Translation Table */
+int RDCXAACopyROP[16] =
+{
+    ROP_0,               /* GXclear */
+    ROP_DSa,             /* GXand */
+    ROP_SDna,            /* GXandReverse */
+    ROP_S,               /* GXcopy */
+    ROP_DSna,            /* GXandInverted */
+    ROP_D,               /* GXnoop */
+    ROP_DSx,             /* GXxor */
+    ROP_DSo,             /* GXor */
+    ROP_DSon,            /* GXnor */
+    ROP_DSxn,            /* GXequiv */
+    ROP_Dn,              /* GXinvert*/
+    ROP_SDno,            /* GXorReverse */
+    ROP_Sn,              /* GXcopyInverted */
+    ROP_DSno,            /* GXorInverted */
+    ROP_DSan,            /* GXnand */
+    ROP_1                /* GXset */
+};
+
+int RDCXAAPatternROP[16]=
+{
+    ROP_0,
+    ROP_DPa,
+    ROP_PDna,
+    ROP_P,
+    ROP_DPna,
+    ROP_D,
+    ROP_DPx,
+    ROP_DPo,
+    ROP_DPon,
+    ROP_PDxn,
+    ROP_Dn,
+    ROP_PDno,
+    ROP_Pn,
+    ROP_DPno,
+    ROP_DPan,
+    ROP_1
+};
+
+/* extern function */
+extern void vWaitEngIdle(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+extern UCHAR *pjRequestCMDQ(RDCRecPtr pRDC, ULONG ulDataLen);
+extern Bool bGetLineTerm(_LINEInfo *LineInfo, LINEPARAM *dsLineParam);
+
+/* Prototype type declaration */
+Bool RDCAccelInit(ScreenPtr pScreen);
+static void RDCSync(ScrnInfoPtr pScrn);
+static void RDCSetupForScreenToScreenCopy(ScrnInfoPtr pScrn, 
+                                          int xdir, int ydir, int rop,
+                                          unsigned int planemask, int trans_color);
+static void RDCSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2,
+                                            int y2, int w, int h);                                
+static void RDCSetupForSolidFill(ScrnInfoPtr pScrn,
+                                 int color, int rop, unsigned int planemask);
+static void RDCSubsequentSolidFillRect(ScrnInfoPtr pScrn,
+                                       int dst_x, int dst_y, int width, int height);  
+static void RDCSetupForSolidLine(ScrnInfoPtr pScrn,
+                                 int color, int rop, unsigned int planemask);
+static void RDCSubsequentSolidHorVertLine(ScrnInfoPtr pScrn,
+                                          int x, int y, int len, int dir);
+static void RDCSetupForDashedLine(ScrnInfoPtr pScrn,
+                                  int fg, int bg, int rop, unsigned int planemask,
+                                  int length, UCHAR *pattern);
+static void RDCSetupForMonoPatternFill(ScrnInfoPtr pScrn,
+                                       int patx, int paty, int fg, int bg,
+                                       int rop, unsigned int planemask);
+static void RDCSubsequentMonoPatternFill(ScrnInfoPtr pScrn,
+                                         int patx, int paty,
+                                         int x, int y, int w, int h);
+static void RDCSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
+                               int rop, unsigned int planemask, int trans_col);
+static void RDCSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
+                                                 int x, int y, int w, int h);
+static void RDCSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                                  int fg, int bg,
+                                                  int rop, unsigned int planemask);
+static void RDCSubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                                    int x, int y,
+                                                    int width, int height, int skipleft);
+static void RDCSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                                     int fg, int bg,
+                                                     int rop, unsigned int planemask);
+static void RDCSubsequentScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                                       int x, int y, int width, int height,
+                                                       int src_x, int src_y, int offset);
+static void RDCSetClippingRectangle(ScrnInfoPtr pScrn,
+                                    int left, int top, int right, int bottom);
+static void RDCDisableClipping(ScrnInfoPtr pScrn); 
+
+static void RDCSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
+                                           int x1, int y1, int x2, int y2, int flags);                                       
+static void RDCSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
+                                            int x1, int y1, int x2, int y2,
+                                            int flags, int phase);
+
+Bool
+RDCAccelInit(ScreenPtr pScreen)
+{
+    XAAInfoRecPtr  infoPtr;
+    ScrnInfoPtr    pScrn = xf86Screens[pScreen->myNum];
+    RDCRecPtr      pRDC = RDCPTR(pScrn);
+    
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCAccelInit()== \n");
+#endif
+    pRDC->AccelInfoPtr = infoPtr = XAACreateInfoRec();
+    if (!infoPtr)
+    {
+#if Accel_2D_DEBUG
+        xf86DrvMsgVerb(0, X_INFO, ErrorLevel, "==Exit1 RDCAccelInit(), return FALSE== \n");
+#endif
+        return FALSE;
+    }
+    infoPtr->Flags = LINEAR_FRAMEBUFFER |
+                     OFFSCREEN_PIXMAPS |
+                     PIXMAP_CACHE;
+
+    /* Sync */
+    if (pRDC->ENGCaps & ENG_CAP_Sync)
+        infoPtr->Sync = RDCSync;
+
+    /* Screen To Screen copy */
+    if (pRDC->ENGCaps & ENG_CAP_ScreenToScreenCopy)
+    {    
+        infoPtr->SetupForScreenToScreenCopy =  RDCSetupForScreenToScreenCopy;
+        infoPtr->SubsequentScreenToScreenCopy = RDCSubsequentScreenToScreenCopy;
+        infoPtr->ScreenToScreenCopyFlags = NO_TRANSPARENCY | NO_PLANEMASK;
+    }
+
+    /* Solid fill */
+    if (pRDC->ENGCaps & ENG_CAP_SolidFill)
+    {    
+        infoPtr->SetupForSolidFill = RDCSetupForSolidFill;
+        infoPtr->SubsequentSolidFillRect = RDCSubsequentSolidFillRect;
+        infoPtr->SolidFillFlags = NO_PLANEMASK;
+    } 
+        
+    /* Solid Lines */
+    if (pRDC->ENGCaps & ENG_CAP_SolidLine)
+    {    
+        infoPtr->SetupForSolidLine = RDCSetupForSolidLine;            
+        infoPtr->SubsequentSolidTwoPointLine = RDCSubsequentSolidTwoPointLine;
+        infoPtr->SubsequentSolidHorVertLine = RDCSubsequentSolidHorVertLine;    
+        infoPtr->SolidLineFlags = NO_PLANEMASK;
+    }
+
+    /* Dashed Lines */
+    if (pRDC->ENGCaps & ENG_CAP_DashedLine)
+    {
+        infoPtr->SetupForDashedLine = RDCSetupForDashedLine;        
+        infoPtr->SubsequentDashedTwoPointLine = RDCSubsequentDashedTwoPointLine;
+        infoPtr->DashPatternMaxLength = 64;
+        infoPtr->DashedLineFlags = NO_PLANEMASK |
+                       LINE_PATTERN_MSBFIRST_LSBJUSTIFIED;
+    }                                              
+
+    /* 8x8 mono pattern fill */
+    if (pRDC->ENGCaps & ENG_CAP_Mono8x8PatternFill)
+    {    
+        infoPtr->SetupForMono8x8PatternFill = RDCSetupForMonoPatternFill;
+        infoPtr->SubsequentMono8x8PatternFillRect = RDCSubsequentMonoPatternFill;
+        infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK |
+                                           NO_TRANSPARENCY |
+                                           HARDWARE_PATTERN_SCREEN_ORIGIN |
+                                           HARDWARE_PATTERN_PROGRAMMED_BITS |
+                                           BIT_ORDER_IN_BYTE_MSBFIRST;
+    }                           
+                           
+    /* 8x8 color pattern fill */
+    if (pRDC->ENGCaps & ENG_CAP_Color8x8PatternFill)
+    {    
+        infoPtr->SetupForColor8x8PatternFill = RDCSetupForColor8x8PatternFill;
+        infoPtr->SubsequentColor8x8PatternFillRect = RDCSubsequentColor8x8PatternFillRect;
+        infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK |
+                                            NO_TRANSPARENCY |    
+                                            HARDWARE_PATTERN_SCREEN_ORIGIN;
+    }                         
+                     
+    /* CPU To Screen Color Expand */
+    if (pRDC->ENGCaps & ENG_CAP_CPUToScreenColorExpand)
+    {    
+        infoPtr->SetupForCPUToScreenColorExpandFill = RDCSetupForCPUToScreenColorExpandFill;
+        infoPtr->SubsequentCPUToScreenColorExpandFill = RDCSubsequentCPUToScreenColorExpandFill;
+        infoPtr->ColorExpandRange = MAX_PATReg_Size;
+        infoPtr->ColorExpandBase = MMIOREG_PAT;
+        infoPtr->CPUToScreenColorExpandFillFlags = NO_PLANEMASK |
+                                                   BIT_ORDER_IN_BYTE_MSBFIRST;
+    }                                  
+
+    /* Screen To Screen Color Expand */
+    if (pRDC->ENGCaps & ENG_CAP_ScreenToScreenColorExpand)
+    {    
+        infoPtr->SetupForScreenToScreenColorExpandFill = RDCSetupForScreenToScreenColorExpandFill;
+        infoPtr->SubsequentScreenToScreenColorExpandFill = RDCSubsequentScreenToScreenColorExpandFill;
+        infoPtr->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK |
+                                                      BIT_ORDER_IN_BYTE_MSBFIRST;
+    }                                                  
+                                              
+    /* Clipping */
+    if (pRDC->ENGCaps & ENG_CAP_Clipping)
+    {    
+        infoPtr->SetClippingRectangle = RDCSetClippingRectangle;
+        infoPtr->DisableClipping = RDCDisableClipping;
+        infoPtr->ClippingFlags = HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY     |
+                                 HARDWARE_CLIP_MONO_8x8_FILL |
+                                 HARDWARE_CLIP_COLOR_8x8_FILL |
+                                 HARDWARE_CLIP_SOLID_LINE | 
+                                 HARDWARE_CLIP_DASHED_LINE | 
+                                 HARDWARE_CLIP_SOLID_LINE; 
+    }                         
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 RDCAccelInit()== \n");
+#endif
+
+    return(XAAInit(pScreen, infoPtr));
+} /* end of RDCAccelInit */
+
+
+static void
+RDCSync(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCSync()== \n");
+#endif
+    /* wait engle idle */
+    vWaitEngIdle(pScrn, pRDC);
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit RDCSync()== \n");
+#endif
+} /* end of RDCSync */
+
+
+static void RDCSetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+                                          int xdir, int ydir, int rop,
+                                          unsigned int planemask, int trans_color)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG  cmdreg = 0;
+    
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForScreenToScreenCopy(xdir = %d, ydir = %d, rop = 0x%x, planemask = 0x%x, trans_color = 0x%x)== \n", xdir, ydir, rop, planemask, trans_color);
+#endif    
+    /* Modify Reg. Value */
+    cmdreg = CMD_BITBLT;
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+        case 8:
+            cmdreg |= CMD_COLOR_08;
+            break;
+        case 15:
+        case 16:
+            cmdreg |= CMD_COLOR_16;
+            break;    
+        case 24:
+        case 32:
+            cmdreg |= CMD_COLOR_32;
+            break;        
+    }
+    
+    cmdreg |= (RDCXAACopyROP[rop] << 8);
+    
+    if (xdir == -1)
+    {
+        cmdreg |= CMD_X_DEC;
+    }
+    if (ydir == -1)
+    {
+        cmdreg |= CMD_Y_DEC;
+    }
+    
+    pRDC->ulCMDReg = cmdreg;
+     
+    if (!pRDC->MMIO2D)
+    {   
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*2);
+                
+        RDCSetupSRCPitch(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch);  
+        pSingleCMD++;
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+    }
+    else
+    {
+        /* Write to MMIO */                
+        RDCSetupSRCPitch_MMIO(pRDC->VideoModeInfo.ScreenPitch);  
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);    
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForScreenToScreenCopy()== \n");
+#endif
+} /* end of RDCSetupForScreenToScreenCopy */
+
+static void
+RDCSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2,
+                                int y2, int width, int height)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    int src_x, src_y, dst_x, dst_y;
+    ULONG srcbase, dstbase, cmdreg;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSubsequentScreenToScreenCopy(x1 = %d, y1 = %d, x2 = %d, y2 = %d, width = %d, height = %d)== \n", x1, y1, x2, y2, width, height);
+#endif        
+    /* Modify Reg. Value */
+    cmdreg = pRDC->ulCMDReg;
+
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;        
+        
+    srcbase = pRDC->VideoModeInfo.ScreenPitch*y1;
+    dstbase = pRDC->VideoModeInfo.ScreenPitch*y2;
+          
+    if (cmdreg & CMD_X_DEC)
+    {
+        src_x = x1 + width - 1;
+        dst_x = x2 + width - 1;
+    }
+    else
+    {
+        src_x = x1;
+        dst_x = x2;    
+    }
+
+    if (cmdreg & CMD_Y_DEC)
+    {
+        src_y = height - 1;
+        dst_y = height - 1;
+    }
+    else
+    {
+        src_y = 0;
+        dst_y = 0;    
+    }
+        
+    if (!pRDC->MMIO2D)        
+    {
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*6);
+      
+        RDCSetupSRCBase(pSingleCMD, srcbase);
+        pSingleCMD++;
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;
+        RDCSetupDSTXY(pSingleCMD, dst_x, dst_y);
+        pSingleCMD++;
+        RDCSetupSRCXY(pSingleCMD, src_x, src_y);
+        pSingleCMD++;
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;
+        RDCSetupCMDReg(pSingleCMD, cmdreg);
+
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+    
+    }
+    else
+    {
+        RDCSetupSRCBase_MMIO(srcbase);
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(dst_x, dst_y);    
+        RDCSetupSRCXY_MMIO(src_x, src_y);    
+        RDCSetupRECTXY_MMIO(width, height);    
+        RDCSetupCMDReg_MMIO(cmdreg);       
+                
+        vWaitEngIdle(pScrn, pRDC);
+    }
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentScreenToScreenCopy()== \n");
+#endif
+} /* end of RDCSubsequentScreenToScreenCopy */
+
+static void
+RDCSetupForSolidFill(ScrnInfoPtr pScrn,
+                     int color, int rop, unsigned int planemask)
+{
+    
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG cmdreg;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForSolidFill(color = 0x%x, rop = 0x%x, planemake = 0x%x)== \n", color, rop, planemask);
+#endif
+    /* Modify Reg. Value */
+    cmdreg = CMD_BITBLT | CMD_PAT_FGCOLOR;
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);
+    pRDC->ulCMDReg = cmdreg;
+            
+    if (!pRDC->MMIO2D)                    
+    {
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*2);
+
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        RDCSetupFG(pSingleCMD, color);        
+    }
+    else
+    {
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);
+        RDCSetupFG_MMIO(color);                
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForSolidFill()== \n");           
+#endif
+} /* end of RDCSetupForSolidFill */
+
+
+static void
+RDCSubsequentSolidFillRect(ScrnInfoPtr pScrn,
+                           int dst_x, int dst_y, int width, int height)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG dstbase, cmdreg;        
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSubsequentSolidFillRect(dst_x = %d, dst_y = %d, width = %d, height = %d)== \n", dst_x, dst_y, width, height);           
+#endif
+    /* Modify Reg. Value */
+    cmdreg = pRDC->ulCMDReg;
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;            
+    dstbase = 0;
+
+    if (dst_y >= pScrn->virtualY) 
+    {   
+        dstbase=pRDC->VideoModeInfo.ScreenPitch*dst_y;
+        dst_y=0;
+    }
+                  
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*4);
+
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupDSTXY(pSingleCMD, dst_x, dst_y);
+        pSingleCMD++;    
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;    
+        RDCSetupCMDReg(pSingleCMD, cmdreg);        
+      
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+                
+    }
+    else
+    {                  
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(dst_x, dst_y);
+        RDCSetupRECTXY_MMIO(width, height);
+        RDCSetupCMDReg_MMIO(cmdreg);        
+ 
+        vWaitEngIdle(pScrn, pRDC);
+      
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentSolidFillRect()== \n");           
+#endif
+} /* end of RDCSubsequentSolidFillRect */
+
+/* Line */
+static void RDCSetupForSolidLine(ScrnInfoPtr pScrn, 
+                                 int color, int rop, unsigned int planemask)
+{
+
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG  cmdreg;
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==RDCSetupForSolidLine(color = 0x%x, rop = 0x%x, planemask = 0x%x)\n==", color, rop, planemask);
+#endif
+    /* Modify Reg. Value */
+    cmdreg = CMD_BITBLT;
+    
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);  
+    
+    pRDC->ulCMDReg = cmdreg;
+     
+    if (!pRDC->MMIO2D)
+    {   
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*3);
+
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        RDCSetupFG(pSingleCMD, color);  
+        pSingleCMD++;
+        RDCSetupBG(pSingleCMD, 0);
+        
+    }
+    else
+    {
+        /* Write to MMIO */   
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);                     
+        RDCSetupFG_MMIO(color);  
+        RDCSetupBG_MMIO(0);            
+    }
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForSolidLine()== \n");           
+#endif
+} /* end of RDCSetupForSolidLine */
+
+
+static void RDCSubsequentSolidHorVertLine(ScrnInfoPtr pScrn,
+                                          int x, int y, int len, int dir)
+{
+
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG dstbase, cmdreg;   
+    int width, height;
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSubsequentSolidHorVertLine(x = %d, y = %d, len = %d, dir = %d)\n==", x, y, len, dir);
+#endif
+            
+    /* Modify Reg. Value */
+    cmdreg = (pRDC->ulCMDReg & (~CMD_MASK)) | CMD_BITBLT;
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;            
+    dstbase = 0;
+    
+    if(dir == DEGREES_0)
+    {            /* horizontal */
+        width  = len;
+        height = 1;    
+    } 
+    else 
+    {                    /* vertical */
+        width  = 1;
+        height = len;            
+    }
+              
+    if ((y + height) >= pScrn->virtualY) 
+    {   
+        dstbase=pRDC->VideoModeInfo.ScreenPitch*y;
+        y=0;
+    }
+              
+    
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*4);
+
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupDSTXY(pSingleCMD, x, y);
+        pSingleCMD++;    
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;    
+        RDCSetupCMDReg(pSingleCMD, cmdreg);        
+      
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+               
+    }
+    else
+    {                  
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(x, y);
+        RDCSetupRECTXY_MMIO(width, height);
+        RDCSetupCMDReg_MMIO(cmdreg);        
+ 
+        vWaitEngIdle(pScrn, pRDC);
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentSolidHorVertLine()== \n");           
+#endif
+} /* end of RDCSubsequentSolidHorVertLine */
+
+/* Dash Line */
+static void
+RDCSetupForDashedLine(ScrnInfoPtr pScrn,
+                      int fg, int bg, int rop, unsigned int planemask,
+                      int length, UCHAR *pattern)
+{
+
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG  cmdreg;
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForDashedLine(fg = 0x%x, bg = 0x%x, rop = 0x%x, planemask = 0x%x, length = %d)\n==", fg, bg, rop, planemask, length);
+#endif
+    /* Modify Reg. Value */
+    cmdreg = CMD_LINEDRAW | CMD_RESET_STYLE_COUNTER | CMD_ENABLE_LINE_STYLE;
+    
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);  
+
+    if(bg == -1) 
+    {
+        cmdreg |= CMD_TRANSPARENT;    
+        bg = 0;
+    }
+
+    cmdreg |= (((length-1) & 0x3F) << 24);        /* line period */
+    pRDC->ulCMDReg = cmdreg;
+     
+    if (!pRDC->MMIO2D)
+    {   
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*5);
+
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        RDCSetupFG(pSingleCMD, fg);  
+        pSingleCMD++;
+        RDCSetupBG(pSingleCMD, bg); 
+        pSingleCMD++;
+        RDCSetupLineStyle1(pSingleCMD, *pattern);
+        pSingleCMD++;
+        RDCSetupLineStyle2(pSingleCMD, *(pattern+4));                   
+                       
+    }
+    else
+    {
+        /* Write to MMIO */   
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);
+        RDCSetupFG_MMIO(fg);  
+        RDCSetupBG_MMIO(bg); 
+        RDCSetupLineStyle1_MMIO(*pattern);
+        RDCSetupLineStyle2_MMIO(*(pattern+4));                
+    }
+                                     
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForDashedLine()== \n");           
+#endif
+}
+
+/* Mono Pattern Fill */
+static void
+RDCSetupForMonoPatternFill(ScrnInfoPtr pScrn,
+                           int patx, int paty, int fg, int bg,
+                           int rop, unsigned int planemask)
+{
+    
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG cmdreg;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFill(patx = %d, paty = %d, fg = 0x%x, bg = 0x%x, rop = 0x%x, planemask = 0x%x)\n==", patx, paty, fg, bg, rop, planemask);
+#endif
+    /* Modify Reg. Value */
+    cmdreg = CMD_BITBLT | CMD_PAT_MONOMASK;
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);
+    pRDC->ulCMDReg = cmdreg;
+            
+    if (!pRDC->MMIO2D)                    
+    {
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*5);
+
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        RDCSetupFG(pSingleCMD, fg);  
+        pSingleCMD++;
+        RDCSetupBG(pSingleCMD, bg);
+        pSingleCMD++;
+        RDCSetupMONO1(pSingleCMD, patx);  
+        pSingleCMD++;
+        RDCSetupMONO2(pSingleCMD, paty);                           
+    }
+    else
+    {
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);
+        RDCSetupFG_MMIO(fg);   
+        RDCSetupBG_MMIO(bg);
+        RDCSetupMONO1_MMIO(patx);  
+        RDCSetupMONO2_MMIO(paty);                         
+    }
+               
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForMonoPatternFill()== \n");           
+#endif
+} /* end of RDCSetupForMonoPatternFill */
+
+                      
+static void
+RDCSubsequentMonoPatternFill(ScrnInfoPtr pScrn,
+                             int patx, int paty,
+                             int dst_x, int dst_y, int width, int height)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG dstbase, cmdreg;        
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSubsequentMonoPatternFill(patx = %d, paty = %d, dst_x = %d, dst_y = %d, width = %d, height = %d,)\n==", patx, paty, dst_x, dst_y, width, height);
+#endif
+            
+    /* Modify Reg. Value */
+    cmdreg = pRDC->ulCMDReg;
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;            
+    dstbase = 0;
+
+    if (dst_y >= pScrn->virtualY) 
+    {   
+        dstbase=pRDC->VideoModeInfo.ScreenPitch*dst_y;
+        dst_y=0;
+    }
+                  
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*4);
+
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupDSTXY(pSingleCMD, dst_x, dst_y);
+        pSingleCMD++;    
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;    
+        RDCSetupCMDReg(pSingleCMD, cmdreg);        
+      
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+              
+    }
+    else
+    {                  
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(dst_x, dst_y);
+        RDCSetupRECTXY_MMIO(width, height);
+        RDCSetupCMDReg_MMIO(cmdreg);        
+ 
+        vWaitEngIdle(pScrn, pRDC);      
+    }    
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentMonoPatternFill()== \n");           
+#endif
+} /* end of RDCSubsequentMonoPatternFill */
+
+static void
+RDCSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
+                   int rop, unsigned int planemask, int trans_col)
+{
+    
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG cmdreg;
+    CARD32 *pataddr;
+    ULONG ulPatSize;
+    int i, j, cpp;
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSetupForColor8x8PatternFill(patx = %d, paty = %d, rop = 0x%x, planemask = 0x%x, trans_col = 0x%x)\n==", patx, paty, rop, planemask, trans_col);
+#endif
+    /* Modify Reg. Value */
+    cmdreg = CMD_BITBLT | CMD_PAT_PATREG;
+
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);
+    pRDC->ulCMDReg = cmdreg;
+    cpp = (pScrn->bitsPerPixel + 1) / 8;
+    pataddr = (CARD32 *)(pRDC->FBVirtualAddr +
+                        (paty * pRDC->VideoModeInfo.ScreenWidth) + (patx * cpp));   
+    ulPatSize = 8*8*cpp;
+                
+    if (!pRDC->MMIO2D)                    
+    {
+        /* Write to CMDQ */        
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*(1 + ulPatSize/4));
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        for (i=0; i<8; i++)
+        {
+            for (j=0; j<8*cpp/4; j++)
+            {
+                RDCSetupPatReg(pSingleCMD, (i*j + j) , (*(CARD32 *) (pataddr++)));
+                pSingleCMD++;                    
+            }    
+        }                
+    }
+    else
+    {        
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);
+        for (i=0; i<8; i++)
+        {
+            for (j=0; j<8*cpp/4; j++)
+            {
+                RDCSetupPatReg_MMIO((i*j + j) , (*(CARD32 *) (pataddr++)));
+            }    
+        }                
+                 
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForColor8x8PatternFill()== \n");           
+#endif
+} /* end of RDCSetupForColor8x8PatternFill */
+               
+static void
+RDCSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
+                                     int dst_x, int dst_y, int width, int height)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG dstbase, cmdreg;        
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSubsequentColor8x8PatternFillRect(patx = %d, paty = %d, dst_x = %d, dst_y = %d, width = %d, height)\n==", patx, paty, dst_x, dst_y, width, height);
+#endif
+            
+    /* Modify Reg. Value */
+    cmdreg = pRDC->ulCMDReg;
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;            
+
+    dstbase = 0;
+
+    if (dst_y >= pScrn->virtualY) 
+    {   
+        dstbase=pRDC->VideoModeInfo.ScreenPitch*dst_y;
+        dst_y=0;
+    }
+                  
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*4);
+
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupDSTXY(pSingleCMD, dst_x, dst_y);
+        pSingleCMD++;    
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;    
+        RDCSetupCMDReg(pSingleCMD, cmdreg);        
+      
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+                
+    }
+    else
+    {                  
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(dst_x, dst_y);
+        RDCSetupRECTXY_MMIO(width, height);
+        RDCSetupCMDReg_MMIO(cmdreg);        
+ 
+        vWaitEngIdle(pScrn, pRDC);      
+    }    
+    
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentColor8x8PatternFillRect()== \n");           
+#endif
+} /* RDCSubsequentColor8x8PatternFillRect */
+
+/* CPU to Screen Expand */
+static void
+RDCSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                      int fg, int bg,
+                                      int rop, unsigned int planemask)
+{
+
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG cmdreg;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSetupForCPUToScreenColorExpandFill(fg = 0x%x, bg = ox%x, rop = ox%x, planemask = ox%x)\n==", fg, bg, rop, planemask);
+#endif
+    /* Modify Reg. Value */
+    cmdreg = CMD_COLOREXP;
+
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);
+
+    if(bg == -1) 
+    {
+        cmdreg |= CMD_FONT_TRANSPARENT;    
+        bg = 0;
+    }
+    
+    pRDC->ulCMDReg = cmdreg;
+            
+    if (!pRDC->MMIO2D)                    
+    {
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*3);
+
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        RDCSetupFG(pSingleCMD, fg);  
+        pSingleCMD++;
+        RDCSetupBG(pSingleCMD, bg); 
+       
+    }
+    else
+    {
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);
+        RDCSetupFG_MMIO(fg); 
+        RDCSetupBG_MMIO(bg); 
+                       
+    }
+               
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForCPUToScreenColorExpandFill()== \n");           
+#endif
+}
+                               
+static void
+RDCSubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                        int dst_x, int dst_y,
+                                        int width, int height, int offset)
+{
+
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG dstbase, cmdreg;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSetupForCPUToScreenColorExpandFill(dst_x = %d, dst_y = %d, width = %d, height, offset = %d)\n==", dst_x, dst_y, width, height, offset);
+#endif
+            
+    /* Modify Reg. Value */
+    cmdreg = pRDC->ulCMDReg;
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;            
+    dstbase = 0;
+
+    if (dst_y >= pScrn->virtualY) 
+    {   
+        dstbase=pRDC->VideoModeInfo.ScreenPitch*dst_y;
+        dst_y=0;
+    }
+                  
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*5);
+
+        RDCSetupSRCPitch(pSingleCMD, ((width+7)/8));  
+        pSingleCMD++;    
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupDSTXY(pSingleCMD, dst_x, dst_y);
+        pSingleCMD++;    
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;    
+        RDCSetupCMDReg(pSingleCMD, cmdreg);        
+      
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+               
+    }
+    else
+    {  
+        RDCSetupSRCPitch_MMIO((width+7)/8);                          
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(dst_x, dst_y);
+        RDCSetupSRCXY_MMIO(0, 0);
+        
+        RDCSetupRECTXY_MMIO(width, height);
+        RDCSetupCMDReg_MMIO(cmdreg);        
+ 
+        vWaitEngIdle(pScrn, pRDC);      
+    }
+        
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentCPUToScreenColorExpandFill()== \n");           
+#endif
+}
+
+
+/* Screen to Screen Color Expand */
+static void
+RDCSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                         int fg, int bg,
+                                         int rop, unsigned int planemask)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG cmdreg;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSetupForScreenToScreenColorExpandFill(fg = 0x%x, bg = ox%x, rop = ox%x, planemask = ox%x)\n==", fg, bg, rop, planemask);
+#endif
+           
+    /* Modify Reg. Value */
+    cmdreg = CMD_ENHCOLOREXP;
+    switch (pRDC->VideoModeInfo.bitsPerPixel)
+    {
+    case 8:
+        cmdreg |= CMD_COLOR_08;
+        break;
+    case 15:
+    case 16:
+        cmdreg |= CMD_COLOR_16;
+        break;    
+    case 24:
+    case 32:
+        cmdreg |= CMD_COLOR_32;
+        break;        
+    }
+    
+    cmdreg |= (RDCXAAPatternROP[rop] << 8);
+    
+    if(bg == -1)
+    {
+        cmdreg |= CMD_FONT_TRANSPARENT;    
+        bg = 0;
+    }    
+    pRDC->ulCMDReg = cmdreg;
+            
+    if (!pRDC->MMIO2D)                    
+    {
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*3);
+
+        RDCSetupDSTPitchHeight(pSingleCMD, pRDC->VideoModeInfo.ScreenPitch, -1);
+        pSingleCMD++;
+        RDCSetupFG(pSingleCMD, fg);  
+        pSingleCMD++;
+        RDCSetupBG(pSingleCMD, bg); 
+       
+    }
+    else
+    {
+        RDCSetupDSTPitchHeight_MMIO(pRDC->VideoModeInfo.ScreenPitch, -1);
+        RDCSetupFG_MMIO(fg); 
+        RDCSetupBG_MMIO(bg); 
+                       
+    }
+               
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetupForScreenToScreenColorExpandFill()== \n");           
+#endif
+}
+
+
+
+static void
+RDCSubsequentScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                           int dst_x, int dst_y, int width, int height,
+                                           int src_x, int src_y, int offset)
+{
+   RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+    ULONG srcbase, dstbase, cmdreg;
+    USHORT srcpitch;
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSubsequentScreenToScreenColorExpandFill(dst_x = %d, dst_y = %d, width = %d, height, src_x = %d, src_y = %d, offset = %d)\n==", dst_x, dst_y, width, height, src_x, src_y, offset);
+#endif
+            
+    /* Modify Reg. Value */
+    cmdreg = pRDC->ulCMDReg;
+    
+    if (pRDC->EnableClip)
+        cmdreg |= CMD_ENABLE_CLIP;
+    else
+        cmdreg &= ~CMD_ENABLE_CLIP;   
+        
+    dstbase = 0;
+    
+    if (dst_y >= pScrn->virtualY) 
+    {   
+        dstbase=pRDC->VideoModeInfo.ScreenPitch*dst_y;
+        dst_y=0;
+    }
+    
+    srcbase = pRDC->VideoModeInfo.ScreenPitch*src_y + ((pScrn->bitsPerPixel+1)/8)*src_x;            
+    srcpitch = (pScrn->displayWidth+7)/8;
+    
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*6);
+
+        RDCSetupSRCBase(pSingleCMD, srcbase);
+        pSingleCMD++;  
+        RDCSetupSRCPitch(pSingleCMD,srcpitch);  
+        pSingleCMD++;    
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupDSTXY(pSingleCMD, dst_x, dst_y);
+        pSingleCMD++;    
+        RDCSetupRECTXY(pSingleCMD, width, height);
+        pSingleCMD++;    
+        RDCSetupCMDReg(pSingleCMD, cmdreg);        
+      
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+       
+    }
+    else
+    { 
+        RDCSetupSRCBase_MMIO(srcbase);         
+        RDCSetupSRCPitch_MMIO(srcpitch);                          
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupDSTXY_MMIO(dst_x, dst_y);
+        RDCSetupRECTXY_MMIO(width, height);
+        RDCSetupCMDReg_MMIO(cmdreg);        
+ 
+        vWaitEngIdle(pScrn, pRDC);
+      
+    }
+        
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentScreenToScreenColorExpandFill()== \n");           
+#endif
+}
+
+      
+/* Clipping */
+static void
+RDCSetClippingRectangle(ScrnInfoPtr pScrn,
+                        int left, int top, int right, int bottom)
+{
+    
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC *pSingleCMD;
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSetClippingRectangle(left = %d, top = %d, right = %d, bottom = %d)\n==", left, top, right, bottom);
+#endif
+    pRDC->EnableClip = TRUE;
+            
+    if (!pRDC->MMIO2D)                    
+    {
+        /* Write to CMDQ */
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*2);
+
+        RDCSetupCLIP1(pSingleCMD, left, top);
+        pSingleCMD++;
+        RDCSetupCLIP2(pSingleCMD, right, bottom);                 
+    }
+    else
+    {
+        RDCSetupCLIP1_MMIO(left, top);
+        RDCSetupCLIP2_MMIO(right, bottom);                       
+    }
+    
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetClippingRectangle()== \n");           
+#endif
+}
+
+static void
+RDCDisableClipping(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCDisableClipping()\n==");
+#endif
+    pRDC->EnableClip = FALSE;
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCDisableClipping()== \n");           
+#endif
+}
+
+static void RDCSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
+                                           int x1, int y1, int x2, int y2, int flags)
+{
+ 
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    PKT_SC    *pSingleCMD;
+    ULONG     dstbase, ulCommand;
+    ULONG     miny, maxy;         
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSubsequentSolidTwoPointLine(x1 = %d, y1 = %d, x2 = %d, y2 = %d, flags = 0x%x)\n==", x1, y1, x2, y2, flags);
+#endif
+
+    /* Modify Reg. Value */
+    ulCommand = (pRDC->ulCMDReg & (~CMD_MASK)) | CMD_LINEDRAW | CMD_NORMAL_LINE;
+    
+    if(flags & OMIT_LAST)
+        ulCommand |= CMD_NOT_DRAW_LAST_PIXEL;
+    else
+        ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL;
+        
+    if (pRDC->EnableClip)
+        ulCommand |= CMD_ENABLE_CLIP;
+    else
+        ulCommand &= ~CMD_ENABLE_CLIP;        
+    dstbase = 0;
+    miny = (y1 > y2) ? y2 : y1;
+    maxy = (y1 > y2) ? y1 : y2;
+    
+    if(maxy >= pScrn->virtualY) 
+    {
+        dstbase = pRDC->VideoModeInfo.ScreenPitch * miny;
+        y1 -= miny;
+        y2 -= miny;
+    }
+
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*5);
+
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupLineXY(pSingleCMD, x1, y1);
+        pSingleCMD++;
+        RDCSetupLineXY2(pSingleCMD, x2, y2);
+        pSingleCMD++;
+        RDCSetupLineNumber(pSingleCMD, 0);
+        pSingleCMD++;                     
+        RDCSetupCMDReg(pSingleCMD, ulCommand);        
+              
+        /* Update Write Pointer */
+        mUpdateWritePointer;                
+
+        /* Patch KDE pass abnormal point, ycchen@052507 */
+        vWaitEngIdle(pScrn, pRDC);
+        
+    }
+    else
+    {                  
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupLineXY_MMIO(x1, y1);
+        RDCSetupLineXY2_MMIO(x2, y2);
+        RDCSetupLineNumber_MMIO(0);
+        RDCSetupCMDReg_MMIO(ulCommand);        
+             
+        vWaitEngIdle(pScrn, pRDC);
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentSolidTwoPointLine()== \n");           
+#endif
+} /* end of M2010SubsequentSolidTwoPointLine */
+
+/* M2010 Dash Line */
+static void
+RDCSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
+                                int x1, int y1, int x2, int y2,
+                                int flags, int phase)
+{
+ 
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    PKT_SC     *pSingleCMD;
+    ULONG      dstbase, ulCommand; 
+    ULONG      miny, maxy;  
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetupForMonoPatternFillRDCSubsequentDashedTwoPointLine(x1 = %d, y1 = %d, x2 = %d, y2 = %d, flags = 0x%x, phase = %d(0x%x)\n==", x1, y1, x2, y2, phase, phase);
+#endif
+
+    /* Modify Reg. Value */
+    ulCommand = pRDC->ulCMDReg | CMD_NORMAL_LINE;
+    
+    if(flags & OMIT_LAST)
+        ulCommand |= CMD_NOT_DRAW_LAST_PIXEL;
+    else
+        ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL;
+        
+    if (pRDC->EnableClip)
+        ulCommand |= CMD_ENABLE_CLIP;
+    else
+        ulCommand &= ~CMD_ENABLE_CLIP;        
+    dstbase = 0;        
+    miny = (y1 > y2) ? y2 : y1;
+    maxy = (y1 > y2) ? y1 : y2;
+    
+    if(maxy >= pScrn->virtualY) 
+    {
+        dstbase = pRDC->VideoModeInfo.ScreenPitch * miny;
+        y1 -= miny;
+        y2 -= miny;
+    }
+
+    if (!pRDC->MMIO2D)                    
+    {                  
+        /* Write to CMDQ */    
+        pSingleCMD = (PKT_SC *) pjRequestCMDQ(pRDC, PKT_SINGLE_LENGTH*5);
+
+        RDCSetupDSTBase(pSingleCMD, dstbase);
+        pSingleCMD++;    
+        RDCSetupLineXY(pSingleCMD, x1, y1);
+        pSingleCMD++;
+        RDCSetupLineXY2(pSingleCMD, x2, y2);
+        pSingleCMD++;
+        RDCSetupLineNumber(pSingleCMD, 0);
+        pSingleCMD++;                     
+        RDCSetupCMDReg(pSingleCMD, ulCommand);        
+              
+        /* Update Write Pointer */
+        mUpdateWritePointer;
+
+        /* Patch KDE pass abnormal point, ycchen@052507 */
+        vWaitEngIdle(pScrn, pRDC);
+              
+    }
+    else
+    {                  
+        RDCSetupDSTBase_MMIO(dstbase);
+        RDCSetupLineXY_MMIO(x1, y1);
+        RDCSetupLineXY2_MMIO(x2, y2);
+        RDCSetupLineNumber_MMIO(0);
+        RDCSetupCMDReg_MMIO(ulCommand);
+       
+        vWaitEngIdle(pScrn, pRDC);
+    }
+
+#if Accel_2D_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSubsequentDashedTwoPointLine()== \n");           
+#endif
+}
+                                         
+#endif    /* end of Accel_2D */
diff --git a/src/rdc_cursor.c b/src/rdc_cursor.c
new file mode 100644
index 0000000..e11b44b
--- /dev/null
+++ b/src/rdc_cursor.c
@@ -0,0 +1,852 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+#include "cursorstr.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+#ifdef HWC
+/* Prototype type declaration */
+Bool RDCCursorInit(ScreenPtr pScreen);
+Bool bInitHWC(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+static void RDCShowCursor(ScrnInfoPtr pScrn); 
+void RDCHideCursor(ScrnInfoPtr pScrn);
+static void RDCSetCursorPosition(ScrnInfoPtr pScrn, int x, int y);
+static void RDCSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg);
+static void RDCLoadCursorImage(ScrnInfoPtr pScrn, UCHAR *src);
+static Bool RDCUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs);
+static void RDCLoadCursorARGB(ScrnInfoPtr pScrn, CursorPtr pCurs);
+static Bool RDCUseHWCursorARGB(ScreenPtr pScreen, CursorPtr pCurs);
+
+static void RDCFireCursor(ScrnInfoPtr pScrn); 
+
+//
+// For 32bit data and MMIO control Hardware Cursor
+void RDCHideCursor_HQ(ScrnInfoPtr pScrn);
+static void RDCShowCursor_HQ(ScrnInfoPtr pScrn); 
+static void RDCSetCursorColors_HQ(ScrnInfoPtr pScrn, int bg, int fg);
+static void RDCLoadCursorImage_HQ(ScrnInfoPtr pScrn, UCHAR *src);
+static void RDCLoadCursorARGB_HQ(ScrnInfoPtr pScrn, CursorPtr pCurs);
+static void RDCSetCursorPosition_HQ(ScrnInfoPtr pScrn, int x, int y);
+
+
+Bool
+RDCCursorInit(ScreenPtr pScreen)
+{
+    ScrnInfoPtr    pScrn = xf86Screens[pScreen->myNum];
+    RDCRecPtr     pRDC = RDCPTR(pScrn);
+    xf86CursorInfoPtr infoPtr;
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCCursorInit()== \n");
+#endif
+
+    infoPtr = xf86CreateCursorInfoRec();
+    if(!infoPtr) return FALSE;
+
+    pRDC->HWCInfoPtr = infoPtr;
+
+    infoPtr->Flags = HARDWARE_CURSOR_TRUECOLOR_AT_8BPP |
+                     HARDWARE_CURSOR_INVERT_MASK |        
+                     HARDWARE_CURSOR_BIT_ORDER_MSBFIRST;
+
+    infoPtr->MaxWidth  = MAX_HWC_WIDTH;
+    infoPtr->MaxHeight = MAX_HWC_HEIGHT;
+    
+    infoPtr->UseHWCursor = RDCUseHWCursor;
+    infoPtr->UseHWCursorARGB = RDCUseHWCursorARGB;
+
+    if (pRDC->ENGCaps & ENG_CAP_HWC_MMIO)
+    {
+        *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)) = BIT31;
+        infoPtr->SetCursorPosition = RDCSetCursorPosition_HQ;
+        infoPtr->SetCursorColors = RDCSetCursorColors_HQ;
+        infoPtr->LoadCursorImage = RDCLoadCursorImage_HQ;
+        infoPtr->ShowCursor = RDCShowCursor_HQ;
+        infoPtr->HideCursor = RDCHideCursor_HQ;
+        infoPtr->LoadCursorARGB = RDCLoadCursorARGB_HQ;
+    }
+    else
+    {
+        infoPtr->SetCursorPosition = RDCSetCursorPosition;
+        infoPtr->SetCursorColors = RDCSetCursorColors;
+        infoPtr->LoadCursorImage = RDCLoadCursorImage;
+        infoPtr->ShowCursor = RDCShowCursor;
+        infoPtr->HideCursor = RDCHideCursor;
+        infoPtr->LoadCursorARGB = RDCLoadCursorARGB;
+    }
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCCursorInit()== \n");
+#endif
+    return(xf86InitCursor(pScreen, infoPtr));    
+}
+
+Bool bInitHWC(ScrnInfoPtr pScrn, RDCRecPtr pRDC)
+{
+    /* init cursor cache info */
+    /* Set HWC_NUM in Options instead */ 
+    /* pRDC->HWCInfo.HWC_NUM = DEFAULT_HWC_NUM; */
+    pRDC->HWCInfo.HWC_NUM_Next = 0;    
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter bInitHWC()== \n");
+#endif
+
+    /* allocate HWC cache */  
+    pRDC->HWCInfo.pjHWCVirtualAddr = pRDC->FBVirtualAddr + pRDC->HWCInfo.ulHWCOffsetAddr; 
+        
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "==HWC Virtual Addr = 0x%8x==\n", (ULONG)pRDC->HWCInfo.pjHWCVirtualAddr);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "==HWC Physical Offset = 0x%8x==\n", pRDC->HWCInfo.ulHWCOffsetAddr);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "==Exit2 bInitHWC(), return TRUE== \n");
+#endif
+    
+    return (TRUE);    
+}
+
+
+static void
+RDCShowCursor(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);    
+    UCHAR     jReg;
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCShowCursor()== \n");
+#endif
+    jReg= 0x02;
+    if (pRDC->HWCInfo.cursortype ==HWC_COLOR)
+        jReg |= 0x01;
+               
+    SetIndexRegMask(CRTC_PORT, 0xCB, 0xFC, jReg);    /* enable mono */     
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCShowCursor()== \n");
+#endif
+}
+
+void
+RDCHideCursor(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+        
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCHideCursor()== \n");
+#endif
+    SetIndexRegMask(CRTC_PORT, 0xCB, 0xFC, 0x00);    /* disable HWC */     
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCHideCursor()== \n");
+#endif
+}
+
+static void
+RDCSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
+{
+    RDCRecPtr    pRDC = RDCPTR(pScrn);
+    DisplayModePtr mode = pRDC->ModePtr;    
+    int        x_offset, y_offset, y_end;
+    UCHAR     *pjSignature;    
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 7, "==Enter RDCSetCursorPosition(x = %d, y = %d)== \n", x, y);
+#endif
+    /* Set cursor info to Offscreen */    
+    pjSignature = (UCHAR *) pRDC->HWCInfo.pjHWCVirtualAddr + 
+                  (HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next + 
+                  HWC_SIZE;
+                  
+    *((ULONG *) (pjSignature + HWC_SIGNATURE_X)) = x;
+    *((ULONG *) (pjSignature + HWC_SIGNATURE_Y)) = y;
+               
+    x_offset = pRDC->HWCInfo.offset_x;
+    y_offset = pRDC->HWCInfo.offset_y;
+
+    if(x < 0)
+    {
+        x_offset = (-x) + pRDC->HWCInfo.offset_x;
+        x = 0;
+    }
+
+    if(y < 0)
+    {
+        y_offset = (-y) + pRDC->HWCInfo.offset_y;
+        y = 0;
+    }
+
+    if ( pRDC->DeviceInfo.ScalerConfig.EnableHorScaler &&
+       ((VENDOR_ID(pRDC->PciInfo) != PCI_VENDOR_RDC) || (DEVICE_ID(pRDC->PciInfo) != PCI_CHIP_M2010_A0)))
+    {
+        x = (x * pRDC->DeviceInfo.ScalerConfig.ulHorScalingFactor + 4095) >> 12;
+    }
+
+    if (pRDC->DeviceInfo.ScalerConfig.EnableVerScaler)
+    {
+        y = (y * pRDC->DeviceInfo.ScalerConfig.ulVerScalingFactor + 2047) >> 11;
+        y_end = y + (((MAX_HWC_HEIGHT - y_offset) * pRDC->DeviceInfo.ScalerConfig.ulVerScalingFactor + 2047) >> 11) - 1;
+    }
+
+    if(mode->Flags & V_DBLSCAN)
+        y *= 2;
+ 
+    /* Set to Reg. */
+    SetIndexReg(CRTC_PORT, 0xC2, (UCHAR) (x_offset));     
+    SetIndexReg(CRTC_PORT, 0xC3, (UCHAR) (y_offset));     
+    SetIndexReg(CRTC_PORT, 0xC4, (UCHAR) (x & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xC5, (UCHAR) ((x >> 8) & 0x0F));     
+    SetIndexReg(CRTC_PORT, 0xC6, (UCHAR) (y & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xC7, (UCHAR) ((y >> 8) & 0x07));     
+    SetIndexReg(CRTC_PORT, 0xCC, (UCHAR) (y_end & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xCD, (UCHAR) ((y_end >> 8) & 0x07));     
+    
+    /* Fire HWC */
+    RDCFireCursor(pScrn);
+    
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 7, "==Exit RDCSetCursorPosition()== \n");
+#endif
+}  
+
+
+static void
+RDCSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
+{
+    RDCRecPtr     pRDC = RDCPTR(pScrn);
+
+#if HWC_DEBUG    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetCursorColors(bg = %x, fg = %x)== \n", bg, fg);
+#endif    
+    pRDC->HWCInfo.MonoHWC.fg = (fg & 0x0F) | (((fg>>8) & 0x0F) << 4) | (((fg>>16) & 0x0F) << 8);
+    pRDC->HWCInfo.MonoHWC.bg = (bg & 0x0F) | (((bg>>8) & 0x0F) << 4) | (((bg>>16) & 0x0F) << 8);
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSetCursorColors()== \n");
+#endif
+}
+
+static void
+RDCLoadCursorImage(ScrnInfoPtr pScrn, UCHAR *src)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);   
+    int         i, j, k;
+    UCHAR       *pjSrcAnd, *pjSrcXor, *pjDstData;
+    ULONG       ulTempDstAnd32[2], ulTempDstXor32[2], ulTempDstData32[2];
+    UCHAR       jTempSrcAnd32, jTempSrcXor32;
+    ULONG       ulCheckSum = 0;                         
+    ULONG       ulPatternAddr;
+    
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCLoadCursorImage()== \n");
+#endif 
+    /* init cursor info. */
+    pRDC->HWCInfo.cursortype = HWC_MONO;
+    pRDC->HWCInfo.width  = (USHORT) MAX_HWC_WIDTH;
+    pRDC->HWCInfo.height = (USHORT) MAX_HWC_HEIGHT;
+    pRDC->HWCInfo.offset_x = MAX_HWC_WIDTH - pRDC->HWCInfo.width;
+    pRDC->HWCInfo.offset_y = MAX_HWC_HEIGHT - pRDC->HWCInfo.height;
+
+    /* copy cursor image to cache */
+    pjSrcXor = src;
+    pjSrcAnd = src + (MAX_HWC_WIDTH*MAX_HWC_HEIGHT/8);
+    pjDstData =  pRDC->HWCInfo.pjHWCVirtualAddr+(HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next;
+      
+    for (j = 0; j < MAX_HWC_HEIGHT; j++)
+    {
+        for (i = 0; i < (MAX_HWC_WIDTH/8); i++ )
+        {
+            for (k=7; k>0; k-=2)
+            {
+                jTempSrcAnd32 = *((UCHAR *) pjSrcAnd);
+                jTempSrcXor32 = *((UCHAR *) pjSrcXor);
+                ulTempDstAnd32[0] = ((jTempSrcAnd32 >> k) & 0x01) ? 0x00008000L:0x00L;
+                ulTempDstXor32[0] = ((jTempSrcXor32 >> k) & 0x01) ? 0x00004000L:0x00L;
+                ulTempDstData32[0] = ((jTempSrcXor32 >> k) & 0x01) ? pRDC->HWCInfo.MonoHWC.fg:pRDC->HWCInfo.MonoHWC.bg;
+                ulTempDstAnd32[1] = ((jTempSrcAnd32 >> (k-1)) & 0x01) ? 0x80000000L:0x00L;
+                ulTempDstXor32[1] = ((jTempSrcXor32 >> (k-1)) & 0x01) ? 0x40000000L:0x00L;
+                ulTempDstData32[1] = ((jTempSrcXor32 >> (k-1)) & 0x01) ? (pRDC->HWCInfo.MonoHWC.fg << 16):(pRDC->HWCInfo.MonoHWC.bg << 16);
+                *((ULONG *) pjDstData) = ulTempDstAnd32[0] | ulTempDstXor32[0] | ulTempDstData32[0] | ulTempDstAnd32[1] | ulTempDstXor32[1] | ulTempDstData32[1];
+                ulCheckSum += *((ULONG *) pjDstData);                               
+                pjDstData += 4;
+            }
+            pjSrcAnd ++;
+            pjSrcXor ++;
+        }        
+    }                    
+
+    /* Write Checksum as signature */
+    pjDstData = (UCHAR *) pRDC->HWCInfo.pjHWCVirtualAddr + (HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next + HWC_SIZE;   
+    *((ULONG *) pjDstData) = ulCheckSum;
+    *((ULONG *) (pjDstData + HWC_SIGNATURE_SizeX)) = pRDC->HWCInfo.width;
+    *((ULONG *) (pjDstData + HWC_SIGNATURE_SizeY)) = pRDC->HWCInfo.height;
+    *((ULONG *) (pjDstData + HWC_SIGNATURE_HOTSPOTX)) = 0;
+    *((ULONG *) (pjDstData + HWC_SIGNATURE_HOTSPOTY)) = 0;
+    
+    /* set pattern offset */
+    ulPatternAddr = ((pRDC->HWCInfo.ulHWCOffsetAddr+(HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next) >> 3);
+    
+    SetIndexReg(CRTC_PORT, 0xC8, (UCHAR) (ulPatternAddr & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xC9, (UCHAR) ((ulPatternAddr >> 8) & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xCA, (UCHAR) ((ulPatternAddr >> 16) & 0xFF)); 
+    
+    /* update HWC_NUM_Next */
+    pRDC->HWCInfo.HWC_NUM_Next = (pRDC->HWCInfo.HWC_NUM_Next+1) % pRDC->HWCInfo.HWC_NUM;
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCLoadCursorImage()== \n");
+#endif
+}
+
+static Bool 
+RDCUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs)
+{
+#if HWC_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCUseHWCursor(), return TRUE== \n");
+#endif
+    return TRUE;
+}
+
+static void
+RDCLoadCursorARGB(ScrnInfoPtr pScrn, CursorPtr pCurs)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);   
+
+    UCHAR       *pjDstXor, *pjSrcXor;
+    ULONG       i, j, ulSrcWidth, ulSrcHeight;
+    ULONG       ulPerPixelCopy, ulTwoPixelCopy;    
+    LONG        lAlphaDstDelta, lLastAlphaDstDelta;
+    
+    union
+    {
+        ULONG   ul;
+        UCHAR   b[4];
+    } ulSrcData32[2], ulData32;
+    union
+    {
+        USHORT  us;
+        UCHAR   b[2];
+    } usData16;
+    
+    ULONG       ulCheckSum = 0;                     
+    ULONG       ulPatternAddr;
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCLoadCursorARGB()== \n");
+#endif
+    /* init cursor info. */
+    pRDC->HWCInfo.cursortype = HWC_COLOR;
+    pRDC->HWCInfo.width  = pCurs->bits->width;
+    pRDC->HWCInfo.height = pCurs->bits->height;
+    pRDC->HWCInfo.offset_x = MAX_HWC_WIDTH - pRDC->HWCInfo.width;
+    pRDC->HWCInfo.offset_y = MAX_HWC_HEIGHT - pRDC->HWCInfo.height;
+    
+    /* copy cursor image to cache */
+    ulSrcWidth  =  pRDC->HWCInfo.width;  
+    ulSrcHeight =  pRDC->HWCInfo.height;  
+        
+    lAlphaDstDelta = MAX_HWC_WIDTH << 1;
+    lLastAlphaDstDelta = lAlphaDstDelta - (ulSrcWidth << 1);
+
+    pjSrcXor  = (UCHAR *) pCurs->bits->argb;;
+    pjDstXor  = (UCHAR *) pRDC->HWCInfo.pjHWCVirtualAddr + (HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next
+                        + lLastAlphaDstDelta + (MAX_HWC_HEIGHT - ulSrcHeight) * lAlphaDstDelta;
+    
+    ulPerPixelCopy =  ulSrcWidth & 1;
+    ulTwoPixelCopy =  ulSrcWidth >> 1;
+                   
+    for (j = 0; j < ulSrcHeight; j++)
+    {
+        for (i = 0; i < ulTwoPixelCopy; i++ )
+        {
+            ulSrcData32[0].ul = *((ULONG *) pjSrcXor) & 0xF0F0F0F0;
+            ulSrcData32[1].ul = *((ULONG *) (pjSrcXor+4)) & 0xF0F0F0F0;
+            ulData32.b[0] = ulSrcData32[0].b[1] | (ulSrcData32[0].b[0] >> 4);
+            ulData32.b[1] = ulSrcData32[0].b[3] | (ulSrcData32[0].b[2] >> 4);
+            ulData32.b[2] = ulSrcData32[1].b[1] | (ulSrcData32[1].b[0] >> 4);
+            ulData32.b[3] = ulSrcData32[1].b[3] | (ulSrcData32[1].b[2] >> 4);                     
+            *((ULONG *) pjDstXor) = ulData32.ul;
+            ulCheckSum += (ULONG) ulData32.ul;                                     
+            pjDstXor += 4;
+            pjSrcXor += 8;
+        } 
+        
+        for (i = 0; i < ulPerPixelCopy; i++ )
+        {
+            ulSrcData32[0].ul = *((ULONG *) pjSrcXor) & 0xF0F0F0F0;
+            usData16.b[0] = ulSrcData32[0].b[1] | (ulSrcData32[0].b[0] >> 4);
+            usData16.b[1] = ulSrcData32[0].b[3] | (ulSrcData32[0].b[2] >> 4);
+            *((USHORT *) pjDstXor) = usData16.us;
+            ulCheckSum += (ULONG) usData16.us;                                                 
+            pjDstXor += 2;
+            pjSrcXor += 4;
+        } 
+
+        /* Point to next source and dest scans */
+        pjDstXor += lLastAlphaDstDelta;
+    } /* end of for-loop */
+
+    /* Write Checksum as signature */
+    pjDstXor = (UCHAR *) pRDC->HWCInfo.pjHWCVirtualAddr + (HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next + HWC_SIZE;   
+    *((ULONG *) pjDstXor) = ulCheckSum;
+    *((ULONG *) (pjDstXor + HWC_SIGNATURE_SizeX)) = pRDC->HWCInfo.width;
+    *((ULONG *) (pjDstXor + HWC_SIGNATURE_SizeY)) = pRDC->HWCInfo.height;
+    *((ULONG *) (pjDstXor + HWC_SIGNATURE_HOTSPOTX)) = 0;
+    *((ULONG *) (pjDstXor + HWC_SIGNATURE_HOTSPOTY)) = 0;
+           
+    /* set pattern offset */
+    ulPatternAddr = ((pRDC->HWCInfo.ulHWCOffsetAddr +(HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM_Next) >> 3);
+    SetIndexReg(CRTC_PORT, 0xC8, (UCHAR) (ulPatternAddr & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xC9, (UCHAR) ((ulPatternAddr >> 8) & 0xFF));     
+    SetIndexReg(CRTC_PORT, 0xCA, (UCHAR) ((ulPatternAddr >> 16) & 0xFF)); 
+    
+    /* update HWC_NUM_Next */
+    pRDC->HWCInfo.HWC_NUM_Next = (pRDC->HWCInfo.HWC_NUM_Next+1) % pRDC->HWCInfo.HWC_NUM;
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCLoadCursorARGB()== \n");
+#endif
+}
+
+static Bool 
+RDCUseHWCursorARGB(ScreenPtr pScreen, CursorPtr pCurs)
+{
+#if HWC_DEBUG
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCUseHWCursorARGB(), return TRUE== \n");
+#endif
+    return TRUE;
+}
+
+static void
+RDCFireCursor(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCFireCursor()== \n");
+#endif
+    SetIndexRegMask(CRTC_PORT, 0xCB, 0xFF, 0x00);    /* dummp write to fire HWC */     
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCFireCursor()== \n");
+#endif
+}
+
+//
+// For 32bit data and MMIO control Hardware Cursor
+void RDCHideCursor_HQ(ScrnInfoPtr pScrn)
+{
+    ULONG      ulCursorCTRL;
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    
+    ulCursorCTRL = *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)); 
+    *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)) = (ulCursorCTRL& ~BIT1);
+}
+
+static void RDCShowCursor_HQ(ScrnInfoPtr pScrn)
+{
+    ULONG      ulCursorCTRL;
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Enter RDCShowCursor_HQ()== \n");
+#endif
+
+    ulCursorCTRL = *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL));
+
+    if (pRDC->HWCInfo.cursortype ==HWC_COLOR)
+        ulCursorCTRL |= BIT0;
+        
+    *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)) = (ulCursorCTRL | BIT1);
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Cursor MMIO regs = %08x %08x %08x %08x== \n", 
+                                *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)),
+                                *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_OFFSET)),
+                                *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_POSITION)),
+                                *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_ADDRESS)));
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Exit RDCShowCursor_HQ()== \n");
+#endif
+
+}
+
+static void RDCSetCursorColors_HQ(ScrnInfoPtr pScrn, int bg, int fg)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);
+
+    int         i, j, k;
+    UCHAR       *pjSrcAnd, *pjSrcXor;
+    UCHAR       jTempSrcAnd, jTempSrcXor;
+    ULONG       ulTempDstXor32, ulTempDstAnd32, ulTempDstData32;
+    ULONG       *pulDstData;
+  
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSetCursorColors_HQ(bg = %x, fg = %x)== \n", bg, fg);
+#endif
+
+    pRDC->HWCInfo.MonoHWC.fg = fg;
+    pRDC->HWCInfo.MonoHWC.bg = bg;
+
+    pjSrcXor = pRDC->HWCInfo.MonoHWC.ucXorBitmap;
+    pjSrcAnd = pRDC->HWCInfo.MonoHWC.ucAndBitmap;
+    pulDstData = (ULONG*)(pRDC->HWCInfo.MonoHWC.pjPatternVirtualAddr);
+
+    for (j = 0; j < MAX_HWC_HEIGHT; j++)
+    {
+        for (i = 0; i < (MAX_HWC_WIDTH/8); i++)
+        {
+            jTempSrcXor = *pjSrcXor;
+            jTempSrcAnd = *pjSrcAnd;
+
+            for (k=7; k>=0; k--)
+            {
+                ulTempDstAnd32 = ((jTempSrcAnd >> k) & 0x01) ? 0x80000000L:0x00L;
+                ulTempDstXor32 = ((jTempSrcXor >> k) & 0x01) ? 0x40000000L:0x00L;
+                ulTempDstData32 = ((jTempSrcXor >> k) & 0x01) ? fg:bg;
+                *pulDstData = ulTempDstAnd32|ulTempDstXor32|ulTempDstData32;
+                pulDstData++;
+            }
+
+            pjSrcXor++;
+            pjSrcAnd++;
+        }        
+    }                    
+}
+
+static void RDCLoadCursorImage_HQ(ScrnInfoPtr pScrn, UCHAR *src)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);   
+    UCHAR       *pjSrcAnd, *pjSrcXor;
+    ULONG       ulPatternOffset;
+
+    
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCLoadCursorImage_HQ()== \n");
+#endif 
+    /* init cursor info. */
+    pRDC->HWCInfo.cursortype = HWC_MONO;
+    pRDC->HWCInfo.width  = (USHORT) MAX_HWC_WIDTH;
+    pRDC->HWCInfo.height = (USHORT) MAX_HWC_HEIGHT;
+    pRDC->HWCInfo.offset_x = MAX_HWC_WIDTH - pRDC->HWCInfo.width;
+    pRDC->HWCInfo.offset_y = MAX_HWC_HEIGHT - pRDC->HWCInfo.height;
+
+    /* copy cursor image to cache */
+    pjSrcXor = src;
+    pjSrcAnd = src + (MAX_HWC_WIDTH*MAX_HWC_HEIGHT/8);
+
+    memcpy(&(pRDC->HWCInfo.MonoHWC.ucXorBitmap),pjSrcXor, sizeof(pRDC->HWCInfo.MonoHWC.ucXorBitmap));
+    memcpy(&(pRDC->HWCInfo.MonoHWC.ucAndBitmap),pjSrcAnd, sizeof(pRDC->HWCInfo.MonoHWC.ucAndBitmap));
+
+    /* set pattern offset */
+    ulPatternOffset = pRDC->HWCInfo.ulHWCOffsetAddr+HQ_HWC_SIZE*pRDC->HWCInfo.HWC_NUM_Next;
+    pRDC->HWCInfo.MonoHWC.pjPatternVirtualAddr = pRDC->FBVirtualAddr + ulPatternOffset;
+    *((ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_ADDRESS)) = ((ulPatternOffset >> 3) & 0xFFFFFF);
+
+    /* update HWC_NUM_Next */
+    pRDC->HWCInfo.HWC_NUM_Next = (pRDC->HWCInfo.HWC_NUM_Next+1) % pRDC->HWCInfo.HWC_NUM;
+    
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCLoadCursorImage_HQ()== \n");
+#endif
+}
+
+static void RDCLoadCursorARGB_HQ(ScrnInfoPtr pScrn, CursorPtr pCurs)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);   
+
+    UCHAR       *pjDstXor, *pjSrcXor;
+    ULONG       j, ulSrcWidthInByte, ulSrcHeight;
+    LONG        ulDstCursorPitch;
+    ULONG       ulPatternAddr;
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCLoadCursorARGB_HQ()== \n");
+#endif
+    /* init cursor info. */
+    pRDC->HWCInfo.cursortype = HWC_COLOR;
+    pRDC->HWCInfo.width  = pCurs->bits->width;
+    pRDC->HWCInfo.height = pCurs->bits->height;
+    pRDC->HWCInfo.xhot = pCurs->bits->xhot;
+    pRDC->HWCInfo.yhot = pCurs->bits->yhot;
+    pRDC->HWCInfo.offset_x = MAX_HWC_WIDTH - pRDC->HWCInfo.width;
+    pRDC->HWCInfo.offset_y = MAX_HWC_HEIGHT - pRDC->HWCInfo.height;
+    
+    /* copy cursor image to cache */
+    ulSrcWidthInByte = pRDC->HWCInfo.width << 2;  
+    ulSrcHeight = pRDC->HWCInfo.height;  
+        
+    ulDstCursorPitch = MAX_HWC_WIDTH << 2;
+
+    pjSrcXor  = (UCHAR *) pCurs->bits->argb;
+    pjDstXor  = (UCHAR *) pRDC->HWCInfo.pjHWCVirtualAddr + 
+                HQ_HWC_SIZE*pRDC->HWCInfo.HWC_NUM_Next +
+                (MAX_HWC_HEIGHT - ulSrcHeight) * ulDstCursorPitch +
+                (ulDstCursorPitch - ulSrcWidthInByte);
+    
+    for (j = 0; j < ulSrcHeight; j++)
+    {
+        memcpy(pjDstXor,pjSrcXor, ulSrcWidthInByte);
+        
+        /* Point to next source and dest scans */
+        pjSrcXor += ulSrcWidthInByte;
+        pjDstXor += ulDstCursorPitch;
+    } /* end of for-loop */
+
+           
+    /* set pattern offset */
+    ulPatternAddr = ((pRDC->HWCInfo.ulHWCOffsetAddr +HQ_HWC_SIZE*pRDC->HWCInfo.HWC_NUM_Next) >> 3);
+
+    *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_ADDRESS)) = (ulPatternAddr & 0xFFFFFF);
+    
+    /* update HWC_NUM_Next */
+    pRDC->HWCInfo.HWC_NUM_Next = (pRDC->HWCInfo.HWC_NUM_Next+1) % pRDC->HWCInfo.HWC_NUM;
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCLoadCursorARGB()== \n");
+#endif
+}
+
+static void RDCSetCursorPosition_HQ(ScrnInfoPtr pScrn, int x, int y)
+{
+    RDCRecPtr    pRDC = RDCPTR(pScrn);
+    DisplayModePtr mode = pRDC->ModePtr;
+    HWCINFO     *pHWCInfo = &pRDC->HWCInfo;
+    int         x_offset, y_offset, y_end;
+    int         xhot, yhot;
+    int         iOverlayStartX, iOverlayStartY;
+    int         iOverlayEndX,   iOverlayEndY;
+    int         iOverlayDispCntX, iOverlayDispCntY;
+    int         iOverlayStartOffsetX, iOverlayStartOffsetY;
+    int         iOverlaySrcWidth, iOverlaySrcHeight;
+    int         iOverlayDstWidth, iOverlayDstHeight;
+    int         iOverlayFetchCnt;
+    ULONG       ulCursorCtrl;
+    Bool        bNeedAdjustFrame = false;
+
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Enter RDCSetCursorPosition_HQ(x = %d, y = %d)== \n", x, y);
+#endif
+
+    xhot = pRDC->HWCInfo.xhot;
+    yhot = pRDC->HWCInfo.yhot;
+
+    x_offset = pRDC->HWCInfo.offset_x;
+    y_offset = pRDC->HWCInfo.offset_y;
+
+    /* limit cursor in screen region */
+    if ((x+xhot) >= mode->HDisplay)
+    {
+        x = mode->HDisplay - xhot -1;
+    }
+
+    if ((y+yhot) >= mode->VDisplay)
+    {
+        y = mode->VDisplay - yhot -1;
+    }
+    
+    if ((x+xhot) < 0)
+    {
+        x = (-xhot);
+    }
+
+    if ((y+yhot) < 0)
+    {
+        y = (-yhot);
+    }
+
+    
+    /* adjust cursor position for panning mode */
+    if (pRDC->DeviceInfo.ucDeviceID == 1)
+    {
+            if (x+xhot >= pHWCInfo->iScreenOffset_x + (int)pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution)
+            {
+               pHWCInfo->iScreenOffset_x = x + xhot - ((int)(pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution) - 1);
+               x = (int)(pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution) - 1 - xhot;
+               bNeedAdjustFrame = true;
+            }
+            else if (x+xhot < pHWCInfo->iScreenOffset_x)
+            {
+                pHWCInfo->iScreenOffset_x = x + xhot;
+                x = -xhot;
+                bNeedAdjustFrame = true;
+            }
+            else
+            {
+                x -= pHWCInfo->iScreenOffset_x;
+            }
+
+            if (y+yhot >= pHWCInfo->iScreenOffset_y + (int)pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution)
+            {
+               pHWCInfo->iScreenOffset_y = y + yhot - ((int)pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution - 1);
+               y = (int)pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution - 1 - yhot;
+               bNeedAdjustFrame = true;
+            }
+            else if (y+yhot < pHWCInfo->iScreenOffset_y)
+            {
+                pHWCInfo->iScreenOffset_y = y + yhot;
+                y = -yhot;
+                bNeedAdjustFrame = true;
+            }
+            else
+            {
+                y -= pHWCInfo->iScreenOffset_y;
+            }
+
+            if (bNeedAdjustFrame)
+            {
+                RDCAdjustFrame(pScrn->scrnIndex, pHWCInfo->iScreenOffset_x, pHWCInfo->iScreenOffset_y, 0);
+                if (pRDC->OverlayStatus.bOverlayEnable)
+                {
+                    iOverlaySrcWidth = pRDC->OverlayStatus.iSrcWidth;
+                    iOverlaySrcHeight = pRDC->OverlayStatus.iSrcHeight;
+
+                    iOverlayDstWidth = pRDC->OverlayStatus.iDstWidth;
+                    iOverlayDstHeight = pRDC->OverlayStatus.iDstHeight;
+                                        
+                    iOverlayStartX = pRDC->OverlayStatus.iDstLeft - pHWCInfo->iScreenOffset_x;
+                    iOverlayStartY = pRDC->OverlayStatus.iDstTop - pHWCInfo->iScreenOffset_y;
+                    
+                    iOverlayEndX = iOverlayStartX + iOverlayDstWidth - 1;
+                    iOverlayEndY = iOverlayStartY + iOverlayDstHeight - 1;
+                    
+                    iOverlayStartOffsetX = 0;
+                    iOverlayStartOffsetY = 0;
+                    
+                    if (iOverlayEndX >= pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution)
+                    {
+                        iOverlayEndX = pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution - 1;
+                    }
+                    
+                    if (iOverlayEndY >= pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution)
+                    {
+                        iOverlayEndY = pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution - 1;
+                    }
+                    
+                    iOverlayDispCntX = (iOverlaySrcWidth * (iOverlayEndX - iOverlayStartX + 1) -1) / iOverlayDstWidth;
+                    iOverlayDispCntY = (iOverlaySrcHeight * (iOverlayEndY - iOverlayStartY + 1) -1) / iOverlayDstHeight;
+
+                    if (iOverlayStartX < 0)
+                    {
+                        iOverlayStartOffsetX = (iOverlaySrcWidth * (-iOverlayStartX)) / iOverlayDstWidth;
+                        iOverlayStartX = 0;
+                    }
+                    
+                    if (iOverlayStartY < 0)
+                    {
+                        iOverlayStartOffsetY = (iOverlaySrcHeight * (-iOverlayStartY)) / iOverlayDstHeight;
+                        iOverlayStartY = 0;
+                    }
+                    
+                    iOverlayFetchCnt = ((((iOverlaySrcWidth << 1) * (iOverlayEndX - iOverlayStartX + 1)+ iOverlayDstWidth - 1) / iOverlayDstWidth) + 7) >> 3;
+                    
+                    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_START_LOCATION) = (iOverlayStartX << 16) | iOverlayStartY;
+                    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_END_LOCATION) = (iOverlayEndX << 16) | iOverlayEndY;
+                    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_START_OFFSET) = (iOverlayStartOffsetX << 16) | iOverlayStartOffsetY;
+                    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_SRC_DISP_COUNT_ON_SCR) = (iOverlayDispCntY << 16) | iOverlayDispCntX;
+                    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FETCH_COUNT) = iOverlayFetchCnt;
+                    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_REG_UPDATE_MOD_SELECT) = VDPS_FIRE;
+                }
+                else
+                {
+                    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "overlay disabled\n");
+                }
+            }
+    }
+
+    /* adjust cursor position by 1 line */
+    y++;
+
+
+    if(x < 0)
+    {
+        x_offset = (-x) + pRDC->HWCInfo.offset_x;
+        x = 0;
+    }
+
+    if(y < 0)
+    {
+        y_offset = (-y) + pRDC->HWCInfo.offset_y;
+        y = 0;
+    }
+
+    if ( pRDC->DeviceInfo.ScalerConfig.EnableHorScaler)
+    {
+        x = (x * pRDC->DeviceInfo.ScalerConfig.ulHorScalingFactor + 4095) >> 12;
+#if HWC_DEBUG
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "H scaling factor = %x\n", pRDC->DeviceInfo.ScalerConfig.ulHorScalingFactor);
+#endif
+
+    }
+
+    y_end = y + (MAX_HWC_HEIGHT - y_offset);
+
+    if (pRDC->DeviceInfo.ScalerConfig.EnableVerScaler)
+    {
+        y = (y * pRDC->DeviceInfo.ScalerConfig.ulVerScalingFactor + 2047) >>11;
+        y_end =  ((y_end * pRDC->DeviceInfo.ScalerConfig.ulVerScalingFactor + 2047) >> 11) - 1;
+    }
+    else
+    {
+        y_end--;
+    }
+
+    if(mode->Flags & V_DBLSCAN)
+        y *= 2;
+ 
+    /* Set to Reg. */
+    *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_OFFSET)) = 
+        (x_offset & 0x3F) | ((y_offset & 0x3F) << 8) | ((y_end & 0x7FF) << 16);
+    *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_POSITION)) =
+         (x & 0xFFF) | ((y & 0x7FF)<< 16);
+    
+    /* Fire HWC */
+    ulCursorCtrl = *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)); 
+    *((volatile ULONG*)(pRDC->MMIOVirtualAddr + HWC_MMIO_CTRL)) = ulCursorCtrl;
+    
+#if HWC_DEBUG
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Exit RDCSetCursorPosition()== \n");
+#endif
+}
+#endif    /* End of HWC */
diff --git a/src/rdc_cursor.h b/src/rdc_cursor.h
new file mode 100644
index 0000000..4ab1fad
--- /dev/null
+++ b/src/rdc_cursor.h
@@ -0,0 +1,44 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#define MAX_HWC_WIDTH           64
+#define MAX_HWC_HEIGHT          64
+#define HWC_SIZE                (MAX_HWC_WIDTH*MAX_HWC_HEIGHT*2)
+#define HQ_HWC_SIZE             (MAX_HWC_WIDTH*MAX_HWC_HEIGHT*4)
+#define HWC_SIGNATURE_SIZE      32
+#define HWC_ALIGN               32
+
+#define HWC_MONO                0
+#define HWC_COLOR               1
+
+/* define for signature structure */
+#define HWC_SIGNATURE_CHECKSUM  0x00
+#define HWC_SIGNATURE_SizeX     0x04
+#define HWC_SIGNATURE_SizeY     0x08
+#define HWC_SIGNATURE_X         0x0C
+#define HWC_SIGNATURE_Y         0x10
+#define HWC_SIGNATURE_HOTSPOTX  0x14
+#define HWC_SIGNATURE_HOTSPOTY  0x18
+
+
+#define HWC_MMIO_CTRL           0x580
+#define HWC_MMIO_OFFSET         0x584
+#define HWC_MMIO_POSITION       0x588
+#define HWC_MMIO_ADDRESS        0x58C
diff --git a/src/rdc_driver.c b/src/rdc_driver.c
new file mode 100644
index 0000000..08ca023
--- /dev/null
+++ b/src/rdc_driver.c
@@ -0,0 +1,1701 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define XF86_VERSION_NUMERIC(major,minor,patch,snap,dummy) \
+         (((major) * 10000000) + ((minor) * 100000) + ((patch) * 1000) + snap)
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+/* external reference fucntion */
+#if !XSERVER_LIBPCIACCESS
+extern Bool RDCMapMem(ScrnInfoPtr pScrn);
+#endif
+extern Bool RDCUnmapMem(ScrnInfoPtr pScrn);
+extern Bool RDCMapMMIO(ScrnInfoPtr pScrn);
+extern void RDCUnmapMMIO(ScrnInfoPtr pScrn);
+extern Bool RDCMapVBIOS(ScrnInfoPtr pScrn);
+extern Bool RDCUnmapVBIOS(ScrnInfoPtr pScrn);
+
+extern void vRDCOpenKey(ScrnInfoPtr pScrn);
+extern Bool bRDCRegInit(ScrnInfoPtr pScrn);
+extern ULONG GetVRAMInfo(ScrnInfoPtr pScrn);
+extern Bool RDCFilterModeByBandWidth(ScrnInfoPtr pScrn, DisplayModePtr mode);
+extern ULONG RDCGetMemBandWidth(ScrnInfoPtr pScrn);
+extern void vRDCLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, VisualPtr pVisual);
+extern void RDCDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags);
+extern void vSetStartAddressCRT1(RDCRecPtr pRDC, ULONG base);
+extern Bool RDCSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode);
+
+extern Bool bInitCMDQInfo(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+extern Bool bEnableCMDQ(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+extern void vDisable2D(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+
+extern Bool RDCAccelInit(ScreenPtr pScreen);
+
+extern Bool RDCCursorInit(ScreenPtr pScreen);
+extern DisplayModePtr RDCBuildModePool(ScrnInfoPtr pScrn);
+extern void RDCVideoInit(ScreenPtr pScreen);
+
+/* Mandatory functions */
+static void RDCIdentify(int flags);
+const OptionInfoRec *RDCAvailableOptions(int chipid, int busid);
+#if XSERVER_LIBPCIACCESS
+static Bool rdc_pci_probe (DriverPtr drv, int entity_num, struct pci_device *dev, intptr_t match_data);
+#else
+static Bool RDCProbe(DriverPtr drv, int flags);
+#endif
+static Bool RDCPreInit(ScrnInfoPtr pScrn, int flags);
+static Bool RDCScreenInit(int Index, ScreenPtr pScreen, int argc, char **argv);
+Bool RDCSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
+void RDCAdjustFrame(int scrnIndex, int x, int y, int flags);
+static Bool RDCEnterVT(int scrnIndex, int flags);
+static void RDCLeaveVT(int scrnIndex, int flags);
+static void RDCFreeScreen(int scrnIndex, int flags);
+static ModeStatus RDCValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags);
+
+/* Internally used functions */
+static Bool RDCGetRec(ScrnInfoPtr pScrn);
+static void RDCFreeRec(ScrnInfoPtr pScrn);
+static Bool RDCSaveScreen(ScreenPtr pScreen, Bool unblack);
+static Bool RDCCloseScreen(int scrnIndex, ScreenPtr pScreen);
+static void RDCSave(ScrnInfoPtr pScrn);
+static void RDCRestore(ScrnInfoPtr pScrn);
+static void RDCProbeDDC(ScrnInfoPtr pScrn, int index);
+static xf86MonPtr RDCDoDDC(ScrnInfoPtr pScrn, int index);
+static void vFillRDCModeInfo (ScrnInfoPtr pScrn);
+static Bool RDCModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
+static void RDCSetHWCaps(RDCRecPtr pRDC);
+
+#if XSERVER_LIBPCIACCESS
+#define RDC_DEVICE_MATCH(d,i) \
+    { PCI_VENDOR_RDC, (d), PCI_MATCH_ANY, PCI_MATCH_ANY, 0, 0, (i) }
+
+static const struct pci_id_match rdc_device_match[] = {
+   RDC_DEVICE_MATCH (PCI_VENDOR_RDC_M2010_A0, 0 ),
+   RDC_DEVICE_MATCH (PCI_CHIP_M2010, 0 ),
+   RDC_DEVICE_MATCH (PCI_CHIP_M2010_A0, 0 ),
+   RDC_DEVICE_MATCH (PCI_CHIP_M2011, 0 ),
+    { 0, 0, 0 },
+};
+#endif
+
+/*
+ * This is intentionally screen-independent.  It indicates the binding
+ * choice made in the first PreInit.
+ */
+_X_EXPORT DriverRec RDC = {
+   RDC_VERSION,
+   RDC_DRIVER_NAME,
+   RDCIdentify,
+#if XSERVER_LIBPCIACCESS
+   NULL,
+#else
+   RDCProbe,
+#endif
+   RDCAvailableOptions,
+   NULL,
+   0,
+   NULL,
+#if XSERVER_LIBPCIACCESS
+   rdc_device_match,
+   rdc_pci_probe
+#endif
+};
+
+
+/* Chipsets */
+static SymTabRec RDCChipsets[] = {
+    {PCI_CHIP_M2010_A0, "M2010_A0"},
+    {PCI_CHIP_M2010, "M2010"},
+    {PCI_CHIP_M2011, "M2011"},
+    {-1,              NULL}
+};
+
+static PciChipsets RDCPciChipsets[] = {
+    {PCI_CHIP_M2010, PCI_CHIP_M2010, RES_SHARED_VGA},
+    {PCI_CHIP_M2010_A0, PCI_CHIP_M2010_A0, RES_SHARED_VGA},
+    {PCI_CHIP_M2011, PCI_CHIP_M2011, RES_SHARED_VGA},
+    {-1,              -1,              RES_UNDEFINED }
+};
+
+typedef enum {
+    OPTION_NOACCEL,
+    OPTION_MMIO2D,   
+    OPTION_SW_CURSOR,
+    OPTION_HWC_NUM,
+    OPTION_ENG_CAPS,   
+    OPTION_DBG_SELECT,
+    OPTION_NO_DDC
+} RDCOpts;
+
+static const OptionInfoRec RDCOptions[] = {
+    {OPTION_NOACCEL,    "NoAccel",      OPTV_BOOLEAN,   {0},    FALSE},
+    {OPTION_MMIO2D,     "MMIO2D",       OPTV_BOOLEAN,   {0},    FALSE},   
+    {OPTION_SW_CURSOR,  "SWCursor",     OPTV_BOOLEAN,   {0},    FALSE},    
+    {OPTION_HWC_NUM,    "HWCNumber",    OPTV_INTEGER,   {0},    FALSE},
+    {OPTION_ENG_CAPS,   "ENGCaps",      OPTV_INTEGER,   {0},    FALSE},                    
+    {OPTION_DBG_SELECT, "DBGSelect",    OPTV_INTEGER,   {0},    FALSE},           
+    {OPTION_NO_DDC,     "NoDDC",        OPTV_BOOLEAN,   {0},    FALSE},   
+    {-1,                NULL,           OPTV_NONE,      {0},    FALSE}
+};
+
+const char *vgahwSymbols[] = {
+    "vgaHWFreeHWRec",
+    "vgaHWGetHWRec",
+    "vgaHWGetIOBase",
+    "vgaHWGetIndex",
+    "vgaHWInit",
+    "vgaHWLock",
+    "vgaHWMapMem",
+    "vgaHWProtect",
+    "vgaHWRestore",
+    "vgaHWSave",
+    "vgaHWSaveScreen",
+    "vgaHWSetMmioFuncs",
+    "vgaHWUnlock",
+    "vgaHWUnmapMem",
+    NULL
+};
+
+const char *fbSymbols[] = {
+    "fbPictureInit",
+    "fbScreenInit",
+    NULL
+};
+
+const char *vbeSymbols[] = {
+    "VBEInit",
+    "VBEFreeModeInfo",
+    "VBEFreeVBEInfo",
+    "VBEGetModeInfo",
+    "VBEGetModePool",
+    "VBEGetVBEInfo",
+    "VBEGetVBEMode",
+    "VBEPrintModes",
+    "VBESaveRestore",
+    "VBESetDisplayStart",
+    "VBESetGetDACPaletteFormat",
+    "VBESetGetLogicalScanlineLength",
+    "VBESetGetPaletteData",
+    "VBESetModeNames",
+    "VBESetModeParameters",
+    "VBESetVBEMode",
+    "VBEValidateModes",
+    "vbeDoEDID",
+    "vbeFree",
+    NULL
+};
+
+#ifdef XFree86LOADER
+static const char *vbeOptionalSymbols[] = {
+    "VBEDPMSSet",
+    "VBEGetPixelClock",
+    NULL
+};
+#endif
+
+const char *ddcSymbols[] = {
+    "xf86PrintEDID",
+    "xf86SetDDCproperties",
+    NULL
+};
+
+const char *int10Symbols[] = {
+    "xf86ExecX86int10",
+    "xf86InitInt10",
+    "xf86Int10AllocPages",
+    "xf86int10Addr",
+    NULL
+};
+
+const char *xaaSymbols[] = {
+    "XAACreateInfoRec",
+    "XAADestroyInfoRec",
+    "XAAInit",
+    "XAACopyROP",
+    "XAAPatternROP",
+    NULL
+};
+
+const char *ramdacSymbols[] = {
+    "xf86CreateCursorInfoRec",
+    "xf86DestroyCursorInfoRec",
+    "xf86InitCursor",
+    NULL
+};
+
+
+#ifdef XFree86LOADER
+
+static MODULESETUPPROTO(RDCSetup);
+
+static XF86ModuleVersionInfo RDCVersRec = {
+    RDC_DRIVER_NAME,
+    MODULEVENDORSTRING,
+    MODINFOSTRING1,
+    MODINFOSTRING2,
+    XORG_VERSION_CURRENT,
+    RDC_MAJOR_VERSION, RDC_MINOR_VERSION, RDC_PATCH_VERSION,
+    ABI_CLASS_VIDEODRV,
+#ifdef PATCH_ABI_VERSION
+    SET_ABI_VERSION(0, 5),
+#else 
+    ABI_VIDEODRV_VERSION,
+#endif
+    MOD_CLASS_VIDEODRV,
+    {0, 0, 0, 0}
+};
+
+XF86ModuleData rdcModuleData = { &RDCVersRec, RDCSetup, NULL };
+
+static pointer
+RDCSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+{
+    static Bool setupDone = FALSE;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCSetup()== \n");
+    
+    /* This module should be loaded only once, but check to be sure. */
+
+    if (!setupDone)
+    {
+        setupDone = TRUE;
+        xf86AddDriver(&RDC, module, 
+#if XSERVER_LIBPCIACCESS
+		      HaveDriverFuncs
+#else
+		      0
+#endif
+                     );
+
+        /* Tell the loader about symbols from other modules that this module might refer to. */
+        /*========================================================
+            void LoaderRefSymLists(const char **list0, ...)
+            This function allows the registration of possibly unresolved symbols with
+            the loader. When LoaderCheckUnresolved() is run it won't generate
+            warnings for symbols registered in this way unless they were also registered
+            as required symbols. The function takes one or more NULL terminated
+            lists of symbols. The end of the argument list is indicated by a NULL
+            argument.
+        ==========================================================*/
+        LoaderRefSymLists(vgahwSymbols,
+        fbSymbols, xaaSymbols, ramdacSymbols,
+        vbeSymbols, vbeOptionalSymbols,
+        ddcSymbols, int10Symbols, NULL);
+
+        /* The return value must be non-NULL on success even though there is no TearDownProc. */
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 RDCSetup()== return TRUE\n");
+        return (pointer) TRUE;
+    }
+    else
+    {
+        if (errmaj)
+        *errmaj = LDR_ONCEONLY;
+
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit2 RDCSetup()== return NULL\n");
+        return NULL;
+    }
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit3 RDCSetup()== \n");
+}
+
+#endif    /* XFree86LOADER */
+
+/*
+ * RDCIdentify --
+ *
+ * Returns the string name for the driver based on the chipset. In this
+ * case it will always be an RDC, so we can return a static string.
+ *
+ */
+static void
+RDCIdentify(int flags)
+{
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCIdentify()== \n");
+    xf86PrintChipsets(RDC_NAME, "Driver for RDC Graphics Chipsets", RDCChipsets);
+    xf86DrvMsgVerb(1, X_INFO, DefaultLevel, "==Exit RDCIdentify()== \n");
+}
+
+const OptionInfoRec *
+RDCAvailableOptions(int chipid, int busid)
+{
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCAvailableOptions()== return RDCOptions\n");
+    return RDCOptions;
+}
+
+#if XSERVER_LIBPCIACCESS
+/*
+ * rdc_pci_probe --
+ *
+ * Look through the PCI bus to find cards that are rdc boards.
+ * Setup the dispatch table for the rest of the driver functions.
+ *
+ */
+static Bool rdc_pci_probe (DriverPtr		driver,
+			   int		        entity_num,
+			   struct pci_device	*device,
+			   intptr_t		match_data)
+{
+    ScrnInfoPtr	    pScrn = NULL;
+    EntityInfoPtr   entity;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter rdc_pci_probe== \n");
+
+    pScrn = xf86ConfigPciEntity (pScrn, 0, entity_num, RDCPciChipsets,
+				NULL,
+				NULL, NULL, NULL, NULL);
+    if (pScrn != NULL)
+    {
+	pScrn->driverVersion = RDC_VERSION;
+	pScrn->driverName = RDC_DRIVER_NAME;
+	pScrn->name = RDC_NAME;
+	pScrn->Probe = NULL;
+
+	entity = xf86GetEntityInfo (entity_num);
+	
+	switch (DEVICE_ID(device)) {
+        case PCI_VENDOR_RDC_M2010_A0:
+        case PCI_CHIP_M2010:
+        case PCI_CHIP_M2010_A0:
+        case PCI_CHIP_M2011:
+            pScrn->PreInit = RDCPreInit;
+            pScrn->ScreenInit = RDCScreenInit;
+            pScrn->SwitchMode = RDCSwitchMode;
+            pScrn->AdjustFrame = RDCAdjustFrame;   
+            pScrn->EnterVT = RDCEnterVT;
+            pScrn->LeaveVT = RDCLeaveVT;
+            pScrn->FreeScreen = RDCFreeScreen;
+            pScrn->ValidMode = RDCValidMode;
+            break;
+
+	default:
+	    break;
+	}
+    }
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit rdc_pci_probe== \n");
+    return pScrn != NULL;
+}
+#else
+/*
+ * RDCProbe --
+ *
+ * Look through the PCI bus to find cards that are RDC boards.
+ * Setup the dispatch table for the rest of the driver functions.
+ *
+ */
+static Bool
+RDCProbe(DriverPtr drv, int flags)
+{
+    int i, numUsed, numDevSections, *usedChips;
+    Bool foundScreen = FALSE;
+    GDevPtr *devSections;   
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCProbe== \n");
+
+    /*
+    * Find the config file Device sections that match this
+    * driver, and return if there are none.
+    */
+    if ((numDevSections = xf86MatchDevice(RDC_DRIVER_NAME, &devSections)) <= 0)
+    {
+        xf86DrvMsgVerb(0, X_INFO, 0, "==Exit1 RDCProbe()== return FALSE\n");
+        return FALSE;
+    }
+
+    /*
+    * This probing is just checking the PCI data the server already
+    * collected.
+    */
+    if (xf86GetPciVideoInfo() == NULL)
+    {
+        xf86DrvMsgVerb(0, X_INFO, 0, "==Exit2 RDCProbe()== return FALSE\n");
+        return FALSE;
+    }
+
+    numUsed = xf86MatchPciInstances(RDC_NAME, PCI_VENDOR_RDC,
+                                    RDCChipsets, RDCPciChipsets,
+                                    devSections, numDevSections,
+                                    drv, &usedChips);
+    xf86DrvMsgVerb(0, X_INFO, 5, "numUsed = %d\n", numUsed);
+    xfree(devSections);
+
+    if (flags & PROBE_DETECT) 
+    {
+        if (numUsed > 0)
+        foundScreen = TRUE;
+    }
+    else
+    {
+        for (i = 0; i < numUsed; i++) 
+        {
+            ScrnInfoPtr pScrn = NULL;
+
+            /* Allocate new ScrnInfoRec and claim the slot */
+            if ((pScrn = xf86ConfigPciEntity(pScrn, 0, usedChips[i],
+                                             RDCPciChipsets, 0, 0, 0, 0, 0)))
+            {
+                pScrn->driverVersion = RDC_VERSION;
+                pScrn->driverName = RDC_DRIVER_NAME;
+                pScrn->name = RDC_NAME;
+            
+                pScrn->Probe = RDCProbe;
+                pScrn->PreInit = RDCPreInit;
+                pScrn->ScreenInit = RDCScreenInit;
+                pScrn->SwitchMode = RDCSwitchMode;
+                pScrn->AdjustFrame = RDCAdjustFrame;   
+                pScrn->EnterVT = RDCEnterVT;
+                pScrn->LeaveVT = RDCLeaveVT;
+                pScrn->FreeScreen = RDCFreeScreen;
+                pScrn->ValidMode = RDCValidMode;
+            
+                foundScreen = TRUE;        
+            } /* end of if */
+        }  /* end of for-loop */
+    } /* end of if flags */       
+
+    xfree(usedChips);
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit3 RDCProbe()== return(foundScreen=%X)\n", foundScreen);
+    return foundScreen;
+}
+#endif
+
+/*
+ * RDCPreInit --
+ *
+ * Do initial setup of the board before we know what resolution we will
+ * be running at.
+ *
+ */
+static Bool
+RDCPreInit(ScrnInfoPtr pScrn, int flags)
+{
+    EntityInfoPtr pEnt;
+    vgaHWPtr hwp;
+    int flags24;
+    rgb defaultWeight = { 0, 0, 0 };
+    Gamma zeros = { 0.0, 0.0, 0.0 };
+    RDCRecPtr pRDC;
+    ClockRangePtr clockRanges;
+    int i;
+    MessageType from;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCPreInit()==\n");
+    /* Suport one adapter only now */
+    if (pScrn->numEntities != 1)
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit1 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+ 
+    pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+ 
+    if (flags & PROBE_DETECT)
+    {
+        RDCProbeDDC(pScrn, pEnt->index);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit2 RDCPreInit()== return TRUE\n");
+        return TRUE;
+    }
+ 
+    if (pEnt->location.type != BUS_PCI)
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit3 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+ 
+    if (xf86RegisterResources(pEnt->index, 0, ResExclusive))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit4 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+
+    /* The vgahw module should be loaded here when needed */
+    if (!xf86LoadSubModule(pScrn, "vgahw"))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit5 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+    xf86LoaderReqSymLists(vgahwSymbols, NULL);
+ 
+    /* The fb module should be loaded here when needed */
+    if (!xf86LoadSubModule(pScrn, "fb"))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit6 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+    xf86LoaderReqSymLists(fbSymbols, NULL);      
+        
+    /* Allocate a vgaHWRec */
+    if (!vgaHWGetHWRec(pScrn))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit7 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+    hwp = VGAHWPTR(pScrn);
+ 
+    /* Color Depth Check */
+    flags24 = Support32bppFb;
+    if (!xf86SetDepthBpp(pScrn, 0, 0, 0, flags24))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit8 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+    else
+    {
+        switch (pScrn->depth)
+        {
+            case 8:
+            case 16:
+            case 24:
+                break;
+
+            default:
+                xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                           "Given depth (%d) is not supported by RDC driver\n",
+                           pScrn->depth);
+                xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit9 RDCPreInit()== return FALSE\n");
+                return FALSE;
+        }
+    }
+
+    xf86PrintDepthBpp(pScrn);
+
+    switch (pScrn->bitsPerPixel)
+    {
+        case 8:
+        case 16:
+        case 32:
+            break;
+
+        default:
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "Given bpp (%d) is not supported by RDC driver\n",
+                       pScrn->bitsPerPixel);
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit10 RDCPreInit()== return FALSE\n");
+            return FALSE;
+    }
+   
+    /* fill pScrn misc. */
+    pScrn->progClock = TRUE;
+    pScrn->rgbBits = 6;
+    pScrn->monitor = pScrn->confScreen->monitor; /* should be initialized before set gamma */
+    pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT;
+    pScrn->racIoFlags = RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT;   
+       
+    /*
+     * If the driver can do gamma correction, it should call xf86SetGamma()
+     * here.
+     */
+    if (!xf86SetGamma(pScrn, zeros)) 
+    {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "call xf86SetGamma failed \n");
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit11 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+
+
+    if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit12 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }    
+ 
+    if (!xf86SetDefaultVisual(pScrn, -1))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit13 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }      
+
+    /* Allocate driverPrivate */
+    if (!RDCGetRec(pScrn))
+    {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "call RDCGetRec failed \n");
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit14 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }    
+
+    /* Fill RDC Info */
+    pRDC = RDCPTR(pScrn);
+    pRDC->pEnt    = xf86GetEntityInfo(pScrn->entityList[0]);
+    pRDC->PciInfo = xf86GetPciInfoForEntity(pRDC->pEnt->index);
+#if !XSERVER_LIBPCIACCESS
+    pRDC->PciTag  = pciTag(pRDC->PciInfo->bus, pRDC->PciInfo->device,
+                           pRDC->PciInfo->func);
+#endif
+
+    /* Process the options
+     * pScrn->confScreen, pScrn->display, pScrn->monitor, pScrn->numEntities, 
+     * and pScrn->entityList should be initialized before
+     */
+    xf86CollectOptions(pScrn, NULL);   
+    if (!(pRDC->Options = xalloc(sizeof(RDCOptions))))
+    {      
+        RDCFreeRec(pScrn);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit15 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }      
+    memcpy(pRDC->Options, RDCOptions, sizeof(RDCOptions));
+    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pRDC->Options);
+    
+    /*
+     * Set the Chipset and ChipRev, allowing config file entries to
+     * override.
+     */
+    if (pRDC->pEnt->device->chipset && *pRDC->pEnt->device->chipset)
+    {
+        pScrn->chipset = pRDC->pEnt->device->chipset;
+        from = X_CONFIG;
+    }
+    else if (pRDC->pEnt->device->chipID >= 0)
+    {
+        pScrn->chipset = (char *)xf86TokenToString(RDCChipsets,
+                          pRDC->pEnt->device->chipID);
+        from = X_CONFIG;
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_CONFIG, DefaultLevel, "ChipID override: 0x%04X\n",
+                   pRDC->pEnt->device->chipID);
+    }
+    else 
+    {
+        from = X_PROBED;
+        pScrn->chipset = (char *)xf86TokenToString(RDCChipsets,
+                          DEVICE_ID(pRDC->PciInfo));
+    }
+   
+    if (pRDC->pEnt->device->chipRev >= 0)
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_CONFIG, DefaultLevel, "ChipRev override: %d\n",
+        pRDC->pEnt->device->chipRev);
+    }
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, from, DefaultLevel, "Chipset: \"%s\"\n",
+               (pScrn->chipset != NULL) ? pScrn->chipset : "Unknown rdc");
+
+    /* Resource Allocation */
+#if XF86_VERSION_CURRENT < XF86_VERSION_NUMERIC(4,2,99,0,0)
+     pRDC->IODBase = 0;
+#else
+     pRDC->IODBase = pScrn->domainIOBase;  
+#endif
+     /* "Patch" the PIOOffset inside vgaHW in order to force
+      * the vgaHW module to use our relocated i/o ports.
+      */
+#if XSERVER_LIBPCIACCESS
+    VGAHWPTR(pScrn)->PIOOffset = pRDC->PIOOffset = pRDC->IODBase + pRDC->PciInfo->regions[2].base_addr - 0x380;
+    pRDC->RelocateIO = (IOADDRESS)(pRDC->PciInfo->regions[2].base_addr + pRDC->IODBase);
+#else
+    VGAHWPTR(pScrn)->PIOOffset = pRDC->PIOOffset = pRDC->IODBase + pRDC->PciInfo->ioBase[2] - 0x380;
+    
+    pRDC->RelocateIO = (IOADDRESS)(pRDC->PciInfo->ioBase[2] + pRDC->IODBase);
+#endif
+    
+    if (pRDC->pEnt->device->MemBase != 0) 
+    {
+        pRDC->FBPhysAddr = pRDC->pEnt->device->MemBase;
+        from = X_CONFIG;
+    }
+    else
+    {
+        if (RDC_MEMBASE(pRDC->PciInfo, 0) != 0)
+        {
+            pRDC->FBPhysAddr = RDC_MEMBASE(pRDC->PciInfo, 0) & 0xFFF00000;
+            from = X_PROBED;
+        }
+        else
+        {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+                       "No valid FB address in PCI config space\n");
+            RDCFreeRec(pScrn);
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit16 RDCPreInit()== return FALSE\n");
+            return FALSE;
+        }
+    }
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "Linear framebuffer at 0x%lX\n",
+               (unsigned long) pRDC->FBPhysAddr);
+
+    if (pRDC->pEnt->device->IOBase != 0) 
+    {
+        pRDC->MMIOPhysAddr = pRDC->pEnt->device->IOBase;
+        from = X_CONFIG;
+    }
+    else
+    {
+        if (RDC_MEMBASE(pRDC->PciInfo, 1))
+        {
+            pRDC->MMIOPhysAddr = RDC_MEMBASE(pRDC->PciInfo, 1) & 0xFFFF0000;
+            from = X_PROBED;
+        }
+        else
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel,
+                       "No valid MMIO address in PCI config space\n");
+            RDCFreeRec(pScrn);
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit17 RDCPreInit()== return FALSE\n");
+            return FALSE;
+        }
+    }
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "IO registers at addr 0x%lX\n",
+               (unsigned long) pRDC->MMIOPhysAddr);
+          
+    pScrn->videoRam = GetVRAMInfo(pScrn) / 1024;
+    from = X_DEFAULT;
+
+
+    if (pRDC->pEnt->device->videoRam) 
+    {
+        pScrn->videoRam = pRDC->pEnt->device->videoRam;
+        from = X_CONFIG;
+    }
+
+    pRDC->FbMapSize = pScrn->videoRam * 1024;
+    pRDC->AvailableFBsize = pRDC->FbMapSize;
+    
+    pRDC->MMIOMapSize = DEFAULT_MMIO_SIZE;
+
+    /* Get Memory Bandwidth */
+    pRDC->MemoryBandwidth = RDCGetMemBandWidth(pScrn);
+
+    /* Map resource */
+    if (!RDCMapMem(pScrn))
+    {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Map FB Memory Failed \n");
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit18 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+   
+    if (!RDCMapMMIO(pScrn)) 
+    {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Map Memory Map IO Failed \n");
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit19 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+
+    if (!RDCMapVBIOS(pScrn))
+    {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "==Exit RDCPreInit()==Map VBIOS Failed \n");
+        return FALSE;
+    }
+
+    /* init BIOS data */
+    {
+        CBIOS_ARGUMENTS CBiosArguments;
+        CBIOS_Extension CBiosExtension;
+     
+        CBiosExtension.pCBiosArguments = &CBiosArguments;
+        CBiosExtension.IOAddress = (USHORT)(pRDC->RelocateIO);
+        CBiosExtension.VideoVirtualAddress = (ULONG)(pRDC->FBVirtualAddr);
+
+        CBiosArguments.reg.x.AX = 0x4f14;
+        CBiosArguments.reg.x.BX = CINT10DataInit;
+        CBiosArguments.reg.ex.ECX = (ULONG)pRDC->BIOSVirtualAddr;
+        CInt10(&CBiosExtension);
+    }
+    
+    pScrn->memPhysBase = (ULONG)pRDC->FBPhysAddr;
+    pScrn->fbOffset = 0;
+
+    /* Get Revision */
+    pRDC->jChipType = M2010;
+       
+    /* Do DDC 
+     * should be done after xf86CollectOptions
+     */
+    pScrn->monitor->DDC = RDCDoDDC(pScrn, pRDC->pEnt->index);    
+
+
+    /* Built Mode Pool */
+    pScrn->modePool = RDCBuildModePool(pScrn);
+    
+   if (!pScrn->modePool) 
+   {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "== No Video BIOS modes for chosen ==\n");
+      return FALSE;
+   }
+    /* Mode Valid */
+    clockRanges = xnfcalloc(sizeof(ClockRange), 1);
+    clockRanges->next = NULL;
+    clockRanges->minClock = 9500;
+    clockRanges->maxClock = 266950;
+    clockRanges->clockIndex = -1;               /* -1 for programmable clocks */
+    clockRanges->interlaceAllowed = FALSE;
+    clockRanges->doubleScanAllowed = FALSE;
+   
+#ifdef FPGA
+    i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
+                          pScrn->display->modes, clockRanges,
+                          0, 320, 1024, 8 * pScrn->bitsPerPixel,
+                          200, 768,
+                          pScrn->display->virtualX, pScrn->display->virtualY,
+                          pRDC->FbMapSize, LOOKUP_BEST_REFRESH);
+#else   
+    i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
+                          pScrn->display->modes, clockRanges,
+                          0, 320, 1920, 8 * pScrn->bitsPerPixel,
+                          200, 1200,
+                          pScrn->display->virtualX, pScrn->display->virtualY,
+                          pRDC->FbMapSize, LOOKUP_BEST_REFRESH);
+#endif
+
+    if (i == -1)
+    {
+        RDCFreeRec(pScrn);
+        xf86DrvMsgVerb(0, X_INFO, ErrorLevel, "==Exit20 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+
+    xf86PruneDriverModes(pScrn);
+
+    if (!i || !pScrn->modes)
+    {
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
+        RDCFreeRec(pScrn);
+        xf86DrvMsgVerb(0, X_INFO, ErrorLevel, "==Exit21 RDCPreInit()== return FALSE\n");
+        return FALSE;
+    }
+
+    xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V);
+ 
+    pScrn->currentMode = pScrn->modes;
+ 
+    xf86PrintModes(pScrn);
+ 
+    xf86SetDpi(pScrn, 0, 0);
+ 
+    /* Accelaration Check */
+    pRDC->noAccel = TRUE;
+    pRDC->AccelInfoPtr = NULL; 
+    pRDC->CMDQInfo.ulCMDQSize = 0;      
+#ifdef    Accel_2D
+    if (!xf86ReturnOptValBool(pRDC->Options, OPTION_NOACCEL, FALSE))
+    {
+        if (!xf86LoadSubModule(pScrn, "xaa"))
+        {
+            RDCFreeRec(pScrn);
+            xf86DrvMsgVerb(0, X_INFO, ErrorLevel, "==Exit22 RDCPreInit()== return FALSE\n");
+            return FALSE;
+        }       
+        xf86LoaderReqSymLists(xaaSymbols, NULL);
+        
+        pRDC->noAccel = FALSE; 
+       
+        pRDC->MMIO2D = TRUE;
+#ifndef    MMIO_2D                   
+        if (!xf86ReturnOptValBool(pRDC->Options, OPTION_MMIO2D, FALSE)) 
+        {
+            pRDC->CMDQInfo.ulCMDQSize = DEFAULT_CMDQ_SIZE;   
+            pRDC->AvailableFBsize = pRDC->AvailableFBsize - pRDC->CMDQInfo.ulCMDQSize;
+            pRDC->CMDQInfo.ulCMDQOffsetAddr = pRDC->AvailableFBsize;
+            pRDC->MMIO2D = FALSE;        
+        }    
+#endif
+
+        pRDC->ENGCaps = ENG_CAP_ALL;
+        if (!xf86GetOptValInteger(pRDC->Options, OPTION_ENG_CAPS, &pRDC->ENGCaps)) 
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "No ENG Capability options found\n");          
+        }
+       
+        pRDC->DBGSelect = 0;
+        if (!xf86GetOptValInteger(pRDC->Options, OPTION_DBG_SELECT, &pRDC->DBGSelect))
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "No DBG Seleclt options found\n");          
+        }           
+   }
+#endif   
+
+    /* Setup HW support capability */
+    RDCSetHWCaps(pRDC);
+    
+    /* HW Cursor Check */
+    pRDC->noHWC = TRUE; 
+    pRDC->HWCInfoPtr = NULL;
+#ifdef HWC   
+    if (!xf86ReturnOptValBool(pRDC->Options, OPTION_SW_CURSOR, FALSE))
+    {
+        if (!xf86LoadSubModule(pScrn, "ramdac"))
+        {
+            RDCFreeRec(pScrn);
+            xf86DrvMsgVerb(0, X_INFO, ErrorLevel, "==Exit23 RDCPreInit()== return FALSE\n");
+            return FALSE;
+        }
+        xf86LoaderReqSymLists(ramdacSymbols, NULL);
+      
+        pRDC->noHWC = FALSE;  
+        pRDC->HWCInfo.HWC_NUM = DEFAULT_HWC_NUM;
+        
+        if (!xf86GetOptValInteger(pRDC->Options, OPTION_HWC_NUM, &pRDC->HWCInfo.HWC_NUM))
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "No HWC_NUM options found\n");          
+        }    
+
+        if (pRDC->ENGCaps & ENG_CAP_HWC_MMIO)
+            pRDC->AvailableFBsize = 
+                pRDC->AvailableFBsize - (HQ_HWC_SIZE)*pRDC->HWCInfo.HWC_NUM;
+        else
+            pRDC->AvailableFBsize = 
+                pRDC->AvailableFBsize - (HWC_SIZE+HWC_SIGNATURE_SIZE)*pRDC->HWCInfo.HWC_NUM;
+                
+        pRDC->HWCInfo.ulHWCOffsetAddr = pRDC->AvailableFBsize;
+    }    
+#endif
+
+    /*  We won't be using the VGA access after the probe */
+    xf86SetOperatingState(resVgaIo, pRDC->pEnt->index, ResUnusedOpr);
+    xf86SetOperatingState(resVgaMem, pRDC->pEnt->index, ResDisableOpr);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit24 RDCPreInit()== return TRUE\n");
+    return TRUE;
+}
+
+
+static Bool
+RDCScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
+{
+    ScrnInfoPtr pScrn;
+    RDCRecPtr pRDC;
+    vgaHWPtr hwp;   
+    VisualPtr visual;
+ 
+    /* for FB Manager */
+    BoxRec FBMemBox;   
+    int    AvailFBSize;     
+
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Enter RDCScreenInit()== \n");
+    
+    pScrn = xf86Screens[pScreen->myNum];
+    pRDC = RDCPTR(pScrn);
+    hwp = VGAHWPTR(pScrn);
+      
+    /* AvailFBSize = pRDC->FbMapSize - pRDC->CMDQInfo.ulCMDQSize; */
+    AvailFBSize = pRDC->AvailableFBsize;
+
+    FBMemBox.x1 = 0;
+    FBMemBox.y1 = 0;
+    FBMemBox.x2 = pScrn->displayWidth;
+    FBMemBox.y2 = (AvailFBSize / (pScrn->displayWidth * ((pScrn->bitsPerPixel+1)/8))) - 1;
+    if (FBMemBox.y2 <= 0)
+        FBMemBox.y2 = 32767; /* because FBMemBox.y2 is a value of short type, so its range is from -32768 ~ 32767*/
+    
+    xf86DrvMsgVerb(scrnIndex, X_INFO, InfoLevel, "AvailFBSize = %d\n", AvailFBSize);
+    xf86DrvMsgVerb(scrnIndex, X_INFO, InfoLevel, "FBMemBox: x1 = %d, y1 = %d, x2 = %d, y2 = %d\n",FBMemBox.x1, FBMemBox.y1, FBMemBox.x2, FBMemBox.y2);
+
+    if (!xf86InitFBManager(pScreen, &FBMemBox))
+    {
+        xf86DrvMsg(scrnIndex, X_ERROR, "Failed to init memory manager\n");
+        return FALSE;
+    }      
+       
+    vgaHWGetIOBase(hwp);
+ 
+    vFillRDCModeInfo (pScrn);      
+ 
+    RDCSave(pScrn);     
+    if (!RDCModeInit(pScrn, pScrn->currentMode))
+    {
+        xf86DrvMsg(scrnIndex, X_ERROR, "Mode Init Failed \n");
+        return FALSE;
+    }   
+
+    RDCSaveScreen(pScreen, FALSE);
+    RDCAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+
+    miClearVisualTypes();
+
+    /* Re-implemented Direct Color support, -jens */
+    if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth), pScrn->rgbBits, pScrn->defaultVisual))
+    {
+        xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "==RDCScreenInit() Set Visual Type Fail== return FALSE\n");
+        return FALSE;
+    }
+ 
+    if (!miSetPixmapDepths())
+    {
+        RDCSaveScreen(pScreen, SCREEN_SAVER_OFF);
+        xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "==RDCScreenInit() SetPixmapDepth fail== return FALSE\n");
+        return FALSE;
+    }    
+
+    switch(pScrn->bitsPerPixel)
+    {
+        case 8:
+        case 16:
+        case 32:
+            if (!fbScreenInit(pScreen, pRDC->FBVirtualAddr + pScrn->fbOffset,
+                              pScrn->virtualX, pScrn->virtualY,
+                              pScrn->xDpi, pScrn->yDpi,
+                              pScrn->displayWidth, pScrn->bitsPerPixel))
+            {
+                xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "==RDCScreenInit() fbScreenInit fail== return FALSE\n");
+                return FALSE;
+            }
+            break;
+
+        default:
+            xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "==RDCScreenInit() Color Depth not supprt== return FALSE\n");
+            return FALSE;                  
+    }
+
+    if (pScrn->bitsPerPixel > 8)
+    {
+        /* Fixup RGB ordering */
+        visual = pScreen->visuals + pScreen->numVisuals;
+        while (--visual >= pScreen->visuals)
+        {
+            if ((visual->class | DynamicClass) == DirectColor)
+            {
+                visual->offsetRed = pScrn->offset.red;
+                visual->offsetGreen = pScrn->offset.green;
+                visual->offsetBlue = pScrn->offset.blue;
+                visual->redMask = pScrn->mask.red;
+                visual->greenMask = pScrn->mask.green;
+                visual->blueMask = pScrn->mask.blue;
+            }
+        }
+    }
+     
+    fbPictureInit(pScreen, 0, 0);
+ 
+    xf86SetBlackWhitePixels(pScreen);
+
+#ifdef Accel_2D
+    if (!pRDC->noAccel)
+    {
+        if (!RDCAccelInit(pScreen))
+        {
+            xf86DrvMsg(scrnIndex, X_ERROR, "Hardware acceleration initialization failed\n");
+            pRDC->noAccel = TRUE;           
+        }
+    }
+#endif /* end of Accel_2D */
+     
+    miInitializeBackingStore(pScreen);
+    xf86SetBackingStore(pScreen);
+    xf86SetSilkenMouse(pScreen);
+
+    miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
+
+    /* Init hardware cursor */
+    if (!pRDC->noHWC)
+    {
+        if (!RDCCursorInit(pScreen)) 
+        {
+            xf86DrvMsg(scrnIndex, X_ERROR, "Hardware cursor initialization failed\n");
+            pRDC->noHWC = TRUE;                      
+        }
+    }
+    
+    if (!miCreateDefColormap(pScreen))
+    {
+        xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "==Exit7 RDCScreenInit()== return FALSE\n");
+        return FALSE;
+    }
+
+    if(!xf86HandleColormaps(pScreen, 256, (pScrn->depth == 8) ? 8 : pScrn->rgbBits,
+                            vRDCLoadPalette, NULL,
+                            CMAP_PALETTED_TRUECOLOR | CMAP_RELOAD_ON_MODE_SWITCH))
+    {
+        xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "==RDCScreenInit() xf86HandleColormaps fail== return FALSE\n");
+        return FALSE;
+    }
+
+    /* Init DPMS */
+    xf86DPMSInit(pScreen, RDCDisplayPowerManagementSet, 0);
+   
+    pScreen->SaveScreen = RDCSaveScreen;
+    pRDC->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = RDCCloseScreen;
+#if 0
+    /* Remove restart flag file for utility */
+    UTRemoveRestartFlag(pBIOSInfo);
+#endif
+    /* Create a extension handler to receive the request of RDCutility. */
+    RDCDisplayExtensionInit(pScrn);
+
+    /* Init Video */
+    if (pRDC->ENGCaps & ENG_CAP_VIDEO_DISP)
+        RDCVideoInit(pScreen);
+    
+    if (serverGeneration == 1)
+        xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==RDCScreenInit() Normal Exit==\n");
+    return TRUE;
+} /* RDCScreenInit */
+
+Bool RDCSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    Bool RetStatus = FALSE;
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSwitchMode()== \n");
+#ifdef HWC
+    pRDC->HWCInfoPtr->HideCursor(pScrn);
+#endif
+
+#ifdef Accel_2D 
+    vDisable2D(pScrn, pRDC);
+#endif
+   
+    RetStatus = RDCModeInit(pScrn, mode);
+
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "== RDCSwitchMode() Exit== return %X\n", RetStatus);
+    return RetStatus;
+}
+
+void
+RDCAdjustFrame(int scrnIndex, int x, int y, int flags)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    RDCRecPtr   pRDC  = RDCPTR(pScrn);
+    ULONG base;
+
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Enter RDCAdjustFrame(x = %d, y = %d)== \n", x, y);
+    base = y * pRDC->VideoModeInfo.ScreenPitch + x * pRDC->VideoModeInfo.bitsPerPixel / 8;
+
+ 
+    vSetStartAddressCRT1(pRDC, base);
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Exit1 RDCAdjustFrame()== \n");
+}
+
+/* enter into X Server */        
+static Bool
+RDCEnterVT(int scrnIndex, int flags)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCEnterVT()== \n");
+    if (!RDCModeInit(pScrn, pScrn->currentMode))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit1 RDCEnterVT() RDCModeInit Fail== return FALSE\n");
+        return FALSE;
+    }
+
+    RDCAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit2 RDCEnterVT() Normal Exit== return TRUE\n");
+    return TRUE;
+}
+
+/* leave X server */
+static void
+RDCLeaveVT(int scrnIndex, int flags)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCLeaveVT();== \n");
+#ifdef HWC
+    pRDC->HWCInfoPtr->HideCursor(pScrn);
+#endif
+
+#ifdef Accel_2D  
+    vDisable2D(pScrn, pRDC);
+#endif
+      
+    RDCRestore(pScrn);  
+    vgaHWLock(hwp);
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCLeaveVT() Normal Exit== \n");
+}
+
+static void
+RDCFreeScreen(int scrnIndex, int flags)
+{
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Enter RDCFreeScreen()== \n");
+    
+    RDCFreeRec(xf86Screens[scrnIndex]);
+    if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
+        vgaHWFreeHWRec(xf86Screens[scrnIndex]);
+
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Exit1 RDCFreeScreen()== \n");
+}
+
+static ModeStatus
+RDCValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
+{
+    Bool Flags = MODE_NOMODE;
+
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    CBIOS_ARGUMENTS CBiosArguments;
+    CBIOS_Extension CBiosExtension;
+    BYTE bCurrentDeviceIdx;
+    USHORT wLCDHorSize, wLCDVerSize;
+    USHORT wVESAModeHorSize, wVESAModeVerSize;
+
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Enter RDCValidMode() Verbose = %d, Flags = 0x%x==\n", 
+               verbose, flags);
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Mode name=%s, Width=%d, Height=%d, Refresh reate=%f==\n", 
+               mode->name, mode->HDisplay, mode->VDisplay, mode->VRefresh);
+
+    CBiosExtension.pCBiosArguments = &CBiosArguments;
+    CBiosExtension.IOAddress = (USHORT)(pRDC->RelocateIO);
+    CBiosExtension.VideoVirtualAddress = (ULONG)(pRDC->FBVirtualAddr);
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = QueryDisplayPathInfo;
+    CInt10(&CBiosExtension);
+    bCurrentDeviceIdx = (CBiosArguments.reg.ex.EBX & 0xf0000) >> 16;
+
+/*
+    if (bCurrentDeviceIdx == 0x1) // if LCD is active in disp1
+    {
+        if ((wVESAModeHorSize > 1280) || (wVESAModeVerSize > 1024))
+        {
+            return MODE_BAD;
+        }
+    }
+    else
+    {
+        if (mode->PrivFlags & LCD_TIMING)
+        {
+            return MODE_BAD;
+        }
+    }
+*/
+    if (mode->Flags & V_INTERLACE)
+    {
+        if (verbose)
+        {
+            xf86DrvMsgVerb(scrnIndex, X_PROBED, InfoLevel,
+                       "==Removing interlaced mode \"%s\"\n==", mode->name);
+        }
+        xf86DrvMsgVerb(scrnIndex, X_INFO, ErrorLevel, "== RDCValidMode() Fail, Not Interlace Mode==\n");
+        return MODE_NO_INTERLACE;
+    }
+
+    if ((mode->HDisplay > 1680) || (mode->VDisplay > 1050))
+    {
+        return MODE_BAD;
+    }
+
+    if ((mode->HDisplay < 640) || (mode->VDisplay < 480))
+    {
+        return MODE_BAD;
+    }
+
+    if ((mode->HDisplay >= 1280) && 
+        ((pScrn->bitsPerPixel > 16) || (mode->VRefresh > 62.0)))
+    {
+        return MODE_BAD;
+    }
+
+    /* To Do */
+    /* 1. Validate Mode by memory bandwidth */
+    /* 2. If LCD enable, validate mode by panel size */
+    /* 3. If TV enable, validate mode by TV type */
+    Flags = RDCFilterModeByBandWidth(pScrn, mode);
+
+    return Flags;
+}            
+
+
+/* Internal used modules */
+/*
+ * RDCGetRec and RDCFreeRec --
+ *
+ * Private data for the driver is stored in the screen structure.
+ * These two functions create and destroy that private data.
+ *
+ */
+static Bool
+RDCGetRec(ScrnInfoPtr pScrn)
+{
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCGetRec()== \n");
+
+    if (pScrn->driverPrivate)
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==RDCGetRec() driverPrivate is TRUE== return TRUE\n");
+        return TRUE;
+    }
+
+    pScrn->driverPrivate = xnfcalloc(sizeof(RDCRec), 1);
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCGetRec()== return TRUE\n");
+    return TRUE;
+}
+
+static void
+RDCFreeRec(ScrnInfoPtr pScrn)
+{
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCFreeRec()== \n");
+    
+    if (!pScrn)
+    {
+        xf86DrvMsgVerb(0, X_INFO, ErrorLevel, "==RDCFreeRec() pScrn is NULL== \n");
+        return;
+    }
+    
+    if (!pScrn->driverPrivate)
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==RDCFreeRec() driverPrivate is FALSE== \n");
+        return;
+    }
+    
+    xfree(pScrn->driverPrivate);
+    pScrn->driverPrivate = 0;
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit3 RDCFreeRec()== \n");
+}
+
+static Bool
+RDCSaveScreen(ScreenPtr pScreen, Bool unblack)
+{
+    Bool RetStatus;
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Enter RDCSaveScreen(unblack = %d)== \n", unblack);
+    /* more ref. SiS */
+    RetStatus = vgaHWSaveScreen(pScreen, unblack);
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==Exit1 RDCSaveScreen()== return RetStatus\n");
+    return RetStatus;
+}
+
+static Bool
+RDCCloseScreen(int scrnIndex, ScreenPtr pScreen)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    vgaHWPtr hwp = VGAHWPTR(pScrn);
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    Bool RetStatus;
+    
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Enter RDCCloseScreen(); Screen Index = 0x%x == \n",scrnIndex);
+    
+    if (pScrn->vtSema == TRUE)
+    {  
+#ifdef HWC
+        pRDC->HWCInfoPtr->HideCursor(pScrn);
+#endif
+          
+#ifdef Accel_2D  
+        vDisable2D(pScrn, pRDC);
+#endif
+         
+        RDCRestore(pScrn);
+        vgaHWLock(hwp);
+    }
+
+    RDCUnmapMem(pScrn);
+    RDCUnmapMMIO(pScrn);
+    RDCUnmapVBIOS(pScrn);
+    
+    vgaHWUnmapMem(pScrn);
+
+    if(pRDC->AccelInfoPtr)
+    {
+        XAADestroyInfoRec(pRDC->AccelInfoPtr);
+        pRDC->AccelInfoPtr = NULL;
+    }
+ 
+    if(pRDC->HWCInfoPtr)
+    {
+        xf86DestroyCursorInfoRec(pRDC->HWCInfoPtr);
+        pRDC->HWCInfoPtr = NULL;
+    }
+ 
+    pScrn->vtSema = FALSE;
+    pScreen->CloseScreen = pRDC->CloseScreen;
+    RetStatus = (*pScreen->CloseScreen) (scrnIndex, pScreen);
+    
+    xf86DrvMsgVerb(scrnIndex, X_INFO, DefaultLevel, "==Exit1 RDCCloseScreen()== return(RetStatus=%X\n", RetStatus);
+    return RetStatus;
+}
+
+static void
+RDCSave(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC;
+    vgaRegPtr vgaReg;
+    RDCRegPtr RDCReg;   
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCSave()== \n");
+    pRDC = RDCPTR(pScrn);
+    vgaReg = &VGAHWPTR(pScrn)->SavedReg;
+    RDCReg = &pRDC->SavedReg;
+     
+    /* do save */    
+    vgaHWSave(pScrn, vgaReg, VGA_SR_ALL);
+    
+    /* Ext. Save */
+    vRDCOpenKey(pScrn);
+
+    /* save PLL value */
+    GetIndexReg(CRTC_PORT, 0xC0, RDCReg->ucPLLValue[0]);
+    GetIndexReg(CRTC_PORT, 0xC1, RDCReg->ucPLLValue[1]);
+    GetIndexReg(CRTC_PORT, 0xCF, RDCReg->ucPLLValue[2]);
+
+    GetIndexReg(CRTC_PORT, 0xA3, RDCReg->ucCRA3);
+    GetIndexReg(SEQ_PORT, 0x58, RDCReg->ucSR58);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCSave()== \n");
+}
+
+static void
+RDCRestore(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC;
+    vgaRegPtr vgaReg;
+    RDCRegPtr RDCReg;   
+    
+    pRDC = RDCPTR(pScrn);
+    vgaReg = &VGAHWPTR(pScrn)->SavedReg;
+    RDCReg = &pRDC->SavedReg;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCRestore()== \n");
+     
+    /* do restore */    
+    vgaHWProtect(pScrn, TRUE);   
+    vgaHWRestore(pScrn, vgaReg, VGA_SR_ALL);          
+    vgaHWProtect(pScrn, FALSE);   
+    
+    /* Ext. restore */
+    vRDCOpenKey(pScrn);
+    
+   /* restore PLL value */    
+    SetIndexReg(CRTC_PORT, 0xC0, RDCReg->ucPLLValue[0]);
+    SetIndexReg(CRTC_PORT, 0xC1, RDCReg->ucPLLValue[1]);
+    SetIndexReg(CRTC_PORT, 0xCF, RDCReg->ucPLLValue[2]);
+
+    SetIndexRegMask(CRTC_PORT, 0xA3, ~0x20, RDCReg->ucCRA3 & 0x20);
+    
+    SetIndexRegMask(CRTC_PORT, 0xBB, 0xFF, 0);
+
+    SetIndexReg(SEQ_PORT, 0x58, RDCReg->ucSR58);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit1 RDCRestore()== \n");    
+}
+
+static void
+RDCProbeDDC(ScrnInfoPtr pScrn, int index)
+{
+    vbeInfoPtr pVbe;
+ 
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCProbeDDC()== \n");
+    
+    if (xf86LoadSubModule(pScrn, "vbe")) 
+    {
+        pVbe = VBEInit(NULL, index);
+        ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
+        vbeFree(pVbe);
+    }
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCProbeDDC()== \n");
+}
+
+static xf86MonPtr
+RDCDoDDC(ScrnInfoPtr pScrn, int index)
+{
+    vbeInfoPtr pVbe;
+    xf86MonPtr MonInfo = NULL;
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCDoDDC()== \n");
+    /* Honour Option "noDDC" */
+    if (xf86ReturnOptValBool(pRDC->Options, OPTION_NO_DDC, FALSE))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit1 RDCDoDDC()== return(MonInfo)\n");
+        return MonInfo;
+    }
+ 
+    if (xf86LoadSubModule(pScrn, "vbe") && (pVbe = VBEInit(NULL, index)))
+    {
+        xf86LoaderReqSymLists(vbeSymbols, NULL);
+        MonInfo = vbeDoEDID(pVbe, NULL);
+        xf86PrintEDID(MonInfo);
+        xf86SetDDCproperties(pScrn, MonInfo);
+        vbeFree(pVbe);
+    }
+    else
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel,
+          "this driver cannot do DDC without VBE\n");
+    }
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit2 RDCDoDDC()== return (MonInfo)\n");
+    return MonInfo;
+}
+
+static void
+vFillRDCModeInfo (ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter vFillRDCModeInfo()== \n");
+
+    pRDC = RDCPTR(pScrn);
+    
+    pRDC->VideoModeInfo.ScreenWidth = pScrn->virtualX;   
+    pRDC->VideoModeInfo.ScreenHeight = pScrn->virtualY;   
+    pRDC->VideoModeInfo.bitsPerPixel = pScrn->bitsPerPixel;   
+    pRDC->VideoModeInfo.Bpp         =  (pScrn->bitsPerPixel + 1) / 8;
+    pRDC->VideoModeInfo.ScreenPitch = pScrn->displayWidth * pRDC->VideoModeInfo.Bpp;
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit1 vFillRDCModeInfo()== \n");
+}
+
+static Bool
+RDCModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+    vgaHWPtr hwp;
+    RDCRecPtr pRDC;
+    CBIOS_Extension CBiosExtension;
+    CBIOS_ARGUMENTS CBiosArguments;
+
+    hwp = VGAHWPTR(pScrn);
+    pRDC = RDCPTR(pScrn);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCModeInit()== \n");
+    
+    CBiosExtension.pCBiosArguments = &CBiosArguments;
+    CBiosExtension.IOAddress = (USHORT)(pRDC->RelocateIO);
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = QueryDisplayPathInfo;
+    CInt10(&CBiosExtension);
+    if (((CBiosArguments.reg.ex.EBX >> 22) & 0xF) != 0x1) /* if not LCD */
+    {
+        if (mode->PrivFlags & LCD_TIMING)
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==RDCModeInit() Fail== LCD timing is not supported!!\n");
+            return FALSE;
+        }
+    }
+    
+    
+    vgaHWUnlock(hwp);
+
+    if (!vgaHWInit(pScrn, mode))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==RDCModeInit() vgaHWInit Fail== return FALSE\n");
+        return FALSE;
+    }
+    
+    pScrn->vtSema = TRUE;
+    pRDC->ModePtr = mode;
+
+    if (!RDCSetMode(pScrn, mode))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==RDCModeInit() RDCSetMode Fail== return FALSE\n");
+        return FALSE;
+    }
+    
+    /* update display path info */
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = QueryDisplayPathInfo;
+    CInt10(&CBiosExtension);
+    if (CBiosArguments.reg.x.AX == VBEFunctionCallSuccessful)
+    {
+        pRDC->DeviceInfo.ucDeviceID = (CBiosArguments.reg.ex.EBX & 0x000F0000) >> 16;
+        pRDC->DeviceInfo.ucDisplayPath = 1;
+        pRDC->DeviceInfo.ScalerConfig.EnableHorScaler = ((CBiosArguments.reg.ex.EBX & 0x00200000) ? true : false);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "H scaler enable = %d\n", pRDC->DeviceInfo.ScalerConfig.EnableHorScaler);
+        pRDC->DeviceInfo.ScalerConfig.EnableVerScaler = ((CBiosArguments.reg.ex.EBX & 0x00100000) ? true : false);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "V scaler enable = %d\n", pRDC->DeviceInfo.ScalerConfig.EnableVerScaler);
+    }
+    else
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_ERROR, ErrorLevel, "Query Display Path Info Fail(%04X)\n", CBiosArguments.reg.x.AX);
+    }
+
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = QueryLCDPanelSizeMode;
+    CBiosArguments.reg.lh.CL = 0;
+    CInt10(&CBiosExtension);
+    if (CBiosArguments.reg.x.AX == VBEFunctionCallSuccessful)
+    {
+        pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution = CBiosArguments.reg.x.DX;
+        pRDC->DeviceInfo.ScalerConfig.ulHorScalingFactor = (pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution << 12) / mode->HDisplay;
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "LCD H Size = %d\n", pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "Mode H Size = %d\n", mode->HDisplay);
+
+        pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution = CBiosArguments.reg.ex.EDX >> 16;
+        pRDC->DeviceInfo.ScalerConfig.ulVerScalingFactor = (pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution << 11) / mode->VDisplay;
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "LCD V Size = %d\n", pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution);
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "Mode V Size = %d\n", mode->VDisplay);
+    }
+    else
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_ERROR, ErrorLevel, "Query LCD Panel Size Fail(%04X)\n", CBiosArguments.reg.x.AX);
+    }
+
+    /* reset screen offset */
+    pRDC->HWCInfo.iScreenOffset_x = 0;
+    pRDC->HWCInfo.iScreenOffset_y = 0;
+    RDCAdjustFrame(pScrn->scrnIndex, 0, 0, 0);
+ 
+    vgaHWProtect(pScrn, FALSE);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCModeInit()== return TRUE\n");
+    return TRUE;
+}
+
+static void RDCSetHWCaps(RDCRecPtr pRDC)
+{
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCSetHWCaps() Entry==\n");
+
+    switch(DEVICE_ID(pRDC->PciInfo))
+    {
+    case PCI_CHIP_M2010_A0:
+        break;
+    case PCI_CHIP_M2010:
+        pRDC->ENGCaps |= ENG_CAP_VIDEO_DISP;
+        pRDC->ENGCaps |= ENG_CAP_HWC_MMIO;
+        break;
+    case PCI_CHIP_M2011:
+        break;
+    default:
+        break;
+    }
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCSetHWCaps() Exit Caps = 0x%x==\n",pRDC->ENGCaps);
+}
diff --git a/src/rdc_extension.c b/src/rdc_extension.c
new file mode 100644
index 0000000..cba9c61
--- /dev/null
+++ b/src/rdc_extension.c
@@ -0,0 +1,575 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+/*
+ * I N C L U D E S
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+#include "X11/Xproto.h"     /* For Xextension */
+#include "extnsionst.h" /* For Xextension */
+#include "dixstruct.h"  /* For Xextension */
+
+#include "rdc_extension.h"
+
+//#include <sys/ipc.h>
+//#include <sys/shm.h>
+
+CARD32 *inBufPtr, *outBufPtr ; /* For share memory use */
+
+/* Record screen number. */
+int g_ScreenNumber;
+
+
+/*
+    Query the RDCGFX_API version.
+*/
+static int ProcRDCGFXQueryVersion (ClientPtr client)
+{        
+    xRDCGFXQueryVersionReply rep;
+    register int n;
+
+    REQUEST_SIZE_MATCH(xRDCGFXQueryVersionReply);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = 2;
+    rep.minorVersion = 0;
+    
+    if(client->swapped)
+    {
+        swaps(&rep.sequenceNumber, n);
+        swapl(&rep.length, n);
+        swaps(&rep.majorVersion, n);
+        swaps(&rep.minorVersion, n);
+    }
+    
+    WriteToClient(client, sizeof(xRDCGFXQueryVersionReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+
+/*
+    Receive and process the request from AP.
+*/
+static int ProcRDCGFXCommand(ClientPtr client)
+{
+    xRDCGFXCommandReq *req = (xRDCGFXCommandReq*)client->requestBuffer;    register int     n;
+    int          i, ret;    
+
+    REQUEST_SIZE_MATCH(*req);
+	/*if ((SIZEOF(xRDCGFXCommandReq) >> 2) != req->length) {	\
+	    int lengthword = req->length;				\
+	    SendErrToClient(client, FSBadLength, (pointer)&lengthword); \
+	    return (FSBadLength);	\
+	}*/
+
+    /* Get pointer to ExtensionEntry */
+    if(!CheckExtension(RDC_GFX_UT_EXTENSION_NAME)) return BadMatch;       
+
+    /* Process the request. */
+    RDCGFXUtilityProc(req);
+    
+    //req->reqType = X_Reply;
+    //req->length = (CARD16)(sizeof(xRDCGFXCommandReq) - sizeof(xGenericReply)) >> 2;
+    xGenericReply *reply = client->requestBuffer;
+    reply->type = X_Reply;
+    reply->length = 0;
+#if 0
+    if(client->swapped)
+    {
+       swapl(&req->length, n);       
+       swapl(&req->util_cmd_id, n);
+       swapl(&req->result_header, n);
+       
+       for(i = 0; i < req->outBufferSize; i++)
+       {
+          swapl(&req->outBuffer[i], n);
+       }
+    }
+#endif
+    //WriteToClient(client, sizeof(xRDCGFXCommandReq), (char *)req);
+    WriteToClient(client, sizeof(xGenericReply), (char *)reply);
+    return client->noClientException;
+}
+
+static void RDCGFXResetProc(ExtensionEntry* extEntry)
+{    
+}
+
+static int ProcRDCGFXDispatch(ClientPtr client)
+{   
+    REQUEST(xReq);
+    switch(stuff->data)
+    {
+        case X_RDCGFXQueryVersion:
+            return ProcRDCGFXQueryVersion(client);
+        case X_RDCGFXCommand:
+            return ProcRDCGFXCommand(client);
+    }
+    
+    return BadRequest;
+}
+
+void RDCDisplayExtensionInit(ScrnInfoPtr pScrn)
+{
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "==Enter RDCDisplayExtensionInit()== \n");
+
+    // init share memory
+    int shm_in_id, shm_out_id ;
+    key_t in_key, out_key ;
+    char inBufName[32] = "/RDC/GFX/shm/inBuf" ;
+    char outBufName[32] = "/RDC/GFX/shm/outBuf" ;
+
+    in_key = ftok(inBufName, 4) ;
+    out_key = ftok(outBufName, 4) ;
+    shm_in_id = shmget(in_key, 4096, IPC_CREAT) ;
+    shm_out_id = shmget(out_key, 4096, IPC_CREAT) ;
+    inBufPtr = (CARD32 *) shmat(shm_in_id, NULL, 0) ;
+    outBufPtr = (CARD32 *) shmat(shm_out_id, NULL, 0) ;
+    
+    if(NULL == CheckExtension(RDC_GFX_UT_EXTENSION_NAME))
+    {
+	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 6, "== check point 1== \n");
+        /* if extension doesn't exist, add it */
+        if (!AddExtension(RDC_GFX_UT_EXTENSION_NAME, 0, 0,
+                                     ProcRDCGFXDispatch,
+                                     ProcRDCGFXDispatch,
+                                     RDCGFXResetProc,
+                                     StandardMinorOpcode))
+        {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Failed to add RDCGFX extension\n");
+            return;
+        }
+    }
+    else
+    {
+        /* else if extension exists */
+        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "error: RDC GFX Extension Exists!\n");
+    }
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "==Exit RDCDisplayExtensionInit()== \n");    
+}
+
+int RDCGFXUtilityProc(xRDCGFXCommandReq* req)
+{
+    ScrnInfoPtr pScrn = xf86Screens[g_ScreenNumber];
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    CBIOS_Extension CBIOSExtension;
+    CBIOS_ARGUMENTS CBiosArguments;
+
+    CBIOSExtension.pCBiosArguments = &CBiosArguments;
+    CBIOSExtension.IOAddress = (USHORT)(pRDC->RelocateIO) ;
+    CBIOSExtension.VideoVirtualAddress = (ULONG)(pRDC->FBVirtualAddr);
+    /* 
+        STChen[2006.7.11]: In SAMM case, a driver controls a screen.
+        In the past, we have to move application's window to switch to correct driver.
+        So I add following step to detect which driver we should use to avoid this problem.
+
+        if (pRDC->pBIOSInfo->SAMM)
+        {        
+            pScrn = RDCScreenSelection(pScrn, rep->primary_id, rep->secondary_id);
+            pRDC = RDCPTR(pScrn);
+        }
+    */
+            
+    ULONG   ulResult;
+
+    switch(req->util_cmd_id)
+    {
+        //
+        // Output devices function group
+        //
+        case UT_QUERY_SUPPORT_DEVICE: /* done */
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "DrvEscape: Query Device Support");
+            
+            if (req->outBufferSize != sizeof(ULONG))
+                return UT_FAIL;
+
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = QueryBiosInfo;
+            if (CInt10(&CBIOSExtension))
+            {
+                ((UTDEVICELIST *) outBufPtr)->MERGE = (USHORT)CBiosArguments.reg.x.SI;
+                return (UT_SUCCESS);
+            }
+            else
+            {
+                return(UT_FAIL);
+            }
+            break;
+
+        case UT_QUERY_CONNECT_DEVICE: /* done */
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "DrvEscape: Query Device Connect");
+            
+            if (req->outBufferSize != sizeof(ULONG))
+                return UT_FAIL;
+                
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = QueryDeviceConnectStatus;
+            if (CInt10(&CBIOSExtension))
+            {
+                ((UTDEVICELIST *) outBufPtr)->MERGE = (USHORT)CBiosArguments.reg.x.BX;
+                return (UT_SUCCESS);
+            }
+            else
+            {
+                return(UT_FAIL);
+            }
+            break;
+
+        case UT_SET_DEVICE_ACT:
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "DrvEscape: Set Active Device");
+            
+            if (req->inBufferSize != sizeof(UTDEVICELIST))
+                return UT_FAIL;
+
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = SetActiveDisplayDevice;
+         
+            switch (inBufPtr[0] & 0xFFFF)
+            {
+                case 0x04: /* B_CRT */
+                    CBiosArguments.reg.lh.CL = 3; /* CRT_ID */
+                    break;
+                case 0x01: /* B_LCD */
+                    CBiosArguments.reg.lh.CL = 1; /* LCD_ID */
+                    break;
+                case 0x02: /* B_DVI */
+                    CBiosArguments.reg.lh.CL = 2; /* DVI_ID */
+                    break;
+                case 0x20: /* B_TV */
+                    CBiosArguments.reg.lh.CL = 6; /* TV_ID */
+                    break;
+                default:
+                    CBiosArguments.reg.lh.CL = 0;
+                    break;
+            }
+
+            if (CInt10(&CBIOSExtension))
+            {
+                return(UT_SUCCESS | UT_MODESET);
+            }
+            else
+            {
+                return(UT_FAIL);
+            }
+            break;
+
+        case UT_QUERY_ACT_DEVICE:
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "DrvEscape: Query active device");
+            
+            if (req->outBufferSize != sizeof(UCHAR) * 2)
+                return UT_FAIL;
+
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = QueryDisplayPathInfo;
+            if (CInt10(&CBIOSExtension))
+            {
+                outBufPtr[0] = 0;
+                switch ((CBiosArguments.reg.ex.EBX & 0x000F0000) >> 16)
+                {
+                    case 3: /* CRT_ID */
+                        outBufPtr[0] |= 0x0004; /* B_CRT */
+                        break;
+                    case 1: /* LCD_ID */
+                        outBufPtr[0] |= 0x0001; /* B_LCD */
+                        break;
+                    case 2: /* DVI_ID */
+                        outBufPtr[0] |= 0x0002; /* B_DVI */
+                        break;
+                    case 6: /* TV_ID */
+                        outBufPtr[0] |= 0x0020; /* B_TV */
+                        break;
+                    default:
+                        break;
+                }
+                switch ((CBiosArguments.reg.ex.ECX & 0x000F0000) >> 16)
+                {
+                    case 3: /* CRT_ID */
+                        outBufPtr[0] |= 0x0004; /* B_CRT */
+                        break;
+                    case 1: /* LCD_ID */
+                        outBufPtr[0] |= 0x0001; /* B_LCD */
+                        break;
+                    case 2: /* DVI_ID */
+                        outBufPtr[0] |= 0x0002; /* B_DVI */
+                        break;
+                    case 6: /* TV_ID */
+                        outBufPtr[0] |= 0x0020; /* B_TV */
+                        break;
+                    default:
+                        break;
+                }
+
+                return (UT_SUCCESS);
+            }
+            else
+            {
+                return (UT_NOT_IMPLEMENT);
+            }
+            break;
+
+        /* Query hardware info function group */
+        case UT_QUERY_HW_INFO:
+            if (req->outBufferSize != sizeof(UTHWINFO))
+                return UT_FAIL;
+            {
+                UTHWINFO *pUTHWInfo = (UTHWINFO*)outBufPtr;
+                pUTHWInfo->ulVenderID = (ULONG)VENDOR_ID(pRDC->PciInfo);
+                pUTHWInfo->ulDeviceID = (ULONG)DEVICE_ID(pRDC->PciInfo);
+                pUTHWInfo->ulSubSystemID = (ULONG)SUBSYS_ID(pRDC->PciInfo);
+                pUTHWInfo->ulSubVenderID = (ULONG)SUBVENDOR_ID(pRDC->PciInfo);
+                pUTHWInfo->ulRevision = (ULONG)CHIP_REVISION(pRDC->PciInfo);
+                return (UT_SUCCESS);
+                break;
+            }
+        case UT_QUERY_BIOS_VERSION:
+            if (req->outBufferSize != sizeof(ULONG))
+                return UT_FAIL;
+
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = QueryBiosInfo;
+            if (CInt10(&CBIOSExtension))
+            {
+                outBufPtr[0] = CBiosArguments.reg.ex.EBX;
+                return(UT_SUCCESS);
+            }
+            else
+            {
+                return (UT_NOT_IMPLEMENT);
+            }
+            break;
+            
+        case UT_QUERY_MEM_INFO:
+            if (req->outBufferSize != sizeof(ULONG))
+                return UT_FAIL;
+
+            outBufPtr[0] = pRDC->FbMapSize;
+            return(UT_SUCCESS);
+            break;
+            
+        case UT_QUERY_CLK_SPEED:
+            if (req->outBufferSize != sizeof(CLKINFO))
+                return UT_FAIL;
+            {
+                CLKINFO *pCLKInfo = (CLKINFO*)outBufPtr;
+                CBiosArguments.reg.x.AX = OEMFunction;
+                CBiosArguments.reg.x.BX = QueryBiosInfo;
+                if (CInt10(&CBIOSExtension))
+                {
+                    ULONG ulMCLK;
+                    switch (CBiosArguments.reg.x.CX & 0x000F)
+                    {
+                        case 0:
+                            ulMCLK = 266;
+                            break;
+                        case 1:
+                            ulMCLK = 333;
+                            break;
+                        case 2:
+                            ulMCLK = 400;
+                            break;
+                        case 3:
+                            ulMCLK = 533;
+                            break;
+                    }
+                    pCLKInfo->EngCLK = pCLKInfo->MemCLK = ulMCLK;
+                    return(UT_SUCCESS);
+                }
+                else
+                {
+                    return (UT_NOT_IMPLEMENT);
+                }
+            }
+            break;
+#if 0            
+/*
+        case UT_QUERY_SAMM:
+            {
+                if (cjOut != sizeof(ULONG))
+                    return UT_INVALID;
+
+                *(ULONG*)pvOut = ppdev->pMultiMon->bEnableSAMMMode;
+
+                return (UT_SUCCESS);
+            }
+            break;
+        case UT_SET_GAMMA:
+            {
+                if ((cjIn != sizeof(GammaTbl)) || 
+                    (((pGammaTbl)pvIn)->dwSize != MAX_CLUT_SIZE))
+                    return UT_INVALID;
+
+                if (!EngDeviceIoControl(ppdev->hDriver,
+                                     IOCTL_VIDEO_SET_COLOR_REGISTERS,
+                                     ((pGammaTbl)pvIn)->pClut,
+                                     ((pGammaTbl)pvIn)->dwSize,
+                                     NULL,
+                                     0,
+                                     &ulResult))
+                {
+                    return UT_SUCCESS;
+                }
+                else
+                    return UT_FAIL;
+            }
+            break;
+        case UT_QUERY_GAMMA:
+            {
+                if ((cjOut != sizeof(GammaTbl)) ||
+                    (((pGammaTbl)pvIn)->dwSize != MAX_CLUT_SIZE))
+                    return UT_INVALID;
+
+                //
+                // Get Gamma value from Look up table
+                //
+                if (*(ULONG*)pvIn & CRT)
+                    QueryRegistryValue(ppdev, CRTGamma, ((pGammaTbl)pvOut)->pClut, MAX_CLUT_SIZE);
+                else if (*(ULONG*)pvIn & LCD)
+                    QueryRegistryValue(ppdev, LCDGamma, ((pGammaTbl)pvOut)->pClut, MAX_CLUT_SIZE);
+                    
+                return UT_SUCCESS;    
+            }
+            break;
+*/
+#endif
+        case UT_SET_LCD_PWM:
+            if (req->inBufferSize != sizeof(UCHAR))
+                return UT_FAIL;
+                
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = SetLCDPWMLevel;
+            CBiosArguments.reg.lh.CL = *(UCHAR*)req->inBuffer;
+            if (CInt10(&CBIOSExtension))
+            {
+                return(UT_SUCCESS);
+            }
+            break;
+
+        case UT_QUERY_LCD_PWM:
+            if (req->outBufferSize != sizeof(UCHAR))
+                return UT_FAIL;
+                
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = QueryLCDPWMLevel;
+            if (CInt10(&CBIOSExtension))
+            {
+                *(UCHAR*)req->outBuffer = CBiosArguments.reg.lh.BL;
+                return(UT_SUCCESS);
+            }
+            break;
+
+        case UT_QUERY_LCD_SIZE:
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "DrvEscape: Query LCD Size");
+
+            if (req->outBufferSize != sizeof(LCDINFO))
+                return UT_FAIL;
+
+            // If color depth is 32 bpp, set it to 24.
+            int iDepth = pScrn->depth;
+            if (iDepth == 32) // 24 and 32 bpp should have same index 2.
+                iDepth = 24;
+                
+            CBiosArguments.reg.x.AX = OEMFunction;
+            CBiosArguments.reg.x.BX = QueryLCDPanelSizeMode;
+            CBiosArguments.reg.lh.CL = (iDepth/8) - 1; // Color depth : 0(8 bpp), 1(16 bpp), 2(24/32 bpp)
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "Color depth is %d\n", CBiosArguments.reg.lh.CL);
+            if (CInt10(&CBIOSExtension))
+            {
+                PLCDINFO pLcdPanelSize;
+                pLcdPanelSize = (PLCDINFO) outBufPtr;
+                pLcdPanelSize->wLCDWidth = CBiosArguments.reg.ex.EDX & 0x0000FFFF;
+                pLcdPanelSize->wLCDHeight = CBiosArguments.reg.ex.EDX >> 16;
+                return(UT_SUCCESS);
+            }
+            break;
+#if 0
+/*
+        case UT_DECODER_JPEG_ENTRY:
+            {
+                DBG_GDI((0, "DrvEscape: UT_DECODER_JPEG_ENTRY"));
+                ulResult = ExtJpegDecoderEntry(pso, cjIn, pvIn, cjOut, pvOut);
+                return ulResult;
+            }
+            break;
+        case UT_ENCODER_JPEG_ENTRY:
+            {
+                DBG_GDI((0, "DrvEscape: UT_ENCODER_JPEG_ENTRY"));
+                ulResult = ExtJpegEncoderEntry(pso, cjIn, pvIn, cjOut, pvOut);
+                return ulResult;
+            }
+            break;
+        case UT_GET_USERMODE_DIRECTACCESS:
+            {
+                DBG_GDI((0, "DrvEscape: UT_GET_USERMODE_DIRECTACCESS")) ;
+                ulResult = ExtUserModeDirectAccess(pso, cjIn, pvIn, cjOut, pvOut) ;
+                return ulResult ;
+            }
+            break ;
+*/
+#endif
+        default:
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 4, "RDCGFXUtilityProc: unknown command 0x%x", req->util_cmd_id);
+            break;
+    }
+
+    return UT_INVALID;
+}
+
+
diff --git a/src/rdc_extension.h b/src/rdc_extension.h
new file mode 100644
index 0000000..81144ee
--- /dev/null
+++ b/src/rdc_extension.h
@@ -0,0 +1,180 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+/******************************************************************************/
+/*                                                                            */  
+/*  Escape function definite                                                  */
+/*                                                                            */
+/******************************************************************************/
+
+// user defined type.
+typedef unsigned short          WORD;
+typedef unsigned long           DWORD;
+
+// Escape return value
+#define UT_FAIL                         0x0000
+#define UT_SUCCESS                      0x0001
+#define UT_MODESET                      0x0002
+#define UT_INVALID                      0x1FFF
+#define UT_NOT_IMPLEMENT                0xFFFF
+
+// Escape function define
+#define UT_QUERY_SUPPORT_DEVICE      0x1001
+#define UT_QUERY_CONNECT_DEVICE      0x1002
+#define UT_SET_DEVICE_ACT            0x1003
+#define UT_QUERY_PRIMARY_DEVICE      0x1004
+#define UT_SET_PRIMARY_DEVICE        0x1005
+#define UT_QUERY_ACT_DEVICE          0x1006
+
+#define UT_QUERY_HW_INFO                0x1201
+#define UT_QUERY_BIOS_VERSION           0x1202
+#define UT_QUERY_MEM_INFO               0x1203
+#define UT_QUERY_CLK_SPEED              0x1204
+#define UT_QUERY_SAMM                   0x1205
+
+#define UT_SET_GAMMA                    0x1101
+#define UT_QUERY_GAMMA                  0x1102
+
+#define UT_SET_LCD_PWM                  0x1103
+#define UT_QUERY_LCD_PWM                0x1104
+#define UT_QUERY_LCD_SIZE               0X1105
+
+
+// Escape jpeg decoder function define
+#define UT_DECODER_JPEG_ENTRY           0x2001
+
+// Escape jpeg eecoder function define
+#define UT_ENCODER_JPEG_ENTRY           0x2101
+
+#define UT_GET_USERMODE_DIRECTACCESS    0x2200
+
+/* For display Xextension */
+#define RDC_GFX_UT_EXTENSION_NAME       "RDCGFX_API"
+
+#define RDCGFX_PARM_NUM         256
+
+#define X_RDCGFXQueryVersion   0
+#define X_RDCGFXCommand        1
+
+typedef struct {
+    BYTE    type;           /* X_Reply */
+    BOOL    pad1;
+    CARD16  sequenceNumber B16;
+    CARD32  length B32;
+    CARD16  majorVersion B16;   
+    CARD16  minorVersion B16;   
+    CARD32  pad2 B32;
+    CARD32  pad3 B32;
+    CARD32  pad4 B32;
+    CARD32  pad5 B32;
+    CARD32  pad6 B32;
+} xRDCGFXQueryVersionReply;
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   RDCGFXReqType;
+    CARD16  length B16;
+    CARD32  util_cmd_id;
+    CARD32  *inBuffer;
+    CARD32  inBufferSize;
+    CARD32  *outBuffer;
+    CARD32  outBufferSize;
+    CARD32  result_header;
+    CARD32  pad;
+} xRDCGFXCommandReq;
+
+/*============ Request and Reply Structures Definition==================*/
+typedef union
+{
+        struct
+        {
+                WORD LCD ;
+                WORD DVI ;
+                WORD CRT ;
+                WORD HDMI ;
+                WORD HDTV ;
+                WORD TV ;
+                WORD LCD2 ;
+                WORD DVI2 ;
+                WORD CRT2 ;
+                WORD HDMI2 ;
+                WORD HDTV2 ;
+                WORD TV2 ;
+                WORD RESERVE ;
+        } TABLE ;
+        WORD MERGE ;
+} UTDEVICELIST;
+
+typedef struct _UTHWINFO
+{
+	ULONG ulVenderID;
+    ULONG ulDeviceID;
+	ULONG ulSubSystemID;
+    ULONG ulSubVenderID;
+    ULONG ulRevision;
+}UTHWINFO;
+
+typedef struct _UTBIOSDATA
+	{
+		ULONG wData1;
+		ULONG wData2;
+		ULONG wData3;
+		ULONG wDate;
+}UTBIOSDATA;
+
+typedef struct _CLKINFO
+{
+	ULONG MemCLK; /*(The unit is MHz)*/
+	ULONG EngCLK; /*(The unit is MHz)*/
+}CLKINFO;
+
+typedef struct _VIDEO_CLUTDATA
+{   
+    UCHAR Red;
+    UCHAR Green;
+    UCHAR Blue;
+    UCHAR Unused;
+} VIDEO_CLUTDATA, *PVIDEO_CLUTDATA;
+
+typedef struct
+{   
+    USHORT   NumEntries ;               // total 256 entries
+    USHORT   FirstEntry ;               // start from 0
+    union
+        {
+        VIDEO_CLUTDATA  RgbArray ;
+        ULONG           RgbLong ;
+    } LookupTable[1] ;
+} VIDEO_CLUT, *PVIDEO_CLUT ;
+
+typedef struct
+{
+        DWORD           device ;        // the device
+        DWORD           dwSize;         // the size of gamma tbl
+        PVIDEO_CLUT     table ;         // the table
+} GammaTbl, *pGammaTbl ;
+
+// LCD info structure.
+typedef struct _LCDINFO
+{
+	WORD wLCDHeight; 
+	WORD wLCDWidth; 
+} LCDINFO, *PLCDINFO;
+
diff --git a/src/rdc_mode.c b/src/rdc_mode.c
new file mode 100644
index 0000000..7834e68
--- /dev/null
+++ b/src/rdc_mode.c
@@ -0,0 +1,483 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+ 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+RRateInfo RefreshRateMap[] = { {60.0f,  FALSE, 0},
+                               {50.0f,  TRUE,  1},
+                               {50.0f,  FALSE, 3},
+                               {56.0f,  FALSE, 4},
+                               {24.0f,  FALSE, 6},
+                               {70.0f,  FALSE, 7},
+                               {75.0f,  FALSE, 8},
+                               {80.0f,  FALSE, 9},
+                               {85.0f,  FALSE, 10},
+                               {90.0f,  FALSE, 11},
+                               {100.0f, FALSE, 12},
+                               {120.0f, FALSE, 13},
+                               {72.0f,  FALSE, 14},
+                               {65.0f,  FALSE, 15}};
+
+
+/* extern. function */
+extern void vRDCOpenKey(ScrnInfoPtr pScrn);
+extern Bool bRDCRegInit(ScrnInfoPtr pScrn);
+
+#ifdef Accel_2D
+extern Bool bEnable2D(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+#endif
+#ifdef HWC
+extern Bool bInitHWC(ScrnInfoPtr pScrn, RDCRecPtr pRDC);
+#endif
+
+/* Prototype type declaration*/
+Bool RDCSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode);
+USHORT usGetVbeModeNum(ScrnInfoPtr pScrn, DisplayModePtr mode);
+float fDifference(float Value1, float Value2);
+DisplayModePtr RDCBuildModePool(ScrnInfoPtr pScrn);
+Bool BTranslateIndexToRefreshRate(UCHAR ucRRateIndex, float *fRefreshRate);
+char* pcConvertResolutionToString(ULONG ulResolution);
+DisplayModePtr SearchDisplayModeRecPtr(DisplayModePtr pModePoolHead, CBIOS_ARGUMENTS CBiosArguments);
+
+
+Bool
+RDCSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+    RDCRecPtr pRDC;
+    MODE_PRIVATE *pModePrivate;
+    CBIOS_ARGUMENTS CBiosArguments;
+    CBIOS_Extension CBiosExtension;
+    USHORT usVESAMode;
+    
+    pRDC = RDCPTR(pScrn);
+    pModePrivate = MODE_PRIVATE_PTR(mode);
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Enter RDCSetMode()== \n");
+
+    vRDCOpenKey(pScrn);
+    bRDCRegInit(pScrn);
+
+    CBiosExtension.pCBiosArguments = &CBiosArguments;
+    CBiosExtension.IOAddress = (USHORT)(pRDC->RelocateIO);
+    CBiosExtension.VideoVirtualAddress = (ULONG)(pRDC->FBVirtualAddr);
+
+    /*CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = SetActiveDisplayDevice;
+    CBiosArguments.reg.lh.CL = 0x13;
+    CInt10(&CBiosExtension);*/
+    
+    /*xf86DrvMsg(pScrn->scrnIndex, X_INFO, "==RDCSetMode() Set Refresh Rate = %f== \n",mode->VRefresh);*/
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = SetDisplay1RefreshRate;
+    CBiosArguments.reg.lh.CL = pModePrivate->ucRRate_ID;
+    CInt10(&CBiosExtension);
+    
+    usVESAMode = usGetVbeModeNum(pScrn, mode);
+    /*xf86DrvMsg(pScrn->scrnIndex, X_INFO, "==RDCSetMode() Set VESA Mode 0x%x== \n",uVESAMode);*/
+    CBiosArguments.reg.x.AX = VBESetMode;
+    CBiosArguments.reg.x.BX = (0x4000 | usVESAMode);
+    CInt10(&CBiosExtension);
+
+    /*xf86DrvMsg(pScrn->scrnIndex, X_INFO, "==RDCSetMode() Set Scan Line pixels== \n");*/
+    CBiosArguments.reg.x.AX = VBESetGetScanLineLength;
+    CBiosArguments.reg.lh.BL = 0x00;
+    CBiosArguments.reg.x.CX = (USHORT)(pScrn->displayWidth);
+    CInt10(&CBiosExtension);
+
+    /*
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = SetVESAModeForDisplay2;
+    CBiosArguments.reg.x.CX = (0x4000 | usVESAMode);
+    CInt10(&CBiosExtension);
+
+    CBiosArguments.reg.x.AX = 0x4f14;
+    CBiosArguments.reg.x.BX = SetDisplay2PitchInPixels;
+    CBiosArguments.reg.x.CX = (USHORT)(pScrn->displayWidth);
+    CInt10(&CBiosExtension);
+    */
+    /* post set mode */
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 7, "==RDCSetMode() Enable 2D== \n");
+#ifdef Accel_2D
+    if (!pRDC->noAccel) 
+    {
+        if (!bEnable2D(pScrn, pRDC)) 
+        {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Enable 2D failed\n");  
+            pRDC->noAccel = TRUE;                        
+        }           
+    }
+#endif
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 7, "==RDCSetMode() Enable Cursor== \n");
+#ifdef HWC
+    if (!pRDC->noHWC) 
+    {
+        if (!bInitHWC(pScrn, pRDC))
+        {
+            xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Init HWC failed\n");
+            pRDC->noHWC = TRUE;                         
+        }           
+    }
+#endif       
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InternalLevel, "==Exit RDCSetMode(), return true== \n");    
+    return (TRUE);    
+}
+
+USHORT usGetVbeModeNum(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+    RDCRecPtr pRDC;
+    MODE_PRIVATE *pModePrivate;
+    USHORT usVESAModeNum;
+    UCHAR  ucColorDepth = (UCHAR)(pScrn->bitsPerPixel);
+
+    pRDC = RDCPTR(pScrn);
+    pModePrivate = MODE_PRIVATE_PTR(mode);
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter usGetVbeModeNum()== \n");
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "==Display Width=0x%x, Height=0x%x, Color Depth=0x%x==\n",
+               mode->HDisplay,mode->VDisplay,pScrn->bitsPerPixel);
+
+
+    switch (ucColorDepth)
+    {
+        case 8:
+            usVESAModeNum = pModePrivate->Mode_ID_8bpp;
+            break;
+
+        case 16:
+            usVESAModeNum = pModePrivate->Mode_ID_16bpp;
+            break;
+
+        case 32:
+            usVESAModeNum = pModePrivate->Mode_ID_32bpp;
+            break;
+    }
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit usGetVbeModeNum() return VESA Mode = 0x%x==\n", usVESAModeNum);
+    return usVESAModeNum;
+
+}
+
+DisplayModePtr RDCBuildModePool(ScrnInfoPtr pScrn)
+{
+    DisplayModePtr pMode = NULL, pModePoolHead = NULL, pModePoolTail = NULL;
+    
+    CBIOS_ARGUMENTS CBiosArguments;
+    CBIOS_Extension CBiosExtension;
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    MODE_PRIVATE *pModePrivate;
+    USHORT usSerialNum = 0;
+    BYTE bCurrentDeviceIdx;
+    USHORT wLCDHorSize, wLCDVerSize;
+    USHORT wVESAModeHorSize, wVESAModeVerSize;
+    BYTE bColorDepth; //0: 8bpp, 1: 16bpp, 2: 32bpp
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Enter RDCBuildModePool()== \n");
+
+    CBiosExtension.pCBiosArguments = &CBiosArguments;
+    CBiosExtension.IOAddress = (USHORT)(pRDC->RelocateIO);
+    CBiosExtension.VideoVirtualAddress = (ULONG)(pRDC->FBVirtualAddr);
+
+    do {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "Mode serial Num 0x%x\n",usSerialNum);
+
+        CBiosArguments.reg.x.AX = 0x4f14;
+        CBiosArguments.reg.x.BX = QuerySupportedMode;
+        CBiosArguments.reg.x.CX = usSerialNum++;
+        CInt10(&CBiosExtension);
+
+        wVESAModeHorSize = (USHORT)(CBiosArguments.reg.ex.EDX & 0x0000FFFF);
+        wVESAModeVerSize = (USHORT)(CBiosArguments.reg.ex.EDX >> 16);
+
+        
+        if (CBiosArguments.reg.x.AX == VBEFunctionCallSuccessful)
+        {
+            pMode = SearchDisplayModeRecPtr(pModePoolHead, CBiosArguments);
+
+            if (pMode == NULL)
+            {
+                if (pModePoolHead != NULL)
+                {
+                    pModePoolTail->next = xnfalloc(sizeof(DisplayModeRec));
+                    pModePoolTail->next->prev = pModePoolTail;
+                    pModePoolTail = pModePoolTail->next;
+                }
+                else
+                {
+                    pModePoolHead = xnfalloc(sizeof(DisplayModeRec));
+                    pModePoolHead->prev = NULL;
+                    pModePoolTail = pModePoolHead;
+                }
+                /* pModePoolTail points to the last mode */
+                pModePoolTail->next = NULL;
+
+                pModePoolTail->name = pcConvertResolutionToString(CBiosArguments.reg.ex.EDX);
+
+                pModePoolTail->status = MODE_OK;
+                pModePoolTail->type = M_T_BUILTIN;
+                pModePoolTail->Flags = 0;
+
+                /* allocate memory to pModePoolTail->Private */
+                pModePoolTail->PrivSize = sizeof(MODE_PRIVATE);
+                pModePoolTail->Private  = xnfalloc(pModePoolTail->PrivSize);
+                pModePrivate = MODE_PRIVATE_PTR(pModePoolTail);
+
+                /* required timing parameters */
+                pModePoolTail->Clock = pModePoolTail->SynthClock = CBiosArguments.reg.ex.EDI;
+                pModePoolTail->HDisplay = pModePoolTail->CrtcHDisplay = wVESAModeHorSize;
+                pModePoolTail->VDisplay = pModePoolTail->CrtcVDisplay = wVESAModeVerSize;
+                BTranslateIndexToRefreshRate(CBiosArguments.reg.lh.CH, &(pModePoolTail->VRefresh));
+                
+                pModePoolTail->PrivFlags = (int)CBiosArguments.reg.x.SI;
+                pModePrivate->ucRRate_ID = CBiosArguments.reg.lh.CH;
+            }
+            else
+            {
+                pModePrivate = MODE_PRIVATE_PTR(pMode);
+            }
+            
+            switch (CBiosArguments.reg.lh.CL)
+            {
+                case 8:
+                    pModePrivate->Mode_ID_8bpp = CBiosArguments.reg.x.BX;
+                    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "pModePrivate->Mode_ID_8bpp = 0x%x\n",pModePrivate->Mode_ID_8bpp);
+                    break;
+                case 16:
+                    pModePrivate->Mode_ID_16bpp = CBiosArguments.reg.x.BX;
+                    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "pModePrivate->Mode_ID_16bpp = 0x%x\n",pModePrivate->Mode_ID_16bpp);
+                    break;
+                case 32:
+                    pModePrivate->Mode_ID_32bpp = CBiosArguments.reg.x.BX;
+                    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 5, "pModePrivate->Mode_ID_32bpp = 0x%x\n",pModePrivate->Mode_ID_32bpp);
+                    break;
+            }
+        }
+    } while (CBiosArguments.reg.x.AX == VBEFunctionCallSuccessful);
+
+    // query LCD panel modes
+        for (bColorDepth = 0; bColorDepth < 3; bColorDepth++)
+        {
+            CBiosArguments.reg.x.AX = 0x4f14;
+            CBiosArguments.reg.x.BX = QueryLCDPanelSizeMode;
+            CBiosArguments.reg.x.CX = bColorDepth;
+            CInt10(&CBiosExtension);
+
+            if (CBiosArguments.reg.x.AX == VBEFunctionCallSuccessful)
+            {
+                pMode = SearchDisplayModeRecPtr(pModePoolHead, CBiosArguments);
+
+                if (pMode == NULL)
+                {
+                    if (pModePoolHead != NULL)
+                    {
+                        pModePoolTail->next = xnfalloc(sizeof(DisplayModeRec));
+                        pModePoolTail->next->prev = pModePoolTail;
+                        pModePoolTail = pModePoolTail->next;
+                    }
+                    else
+                    {
+                        pModePoolHead = xnfalloc(sizeof(DisplayModeRec));
+                        pModePoolHead->prev = NULL;
+                        pModePoolTail = pModePoolHead;
+                    }
+                    /* pModePoolTail points to the last mode */
+                    pModePoolTail->next = NULL;
+
+                    pModePoolTail->name = pcConvertResolutionToString(CBiosArguments.reg.ex.EDX);
+
+                    pModePoolTail->status = MODE_OK;
+                    pModePoolTail->type = M_T_BUILTIN;
+                    pModePoolTail->Flags = 0;
+
+                    /* allocate memory to pModePoolTail->Private */
+                    pModePoolTail->PrivSize = sizeof(MODE_PRIVATE);
+                    pModePoolTail->Private  = xnfalloc(pModePoolTail->PrivSize);
+                    pModePrivate = MODE_PRIVATE_PTR(pModePoolTail);
+
+                    /* required timing parameters */
+                    pModePoolTail->Clock = pModePoolTail->SynthClock = CBiosArguments.reg.ex.EDI;
+                    pModePoolTail->HDisplay = pModePoolTail->CrtcHDisplay = (CBiosArguments.reg.ex.EDX & 0x0000FFFF);
+                    pModePoolTail->VDisplay = pModePoolTail->CrtcVDisplay = (CBiosArguments.reg.ex.EDX >> 16);
+                    BTranslateIndexToRefreshRate(CBiosArguments.reg.lh.CH, &(pModePoolTail->VRefresh));
+                    
+                    pModePoolTail->PrivFlags = (int)CBiosArguments.reg.x.SI | LCD_TIMING;
+                    pModePrivate->ucRRate_ID = CBiosArguments.reg.lh.CH;
+                }
+                else
+                {
+                    pModePrivate = MODE_PRIVATE_PTR(pMode);
+                }
+                
+                switch (CBiosArguments.reg.lh.CL)
+                {
+                    case 8:
+                        pModePrivate->Mode_ID_8bpp = CBiosArguments.reg.x.BX;
+                        break;
+                    case 16:
+                        pModePrivate->Mode_ID_16bpp = CBiosArguments.reg.x.BX;
+                        break;
+                    case 32:
+                        pModePrivate->Mode_ID_32bpp = CBiosArguments.reg.x.BX;
+                        break;
+                }
+                
+            }
+        }
+
+    /* To Do */
+    /* Get Mode Support from VGA Bios, if platform has VGA Bios */
+    /* Compare Bios mode and driver mode. */
+    /* If they have the same mode information, replace driver mode with Bios mode*/
+    /* If Bios has new mode, add it to mode pool*/
+       
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DefaultLevel, "==Exit RDCBuildModePool()== pModePoolHead = 0x%x\n", pModePoolHead);         
+    return pModePoolHead;
+}
+
+Bool BTranslateIndexToRefreshRate(UCHAR ucRRateIndex, float *fRefreshRate)
+{
+    int i;
+
+    for (i = 0; i < sizeof(RefreshRateMap)/sizeof(RRateInfo); i++)
+    {
+        if (RefreshRateMap[i].ucRRateIndex == ucRRateIndex)
+        {
+            *fRefreshRate = RefreshRateMap[i].fRefreshRate;
+            return (TRUE);
+        }
+    }
+    return (FALSE);
+}
+
+char* pcConvertResolutionToString(ULONG ulResolution)
+{
+    USHORT usHorResolution = (USHORT)(ulResolution & 0x0000FFFF);
+    USHORT usVerResolution = (USHORT)(ulResolution >> 16);
+    USHORT usTemp;
+    int iIndex, iStringSize, i;
+    char *pcResolution;
+    
+    pcResolution = xnfalloc(10);
+    
+    /* compute string size */
+    iIndex = 0;
+
+    iStringSize = 1;
+    usTemp = usHorResolution;
+    while ((usTemp/10) > 0)
+    {
+        iStringSize++;
+        usTemp /= 10;
+    }
+
+    usTemp = usHorResolution;
+    for ( i = 1 ; i <= iStringSize; i++)
+    {
+        pcResolution[iIndex+ iStringSize - i] = (usTemp%10) + 0x30;
+        usTemp /= 10;
+    }
+    iIndex += iStringSize;
+
+    pcResolution[iIndex] = 'x';
+    iIndex++;
+    
+    iStringSize = 1;
+    usTemp = usVerResolution;
+    while ((usTemp/10) > 0)
+    {
+        iStringSize++;
+        usTemp /= 10;
+    }
+
+    usTemp = usVerResolution;
+    for ( i = 1 ; i <= iStringSize; i++)
+    {
+        pcResolution[iIndex+ iStringSize - i] = (usTemp%10) + 0x30;
+        usTemp /= 10;
+    }
+    iIndex += iStringSize;
+    
+    pcResolution[iIndex] = '\0';
+
+    return pcResolution;
+}
+
+DisplayModePtr SearchDisplayModeRecPtr(DisplayModePtr pModePoolHead, CBIOS_ARGUMENTS CBiosArguments)
+{
+    DisplayModePtr pMode = pModePoolHead;
+    MODE_PRIVATE *pModePrivate;
+    
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Enter SearchDisplayModeRecPtr(CH = 0x%02X, EDX = 0x%08X, SI = 0x%X, EDI = %d)== \n", CBiosArguments.reg.lh.CH, CBiosArguments.reg.ex.EDX, CBiosArguments.reg.x.SI, CBiosArguments.reg.ex.EDI);
+    
+    while(pMode != NULL)
+    {
+        pModePrivate = MODE_PRIVATE_PTR(pMode);
+        
+        if ((pModePrivate->ucRRate_ID == CBiosArguments.reg.lh.CH) &&
+            (pMode->HDisplay == (int)(CBiosArguments.reg.ex.EDX & 0x0000FFFF)) &&
+            (pMode->VDisplay == (int)(CBiosArguments.reg.ex.EDX >>16)) &&
+            ((pMode->PrivFlags & 0xFFFF) == (int)CBiosArguments.reg.x.SI) &&
+            (pMode->Clock == CBiosArguments.reg.ex.EDI))
+        {
+            xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Exit1 SearchDisplayModeRecPtr()== \n");
+            return pMode;
+        }
+
+        pMode = pMode->next;
+    }
+    xf86DrvMsgVerb(0, X_INFO, InternalLevel, "==Exit2 SearchDisplayModeRecPtr()== \n");
+    return NULL;
+}
diff --git a/src/rdc_mode.h b/src/rdc_mode.h
new file mode 100644
index 0000000..f2bbec4
--- /dev/null
+++ b/src/rdc_mode.h
@@ -0,0 +1,107 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+/* Mode Limitation */
+#ifdef FPGA
+#define MAX_HResolution     1024
+#define MAX_VResolution     768
+#else
+#define MAX_HResolution     1920
+#define MAX_VResolution     1200
+#endif
+ 
+/* Std. Table Index Definition */
+#define TextModeIndex       0
+#define EGAModeIndex        1
+#define VGAModeIndex        2
+#define HiCModeIndex        3
+#define TrueCModeIndex      4
+
+/* DCLK Index */
+#define VCLK25_175          0x00
+#define VCLK28_322          0x01
+#define VCLK31_5            0x02
+#define VCLK36              0x03
+#define VCLK40              0x04
+#define VCLK49_5            0x05
+#define VCLK50              0x06
+#define VCLK56_25           0x07
+#define VCLK65              0x08
+#define VCLK75              0x09
+#define VCLK78_75           0x0A
+#define VCLK94_5            0x0B
+#define VCLK108             0x0C
+#define VCLK135             0x0D
+#define VCLK157_5           0x0E
+#define VCLK162             0x0F
+/* #define VCLK193_25           0x10 */
+#define VCLK154             0x10
+
+/* Flags Definition */
+#define Charx8Dot           0x00000001
+#define HalfDCLK            0x00000002
+#define DoubleScanMode      0x00000004
+#define LineCompareOff      0x00000008
+#define SyncPP              0x00000000
+#define SyncPN              0x00000040
+#define SyncNP              0x00000080
+#define SyncNN              0x000000C0
+#define HBorder             0x00000020
+#define VBorder             0x00000010
+
+/* DAC Definition */
+#define DAC_NUM_TEXT        64
+#define DAC_NUM_EGA         64
+#define DAC_NUM_VGA         256
+
+/* DisplayModePtr->PrivFlags */
+#define LCD_TIMING          0x00010000
+
+/* Data Structure decalration for internal use */
+typedef struct {
+    UCHAR   MISC;
+    UCHAR   SEQ[4];
+    UCHAR   CRTC[25];
+    UCHAR   AR[20];
+    UCHAR   GR[9];
+    
+} VBIOS_STDTABLE_STRUCT, *PVBIOS_STDTABLE_STRUCT;
+
+typedef struct {
+    UCHAR   ucNS;
+    UCHAR   ucMS;
+    UCHAR   ucRS;
+} VBIOS_DCLK_INFO, *PVBIOS_DCLK_INFO;
+
+typedef struct _RRateInfo{
+    float fRefreshRate;
+    Bool  BInterlaced;
+    UCHAR ucRRateIndex;
+}RRateInfo;
+
+typedef struct _MODE_PRIVATE
+{
+    USHORT  Mode_ID_8bpp;
+    USHORT  Mode_ID_16bpp;
+    USHORT  Mode_ID_32bpp;
+    UCHAR   ucRRate_ID;
+} MODE_PRIVATE;
+
+
diff --git a/src/rdc_tool.c b/src/rdc_tool.c
new file mode 100644
index 0000000..4ba363a
--- /dev/null
+++ b/src/rdc_tool.c
@@ -0,0 +1,259 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+ 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+/* Prototype type declaration*/
+Bool RDCMapMem(ScrnInfoPtr pScrn);
+Bool RDCUnmapMem(ScrnInfoPtr pScrn);
+Bool RDCMapMMIO(ScrnInfoPtr pScrn);
+void RDCUnmapMMIO(ScrnInfoPtr pScrn);
+Bool RDCMapVBIOS(ScrnInfoPtr pScrn);
+Bool RDCUnmapVBIOS(ScrnInfoPtr pScrn);
+
+
+// map, unmap frame buffer
+Bool
+RDCMapMem(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    
+#if XSERVER_LIBPCIACCESS
+    struct pci_device *const device = pRDC->PciInfo;
+    int err;
+    
+    err = pci_device_map_range(device, pRDC->FBPhysAddr, pRDC->FbMapSize, 
+                                   PCI_DEV_MAP_FLAG_WRITABLE | PCI_DEV_MAP_FLAG_WRITE_COMBINE,
+                                   (void **) &pRDC->FBVirtualAddr);
+    
+    if (err)
+    {
+        xf86DrvMsg (pScrn->scrnIndex, X_ERROR,
+        "Unable to map frame buffer BAR. %s (%d)\n",
+        strerror (err), err);
+        return FALSE;
+    }
+#else
+    pRDC->FBVirtualAddr = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
+                                        pRDC->PciTag,
+                                        pRDC->FBPhysAddr, pRDC->FbMapSize);
+#endif
+
+    if (!pRDC->FBVirtualAddr)
+        return FALSE;
+
+    return TRUE;
+}
+
+Bool
+RDCUnmapMem(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+#if XSERVER_LIBPCIACCESS
+       pci_device_unmap_range (pRDC->PciInfo, pRDC->FBVirtualAddr, pRDC->FbMapSize);
+#else 
+    xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pRDC->FBVirtualAddr,
+                    pRDC->FbMapSize);
+#endif
+
+    pRDC->FBVirtualAddr = 0;
+   
+    return TRUE;
+}
+
+// map, ummap MMIO
+Bool
+RDCMapMMIO(ScrnInfoPtr pScrn)
+{
+   int mmioFlags;
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+#if !defined(__alpha__)
+    mmioFlags = VIDMEM_MMIO | VIDMEM_READSIDEEFFECT;
+#else
+    mmioFlags = VIDMEM_MMIO | VIDMEM_READSIDEEFFECT | VIDMEM_SPARSE;
+#endif
+
+#if XSERVER_LIBPCIACCESS
+    struct pci_device *const device = pRDC->PciInfo;
+        
+    pci_device_map_range(device, pRDC->MMIOPhysAddr, pRDC->MMIOMapSize,
+                         PCI_DEV_MAP_FLAG_WRITABLE | PCI_DEV_MAP_FLAG_WRITE_COMBINE,
+                         (void **) &pRDC->MMIOVirtualAddr);
+#else
+    pRDC->MMIOVirtualAddr = xf86MapPciMem(pScrn->scrnIndex, mmioFlags,
+                                          pRDC->PciTag,
+                                          pRDC->MMIOPhysAddr, pRDC->MMIOMapSize);
+#endif
+
+    if (!pRDC->MMIOVirtualAddr)
+        return FALSE;
+
+    return TRUE;
+}
+
+void
+RDCUnmapMMIO(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+#if XSERVER_LIBPCIACCESS
+        pci_device_unmap_range (pRDC->PciInfo, pRDC->MMIOVirtualAddr, pRDC->MMIOMapSize);
+#else
+    xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pRDC->MMIOVirtualAddr,
+                    pRDC->MMIOMapSize);
+#endif
+
+    pRDC->MMIOVirtualAddr = 0;
+   
+}
+
+// map, unmap VBIOS
+Bool RDCMapVBIOS(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr   pRDC = RDCPTR(pScrn);
+    FILE        *fpVBIOS;
+    int         i;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Enter RDCMapVBIOS()==\n");
+    pRDC->ulROMType = 0;
+
+    // Map C000
+    if (pRDC->ulROMType == 0)
+    {
+        pRDC->BIOSVirtualAddr = xf86MapVidMem(pScrn->scrnIndex, VIDMEM_READONLY, BIOS_ROM_PHY_BASE, BIOS_ROM_SIZE);
+        if (pRDC->BIOSVirtualAddr)
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 0, "pRDC->BIOSVirtualAddr = 0x%08x\n", pRDC->BIOSVirtualAddr);
+            pRDC->ulROMType = 1;
+        }
+        else
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "==BIOS ROM not found()==\n");
+        }
+    }
+
+    // read ROM file
+    if (pRDC->ulROMType == 0)
+    {
+        // open BIOS ROM file
+        fpVBIOS = fopen(BIOS_ROM_PATH_FILE, "r");
+        if (!fpVBIOS)
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "BIOS ROM file \"/root/RDCVBIOS.ROM\" not found()==\n");
+        }
+    
+        // memory allocate
+        pRDC->BIOSVirtualAddr = xnfalloc(BIOS_ROM_SIZE);
+        if (!pRDC->BIOSVirtualAddr)
+        {
+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "Read BIOS ROM file: Mem Allocate Fail!!==\n");
+            fclose (fpVBIOS);
+        }
+
+        // set ROM type
+        if (fpVBIOS && pRDC->BIOSVirtualAddr)
+        {
+            pRDC->ulROMType = 2;
+            for (i = 0; i < BIOS_ROM_SIZE; i++)
+            {
+                fscanf(fpVBIOS, "%c", pRDC->BIOSVirtualAddr+i);
+            }
+            fclose (fpVBIOS);
+        }
+    }
+
+    if (pRDC->ulROMType == 0)
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit1 RDCMapVBIOS()== No VBIOS\n");
+        return false; // no VBIOS and ROM file
+    }
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, "pRDC->ulROMType = %d\n", pRDC->ulROMType);
+
+    if ((*(USHORT*)pRDC->BIOSVirtualAddr == 0xAA55) && (*(USHORT*)(pRDC->BIOSVirtualAddr+0x40) == PCI_VENDOR_RDC))
+    {
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit RDCMapVBIOS()== return TRUE\n");
+        return TRUE;
+    }
+    else
+    {
+        RDCUnmapVBIOS(pScrn);
+
+        xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, ErrorLevel, "==Exit2 RDCMapVBIOS()== Not RDC VBIOS\n");
+        return false; // not RDC VGA BIOS
+    }
+}
+
+Bool RDCUnmapVBIOS(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    if (pRDC->ulROMType == 1)
+    {
+        xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pRDC->BIOSVirtualAddr, BIOS_ROM_SIZE);
+    }
+    else if (pRDC->ulROMType == 2)
+    {
+        xfree(pRDC->BIOSVirtualAddr);
+    }
+    pRDC->BIOSVirtualAddr = 0;
+   
+    return TRUE;
+}
+
diff --git a/src/rdc_vgatool.c b/src/rdc_vgatool.c
new file mode 100644
index 0000000..0d84bad
--- /dev/null
+++ b/src/rdc_vgatool.c
@@ -0,0 +1,321 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+/* Prototype type declaration*/
+void vRDCOpenKey(ScrnInfoPtr pScrn);
+Bool bRDCRegInit(ScrnInfoPtr pScrn);
+ULONG GetVRAMInfo(ScrnInfoPtr pScrn);
+Bool RDCFilterModeByBandWidth(ScrnInfoPtr pScrn, DisplayModePtr mode);
+void vSetStartAddressCRT1(RDCRecPtr pRDC, ULONG base);
+void vRDCLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, VisualPtr pVisual);
+void RDCDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags);
+ULONG RDCGetMemBandWidth(ScrnInfoPtr pScrn);
+
+
+void
+vRDCOpenKey(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    SetIndexReg(CRTC_PORT,0x80, 0xA8);     
+}
+
+Bool
+bRDCRegInit(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    /* Enable MMIO */
+    SetIndexRegMask(CRTC_PORT,0xA1, 0xFF, 0x04);
+
+   return (TRUE);
+}
+
+ULONG
+GetVRAMInfo(ScrnInfoPtr pScrn)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    UCHAR jReg;
+
+    vRDCOpenKey(pScrn);
+
+    GetIndexRegMask(CRTC_PORT, 0xAA, 0xFF, jReg);  
+
+    switch (jReg & 0x07)
+    {
+    case 0x00:
+        return (VIDEOMEM_SIZE_08M);
+    case 0x01:
+        return (VIDEOMEM_SIZE_16M);
+    case 0x02:
+        return (VIDEOMEM_SIZE_32M);
+    case 0x03:
+        return (VIDEOMEM_SIZE_64M);
+    case 0x04:
+        return (VIDEOMEM_SIZE_128M);       
+    }
+
+    return (DEFAULT_VIDEOMEM_SIZE);
+}
+
+Bool 
+RDCFilterModeByBandWidth(ScrnInfoPtr pScrn, DisplayModePtr mode)
+{
+    ULONG RequestMemBandWidth = 0;
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    Bool Flags = MODE_OK;
+    
+    RequestMemBandWidth = mode->Clock * ((pScrn->bitsPerPixel + 7) >> 3) / 1000;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, 
+        "==Filter Mode() Memory bandwidth request %u MB==\n", RequestMemBandWidth);
+
+    if (RequestMemBandWidth > pRDC->MemoryBandwidth)
+        Flags = MODE_MEM;
+    
+    return(Flags);
+}
+
+void
+vSetStartAddressCRT1(RDCRecPtr pRDC, ULONG base)
+{
+    /* base is byte aligned, flipping base address is quad-word aligned */
+    ULONG uc1stFlippingCmdReg;
+
+    /* clear [27:3] base address of flipping control */
+    uc1stFlippingCmdReg = *(ULONG *)MMIOREG_1ST_FLIP & (~MASK_1ST_FLIP_BASE);
+
+    /* combine base with uc1stFlippingCmdReg */
+    uc1stFlippingCmdReg |= (base & MASK_1ST_FLIP_BASE);
+
+    *(ULONG *)MMIOREG_1ST_FLIP = uc1stFlippingCmdReg;
+}
+
+ULONG
+RDCGetMemBandWidth(ScrnInfoPtr pScrn)
+{
+    CBIOS_ARGUMENTS CBiosArguments;
+    CBIOS_Extension CBiosExtension;
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+
+    ULONG ulDRAMBusWidth, DRAMEfficiency; 
+    ULONG ulMCLK, ulDRAMBandwidth, ActualDRAMBandwidth; 
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 7, 
+        "==Device ID 0x%x==\n",DEVICE_ID(pRDC->PciInfo));
+
+    switch(DEVICE_ID(pRDC->PciInfo))
+    {
+    case PCI_CHIP_M2010_A0:
+        /* Bus width is 16bit, and DRAM utilization is 30% */
+        ulDRAMBusWidth = 16;
+        DRAMEfficiency = 300;
+        break;
+    case PCI_CHIP_M2011:
+        /* Bus width is 32bit, and DRAM utilization is 60% */
+        ulDRAMBusWidth = 32;
+        DRAMEfficiency = 600;
+        break;
+    default:
+        /* Bus width is 16bit, and DRAM utilization is 60% */
+        ulDRAMBusWidth = 16;
+        DRAMEfficiency = 600;
+    }
+    
+    CBiosExtension.pCBiosArguments = &CBiosArguments;
+    CBiosExtension.IOAddress = (USHORT)(pRDC->RelocateIO);
+    CBiosExtension.VideoVirtualAddress = (ULONG)(pRDC->FBVirtualAddr);
+    
+    vRDCOpenKey(pScrn);
+
+    CBiosExtension.pCBiosArguments->reg.x.AX = 0x4F14;
+    CBiosExtension.pCBiosArguments->reg.x.BX = 0x0000;
+    CInt10(&CBiosExtension);
+
+    if ((CBiosExtension.pCBiosArguments->reg.lh.CL & (0x07)) == 0x03)
+    {
+        ulMCLK = 266;
+    }
+    else
+    {
+        ulMCLK = 200;
+    }
+
+    /* Get Bandwidth */
+    /* Use DDRII DRAM, so multiply 2 */
+    /* Translate DRAM Bandwidth to byte, so div 8*/
+    ulDRAMBandwidth = ulMCLK * ulDRAMBusWidth * 2 / 8;
+
+    ActualDRAMBandwidth = ulDRAMBandwidth * DRAMEfficiency / 1000;
+    
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, InfoLevel, 
+        "==Get actual memory bandwidth request %u MB==\n", ActualDRAMBandwidth);
+
+    return(ActualDRAMBandwidth);
+}
+
+void
+vRDCLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors,
+               VisualPtr pVisual)
+{
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    int     i, j, index;
+    UCHAR DACIndex, DACR, DACG, DACB;
+
+    switch (pScrn->bitsPerPixel) 
+    {
+    case 15:
+        for(i=0; i<numColors; i++)
+        {
+            index = indices[i];
+            for(j=0; j<8; j++) 
+            {
+                DACIndex = (index * 8) + j;
+                DACR = colors[index].red << (8- pScrn->rgbBits);
+                DACG = colors[index].green << (8- pScrn->rgbBits);
+                DACB = colors[index].blue << (8- pScrn->rgbBits);
+
+                VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB);                         
+            }
+        }
+        break;
+
+    case 16:
+        for(i=0; i<numColors; i++) 
+        {
+            index = indices[i];
+            for(j=0; j<4; j++) 
+            {
+                DACIndex = (index * 4) + j;
+                DACR = colors[index/2].red << (8- pScrn->rgbBits);
+                DACG = colors[index].green << (8- pScrn->rgbBits);
+                DACB = colors[index/2].blue << (8- pScrn->rgbBits);
+
+                VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB);                         
+            }
+        }
+        break;
+
+    case 24:
+        for(i=0; i<numColors; i++) 
+        {
+            index = indices[i];
+            DACIndex = index;
+            DACR = colors[index].red;
+            DACG = colors[index].green;
+            DACB = colors[index].blue;
+
+            VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB);                         
+        }    
+        break;
+
+    default:
+        for(i=0; i<numColors; i++) 
+        {
+            index = indices[i];
+            DACIndex = index;
+            DACR = colors[index].red >> (8 - pScrn->rgbBits);
+            DACG = colors[index].green >> (8 - pScrn->rgbBits);
+            DACB = colors[index].blue >> (8 - pScrn->rgbBits);
+
+            VGA_LOAD_PALETTE_INDEX (DACIndex, DACR, DACG, DACB);                         
+        }    
+    } /* end of switch */
+} /* end of vRDCLoadPalette */
+
+void
+RDCDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode, int flags)
+{
+    RDCRecPtr pRDC;
+    UCHAR SEQ01, CRB6;
+
+    pRDC = RDCPTR(pScrn);
+    SEQ01=CRB6=0;
+
+    vRDCOpenKey(pScrn);
+   
+    switch (PowerManagementMode) 
+    {
+    case DPMSModeOn:
+        /* Screen: On; HSync: On, VSync: On */
+        SEQ01 = 0x00;
+        CRB6 = 0x00;
+        break;
+        
+    case DPMSModeStandby:
+        /* Screen: Off; HSync: Off, VSync: On */
+        SEQ01 = 0x20;
+        CRB6  = 0x01;     
+        break;
+        
+    case DPMSModeSuspend:
+        /* Screen: Off; HSync: On, VSync: Off */
+        SEQ01 = 0x20;
+        CRB6  = 0x02;           
+        break;
+        
+    case DPMSModeOff:
+        /* Screen: Off; HSync: Off, VSync: Off */
+        SEQ01 = 0x20;
+        CRB6  = 0x03;           
+        break;
+    }
+
+    SetIndexRegMask(SEQ_PORT,0x01, 0xDF, SEQ01);
+    SetIndexRegMask(CRTC_PORT,0xB6, 0xFC, CRB6);
+}
+
diff --git a/src/rdc_vgatool.h b/src/rdc_vgatool.h
new file mode 100644
index 0000000..07cf2f7
--- /dev/null
+++ b/src/rdc_vgatool.h
@@ -0,0 +1,78 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+/* VRAM Size Definition */
+#define VIDEOMEM_SIZE_08M       0x00800000
+#define VIDEOMEM_SIZE_16M       0x01000000
+#define VIDEOMEM_SIZE_32M       0x02000000
+#define VIDEOMEM_SIZE_64M       0x04000000
+#define VIDEOMEM_SIZE_128M      0x08000000
+
+#define AR_PORT_WRITE           (pRDC->RelocateIO + 0x40)
+#define MISC_PORT_WRITE         (pRDC->RelocateIO + 0x42)
+#define SEQ_PORT                (pRDC->RelocateIO + 0x44)
+#define DAC_INDEX_WRITE         (pRDC->RelocateIO + 0x48)
+#define DAC_DATA                (pRDC->RelocateIO + 0x49)
+#define GR_PORT                 (pRDC->RelocateIO + 0x4E)
+#define CRTC_PORT               (pRDC->RelocateIO + 0x54)
+#define INPUT_STATUS1_READ      (pRDC->RelocateIO + 0x5A)
+#define MISC_PORT_READ          (pRDC->RelocateIO + 0x4C)
+
+#define GetReg(base)                    inb(base)
+#define SetReg(base,val)                outb(base,val)
+
+#define GetIndexReg(base,index,val)     \
+    do {                                \
+        outb(base,index);               \
+        val = inb(base+1);              \
+    } while (0)
+                                        
+#define SetIndexReg(base,index, val)    \
+    do {                                \
+        outb(base,index);               \
+        outb(base+1,val);                 \
+    } while (0)
+                                        
+#define GetIndexRegMask(base,index, and, val)   \
+    do {                                        \
+        outb(base,index);                       \
+        val = (inb(base+1) & and);              \
+    } while (0)
+    
+#define SetIndexRegMask(base,index, and, val)   \
+    do {                                        \
+        UCHAR __Temp;                           \
+        outb(base,index);                       \
+         __Temp = (inb((base)+1)&(and))|(val);  \
+        SetIndexReg(base,index,__Temp);         \
+    } while (0)
+
+#define VGA_LOAD_PALETTE_INDEX(index, red, green, blue)     \
+    {                                                       \
+        UCHAR __junk;                                       \
+        SetReg(DAC_INDEX_WRITE,(UCHAR)(index));             \
+        __junk = GetReg(SEQ_PORT);                          \
+        SetReg(DAC_DATA,(UCHAR)(red));                      \
+        __junk = GetReg(SEQ_PORT);                          \
+        SetReg(DAC_DATA,(UCHAR)(green));                    \
+        __junk = GetReg(SEQ_PORT);                          \
+        SetReg(DAC_DATA,(UCHAR)(blue));                     \
+        __junk = GetReg(SEQ_PORT);                          \
+    }
diff --git a/src/rdc_video.c b/src/rdc_video.c
new file mode 100644
index 0000000..3cde151
--- /dev/null
+++ b/src/rdc_video.c
@@ -0,0 +1,914 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include <X11/extensions/Xv.h>
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+#include "cursorstr.h"
+
+/* FOURCC format support */
+#include "fourcc.h"
+
+/* Driver specific headers */
+#include "rdc.h"
+
+
+/* Function Declaration */
+static XF86VideoAdaptorPtr RDCSetupImageVideoOverlay(ScreenPtr);
+static void RDCStopVideo(ScrnInfoPtr,pointer,Bool);
+static int RDCSetPortAttribute(ScrnInfoPtr,Atom,INT32,pointer);
+static int RDCGetPortAttribute(ScrnInfoPtr,Atom,INT32*,pointer);
+static void RDCQueryBestSize(ScrnInfoPtr,Bool,short,short,short,short,unsigned int*,unsigned int*,pointer);
+static int RDCPutImage(ScrnInfoPtr,short,short,short,short,short,short,short,short,
+		               int,unsigned char*,short,short,Bool,RegionPtr,pointer,DrawablePtr);
+static int RDCQueryImageAttributesOverlay(ScrnInfoPtr,int,unsigned short*,unsigned short*,int*,int*);
+static FBLinearPtr RDCAllocateMemory(ScrnInfoPtr, FBLinearPtr, int);
+void RDCUpdateVID(RDCRecPtr, RDCPortPrivPtr, BYTE);
+void RDCCopyFOURCC(RDCRecPtr, unsigned char*, RDCPortPrivPtr, unsigned long, 
+                   unsigned long, int, short, short);
+
+/* Overlay windows max size */
+#define IMAGE_MAX_WIDTH		1280
+#define IMAGE_MAX_HEIGHT	1024
+
+#define NUM_FORMATS 2
+static XF86VideoFormatRec Formats[NUM_FORMATS] = 
+{
+    {16, TrueColor}, 
+    {24, TrueColor}
+};
+
+#define NUM_ATTRIBUTES 4
+static XF86AttributeRec Attributes[NUM_ATTRIBUTES] =
+{
+   {XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"},
+   {XvSettable | XvGettable, 0, 10000, "XV_BRIGHTNESS"},
+   {XvSettable | XvGettable, 0, 20000, "XV_CONTRAST"},
+   {XvSettable | XvGettable, 0, 20000, "XV_SATURATION"},
+};
+
+#define NUM_IMAGES 1
+static XF86ImageRec Images[NUM_IMAGES] = 
+{
+    XVIMAGE_YUY2
+};
+
+#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
+
+static Atom xvBrightness, xvContrast, xvSaturation, xvColorKey;
+
+static XF86VideoEncodingRec DummyEncoding[1] = 
+{
+    {0,"XV_IMAGE",IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT,{1, 1}}
+};
+
+
+void RDCVideoInit(ScreenPtr pScreen)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
+    XF86VideoAdaptorPtr overlayAdaptor = NULL;
+    int num_adaptors;
+    Bool bTrue = FALSE;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCVideoInit()  entry==\n");
+    
+    num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
+    xf86DrvMsgVerb(0,X_INFO,4,"==RDCVideoInit() Adaptor number %d==\n",num_adaptors);
+    
+    newAdaptors = xalloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr *));
+
+    if (newAdaptors == NULL)
+	    return;
+    memcpy(newAdaptors, adaptors, num_adaptors * sizeof(XF86VideoAdaptorPtr));
+    adaptors = newAdaptors;
+   
+    overlayAdaptor = RDCSetupImageVideoOverlay(pScreen);
+
+    if (overlayAdaptor != NULL)
+    {
+        xf86DrvMsgVerb(0,X_INFO,DefaultLevel,"==RDCVideoInit() Get Overlay Adapter==\n");
+        adaptors[num_adaptors++] = overlayAdaptor;
+    }
+    
+    if (num_adaptors)
+    {
+        xf86DrvMsgVerb(0,X_INFO,DefaultLevel,"==RDCVideoInit() Adapter number %d==\n",num_adaptors);
+        bTrue = xf86XVScreenInit(pScreen, adaptors, num_adaptors);
+        if (!bTrue)
+	    xf86DrvMsgVerb(0,X_INFO,DefaultLevel,"==RDCVideoInit() XVScreenInit Fail==\n");
+    }
+	    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCVideoInit()  Exit==\n");
+    xfree(adaptors);
+}
+
+
+static XF86VideoAdaptorPtr
+RDCSetupImageVideoOverlay(ScreenPtr pScreen)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    RDCPortPrivPtr pXVPriv = NULL;
+    XF86VideoAdaptorPtr adapt = NULL;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCSetupImageVideoOverlay()  entry==\n");
+    
+    if (!(adapt = xcalloc(1, sizeof(XF86VideoAdaptorRec) + 
+                             sizeof(RDCPortPrivRec) + 
+                             sizeof(DevUnion))))
+    {
+        xf86DrvMsgVerb(0, X_INFO, 0, "==RDCSetupImageVideoOverlay() allocate fail==\n");
+        return NULL;            
+    }
+    
+    adapt->type = XvWindowMask | XvInputMask | XvImageMask;
+    adapt->flags = VIDEO_OVERLAID_IMAGES /*| VIDEO_CLIP_TO_VIEWPORT*/;
+    adapt->name = "RDC Video Overlay";
+    adapt->nEncodings = 1;
+    adapt->pEncodings = DummyEncoding;
+    
+    adapt->nFormats = NUM_FORMATS;
+    adapt->pFormats = Formats;
+    adapt->nPorts = 1;
+    adapt->pPortPrivates = (DevUnion *) (&adapt[1]);
+
+    pXVPriv = (RDCPortPrivPtr)(&adapt->pPortPrivates[1]);
+
+    /* Init Color Key */
+    pXVPriv->colorkey = (1 << pScrn->offset.red) |
+                        (1 << pScrn->offset.green) |
+                        (((pScrn->mask.blue >> pScrn->offset.blue) - 1) << pScrn->offset.blue);
+    
+    adapt->pPortPrivates[0].ptr = (pointer) (pXVPriv);
+    
+    adapt->nAttributes = NUM_ATTRIBUTES;
+    adapt->pAttributes = Attributes;
+
+    adapt->nImages = NUM_IMAGES;
+    adapt->pImages = Images;
+    adapt->PutVideo = NULL;
+    adapt->PutStill = NULL;
+    adapt->GetVideo = NULL;
+    adapt->GetStill = NULL;
+    adapt->StopVideo = RDCStopVideo;
+    adapt->SetPortAttribute = RDCSetPortAttribute;
+    adapt->GetPortAttribute = RDCGetPortAttribute;
+    adapt->QueryBestSize = RDCQueryBestSize;
+    adapt->PutImage = RDCPutImage;
+    adapt->QueryImageAttributes = RDCQueryImageAttributesOverlay;
+
+    /* Setting private data structure */
+    pXVPriv->VidhwInfo.dwVidCtl         = 0;
+    pXVPriv->VidhwInfo.dwVideoSrcOffset = 0;
+    pXVPriv->VidhwInfo.dwFetch          = 0;
+    pXVPriv->VidhwInfo.dwVDisplayCount  = 0;
+    pXVPriv->VidhwInfo.dwVSrcPitch      = 0;
+    pXVPriv->VidhwInfo.dwWinStartXY     = 0;
+    pXVPriv->VidhwInfo.dwWinEndXY       = 0;
+    pXVPriv->VidhwInfo.dwzoomCtl        = 0;
+    pXVPriv->VidhwInfo.dwVIDBuffer[0]   = 0;
+    pXVPriv->VidhwInfo.dwVIDBuffer[1]   = 0;
+    pXVPriv->VidhwInfo.dwVIDBuffer[2]   = 0;
+    pXVPriv->VidhwInfo.dwColorKey       = (pXVPriv->colorkey & 0x00FFFFFF) | VDPS_ENABLE_CK;
+
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_CTL)                      = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_START_OFFSET)             = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FETCH_COUNT)              = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_SRC_DISP_COUNT_ON_SCR)    = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FB_STRIDE)                = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_START_LOCATION)           = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_END_LOCATION)             = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_ZOOM_CTL)                 = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FB0)                      = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FIRST_COLORKEY)           = pXVPriv->VidhwInfo.dwColorKey;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_SECOND_COLORKEY)          = pXVPriv->VidhwInfo.dwColorKey;
+
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FIFO_THRESHOLD) = VDPS_FIFO_THRESHOLD;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_CHROMA_KEY_LOW) = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_CHROMA_KEY_UPPER) = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_COLOR_ENHANCE_CTL1) = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_COLOR_ENHANCE_CTL2) = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_COLOR_ENHANCE_CTL3) = 0;
+    *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_COLOR_ENHANCE_CTL4) = 0;    
+
+    
+    /* gotta uninit this someplace */
+    REGION_NULL(pScreen, &pXVPriv->clip);
+    
+    xvColorKey = MAKE_ATOM("XV_COLORKEY");
+    xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
+    xvContrast = MAKE_ATOM("XV_CONTRAST");
+    xvSaturation = MAKE_ATOM("XV_SATURATION");
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCSetupImageVideoOverlay()  exit==\n");
+    return adapt;
+}
+
+static void
+RDCStopVideo(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
+{
+    RDCRecPtr pRDC = RDCPTR(pScrn);
+    RDCPortPrivPtr pXVPriv = (RDCPortPrivPtr)data;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCStopVideo()  Entry==\n");
+
+    pRDC->OverlayStatus.bOverlayEnable = false;
+
+    /* Turn Off overlay engine */
+    if (shutdown)
+    {
+        xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCStopVideo()  Stop Overlay==\n");
+        while (!(GetReg(INPUT_STATUS1_READ) & 0x08))
+        {
+            xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "wait v sync\n");
+        }
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_CTL) = 0;
+        pXVPriv->VidhwInfo.dwVidCtl = 0;
+    }
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCStopVideo()  Exit==\n");
+}
+
+static int
+RDCSetPortAttribute(
+        ScrnInfoPtr pScrn,
+		Atom attribute, 
+		INT32 value, 
+		pointer data)
+{
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    RDCPortPrivPtr pXVPriv = (RDCPortPrivPtr)data;
+    int ReturnValue = Success;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCSetPortAttribute()  Entry==\n");
+
+    if (attribute == xvBrightness)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==SetPort Attribute Brightness %d==\n",value);
+        pXVPriv->brightness = value;
+    }
+    else if (attribute == xvContrast)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==SetPort Attribute Contrast %d==\n",value);
+        pXVPriv->contrast = value;
+    }
+    else if (attribute == xvSaturation)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==SetPort Attribute Saturation %d==\n", value);
+        pXVPriv->saturation = value;
+    }
+    else if (attribute == xvColorKey)
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==SetPort Attribute ColorKey 0x%x==\n", value);
+        pXVPriv->colorkey = value;
+
+        pXVPriv->VidhwInfo.dwColorKey = (value & 0x00FFFFFF) | VDPS_ENABLE_CK;
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FIRST_COLORKEY) = pXVPriv->VidhwInfo.dwColorKey;
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_SECOND_COLORKEY) = pXVPriv->VidhwInfo.dwColorKey;
+    }
+    else
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==SetPort Attribute not Support==\n");
+        ReturnValue = BadValue;        
+    }
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCSetPortAttribute()  Exit==\n");
+    
+    return ReturnValue;
+}
+
+static int
+RDCGetPortAttribute(
+        ScrnInfoPtr pScrn,
+		Atom attribute, 
+		INT32 * value, 
+		pointer data)
+{
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    RDCPortPrivPtr pXVPriv = (RDCPortPrivPtr)data;
+    int ReturnValue = Success;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCGetPortAttribute()  Entry==\n");
+    
+    if (attribute == xvBrightness)
+    {
+        *value = pXVPriv->brightness;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==GetPort Attribute Brightness %d==\n",value);
+    }
+    else if (attribute == xvContrast)
+    {
+        *value = pXVPriv->contrast;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==GetPort Attribute Contrast %d==\n",value);
+    }
+    else if (attribute == xvSaturation)
+    {
+        *value = pXVPriv->saturation;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==GetPort Attribute Saturation %d==\n", value);
+    }
+    else if (attribute == xvColorKey)
+    {
+        *value = pXVPriv->colorkey;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==GetPort Attribute ColorKey 0x%x==\n", value);
+    }
+    else
+    {
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==GetPort Attribute not Support==\n");
+        ReturnValue = BadValue;        
+    }
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCGetPortAttribute()  Exit==\n");
+
+    return ReturnValue;
+}
+
+static void
+RDCQueryBestSize(ScrnInfoPtr pScrn,
+		  Bool motion,
+		  short vid_w, short vid_h,
+		  short drw_w, short drw_h,
+		  unsigned int *p_w, unsigned int *p_h, pointer data)
+{
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCQueryBestSize()  Entry==\n");
+
+    *p_w = drw_w;
+    *p_h = drw_h;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCQueryBestSize()  Exit==\n");
+}
+
+
+/*
+ * The source rectangle of the video is defined by (src_x, src_y, src_w, src_h).
+ * The dest rectangle of the video is defined by (drw_x, drw_y, drw_w, drw_h).
+ * id is a fourcc code for the format of the video.
+ * buf is the pointer to the source data in system memory.
+ * width and height are the w/h of the source data.
+ * If "sync" is TRUE, then we must be finished with *buf at the point of return
+ * (which we always are).
+ * clipBoxes is the clipping region in screen space.
+ * data is a pointer to our port private.
+ * pDraw is a Drawable, which might not be the screen in the case of
+ * compositing.  It's a new argument to the function in the 1.1 server.
+ */
+static int
+RDCPutImage(ScrnInfoPtr pScrn,
+	     short src_x, short src_y,
+	     short drw_x, short drw_y,
+	     short src_w, short src_h,
+	     short drw_w, short drw_h,
+	     int id, unsigned char *buf,
+	     short width, short height,
+	     Bool sync, RegionPtr clipBoxes, pointer data,
+	     DrawablePtr pDraw)
+{
+    RDCRecPtr  pRDC = RDCPTR(pScrn);
+    RDCPortPrivPtr  pRDCPortPriv = (RDCPortPrivPtr)data;
+    unsigned long   SrcPitch, DstPitch;
+    unsigned long   DstWidth, DstHeight, ScreenWidth, ScreenHeight, ViewWidth, ViewHeight;
+    HWCINFO         *pHWCInfo = &pRDC->HWCInfo;
+    OVERLAY_STATUS  *pOverlayStatus = &pRDC->OverlayStatus;
+    int   size = 0;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCPutImage()  Entry==\n");
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==FOURCC ID 0x%x, Width = 0x%x, Height = 0x%x==\n", id, width, height);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Src position X = %d, Y = %d==\n",src_x, src_y);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Src size width = %d, Height = %d==\n",src_w, src_h);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Dst position X = %d, Y = %d==\n",drw_x, drw_y);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Dst size width = %d, Height = %d==\n",drw_w, drw_h);
+
+    pOverlayStatus->bOverlayEnable = true;
+    pOverlayStatus->iDstLeft = (int)drw_x;
+    pOverlayStatus->iDstTop = (int)drw_y;
+    pOverlayStatus->iDstWidth = (int)drw_w;
+    pOverlayStatus->iDstHeight = (int)drw_h;
+    pOverlayStatus->iSrcWidth = (int)src_w;
+    pOverlayStatus->iSrcHeight = (int)src_h;
+
+    ScreenWidth  = pRDC->ModePtr->HDisplay;
+    ScreenHeight = pRDC->ModePtr->VDisplay;
+    if (pRDC->DeviceInfo.ucDeviceID == 1) /* if Device == LCD */
+    {
+        ViewWidth    = pRDC->DeviceInfo.MonitorSize.ulHorMaxResolution;
+        ViewHeight   = pRDC->DeviceInfo.MonitorSize.ulVerMaxResolution;
+    }
+    else
+    {
+        ViewWidth    = ScreenWidth;
+        ViewHeight   = ScreenHeight;
+    }
+
+    /* if device == LCD, adjust dst x,y */
+    if (pRDC->DeviceInfo.ucDeviceID == 1)
+    {
+	if (pScrn->bitsPerPixel == 16)
+        {
+            drw_x -= (pHWCInfo->iScreenOffset_x & ~0x3);
+        }
+        else if((pScrn->bitsPerPixel == 24) || (pScrn->bitsPerPixel == 32))
+        {
+            drw_x -= (pHWCInfo->iScreenOffset_x & ~0x1);
+        }
+        drw_y -= pHWCInfo->iScreenOffset_y;
+    }
+
+    switch(id)
+    {
+    case FOURCC_YV12:
+        SrcPitch = (width + 3) & ~3;
+        break;
+    case FOURCC_YUY2:
+        SrcPitch = (width << 1);
+        break;
+    }
+
+    /* HW only support YUY2, So Destination is always YUY2 */
+    DstPitch = (width << 1);
+    DstPitch = (DstPitch + 7) & ~7;     /* Pitch 8 byte alignment */
+    size = DstPitch * height;
+    
+    pRDCPortPriv->SrcPitch = DstPitch;
+    
+    /* Create Off-screen plan for overlay window*/
+    if(!(pRDCPortPriv->PackedBuf0 = RDCAllocateMemory(pScrn, pRDCPortPriv->PackedBuf0, 
+		(pScrn->bitsPerPixel == 16) ? size : (size >> 1))))
+	    return BadAlloc;
+	    
+    /* Copy src data to desination buffer*/
+    RDCCopyFOURCC(pRDC, buf, pRDCPortPriv, SrcPitch, DstPitch, id, width, height);
+    
+    /* update cliplist */
+    if(!REGION_EQUAL(pScrn->pScreen, &pRDCPortPriv->clip, clipBoxes)) 
+    {
+	    REGION_COPY(pScrn->pScreen, &pRDCPortPriv->clip, clipBoxes);
+	    /* draw these */
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Color Key 0x%x==\n",pRDCPortPriv->colorkey);
+        
+	    xf86XVFillKeyHelper(pScrn->pScreen, pRDCPortPriv->colorkey, clipBoxes);
+    }
+
+    /* Setting active rectangle */
+    if(0 == drw_w)
+        DstWidth = 1;
+    else 
+        DstWidth = drw_w;
+        
+    if(0 == drw_h)
+        DstHeight = 1;
+    else 
+        DstHeight = drw_h;
+
+    pRDCPortPriv->rSrc.left = src_x;
+    pRDCPortPriv->rDst.left = drw_x;
+    if (drw_x < 0)
+    {
+        pRDCPortPriv->rSrc.left  += (((-drw_x) * src_w) + (DstWidth >> 1)) / DstWidth;
+        pRDCPortPriv->rDst.left = 0;
+    }
+
+    pRDCPortPriv->rSrc.right = src_x + src_w; 
+    pRDCPortPriv->rDst.right = drw_x + drw_w;
+    if (ViewWidth > ScreenWidth)
+    {
+        if ((drw_x + drw_w) > ScreenWidth)
+        {
+            pRDCPortPriv->rSrc.right -= (((drw_x + drw_w - ScreenWidth) * src_w) + (DstWidth >> 1)) / DstWidth;
+            pRDCPortPriv->rDst.right = ScreenWidth;
+        }
+    }
+    else
+    {
+        if ((drw_x + drw_w) > ViewWidth)
+        {
+            pRDCPortPriv->rSrc.right -= (((drw_x + drw_w - ViewWidth) * src_w) + (DstWidth >> 1)) / DstWidth;
+            pRDCPortPriv->rDst.right = ViewWidth;
+        }
+    }
+
+    pRDCPortPriv->rSrc.top = src_y;
+    pRDCPortPriv->rDst.top = drw_y;
+    if (drw_y < 0)
+    {
+        pRDCPortPriv->rSrc.top +=  ((-drw_y) * height + (DstHeight >> 1)) / DstHeight;
+        pRDCPortPriv->rDst.top = 0;
+    }
+
+    pRDCPortPriv->rSrc.bottom = src_y + src_h;
+    pRDCPortPriv->rDst.bottom = drw_y + drw_h;
+    if (ViewHeight > ScreenHeight)
+    {
+        if ((drw_y + drw_h) > ScreenHeight)
+        {
+            pRDCPortPriv->rSrc.bottom -= (((drw_y + drw_h - ScreenHeight) * src_h) + (DstHeight >> 1)) / DstHeight;
+            pRDCPortPriv->rDst.bottom = ScreenHeight;
+        }
+    }
+    else
+    {
+        if ((drw_y + drw_h) > ViewHeight)
+        {
+            pRDCPortPriv->rSrc.bottom -= (((drw_y + drw_h - ViewHeight) * src_h) + (DstHeight >> 1)) / DstHeight;
+            pRDCPortPriv->rDst.bottom = ViewHeight;
+        }
+    }
+    
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Src left = 0x%x, Src right  = 0x%x==\n",pRDCPortPriv->rSrc.left,pRDCPortPriv->rSrc.right);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Src top  = 0x%x, Src bottom = 0x%x==\n",pRDCPortPriv->rSrc.top, pRDCPortPriv->rSrc.bottom);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Dst left = 0x%x, Dst right  = 0x%x==\n",pRDCPortPriv->rDst.left,pRDCPortPriv->rDst.right);
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Dst top  = 0x%x, Dst bottom = 0x%x==\n",pRDCPortPriv->rDst.top, pRDCPortPriv->rDst.bottom);
+
+    RDCUpdateVID(pRDC, pRDCPortPriv, VID_Enable);
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCPutImage()  Exit==\n");
+    return Success;
+}
+
+static int
+RDCQueryImageAttributesOverlay(ScrnInfoPtr pScrn,int id,
+				               unsigned short *w, unsigned short *h,
+				               int *pitches, int *offsets)
+{
+    int size = 0, chromasize = 0;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCQueryImageAttributesOverlay()  Entry; Width = %d, Height = %d==\n", *w, *h);
+
+    if ((!w) || (!h))
+        return 0;
+
+    if ((pitches == NULL) || (offsets == NULL))
+        return 0;
+
+    if (*w > IMAGE_MAX_WIDTH)
+        *w = IMAGE_MAX_WIDTH;
+    if (*h > IMAGE_MAX_HEIGHT)
+        *h = IMAGE_MAX_HEIGHT;
+
+    *offsets = 0;
+
+    switch (id)
+    {
+    case FOURCC_YV12:
+        /* aligment width and height */
+        *w = (*w + 3) & ~3;
+        *h = (*h + 1) & ~1;
+
+        size = *w;
+        pitches[0] = size;
+
+        size *= *h;
+        chromasize = ((*h >> 1) * (*w >> 1)); 
+        offsets[1] = size;
+
+        pitches[1] = pitches[2] = (*w >> 1);
+        size += chromasize;
+
+        offsets[2] = size;
+        size += chromasize;         
+        break;
+    case FOURCC_YUY2:
+    default:
+        /* aligment width and height */
+        *w = (*w + 1) & ~1;
+        
+        size = (*w << 1);
+
+        if (pitches)
+            pitches[0] = size;
+
+        size *= *h; 
+        break;
+    }
+
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==pitche0 = 0x%x; pitche1 = 0x%x; pitche2 = 0x%x==\n", 
+                   pitches[0],pitches[1],pitches[2]);
+
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==offset0 = 0x%x;offset1 = 0x%x;offset2 = 0x%x;==\n", 
+                   offsets[0], offsets[1], offsets[2]);
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCQueryImageAttributesOverlay()  Exit; Size = %d==\n",size);
+
+    return size;
+}
+
+/*******************************************************************
+* Allocate Local video memory for video display                    *
+********************************************************************/
+static FBLinearPtr
+RDCAllocateMemory(
+    ScrnInfoPtr pScrn,
+    FBLinearPtr PackedBuf,
+    int size)
+{
+    ScreenPtr pScreen;
+    FBLinearPtr newBuf;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCAllocateMemory()  Entry==\n");
+    xf86DrvMsgVerb(0, X_INFO, 8, "==RDCAllocateMemory()  Total size %d==\n",size);
+    
+    if(PackedBuf) 
+    {
+        if(PackedBuf->size >= size)
+        {
+            return PackedBuf;
+        }
+        
+        if(xf86ResizeOffscreenLinear(PackedBuf, size))
+        {
+            return PackedBuf;
+        }
+        xf86FreeOffscreenLinear(PackedBuf);
+    }
+
+    pScreen = screenInfo.screens[pScrn->scrnIndex];
+
+    newBuf = xf86AllocateOffscreenLinear(pScreen, 
+                                         size, 
+                                         8,
+                                         NULL, NULL, NULL);
+
+    if(!newBuf) 
+    {
+        int max_size;
+
+        xf86QueryLargestOffscreenLinear(pScreen, 
+                                        &max_size, 
+                                        8, 
+                                        PRIORITY_EXTREME);
+                                        
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==RDCAllocateMemory()  Max size %d==\n",max_size);
+        
+        if(max_size < size) 
+            return NULL;
+
+        xf86PurgeUnlockedOffscreenAreas(pScreen);
+        newBuf = xf86AllocateOffscreenLinear(pScreen, 
+                                             size, 
+                                             8, 
+                                             NULL, NULL, NULL);
+    } 
+    
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Buffer size %d==\n",newBuf->size);
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Buffer offset %d==\n",newBuf->offset);
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Buffer granularity %d==\n",newBuf->granularity);
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCAllocateMemory()  Exit==\n");
+    return newBuf;
+}
+
+/*****************************************************************
+* Setting Video Display register                                 *
+******************************************************************/
+void RDCUpdateVID(RDCRecPtr  pRDC, RDCPortPrivPtr pRDCPortPriv, BYTE bEnable)
+{
+    unsigned long   SrcWidth, DstWidth, SrcHeight, DstHeight;
+    VIDHWINFOPtr pVIDHwInfo = &pRDCPortPriv->VidhwInfo;
+    OV_RECTLPtr  pRSrc      = &pRDCPortPriv->rSrc;
+    OV_RECTLPtr  pRDst      = &pRDCPortPriv->rDst;
+
+    ULONG   dwVidCtl;                               
+    ULONG   dwVideoSrcOffset;                             
+    ULONG   dwFetch;                  // Video engine fetch count
+    ULONG   dwVDisplayCount;          // Video engine display count 0x26c,0x27c
+    ULONG   dwVSrcPitch;                 // Video engine stride
+    ULONG   dwWinStartXY;
+    ULONG   dwWinEndXY;
+    ULONG   dwzoomCtl;
+    ULONG   dwVIDBuffer[3];
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCUpdateVID()  Entry==\n");
+
+    /*   Enable or Disable VID */
+    if (bEnable)
+        dwVidCtl = VDPS_ENABLE|
+                   VDPS_SW_FLIP|
+                   VDPS_DISP_REQ_EXPIRE|
+                   VDPS_DISP_PRE_FETCH|
+                   VDPS_DISP1;
+    else
+        dwVidCtl = 0;
+
+    SrcWidth = pRSrc->right - pRSrc->left;
+    SrcHeight = pRSrc->bottom - pRSrc->top;
+
+    DstWidth = pRDst->right - pRDst->left;
+    DstHeight = pRDst->bottom - pRDst->top;
+    
+    /* Color Key Setting */
+
+    /* Chrome Key Setting */
+
+
+    dwVSrcPitch = pRDCPortPriv->SrcPitch;
+    dwVIDBuffer[0] = pRDCPortPriv->Packed0Offset;
+
+    dwVDisplayCount = ((pRSrc->bottom - 1) << 16) | (pRSrc->right - 1);
+    dwVideoSrcOffset = (pRSrc->left << 16) | pRSrc->top;
+    dwWinStartXY = (pRDst->left << 16) | pRDst->top;
+    dwWinEndXY = ((pRDst->right - 1) << 16) | (pRDst->bottom - 1);
+    
+    dwFetch = (((pRSrc->right - pRSrc->left) << 1) + 7) >> 3;
+    
+    if (dwFetch < 4)
+        dwFetch = 4;
+        
+    dwzoomCtl &= 0x0000FFFF;
+    if (SrcWidth < DstWidth)
+    {
+        dwzoomCtl |=((ULONG)(((SrcWidth*0x1000)/DstWidth)&0x0FFF)<<16)|
+                                VDPS_H_ZOOM_ENABLE|VDPS_H_INTERP;        
+    }
+
+    dwzoomCtl &= 0xFFFF0000;
+    if (SrcHeight < DstHeight)
+    {
+        dwzoomCtl |=(ULONG)(((SrcHeight*0x1000)/DstHeight)&0x0FFF)|
+                                VDPS_V_ZOOM_ENABLE|VDPS_V_INTERP;        
+    }
+    
+    xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Color Key 0x%x==\n",pVIDHwInfo->dwColorKey);
+
+    if (pVIDHwInfo->dwVidCtl != dwVidCtl)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_CTL) = dwVidCtl;
+        pVIDHwInfo->dwVidCtl = dwVidCtl;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==VID CTRL Setting 0x%x==\n",pVIDHwInfo->dwVidCtl);
+    }
+    if (pVIDHwInfo->dwFetch != dwFetch)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FETCH_COUNT) = dwFetch;
+        pVIDHwInfo->dwFetch = dwFetch;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Fetch count 0x%x==\n",pVIDHwInfo->dwFetch);
+    }
+    if (pVIDHwInfo->dwVideoSrcOffset != dwVideoSrcOffset)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_START_OFFSET) = dwVideoSrcOffset;
+        pVIDHwInfo->dwVideoSrcOffset = dwVideoSrcOffset;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Video Src Offset 0x%x==\n",pVIDHwInfo->dwVideoSrcOffset);
+    }
+    if (pVIDHwInfo->dwVDisplayCount != dwVDisplayCount)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_SRC_DISP_COUNT_ON_SCR) = dwVDisplayCount;
+        pVIDHwInfo->dwVDisplayCount = dwVDisplayCount;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Display count 0x%x==\n",pVIDHwInfo->dwVDisplayCount);
+    }
+    if (pVIDHwInfo->dwWinStartXY != dwWinStartXY)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_START_LOCATION) = dwWinStartXY;
+        pVIDHwInfo->dwWinStartXY = dwWinStartXY;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Start Location 0x%x==\n",pVIDHwInfo->dwWinStartXY);
+    }
+    if (pVIDHwInfo->dwWinEndXY != dwWinEndXY)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_END_LOCATION) = dwWinEndXY;
+        pVIDHwInfo->dwWinEndXY = dwWinEndXY;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==End Location 0x%x==\n",pVIDHwInfo->dwWinEndXY);
+    }
+    if (pVIDHwInfo->dwzoomCtl != dwzoomCtl)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_ZOOM_CTL) = dwzoomCtl;
+        pVIDHwInfo->dwzoomCtl = dwzoomCtl;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Zoom Setting 0x%x==\n",pVIDHwInfo->dwzoomCtl);
+    }
+    if (pVIDHwInfo->dwVIDBuffer[0] != dwVIDBuffer[0])
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FB0) = dwVIDBuffer[0];
+        pVIDHwInfo->dwVIDBuffer[0] = dwVIDBuffer[0];
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Video Display Buffer 0x%x==\n",pVIDHwInfo->dwVIDBuffer[0]);
+    }
+    if (pVIDHwInfo->dwVSrcPitch != dwVSrcPitch)
+    {
+        *(ULONG*)(pRDC->MMIOVirtualAddr + VDP_FB_STRIDE) = dwVSrcPitch;
+        pVIDHwInfo->dwVSrcPitch = dwVSrcPitch;
+        xf86DrvMsgVerb(0, X_INFO, InfoLevel, "==Buffer stride 0x%x==\n",pVIDHwInfo->dwVSrcPitch);
+    }
+
+    *(unsigned long*)(pRDC->MMIOVirtualAddr + VDP_REG_UPDATE_MOD_SELECT) = VDPS_FIRE;
+
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCUpdateVID()  Exit==\n");
+}
+
+/*****************************************************************
+* We copy video source from system memory to local video memory, *
+* and convert source format to YVY2                              *
+******************************************************************/
+void RDCCopyFOURCC(RDCRecPtr  pRDC, unsigned char* pSrcStart, RDCPortPrivPtr pRDCPortPriv,
+                   unsigned long SrcPitch, unsigned long DstPitch, int FourCC, 
+                   short width, short height)
+{
+    unsigned char* pDst = NULL;
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCCopyFOURCC()  Entry==\n");
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Packed1 Offset  0x%x==\n", pRDCPortPriv->PackedBuf0->offset);
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Per Pixel Bits 0x%x==\n",pRDC->VideoModeInfo.Bpp);
+
+    pRDCPortPriv->Packed0Offset = 
+        (pRDCPortPriv->PackedBuf0->offset * pRDC->VideoModeInfo.Bpp);
+
+    pDst = pRDC->FBVirtualAddr + pRDCPortPriv->Packed0Offset;
+    
+    xf86DrvMsgVerb(0, X_INFO, 8, "==FB  Base  0x%x==\n", (unsigned long)((unsigned long*)pRDC->FBVirtualAddr));
+    xf86DrvMsgVerb(0, X_INFO, 6, "==Dst Start 0x%x==\n", (unsigned long)((unsigned long*)pDst));
+    xf86DrvMsgVerb(0, X_INFO, 6, "==Src Start 0x%x==\n", (unsigned long)((unsigned long*)pSrcStart));
+    xf86DrvMsgVerb(0, X_INFO, 6, "==Src Pitch 0x%x==\n", SrcPitch);
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Dst Pitch 0x%x==\n", DstPitch);
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Width 0x%x==\n", width);
+    xf86DrvMsgVerb(0, X_INFO, 8, "==Height 0x%x==\n", height);
+    
+    switch (FourCC)
+    {
+    case FOURCC_YV12:
+        {
+            int i,j;
+            CARD32 *pDst1 = (CARD32*)pDst;
+            unsigned long SrcYPitch = SrcPitch;
+            unsigned long SrcVPitch = SrcPitch >> 1;
+            unsigned long SrcUPitch = SrcPitch >> 1;
+            unsigned char* pSrcY = pSrcStart;
+            unsigned char* pSrcV = pSrcStart + (width * height);
+            unsigned char* pSrcU = pSrcStart + ((width << 1) * (height << 1));
+
+            xf86DrvMsgVerb(0, X_INFO, 8, "==Y Start 0x%x==\n", (unsigned long)((unsigned long*)pSrcY));
+            xf86DrvMsgVerb(0, X_INFO, 8, "==V Start 0x%x==\n", (unsigned long)((unsigned long*)pSrcV));
+            xf86DrvMsgVerb(0, X_INFO, 8, "==U Start 0x%x==\n", (unsigned long)((unsigned long*)pSrcU));
+            xf86DrvMsgVerb(0, X_INFO, 8, "==Y Pitch 0x%x==\n", SrcYPitch);
+            xf86DrvMsgVerb(0, X_INFO, 8, "==V,U Pitch 0x%x==\n", SrcVPitch);
+            
+            for(j = 0; j < height; j++)
+            {
+                for(i = 0; i < (width >> 1); i++) 
+                {
+                    pDst1[i] = pSrcY[i << 1] | (pSrcY[(i << 1) + 1] << 16) |
+                              (pSrcU[i] << 8) | (pSrcV[i] << 24);
+                }
+                
+                pDst1 += DstPitch;
+                pSrcY += SrcYPitch;
+
+                if(j & 1)
+                {
+                    pSrcV += SrcVPitch;
+                    pSrcU += SrcUPitch;
+                }
+            }
+        }
+        break;
+    case FOURCC_YUY2:
+        while(height--)
+        {
+            memcpy(pDst, pSrcStart, (width << 1));
+            pSrcStart += SrcPitch;
+            pDst += DstPitch;
+        }
+        break;
+    }
+    
+    xf86DrvMsgVerb(0, X_INFO, DefaultLevel, "==RDCCopyFOURCC()  Exit==\n");
+}
diff --git a/src/rdc_video.h b/src/rdc_video.h
new file mode 100644
index 0000000..f6d19cb
--- /dev/null
+++ b/src/rdc_video.h
@@ -0,0 +1,111 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+#include "xf86.h"
+
+// VIDEO Register definition VDISP
+#define VDP_CTL                         0x700
+#define VDP_REG_UPDATE_MOD_SELECT       0x704
+#define VDP_FIFO_THRESHOLD              0x708
+#define VDP_FETCH_COUNT                 0x70C
+#define VDP_START_OFFSET                0x710
+#define VDP_SRC_DISP_COUNT_ON_SCR       0x714
+#define VDP_START_LOCATION              0x718
+#define VDP_END_LOCATION                0x71C
+#define VDP_FIRST_COLORKEY              0x720
+#define VDP_CHROMA_KEY_LOW              0x724
+#define VDP_CHROMA_KEY_UPPER            0x728
+#define VDP_ZOOM_CTL                    0x72C
+#define VDP_FB0                         0x730
+#define VDP_FB1                         0x734
+#define VDP_FB2                         0x738
+#define VDP_FB_STRIDE                   0x73C
+#define VDP_COLOR_ENHANCE_CTL1          0x740
+#define VDP_COLOR_ENHANCE_CTL2          0x744
+#define VDP_COLOR_ENHANCE_CTL3          0x748
+#define VDP_COLOR_ENHANCE_CTL4          0x74C
+#define VDP_SECOND_COLORKEY             0x750
+
+#define VID_Enable                      1
+#define VID_Disable                     0
+
+// VIDEO states
+#define VDPS_ENABLE                     BIT0
+#define VDPS_SW_FLIP                    0x00010000
+#define VDPS_HW_FLIP                    0
+#define VDPS_DISP_REQ_EXPIRE            0x00000140
+#define VDPS_DISP_PRE_FETCH             BIT20
+#define VDPS_DISP1                      0x0
+#define VDPS_DISP2                      BIT18
+#define VDPS_FIRE                       BIT7
+#define VDPS_FIFO_THRESHOLD             0x60006000
+#define VDPS_ENABLE_CK                  BIT30
+#define VDPS_ENABLE_CHK                 BIT31
+#define VDPS_H_ZOOM_ENABLE              BIT31
+#define VDPS_H_INTERP                   BIT30
+#define VDPS_V_ZOOM_ENABLE              BIT15
+#define VDPS_V_INTERP                   BIT14
+
+typedef struct {
+     // overlay reg                                
+     ULONG dwVidCtl;                               
+     ULONG dwVideoSrcOffset;                             
+     ULONG dwFetch;                  // Video engine fetch count
+     ULONG dwVDisplayCount;          // Video engine display count 0x26c,0x27c
+     ULONG dwVSrcPitch;                 // Video engine stride
+     ULONG dwWinStartXY;
+     ULONG dwWinEndXY;
+     ULONG dwzoomCtl;
+     ULONG dwColorKey;
+     ULONG dwVIDBuffer[3];
+} VIDHWINFO, *VIDHWINFOPtr;
+
+/*
+ * structure for passing information to UpdateOverlay fn
+ */
+typedef struct _OV_RECTL
+{
+    unsigned long     left;
+    unsigned long     top;
+    unsigned long     right;
+    unsigned long     bottom;
+} OV_RECTL, *OV_RECTLPtr;
+
+
+/*
+ *  Xv port specific struct, each port has it's own struct
+ */
+typedef struct {
+    long            brightness;
+    long            saturation;
+    long            contrast;
+    long            hue;
+    RegionRec       clip;
+    CARD32          colorkey;
+
+    VIDHWINFO       VidhwInfo;
+	FBLinearPtr     PackedBuf0;
+	unsigned long   Packed0Offset;
+	
+    OV_RECTL        rDst;
+    OV_RECTL        rSrc;
+    unsigned long   SrcPitch;
+} RDCPortPrivRec, *RDCPortPrivPtr;
+
diff --git a/src/typedef.h b/src/typedef.h
new file mode 100644
index 0000000..3bd965b
--- /dev/null
+++ b/src/typedef.h
@@ -0,0 +1,504 @@
+/* 
+ * Copyright (C) 2009 RDC Semiconductor Co.,Ltd
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * For technical support : 
+ *     <jason.lin@rdc.com.tw>
+ */
+
+
+#define X_INFO 0
+#define X_WARNING 1
+#define X_ERROR 2
+
+/* Verberse level define */
+typedef unsigned char UCHAR;
+typedef unsigned short USHORT;
+typedef unsigned long ULONG;
+
+typedef enum _bool
+{
+    FALSE = 0,
+    TRUE = 1
+}bool;
+
+#ifndef ErrorLevel
+    #define ErrorLevel             0    /* Report Error message */
+#endif
+
+#ifndef DefaultLevel
+    #define DefaultLevel           4    /* Driver entry function */
+#endif
+
+#ifndef InfoLevel
+    #define InfoLevel              5    /* Report information    */
+#endif
+
+#ifndef InternalLevel
+    #define InternalLevel          6    /* Driver interanl function entry     */
+#endif
+
+/* Related IO offset */
+#define ATTR_ADDR                   0X0040
+#define ATTR_DATA_WRITE             0X0040
+#define ATTR_DATA_READ              0X0041
+#define MISC_WRITE                  0X0042
+#define INPUT_STATUS_0_READ         0X0042
+#define RIO_VGA_ENABLE              0X0043
+#define SEQ_INDEX                   0X0044
+#define SEQ_DATA                    0X0045
+#define PEL_MASK                    0X0046
+#define DAC_INDEX_READ              0X0047
+#define FEAT_CTRL_READ              0X004A
+#define MISC_READ                   0X004C
+#define GRAPH_INDEX                 0X004E
+#define GRAPH_DATA                  0X004F
+
+#define MONO_CRTC_INDEX             0X0034
+#define MONO_CRTC_DATA              0X0035
+#define MONO_INPUT_STATUS1_READ     0X003A
+
+#define COLOR_CRTC_INDEX            0X0054
+#define COLOR_CRTC_DATA             0X0055
+#define COLOR_INPUT_STATUS1_READ    0X005A
+
+
+#define VBIOSVerNum                 0x00000
+
+
+/* Scratch registers */
+
+#define SCRATCH_01                               0x81 * 0x100
+#define     IDX_SCRATCH_01                       SCRATCH_01 + 0xFF
+#define     IDX_IGA1_DEV_ID                      SCRATCH_01 + 0x0F
+#define     IDX_IGA2_DEV_ID                      SCRATCH_01 + 0xF0
+
+#define SCRATCH_02                               0x82 * 0x100
+#define     IDX_SCRATCH_02                       SCRATCH_02 + 0xFF
+#define     IDX_DISPLAY1_CHANGED                 SCRATCH_02 + 0x01
+#define     IDX_DISPLAY2_CHANGED                 SCRATCH_02 + 0x02
+#define     IDX_PWR_SEQ_ON                       SCRATCH_02 + 0x04
+
+#define SCRATCH_03                               0x83 * 0x100
+#define     IDX_SCRATCH_03                       SCRATCH_03 + 0xFF
+#define     IDX_IGA2_VESA_MODE                   SCRATCH_03 + 0xFF
+
+#define SCRATCH_04                               0x84 * 0x100
+#define     IDX_SCRATCH_04                       SCRATCH_04 + 0xFF
+#define     IDX_IGA2_VESA_MODE_OVERFLOW          SCRATCH_04 + 0x01
+#define     IDX_IGA2_RRATE_ID                    SCRATCH_04 + 0xFE
+
+#define SCRATCH_05                               0x85 * 0x100
+#define     IDX_SCRATCH_05                       SCRATCH_05 + 0xFF
+#define     IDX_TV1_TYPE                         SCRATCH_05 + 0x0F
+#define     IDX_TV1_CONNECTION_TYPE              SCRATCH_05 + 0x30
+
+#define SCRATCH_06                               0x86 * 0x100
+#define     IDX_SCRATCH_06                       SCRATCH_06 + 0xFF
+#define     IDX_TV2_TYPE                         SCRATCH_06 + 0x0F
+#define     IDX_TV2_CONNECTION_TYPE              SCRATCH_06 + 0x30
+
+#define SCRATCH_07                               0x87 * 0x100
+#define     IDX_SCRATCH_07                       SCRATCH_07 + 0xFF
+#define     IDX_HDTV1_TYPE                       SCRATCH_07 + 0x07
+#define     IDX_HDTV1_CONNECTION_TYPE            SCRATCH_07 + 0x08
+#define     IDX_HDTV2_TYPE                       SCRATCH_07 + 0x70
+#define     IDX_HDTV2_CONNECTION_TYPE            SCRATCH_07 + 0x80
+
+#define SCRATCH_08                               0x88 * 0x100
+#define     IDX_SCRATCH_08                       SCRATCH_08 + 0xFF
+#define     IDX_HDMI1_TYPE                       SCRATCH_08 + 0x0F
+#define     IDX_HDMI2_TYPE                       SCRATCH_08 + 0xF0
+
+#define SCRATCH_09                               0x89 * 0x100
+#define     IDX_SCRATCH_09                       SCRATCH_09 + 0xFF
+#define     IDX_HDMI1_CONNECTION_TYPE            SCRATCH_09 + 0x03
+#define     IDX_HDMI2_CONNECTION_TYPE            SCRATCH_09 + 0x30
+
+#define SCRATCH_10                               0x8A * 0x100
+#define     IDX_SCRATCH_10                       SCRATCH_10 + 0xFF
+#define     IDX_LCD_H_SIZE_OVERFLOW              SCRATCH_10 + 0xF0
+#define     IDX_LCD_V_SIZE_OVERFLOW              SCRATCH_10 + 0x0F
+
+#define SCRATCH_11                               0x8B * 0x100
+#define     IDX_SCRATCH_11                       SCRATCH_11 + 0xFF
+#define     IDX_LCD_H_SIZE                       SCRATCH_11 + 0xFF
+
+#define SCRATCH_12                               0x8C * 0x100
+#define     IDX_SCRATCH_12                       SCRATCH_12 + 0xFF
+#define     IDX_LCD_V_SIZE                       SCRATCH_12 + 0xFF
+
+#define SCRATCH_13                               0x8D * 0x100
+#define     IDX_SCRATCH_13                       SCRATCH_13 + 0xFF
+#define     IDX_IGA1_VESA_MODE_OVERFLOW          SCRATCH_13 + 0x01
+#define     IDX_IGA1_RRATE_ID                    SCRATCH_13 + 0xFE
+
+#define SCRATCH_14                               0x8E * 0x100
+#define     IDX_SCRATCH_14                       SCRATCH_14 + 0xFF
+#define     IDX_IGA1_VGA_MODE                    SCRATCH_14 + 0xFF
+#define     IDX_IGA1_VESA_MODE                   SCRATCH_14 + 0xFF
+
+#define SCRATCH_15                               0x8F * 0x100
+#define     IDX_SCRATCH_15                       SCRATCH_15 + 0xFF
+#define     IDX_NEW_IGA1_DEV_ID                  SCRATCH_15 + 0x0F
+#define     IDX_NEW_IGA2_DEV_ID                  SCRATCH_15 + 0xF0
+
+#define SCRATCH_16                               0x90 * 0x100
+#define     IDX_SCRATCH_16                       SCRATCH_16 + 0xFF
+#define     IDX_KEEP_DISPLAY_OFF                 SCRATCH_16 + 0x80
+#define     IDX_DPMS_STATE                       SCRATCH_16 + 0x40
+#define     IDX_LINEAR_MODE                      SCRATCH_16 + 0x20
+
+#define SCRATCH_17                               0x91 * 0x100
+#define     IDX_SCRATCH_17                       SCRATCH_17 + 0xFF
+#define     IDX_LCD2_H_SIZE_OVERFLOW             SCRATCH_10 + 0xF0
+#define     IDX_LCD2_V_SIZE_OVERFLOW             SCRATCH_10 + 0x0F
+
+#define SCRATCH_18                               0x92 * 0x100
+#define     IDX_SCRATCH_18                       SCRATCH_18 + 0xFF
+#define     IDX_LCD2_H_SIZE                      SCRATCH_18 + 0xFF
+
+#define SCRATCH_19                               0x93 * 0x100
+#define     IDX_SCRATCH_19                       SCRATCH_19 + 0xFF
+#define     IDX_LCD2_V_SIZE                      SCRATCH_19 + 0xFF
+
+#define SCRATCH_20                               0x94 * 0x100
+#define     IDX_SCRATCH_20                       SCRATCH_20 + 0xFF
+#define     IDX_LVDS1_TX_ID                      SCRATCH_20 + 0xF0
+#define     IDX_LVDS2_TX_ID                      SCRATCH_20 + 0x0F
+
+#define SCRATCH_21                               0x95 * 0x100
+#define     IDX_SCRATCH_21                       SCRATCH_21 + 0xFF
+#define     IDX_TMDS1_TX_ID                      SCRATCH_21 + 0xF0
+#define     IDX_TMDS2_TX_ID                      SCRATCH_21 + 0x0F
+
+#define SCRATCH_22                               0x96 * 0x100
+#define     IDX_SCRATCH_22                       SCRATCH_22 + 0xFF
+#define     IDX_TV1_ENCODER_ID                   SCRATCH_22 + 0xF0
+#define     IDX_TV2_ENCODER_ID                   SCRATCH_22 + 0x0F
+
+#define SCRATCH_23                               0x97 * 0x100
+#define     IDX_SCRATCH_23                       SCRATCH_23 + 0xFF
+#define     IDX_LCD1_TABLE_INDEX                 SCRATCH_23 + 0xF0
+#define     IDX_LCD2_TABLE_INDEX                 SCRATCH_23 + 0x0F
+
+/* For Bit mask using */
+#define BIT0                        0x00000001
+#define BIT1                        0x00000002
+#define BIT2                        0x00000004
+#define BIT3                        0x00000008
+#define BIT4                        0x00000010
+#define BIT5                        0x00000020
+#define BIT6                        0x00000040
+#define BIT7                        0x00000080
+#define BIT8                        0x00000100
+#define BIT9                        0x00000200
+#define BIT10                       0x00000400
+#define BIT11                       0x00000800
+#define BIT12                       0x00001000
+#define BIT13                       0x00002000
+#define BIT14                       0x00004000
+#define BIT15                       0x00008000
+#define BIT16                       0x00010000
+#define BIT17                       0x00020000
+#define BIT18                       0x00040000
+#define BIT19                       0x00080000
+#define BIT20                       0x00100000
+#define BIT21                       0x00200000
+#define BIT22                       0x00400000
+#define BIT23                       0x00800000
+#define BIT24                       0x01000000
+#define BIT25                       0x02000000
+#define BIT26                       0x04000000
+#define BIT27                       0x08000000
+#define BIT28                       0x10000000
+#define BIT29                       0x20000000
+#define BIT30                       0x40000000
+#define BIT31                       0x80000000
+
+/* definition of output ports */
+#define CRT_PORT    0
+#define DVP1        1
+#define DVP2        2
+#define DVP12       3
+
+/* definition of RRATE_TABLE.RRate_ID */
+#define RR60        0
+#define RR50I       1
+#define RR59_94I    2
+#define RR50        3
+#define RR56        4
+#define RR59_94     5
+#define RR24        6
+#define RR70        7
+#define RR75        8
+#define RR80        9
+#define RR85        10
+#define RR90        11
+#define RR100       12
+#define RR120       13
+#define RR72        14
+#define RR65        15
+
+/* Output Device Index */
+#define LCD_ID      1
+#define DVI_ID      2
+#define CRT_ID      3
+#define HDMI_ID     4
+#define HDTV_ID     5
+#define TV_ID       6
+#define LCD2_ID     8
+#define DVI2_ID     9
+#define CRT2_ID     10
+#define HDMI2_ID    11
+#define HDTV2_ID    12
+#define TV2_ID      13
+
+/* Output Device Combination Bit */
+#define B_LCD       BIT0
+#define B_DVI       BIT1
+#define B_CRT       BIT2
+#define B_HDMI      BIT3
+#define B_HDTV      BIT4
+#define B_TV        BIT5
+#define B_LCD2      BIT7
+#define B_DVI2      BIT8
+#define B_CRT2      BIT9
+#define B_HDMI2     BIT10
+#define B_HDTV2     BIT11
+#define B_TV2       BIT12
+
+
+
+/* clock definition */
+#define PLLReferenceClock           14318
+#define MaxFCKVCO9003A              810000
+#define MinFCKVCO9003A              350000
+#define MaxFCKVCO9001A              1600000
+#define MinFCKVCO9001A              833000
+
+/* DPMS State */
+#define DPMS__ON                     0
+#define DPMS__STANDBY                1
+#define DPMS__SUSPEND                2
+#define DPMS__OFF                    3
+
+
+/* definitions only for PANEL_TABLE.Attribute */
+#define SEQ         BIT1                /* sequential output format */
+#define TTL         BIT6                /* TTL LCD */
+
+/* _PORT_CONFIG.TX_Enc_ID */
+#define NONE        0x00        /* no TX/encoder */
+#define TX_VT1636   0x01
+#define TX_SIL1162  0x02
+#define TX_HW       0x03        /* hardwired TX */
+#define ENC_VT1625  0x04
+#define DSTN        0x05        /* DSTN */
+
+/* _PORT_CONFIG.Attribute */
+#define Dev_SUPPORT BIT0        /* Device Support */
+#define TX_DIT      BIT1
+#define TX_PS       BIT2
+#define DSTN_COLOR  BIT3        /* DSTN color */
+#define DSTN_MONO   0           /* DSTN mono */
+#define DSTN_6X4    BIT4        /* DSTN 640x480 */
+#define DSTN_3X2    0           /* DSTN 320x240 */
+#define TX_MSB      BIT5
+
+/* definitions of display path */
+#define DISP1       1
+#define DISP2       2
+
+/* mode numbers */
+
+#define MODE_640x480x8      0x101
+#define MODE_800x600x8      0x103
+#define MODE_1024x768x8     0x105
+#define MODE_1280x1024x8    0x107
+#define MODE_640x480x16     0x111
+#define MODE_640x480x32     0x112
+#define MODE_800x600x16     0x114
+#define MODE_800x600x32     0x115
+#define MODE_1024x768x16    0x117
+#define MODE_1024x768x32    0x118
+#define MODE_1280x1024x16   0x11A
+#define MODE_1280x1024x32   0x11B
+
+#define MODE_1600x1200x8    0x120
+#define MODE_1600x1200x16   0x121
+#define MODE_1600x1200x32   0x122
+
+#define MODE_320x240x8      0x123
+#define MODE_320x240x16     0x124
+#define MODE_320x240x32     0x125
+
+#define MODE_720x480x8      0x126
+#define MODE_720x480x16     0x127
+#define MODE_720x480x32     0x128
+
+#define MODE_1360x768x8     0x129
+#define MODE_1360x768x16    0x12A
+#define MODE_1360x768x32    0x12B
+
+#define MODE_848x480x8      0x12C
+#define MODE_848x480x16     0x12D
+#define MODE_848x480x32     0x12E
+
+#define MODE_1440x900x8     0x12F
+#define MODE_1440x900x16    0x130
+#define MODE_1440x900x32    0x131
+
+#define MODE_1152x864x8     0x132
+#define MODE_1152x864x16    0x133
+#define MODE_1152x864x32    0x134
+
+#define MODE_1280x960x8     0x135
+#define MODE_1280x960x16    0x136
+#define MODE_1280x960x32    0x137
+
+#define MODE_1400x1050x8    0x138
+#define MODE_1400x1050x16   0x139
+#define MODE_1400x1050x32   0x13A
+
+#define MODE_800x480x8      0x13B
+#define MODE_800x480x16     0x13C
+#define MODE_800x480x32     0x13D
+
+#define MODE_1024x600x8     0x13E
+#define MODE_1024x600x16    0x13F
+#define MODE_1024x600x32    0x140
+
+#define MODE_USR_DEF1x8     0x1F1
+#define MODE_USR_DEF1x16    0x1F2
+#define MODE_USR_DEF1x32    0x1F3
+
+#define MODE_USR_DEF2x8     0x1F4
+#define MODE_USR_DEF2x16    0x1F5
+#define MODE_USR_DEF2x32    0x1F6
+
+
+typedef struct _RRATE_TABLE RRATE_TABLE;
+typedef struct _MODE_INFO MODE_INFO;
+typedef struct _PANEL_TABLE PANEL_TABLE;
+typedef struct _PORT_CONFIG PORT_CONFIG;
+typedef struct _VESA_TABLE VESA_TABLE;
+
+struct _RRATE_TABLE {
+    ULONG   Clock;          /* in khz */
+    UCHAR   RRate_ID;
+    USHORT  Attribute;
+    USHORT  H_Blank_Time;
+    USHORT  H_Sync_Start;
+    USHORT  H_Sync_Time;
+    USHORT  V_Blank_Time;
+    USHORT  V_Sync_Start;
+    USHORT  V_Sync_Time;
+}__attribute__((packed));;
+
+struct _MODE_INFO{
+    USHORT  H_Size;
+    USHORT  V_Size;
+    USHORT  Mode_ID_8bpp;
+    USHORT  Mode_ID_16bpp;
+    USHORT  Mode_ID_32bpp;
+    UCHAR   RRTableCount;
+}__attribute__((packed));;
+
+struct _PANEL_TABLE {
+    USHORT    TD0;
+    USHORT    TD1;
+    USHORT    TD2;
+    USHORT    TD3;
+    USHORT    TD5;
+    USHORT    TD6;
+    USHORT    TD7;
+    UCHAR   PWM_Clock;
+    USHORT  Reserved1;
+    USHORT  Reserved2;
+    RRATE_TABLE Timing;
+}__attribute__((packed));;
+
+struct _VESA_TABLE {
+    MODE_INFO   ModeInfo;
+    RRATE_TABLE RRateTable;
+}__attribute__((packed));;
+
+#if 0
+typedef struct _LCD_TABLE {
+    MODE_INFO   ModeInfo;
+    PANEL_TABLE *pPanelTable;
+} LCD_TABLE;
+#endif
+
+typedef struct _REG_OP {
+    UCHAR    RegGroup;
+    UCHAR    RegMask;
+    UCHAR    RegIndex;
+    UCHAR    RegShiftBit;
+} REG_OP;
+
+#if 0
+typedef struct _REG_PACKAGE {
+    UCHAR    RegGroup;
+    UCHAR    RegIndex;
+    UCHAR    RegValue;
+    UCHAR    RegMask;
+} REG_PACKAGE;
+#else
+/* definitions for SerialLoadTable() */
+#define    CR       0x00
+#define    SR       0x01
+#define    GR       0x02
+#define    I2C      0x03
+#define    NR       0xFF
+#define    BITS     BIT7
+#endif
+
+
+typedef struct _PLL_Info {
+    UCHAR NS;
+    UCHAR MS;
+    UCHAR RS;
+}PLL_Info;
+
+struct _PORT_CONFIG
+{
+    UCHAR        DevID;
+    UCHAR        PortID;
+    UCHAR        TX_Enc_ID;
+    UCHAR        TX_I2C_Port;
+    UCHAR        TX_I2C_Addr;
+    UCHAR        Attribute;
+}__attribute__((packed));;
+
+/* PCI Data Structure */
+#define OFF_VID             0
+#define OFF_DID             2
+#define OFF_PTR_VPD         4
+#define OFF_PCI_DS_LEN      6
+#define OFF_PCI_DS_REV      8
+#define OFF_CLASS_CODE1     9
+#define OFF_CLASS_CODE2     10
+#define OFF_CLASS_CODE3     11
+#define OFF_SIZE_VBIOS      12
+#define OFF_ROM_CODE_REV    14
+#define OFF_PC_AT_COMP      16
+#define OFF_LII             17
+#define OFF_RESERVED        18
+
+/* Definition of PCI Data Structure.RESERVED */
+
+
author	Otavio Salvador <otavio@ossystems.com.br>	2010-06-01 19:45:54 -0300
committer	Otavio Salvador <otavio@ossystems.com.br>	2010-06-01 19:45:54 -0300
commit	c9ebd877197924bb97412019db498712f3b14d22 (patch)
tree	4d3a09af0fb56ed88f4cf6f6064020efe28488e3